From 87508735367bacada03d41771ca09f4e5170954f Mon Sep 17 00:00:00 2001
From: xiaolai <lixiaolai@gmail.com>
Date: Thu, 1 Oct 2026 01:09:27 +0800
Subject: [PATCH 1/2] fix(shell): keep the terminal mounted when it swaps sides

Swapping the terminal between top and bottom (or left and right) killed
every running shell, taking programs like a Claude session with it.

EditorArea rendered the panel in one of two child slots depending on
panelPosition, so a top<->bottom or left<->right swap moved it to the
other slot and React unmounted and remounted TerminalPanel. The panel's
unmount disposes all sessions, which kills their PTYs; the remount then
started fresh shells. Auto mode rarely hit it because bottom and right
share a slot.

The panel now always occupies one slot after the editor column; top and
left reverse the flex axis instead, so no node moves and nothing
remounts. Reordering keyed children instead would have made React move
the editor column, which reloads its iframes and drops focus. The cost
is that for top/left the Tab order reaches the panel after the editor
while it is drawn before; the two are independent landmarks.

A regression test swaps a stateful panel through every position and
asserts one mount; a WebKit test measures that each position still
draws the panel on its side of the editor.
---
 src/shell/EditorArea.test.tsx            | 40 +++++++++------
 src/shell/EditorArea.tsx                 | 19 ++++++--
 src/shell/panelPlacement.webkit.test.tsx | 62 ++++++++++++++++++++++++
 3 files changed, 100 insertions(+), 21 deletions(-)
 create mode 100644 src/shell/panelPlacement.webkit.test.tsx

diff --git a/src/shell/EditorArea.test.tsx b/src/shell/EditorArea.test.tsx
index 9410d88bf..7aab9ff3a 100644
--- a/src/shell/EditorArea.test.tsx
+++ b/src/shell/EditorArea.test.tsx
@@ -8,6 +8,7 @@
 
 import { render, screen } from "@testing-library/react";
 import { describe, it, expect } from "vitest";
