diff --git a/app/src-tauri/src/commands/chat.rs b/app/src-tauri/src/commands/chat.rs
new file mode 100644
index 0000000..4f4124e
--- /dev/null
+++ b/app/src-tauri/src/commands/chat.rs
@@ -0,0 +1,434 @@
+//! Reviewer-chat commands — the multi-turn "Ask the reviewer" panel.
+//!
+//! Design: `cockpit-docs/REVIEWER_CHAT.md`. Each turn is a stateless one-shot
+//! spawn in the review's worktree, provably read-only (`--disallowedTools`),
+//! never attached to `Review::agent` (no fleet row, no `max_parallel_agents`
+//! pressure, no Stop-hook session), streamed to the frontend over dedicated
+//! `chat-stream` / `chat-complete` events so it can never collide with the
+//! AgentPanel timeline.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use tauri::{Emitter, State};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
+use cockpit_core::adapters::agent::{self, SpawnConfig};
+use cockpit_core::adapters::agent_stream;
+use cockpit_core::chat::parse_chat_reply;
+use cockpit_core::config::Config;
+use cockpit_core::model::{ChatMessage, ChatMessageId, ChatRole, PrRef, Review};
+use cockpit_core::prompt::{ChatInput, assemble_chat_prompt};
+
+use crate::error::CommandError;
+use crate::state::AppState;
+
+/// Hard wall-clock budget for one chat turn; a hung turn is killed and
+/// surfaces as an error message so the PR's chat is never blocked forever.
+const CHAT_TURN_TIMEOUT: Duration = Duration::from_secs(300);
+
+/// Tools denied to every chat turn. Deny rules outrank allows in the Claude
+/// CLI, so the reviewer chat is *provably* read-only — and therefore can never
+/// raise a permission prompt.
+const CHAT_DENIED_TOOLS: &[&str] = &["Write", "Edit", "MultiEdit", "NotebookEdit", "Bash", "Task"];
+
+/// A `chat-stream` event: one text delta of the in-flight answer.
+#[derive(Debug, Clone, serde::Serialize)]
+struct ChatStreamPayload {
+    /// PR ref the turn belongs to.
+    pr: String,
+    /// Id the finished agent message will carry.
+    message_id: String,
+    /// Appended answer text.
+    delta: String,
+}
+
+/// A `chat-complete` event: the turn finished (the message is in the review).
+#[derive(Debug, Clone, serde::Serialize)]
+struct ChatCompletePayload {
+    /// PR ref the turn belonged to.
+    pr: String,
+    /// Id of the appended agent message.
+    message_id: String,
+    /// False when the turn failed (spawn error, timeout, or empty output).
+    ok: bool,
+}
+
+/// Lock the chat-turn registry, recovering from a poisoned lock.
+///
+/// INVARIANT: the lock guards only trivial `HashMap` operations (no `.await`,
+/// no I/O), so poisoning is practically impossible — but the driver task MUST
+/// always be able to release a claim, or a PR's chat wedges until restart.
+/// Recovering with the inner value instead of panicking guarantees that.
+fn lock_turns(state: &AppState) -> std::sync::MutexGuard<'_, HashMap<String, u32>> {
+    state
+        .chat_turns
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+}
+
+/// Wall-clock now in epoch milliseconds (0 on a pre-epoch clock).
+fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| u64::try_from(d.as_millis()).unwrap_or(u64::MAX))
+        .unwrap_or(0)
+}
+
+/// Send one reviewer-chat message and start the agent turn answering it.
+///
+/// Appends the user message to the review's thread immediately (the returned
+/// `Review` carries it), then drives the turn on a background task: stream
+/// deltas via `chat-stream`, and on completion parse the reply (inline drafts
+/// block extracted by [`parse_chat_reply`]), append the agent message, and
+/// emit `chat-complete`. One turn per PR at a time.
+///
+/// Fail-open (Invariant §0.1): every failure path appends an `error: true`
+/// agent message rather than wedging the thread.
+#[tauri::command]
+pub async fn send_chat_message(
+    state: State<'_, Arc<AppState>>,
+    app_handle: tauri::AppHandle,
+    pr: String,
+    text: String,
+) -> Result<Review, CommandError> {
+    let question = text.trim().to_owned();
+    if question.is_empty() {
+        return Err(CommandError {
+            message: "Cannot send an empty message".into(),
+        });
+    }
+    let pr_ref = PrRef::new(&pr);
+    let review = state.reviews.get(&pr_ref).ok_or_else(|| CommandError {
+        message: format!("Review not found: {pr}"),
+    })?;
+
+    // One in-flight turn per PR. Registered with a placeholder pid (0) BEFORE
+    // any await so two rapid sends cannot both pass the check; the real pid
+    // replaces it right after spawn.
+    {
+        let mut turns = lock_turns(&state);
+        if turns.contains_key(&pr) {
+            return Err(CommandError {
+                message: "A chat turn is already running for this review".into(),
+            });
+        }
+        turns.insert(pr.clone(), 0);
+    }
+
+    // Everything below must unregister on failure — a small guard tidies the
+    // early-return paths.
+    let result = start_chat_turn(&state, &app_handle, &pr, &pr_ref, &review, question).await;
+    if result.is_err() {
+        lock_turns(&state).remove(&pr);
+    }
+    result
+}
+
+/// The body of [`send_chat_message`] after the turn slot is claimed.
+///
+/// Fail-open (Invariant §0.1): the user's question is appended to the thread
+/// FIRST, and any subsequent failure (config, worktree, spawn) settles the
+/// turn in place — an `error: true` agent reply in the thread, the claim
+/// released, and `chat-complete` emitted so the frontend's pending state
+/// clears — while still returning `Ok` with the updated review.
+async fn start_chat_turn(
+    state: &State<'_, Arc<AppState>>,
+    app_handle: &tauri::AppHandle,
+    pr: &str,
+    pr_ref: &PrRef,
+    review: &Review,
+    question: String,
+) -> Result<Review, CommandError> {
+    // The transcript replayed to the agent is the thread BEFORE this question
+    // (the question is its own prompt section).
+    let transcript = review.chat.clone();
+
+    let user_message = ChatMessage {
+        id: ChatMessageId::new(format!("cm-{}", uuid::Uuid::new_v4())),
+        role: ChatRole::User,
+        text: question.clone(),
+        drafts: Vec::new(),
+        error: false,
+        created_at_epoch_ms: now_ms(),
+    };
+    state.reviews.update(pr_ref, |r| {
+        r.chat.push(user_message);
+    });
+
+    let message_id = format!("cm-{}", uuid::Uuid::new_v4());
+
+    match prepare_and_spawn(state, pr_ref, review, &transcript, &question).await {
+        Ok(turn) => {
+            lock_turns(state).insert(pr.to_owned(), turn.pid);
+
+            // Drive the turn to completion in the background; the command
+            // returns the review with the user message appended so the UI
+            // updates instantly.
+            let task_state = Arc::clone(state.inner());
+            let task_handle = app_handle.clone();
+            let task_pr = pr.to_owned();
+            let task_pr_ref = pr_ref.clone();
+            tauri::async_runtime::spawn(async move {
+                drive_chat_turn(
+                    task_state,
+                    task_handle,
+                    task_pr,
+                    task_pr_ref,
+                    message_id,
+                    turn,
+                )
+                .await;
+            });
+        }
+        Err(reason) => {
+            // Settle the failed turn in the thread rather than erroring the
+            // command: the question stays, the failure is visible where the
+            // user asked it, and `chat-complete` releases the pending state.
+            append_agent_message(
+                state,
+                pr_ref,
+                &message_id,
+                format!("The reviewer agent could not start: {reason}"),
+                true,
+            );
+            lock_turns(state).remove(pr);
+            let _ = app_handle.emit(
+                "chat-complete",
+                ChatCompletePayload {
+                    pr: pr.to_owned(),
+                    message_id,
+                    ok: false,
+                },
+            );
+        }
+    }
+
+    state.reviews.get(pr_ref).ok_or_else(|| CommandError {
+        message: format!("Review not found: {pr}"),
+    })
+}
+
+/// Assemble the prompt and spawn the turn's process. Every failure returns a
+/// human-readable reason for the in-thread error reply.
+async fn prepare_and_spawn(
+    state: &State<'_, Arc<AppState>>,
+    pr_ref: &PrRef,
+    review: &Review,
+    transcript: &[ChatMessage],
+    question: &str,
+) -> Result<agent::ChatTurn, String> {
+    let config = Config::load().map_err(|e| format!("config: {e}"))?;
+
+    // Recap markdown, when one exists on disk (best-effort context).
+    let recap_mdx: Option<String> = match cockpit_core::config::recap_dir_for_pr(pr_ref) {
+        Ok(dir) => {
+            let sha = review.recap_sha.clone();
+            tokio::task::spawn_blocking(move || cockpit_core::recap::read_recap(&dir, sha).mdx)
+                .await
+                .unwrap_or(None)
+        }
+        Err(_) => None,
+    };
+
+    let prompt = assemble_chat_prompt(&ChatInput {
+        title: &review.title,
+        body: &review.body,
+        issue: review.issue.as_str(),
+        diff: &review.diff,
+        intent: review.distilled_intent.as_deref(),
+        findings: &review.review_findings,
+        recap_mdx: recap_mdx.as_deref(),
+        comments: &review.comments,
+        conversation: &review.conversation,
+        transcript,
+        question,
+    });
+
+    // Materialize the worktree (same path pre-review uses) so the agent can
+    // read the actual repository, not just the diff.
+    let worktree = super::ensure_worktree_for_review(state, pr_ref)
+        .await
+        .map_err(|e| format!("worktree: {}", e.message))?;
+
+    let mut spawn_config = SpawnConfig::from_config(&config).disallow_tools(CHAT_DENIED_TOOLS);
+    if let Some(model) = config
+        .review_model
+        .as_deref()
+        .filter(|m| !m.trim().is_empty())
+    {
+        spawn_config = spawn_config.with_model(model);
+    }
+
+    agent::spawn_chat_turn(&worktree, &prompt, &spawn_config)
+        .await
+        .map_err(|e| format!("spawn: {e}"))
+}
+
+/// Append an agent message to a review's thread (used by every finish path).
+fn append_agent_message(
+    state: &AppState,
+    pr_ref: &PrRef,
+    message_id: &str,
+    text: String,
+    error: bool,
+) {
+    let reply = if error {
+        cockpit_core::chat::ChatReply {
+            text,
+            drafts: Vec::new(),
+        }
+    } else {
+        parse_chat_reply(&text)
+    };
+    let message = ChatMessage {
+        id: ChatMessageId::new(message_id),
+        role: ChatRole::Agent,
+        text: reply.text,
+        drafts: reply.drafts,
+        error,
+        created_at_epoch_ms: now_ms(),
+    };
+    state.reviews.update(pr_ref, |r| {
+        r.chat.push(message);
+    });
+}
+
+/// Read the turn's stdout to completion, streaming text deltas, then append
+/// the final agent message and emit `chat-complete`.
+async fn drive_chat_turn(
+    state: Arc<AppState>,
+    app_handle: tauri::AppHandle,
+    pr: String,
+    pr_ref: PrRef,
+    message_id: String,
+    mut turn: agent::ChatTurn,
+) {
+    let stdout = turn.child.stdout.take();
+    let outcome = match stdout {
+        Some(stdout) => {
+            let read = read_turn_output(&app_handle, &pr, &message_id, stdout, &turn.log_path);
+            match tokio::time::timeout(CHAT_TURN_TIMEOUT, read).await {
+                Ok(text) => TurnOutcome::Finished(text),
+                Err(_) => {
+                    // Hung turn: kill it so the child doesn't linger.
+                    let _ = agent::kill_agent(turn.pid).await;
+                    TurnOutcome::TimedOut
+                }
+            }
+        }
+        None => TurnOutcome::NoStdout,
+    };
+    // Reap the child (best-effort; it exited or was just killed).
+    let _ = turn.child.wait().await;
+
+    lock_turns(&state).remove(&pr);
+
+    let (text, error) = match outcome {
+        TurnOutcome::Finished(text) if !text.trim().is_empty() => (text, false),
+        TurnOutcome::Finished(_) => (
+            "The reviewer agent produced no answer (the turn may have been stopped).".to_owned(),
+            true,
+        ),
+        TurnOutcome::TimedOut => (
+            "The reviewer agent timed out after 5 minutes and was stopped.".to_owned(),
+            true,
+        ),
+        TurnOutcome::NoStdout => (
+            "The reviewer agent produced no output stream.".to_owned(),
+            true,
+        ),
+    };
+    let ok = !error;
+    append_agent_message(&state, &pr_ref, &message_id, text, error);
+
+    let _ = app_handle.emit("chat-complete", ChatCompletePayload { pr, message_id, ok });
+}
+
+/// How a chat turn's read phase ended.
+enum TurnOutcome {
+    /// Stream ended; carries the final answer text (possibly empty).
+    Finished(String),
+    /// The 5-minute budget elapsed.
+    TimedOut,
+    /// The child had no stdout pipe (should not happen).
+    NoStdout,
+}
+
+/// Consume the turn's JSONL stdout: tee to the log, emit a `chat-stream`
+/// delta per assistant text block, and return the final answer text
+/// (`Complete.result_text` when present, else the accumulated blocks).
+async fn read_turn_output(
+    app_handle: &tauri::AppHandle,
+    pr: &str,
+    message_id: &str,
+    stdout: tokio::process::ChildStdout,
+    log_path: &std::path::Path,
+) -> String {
+    let log_file = tokio::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(log_path)
+        .await;
+    let mut log_writer = log_file.ok().map(tokio::io::BufWriter::new);
+
+    let mut lines = BufReader::new(stdout).lines();
+    let mut accumulated = String::new();
+    let mut final_text: Option<String> = None;
+
+    while let Ok(Some(line)) = lines.next_line().await {
+        if let Some(ref mut writer) = log_writer {
+            let _ = writer.write_all(line.as_bytes()).await;
+            let _ = writer.write_all(b"\n").await;
+            let _ = writer.flush().await;
+        }
+        match agent_stream::parse_stream_line(&line) {
+            Some(agent_stream::Event::Text { content }) => {
+                if !accumulated.is_empty() {
+                    accumulated.push_str("\n\n");
+                }
+                accumulated.push_str(&content);
+                let _ = app_handle.emit(
+                    "chat-stream",
+                    ChatStreamPayload {
+                        pr: pr.to_owned(),
+                        message_id: message_id.to_owned(),
+                        delta: content,
+                    },
+                );
+            }
+            Some(agent_stream::Event::Complete { result_text, .. })
+                if !result_text.trim().is_empty() =>
+            {
+                final_text = Some(result_text);
+            }
+            _ => {}
+        }
+    }
+    if let Some(ref mut writer) = log_writer {
+        let _ = writer.flush().await;
+    }
+
+    final_text.unwrap_or(accumulated)
+}
+
+/// Stop the in-flight chat turn for a review (explicit user action).
+///
+/// Kills the turn's process; the driver task then sees EOF and settles the
+/// thread with whatever the turn produced (or an error message).
+#[tauri::command]
+pub async fn cancel_chat_turn(
+    state: State<'_, Arc<AppState>>,
+    pr: String,
+) -> Result<(), CommandError> {
+    let pid = { lock_turns(&state).get(&pr).copied() };
+    match pid {
+        // A placeholder (0) means the spawn is still in flight; nothing to kill
+        // yet — the send path's own error handling covers it.
+        Some(0) | None => Ok(()),
+        Some(pid) => agent::kill_agent(pid).await.map_err(|e| CommandError {
+            message: format!("failed to stop chat turn: {e}"),
+        }),
+    }
+}
diff --git a/app/src-tauri/src/commands/mod.rs b/app/src-tauri/src/commands/mod.rs
index 342d8a6..31422ca 100644
--- a/app/src-tauri/src/commands/mod.rs
+++ b/app/src-tauri/src/commands/mod.rs
@@ -3,6 +3,7 @@
 //! Commands parse params, call core, and map results through
 //! [`CommandError`](crate::error::CommandError). All logic lives in core.
 
