diff --git a/src/content/docs/cli/agent-conversations.mdx b/src/content/docs/cli/agent-conversations.mdx
index 76bd0dc99..e7d641f04 100644
--- a/src/content/docs/cli/agent-conversations.mdx
+++ b/src/content/docs/cli/agent-conversations.mdx
@@ -1,43 +1,146 @@
 ---
-title: "Agent conversations in the {{WARP_CLI}}"
+title: "Agent conversations in the Warp Agent CLI"
 description: >-
-  How agent conversations work in the {{WARP_CLI}}: streaming responses, tool
-  calls, code diffs, agent questions, task lists, and planning.
+  How agent conversations work in the Warp Agent CLI: streaming responses, tool
+  calls, diffs, task lists, plans, plus managing and resuming conversations.
 ---
 import { VARS } from '@data/vars';
 
-{/* TODO(cli-agent-conversations): draft per drafts/warp-cli-launch-plan.md — "cli/agent-conversations.mdx" section. Feature-doc content type. */}
-
-The {VARS.WARP_CLI} documentation for this page is in progress.
+When you send the agent a prompt in the {VARS.WARP_CLI}, the conversation appears in a scrollable transcript directly in your terminal. Responses stream in as they're generated, and everything the agent does along the way renders inline: tool calls, file diffs, questions, task lists, and plans. Conversations persist as you work: you can start new ones, browse history, compact context, and [resume after exiting](#managing-conversations).
 
 ## The conversation transcript
 
-{/* TODO(cli-agent-conversations): streaming responses, markdown and Mermaid rendering, scrolling. */}
+The agent's response streams into the transcript below your prompt as it's generated. Press `Ctrl+C` once to stop a response that's still in progress.
+
+Responses render as formatted Markdown, including syntax-highlighted code blocks and tables. A few terminal-specific caveats: Mermaid diagrams appear as their source in a code block, images show their alt text instead of rendering inline, and very long code blocks are truncated to keep the transcript responsive.
 
 ## Tool calls
 
