chainlesschain 0.162.49 → 0.162.61

package/src/lib/terminal-setup.js

@@ -0,0 +1,209 @@
+/**
+ * terminal-setup — make Shift+Enter insert a newline in the agent REPL
+ * (Claude-Code `/terminal-setup` parity).
+ *
+ * cc's REPL is readline-based, so a bare Enter always submits. Multiline input
+ * is reached by ending a line with a continuation backslash (see
+ * repl-multiline.js). This module configures the terminal so that pressing
+ * Shift+Enter emits the byte sequence `<space>\<CR>` — which cc's
+ * backslash-continuation turns into a soft newline — giving the familiar
+ * "Shift+Enter = newline, Enter = send" editing without any REPL raw-mode hacks.
+ *
+ * Everything here is pure (detection + keybindings JSON shaping); the command
+ * (commands/terminal-setup.js) does the file I/O.
+ */
+
+import path from "node:path";
+import os from "node:os";
+
+/**
+ * The bytes Shift+Enter should send: space + backslash + carriage return. The
+ * leading space makes the trailing backslash satisfy repl-multiline's
+ * whitespace-gated continuation rule (so it is never mistaken for a Windows
+ * path), and the backslash is stripped back out when the line is joined.
+ */
+export const SHIFT_ENTER_SEQUENCE = " \\\r";
+
+/** Identify the host terminal from environment variables. */
+export function detectTerminal(env = process.env) {
+  const tp = String(env.TERM_PROGRAM || "").toLowerCase();
+  if (tp === "vscode" || env.VSCODE_PID || env.VSCODE_INJECTION) {
+    return { id: "vscode", name: "VS Code integrated terminal" };
+  }
+  if (tp === "iterm.app") return { id: "iterm2", name: "iTerm2" };
+  if (tp === "apple_terminal")
+    return { id: "apple-terminal", name: "Apple Terminal" };
+  if (tp === "wezterm") return { id: "wezterm", name: "WezTerm" };
+  if (env.WT_SESSION)
+    return { id: "windows-terminal", name: "Windows Terminal" };
+  return {
+    id: "unknown",
+    name: env.TERM_PROGRAM || env.TERM || "your terminal",
+  };
+}
+
+/** The VS Code keybinding that sends the Shift+Enter sequence in the terminal. */
+export function vscodeKeybinding() {
+  return {
+    key: "shift+enter",
+    command: "workbench.action.terminal.sendSequence",
+    when: "terminalFocus",
+    args: { text: SHIFT_ENTER_SEQUENCE },
+  };
+}
+
+/** Per-OS path to VS Code's user keybindings.json. */
+export function vscodeKeybindingsPath(
+  platform = process.platform,
+  env = process.env,
+) {
+  const home = os.homedir();
+  if (platform === "win32") {
+    const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
+    return path.join(appData, "Code", "User", "keybindings.json");
+  }
+  if (platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "keybindings.json",
+    );
+  }
+  return path.join(home, ".config", "Code", "User", "keybindings.json");
+}
+
+/**
+ * Strip JSONC (line + block comments, trailing commas) so a keybindings.json
+ * with comments can be parsed. Best-effort and string-aware enough for the
+ * common case; callers must tolerate a null parse.
+ */
+export function stripJsonc(text) {
+  let out = "";
+  const s = String(text || "");
+  let inStr = false;
+  let strCh = "";
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    const n = s[i + 1];
+    if (inStr) {
+      out += c;
+      if (c === "\\") {
+        out += n ?? "";
+        i += 2;
+        continue;
+      }
+      if (c === strCh) inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = true;
+      strCh = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === "/" && n === "/") {
+      while (i < s.length && s[i] !== "\n") i += 1;
+      continue;
+    }
+    if (c === "/" && n === "*") {
+      i += 2;
+      while (i < s.length && !(s[i] === "*" && s[i + 1] === "/")) i += 1;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  // Drop trailing commas before } or ].
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+
+/** Parse a JSONC keybindings array → array, or null when it cannot be parsed. */
+export function parseKeybindings(text) {
+  const src = String(text || "").trim();
+  if (!src) return [];
+  try {
+    const v = JSON.parse(stripJsonc(src));
+    return Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/** True when an equivalent keybinding (key+command+when) already exists. */
+export function hasKeybinding(arr, binding) {
+  return (Array.isArray(arr) ? arr : []).some(
+    (b) =>
+      b &&
+      b.key === binding.key &&
+      b.command === binding.command &&
+      (b.when || "") === (binding.when || ""),
+  );
+}
+
+/**
+ * Textually append a keybinding before the closing `]`, preserving the file's
+ * existing comments/formatting. Returns the new file text, or null when `text`
+ * is non-empty but not a JSON array (caller should not overwrite blindly).
+ */
+export function appendKeybindingText(text, binding) {
+  const bindingJson = JSON.stringify(binding, null, 2)
+    .split("\n")
+    .map((l) => "  " + l)
+    .join("\n")
+    .trimStart();
+  const src = String(text || "").trim();
+  if (!src || src === "[]") {
+    return `[\n  ${bindingJson}\n]\n`;
+  }
+  const close = src.lastIndexOf("]");
+  if (close === -1) return null; // not an array
+  const before = src.slice(0, close).replace(/\s*$/, "");
+  const sep = before.endsWith("[") ? "" : ",";
+  return `${before}${sep}\n  ${bindingJson}\n]\n`;
+}
+
+/** Manual instructions for terminals cc cannot auto-configure. */
+export function instructionsFor(id) {
+  const seq = "a space, then a backslash, then Enter";
+  const common = `Bind Shift+Enter to send ${seq} (cc turns a trailing "\\" into a newline).`;
+  switch (id) {
+    case "iterm2":
+      return [
+        common,
+        "iTerm2 → Settings → Profiles → Keys → Key Mappings → + :",
+        '  Shortcut: Shift+Return   Action: "Send Text"   Text:  \\  (then a literal Return)',
+      ];
+    case "apple-terminal":
+      return [
+        common,
+        "Terminal → Settings → Profiles → Keyboard → + :",
+        '  Key: Shift+Return   Action: send string  " \\015" (space, backslash, CR)',
+      ];
+    case "windows-terminal":
+      return [
+        common,
+        "Windows Terminal → Settings → Actions (settings.json) → add:",
+        '  { "command": { "action": "sendInput", "input": " \\\\\\r" }, "keys": "shift+enter" }',
+      ];
+    case "wezterm":
+      return [
+        common,
+        "WezTerm (~/.wezterm.lua) keys:",
+        '  { key="Enter", mods="SHIFT", action=wezterm.action.SendString(" \\\\\\r") }',
+      ];
+    default:
+      return [
+        common,
+        "Most terminals let you remap a key to send custom text/bytes — point",
+        "Shift+Enter at the 3 bytes: space (0x20), backslash (0x5C), CR (0x0D).",
+        "Or just type a trailing \\ yourself to continue onto the next line.",
+      ];
+  }
+}

package/src/repl/agent-repl.js

@@ -24,6 +24,11 @@ import os from "os";
 import path from "path";
 import { logger } from "../lib/logger.js";
 import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
+import { createVimState, feedNormalKey } from "../lib/repl-vim.js";
+import {
+  analyzeContinuation,
+  joinContinuation,
+} from "../lib/repl-multiline.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   createSession,
@@ -73,7 +78,10 @@ import {
 } from "../runtime/agent-core.js";
 import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
-import { makeFallbackChatFn } from "../runtime/fallback-model.js";
+import {
+  makeFallbackChatFn,
+  normalizeFallbackModels,
+} from "../runtime/fallback-model.js";
 import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
@@ -168,6 +176,17 @@ async function agentLoop(messages, options) {
     ...options,
   })) {
     if (event.type === "checkpoint") {
+      // Remember which file snapshot lines up with the live conversation so
+      // `/rewind <n>` can restore code + conversation together (Claude-Code
+      // parity). atMessageCount = messages.length at snapshot time; see
+      // repl-rewind.js for how a turn is matched back to its checkpoint.
+      if (Array.isArray(options.checkpointMarks)) {
+        options.checkpointMarks.push({
+          atMessageCount: messages.length,
+          id: event.id,
+          tool: event.tool,
+        });
+      }
       process.stdout.write(
         chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
       );
@@ -245,12 +264,19 @@ export async function startAgentRepl(options = {}) {
   // can `cc checkpoint restore` to just before any tool call.
   const autoCheckpoint = options.autoCheckpoint === true;
 
-  // --fallback-model: retry a turn's LLM call once on a backup model when the
-  // primary errors out (overload / network). Built once; passed into every
-  // agentLoop call via chatFn. Undefined when no fallback configured.
-  const _fallbackChatFn = options.fallbackModel
+  // --fallback-model: walk an ordered backup-model chain when a turn's LLM
+  // call fails (transient error or model-not-found). Built once; passed into
+  // every agentLoop call via chatFn. Accepts the resolved chain
+  // (options.fallbackModels) or a legacy single model (options.fallbackModel).
+  // Undefined when no fallback configured.
+  const _fallbackModels = normalizeFallbackModels(
+    options.fallbackModels != null
+      ? options.fallbackModels
+      : options.fallbackModel,
+  );
+  const _fallbackChatFn = _fallbackModels.length
     ? makeFallbackChatFn({
-        fallbackModel: options.fallbackModel,
+        fallbackModels: _fallbackModels,
         onFallback: ({ from, to, error }) =>
           logger.info(
             chalk.yellow(
@@ -491,6 +517,10 @@ export async function startAgentRepl(options = {}) {
   );
   let _activeOutputStyle = null; // { name, body }
   const messages = [{ role: "system", content: _replBaseSystem }];
+  // Checkpoint marks ({ atMessageCount, id, tool }) recorded as the agent loop
+  // emits `checkpoint` events, so `/rewind <n>` can also restore files to the
+  // snapshot taken before that turn (Claude-Code rewind = code + conversation).
+  const _checkpointMarks = [];
   // Apply --output-style or the settings.json `outputStyle` default at startup.
   try {
     const { resolveOutputStyle } = await import("../lib/output-styles.js");
@@ -638,6 +668,8 @@ export async function startAgentRepl(options = {}) {
           // (parity with headless; auto-detect already works via process.env).
           ide: options.ide,
           cwd: process.cwd(),
+          // advertise the session id to spawned stdio MCP servers
+          sessionId,
         },
         { writeErr: (s) => process.stderr.write(s) },
       );
@@ -734,16 +766,31 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
+  // Vim mode (Claude-Code `/vim` parity): opt-in modal line editing. `_vim`
+  // holds the NORMAL-mode engine state while normal mode is active (readline's
+  // own key handling is suspended then); it is null in INSERT mode (readline
+  // owns editing). Default off — toggled by `/vim`, or on at startup via
+  // --vim / CC_VIM=1.
+  let _vimEnabled =
+    options.vimMode === true || process.env.CC_VIM === "1" ? true : false;
+  let _vim = null;
+
   const getPrompt = () => {
+    // Mode indicator first so it survives the plan-mode prompt variants.
+    const vim = _vimEnabled
+      ? _vim
+        ? chalk.cyan("[N] ")
+        : chalk.dim("[I] ")
+      : "";
     const planManager = getPlanModeManager();
     if (planManager.isActive()) {
       const state = planManager.state;
       if (state === PlanState.APPROVED || state === PlanState.EXECUTING) {
-        return chalk.green("[plan:exec] > ");
+        return vim + chalk.green("[plan:exec] > ");
       }
-      return chalk.yellow("[plan] > ");
+      return vim + chalk.yellow("[plan] > ");
     }
-    return chalk.green("> ");
+    return vim + chalk.green("> ");
   };
 
   // `@` tab-completion (Claude-Code @-mention parity): filesystem paths +
@@ -786,6 +833,8 @@ export async function startAgentRepl(options = {}) {
       "/statusline",
       "/sub-agents",
       "/task",
+      "/terminal-setup",
+      "/vim",
     ],
     getIdeOpenFiles: async () => {
       const exec = _adhocMcp?.externalToolExecutors?.mcp__ide__getOpenEditors;
@@ -813,6 +862,54 @@ export async function startAgentRepl(options = {}) {
     completer: atCompleter,
   });
 
+  // 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).
+  const _rlKeypressListeners = process.stdin.isTTY
+    ? process.stdin.listeners("keypress").slice()
+    : [];
+  const _suspendReadlineKeys = () => {
+    for (const l of _rlKeypressListeners)
+      process.stdin.removeListener("keypress", l);
+  };
+  const _resumeReadlineKeys = () => {
+    const cur = process.stdin.listeners("keypress");
+    for (const l of _rlKeypressListeners)
+      if (!cur.includes(l)) process.stdin.on("keypress", l);
+  };
+  // Push the engine's line/cursor onto readline and redraw the current line.
+  const _vimSync = (vstate) => {
+    try {
+      rl.line = vstate.line;
+      rl.cursor = Math.max(0, Math.min(vstate.cursor, vstate.line.length));
+      if (typeof rl._refreshLine === "function") rl._refreshLine();
+    } catch {
+      /* redraw is best-effort */
+    }
+  };
+  const _vimEnterNormal = () => {
+    const cur = Math.max(
+      0,
+      Math.min(rl.cursor, Math.max(0, rl.line.length - 1)),
+    );
+    _vim = { ...createVimState(rl.line, cur), mode: "normal" };
+    _suspendReadlineKeys();
+    rl.setPrompt(getPrompt());
+    _vimSync(_vim);
+  };
+  const _vimEnterInsert = (vstate) => {
+    _resumeReadlineKeys();
+    _vim = null;
+    rl.setPrompt(getPrompt());
+    _vimSync(vstate);
+  };
+  // Exposed so /vim can leave normal mode cleanly when disabling.
+  const _vimDisable = () => {
+    if (_vim) _resumeReadlineKeys();
+    _vim = null;
+    _vimEnabled = false;
+  };
+
   // Esc interrupt (Claude-Code parity): pressing Esc while a turn is in
   // flight aborts the in-flight agentLoop through its existing AbortSignal
   // seam (throwIfAborted at each iteration); partial conversation is kept.
@@ -822,8 +919,9 @@ export async function startAgentRepl(options = {}) {
   let _lastIdleEscAt = 0;
   if (process.stdin.isTTY) {
     process.stdin.on("keypress", (_str, key) => {
-      if (!key || key.name !== "escape" || key.meta) return;
-      if (_turnAbort) {
+      const k = key || {};
+      // 1) Turn abort always wins, regardless of vim mode.
+      if (k.name === "escape" && !k.meta && _turnAbort) {
         process.stdout.write(chalk.yellow("\n⎋ interrupting…\n"));
         try {
           _turnAbort.abort();
@@ -833,8 +931,34 @@ export async function startAgentRepl(options = {}) {
         _turnAbort = null;
         return;
       }
-      // Double-Esc while idle → rewind picker shortcut (Claude-Code parity);
-      // the actual rewind is `/rewind <n>` so stdin stays readline-owned.
+
+      // 2) Vim mode: modal editing on the current input line.
+      if (_vimEnabled && !_turnAbort) {
+        if (!_vim) {
+          // INSERT mode — readline owns the keys; Esc switches to NORMAL.
+          if (k.name === "escape" && !k.meta) _vimEnterNormal();
+          return;
+        }
+        // NORMAL mode — readline suspended; the engine interprets every key.
+        const res = feedNormalKey(_vim, _str || "", k);
+        if (res.submit) {
+          // Hand the line to readline as a normal Enter (fires 'line', clears).
+          _vimEnterInsert({ ...res, cursor: res.line.length });
+          process.stdin.emit("keypress", "\r", { name: "return" });
+          return;
+        }
+        if (res.mode === "insert") {
+          _vimEnterInsert(res);
+          return;
+        }
+        _vim = res;
+        if (res.message === "bell") process.stdout.write("\x07");
+        _vimSync(res);
+        return;
+      }
+
+      // 3) Non-vim: double-Esc while idle → rewind picker shortcut.
+      if (k.name !== "escape" || k.meta) return;
       const nowTs = Date.now();
       if (nowTs - _lastIdleEscAt < 600) {
         _lastIdleEscAt = 0;
@@ -848,7 +972,9 @@ export async function startAgentRepl(options = {}) {
             );
             process.stdout.write(
               chalk.gray(
-                "Run /rewind <n> to rewind the conversation (files: cc checkpoint restore).\n",
+                _checkpointMarks.length
+                  ? "Run /rewind <n> to rewind the conversation (and optionally its files).\n"
+                  : "Run /rewind <n> to rewind the conversation.\n",
               ),
             );
             prompt();
@@ -950,7 +1076,24 @@ export async function startAgentRepl(options = {}) {
   // when the current turn finishes.
   let _processingLine = false;
   const _pendingLines = [];
+  // Multiline input (Claude-Code parity): a physical line ending in a
+  // continuation backslash keeps the prompt open; `_mlBuffer` accumulates the
+  // pieces and the whole block submits when a line does not continue.
+  const _mlBuffer = [];
   const handleLine = async (input) => {
+    // Backslash continuation — accumulate and re-prompt without firing a turn.
+    const _cont = analyzeContinuation(input);
+    if (_cont.continued) {
+      _mlBuffer.push(_cont.text);
+      rl.setPrompt(chalk.dim("... "));
+      rl.prompt();
+      return;
+    }
+    if (_mlBuffer.length) {
+      input = joinContinuation(_mlBuffer, input);
+      _mlBuffer.length = 0;
+    }
+
     const trimmed = input.trim();
     if (!trimmed) {
       prompt();
@@ -1022,12 +1165,21 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("# <note>")}    Remember a note in the project cc.md`,
       );
+      logger.log(
+        `  ${chalk.cyan("… \\")}         End a line with \\ to continue input onto the next line`,
+      );
       logger.log(`  ${chalk.cyan("/exit")}       Exit the agent`);
       logger.log(
         `  ${chalk.cyan("/model")}      Show/change model (/model <name>)`,
       );
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
+      logger.log(
+        `  ${chalk.cyan("/vim")}        Toggle vim-mode line editing (/vim [on|off]; Esc → NORMAL)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/terminal-setup")} Bind Shift+Enter → newline (--apply for VS Code)`,
+      );
       logger.log(
         `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
@@ -1044,7 +1196,7 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/context")}    Live context-window usage by role`,
       );
       logger.log(
-        `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (so far)`,
+        `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (per model & category)`,
       );
       logger.log(
         `  ${chalk.cyan("/permissions")} Allow/ask/deny rules in effect this session`,
@@ -1053,7 +1205,7 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
       );
       logger.log(
-        `  ${chalk.cyan("/rewind")}     Rewind conversation to an earlier turn (double-Esc lists)`,
+        `  ${chalk.cyan("/rewind")}     Rewind conversation + files to an earlier turn (double-Esc lists)`,
       );
       logger.log(
         `  ${chalk.cyan("/cd <dir>")}   Change working directory mid-session (completion/memory follow)`,
@@ -1230,11 +1382,47 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/clear") {
       messages.length = 1; // Keep system prompt
+      _checkpointMarks.length = 0; // checkpoint marks no longer map to anything
       logger.info("Conversation cleared");
       prompt();
       return;
     }
 
+    if (
+      trimmed === "/terminal-setup" ||
+      trimmed.startsWith("/terminal-setup ")
+    ) {
+      try {
+        const arg = trimmed.slice("/terminal-setup".length).trim();
+        const { runTerminalSetup } =
+          await import("../commands/terminal-setup.js");
+        const res = runTerminalSetup({ apply: arg === "--apply" });
+        for (const l of res.lines) logger.log(l);
+      } catch (err) {
+        logger.error(`/terminal-setup failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
+    if (trimmed === "/vim" || trimmed.startsWith("/vim ")) {
+      const arg = trimmed.slice("/vim".length).trim().toLowerCase();
+      const turnOn = arg === "on" || (arg === "" && !_vimEnabled);
+      if (turnOn) {
+        _vimEnabled = true;
+        logger.info(
+          chalk.gray(
+            "Vim mode: on — Esc → NORMAL (hjkl/w/b/e, x/dd/dw, i/a/A, etc.), i to insert.",
+          ),
+        );
+      } else {
+        _vimDisable();
+        logger.info(chalk.gray("Vim mode: off"));
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/statusline" || trimmed.startsWith("/statusline ")) {
       const arg = trimmed.slice("/statusline".length).trim().toLowerCase();
       if (arg === "off") {
@@ -1327,17 +1515,21 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/rewind" || trimmed.startsWith("/rewind ")) {
       try {
-        const { listUserTurns, rewindToTurn, renderTurnList } =
-          await import("../lib/repl-rewind.js");
+        const {
+          listUserTurns,
+          rewindToTurn,
+          renderTurnList,
+          pickCheckpointForTurn,
+          pruneMarksAfter,
+        } = await import("../lib/repl-rewind.js");
         const arg = trimmed.slice("/rewind".length).trim();
         if (!arg) {
           logger.log(chalk.bold("\nRewind — pick a user turn (newest first):"));
           logger.log(renderTurnList(listUserTurns(messages)));
-          logger.log(
-            chalk.gray(
-              "Usage: /rewind <n>  (conversation only — restore files with `cc checkpoint restore`)",
-            ),
-          );
+          const fileHint = _checkpointMarks.length
+            ? "  (restores files to that point too — checkpoints are on)"
+            : "  (conversation only — start with --checkpoint / git to also rewind files)";
+          logger.log(chalk.gray(`Usage: /rewind <n>${fileHint}`));
         } else {
           const res = rewindToTurn(messages, arg);
           if (!res) {
@@ -1348,6 +1540,48 @@ export async function startAgentRepl(options = {}) {
                 `⎌ rewound — dropped ${res.removed} message(s); edit and resend below`,
               ),
             );
+            // Claude-Code parity: rewind restores files too. Match the dropped
+            // turn to the snapshot taken just before it first mutated the tree,
+            // then offer to roll the working tree back to it (undoable — the
+            // restore takes its own safety checkpoint first).
+            const cp = pickCheckpointForTurn(_checkpointMarks, res.index);
+            pruneMarksAfter(_checkpointMarks, res.index);
+            if (cp) {
+              const q = (p) => new Promise((r) => rl.question(p, r));
+              const ans = (
+                await q(
+                  chalk.yellow(
+                    `  Also restore files to before this turn? (checkpoint ${cp.id}) [Y/n] `,
+                  ),
+                )
+              )
+                .trim()
+                .toLowerCase();
+              if (ans === "" || ans === "y" || ans === "yes") {
+                try {
+                  const { rewindTo } =
+                    await import("../lib/checkpoint-store.js");
+                  const r = rewindTo(process.cwd(), cp.id, {
+                    session: sessionId,
+                  });
+                  logger.log(
+                    chalk.green(
+                      `  ⎌ files restored to ${cp.id} (${r.modified} changed, ${r.deleted} removed, ${r.recreated} recreated; undo: cc checkpoint restore ${r.safetyId})`,
+                    ),
+                  );
+                } catch (e) {
+                  logger.error(
+                    `  file restore skipped: ${e.message} (conversation already rewound)`,
+                  );
+                }
+              } else {
+                logger.log(
+                  chalk.gray(
+                    `  files left as-is — restore later with  cc checkpoint restore ${cp.id}`,
+                  ),
+                );
+              }
+            }
             prompt();
             if (res.text) rl.write(res.text);
             return;
@@ -2279,15 +2513,27 @@ export async function startAgentRepl(options = {}) {
     // parity). In-memory accumulation, so it works without session persistence.
     if (trimmed === "/cost" || trimmed === "/cost ") {
       let overrides;
+      let visionModel;
       try {
         const { loadConfig } = await import("../lib/config-manager.js");
-        overrides = loadConfig()?.llm?.pricing;
+        const cfg = loadConfig();
+        overrides = cfg?.llm?.pricing;
+        visionModel = cfg?.llm?.visionModel;
       } catch (_err) {
-        // pricing overrides are optional — fall back to the built-in table
-      }
+        // config is optional — fall back to the built-in pricing table
+      }
+      // Category breakdown (Claude-Code parity): classify spend by model role —
+      // the live model is "main", the vision model "vision", the fallback chain
+      // "fallback", a switched-to model "other". Shown only when >1 was used.
+      const roles = {
+        mainProvider: provider,
+        mainModel: _curModel || model,
+        visionModel: visionModel || "doubao-seed-2-0-lite-260215",
+        fallbackModels: _fallbackModels || [],
+      };
       const { renderSessionCost } = await import("./session-cost.js");
       logger.log(
-        renderSessionCost(_costStore, { pricingOverrides: overrides }),
+        renderSessionCost(_costStore, { pricingOverrides: overrides, roles }),
       );
       prompt();
       return;
@@ -2522,6 +2768,7 @@ export async function startAgentRepl(options = {}) {
         additionalDirectories,
         autoCheckpoint,
         checkpointSession: sessionId,
+        checkpointMarks: _checkpointMarks,
         prepareCall,
         approvalGate: _approvalGate,
         permissionRules: _permissionRules,