chainlesschain 0.162.157 → 0.162.159

package/src/repl/agent-repl.js

@@ -47,6 +47,7 @@ import {
   appendAssistantMessage,
   appendCompactEvent,
   appendTokenUsage,
+  appendToolCallCompact,
   rebuildMessages,
   sessionExists,
 } from "../harness/jsonl-session-store.js";
@@ -111,6 +112,7 @@ import {
   resolveAskIdleTimeoutMs,
   questionWithIdleTimeout,
 } from "./permission-prompt.js";
+import { describeAskContext, raceLocalAndRemote } from "./remote-approval.js";
 import {
   parsePermissionTier,
   parsePermissionModeArg,
@@ -315,6 +317,25 @@ export async function agentLoop(messages, options) {
         ),
       );
     } else if (event.type === "tool-result") {
+      // 用量归因: persist a compact tool_call record (name + error flag +
+      // skill hint — never args, which can carry whole file bodies) so
+      // `cc session usage --by tool|mcp` and `cc insights` can aggregate
+      // tool use for REPL sessions. Best-effort; opt out with
+      // options.persistToolCalls === false.
+      if (options.sessionId && options.persistToolCalls !== false) {
+        try {
+          appendToolCallCompact(options.sessionId, {
+            tool: event.tool,
+            isError: Boolean(event.error || event.result?.error),
+            skill:
+              event.tool === "run_skill" && _lastExec?.tool === "run_skill"
+                ? _lastExec.args?.skill_name
+                : undefined,
+          });
+        } catch (_e) {
+          // persistence is best-effort — never break the turn
+        }
+      }
       if (event.error || event.result?.error) {
         process.stdout.write(
           chalk.red(`  Error: ${event.error || event.result?.error}\n`),
@@ -448,6 +469,11 @@ export async function startAgentRepl(options = {}) {
   // gate is wired. The wrapper is installed only when settings customize the
   // map, and only bites while _sessionTier === "auto" (isActive predicate).
   let _autoModeResolved = null;
+  // `/remote-control` (批17/18 REPL 收口): paired-device approvals for this
+  // interactive session. Holds { bridge, pairing, close } while active; both
+  // interactive confirmers below race the terminal against the paired device
+  // (first answer wins). null = local-only (byte-identical prompt path).
+  let _remoteApproval = null;
   const baseUrl = options.baseUrl || "http://localhost:11434";
   const apiKey = options.apiKey || null;
   // Configured vision model (config.llm.visionModel) — used when a turn carries
@@ -617,54 +643,79 @@ export async function startAgentRepl(options = {}) {
       _autoModeResolved = null; // fail to the plain gate tiers
     }
     if (typeof _approvalGate.setConfirmer === "function") {
-      _approvalGate.setConfirmer(async ({ tool, args, riskLevel }) => {
-        if (_dontAskActive()) {
-          process.stdout.write(
-            chalk.yellow(
-              `\n  ✕ denied without asking (dontAsk mode): ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}\n`,
-            ),
-          );
-          return false;
-        }
-        await _fireNotification(
-          `Permission needed: ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}`,
-        );
+      // The local prompt as a cancelable handle so an active /remote-control
+      // can race it against a paired device: cancel closes the readline when
+      // the device answers first, and `canceled` mutes the stranded
+      // idle-timeout leg so it can't print "auto-denied" after the fact.
+      const askGateApprovalLocally = ({ tool, args, riskLevel }) => {
         const rlConfirm = readline.createInterface({
           input: process.stdin,
           output: process.stdout,
         });
+        let canceled = false;
         const q = (p) => new Promise((res) => rlConfirm.question(p, res));
         const cmd = args?.command ? ` ${args.command}` : "";
-        const res = await questionWithIdleTimeout(
-          q,
-          chalk.yellow(
-            `\n[ApprovalGate] ${riskLevel || "medium"} risk command:${cmd}\n` +
-              `  Proceed? [y]es once / [a]lways allow / [N]o: `,
-          ),
-          _askIdleTimeoutMs,
-        );
-        rlConfirm.close();
-        if (res.timedOut) {
-          process.stdout.write(
+        const promise = (async () => {
+          const res = await questionWithIdleTimeout(
+            q,
             chalk.yellow(
-              `\n  ⏱ no response in ${_askIdleTimeoutMs}ms — auto-denied\n`,
+              `\n[ApprovalGate] ${riskLevel || "medium"} risk command:${cmd}\n` +
+                `  Proceed? [y]es once / [a]lways allow / [N]o: `,
             ),
+            _askIdleTimeoutMs,
           );
-          return false;
-        }
-        const ans = res.answer.trim().toLowerCase();
-        if (ans === "a" || ans === "always") {
-          const saved = await _persistAlwaysAllow(tool || "run_shell", args);
-          if (saved) {
+          rlConfirm.close();
+          if (canceled) return false; // raced out — the device already decided
+          if (res.timedOut) {
             process.stdout.write(
-              chalk.green(
-                `  ✓ always allow: added ${saved.rule} → ${saved.file}\n`,
+              chalk.yellow(
+                `\n  ⏱ no response in ${_askIdleTimeoutMs}ms — auto-denied\n`,
               ),
             );
+            return false;
           }
-          return true;
+          const ans = res.answer.trim().toLowerCase();
+          if (ans === "a" || ans === "always") {
+            const saved = await _persistAlwaysAllow(tool || "run_shell", args);
+            if (saved) {
+              process.stdout.write(
+                chalk.green(
+                  `  ✓ always allow: added ${saved.rule} → ${saved.file}\n`,
+                ),
+              );
+            }
+            return true;
+          }
+          return ans === "y" || ans === "yes";
+        })();
+        return {
+          promise,
+          cancel: () => {
+            canceled = true;
+            rlConfirm.close();
+          },
+        };
+      };
+      _approvalGate.setConfirmer(async ({ tool, args, riskLevel }) => {
+        if (_dontAskActive()) {
+          process.stdout.write(
+            chalk.yellow(
+              `\n  ✕ denied without asking (dontAsk mode): ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}\n`,
+            ),
+          );
+          return false;
         }
-        return ans === "y" || ans === "yes";
+        await _fireNotification(
+          `Permission needed: ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}`,
+        );
+        const local = askGateApprovalLocally({ tool, args, riskLevel });
+        if (!_remoteApproval?.bridge) return local.promise;
+        return raceLocalAndRemote({
+          bridge: _remoteApproval.bridge,
+          ask: describeAskContext({ tool, args, riskLevel }),
+          local,
+          writeOut: (text) => process.stdout.write(chalk.cyan(text)),
+        });
       });
     }
   } catch (_err) {
@@ -693,45 +744,68 @@ export async function startAgentRepl(options = {}) {
       loaded.rules.ask.length +
       loaded.rules.deny.length;
     _permissionRules = total > 0 ? loaded.rules : null;
-    // Confirmer is shared by permission `ask` rules AND hook `ask` decisions,
-    // so define it unconditionally (a `hook:` rule label flows through too).
-    _permissionConfirm = async ({ tool, args, rule, reason }) => {
-      if (_dontAskActive()) {
-        process.stdout.write(
-          chalk.yellow(
-            `\n  ✕ denied without asking (dontAsk mode): ${tool}${rule ? ` (${rule})` : reason ? ` — ${reason}` : ""}\n`,
-          ),
-        );
-        return false;
-      }
-      await _fireNotification(
-        `Permission needed: ${tool}${rule ? " (" + rule + ")" : ""}`,
-      );
+    // Local prompt as a cancelable handle (same shape as the gate confirmer
+    // above) so /remote-control can race it against a paired device.
+    const askPermissionLocally = ({ tool, args, rule, reason }) => {
       const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
       });
+      let canceled = false;
       const q = (p) => new Promise((res) => rl.question(p, res));
       // Picks the right phrasing whether the caller passed a `rule`
       // (settings/hook ask) or a `reason` (destructive-git / sensitive-file
       // guards) — avoids the literal "null" the old template printed.
       const header = buildPermissionPrompt({ tool, args, rule, reason });
-      const res = await questionWithIdleTimeout(
-        q,
-        chalk.yellow(`\n${header}\n  Proceed? (y/N) `),
-        _askIdleTimeoutMs,
-      );
-      rl.close();
-      if (res.timedOut) {
+      const promise = (async () => {
+        const res = await questionWithIdleTimeout(
+          q,
+          chalk.yellow(`\n${header}\n  Proceed? (y/N) `),
+          _askIdleTimeoutMs,
+        );
+        rl.close();
+        if (canceled) return false; // raced out — the device already decided
+        if (res.timedOut) {
+          process.stdout.write(
+            chalk.yellow(
+              `\n  ⏱ no response in ${_askIdleTimeoutMs}ms — auto-denied\n`,
+            ),
+          );
+          return false;
+        }
+        const ans = res.answer.trim().toLowerCase();
+        return ans === "y" || ans === "yes";
+      })();
+      return {
+        promise,
+        cancel: () => {
+          canceled = true;
+          rl.close();
+        },
+      };
+    };
+    // Confirmer is shared by permission `ask` rules AND hook `ask` decisions,
+    // so define it unconditionally (a `hook:` rule label flows through too).
+    _permissionConfirm = async ({ tool, args, rule, reason }) => {
+      if (_dontAskActive()) {
         process.stdout.write(
           chalk.yellow(
-            `\n  ⏱ no response in ${_askIdleTimeoutMs}ms — auto-denied\n`,
+            `\n  ✕ denied without asking (dontAsk mode): ${tool}${rule ? ` (${rule})` : reason ? ` — ${reason}` : ""}\n`,
           ),
         );
         return false;
       }
-      const ans = res.answer.trim().toLowerCase();
-      return ans === "y" || ans === "yes";
+      await _fireNotification(
+        `Permission needed: ${tool}${rule ? " (" + rule + ")" : ""}`,
+      );
+      const local = askPermissionLocally({ tool, args, rule, reason });
+      if (!_remoteApproval?.bridge) return local.promise;
+      return raceLocalAndRemote({
+        bridge: _remoteApproval.bridge,
+        ask: describeAskContext({ tool, args, rule, reason }),
+        local,
+        writeOut: (text) => process.stdout.write(chalk.cyan(text)),
+      });
     };
   } catch (_err) {
     if (_err?.code === "CC_MANAGED_SETTINGS_INVALID") throw _err;
@@ -900,6 +974,60 @@ export async function startAgentRepl(options = {}) {
     // Non-critical — SessionManager integration must not block startup
   }
 
+  // `/remote-control` start/stop (批17 slash 入口 + 批18 REPL 接线): reuses
+  // the headless assembly (self-hosted WS on an OS-assigned port + a
+  // RemoteApprovalBridge for this session); the interactive difference is
+  // purely how the confirmers consume it — they RACE the terminal prompt
+  // against the paired device instead of gating on the remote alone.
+  const _startRemoteApproval = async () => {
+    const { startHeadlessRemoteApproval } =
+      await import("../lib/remote-approval-bridge.js");
+    const started = await startHeadlessRemoteApproval({
+      agentSessionId:
+        sessionId || `repl-${process.pid}-${Date.now().toString(36)}`,
+      isText: false, // the REPL prints its own pairing lines below
+    });
+    _remoteApproval = {
+      bridge: started.bridge,
+      pairing: started.pairing,
+      close: started.close,
+    };
+    logger.log(
+      chalk.cyan(
+        "  remote-control: permission prompts can be answered from a paired device (first answer — terminal or device — wins)",
+      ),
+    );
+    logger.log(`  pairing: ${started.pairing.uri}`);
+    try {
+      const { renderQrCode } = await import("../lib/remote-control.js");
+      const qr = await renderQrCode(started.pairing.uri);
+      if (qr) logger.log(qr);
+    } catch (_err) {
+      // QR is progressive enhancement — the URI line is the contract
+    }
+  };
+  const _stopRemoteApproval = async () => {
+    const active = _remoteApproval;
+    _remoteApproval = null; // confirmers fall back to local-only immediately
+    if (active) await active.close().catch(() => undefined);
+  };
+
+  // --remote-control also applies to interactive sessions. Headless fails
+  // closed when the bridge can't start (approvals would silently fall
+  // closed); interactively the terminal still prompts, so a start failure
+  // degrades to local-only with a warning instead of aborting the session.
+  if (options.remoteControl === true) {
+    try {
+      await _startRemoteApproval();
+    } catch (err) {
+      logger.log(
+        chalk.yellow(
+          `  remote-control unavailable (${err.message}) — approvals stay local-only`,
+        ),
+      );
+    }
+  }
+
   // --system-prompt replaces the built-in prompt; --append-system-prompt
   // extends it (parity with the headless runners). The base is kept so an
   // output-style persona can be swapped in/out at runtime via /output-style.
@@ -1190,6 +1318,21 @@ export async function startAgentRepl(options = {}) {
   if (options.sessionId && sessionId) {
     try {
       if (useJsonl) {
+        // Interactive tamper warning: a broken hash chain means the transcript
+        // was edited outside the store — resume proceeds (the user is present)
+        // but the restored context is flagged untrusted.
+        try {
+          const { verifySession } =
+            await import("../harness/jsonl-session-store.js");
+          const trust = verifySession(sessionId);
+          if (trust.status === "tampered") {
+            logger.warn(
+              `⚠ Transcript integrity check FAILED (${trust.reason}) — restored context is untrusted. Run 'cc session verify ${sessionId}'.`,
+            );
+          }
+        } catch (_err) {
+          // verification is best-effort in the interactive path
+        }
         const rebuilt = rebuildMessages(sessionId);
         if (rebuilt.length > 0) {
           messages.push(...rebuilt.filter((m) => m.role !== "system"));
@@ -1305,6 +1448,84 @@ export async function startAgentRepl(options = {}) {
   // stored cli.theme is untouched — /theme still shows and can change it).
   if (_screenReaderMode) _theme = "mono";
   applyThemeChalk(_theme, chalk, _chalkBaselineLevel);
+
+  // Fullscreen / no-flicker TUI mode (Claude-Code `/tui` parity). Resolve from
+  // CC_NO_FLICKER (forces fullscreen) or persisted `cli.tuiMode`; switchable at
+  // runtime via `/tui fullscreen|default`. Screen-reader mode forces default —
+  // an alternate screen buffer breaks readers. The heavy renderer lives in
+  // fullscreen-tui.js; here we just track the mode and toggle the alt buffer.
+  const {
+    resolveTuiMode: _resolveTuiMode,
+    renderTuiStatus: _renderTuiStatus,
+    ALT_SCREEN_ENTER: _ALT_ENTER,
+    ALT_SCREEN_LEAVE: _ALT_LEAVE,
+  } = await import("./fullscreen-tui.js");
+  let _tuiMode = "default";
+  try {
+    const { getConfigValue } = await import("../lib/config-manager.js");
+    _tuiMode = _resolveTuiMode({
+      env: process.env.CC_NO_FLICKER,
+      setting: getConfigValue("cli.tuiMode"),
+    });
+  } catch (_e) {
+    _tuiMode = _resolveTuiMode({ env: process.env.CC_NO_FLICKER });
+  }
+  if (_screenReaderMode) _tuiMode = "default";
+  const _setTuiMode = (next) => {
+    if (next === _tuiMode) return;
+    // Enter/leave the alternate screen buffer so the user's scrollback is
+    // preserved either way. Only touch a real TTY.
+    if (process.stdout.isTTY) {
+      process.stdout.write(next === "fullscreen" ? _ALT_ENTER : _ALT_LEAVE);
+    }
+    _tuiMode = next;
+  };
+  if (_tuiMode === "fullscreen" && process.stdout.isTTY) {
+    process.stdout.write(_ALT_ENTER);
+  }
+
+  // Fast mode (Claude-Code `/fast` parity, generalized to a latency profile).
+  // When on, the next turn minimizes reasoning and — unless the user pinned a
+  // model this session — swaps to the provider's low-latency model. Resolved
+  // from config `cli.fastMode`; toggled at runtime via `/fast`. `_modelPinned`
+  // tracks an explicit `/model x` so fast mode never overrides a chosen model.
+  const {
+    parseFastCommand: _parseFastCommand,
+    resolveFastPlan: _resolveFastPlan,
+    renderFastStatus: _renderFastStatus,
+  } = await import("./fast-mode.js");
+  let _fastMode = false;
+  let _modelPinned = false;
+  try {
+    const { getConfigValue } = await import("../lib/config-manager.js");
+    _fastMode = getConfigValue("cli.fastMode") === true;
+  } catch (_e) {
+    /* config optional */
+  }
+
+  // Voice dictation (Claude-Code `/voice` parity). Local-first STT priority;
+  // degrades cleanly on headless/SSH. Real capture is a host binding — probed
+  // from config `voice.backends` (map of backend id → true) — so with no
+  // backend bundled, `/voice hold` reports how to enable one rather than
+  // pretending to listen. `voice.allowCloud` gates cloud transcription.
+  const {
+    parseVoiceCommand: _parseVoiceCommand,
+    resolveSttBackend: _resolveSttBackend,
+    detectVoiceEnvironment: _detectVoiceEnvironment,
+    renderVoiceStatus: _renderVoiceStatus,
+  } = await import("./voice-dictation.js");
+  let _voiceMode = "off";
+  let _voiceConfig = { backends: {}, allowCloud: false };
+  try {
+    const { getConfigValue } = await import("../lib/config-manager.js");
+    const v = getConfigValue("voice") || {};
+    _voiceConfig = {
+      backends: v.backends || {},
+      allowCloud: v.allowCloud === true,
+    };
+  } catch (_e) {
+    /* config optional */
+  }
   const themedPrompt = (text) => {
     const a = promptAccent(_theme);
     if (a === "blue") return chalk.blue(text);
@@ -1349,6 +1570,7 @@ export async function startAgentRepl(options = {}) {
           "/cd",
           "/clear",
           "/compact",
+          "/checkup",
           "/config",
           "/context",
           "/copy",
@@ -1358,6 +1580,7 @@ export async function startAgentRepl(options = {}) {
           "/effort",
           "/exit",
           "/export",
+          "/fast",
           "/help",
           "/hooks",
           "/ide",
@@ -1377,6 +1600,7 @@ export async function startAgentRepl(options = {}) {
           "/release-notes",
           "/reload-plugins",
           "/reload-skills",
+          "/remote-control",
           "/review",
           "/rewind",
           "/search",
@@ -1392,8 +1616,10 @@ export async function startAgentRepl(options = {}) {
           "/theme",
           "/think",
           "/todos",
+          "/tui",
           "/ultrathink",
           "/vim",
+          "/voice",
         ],
     // User/project custom commands (.claude/commands/*.md) join TAB completion
     // alongside the built-ins above. Sync + best-effort; the completer
@@ -1436,6 +1662,37 @@ export async function startAgentRepl(options = {}) {
   // "close" cleanup instead of a bare exit.
   _replRl = rl;
 
+  // Inbound channels (--channels, gap-2026-07-11 P0#5): external events enter
+  // this session as user turns. rl.emit("line") reuses the REPL's own input
+  // path, so an event landing mid-turn queues behind it (pending-lines), and
+  // the [channel:...] prefix keeps provenance visible while guaranteeing the
+  // injected line can never read as a slash command or shell escape.
+  let _channels = null;
+  if (options.channels) {
+    try {
+      const { startChannels, formatChannelEvent } =
+        await import("../lib/channels/channel-manager.js");
+      let channelsConfig = {};
+      try {
+        channelsConfig =
+          (await import("../lib/config-manager.js")).loadConfig()?.channels ||
+          {};
+      } catch (_err) {
+        // config read is best-effort; channels validate their own inputs
+      }
+      _channels = await startChannels(options.channels, {
+        config: channelsConfig,
+        onEvent: (event) => rl.emit("line", formatChannelEvent(event)),
+        log: (msg) => logger.info(msg),
+      });
+      for (const c of _channels.channels) {
+        logger.info(`channel ready: ${c.describe}`);
+      }
+    } catch (err) {
+      logger.warn(`channels: ${err.message}`);
+    }
+  }
+
   // Vim-mode plumbing: capture readline's OWN keypress listeners now so we can
   // suspend them while in NORMAL mode (the engine drives editing then) and
   // reattach them for INSERT mode (readline's rich editing/history/completion).
@@ -1876,6 +2133,15 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/theme")}      Color theme (/theme <auto|dark|light|mono>; mono = no color)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/tui")}        Fullscreen no-flicker view (/tui <fullscreen|default>; CC_NO_FLICKER=1)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/fast")}       Latency profile — faster+cheaper, less reasoning (/fast on|off|status)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/voice")}      Speech dictation — local-first STT (/voice hold|tap|off)`,
+      );
       logger.log(
         `  ${chalk.cyan("/output-style")} Response persona (/output-style <name|list>; explanatory/learning built-in)`,
       );
@@ -1883,7 +2149,7 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/config")}     Show config; ${chalk.cyan("/config <key>")} read, ${chalk.cyan("/config <key>=<val>")} set, ${chalk.cyan("/config --help")} keys`,
       );
       logger.log(
-        `  ${chalk.cyan("/doctor")}     Session health check (provider/key/IDE/MCP/hooks)`,
+        `  ${chalk.cyan("/doctor")}     Session health check (provider/key/IDE/MCP/hooks; alias /checkup)`,
       );
       logger.log(
         `  ${chalk.cyan("/status")}     Environment snapshot (version/model/session/cwd/roots/IDE·MCP·hooks)`,
@@ -1909,6 +2175,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/permissions")} Allow/ask/deny rules; set/cycle tier (/permissions <tier> · Shift+Tab); /permissions denials to review blocked calls`,
       );
+      logger.log(
+        `  ${chalk.cyan("/remote-control")} Answer permission prompts from a paired phone/web device (on|off|status; alias /rc)`,
+      );
       logger.log(
         `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
       );
@@ -2290,6 +2559,7 @@ export async function startAgentRepl(options = {}) {
       if (arg) {
         model = arg;
         _curModel = model; // keep the status-line readout in sync
+        _modelPinned = true; // explicit choice — fast mode must not override it
         logger.info(`Model: ${chalk.cyan(model)}`);
         // Claude-Code 2.1.183 parity: warn when the newly-selected model is a
         // provider-retired/deprecated snapshot. Headless paths already warn via
@@ -2468,6 +2738,149 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/tui` — fullscreen no-flicker view (Claude-Code parity). `fullscreen`
+    // enters the alternate screen buffer; `default` returns to streaming
+    // scrollback. No arg prints the current mode. Persisted to `cli.tuiMode`.
+    if (trimmed === "/tui" || trimmed.startsWith("/tui ")) {
+      const arg = trimmed.slice("/tui".length).trim().toLowerCase();
+      if (!arg) {
+        logger.log(chalk.gray(_renderTuiStatus(_tuiMode)));
+        prompt();
+        return;
+      }
+      const next = _resolveTuiMode({ arg });
+      if (arg !== "fullscreen" && arg !== "default") {
+        logger.error(
+          chalk.red(`Unknown TUI mode "${arg}". Use: fullscreen | default`),
+        );
+        prompt();
+        return;
+      }
+      if (_screenReaderMode && next === "fullscreen") {
+        logger.info(
+          chalk.gray(
+            "Screen-reader mode is on — staying in default (scrollback) view.",
+          ),
+        );
+        prompt();
+        return;
+      }
+      _setTuiMode(next);
+      try {
+        const { setConfigValue } = await import("../lib/config-manager.js");
+        setConfigValue("cli.tuiMode", _tuiMode);
+      } catch (_e) {
+        /* persistence is best-effort */
+      }
+      logger.log(chalk.gray(_renderTuiStatus(_tuiMode)));
+      prompt();
+      return;
+    }
+
+    // `/fast` — latency profile (Claude-Code parity). on/off/status/toggle.
+    // When on, the next turn minimizes reasoning and swaps to the provider's
+    // low-latency model (unless a model is pinned). Persisted to cli.fastMode.
+    {
+      const fast = _parseFastCommand(trimmed);
+      if (fast) {
+        if (fast.error) {
+          logger.error(chalk.red(fast.error));
+          prompt();
+          return;
+        }
+        if (fast.action === "status") {
+          logger.log(
+            chalk.gray(
+              _renderFastStatus({ enabled: _fastMode, provider, model }),
+            ),
+          );
+          prompt();
+          return;
+        }
+        _fastMode =
+          fast.action === "on"
+            ? true
+            : fast.action === "off"
+              ? false
+              : !_fastMode;
+        try {
+          const { setConfigValue } = await import("../lib/config-manager.js");
+          setConfigValue("cli.fastMode", _fastMode);
+        } catch (_e) {
+          /* persistence is best-effort */
+        }
+        logger.log(
+          chalk.gray(
+            _renderFastStatus({ enabled: _fastMode, provider, model }),
+          ),
+        );
+        prompt();
+        return;
+      }
+    }
+
+    // `/voice` — speech dictation (Claude-Code parity). hold=push-to-talk,
+    // tap=toggle, off, status. Local-first STT; degrades on headless/SSH or
+    // when no capture backend is configured (voice.backends / voice.allowCloud).
+    {
+      const voice = _parseVoiceCommand(trimmed);
+      if (voice) {
+        if (voice.error) {
+          logger.error(chalk.red(voice.error));
+          prompt();
+          return;
+        }
+        const voiceEnv = _detectVoiceEnvironment({
+          env: process.env,
+          isTTY: Boolean(process.stdin.isTTY),
+        });
+        if (voice.action === "status") {
+          const be = _resolveSttBackend(_voiceConfig).backend;
+          logger.log(
+            chalk.gray(
+              _renderVoiceStatus({
+                mode: _voiceMode,
+                backend: be,
+                env: voiceEnv,
+              }),
+            ),
+          );
+          prompt();
+          return;
+        }
+        if (voice.action === "off") {
+          _voiceMode = "off";
+          logger.log(chalk.gray("Voice: off."));
+          prompt();
+          return;
+        }
+        // hold | tap — need a usable environment AND a resolvable backend.
+        if (!voiceEnv.supported) {
+          logger.info(chalk.yellow(`Voice unavailable — ${voiceEnv.reason}.`));
+          prompt();
+          return;
+        }
+        const { backend, reason } = _resolveSttBackend(_voiceConfig);
+        if (!backend) {
+          logger.info(chalk.yellow(`Voice: ${reason}`));
+          prompt();
+          return;
+        }
+        _voiceMode = voice.action;
+        logger.log(
+          chalk.gray(
+            _renderVoiceStatus({
+              mode: _voiceMode,
+              backend,
+              env: voiceEnv,
+            }) + ` (${reason})`,
+          ),
+        );
+        prompt();
+        return;
+      }
+    }
+
     if (trimmed === "/vim" || trimmed.startsWith("/vim ")) {
       const arg = trimmed.slice("/vim".length).trim().toLowerCase();
       const turnOn = arg === "on" || (arg === "" && !_vimEnabled);
@@ -2870,6 +3283,18 @@ export async function startAgentRepl(options = {}) {
         const resumeId = sessionArg.slice(7).trim();
         try {
           if (useJsonl && sessionExists(resumeId)) {
+            try {
+              const { verifySession } =
+                await import("../harness/jsonl-session-store.js");
+              const trust = verifySession(resumeId);
+              if (trust.status === "tampered") {
+                logger.warn(
+                  `⚠ Transcript integrity check FAILED (${trust.reason}) — restored context is untrusted. Run 'cc session verify ${resumeId}'.`,
+                );
+              }
+            } catch (_err) {
+              // verification is best-effort in the interactive path
+            }
             const rebuilt = rebuildMessages(resumeId);
             messages.length = 1; // keep system prompt
             messages.push(...rebuilt.filter((m) => m.role !== "system"));
@@ -3812,7 +4237,13 @@ export async function startAgentRepl(options = {}) {
 
     // `/doctor` — consolidated session-health readout (Claude-Code parity):
     // provider/key/IDE/MCP/permissions/hooks in one pass-or-warn view.
-    if (trimmed === "/doctor" || trimmed.startsWith("/doctor ")) {
+    // `/checkup` is the Claude-Code 2.1.205 alias for the same readout.
+    if (
+      trimmed === "/doctor" ||
+      trimmed.startsWith("/doctor ") ||
+      trimmed === "/checkup" ||
+      trimmed.startsWith("/checkup ")
+    ) {
       let config = {};
       try {
         config = (await import("../lib/config-manager.js")).loadConfig() || {};
@@ -4028,6 +4459,57 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/remote-control` — pair a phone/web device to answer this session's
+    // permission prompts (批17 slash 入口 + 批18 REPL 接线). First answer —
+    // terminal or device — wins; devices get permission.request cards + push.
+    if (
+      trimmed === "/remote-control" ||
+      trimmed.startsWith("/remote-control ") ||
+      trimmed === "/rc" ||
+      trimmed.startsWith("/rc ")
+    ) {
+      const arg = trimmed
+        .replace(/^\/(remote-control|rc)/, "")
+        .trim()
+        .toLowerCase();
+      if (arg === "off" || arg === "stop") {
+        if (!_remoteApproval) {
+          logger.info("remote-control is not active.");
+        } else {
+          await _stopRemoteApproval();
+          logger.info(
+            "remote-control stopped — approvals are local-only again.",
+          );
+        }
+      } else if (arg === "status") {
+        if (!_remoteApproval) {
+          logger.info("remote-control: off — start with /remote-control");
+        } else {
+          logger.log(`  pairing: ${_remoteApproval.pairing.uri}`);
+          const approvers = await _remoteApproval.bridge.approverCount();
+          logger.log(
+            `  paired approvers: ${approvers}${approvers === 0 ? "  (scan the pairing URI from the mobile app or web panel)" : ""}`,
+          );
+        }
+      } else if (arg === "" || arg === "on" || arg === "start") {
+        if (_remoteApproval) {
+          logger.info(
+            "remote-control already running — /remote-control status",
+          );
+        } else {
+          try {
+            await _startRemoteApproval();
+          } catch (err) {
+            logger.info(`remote-control failed to start: ${err.message}`);
+          }
+        }
+      } else {
+        logger.info("Usage: /remote-control [on|off|status]   (alias /rc)");
+      }
+      prompt();
+      return;
+    }
+
     // `/cost` — running token spend + estimated $ for this session (Claude-Code
     // parity). In-memory accumulation, so it works without session persistence.
     if (trimmed === "/cost" || trimmed.startsWith("/cost ")) {
@@ -4470,6 +4952,22 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Fast mode (P2#12): minimize reasoning + swap to the provider's
+    // low-latency model for this turn (never over a pinned model). Applied
+    // after auto-selection so it has the last word on latency.
+    let turnThinking = thinking;
+    if (_fastMode) {
+      const fastPlan = _resolveFastPlan({
+        enabled: true,
+        provider,
+        model: activeModel,
+        modelPinned: _modelPinned,
+      });
+      turnThinking = fastPlan.thinking;
+      if (fastPlan.swapped) activeModel = fastPlan.model;
+      logger.info(chalk.gray(`[fast] ${fastPlan.note}`));
+    }
+
     try {
       process.stdout.write("\n");
       const iterationBudget = new IterationBudget({ owner: sessionId });
@@ -4588,7 +5086,7 @@ export async function startAgentRepl(options = {}) {
         // turn only (provider/baseUrl/apiKey unchanged, model → vision model).
         provider: _visionLlm ? _visionLlm.provider : provider,
         model: _visionLlm ? _visionLlm.model : activeModel,
-        thinking,
+        thinking: turnThinking,
         thinkingBudget,
         baseUrl: _visionLlm ? _visionLlm.baseUrl : baseUrl,
         apiKey: _visionLlm ? _visionLlm.apiKey : apiKey,
@@ -4641,6 +5139,10 @@ export async function startAgentRepl(options = {}) {
               provider: ue.provider,
               model: ue.model,
               usage: ue.usage,
+              // 用量归因: sub-agent / isolated-skill usage carries its
+              // attribution frame into the transcript; main-loop events stay
+              // exactly as before (absence ⇒ origin "main").
+              ...(ue.attribution ? { attribution: ue.attribution } : {}),
             });
           } catch (_e) {
             /* best-effort */
@@ -4876,6 +5378,25 @@ export async function startAgentRepl(options = {}) {
   });
 
   rl.on("close", async () => {
+    // Leave the alternate screen buffer first so the terminal is restored to
+    // the user's scrollback no matter how the REPL exits.
+    if (_tuiMode === "fullscreen" && process.stdout.isTTY) {
+      try {
+        process.stdout.write(_ALT_LEAVE);
+      } catch (_err) {
+        // best-effort restore
+      }
+    }
+    // Stop inbound channel listeners before anything else — no new external
+    // events may enter a session that is shutting down.
+    if (_channels) {
+      try {
+        _channels.stop();
+      } catch (_err) {
+        // best-effort
+      }
+      _channels = null;
+    }
     // settings.json SessionEnd hooks (observe-only) when the REPL exits.
     if (_settingsHooks) {
       try {
@@ -4968,6 +5489,16 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Tear down /remote-control (bridge + its self-hosted WS server) so the
+    // pairing endpoint doesn't outlive the session.
+    if (_remoteApproval) {
+      try {
+        await _stopRemoteApproval();
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+
     // Kill any background run_shell tasks so a backgrounded command (e.g. a
     // dev server) doesn't outlive the REPL session.
     try {