chainlesschain 0.162.158 → 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";
@@ -316,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`),
@@ -1298,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"));
@@ -1413,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);
@@ -1457,6 +1570,7 @@ export async function startAgentRepl(options = {}) {
           "/cd",
           "/clear",
           "/compact",
+          "/checkup",
           "/config",
           "/context",
           "/copy",
@@ -1466,6 +1580,7 @@ export async function startAgentRepl(options = {}) {
           "/effort",
           "/exit",
           "/export",
+          "/fast",
           "/help",
           "/hooks",
           "/ide",
@@ -1501,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
@@ -1545,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).
@@ -1985,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)`,
       );
@@ -1992,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)`,
@@ -2402,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
@@ -2580,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);
@@ -2982,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"));
@@ -3924,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() || {};
@@ -4633,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 });
@@ -4751,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,
@@ -4804,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 */
@@ -5039,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 {