chainlesschain 0.162.48 → 0.162.60

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,9 +78,13 @@ 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";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -167,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`),
       );
@@ -244,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(
@@ -490,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");
@@ -637,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) },
       );
@@ -733,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 +
@@ -757,14 +805,20 @@ export async function startAgentRepl(options = {}) {
       "/cd",
       "/clear",
       "/compact",
+      "/config",
       "/context",
+      "/cost",
       "/cowork",
+      "/doctor",
       "/exit",
+      "/export",
       "/help",
       "/ide",
       "/mcp",
+      "/memory",
       "/model",
       "/output-style",
+      "/permissions",
       "/plan",
       "/profile",
       "/provider",
@@ -774,10 +828,12 @@ export async function startAgentRepl(options = {}) {
       "/rewind",
       "/search",
       "/session",
+      "/sessions",
       "/stats",
       "/statusline",
       "/sub-agents",
       "/task",
+      "/vim",
     ],
     getIdeOpenFiles: async () => {
       const exec = _adhocMcp?.externalToolExecutors?.mcp__ide__getOpenEditors;
@@ -805,6 +861,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.
@@ -814,8 +918,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();
@@ -825,8 +930,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;
@@ -840,7 +971,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();
@@ -881,6 +1014,7 @@ export async function startAgentRepl(options = {}) {
   let _curModel = model; // tracks the per-turn active model for the readout
   let _ctxUsedTokens = 0;
   let _turnCount = 0;
+  const _costStore = newCostStore(); // running token spend for `/cost`
   let _renderStatus = null;
   try {
     const slm = await import("../lib/status-line.cjs");
@@ -941,7 +1075,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();
@@ -1013,20 +1164,44 @@ 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("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
+      logger.log(
+        `  ${chalk.cyan("/config")}     Effective config (provider/model, keys masked)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/doctor")}     Session health check (provider/key/IDE/MCP/hooks)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/memory")}     Project-memory files loaded (cc.md hierarchy + rules)`,
+      );
       logger.log(
         `  ${chalk.cyan("/context")}    Live context-window usage by role`,
       );
       logger.log(
-        `  ${chalk.cyan("/rewind")}     Rewind conversation to an earlier turn (double-Esc lists)`,
+        `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (per model & category)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/permissions")} Allow/ask/deny rules in effect this session`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
+      );
+      logger.log(
+        `  ${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)`,
@@ -1042,6 +1217,9 @@ export async function startAgentRepl(options = {}) {
       );
       logger.log(`  ${chalk.cyan("/task clear")} Clear current task`);
       logger.log(`  ${chalk.cyan("/session")}    Show current session info`);
+      logger.log(
+        `  ${chalk.cyan("/sessions")}   List recent resumable sessions (/session resume <id> to switch)`,
+      );
       logger.log(
         `  ${chalk.cyan("/reindex")}    Reindex notes for BM25 search`,
       );
@@ -1200,11 +1378,30 @@ 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 === "/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") {
@@ -1297,17 +1494,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) {
@@ -1318,6 +1519,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;
@@ -1432,7 +1675,7 @@ export async function startAgentRepl(options = {}) {
     }
 
     // Session info
-    if (trimmed.startsWith("/session")) {
+    if (trimmed === "/session" || trimmed.startsWith("/session ")) {
       const sessionArg = trimmed.slice(8).trim();
       if (sessionArg.startsWith("resume ")) {
         const resumeId = sessionArg.slice(7).trim();
@@ -2110,6 +2353,42 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/sessions` — list recent RESUMABLE conversations (read-only; the ids
+    // work with `cc agent --resume <id>`). `/session` shows the current one.
+    if (trimmed === "/sessions" || trimmed === "/sessions ") {
+      try {
+        const { listRecentSessions } = await import("../lib/recent-session.js");
+        const { renderRecentSessions } = await import("./recent-sessions.js");
+        const sessions = listRecentSessions({ db: _hookDb }, { scan: 20 });
+        logger.log(renderRecentSessions(sessions, { currentId: sessionId }));
+      } catch (err) {
+        logger.error(chalk.red(`/sessions failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/memory` — project-memory files auto-loaded into the system prompt
+    // (cc.md hierarchy + imports + path-scoped rules). Distinct from `#` (add
+    // a note) and `cc memory recall` (scoped store).
+    if (trimmed === "/memory" || trimmed === "/memory ") {
+      try {
+        const { loadProjectInstructions } =
+          await import("../lib/project-instructions.js");
+        const { renderMemoryFiles } = await import("./memory-status.js");
+        const loaded = loadProjectInstructions({ cwd: process.cwd() });
+        logger.log(
+          renderMemoryFiles(loaded, {
+            enabled: process.env.CC_PROJECT_MEMORY !== "0",
+          }),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/memory failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     // `/mcp` — overview of connected MCP servers' resources + prompts.
     if (trimmed === "/mcp" || trimmed === "/mcp ") {
       const mcpClient = _adhocMcp?.mcpClient || _bundleMcpClient;
@@ -2118,6 +2397,127 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/config` — effective configuration (secret-safe): the LLM provider/model
+    // in effect, whether keys are set, web-search backend, config path.
+    if (trimmed === "/config" || trimmed === "/config ") {
+      try {
+        const { loadConfig } = await import("../lib/config-manager.js");
+        const { getConfigPath } = await import("../lib/paths.js");
+        const { renderConfigSummary } = await import("./config-summary.js");
+        logger.log(
+          renderConfigSummary(loadConfig(), {
+            path: getConfigPath(),
+            activeProvider: provider,
+            activeModel: _curModel || model,
+          }),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/config failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/doctor` — consolidated session-health readout (Claude-Code parity):
+    // provider/key/IDE/MCP/permissions/hooks in one pass-or-warn view.
+    if (trimmed === "/doctor" || trimmed === "/doctor ") {
+      let config = {};
+      try {
+        config = (await import("../lib/config-manager.js")).loadConfig() || {};
+      } catch (_err) {
+        // config read is best-effort; checks degrade gracefully
+      }
+      const { buildDoctorChecks, renderDoctor } =
+        await import("./doctor-status.js");
+      const { ideToolNames } = await import("./ide-status.js");
+      const checks = buildDoctorChecks({
+        config,
+        ideTools: ideToolNames(_adhocMcp),
+        mcpServers: _adhocMcp?.connected,
+        permissionRules: _permissionRules,
+        settingsHooks: _settingsHooks,
+      });
+      logger.log(renderDoctor(checks));
+      prompt();
+      return;
+    }
+
+    // `/export [path]` — dump the live conversation to a Markdown transcript
+    // (Claude-Code parity). Distinct from `cc export` (knowledge base). Captures
+    // exactly what's in context now, persisted or not.
+    if (trimmed === "/export" || trimmed.startsWith("/export ")) {
+      const arg = trimmed.slice("/export".length).trim();
+      try {
+        const { renderConversationMarkdown, defaultExportFilename } =
+          await import("./conversation-export.js");
+        const fs = await import("fs");
+        const path = await import("path");
+        const md = renderConversationMarkdown(messages, {
+          provider,
+          model: _curModel || model,
+          sessionId,
+          exportedAt: new Date().toISOString(),
+        });
+        const file = arg
+          ? path.resolve(process.cwd(), arg)
+          : path.resolve(process.cwd(), defaultExportFilename(new Date()));
+        fs.writeFileSync(file, md, "utf-8");
+        logger.log(
+          chalk.green(`Exported ${messages.length} messages → ${file}`),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/export failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/permissions` — allow/ask/deny rules in effect this session (Claude-Code
+    // parity): what the agent runs unprompted, asks about, or is blocked from.
+    if (trimmed === "/permissions" || trimmed === "/permissions ") {
+      let files = [];
+      try {
+        const { loadSettings } = await import("../lib/settings-loader.cjs");
+        files = loadSettings({ cwd: process.cwd() }).files || [];
+      } catch (_err) {
+        // source listing is best-effort — still show the live rules
+      }
+      const { renderPermissions } = await import("./permissions-status.js");
+      logger.log(renderPermissions(_permissionRules, { files }));
+      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 === "/cost ") {
+      let overrides;
+      let visionModel;
+      try {
+        const { loadConfig } = await import("../lib/config-manager.js");
+        const cfg = loadConfig();
+        overrides = cfg?.llm?.pricing;
+        visionModel = cfg?.llm?.visionModel;
+      } catch (_err) {
+        // 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-1-6-vision-250815",
+        fallbackModels: _fallbackModels || [],
+      };
+      const { renderSessionCost } = await import("./session-cost.js");
+      logger.log(
+        renderSessionCost(_costStore, { pricingOverrides: overrides, roles }),
+      );
+      prompt();
+      return;
+    }
+
     // `/ide` — IDE bridge connection status (Claude-Code parity): which editor
     // is connected, its tools, or why discovery came up empty.
     if (trimmed === "/ide" || trimmed === "/ide ") {
@@ -2347,6 +2747,7 @@ export async function startAgentRepl(options = {}) {
         additionalDirectories,
         autoCheckpoint,
         checkpointSession: sessionId,
+        checkpointMarks: _checkpointMarks,
         prepareCall,
         approvalGate: _approvalGate,
         permissionRules: _permissionRules,
@@ -2362,6 +2763,9 @@ export async function startAgentRepl(options = {}) {
       });
       _turnAbort = null;
 
+      // Running spend for `/cost` (in-memory, works without persistence).
+      if (usageEvents?.length) addUsage(_costStore, usageEvents);
+
       if (sessionId && usageEvents?.length) {
         for (const ue of usageEvents) {
           try {