merge(domain,application,infrastructure,backend,web-server,app-tauri,frontend): feature #363 — persistance et reprise des conversations de CLI custom par agent (QA verte)

2026-09-16 23:20:38 +02:00
parent 83b78f438f 943c4525d7
commit 72f8d37ec3
30 changed files with 1794 additions and 109 deletions
--- a/crates/app-tauri/src/commands.rs
+++ b/crates/app-tauri/src/commands.rs
@ -54,17 +54,18 @@ use crate::dto::{
    CloneProfileFromSeedRequestDto, ConfigureProfilesRequestDto, ConversationDetailsDto,
    CreateAgentFromTemplateRequestDto, CreateAgentRequestDto, CreateLayoutRequestDto,
    CreateLayoutResultDto, CreateMemoryRequestDto, CreateProjectRequestDto, CreateSkillRequestDto,
-    CreateTemplateRequestDto, CustomProjectIconAssetContentDto, CustomProjectIconAssetDto,
-    CustomProjectIconUsageDto, DeleteLayoutRequestDto, DeleteLayoutResultDto,
-    DeliveredDelegationRequestDto, DetectProfilesRequestDto, DetectProfilesResponseDto,
-    EmbedderEnginesDto, EmbedderProfileDto, EmbedderProfileListDto, ErrorDto,
-    ExecuteSlashCommandRequestDto, ExecuteSlashCommandResponseDto, FirstRunStateDto,
-    FrontAttachedRequestDto, GitBranchesDto, GitCheckoutRequestDto, GitCommitDto, GitCommitListDto,
-    GitCommitRequestDto, GitStageRequestDto, GitStatusListDto, GraphCommitListDto,
-    HealthRequestDto, HealthResponseDto, ImportChatAttachmentsRequestDto,
-    ImportChatAttachmentsResponseDto, ImportCustomProjectIconAssetRequestDto,
-    InspectConversationRequestDto, InterruptAgentRequestDto, LaunchAgentRequestDto, LayoutDto,
-    LayoutOperationDto, ListLayoutsDto, LiveAgentListDto, ManagedTempGcResponseDto,
+    CreateTemplateRequestDto, CustomConversationListDto, CustomConversationSummaryDto,
+    CustomProjectIconAssetContentDto, CustomProjectIconAssetDto, CustomProjectIconUsageDto,
+    DeleteLayoutRequestDto, DeleteLayoutResultDto, DeliveredDelegationRequestDto,
+    DetectProfilesRequestDto, DetectProfilesResponseDto, EmbedderEnginesDto, EmbedderProfileDto,
+    EmbedderProfileListDto, ErrorDto, ExecuteSlashCommandRequestDto,
+    ExecuteSlashCommandResponseDto, FirstRunStateDto, FrontAttachedRequestDto, GitBranchesDto,
+    GitCheckoutRequestDto, GitCommitDto, GitCommitListDto, GitCommitRequestDto, GitStageRequestDto,
+    GitStatusListDto, GraphCommitListDto, HealthRequestDto, HealthResponseDto,
+    ImportChatAttachmentsRequestDto, ImportChatAttachmentsResponseDto,
+    ImportCustomProjectIconAssetRequestDto, InspectConversationRequestDto,
+    InterruptAgentRequestDto, LaunchAgentRequestDto, LayoutDto, LayoutOperationDto,
+    ListCustomConversationsRequestDto, ListLayoutsDto, LiveAgentListDto, ManagedTempGcResponseDto,
    ManagedTempHandleRequestDto, ManagedTempLeaseDto, ManagedTempLeaseResponseDto, MemoryDto,
    MemoryIndexDto, MemoryLinksDto, MemoryListDto, ModelServerConfigDto, ModelServerConfigListDto,
    OpenCodeProviderListDto, OpenProjectRestoreStateDto, OpenTerminalRequestDto,
@ -192,15 +193,94 @@ pub async fn execute_slash_command(
    let effect = match output.effect {
        SlashCommandEffect::Help { commands } => SlashCommandEffectDto::Help { commands },
        SlashCommandEffect::CleanConversation { session_id } => {
-            if state.structured_sessions.session(&session_id).is_none() {
-                return Err(ErrorDto::from(AppError::NotFound(format!(
-                    "structured session {session_id}"
-                ))));
-            }
            let cleared_chunks = state.chat_bridge.clear_scrollback(&session_id);
+            let (project_id, agent_id, node_id, _) = state
+                .structured_sessions
+                .meta_for_session(&session_id)
+                .ok_or_else(|| {
+                    ErrorDto::from(AppError::NotFound(format!(
+                        "structured session {session_id}"
+                    )))
+                })?;
+            let runtime_key = domain::RuntimeAgentKey::new(project_id, agent_id);
+            let context = state
+                .resume_contexts
+                .lock()
+                .ok()
+                .and_then(|contexts| contexts.get(&runtime_key).cloned())
+                .ok_or_else(|| {
+                    ErrorDto::from(AppError::NotFound(format!(
+                        "launch context for structured session {session_id}"
+                    )))
+                })?;
+            let removed = state
+                .structured_sessions
+                .remove_runtime(&session_id)
+                .ok_or_else(|| {
+                    ErrorDto::from(AppError::NotFound(format!(
+                        "structured session {session_id}"
+                    )))
+                })?;
+            removed
+                .session
+                .shutdown()
+                .await
+                .map_err(|error| ErrorDto::from(AppError::Process(error.to_string())))?;
+            if let Some(handle) = removed.managed_temp_handle {
+                let _ = state
+                    .release_managed_temp
+                    .execute(application::ReleaseManagedTempInput { handle })
+                    .await;
+            }
+            let mcp_runtime = crate::mcp_endpoint::idea_exe_path().map(|exe| McpRuntime {
+                exe,
+                endpoint: crate::mcp_endpoint::mcp_endpoint(&project_id)
+                    .as_cli_arg()
+                    .to_owned(),
+                project_id: project_id.as_uuid().simple().to_string(),
+                requester: agent_id.to_string(),
+            });
+            let relaunched = state
+                .launch_agent
+                .execute(LaunchAgentInput {
+                    project: context.project.clone(),
+                    agent_id,
+                    rows: context.rows,
+                    cols: context.cols,
+                    node_id: Some(node_id),
+                    conversation_id: None,
+                    mcp_runtime,
+                    allow_structured_alongside_pty: false,
+                    require_structured: true,
+                    terminal_interface: Some(domain::DefaultAgentTerminalInterface::IdeaCli),
+                    fresh_start: true,
+                    managed_temp_exposure: application::ManagedTempExposureRequest::default(),
+                })
+                .await
+                .map_err(ErrorDto::from)?;
+            let replacement = relaunched
+                .structured
+                .as_ref()
+                .ok_or_else(|| {
+                    ErrorDto::from(AppError::Process(
+                        "/clean did not relaunch a structured session".to_owned(),
+                    ))
+                })?
+                .session_id;
+            state.chat_bridge.rebind_session(session_id, replacement);
+            if let Ok(mut contexts) = state.resume_contexts.lock() {
+                contexts.insert(
+                    runtime_key,
+                    crate::state::ResumeContext {
+                        conversation_id: relaunched.assigned_conversation_id.clone(),
+                        ..context
+                    },
+                );
+            }
            SlashCommandEffectDto::CleanConversation {
-                session_id: session_id.to_string(),
+                session_id: replacement.to_string(),
                cleared_chunks,
+                conversation_id: relaunched.assigned_conversation_id,
            }
        }
        SlashCommandEffect::ProfileSwitch { session_id } => SlashCommandEffectDto::ProfileSwitch {
@ -2264,6 +2344,25 @@ pub async fn read_conversation_page(
        .map_err(ErrorDto::from)
 }

+/// Lists durable non-empty custom CLI conversations owned by an agent.
+#[tauri::command]
+pub async fn list_custom_agent_conversations(
+    request: ListCustomConversationsRequestDto,
+    state: State<'_, AppState>,
+) -> Result<CustomConversationListDto, ErrorDto> {
+    let project = resolve_project(&request.project_id, &state).await?;
+    let agent_id = parse_agent_id(&request.agent_id)?;
+    let conversations = state
+        .custom_conversations
+        .list(&project.root, agent_id, request.limit.unwrap_or(0))
+        .await
+        .map_err(ErrorDto::from)?
+        .into_iter()
+        .map(CustomConversationSummaryDto::from)
+        .collect();
+    Ok(CustomConversationListDto { conversations })
+}
+
 /// `list_live_agents` — list every agent that currently owns a live session
 /// (raw PTY **or** structured/chat) and the cell hosting each, so the UI can
 /// disable an agent already running in another cell (the "one live session per
@ -2509,6 +2608,39 @@ pub async fn launch_agent(
    let project = resolve_project(&request.project_id, &state).await?;
    let project_id = project.id;
    let agent_id = parse_agent_id(&request.agent_id)?;
+    let resumed_page = if request.cell_kind == Some(CellKind::Chat) {
+        if let Some(raw) = request.conversation_id.as_deref() {
+            let conversation_id = uuid::Uuid::parse_str(raw)
+                .map(domain::ConversationId::from_uuid)
+                .map_err(|_| {
+                    ErrorDto::from(AppError::Invalid(format!("invalid conversation id: {raw}")))
+                })?;
+            state
+                .custom_conversations
+                .assert_owned(&project.root, agent_id, conversation_id)
+                .await
+                .map_err(ErrorDto::from)?;
+            Some(
+                state
+                    .read_conversation_page
+                    .execute(ReadConversationPageInput {
+                        project_root: project.root.clone(),
+                        conversation: conversation_id,
+                        cursor: domain::PageCursor {
+                            anchor: None,
+                            direction: domain::PageDirection::Backward,
+                        },
+                        limit: 50,
+                    })
+                    .await
+                    .map_err(ErrorDto::from)?,
+            )
+        } else {
+            None
+        }
+    } else {
+        None
+    };
    // The hosting cell drives the singleton-invariant guard. Parse it when the
    // frontend supplies one; absent ⇒ `None` (a fresh node is minted, and an
    // already-live agent is refused).
@ -2708,7 +2840,24 @@ pub async fn launch_agent(
        }
    }

-    Ok(TerminalSessionDto::from(output))
+    let mut response = TerminalSessionDto::from(output);
+    if let Some(page) = resumed_page {
+        response.history = page
+            .turns
+            .into_iter()
+            .filter(|turn| {
+                matches!(
+                    turn.role,
+                    domain::TurnRole::Prompt | domain::TurnRole::Response
+                )
+            })
+            .map(crate::dto::TurnViewDto::from)
+            .collect();
+        response.history_has_more = page.has_more;
+        response.history_next_anchor = page.next_anchor.map(|id| id.to_string());
+        response.resumed = true;
+    }
+    Ok(response)
 }

 /// `change_agent_profile` — hot-swap an agent's runtime profile (§15.1).
@ -2968,13 +3117,48 @@ pub async fn agent_send(
        }
    };
    let attachment_refs = chat_prompt_attachment_refs(&imported_attachments);
-    let prompt_for_model =
+    let mut prompt_for_model =
        prompt_with_imported_attachments(&prompt, &imported_attachments, &attachment_refs);
    let attachment_labels = imported_attachments
        .iter()
        .map(|attachment| attachment.filename.clone())
        .collect();
    let session_meta = state.structured_sessions.meta_for_session(&sid);
+    let custom_context = match (
+        session_meta.as_ref(),
+        state.structured_sessions.custom_conversation_id(&sid),
+    ) {
+        (Some((project_id, agent_id, _, _)), Some(conversation_id)) => {
+            let project = state
+                .project_store
+                .list_projects()
+                .await
+                .map_err(|error| ErrorDto::from(AppError::Store(error.to_string())))?
+                .into_iter()
+                .find(|project| project.id == *project_id)
+                .ok_or_else(|| {
+                    ErrorDto::from(AppError::NotFound(format!("project {project_id}")))
+                })?;
+            Some((project.root, *agent_id, conversation_id))
+        }
+        _ => None,
+    };
+    if let Some((root, agent_id, conversation_id)) = &custom_context {
+        let at_ms = u64::try_from(state.clock.now_millis()).unwrap_or_default();
+        if let Err(error) = state
+            .custom_conversations
+            .record_prompt(root, *agent_id, *conversation_id, at_ms, &prompt)
+            .await
+        {
+            state.structured_sessions.finish_turn(&sid, turn_generation);
+            return Err(ErrorDto::from(error));
+        }
+        if let Some(summary) = state.structured_sessions.take_pending_resume_preamble(&sid) {
+            prompt_for_model = format!(
+                "Contexte borné de la conversation reprise :\n\n{summary}\n\n---\n\nNouveau message utilisateur :\n{prompt_for_model}"
+            );
+        }
+    }
    if let Some((project_id, agent_id, _, _)) = &session_meta {
        state.chat_bridge.bind_owner(sid, *project_id, *agent_id);
    }
@ -3109,6 +3293,7 @@ pub async fn agent_send(
    let structured = std::sync::Arc::clone(&state.structured_sessions);
    let runtime = tokio::runtime::Handle::current();
    let meta = session_meta;
+    let custom_conversations = std::sync::Arc::clone(&state.custom_conversations);
    std::thread::spawn(move || {
        let mut terminal_visible = false;
        let mut settler = crate::chat::ProgressSettler::default();
@ -3123,6 +3308,17 @@ pub async fn agent_send(
                    break 'logical_turn;
                }
                let provider_terminal = crate::chat::reply_event_ends_turn(&event);
+                if let domain::ports::ReplyEvent::Final { content } = &event {
+                    if let Some((root, agent_id, conversation_id)) = &custom_context {
+                        let _ = runtime.block_on(custom_conversations.record_response(
+                            root,
+                            *agent_id,
+                            *conversation_id,
+                            u64::try_from(clock.now_millis()).unwrap_or_default(),
+                            content,
+                        ));
+                    }
+                }
                if provider_terminal {
                    concrete_terminal = true;
                    if let Some(guard) = turn_guard.as_mut() {
--- a/crates/app-tauri/src/lib.rs
+++ b/crates/app-tauri/src/lib.rs
@ -353,6 +353,7 @@ pub fn run() {
            tickets::ticket_unassign_sprint,
            commands::get_project_work_state,
            commands::read_conversation_page,
+            commands::list_custom_agent_conversations,
            commands::list_live_agents,
            commands::attach_live_agent,
            commands::stop_live_agent,
--- a/crates/application/src/agent/lifecycle.rs
+++ b/crates/application/src/agent/lifecycle.rs
@ -2516,6 +2516,19 @@ impl LaunchAgent {
                &input.project.root,
            )
            .await;
+        // A resumed human custom CLI must render its durable history without eagerly
+        // injecting the portable handoff into the provider context. Native provider
+        // resume is already represented by `SessionPlan::Resume`; otherwise retain a
+        // bounded one-shot preamble for the first subsequent `send`.
+        let defer_custom_resume = input.require_structured && launch_conversation_id.is_some();
+        let pending_resume_preamble =
+            if defer_custom_resume && !matches!(session_plan, SessionPlan::Resume { .. }) {
+                self.resolve_handoff(&input.project.root, launch_conversation_id.as_deref())
+                    .await
+                    .map(|handoff| handoff.summary_md)
+            } else {
+                None
+            };
        let mut spec =
            self.runtime
                .prepare_invocation(&profile, &prepared, &run_dir, &session_plan)?;
@ -2529,7 +2542,11 @@ impl LaunchAgent {
                &manifest,
                &agent,
                content.clone(),
-                launch_conversation_id.as_deref(),
+                if defer_custom_resume {
+                    None
+                } else {
+                    launch_conversation_id.as_deref()
+                },
            )
            .await?;
        // Best-effort contextual embedder suggestion (LOT C3, §14.5.5): the agent
@ -2731,13 +2748,22 @@ impl LaunchAgent {
                //    l'orchestrateur). C'est cet id — et **non** l'id de session moteur —
                //    qui retrouve log + handoff au (re)lancement (P7) et survit au swap.
                let pair_conversation_id = launch_conversation_id.clone().unwrap_or_else(|| {
-                    ConversationId::for_project_pair(
-                        input.project.id,
-                        ConversationParty::User,
-                        ConversationParty::agent(agent.id),
-                    )
-                    .to_string()
+                    if input.require_structured {
+                        self.ids.new_uuid().to_string()
+                    } else {
+                        ConversationId::for_project_pair(
+                            input.project.id,
+                            ConversationParty::User,
+                            ConversationParty::agent(agent.id),
+                        )
+                        .to_string()
+                    }
                });
+                let transcript_restore_expected = if input.require_structured {
+                    launch_conversation_id.is_some()
+                } else {
+                    transcript_restore_expected(&session_plan)
+                };
                return self
                    .launch_structured(
                        factory.as_ref(),
@ -2752,7 +2778,8 @@ impl LaunchAgent {
                        &input.project.root,
                        input.node_id,
                        size,
-                        transcript_restore_expected(&session_plan),
+                        transcript_restore_expected,
+                        pending_resume_preamble,
                        &spec.env,
                        None,
                        structured_policy.as_ref(),
@ -2857,6 +2884,7 @@ impl LaunchAgent {
        node_id: Option<NodeId>,
        size: PtySize,
        transcript_restore_expected: bool,
+        pending_resume_preamble: Option<String>,
        env: &[(String, String)],
        sandbox: Option<&SandboxPlan>,
        structured_policy: Option<&StructuredProviderLaunchPolicy>,
@ -2901,6 +2929,13 @@ impl LaunchAgent {
            launch_managed_temp.map(|temp| temp.handle),
        );
        structured.set_transcript_restore_expected(session_id, transcript_restore_expected);
+        if let Ok(conversation_uuid) = uuid::Uuid::parse_str(&pair_conversation_id) {
+            structured.bind_custom_conversation(
+                session_id,
+                ConversationId::from_uuid(conversation_uuid),
+                pending_resume_preamble,
+            );
+        }

        // ── SÉPARATION DES DEUX CLÉS (ARCHITECTURE §19.7, lot P8a) ──
        //  - **id de paire** (`pair_conversation_id`) : clé **logique** persistée sur
--- a/crates/application/src/conversation/custom.rs
+++ b/crates/application/src/conversation/custom.rs
@ -0,0 +1,196 @@
+//! Custom CLI conversation catalogue and checkpoint orchestration.
+
+use std::sync::Arc;
+
+use domain::{
+    AgentId, ConversationId, ConversationTurn, CustomConversationEntry, CustomConversationIndex,
+    InputSource, ProjectPath, TurnId, TurnRole,
+};
+
+use crate::{AppError, RecordTurnProvider};
+
+/// Default and maximum number of conversation summaries returned to the UI.
+pub const CUSTOM_CONVERSATION_LIST_LIMIT: usize = 50;
+/// Maximum title length derived from the first prompt.
+pub const CUSTOM_CONVERSATION_TITLE_MAX_CHARS: usize = 80;
+
+/// Resolves a project-scoped custom conversation index.
+pub trait CustomConversationIndexProvider: Send + Sync {
+    /// Returns the index rooted at `root`.
+    fn custom_conversation_index_for(
+        &self,
+        root: &ProjectPath,
+    ) -> Option<Arc<dyn CustomConversationIndex>>;
+}
+
+/// Application service for custom CLI conversation ownership and checkpoints.
+pub struct CustomConversationService {
+    indexes: Arc<dyn CustomConversationIndexProvider>,
+    records: Arc<dyn RecordTurnProvider>,
+}
+
+impl CustomConversationService {
+    /// Builds the service from project-scoped providers.
+    #[must_use]
+    pub fn new(
+        indexes: Arc<dyn CustomConversationIndexProvider>,
+        records: Arc<dyn RecordTurnProvider>,
+    ) -> Self {
+        Self { indexes, records }
+    }
+
+    /// Lists recent non-empty conversations owned by an agent.
+    pub async fn list(
+        &self,
+        root: &ProjectPath,
+        agent_id: AgentId,
+        limit: usize,
+    ) -> Result<Vec<CustomConversationEntry>, AppError> {
+        let Some(index) = self.indexes.custom_conversation_index_for(root) else {
+            return Ok(Vec::new());
+        };
+        let limit = if limit == 0 {
+            CUSTOM_CONVERSATION_LIST_LIMIT
+        } else {
+            limit.min(CUSTOM_CONVERSATION_LIST_LIMIT)
+        };
+        Ok(index.list(agent_id, limit).await?)
+    }
+
+    /// Verifies that the logical conversation exists and belongs to `agent_id`.
+    pub async fn assert_owned(
+        &self,
+        root: &ProjectPath,
+        agent_id: AgentId,
+        conversation_id: ConversationId,
+    ) -> Result<CustomConversationEntry, AppError> {
+        let index = self
+            .indexes
+            .custom_conversation_index_for(root)
+            .ok_or_else(|| AppError::NotFound(format!("custom conversation {conversation_id}")))?;
+        let entry = index
+            .get(conversation_id)
+            .await?
+            .ok_or_else(|| AppError::NotFound(format!("custom conversation {conversation_id}")))?;
+        if entry.agent_id != agent_id {
+            return Err(AppError::Invalid(format!(
+                "conversation {conversation_id} is not owned by agent {agent_id}"
+            )));
+        }
+        Ok(entry)
+    }
+
+    /// Persists an accepted user prompt, materializing the catalogue entry only now.
+    pub async fn record_prompt(
+        &self,
+        root: &ProjectPath,
+        agent_id: AgentId,
+        conversation_id: ConversationId,
+        at_ms: u64,
+        text: &str,
+    ) -> Result<(), AppError> {
+        let index = self
+            .indexes
+            .custom_conversation_index_for(root)
+            .ok_or_else(|| AppError::NotFound("custom conversation index provider".to_owned()))?;
+        let existing = index.get(conversation_id).await?;
+        if existing
+            .as_ref()
+            .is_some_and(|entry| entry.agent_id != agent_id)
+        {
+            return Err(AppError::Invalid(format!(
+                "conversation {conversation_id} is not owned by agent {agent_id}"
+            )));
+        }
+        self.record(root, conversation_id, at_ms, TurnRole::Prompt, text)
+            .await?;
+        let created_at_ms = existing.as_ref().map_or(at_ms, |entry| entry.created_at_ms);
+        let title = existing
+            .as_ref()
+            .map(|entry| entry.title.clone())
+            .unwrap_or_else(|| conversation_title(text));
+        index
+            .upsert(CustomConversationEntry {
+                conversation_id,
+                agent_id,
+                title,
+                created_at_ms,
+                updated_at_ms: at_ms,
+            })
+            .await?;
+        Ok(())
+    }
+
+    /// Persists a final assistant response and advances last activity.
+    pub async fn record_response(
+        &self,
+        root: &ProjectPath,
+        agent_id: AgentId,
+        conversation_id: ConversationId,
+        at_ms: u64,
+        text: &str,
+    ) -> Result<(), AppError> {
+        let entry = self.assert_owned(root, agent_id, conversation_id).await?;
+        self.record(root, conversation_id, at_ms, TurnRole::Response, text)
+            .await?;
+        let index = self
+            .indexes
+            .custom_conversation_index_for(root)
+            .ok_or_else(|| AppError::NotFound("custom conversation index provider".to_owned()))?;
+        index
+            .upsert(CustomConversationEntry {
+                updated_at_ms: at_ms,
+                ..entry
+            })
+            .await?;
+        Ok(())
+    }
+
+    async fn record(
+        &self,
+        root: &ProjectPath,
+        conversation_id: ConversationId,
+        at_ms: u64,
+        role: TurnRole,
+        text: &str,
+    ) -> Result<(), AppError> {
+        let record = self
+            .records
+            .record_turn_for(root)
+            .ok_or_else(|| AppError::NotFound("conversation recorder".to_owned()))?;
+        record
+            .record(
+                conversation_id,
+                ConversationTurn::new(
+                    TurnId::new_random(),
+                    conversation_id,
+                    at_ms,
+                    InputSource::Human,
+                    role,
+                    text,
+                ),
+            )
+            .await
+    }
+}
+
+fn conversation_title(prompt: &str) -> String {
+    let compact = prompt.split_whitespace().collect::<Vec<_>>().join(" ");
+    compact
+        .chars()
+        .take(CUSTOM_CONVERSATION_TITLE_MAX_CHARS)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn title_is_compact_and_bounded() {
+        let input = format!("  hello\n\tworld {}", "x".repeat(100));
+        let title = conversation_title(&input);
+        assert!(title.starts_with("hello world "));
+        assert_eq!(title.chars().count(), CUSTOM_CONVERSATION_TITLE_MAX_CHARS);
+    }
+}
--- a/crates/application/src/conversation/mod.rs
+++ b/crates/application/src/conversation/mod.rs
@ -13,10 +13,16 @@
 //! the PTY or `app-tauri` (that is P6b). It is fully testable with in-memory fakes
 //! of the three ports.

+mod custom;
 mod paginate;
 mod record;
 mod rotate;

+pub use custom::{
+    CustomConversationIndexProvider, CustomConversationService, CUSTOM_CONVERSATION_LIST_LIMIT,
+    CUSTOM_CONVERSATION_TITLE_MAX_CHARS,
+};
+
 pub use paginate::{
    ConversationArchiveProvider, ReadConversationPage, ReadConversationPageInput, TurnPage,
    TurnSource, TurnView,
--- a/crates/application/src/lib.rs
+++ b/crates/application/src/lib.rs
@ -90,8 +90,10 @@ pub use chat_drafts::{
    SaveChatDraftInput,
 };
 pub use conversation::{
-    ConversationArchiveProvider, ReadConversationPage, ReadConversationPageInput, RecordTurn,
-    RotateConversationLog, RotateConversationLogInput, TurnPage, TurnSource, TurnView,
+    ConversationArchiveProvider, CustomConversationIndexProvider, CustomConversationService,
+    ReadConversationPage, ReadConversationPageInput, RecordTurn, RotateConversationLog,
+    RotateConversationLogInput, TurnPage, TurnSource, TurnView, CUSTOM_CONVERSATION_LIST_LIMIT,
+    CUSTOM_CONVERSATION_TITLE_MAX_CHARS,
 };
 pub use device::{
    normalize_pairing_code, pairing_codes_equal, AuthenticateSession, AuthenticateSessionInput,
--- a/crates/application/src/terminal/registry.rs
+++ b/crates/application/src/terminal/registry.rs
@ -536,6 +536,10 @@ struct StructuredEntry {
    /// The launch resumed a logical conversation already linked to the cell.
    /// A fresh in-memory chat bridge therefore cannot provide its transcript.
    transcript_restore_expected: bool,
+    /// Logical custom CLI conversation, distinct from the provider session id.
+    custom_conversation_id: Option<ConversationId>,
+    /// Deferred bounded handoff injected into the first post-resume user prompt.
+    pending_resume_preamble: Option<String>,
    /// Launch-scoped managed-temp handle retained for release.
    managed_temp_handle: Option<String>,
    /// Optional local-model-server usage guard retained for the live session.
@ -674,6 +678,8 @@ impl StructuredSessions {
                    agent_id,
                    node_id,
                    transcript_restore_expected: false,
+                    custom_conversation_id: None,
+                    pending_resume_preamble: None,
                    managed_temp_handle,
                    _model_server_guard: model_server_guard,
                    turn_generation: 0,
@ -834,6 +840,40 @@ impl StructuredSessions {
            .unwrap_or(false)
    }

+    /// Binds a logical custom conversation and an optional one-shot resume preamble.
+    pub fn bind_custom_conversation(
+        &self,
+        id: SessionId,
+        conversation_id: ConversationId,
+        pending_resume_preamble: Option<String>,
+    ) {
+        if let Ok(mut entries) = self.entries.lock() {
+            if let Some(entry) = entries.get_mut(&id) {
+                entry.custom_conversation_id = Some(conversation_id);
+                entry.pending_resume_preamble = pending_resume_preamble;
+            }
+        }
+    }
+
+    /// Returns the logical custom conversation bound to a live session.
+    #[must_use]
+    pub fn custom_conversation_id(&self, id: &SessionId) -> Option<ConversationId> {
+        self.entries.lock().ok().and_then(|entries| {
+            entries
+                .get(id)
+                .and_then(|entry| entry.custom_conversation_id)
+        })
+    }
+
+    /// Takes the deferred resume preamble. It can therefore be injected at most once.
+    pub fn take_pending_resume_preamble(&self, id: &SessionId) -> Option<String> {
+        self.entries.lock().ok().and_then(|mut entries| {
+            entries
+                .get_mut(id)
+                .and_then(|entry| entry.pending_resume_preamble.take())
+        })
+    }
+
    /// Enregistre une session assistant ticket éphémère, keyée par `issue_ref`.
    ///
    /// Retourne l'éventuelle session remplacée pour que l'appelant puisse la fermer
--- a/crates/application/tests/cancel_agent_chat.rs
+++ b/crates/application/tests/cancel_agent_chat.rs
@ -74,6 +74,40 @@ fn id<T>(value: u128, make: impl FnOnce(Uuid) -> T) -> T {
    make(Uuid::from_u128(value))
 }

+#[test]
+fn custom_conversation_binding_keeps_logical_id_and_consumes_resume_once() {
+    let session_id = id(1, SessionId::from_uuid);
+    let project_id = id(2, ProjectId::from_uuid);
+    let agent_id = id(3, AgentId::from_uuid);
+    let node_id = id(4, NodeId::from_uuid);
+    let conversation_id = domain::ConversationId::from_uuid(Uuid::from_u128(5));
+    let sessions = StructuredSessions::new();
+    sessions.insert_in_project(
+        project_id,
+        Arc::new(FakeSession::new(session_id, [])),
+        agent_id,
+        node_id,
+    );
+
+    sessions.bind_custom_conversation(
+        session_id,
+        conversation_id,
+        Some("bounded handoff".to_owned()),
+    );
+
+    assert_eq!(
+        sessions.custom_conversation_id(&session_id),
+        Some(conversation_id)
+    );
+    assert_eq!(
+        sessions
+            .take_pending_resume_preamble(&session_id)
+            .as_deref(),
+        Some("bounded handoff")
+    );
+    assert_eq!(sessions.take_pending_resume_preamble(&session_id), None);
+}
+
 struct TurnAccounting {
    state: Mutex<AgentBusyState>,
    cancelled: Mutex<Vec<(RuntimeAgentKey, TicketId)>>,
--- a/crates/application/tests/structured_launch_d3.rs
+++ b/crates/application/tests/structured_launch_d3.rs
@ -918,6 +918,44 @@ async fn global_idea_cli_preference_applies_to_a_new_human_launch() {
    assert_eq!(f.pty.spawn_count(), 0);
 }

+#[tokio::test]
+async fn explicit_custom_chat_gets_a_fresh_logical_conversation_without_persisting_it() {
+    let f = launch_fixture(
+        structured_profile(pid(9)),
+        FakeFactory::new(500, Some("engine-conv")),
+    );
+    let mut input = launch_input(f.agent.id);
+    input.require_structured = true;
+
+    let output = f.launch.execute(input).await.unwrap();
+    let assigned = output
+        .assigned_conversation_id
+        .as_deref()
+        .and_then(|raw| Uuid::parse_str(raw).ok())
+        .map(ConversationId::from_uuid)
+        .expect("fresh logical conversation id");
+
+    assert_eq!(assigned, ConversationId::from_uuid(Uuid::from_u128(1)));
+    assert_ne!(
+        assigned,
+        ConversationId::for_project_pair(
+            project_id(),
+            ConversationParty::User,
+            ConversationParty::agent(f.agent.id),
+        ),
+        "each explicit custom chat is a distinct logical thread"
+    );
+    assert_eq!(
+        f.structured.custom_conversation_id(&sid(500)),
+        Some(assigned)
+    );
+    assert_eq!(
+        f.structured.take_pending_resume_preamble(&sid(500)),
+        None,
+        "a fresh chat has no resume context"
+    );
+}
+
 #[tokio::test]
 async fn explicit_native_tui_overrides_the_global_idea_cli_preference() {
    let f = launch_fixture_with_preference(DefaultAgentTerminalInterface::IdeaCli);
--- a/crates/backend/src/dto.rs
+++ b/crates/backend/src/dto.rs
@ -1054,6 +1054,9 @@ pub enum SlashCommandEffectDto {
        /// Number of retained chunks removed by the backend bridge.
        #[serde(rename = "clearedChunks")]
        cleared_chunks: usize,
+        /// Fresh ephemeral logical conversation id; it is indexed only on first send.
+        #[serde(rename = "conversationId", skip_serializing_if = "Option::is_none")]
+        conversation_id: Option<String>,
    },
    /// Placeholder for ticket #164.
    ProfileSwitch {
@ -1085,6 +1088,7 @@ impl From<SlashCommandEffect> for SlashCommandEffectDto {
            SlashCommandEffect::CleanConversation { session_id } => Self::CleanConversation {
                session_id: session_id.to_string(),
                cleared_chunks: 0,
+                conversation_id: None,
            },
            SlashCommandEffect::ProfileSwitch { session_id } => Self::ProfileSwitch {
                session_id: session_id.to_string(),
@ -1444,6 +1448,18 @@ pub struct TerminalSessionDto {
    /// [`CellKind::Pty`] (the historical, non-breaking shape: a PTY session DTO
    /// always serialises with `cellKind: "pty"`).
    pub cell_kind: CellKind,
+    /// Durable human-visible history loaded for an explicitly resumed custom chat.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub history: Vec<TurnViewDto>,
+    /// Whether older history pages exist before `history`.
+    #[serde(default)]
+    pub history_has_more: bool,
+    /// Anchor for the next older history page.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub history_next_anchor: Option<String>,
+    /// True when this launch explicitly reopened an indexed custom conversation.
+    #[serde(default)]
+    pub resumed: bool,
 }

 /// Whether a session's hosting cell renders as a structured chat view or a raw
@ -1469,6 +1485,10 @@ impl From<OpenTerminalOutput> for TerminalSessionDto {
            assigned_conversation_id: None,
            engine_session_id: None,
            cell_kind: CellKind::Pty,
+            history: Vec::new(),
+            history_has_more: false,
+            history_next_anchor: None,
+            resumed: false,
        }
    }
 }
@ -3569,10 +3589,60 @@ impl From<LaunchAgentOutput> for TerminalSessionDto {
            assigned_conversation_id,
            engine_session_id,
            cell_kind,
+            history: Vec::new(),
+            history_has_more: false,
+            history_next_anchor: None,
+            resumed: false,
        }
    }
 }

+/// Request for the durable custom CLI conversation menu.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListCustomConversationsRequestDto {
+    /// Owning project.
+    pub project_id: String,
+    /// Owning agent.
+    pub agent_id: String,
+    /// Requested maximum, defaulting and clamped to 50.
+    #[serde(default)]
+    pub limit: Option<usize>,
+}
+
+/// One conversation menu row.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomConversationSummaryDto {
+    /// Logical conversation id.
+    pub conversation_id: String,
+    /// First-prompt title.
+    pub title: String,
+    /// Creation timestamp.
+    pub created_at_ms: u64,
+    /// Last durable activity timestamp.
+    pub updated_at_ms: u64,
+}
+
+impl From<domain::CustomConversationEntry> for CustomConversationSummaryDto {
+    fn from(entry: domain::CustomConversationEntry) -> Self {
+        Self {
+            conversation_id: entry.conversation_id.to_string(),
+            title: entry.title,
+            created_at_ms: entry.created_at_ms,
+            updated_at_ms: entry.updated_at_ms,
+        }
+    }
+}
+
+/// Recent custom CLI conversations for one agent.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomConversationListDto {
+    /// Newest-first, non-empty rows.
+    pub conversations: Vec<CustomConversationSummaryDto>,
+}
+
 /// Request DTO for `interrupt_agent` (cadrage C4 §4.2): the Interrompre path. The
 /// frontend sends `{ request: { projectId, agentId } }`.
 #[derive(Debug, Clone, Deserialize)]
@ -3708,6 +3778,10 @@ impl From<TerminalSession> for TerminalSessionDto {
            assigned_conversation_id: None,
            engine_session_id: None,
            cell_kind: CellKind::Pty,
+            history: Vec::new(),
+            history_has_more: false,
+            history_next_anchor: None,
+            resumed: false,
        }
    }
 }
--- a/crates/backend/src/lib.rs
+++ b/crates/backend/src/lib.rs
@ -21,15 +21,15 @@ use application::{
    ClearChatDraft, CloneOpenCodeProfileFromSeed, CloneProfileFromSeed, CloseProject, CloseTab,
    CloseTerminal, CloseTicketAssistant, ConfigureProfiles, ContextGuardUseCases,
    CreateAgentFromScratch, CreateAgentFromTemplate, CreateIssue, CreateLayout, CreateMemory,
-    CreateProject, CreateSkill, CreateSprint, CreateTemplate, DeleteAgent,
-    DeleteCustomProjectIconAsset, DeleteEmbedderProfile, DeleteIssue, DeleteLayout, DeleteMemory,
-    DeleteModelArtifact, DeleteModelServer, DeleteProfile, DeleteSkill, DeleteSprint,
-    DeleteTemplate, DescribeEmbedderEngines, DetectAgentDrift, DetectProfiles,
-    DismissEmbedderSuggestion, EnsureLocalModelServer, ExecuteSlashCommand, FirstRunState,
-    GcManagedTemp, GetAppExitWorkGuardState, GetCustomProjectIconAssetUsage, GetLiveStateLean,
-    GetMemory, GetProjectPermissions, GetProjectSystemPermissions, GetProjectWorkState,
-    GitBranches, GitCheckout, GitCommit, GitGraph, GitInit, GitLog, GitStage, GitStatus,
-    GitUnstage, HarvestMemoryFromTurn, HealthUseCase, ImportChatAttachments,
+    CreateProject, CreateSkill, CreateSprint, CreateTemplate, CustomConversationIndexProvider,
+    CustomConversationService, DeleteAgent, DeleteCustomProjectIconAsset, DeleteEmbedderProfile,
+    DeleteIssue, DeleteLayout, DeleteMemory, DeleteModelArtifact, DeleteModelServer, DeleteProfile,
+    DeleteSkill, DeleteSprint, DeleteTemplate, DescribeEmbedderEngines, DetectAgentDrift,
+    DetectProfiles, DismissEmbedderSuggestion, EnsureLocalModelServer, ExecuteSlashCommand,
+    FirstRunState, GcManagedTemp, GetAppExitWorkGuardState, GetCustomProjectIconAssetUsage,
+    GetLiveStateLean, GetMemory, GetProjectPermissions, GetProjectSystemPermissions,
+    GetProjectWorkState, GitBranches, GitCheckout, GitCommit, GitGraph, GitInit, GitLog, GitStage,
+    GitStatus, GitUnstage, HarvestMemoryFromTurn, HealthUseCase, ImportChatAttachments,
    ImportCustomProjectIconAsset, InspectConversation, InstallPluginFromArchive,
    InstallPluginFromDirectory, JsonPluginManifestValidator, LaunchAgent, LaunchAgentInput,
    LinkIssues, ListAgents, ListAgentsInput, ListClaudeModels, ListCodexModels,
@ -107,20 +107,20 @@ use infrastructure::{
    CliAgentRuntime, CodexPermissionProjector, CommandBackgroundRunner,
    DiagnosticPluginWorkspaceExecAudit, EmbeddedCompatibilityMatrix, EmbedderEnvProbe,
    ExternalMcpPluginSupervisor, FsAssistantContextStore, FsBackgroundTaskStore,
-    FsChatAttachmentStore, FsChatDraftStore, FsConversationLog, FsCustomProjectIconAssetStore,
-    FsDeviceSessionStore, FsEmbedderProfileStore, FsEmbedderPromptStore, FsHandoffStore,
-    FsIssueNumberAllocator, FsIssueStore, FsLiveStateStore, FsManagedTempStore,
-    FsMcpToolPermissionStore, FsMemoryStore, FsModelServerRegistry, FsOpenProjectRestoreStore,
-    FsOrchestratorWatcher, FsPermissionStore, FsPluginPackageStore, FsPluginRegistryStore,
-    FsPluginStorageStore, FsProfileStore, FsProjectPluginSettingsStore, FsProjectSettingsStore,
-    FsProjectStore, FsProviderSessionStore, FsScheduledProjectTaskStore, FsSecretStore,
-    FsSkillStore, FsSprintStore, FsSystemPermissionStore, FsTemplateStore, FsUserSettingsStore,
-    FsWindowStateStore, FsWorkspaceToolProvider, Git2Repository, HeuristicHandoffSummarizer,
-    HfModelArtifactDownloader, HttpOpenAiCompatibleProbe, HttpProviderModelCatalogue,
-    IdeaiContextStore, InMemoryConversationRegistry, InMemoryMailbox, InMemoryPairAttemptLimiter,
-    LlamaCppRuntime, LocalEnvironmentReader, LocalFileSystem, LocalManagedProcess,
-    LocalProcessSpawner, LocalWorkspaceToolRunner, ManagedTempToolProvider, McpServer,
-    MediatedInbox, NaiveMemoryRecall, OrchestratorWatchHandle, PortablePtyAdapter,
+    FsChatAttachmentStore, FsChatDraftStore, FsConversationLog, FsCustomConversationIndex,
+    FsCustomProjectIconAssetStore, FsDeviceSessionStore, FsEmbedderProfileStore,
+    FsEmbedderPromptStore, FsHandoffStore, FsIssueNumberAllocator, FsIssueStore, FsLiveStateStore,
+    FsManagedTempStore, FsMcpToolPermissionStore, FsMemoryStore, FsModelServerRegistry,
+    FsOpenProjectRestoreStore, FsOrchestratorWatcher, FsPermissionStore, FsPluginPackageStore,
+    FsPluginRegistryStore, FsPluginStorageStore, FsProfileStore, FsProjectPluginSettingsStore,
+    FsProjectSettingsStore, FsProjectStore, FsProviderSessionStore, FsScheduledProjectTaskStore,
+    FsSecretStore, FsSkillStore, FsSprintStore, FsSystemPermissionStore, FsTemplateStore,
+    FsUserSettingsStore, FsWindowStateStore, FsWorkspaceToolProvider, Git2Repository,
+    HeuristicHandoffSummarizer, HfModelArtifactDownloader, HttpOpenAiCompatibleProbe,
+    HttpProviderModelCatalogue, IdeaiContextStore, InMemoryConversationRegistry, InMemoryMailbox,
+    InMemoryPairAttemptLimiter, LlamaCppRuntime, LocalEnvironmentReader, LocalFileSystem,
+    LocalManagedProcess, LocalProcessSpawner, LocalWorkspaceToolRunner, ManagedTempToolProvider,
+    McpServer, MediatedInbox, NaiveMemoryRecall, OrchestratorWatchHandle, PortablePtyAdapter,
    ProcessCliVersionReader, ReadOnlyRuntimePermissionProbe, RwFileGuard, StructuredSessionFactory,
    SystemClock, SystemMillisClock, TemplateToolProvider, TicketAssistantEnvironmentPreparer,
    TicketToolProvider, TokioBroadcastEventBus, TokioScheduler, ToolPolicyRegistry, UuidGenerator,
@ -496,6 +496,26 @@ impl RecordTurnProvider for AppRecordTurnProvider {
    }
 }

+/// Resolves the durable custom CLI conversation catalogue for a project root.
+#[derive(Default)]
+struct AppCustomConversationIndexProvider {
+    indexes: Mutex<HashMap<String, Arc<FsCustomConversationIndex>>>,
+}
+
+impl CustomConversationIndexProvider for AppCustomConversationIndexProvider {
+    fn custom_conversation_index_for(
+        &self,
+        root: &domain::project::ProjectPath,
+    ) -> Option<Arc<dyn domain::CustomConversationIndex>> {
+        let mut indexes = self.indexes.lock().ok()?;
+        let index = indexes
+            .entry(root.as_str().to_owned())
+            .or_insert_with(|| Arc::new(FsCustomConversationIndex::new(root)))
+            .clone();
+        Some(index as Arc<dyn domain::CustomConversationIndex>)
+    }
+}
+
 /// Implémente [`ConversationArchiveProvider`](application::ConversationArchiveProvider)
 /// (lot LS6) en matérialisant un [`FsConversationLog`] (qui implémente aussi
 /// [`domain::ConversationArchive`]) ciblant le **project root** courant.
@ -2317,6 +2337,8 @@ pub struct BackendCore {
    pub get_app_exit_work_guard_state: Arc<GetAppExitWorkGuardState>,
    /// Human paginated read of a conversation's full transcript (lot LS6).
    pub read_conversation_page: Arc<ReadConversationPage>,
+    /// Durable listing, ownership and Prompt/Final checkpoints for custom CLI chats.
+    pub custom_conversations: Arc<CustomConversationService>,
    /// Best-effort log rotation, triggered off the hot path at thread resume/open (lot LS6).
    pub rotate_conversation_log: Arc<RotateConversationLog>,
    /// Rebinds an already-running agent's live session to a visible cell (Lot D).
@ -4202,6 +4224,11 @@ impl BackendCore {
            as Arc<dyn application::ConversationArchiveProvider>;
        let read_conversation_page =
            Arc::new(ReadConversationPage::new(Arc::clone(&archive_provider)));
+        let custom_conversations = Arc::new(CustomConversationService::new(
+            Arc::new(AppCustomConversationIndexProvider::default())
+                as Arc<dyn CustomConversationIndexProvider>,
+            Arc::new(AppRecordTurnProvider) as Arc<dyn RecordTurnProvider>,
+        ));
        let rotate_conversation_log = Arc::new(RotateConversationLog::new(
            Arc::clone(&archive_provider),
            Arc::new(AppHandoffProvider) as Arc<dyn application::HandoffProvider>,
@ -4617,6 +4644,7 @@ impl BackendCore {
            get_project_work_state,
            get_app_exit_work_guard_state,
            read_conversation_page,
+            custom_conversations,
            rotate_conversation_log,
            attach_live_agent,
            stop_live_agent,
--- a/crates/domain/src/custom_conversation.rs
+++ b/crates/domain/src/custom_conversation.rs
@ -0,0 +1,43 @@
+//! Durable catalogue of user-facing custom CLI conversations.
+
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+
+use crate::ports::StoreError;
+use crate::{AgentId, ConversationId};
+
+/// One non-empty custom CLI conversation owned by an agent.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomConversationEntry {
+    /// Stable logical conversation id used by log, handoff and provider-session stores.
+    pub conversation_id: ConversationId,
+    /// Agent that owns the conversation.
+    pub agent_id: AgentId,
+    /// Title derived from the first accepted user prompt.
+    pub title: String,
+    /// Creation timestamp in epoch milliseconds.
+    pub created_at_ms: u64,
+    /// Most recent persisted human/final activity in epoch milliseconds.
+    pub updated_at_ms: u64,
+}
+
+/// Project-scoped durable index for non-empty custom CLI conversations.
+#[async_trait]
+pub trait CustomConversationIndex: Send + Sync {
+    /// Lists conversations owned by `agent_id`, newest first and capped by `limit`.
+    async fn list(
+        &self,
+        agent_id: AgentId,
+        limit: usize,
+    ) -> Result<Vec<CustomConversationEntry>, StoreError>;
+
+    /// Finds an indexed conversation by logical id.
+    async fn get(
+        &self,
+        conversation_id: ConversationId,
+    ) -> Result<Option<CustomConversationEntry>, StoreError>;
+
+    /// Inserts the first non-empty prompt or updates the last-activity timestamp.
+    async fn upsert(&self, entry: CustomConversationEntry) -> Result<(), StoreError>;
+}
--- a/crates/domain/src/lib.rs
+++ b/crates/domain/src/lib.rs
@ -37,6 +37,7 @@ pub mod chat_attachment;
 pub mod chat_draft;
 pub mod conversation;
 pub mod conversation_log;
+pub mod custom_conversation;
 pub mod device;
 pub mod error;
 pub mod events;
@ -177,6 +178,7 @@ pub use conversation_log::{
    TurnSlice, HANDOFF_SUMMARY_MAX_CHARS, MAX_ARCHIVE_SEGMENTS, PAGE_DEFAULT_LIMIT, PAGE_MAX_LIMIT,
    ROTATE_AFTER_BYTES, ROTATE_AFTER_TURNS,
 };
+pub use custom_conversation::{CustomConversationEntry, CustomConversationIndex};

 pub use device::{
    AuthenticatedDevice, DeviceError, DeviceId, DeviceName, PairedDevice, SessionTokenHash,
--- a/crates/infrastructure/src/conversation_log/custom_index.rs
+++ b/crates/infrastructure/src/conversation_log/custom_index.rs
@ -0,0 +1,124 @@
+//! Filesystem adapter for the custom CLI conversation catalogue.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tokio::io::AsyncWriteExt;
+
+use domain::ports::StoreError;
+use domain::ProjectPath;
+use domain::{AgentId, ConversationId, CustomConversationEntry, CustomConversationIndex};
+
+use super::{CONVERSATIONS_DIR, IDEAI_DIR};
+
+const INDEX_FILE: &str = "custom-index.json";
+
+/// JSON-backed project-scoped custom conversation catalogue.
+pub struct FsCustomConversationIndex {
+    path: PathBuf,
+    lock: Arc<tokio::sync::Mutex<()>>,
+}
+
+impl FsCustomConversationIndex {
+    /// Creates an index rooted below `<project>/.ideai/conversations/`.
+    #[must_use]
+    pub fn new(root: &ProjectPath) -> Self {
+        Self {
+            path: PathBuf::from(root.as_str())
+                .join(IDEAI_DIR)
+                .join(CONVERSATIONS_DIR)
+                .join(INDEX_FILE),
+            lock: Arc::new(tokio::sync::Mutex::new(())),
+        }
+    }
+
+    async fn read_entries(&self) -> Result<Vec<CustomConversationEntry>, StoreError> {
+        match tokio::fs::read(&self.path).await {
+            Ok(bytes) => serde_json::from_slice(&bytes)
+                .map_err(|error| StoreError::Serialization(error.to_string())),
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(Vec::new()),
+            Err(error) => Err(StoreError::Io(error.to_string())),
+        }
+    }
+
+    async fn write_entries(&self, entries: &[CustomConversationEntry]) -> Result<(), StoreError> {
+        let parent = self.path.parent().expect("custom index path has parent");
+        tokio::fs::create_dir_all(parent)
+            .await
+            .map_err(|error| StoreError::Io(error.to_string()))?;
+        let bytes = serde_json::to_vec_pretty(entries)
+            .map_err(|error| StoreError::Serialization(error.to_string()))?;
+        let temporary = self.path.with_extension("json.tmp");
+        let mut file = tokio::fs::File::create(&temporary)
+            .await
+            .map_err(|error| StoreError::Io(error.to_string()))?;
+        file.write_all(&bytes)
+            .await
+            .map_err(|error| StoreError::Io(error.to_string()))?;
+        file.sync_all()
+            .await
+            .map_err(|error| StoreError::Io(error.to_string()))?;
+        drop(file);
+        tokio::fs::rename(&temporary, &self.path)
+            .await
+            .map_err(|error| StoreError::Io(error.to_string()))
+    }
+}
+
+#[async_trait]
+impl CustomConversationIndex for FsCustomConversationIndex {
+    async fn list(
+        &self,
+        agent_id: AgentId,
+        limit: usize,
+    ) -> Result<Vec<CustomConversationEntry>, StoreError> {
+        let _guard = self.lock.lock().await;
+        let mut entries = self
+            .read_entries()
+            .await?
+            .into_iter()
+            .filter(|entry| entry.agent_id == agent_id)
+            .collect::<Vec<_>>();
+        entries.sort_by(|left, right| {
+            right
+                .updated_at_ms
+                .cmp(&left.updated_at_ms)
+                .then_with(|| right.created_at_ms.cmp(&left.created_at_ms))
+        });
+        entries.truncate(limit);
+        Ok(entries)
+    }
+
+    async fn get(
+        &self,
+        conversation_id: ConversationId,
+    ) -> Result<Option<CustomConversationEntry>, StoreError> {
+        let _guard = self.lock.lock().await;
+        Ok(self
+            .read_entries()
+            .await?
+            .into_iter()
+            .find(|entry| entry.conversation_id == conversation_id))
+    }
+
+    async fn upsert(&self, entry: CustomConversationEntry) -> Result<(), StoreError> {
+        let _guard = self.lock.lock().await;
+        let mut entries = self.read_entries().await?;
+        if let Some(existing) = entries
+            .iter_mut()
+            .find(|candidate| candidate.conversation_id == entry.conversation_id)
+        {
+            // Ownership and the first-prompt title are immutable.
+            if existing.agent_id != entry.agent_id {
+                return Err(StoreError::Serialization(
+                    "custom conversation ownership mismatch".to_owned(),
+                ));
+            }
+            existing.updated_at_ms = existing.updated_at_ms.max(entry.updated_at_ms);
+        } else {
+            entries.push(entry);
+        }
+        self.write_entries(&entries).await
+    }
+}
--- a/crates/infrastructure/src/conversation_log/mod.rs
+++ b/crates/infrastructure/src/conversation_log/mod.rs
@ -46,10 +46,12 @@ use domain::conversation_log::{
 use domain::ports::StoreError;
 use domain::project::ProjectPath;

+mod custom_index;
 mod handoff;
 mod providers;
 mod summarizer;

+pub use custom_index::FsCustomConversationIndex;
 pub use handoff::FsHandoffStore;
 pub use providers::FsProviderSessionStore;
 pub use summarizer::{HeuristicHandoffSummarizer, TURN_LINE_MAX_CHARS, WINDOW};
--- a/crates/infrastructure/src/lib.rs
+++ b/crates/infrastructure/src/lib.rs
@ -62,8 +62,8 @@ pub use chat_drafts::FsChatDraftStore;
 pub use clock::SystemClock;
 pub use conversation::InMemoryConversationRegistry;
 pub use conversation_log::{
-    FsConversationLog, FsHandoffStore, FsProviderSessionStore, HeuristicHandoffSummarizer,
-    TURN_LINE_MAX_CHARS, WINDOW,
+    FsConversationLog, FsCustomConversationIndex, FsHandoffStore, FsProviderSessionStore,
+    HeuristicHandoffSummarizer, TURN_LINE_MAX_CHARS, WINDOW,
 };
 pub use eventbus::TokioBroadcastEventBus;
 pub use fileguard::RwFileGuard;
--- a/crates/infrastructure/tests/conversation_log.rs
+++ b/crates/infrastructure/tests/conversation_log.rs
@ -15,6 +15,7 @@
 //! requires, and is cleaned up on drop. No extra dependency is pulled in.

 use std::path::PathBuf;
+use std::sync::Arc;

 use domain::conversation::ConversationId;
 use domain::conversation_log::{
@ -25,12 +26,36 @@ use domain::conversation_log::{
 use domain::input::InputSource;
 use domain::ports::StoreError;
 use domain::project::ProjectPath;
+use domain::{AgentId, CustomConversationEntry, CustomConversationIndex};
 use infrastructure::{
-    FsConversationLog, FsHandoffStore, FsProviderSessionStore, HeuristicHandoffSummarizer,
-    TURN_LINE_MAX_CHARS, WINDOW,
+    FsConversationLog, FsCustomConversationIndex, FsHandoffStore, FsProviderSessionStore,
+    HeuristicHandoffSummarizer, TURN_LINE_MAX_CHARS, WINDOW,
 };
 use uuid::Uuid;

+struct CustomIndexProvider;
+
+impl application::CustomConversationIndexProvider for CustomIndexProvider {
+    fn custom_conversation_index_for(
+        &self,
+        root: &ProjectPath,
+    ) -> Option<Arc<dyn CustomConversationIndex>> {
+        Some(Arc::new(FsCustomConversationIndex::new(root)))
+    }
+}
+
+struct ConversationRecordProvider;
+
+impl application::RecordTurnProvider for ConversationRecordProvider {
+    fn record_turn_for(&self, root: &ProjectPath) -> Option<Arc<application::RecordTurn>> {
+        Some(Arc::new(application::RecordTurn::new(
+            Arc::new(FsConversationLog::new(root)),
+            Arc::new(FsHandoffStore::new(root)),
+            Arc::new(HeuristicHandoffSummarizer::new()),
+        )))
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Test scaffolding
 // ---------------------------------------------------------------------------
@ -77,6 +102,138 @@ impl TempDir {
            .join("providers.json.tmp")
    }
 }
+
+#[tokio::test]
+async fn custom_index_is_durable_owned_sorted_and_capped() {
+    let tmp = TempDir::new();
+    let root = tmp.project_path();
+    let index = FsCustomConversationIndex::new(&root);
+    let agent_a = AgentId::from_uuid(Uuid::from_u128(10));
+    let agent_b = AgentId::from_uuid(Uuid::from_u128(20));
+
+    index
+        .upsert(CustomConversationEntry {
+            conversation_id: conv_id(1),
+            agent_id: agent_a,
+            title: "first prompt".to_owned(),
+            created_at_ms: 100,
+            updated_at_ms: 100,
+        })
+        .await
+        .unwrap();
+    index
+        .upsert(CustomConversationEntry {
+            conversation_id: conv_id(2),
+            agent_id: agent_a,
+            title: "newer prompt".to_owned(),
+            created_at_ms: 200,
+            updated_at_ms: 300,
+        })
+        .await
+        .unwrap();
+    index
+        .upsert(CustomConversationEntry {
+            conversation_id: conv_id(3),
+            agent_id: agent_b,
+            title: "foreign".to_owned(),
+            created_at_ms: 400,
+            updated_at_ms: 400,
+        })
+        .await
+        .unwrap();
+
+    let restarted = FsCustomConversationIndex::new(&root);
+    let rows = restarted.list(agent_a, 1).await.unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].conversation_id, conv_id(2));
+    assert_eq!(rows[0].title, "newer prompt");
+    assert_eq!(
+        restarted.get(conv_id(3)).await.unwrap().unwrap().agent_id,
+        agent_b
+    );
+}
+
+#[tokio::test]
+async fn custom_index_keeps_first_title_and_rejects_owner_change() {
+    let tmp = TempDir::new();
+    let index = FsCustomConversationIndex::new(&tmp.project_path());
+    let agent_a = AgentId::from_uuid(Uuid::from_u128(10));
+    let agent_b = AgentId::from_uuid(Uuid::from_u128(20));
+    let original = CustomConversationEntry {
+        conversation_id: conv_id(1),
+        agent_id: agent_a,
+        title: "original".to_owned(),
+        created_at_ms: 100,
+        updated_at_ms: 100,
+    };
+    index.upsert(original.clone()).await.unwrap();
+    index
+        .upsert(CustomConversationEntry {
+            title: "must not replace".to_owned(),
+            updated_at_ms: 200,
+            ..original
+        })
+        .await
+        .unwrap();
+    let stored = index.get(conv_id(1)).await.unwrap().unwrap();
+    assert_eq!(stored.title, "original");
+    assert_eq!(stored.updated_at_ms, 200);
+
+    let error = index
+        .upsert(CustomConversationEntry {
+            agent_id: agent_b,
+            ..stored
+        })
+        .await
+        .unwrap_err();
+    assert!(matches!(error, StoreError::Serialization(_)));
+}
+
+#[tokio::test]
+async fn custom_service_materializes_on_prompt_records_final_and_checks_owner() {
+    let tmp = TempDir::new();
+    let root = tmp.project_path();
+    let service = application::CustomConversationService::new(
+        Arc::new(CustomIndexProvider),
+        Arc::new(ConversationRecordProvider),
+    );
+    let agent = AgentId::from_uuid(Uuid::from_u128(10));
+    let foreign = AgentId::from_uuid(Uuid::from_u128(20));
+    let conversation = conv_id(99);
+
+    assert!(service.list(&root, agent, 50).await.unwrap().is_empty());
+    assert!(!tmp
+        .0
+        .join(".ideai/conversations/custom-index.json")
+        .exists());
+
+    service
+        .record_prompt(&root, agent, conversation, 100, "  First\n user prompt  ")
+        .await
+        .unwrap();
+    service
+        .record_response(&root, agent, conversation, 200, "Final answer")
+        .await
+        .unwrap();
+
+    let rows = service.list(&root, agent, 50).await.unwrap();
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].title, "First user prompt");
+    assert_eq!(rows[0].updated_at_ms, 200);
+    let turns = FsConversationLog::new(&root)
+        .read(conversation, None)
+        .await
+        .unwrap();
+    assert_eq!(turns.len(), 2);
+    assert_eq!(turns[0].role, TurnRole::Prompt);
+    assert_eq!(turns[1].role, TurnRole::Response);
+
+    let error = service
+        .assert_owned(&root, foreign, conversation)
+        .await
+        .unwrap_err();
+    assert!(matches!(error, application::AppError::Invalid(_)));
+}
 impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.0);
--- a/crates/web-server/src/lib.rs
+++ b/crates/web-server/src/lib.rs
@ -86,16 +86,18 @@ use backend::dto::{
    ConversationTranscriptUnavailableReasonDto, CreateAgentFromTemplateRequestDto,
    CreateAgentRequestDto, CreateLayoutRequestDto, CreateLayoutResultDto, CreateMemoryRequestDto,
    CreateScheduledProjectTaskRequestDto, CreateSkillRequestDto, CreateTemplateRequestDto,
-    CustomProjectIconAssetDto, CustomProjectIconUsageDto, DeleteLayoutRequestDto,
-    DeleteLayoutResultDto, DetectProfilesRequestDto, DetectProfilesResponseDto, EmbedderEnginesDto,
-    EmbedderProfileDto, EmbedderProfileListDto, ErrorDto, FirstRunStateDto, GitBranchesDto,
-    GitCheckoutRequestDto, GitCommitDto, GitCommitListDto, GitCommitRequestDto, GitStageRequestDto,
-    GitStatusListDto, GraphCommitListDto, HealthRequestDto, HealthResponseDto,
+    CustomConversationListDto, CustomConversationSummaryDto, CustomProjectIconAssetDto,
+    CustomProjectIconUsageDto, DeleteLayoutRequestDto, DeleteLayoutResultDto,
+    DetectProfilesRequestDto, DetectProfilesResponseDto, EmbedderEnginesDto, EmbedderProfileDto,
+    EmbedderProfileListDto, ErrorDto, FirstRunStateDto, GitBranchesDto, GitCheckoutRequestDto,
+    GitCommitDto, GitCommitListDto, GitCommitRequestDto, GitStageRequestDto, GitStatusListDto,
+    GraphCommitListDto, HealthRequestDto, HealthResponseDto,
    ImportCustomProjectIconAssetRequestDto, InspectConversationRequestDto, LaunchAgentRequestDto,
-    LayoutDto, LayoutOperationDto, ListLayoutsDto, LiveAgentListDto, MemoryDto, MemoryIndexDto,
-    MemoryLinksDto, MemoryListDto, OpenCodeProviderListDto, OpenProjectRestoreStateDto,
-    OpenTerminalRequestDto, ProfileDto, ProfileListDto, ProfileModelCatalogDto, ProjectDto,
-    ProjectListDto, ProjectMcpToolPermissionsDto, ProjectPermissionsDto, ProjectSettingsDto,
+    LayoutDto, LayoutOperationDto, ListCustomConversationsRequestDto, ListLayoutsDto,
+    LiveAgentListDto, MemoryDto, MemoryIndexDto, MemoryLinksDto, MemoryListDto,
+    OpenCodeProviderListDto, OpenProjectRestoreStateDto, OpenTerminalRequestDto, ProfileDto,
+    ProfileListDto, ProfileModelCatalogDto, ProjectDto, ProjectListDto,
+    ProjectMcpToolPermissionsDto, ProjectPermissionsDto, ProjectSettingsDto,
    ProjectSystemPermissionsDto, ProjectWorkStateDto, ReadAgentContextResponseDto,
    ReadConversationPageRequestDto, RecallMemoryRequestDto,
    RemoveOpenProjectRestoreEntryRequestDto, RemoveProjectRequestDto, RemoveProjectResponseDto,
@ -1585,13 +1587,32 @@ async fn ws_launch_agent(
    send_launch_agent_attached(frame, state, tx, owned, output).await
 }

+struct WsLaunchOutput {
+    launch: application::LaunchAgentOutput,
+    history: Option<application::TurnPage>,
+}
+
+impl From<application::LaunchAgentOutput> for WsLaunchOutput {
+    fn from(launch: application::LaunchAgentOutput) -> Self {
+        Self {
+            launch,
+            history: None,
+        }
+    }
+}
+
 async fn send_launch_agent_attached(
    frame: &ClientFrame,
    state: &Arc<ServerState>,
    tx: &mpsc::Sender<ServerFrame>,
    owned: &Arc<Mutex<Vec<WsAttachment>>>,
-    output: application::LaunchAgentOutput,
+    output: impl Into<WsLaunchOutput>,
 ) -> Result<(), ErrorDto> {
+    let output = output.into();
+    let WsLaunchOutput {
+        launch: output,
+        history,
+    } = output;
    if let Some(structured) = output.structured.as_ref() {
        let transcript_unavailable_reason =
            ConversationTranscriptUnavailableReasonDto::for_scrollback(
@ -1608,6 +1629,7 @@ async fn send_launch_agent_attached(
            output.engine_session_id.as_deref(),
            Vec::new(),
            transcript_unavailable_reason,
+            history,
        ))
        .await
        .map_err(|_| ErrorDto {
@ -1632,11 +1654,48 @@ async fn send_launch_agent_attached(
 async fn execute_launch_agent_for_ws(
    state: &Arc<ServerState>,
    request: LaunchAgentRequestDto,
-) -> Result<application::LaunchAgentOutput, ErrorDto> {
+) -> Result<WsLaunchOutput, ErrorDto> {
    let project = resolve_project_readonly(&request.project_id, &state.app).await?;
    let project_id = project.id;
    let agent_id = parse_agent_id(&request.agent_id)?;
    let node_id = request.node_id.as_deref().map(parse_node_id).transpose()?;
+    let history = if request.cell_kind == Some(backend::dto::CellKind::Chat) {
+        if let Some(raw) = request.conversation_id.as_deref() {
+            let conversation = Uuid::parse_str(raw)
+                .map(domain::ConversationId::from_uuid)
+                .map_err(|_| {
+                    ErrorDto::from(application::AppError::Invalid(format!(
+                        "invalid conversation id: {raw}"
+                    )))
+                })?;
+            state
+                .app
+                .custom_conversations
+                .assert_owned(&project.root, agent_id, conversation)
+                .await
+                .map_err(ErrorDto::from)?;
+            Some(
+                state
+                    .app
+                    .read_conversation_page
+                    .execute(ReadConversationPageInput {
+                        project_root: project.root.clone(),
+                        conversation,
+                        cursor: domain::PageCursor {
+                            anchor: None,
+                            direction: domain::PageDirection::Backward,
+                        },
+                        limit: 50,
+                    })
+                    .await
+                    .map_err(ErrorDto::from)?,
+            )
+        } else {
+            None
+        }
+    } else {
+        None
+    };
    let mcp_runtime = backend::mcp_endpoint::idea_exe_path().map(|exe| McpRuntime {
        exe,
        endpoint: backend::mcp_endpoint::mcp_endpoint(&project.id)
@ -1722,7 +1781,10 @@ async fn execute_launch_agent_for_ws(
        });
    }

-    Ok(output)
+    Ok(WsLaunchOutput {
+        launch: output,
+        history,
+    })
 }

 async fn ws_attach_terminal(
@ -1749,6 +1811,10 @@ async fn ws_attach_terminal(
        assigned_conversation_id: None,
        engine_session_id: None,
        cell_kind: backend::dto::CellKind::Pty,
+        history: Vec::new(),
+        history_has_more: false,
+        history_next_anchor: None,
+        resumed: false,
    };
    let next_seq = u64::from(!scrollback.is_empty());
    tx.send(ServerFrame::attached(
@ -1917,6 +1983,7 @@ async fn ws_attach_chat(
        session.conversation_id().as_deref(),
        Vec::new(),
        transcript_unavailable_reason,
+        None,
    ))
    .await
    .map_err(|_| ErrorDto {
@ -1949,6 +2016,52 @@ async fn ws_send_chat(
            message: "structured chat session not found".to_owned(),
        })?;
    let session_meta = state.app.structured_sessions.meta_for_session(&sid);
+    let custom_context = match (
+        session_meta.as_ref(),
+        state.app.structured_sessions.custom_conversation_id(&sid),
+    ) {
+        (Some((project_id, agent_id, _, _)), Some(conversation_id)) => {
+            let project = state
+                .app
+                .project_store
+                .list_projects()
+                .await
+                .map_err(|error| ErrorDto::from(application::AppError::Store(error.to_string())))?
+                .into_iter()
+                .find(|project| project.id == *project_id)
+                .ok_or_else(|| {
+                    ErrorDto::from(application::AppError::NotFound(format!(
+                        "project {project_id}"
+                    )))
+                })?;
+            Some((project.root, *agent_id, conversation_id))
+        }
+        _ => None,
+    };
+    let mut provider_prompt = prompt.clone();
+    if let Some((root, agent_id, conversation_id)) = &custom_context {
+        state
+            .app
+            .custom_conversations
+            .record_prompt(
+                root,
+                *agent_id,
+                *conversation_id,
+                u64::try_from(state.app.clock.now_millis()).unwrap_or_default(),
+                &prompt,
+            )
+            .await
+            .map_err(ErrorDto::from)?;
+        if let Some(summary) = state
+            .app
+            .structured_sessions
+            .take_pending_resume_preamble(&sid)
+        {
+            provider_prompt = format!(
+                "Contexte borné de la conversation reprise :\n\n{summary}\n\n---\n\nNouveau message utilisateur :\n{prompt}"
+            );
+        }
+    }
    let turn_guard = session_meta.as_ref().map(|(project_id, agent_id, _, _)| {
        backend::StructuredHumanTurnGuard::start_with_source(
            Arc::clone(&state.app.turn_watch_input),
@ -1984,7 +2097,7 @@ async fn ws_send_chat(
            }
        }
    });
-    let stream_result = session.send_with_tap(&prompt, tap_tx).await;
+    let stream_result = session.send_with_tap(&provider_prompt, tap_tx).await;
    let _ = tap_pump.join();
    let mut turn_guard = turn_guard;
    let mut stream = match stream_result {
@ -2010,6 +2123,21 @@ async fn ws_send_chat(
        let mut resume = false;
        let mut resume_prompt = None;
        for event in stream {
+            if let ReplyEvent::Final { content } = &event {
+                if let Some((root, agent_id, conversation_id)) = &custom_context {
+                    let _ = state
+                        .app
+                        .custom_conversations
+                        .record_response(
+                            root,
+                            *agent_id,
+                            *conversation_id,
+                            u64::try_from(state.app.clock.now_millis()).unwrap_or_default(),
+                            content,
+                        )
+                        .await;
+                }
+            }
            let provider_terminal =
                matches!(event, ReplyEvent::Final { .. } | ReplyEvent::Error { .. });
            if provider_terminal {
@ -3699,6 +3827,9 @@ async fn invoke(
        "git_init" => invoke_git_init(&request.args, &state.app).await,
        "git_graph" => invoke_git_graph(&request.args, &state.app).await,
        "read_conversation_page" => invoke_read_conversation_page(&request.args, &state.app).await,
+        "list_custom_agent_conversations" => {
+            invoke_list_custom_agent_conversations(&request.args, &state.app).await
+        }
        "get_project_work_state" => invoke_get_project_work_state(&request.args, &state.app).await,
        "list_background_tasks" => invoke_list_background_tasks(&request.args, &state.app).await,
        "cancel_background_task" => invoke_cancel_background_task(&request.args, &state.app).await,
@ -5863,6 +5994,27 @@ async fn invoke_read_conversation_page(
    serde_json::to_value(output).map_err(serialization_error)
 }

+async fn invoke_list_custom_agent_conversations(
+    args: &Value,
+    state: &BackendCore,
+) -> Result<Value, ErrorDto> {
+    let request = required_request::<ListCustomConversationsRequestDto>(
+        "list_custom_agent_conversations",
+        args,
+    )?;
+    let project = resolve_project_readonly(&request.project_id, state).await?;
+    let agent_id = parse_agent_id(&request.agent_id)?;
+    let conversations = state
+        .custom_conversations
+        .list(&project.root, agent_id, request.limit.unwrap_or(0))
+        .await
+        .map_err(ErrorDto::from)?
+        .into_iter()
+        .map(CustomConversationSummaryDto::from)
+        .collect();
+    serde_json::to_value(CustomConversationListDto { conversations }).map_err(serialization_error)
+}
+
 fn task_id_arg(args: &Value, command: &str) -> Result<domain::TaskId, ErrorDto> {
    args.get("taskId")
        .and_then(Value::as_str)
@ -6447,7 +6599,18 @@ impl ServerFrame {
        engine_session_id: Option<&str>,
        scrollback: Vec<ChatChunk>,
        transcript_unavailable_reason: Option<ConversationTranscriptUnavailableReasonDto>,
+        history: Option<application::TurnPage>,
    ) -> Self {
+        let history = history.map(|mut page| {
+            page.turns.retain(|turn| {
+                matches!(
+                    turn.role,
+                    domain::TurnRole::Prompt | domain::TurnRole::Response
+                )
+            });
+            TurnPageDto::from(page)
+        });
+        let resumed = history.is_some();
        Self {
            kind: "chat.attached".to_owned(),
            reply_to: Some(request_id.to_owned()),
@ -6462,6 +6625,8 @@ impl ServerFrame {
                "engineSessionId": engine_session_id,
                "scrollback": scrollback,
                "transcriptUnavailableReason": transcript_unavailable_reason,
+                "history": history,
+                "resumed": resumed,
            }),
        }
    }
@ -7946,6 +8111,10 @@ mod tests {
                assigned_conversation_id: None,
                engine_session_id: None,
                cell_kind: backend::dto::CellKind::Pty,
+                history: Vec::new(),
+                history_has_more: false,
+                history_next_anchor: None,
+                resumed: false,
            },
            vec![4, 5, 6],
            1,
--- a/frontend/src/adapters/agent.test.ts
+++ b/frontend/src/adapters/agent.test.ts
@ -369,6 +369,12 @@ describe("TauriAgentGateway invoke payloads", () => {
      cellKind: "chat",
      assignedConversationId: "conversation-1",
      transcriptUnavailableReason: "missingTranscript",
+      history: [
+        { id: "turn-1", atMs: 42, role: "prompt", source: { kind: "human" }, text: "Hello", textLen: 5 },
+      ],
+      historyHasMore: true,
+      historyNextAnchor: "turn-0",
+      resumed: true,
    });

    const out = await new TauriAgentGateway().launchAgentChat("proj-1", "agent-2", {
@ -397,6 +403,32 @@ describe("TauriAgentGateway invoke payloads", () => {
      cellKind: "chat",
      assignedConversationId: "conversation-1",
      transcriptUnavailableReason: "missingTranscript",
+      history: [
+        { id: "turn-1", atMs: 42, role: "prompt", source: { kind: "human" }, text: "Hello", textLen: 5 },
+      ],
+      historyHasMore: true,
+      historyNextAnchor: "turn-0",
+      resumed: true,
+    });
+  });
+
+  it("lists custom conversations with the nested backend request contract", async () => {
+    invoke.mockResolvedValueOnce({
+      conversations: [
+        {
+          conversationId: "conversation-1",
+          title: "First prompt",
+          createdAtMs: 10,
+          updatedAtMs: 20,
+        },
+      ],
+    });
+
+    await expect(
+      new TauriAgentGateway().listCustomAgentConversations("proj-1", "agent-2", 25),
+    ).resolves.toHaveLength(1);
+    expect(invoke).toHaveBeenCalledWith("list_custom_agent_conversations", {
+      request: { projectId: "proj-1", agentId: "agent-2", limit: 25 },
    });
  });

--- a/frontend/src/adapters/agent.ts
+++ b/frontend/src/adapters/agent.ts
@ -32,6 +32,7 @@ import type {
  ChatDraftScope,
  ChatDraftSnapshot,
  ConversationDetails,
+  CustomAgentConversationSummary,
  CreateAgentInput,
  LiveAgent,
  OpenTerminalOptions,
@ -55,6 +56,10 @@ interface LaunchAgentResponse {
  cellKind?: "chat" | "pty";
  /** Conversation id minted by this launch (omitted when nothing was assigned). */
  assignedConversationId?: string;
+  history?: import("@/domain").TurnView[];
+  historyHasMore?: boolean;
+  historyNextAnchor?: string;
+  resumed?: boolean;
  transcriptUnavailableReason?: AgentChatHandle["transcriptUnavailableReason"];
 }

@ -306,12 +311,32 @@ export class TauriAgentGateway implements AgentGateway {
      ...(res.assignedConversationId
        ? { assignedConversationId: res.assignedConversationId }
        : {}),
+      ...(res.history ? { history: res.history } : {}),
+      ...(res.historyHasMore !== undefined
+        ? { historyHasMore: res.historyHasMore }
+        : {}),
+      ...(res.historyNextAnchor
+        ? { historyNextAnchor: res.historyNextAnchor }
+        : {}),
+      ...(res.resumed !== undefined ? { resumed: res.resumed } : {}),
      ...(res.transcriptUnavailableReason
        ? { transcriptUnavailableReason: res.transcriptUnavailableReason }
        : {}),
    };
  }

+  async listCustomAgentConversations(
+    projectId: string,
+    agentId: string,
+    limit?: number,
+  ): Promise<CustomAgentConversationSummary[]> {
+    const response = await invoke<{ conversations: CustomAgentConversationSummary[] }>(
+      "list_custom_agent_conversations",
+      { request: { projectId, agentId, ...(limit === undefined ? {} : { limit }) } },
+    );
+    return response.conversations;
+  }
+
  async reattachAgentChat(
    sessionId: string,
    onChunk: (chunk: ReplyChunk) => void,
--- a/frontend/src/adapters/http/frames.ts
+++ b/frontend/src/adapters/http/frames.ts
@ -14,7 +14,7 @@
 * survives JSON.
 */

-import type { ReplyChunk } from "@/domain";
+import type { ReplyChunk, TurnView } from "@/domain";

 // ---------------------------------------------------------------------------
 // Base64 helpers (binary PTY bytes over JSON frames)
@ -156,4 +156,8 @@ export interface ChatAttachedPayload {
  engineSessionId?: string;
  scrollback?: ReplyChunk[];
  transcriptUnavailableReason?: "missingTranscript" | "emptyConversation";
+  history?: TurnView[];
+  historyHasMore?: boolean;
+  historyNextAnchor?: string;
+  resumed?: boolean;
 }
--- a/frontend/src/adapters/http/streamGateways.ts
+++ b/frontend/src/adapters/http/streamGateways.ts
@ -48,6 +48,7 @@ import type {
  ChatDraftScope,
  ChatDraftSnapshot,
  ConversationDetails,
+  CustomAgentConversationSummary,
  CreateAgentInput,
  CreateTicketInput,
  LiveAgent,
@ -389,9 +390,30 @@ export class HttpAgentGateway implements AgentGateway {
      ...(payload.transcriptUnavailableReason
        ? { transcriptUnavailableReason: payload.transcriptUnavailableReason }
        : {}),
+      ...(payload.history ? { history: payload.history } : {}),
+      ...(payload.historyHasMore !== undefined
+        ? { historyHasMore: payload.historyHasMore }
+        : {}),
+      ...(payload.historyNextAnchor
+        ? { historyNextAnchor: payload.historyNextAnchor }
+        : {}),
+      ...(payload.resumed !== undefined ? { resumed: payload.resumed } : {}),
    };
  }

+  async listCustomAgentConversations(
+    projectId: string,
+    agentId: string,
+    limit?: number,
+  ): Promise<CustomAgentConversationSummary[]> {
+    const response = await this.http.invoke<{
+      conversations: CustomAgentConversationSummary[];
+    }>("list_custom_agent_conversations", {
+      request: { projectId, agentId, ...(limit === undefined ? {} : { limit }) },
+    });
+    return response.conversations;
+  }
+
  async reattachAgentChat(
    sessionId: string,
    onChunk: (chunk: ReplyChunk) => void,
--- a/frontend/src/adapters/mock/index.ts
+++ b/frontend/src/adapters/mock/index.ts
@ -118,6 +118,7 @@ import type {
  ConversationGateway,
  ConversationPageRequest,
  ConversationDetails,
+  CustomAgentConversationSummary,
  CloneProfileFromSeedInput,
  CloneOpenCodeProfileFromSeedInput,
  CreateAgentInput,
@ -961,6 +962,14 @@ export class MockAgentGateway implements AgentGateway {
    };
  }

+  async listCustomAgentConversations(
+    _projectId: string,
+    _agentId: string,
+    _limit?: number,
+  ): Promise<CustomAgentConversationSummary[]> {
+    return [];
+  }
+
  async reattachAgentChat(
    sessionId: string,
    _onChunk: (chunk: ReplyChunk) => void,
@ -1057,6 +1066,7 @@ export class MockAgentGateway implements AgentGateway {
          kind: "cleanConversation",
          sessionId: options.sessionId,
          clearedChunks: 0,
+          conversationId: `mock-conversation-${options.sessionId}-${Date.now()}`,
        },
      };
    }
--- a/frontend/src/domain/index.ts
+++ b/frontend/src/domain/index.ts
@ -1922,7 +1922,12 @@ export interface SlashCommand {

 export type SlashCommandEffect =
  | { kind: "help"; commands: SlashCommand[] }
-  | { kind: "cleanConversation"; sessionId: string; clearedChunks: number }
+  | {
+      kind: "cleanConversation";
+      sessionId: string;
+      clearedChunks: number;
+      conversationId?: string;
+    }
  | { kind: "profileSwitch"; sessionId: string }
  | {
      kind: "pluginCallback";
--- a/frontend/src/features/agents/CustomAgentChatView.test.tsx
+++ b/frontend/src/features/agents/CustomAgentChatView.test.tsx
@ -5585,7 +5585,7 @@ describe("CustomAgentChatView", () => {
    expect(shell.className).toContain("h-full");
    expect(shell.className).toContain("min-h-0");
    expect(shell.className).toContain("overflow-hidden");
-    expect(toolbar.className).toContain("overflow-hidden");
+    expect(toolbar.className).not.toContain("overflow-hidden");
    expect(screen.queryByRole("button", { name: "Cancel" })).toBeNull();
    expect(scroll.className).toContain("flex-1");
    expect(scroll.className).toContain("basis-0");
@ -6322,4 +6322,120 @@ describe("CustomAgentChatView", () => {
    );
    expect(agent.launchAgentChat).not.toHaveBeenCalled();
  });
+
+  it("lists and resumes durable custom conversations without recreating technical history", async () => {
+    const history = [
+      { id: "p1", atMs: 10, role: "prompt" as const, source: { kind: "human" as const }, text: "Saved question", textLen: 14 },
+      { id: "tool", atMs: 11, role: "toolActivity" as const, source: { kind: "agent" as const, agentId: "agent-1" }, text: "Hidden tool", textLen: 11 },
+      { id: "r1", atMs: 12, role: "response" as const, source: { kind: "agent" as const, agentId: "agent-1" }, text: "Saved final", textLen: 11 },
+    ];
+    const agent = {
+      launchAgentChat: vi.fn()
+        .mockResolvedValueOnce({ sessionId: "fresh-session", assignedConversationId: "fresh-conversation" })
+        .mockResolvedValueOnce({
+          sessionId: "resumed-session",
+          assignedConversationId: "past-conversation",
+          history,
+          historyHasMore: false,
+          resumed: true,
+        }),
+      reattachAgentChat: vi.fn(async (sessionId: string) => ({ sessionId, scrollback: [] })),
+      listCustomAgentConversations: vi.fn(async () => [{
+        conversationId: "past-conversation",
+        title: "Saved question",
+        createdAtMs: 10,
+        updatedAtMs: 12,
+      }]),
+      sendAgentChat: vi.fn(async (_sid: string, _prompt: string, onChunk: (chunk: ReplyChunk) => void) => {
+        onChunk({ kind: "final", content: "New final" });
+      }),
+      cancelAgentChat: vi.fn(async () => ({ sessionId: "resumed-session", outcome: "cancelled" as const })),
+      closeAgentChat: vi.fn(async () => {}),
+    };
+
+    render(
+      <DIProvider gateways={{
+        agent,
+        conversation: { readPage: vi.fn() },
+        system: { pickFile: vi.fn(async () => null) },
+      } as unknown as Gateways}>
+        <CustomAgentChatView
+          freshOnOpen
+          projectId="project-1"
+          agentId="agent-1"
+          agentName="Worker"
+          profile={profile}
+          cwd="/repo"
+          nodeId="node-1"
+          sessionId={null}
+          conversationId="stale-layout-conversation"
+          onSessionId={vi.fn()}
+          onConversationId={vi.fn()}
+        />
+      </DIProvider>,
+    );
+
+    await waitFor(() => expect(agent.launchAgentChat).toHaveBeenCalledTimes(1));
+    expect(agent.launchAgentChat.mock.calls[0]?.[2].conversationId).toBeUndefined();
+    fireEvent.click(screen.getByRole("button", { name: "Conversations" }));
+    const past = await screen.findByRole("menuitem", { name: /Saved question/ });
+    fireEvent.click(past);
+
+    expect(await screen.findByText("Conversation reprise")).toBeTruthy();
+    expect(screen.getByText("Saved question")).toBeTruthy();
+    expect(screen.getByText("Saved final")).toBeTruthy();
+    expect(screen.queryByText("Hidden tool")).toBeNull();
+    expect(agent.sendAgentChat).not.toHaveBeenCalled();
+
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "Continue" } });
+    fireEvent.click(screen.getByRole("button", { name: "Envoyer" }));
+    expect(await screen.findByText("Conversation poursuivie")).toBeTruthy();
+    expect(await screen.findByText("New final")).toBeTruthy();
+  });
+
+  it("uses /clean for a new conversation and disables conversation changes during a turn", async () => {
+    let finishSend: (() => void) | undefined;
+    const agent = {
+      launchAgentChat: vi.fn(async () => ({ sessionId: "chat-session", assignedConversationId: "conversation-1" })),
+      reattachAgentChat: vi.fn(async (sessionId: string) => ({ sessionId, scrollback: [] })),
+      listCustomAgentConversations: vi.fn(async () => [{
+        conversationId: "past-conversation",
+        title: "Past conversation",
+        createdAtMs: 10,
+        updatedAtMs: 20,
+      }]),
+      sendAgentChat: vi.fn(() => new Promise<void>((resolve) => { finishSend = resolve; })),
+      executeSlashCommand: vi.fn(async () => ({
+        command: { name: "/clean", shortDescription: "Clean", requiresConfirmation: false, availability: { status: "available" as const }, source: "native" as const, native: "clean" as const },
+        effect: { kind: "cleanConversation" as const, sessionId: "clean-session", clearedChunks: 0, conversationId: "conversation-2" },
+      })),
+      cancelAgentChat: vi.fn(async () => ({ sessionId: "chat-session", outcome: "cancelled" as const })),
+      closeAgentChat: vi.fn(async () => {}),
+    };
+    const onConversationId = vi.fn();
+    render(
+      <DIProvider gateways={{ agent, system: { pickFile: vi.fn(async () => null) } } as unknown as Gateways}>
+        <CustomAgentChatView
+          freshOnOpen projectId="project-1" agentId="agent-1" agentName="Worker"
+          profile={profile} cwd="/repo" nodeId="node-1" sessionId={null}
+          conversationId={null} onSessionId={vi.fn()} onConversationId={onConversationId}
+        />
+      </DIProvider>,
+    );
+    await waitFor(() => expect(agent.launchAgentChat).toHaveBeenCalledTimes(1));
+    fireEvent.click(screen.getByRole("button", { name: "Conversations" }));
+    fireEvent.click(screen.getByRole("menuitem", { name: "Nouvelle conversation" }));
+    await waitFor(() => expect(agent.executeSlashCommand).toHaveBeenCalledWith("/clean", {
+      sessionId: "chat-session",
+    }));
+    expect(await screen.findByText("Nouvelle conversation prête.")).toBeTruthy();
+    expect(onConversationId).toHaveBeenCalledWith("conversation-2");
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "Working" } });
+    fireEvent.click(screen.getByRole("button", { name: "Envoyer" }));
+    fireEvent.click(screen.getByRole("button", { name: "Conversations" }));
+    expect(await screen.findByText("Arrêtez la réponse avant de changer de conversation.")).toBeTruthy();
+    expect(screen.getByRole("menuitem", { name: "Nouvelle conversation" }).hasAttribute("disabled")).toBe(true);
+    expect((await screen.findByRole("menuitem", { name: /Past conversation/ })).hasAttribute("disabled")).toBe(true);
+    finishSend?.();
+  });
 });
--- a/frontend/src/features/agents/CustomAgentChatView.tsx
+++ b/frontend/src/features/agents/CustomAgentChatView.tsx
@ -29,6 +29,7 @@ import type {
  ReplyProgressSource,
  ReplyProgressStage,
  SlashCommand,
+  TurnView,
 } from "@/domain";
 import { useGateways } from "@/app/di";
 import { useI18n } from "@/i18n";
@ -56,6 +57,7 @@ import type {
  ChatAttachmentInput,
  ChatDraftScope,
  ConversationTranscriptUnavailableReason,
+  CustomAgentConversationSummary,
  ProjectIconRef,
 } from "@/ports";

@ -69,6 +71,8 @@ export interface CustomAgentChatViewProps {
  nodeId?: string;
  sessionId: string | null;
  conversationId: string | null;
+  /** Start blank when there is no live session; durable threads reopen via the menu. */
+  freshOnOpen?: boolean;
  composerHeightPx?: number;
  composerDefaultHeightPx?: number;
  onComposerHeightPxChange?: (heightPx: number) => void;
@ -87,6 +91,7 @@ type ChatTurn =
  | { role: "final"; text: string; receivedAtMs?: number | null }
  | { role: "error"; text: string; receivedAtMs?: number | null }
  | { role: "restart"; key: string; text: string; message?: string; failed?: boolean; receivedAtMs?: number | null }
+  | { role: "separator"; text: string }
  | { role: "unknown"; text: string; receivedAtMs?: number | null };

 interface CachedChatView {
@ -488,6 +493,25 @@ function emptyChatViewState(): ChatViewState {
  return { turns: [], progressIndex: new Map(), progressScope: 0 };
 }

+function durableHistoryTurns(history: TurnView[]): ChatTurn[] {
+  return history.flatMap((turn): ChatTurn[] => {
+    if (turn.role === "prompt") {
+      return [{ role: "user", text: turn.text, receivedAtMs: turn.atMs }];
+    }
+    if (turn.role === "response") {
+      return [{ role: "final", text: turn.text, receivedAtMs: turn.atMs }];
+    }
+    return [];
+  });
+}
+
+function conversationActivityLabel(atMs: number): string {
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: "short",
+    timeStyle: "short",
+  }).format(new Date(atMs));
+}
+
 function conversationCacheKey(
  projectId: string,
  agentId: string,
@ -999,6 +1023,7 @@ export function CustomAgentChatView({
  nodeId,
  sessionId,
  conversationId,
+  freshOnOpen = false,
  composerHeightPx = FALLBACK_COMPOSER_HEIGHT,
  composerDefaultHeightPx = FALLBACK_COMPOSER_HEIGHT,
  onComposerHeightPxChange,
@ -1008,13 +1033,13 @@ export function CustomAgentChatView({
  onSessionId,
  onConversationId,
 }: CustomAgentChatViewProps) {
-  const { agent, profile: profileGateway, project, system, workState } = useGateways();
+  const { agent, conversation, profile: profileGateway, project, system, workState } = useGateways();
  const { t, tr } = useI18n();
  const pluginRuntime = usePluginRuntime();
  const initialConversationCacheKey = conversationCacheKey(
    projectId,
    agentId,
-    conversationId,
+    sessionId || !freshOnOpen ? conversationId : null,
  );
  const [turns, setTurns] = useState<ChatTurn[]>(
    () =>
@ -1044,6 +1069,14 @@ export function CustomAgentChatView({
    () => new Set(),
  );
  const [currentSession, setCurrentSession] = useState(sessionId);
+  // A newly opened custom CLI intentionally starts blank. A conversation id
+  // persisted on the layout is only reused when it still has a live session;
+  // durable threads are reopened explicitly from the Conversations menu.
+  const [activeConversationId, setActiveConversationId] = useState<string | null>(
+    sessionId || !freshOnOpen ? conversationId : null,
+  );
+  const activeConversationIdRef = useRef(activeConversationId);
+  activeConversationIdRef.current = activeConversationId;
  const [externalSessionId, setExternalSessionId] = useState(sessionId);
  const initialDraftScope = explicitDraftScope ?? (
    layoutId && nodeId ? { projectId, layoutId, nodeId } : null
@ -1077,7 +1110,9 @@ export function CustomAgentChatView({
  const [slashActiveIndex, setSlashActiveIndex] = useState(0);
  const [profileDialog, setProfileDialog] =
    useState<ProfileCommandDialogState | null>(null);
-  const [opening, setOpening] = useState(Boolean(sessionId || conversationId));
+  const [opening, setOpening] = useState(
+    Boolean(sessionId || (!freshOnOpen && conversationId)),
+  );
  const [openRetryNonce, setOpenRetryNonce] = useState(0);
  const [transcriptUnavailableReason, setTranscriptUnavailableReason] = useState<
    ConversationTranscriptUnavailableReason | "conversationNotFound" | null
@ -1088,6 +1123,16 @@ export function CustomAgentChatView({
  const [stopTerminalOverride, setStopTerminalOverride] = useState(false);
  const [error, setError] = useState<ChatErrorState | null>(null);
  const [projectIcon, setProjectIcon] = useState<ProjectIconRef | null>(null);
+  const [conversationMenuOpen, setConversationMenuOpen] = useState(false);
+  const [conversationList, setConversationList] = useState<CustomAgentConversationSummary[]>([]);
+  const [conversationListLoading, setConversationListLoading] = useState(false);
+  const [conversationListError, setConversationListError] = useState<string | null>(null);
+  const [conversationNotice, setConversationNotice] = useState<string | null>(null);
+  const [resumedConversation, setResumedConversation] = useState(false);
+  const [historyHasMore, setHistoryHasMore] = useState(false);
+  const [historyNextAnchor, setHistoryNextAnchor] = useState<string | undefined>();
+  const [historyLoading, setHistoryLoading] = useState(false);
+  const [historyError, setHistoryError] = useState<string | null>(null);
  const composerRef = useRef<HTMLTextAreaElement | null>(null);
  const chatRootRef = useRef<HTMLDivElement | null>(null);
  const turnsRef = useRef(turns);
@ -1253,8 +1298,8 @@ export function CustomAgentChatView({
    [agentId, layoutId, nodeId, projectId],
  );
  const currentConversationCacheKey = useMemo(
-    () => conversationCacheKey(projectId, agentId, conversationId),
-    [agentId, conversationId, projectId],
+    () => conversationCacheKey(projectId, agentId, activeConversationId),
+    [activeConversationId, agentId, projectId],
  );
  const composerHistoryKey = useMemo(
    () => composerHistoryStorageKey(projectId, agentId, layoutId, nodeId),
@ -1817,6 +1862,12 @@ export function CustomAgentChatView({
    onSessionIdRef.current(nextSessionId);
  }, []);

+  const publishConversationId = useCallback((nextConversationId: string | null) => {
+    activeConversationIdRef.current = nextConversationId;
+    setActiveConversationId(nextConversationId);
+    onConversationIdRef.current(nextConversationId);
+  }, []);
+
  const reattachStructuredSession = useCallback(
    async (
      sid: string,
@ -1857,7 +1908,7 @@ export function CustomAgentChatView({
        publishSessionId(reattached.sessionId);
      }
      if (reattached.conversationId) {
-        onConversationIdRef.current(reattached.conversationId);
+        publishConversationId(reattached.conversationId);
      }
      if (options.applyScrollback) {
        scrollbackChunkCountRef.current = reattached.scrollback.length;
@ -1881,7 +1932,7 @@ export function CustomAgentChatView({
      }
      return reattached.sessionId;
    },
-    [agent, agentId, applyChatViewState, projectId, publishSessionId, receive],
+    [agent, agentId, applyChatViewState, projectId, publishConversationId, publishSessionId, receive],
  );

  useEffect(() => {
@ -1926,7 +1977,7 @@ export function CustomAgentChatView({
      console.debug("[ticket149] recoverStructuredSession:start", {
        timestamp: new Date().toISOString(),
        currentSession: sessionRef.current,
-        conversationId,
+        conversationId: activeConversationIdRef.current,
        options,
      });
      let retryAttachNotFound = Boolean(options.retryAttachNotFound);
@ -1937,7 +1988,7 @@ export function CustomAgentChatView({
          cols: 80,
          conversationId:
            options.conversationId === undefined
-              ? conversationId ?? undefined
+              ? activeConversationIdRef.current ?? undefined
              : options.conversationId ?? undefined,
          ...(nodeId ? { nodeId } : {}),
        };
@ -1973,14 +2024,26 @@ export function CustomAgentChatView({
        setCurrentSession(launched.sessionId);
        publishSessionId(launched.sessionId);
        if (launched.assignedConversationId) {
-          onConversationIdRef.current(launched.assignedConversationId);
+          publishConversationId(launched.assignedConversationId);
+        }
+        if (launched.resumed) {
+          const replayed = {
+            ...emptyChatViewState(),
+            turns: durableHistoryTurns(launched.history ?? []),
+          };
+          applyChatViewState(replayed);
+          setResumedConversation(true);
+          setConversationNotice(null);
+          setHistoryHasMore(Boolean(launched.historyHasMore));
+          setHistoryNextAnchor(launched.historyNextAnchor);
+          setHistoryError(null);
        }
        if (launched.transcriptUnavailableReason) {
          setTranscriptUnavailableReason(launched.transcriptUnavailableReason);
        }
        try {
          const recoveredSessionId = await reattachStructuredSession(launched.sessionId, {
-            applyScrollback: options.applyScrollback,
+            applyScrollback: launched.resumed ? false : options.applyScrollback,
          });
          console.debug("[ticket149] recoverStructuredSession:success", {
            timestamp: new Date().toISOString(),
@ -2012,8 +2075,9 @@ export function CustomAgentChatView({
      agentId,
      cwd,
      nodeId,
-      conversationId,
      reattachStructuredSession,
+      applyChatViewState,
+      publishConversationId,
      publishSessionId,
    ],
  );
@ -2139,8 +2203,13 @@ export function CustomAgentChatView({
              error: instrumentationError(e),
            });
          }
-        } else if (currentConversationCacheKey) {
-          const cached = chatConversationViewCache.get(currentConversationCacheKey);
+        } else {
+          const cacheKey = conversationCacheKey(
+            projectId,
+            agentId,
+            activeConversationIdRef.current,
+          );
+          const cached = cacheKey ? chatConversationViewCache.get(cacheKey) : undefined;
          if (cached) {
            scrollbackChunkCountRef.current = cached.chunkCount;
            applyChatViewState({
@ -2165,7 +2234,7 @@ export function CustomAgentChatView({
          }
        }
        await recoverStructuredSession({
-          applyScrollback: Boolean(conversationId),
+          applyScrollback: Boolean(activeConversationIdRef.current),
          retryAttachNotFound: true,
        });
        if (cancelled) return;
@ -2181,7 +2250,7 @@ export function CustomAgentChatView({
          sessionId: externalSessionId,
          error: instrumentationError(e),
        });
-        if (!cancelled && conversationId && isNotFound(e)) {
+        if (!cancelled && activeConversationIdRef.current && isNotFound(e)) {
          setTranscriptUnavailableReason("conversationNotFound");
          setCurrentSession(null);
          publishSessionId(null);
@ -2204,8 +2273,6 @@ export function CustomAgentChatView({
    recoverStructuredSession,
    publishSessionId,
    applyChatViewState,
-    currentConversationCacheKey,
-    conversationId,
    openRetryNonce,
  ]);

@ -2242,6 +2309,85 @@ export function CustomAgentChatView({
    setOpenRetryNonce((value) => value + 1);
  }

+  const refreshConversationList = useCallback(async () => {
+    if (!agent.listCustomAgentConversations) {
+      setConversationListError(
+        tr("Liste des conversations indisponible.", "Conversation list unavailable."),
+      );
+      return;
+    }
+    setConversationListLoading(true);
+    setConversationListError(null);
+    try {
+      setConversationList(
+        await agent.listCustomAgentConversations(projectId, agentId, 50),
+      );
+    } catch (e) {
+      setConversationListError(describe(e));
+    } finally {
+      setConversationListLoading(false);
+    }
+  }, [agent, agentId, projectId, tr]);
+
+  useEffect(() => {
+    if (conversationMenuOpen) void refreshConversationList();
+  }, [conversationMenuOpen, refreshConversationList]);
+
+  async function reopenConversation(nextConversationId: string) {
+    if (effectiveBusy || opening || nextConversationId === activeConversationId) return;
+    setConversationMenuOpen(false);
+    setOpening(true);
+    setError(null);
+    try {
+      const sid = sessionRef.current;
+      if (sid) await agent.closeAgentChat?.(sid);
+      setCurrentSession(null);
+      setExternalSessionId(null);
+      publishSessionId(null);
+      publishConversationId(nextConversationId);
+      applyChatViewState(emptyChatViewState());
+      setResumedConversation(false);
+      setConversationNotice(null);
+      setHistoryHasMore(false);
+      setHistoryNextAnchor(undefined);
+      setOpenRetryNonce((value) => value + 1);
+    } catch (e) {
+      setError({ message: describe(e), openFailure: false });
+    } finally {
+      setOpening(false);
+    }
+  }
+
+  async function startNewConversation() {
+    if (effectiveBusy || opening) return;
+    setConversationMenuOpen(false);
+    await executeSlashCommand({ name: "/clean", arguments: [] });
+  }
+
+  async function loadOlderHistory() {
+    if (!activeConversationId || !historyNextAnchor || historyLoading) return;
+    setHistoryLoading(true);
+    setHistoryError(null);
+    try {
+      const page = await conversation.readPage(projectId, activeConversationId, {
+        anchor: historyNextAnchor,
+        direction: "backward",
+        limit: 50,
+      });
+      const older = durableHistoryTurns(page.turns);
+      updateChatViewState((previous) => ({
+        ...previous,
+        turns: [...older, ...previous.turns],
+      }));
+      setHistoryHasMore(page.hasMore);
+      setHistoryNextAnchor(page.nextAnchor);
+    } catch (e) {
+      setHistoryError(describe(e));
+    } finally {
+      setHistoryLoading(false);
+    }
+  }
+
  async function openProfileDialog() {
    const availableProfiles = (await profileGateway.listProfiles()).filter((candidate) =>
      Boolean(candidate.structuredAdapter),
@ -2363,6 +2509,17 @@ export function CustomAgentChatView({
      }
      if (result.effect.kind === "cleanConversation") {
        applyChatViewState(emptyChatViewState());
+        setCurrentSession(result.effect.sessionId);
+        setExternalSessionId(result.effect.sessionId);
+        publishSessionId(result.effect.sessionId);
+        publishConversationId(result.effect.conversationId ?? null);
+        setResumedConversation(false);
+        setHistoryHasMore(false);
+        setHistoryNextAnchor(undefined);
+        setHistoryError(null);
+        setConversationNotice(
+          tr("Nouvelle conversation prête.", "New conversation ready."),
+        );
        return;
      }
      if (result.effect.kind === "profileSwitch") {
@ -2549,10 +2706,18 @@ export function CustomAgentChatView({
    threadScroll.followLatest();
    setBusy(true);
    setError(null);
+    const continuingResumedConversation = resumedConversation;
+    if (continuingResumedConversation) {
+      setResumedConversation(false);
+      setConversationNotice(null);
+    }
    updateChatViewState((prev) => ({
      ...prev,
      turns: [
        ...prev.turns,
+        ...(continuingResumedConversation
+          ? [{ role: "separator" as const, text: tr("Conversation poursuivie", "Conversation continued") }]
+          : []),
        {
          role: "user",
          text: displayText,
@ -2801,7 +2966,7 @@ export function CustomAgentChatView({
      <div
        role="toolbar"
        aria-label={t("custom.actions")}
-        className="relative z-20 flex shrink-0 items-center gap-2 overflow-hidden border-b border-border px-3 py-2"
+        className="relative z-20 flex shrink-0 items-center gap-2 border-b border-border px-3 py-2"
      >
        <div className="min-w-0 flex-1 overflow-hidden">
          <div className="truncate text-sm font-medium">{agentName}</div>
@ -2809,6 +2974,92 @@ export function CustomAgentChatView({
            {tr("CLI personnalisée", "Custom CLI")} · {profile.name}
          </div>
        </div>
+        <div className="relative shrink-0">
+          <Button
+            size="sm"
+            variant="ghost"
+            aria-expanded={conversationMenuOpen}
+            aria-haspopup="menu"
+            onClick={() => setConversationMenuOpen((open) => !open)}
+          >
+            {tr("Conversations", "Conversations")}
+          </Button>
+          {conversationMenuOpen && (
+            <div
+              role="menu"
+              aria-label={tr("Conversations", "Conversations")}
+              className="absolute right-0 top-full z-50 mt-1 w-[min(22rem,calc(100vw-1rem))] overflow-hidden rounded-md border border-border bg-raised shadow-xl"
+            >
+              {effectiveBusy && (
+                <p className="border-b border-border bg-warning/10 px-3 py-2 text-xs text-warning">
+                  {tr(
+                    "Arrêtez la réponse avant de changer de conversation.",
+                    "Stop the response before changing conversations.",
+                  )}
+                </p>
+              )}
+              <button
+                type="button"
+                role="menuitem"
+                disabled={effectiveBusy || opening}
+                className="flex min-h-11 w-full items-center px-3 text-left text-sm font-semibold text-content hover:bg-surface disabled:cursor-not-allowed disabled:opacity-50"
+                onClick={() => void startNewConversation()}
+              >
+                {tr("Nouvelle conversation", "New conversation")}
+              </button>
+              <div className="border-t border-border" />
+              <div className="max-h-72 overflow-y-auto py-1">
+                {conversationListLoading ? (
+                  <div className="flex items-center gap-2 px-3 py-3 text-xs text-muted" role="status">
+                    <Spinner size={14} />
+                    {tr("Chargement des conversations…", "Loading conversations…")}
+                  </div>
+                ) : conversationListError ? (
+                  <div className="flex flex-col gap-2 px-3 py-3 text-xs text-danger" role="alert">
+                    <span>{tr("Impossible de charger les conversations.", "Unable to load conversations.")}</span>
+                    <button
+                      type="button"
+                      className="self-start font-semibold text-content"
+                      onClick={() => void refreshConversationList()}
+                    >
+                      {t("common.retry")}
+                    </button>
+                  </div>
+                ) : conversationList.length === 0 ? (
+                  <p className="px-3 py-3 text-xs text-muted">
+                    {tr("Aucune conversation passée.", "No past conversations.")}
+                  </p>
+                ) : (
+                  conversationList.map((item) => {
+                    const isOpen = item.conversationId === activeConversationId;
+                    return (
+                      <button
+                        key={item.conversationId}
+                        type="button"
+                        role="menuitem"
+                        disabled={effectiveBusy || opening || isOpen}
+                        className="flex min-h-11 w-full min-w-0 items-center gap-2 px-3 py-2 text-left hover:bg-surface disabled:cursor-not-allowed disabled:opacity-60"
+                        onClick={() => void reopenConversation(item.conversationId)}
+                      >
+                        <span className="min-w-0 flex-1">
+                          <span className="block truncate text-sm text-content">{item.title}</span>
+                          <span className="block text-[11px] text-muted">
+                            {conversationActivityLabel(item.updatedAtMs)}
+                          </span>
+                        </span>
+                        {isOpen && (
+                          <span className="shrink-0 rounded-full bg-primary/15 px-2 py-0.5 text-[10px] font-semibold text-primary">
+                            {tr("Ouverte", "Open")}
+                          </span>
+                        )}
+                      </button>
+                    );
+                  })
+                )}
+              </div>
+            </div>
+          )}
+        </div>
      </div>
      {hasPreviousFinal && (
        <button
@ -2994,6 +3245,39 @@ export function CustomAgentChatView({
              fallbackText={delegationFallbackText}
            />
          </div>
+          {conversationNotice && (
+            <p role="status" className="shrink-0 rounded-md bg-success/10 px-3 py-2 text-xs text-success">
+              {conversationNotice}
+            </p>
+          )}
+          {resumedConversation && (
+            <div className="shrink-0 rounded-md border border-border bg-raised/75 px-3 py-2 text-xs text-muted">
+              <strong className="block text-content">
+                {tr("Conversation reprise", "Conversation resumed")}
+              </strong>
+              <span>
+                {tr(
+                  "Historique sauvegardé de cet agent. Vous pouvez poursuivre ci-dessous.",
+                  "Saved history for this agent. You can continue below.",
+                )}
+              </span>
+            </div>
+          )}
+          {resumedConversation && historyHasMore && (
+            <button
+              type="button"
+              className="self-center rounded-md px-3 py-1 text-xs font-semibold text-primary hover:bg-raised disabled:opacity-50"
+              disabled={historyLoading}
+              onClick={() => void loadOlderHistory()}
+            >
+              {historyLoading
+                ? tr("Chargement…", "Loading…")
+                : tr("Charger les messages précédents", "Load earlier messages")}
+            </button>
+          )}
+          {historyError && (
+            <p role="alert" className="text-center text-xs text-danger">{historyError}</p>
+          )}
          {opening && displayTurns.length === 0 ? (
            <div className="flex items-center gap-2 text-sm text-muted">
              <Spinner size={14} />
@ -3026,9 +3310,20 @@ export function CustomAgentChatView({
              </div>
            </div>
          ) : displayTurns.length === 0 ? (
-            <p className="project-cell-empty-label text-xs text-muted">
-              {t("custom.empty")}
-            </p>
+            <div className="project-cell-empty-label m-auto max-w-sm text-center text-xs text-muted">
+              <strong className="block text-sm text-content">
+                {tr("Nouvelle conversation", "New conversation")}
+              </strong>
+              <span>
+                {t("custom.empty")}
+              </span>{" "}
+              <span>
+                {tr(
+                  "Vous pouvez aussi ouvrir une conversation passée depuis le menu Conversations.",
+                  "You can also open a past conversation from the Conversations menu.",
+                )}
+              </span>
+            </div>
          ) : (
            displayTurns.map((turn, index) => (
              <ChatBubble
@ -3368,6 +3663,15 @@ function ChatBubble({
  onToggleProgressExpanded: (key: string) => void;
 }) {
  const { tr } = useI18n();
+  if (turn.role === "separator") {
+    return (
+      <div className="flex items-center gap-2 py-1 text-[11px] text-muted" role="separator">
+        <span className="h-px flex-1 bg-border" />
+        <span>{turn.text}</span>
+        <span className="h-px flex-1 bg-border" />
+      </div>
+    );
+  }
  if (turn.role === "restart") {
    return (
      <div
--- a/frontend/src/features/layout/LayoutGrid.chat.test.tsx
+++ b/frontend/src/features/layout/LayoutGrid.chat.test.tsx
@ -481,7 +481,7 @@ describe("LayoutGrid custom agent CLI (#147)", () => {
    expect(screen.queryByText(/déjà actif dans une autre cellule/)).toBeNull();
  });

-  it("restores a custom CLI transcript when returning with a conversation id but no session (#217)", async () => {
+  it("starts a fresh custom CLI conversation when returning without a live session (#363)", async () => {
    const layout = new MockLayoutGateway();
    const agent = new MockAgentGateway();
    const profileGateway = new MockProfileGateway();
@ -506,15 +506,13 @@ describe("LayoutGrid custom agent CLI (#147)", () => {
    });
    window.localStorage.setItem(`idea.agent-cell-mode.p1.${leafId}`, "custom");
    const launchChat = vi.spyOn(agent, "launchAgentChat").mockResolvedValue({
-      sessionId: "chat-resumed",
+      sessionId: "chat-fresh",
      cellKind: "chat" as const,
+      assignedConversationId: "conversation-fresh",
    });
    const reattachChat = vi.spyOn(agent, "reattachAgentChat").mockResolvedValue({
-      sessionId: "chat-resumed",
-      scrollback: [
-        { kind: "userPrompt", text: "known prompt" },
-        { kind: "final", content: "known answer" },
-      ],
+      sessionId: "chat-fresh",
+      scrollback: [],
    });

    renderGrid({
@ -525,25 +523,25 @@ describe("LayoutGrid custom agent CLI (#147)", () => {
      system,
    } as unknown as Gateways);

-    expect(await screen.findByText("known answer")).toBeTruthy();
-    expect(screen.getByText("known prompt")).toBeTruthy();
+    expect(await screen.findByText("Nouvelle conversation")).toBeTruthy();
+    expect(screen.queryByText("known prompt")).toBeNull();
    expect(launchChat).toHaveBeenCalledWith(
      "p1",
      created.id,
      expect.objectContaining({
        nodeId: leafId,
-        conversationId: "conversation-known",
+        conversationId: undefined,
      }),
    );
-    expect(reattachChat).toHaveBeenCalledWith("chat-resumed", expect.any(Function));
+    expect(reattachChat).toHaveBeenCalledWith("chat-fresh", expect.any(Function));
    await waitFor(async () => {
      const updated = await layout.loadLayout("p1");
      const leaf = leaves(updated)[0];
-      expect(leaf.conversationId).toBe("conversation-known");
-      expect(leaf.session).toBe("chat-resumed");
+      expect(leaf.conversationId).toBe("conversation-fresh");
+      expect(leaf.session).toBe("chat-fresh");
    });
-    expect(screen.queryByText("Envoyez un message pour démarrer la conversation structurée."))
-      .toBeNull();
+    expect(screen.getByText("Envoyez un message pour démarrer la conversation structurée."))
+      .toBeTruthy();
  });

  it("relaunches a stopped custom CLI agent from scratch (#197)", async () => {
--- a/frontend/src/features/layout/LayoutGrid.tsx
+++ b/frontend/src/features/layout/LayoutGrid.tsx
@ -1695,6 +1695,7 @@ function LeafView({
        ) : agentId && cellMode === "custom" && effectiveCustomCliAvailable && customCliAgent && customCliProfile ? (
          <CustomAgentChatView
            key={`${id}-${agentId}-custom`}
+            freshOnOpen
            projectId={projectId}
            agentId={agentId}
            agentName={customCliAgent.name}
--- a/frontend/src/features/web/WebAgentCell.tsx
+++ b/frontend/src/features/web/WebAgentCell.tsx
@ -200,6 +200,7 @@ export function WebAgentCell({
      )}
      {mode === "custom" && showModeSwitch && resolvedAgent && resolvedProfile ? (
        <CustomAgentChatView
+          freshOnOpen
          projectId={projectId}
          agentId={agentId}
          agentName={resolvedAgent.name}
--- a/frontend/src/ports/index.ts
+++ b/frontend/src/ports/index.ts
@ -107,6 +107,7 @@ import type {
  TicketPriority,
  TicketStatus,
  TurnPage,
+  TurnView,
  Unsubscribe,
 } from "@/domain";

@ -207,10 +208,23 @@ export interface AgentChatHandle {
  readonly cellKind: "chat";
  /** Conversation id assigned by launch when the backend minted one. */
  readonly assignedConversationId?: string;
+  /** Durable Prompt/Final history returned only for an explicit reopen. */
+  readonly history?: TurnView[];
+  readonly historyHasMore?: boolean;
+  readonly historyNextAnchor?: string;
+  readonly resumed?: boolean;
  /** Why a successful structured open has no replayable transcript. */
  readonly transcriptUnavailableReason?: ConversationTranscriptUnavailableReason;
 }

+/** One non-empty durable custom-CLI conversation in the agent menu. */
+export interface CustomAgentConversationSummary {
+  conversationId: string;
+  title: string;
+  createdAtMs: number;
+  updatedAtMs: number;
+}
+
 export type ConversationTranscriptUnavailableReason =
  | "missingTranscript"
  | "emptyConversation";
@ -364,6 +378,12 @@ export interface AgentGateway {
    agentId: string,
    options: OpenTerminalOptions,
  ): Promise<AgentChatHandle>;
+  /** Lists the latest durable custom-CLI conversations for one agent. */
+  listCustomAgentConversations?(
+    projectId: string,
+    agentId: string,
+    limit?: number,
+  ): Promise<CustomAgentConversationSummary[]>;
  /**
   * Re-attaches a custom chat view to a still-live structured session, replaying
   * retained reply chunks before subsequent live chunks arrive.