+import { useEffect } from "react";
 import { EditorArea } from "./EditorArea";
 
 describe("EditorArea", () => {
@@ -84,21 +85,9 @@ describe("EditorArea", () => {
     expect(screen.getByTestId("editor")).toBeInTheDocument();
   });
 
-  it("uses column layout when panel is top", () => {
-    const { container } = render(
-      <EditorArea editor={<div>editor</div>} bottomBar={<div>bottom</div>} panel={<div>panel</div>} panelPosition="top" />
-    );
-    expect(container.firstChild as HTMLElement).toHaveStyle({ flexDirection: "column" });
-  });
-
-  it("uses row layout when panel is left", () => {
-    const { container } = render(
-      <EditorArea editor={<div>editor</div>} bottomBar={<div>bottom</div>} panel={<div>panel</div>} panelPosition="left" />
-    );
-    expect(container.firstChild as HTMLElement).toHaveStyle({ flexDirection: "row" });
-  });
-
-  it.each(["top", "left"] as const)("renders the panel before the editor for %s", (panelPosition) => {
+  // The panel is drawn FIRST for top/left by reversing the flex axis, not by
+  // moving it to another child slot — see the remount regression test below.
+  it.each([["top", "column-reverse"], ["left", "row-reverse"]] as const)("draws the panel before the editor for %s", (panelPosition, flexDirection) => {
     const { container } = render(
       <EditorArea
         editor={<div data-testid="editor">editor</div>}
@@ -108,7 +97,26 @@ describe("EditorArea", () => {
       />
     );
     const root = container.firstChild as HTMLElement;
-    expect(root.firstChild).toHaveAttribute("data-testid", "panel");
+    expect(root).toHaveStyle({ flexDirection });
+    expect(root.lastChild).toHaveAttribute("data-testid", "panel");
+  });
+
+  // Regression: swapping the terminal between top and bottom (or left and
+  // right) moved the panel to a different child slot, so React unmounted it —
+  // and the terminal's unmount kills every PTY, taking running programs (a
+  // Claude session) with it. The panel must survive every position change.
+  it("keeps the panel mounted across every position change", () => {
+    let mounts = 0;
+    function Panel() {
+      useEffect(() => { mounts += 1; }, []);
+      return <div data-testid="panel">panel</div>;
+    }
+    const area = (panelPosition: "top" | "bottom" | "left" | "right") => (
+      <EditorArea editor={<div>editor</div>} bottomBar={<div>bottom</div>} panel={<Panel />} panelPosition={panelPosition} />
+    );
+    const { rerender } = render(area("bottom"));
+    for (const position of ["top", "bottom", "left", "right", "top", "left"] as const) rerender(area(position));
+    expect(mounts).toBe(1);
   });
 
   it.each(["bottom", "right"] as const)("renders the panel after the editor for %s", (panelPosition) => {
diff --git a/src/shell/EditorArea.tsx b/src/shell/EditorArea.tsx
index 71965ad19..4b85d421b 100644
--- a/src/shell/EditorArea.tsx
+++ b/src/shell/EditorArea.tsx
@@ -4,9 +4,17 @@
  *
  * Per ADR-007, EditorArea is a pure layout helper — no store imports.
  * The dynamic panel positioning (top/bottom/left/right) is the only layout
- * intelligence: left/right use a row axis, top/left render the panel before
+ * intelligence: left/right use a row axis, top/left draw the panel before
  * the editor. Everything else is pass-through composition.
  *
+ * The panel always occupies ONE child slot, after the editor column; top/left
+ * reverse the flex axis instead of moving it. Moving it between slots made
+ * React unmount and remount it on every top↔bottom / left↔right swap, and the
+ * terminal's unmount kills its PTYs — a running Claude session died with it.
+ * The cost is that for top/left the DOM (and so Tab) order puts the panel after
+ * the editor while it is drawn before; the two are independent landmarks, so
+ * no reading sequence depends on that order.
+ *
  * The editor + bottom-bar are siblings inside a flex column so the
  * 40px bottom bar always hugs the editor. The panel arranges around
  * that column based on panelPosition.
@@ -56,21 +64,22 @@ export function EditorArea({
 }: EditorAreaProps) {
   const { t } = useTranslation();
 
-  // left/right share a row axis; top/left render the panel before the editor.
+  // left/right share a row axis; top/left draw the panel first by REVERSING
+  // the axis — never by moving the panel to another slot (see header).
   const horizontal = panelPosition === "left" || panelPosition === "right";
   const panelFirst = panelPosition === "top" || panelPosition === "left";
+  const axis = horizontal ? "row" : "column";
 
   const panelAxis = (
     <div
       style={{
         flex: 1,
         display: "flex",
-        flexDirection: horizontal ? "row" : "column",
+        flexDirection: panelFirst ? `${axis}-reverse` : axis,
         minHeight: 0,
         minWidth: 0,
       }}
     >
-      {panelFirst && panel}
       <div
         style={{
           flex: 1,
@@ -107,7 +116,7 @@ export function EditorArea({
           {bottomBar}
         </div>
       </div>
-      {!panelFirst && panel}
+      {panel}
     </div>
   );
 
diff --git a/src/shell/panelPlacement.webkit.test.tsx b/src/shell/panelPlacement.webkit.test.tsx
new file mode 100644
index 000000000..cc0351021
--- /dev/null
+++ b/src/shell/panelPlacement.webkit.test.tsx
@@ -0,0 +1,62 @@
+/**
+ * The panel is drawn on its side of the editor, measured in a real engine.
+ *
+ * EditorArea keeps the panel in ONE child slot and reverses the flex axis for
+ * top/left (moving it between slots remounted the terminal and killed its
+ * PTYs). jsdom has no layout, so only a real engine can show the reversed axis
+ * still puts the panel where the user asked for it.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { createRoot, type Root } from "react-dom/client";
+import { flushSync } from "react-dom";
+import "@/styles/index.css";
+import { EditorArea } from "./EditorArea";
+
+let root: Root | null = null;
+let host: HTMLElement | null = null;
+
+function mount(panelPosition: "top" | "bottom" | "left" | "right") {
+  host = document.createElement("div");
+  host.style.cssText = "width: 800px; height: 600px; display: flex";
+  document.body.append(host);
+  root = createRoot(host);
+  const horizontal = panelPosition === "left" || panelPosition === "right";
+  flushSync(() =>
+    root!.render(
+      <EditorArea
+        panelPosition={panelPosition}
+        editor={<div style={{ height: "100%" }} />}
+        bottomBar={<div style={{ height: 40 }} />}
+        panel={<div data-testid="panel" style={horizontal ? { width: 200 } : { height: 150 }} />}
+      />,
+    ),
+  );
+}
+
+afterEach(() => {
+  root?.unmount();
+  host?.remove();
+  root = null;
+  host = null;
+});
+
+const box = (sel: string) => (document.querySelector(sel) as HTMLElement).getBoundingClientRect();
+
+describe("panel placement (real engine, production EditorArea)", () => {
+  it("top: above the editor", () => {
+    mount("top");
+    expect(box('[data-testid="panel"]').bottom).toBeLessThanOrEqual(box('[role="main"]').top + 0.5);
+  });
+  it("bottom: below the editor and its bar", () => {
+    mount("bottom");
+    expect(box('[data-testid="panel"]').top).toBeGreaterThanOrEqual(box('[role="main"]').bottom - 0.5);
+  });
+  it("left: left of the editor", () => {
+    mount("left");
+    expect(box('[data-testid="panel"]').right).toBeLessThanOrEqual(box('[role="main"]').left + 0.5);
+  });
+  it("right: right of the editor", () => {
+    mount("right");
+    expect(box('[data-testid="panel"]').left).toBeGreaterThanOrEqual(box('[role="main"]').right - 0.5);
+  });
+});

From 11d8048381ca1da942c806b0ae7682527a5a1db1 Mon Sep 17 00:00:00 2001
From: xiaolai <lixiaolai@gmail.com>
Date: Thu, 1 Oct 2026 01:09:56 +0800
Subject: [PATCH 2/2] feat(terminal): render Claude/Codex transcripts beside
 the terminal

A terminal cannot draw a Markdown table or a Mermaid diagram, so the
replies where Claude Code or Codex answer with one arrive as pipes and
source. With Settings > Terminal > "Automatic transcript rendering" on
(off by default), VMark renders those replies beside the CLI.

Binding: each shell gets an opaque token (VMARK_TRANSCRIPT_TOKEN). A
SessionStart hook installed additively into ~/.claude/settings.json and
~/.codex/hooks.json records that CLI session's transcript path under the
token, so every terminal follows its own session, never "the most
recently modified transcript". Config is written only when the hook is
missing, and invalid user config is refused rather than replaced.
Disabling removes the enabled marker and every binding; closing or
restarting a shell deletes its binding.

Reading: terminal_transcript_read is bounded to the last 2 MiB, confined
to canonical paths under the CLIs' session directories, returns only
when the file changed, and treats a transcript announced but not yet
written as waiting. Parsing keeps complete JSONL lines and the last 100
assistant messages.

Rendering: Markdown becomes React elements (no raw HTML, links or remote
images); Mermaid renders with strict security and SVG labels into a
scriptless sandboxed iframe, then restores the editor's config. The
region sits right of the CLI in a top/bottom panel and below it in a
side panel, starts collapsed, and opens once per new reply that holds a
table or diagram. A pressed-state chart toggle in the tab bar shows or
hides it; hidden, it leaves the layout.

Documented in terminal.md and settings.md in all ten locales.
---
 .claude/feature-ledger.md                     |   2 +-
 scripts/feature-map.json                      |   2 +
 .../lib/docJoins/settingsDefaults.test.mjs    |  14 +-
 .../lib/docJoins/settingsDefaultsRowMap.mjs   |   2 +
 scripts/terminal-transcript-hook.test.mjs     |  26 ++
 .../resources/terminal-transcript-hook.cjs    |  19 ++
 src-tauri/src/command_registry.rs             |   4 +
 src-tauri/src/lib.rs                          |   3 +
 src-tauri/src/lib.test.rs                     |   1 +
 src-tauri/src/terminal_transcript/config.rs   |  57 ++++
 src-tauri/src/terminal_transcript/mod.rs      | 276 ++++++++++++++++++
 src-tauri/src/terminal_transcript/tests.rs    | 160 ++++++++++
 .../TerminalPanel.transcript.test.tsx         |  92 ++++++
 src/components/Terminal/TerminalPanel.tsx     |  24 +-
 .../Terminal/TerminalSessionsArea.test.tsx    |  24 ++
 .../Terminal/TerminalSessionsArea.tsx         |  14 +
 .../Terminal/TerminalTabBar.test.tsx          |  30 ++
 src/components/Terminal/TerminalTabBar.tsx    |  28 +-
 .../Terminal/TerminalTranscript.test.tsx      |  23 ++
 .../Terminal/TerminalTranscript.tsx           |  15 +
 .../Terminal/TranscriptMarkdown.test.tsx      |  32 ++
 .../Terminal/TranscriptMarkdown.tsx           |  34 +++
 .../Terminal/TranscriptMermaid.test.tsx       |  15 +
 src/components/Terminal/TranscriptMermaid.tsx |  24 ++
 src/components/Terminal/spawnPty.ts           |  12 +
 src/components/Terminal/terminal-panel.css    |  17 ++
 .../Terminal/terminal-transcript.css          |  28 ++
 .../Terminal/terminalSessionRegistry.ts       |   4 +
 .../terminalTranscriptLayout.webkit.test.tsx  |  90 ++++++
 .../Terminal/transcriptMarkdownTree.test.ts   |  30 ++
 .../Terminal/transcriptMarkdownTree.ts        |  22 ++
 .../Terminal/useRenderedTranscript.test.tsx   |  40 +++
 .../Terminal/useRenderedTranscript.ts         |  15 +
 .../Terminal/useTerminalShellLifecycle.ts     |   1 +
 .../Terminal/useTerminalTranscript.test.tsx   |  54 ++++
 .../Terminal/useTerminalTranscript.ts         |  53 ++++
 .../Terminal/useTranscriptAutoOpen.test.tsx   |  52 ++++
 .../Terminal/useTranscriptAutoOpen.ts         |  46 +++
 .../useTranscriptConfiguration.test.tsx       |  28 ++
 .../Terminal/useTranscriptConfiguration.ts    |  21 ++
 src/locales/de/settings.json                  |   8 +-
 src/locales/en/settings.json                  |   8 +-
 src/locales/es/settings.json                  |   8 +-
 src/locales/fr/settings.json                  |   8 +-
 src/locales/it/settings.json                  |   8 +-
 src/locales/ja/settings.json                  |   8 +-
 src/locales/ko/settings.json                  |   8 +-
 src/locales/pt-BR/settings.json               |   8 +-
 src/locales/zh-CN/settings.json               |   8 +-
 src/locales/zh-TW/settings.json               |   8 +-
 src/pages/settings/TerminalSettings.test.tsx  |   8 +
 src/pages/settings/TerminalSettings.tsx       |   4 +
 src/plugins/mermaid/plugin.test.ts            |   8 +
 src/plugins/mermaid/plugin.ts                 |  13 +-
 .../mermaid/strictRender.webkit.test.ts       |  28 ++
 .../terminal/transcriptBinding.test.ts        |  42 +++
 src/services/terminal/transcriptBinding.ts    |  31 ++
 src/stores/settingsStore/defaults.ts          |   1 +
 src/stores/settingsTypes/system.ts            |   1 +
 src/utils/terminalTranscript.test.ts          |  26 ++
 src/utils/terminalTranscript.ts               |  22 ++
 website/de/guide/settings.md                  |   1 +
 website/de/guide/terminal.md                  |  11 +
 website/es/guide/settings.md                  |   1 +
 website/es/guide/terminal.md                  |  11 +
 website/fr/guide/settings.md                  |   1 +
 website/fr/guide/terminal.md                  |  11 +
 website/guide/settings.md                     |   1 +
 website/guide/terminal.md                     |  11 +
 website/it/guide/settings.md                  |   1 +
 website/it/guide/terminal.md                  |  11 +
 website/ja/guide/settings.md                  |   1 +
 website/ja/guide/terminal.md                  |  11 +
 website/ko/guide/settings.md                  |   1 +
 website/ko/guide/terminal.md                  |  11 +
 website/pt-BR/guide/settings.md               |   1 +
 website/pt-BR/guide/terminal.md               |  11 +
 website/zh-CN/guide/settings.md               |   1 +
 website/zh-CN/guide/terminal.md               |  11 +
 website/zh-TW/guide/settings.md               |   1 +
 website/zh-TW/guide/terminal.md               |  11 +
 81 files changed, 1789 insertions(+), 29 deletions(-)
 create mode 100644 scripts/terminal-transcript-hook.test.mjs
 create mode 100644 src-tauri/resources/terminal-transcript-hook.cjs
 create mode 100644 src-tauri/src/terminal_transcript/config.rs
 create mode 100644 src-tauri/src/terminal_transcript/mod.rs
 create mode 100644 src-tauri/src/terminal_transcript/tests.rs
 create mode 100644 src/components/Terminal/TerminalPanel.transcript.test.tsx
 create mode 100644 src/components/Terminal/TerminalSessionsArea.test.tsx
 create mode 100644 src/components/Terminal/TerminalSessionsArea.tsx
 create mode 100644 src/components/Terminal/TerminalTranscript.test.tsx
 create mode 100644 src/components/Terminal/TerminalTranscript.tsx
 create mode 100644 src/components/Terminal/TranscriptMarkdown.test.tsx
 create mode 100644 src/components/Terminal/TranscriptMarkdown.tsx
 create mode 100644 src/components/Terminal/TranscriptMermaid.test.tsx
 create mode 100644 src/components/Terminal/TranscriptMermaid.tsx
 create mode 100644 src/components/Terminal/terminal-transcript.css
 create mode 100644 src/components/Terminal/terminalTranscriptLayout.webkit.test.tsx
 create mode 100644 src/components/Terminal/transcriptMarkdownTree.test.ts
 create mode 100644 src/components/Terminal/transcriptMarkdownTree.ts
 create mode 100644 src/components/Terminal/useRenderedTranscript.test.tsx
 create mode 100644 src/components/Terminal/useRenderedTranscript.ts
 create mode 100644 src/components/Terminal/useTerminalTranscript.test.tsx
 create mode 100644 src/components/Terminal/useTerminalTranscript.ts
 create mode 100644 src/components/Terminal/useTranscriptAutoOpen.test.tsx
 create mode 100644 src/components/Terminal/useTranscriptAutoOpen.ts
 create mode 100644 src/components/Terminal/useTranscriptConfiguration.test.tsx
 create mode 100644 src/components/Terminal/useTranscriptConfiguration.ts
 create mode 100644 src/plugins/mermaid/strictRender.webkit.test.ts
 create mode 100644 src/services/terminal/transcriptBinding.test.ts
 create mode 100644 src/services/terminal/transcriptBinding.ts
 create mode 100644 src/utils/terminalTranscript.test.ts
 create mode 100644 src/utils/terminalTranscript.ts

diff --git a/.claude/feature-ledger.md b/.claude/feature-ledger.md
index 283620fb4..a9118c374 100644
--- a/.claude/feature-ledger.md
+++ b/.claude/feature-ledger.md
@@ -2269,7 +2269,7 @@ The panel is lazy-imported in `src/App.tsx` behind a `FeatureErrorBoundary`; `sr
 - id: terminal-panel
 - feature: Integrated terminal
 - summary: A dockable shell panel on any side of the editor, toggled with Ctrl+`, with drag-resize, double-click maximize, and an empty-state hint when no session can be created.
-- capabilities: toggle via shortcut, View menu, status-bar button or command palette; opening moves the caret into the shell and closing returns it to the editor only when nothing else owns focus; docking top/bottom/left/right/auto/auto-flipped with aspect-ratio auto-placement (ratio ≥ 1.5 → right, ≤ 0.85 → bottom, 1440 px width threshold with 50 px hysteresis in between); drag-to-resize handle on the editor-adjacent edge; double-click on the handle toggles maximize to the 80% cap and back without rewriting the stored ratio; panelRatio persisted on drag end; deferred xterm activation until first show; ResizeObserver auto-refit; `terminal-resizing` class suppresses transitions during drag; localized empty-state hint `terminal.noWorkspaceSession`
+- capabilities: opt-in `terminal.transcriptPreview` automatically follows exact Claude/Codex SessionStart transcript bindings and renders assistant Markdown, selectable GFM tables and sandboxed Mermaid in a collapsible section beside the CLI (right of it in a top/bottom panel, below it in a side panel); collapsed by default and auto-opened once per new reply containing a table or Mermaid block; shown/hidden by a pressed-state chart toggle (`data-terminal-action="transcript"`) in the tab bar actions; hidden panels stop reads; toggle via shortcut, View menu, status-bar button or command palette; opening moves the caret into the shell and closing returns it to the editor only when nothing else owns focus; docking top/bottom/left/right/auto/auto-flipped with aspect-ratio auto-placement (ratio ≥ 1.5 → right, ≤ 0.85 → bottom, 1440 px width threshold with 50 px hysteresis in between); drag-to-resize handle on the editor-adjacent edge; double-click on the handle toggles maximize to the 80% cap and back without rewriting the stored ratio; panelRatio persisted on drag end; deferred xterm activation until first show; ResizeObserver auto-refit; `terminal-resizing` class suppresses transitions during drag; localized empty-state hint `terminal.noWorkspaceSession`
 - status: shipped-on
 - gate: always on; `terminal.position = "auto"`, `terminal.panelRatio = 0.4`; opening refused with a toast by `canOpenTerminal()` unless workspace mode is on or the active tab has a saved file
 - surfaces: menu id `toggle-terminal` (View menu, accel `Ctrl+\``); shortcut id `toggleTerminal` (default `Ctrl-\``); status-bar terminal button; command palette `view.toggleTerminal`; resize handle
diff --git a/scripts/feature-map.json b/scripts/feature-map.json
index cbfc9045c..f4229eb24 100644
--- a/scripts/feature-map.json
+++ b/scripts/feature-map.json
@@ -795,6 +795,8 @@
         "src-tauri/src/pty",
         "src-tauri/src/shell_env.rs",
         "src-tauri/src/shell_integration.rs",
+        "src-tauri/src/terminal_transcript",
+        "src/utils/terminalTranscript.ts",
         "src/lib/pty.ts",
         "src/services/terminalAttention.ts",
         "src/pages/settings/TerminalSettings.tsx",
diff --git a/scripts/lib/docJoins/settingsDefaults.test.mjs b/scripts/lib/docJoins/settingsDefaults.test.mjs
index 73590f399..bd2478764 100644
--- a/scripts/lib/docJoins/settingsDefaults.test.mjs
+++ b/scripts/lib/docJoins/settingsDefaults.test.mjs
@@ -79,6 +79,7 @@ const TERMINAL_DOC = `
 | Font Size | 10 – 24 px | 13 px | All |
 | Line Height | 1.0 – 2.0 | 1.2 | All |
 | Copy on Select | On / Off | Off | All |
+| Automatic transcript rendering | On / Off | Off | All |
 | Mac Option as Meta | On / Off | On | macOS |
 | Shell Integration | On / Off | On | macOS / Linux (zsh, bash) |
 | Remote Clipboard (OSC 52) | On / Off | On | All |
@@ -100,6 +101,7 @@ const TERMINAL_DEFAULTS = {
     fontSize: 13,
     lineHeight: 1.2,
     copyOnSelect: false,
+    transcriptPreview: false,
     macOptionIsMeta: true,
     shellIntegration: true,
     osc52Clipboard: true,
@@ -446,18 +448,18 @@ describe("compare", () => {
 // ---------------------------------------------------------------------------
 
 describe("terminal.md Default column ↔ defaults (formerly terminalDocDefaults.test.ts)", () => {
-  it("maps all eleven published terminal rows and finds them all correct against the shipped defaults", () => {
-    expect(TERMINAL_MAP).toHaveLength(11);
+  it("maps all twelve published terminal rows and finds them all correct against the shipped defaults", () => {
+    expect(TERMINAL_MAP).toHaveLength(12);
     const { findings, info } = compare(pagesFrom({ terminal: TERMINAL_DOC }), TERMINAL_DEFAULTS, TERMINAL_MAP);
     expect(findings).toEqual([]);
-    expect(info).toContain("terminal.md: 11 Default rows, 11 mapped");
+    expect(info).toContain("terminal.md: 12 Default rows, 12 mapped");
   });
 
   it("catches T9 — Option-as-Meta documented Off while the code ships true", () => {
     const doc = TERMINAL_DOC.replace("| Mac Option as Meta | On / Off | On |", "| Mac Option as Meta | On / Off | Off |");
     const { findings } = compare(pagesFrom({ terminal: doc }), TERMINAL_DEFAULTS, TERMINAL_MAP);
     expect(findings).toEqual([
-      'terminal.md:10 "Mac Option as Meta": doc says "Off", code (terminal.macOptionIsMeta) says "On"',
+      'terminal.md:11 "Mac Option as Meta": doc says "Off", code (terminal.macOptionIsMeta) says "On"',
     ]);
   });
 
@@ -551,7 +553,7 @@ describe("run", () => {
     const { findings, info } = await run({ root, paths, deps: { defaults, rowMap } });
     expect(findings).toEqual(['docs/settings.md:3 "Confirm quit": doc says "On", code (general.confirmQuit) says "Off"']);
     expect(info).toContain("defaults: injected by the caller");
-    expect(info).toContain("docs/terminal.md: 11 Default rows, 11 mapped");
+    expect(info).toContain("docs/terminal.md: 12 Default rows, 12 mapped");
   });
 
   it("LIVE: settings.md and terminal.md agree with defaults.ts in both directions", async () => {
@@ -564,7 +566,7 @@ describe("run", () => {
         .filter(Boolean)
         .map((m) => [m[1], { rows: Number(m[2]), mapped: Number(m[3]) }]),
     );
-    expect(rows["website/guide/terminal.md"]).toEqual({ rows: 11, mapped: 11 });
+    expect(rows["website/guide/terminal.md"]).toEqual({ rows: 12, mapped: 12 });
     expect(rows["website/guide/settings.md"].rows).toBeGreaterThan(100);
     expect(rows["website/guide/settings.md"].mapped).toBe(rows["website/guide/settings.md"].rows);
   });
diff --git a/scripts/lib/docJoins/settingsDefaultsRowMap.mjs b/scripts/lib/docJoins/settingsDefaultsRowMap.mjs
index 56fb76255..936daed6d 100644
--- a/scripts/lib/docJoins/settingsDefaultsRowMap.mjs
+++ b/scripts/lib/docJoins/settingsDefaultsRowMap.mjs
@@ -195,6 +195,7 @@ export const ROW_MAP = [
   settings("Cursor Style", "terminal.cursorStyle", { enum: { bar: "Bar", block: "Block", underline: "Underline" } }),
   settings("Cursor Blink", "terminal.cursorBlink", ON_OFF),
   settings("Copy on Select", "terminal.copyOnSelect", ON_OFF),
+  settings("Automatic transcript rendering", "terminal.transcriptPreview", ON_OFF),
   settings("WebGL Renderer", "terminal.useWebGL", ON_OFF),
   settings("Remote Clipboard (OSC 52)", "terminal.osc52Clipboard", ON_OFF),
   settings("Scrollback", "terminal.scrollback", "thousands"),
@@ -225,6 +226,7 @@ export const ROW_MAP = [
   terminal("Font Size", "terminal.fontSize", "px"),
   terminal("Line Height", "terminal.lineHeight", "number"),
   terminal("Copy on Select", "terminal.copyOnSelect", ON_OFF),
+  terminal("Automatic transcript rendering", "terminal.transcriptPreview", ON_OFF),
   terminal("Mac Option as Meta", "terminal.macOptionIsMeta", ON_OFF),
   terminal("Shell Integration", "terminal.shellIntegration", ON_OFF),
   terminal("Remote Clipboard (OSC 52)", "terminal.osc52Clipboard", ON_OFF),
diff --git a/scripts/terminal-transcript-hook.test.mjs b/scripts/terminal-transcript-hook.test.mjs
new file mode 100644
index 000000000..c3e19b397
--- /dev/null
+++ b/scripts/terminal-transcript-hook.test.mjs
@@ -0,0 +1,26 @@
+// WI-TP1.1: hook handshake without touching real CLI configuration.
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+import { mkdtempSync, copyFileSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+const token = 'cb28fc00-2c1b-4eaf-9d09-71d9d5392926';
+test('SessionStart binds exactly, is silent, and ignores disabled/foreign invocations', () => {
+  const root = mkdtempSync(join(tmpdir(), 'vmark-transcript-'));
+  try {
+    const script = join(root, 'terminal-transcript-hook.cjs');
+    copyFileSync('src-tauri/resources/terminal-transcript-hook.cjs', script);
+    const input = JSON.stringify({ hook_event_name: 'SessionStart', session_id: 'exact', transcript_path: '/tmp/exact.jsonl' });
+    const run = (env = {}) => spawnSync(process.execPath, [script], { env: { ...process.env, ...env }, input, encoding: 'utf8' });
+    const dest = join(root, token + '.json');
+    assert.equal(run({ VMARK_TRANSCRIPT_TOKEN: token }).status, 0);
+    assert.equal(existsSync(dest), false);
+    writeFileSync(join(root, 'enabled'), 'enabled');
+    assert.equal(run({ VMARK_TRANSCRIPT_TOKEN: '../invalid' }).status, 0);
+    assert.equal(existsSync(dest), false);
+    const result = run({ VMARK_TRANSCRIPT_TOKEN: token });
+    assert.equal(result.status, 0); assert.equal(result.stdout, ''); assert.equal(result.stderr, '');
+    assert.deepEqual(JSON.parse(readFileSync(dest, 'utf8')), { path: '/tmp/exact.jsonl', sessionId: 'exact' });
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});
diff --git a/src-tauri/resources/terminal-transcript-hook.cjs b/src-tauri/resources/terminal-transcript-hook.cjs
new file mode 100644
index 000000000..dff1c784b
--- /dev/null
+++ b/src-tauri/resources/terminal-transcript-hook.cjs
@@ -0,0 +1,19 @@
+// VMark SessionStart hook: never emits model context; outside VMark, no-op.
+const fs = require('node:fs');
+const path = require('node:path');
+const token = process.env.VMARK_TRANSCRIPT_TOKEN;
+const root = __dirname;
+if (!/^[a-f0-9-]{36}$/i.test(token || '') || !fs.existsSync(path.join(root, 'enabled'))) process.exit(0);
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; if (input.length > 65536) process.exit(0); });
+process.stdin.on('end', () => {
+  try {
+    const value = JSON.parse(input);
+    if (value.hook_event_name !== 'SessionStart' || typeof value.transcript_path !== 'string' || !path.isAbsolute(value.transcript_path)) return;
+    const dest = path.join(root, token + '.json');
+    const tmp = dest + '.' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify({ path: value.transcript_path, sessionId: value.session_id }), { mode: 0o600 });
+    fs.renameSync(tmp, dest);
+  } catch { /* Preview must never prevent the CLI from starting. */ }
+});
diff --git a/src-tauri/src/command_registry.rs b/src-tauri/src/command_registry.rs
index c8dc8d9d1..45d3fdb19 100644
--- a/src-tauri/src/command_registry.rs
+++ b/src-tauri/src/command_registry.rs
@@ -213,6 +213,10 @@ macro_rules! all_commands {
             pty::pty_pause,
             pty::pty_resume,
             shell_integration::prepare_shell_integration,
+            terminal_transcript::terminal_transcript_prepare,
+            terminal_transcript::terminal_transcript_configure,
+            terminal_transcript::terminal_transcript_read,
+            terminal_transcript::terminal_transcript_forget,
             system_fonts::list_system_font_families,
         ]
     };
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index d02690d18..80959dca3 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -66,6 +66,7 @@ mod system_fonts;
 mod tab_transfer;
 mod task;
 mod temp_html;
+mod terminal_transcript;
 mod trusted_html; // #1273 opt-in origin-isolated execution for standalone HTML
 mod watcher;
 mod webview_edit;
@@ -145,6 +146,8 @@ fn manage_state<R: tauri::Runtime>(builder: tauri::Builder<R>) -> tauri::Builder
         // WI-LX1.1: the workspace roots the user chose. Loaded from app data
         // and re-granted in `setup_app`; picks made before that are merged.
         .manage(workspace_grants::WorkspaceGrants::default())
+        // Serializes terminal-transcript CLI hook configuration writes.
+        .manage(terminal_transcript::TranscriptConfigState::default())
 }
 
 /// Build and run the Tauri application with all plugins, commands, and event handlers.
diff --git a/src-tauri/src/lib.test.rs b/src-tauri/src/lib.test.rs
index 27fed0801..2a34289da 100644
--- a/src-tauri/src/lib.test.rs
+++ b/src-tauri/src/lib.test.rs
@@ -82,5 +82,6 @@ fn manage_state_registers_every_backend_state() {
         crate::trusted_html::TrustedHtmlState,
         crate::close_to_tray::CloseToTrayState,
         crate::workspace_grants::WorkspaceGrants,
+        crate::terminal_transcript::TranscriptConfigState,
     );
 }
diff --git a/src-tauri/src/terminal_transcript/config.rs b/src-tauri/src/terminal_transcript/config.rs
new file mode 100644
index 000000000..2df2eb65d
--- /dev/null
+++ b/src-tauri/src/terminal_transcript/config.rs
@@ -0,0 +1,57 @@
+//! Additive, idempotent hook configuration. Invalid user config is never replaced.
+use crate::command_error::CommandError;
+use serde_json::{json, Value};
+use std::path::Path;
+/// Returns whether the config changed — callers write the file only then, so an
+/// already-configured CLI file is never rewritten (or reformatted).
+pub(super) fn add_hook(config: &mut Value, command: &str) -> Result<bool, CommandError> {
+    let object = config
+        .as_object_mut()
+        .ok_or_else(|| CommandError::invalid_input("CLI configuration must be an object"))?;
+    let hooks = object
+        .entry("hooks")
+        .or_insert_with(|| json!({}))
+        .as_object_mut()
+        .ok_or_else(|| CommandError::invalid_input("CLI hooks must be an object"))?;
+    let groups = hooks
+        .entry("SessionStart")
+        .or_insert_with(|| json!([]))
+        .as_array_mut()
+        .ok_or_else(|| CommandError::invalid_input("SessionStart hooks must be an array"))?;
+    if groups.iter().any(|group| {
+        group["hooks"]
+            .as_array()
+            .is_some_and(|hooks| hooks.iter().any(|hook| hook["command"] == command))
+    }) {
+        return Ok(false);
+    }
+    groups.push(json!({"hooks":[{"type":"command", "command": command, "timeout": 5}]}));
+    Ok(true)
+}
+pub(super) fn write_atomic(path: &Path, bytes: &[u8]) -> Result<(), CommandError> {
+    let temporary = path.with_extension(format!("{}.tmp", uuid::Uuid::new_v4()));
+    let mut options = std::fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.mode(0o600);
+    }
+    let mut file = options
+        .open(&temporary)
+        .map_err(|e| CommandError::io(e.to_string()))?;
+    {
+        use std::io::Write;
+        file.write_all(bytes)
+            .map_err(|e| CommandError::io(e.to_string()))?;
+    }
+    if let Ok(meta) = std::fs::metadata(path) {
+        std::fs::set_permissions(&temporary, meta.permissions())
+            .map_err(|e| CommandError::io(e.to_string()))?;
+    }
+    drop(file);
+    std::fs::rename(&temporary, path).map_err(|e| {
+        let _ = std::fs::remove_file(&temporary);
+        CommandError::io(e.to_string())
+    })
+}
diff --git a/src-tauri/src/terminal_transcript/mod.rs b/src-tauri/src/terminal_transcript/mod.rs
new file mode 100644
index 000000000..f7fe68293
--- /dev/null
+++ b/src-tauri/src/terminal_transcript/mod.rs
@@ -0,0 +1,276 @@
+//! Exact terminal-to-transcript bindings, delivered by CLI SessionStart hooks.
+//! Reads are bounded, canonical-root confined, and never touch PTY output.
+use crate::command_error::CommandError;
+use serde::Serialize;
+use serde_json::{json, Value};
+use std::io::{Read, Seek, SeekFrom};
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+use tauri::{AppHandle, Manager, Runtime, State};
+mod config;
+use config::add_hook;
+#[cfg(test)]
+mod tests;
+/// Serializes CLI config writes; a newer request supersedes queued older ones.
+#[derive(Default)]
+pub struct TranscriptConfigState(Arc<ConfigGate>);
+#[derive(Default)]
+struct ConfigGate {
+    lock: Mutex<()>,
+    revision: AtomicU64,
+}
+const LIMIT: u64 = 2 * 1024 * 1024;
+fn valid_token(token: &str) -> bool {
+    uuid::Uuid::parse_str(token).is_ok()
+}
+fn directory<R: Runtime>(app: &AppHandle<R>) -> Result<PathBuf, CommandError> {
+    app.path()
+        .app_local_data_dir()
+        .map(|p| p.join("terminal-transcripts"))
+        .map_err(|e| CommandError::io(e.to_string()))
+}
+/// Allocate an opaque binding for this shell, even if preview is currently off.
+#[tauri::command]
+pub fn terminal_transcript_prepare() -> String {
+    uuid::Uuid::new_v4().to_string()
+}
+/// Install additive CLI hooks, or deactivate installed hooks without deleting user config.
+#[tauri::command]
+pub async fn terminal_transcript_configure<R: Runtime>(
+    app: AppHandle<R>,
+    state: State<'_, TranscriptConfigState>,
+    enabled: bool,
+) -> Result<(), CommandError> {
+    let root = directory(&app)?;
+    let gate = Arc::clone(&state.0);
+    let generation = gate.revision.fetch_add(1, Ordering::SeqCst) + 1;
+    tauri::async_runtime::spawn_blocking(move || {
+        let _guard = gate
+            .lock
+            .lock()
+            .map_err(|e| CommandError::internal(e.to_string()))?;
+        if generation != gate.revision.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+        let (claude, codex) = cli_roots()?;
+        configure(&root, enabled, &claude, &codex)
+    })
+    .await
+    .map_err(|e| CommandError::internal(e.to_string()))?
+}
+fn configure(root: &Path, enabled: bool, claude: &Path, codex: &Path) -> Result<(), CommandError> {
+    std::fs::create_dir_all(root).map_err(|e| CommandError::io(e.to_string()))?;
+    let marker = root.join("enabled");
+    if !enabled {
+        if marker.exists() {
+            std::fs::remove_file(marker).map_err(|e| CommandError::io(e.to_string()))?;
+        }
+        return prune_bindings(root);
+    }
+    let script = root.join("terminal-transcript-hook.cjs");
+    std::fs::write(
+        &script,
+        include_str!("../../resources/terminal-transcript-hook.cjs"),
+    )
+    .map_err(|e| CommandError::io(e.to_string()))?;
+    let command = if cfg!(windows) {
+        format!("node \"{}\"", script.display())
+    } else {
+        format!("node '{}'", script.to_string_lossy().replace('\'', "'\\''"))
+    };
+    // Parse and validate BOTH before writing either, so malformed config is preserved.
+    let paths = [claude.join("settings.json"), codex.join("hooks.json")];
+    let mut configs = Vec::new();
+    for path in &paths {
+        let mut value: Value = if path.exists() {
+            serde_json::from_slice(
+                &std::fs::read(path).map_err(|e| CommandError::io(e.to_string()))?,
+            )
+            .map_err(|e| CommandError::invalid_input(e.to_string()))?
+        } else {
+            json!({})
+        };
+        if add_hook(&mut value, &command)? {
+            configs.push((path, value));
+        }
+    }
+    for (path, value) in configs {
+        std::fs::create_dir_all(path.parent().unwrap())
+            .map_err(|e| CommandError::io(e.to_string()))?;
+        config::write_atomic(
+            path,
+            &serde_json::to_vec_pretty(&value)
+                .map_err(|e| CommandError::internal(e.to_string()))?,
+        )?;
+    }
+    std::fs::write(marker, b"enabled").map_err(|e| CommandError::io(e.to_string()))?;
+    Ok(())
+}
+/// The Claude and Codex config roots, honouring their override variables.
+fn cli_roots() -> Result<(PathBuf, PathBuf), CommandError> {
+    let home =
+        dirs::home_dir().ok_or_else(|| CommandError::not_found("Home directory unavailable"))?;
+    Ok((
+        config_root("CLAUDE_CONFIG_DIR", home.join(".claude")),
+        config_root("CODEX_HOME", home.join(".codex")),
+    ))
+}
+fn config_root(key: &str, fallback: PathBuf) -> PathBuf {
+    std::env::var_os(key)
+        .filter(|s| !s.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or(fallback)
+}
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TranscriptSnapshot {
+    revision: String,
+    data: Option<String>,
+}
+/// A missing binding is a normal waiting state. Caller supplies no filesystem path.
+#[tauri::command]
+pub async fn terminal_transcript_read<R: Runtime>(
+    app: AppHandle<R>,
+    token: String,
+    revision: Option<String>,
+) -> Result<Option<TranscriptSnapshot>, CommandError> {
+    if !valid_token(&token) {
+        return Err(CommandError::invalid_input("Invalid transcript token"));
+    }
+    let root = directory(&app)?;
+    let (claude, codex) = cli_roots()?;
+    let roots = [claude.join("projects"), codex.join("sessions")];
+    tauri::async_runtime::spawn_blocking(move || {
+        read_snapshot(&root, &roots, &token, revision.as_deref())
+    })
+    .await
+    .map_err(|e| CommandError::internal(e.to_string()))?
+}
+/// Delete a shell's binding when its session closes or its shell is replaced.
+#[tauri::command]
+pub async fn terminal_transcript_forget<R: Runtime>(
+    app: AppHandle<R>,
+    token: String,
+) -> Result<(), CommandError> {
+    if !valid_token(&token) {
+        return Err(CommandError::invalid_input("Invalid transcript token"));
+    }
+    let root = directory(&app)?;
+    tauri::async_runtime::spawn_blocking(move || remove_binding(&root, &token))
+        .await
+        .map_err(|e| CommandError::internal(e.to_string()))?
+}
+fn remove_binding(root: &Path, token: &str) -> Result<(), CommandError> {
+    match std::fs::remove_file(root.join(format!("{token}.json"))) {
+        Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(CommandError::io(e.to_string())),
+        _ => Ok(()),
+    }
+}
+/// Disabling drops every binding; enabled shells re-bind on their next CLI start.
+fn prune_bindings(root: &Path) -> Result<(), CommandError> {
+    let entries = std::fs::read_dir(root).map_err(|e| CommandError::io(e.to_string()))?;
+    for entry in entries {
+        let path = entry.map_err(|e| CommandError::io(e.to_string()))?.path();
+        let is_binding = path.extension().is_some_and(|ext| ext == "json")
+            && path
+                .file_stem()
+                .and_then(|stem| stem.to_str())
+                .is_some_and(valid_token);
+        if is_binding {
+            std::fs::remove_file(&path).map_err(|e| CommandError::io(e.to_string()))?;
+        }
+    }
+    Ok(())
+}
+fn allowed_path(path: &Path, roots: &[PathBuf]) -> bool {
+    path.extension().is_some_and(|ext| ext == "jsonl")
+        && roots
+            .iter()
+            .any(|root| root.canonicalize().is_ok_and(|root| path.starts_with(root)))
+}
+fn read_snapshot(
+    root: &Path,
+    roots: &[PathBuf],
+    token: &str,
+    previous: Option<&str>,
+) -> Result<Option<TranscriptSnapshot>, CommandError> {
+    if !root.join("enabled").exists() {
+        return Ok(None);
+    }
+    let binding = root.join(format!("{token}.json"));
+    let bytes = match std::fs::read(&binding) {
+        Ok(bytes) => bytes,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(e) => return Err(CommandError::io(e.to_string())),
+    };
+    let value: Value =
+        serde_json::from_slice(&bytes).map_err(|e| CommandError::invalid_input(e.to_string()))?;
+    let path = value["path"]
+        .as_str()
+        .ok_or_else(|| CommandError::invalid_input("Missing transcript path"))?;
+    // The CLI announces its transcript before writing it: absent is still waiting.
+    let path = match Path::new(path).canonicalize() {
+        Ok(path) => path,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(e) => return Err(CommandError::io(e.to_string())),
+    };
+    if !allowed_path(&path, roots) {
+        return Err(CommandError::permission_denied(
+            "Transcript outside CLI session directories",
+        ));
+    }
+    let meta = std::fs::metadata(&path).map_err(|e| CommandError::io(e.to_string()))?;
+    let revision = format!(
+        "{}:{:?}:{}:{:?}",
+        path.display(),
+        value["sessionId"],
+        meta.len(),
+        meta.modified()
+    );
+    if Some(revision.as_str()) == previous {
+        return Ok(Some(TranscriptSnapshot {
+            revision,
+            data: None,
+        }));
+    }
+    Ok(Some(TranscriptSnapshot {
+        revision,
+        data: Some(read_tail(&path, LIMIT)?),
+    }))
+}
+fn read_tail(path: &Path, limit: u64) -> Result<String, CommandError> {
+    let mut file = std::fs::File::open(path).map_err(|e| CommandError::io(e.to_string()))?;
+    let meta = file
+        .metadata()
+        .map_err(|e| CommandError::io(e.to_string()))?;
+    if !meta.is_file() {
+        return Err(CommandError::invalid_input(
+            "Transcript must be a regular file",
+        ));
+    }
+    let start = meta.len().saturating_sub(limit);
+    let mut at_boundary = start == 0;
+    if start > 0 {
+        file.seek(SeekFrom::Start(start - 1))
+            .map_err(|e| CommandError::io(e.to_string()))?;
+        let mut preceding = [0u8; 1];
+        file.read_exact(&mut preceding)
+            .map_err(|e| CommandError::io(e.to_string()))?;
+        at_boundary = preceding[0] == b'\n';
+    }
+    file.seek(SeekFrom::Start(start))
+        .map_err(|e| CommandError::io(e.to_string()))?;
+    let mut bytes = Vec::new();
+    file.take(limit)
+        .read_to_end(&mut bytes)
+        .map_err(|e| CommandError::io(e.to_string()))?;
+    if !at_boundary {
+        if let Some(i) = bytes.iter().position(|b| *b == b'\n') {
+            bytes.drain(..=i);
+        } else {
+            bytes.clear();
+        }
+    }
+    Ok(String::from_utf8_lossy(&bytes).into_owned())
+}
diff --git a/src-tauri/src/terminal_transcript/tests.rs b/src-tauri/src/terminal_transcript/tests.rs
new file mode 100644
index 000000000..8cf7b5fbc
--- /dev/null
+++ b/src-tauri/src/terminal_transcript/tests.rs
@@ -0,0 +1,160 @@
+//! WI-TP1.1: preserve existing hooks; refuse arbitrary file reads.
+use super::*;
+#[test]
+fn merges_hooks_without_destroying_settings() {
+    let mut config = serde_json::json!({"theme":"dark", "hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"existing"}]}]}});
+    assert!(add_hook(&mut config, "node '/preview.cjs'").unwrap());
+    assert!(
+        !add_hook(&mut config, "node '/preview.cjs'").unwrap(),
+        "second add is a no-op"
+    );
+    assert_eq!(config["theme"], "dark");
+    assert_eq!(config["hooks"]["SessionStart"].as_array().unwrap().len(), 2);
+    assert_eq!(
+        config["hooks"]["SessionStart"][0]["hooks"][0]["command"],
+        "existing"
+    );
+}
+#[test]
+fn invalid_hook_config_is_not_overwritten() {
+    assert!(add_hook(&mut serde_json::json!({"hooks":false}), "test").is_err());
+}
+#[test]
+fn tokens_are_opaque_uuids() {
+    assert!(valid_token("cb28fc00-2c1b-4eaf-9d09-71d9d5392926"));
+    assert!(!valid_token("../secret"));
+    assert!(!valid_token(""));
+}
+#[test]
+fn canonical_paths_are_confined_to_session_roots() {
+    let root = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+    std::fs::create_dir_all(&root).unwrap();
+    let transcript = root.join("test.jsonl");
+    std::fs::write(&transcript, b"{}\n").unwrap();
+    assert!(allowed_path(
+        &transcript.canonicalize().unwrap(),
+        std::slice::from_ref(&root)
+    ));
+    assert!(!allowed_path(
+        Path::new("/etc/passwd"),
+        std::slice::from_ref(&root)
+    ));
+    assert!(!allowed_path(
+        &root.join("test.json"),
+        std::slice::from_ref(&root)
+    ));
+    std::fs::remove_dir_all(root).unwrap();
+}
+#[test]
+fn tail_reader_bounds_bytes_and_drops_split_records() {
+    let root = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+    std::fs::create_dir_all(&root).unwrap();
+    let path = root.join("tail.jsonl");
+    std::fs::write(&path, b"first\nsecond\npartial").unwrap();
+    assert_eq!(read_tail(&path, 12).unwrap(), "partial");
+    assert_eq!(read_tail(&path, 14).unwrap(), "second\npartial");
+    assert_eq!(read_tail(&path, 100).unwrap(), "first\nsecond\npartial");
+    std::fs::write(&path, b"truncated\n").unwrap();
+    assert_eq!(read_tail(&path, 100).unwrap(), "truncated\n");
+    std::fs::remove_dir_all(root).unwrap();
+}
+fn snapshot_fixture() -> (PathBuf, PathBuf, String) {
+    let base = std::env::temp_dir().join(uuid::Uuid::new_v4().to_string());
+    std::fs::create_dir_all(&base).unwrap();
+    // Canonical, so the macOS /var -> /private/var link does not defeat confinement.
+    let base = base.canonicalize().unwrap();
+    let root = base.join("bindings");
+    let sessions = base.join("sessions");
+    std::fs::create_dir_all(&root).unwrap();
+    std::fs::create_dir_all(&sessions).unwrap();
+    std::fs::write(root.join("enabled"), b"enabled").unwrap();
+    (root, sessions, uuid::Uuid::new_v4().to_string())
+}
+fn bind(root: &Path, token: &str, transcript: &Path) {
+    let binding = serde_json::json!({"path": transcript, "sessionId": "s"});
+    std::fs::write(root.join(format!("{token}.json")), binding.to_string()).unwrap();
+}
+#[test]
+fn snapshot_waits_until_enabled_bound_and_written() {
+    let (root, sessions, token) = snapshot_fixture();
+    let roots = [sessions.clone()];
+    assert!(read_snapshot(&root, &roots, &token, None)
+        .unwrap()
+        .is_none());
+    // The CLI announces its transcript before creating it.
+    let transcript = sessions.join("t.jsonl");
+    bind(&root, &token, &transcript);
+    assert!(read_snapshot(&root, &roots, &token, None)
+        .unwrap()
+        .is_none());
+    std::fs::write(&transcript, b"{\"a\":1}\n").unwrap();
+    let first = read_snapshot(&root, &roots, &token, None).unwrap().unwrap();
+    assert_eq!(first.data.as_deref(), Some("{\"a\":1}\n"));
+    let same = read_snapshot(&root, &roots, &token, Some(&first.revision))
+        .unwrap()
+        .unwrap();
+    assert!(same.data.is_none(), "unchanged revision skips the read");
+    std::fs::remove_file(root.join("enabled")).unwrap();
+    assert!(read_snapshot(&root, &roots, &token, None)
+        .unwrap()
+        .is_none());
+    std::fs::remove_dir_all(root.parent().unwrap()).unwrap();
+}
+#[test]
+fn snapshot_refuses_transcripts_outside_session_roots() {
+    let (root, sessions, token) = snapshot_fixture();
+    let outside = root.parent().unwrap().join("secret.jsonl");
+    std::fs::write(&outside, b"{}\n").unwrap();
+    bind(&root, &token, &outside);
+    let err = read_snapshot(&root, &[sessions], &token, None)
+        .err()
+        .unwrap();
+    assert!(format!("{err:?}").contains("outside"));
+    std::fs::remove_dir_all(root.parent().unwrap()).unwrap();
+}
+#[test]
+fn forgetting_and_disabling_remove_bindings_only() {
+    let (root, sessions, token) = snapshot_fixture();
+    bind(&root, &token, &sessions.join("t.jsonl"));
+    remove_binding(&root, &token).unwrap();
+    remove_binding(&root, &token).unwrap(); // idempotent
+    assert!(!root.join(format!("{token}.json")).exists());
+    bind(&root, &token, &sessions.join("t.jsonl"));
+    std::fs::write(root.join("unrelated.json"), b"{}").unwrap();
+    configure(&root, false, &root.join("claude"), &root.join("codex")).unwrap();
+    assert!(!root.join(format!("{token}.json")).exists());
+    assert!(!root.join("enabled").exists());
+    assert!(root.join("unrelated.json").exists());
+    std::fs::remove_dir_all(root.parent().unwrap()).unwrap();
+}
+#[test]
+fn enabling_leaves_already_configured_cli_files_untouched() {
+    let (root, _sessions, _token) = snapshot_fixture();
+    let base = root.parent().unwrap().to_path_buf();
+    let (claude, codex) = (base.join("claude"), base.join("codex"));
+    configure(&root, true, &claude, &codex).unwrap();
+    let settings = claude.join("settings.json");
+    let hooks = codex.join("hooks.json");
+    assert!(std::fs::read_to_string(&settings)
+        .unwrap()
+        .contains("terminal-transcript-hook.cjs"));
+    // Rewrite both compactly: a second enable must not reformat (i.e. rewrite) them.
+    for path in [&settings, &hooks] {
+        let value: serde_json::Value =
+            serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
+        std::fs::write(path, serde_json::to_vec(&value).unwrap()).unwrap();
+    }
+    let before = (
+        std::fs::read(&settings).unwrap(),
+        std::fs::read(&hooks).unwrap(),
+    );
+    configure(&root, true, &claude, &codex).unwrap();
+    assert_eq!(
+        before,
+        (
+            std::fs::read(&settings).unwrap(),
+            std::fs::read(&hooks).unwrap()
+        )
+    );
+    std::fs::remove_dir_all(base).unwrap();
+}
diff --git a/src/components/Terminal/TerminalPanel.transcript.test.tsx b/src/components/Terminal/TerminalPanel.transcript.test.tsx
new file mode 100644
index 000000000..78bfa70af
--- /dev/null
+++ b/src/components/Terminal/TerminalPanel.transcript.test.tsx
@@ -0,0 +1,92 @@
+/**
+ * TerminalPanel — rendered-transcript wiring (WI-TP3.3).
+ *
+ * The audit flagged the path from `terminal.transcriptPreview` through hook
+ * configuration and following to the tab-bar toggle and the region as an
+ * untested critical path: each piece is tested alone, so broken wiring here
+ * would pass them all. The hooks are mocked at their boundary; the panel's
+ * job is only to connect them.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, fireEvent, screen } from "@testing-library/react";
+
+const mocks = vi.hoisted(() => ({
+  rendered: vi.fn(),
+  toggle: vi.fn(),
+  state: { expanded: false, failed: false, messages: [] as { id: string; text: string }[] },
+}));
+
+vi.mock("./useTerminalSessions", () => ({
+  useTerminalSessions: () => ({ fit: vi.fn(), getActiveTerminal: () => null, getActiveSearchAddon: () => null, restartActiveSession: vi.fn() }),
+}));
+vi.mock("./useTerminalResize", () => ({ useTerminalResize: () => ({ isResizing: false, handleResizeStart: vi.fn() }) }));
+vi.mock("./TerminalSearchBar", () => ({ TerminalSearchBar: () => null }));
+vi.mock("@/plugins/mermaid", () => ({ renderMermaid: vi.fn().mockResolvedValue(null) }));
+vi.mock("./useTranscriptConfiguration", () => ({ useTranscriptConfiguration: (enabled: boolean) => (enabled ? "ready" : "pending") }));
+vi.mock("./useRenderedTranscript", () => ({
+  useRenderedTranscript: (...args: unknown[]) => {
+    mocks.rendered(...args);
+    return { ...mocks.state, toggle: mocks.toggle };
+  },
+}));
+vi.mock("./TerminalTabBar", () => ({
+  TerminalTabBar: (props: { transcript?: { expanded: boolean; controls: string; onToggle: () => void } }) =>
+    props.transcript ? (
+      <button data-testid="toggle" data-expanded={String(props.transcript.expanded)} data-controls={props.transcript.controls} onClick={props.transcript.onToggle} />
+    ) : (
+      <div data-testid="no-toggle" />
+    ),
+}));
+
+import { TerminalPanel } from "./TerminalPanel";
+import { useUIStore, resetTerminalSessionStore } from "@/stores/uiStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.state = { expanded: false, failed: false, messages: [] };
+  useUIStore.setState({ terminalVisible: true, terminalHeight: 200, terminalWidth: 300, effectiveTerminalPosition: "bottom" } as never);
+  // A real, visible session: the panel realigns a stale active id to null.
+  resetTerminalSessionStore();
+  useUIStore.getState().terminalCreateSession();
+  useSettingsStore.getState().updateTerminalSetting("transcriptPreview", false);
+});
+
+const activeId = () => {
+  const id = useUIStore.getState().terminal.activeSessionId;
+  expect(id).toEqual(expect.any(String));
+  return id;
+};
+
+describe("TerminalPanel — rendered transcript wiring", () => {
+  it("offers no toggle and no region while the setting is off, and follows nothing", () => {
+    render(<TerminalPanel />);
+    expect(screen.getByTestId("no-toggle")).toBeInTheDocument();
+    expect(document.querySelector(".terminal-transcript")).toBeNull();
+    expect(mocks.rendered).toHaveBeenLastCalledWith(activeId(), false, true, "pending");
+  });
+
+  it("follows the active session and offers a collapsed toggle once enabled", () => {
+    useSettingsStore.getState().updateTerminalSetting("transcriptPreview", true);
+    render(<TerminalPanel />);
+    expect(mocks.rendered).toHaveBeenLastCalledWith(activeId(), true, true, "ready");
+    expect(screen.getByTestId("toggle")).toHaveAttribute("data-expanded", "false");
+    expect(document.querySelector(".terminal-transcript")).toBeNull();
+    fireEvent.click(screen.getByTestId("toggle"));
+    expect(mocks.toggle).toHaveBeenCalledOnce();
+  });
+
+  it("renders the region the toggle controls, with the followed messages, while expanded", () => {
+    useSettingsStore.getState().updateTerminalSetting("transcriptPreview", true);
+    mocks.state = { expanded: true, failed: false, messages: [{ id: "m", text: "| A |\n| - |\n| 1 |" }] };
+    render(<TerminalPanel />);
+    const toggle = screen.getByTestId("toggle");
+    const region = document.querySelector(".terminal-transcript");
+    expect(toggle).toHaveAttribute("data-expanded", "true");
+    expect(region).not.toBeNull();
+    expect(region).toHaveAttribute("id", toggle.getAttribute("data-controls"));
+    expect(screen.getByRole("table")).toHaveTextContent("1");
+    // Beside the CLI for a bottom panel.
+    expect(document.querySelector(".terminal-sessions-container")).toHaveClass("terminal-sessions-container--row");
+  });
+});
diff --git a/src/components/Terminal/TerminalPanel.tsx b/src/components/Terminal/TerminalPanel.tsx
index 572746b16..7bdb632e7 100644
--- a/src/components/Terminal/TerminalPanel.tsx
+++ b/src/components/Terminal/TerminalPanel.tsx
@@ -6,7 +6,8 @@
  * drag-to-resize handle on the editor-adjacent edge. Hosts multiple terminal
  * sessions via useTerminalSessions, a search
  * bar, a tab bar (vertical for a top/bottom panel, horizontal for left/right),
- * and a context menu.
+ * a context menu, and — with terminal.transcriptPreview on — the rendered
+ * Claude/Codex transcript beside the CLI (TerminalSessionsArea).
  *
  * User interactions:
  *   - Drag the resize handle to adjust panel height (top/bottom) or width (left/right)
@@ -28,6 +29,8 @@
  *     dimensions in sync, and again from a ResizeObserver on the container so
  *     transition frames and cross-axis window resizes are not missed.
  *   - Adds .terminal-resizing class during drag to suppress CSS transitions.
+ *   - Transcript open state has one owner (useRenderedTranscript) shared by the
+ *     tab-bar toggle and the region, which mounts only while open.
  *
  * @coordinates-with useTerminalSessions.ts — manages xterm + PTY lifecycle
  * @coordinates-with useTerminalResize.ts — vertical/horizontal drag handle
@@ -36,9 +39,10 @@
  * @coordinates-with TerminalTabBar.tsx — session switching and management
  * @coordinates-with TerminalSearchBar.tsx — inline search within terminal output
  * @coordinates-with TerminalContextMenu.tsx — right-click copy/paste/clear/reset-display menu
+ * @coordinates-with TerminalSessionsArea.tsx — CLI grid beside the transcript region
  * @module components/Terminal/TerminalPanel
  */
-import { useRef, useEffect, useState, useCallback, type RefObject, type MutableRefObject } from "react";
+import { useRef, useEffect, useState, useCallback, useId, type RefObject, type MutableRefObject } from "react";
 import { useTranslation } from "react-i18next";
 import { useUIStore } from "@/stores/uiStore";
 import { useSettingsStore } from "@/stores/settingsStore";
@@ -56,6 +60,10 @@ import { TerminalTabBar } from "./TerminalTabBar";
 import { TerminalContextMenu } from "./TerminalContextMenu";
 import { TerminalSearchBar } from "./TerminalSearchBar";
 import { resolveBufferLineFromEvent } from "./resolveBufferLine";
+import { TerminalTranscript } from "./TerminalTranscript";
+import { TerminalSessionsArea } from "./TerminalSessionsArea";
+import { useTranscriptConfiguration } from "./useTranscriptConfiguration";
+import { useRenderedTranscript } from "./useRenderedTranscript";
 import "./terminal-panel.css";
 
 const NULL_REF: RefObject<HTMLDivElement | null> = { current: null };
@@ -63,6 +71,8 @@ const NULL_REF: RefObject<HTMLDivElement | null> = { current: null };
 /** Container for the integrated terminal with resize handle, tab bar, search bar, and context menu. */
 export function TerminalPanel() {
   const { t } = useTranslation("statusbar");
+  const transcriptEnabled = useSettingsStore(s => s.terminal.transcriptPreview);
+  const transcriptConfiguration = useTranscriptConfiguration(transcriptEnabled);
   const visible = useUIStore((s) => s.terminalVisible);
   const height = useUIStore((s) => s.terminalHeight);
   const width = useUIStore((s) => s.terminalWidth);
@@ -83,6 +93,8 @@ export function TerminalPanel() {
   }, []);
 
   const activeSessionId = useUIStore((s) => s.terminal.activeSessionId);
+  const transcript = useRenderedTranscript(activeSessionId, transcriptEnabled, visible, transcriptConfiguration);
+  const transcriptId = useId();
 
   const { fit, getActiveTerminal, getActiveSearchAddon, restartActiveSession } =
     useTerminalSessions(activated ? containerRef : NULL_REF, { onSearch });
@@ -241,7 +253,10 @@ export function TerminalPanel() {
         title={t("terminal.maximizeHint")}
       />
       <div className={`terminal-body ${isHorizontal ? "terminal-body--column" : ""}`}>
-        <div className="terminal-sessions-container">
+        <TerminalSessionsArea
+          position={position}
+          transcript={transcript.expanded ? <TerminalTranscript id={transcriptId} messages={transcript.messages} failed={transcript.failed} configuration={transcriptConfiguration} /> : null}
+        >
           <div
             ref={containerRef}
             className="terminal-container"
@@ -260,12 +275,13 @@ export function TerminalPanel() {
               onClose={() => setSearchVisible(false)}
             />
           )}
-        </div>
+        </TerminalSessionsArea>
         <TerminalTabBar
           onClose={handleClose}
           onRestart={handleRestart}
           orientation={isHorizontal ? "horizontal" : "vertical"}
           position={position}
+          {...(transcriptEnabled ? { transcript: { expanded: transcript.expanded, controls: transcriptId, onToggle: transcript.toggle } } : {})}
         />
       </div>
       {contextMenu && active && (
diff --git a/src/components/Terminal/TerminalSessionsArea.test.tsx b/src/components/Terminal/TerminalSessionsArea.test.tsx
new file mode 100644
index 000000000..e9f539a46
--- /dev/null
+++ b/src/components/Terminal/TerminalSessionsArea.test.tsx
@@ -0,0 +1,24 @@
+// WI-TP3.2: the transcript takes the panel's long axis; terminal overlays stay over the CLI.
+import { render } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { TerminalSessionsArea, transcriptAxis } from "./TerminalSessionsArea";
+describe("transcriptAxis", () => {
+  it.each([["bottom", "row"], ["top", "row"], ["left", "column"], ["right", "column"]] as const)("%s panel → %s", (position, axis) => {
+    expect(transcriptAxis(position)).toBe(axis);
+  });
+});
+describe("TerminalSessionsArea", () => {
+  it("keeps the CLI and its overlays in their own area beside the transcript", () => {
+    const { container } = render(<TerminalSessionsArea position="bottom" transcript={<aside data-testid="t" />}><div className="terminal-container" /><div className="overlay" /></TerminalSessionsArea>);
+    const area = container.querySelector(".terminal-sessions-container");
+    expect(area).toHaveClass("terminal-sessions-container--row");
+    const grid = area?.querySelector(":scope > .terminal-grid-area");
+    expect(grid?.querySelector(".terminal-container")).not.toBeNull();
+    expect(grid?.querySelector(".overlay")).not.toBeNull();
+    expect(grid?.nextElementSibling).toHaveAttribute("data-testid", "t");
+  });
+  it("adds no split modifier without a transcript", () => {
+    const { container } = render(<TerminalSessionsArea position="right" transcript={null}><div /></TerminalSessionsArea>);
+    expect(container.querySelector(".terminal-sessions-container")?.className).toBe("terminal-sessions-container");
+  });
+});
diff --git a/src/components/Terminal/TerminalSessionsArea.tsx b/src/components/Terminal/TerminalSessionsArea.tsx
new file mode 100644
index 000000000..319aaf0ad
--- /dev/null
+++ b/src/components/Terminal/TerminalSessionsArea.tsx
@@ -0,0 +1,14 @@
+/** The terminal grid beside its optional rendered transcript. The transcript takes the
+ * panel's long axis — to the right in a top/bottom panel, below in a left/right one —
+ * and the grid's overlays (search bar, empty state) stay inside the grid's own area.
+ * @module components/Terminal/TerminalSessionsArea */
+import type { ReactNode } from "react";
+import type { EffectiveTerminalPosition } from "@/stores/uiStore";
+import { isHorizontalTerminalAxis } from "./useTerminalPosition";
+export function transcriptAxis(position: EffectiveTerminalPosition): "row" | "column" {
+  return isHorizontalTerminalAxis(position) ? "column" : "row";
+}
+export function TerminalSessionsArea({ position, transcript, children }: { position: EffectiveTerminalPosition; transcript: ReactNode; children: ReactNode }) {
+  const className = transcript ? `terminal-sessions-container terminal-sessions-container--${transcriptAxis(position)}` : "terminal-sessions-container";
+  return <div className={className}><div className="terminal-grid-area">{children}</div>{transcript}</div>;
+}
diff --git a/src/components/Terminal/TerminalTabBar.test.tsx b/src/components/Terminal/TerminalTabBar.test.tsx
index 240c912d0..d567ccdfe 100644
--- a/src/components/Terminal/TerminalTabBar.test.tsx
+++ b/src/components/Terminal/TerminalTabBar.test.tsx
@@ -470,6 +470,35 @@ describe("TerminalTabBar", () => {
       expect(screen.getByTitle("🇯🇵 tokyo").textContent).toBe("🇯🇵");
     });
   });
+  // WI-TP3.3: the rendered-transcript toggle lives with the other panel actions.
+  describe("transcript toggle", () => {
+    it("is absent while transcript rendering is off", () => {
+      const { container } = renderWithSession();
+      expect(container.querySelector('[data-terminal-action="transcript"]')).toBeNull();
+    });
+
+    it("sits in the actions group as a chart toggle that names itself and shows its state", () => {
+      useUIStore.getState().terminalCreateSession();
+      const onToggle = vi.fn();
+      const { container, rerender } = render(
+        <TerminalTabBar onClose={onClose} onRestart={onRestart} position="bottom" transcript={{ expanded: false, controls: "tx", onToggle }} />,
+      );
+      const button = container.querySelector('.terminal-tab-bar-actions [data-terminal-action="transcript"]')!;
+      expect(button).toHaveAttribute("aria-label", "Rendered Transcript");
+      expect(button).toHaveAttribute("title", "Rendered Transcript");
+      expect(button).toHaveAttribute("aria-pressed", "false");
+      expect(button).not.toHaveAttribute("aria-controls");
+      expect(button.querySelector("svg")).toHaveClass("lucide-chart-column");
+      fireEvent.click(button);
+      expect(onToggle).toHaveBeenCalledOnce();
+      rerender(
+        <TerminalTabBar onClose={onClose} onRestart={onRestart} position="right" orientation="horizontal" transcript={{ expanded: true, controls: "tx", onToggle }} />,
+      );
+      expect(button).toHaveAttribute("aria-pressed", "true");
+      expect(button).toHaveAttribute("aria-controls", "tx");
+      expect(button.querySelector("svg")).toHaveClass("lucide-chart-column");
+    });
+  });
 });
 
 // WI-UI3.6 (R13) — a dead session announces its state, and shows a glyph.
@@ -489,4 +518,5 @@ describe("dead session indicator (R13)", () => {
     expect(tab!.getAttribute("aria-label")).toContain("(exited)");
     expect(tab!.querySelector(".terminal-tab-dead-glyph")).not.toBeNull();
   });
+
 });
diff --git a/src/components/Terminal/TerminalTabBar.tsx b/src/components/Terminal/TerminalTabBar.tsx
index ef5f1b248..5751b5cd6 100644
--- a/src/components/Terminal/TerminalTabBar.tsx
+++ b/src/components/Terminal/TerminalTabBar.tsx
@@ -22,8 +22,11 @@
  *     unreachable in production (T5).
  *   - Dead sessions (process exited) get a visual indicator via CSS class.
  *   - Uses getState() pattern for session creation to avoid stale closures.
+ *   - With transcript rendering on, the actions group also holds the
+ *     rendered-transcript toggle: a chart icon, pressed (accent wash) while the
+ *     transcript is open, with `aria-controls` naming the region (WI-TP3.3).
  *   - Every action button carries a stable `data-terminal-action`
- *     (`new`/`close`/`restart`/`swap`). The E2E terminal journeys drive these to
+ *     (`new`/`close`/`restart`/`swap`, and `transcript` when enabled). The E2E terminal journeys drive these to
  *     create and dispose their OWN session, so the values are an automation
  *     CONTRACT, not decoration: selecting by DOM order is fragile and by
  *     aria-label breaks under any non-English locale. Renaming or dropping one
@@ -35,7 +38,7 @@
  * @module components/Terminal/TerminalTabBar
  */
 import { useCallback, useState } from "react";
-import { Plus, Trash2, RotateCcw, ArrowLeftRight, ArrowUpDown } from "lucide-react";
+import { Plus, Trash2, RotateCcw, ArrowLeftRight, ArrowUpDown, ChartColumn } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { useUIStore, MAX_TERMINAL_SESSIONS, type EffectiveTerminalPosition } from "@/stores/uiStore";
 import type { TerminalSession } from "@/stores/uiStore/types";
@@ -54,6 +57,8 @@ interface TerminalTabBarProps {
   orientation?: "vertical" | "horizontal";
   /** Current effective panel position — drives the swap control's direction. */
   position: EffectiveTerminalPosition;
+  /** Present only while transcript rendering is enabled. */
+  transcript?: { expanded: boolean; controls: string; onToggle: () => void };
 }
 
 /**
@@ -91,8 +96,9 @@ function getTabDisplay(session: TerminalSession, displayName: string): string {
 }
 
 /** Renders numbered buttons for switching between terminal sessions plus create/close/restart controls. */
-export function TerminalTabBar({ onClose, onRestart, orientation = "vertical", position }: TerminalTabBarProps) {
+export function TerminalTabBar({ onClose, onRestart, orientation = "vertical", position, transcript }: TerminalTabBarProps) {
   const { t } = useTranslation("statusbar");
+  const { t: tSettings } = useTranslation("settings");
   // WI-TS3.1: the tab bar renders the VISIBLE population — the active
   // workspace scope's sessions ∪ window-scoped (everything with rail off).
   const sessions = useVisibleTerminalSessions();
@@ -141,6 +147,9 @@ export function TerminalTabBar({ onClose, onRestart, orientation = "vertical", p
   // The cap gates on what the user can SEE (D-T5's visible union) — a hidden
   // scope's sessions do not consume this scope's headroom.
   const isMaxed = sessions.length >= MAX_TERMINAL_SESSIONS;
+  // The transcript's strings live with its setting; asking for the namespace
+  // through the hook is what loads it (a bare `{ ns }` option renders the key).
+  const transcriptLabel = tSettings("terminal.transcript.title");
 
   return (
     <div className={`terminal-tab-bar ${orientation === "horizontal" ? "terminal-tab-bar--horizontal" : ""}`}>
@@ -198,6 +207,19 @@ export function TerminalTabBar({ onClose, onRestart, orientation = "vertical", p
       </div>
 
       <div className="terminal-tab-bar-actions">
+        {transcript && (
+          <button
+            className="vm-icon-btn vm-icon-btn--sm"
+            data-terminal-action="transcript"
+            onClick={transcript.onToggle}
+            title={transcriptLabel}
+            aria-label={transcriptLabel}
+            aria-pressed={transcript.expanded}
+            aria-controls={transcript.expanded ? transcript.controls : undefined}
+          >
+            <ChartColumn size={14} />
+          </button>
+        )}
         <button className="vm-icon-btn vm-icon-btn--sm" data-terminal-action="swap" onClick={handleSwap} title={t("terminal.swapPosition")} aria-label={t("terminal.swapPosition")}>
           <SwapIcon size={14} />
         </button>
diff --git a/src/components/Terminal/TerminalTranscript.test.tsx b/src/components/Terminal/TerminalTranscript.test.tsx
new file mode 100644
index 000000000..c218551d6
--- /dev/null
+++ b/src/components/Terminal/TerminalTranscript.test.tsx
@@ -0,0 +1,23 @@
+// WI-TP2.1 / WI-TP3.3: the rendered transcript region; its toggle lives in the tab bar.
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { TerminalTranscript } from "./TerminalTranscript";
+vi.mock("@/plugins/mermaid", () => ({ renderMermaid: vi.fn().mockResolvedValue(null) }));
+const TABLE = { id: "t", text: "| A | B |\n| --- | --- |\n| X | Y |" };
+describe("TerminalTranscript", () => {
+  it("is a named region the toggle can point at, rendering each reply", () => {
+    render(<TerminalTranscript id="tx" messages={[TABLE]} failed={false} configuration="ready" />);
+    const region = screen.getByRole("region", { name: "Rendered Transcript" });
+    expect(region).toHaveAttribute("id", "tx");
+    expect(screen.getByRole("table")).toHaveTextContent("X");
+  });
+  it("waits without an error while hook configuration is still pending", () => {
+    render(<TerminalTranscript id="tx" messages={[]} failed={false} configuration="pending" />);
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    expect(screen.getByText(/Waiting for a Claude\/Codex session/)).toBeInTheDocument();
+  });
+  it.each([["configuration", { failed: false, configuration: "failed" as const }], ["reading", { failed: true, configuration: "ready" as const }]])("reports a %s failure", (_label, state) => {
+    render(<TerminalTranscript id="tx" messages={[TABLE]} {...state} />);
+    expect(screen.getByRole("alert")).toHaveTextContent("Transcript unavailable");
+  });
+});
diff --git a/src/components/Terminal/TerminalTranscript.tsx b/src/components/Terminal/TerminalTranscript.tsx
new file mode 100644
index 000000000..71c6cd491
--- /dev/null
+++ b/src/components/Terminal/TerminalTranscript.tsx
@@ -0,0 +1,15 @@
+/** The rendered transcript region beside the CLI grid. Mounted only while open —
+ * its toggle lives in the tab bar and its state in useRenderedTranscript — so a
+ * collapsed transcript costs no space and renders no diagrams.
+ * @module components/Terminal/TerminalTranscript */
+import { useTranslation } from "react-i18next";
+import type { TranscriptMessage } from "@/utils/terminalTranscript";
+import { TranscriptMarkdown } from "./TranscriptMarkdown";
+import type { TranscriptConfigStatus } from "./useTranscriptConfiguration";
+import "./terminal-transcript.css";
+export function TerminalTranscript({ id, messages, failed, configuration }: { id: string; messages: TranscriptMessage[]; failed: boolean; configuration: TranscriptConfigStatus }) {
+  const { t } = useTranslation("settings");
+  return <section id={id} className="terminal-transcript" aria-label={t("terminal.transcript.title")}>
+    {configuration === "failed" || failed ? <p role="alert">{t("terminal.transcript.error")}</p> : messages.length ? messages.map(message => <article key={message.id}><TranscriptMarkdown text={message.text} /></article>) : <p>{t("terminal.transcript.waiting")}</p>}
+  </section>;
+}
diff --git a/src/components/Terminal/TranscriptMarkdown.test.tsx b/src/components/Terminal/TranscriptMarkdown.test.tsx
new file mode 100644
index 000000000..cffc79847
--- /dev/null
+++ b/src/components/Terminal/TranscriptMarkdown.test.tsx
@@ -0,0 +1,32 @@
+// WI-TP2.1: real tables, inert model-supplied markup, failure fallback.
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { TranscriptMarkdown } from "./TranscriptMarkdown";
+vi.mock("@/plugins/mermaid", () => ({ renderMermaid: vi.fn().mockResolvedValue(null) }));
+describe("TranscriptMarkdown", () => {
+  it("renders ordinary Markdown without using editor state", () => {
+    const { container } = render(<TranscriptMarkdown text={"# Heading\n\nText *emphasis* **strong** ~~removed~~ `inline`  \nbreak\n\n> quote\n\n1. ordered\n\n- unordered\n\n---\n\n```js\nconst x = 1;\n```\n\n[reference][r]\n\n[r]: https://example.com\n\n![alternate][i]\n\n[i]: https://example.com/image"} />);
+    expect(container.querySelector("em")).toHaveTextContent("emphasis");
+    expect(container.querySelector("del")).toHaveTextContent("removed");
+    expect(container.querySelector("blockquote")).toHaveTextContent("quote");
+    expect(container.querySelector("ol")).toHaveTextContent("ordered");
+    expect(container.querySelector("ul")).toHaveTextContent("unordered");
+    expect(container.querySelector("hr")).not.toBeNull();
+    expect(container.querySelector("br")).not.toBeNull();
+    expect(container.querySelector("pre")).toHaveTextContent("const x = 1;");
+    expect(container.querySelector("img, a")).toBeNull();
+  });
+  it("renders GFM tables with selectable text", () => {
+    render(<TranscriptMarkdown text={"| Name | Value |\n| --- | --- |\n| 中文 | 42 |"} />);
+    expect(screen.getByRole("table")).toHaveTextContent("中文");
+    expect(screen.getAllByRole("columnheader")).toHaveLength(2);
+  });
+  it("does not activate raw HTML, external images or javascript links", () => {
+    const { container } = render(<TranscriptMarkdown text={'<script>alert(1)</script>\n\n![image](https://example.com/i.png)\n\n[link](javascript:alert(1))'} />);
+    expect(container.querySelector("script, img, a")).toBeNull();
+  });
+  it("keeps invalid Mermaid readable", async () => {
+    render(<TranscriptMarkdown text={'```mermaid\ninvalid diagram\n```'} />);
+    expect(await screen.findByText("invalid diagram")).toBeInTheDocument();
+  });
+});
diff --git a/src/components/Terminal/TranscriptMarkdown.tsx b/src/components/Terminal/TranscriptMarkdown.tsx
new file mode 100644
index 000000000..c7984348b
--- /dev/null
+++ b/src/components/Terminal/TranscriptMarkdown.tsx
@@ -0,0 +1,34 @@
+/** Read-only transcript Markdown: React elements, no raw HTML or remote resources.
+ * @module components/Terminal/TranscriptMarkdown */
+import { useMemo, type ReactNode } from "react";
+import type { RootContent, PhrasingContent } from "mdast";
+import { TranscriptMermaid } from "./TranscriptMermaid";
+import { parseTranscriptMarkdown } from "./transcriptMarkdownTree";
+type Node = RootContent | PhrasingContent;
+function renderNode(node: Node, key: number): ReactNode {
+  const children = "children" in node ? node.children.map((child, index) => renderNode(child as Node, index)) : null;
+  switch (node.type) {
+    case "text": return node.value;
+    case "paragraph": return <p key={key}>{children}</p>;
+    case "heading": return <strong key={key} className="transcript-heading">{children}</strong>;
+    case "emphasis": return <em key={key}>{children}</em>;
+    case "strong": return <strong key={key}>{children}</strong>;
+    case "delete": return <del key={key}>{children}</del>;
+    case "inlineCode": return <code key={key}>{node.value}</code>;
+    case "code": return node.lang === "mermaid" ? <TranscriptMermaid key={key} source={node.value} /> : <pre key={key}><code>{node.value}</code></pre>;
+    case "blockquote": return <blockquote key={key}>{children}</blockquote>;
+    case "list": return node.ordered ? <ol key={key} start={node.start ?? 1}>{children}</ol> : <ul key={key}>{children}</ul>;
+    case "listItem": return <li key={key}>{children}</li>;
+    case "break": return <br key={key} />;
+    case "thematicBreak": return <hr key={key} />;
+    case "table": return <div key={key} className="transcript-table"><table><thead><tr>{node.children[0]?.children.map((cell, index) => <th key={index}>{cell.children.map(renderNode)}</th>)}</tr></thead><tbody>{node.children.slice(1).map((row, index) => <tr key={index}>{row.children.map((cell, index) => <td key={index}>{cell.children.map(renderNode)}</td>)}</tr>)}</tbody></table></div>;
+    case "link": case "linkReference": return <span key={key}>{children}</span>;
+    case "image": case "imageReference": return <span key={key}>{node.alt}</span>;
+    case "html": return <pre key={key}>{node.value}</pre>;
+    default: return null;
+  }
+}
+export function TranscriptMarkdown({ text }: { text: string }) {
+  const nodes = useMemo(() => parseTranscriptMarkdown(text), [text]);
+  return <div className="transcript-markdown">{nodes ? nodes.map(renderNode) : <pre>{text}</pre>}</div>;
+}
diff --git a/src/components/Terminal/TranscriptMermaid.test.tsx b/src/components/Terminal/TranscriptMermaid.test.tsx
new file mode 100644
index 000000000..232631f1a
--- /dev/null
+++ b/src/components/Terminal/TranscriptMermaid.test.tsx
@@ -0,0 +1,15 @@
+// WI-TP2.1: diagram isolation and intrinsic sizing within the terminal.
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { TranscriptMermaid } from "./TranscriptMermaid";
+vi.mock("@/plugins/mermaid", () => ({ renderMermaid: vi.fn().mockResolvedValue('<svg viewBox="0 0 600 100"><script>alert(1)</script><text>Diagram</text></svg>') }));
+describe("TranscriptMermaid", () => {
+  it("uses intrinsic aspect ratio and a scriptless sandbox", async () => {
+    render(<TranscriptMermaid source="graph TD; A-->B" />);
+    const frame = await screen.findByTitle("Mermaid diagram");
+    expect(frame).toHaveAttribute("sandbox", "");
+    expect(frame).toHaveStyle({ aspectRatio: "6" });
+    expect(frame.getAttribute("srcdoc")).not.toContain("<script");
+    expect(frame.getAttribute("srcdoc")).toContain("default-src");
+  });
+});
diff --git a/src/components/Terminal/TranscriptMermaid.tsx b/src/components/Terminal/TranscriptMermaid.tsx
new file mode 100644
index 000000000..8bbfc6367
--- /dev/null
+++ b/src/components/Terminal/TranscriptMermaid.tsx
@@ -0,0 +1,24 @@
+/** Lazy Mermaid preview in a scriptless sandbox. Invalid input remains readable.
+ * @module components/Terminal/TranscriptMermaid */
+import { useEffect, useId, useState } from "react";
+import { useTranslation } from "react-i18next";
+import DOMPurify from "dompurify";
+import { renderMermaid } from "@/plugins/mermaid";
+export function TranscriptMermaid({ source }: { source: string }) {
+  const { t } = useTranslation("settings");
+  const id = useId().replace(/[^a-zA-Z0-9]/g, "");
+  const [rendered, setRendered] = useState<{ source: string; html: string; ratio: number } | null>(null);
+  useEffect(() => {
+    let cancelled = false;
+    void renderMermaid(source, `transcript-${id}`, true).then(svg => {
+      if (!cancelled && svg) {
+        const clean = DOMPurify.sanitize(svg, { USE_PROFILES: { svg: true, svgFilters: true }, FORBID_TAGS: ["script", "image", "a"] });
+        const box = new DOMParser().parseFromString(clean, "image/svg+xml").documentElement.getAttribute("viewBox")?.trim().split(/[\s,]+/).map(Number);
+        const ratio = box && box.length === 4 && box[2] > 0 && box[3] > 0 && Number.isFinite(box[2] / box[3]) ? box[2] / box[3] : 2;
+        setRendered({ source, ratio, html: '<!doctype html><meta http-equiv="Content-Security-Policy" content="default-src &#39;none&#39;; style-src &#39;unsafe-inline&#39;"><style>body{margin:0}svg{max-width:100%;height:auto}</style>' + clean });
+      }
+    });
+    return () => { cancelled = true; };
+  }, [source, id]);
+  return rendered?.source === source ? <iframe sandbox="" title={t("terminal.transcript.diagram")} srcDoc={rendered.html} style={{ aspectRatio: rendered.ratio }} className="transcript-diagram" /> : <pre><code>{source}</code></pre>;
+}
diff --git a/src/components/Terminal/spawnPty.ts b/src/components/Terminal/spawnPty.ts
index 3f81e1aa3..2fae8026a 100644
--- a/src/components/Terminal/spawnPty.ts
+++ b/src/components/Terminal/spawnPty.ts
@@ -16,6 +16,10 @@
  *     for it lives there, next to the code that sets it.
  *   - The disposed() callback lets the caller abort if the session was removed
  *     while the async spawn was in flight.
+ *   - With a sessionId, the shell gets VMARK_TRANSCRIPT_TOKEN — an opaque token
+ *     the CLI SessionStart hook binds its transcript to, prepared even while
+ *     transcript rendering is off. A failed or superseded binding is logged and
+ *     the shell starts without one; it never blocks the shell.
  *   - Watermark-based flow control pauses the PTY when xterm.js's parser can't
  *     keep up with rapid output (e.g. AI tool redraws), preventing lag/freezes.
  *     Retained after WI-1.1: the binary Channel removed the IPC-encoding
@@ -25,8 +29,10 @@
  *
  * @coordinates-with useTerminalSessions.ts — calls spawnPty when starting a shell
  * @coordinates-with createTerminalInstance.ts — provides the xterm Terminal instance
+ * @coordinates-with services/terminal/transcriptBinding.ts — per-shell transcript token
  * @module components/Terminal/spawnPty
  */
+import { prepareTranscriptBinding } from "@/services/terminal/transcriptBinding";
 import { spawn, type IPty, type IEvent } from "@/lib/pty";
 import { invoke } from "@tauri-apps/api/core";
 import type { Terminal } from "@xterm/xterm";
@@ -101,6 +107,7 @@ export function resolveTerminalWorkspaceRoot(
 
 /** Options for spawning a PTY process connected to an xterm instance. */
 export interface SpawnOptions {
+  sessionId?: string;
   term: Terminal;
   cwd?: string;
   /** VMARK_WORKSPACE root, resolved ONCE by the caller before the spawn
@@ -196,6 +203,11 @@ export async function spawnPty(options: SpawnOptions): Promise<IPty> {
   if (disposed()) throw new Error("disposed before spawn");
 
   const env = buildBaseTerminalEnv(loginPath, workspaceRoot);
+  if (options.sessionId) {
+    try { env.VMARK_TRANSCRIPT_TOKEN = await prepareTranscriptBinding(options.sessionId); }
+    catch (error) { terminalLog("Transcript binding unavailable:", error); }
+    if (disposed()) throw new Error("disposed before transcript binding");
+  }
   // Observability (T1): make "why doesn't `git commit` open VMark?" answerable
   // from a dev-mode log instead of guesswork. Once per session, not per bell.
   terminalLog(
diff --git a/src/components/Terminal/terminal-panel.css b/src/components/Terminal/terminal-panel.css
index c0bfb020d..f64ed53e9 100644
--- a/src/components/Terminal/terminal-panel.css
+++ b/src/components/Terminal/terminal-panel.css
@@ -103,12 +103,29 @@
 
 .terminal-sessions-container {
   position: relative;
+  display: flex;
+  flex-direction: column;
   flex: 1;
   min-height: 0;
   min-width: 0;
   overflow: hidden;
 }
 
+/* A top/bottom panel is wide and short: its transcript goes beside the CLI.
+   Declared here, after the base rule, so it wins in any stylesheet load order. */
+.terminal-sessions-container--row {
+  flex-direction: row;
+}
+
+/* The CLI grid and its overlays (search bar, empty state); the rendered
+   transcript, when enabled, is its sibling (TerminalSessionsArea). */
+.terminal-grid-area {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+}
+
 .terminal-container {
   width: 100%;
   height: 100%;
diff --git a/src/components/Terminal/terminal-transcript.css b/src/components/Terminal/terminal-transcript.css
new file mode 100644
index 000000000..77e751427
--- /dev/null
+++ b/src/components/Terminal/terminal-transcript.css
@@ -0,0 +1,28 @@
+/* The transcript takes the panel's long axis: right of the CLI in a top/bottom
+   panel (--row), below it in a side panel (--column). See TerminalSessionsArea;
+   the container's direction itself lives in terminal-panel.css. Mounted only
+   while open; its toggle is in the tab bar. */
+.terminal-transcript {
+  flex: 0 1 50%;
+  min-height: 0;
+  min-width: 0;
+  overflow: auto;
+  color: var(--text-color);
+  background: var(--bg-color);
+  padding: var(--space-2) var(--space-4);
+  font-size: var(--font-size-sm);
+}
+.terminal-sessions-container--column > .terminal-transcript { border-top: var(--border-thin) solid var(--border-color); }
+.terminal-sessions-container--row > .terminal-transcript { flex-basis: 45%; border-left: var(--border-thin) solid var(--border-color); }
+.terminal-transcript article + article { border-top: var(--border-thin) solid var(--border-color); }
+.transcript-markdown { user-select: text; overflow-wrap: anywhere; }
+.transcript-markdown pre { white-space: pre-wrap; font-family: var(--font-mono); }
+.transcript-heading { display: block; margin-block: var(--space-2); }
+.transcript-table { overflow-x: auto; margin-block: var(--space-2); }
+.transcript-table table { border-collapse: collapse; width: 100%; }
+.transcript-table td, .transcript-table th {
+  border: var(--border-thin) solid var(--border-color);
+  padding: var(--space-1) var(--space-2);
+  text-align: start;
+}
+.transcript-diagram { border: none; width: 100%; height: auto; }
diff --git a/src/components/Terminal/terminalSessionRegistry.ts b/src/components/Terminal/terminalSessionRegistry.ts
index dfdc75654..aa0587d12 100644
--- a/src/components/Terminal/terminalSessionRegistry.ts
+++ b/src/components/Terminal/terminalSessionRegistry.ts
@@ -8,11 +8,14 @@
  * Key decisions:
  *   - switchVisibility starts a session's first shell but does not reset its
  *     terminal: startShell resets for every new PTY (#1471).
+ *   - removeSessionEntry releases the session's transcript binding, which
+ *     deletes its binding file (transcriptBinding.forgetTranscriptBinding).
  *
  * @coordinates-with useTerminalSessions.ts — sole caller
  * @coordinates-with useTerminalShellLifecycle.ts — startShell, which resets the terminal
  * @module components/Terminal/terminalSessionRegistry
  */
+import { forgetTranscriptBinding } from "@/services/terminal/transcriptBinding";
 import type { SessionEntry, SessionsRef } from "./terminalSessionTypes";
 import { fitAndResizePty } from "./fitAndResizePty";
 import { terminalLog } from "@/utils/debug";
@@ -46,6 +49,7 @@ export function removeSessionEntry(
       /* ignore */
     }
   }
+  forgetTranscriptBinding(sessionId);
   sessionsRef.current.delete(sessionId);
 }
 
diff --git a/src/components/Terminal/terminalTranscriptLayout.webkit.test.tsx b/src/components/Terminal/terminalTranscriptLayout.webkit.test.tsx
new file mode 100644
index 000000000..c2131fe8b
--- /dev/null
+++ b/src/components/Terminal/terminalTranscriptLayout.webkit.test.tsx
@@ -0,0 +1,90 @@
+/**
+ * The rendered transcript must share the terminal surface without covering it,
+ * measured in a real engine (rule 32: shared-surface chrome gets a geometry test).
+ *
+ * In a top/bottom panel — wide and short — the transcript sits to the RIGHT of
+ * the CLI; stacking it below would halve a height that is already scarce. In a
+ * side panel it sits BELOW. The grid's overlays (search bar) stay over the CLI,
+ * never over the transcript. Collapsed, the region is not mounted at all (its
+ * toggle lives in the tab bar), so the CLI gets the whole area back.
+ *
+ * Renders the production TerminalSessionsArea + TerminalTranscript with the real
+ * panel and transcript styles.
+ *
+ * Stylesheets load in TerminalPanel.tsx's order — the transcript's (imported by
+ * TerminalTranscript) BEFORE terminal-panel.css. Equal-specificity rules resolve
+ * by that order; importing them the other way round once hid a real bug here.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { createRoot, type Root } from "react-dom/client";
+import { flushSync } from "react-dom";
+import "@/styles/index.css";
+import type { EffectiveTerminalPosition } from "@/stores/uiStore";
+import "./TerminalSearchBar.css";
+import { TerminalTranscript } from "./TerminalTranscript";
+import { TerminalSessionsArea } from "./TerminalSessionsArea";
+import "./terminal-panel.css";
+
+let root: Root | null = null;
+let host: HTMLElement | null = null;
+
+function mount(position: EffectiveTerminalPosition, open = true) {
+  host = document.createElement("div");
+  const wide = position === "top" || position === "bottom";
+  host.style.cssText = `width: ${wide ? 900 : 420}px; height: ${wide ? 260 : 700}px; display: flex`;
+  document.body.append(host);
+  root = createRoot(host);
+  flushSync(() =>
+    root!.render(
+      <TerminalSessionsArea position={position} transcript={open ? <TerminalTranscript id="tx" messages={[]} failed={false} configuration="ready" /> : null}>
+        <div className="terminal-container" data-testid="grid" />
+        <div className="terminal-search-bar" data-testid="search">search</div>
+      </TerminalSessionsArea>,
+    ),
+  );
+}
+
+afterEach(() => {
+  root?.unmount();
+  host?.remove();
+  root = null;
+  host = null;
+});
+
+const box = (sel: string) => (document.querySelector(sel) as HTMLElement).getBoundingClientRect();
+
+describe("terminal transcript layout (real engine, production components)", () => {
+  it.each(["bottom", "top"] as const)("a %s panel puts the open transcript to the right of the CLI", async (position) => {
+    mount(position);
+    await new Promise(requestAnimationFrame);
+    const grid = box('[data-testid="grid"]');
+    const transcript = box(".terminal-transcript");
+    expect(grid.width).toBeGreaterThan(300);
+    expect(grid.right).toBeLessThanOrEqual(transcript.left + 0.5);
+    expect(Math.round(transcript.height)).toBe(Math.round(grid.height));
+  });
+
+  it.each(["right", "left"] as const)("a %s panel puts the open transcript below the CLI", async (position) => {
+    mount(position);
+    await new Promise(requestAnimationFrame);
+    const grid = box('[data-testid="grid"]');
+    const transcript = box(".terminal-transcript");
+    expect(grid.height).toBeGreaterThan(200);
+    expect(grid.bottom).toBeLessThanOrEqual(transcript.top + 0.5);
+  });
+
+  it("the search bar stays over the CLI, not the transcript", async () => {
+    mount("bottom");
+    await new Promise(requestAnimationFrame);
+    const search = box('[data-testid="search"]');
+    const transcript = box(".terminal-transcript");
+    expect(search.right).toBeLessThanOrEqual(transcript.left + 0.5);
+  });
+
+  it("collapsed, the transcript leaves the layout and the CLI takes the whole area", async () => {
+    mount("bottom", false);
+    await new Promise(requestAnimationFrame);
+    expect(document.querySelector(".terminal-transcript")).toBeNull();
+    expect(Math.round(box('[data-testid="grid"]').width)).toBe(900);
+  });
+});
diff --git a/src/components/Terminal/transcriptMarkdownTree.test.ts b/src/components/Terminal/transcriptMarkdownTree.test.ts
new file mode 100644
index 000000000..c58682232
--- /dev/null
+++ b/src/components/Terminal/transcriptMarkdownTree.test.ts
@@ -0,0 +1,30 @@
+// @vitest-environment node
+// WI-TP3.1: only replies the terminal cannot draw (tables, diagrams) open the transcript.
+import { describe, expect, it } from "vitest";
+import { hasRichTranscriptContent, parseTranscriptMarkdown } from "./transcriptMarkdownTree";
+describe("hasRichTranscriptContent", () => {
+  it.each([
+    ["a GFM table", "Intro\n\n| A | B |\n| --- | --- |\n| 1 | 2 |"],
+    ["a Mermaid fence", "```mermaid\ngraph TD; A-->B\n```"],
+    ["a tilde Mermaid fence", "~~~mermaid\nsequenceDiagram\n  A->>B: hi\n~~~"],
+    ["a table nested in a list", "- item\n\n  | A | B |\n  | - | - |\n  | 1 | 2 |"],
+    ["a table in a blockquote", "> | A |\n> | - |\n> | 1 |"],
+  ])("detects %s", (_label, text) => {
+    expect(hasRichTranscriptContent(text)).toBe(true);
+  });
+  it.each([
+    ["plain prose", "Just text, with a | pipe."],
+    ["a table inside a code block", "```\n| A | B |\n| --- | --- |\n```"],
+    ["a non-Mermaid code block", "```ts\nconst mermaid = 1;\n```"],
+    ["pipes without a delimiter row", "| A | B |\n| 1 | 2 |"],
+    ["an empty reply", ""],
+    ["CJK prose", "这是一个表格：没有分隔行"],
+  ])("ignores %s", (_label, text) => {
+    expect(hasRichTranscriptContent(text)).toBe(false);
+  });
+});
+describe("parseTranscriptMarkdown", () => {
+  it("returns the top-level block nodes", () => {
+    expect(parseTranscriptMarkdown("# H\n\ntext")?.map(node => node.type)).toEqual(["heading", "paragraph"]);
+  });
+});
diff --git a/src/components/Terminal/transcriptMarkdownTree.ts b/src/components/Terminal/transcriptMarkdownTree.ts
new file mode 100644
index 000000000..deaa1d7f2
--- /dev/null
+++ b/src/components/Terminal/transcriptMarkdownTree.ts
@@ -0,0 +1,22 @@
+/** One Markdown parser for the transcript: the renderer's tree, and the question of
+ * whether a reply holds anything the terminal grid cannot draw (tables, diagrams).
+ * @module components/Terminal/transcriptMarkdownTree */
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import type { Root, RootContent } from "mdast";
+const processor = unified().use(remarkParse).use(remarkGfm);
+/** Top-level nodes, or null when the text cannot be parsed (render it raw). */
+export function parseTranscriptMarkdown(text: string): RootContent[] | null {
+  try { return (processor.runSync(processor.parse(text)) as Root).children; }
+  catch { return null; }
+}
+function isRich(node: RootContent): boolean {
+  if (node.type === "table") return true;
+  if (node.type === "code") return node.lang === "mermaid";
+  return "children" in node && (node.children as RootContent[]).some(isRich);
+}
+/** True when the reply contains a GFM table or a Mermaid block, at any depth. */
+export function hasRichTranscriptContent(text: string): boolean {
+  return parseTranscriptMarkdown(text)?.some(isRich) ?? false;
+}
diff --git a/src/components/Terminal/useRenderedTranscript.test.tsx b/src/components/Terminal/useRenderedTranscript.test.tsx
new file mode 100644
index 000000000..dd82ed69d
--- /dev/null
+++ b/src/components/Terminal/useRenderedTranscript.test.tsx
@@ -0,0 +1,40 @@
+// WI-TP3.3: one owner for following + open state, shared by the tab-bar toggle and the region.
+import { act, renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useRenderedTranscript } from "./useRenderedTranscript";
+import type { TranscriptMessage } from "@/utils/terminalTranscript";
+const mocks = vi.hoisted(() => ({ follow: vi.fn(), view: { messages: [] as TranscriptMessage[], failed: false, loaded: true } }));
+vi.mock("./useTerminalTranscript", () => ({ useTerminalTranscript: mocks.follow }));
+beforeEach(() => {
+  mocks.view = { messages: [], failed: false, loaded: true };
+  mocks.follow.mockReset();
+  mocks.follow.mockImplementation(() => mocks.view);
+});
+describe("useRenderedTranscript", () => {
+  it("follows only while enabled, visible and configured — collapsed included", () => {
+    const { rerender } = renderHook((p: { enabled: boolean; visible: boolean; ready: boolean }) => useRenderedTranscript("s", p.enabled, p.visible, p.ready ? "ready" : "pending"), { initialProps: { enabled: true, visible: true, ready: true } });
+    expect(mocks.follow).toHaveBeenLastCalledWith("s", true);
+    rerender({ enabled: false, visible: true, ready: true });
+    expect(mocks.follow).toHaveBeenLastCalledWith("s", false);
+    rerender({ enabled: true, visible: false, ready: true });
+    expect(mocks.follow).toHaveBeenLastCalledWith("s", false);
+    rerender({ enabled: true, visible: true, ready: false });
+    expect(mocks.follow).toHaveBeenLastCalledWith("s", false);
+  });
+  it("starts collapsed, opens for a new rich reply, and toggles", () => {
+    const { result, rerender } = renderHook(() => useRenderedTranscript("s", true, true, "ready"));
+    expect(result.current.expanded).toBe(false);
+    mocks.view = { messages: [{ id: "1", text: "| A |\n| - |\n| 1 |" }], failed: false, loaded: true };
+    rerender();
+    expect(result.current.expanded).toBe(true);
+    act(() => result.current.toggle());
+    expect(result.current.expanded).toBe(false);
+    act(() => result.current.toggle());
+    expect(result.current.expanded).toBe(true);
+  });
+  it("is never expanded while rendering is disabled", () => {
+    const { result } = renderHook(() => useRenderedTranscript("s", false, true, "ready"));
+    act(() => result.current.toggle());
+    expect(result.current.expanded).toBe(false);
+  });
+});
diff --git a/src/components/Terminal/useRenderedTranscript.ts b/src/components/Terminal/useRenderedTranscript.ts
new file mode 100644
index 000000000..c3a70fbfb
--- /dev/null
+++ b/src/components/Terminal/useRenderedTranscript.ts
@@ -0,0 +1,15 @@
+/** The one owner of the rendered transcript's following and open state, shared by
+ * the tab-bar toggle (TerminalTabBar) and the region (TerminalTranscript). It keeps
+ * following while collapsed so a new reply with a table or diagram can open it.
+ * @module components/Terminal/useRenderedTranscript */
+import { useCallback } from "react";
+import { useTerminalTranscript } from "./useTerminalTranscript";
+import { useTranscriptAutoOpen } from "./useTranscriptAutoOpen";
+import type { TranscriptConfigStatus } from "./useTranscriptConfiguration";
+export function useRenderedTranscript(sessionId: string | null, enabled: boolean, visible: boolean, configuration: TranscriptConfigStatus) {
+  const { messages, failed, loaded } = useTerminalTranscript(sessionId, enabled && visible && configuration === "ready");
+  const [open, setOpen] = useTranscriptAutoOpen(sessionId, messages, loaded);
+  const expanded = enabled && open;
+  const toggle = useCallback(() => setOpen(!expanded), [setOpen, expanded]);
+  return { messages, failed, expanded, toggle };
+}
diff --git a/src/components/Terminal/useTerminalShellLifecycle.ts b/src/components/Terminal/useTerminalShellLifecycle.ts
index 3c0cb8e40..e828b6841 100644
--- a/src/components/Terminal/useTerminalShellLifecycle.ts
+++ b/src/components/Terminal/useTerminalShellLifecycle.ts
@@ -128,6 +128,7 @@ export function useTerminalShellLifecycle(
 
       try {
         const pty = await spawnPty({
+          sessionId,
           term: entry.instance.term,
           // Omitted when nothing resolved a directory — see spawnPty's cwd note.
           ...(cwd !== undefined ? { cwd } : {}),
diff --git a/src/components/Terminal/useTerminalTranscript.test.tsx b/src/components/Terminal/useTerminalTranscript.test.tsx
new file mode 100644
index 000000000..b5615c805
--- /dev/null
+++ b/src/components/Terminal/useTerminalTranscript.test.tsx
@@ -0,0 +1,54 @@
+// WI-TP1.2: polling is disabled when hidden; late reads cannot cross sessions.
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useTerminalTranscript } from "./useTerminalTranscript";
+const mocks = vi.hoisted(() => ({ invoke: vi.fn(), log: vi.fn() }));
+vi.mock("@/utils/debug", () => ({ terminalLog: mocks.log }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+vi.mock("@/services/terminal/transcriptBinding", () => ({ transcriptToken: (id: string) => id }));
+beforeEach(() => { vi.useFakeTimers(); mocks.invoke.mockReset(); mocks.log.mockClear(); });
+afterEach(() => vi.useRealTimers());
+describe("useTerminalTranscript", () => {
+  it("does no IO when disabled", () => {
+    mocks.invoke.mockClear();
+    renderHook(() => useTerminalTranscript("a", false));
+    expect(mocks.invoke).not.toHaveBeenCalled();
+  });
+  it("drops late responses when the session changes", async () => {
+    let resolveFirst: (value: unknown) => void = () => {};
+    mocks.invoke.mockImplementation((command: string, args?: { token?: string }) => {
+      if (command === "terminal_transcript_configure") return Promise.resolve();
+      if (args?.token === "a") return new Promise(resolve => { resolveFirst = resolve; });
+      return Promise.resolve({ revision: "b", data: JSON.stringify({ type: "assistant", uuid: "b", message: { role: "assistant", content: [{ type: "text", text: "second" }] } }) + "\n" });
+    });
+    const { result, rerender, unmount } = renderHook(({ id }) => useTerminalTranscript(id, true), { initialProps: { id: "a" } });
+    expect(mocks.invoke).toHaveBeenCalledWith("terminal_transcript_read", expect.objectContaining({ token: "a" }));
+    await act(async () => { await vi.advanceTimersByTimeAsync(5000); });
+    expect(mocks.invoke).toHaveBeenCalledTimes(1);
+    rerender({ id: "b" });
+    await act(async () => {});
+    expect(result.current.messages[0]?.text).toBe("second");
+    await act(async () => { resolveFirst({ revision: "a", data: "stale\n" }); });
+    expect(result.current.messages[0]?.text).toBe("second");
+    unmount();
+  });
+  it("logs a persistent read failure once, not on every poll", async () => {
+    mocks.invoke.mockRejectedValue(new Error("denied"));
+    const { result, unmount } = renderHook(() => useTerminalTranscript("a", true));
+    await act(async () => { await vi.advanceTimersByTimeAsync(3500); });
+    expect(mocks.invoke.mock.calls.length).toBeGreaterThan(2);
+    expect(result.current.failed).toBe(true);
+    expect(mocks.log).toHaveBeenCalledTimes(1);
+    unmount();
+  });
+  it("reports loaded only once a snapshot for the current binding has arrived", async () => {
+    let resolve: (value: unknown) => void = () => {};
+    mocks.invoke.mockImplementation(() => new Promise(r => { resolve = r; }));
+    const { result, unmount } = renderHook(() => useTerminalTranscript("a", true));
+    expect(result.current.loaded).toBe(false);
+    await act(async () => { resolve(null); });
+    expect(result.current.loaded).toBe(true);
+    expect(result.current.messages).toEqual([]);
+    unmount();
+  });
+});
diff --git a/src/components/Terminal/useTerminalTranscript.ts b/src/components/Terminal/useTerminalTranscript.ts
new file mode 100644
index 000000000..88ede41ab
--- /dev/null
+++ b/src/components/Terminal/useTerminalTranscript.ts
@@ -0,0 +1,53 @@
+/** Automatic, non-overlapping transcript following. Hidden/disabled panels do no reads.
+ * `loaded` turns true once a snapshot for the current binding has arrived (even an empty one).
+ * @module components/Terminal/useTerminalTranscript */
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { transcriptToken } from "@/services/terminal/transcriptBinding";
+import { parseTerminalTranscript, type TranscriptMessage } from "@/utils/terminalTranscript";
+import { terminalLog } from "@/utils/debug";
+interface Snapshot { revision: string; data: string | null }
+interface View { sessionId: string | null; messages: TranscriptMessage[]; failed: boolean; loaded: boolean }
+export function useTerminalTranscript(sessionId: string | null, active: boolean) {
+  const [view, setView] = useState<View>({ sessionId: null, messages: [], failed: false, loaded: false });
+  useEffect(() => {
+    if (!active || !sessionId) return;
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let revision: string | null = null;
+    let lastToken: string | undefined;
+    let failing = false;
+    const poll = async () => {
+      try {
+        const token = transcriptToken(sessionId);
+        if (token !== lastToken) {
+          lastToken = token;
+          revision = null;
+          if (!cancelled) setView({ sessionId, messages: [], failed: false, loaded: false });
+        }
+        if (!token) return;
+        const snapshot = await invoke<Snapshot | null>("terminal_transcript_read", { token, revision });
+        failing = false;
+        if (cancelled || transcriptToken(sessionId) !== token) return;
+        if (!snapshot) {
+          revision = null;
+          setView({ sessionId, messages: [], failed: false, loaded: true });
+        } else {
+          revision = snapshot.revision;
+          if (snapshot.data !== null) setView({ sessionId, messages: parseTerminalTranscript(snapshot.data), failed: false, loaded: true });
+        }
+      } catch (error) {
+        // Polling retries every second; log the transition, not every attempt.
+        if (!failing) terminalLog("Transcript read failed:", error);
+        failing = true;
+        revision = null;
+        if (!cancelled) setView({ sessionId, messages: [], failed: true, loaded: false });
+      } finally {
+        if (!cancelled) timer = setTimeout(poll, 1000);
+      }
+    };
+    void poll();
+    return () => { cancelled = true; if (timer) clearTimeout(timer); };
+  }, [sessionId, active]);
+  return view.sessionId === sessionId ? view : { sessionId, messages: [], failed: false, loaded: false };
+}
diff --git a/src/components/Terminal/useTranscriptAutoOpen.test.tsx b/src/components/Terminal/useTranscriptAutoOpen.test.tsx
new file mode 100644
index 000000000..bce82efcb
--- /dev/null
+++ b/src/components/Terminal/useTranscriptAutoOpen.test.tsx
@@ -0,0 +1,52 @@
+// WI-TP3.1: collapsed by default; each new rich reply opens once; a user's collapse is respected.
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { useTranscriptAutoOpen } from "./useTranscriptAutoOpen";
+import type { TranscriptMessage } from "@/utils/terminalTranscript";
+const TABLE = "| A |\n| - |\n| 1 |";
+const plain = (id: string): TranscriptMessage => ({ id, text: `plain ${id}` });
+const rich = (id: string): TranscriptMessage => ({ id, text: TABLE });
+interface Props { sessionId: string | null; messages: TranscriptMessage[]; loaded: boolean }
+function setup(initial: Props) {
+  return renderHook((props: Props) => useTranscriptAutoOpen(props.sessionId, props.messages, props.loaded), { initialProps: initial });
+}
+describe("useTranscriptAutoOpen", () => {
+  it("starts collapsed and stays collapsed for plain replies", () => {
+    const { result, rerender } = setup({ sessionId: "s", messages: [], loaded: true });
+    expect(result.current[0]).toBe(false);
+    rerender({ sessionId: "s", messages: [plain("1"), plain("2")], loaded: true });
+    expect(result.current[0]).toBe(false);
+  });
+  it("opens when a new reply contains a table or diagram", () => {
+    const { result, rerender } = setup({ sessionId: "s", messages: [plain("1")], loaded: true });
+    rerender({ sessionId: "s", messages: [plain("1"), rich("2")], loaded: true });
+    expect(result.current[0]).toBe(true);
+  });
+  it("does not reopen for the same reply after the user collapses it, but does for the next", () => {
+    const { result, rerender } = setup({ sessionId: "s", messages: [], loaded: true });
+    rerender({ sessionId: "s", messages: [rich("1")], loaded: true });
+    act(() => result.current[1](false));
+    rerender({ sessionId: "s", messages: [rich("1"), plain("2")], loaded: true });
+    expect(result.current[0]).toBe(false);
+    rerender({ sessionId: "s", messages: [rich("1"), plain("2"), rich("3")], loaded: true });
+    expect(result.current[0]).toBe(true);
+  });
+  it("treats history present on the first loaded snapshot as the baseline", () => {
+    const { result, rerender } = setup({ sessionId: "s", messages: [], loaded: false });
+    rerender({ sessionId: "s", messages: [rich("old")], loaded: true });
+    expect(result.current[0]).toBe(false);
+  });
+  it("re-baselines when the terminal switches session, without opening for old content", () => {
+    const { result, rerender } = setup({ sessionId: "a", messages: [], loaded: true });
+    rerender({ sessionId: "b", messages: [], loaded: false });
+    rerender({ sessionId: "b", messages: [rich("b1")], loaded: true });
+    expect(result.current[0]).toBe(false);
+    rerender({ sessionId: "b", messages: [rich("b1"), rich("b2")], loaded: true });
+    expect(result.current[0]).toBe(true);
+  });
+  it("lets the user open it manually with nothing rich", () => {
+    const { result } = setup({ sessionId: "s", messages: [plain("1")], loaded: true });
+    act(() => result.current[1](true));
+    expect(result.current[0]).toBe(true);
+  });
+});
diff --git a/src/components/Terminal/useTranscriptAutoOpen.ts b/src/components/Terminal/useTranscriptAutoOpen.ts
new file mode 100644
index 000000000..e91160f1f
--- /dev/null
+++ b/src/components/Terminal/useTranscriptAutoOpen.ts
@@ -0,0 +1,46 @@
+/** Collapsed by default; each NEW reply with a table or diagram opens the transcript
+ * once. Content present when a session is first loaded is the baseline, not news, and
+ * a collapse by the user holds until the next rich reply.
+ * @module components/Terminal/useTranscriptAutoOpen */
+import { useEffect, useRef, useState } from "react";
+import type { TranscriptMessage } from "@/utils/terminalTranscript";
+import { hasRichTranscriptContent } from "./transcriptMarkdownTree";
+/** Newest message holding rich content; results are cached by message id. */
+function newestRichId(messages: TranscriptMessage[], cache: Map<string, boolean>): string | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const { id, text } = messages[i];
+    let rich = cache.get(id);
+    if (rich === undefined) cache.set(id, rich = hasRichTranscriptContent(text));
+    if (rich) return id;
+  }
+  return null;
+}
+export function useTranscriptAutoOpen(
+  sessionId: string | null,
+  messages: TranscriptMessage[],
+  loaded: boolean,
+): [boolean, (open: boolean) => void] {
+  const [expanded, setExpanded] = useState(false);
+  const baseline = useRef<{ sessionId: string | null; richId: string | null } | null>(null);
+  const cache = useRef(new Map<string, boolean>());
+  useEffect(() => {
+    if (baseline.current && baseline.current.sessionId !== sessionId) {
+      baseline.current = null;
+      cache.current.clear();
+    }
+    if (!loaded) return;
+    const richId = newestRichId(messages, cache.current);
+    if (!baseline.current) {
+      baseline.current = { sessionId, richId };
+    } else if (richId !== null && richId !== baseline.current.richId) {
+      baseline.current = { sessionId, richId };
+      setExpanded(true);
+    }
+    // Bound the cache to the retained window (the parser keeps the last 100).
+    if (cache.current.size > messages.length * 2) {
+      const live = new Set(messages.map(message => message.id));
+      for (const id of cache.current.keys()) if (!live.has(id)) cache.current.delete(id);
+    }
+  }, [sessionId, messages, loaded]);
+  return [expanded, setExpanded];
+}
diff --git a/src/components/Terminal/useTranscriptConfiguration.test.tsx b/src/components/Terminal/useTranscriptConfiguration.test.tsx
new file mode 100644
index 000000000..af3281bc0
--- /dev/null
+++ b/src/components/Terminal/useTranscriptConfiguration.test.tsx
@@ -0,0 +1,28 @@
+// WI-TP1.2: persisted toggle configures hooks; late configuration cannot resurrect state.
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useTranscriptConfiguration } from "./useTranscriptConfiguration";
+const mocks = vi.hoisted(() => ({ invoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+describe("useTranscriptConfiguration", () => {
+  it("is pending until configuration succeeds, then ready", async () => {
+    mocks.invoke.mockResolvedValue(undefined);
+    const { result } = renderHook(() => useTranscriptConfiguration(true));
+    expect(result.current).toBe("pending");
+    await act(async () => {});
+    expect(result.current).toBe("ready");
+    expect(mocks.invoke).toHaveBeenCalledWith("terminal_transcript_configure", { enabled: true });
+  });
+  it("ignores late configuration after disabling and exposes failure", async () => {
+    let resolve: (value: unknown) => void = () => {};
+    mocks.invoke.mockImplementationOnce(() => new Promise(r => { resolve = r; })).mockResolvedValueOnce(undefined);
+    const { result, rerender } = renderHook(({ enabled }) => useTranscriptConfiguration(enabled), { initialProps: { enabled: true } });
+    rerender({ enabled: false });
+    await act(async () => { resolve(undefined); });
+    mocks.invoke.mockRejectedValueOnce(new Error("permissions"));
+    rerender({ enabled: true });
+    expect(result.current).toBe("pending");
+    await act(async () => {});
+    expect(result.current).toBe("failed");
+  });
+});
diff --git a/src/components/Terminal/useTranscriptConfiguration.ts b/src/components/Terminal/useTranscriptConfiguration.ts
new file mode 100644
index 000000000..b6d10b646
--- /dev/null
+++ b/src/components/Terminal/useTranscriptConfiguration.ts
@@ -0,0 +1,21 @@
+/** Reflect the persisted setting into the additive CLI hook configuration.
+ * @module components/Terminal/useTranscriptConfiguration */
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { terminalLog } from "@/utils/debug";
+/** "pending" until the backend confirms the current setting; never mistaken for failure. */
+export type TranscriptConfigStatus = "pending" | "ready" | "failed";
+export function useTranscriptConfiguration(enabled: boolean): TranscriptConfigStatus {
+  const [settled, setSettled] = useState<{ enabled: boolean; status: TranscriptConfigStatus } | null>(null);
+  useEffect(() => {
+    let cancelled = false;
+    void invoke("terminal_transcript_configure", { enabled }).then(() => {
+      if (!cancelled) setSettled({ enabled, status: "ready" });
+    }).catch((error: unknown) => {
+      terminalLog("Transcript configuration failed:", error);
+      if (!cancelled) setSettled({ enabled, status: "failed" });
+    });
+    return () => { cancelled = true; };
+  }, [enabled]);
+  return settled?.enabled === enabled ? settled.status : "pending";
+}
diff --git a/src/locales/de/settings.json b/src/locales/de/settings.json
index ed9028551..6a1b7d679 100644
--- a/src/locales/de/settings.json
+++ b/src/locales/de/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Dunkler Schiefer für wenig Licht",
   "appearance.theme.solarized.description": "Solarized Dark, die klassische Palette",
   "appearance.theme.badge.light": "Hell",
-  "appearance.theme.badge.dark": "Dunkel"
+  "appearance.theme.badge.dark": "Dunkel",
+  "terminal.transcript.label": "Gesprächsprotokolle automatisch darstellen",
+  "terminal.transcript.description": "Claude/Codex-Markdown, Tabellen und Diagramme im Terminal darstellen. Fügt einen lokalen Start-Hook hinzu; laufende CLI-Sitzungen danach neu starten.",
+  "terminal.transcript.title": "Formatiertes Gesprächsprotokoll",
+  "terminal.transcript.waiting": "Warte auf eine Claude/Codex-Sitzung. CLI in diesem Terminal starten oder fortsetzen.",
+  "terminal.transcript.error": "Protokoll nicht verfügbar. CLI-Hooks und Node prüfen und Sitzung neu starten.",
+  "terminal.transcript.diagram": "Mermaid-Diagramm"
 }
diff --git a/src/locales/en/settings.json b/src/locales/en/settings.json
index 3d3c0b8e8..dcdd3afdb 100644
--- a/src/locales/en/settings.json
+++ b/src/locales/en/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Dark slate for low light",
   "appearance.theme.solarized.description": "Solarized Dark, the classic palette",
   "appearance.theme.badge.light": "Light",
-  "appearance.theme.badge.dark": "Dark"
+  "appearance.theme.badge.dark": "Dark",
+  "terminal.transcript.label": "Automatic transcript rendering",
+  "terminal.transcript.description": "Render Claude/Codex Markdown, tables and diagrams inside the terminal. Adds a local start hook; restart running CLI sessions after enabling",
+  "terminal.transcript.title": "Rendered Transcript",
+  "terminal.transcript.waiting": "Waiting for a Claude/Codex session. Start or resume the CLI in this terminal.",
+  "terminal.transcript.error": "Transcript unavailable. Check CLI hooks and Node, then restart the session.",
+  "terminal.transcript.diagram": "Mermaid diagram"
 }
diff --git a/src/locales/es/settings.json b/src/locales/es/settings.json
index 7888d0b13..44b91e320 100644
--- a/src/locales/es/settings.json
+++ b/src/locales/es/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Pizarra oscura para poca luz",
   "appearance.theme.solarized.description": "Solarized Dark, la paleta clásica",
   "appearance.theme.badge.light": "Claro",
-  "appearance.theme.badge.dark": "Oscuro"
+  "appearance.theme.badge.dark": "Oscuro",
+  "terminal.transcript.label": "Mostrar transcripciones automáticamente",
+  "terminal.transcript.description": "Mostrar Markdown, tablas y diagramas de Claude/Codex dentro del terminal. Añade un hook de inicio local; reinicie las sesiones CLI activas después de habilitarlo.",
+  "terminal.transcript.title": "Transcripción con formato",
+  "terminal.transcript.waiting": "Esperando una sesión de Claude/Codex. Inicie o reanude el CLI en este terminal.",
+  "terminal.transcript.error": "Transcripción no disponible. Revise los hooks del CLI y Node y reinicie la sesión.",
+  "terminal.transcript.diagram": "Diagrama Mermaid"
 }
diff --git a/src/locales/fr/settings.json b/src/locales/fr/settings.json
index f5fd60874..6bef807f8 100644
--- a/src/locales/fr/settings.json
+++ b/src/locales/fr/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Ardoise sombre pour la pénombre",
   "appearance.theme.solarized.description": "Solarized Dark, la palette classique",
   "appearance.theme.badge.light": "Clair",
-  "appearance.theme.badge.dark": "Sombre"
+  "appearance.theme.badge.dark": "Sombre",
+  "terminal.transcript.label": "Afficher automatiquement les transcriptions",
+  "terminal.transcript.description": "Afficher le Markdown, les tableaux et les diagrammes Claude/Codex dans le terminal. Ajoute un hook de démarrage local ; redémarrez les sessions CLI en cours après activation.",
+  "terminal.transcript.title": "Transcription mise en forme",
+  "terminal.transcript.waiting": "En attente d’une session Claude/Codex. Lancez ou reprenez le CLI dans ce terminal.",
+  "terminal.transcript.error": "Transcription indisponible. Vérifiez les hooks du CLI et Node, puis redémarrez la session.",
+  "terminal.transcript.diagram": "Diagramme Mermaid"
 }
diff --git a/src/locales/it/settings.json b/src/locales/it/settings.json
index afd817a99..4ac4381c1 100644
--- a/src/locales/it/settings.json
+++ b/src/locales/it/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Ardesia scura per poca luce",
   "appearance.theme.solarized.description": "Solarized Dark, la palette classica",
   "appearance.theme.badge.light": "Chiaro",
-  "appearance.theme.badge.dark": "Scuro"
+  "appearance.theme.badge.dark": "Scuro",
+  "terminal.transcript.label": "Visualizza automaticamente le trascrizioni",
+  "terminal.transcript.description": "Mostra Markdown, tabelle e diagrammi di Claude/Codex nel terminale. Aggiunge un hook di avvio locale; riavvia le sessioni CLI attive dopo l’attivazione.",
+  "terminal.transcript.title": "Trascrizione formattata",
+  "terminal.transcript.waiting": "In attesa di una sessione Claude/Codex. Avvia o riprendi il CLI in questo terminale.",
+  "terminal.transcript.error": "Trascrizione non disponibile. Controlla gli hook del CLI e Node, poi riavvia la sessione.",
+  "terminal.transcript.diagram": "Diagramma Mermaid"
 }
diff --git a/src/locales/ja/settings.json b/src/locales/ja/settings.json
index d8812d373..8212e9098 100644
--- a/src/locales/ja/settings.json
+++ b/src/locales/ja/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "暗いスレート、暗所向け",
   "appearance.theme.solarized.description": "Solarized Dark、定番パレット",
   "appearance.theme.badge.light": "ライト",
-  "appearance.theme.badge.dark": "ダーク"
+  "appearance.theme.badge.dark": "ダーク",
+  "terminal.transcript.label": "会話記録を自動表示",
+  "terminal.transcript.description": "Claude/Codex の Markdown、表、図をターミナル内に表示します。ローカル起動フックを追加します。有効化後、実行中の CLI を再起動してください。",
+  "terminal.transcript.title": "整形された会話記録",
+  "terminal.transcript.waiting": "Claude/Codex のセッションを待っています。このターミナルで CLI を起動または再開してください。",
+  "terminal.transcript.error": "会話記録を読み込めません。CLI フックと Node を確認し、セッションを再起動してください。",
+  "terminal.transcript.diagram": "Mermaid の図"
 }
diff --git a/src/locales/ko/settings.json b/src/locales/ko/settings.json
index 2da9aa953..7a6c030b1 100644
--- a/src/locales/ko/settings.json
+++ b/src/locales/ko/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "어두운 슬레이트, 저조도용",
   "appearance.theme.solarized.description": "Solarized Dark 클래식 팔레트",
   "appearance.theme.badge.light": "라이트",
-  "appearance.theme.badge.dark": "다크"
+  "appearance.theme.badge.dark": "다크",
+  "terminal.transcript.label": "대화 기록 자동 렌더링",
+  "terminal.transcript.description": "터미널 안에서 Claude/Codex의 Markdown, 표, 다이어그램을 표시합니다. 로컬 시작 훅을 추가합니다. 활성화한 후 실행 중인 CLI 세션을 다시 시작하세요.",
+  "terminal.transcript.title": "렌더링된 대화 기록",
+  "terminal.transcript.waiting": "Claude/Codex 세션을 기다리고 있습니다. 이 터미널에서 CLI를 시작하거나 재개하세요.",
+  "terminal.transcript.error": "대화 기록을 읽을 수 없습니다. CLI 훅과 Node를 확인하고 세션을 다시 시작하세요.",
+  "terminal.transcript.diagram": "Mermaid 다이어그램"
 }
diff --git a/src/locales/pt-BR/settings.json b/src/locales/pt-BR/settings.json
index 9c2a68f9a..df3b76efe 100644
--- a/src/locales/pt-BR/settings.json
+++ b/src/locales/pt-BR/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "Ardósia escura para pouca luz",
   "appearance.theme.solarized.description": "Solarized Dark, a paleta clássica",
   "appearance.theme.badge.light": "Claro",
-  "appearance.theme.badge.dark": "Escuro"
+  "appearance.theme.badge.dark": "Escuro",
+  "terminal.transcript.label": "Renderizar transcrições automaticamente",
+  "terminal.transcript.description": "Exibir Markdown, tabelas e diagramas do Claude/Codex no terminal. Adiciona um hook de início local; reinicie as sessões CLI em execução após ativar.",
+  "terminal.transcript.title": "Transcrição formatada",
+  "terminal.transcript.waiting": "Aguardando uma sessão do Claude/Codex. Inicie ou retome o CLI neste terminal.",
+  "terminal.transcript.error": "Transcrição indisponível. Verifique os hooks do CLI e o Node e reinicie a sessão.",
+  "terminal.transcript.diagram": "Diagrama Mermaid"
 }
diff --git a/src/locales/zh-CN/settings.json b/src/locales/zh-CN/settings.json
index c027f5ce2..9c5d6223e 100644
--- a/src/locales/zh-CN/settings.json
+++ b/src/locales/zh-CN/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "暗色石板，弱光环境",
   "appearance.theme.solarized.description": "Solarized Dark 经典配色",
   "appearance.theme.badge.light": "浅色",
-  "appearance.theme.badge.dark": "深色"
+  "appearance.theme.badge.dark": "深色",
+  "terminal.transcript.label": "自动渲染对话记录",
+  "terminal.transcript.description": "在终端内渲染 Claude/Codex 的 Markdown、表格和图表。启用时添加本地启动钩子；启用后请重启正在运行的 CLI 会话。",
+  "terminal.transcript.title": "渲染后的对话记录",
+  "terminal.transcript.waiting": "正在等待 Claude/Codex 会话。请在此终端中启动或恢复 CLI。",
+  "terminal.transcript.error": "无法读取对话记录。请检查 CLI 钩子和 Node，然后重启会话。",
+  "terminal.transcript.diagram": "Mermaid 图表"
 }
diff --git a/src/locales/zh-TW/settings.json b/src/locales/zh-TW/settings.json
index 140465e30..fa0d80664 100644
--- a/src/locales/zh-TW/settings.json
+++ b/src/locales/zh-TW/settings.json
@@ -784,5 +784,11 @@
   "appearance.theme.night.description": "暗色石板，弱光環境",
   "appearance.theme.solarized.description": "Solarized Dark 經典配色",
   "appearance.theme.badge.light": "淺色",
-  "appearance.theme.badge.dark": "深色"
+  "appearance.theme.badge.dark": "深色",
+  "terminal.transcript.label": "自動渲染對話記錄",
+  "terminal.transcript.description": "在終端內渲染 Claude/Codex 的 Markdown、表格和圖表。啟用時新增本機啟動鉤子；啟用後請重新啟動正在執行的 CLI 工作階段。",
+  "terminal.transcript.title": "渲染後的對話記錄",
+  "terminal.transcript.waiting": "正在等待 Claude/Codex 工作階段。請在此終端中啟動或恢復 CLI。",
+  "terminal.transcript.error": "無法讀取對話記錄。請檢查 CLI 鉤子和 Node，然後重新啟動工作階段。",
+  "terminal.transcript.diagram": "Mermaid 圖表"
 }
diff --git a/src/pages/settings/TerminalSettings.test.tsx b/src/pages/settings/TerminalSettings.test.tsx
index 61a92ff82..8b9dbdce0 100644
--- a/src/pages/settings/TerminalSettings.test.tsx
+++ b/src/pages/settings/TerminalSettings.test.tsx
@@ -182,3 +182,11 @@ describe("TerminalSettings panel size (WI-1.2)", () => {
     expect(panelSizeSelect().value).toBe(String(TERMINAL_MAX_RATIO));
   });
 });
+
+// WI-TP2.1: automatic transcript rendering is an opt-in persisted preference.
+describe("TerminalSettings transcript preview", () => {
+  it("offers a transcript preview toggle", () => {
+    render(<TerminalSettings />);
+    expect(screen.getByText("Automatic transcript rendering")).toBeInTheDocument();
+  });
+});
diff --git a/src/pages/settings/TerminalSettings.tsx b/src/pages/settings/TerminalSettings.tsx
index 74094fb70..efcdfe2ad 100644
--- a/src/pages/settings/TerminalSettings.tsx
+++ b/src/pages/settings/TerminalSettings.tsx
@@ -106,6 +106,10 @@ export function TerminalSettings() {
   return (
     <div className="space-y-6">
       <SettingsGroup title={t("terminal.group.terminal")}>
+        <SettingRow label={t("terminal.transcript.label")} description={t("terminal.transcript.description")}>
+          <Toggle checked={terminal.transcriptPreview} onChange={(v) => updateTerminalSetting("transcriptPreview", v)} />
+        </SettingRow>
+
         <SettingRow label={t("terminal.shell.label")} description={t("terminal.shell.description")}>
           <Select
             value={terminal.shell}
diff --git a/src/plugins/mermaid/plugin.test.ts b/src/plugins/mermaid/plugin.test.ts
index a469bc64b..00cf605fc 100644
--- a/src/plugins/mermaid/plugin.test.ts
+++ b/src/plugins/mermaid/plugin.test.ts
@@ -56,6 +56,14 @@ beforeEach(() => {
 });
 
 describe("renderMermaid", () => {
+  // WI-TP2.1: transcript rendering must not change the editor's global config.
+  it("uses strict SVG labels for transcripts and restores normal config on the next render", async () => {
+    const { renderMermaid } = await loadPlugin();
+    await renderMermaid("graph TD; A-->B", "transcript", true);
+    expect(mockInitialize).toHaveBeenLastCalledWith(expect.objectContaining({ securityLevel: "strict", htmlLabels: false }));
+    await renderMermaid("graph TD; A-->B", "editor");
+    expect(mockInitialize).toHaveBeenLastCalledWith(expect.objectContaining({ securityLevel: "antiscript" }));
+  });
   it("renders content to SVG with the live 'base' theme config", async () => {
     const { renderMermaid } = await loadPlugin();
 
diff --git a/src/plugins/mermaid/plugin.ts b/src/plugins/mermaid/plugin.ts
index e124af0bf..6dde0995f 100644
--- a/src/plugins/mermaid/plugin.ts
+++ b/src/plugins/mermaid/plugin.ts
@@ -87,7 +87,7 @@ function computeConfigKey(): string {
  * to avoid double-scaling. Mermaid's default flowchart padding/wrapping
  * are left untouched so its node-sizing algorithm stays accurate.
  */
-function applyMermaidConfig(): void {
+function applyMermaidConfig(strict = false): void {
   const key = computeConfigKey();
   if (!mermaidModule) {
     appliedConfigKey = observedConfigKey = key;
@@ -102,7 +102,8 @@ function applyMermaidConfig(): void {
     theme: "base",
     // Use "antiscript" (mermaid's default) to allow inline styles from `style` directives
     // while still sanitizing scripts. "strict" would strip all custom styling.
-    securityLevel: "antiscript",
+    securityLevel: strict ? "strict" : "antiscript",
+    ...(strict ? { htmlLabels: false, flowchart: { htmlLabels: false } } : {}),
     ...MERMAID_V11_RENDERING,
     fontFamily: tokens.fontMono,
     fontSize: currentFontSize,
@@ -164,7 +165,8 @@ async function initMermaid(): Promise<void> {
  */
 export async function renderMermaid(
   content: string,
-  id?: string
+  id?: string,
+  strict = false
 ): Promise<string | null> {
   try {
     await initMermaid();
@@ -183,8 +185,8 @@ export async function renderMermaid(
       id ?? `mermaid-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
 
     try {
-      if (appliedConfigKey !== computeConfigKey()) {
-        applyMermaidConfig();
+      if (strict || appliedConfigKey !== computeConfigKey()) {
+        applyMermaidConfig(strict);
       }
       // mermaidModule is guaranteed non-null after initMermaid()
       const { svg } = await mermaidModule!.default.render(diagramId, content);
@@ -198,6 +200,7 @@ export async function renderMermaid(
     } finally {
       // Clean up the temporary container Mermaid creates in document.body
       // (on error it leaves error displays there too).
+      if (strict) appliedConfigKey = null;
       cleanupMermaidContainer(diagramId);
     }
   });
diff --git a/src/plugins/mermaid/strictRender.webkit.test.ts b/src/plugins/mermaid/strictRender.webkit.test.ts
new file mode 100644
index 000000000..e93f77f62
--- /dev/null
+++ b/src/plugins/mermaid/strictRender.webkit.test.ts
@@ -0,0 +1,28 @@
+/**
+ * The terminal transcript renders Mermaid with `strict` security and SVG (not
+ * HTML) labels. Every diagram type the transcript may meet must still render
+ * under that config in a real engine — jsdom has no layout, so it cannot tell.
+ * Also pins that a strict render leaves the editor's config intact.
+ */
+import { describe, it, expect } from "vitest";
+import "@/styles/index.css";
+import { renderMermaid } from "./index";
+
+const DIAGRAMS = {
+  flowchart: 'flowchart LR\n  A["User types"] --> B{"Mermaid?"}\n  B -->|Yes| C["Render"]',
+  sequence: 'sequenceDiagram\n  participant U as User\n  participant W as Webview\n  U->>W: Click Save\n  W-->>U: Ok',
+};
+
+describe("strict (transcript) Mermaid rendering, real engine", () => {
+  it.each(Object.entries(DIAGRAMS))("renders a %s diagram", async (_kind, source) => {
+    const svg = await renderMermaid(source, `strict-${_kind}`, true);
+    expect(svg).toMatch(/^<svg/);
+    expect(svg).not.toContain("<foreignObject");
+  });
+
+  it("returns the editor to its own config after a strict render", async () => {
+    await renderMermaid(DIAGRAMS.flowchart, "strict-first", true);
+    const svg = await renderMermaid(DIAGRAMS.flowchart, "editor-after");
+    expect(svg).toContain("<foreignObject");
+  });
+});
diff --git a/src/services/terminal/transcriptBinding.test.ts b/src/services/terminal/transcriptBinding.test.ts
new file mode 100644
index 000000000..00e98142f
--- /dev/null
+++ b/src/services/terminal/transcriptBinding.test.ts
@@ -0,0 +1,42 @@
+// WI-TP1.1: opaque identities separate sessions and reset on shell restart.
+import { beforeEach, describe, it, expect, vi } from "vitest";
+import { prepareTranscriptBinding, transcriptToken, forgetTranscriptBinding } from "./transcriptBinding";
+const mocks = vi.hoisted(() => ({ invoke: vi.fn(), tokens: [] as string[] }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+const forgotten = () => mocks.invoke.mock.calls.filter(([command]) => command === "terminal_transcript_forget").map(([, args]) => (args as { token: string }).token);
+beforeEach(() => {
+  mocks.invoke.mockReset();
+  mocks.invoke.mockImplementation((command: string) => Promise.resolve(command === "terminal_transcript_prepare" ? mocks.tokens.shift() : undefined));
+});
+describe("transcriptBinding", () => {
+  it("keeps shells isolated and drops closed bindings on disk too", async () => {
+    mocks.tokens = ["first", "second", "restart"];
+    await prepareTranscriptBinding("a"); await prepareTranscriptBinding("b");
+    expect(transcriptToken("a")).toBe("first");
+    expect(transcriptToken("b")).toBe("second");
+    await prepareTranscriptBinding("a");
+    expect(transcriptToken("a")).toBe("restart");
+    expect(forgotten()).toEqual(["first"]);
+    forgetTranscriptBinding("a"); forgetTranscriptBinding("b");
+    expect(transcriptToken("a")).toBeUndefined();
+    expect(forgotten()).toEqual(["first", "restart", "second"]);
+  });
+  it("does not register a shell that was closed during preparation", async () => {
+    let resolve: (value: string) => void = () => {};
+    mocks.invoke.mockImplementationOnce(() => new Promise<string>(r => { resolve = r; }));
+    const preparing = prepareTranscriptBinding("closed");
+    forgetTranscriptBinding("closed");
+    resolve("late-token");
+    // The stale shell must not receive a token whose binding was just released.
+    await expect(preparing).rejects.toThrow("superseded");
+    expect(transcriptToken("closed")).toBeUndefined();
+    expect(forgotten()).toEqual(["late-token"]);
+  });
+  it("logs rather than throws when cleanup fails", async () => {
+    mocks.tokens = ["gone"];
+    await prepareTranscriptBinding("x");
+    mocks.invoke.mockRejectedValueOnce(new Error("io"));
+    expect(() => forgetTranscriptBinding("x")).not.toThrow();
+    await Promise.resolve();
+  });
+});
diff --git a/src/services/terminal/transcriptBinding.ts b/src/services/terminal/transcriptBinding.ts
new file mode 100644
index 000000000..81b3a4925
--- /dev/null
+++ b/src/services/terminal/transcriptBinding.ts
@@ -0,0 +1,31 @@
+/** Window-local shell binding registry; tokens never derive from working directories.
+ * A token that stops identifying a live shell is released, so its binding file is deleted.
+ * @module services/terminal/transcriptBinding */
+import { invoke } from "@tauri-apps/api/core";
+import { terminalLog } from "@/utils/debug";
+const tokens = new Map<string, string>();
+const pending = new Map<string, object>();
+function release(token: string): void {
+  void invoke("terminal_transcript_forget", { token }).catch((error: unknown) => terminalLog("Transcript binding cleanup failed:", error));
+}
+export async function prepareTranscriptBinding(sessionId: string): Promise<string> {
+  const request = {};
+  pending.set(sessionId, request);
+  const token = await invoke<string>("terminal_transcript_prepare");
+  // A closed or restarted shell must not carry a token whose binding is released.
+  if (pending.get(sessionId) !== request) {
+    release(token);
+    throw new Error("Transcript binding superseded");
+  }
+  const previous = tokens.get(sessionId);
+  tokens.set(sessionId, token);
+  if (previous) release(previous);
+  return token;
+}
+export function transcriptToken(sessionId: string): string | undefined { return tokens.get(sessionId); }
+export function forgetTranscriptBinding(sessionId: string): void {
+  const token = tokens.get(sessionId);
+  tokens.delete(sessionId);
+  pending.delete(sessionId);
+  if (token) release(token);
+}
diff --git a/src/stores/settingsStore/defaults.ts b/src/stores/settingsStore/defaults.ts
index 30018c0e3..87930682e 100644
--- a/src/stores/settingsStore/defaults.ts
+++ b/src/stores/settingsStore/defaults.ts
@@ -103,6 +103,7 @@ export const initialState: SettingsState = {
     cleanupOrphansOnClose: false, // Off by default - user must opt in
   },
   terminal: {
+    transcriptPreview: false,
     shell: "",
     // D15: deliberately independent of the 18px reading size — a terminal is
     // a dense monitoring surface, and 13/1.2 matches what real terminals ship.
diff --git a/src/stores/settingsTypes/system.ts b/src/stores/settingsTypes/system.ts
index 09ed1beb2..d42c47e65 100644
--- a/src/stores/settingsTypes/system.ts
+++ b/src/stores/settingsTypes/system.ts
@@ -28,6 +28,7 @@ export type TerminalBellMode = "off" | "visual" | "audible";
 
 /** Terminal emulator preferences — shell, font, cursor, renderer, and panel layout. */
 export interface TerminalSettings {
+  transcriptPreview: boolean; // Default false: automatic assistant transcript rendering within the terminal area
   shell: string;       // Default: "" (empty = system default via getpwuid → $SHELL → /bin/sh)
   fontSize: number;    // Default: 13 (clamp range: 8–32, see CLAMP_RANGES.terminal)
   lineHeight: number;  // Default: 1.2 (clamp range: 1–2.5, see CLAMP_RANGES.terminal)
diff --git a/src/utils/terminalTranscript.test.ts b/src/utils/terminalTranscript.test.ts
new file mode 100644
index 000000000..d773fa573
--- /dev/null
+++ b/src/utils/terminalTranscript.test.ts
@@ -0,0 +1,26 @@
+// WI-TP1.1: exact assistant-only transcript parsing.
+import { describe, expect, it } from "vitest";
+import { parseTerminalTranscript } from "./terminalTranscript";
+const line = (value: unknown) => JSON.stringify(value) + "\n";
+describe("parseTerminalTranscript", () => {
+  it("reads Claude assistant text and ignores tools, user text and partial lines", () => {
+    const data = line({ type: "user", message: { role: "user", content: "secret" } }) +
+      line({ type: "assistant", uuid: "a", message: { role: "assistant", content: [{ type: "text", text: "中文 | table" }, { type: "tool_use", name: "shell" }] } }) + '{"type":"assistant"';
+    expect(parseTerminalTranscript(data)).toEqual([{ id: "a:0", text: "中文 | table" }]);
+  });
+  it("reads Codex output_text once and updates repeated identities", () => {
+    const record = (text: string) => ({ type: "response_item", payload: { type: "message", role: "assistant", id: "m", content: [{ type: "output_text", text }] } });
+    expect(parseTerminalTranscript(line(record("old")) + "bad\n" + line(record("new")))).toEqual([{ id: "m:0", text: "new" }]);
+  });
+  it("handles empty input and bounds retained messages", () => {
+    expect(parseTerminalTranscript("")).toEqual([]);
+    const data = Array.from({ length: 150 }, (_, i) => line({ type: "assistant", uuid: String(i), message: { role: "assistant", content: [{ type: "text", text: String(i) }] } })).join("");
+    expect(parseTerminalTranscript(data)).toHaveLength(100);
+    expect(parseTerminalTranscript(data)[0].text).toBe("50");
+  });
+});
+// Preserve repeated legitimate replies when Codex does not supply a message id.
+it("uses event timestamps to preserve repeated assistant replies", () => {
+  const record = (timestamp: string) => ({ timestamp, type: "response_item", payload: { type: "message", role: "assistant", content: [{ type: "output_text", text: "Done" }] } });
+  expect(parseTerminalTranscript(line(record("first")) + line(record("second")))).toHaveLength(2);
+});
diff --git a/src/utils/terminalTranscript.ts b/src/utils/terminalTranscript.ts
new file mode 100644
index 000000000..7105cfd85
--- /dev/null
+++ b/src/utils/terminalTranscript.ts
@@ -0,0 +1,22 @@
+/** Assistant-only JSONL transcript decoding. Complete lines only; bounded history.
+ * @module utils/terminalTranscript */
+export interface TranscriptMessage { id: string; text: string }
+export function parseTerminalTranscript(data: string): TranscriptMessage[] {
+  const messages = new Map<string, TranscriptMessage>();
+  const lines = data.split("\n");
+  lines.pop(); // A writer may still be appending the final record.
+  for (const [lineIndex, line] of lines.entries()) {
+    try {
+      const value = JSON.parse(line);
+      const message = value.type === "assistant" ? value.message :
+        value.type === "response_item" && value.payload?.type === "message" ? value.payload : null;
+      if (!message || message.role !== "assistant" || !Array.isArray(message.content)) continue;
+      message.content.forEach((part: { type?: string; text?: unknown }, index: number) => {
+        if (!["text", "output_text"].includes(part.type ?? "") || typeof part.text !== "string") return;
+        const id = `${value.uuid ?? message.id ?? value.timestamp ?? lineIndex}:${index}`;
+        messages.set(id, { id, text: part.text.slice(0, 100_000) });
+      });
+    } catch { /* Malformed or non-message records do not interrupt following. */ }
+  }
+  return [...messages.values()].slice(-100);
+}
diff --git a/website/de/guide/settings.md b/website/de/guide/settings.md
index 6fa07890a..937df88cb 100644
--- a/website/de/guide/settings.md
+++ b/website/de/guide/settings.md
@@ -447,6 +447,7 @@ Konfigurieren Sie das integrierte Terminal-Panel. Öffnen Sie das Terminal mit `
 | Cursor-Stil | Form des Terminal-Cursors | Balken | Balken, Block, Unterstrichen |
 | Cursor blinken | Ob der Terminal-Cursor blinkt | Ein | Ein / Aus |
 | Bei Auswahl kopieren | Ausgewählten Terminaltext automatisch in die Zwischenablage kopieren | Aus | Ein / Aus |
+| Gesprächsprotokolle automatisch darstellen | Claude/Codex-Markdown, Tabellen und Mermaid-Diagramme neben der Terminal-CLI darstellen. Fügt der Konfiguration von Claude Code und Codex einen lokalen SessionStart-Hook hinzu; laufende CLI-Sitzungen nach dem Aktivieren neu starten | Aus | Ein / Aus |
 | WebGL-Renderer | GPU-beschleunigtes Rendering für das Terminal verwenden. Deaktivieren bei IME-Eingabeproblemen. Erfordert Terminal-Neustart | Ein | Ein / Aus |
 | Zwischenablage aus der Ferne (OSC 52) | Programmen im Terminal — über ssh, in tmux — erlauben, in Ihre Systemzwischenablage zu kopieren. Der Kanal ist nur schreibend: Das Lesen der Zwischenablage wird immer verweigert, da jede im Terminal ausgegebene Ausgabe es anfordern könnte | Ein | Ein / Aus |
 | Scrollback-Puffer | Anzahl der Ausgabezeilen, die jede Sitzung in ihrem Scrollverlauf behält. Höhere Werte benötigen mehr Speicher | 5.000 | 1.000 / 5.000 / 10.000 / 50.000 |
diff --git a/website/de/guide/terminal.md b/website/de/guide/terminal.md
index d0a916e16..d6ab70a64 100644
--- a/website/de/guide/terminal.md
+++ b/website/de/guide/terminal.md
@@ -228,12 +228,23 @@ haben, als gäbe es sie bereits:
 | Schriftgröße | 10 – 24 px | 13 px | Alle |
 | Zeilenhöhe | 1,0 – 2,0 | 1,2 | Alle |
 | Bei Auswahl kopieren | Ein / Aus | Aus | Alle |
+| Gesprächsprotokolle automatisch darstellen | Ein / Aus | Aus | Alle |
 | Mac Option als Meta | Ein / Aus | Ein | macOS |
 | Shell-Integration | Ein / Aus | Ein | macOS / Linux (zsh, bash) |
 | Zwischenablage aus der Ferne (OSC 52) | Ein / Aus | Ein | Alle |
 | Scrollback-Puffer | 1.000 / 5.000 / 10.000 / 50.000 Zeilen | 5.000 | Alle |
 | Screenreader-Modus | Ein / Aus | Aus | Alle |
 
+### Gesprächsprotokolle automatisch darstellen
+
+Aktivieren Sie **Gesprächsprotokolle automatisch darstellen**, um Markdown, auswählbare Tabellen und Mermaid-Diagramme des Assistenten in einem Bereich für das formatierte Gesprächsprotokoll innerhalb des Terminalbereichs anzuzeigen. Er befindet sich rechts neben der CLI, wenn das Terminal oben oder unten angeordnet ist, und darunter, wenn das Terminal links oder rechts angeordnet ist; die interaktive CLI bleibt daneben nutzbar.
+
+Der Bereich ist anfangs eingeklappt. Er öffnet sich von selbst, wenn eine neue Antwort eine Tabelle oder ein Mermaid-Diagramm enthält — reine Textantworten, die das Terminal ohnehin gut darstellt, lassen ihn geschlossen. Klicken Sie jederzeit auf die Diagramm-Schaltfläche in der Tab-Leiste des Terminals (Tooltip **Formatiertes Gesprächsprotokoll**), um ihn ein- oder auszublenden; die Schaltfläche ist hervorgehoben, solange das Protokoll angezeigt wird, und beim Ausblenden erhält die CLI den gesamten Bereich zurück; nachdem Sie ihn eingeklappt haben, bleibt er bis zur nächsten Antwort mit einer Tabelle oder einem Diagramm geschlossen. Inhalte, die sich beim ersten Anzeigen der Sitzung bereits im Protokoll befinden, öffnen ihn nicht. Ein ausgeblendetes Terminal liest keine Protokolle mehr.
+
+Beim Aktivieren wird ein lokaler `SessionStart`-Hook zur `settings.json` von Claude Code und zur `hooks.json` von Codex hinzugefügt, wobei vorhandene Hooks erhalten bleiben. Starten Sie Claude/Codex nach dem Aktivieren in einem VMark-Terminal oder setzen Sie eine Sitzung dort fort; bereits laufende Sitzungen müssen neu gestartet werden. Codex fordert Sie beim ersten Start möglicherweise auf, dem neuen Hook zu vertrauen. Erforderlich sind Node und eine CLI-Version mit Lifecycle-Hooks. Ausdrücklich deaktivierte oder durch Richtlinien eingeschränkte Hooks, entfernte SSH-Sitzungen sowie benutzerdefinierte CLI-Konfigurationsverzeichnisse, die von der Umgebung von VMark abweichen, können keine Bindung herstellen.
+
+Jedes Terminal folgt genau seiner eigenen Sitzung statt dem zuletzt geänderten Protokoll. Die Vorschau behält bis zu 100 Assistentennachrichten aus den letzten 2 MiB der Protokolldaten. Rohes HTML und entfernte Bilder bleiben wirkungslos; ungültige Diagramme bleiben als Quelltext lesbar. Beim Deaktivieren wird der formatierte Bereich entfernt, und die von VMark installierten Hooks werden deaktiviert.
+
 ### Barrierefreiheit
 
 | Einstellung | Optionen | Standard |
diff --git a/website/es/guide/settings.md b/website/es/guide/settings.md
index 0c2ad67ba..593459e1b 100644
--- a/website/es/guide/settings.md
+++ b/website/es/guide/settings.md
@@ -447,6 +447,7 @@ Configura el panel del terminal integrado. Abre el terminal con `` Ctrl + ` ``.
 | Estilo del Cursor | Forma del cursor del terminal | Barra | Barra, Bloque, Subrayado |
 | Cursor Parpadeante | Si el cursor del terminal parpadea | Activado | Activado / Desactivado |
 | Copiar al Seleccionar | Copia automáticamente el texto del terminal seleccionado al portapapeles | Desactivado | Activado / Desactivado |
+| Mostrar transcripciones automáticamente | Muestra Markdown, tablas y diagramas Mermaid de Claude/Codex junto a la CLI del terminal. Añade un hook SessionStart local a la configuración de Claude Code y Codex; reinicia las sesiones CLI activas después de habilitarlo | Desactivado | Activado / Desactivado |
 | Renderizador WebGL | Usa renderizado acelerado por GPU para el terminal. Desactívalo si experimentas problemas de entrada IME. Requiere reiniciar el terminal | Activado | Activado / Desactivado |
 | Portapapeles remoto (OSC 52) | Permite que los programas que se ejecutan en el terminal — por ssh, dentro de tmux — copien al portapapeles del sistema. El canal es solo de escritura: la lectura del portapapeles siempre se rechaza, ya que cualquier salida impresa en el terminal podría solicitarla | Activado | Activado / Desactivado |
 | Historial de desplazamiento | Número de líneas de salida que cada sesión conserva en su historial de desplazamiento. Los valores más altos usan más memoria | 5.000 | 1.000 / 5.000 / 10.000 / 50.000 |
diff --git a/website/es/guide/terminal.md b/website/es/guide/terminal.md
index 26cbcf752..2056e3a8e 100644
--- a/website/es/guide/terminal.md
+++ b/website/es/guide/terminal.md
@@ -225,12 +225,23 @@ Abre **Configuración → Terminal** para configurar:
 | Tamaño de Fuente | 10 – 24 px | 13 px | Todas |
 | Altura de Línea | 1.0 – 2.0 | 1.2 | Todas |
 | Copiar al Seleccionar | Activado / Desactivado | Desactivado | Todas |
+| Mostrar transcripciones automáticamente | Activado / Desactivado | Desactivado | Todas |
 | Tecla Option de Mac como Meta | Activado / Desactivado | Activado | macOS |
 | Integración con el shell | Activado / Desactivado | Activado | macOS / Linux (zsh, bash) |
 | Portapapeles remoto (OSC 52) | Activado / Desactivado | Activado | Todas |
 | Historial de desplazamiento | 1.000 / 5.000 / 10.000 / 50.000 líneas | 5.000 | Todas |
 | Modo lector de pantalla | Activado / Desactivado | Desactivado | Todas |
 
+### Mostrar transcripciones automáticamente
+
+Activa **Mostrar transcripciones automáticamente** para ver el Markdown del asistente, tablas seleccionables y diagramas Mermaid en una sección de transcripción con formato dentro del área del terminal. Se sitúa a la derecha de la CLI cuando el terminal está arriba o abajo, y debajo de ella cuando el terminal está a la izquierda o a la derecha; la CLI interactiva sigue siendo utilizable a su lado.
+
+La sección empieza contraída. Se abre sola cuando una nueva respuesta contiene una tabla o un diagrama Mermaid — las respuestas de texto sin formato, que el terminal ya muestra bien, la dejan cerrada. Haz clic en el botón de gráfico de la barra de pestañas del terminal (texto emergente **Transcripción con formato**) para mostrarla u ocultarla en cualquier momento; el botón aparece resaltado mientras se muestra la transcripción, y al ocultarla la CLI recupera toda el área; después de contraerla, permanece cerrada hasta la siguiente respuesta con una tabla o un diagrama. El contenido que ya está en la transcripción cuando la sesión se muestra por primera vez no la abre. Un terminal oculto deja de leer transcripciones.
+
+Al habilitarla se añade un hook `SessionStart` local al `settings.json` de Claude Code y al `hooks.json` de Codex, conservando los hooks existentes. Después de habilitarla, inicia o reanuda Claude/Codex en un terminal de VMark; reinicia las sesiones que ya estén en ejecución. Codex puede pedirte que confíes en el nuevo hook la primera vez que se ejecute. Se requieren Node y una versión de la CLI con hooks de ciclo de vida. Los hooks deshabilitados explícitamente o restringidos por políticas, las sesiones SSH remotas y los directorios de configuración personalizados de la CLI que difieran del entorno de VMark no pueden proporcionar un vínculo.
+
+Cada terminal sigue su sesión exacta en lugar de la transcripción modificada más recientemente. La vista previa conserva hasta 100 mensajes del asistente de los últimos 2 MiB de datos de la transcripción. El HTML sin procesar y las imágenes remotas permanecen inertes; los diagramas no válidos siguen siendo legibles como código fuente. Al deshabilitarla se elimina la sección con formato y se desactivan los hooks instalados por VMark.
+
 ### Accesibilidad
 
 | Configuración | Opciones | Predeterminado |
diff --git a/website/fr/guide/settings.md b/website/fr/guide/settings.md
index 03bc36ea8..a5ac3a9f1 100644
--- a/website/fr/guide/settings.md
+++ b/website/fr/guide/settings.md
@@ -449,6 +449,7 @@ Configurer le panneau de terminal intégré. Ouvrez le terminal avec `` Ctrl + `
 | Style du curseur | Forme du curseur du terminal | Barre | Barre, Bloc, Souligné |
 | Clignotement du curseur | Si le curseur du terminal clignote | Activé | Activé / Désactivé |
 | Copier à la sélection | Copier automatiquement le texte du terminal sélectionné dans le presse-papiers | Désactivé | Activé / Désactivé |
+| Afficher automatiquement les transcriptions | Afficher le Markdown, les tableaux et les diagrammes Mermaid Claude/Codex à côté de la CLI du terminal. Ajoute un hook SessionStart local à la configuration de Claude Code et de Codex ; redémarrez les sessions CLI en cours après activation | Désactivé | Activé / Désactivé |
 | Rendu WebGL | Utiliser le rendu accéléré GPU pour le terminal. Désactiver en cas de problèmes de saisie IME. Nécessite un redémarrage du terminal | Activé | Activé / Désactivé |
 | Presse-papiers distant (OSC 52) | Permettre aux programmes exécutés dans le terminal — via ssh, dans tmux — de copier vers le presse-papiers du système. Le canal fonctionne en écriture seule : la lecture du presse-papiers est toujours refusée, car n'importe quelle sortie affichée dans le terminal pourrait la demander | Activé | Activé / Désactivé |
 | Historique de défilement | Nombre de lignes de sortie que chaque session conserve dans son historique de défilement. Des valeurs plus élevées consomment plus de mémoire | 5 000 | 1 000 / 5 000 / 10 000 / 50 000 |
diff --git a/website/fr/guide/terminal.md b/website/fr/guide/terminal.md
index 25a9c6906..9bd6fc708 100644
--- a/website/fr/guide/terminal.md
+++ b/website/fr/guide/terminal.md
@@ -227,12 +227,23 @@ Ouvrez **Paramètres → Terminal** pour configurer :
 | Taille de police | 10 – 24 px | 13 px | Toutes |
 | Interligne | 1.0 – 2.0 | 1.2 | Toutes |
 | Copier à la sélection | Activé / Désactivé | Désactivé | Toutes |
+| Afficher automatiquement les transcriptions | Activé / Désactivé | Désactivé | Toutes |
 | Option comme touche Meta | Activé / Désactivé | Activé | macOS |
 | Intégration du shell | Activé / Désactivé | Activé | macOS / Linux (zsh, bash) |
 | Presse-papiers distant (OSC 52) | Activé / Désactivé | Activé | Toutes |
 | Historique de défilement | 1 000 / 5 000 / 10 000 / 50 000 lignes | 5 000 | Toutes |
 | Mode lecteur d'écran | Activé / Désactivé | Désactivé | Toutes |
 
+### Afficher automatiquement les transcriptions
+
+Activez **Afficher automatiquement les transcriptions** pour afficher le Markdown de l'assistant, des tableaux sélectionnables et des diagrammes Mermaid dans une section de transcription mise en forme, à l'intérieur de la zone du terminal. Elle se place à droite de la CLI lorsque le terminal est en haut ou en bas, et en dessous lorsque le terminal est à gauche ou à droite ; la CLI interactive reste utilisable à côté.
+
+La section est d'abord repliée. Elle s'ouvre d'elle-même lorsqu'une nouvelle réponse contient un tableau ou un diagramme Mermaid — les réponses en texte brut, que le terminal affiche déjà bien, la laissent fermée. Cliquez sur le bouton graphique dans la barre d'onglets du terminal (info-bulle **Transcription mise en forme**) pour l'afficher ou la masquer à tout moment ; le bouton est mis en surbrillance tant que la transcription est affichée, et la masquer rend toute la zone à la CLI ; après l'avoir repliée, elle reste fermée jusqu'à la prochaine réponse contenant un tableau ou un diagramme. Le contenu déjà présent dans la transcription lorsque la session est affichée pour la première fois ne l'ouvre pas. Un terminal masqué cesse de lire les transcriptions.
+
+L'activation ajoute un hook `SessionStart` local au `settings.json` de Claude Code et au `hooks.json` de Codex, en conservant les hooks existants. Après l'activation, démarrez ou reprenez Claude/Codex dans un terminal VMark ; redémarrez les sessions déjà en cours. Codex peut vous demander de faire confiance au nouveau hook lors de sa première exécution. Node et une version de la CLI prenant en charge les hooks de cycle de vie sont requis. Les hooks explicitement désactivés ou restreints par une stratégie, les sessions SSH distantes et les répertoires de configuration CLI personnalisés qui diffèrent de l'environnement de VMark ne peuvent pas établir de liaison.
+
+Chaque terminal suit exactement sa propre session plutôt que la transcription modifiée le plus récemment. L'aperçu conserve jusqu'à 100 messages de l'assistant issus des 2 derniers MiB de données de transcription. Le HTML brut et les images distantes restent inertes ; les diagrammes non valides restent lisibles sous forme de source. La désactivation supprime la section mise en forme et désactive les hooks installés par VMark.
+
 ### Accessibilité
 
 | Paramètre | Options | Par défaut |
diff --git a/website/guide/settings.md b/website/guide/settings.md
index a2f46f8c1..a4bffead1 100644
--- a/website/guide/settings.md
+++ b/website/guide/settings.md
@@ -444,6 +444,7 @@ Configure the integrated terminal panel. Open the terminal with `` Ctrl + ` ``.
 | Cursor Style | Shape of the terminal cursor | Bar | Bar, Block, Underline |
 | Cursor Blink | Whether the terminal cursor blinks | On | On / Off |
 | Copy on Select | Automatically copy selected terminal text to the clipboard | Off | On / Off |
+| Automatic transcript rendering | Render Claude/Codex Markdown, tables and Mermaid diagrams beside the terminal CLI. Adds a local SessionStart hook to the Claude Code and Codex configuration; restart running CLI sessions after enabling | Off | On / Off |
 | WebGL Renderer | Use GPU-accelerated rendering for the terminal. Disable if you experience IME input issues. Requires a terminal restart | On | On / Off |
 | Remote Clipboard (OSC 52) | Let programs running in the terminal — over ssh, inside tmux — copy to your system clipboard. The channel is write-only: reading the clipboard is always refused, since any output printed to the terminal could request it | On | On / Off |
 | Scrollback | Number of lines of output each session keeps in its scroll history. Higher values use more memory | 5,000 | 1,000 / 5,000 / 10,000 / 50,000 |
diff --git a/website/guide/terminal.md b/website/guide/terminal.md
index 3fcd8f369..a10544166 100644
--- a/website/guide/terminal.md
+++ b/website/guide/terminal.md
@@ -218,12 +218,23 @@ Open **Settings → Terminal** to configure:
 | Font Size | 10 – 24 px | 13 px | All |
 | Line Height | 1.0 – 2.0 | 1.2 | All |
 | Copy on Select | On / Off | Off | All |
+| Automatic transcript rendering | On / Off | Off | All |
 | Mac Option as Meta | On / Off | On | macOS |
 | Shell Integration | On / Off | On | macOS / Linux (zsh, bash) |
 | Remote Clipboard (OSC 52) | On / Off | On | All |
 | Scrollback | 1,000 / 5,000 / 10,000 / 50,000 lines | 5,000 | All |
 | Screen Reader Mode | On / Off | Off | All |
 
+### Automatic transcript rendering
+
+Enable **Automatic transcript rendering** to display assistant Markdown, selectable tables and Mermaid diagrams in a rendered-transcript section inside the terminal area. It sits to the right of the CLI when the terminal is at the top or bottom, and below it when the terminal is on the left or right; the interactive CLI stays usable beside it.
+
+The section starts collapsed. It opens by itself when a new reply contains a table or a Mermaid diagram — plain-text replies, which the terminal already shows well, leave it closed. Click the chart button in the terminal tab bar (tooltip **Rendered Transcript**) to show or hide it at any time; the button is highlighted while the transcript is shown, and hiding it gives the CLI the whole area back; after you collapse it, it stays closed until the next reply with a table or diagram. Content already in the transcript when the session is first shown does not open it. A hidden terminal stops reading transcripts.
+
+Enabling adds a local `SessionStart` hook to Claude Code's `settings.json` and Codex's `hooks.json`, preserving existing hooks. Start or resume Claude/Codex in a VMark terminal after enabling; restart sessions that are already running. Codex may ask you to trust the new hook on its first run. Node and a CLI version with lifecycle hooks are required. Explicitly disabled or policy-restricted hooks, remote SSH sessions, and custom CLI configuration directories that differ from VMark's environment cannot provide a binding.
+
+Each terminal follows its exact session rather than whichever transcript was modified most recently. The preview retains up to 100 assistant messages from the last 2 MiB of transcript data. Raw HTML and remote images remain inert; invalid diagrams remain readable as source. Disabling removes the rendered section and deactivates VMark's installed hooks.
+
 ### Accessibility
 
 | Setting | Options | Default |
diff --git a/website/it/guide/settings.md b/website/it/guide/settings.md
index 30067f727..bb3542b8d 100644
--- a/website/it/guide/settings.md
+++ b/website/it/guide/settings.md
@@ -448,6 +448,7 @@ Configura il pannello terminale integrato. Apri il terminale con `` Ctrl + ` ``.
 | Stile Cursore | Forma del cursore del terminale | Barra | Barra, Blocco, Sottolineato |
 | Cursore Lampeggiante | Se il cursore del terminale lampeggia | Attivo | Attivo / Off |
 | Copia alla Selezione | Copia automaticamente il testo selezionato nel terminale negli appunti | Off | Attivo / Off |
+| Visualizza automaticamente le trascrizioni | Mostra Markdown, tabelle e diagrammi Mermaid di Claude/Codex accanto alla CLI del terminale. Aggiunge un hook SessionStart locale alla configurazione di Claude Code e Codex; riavvia le sessioni CLI attive dopo l'attivazione | Off | Attivo / Off |
 | Renderer WebGL | Usa il rendering con accelerazione GPU per il terminale. Disabilita se si verificano problemi di input IME. Richiede il riavvio del terminale | Attivo | Attivo / Off |
 | Appunti remoti (OSC 52) | Consente ai programmi in esecuzione nel terminale — via ssh, dentro tmux — di copiare negli appunti di sistema. Il canale è di sola scrittura: la lettura degli appunti è sempre rifiutata, poiché qualsiasi output stampato nel terminale potrebbe richiederla | Attivo | Attivo / Off |
 | Cronologia di scorrimento | Numero di righe di output che ogni sessione conserva nella cronologia di scorrimento. Valori più alti usano più memoria | 5.000 | 1.000 / 5.000 / 10.000 / 50.000 |
diff --git a/website/it/guide/terminal.md b/website/it/guide/terminal.md
index 34749cf01..5d700f46f 100644
--- a/website/it/guide/terminal.md
+++ b/website/it/guide/terminal.md
@@ -227,12 +227,23 @@ Apri **Impostazioni → Terminale** per configurare:
 | Dimensione carattere | 10 – 24 px | 13 px | Tutte |
 | Interlinea | 1.0 – 2.0 | 1.2 | Tutte |
 | Copia alla selezione | Attivo / Disattivato | Disattivato | Tutte |
+| Visualizza automaticamente le trascrizioni | Attivo / Disattivato | Disattivato | Tutte |
 | Option come tasto Meta | Attivo / Disattivato | Attivo | macOS |
 | Integrazione della shell | Attivo / Disattivato | Attivo | macOS / Linux (zsh, bash) |
 | Appunti remoti (OSC 52) | Attivo / Disattivato | Attivo | Tutte |
 | Cronologia di scorrimento | 1.000 / 5.000 / 10.000 / 50.000 righe | 5.000 | Tutte |
 | Modalità screen reader | Attivo / Disattivato | Disattivato | Tutte |
 
+### Visualizza automaticamente le trascrizioni
+
+Attiva **Visualizza automaticamente le trascrizioni** per mostrare il Markdown dell'assistente, tabelle selezionabili e diagrammi Mermaid in una sezione di trascrizione formattata all'interno dell'area del terminale. Si trova a destra della CLI quando il terminale è in alto o in basso, e sotto di essa quando il terminale è a sinistra o a destra; la CLI interattiva resta utilizzabile accanto.
+
+La sezione parte compressa. Si apre da sola quando una nuova risposta contiene una tabella o un diagramma Mermaid — le risposte in testo semplice, che il terminale mostra già bene, la lasciano chiusa. Fai clic sul pulsante del grafico nella barra delle schede del terminale (tooltip **Trascrizione formattata**) per mostrarla o nasconderla in qualsiasi momento; il pulsante è evidenziato mentre la trascrizione è visibile e nasconderla restituisce l'intera area alla CLI; dopo averla compressa, resta chiusa fino alla successiva risposta con una tabella o un diagramma. Il contenuto già presente nella trascrizione quando la sessione viene mostrata per la prima volta non la apre. Un terminale nascosto smette di leggere le trascrizioni.
+
+L'attivazione aggiunge un hook `SessionStart` locale al `settings.json` di Claude Code e al `hooks.json` di Codex, preservando gli hook esistenti. Dopo l'attivazione, avvia o riprendi Claude/Codex in un terminale di VMark; riavvia le sessioni già in esecuzione. Codex potrebbe chiederti di considerare attendibile il nuovo hook alla prima esecuzione. Sono richiesti Node e una versione della CLI con gli hook del ciclo di vita. Gli hook disattivati esplicitamente o limitati da criteri, le sessioni SSH remote e le directory di configurazione personalizzate della CLI diverse dall'ambiente di VMark non possono fornire un collegamento.
+
+Ogni terminale segue esattamente la propria sessione anziché la trascrizione modificata più di recente. L'anteprima conserva fino a 100 messaggi dell'assistente dagli ultimi 2 MiB di dati della trascrizione. L'HTML grezzo e le immagini remote restano inerti; i diagrammi non validi restano leggibili come sorgente. La disattivazione rimuove la sezione formattata e disattiva gli hook installati da VMark.
+
 ### Accessibilità
 
 | Impostazione | Opzioni | Predefinito |
diff --git a/website/ja/guide/settings.md b/website/ja/guide/settings.md
index 64c41a51d..ac3dbaf08 100644
--- a/website/ja/guide/settings.md
+++ b/website/ja/guide/settings.md
@@ -424,6 +424,7 @@ GUI 設定は環境変数より優先されます — 明示的なものが暗
 | カーソルスタイル | ターミナルカーソルの形状 | Bar | Bar、Block、Underline |
 | カーソルの点滅 | ターミナルカーソルが点滅するかどうか | オン | オン/オフ |
 | 選択時にコピー | 選択したターミナルテキストを自動的にクリップボードにコピー | オフ | オン/オフ |
+| 会話記録を自動表示 | Claude/Codex の Markdown、表、Mermaid 図をターミナルの CLI の横に表示します。Claude Code と Codex の設定にローカルの SessionStart フックを追加します。有効化後、実行中の CLI セッションを再起動してください | オフ | オン/オフ |
 | WebGL レンダラー | ターミナルに GPU アクセラレーションレンダリングを使用します。IME の入力問題が発生した場合は無効にしてください。ターミナルの再起動が必要です | オン | オン/オフ |
 | リモートクリップボード（OSC 52） | ターミナル内で実行されるプログラム — ssh 越しや tmux 内 — がシステムのクリップボードにコピーできるようにします。このチャネルは書き込み専用です。ターミナルに出力されたどんな内容でも要求できてしまうため、クリップボードの読み取りは常に拒否されます | オン | オン/オフ |
 | スクロールバック | 各セッションがスクロール履歴に保持する出力の行数。値を大きくするとメモリ使用量が増えます | 5,000 | 1,000 / 5,000 / 10,000 / 50,000 |
diff --git a/website/ja/guide/terminal.md b/website/ja/guide/terminal.md
index 3dee51536..6faeeefe6 100644
--- a/website/ja/guide/terminal.md
+++ b/website/ja/guide/terminal.md
@@ -180,12 +180,23 @@ BlackHole などの仮想オーディオ入力では、権限だけでは音声
 | フォントサイズ | 10〜24 px | 13 px | すべて |
 | 行の高さ | 1.0〜2.0 | 1.2 | すべて |
 | 選択時にコピー | オン／オフ | オフ | すべて |
+| 会話記録を自動表示 | オン／オフ | オフ | すべて |
 | Option を Meta キーとして使用 | オン／オフ | オン | macOS |
 | シェル統合 | オン／オフ | オン | macOS / Linux（zsh、bash） |
 | リモートクリップボード（OSC 52） | オン／オフ | オン | すべて |
 | スクロールバック | 1,000 / 5,000 / 10,000 / 50,000 行 | 5,000 | すべて |
 | スクリーンリーダーモード | オン／オフ | オフ | すべて |
 
+### 会話記録を自動表示
+
+**会話記録を自動表示** を有効にすると、アシスタントの Markdown、選択可能な表、Mermaid 図が、ターミナル領域内の整形済み会話記録セクションに表示されます。ターミナルが上部または下部にあるときは CLI の右側に、左側または右側にあるときは CLI の下に配置され、対話型 CLI はその横で引き続き使用できます。
+
+このセクションは折りたたまれた状態で始まります。新しい返信に表や Mermaid 図が含まれていると自動的に開きます — ターミナルでも十分に表示できるプレーンテキストの返信では閉じたままです。ターミナルのタブバーにあるグラフボタン（ツールチップ **整形された会話記録**）をクリックすると、いつでも表示・非表示を切り替えられます。会話記録の表示中はボタンが強調表示され、非表示にすると領域全体が CLI に戻ります。折りたたんだ後は、表や図を含む次の返信が届くまで閉じたままです。セッションが初めて表示された時点で会話記録にすでにある内容では開きません。非表示のターミナルは会話記録の読み取りを停止します。
+
+有効にすると、既存のフックを保持したまま、Claude Code の `settings.json` と Codex の `hooks.json` にローカルの `SessionStart` フックが追加されます。有効にした後、VMark のターミナルで Claude/Codex を起動または再開してください。すでに実行中のセッションは再起動してください。Codex は初回実行時に新しいフックを信頼するよう求めることがあります。Node と、ライフサイクルフックに対応した CLI バージョンが必要です。明示的に無効化されたフックやポリシーで制限されたフック、リモート SSH セッション、VMark の環境と異なるカスタム CLI 設定ディレクトリでは、紐付けを確立できません。
+
+各ターミナルは、最も新しく更新された会話記録ではなく、自身の正確なセッションを追跡します。プレビューは、会話記録データの末尾 2 MiB から最大 100 件のアシスタントメッセージを保持します。生の HTML とリモート画像は作用しません。不正な図はソースとして読める状態で残ります。無効にすると整形済みセクションが削除され、VMark がインストールしたフックが無効化されます。
+
 ### アクセシビリティ
 
 | 設定 | オプション | デフォルト |
diff --git a/website/ko/guide/settings.md b/website/ko/guide/settings.md
index f38ed4f35..6158ca743 100644
--- a/website/ko/guide/settings.md
+++ b/website/ko/guide/settings.md
@@ -444,6 +444,7 @@ GUI 설정이 환경 변수보다 우선합니다 — 명시적인 것이 암묵
 | 커서 스타일 | 터미널 커서의 모양 | 바 | 바, 블록, 밑줄 |
 | 커서 깜빡임 | 터미널 커서 깜빡임 여부 | 켜기 | 켜기 / 끄기 |
 | 선택 시 복사 | 선택된 터미널 텍스트를 클립보드에 자동 복사 | 끄기 | 켜기 / 끄기 |
+| 대화 기록 자동 렌더링 | 터미널 CLI 옆에 Claude/Codex의 Markdown, 표, Mermaid 다이어그램을 표시합니다. Claude Code와 Codex 구성에 로컬 SessionStart 훅을 추가합니다. 활성화한 후 실행 중인 CLI 세션을 다시 시작하세요 | 끄기 | 켜기 / 끄기 |
 | WebGL 렌더러 | 터미널에 GPU 가속 렌더링 사용. IME 입력 문제가 발생하면 비활성화합니다. 터미널 재시작 필요 | 켜기 | 켜기 / 끄기 |
 | 원격 클립보드 (OSC 52) | 터미널에서 실행 중인 프로그램이 — ssh 너머나 tmux 안에서 — 시스템 클립보드로 복사하도록 허용합니다. 이 채널은 쓰기 전용입니다: 터미널에 출력되는 어떤 내용이든 읽기를 요청할 수 있으므로 클립보드 읽기는 항상 거부됩니다 | 켜기 | 켜기 / 끄기 |
 | 스크롤백 | 각 세션이 스크롤 기록에 보관하는 출력 줄 수. 값이 클수록 메모리를 더 많이 사용합니다 | 5,000 | 1,000 / 5,000 / 10,000 / 50,000 |
diff --git a/website/ko/guide/terminal.md b/website/ko/guide/terminal.md
index 21265e29d..c3c57c4b3 100644
--- a/website/ko/guide/terminal.md
+++ b/website/ko/guide/terminal.md
@@ -215,12 +215,23 @@ BlackHole 같은 가상 오디오 입력의 경우 권한만으로는 오디오
 | 글꼴 크기 | 10 – 24 px | 13 px | 모두 |
 | 줄 높이 | 1.0 – 2.0 | 1.2 | 모두 |
 | 선택 시 복사 | 켜기 / 끄기 | 끄기 | 모두 |
+| 대화 기록 자동 렌더링 | 켜기 / 끄기 | 끄기 | 모두 |
 | Mac Option을 Meta로 | 켜기 / 끄기 | 켜기 | macOS |
 | 셸 통합 | 켜기 / 끄기 | 켜기 | macOS / Linux (zsh, bash) |
 | 원격 클립보드 (OSC 52) | 켜기 / 끄기 | 켜기 | 모두 |
 | 스크롤백 | 1,000 / 5,000 / 10,000 / 50,000줄 | 5,000 | 모두 |
 | 스크린 리더 모드 | 켜기 / 끄기 | 끄기 | 모두 |
 
+### 대화 기록 자동 렌더링
+
+**대화 기록 자동 렌더링**을 활성화하면 어시스턴트의 Markdown, 선택 가능한 표, Mermaid 다이어그램이 터미널 영역 안의 렌더링된 대화 기록 섹션에 표시됩니다. 터미널이 위쪽이나 아래쪽에 있으면 CLI의 오른쪽에, 왼쪽이나 오른쪽에 있으면 CLI 아래에 배치되며, 대화형 CLI는 그 옆에서 계속 사용할 수 있습니다.
+
+이 섹션은 접힌 상태로 시작합니다. 새 응답에 표나 Mermaid 다이어그램이 포함되면 자동으로 열립니다 — 터미널이 이미 잘 표시하는 일반 텍스트 응답에서는 닫힌 상태로 유지됩니다. 터미널 탭 바의 차트 버튼(툴팁 **렌더링된 대화 기록**)을 클릭하면 언제든지 표시하거나 숨길 수 있습니다. 대화 기록이 표시되는 동안 버튼이 강조 표시되며, 숨기면 전체 영역이 다시 CLI에 돌아갑니다. 접은 뒤에는 표나 다이어그램이 포함된 다음 응답이 올 때까지 닫힌 상태로 유지됩니다. 세션이 처음 표시될 때 대화 기록에 이미 있던 내용으로는 열리지 않습니다. 숨겨진 터미널은 대화 기록 읽기를 중단합니다.
+
+활성화하면 기존 훅을 유지한 채 Claude Code의 `settings.json`과 Codex의 `hooks.json`에 로컬 `SessionStart` 훅이 추가됩니다. 활성화한 후 VMark 터미널에서 Claude/Codex를 시작하거나 재개하세요. 이미 실행 중인 세션은 다시 시작하세요. Codex는 처음 실행할 때 새 훅을 신뢰할지 물어볼 수 있습니다. Node와 라이프사이클 훅을 지원하는 CLI 버전이 필요합니다. 명시적으로 비활성화되었거나 정책으로 제한된 훅, 원격 SSH 세션, VMark 환경과 다른 사용자 지정 CLI 구성 디렉터리에서는 연결을 설정할 수 없습니다.
+
+각 터미널은 가장 최근에 수정된 대화 기록이 아니라 자신의 정확한 세션을 따라갑니다. 미리보기는 대화 기록 데이터의 마지막 2 MiB에서 최대 100개의 어시스턴트 메시지를 보관합니다. 원시 HTML과 원격 이미지는 동작하지 않는 상태로 유지되며, 잘못된 다이어그램은 소스 형태로 읽을 수 있게 남습니다. 비활성화하면 렌더링된 섹션이 제거되고 VMark가 설치한 훅이 비활성화됩니다.
+
 ### 접근성
 
 | 설정 | 옵션 | 기본값 |
diff --git a/website/pt-BR/guide/settings.md b/website/pt-BR/guide/settings.md
index c8ce58ecc..afa1d05ab 100644
--- a/website/pt-BR/guide/settings.md
+++ b/website/pt-BR/guide/settings.md
@@ -443,6 +443,7 @@ Configure o painel de terminal integrado. Abra o terminal com `` Ctrl + ` ``.
 | Estilo do Cursor | Forma do cursor do terminal | Barra | Barra, Bloco, Sublinhado |
 | Cursor Piscante | Se o cursor do terminal pisca | Ligado | Ligado / Desligado |
 | Copiar ao Selecionar | Copiar automaticamente o texto do terminal selecionado para a área de transferência | Desligado | Ligado / Desligado |
+| Renderizar transcrições automaticamente | Exibir Markdown, tabelas e diagramas Mermaid do Claude/Codex ao lado da CLI do terminal. Adiciona um hook SessionStart local à configuração do Claude Code e do Codex; reinicie as sessões CLI em execução após ativar | Desligado | Ligado / Desligado |
 | Renderizador WebGL | Usar renderização acelerada por GPU para o terminal. Desabilite se tiver problemas de entrada IME. Requer reinício do terminal | Ligado | Ligado / Desligado |
 | Área de transferência remota (OSC 52) | Permitir que programas em execução no terminal — por ssh, dentro do tmux — copiem para a área de transferência do sistema. O canal é somente de escrita: a leitura da área de transferência é sempre recusada, pois qualquer saída impressa no terminal poderia solicitá-la | Ligado | Ligado / Desligado |
 | Histórico de rolagem | Número de linhas de saída que cada sessão mantém no histórico de rolagem. Valores maiores usam mais memória | 5.000 | 1.000 / 5.000 / 10.000 / 50.000 |
diff --git a/website/pt-BR/guide/terminal.md b/website/pt-BR/guide/terminal.md
index bf8183896..baf86b99f 100644
--- a/website/pt-BR/guide/terminal.md
+++ b/website/pt-BR/guide/terminal.md
@@ -225,12 +225,23 @@ Abra **Configurações → Terminal** para configurar:
 | Tamanho da fonte | 10 – 24 px | 13 px | Todas |
 | Altura da linha | 1.0 – 2.0 | 1.2 | Todas |
 | Copiar ao selecionar | Ligado / Desligado | Desligado | Todas |
+| Renderizar transcrições automaticamente | Ligado / Desligado | Desligado | Todas |
 | Option como tecla Meta | Ligado / Desligado | Ligado | macOS |
 | Integração com o shell | Ligado / Desligado | Ligado | macOS / Linux (zsh, bash) |
 | Área de transferência remota (OSC 52) | Ligado / Desligado | Ligado | Todas |
 | Histórico de rolagem | 1.000 / 5.000 / 10.000 / 50.000 linhas | 5.000 | Todas |
 | Modo leitor de tela | Ligado / Desligado | Desligado | Todas |
 
+### Renderizar transcrições automaticamente
+
+Ative **Renderizar transcrições automaticamente** para exibir o Markdown do assistente, tabelas selecionáveis e diagramas Mermaid em uma seção de transcrição formatada dentro da área do terminal. Ela fica à direita da CLI quando o terminal está no topo ou na parte inferior, e abaixo dela quando o terminal está à esquerda ou à direita; a CLI interativa continua utilizável ao lado.
+
+A seção começa recolhida. Ela se abre sozinha quando uma nova resposta contém uma tabela ou um diagrama Mermaid — respostas em texto simples, que o terminal já exibe bem, a mantêm fechada. Clique no botão de gráfico na barra de abas do terminal (dica **Transcrição formatada**) para mostrá-la ou ocultá-la a qualquer momento; o botão fica destacado enquanto a transcrição está visível, e ocultá-la devolve toda a área à CLI; depois que você a recolhe, ela permanece fechada até a próxima resposta com uma tabela ou um diagrama. O conteúdo que já está na transcrição quando a sessão é exibida pela primeira vez não a abre. Um terminal oculto para de ler transcrições.
+
+Ao ativar, um hook `SessionStart` local é adicionado ao `settings.json` do Claude Code e ao `hooks.json` do Codex, preservando os hooks existentes. Depois de ativar, inicie ou retome o Claude/Codex em um terminal do VMark; reinicie as sessões que já estão em execução. O Codex pode pedir que você confie no novo hook na primeira execução. São necessários o Node e uma versão da CLI com hooks de ciclo de vida. Hooks explicitamente desativados ou restringidos por política, sessões SSH remotas e diretórios de configuração personalizados da CLI que diferem do ambiente do VMark não conseguem fornecer um vínculo.
+
+Cada terminal acompanha exatamente a sua sessão, em vez da transcrição modificada mais recentemente. A pré-visualização mantém até 100 mensagens do assistente dos últimos 2 MiB de dados da transcrição. HTML bruto e imagens remotas permanecem inertes; diagramas inválidos continuam legíveis como código-fonte. Ao desativar, a seção formatada é removida e os hooks instalados pelo VMark são desativados.
+
 ### Acessibilidade
 
 | Configuração | Opções | Padrão |
diff --git a/website/zh-CN/guide/settings.md b/website/zh-CN/guide/settings.md
index 9b4e6c11b..c903b8f98 100644
--- a/website/zh-CN/guide/settings.md
+++ b/website/zh-CN/guide/settings.md
@@ -424,6 +424,7 @@ Markdown、纯文本和 YAML/YML **始终**已注册 —— 这是默认的稳
 | 光标样式 | 终端光标的形状 | 竖线 | 竖线、方块、下划线 |
 | 光标闪烁 | 终端光标是否闪烁 | 开启 | 开启/关闭 |
 | 选中即复制 | 自动将选中的终端文本复制到剪贴板 | 关闭 | 开启/关闭 |
+| 自动渲染对话记录 | 在终端 CLI 旁渲染 Claude/Codex 的 Markdown、表格和 Mermaid 图表。启用时会在 Claude Code 和 Codex 的配置中添加本地 SessionStart 钩子；启用后请重启正在运行的 CLI 会话 | 关闭 | 开启/关闭 |
 | WebGL 渲染器 | 使用 GPU 加速渲染终端，如遇输入法输入问题请禁用，需要重启终端 | 开启 | 开启/关闭 |
 | 远程剪贴板（OSC 52） | 允许在终端中运行的程序 —— 通过 ssh 或在 tmux 内 —— 复制到你的系统剪贴板。该通道只写：读取剪贴板的请求始终被拒绝，因为终端中打印的任何输出都可能发出这种请求 | 开启 | 开启/关闭 |
 | 回滚缓冲区 | 每个会话在滚动历史中保留的输出行数，数值越大占用内存越多 | 5,000 | 1,000 / 5,000 / 10,000 / 50,000 |
diff --git a/website/zh-CN/guide/terminal.md b/website/zh-CN/guide/terminal.md
index 790e4624b..9e62bd81a 100644
--- a/website/zh-CN/guide/terminal.md
+++ b/website/zh-CN/guide/terminal.md
@@ -180,12 +180,23 @@ VMark 有意**不**设置 `EDITOR`。`git commit`、`crontab -e` 等命令会启
 | 字体大小 | 10 – 24 px | 13 px | 全部 |
 | 行高 | 1.0 – 2.0 | 1.2 | 全部 |
 | 选中时复制 | 开 / 关 | 关 | 全部 |
+| 自动渲染对话记录 | 开 / 关 | 关 | 全部 |
 | 将 Option 用作 Meta 键 | 开 / 关 | 开 | macOS |
 | Shell 集成 | 开 / 关 | 开 | macOS / Linux（zsh、bash） |
 | 远程剪贴板（OSC 52） | 开 / 关 | 开 | 全部 |
 | 回滚缓冲区 | 1,000 / 5,000 / 10,000 / 50,000 行 | 5,000 | 全部 |
 | 屏幕阅读器模式 | 开 / 关 | 关 | 全部 |
 
+### 自动渲染对话记录
+
+启用 **自动渲染对话记录** 后，助手回复中的 Markdown、可选中的表格和 Mermaid 图表会显示在终端区域内的渲染对话记录区中。终端位于顶部或底部时，该区位于 CLI 右侧；终端位于左侧或右侧时，该区位于 CLI 下方；交互式 CLI 在旁边始终可用。
+
+该区默认折叠。当新回复包含表格或 Mermaid 图表时，它会自动展开——纯文本回复本来就能在终端中良好显示，不会使其展开。随时点击终端标签栏中的图表按钮（工具提示为 **渲染后的对话记录**）即可显示或隐藏该区；显示对话记录时按钮会高亮，隐藏后 CLI 重新占据整个区域；手动折叠后，它会保持关闭，直到下一条包含表格或图表的回复到来。首次显示会话时对话记录中已有的内容不会使其展开。隐藏的终端会停止读取对话记录。
+
+启用时，VMark 会在 Claude Code 的 `settings.json` 和 Codex 的 `hooks.json` 中添加一个本地 `SessionStart` 钩子，并保留已有的钩子。启用后，请在 VMark 终端中启动或恢复 Claude/Codex；已在运行的会话需要重启。Codex 首次运行时可能会要求你信任这个新钩子。需要安装 Node，且 CLI 版本须支持生命周期钩子。被明确禁用或受策略限制的钩子、远程 SSH 会话，以及与 VMark 环境不同的自定义 CLI 配置目录，都无法建立绑定。
+
+每个终端都跟随其对应的确切会话，而不是最近修改的那份对话记录。预览最多保留对话记录数据最后 2 MiB 中的 100 条助手消息。原始 HTML 和远程图片保持惰性，不会生效；无效的图表仍以源代码形式可读。禁用后会移除渲染区域，并停用 VMark 安装的钩子。
+
 ### 无障碍
 
 | 设置 | 选项 | 默认值 |
diff --git a/website/zh-TW/guide/settings.md b/website/zh-TW/guide/settings.md
index 34a4f5fbc..8e025963d 100644
--- a/website/zh-TW/guide/settings.md
+++ b/website/zh-TW/guide/settings.md
@@ -424,6 +424,7 @@ Markdown、純文字和 YAML/YML **一律**已登錄 — 這是沉穩的預設
 | 游標樣式 | 終端機游標的形狀 | 直線 | 直線、方塊、底線 |
 | 游標閃爍 | 終端機游標是否閃爍 | 開啟 | 開啟 / 關閉 |
 | 選取時複製 | 自動將選取的終端機文字複製至剪貼簿 | 關閉 | 開啟 / 關閉 |
+| 自動渲染對話記錄 | 在終端機 CLI 旁渲染 Claude/Codex 的 Markdown、表格和 Mermaid 圖表。啟用時會在 Claude Code 與 Codex 的設定中新增本機 SessionStart 鉤子；啟用後請重新啟動正在執行的 CLI 工作階段 | 關閉 | 開啟 / 關閉 |
 | WebGL 渲染器 | 使用 GPU 加速渲染終端機。如果遇到輸入法輸入問題，請停用。需要重新啟動終端機 | 開啟 | 開啟 / 關閉 |
 | 遠端剪貼簿（OSC 52） | 允許終端機中執行的程式 — 透過 ssh 或在 tmux 內 — 複製到系統剪貼簿。此通道只允許寫入：讀取剪貼簿一律被拒絕，因為任何列印到終端機的輸出都可能發出讀取請求 | 開啟 | 開啟 / 關閉 |
 | 回捲緩衝區 | 每個工作階段在捲動歷史中保留的輸出行數。數值越大佔用記憶體越多 | 5,000 | 1,000 / 5,000 / 10,000 / 50,000 |
diff --git a/website/zh-TW/guide/terminal.md b/website/zh-TW/guide/terminal.md
index 563a764c7..0989e77af 100644
--- a/website/zh-TW/guide/terminal.md
+++ b/website/zh-TW/guide/terminal.md
@@ -180,12 +180,23 @@ VMark 刻意**不**設定 `EDITOR`。`git commit`、`crontab -e` 等會啟動的
 | 字型大小 | 10 – 24 px | 13 px | 全部 |
 | 行高 | 1.0 – 2.0 | 1.2 | 全部 |
 | 選取即複製 | 開/關 | 關 | 全部 |
+| 自動渲染對話記錄 | 開/關 | 關 | 全部 |
 | 將 Option 作為 Meta 鍵 | 開/關 | 開 | macOS |
 | Shell 整合 | 開/關 | 開 | macOS / Linux（zsh、bash） |
 | 遠端剪貼簿（OSC 52） | 開/關 | 開 | 全部 |
 | 回捲緩衝區 | 1,000 / 5,000 / 10,000 / 50,000 行 | 5,000 | 全部 |
 | 螢幕閱讀器模式 | 開/關 | 關 | 全部 |
 
+### 自動渲染對話記錄
+
+啟用 **自動渲染對話記錄** 後，助理回覆中的 Markdown、可選取的表格和 Mermaid 圖表會顯示在終端機區域內的渲染對話記錄區。終端機位於頂部或底部時，此區位於 CLI 右側；終端機位於左側或右側時，此區位於 CLI 下方；互動式 CLI 在旁邊始終可用。
+
+此區預設為收合。當新回覆包含表格或 Mermaid 圖表時，它會自動展開 — 純文字回覆本來就能在終端機中清楚顯示，不會使其展開。隨時按一下終端機標籤列中的圖表按鈕（工具提示為 **渲染後的對話記錄**）即可顯示或隱藏此區；顯示對話記錄時按鈕會醒目提示，隱藏後 CLI 會重新佔滿整個區域；手動收合後，它會保持關閉，直到下一則包含表格或圖表的回覆出現。首次顯示工作階段時對話記錄中已有的內容不會使其展開。隱藏的終端機會停止讀取對話記錄。
+
+啟用時，VMark 會在 Claude Code 的 `settings.json` 與 Codex 的 `hooks.json` 中新增一個本機 `SessionStart` 鉤子，並保留既有的鉤子。啟用後，請在 VMark 終端機中啟動或恢復 Claude/Codex；已在執行的工作階段需要重新啟動。Codex 首次執行時可能會要求你信任這個新鉤子。需要安裝 Node，且 CLI 版本須支援生命週期鉤子。被明確停用或受政策限制的鉤子、遠端 SSH 工作階段，以及與 VMark 環境不同的自訂 CLI 設定目錄，都無法建立繫結。
+
+每個終端機都會追蹤其對應的確切工作階段，而不是最近修改的那份對話記錄。預覽最多保留對話記錄資料最後 2 MiB 中的 100 則助理訊息。原始 HTML 與遠端圖片保持惰性，不會生效；無效的圖表仍可作為原始碼閱讀。停用後會移除渲染區域，並停用 VMark 安裝的鉤子。
+
 ### 無障礙
 
 | 設定 | 選項 | 預設值 |