+pub mod chat;
 pub mod shell;
 
 use std::collections::HashSet;
diff --git a/app/src-tauri/src/lib.rs b/app/src-tauri/src/lib.rs
index 92bc8dd..67e657c 100644
--- a/app/src-tauri/src/lib.rs
+++ b/app/src-tauri/src/lib.rs
@@ -319,6 +319,8 @@ pub fn run() {
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
+            commands::chat::send_chat_message,
+            commands::chat::cancel_chat_turn,
             commands::list_reviews,
             commands::get_frontier,
             commands::get_review,
@@ -792,6 +794,9 @@ fn clear_head_anchored_annotations(review: &mut Review) {
     review.review_findings.clear();
     review.distilled_intent = None;
     review.distilled_headline = None;
+    // The chat thread answers questions about the previous head; stale answers
+    // are worse than no answers (cockpit-docs/REVIEWER_CHAT.md).
+    review.chat.clear();
 }
 
 /// Extract the PR number from a PR URL or reference string.
@@ -1426,6 +1431,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
@@ -1525,6 +1531,14 @@ mod tests {
         }];
         review.distilled_intent = Some("intent".into());
         review.recap_sha = Some("headsha9".into());
+        review.chat = vec![cockpit_core::model::ChatMessage {
+            id: cockpit_core::model::ChatMessageId::new("cm-1"),
+            role: cockpit_core::model::ChatRole::User,
+            text: "q".into(),
+            drafts: Vec::new(),
+            error: false,
+            created_at_epoch_ms: 1,
+        }];
 
         clear_head_anchored_annotations(&mut review);
 
@@ -1536,6 +1550,7 @@ mod tests {
             review.distilled_intent.is_none(),
             "intent cleared on refresh"
         );
+        assert!(review.chat.is_empty(), "chat cleared on refresh");
         assert_eq!(
             review.recap_sha.as_deref(),
             Some("headsha9"),
diff --git a/app/src-tauri/src/state.rs b/app/src-tauri/src/state.rs
index e282673..9e5bdf0 100644
--- a/app/src-tauri/src/state.rs
+++ b/app/src-tauri/src/state.rs
@@ -51,6 +51,14 @@ pub struct AppState {
     /// is only ever held for trivial map lookups/inserts — never across an
     /// `.await`.
     pub lsp_bridges: Mutex<HashMap<LspLanguage, LspBridge>>,
+
+    /// In-flight reviewer-chat turns, PR ref → agent pid.
+    ///
+    /// Enforces one turn per PR and gives `cancel_chat_turn` its kill target.
+    /// Chat turns are transient (never attached to `Review::agent`), so this
+    /// registry is their only handle. The `std::sync::Mutex` is held only for
+    /// trivial map operations — never across an `.await`.
+    pub chat_turns: Mutex<HashMap<String, u32>>,
 }
 
 impl AppState {
@@ -67,6 +75,7 @@ impl AppState {
             completion_tx,
             permission_broker,
             lsp_bridges: Mutex::new(HashMap::new()),
+            chat_turns: Mutex::new(HashMap::new()),
         }
     }
 }
diff --git a/app/src/App.tsx b/app/src/App.tsx
index 2220612..6ba31ae 100644
--- a/app/src/App.tsx
+++ b/app/src/App.tsx
@@ -97,6 +97,20 @@ interface AgentEventEnvelope {
   readonly event: AgentStreamEvent;
 }
 
+/** Payload of the reviewer-chat `"chat-stream"` event (hand-typed, no ts-rs). */
+interface ChatStreamPayload {
+  readonly pr: string;
+  readonly message_id: string;
+  readonly delta: string;
+}
+
+/** Payload of the reviewer-chat `"chat-complete"` event (hand-typed, no ts-rs). */
+interface ChatCompletePayload {
+  readonly pr: string;
+  readonly message_id: string;
+  readonly ok: boolean;
+}
+
 type ReviewTab = "my-prs" | "review-requests" | "all";
 
 const SIDEBAR_COLLAPSED_KEY = "cockpit-sidebar-collapsed";
@@ -603,7 +617,30 @@ function App() {
       },
     );
 
+    // Reviewer chat: stream deltas into the in-flight bubble; on completion
+    // settle the turn (the persisted agent message lands via review refresh).
+    const unlistenChatStream = listen<ChatStreamPayload>(
+      "chat-stream",
+      (event) => {
+        useAppStore
+          .getState()
+          .applyChatDelta(event.payload.pr, event.payload.delta);
+      },
+    );
+    const unlistenChatComplete = listen<ChatCompletePayload>(
+      "chat-complete",
+      (event) => {
+        void useAppStore.getState().completeChatTurn(event.payload.pr);
+      },
+    );
+
     return () => {
+      void unlistenChatStream.then((f) => {
+        f();
+      });
+      void unlistenChatComplete.then((f) => {
+        f();
+      });
       void unlisten.then((f) => {
         f();
       });
diff --git a/app/src/bindings/ChatMessage.ts b/app/src/bindings/ChatMessage.ts
new file mode 100644
index 0000000..a85ed41
--- /dev/null
+++ b/app/src/bindings/ChatMessage.ts
@@ -0,0 +1,37 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ChatMessageId } from "./ChatMessageId";
+import type { ChatRole } from "./ChatRole";
+import type { DraftComment } from "./DraftComment";
+
+/**
+ * One message in a review's chat thread with the reviewer agent.
+ *
+ * The thread is head-anchored context like findings and the distilled
+ * intent: it is cleared when the head moves, since answers about superseded
+ * code go stale.
+ */
+export type ChatMessage = { 
+/**
+ * Locally-unique message id.
+ */
+id: ChatMessageId, 
+/**
+ * Who authored the message.
+ */
+role: ChatRole, 
+/**
+ * The message text (markdown; draft blocks already stripped).
+ */
+text: string, 
+/**
+ * Draft comments proposed by the agent in this turn (usually empty).
+ */
+drafts: Array<DraftComment>, 
+/**
+ * Whether this agent message reports a failed turn (spawn/timeout/parse).
+ */
+error: boolean, 
+/**
+ * Wall-clock creation time in epoch milliseconds.
+ */
+created_at_epoch_ms: number, };
diff --git a/app/src/bindings/ChatMessageId.ts b/app/src/bindings/ChatMessageId.ts
new file mode 100644
index 0000000..79b7aec
--- /dev/null
+++ b/app/src/bindings/ChatMessageId.ts
@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Locally-unique identifier for a [`ChatMessage`] in a review's thread.
+ */
+export type ChatMessageId = string;
diff --git a/app/src/bindings/ChatRole.ts b/app/src/bindings/ChatRole.ts
new file mode 100644
index 0000000..b595cf9
--- /dev/null
+++ b/app/src/bindings/ChatRole.ts
@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Who authored a [`ChatMessage`] in a review's chat thread.
+ */
+export type ChatRole = "User" | "Agent";
diff --git a/app/src/bindings/DraftComment.ts b/app/src/bindings/DraftComment.ts
new file mode 100644
index 0000000..1aafb6b
--- /dev/null
+++ b/app/src/bindings/DraftComment.ts
@@ -0,0 +1,27 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { DiffSide } from "./DiffSide";
+
+/**
+ * A review comment the chat agent proposes, for the reviewer to adopt.
+ *
+ * A draft is a *proposal only*: it becomes a real [`Comment`] exclusively
+ * through the reviewer's explicit adopt action, and reaches GitHub only via
+ * the guarded mirror / submit-review flows (Invariant §9).
+ */
+export type DraftComment = { 
+/**
+ * Path relative to the repo root.
+ */
+path: string, 
+/**
+ * Inclusive start and end line in the current head.
+ */
+range: [number, number], 
+/**
+ * Which side of the diff the range refers to.
+ */
+side: DiffSide, 
+/**
+ * The proposed comment body (markdown).
+ */
+body: string, };
diff --git a/app/src/bindings/Review.ts b/app/src/bindings/Review.ts
index b4fed4e..83fea0b 100644
--- a/app/src/bindings/Review.ts
+++ b/app/src/bindings/Review.ts
@@ -1,5 +1,6 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AgentRun } from "./AgentRun";
+import type { ChatMessage } from "./ChatMessage";
 import type { CiSummary } from "./CiSummary";
 import type { Comment } from "./Comment";
 import type { ConversationItem } from "./ConversationItem";
@@ -165,4 +166,12 @@ distilled_headline: string | null,
  * tab can nudge a regenerate. Deliberately NOT cleared when the head moves
  * (unlike `review_findings` / `distilled_intent`) so staleness is derivable.
  */