-{/* TODO(cli-agent-conversations): how tool calls render (commands, file reads, etc.), expand/collapse. */}
+Every tool call the agent makes appears inline in the transcript, in the order it happens. Most render as a one-line status row with a state glyph and a label, such as reading a file or searching your codebase.
+
+Some tool calls render richer, interactive content instead:
+
+* **[Shell commands](/cli/shell-commands/)** - Run in your session and stream their output into the transcript.
+* **[File edits](#code-diffs)** - Expandable diffs with per-file headers.
+* **[Questions](#agent-questions)** - Interactive option prompts.
+* **[Plans](#planning)** - Inline plan documents.
+
+When a tool call needs your approval before it runs, an approval card appears in place of the input. See [permissions in the CLI](/cli/permissions-and-profiles/) for how approvals work.
 
 ## Code diffs
 
-{/* TODO(cli-agent-conversations): file-edit diffs, expanded by default, `e` to expand/collapse all. */}
+When the agent edits files, the edit renders as a diff in the transcript:
+
+* **Per-file sections** - Each edited file gets a header with the action and change counts.
+* **Multi-file edits** - Group under one summary header (for example, `Edited 3 files`) with each file's section nested beneath it.
+
+Diffs open fully expanded while the agent waits for your approval, and collapse to their headers once the edits are applied. Press `e` while the approval card is active to expand or collapse all diffs at once.
 
 ## Thinking blocks
 
-{/* TODO(cli-agent-conversations): collapsed reasoning blocks. */}
+For models that expose their reasoning, the agent's thinking streams into a collapsible section headed `Thinking...`, which collapses to a single `Thought for` row once it finishes.
 
 ## Agent questions
 
-{/* TODO(cli-agent-conversations): interactive question prompts, option selection, recommended answers. */}
+When the agent needs a decision from you mid-task, it asks a question with an interactive option list that temporarily replaces the input. Besides the arrow keys, you can press an option's number to choose it, and **Other…** accepts a free-form answer when the listed options don't fit.
+
+Options the agent suggests as the best fit are labeled `(recommended)`. Multi-select questions mark each chosen option with a check mark so you can pick several. When the agent asks several questions at once, the card advances through them.
 
 ## Task lists
 
-{/* TODO(cli-agent-conversations): agent task list rendering and progress. */}
+For multi-step work, the agent tracks its progress with a task list rendered directly in the transcript under a `≡ Tasks` header. Each task row starts with a status glyph:
+
+* `◌` - Pending
+* <code class="glyph-attention">●</code> - In progress
+* <code class="glyph-success">✓</code> - Completed
+
+Canceled tasks appear struck through. As the agent finishes tasks, compact confirmation rows such as `✓ Completed <task> (2/5)` mark progress without repeating the whole list.
+
+Task lists in the CLI reflect the same agent behavior as in the Warp app. Learn more about [how task lists work](/agent-platform/capabilities/task-lists/).
 
 ## Planning
 
-{/* TODO(cli-agent-conversations): /plan command and plan review flow; cross-link agent-platform/capabilities/planning. */}
+Use the `/plan` slash command, followed by a description of your task, to have the agent research first and produce a plan before making changes. You can also ask for a plan in natural language.
+
+The plan renders inline in the transcript as a formatted document with its own header row showing the plan's status, and an `Updated plan` entry appears when the agent revises it. Toggle the latest plan with `Ctrl+Shift+P`; while a plan is open, a hint below it shows the exact shortcut.
+
+Planning in the CLI follows the same workflow as the Warp app. See [Planning](/agent-platform/capabilities/planning/) for how plans are created, reviewed, and executed.
 
 ## Selecting and copying output
 
-{/* TODO(cli-agent-conversations): transcript selection, copy behavior, opt-in auto-copy on select. */}
+Select text anywhere in the transcript by dragging with the mouse. Releasing the mouse button copies the selection automatically.
+
+:::note
+In local sessions, the CLI writes directly to your system clipboard. Over SSH, it copies through your terminal using OSC 52 escape sequences (including from inside tmux), so the text lands on your local clipboard. Terminals that disable OSC 52 may ignore the copy.
+:::
+
+To copy an entire conversation as Markdown, use the `/export-to-clipboard` slash command, or use `/export-to-file` to save it to a file.
+
+## Managing conversations
+
+The CLI saves every agent conversation as you work, so closing your terminal never loses your progress.
+
+### Conversation persistence
+
+Conversations are saved to your Warp account automatically; there is no separate save step. Reopening a past conversation restores the full transcript, including agent responses, tool calls, and file-edit diffs.
+
+The CLI shows one conversation at a time: opening a past conversation replaces the current transcript, and the previous one remains available in history. You can't switch conversations while the current conversation is responding or a command is running; finish or stop it with `Ctrl+C` first.
+
+### Starting a new conversation
+
+Use any of these slash commands to clear the transcript and start a fresh conversation:
+
+* **`/new`** - Starts a new conversation.
+* **`/agent`** - Same as `/new`.
+* **`/clear`** - Same as `/new`.
+
+Each command accepts an optional prompt. For example, `/new write tests for the parser` starts a new conversation and immediately sends that prompt to the agent. To keep the history but reduce its size instead, use [`/compact`](#compacting-context).
+
+### Conversation history
+
+To browse and reopen past conversations, open the conversation menu in either of two ways:
+
+* **`/conversations`** - Run the slash command from the input.
+* **`←`** - Press the left arrow key when the input is empty and the cursor is at the start. The empty input shows a `← for conversations` hint as a reminder.
+
+The menu lists your Warp Agent conversations, including conversations started in the Warp app and completed cloud agent runs tied to your account. Start typing to filter the list by title. Opening a conversation restores its transcript and continues it.
+
+:::caution
+If the CLI can't load conversation data from Warp's servers, the menu shows conversations from your local device only and displays a warning. Conversations from other devices reappear once the connection recovers.
+:::
+
+To continue a cloud agent run from the CLI, or to hand the current conversation off to a cloud agent, see [cloud handoff and orchestration](/cli/cloud-and-orchestration/).
+
+### Compacting context
+
+Long conversations eventually fill the model's context window, which can degrade response quality. The `/compact` command frees up context by asking the agent to summarize the conversation history so far and carry only the summary forward.
+
+* **`/compact`** - Summarizes the conversation history with default instructions.
+* **`/compact <instructions>`** - Adds custom summarization instructions. For example, `/compact keep the API design decisions` tells the agent what to preserve in the summary.
+
+After compaction, a collapsed **Conversation summary** block appears in the transcript, and the conversation keeps working normally with the summary standing in for the compacted history.
+
+### Resuming conversations
+
+There are two ways to pick a past conversation back up:
+
+* **The conversation menu** - The quickest route, and the one to reach for most of the time. From a running session, open the [conversation menu](#conversation-history) with `/conversations` or `←`, filter to the conversation you want, and open it.
+* **`warp --resume`** - Reopens a specific conversation from your shell as the CLI starts, without going through the menu.
+
+When you exit the CLI with a non-empty conversation, it prints the `--resume` command for that conversation:
+
+```bash
+To continue this conversation, run:
+warp --resume YOUR_CONVERSATION_TOKEN
+```
+
+YOUR_CONVERSATION_TOKEN is a conversation identifier generated by Warp. Either route restores the full transcript, so you can continue prompting where you left off. For the complete list of command-line flags, see the [CLI reference](/cli/reference/).
+
+## Related pages
+
+* **[Permissions and profiles](/cli/permissions-and-profiles/)** - Approve, reject, or auto-approve the agent's tool calls.
+* **[Running shell commands](/cli/shell-commands/)** - How commands the agent (or you) run appear in the transcript.
+* **[Cloud handoff and orchestration](/cli/cloud-and-orchestration/)** - Hand off conversations to cloud agents and resume cloud runs.
+* **[{VARS.WARP_CLI} reference](/cli/reference/)** - Command-line flags, slash commands, and keyboard shortcuts.
+* **[Planning](/agent-platform/capabilities/planning/)** - The full planning workflow.
+* **[Task lists](/agent-platform/capabilities/task-lists/)** - How agents create and update task lists.
diff --git a/src/styles/warp-components.css b/src/styles/warp-components.css
index 0e15a39ce..38e3ce3e5 100644
--- a/src/styles/warp-components.css
+++ b/src/styles/warp-components.css
@@ -1561,3 +1561,27 @@ site-search #starlight__search .pagefind-ui__result-nested .pagefind-ui__result-
 :root[data-theme='light'] .warp-search-keyboard-hints__kbd {
   background: rgba(0, 0, 0, 0.06);
 }
+
+/* --------------------------------------------------------------------------
+   20. Terminal status glyphs — inline color for CLI transcript indicators
+   --------------------------------------------------------------------------
+   The Warp Agent CLI paints status glyphs with the active terminal theme's
+   ANSI colors — yellow while something is in progress, green once it
+   succeeds. Tinting the same glyph inline lets a docs bullet read the way
+   the transcript actually looks on screen.
+
+   Applied to `<code>` so the glyph keeps the inline-code chip that plain
+   Markdown backticks produce; only the foreground changes. Starlight's
+   mode-aware `-high` hue tokens are used instead of fixed hex values, so
+   the glyphs stay legible when the page flips between dark and light mode.
+
+   Color is decorative here: every glyph is paired with a text label, so
+   meaning never depends on color alone. */
+
+.sl-markdown-content code.glyph-attention {
+  color: var(--sl-color-orange-high);
+}
+
+.sl-markdown-content code.glyph-success {
+  color: var(--sl-color-green-high);
+}