-recap_sha: string | null, };
+recap_sha: string | null, 
+/**
+ * The chat thread between the reviewer and the read-only reviewer agent.
+ *
+ * Head-anchored like `review_findings` / `distilled_intent`: cleared when
+ * the head moves. `#[serde(default)]` keeps legacy persisted reviews
+ * loading with an empty thread.
+ */
+chat: Array<ChatMessage>, };
diff --git a/app/src/components/ChatPanel.test.tsx b/app/src/components/ChatPanel.test.tsx
new file mode 100644
index 0000000..9d7ba02
--- /dev/null
+++ b/app/src/components/ChatPanel.test.tsx
@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import { makeReview } from "../test/fixtures";
+import { mockInvoke, callsFor } from "../test/tauri-mock";
+import type { ChatMessage } from "../bindings/ChatMessage";
+
+vi.mock("@tauri-apps/api/core", async () => {
+  const mock = await import("../test/tauri-mock");
+  return { invoke: mock.invoke };
+});
+vi.mock("@tauri-apps/api/event", async () => {
+  const mock = await import("../test/tauri-mock");
+  return { listen: mock.listen };
+});
+vi.mock("@tauri-apps/plugin-opener", () => ({
+  openUrl: vi.fn(() => Promise.resolve()),
+}));
+
+const { useAppStore } = await import("../store");
+const { ChatPanel } = await import("./ChatPanel");
+
+const agentMessage: ChatMessage = {
+  id: "cm-a1",
+  role: "Agent",
+  text: "The flag gates every entry point.",
+  drafts: [
+    {
+      path: "src/a.py",
+      range: [57, 57],
+      side: "New",
+      body: "Use the no-retry policy.",
+    },
+  ],
+  error: false,
+  created_at_epoch_ms: 2,
+};
+
+const userMessage: ChatMessage = {
+  id: "cm-u1",
+  role: "User",
+  text: "What does the flag gate?",
+  drafts: [],
+  error: false,
+  created_at_epoch_ms: 1,
+};
+
+describe("ChatPanel", () => {
+  it("renders the thread and adopts a draft via add_comment", () => {
+    const review = {
+      ...makeReview({ gate_state: "InReview" }),
+      chat: [userMessage, agentMessage],
+    };
+    useAppStore.setState({
+      activeReview: review,
+      view: { kind: "diff", pr: review.pr },
+    });
+    mockInvoke("add_comment", () => review);
+
+    render(<ChatPanel review={review} onClose={() => undefined} />);
+
+    expect(screen.getByText("What does the flag gate?")).toBeDefined();
+    expect(
+      screen.getByText("The flag gates every entry point."),
+    ).toBeDefined();
+
+    fireEvent.click(screen.getByRole("button", { name: "Add to review" }));
+    const calls = callsFor("add_comment");
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.args).toMatchObject({
+      file: "src/a.py",
+      lineStart: 57,
+      lineEnd: 57,
+      body: "Use the no-retry policy.",
+      side: "New",
+    });
+  });
+
+  it("shows the adopted state instead of the button once a comment matches", () => {
+    const base = makeReview({ gate_state: "InReview" });
+    const review = {
+      ...base,
+      chat: [agentMessage],
+      comments: [
+        {
+          id: "c-1",
+          anchor: {
+            DiffLine: {
+              path: "src/a.py",
+              range: [57, 57] as [number, number],
+              side: "New" as const,
+            },
+          },
+          body: "Use the no-retry policy.",
+          origin: "Local" as const,
+        },
+      ],
+    };
+    render(<ChatPanel review={review} onClose={() => undefined} />);
+    expect(screen.queryByRole("button", { name: "Add to review" })).toBeNull();
+    expect(screen.getByText("Added ✓")).toBeDefined();
+  });
+
+  it("disables send on empty input and marks error turns", () => {
+    const review = {
+      ...makeReview({ gate_state: "InReview" }),
+      chat: [
+        {
+          ...agentMessage,
+          id: "cm-err",
+          drafts: [],
+          error: true,
+          text: "The reviewer agent timed out after 5 minutes and was stopped.",
+        },
+      ],
+    };
+    render(<ChatPanel review={review} onClose={() => undefined} />);
+    const send = screen.getByRole("button", { name: "Send message" });
+    expect((send as HTMLButtonElement).disabled).toBe(true);
+    expect(
+      screen.getByText(
+        "The reviewer agent timed out after 5 minutes and was stopped.",
+      ),
+    ).toBeDefined();
+  });
+});
diff --git a/app/src/components/ChatPanel.tsx b/app/src/components/ChatPanel.tsx
new file mode 100644
index 0000000..0e322c7
--- /dev/null
+++ b/app/src/components/ChatPanel.tsx
@@ -0,0 +1,386 @@
+/**
+ * The reviewer-chat panel — "Ask the reviewer" (cockpit-docs/REVIEWER_CHAT.md).
+ *
+ * A workspace-level docked panel: one persistent conversation per PR with the
+ * read-only reviewer agent, reachable from whatever tab is active. User
+ * bubbles right; agent bubbles left with the brand rail (the agent-voice
+ * identity); answers render through the shared safe Markdown. Agent turns can
+ * carry draft comments, shown as adopt-able cards that flow into the same
+ * guarded adopt → Mirror/Submit path as findings (§9).
+ *
+ * The panel owns its width (drag the left divider; persisted) and renders a
+ * streaming bubble while a turn is in flight (`chat-stream` deltas from the
+ * store). Send is disabled during a turn; Stop kills it.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Loader2, Square, X } from "lucide-react";
+import type { Review } from "../bindings/Review";
+import type { ChatMessage } from "../bindings/ChatMessage";
+import type { DraftComment } from "../bindings/DraftComment";
+import { useAppStore } from "../store";
+import { Markdown } from "./Markdown";
+import { AgentMark } from "@/lib/agent-event";
+import { isDraftAdopted } from "@/lib/finding-comment";
+import {
+  CHAT_DEFAULT_WIDTH,
+  CHAT_KEY_STEP,
+  CHAT_MAX_WIDTH,
+  CHAT_MIN_WIDTH,
+  clampChatWidth,
+  loadChatWidth,
+  saveChatWidth,
+} from "@/lib/chat-panel";
+import { cn } from "@/lib/utils";
+
+interface ChatPanelProps {
+  readonly review: Review;
+  readonly onClose: () => void;
+}
+
+/** One draft-comment card inside an agent bubble. */
+function DraftCard({
+  draft,
+  adopted,
+  canAdopt,
+  onAdopt,
+}: {
+  readonly draft: DraftComment;
+  readonly adopted: boolean;
+  /** False when the gate is not InReview (commenting unavailable). */
+  readonly canAdopt: boolean;
+  readonly onAdopt: (draft: DraftComment) => void;
+}) {
+  const location =
+    draft.range[0] > 0
+      ? `${draft.path}:${String(draft.range[0])}${
+          draft.range[1] !== draft.range[0] ? `–${String(draft.range[1])}` : ""
+        }`
+      : draft.path;
+  return (
+    <div className="mt-2 rounded-md border border-border border-l-2 border-l-warning bg-warning/5 px-2.5 py-2">
+      <div className="font-mono text-[9px] font-semibold tracking-wide text-warning uppercase">
+        Draft comment
+      </div>
+      <div
+        className="mt-0.5 truncate font-mono text-[10px] text-muted-foreground"
+        title={location}
+      >
+        {location}
+      </div>
+      <div className="mt-1 text-xs text-foreground">
+        <Markdown text={draft.body} compact />
+      </div>
+      <div className="mt-1.5">
+        {adopted ? (
+          <span className="rounded border border-border/60 px-1.5 py-0.5 text-[10px] text-muted-foreground/70">
+            Added ✓
+          </span>
+        ) : (
+          <button
+            type="button"
+            disabled={!canAdopt}
+            onClick={() => {
+              onAdopt(draft);
+            }}
+            title={
+              canAdopt
+                ? "Add this draft as a review comment (posts to GitHub only via Mirror / Submit review)"
+                : "Open the review (InReview) to add comments"
+            }
+            className={cn(
+              "rounded border border-border bg-transparent px-1.5 py-0.5 text-[10px]",
+              canAdopt
+                ? "cursor-pointer text-muted-foreground hover:border-primary/50 hover:text-foreground"
+                : "cursor-not-allowed text-muted-foreground/50",
+            )}
+          >
+            Add to review
+          </button>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/** One chat bubble. */
+function Bubble({
+  message,
+  review,
+  canAdopt,
+  onAdopt,
+}: {
+  readonly message: ChatMessage;
+  readonly review: Review;
+  readonly canAdopt: boolean;
+  readonly onAdopt: (draft: DraftComment) => void;
+}) {
+  const isUser = message.role === "User";
+  return (
+    <div className={cn("max-w-[92%]", isUser ? "self-end" : "self-start")}>
+      <div
+        className={cn(
+          "font-mono text-[9px] tracking-wide uppercase",
+          isUser ? "text-right text-muted-foreground/70" : "text-brand",
+        )}
+      >
+        {isUser ? "You" : "Reviewer"}
+      </div>
+      <div
+        className={cn(
+          "mt-0.5 rounded-lg px-3 py-2 text-xs leading-relaxed",
+          isUser
+            ? "rounded-br-sm bg-muted text-foreground"
+            : "rounded-bl-sm border border-border border-l-2 bg-background/60",
+          !isUser && (message.error ? "border-l-danger" : "border-l-brand"),
+        )}
+      >
+        {message.error ? (
+          <span className="text-danger">{message.text}</span>
+        ) : (
+          <Markdown text={message.text} compact />
+        )}
+        {message.drafts.map((draft, i) => (
+          <DraftCard
+            // Drafts have no id; position within one immutable message is stable.
+            key={`${message.id}-${String(i)}`}
+            draft={draft}
+            adopted={isDraftAdopted(draft, review.comments)}
+            canAdopt={canAdopt}
+            onAdopt={onAdopt}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+/** The docked reviewer-chat panel (self-sizing; drag its left edge). */
+export function ChatPanel({ review, onClose }: ChatPanelProps) {
+  const pending = useAppStore((s) => s.chatPending[review.pr] === true);
+  const streamText = useAppStore((s) => s.chatStreamText[review.pr] ?? "");
+  const sendChatMessage = useAppStore((s) => s.sendChatMessage);
+  const cancelChatTurn = useAppStore((s) => s.cancelChatTurn);
+  const addComment = useAppStore((s) => s.addComment);
+
+  const [input, setInput] = useState("");
+  const [width, setWidth] = useState<number>(loadChatWidth);
+  const drag = useRef<{ startX: number; startWidth: number } | null>(null);
+  const scrollRef = useRef<HTMLDivElement | null>(null);
+
+  const canAdopt = review.gate_state === "InReview";
+
+  // Keep the newest message in view as the thread grows or streams.
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (el !== null) el.scrollTop = el.scrollHeight;
+  }, [review.chat.length, streamText, pending]);
+
+  const handleSend = useCallback(() => {
+    const text = input.trim();
+    if (text === "" || pending) return;
+    setInput("");
+    void sendChatMessage(review.pr, text);
+  }, [input, pending, review.pr, sendChatMessage]);
+
+  const handleAdopt = useCallback(
+    (draft: DraftComment) => {
+      void addComment(
+        draft.path,
+        draft.range[0],
+        draft.range[1],
+        draft.body,
+        draft.side,
+      );
+    },
+    [addComment],
+  );
+
+  // -- Left-edge resize (mirrors the board preview rail's interaction). --
+  const onDragStart = useCallback(
+    (e: React.PointerEvent<HTMLDivElement>) => {
+      e.preventDefault();
+      e.currentTarget.setPointerCapture(e.pointerId);
+      drag.current = { startX: e.clientX, startWidth: width };
+    },
+    [width],
+  );
+  const onDragMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    const d = drag.current;
+    if (d === null) return;
+    setWidth(clampChatWidth(d.startWidth + (d.startX - e.clientX)));
+  }, []);
+  const onDragEnd = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    const d = drag.current;
+    if (d === null) return;
+    drag.current = null;
+    e.currentTarget.releasePointerCapture(e.pointerId);
+    saveChatWidth(clampChatWidth(d.startWidth + (d.startX - e.clientX)));
+  }, []);
+  const onDividerKey = useCallback(
+    (e: React.KeyboardEvent<HTMLDivElement>) => {
+      const delta =
+        e.key === "ArrowLeft"
+          ? CHAT_KEY_STEP
+          : e.key === "ArrowRight"
+            ? -CHAT_KEY_STEP
+            : null;
+      if (delta === null) return;
+      e.preventDefault();
+      setWidth((w) => {
+        const next = clampChatWidth(w + delta);
+        saveChatWidth(next);
+        return next;
+      });
+    },
+    [],
+  );
+  const resetWidth = useCallback(() => {
+    setWidth(CHAT_DEFAULT_WIDTH);
+    saveChatWidth(CHAT_DEFAULT_WIDTH);
+  }, []);
+
+  const thread = review.chat;
+  const empty = thread.length === 0 && !pending;
+  const contextLine = useMemo(() => {
+    const parts = ["diff"];
+    if (review.review_findings.length > 0)
+      parts.push(`${String(review.review_findings.length)} findings`);
+    if (review.distilled_intent !== null) parts.push("intent");
+    if (review.recap_sha !== null) parts.push("recap");
+    if (review.comments.length > 0) parts.push("your comments");
+    return parts.join(" · ");
+  }, [review]);
+
+  return (
+    <>
+      <div
+        role="separator"
+        aria-orientation="vertical"
+        aria-label="Resize chat panel"
+        aria-valuenow={width}
+        aria-valuemin={CHAT_MIN_WIDTH}
+        aria-valuemax={CHAT_MAX_WIDTH}
+        tabIndex={0}
+        onPointerDown={onDragStart}
+        onPointerMove={onDragMove}
+        onPointerUp={onDragEnd}
+        onDoubleClick={resetWidth}
+        onKeyDown={onDividerKey}
+        className="w-1.5 shrink-0 cursor-col-resize outline-none transition-colors hover:bg-primary/30 focus-visible:bg-primary/40"
+      />
+      <aside
+        style={{ width }}
+        className="flex shrink-0 flex-col border-l border-border bg-card"
+      >
+        {/* Header */}
+        <div className="flex shrink-0 items-center gap-2 border-b border-border px-3 py-2">
+          <AgentMark className="h-3 w-3 text-brand" />
+          <span className="font-mono text-[10px] font-semibold tracking-wide text-brand uppercase">
+            Ask the reviewer
+          </span>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="Close chat"
+            className="ml-auto cursor-pointer rounded border-none bg-transparent p-0.5 text-muted-foreground hover:text-foreground"
+          >
+            <X className="h-3.5 w-3.5" />
+          </button>
+        </div>
+
+        {/* Thread */}
+        <div
+          ref={scrollRef}
+          className="flex min-h-0 flex-1 flex-col gap-3 overflow-y-auto px-3 py-3"
+        >
+          {empty && (
+            <div className="m-auto max-w-[26ch] text-center text-xs text-muted-foreground">
+              Ask the reviewer agent about this PR — it knows the diff, the
+              findings, and the intent. Try “draft a comment for…”.
+            </div>
+          )}
+          {thread.map((message) => (
+            <Bubble
+              key={message.id}
+              message={message}
+              review={review}
+              canAdopt={canAdopt}
+              onAdopt={handleAdopt}
+            />
+          ))}
+          {pending && (
+            <div className="max-w-[92%] self-start">
+              <div className="font-mono text-[9px] tracking-wide text-brand uppercase">
+                Reviewer
+              </div>
+              <div className="mt-0.5 rounded-lg rounded-bl-sm border border-border border-l-2 border-l-brand bg-background/60 px-3 py-2 text-xs leading-relaxed">
+                {streamText === "" ? (
+                  <span className="inline-flex items-center gap-1.5 text-muted-foreground">
+                    <Loader2 className="h-3 w-3 animate-spin" />
+                    Reading the diff…
+                  </span>
+                ) : (
+                  <Markdown text={streamText} compact />
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+
+        {/* Composer */}
+        <div className="shrink-0 border-t border-border px-3 py-2">
+          <div className="flex items-end gap-2">
+            <textarea
+              value={input}
+              onChange={(e) => {
+                setInput(e.target.value);
+              }}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && !e.shiftKey) {
+                  e.preventDefault();
+                  handleSend();
+                }
+              }}
+              rows={2}
+              placeholder='Ask, or "draft a comment for…"'
+              className="min-h-0 flex-1 resize-none rounded-md border border-border bg-background px-2.5 py-1.5 text-xs text-foreground placeholder:text-muted-foreground/60 focus:outline-1 focus:outline-ring"
+            />
+            {pending ? (
+              <button
+                type="button"
+                onClick={() => {
+                  void cancelChatTurn(review.pr);
+                }}
+                title="Stop the reviewer's turn"
+                aria-label="Stop the reviewer's turn"
+                className="flex h-8 w-8 shrink-0 cursor-pointer items-center justify-center rounded-md border border-border bg-transparent text-danger hover:bg-danger/10"
+              >
+                <Square className="h-3 w-3" />
+              </button>
+            ) : (
+              <button
+                type="button"
+                onClick={handleSend}
+                disabled={input.trim() === ""}
+                title="Send (Enter)"
+                aria-label="Send message"
+                className={cn(
+                  "flex h-8 w-8 shrink-0 items-center justify-center rounded-md border-none text-sm font-semibold",
+                  input.trim() === ""
+                    ? "cursor-not-allowed bg-muted text-muted-foreground/50"
+                    : "cursor-pointer bg-primary text-primary-foreground",
+                )}
+              >
+                ↑
+              </button>
+            )}
+          </div>
+          <div className="mt-1 font-mono text-[9px] text-muted-foreground/60">
+            context: {contextLine} · read-only
+          </div>
+        </div>
+      </aside>
+    </>
+  );
+}
diff --git a/app/src/components/ReviewWorkspace.tsx b/app/src/components/ReviewWorkspace.tsx
index 775e24c..495200a 100644
--- a/app/src/components/ReviewWorkspace.tsx
+++ b/app/src/components/ReviewWorkspace.tsx
@@ -21,8 +21,11 @@ import { BriefingTab } from "./BriefingTab";
 import { DiffView } from "./DiffView";
 import { CiPanel } from "./CiPanel";
 import { AgentPanel } from "./AgentPanel";
+import { ChatPanel } from "./ChatPanel";
 import { Terminal } from "./Terminal";
 import { initialReviewTab, type ReviewTab } from "@/lib/review-tab";
+import { loadChatOpen, saveChatOpen } from "@/lib/chat-panel";
+import { AgentMark } from "@/lib/agent-event";
 import { Loader2 } from "lucide-react";
 import { cn } from "@/lib/utils";
 
@@ -64,11 +67,17 @@ function WorkspaceTabBar({
   active,
   onSelect,
   findingsCount,
+  chatOpen,
+  onToggleChat,
 }: {
   readonly active: WorkspaceTab;
   readonly onSelect: (tab: WorkspaceTab) => void;
   /** Advisory finding count; badges the Briefing tab when positive. */
   readonly findingsCount: number;
+  /** Whether the reviewer-chat panel is docked open. */
+  readonly chatOpen: boolean;
+  /** Toggle the reviewer-chat panel. */
+  readonly onToggleChat: () => void;
 }) {
   // Styling mirrors the `ui/Tabs` `line` variant so in-content tabs read the
   // same across the app: a transparent bar with a baseline border and an
@@ -107,6 +116,20 @@ function WorkspaceTabBar({
           </button>
         );
       })}
+      {/* The workspace-level reviewer chat: available on every tab. */}
+      <button
+        type="button"
+        onClick={onToggleChat}
+        aria-pressed={chatOpen}
+        title={chatOpen ? "Close the reviewer chat" : "Ask the reviewer agent about this PR"}
+        className={cn(
+          "ml-auto inline-flex cursor-pointer items-center gap-1.5 rounded-md border-none bg-transparent px-3 py-1.5 font-mono text-[11px] font-semibold tracking-wide uppercase transition-colors",
+          chatOpen ? "text-brand" : "text-muted-foreground hover:text-foreground",
+        )}
+      >
+        <AgentMark className="h-3 w-3" />
+        Ask agent
+      </button>
     </div>
   );
 }
@@ -134,6 +157,15 @@ export function ReviewWorkspace({
   const [activeTab, setActiveTab] = useState<WorkspaceTab>(() =>
     initialLanding(review),
   );
+  // The reviewer-chat panel: open/closed persists app-wide; the conversation
+  // itself is per-PR and lives on the review.
+  const [chatOpen, setChatOpen] = useState<boolean>(loadChatOpen);
+  const toggleChat = useCallback(() => {
+    setChatOpen((open) => {
+      saveChatOpen(!open);
+      return !open;
+    });
+  }, []);
   const error = useAppStore((s) => s.error);
   const clearError = useAppStore((s) => s.clearError);
   const ensureReviewWorktree = useAppStore((s) => s.ensureReviewWorktree);
@@ -269,6 +301,8 @@ export function ReviewWorkspace({
         active={activeTab}
         onSelect={setActiveTab}
         findingsCount={review.review_findings.length}
+        chatOpen={chatOpen}
+        onToggleChat={toggleChat}
       />
       {error !== null && (
         <div className="flex items-center justify-between border-b border-danger bg-danger/10 px-4 py-2 text-xs text-danger">
@@ -282,8 +316,9 @@ export function ReviewWorkspace({
           </button>
         </div>
       )}
-      <div className="flex min-h-0 flex-1 flex-col">
-        {mountedTabs.has("briefing") && (
+      <div className="flex min-h-0 flex-1">
+        <div className="flex min-h-0 min-w-0 flex-1 flex-col">
+          {mountedTabs.has("briefing") && (
           <div
             className={cn(
               "flex min-h-0 flex-1 flex-col",
@@ -339,6 +374,8 @@ export function ReviewWorkspace({
             </div>
           </div>
         )}
+        </div>
+        {chatOpen && <ChatPanel review={review} onClose={toggleChat} />}
       </div>
     </div>
   );
diff --git a/app/src/lib/chat-panel.test.ts b/app/src/lib/chat-panel.test.ts
new file mode 100644
index 0000000..d627444
--- /dev/null
+++ b/app/src/lib/chat-panel.test.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import {
+  CHAT_DEFAULT_WIDTH,
+  CHAT_MAX_WIDTH,
+  CHAT_MIN_WIDTH,
+  CHAT_OPEN_KEY,
+  clampChatWidth,
+  initialChatWidth,
+  loadChatOpen,
+  saveChatOpen,
+} from "./chat-panel";
+
+describe("chat panel width", () => {
+  it("clamps into the usable band and defaults on garbage", () => {
+    expect(clampChatWidth(100)).toBe(CHAT_MIN_WIDTH);
+    expect(clampChatWidth(10_000)).toBe(CHAT_MAX_WIDTH);
+    expect(clampChatWidth(Number.NaN)).toBe(CHAT_DEFAULT_WIDTH);
+    expect(initialChatWidth(null)).toBe(CHAT_DEFAULT_WIDTH);
+    expect(initialChatWidth("bogus")).toBe(CHAT_DEFAULT_WIDTH);
+    expect(initialChatWidth("500")).toBe(500);
+  });
+});
+
+describe("chat panel open state", () => {
+  it("round-trips through localStorage, closed by default", () => {
+    localStorage.removeItem(CHAT_OPEN_KEY);
+    expect(loadChatOpen()).toBe(false);
+    saveChatOpen(true);
+    expect(loadChatOpen()).toBe(true);
+    saveChatOpen(false);
+    expect(loadChatOpen()).toBe(false);
+    localStorage.removeItem(CHAT_OPEN_KEY);
+  });
+});
diff --git a/app/src/lib/chat-panel.ts b/app/src/lib/chat-panel.ts
new file mode 100644
index 0000000..5a89ca7
--- /dev/null
+++ b/app/src/lib/chat-panel.ts
@@ -0,0 +1,60 @@
+/**
+ * Persistence + width model for the reviewer-chat panel.
+ *
+ * Mirrors the board preview rail's pattern (`rail-width.ts`): the panel is
+ * user-resizable by dragging its left edge, the chosen width persists, and
+ * malformed stored values clamp back into the usable band. The open/closed
+ * state persists too, app-wide (the conversation itself is per-PR and lives
+ * on the review).
+ */
+
+/** localStorage key for the panel's open/closed state. */
+export const CHAT_OPEN_KEY = "cockpit.chat.open";
+
+/** localStorage key for the persisted panel width (px). */
+export const CHAT_WIDTH_KEY = "cockpit.chat.width";
+
+/** Narrowest useful panel: below this, answer markdown wraps unreadably. */
+export const CHAT_MIN_WIDTH = 300;
+
+/** Widest allowed panel: keeps the tab behind it usable. */
+export const CHAT_MAX_WIDTH = 640;
+
+/** Width before the user ever resizes. */
+export const CHAT_DEFAULT_WIDTH = 380;
+
+/** Step (px) for one arrow-key press on the focused resize divider. */
+export const CHAT_KEY_STEP = 16;
+
+/** Clamp any candidate width into the usable band. */
+export function clampChatWidth(width: number): number {
+  if (Number.isNaN(width)) return CHAT_DEFAULT_WIDTH;
+  return Math.min(CHAT_MAX_WIDTH, Math.max(CHAT_MIN_WIDTH, Math.round(width)));
+}
+
+/** Parse a stored raw width into a usable one, defaulting when malformed. */
+export function initialChatWidth(stored: string | null): number {
+  if (stored === null) return CHAT_DEFAULT_WIDTH;
+  const parsed = Number.parseInt(stored, 10);
+  return Number.isNaN(parsed) ? CHAT_DEFAULT_WIDTH : clampChatWidth(parsed);
+}
+
+/** Read the persisted panel width. */
+export function loadChatWidth(): number {
+  return initialChatWidth(localStorage.getItem(CHAT_WIDTH_KEY));
+}
+
+/** Persist the user's panel width. */
+export function saveChatWidth(width: number): void {
+  localStorage.setItem(CHAT_WIDTH_KEY, String(clampChatWidth(width)));
+}
+
+/** Read the persisted open/closed state (closed by default). */
+export function loadChatOpen(): boolean {
+  return localStorage.getItem(CHAT_OPEN_KEY) === "true";
+}
+
+/** Persist the open/closed state. */
+export function saveChatOpen(open: boolean): void {
+  localStorage.setItem(CHAT_OPEN_KEY, String(open));
+}
diff --git a/app/src/lib/finding-comment.test.ts b/app/src/lib/finding-comment.test.ts
index 7e49210..799c529 100644
--- a/app/src/lib/finding-comment.test.ts
+++ b/app/src/lib/finding-comment.test.ts
@@ -2,6 +2,7 @@ import { describe, it, expect } from "vitest";
 import {
   findingCommentBody,
   isFindingAdopted,
+  isDraftAdopted,
   adoptedFindingIds,
 } from "./finding-comment";
 import type { ReviewFinding } from "../bindings/ReviewFinding";
@@ -97,3 +98,29 @@ describe("adoptedFindingIds", () => {
     expect(ids.has("f1-ffff0000")).toBe(false);
   });
 });
+
+describe("isDraftAdopted", () => {
+  const draft = {
+    path: "src/a.py",
+    range: [57, 57] as [number, number],
+    side: "New" as const,
+    body: "Use the no-retry policy.",
+  };
+
+  it("matches a local comment at the same anchor with the verbatim body", () => {
+    const comment = commentAt("src/a.py", [57, 57], "New", draft.body);
+    expect(isDraftAdopted(draft, [comment])).toBe(true);
+  });
+
+  it("does not match different anchors or edited bodies", () => {
+    expect(
+      isDraftAdopted(draft, [commentAt("src/a.py", [58, 58], "New", draft.body)]),
+    ).toBe(false);
+    expect(
+      isDraftAdopted(draft, [commentAt("src/a.py", [57, 57], "Old", draft.body)]),
+    ).toBe(false);
+    expect(
+      isDraftAdopted(draft, [commentAt("src/a.py", [57, 57], "New", "edited")]),
+    ).toBe(false);
+  });
+});
diff --git a/app/src/lib/finding-comment.ts b/app/src/lib/finding-comment.ts
index ea0cfb0..b5b4708 100644
--- a/app/src/lib/finding-comment.ts
+++ b/app/src/lib/finding-comment.ts
@@ -1,5 +1,6 @@
 import type { ReviewFinding } from "../bindings/ReviewFinding";
 import type { Comment } from "../bindings/Comment";
+import type { DraftComment } from "../bindings/DraftComment";
 
 /**
  * Turning an agent finding into a review comment ("adopting" it).
@@ -56,3 +57,25 @@ export function adoptedFindingIds(
   }
   return ids;
 }
+
+/**
+ * Whether a chat draft has already been adopted: a local comment exists at
+ * the same anchor carrying the draft body verbatim (drafts are adopted
+ * as-written — the agent composed them to be posted).
+ */
+export function isDraftAdopted(
+  draft: DraftComment,
+  comments: readonly Comment[],
+): boolean {
+  return comments.some((comment) => {
+    if (!("DiffLine" in comment.anchor)) return false;
+    const anchor = comment.anchor.DiffLine;
+    return (
+      anchor.path === draft.path &&
+      anchor.range[0] === draft.range[0] &&
+      anchor.range[1] === draft.range[1] &&
+      anchor.side === draft.side &&
+      comment.body === draft.body
+    );
+  });
+}
diff --git a/app/src/store.test.ts b/app/src/store.test.ts
index 90ecaa0..3c72c37 100644
--- a/app/src/store.test.ts
+++ b/app/src/store.test.ts
@@ -1037,3 +1037,77 @@ describe("agent fleet slice", () => {
     expect((second?.nonce ?? 0) > (first?.nonce ?? 0)).toBe(true);
   });
 });
+
+describe("reviewer chat", () => {
+  const reviewWithChat = (pr: string) => ({
+    ...makeReview({ pr }),
+  });
+
+  it("sendChatMessage sets pending and reconciles the returned review", async () => {
+    const review = reviewWithChat("owner/repo#7");
+    useAppStore.setState({
+      reviews: [review],
+      activeReview: review,
+      view: { kind: "diff", pr: review.pr },
+    });
+    const returned = {
+      ...review,
+      chat: [
+        {
+          id: "cm-1",
+          role: "User" as const,
+          text: "why?",
+          drafts: [],
+          error: false,
+          created_at_epoch_ms: 1,
+        },
+      ],
+    };
+    mockInvoke("send_chat_message", () => returned);
+
+    await useAppStore.getState().sendChatMessage(review.pr, "why?");
+
+    expect(useAppStore.getState().chatPending[review.pr]).toBe(true);
+    expect(useAppStore.getState().activeReview?.chat).toHaveLength(1);
+    expect(useAppStore.getState().reviews[0]?.chat).toHaveLength(1);
+  });
+
+  it("sendChatMessage clears pending and surfaces the error on failure", async () => {
+    const review = reviewWithChat("owner/repo#8");
+    useAppStore.setState({ reviews: [review] });
+    mockInvokeReject("send_chat_message", "turn already running");
+
+    await useAppStore.getState().sendChatMessage(review.pr, "hello");
+
+    expect(useAppStore.getState().chatPending[review.pr]).toBeUndefined();
+    expect(useAppStore.getState().error).toContain("turn already running");
+  });
+
+  it("applyChatDelta accumulates with paragraph separators", () => {
+    useAppStore.getState().applyChatDelta("owner/repo#9", "first");
+    useAppStore.getState().applyChatDelta("owner/repo#9", "second");
+    expect(useAppStore.getState().chatStreamText["owner/repo#9"]).toBe(
+      "first\n\nsecond",
+    );
+  });
+
+  it("completeChatTurn clears streaming state and refreshes the active review", async () => {
+    const review = reviewWithChat("owner/repo#10");
+    useAppStore.setState({
+      reviews: [review],
+      activeReview: review,
+      view: { kind: "diff", pr: review.pr },
+      chatPending: { [review.pr]: true },
+      chatStreamText: { [review.pr]: "partial" },
+    });
+    const refreshed = { ...review, title: "refreshed" };
+    mockInvoke("get_review", () => refreshed);
+    mockInvoke("get_review_diff", () => ({ raw: "" }));
+
+    await useAppStore.getState().completeChatTurn(review.pr);
+
+    expect(useAppStore.getState().chatPending[review.pr]).toBeUndefined();
+    expect(useAppStore.getState().chatStreamText[review.pr]).toBeUndefined();
+    expect(callsFor("get_review").length).toBeGreaterThan(0);
+  });
+});
diff --git a/app/src/store.ts b/app/src/store.ts
index 5ea9175..0bb1b4b 100644
--- a/app/src/store.ts
+++ b/app/src/store.ts
@@ -396,6 +396,39 @@ interface AppStore {
    */
   fetchRecap: (pr: string) => Promise<RecapPayload | null>;
 
+  /**
+   * PRs with a reviewer-chat turn in flight. Set on send, cleared by the
+   * `chat-complete` event; the panel disables send/shows the streaming bubble
+   * off this flag.
+   */
+  readonly chatPending: Readonly<Record<string, boolean>>;
+
+  /**
+   * Accumulated streamed answer text per PR for the in-flight turn (from
+   * `chat-stream` deltas). Cleared on completion — the final text then lives
+   * on the review's persisted thread.
+   */
+  readonly chatStreamText: Readonly<Record<string, string>>;
+
+  /**
+   * Send one reviewer-chat message. The backend appends the user message and
+   * returns the updated review immediately; the agent's answer arrives later
+   * via `chat-stream`/`chat-complete`.
+   */
+  sendChatMessage: (pr: string, text: string) => Promise<void>;
+
+  /** Stop the in-flight chat turn for a PR (explicit user action). */
+  cancelChatTurn: (pr: string) => Promise<void>;
+
+  /** Append a streamed delta for a PR's in-flight turn (`chat-stream`). */
+  applyChatDelta: (pr: string, delta: string) => void;
+
+  /**
+   * Settle a finished turn (`chat-complete`): clear the streaming state and
+   * re-read the active review so the persisted agent message appears.
+   */
+  completeChatTurn: (pr: string) => Promise<void>;
+
   /**
    * A pending cross-tab jump-to-line request for the Diff tab, or null. Set by
    * {@link requestDiffJump} (e.g. a Briefing finding's "Jump"); consumed by
@@ -693,6 +726,8 @@ export const useAppStore = create<AppStore>((set, get) => ({
   restackProgress: {},
   pendingPermissions: [],
   recaps: {},
+  chatPending: {},
+  chatStreamText: {},
   pendingDiffJump: null,
   agentActivity: {},
   recentCompletions: [],
@@ -1177,6 +1212,49 @@ export const useAppStore = create<AppStore>((set, get) => ({
     }
   },
 
+  sendChatMessage: async (pr: string, text: string) => {
+    set({ chatPending: { ...get().chatPending, [pr]: true }, error: null });
+    try {
+      const review = await invoke<Review>("send_chat_message", { pr, text });
+      const replace = (r: Review) => (r.pr === review.pr ? review : r);
+      set({
+        activeReview:
+          get().activeReview?.pr === review.pr ? review : get().activeReview,
+        reviews: get().reviews.map(replace),
+        authoredPrs: get().authoredPrs.map(replace),
+        reviewRequests: get().reviewRequests.map(replace),
+      });
+    } catch (e: unknown) {
+      const { [pr]: _dropped, ...rest } = get().chatPending;
+      set({ error: String(e), chatPending: rest });
+    }
+  },
+
+  cancelChatTurn: async (pr: string) => {
+    try {
+      await invoke("cancel_chat_turn", { pr });
+    } catch (e: unknown) {
+      set({ error: String(e) });
+    }
+  },
+
+  applyChatDelta: (pr: string, delta: string) => {
+    const prev = get().chatStreamText[pr] ?? "";
+    const next = prev === "" ? delta : `${prev}\n\n${delta}`;
+    set({ chatStreamText: { ...get().chatStreamText, [pr]: next } });
+  },
+
+  completeChatTurn: async (pr: string) => {
+    const { [pr]: _pending, ...chatPending } = get().chatPending;
+    const { [pr]: _stream, ...chatStreamText } = get().chatStreamText;
+    set({ chatPending, chatStreamText });
+    // The agent message is persisted on the review; re-read it when the
+    // completed turn belongs to the review being viewed.
+    if (get().activeReview?.pr === pr) {
+      await get().refreshActiveReview();
+    }
+  },
+
   requestDiffJump: (
     pr: string,
     path: string,
diff --git a/app/src/test/fixtures.ts b/app/src/test/fixtures.ts
index db1abc7..f9b1546 100644
--- a/app/src/test/fixtures.ts
+++ b/app/src/test/fixtures.ts
@@ -62,6 +62,7 @@ export function makeReview(overrides: Partial<Review> = {}): Review {
     distilled_intent: null,
     distilled_headline: null,
     recap_sha: null,
+    chat: [],
   };
   return { ...base, ...overrides };
 }
diff --git a/cockpit-docs/REVIEWER_CHAT.md b/cockpit-docs/REVIEWER_CHAT.md
new file mode 100644
index 0000000..5c51b62
--- /dev/null
+++ b/cockpit-docs/REVIEWER_CHAT.md
@@ -0,0 +1,106 @@
+# Reviewer Chat — design spec
+
+**Date:** 2026-07-06 · **Status:** approved for implementation
+
+A multi-turn chat where the reviewer talks to the pre-review agent about the PR
+under review. The agent already knows the diff, intent, findings, and recap; it
+answers questions and can draft review comments the reviewer adopts through the
+existing guarded flow.
+
+## Decisions (locked with the user)
+
+- **Role:** answer + draft comments. Read-only on code; it never edits, and any
+  outward post rides the existing adopt → guarded-submit path (§9).
+- **Placement:** workspace-level docked panel, toggled by an "✦ Ask agent"
+  header button, rendered over whatever tab is active (Briefing / Diff / CI).
+  One conversation, reachable from anywhere in the review.
+- **Persistence:** one thread per PR, persisted with the review; **cleared when
+  the head moves**, alongside `review_findings` / `distilled_intent`
+  (answers about superseded code go stale).
+- **Agent model:** stateless per-turn spawn. Each turn is a fresh one-shot
+  `claude` in the review's worktree; the prompt is assembled from the review
+  context + the prior transcript + the new question. Our store owns the
+  transcript. (Not a resumable CLI session — that hides conversation state in
+  CLI-managed files we can't cleanly persist or replay.)
+- **Exploration:** free. Read-only worktree tools (`Read`/`Grep`/`Glob`), no
+  tight tool budget, best-grounded answers. The spawn hard-disallows
+  `Write`/`Edit`/`NotebookEdit`/`Bash`/`Task` (`--disallowedTools`), so the
+  turn is provably read-only and never triggers a permission prompt.
+
+## Data model (`cockpit-core`)
+
+```rust
+struct ChatMessage {
+    id: ChatMessageId,          // newtype
+    role: ChatRole,             // enum User | Agent
+    text: String,               // markdown
+    drafts: Vec<DraftComment>,  // agent turns only; usually empty
+    error: bool,                // a failed turn's reply (spawn/timeout), styled as such
+    created_at_epoch_ms: u64,   // repo precedent (TrajectorySummary), ts-safe
+}
+struct DraftComment { path, range: (u32,u32), side: DiffSide, body: String }
+```
+
+`Review.chat: Vec<ChatMessage>` — `#[serde(default)]`, TS bindings `T | null`
+where optional (never `ts(optional)`). Added to
+`clear_head_anchored_annotations` so a new push clears it with the findings.
+
+## Prompt
+
+New `AgentMode`-adjacent prompt assembler `assemble_chat_prompt(ChatInput)`:
+frames the agent as the read-only reviewer, embeds intent + findings + diff +
+recap (capped) + the reviewer's local comments + GitHub conversation, then the
+prior transcript (last 40 messages), then the new question. Instructs: answer
+concisely, ground in the diff, say when unsure; you may read files read-only;
+to draft a comment emit a fenced JSON block
+`{"drafts":[{path,line_start,line_end,side,body}]}` **inline in the answer**
+(no file transport — keeps the turn write-free); never edit code. Cockpit
+parses the block out of the final text, renders the drafts as adopt-able
+cards, and shows the remaining text as the answer. Deterministic assembly with
+a golden test.
+
+## Streaming & lifecycle
+
+- **Command** `send_chat_message(pr, text)`: appends the user message, spawns
+  the turn, streams the answer, on completion parses the inline drafts block
+  out of the text and appends the agent message, persists.
+- **Turn registry:** `AppState.chat_turns: Mutex<HashMap<pr, pid>>` — one
+  in-flight turn per PR; `cancel_chat_turn(pr)` kills it; a 5-minute hard
+  timeout kills a hung turn and appends an error message.
+- **Dedicated `chat-stream` event** `{ pr, message_id, delta }` — separate from
+  `agent-event` so chat never collides with the AgentPanel timeline.
+- Turns are **transient spawns, not attached to `review.agent`**: they don't
+  appear in the fleet roster, don't count against `max_parallel_agents`, and
+  never touch the gate.
+- One in-flight turn per PR (send disabled while streaming); a Stop cancels it.
+- Fail-open (§0.1): a spawn/parse failure surfaces an error message in the
+  thread and never blocks the review.
+
+## Frontend
+
+- `ChatPanel` (workspace-level), toggled from the ReviewWorkspace header;
+  docked right, resizable (reuse the preview-rail width pattern), open/closed
+  persisted. User bubbles right; agent bubbles left with the brand rail;
+  answers via the shared safe `<Markdown>`; draft cards inline with an
+  "Add to review" button reusing the finding-adoption path (`add_comment`).
+- One global `chat-stream` listener appends deltas to the in-flight message.
+
+## Guardrails
+
+- Read-only tools only; no code mutation from chat.
+- Drafts are proposals; posting to GitHub still requires explicit adopt +
+  confirmed Mirror/Submit-review (§9).
+- Chat is ephemeral like comments (§0.4-adjacent): head move clears it.
+
+## Testing
+
+- Rust: `ChatMessage`/`DraftComment` serde round-trip; `assemble_chat_prompt`
+  golden; draft-transport parse (reuse findings parser shape); head-move clears
+  chat; transient spawn does not set `review.agent`.
+- TS: chat store slice (append user, stream deltas, finalize agent, adopt
+  draft); ChatPanel render (bubbles, draft card, streaming/disabled states).
+
+## Out of scope (v1)
+
+- Resumable CLI sessions; chat on the plan gate; chat acting on code; sharing a
+  thread to GitHub. Revisit if wanted.
diff --git a/crates/cockpit-core/src/adapters/agent.rs b/crates/cockpit-core/src/adapters/agent.rs
index fdbb26b..e714e0b 100644
--- a/crates/cockpit-core/src/adapters/agent.rs
+++ b/crates/cockpit-core/src/adapters/agent.rs
@@ -253,6 +253,38 @@ impl SpawnConfig {
         self
     }
 
+    /// Hard-deny the named tools by appending `--disallowedTools`.
+    ///
+    /// Deny rules take precedence over allows in the Claude CLI, so this makes
+    /// a spawn *provably* incapable of the listed tools regardless of the
+    /// permission mode. The reviewer chat uses it to guarantee a turn is
+    /// read-only (`Write`, `Edit`, `NotebookEdit`, `Bash`, `Task` all denied),
+    /// which also means the turn can never raise a permission prompt.
+    ///
+    /// Mirrors [`Self::allow_write_under`]'s single-flag contract: a repeated
+    /// flag replaces rather than accumulates, so repeated calls merge into one
+    /// comma-separated value.
+    #[must_use]
+    pub fn disallow_tools(mut self, tools: &[&str]) -> Self {
+        if tools.is_empty() {
+            return self;
+        }
+        let joined = tools.join(",");
+        if let Some(pos) = self
+            .tail_args
+            .iter()
+            .position(|arg| arg == "--disallowedTools")
+            && let Some(existing) = self.tail_args.get_mut(pos + 1)
+        {
+            existing.push(',');
+            existing.push_str(&joined);
+            return self;
+        }
+        self.tail_args.push("--disallowedTools".into());
+        self.tail_args.push(joined);
+        self
+    }
+
     /// Apply the configured [`AgentPermissionMode`] to this spawn configuration.
     ///
     /// - [`AgentPermissionMode::Bypass`] pushes `--dangerously-skip-permissions`
@@ -413,6 +445,64 @@ pub async fn spawn_agent(
     })
 }
 
+/// A spawned reviewer-chat turn: a transient, read-only agent process.
+#[derive(Debug)]
+pub struct ChatTurn {
+    /// OS pid, for cancellation.
+    pub pid: u32,
+    /// The child process; stdout is piped JSONL for streaming.
+    pub child: tokio::process::Child,
+    /// Log file receiving stderr (and a stdout tee, by the caller).
+    pub log_path: PathBuf,
+}
+
+/// Spawn one reviewer-chat turn in the given worktree.
+///
+/// Deliberately NOT [`spawn_agent`]: a chat turn is transient — it registers
+/// no session (the Stop-hook completion pipeline must not fire for it), sets
+/// no hook URL, and is never attached to a review's `agent` handle, so it
+/// stays out of the fleet roster and the `max_parallel_agents` count. The
+/// caller drives its stdout to completion and owns cancellation by pid.
+pub async fn spawn_chat_turn(
+    worktree_path: &Path,
+    prompt: &AssembledPrompt,
+    spawn_config: &SpawnConfig,
+) -> Result<ChatTurn, Error> {
+    tokio::fs::metadata(worktree_path)
+        .await
+        .map_err(|_| Error::WorktreeNotFound(worktree_path.to_path_buf()))?;
+
+    let logs_dir = config::logs_dir()?;
+    tokio::fs::create_dir_all(&logs_dir).await?;
+    let log_path = logs_dir.join(format!("chat-{}.log", Uuid::new_v4()));
+    let stderr_file = std::fs::File::create(&log_path)?;
+
+    let mut command = Command::new(&spawn_config.command);
+    command
+        .args(&spawn_config.base_args)
+        .arg(&prompt.text)
+        .args(&spawn_config.tail_args)
+        .current_dir(worktree_path)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::from(stderr_file));
+    if let Some(path) = login_shell_path() {
+        command.env("PATH", path);
+    }
+
+    let child = command
+        .spawn()
+        .map_err(|e| Error::SpawnFailed(e.to_string()))?;
+    let pid = child
+        .id()
+        .ok_or_else(|| Error::SpawnFailed("process exited before PID could be read".into()))?;
+
+    Ok(ChatTurn {
+        pid,
+        child,
+        log_path,
+    })
+}
+
 // ---------------------------------------------------------------------------
 // Login-shell PATH resolution
 // ---------------------------------------------------------------------------
@@ -643,6 +733,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn disallow_tools_merges_into_one_flag() {
+        let spawn = SpawnConfig::default()
+            .disallow_tools(&["Write", "Edit"])
+            .disallow_tools(&["Bash"]);
+        let flags = spawn
+            .tail_args
+            .iter()
+            .filter(|a| *a == "--disallowedTools")
+            .count();
+        assert_eq!(flags, 1, "denies must merge: {:?}", spawn.tail_args);
+        let pos = spawn
+            .tail_args
+            .iter()
+            .position(|a| a == "--disallowedTools")
+            .expect("flag present");
+        assert_eq!(spawn.tail_args[pos + 1], "Write,Edit,Bash");
+        // Empty input is a no-op.
+        let untouched = SpawnConfig::default().disallow_tools(&[]);
+        assert!(!untouched.tail_args.iter().any(|a| a == "--disallowedTools"));
+    }
+
     #[test]
     fn allow_write_under_merges_repeated_rules() {
         let spawn = SpawnConfig::default()
diff --git a/crates/cockpit-core/src/adapters/github.rs b/crates/cockpit-core/src/adapters/github.rs
index 9704dae..b0aa33d 100644
--- a/crates/cockpit-core/src/adapters/github.rs
+++ b/crates/cockpit-core/src/adapters/github.rs
@@ -946,6 +946,7 @@ pub fn build_review_from_pr(
         distilled_intent: None,
         distilled_headline: None,
         recap_sha: None,
+        chat: Vec::new(),
     }
 }
 
@@ -2668,6 +2669,7 @@ index 1111111..2222222 100644
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/src/chat.rs b/crates/cockpit-core/src/chat.rs
new file mode 100644
index 0000000..58b9b3e
--- /dev/null
+++ b/crates/cockpit-core/src/chat.rs
@@ -0,0 +1,276 @@
+//! Parsing of reviewer-chat agent replies.
+//!
+//! A chat turn's answer arrives as plain markdown that may embed ONE JSON
+//! object of the shape `{"drafts": [ ... ]}` — the comment drafts the agent
+//! proposes (see `cockpit-docs/REVIEWER_CHAT.md`). Drafts travel inline in the
+//! answer (no file transport) so the turn needs zero write access. This module
+//! extracts the drafts, strips the block (and its enclosing code fence, when
+//! present) from the displayed text, and tolerantly skips malformed entries —
+//! a bad draft must never lose the answer (Invariant §0.1).
+
+use serde_json::Value;
+
+use crate::model::{DiffSide, DraftComment};
+
+/// Upper bound on drafts parsed from a single reply.
+const MAX_DRAFTS: usize = 20;
+
+/// Upper bound on a draft body's character length.
+const MAX_DRAFT_BODY_CHARS: usize = 4000;
+
+/// A parsed chat reply: the display text with any drafts block removed, plus
+/// the drafts themselves.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ChatReply {
+    /// The answer markdown, with the drafts JSON (and its fence) stripped.
+    pub text: String,
+    /// Proposed comment drafts, at most [`MAX_DRAFTS`].
+    pub drafts: Vec<DraftComment>,
+}
+
+/// Parse an agent chat reply into display text + drafts.
+///
+/// Scans the reply for the first balanced `{ ... }` region that parses as a
+/// JSON object carrying a `drafts` array (the discriminator, mirroring the
+/// findings parser's objects-first rule). When found, the region — widened to
+/// its enclosing triple-backtick fence if the fence contains only that object —
+/// is removed from the text. Absent or malformed JSON simply yields the whole
+/// text with no drafts: chat must degrade to a plain answer, never fail.
+pub fn parse_chat_reply(raw: &str) -> ChatReply {
+    let Some((start, end, drafts)) = find_drafts_block(raw) else {
+        return ChatReply {
+            text: raw.trim().to_owned(),
+            drafts: Vec::new(),
+        };
+    };
+
+    let (cut_start, cut_end) = widen_to_fence(raw, start, end);
+    let mut text = String::with_capacity(raw.len());
+    text.push_str(&raw[..cut_start]);
+    text.push_str(&raw[cut_end..]);
+    // Collapse the seam so removal never leaves a wall of blank lines.
+    let text = collapse_blank_runs(text.trim());
+
+    ChatReply { text, drafts }
+}
+
+/// Find the first balanced brace region that parses as `{"drafts": [...]}`.
+///
+/// Returns `(byte_start, byte_end_exclusive, drafts)`.
+fn find_drafts_block(text: &str) -> Option<(usize, usize, Vec<DraftComment>)> {
+    for (idx, _) in text.match_indices('{') {
+        let Some(end) = scan_balanced(&text[idx..]) else {
+            continue;
+        };
+        let candidate = &text[idx..idx + end];
+        let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(candidate) else {
+            continue;
+        };
+        let Some(Value::Array(entries)) = obj.get("drafts") else {
+            continue;
+        };
+        let drafts = entries
+            .iter()
+            .filter_map(value_to_draft)
+            .take(MAX_DRAFTS)
+            .collect();
+        return Some((idx, idx + end, drafts));
+    }
+    None
+}
+
+/// Convert one JSON entry into a [`DraftComment`], skipping malformed entries.
+///
+/// Tolerance rules mirror the findings parser: a missing/empty `path` or
+/// `body` drops the entry; a reversed range is swapped; a missing line is `0`;
+/// an unknown or missing `side` defaults to [`DiffSide::New`]; the body is
+/// capped at [`MAX_DRAFT_BODY_CHARS`] on a char boundary.
+fn value_to_draft(value: &Value) -> Option<DraftComment> {
+    let obj = value.as_object()?;
+    let path = obj.get("path")?.as_str()?.trim();
+    if path.is_empty() {
+        return None;
+    }
+    let body_raw = obj.get("body")?.as_str()?.trim();
+    if body_raw.is_empty() {
+        return None;
+    }
+    let body = match body_raw.char_indices().nth(MAX_DRAFT_BODY_CHARS) {
+        Some((i, _)) => body_raw[..i].to_owned(),
+        None => body_raw.to_owned(),
+    };
+
+    let line = |key: &str| -> u32 {
+        obj.get(key)
+            .and_then(Value::as_u64)
+            .and_then(|n| u32::try_from(n).ok())
+            .unwrap_or(0)
+    };
+    let (mut start, mut end) = (line("line_start"), line("line_end"));
+    if end < start {
+        std::mem::swap(&mut start, &mut end);
+    }
+    if end == 0 {
+        end = start;
+    }
+
+    let side = match obj.get("side").and_then(Value::as_str) {
+        Some("Old") => DiffSide::Old,
+        _ => DiffSide::New,
+    };
+
+    Some(DraftComment {
+        path: path.to_owned(),
+        range: (start, end),
+        side,
+        body,
+    })
+}
+
+/// String-aware balanced-brace scan: given text starting at `{`, return the
+/// exclusive end offset of its matching `}`, or `None` when unbalanced.
+fn scan_balanced(text: &str) -> Option<usize> {
+    let bytes = text.as_bytes();
+    let mut depth = 0usize;
+    let mut in_string = false;
+    let mut escaped = false;
+    for (i, &b) in bytes.iter().enumerate() {
+        if in_string {
+            match b {
+                _ if escaped => escaped = false,
+                b'\\' => escaped = true,
+                b'"' => in_string = false,
+                _ => {}
+            }
+            continue;
+        }
+        match b {
+            b'"' => in_string = true,
+            b'{' => depth += 1,
+            b'}' => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(i + 1);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+/// Widen a removal span to its enclosing triple-backtick fence when the fence
+/// contains only the JSON object (i.e. the agent wrote a ```json block).
+fn widen_to_fence(text: &str, start: usize, end: usize) -> (usize, usize) {
+    // Look backwards: the text between the previous "```..." line and `start`
+    // must be whitespace only.
+    let before = &text[..start];
+    let Some(open) = before.rfind("```") else {
+        return (start, end);
+    };
+    let open_line_end = match text[open..].find('\n') {
+        Some(off) => open + off + 1,
+        None => return (start, end),
+    };
+    if open_line_end > start || !text[open_line_end..start].trim().is_empty() {
+        return (start, end);
+    }
+    // Look forwards: whitespace only until a closing "```".
+    let after = &text[end..];
+    let Some(close_rel) = after.find("```") else {
+        return (start, end);
+    };
+    if !after[..close_rel].trim().is_empty() {
+        return (start, end);
+    }
+    let close_end = end + close_rel + 3;
+    (open, close_end)
+}
+
+/// Collapse runs of 3+ newlines (left by block removal) down to a paragraph
+/// break.
+fn collapse_blank_runs(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut newlines = 0usize;
+    for ch in text.chars() {
+        if ch == '\n' {
+            newlines += 1;
+            if newlines <= 2 {
+                out.push(ch);
+            }
+        } else {
+            newlines = 0;
+            out.push(ch);
+        }
+    }
+    out
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn plain_answer_passes_through() {
+        let reply = parse_chat_reply("The flag gates every entry point.\n");
+        assert_eq!(reply.text, "The flag gates every entry point.");
+        assert!(reply.drafts.is_empty());
+    }
+
+    #[test]
+    fn fenced_drafts_block_is_extracted_and_stripped() {
+        let raw = "Here's a draft:\n\n```json\n{\"drafts\":[{\"path\":\"src/a.py\",\"line_start\":57,\"line_end\":57,\"side\":\"New\",\"body\":\"Use the no-retry policy.\"}]}\n```\n\nLet me know if you want it stronger.";
+        let reply = parse_chat_reply(raw);
+        assert_eq!(reply.drafts.len(), 1);
+        let d = &reply.drafts[0];
+        assert_eq!(d.path, "src/a.py");
+        assert_eq!(d.range, (57, 57));
+        assert_eq!(d.side, DiffSide::New);
+        assert_eq!(d.body, "Use the no-retry policy.");
+        assert!(!reply.text.contains("drafts"));
+        assert!(!reply.text.contains("```"));
+        assert!(reply.text.contains("Here's a draft:"));
+        assert!(reply.text.contains("stronger."));
+    }
+
+    #[test]
+    fn bare_object_without_fence_also_works() {
+        let raw = "Draft below.\n{\"drafts\":[{\"path\":\"a.rs\",\"line_start\":3,\"line_end\":2,\"body\":\"b\"}]}\nDone.";
+        let reply = parse_chat_reply(raw);
+        assert_eq!(reply.drafts.len(), 1);
+        // Reversed range is swapped.
+        assert_eq!(reply.drafts[0].range, (2, 3));
+        assert!(!reply.text.contains('{'));
+    }
+
+    #[test]
+    fn malformed_entries_are_skipped_not_fatal() {
+        let raw = r#"{"drafts":[{"path":"","body":"x"},{"path":"ok.rs","body":""},42,{"path":"keep.rs","line_start":1,"line_end":1,"body":"kept"}]}"#;
+        let reply = parse_chat_reply(raw);
+        assert_eq!(reply.drafts.len(), 1);
+        assert_eq!(reply.drafts[0].path, "keep.rs");
+    }
+
+    #[test]
+    fn unrelated_json_in_answer_is_left_alone() {
+        let raw = "The payload looks like `{\"role\": \"viewer\"}` in the new schema.";
+        let reply = parse_chat_reply(raw);
+        assert!(reply.drafts.is_empty());
+        assert_eq!(reply.text, raw);
+    }
+
+    #[test]
+    fn body_is_capped_and_side_defaults_new() {
+        let long = "x".repeat(5000);
+        let raw = format!(
+            r#"{{"drafts":[{{"path":"p.rs","line_start":1,"line_end":1,"body":"{long}"}}]}}"#
+        );
+        let reply = parse_chat_reply(&raw);
+        assert_eq!(reply.drafts[0].body.chars().count(), MAX_DRAFT_BODY_CHARS);
+        assert_eq!(reply.drafts[0].side, DiffSide::New);
+    }
+}
diff --git a/crates/cockpit-core/src/gate.rs b/crates/cockpit-core/src/gate.rs
index a8c3f4a..7ce2bf2 100644
--- a/crates/cockpit-core/src/gate.rs
+++ b/crates/cockpit-core/src/gate.rs
@@ -342,6 +342,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/src/kickoff.rs b/crates/cockpit-core/src/kickoff.rs
index b699a67..f3888f1 100644
--- a/crates/cockpit-core/src/kickoff.rs
+++ b/crates/cockpit-core/src/kickoff.rs
@@ -208,6 +208,7 @@ fn build_review(
         distilled_intent: None,
         distilled_headline: None,
         recap_sha: None,
+        chat: Vec::new(),
     }
 }
 
@@ -841,6 +842,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }];
 
         wire_children(&mut reviews);
@@ -878,6 +880,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         };
 
         let prompt = assemble_implement_prompt(&review, &ProjectRef::new("proj-1"), None, None);
diff --git a/crates/cockpit-core/src/lib.rs b/crates/cockpit-core/src/lib.rs
index 2bebe04..a6dff09 100644
--- a/crates/cockpit-core/src/lib.rs
+++ b/crates/cockpit-core/src/lib.rs
@@ -14,6 +14,7 @@ pub mod config;
 pub mod model;
 
 pub mod adapters;
+pub mod chat;
 pub mod dag;
 pub mod diff_signals;
 pub mod findings;
diff --git a/crates/cockpit-core/src/model.rs b/crates/cockpit-core/src/model.rs
index 49e32c3..c023790 100644
--- a/crates/cockpit-core/src/model.rs
+++ b/crates/cockpit-core/src/model.rs
@@ -77,6 +77,11 @@ newtype_id! {
     ProjectId
 }
 
+newtype_id! {
+    /// Locally-unique identifier for a [`ChatMessage`] in a review's thread.
+    ChatMessageId
+}
+
 // ---------------------------------------------------------------------------
 // Enums
 // ---------------------------------------------------------------------------
@@ -194,6 +199,59 @@ pub enum ConversationKind {
     IssueComment,
 }
 
+/// Who authored a [`ChatMessage`] in a review's chat thread.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
+#[ts(export, export_to = "../../../app/src/bindings/")]
+pub enum ChatRole {
+    /// The human reviewer.
+    User,
+    /// The read-only reviewer agent.
+    Agent,
+}
+
+/// A review comment the chat agent proposes, for the reviewer to adopt.
+///
+/// A draft is a *proposal only*: it becomes a real [`Comment`] exclusively
+/// through the reviewer's explicit adopt action, and reaches GitHub only via
+/// the guarded mirror / submit-review flows (Invariant §9).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
+#[ts(export, export_to = "../../../app/src/bindings/")]
+pub struct DraftComment {
+    /// Path relative to the repo root.
+    pub path: String,
+    /// Inclusive start and end line in the current head.
+    pub range: (u32, u32),
+    /// Which side of the diff the range refers to.
+    pub side: DiffSide,
+    /// The proposed comment body (markdown).
+    pub body: String,
+}
+
+/// One message in a review's chat thread with the reviewer agent.
+///
+/// The thread is head-anchored context like findings and the distilled
+/// intent: it is cleared when the head moves, since answers about superseded
+/// code go stale.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
+#[ts(export, export_to = "../../../app/src/bindings/")]
+pub struct ChatMessage {
+    /// Locally-unique message id.
+    pub id: ChatMessageId,
+    /// Who authored the message.
+    pub role: ChatRole,
+    /// The message text (markdown; draft blocks already stripped).
+    pub text: String,
+    /// Draft comments proposed by the agent in this turn (usually empty).
+    #[serde(default)]
+    pub drafts: Vec<DraftComment>,
+    /// Whether this agent message reports a failed turn (spawn/timeout/parse).
+    #[serde(default)]
+    pub error: bool,
+    /// Wall-clock creation time in epoch milliseconds.
+    #[ts(type = "number")]
+    pub created_at_epoch_ms: u64,
+}
+
 /// A location inside the current artifact that a [`Comment`] points to.
 ///
 /// Anchors are ephemeral — they reference the *current* artifact version only
@@ -586,6 +644,13 @@ pub struct Review {
     /// (unlike `review_findings` / `distilled_intent`) so staleness is derivable.
     #[serde(default)]
     pub recap_sha: Option<String>,
+    /// The chat thread between the reviewer and the read-only reviewer agent.
+    ///
+    /// Head-anchored like `review_findings` / `distilled_intent`: cleared when
+    /// the head moves. `#[serde(default)]` keeps legacy persisted reviews
+    /// loading with an empty thread.
+    #[serde(default)]
+    pub chat: Vec<ChatMessage>,
 }
 
 // ---------------------------------------------------------------------------
@@ -627,6 +692,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/src/persist.rs b/crates/cockpit-core/src/persist.rs
index 8c750db..552f0cf 100644
--- a/crates/cockpit-core/src/persist.rs
+++ b/crates/cockpit-core/src/persist.rs
@@ -156,6 +156,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/src/prompt.rs b/crates/cockpit-core/src/prompt.rs
index 83a79b1..8d70f5e 100644
--- a/crates/cockpit-core/src/prompt.rs
+++ b/crates/cockpit-core/src/prompt.rs
@@ -10,7 +10,10 @@ use std::sync::LazyLock;
 use sha2::{Digest, Sha256};
 
 use crate::config::RECAP_MDX_FILE;
-use crate::model::{AgentMode, Anchor, Artifact, Comment, DiffData, PlanDoc};
+use crate::model::{
+    AgentMode, Anchor, Artifact, ChatMessage, Comment, ConversationItem, DiffData, PlanDoc,
+    ReviewFinding,
+};
 use crate::skills::Skill;
 
 /// The scope-guard text, verbatim from `SPEC.md` §9.
@@ -448,6 +451,181 @@ pub struct ReviewInput<'a> {
     pub recap_dir: Option<&'a std::path::Path>,
 }
 
+/// Inputs for [`assemble_chat_prompt`] — one reviewer-chat turn.
+///
+/// See `cockpit-docs/REVIEWER_CHAT.md`. The turn is stateless: everything the
+/// agent knows (review context, prior transcript, the new question) is
+/// assembled here, deterministically.
+pub struct ChatInput<'a> {
+    /// PR title.
+    pub title: &'a str,
+    /// PR description / body.
+    pub body: &'a str,
+    /// The issue reference (e.g. `NEX-123`).
+    pub issue: &'a str,
+    /// The diff under review.
+    pub diff: &'a DiffData,
+    /// The pre-review agent's distilled read, when one exists.
+    pub intent: Option<&'a str>,
+    /// The pre-review findings, rendered as context.
+    pub findings: &'a [ReviewFinding],
+    /// The visual recap markdown, when one exists (capped at
+    /// [`CHAT_RECAP_CAP_CHARS`] on assembly).
+    pub recap_mdx: Option<&'a str>,
+    /// The reviewer's local comments on this head.
+    pub comments: &'a [Comment],
+    /// Mirrored GitHub conversation items (the last
+    /// [`CHAT_CONVERSATION_CAP`] are rendered).
+    pub conversation: &'a [ConversationItem],
+    /// The chat so far (the last [`CHAT_TRANSCRIPT_CAP`] messages are
+    /// rendered; drafts are elided — their bodies already appear as text).
+    pub transcript: &'a [ChatMessage],
+    /// The reviewer's new question.
+    pub question: &'a str,
+}
+
+/// Character cap applied to the recap markdown embedded in a chat prompt.
+pub const CHAT_RECAP_CAP_CHARS: usize = 4000;
+/// Maximum transcript messages replayed into a chat prompt.
+pub const CHAT_TRANSCRIPT_CAP: usize = 40;
+/// Character cap per replayed transcript message.
+pub const CHAT_MESSAGE_CAP_CHARS: usize = 2000;
+/// Maximum GitHub conversation items rendered into a chat prompt.
+pub const CHAT_CONVERSATION_CAP: usize = 20;
+/// Character cap per rendered finding rationale / conversation body.
+const CHAT_SNIPPET_CAP_CHARS: usize = 500;
+
+/// The chat-turn instruction: read-only reviewer, grounded answers, and the
+/// inline drafts contract (`{"drafts": [...]}` in a fenced json block —
+/// parsed back by [`crate::chat::parse_chat_reply`]).
+const CHAT_INSTRUCTION: &str = r#"You are the read-only advisory reviewer for the pull request above, in an ongoing conversation with the human reviewer. Answer the reviewer's question below.
+
+Ground every claim in the diff and this repository; when unsure, say so plainly. You may read files in this worktree (Read/Grep/Glob) to verify an answer. You cannot and must not modify anything — this conversation never edits code.
+
+When the reviewer asks you to draft a review comment (and only then), include exactly one fenced json block of this shape in your answer:
+   {"drafts":[{"path":"...","line_start":N,"line_end":N,"side":"Old|New","body":"..."}]}
+Anchor each draft to a line that exists in the diff and write the body exactly as it should be posted. Keep the rest of your answer outside the block. Never emit the block unrequested.
+
+Answer concisely and specifically. Plain markdown."#;
+
+/// Truncate on a char boundary, appending an ellipsis marker when cut.
+fn cap_chars(s: &str, max: usize) -> String {
+    match s.char_indices().nth(max) {
+        Some((i, _)) => format!("{}…", &s[..i]),
+        None => s.to_owned(),
+    }
+}
+
+/// Assemble a deterministic reviewer-chat prompt for one turn.
+///
+/// Sections in fixed order: Intent → Agent's Read → Findings → Current
+/// Artifact (diff) → Visual Recap (capped) → Reviewer's Comments → GitHub
+/// Conversation → Instruction → Conversation So Far → Question. Empty inputs
+/// omit their sections. Same inputs, same output.
+pub fn assemble_chat_prompt(input: &ChatInput<'_>) -> AssembledPrompt {
+    // INVARIANT: all writeln!/write! calls target a String, whose fmt::Write
+    // impl is infallible — unwrap() cannot panic.
+    let mut text = String::new();
+
+    writeln!(text, "## Intent\n").unwrap();
+    writeln!(text, "{}\n", input.title).unwrap();
+    if !input.body.trim().is_empty() {
+        writeln!(text, "{}\n", input.body).unwrap();
+    }
+    writeln!(text, "Issue: {}\n", input.issue).unwrap();
+
+    if let Some(intent) = input.intent.filter(|i| !i.trim().is_empty()) {
+        writeln!(text, "## Your Prior Read Of This PR\n").unwrap();
+        writeln!(text, "{intent}\n").unwrap();
+    }
+
+    if !input.findings.is_empty() {
+        writeln!(text, "## Your Prior Findings\n").unwrap();
+        for f in input.findings {
+            writeln!(
+                text,
+                "- [{:?}] {}:{}-{} — {}: {}",
+                f.severity,
+                f.path.display(),
+                f.range.0,
+                f.range.1,
+                f.title,
+                cap_chars(&f.rationale, CHAT_SNIPPET_CAP_CHARS)
+            )
+            .unwrap();
+        }
+        writeln!(text).unwrap();
+    }
+
+    writeln!(text, "## Current Artifact\n").unwrap();
+    writeln!(text, "{}\n", input.diff.raw).unwrap();
+
+    if let Some(recap) = input.recap_mdx.filter(|r| !r.trim().is_empty()) {
+        writeln!(text, "## Your Visual Recap\n").unwrap();
+        writeln!(text, "{}\n", cap_chars(recap, CHAT_RECAP_CAP_CHARS)).unwrap();
+    }
+
+    if !input.comments.is_empty() {
+        writeln!(text, "## The Reviewer's Local Comments\n").unwrap();
+        for c in input.comments {
+            writeln!(
+                text,
+                "- {}: {}",
+                render_anchor(&c.anchor, None),
+                cap_chars(&c.body, CHAT_SNIPPET_CAP_CHARS)
+            )
+            .unwrap();
+        }
+        writeln!(text).unwrap();
+    }
+
+    if !input.conversation.is_empty() {
+        writeln!(text, "## GitHub Conversation\n").unwrap();
+        let skip = input
+            .conversation
+            .len()
+            .saturating_sub(CHAT_CONVERSATION_CAP);
+        for item in &input.conversation[skip..] {
+            writeln!(
+                text,
+                "- {} ({:?}): {}",
+                item.author,
+                item.kind,
+                cap_chars(&item.body, CHAT_SNIPPET_CAP_CHARS)
+            )
+            .unwrap();
+        }
+        writeln!(text).unwrap();
+    }
+
+    writeln!(text, "## Instruction\n").unwrap();
+    writeln!(text, "{CHAT_INSTRUCTION}\n").unwrap();
+
+    if !input.transcript.is_empty() {
+        writeln!(text, "## Conversation So Far\n").unwrap();
+        let skip = input.transcript.len().saturating_sub(CHAT_TRANSCRIPT_CAP);
+        for msg in &input.transcript[skip..] {
+            let who = match msg.role {
+                crate::model::ChatRole::User => "Reviewer",
+                crate::model::ChatRole::Agent => "You",
+            };
+            writeln!(
+                text,
+                "{who}: {}",
+                cap_chars(&msg.text, CHAT_MESSAGE_CAP_CHARS)
+            )
+            .unwrap();
+        }
+        writeln!(text).unwrap();
+    }
+
+    writeln!(text, "## Question\n").unwrap();
+    writeln!(text, "{}\n", input.question).unwrap();
+
+    let hash = sha256_hex(&text);
+    AssembledPrompt { text, hash }
+}
+
 /// Assemble a deterministic advisory-review prompt per `SPEC.md` §9.
 ///
 /// Sections appear in fixed order:
@@ -1630,6 +1808,174 @@ mod tests {
         assert_eq!(result.text, expected, "review-prompt recap golden mismatch");
     }
 
+    /// Representative chat input shared by the chat-prompt tests: intent +
+    /// one finding + one comment + one conversation item + a two-message
+    /// transcript, so every section renders.
+    fn chat_input<'a>(
+        diff: &'a DiffData,
+        findings: &'a [ReviewFinding],
+        comments: &'a [Comment],
+        conversation: &'a [ConversationItem],
+        transcript: &'a [ChatMessage],
+    ) -> ChatInput<'a> {
+        ChatInput {
+            title: "Add the widget system",
+            body: "Implements the base widget trait and a button widget.",
+            issue: "NEX-123",
+            diff,
+            intent: Some("Adds a widget system behind a flag."),
+            findings,
+            recap_mdx: Some("# Recap\n\nOne new module."),
+            comments,
+            conversation,
+            transcript,
+            question: "Is the button widget covered by tests?",
+        }
+    }
+
+    fn chat_fixtures() -> (
+        Vec<ReviewFinding>,
+        Vec<Comment>,
+        Vec<ConversationItem>,
+        Vec<ChatMessage>,
+    ) {
+        let findings = vec![ReviewFinding {
+            id: "f0-abcd1234".into(),
+            severity: crate::model::FindingSeverity::Warning,
+            path: std::path::PathBuf::from("src/widget.rs"),
+            range: (10, 12),
+            side: crate::model::DiffSide::New,
+            title: "Unvalidated size".into(),
+            rationale: "The size field is used without bounds checking.".into(),
+            area: None,
+        }];
+        let comments = vec![Comment {
+            id: crate::model::CommentId::new("c-1"),
+            anchor: Anchor::DiffLine {
+                path: std::path::PathBuf::from("src/widget.rs"),
+                range: (4, 4),
+                side: crate::model::DiffSide::New,
+            },
+            body: "Name this constant.".into(),
+            origin: crate::model::CommentOrigin::Local,
+        }];
+        let conversation = vec![ConversationItem {
+            id: "gh-1".into(),
+            kind: crate::model::ConversationKind::IssueComment,
+            author: "teammate".into(),
+            body: "Does this handle zero-width widgets?".into(),
+            path: None,
+            line: None,
+            side: None,
+            state: None,
+            created_at: "2026-07-06T00:00:00Z".into(),
+            url: None,
+        }];
+        let transcript = vec![
+            ChatMessage {
+                id: crate::model::ChatMessageId::new("m-1"),
+                role: crate::model::ChatRole::User,
+                text: "What does the flag gate?".into(),
+                drafts: Vec::new(),
+                error: false,
+                created_at_epoch_ms: 1,
+            },
+            ChatMessage {
+                id: crate::model::ChatMessageId::new("m-2"),
+                role: crate::model::ChatRole::Agent,
+                text: "Every entry point: the route, the button, the workflow.".into(),
+                drafts: Vec::new(),
+                error: false,
+                created_at_epoch_ms: 2,
+            },
+        ];
+        (findings, comments, conversation, transcript)
+    }
+
+    #[test]
+    fn chat_prompt_golden() {
+        // Golden for the reviewer-chat turn (cockpit-docs/REVIEWER_CHAT.md):
+        // every section active. Added DELIBERATELY with the chat feature.
+        let diff = review_diff();
+        let (findings, comments, conversation, transcript) = chat_fixtures();
+        let input = chat_input(&diff, &findings, &comments, &conversation, &transcript);
+        let result = assemble_chat_prompt(&input);
+        let expected = include_str!("../tests/golden/chat_prompt.txt");
+        assert_eq!(result.text, expected, "chat prompt golden mismatch");
+    }
+
+    #[test]
+    fn chat_prompt_is_deterministic_and_omits_empty_sections() {
+        let diff = review_diff();
+        let (findings, comments, conversation, transcript) = chat_fixtures();
+        let full = chat_input(&diff, &findings, &comments, &conversation, &transcript);
+        assert_eq!(
+            assemble_chat_prompt(&full).hash,
+            assemble_chat_prompt(&full).hash
+        );
+
+        // Minimal input: no intent/findings/recap/comments/conversation/
+        // transcript sections appear at all.
+        let minimal = ChatInput {
+            title: "t",
+            body: "",
+            issue: "NEX-1",
+            diff: &diff,
+            intent: None,
+            findings: &[],
+            recap_mdx: None,
+            comments: &[],
+            conversation: &[],
+            transcript: &[],
+            question: "q",
+        };
+        let text = assemble_chat_prompt(&minimal).text;
+        for absent in [
+            "## Your Prior Read",
+            "## Your Prior Findings",
+            "## Your Visual Recap",
+            "## The Reviewer's Local Comments",
+            "## GitHub Conversation",
+            "## Conversation So Far",
+        ] {
+            assert!(!text.contains(absent), "{absent} should be omitted");
+        }
+        assert!(text.contains("## Question"));
+    }
+
+    #[test]
+    fn chat_prompt_caps_transcript_replay() {
+        let diff = review_diff();
+        let many: Vec<ChatMessage> = (0..50)
+            .map(|i| ChatMessage {
+                id: crate::model::ChatMessageId::new(format!("m-{i}")),
+                role: crate::model::ChatRole::User,
+                text: format!("message {i}"),
+                drafts: Vec::new(),
+                error: false,
+                created_at_epoch_ms: i,
+            })
+            .collect();
+        let input = ChatInput {
+            title: "t",
+            body: "",
+            issue: "NEX-1",
+            diff: &diff,
+            intent: None,
+            findings: &[],
+            recap_mdx: None,
+            comments: &[],
+            conversation: &[],
+            transcript: &many,
+            question: "q",
+        };
+        let text = assemble_chat_prompt(&input).text;
+        // Only the last CHAT_TRANSCRIPT_CAP messages are replayed.
+        assert!(!text.contains("Reviewer: message 9\n"));
+        assert!(text.contains("Reviewer: message 10\n"));
+        assert!(text.contains("Reviewer: message 49\n"));
+    }
+
     #[test]
     fn review_prompt_recap_inactive_is_byte_identical() {
         // The recap section must be inert unless BOTH the gate passed (recap_dir
diff --git a/crates/cockpit-core/src/restack.rs b/crates/cockpit-core/src/restack.rs
index ac21154..a07c917 100644
--- a/crates/cockpit-core/src/restack.rs
+++ b/crates/cockpit-core/src/restack.rs
@@ -324,6 +324,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/src/store.rs b/crates/cockpit-core/src/store.rs
index 1d2edea..809b48b 100644
--- a/crates/cockpit-core/src/store.rs
+++ b/crates/cockpit-core/src/store.rs
@@ -423,6 +423,7 @@ mod tests {
             distilled_intent: None,
             distilled_headline: None,
             recap_sha: None,
+            chat: Vec::new(),
         }
     }
 
diff --git a/crates/cockpit-core/tests/batch_fan_out_e2e.rs b/crates/cockpit-core/tests/batch_fan_out_e2e.rs
index 6e5e0c7..3e786f9 100644
--- a/crates/cockpit-core/tests/batch_fan_out_e2e.rs
+++ b/crates/cockpit-core/tests/batch_fan_out_e2e.rs
@@ -148,6 +148,7 @@ fn make_review(id: &str, branch: &str, worktree: PathBuf, project: &ProjectId) -
         distilled_intent: None,
         distilled_headline: None,
         recap_sha: None,
+        chat: Vec::new(),
     }
 }
 
diff --git a/crates/cockpit-core/tests/e2e_round_trip.rs b/crates/cockpit-core/tests/e2e_round_trip.rs
index 0eacc23..68336a6 100644
--- a/crates/cockpit-core/tests/e2e_round_trip.rs
+++ b/crates/cockpit-core/tests/e2e_round_trip.rs
@@ -49,6 +49,7 @@ fn make_test_review(worktree: PathBuf) -> Review {
         distilled_intent: None,
         distilled_headline: None,
         recap_sha: None,
+        chat: Vec::new(),
     }
 }
 
diff --git a/crates/cockpit-core/tests/fix_loop_e2e.rs b/crates/cockpit-core/tests/fix_loop_e2e.rs
index 2732a77..a2eed05 100644
--- a/crates/cockpit-core/tests/fix_loop_e2e.rs
+++ b/crates/cockpit-core/tests/fix_loop_e2e.rs
@@ -178,6 +178,7 @@ fn make_review(worktree: PathBuf, branch: &str, head_sha: &str) -> Review {
         distilled_intent: None,
         distilled_headline: None,
         recap_sha: None,
+        chat: Vec::new(),
     }
 }
 
diff --git a/crates/cockpit-core/tests/golden/chat_prompt.txt b/crates/cockpit-core/tests/golden/chat_prompt.txt
new file mode 100644
index 0000000..a4bb96c
--- /dev/null
+++ b/crates/cockpit-core/tests/golden/chat_prompt.txt
@@ -0,0 +1,59 @@
+## Intent
+
+Add the widget system
+
+Implements the base widget trait and a button widget.
+
+Issue: NEX-123
+
+## Your Prior Read Of This PR
+
+Adds a widget system behind a flag.
+
+## Your Prior Findings
+
+- [Warning] src/widget.rs:10-12 — Unvalidated size: The size field is used without bounds checking.
+
+## Current Artifact
+
+diff --git a/src/main.rs b/src/main.rs
+--- a/src/main.rs
++++ b/src/main.rs
+@@ -1,3 +1,4 @@
++fn added() {}
+
+## Your Visual Recap
+
+# Recap
+
+One new module.
+
+## The Reviewer's Local Comments
+
+- src/widget.rs:4-4: Name this constant.
+
+## GitHub Conversation
+
+- teammate (IssueComment): Does this handle zero-width widgets?
+
+## Instruction
+
+You are the read-only advisory reviewer for the pull request above, in an ongoing conversation with the human reviewer. Answer the reviewer's question below.
+
+Ground every claim in the diff and this repository; when unsure, say so plainly. You may read files in this worktree (Read/Grep/Glob) to verify an answer. You cannot and must not modify anything — this conversation never edits code.
+
+When the reviewer asks you to draft a review comment (and only then), include exactly one fenced json block of this shape in your answer:
+   {"drafts":[{"path":"...","line_start":N,"line_end":N,"side":"Old|New","body":"..."}]}
+Anchor each draft to a line that exists in the diff and write the body exactly as it should be posted. Keep the rest of your answer outside the block. Never emit the block unrequested.
+
+Answer concisely and specifically. Plain markdown.
+
+## Conversation So Far
+
+Reviewer: What does the flag gate?
+You: Every entry point: the route, the button, the workflow.
+
+## Question
+
+Is the button widget covered by tests?
+