chainlesschain 0.162.35 → 0.162.37

package/src/repl/agent-repl.js

@@ -48,7 +48,10 @@ import {
 } from "../lib/task-model-selector.js";
 import { CLIPermanentMemory } from "../lib/permanent-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
-import { PromptCompressor } from "../harness/prompt-compressor.js";
+import {
+  PromptCompressor,
+  getContextWindow,
+} from "../harness/prompt-compressor.js";
 import { feature } from "../lib/feature-flags.js";
 import { recordCompressionMetric } from "../lib/compression-telemetry.js";
 import {
@@ -58,17 +61,19 @@ import {
 } from "../lib/session-hooks.js";
 import { HookEvents } from "../lib/hook-manager.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
-import { loadMcpConfig } from "../runtime/mcp-config.js";
+import { resolveAgentMcp } from "../runtime/mcp-config.js";
 import {
   AGENT_TOOLS,
   buildSystemPrompt,
   executeTool as coreExecuteTool,
   agentLoop as coreAgentLoop,
   formatToolArgs,
+  killAllBackgroundShellTasks,
 } 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 { resolveSlashMacro } from "./slash-macro.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -76,6 +81,61 @@ import { makeFallbackChatFn } from "../runtime/fallback-model.js";
 let _hookDb = null;
 let _compressor = null;
 let _approvalGate = null;
+// .claude/settings.json permission rules (deny > ask > allow) + an interactive
+// confirmer for `ask` matches. Loaded once at REPL startup; null = no file.
+let _permissionRules = null;
+let _permissionConfirm = null;
+// .claude/settings.json `hooks` block (decision-capable PreToolUse/PostToolUse).
+let _settingsHooks = null;
+
+/**
+ * Fire settings.json Notification hooks (observe-only) — the agent needs the
+ * user's attention (e.g. waiting on a permission/risk confirmation). A hook can
+ * ring a bell / send a desktop notification. Best-effort, never blocks.
+ */
+async function _fireNotification(message) {
+  if (!_settingsHooks) return;
+  try {
+    const { runObserveHooks } = await import("../lib/settings-hook-events.cjs");
+    runObserveHooks(
+      _settingsHooks,
+      "Notification",
+      { message, cwd: process.cwd(), session_id: null },
+      { cwd: process.cwd() },
+    );
+  } catch (_err) {
+    // observe-only — never affect the prompt
+  }
+}
+
+/**
+ * "Always allow" persistence: derive a sensible allow rule for a tool call,
+ * append it to .claude/settings.local.json (personal, gitignored), and reflect
+ * it in the in-memory ruleset so the rest of the session stops prompting. A
+ * persisted `allow` short-circuits the ApprovalGate via agent-core's
+ * `ruleAllowed` path (see permission-rules wiring). Returns {rule,file} or null.
+ */
+async function _persistAlwaysAllow(tool, args) {
+  try {
+    const rulesMod = await import("../lib/permission-rules.cjs");
+    const { suggestAllowRule } = rulesMod.default || rulesMod;
+    const rule = suggestAllowRule(tool || "run_shell", args || {});
+    if (!rule) return null;
+    const { addRule } = await import("../lib/settings-loader.cjs");
+    const { file } = addRule({
+      cwd: process.cwd(),
+      kind: "allow",
+      rule,
+      scope: "local",
+    });
+    if (!_permissionRules) _permissionRules = { allow: [], ask: [], deny: [] };
+    if (!_permissionRules.allow.includes(rule)) _permissionRules.allow.push(rule);
+    return { rule, file };
+  } catch (err) {
+    process.stderr.write(`  always-allow persist failed: ${err.message}\n`);
+    return null;
+  }
+}
 
 /**
  * Execute a tool call — delegates to agent-core with REPL's hookDb and cwd.
@@ -85,6 +145,9 @@ async function executeTool(name, args) {
     hookDb: _hookDb,
     cwd: process.cwd(),
     approvalGate: _approvalGate,
+    permissionRules: _permissionRules,
+    permissionConfirm: _permissionConfirm,
+    settingsHooks: _settingsHooks,
   });
 }
 
@@ -162,6 +225,11 @@ async function agentLoop(messages, options) {
 export async function startAgentRepl(options = {}) {
   let model = options.model || "qwen2.5:7b";
   let provider = options.provider || "ollama";
+  // Extended thinking (Anthropic; opt-in via --think/--ultrathink). Carried from
+  // the runtime policy into the agent-loop options below. thinkingBudget
+  // (--thinking-budget) is the companion legacy-model budget_tokens override.
+  const thinking = options.thinking || null;
+  const thinkingBudget = options.thinkingBudget || null;
   const baseUrl = options.baseUrl || "http://localhost:11434";
   const apiKey = options.apiKey || null;
   // Extra workspace roots (--add-dir): advertised in the system prompt and
@@ -233,7 +301,10 @@ export async function startAgentRepl(options = {}) {
       await import("../lib/session-core-singletons.js");
     _approvalGate = await getApprovalGate();
     if (typeof _approvalGate.setConfirmer === "function") {
-      _approvalGate.setConfirmer(async ({ args, riskLevel }) => {
+      _approvalGate.setConfirmer(async ({ tool, args, riskLevel }) => {
+        await _fireNotification(
+          `Permission needed: ${riskLevel || "medium"}-risk ${tool || "run_shell"}${args?.command ? " — " + args.command : ""}`,
+        );
         const rlConfirm = readline.createInterface({
           input: process.stdin,
           output: process.stdout,
@@ -243,13 +314,25 @@ export async function startAgentRepl(options = {}) {
         const ans = (
           await q(
             chalk.yellow(
-              `\n[ApprovalGate] ${riskLevel || "medium"} risk command:${cmd}\n  Proceed? (y/N) `,
+              `\n[ApprovalGate] ${riskLevel || "medium"} risk command:${cmd}\n` +
+                `  Proceed? [y]es once / [a]lways allow / [N]o: `,
             ),
           )
         )
           .trim()
           .toLowerCase();
         rlConfirm.close();
+        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";
       });
     }
@@ -257,6 +340,63 @@ export async function startAgentRepl(options = {}) {
     _approvalGate = null;
   }
 
+  // Load .claude/settings.json permission rules + wire an interactive confirmer
+  // so `ask` rules prompt (rather than fall closed like headless does).
+  try {
+    const { loadSettings } = await import("../lib/settings-loader.cjs");
+    const loaded = loadSettings({ cwd: process.cwd() });
+    const total =
+      loaded.rules.allow.length +
+      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 }) => {
+      await _fireNotification(
+        `Permission needed: ${tool}${rule ? " (" + rule + ")" : ""}`,
+      );
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      const q = (p) => new Promise((res) => rl.question(p, res));
+      const detail = args?.command
+        ? ` ${args.command}`
+        : args?.path
+          ? ` ${args.path}`
+          : "";
+      const ans = (
+        await q(
+          chalk.yellow(
+            `\n[Permission] ${rule} asks before ${tool}:${detail}\n  Proceed? (y/N) `,
+          ),
+        )
+      )
+        .trim()
+        .toLowerCase();
+      rl.close();
+      return ans === "y" || ans === "yes";
+    };
+  } catch (_err) {
+    _permissionRules = null;
+    _permissionConfirm = null;
+  }
+
+  // Load .claude/settings.json `hooks` block (decision-capable PreToolUse/
+  // PostToolUse). The interactive _permissionConfirm above doubles as the
+  // confirmer for a hook `ask` decision.
+  try {
+    const { loadHooks } = await import("../lib/settings-hooks.cjs");
+    const loaded = loadHooks({ cwd: process.cwd() });
+    _settingsHooks =
+      loaded.hooks && Object.keys(loaded.hooks).length > 0
+        ? loaded.hooks
+        : null;
+  } catch (_err) {
+    _settingsHooks = null;
+  }
+
   // Resume existing session or create new one
   const useJsonl = feature("JSONL_SESSION");
 
@@ -335,20 +475,47 @@ export async function startAgentRepl(options = {}) {
     // Non-critical — SessionManager integration must not block startup
   }
 
-  const messages = [
+  // --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.
+  const _replBaseSystem = composeSystemPrompt(
+    buildSystemPrompt(process.cwd(), { additionalDirectories }),
     {
-      role: "system",
-      // --system-prompt replaces the built-in prompt; --append-system-prompt
-      // extends it (parity with the headless runners).
-      content: composeSystemPrompt(
-        buildSystemPrompt(process.cwd(), { additionalDirectories }),
-        {
-          systemPrompt: options.systemPrompt,
-          appendSystemPrompt: options.appendSystemPrompt,
-        },
-      ),
+      systemPrompt: options.systemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt,
     },
-  ];
+  );
+  let _activeOutputStyle = null; // { name, body }
+  const messages = [{ role: "system", content: _replBaseSystem }];
+  // Apply --output-style or the settings.json `outputStyle` default at startup.
+  try {
+    const { resolveOutputStyle } = await import("../lib/output-styles.js");
+    const st = resolveOutputStyle(options.outputStyle, process.cwd());
+    if (st && st.body) {
+      _activeOutputStyle = { name: st.name, body: st.body };
+      messages[0].content = `${_replBaseSystem}\n\n${st.body}`;
+    } else if (st && st.name && !st.missing) {
+      _activeOutputStyle = { name: st.name, body: "" };
+    }
+  } catch (_err) {
+    // best-effort — no output style
+  }
+
+  // settings.json SessionStart hooks → inject session context (observe-only).
+  if (_settingsHooks) {
+    try {
+      const { runSessionStartHooks } = await import(
+        "../lib/settings-hook-events.cjs"
+      );
+      const ctx = runSessionStartHooks(_settingsHooks, {
+        source: "startup",
+        cwd: process.cwd(),
+      }).additionalContext;
+      if (ctx) messages.push({ role: "system", content: ctx });
+    } catch (_err) {
+      // best-effort
+    }
+  }
 
   // Deep Agents Deploy Phase 1 — load agent bundle if --bundle provided.
   // Injects AGENTS.md as system prompt, seeds USER.md into MemoryStore,
@@ -451,22 +618,35 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
-  // --mcp-config: connect ad-hoc MCP servers for this interactive session and
-  // expose their tools to the LLM (Claude-Code parity with headless). Reuses the
-  // shared engine, so tools surface as mcp__<server>__<tool>. Best-effort: a bad
-  // config is reported but never aborts the REPL.
-  if (options.mcpConfig) {
+  // MCP for this interactive session: the ad-hoc --mcp-config file PLUS the
+  // servers registered with `cc mcp add --auto-connect`, combined into one
+  // client so their tools surface to the LLM as mcp__<server>__<tool>. Reuses
+  // the shared engine. Best-effort: a bad --mcp-config is reported but never
+  // aborts the REPL; --no-mcp skips the registered set.
+  {
     try {
-      _adhocMcp = await loadMcpConfig(options.mcpConfig, {
-        writeErr: (s) => process.stderr.write(s),
-      });
-      const toolCount = _adhocMcp.extraToolDefinitions.length;
-      logger.log(
-        chalk.gray(
-          `MCP: ${_adhocMcp.connected.length} server(s), ${toolCount} tool(s) ` +
-            `(mcp__<server>__<tool>)`,
-        ),
+      _adhocMcp = await resolveAgentMcp(
+        {
+          mcpConfigPath: options.mcpConfig || null,
+          db: db?.getDatabase?.() || null,
+          includeRegistered: options.useRegisteredMcp !== false,
+          // IDE bridge: auto-connect a running editor's MCP server when inside
+          // an IDE integrated terminal. --ide forces it, --no-ide disables it
+          // (parity with headless; auto-detect already works via process.env).
+          ide: options.ide,
+          cwd: process.cwd(),
+        },
+        { writeErr: (s) => process.stderr.write(s) },
       );
+      if (_adhocMcp) {
+        const toolCount = _adhocMcp.extraToolDefinitions.length;
+        logger.log(
+          chalk.gray(
+            `MCP: ${_adhocMcp.connected.length} server(s), ${toolCount} tool(s) ` +
+              `(mcp__<server>__<tool>)`,
+          ),
+        );
+      }
     } catch (mcpErr) {
       logger.log(chalk.yellow(`MCP: --mcp-config failed — ${mcpErr.message}`));
       _adhocMcp = null;
@@ -575,7 +755,58 @@ export async function startAgentRepl(options = {}) {
   );
   logger.log(chalk.gray("Type /exit to quit, /help for commands\n"));
 
+  // statusLine (Claude-Code parity): a line above the prompt each turn.
+  //  - A user-configured `.claude/settings.json` `statusLine` command wins
+  //    (model / branch / cost / … — first stdout line; best-effort, sync).
+  //  - Otherwise a BUILT-IN context-usage line is shown: model · ⛁ used/window
+  //    (pct%) · cwd · turn N — the "上下文用量显示" half. Default-on.
+  //  - Suppressed entirely by `statusLine: false`, env CC_STATUSLINE=0, or
+  //    `/statusline off`. Token usage is fed in from each turn's usage events.
+  let _statusLineEnabled = process.env.CC_STATUSLINE !== "0";
+  let _customStatus = false; // true when a settings.json command is configured
+  let _curModel = model; // tracks the per-turn active model for the readout
+  let _ctxUsedTokens = 0;
+  let _turnCount = 0;
+  let _renderStatus = null;
+  try {
+    const slm = await import("../lib/status-line.cjs");
+    const _sl = slm.default || slm;
+    const _slCfg = _sl.loadStatusLineConfig({ cwd: process.cwd() });
+    _customStatus = !!_slCfg;
+    const _slDisabled = _sl.isStatusLineDisabled({ cwd: process.cwd() });
+    if (_slDisabled) _statusLineEnabled = false;
+    _renderStatus = () => {
+      if (!_statusLineEnabled) return null;
+      try {
+        const context = _sl.buildContext({
+          sessionId,
+          model: _curModel,
+          provider,
+          cwd: process.cwd(),
+          usedTokens: _ctxUsedTokens,
+          contextWindow: getContextWindow(_curModel, provider),
+          turn: _turnCount,
+        });
+        // Custom command wins; otherwise the built-in context-usage render.
+        if (_slCfg) {
+          return _sl.renderStatusLine(_slCfg, context, { cwd: process.cwd() });
+        }
+        const line = _sl.renderDefaultStatusLine(context);
+        return line && line.trim() ? line : null;
+      } catch {
+        return null; // never let the status line break the REPL
+      }
+    };
+  } catch {
+    _renderStatus = null;
+  }
+
   const prompt = () => {
+    if (_statusLineEnabled && _renderStatus) {
+      const line = _renderStatus();
+      // Built-in line is dimmed; a custom command may carry its own ANSI.
+      if (line) process.stdout.write((_customStatus ? line : chalk.dim(line)) + "\n");
+    }
     rl.setPrompt(getPrompt());
     rl.prompt();
   };
@@ -612,6 +843,9 @@ export async function startAgentRepl(options = {}) {
       );
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
+      logger.log(
+        `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
+      );
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
@@ -658,6 +892,29 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         "  Context engineering: instinct + memory + notes injection\n",
       );
+      // User-defined command macros (.claude/commands/*.md) become runnable
+      // slash commands here — list whatever is discovered so they're visible.
+      try {
+        const { discoverCommands } = await import("../lib/slash-commands.js");
+        const macros = discoverCommands(process.cwd());
+        if (macros.length > 0) {
+          logger.log(chalk.bold("Custom commands (.claude/commands):"));
+          for (const m of macros) {
+            const tag =
+              m.scope === "project"
+                ? chalk.cyan("[proj]")
+                : chalk.gray("[pers]");
+            logger.log(
+              `  ${chalk.cyan("/" + m.name)} ${tag}` +
+                (m.argumentHint ? chalk.dim(` ${m.argumentHint}`) : "") +
+                (m.description ? `  ${chalk.gray(m.description)}` : ""),
+            );
+          }
+          logger.log("");
+        }
+      } catch (_err) {
+        // Non-critical — macro discovery failure must not break /help
+      }
       prompt();
       return;
     }
@@ -708,6 +965,7 @@ export async function startAgentRepl(options = {}) {
       const arg = trimmed.slice(6).trim();
       if (arg) {
         model = arg;
+        _curModel = model; // keep the status-line readout in sync
         logger.info(`Model: ${chalk.cyan(model)}`);
       } else {
         logger.info(`Current model: ${chalk.cyan(model)}`);
@@ -756,6 +1014,76 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    if (trimmed === "/statusline" || trimmed.startsWith("/statusline ")) {
+      const arg = trimmed.slice("/statusline".length).trim().toLowerCase();
+      if (arg === "off") {
+        _statusLineEnabled = false;
+        logger.info("Status line: off");
+      } else if (arg === "on") {
+        _statusLineEnabled = true;
+        logger.info("Status line: on");
+      } else {
+        // bare / "show" → report state + a one-off render
+        const line = _statusLineEnabled && _renderStatus ? _renderStatus() : null;
+        if (line) {
+          logger.info(
+            `Status line: ${_customStatus ? line : chalk.dim(line)}`,
+          );
+        } else {
+          logger.info(
+            `Status line: ${_statusLineEnabled ? "on (no content yet)" : "off"}` +
+              (_statusLineEnabled ? "" : ` — enable with ${chalk.cyan("/statusline on")}`),
+          );
+        }
+        if (_customStatus) {
+          logger.info(chalk.gray("  source: settings.json statusLine command"));
+        }
+      }
+      prompt();
+      return;
+    }
+
+    if (trimmed === "/output-style" || trimmed.startsWith("/output-style ")) {
+      const arg = trimmed.slice("/output-style".length).trim();
+      try {
+        const { discoverOutputStyles, getOutputStyle } = await import(
+          "../lib/output-styles.js"
+        );
+        if (!arg) {
+          logger.log(chalk.bold("Output styles:"));
+          for (const s of discoverOutputStyles(process.cwd())) {
+            const cur =
+              _activeOutputStyle?.name === s.name ? chalk.green(" *") : "";
+            logger.log(
+              `  ${s.name.padEnd(16)}${cur}  ${chalk.gray(s.description || "")}`,
+            );
+          }
+          logger.log(
+            chalk.gray(`current: ${_activeOutputStyle?.name || "none"}`),
+          );
+        } else if (arg === "none" || arg === "default") {
+          _activeOutputStyle = null;
+          messages[0].content = _replBaseSystem;
+          logger.info("output style cleared");
+        } else {
+          const s = getOutputStyle(arg, process.cwd());
+          if (!s) {
+            logger.error(chalk.red(`no such output style: ${arg}`));
+          } else {
+            _activeOutputStyle = { name: s.name, body: s.body || "" };
+            messages[0].content = s.body
+              ? `${_replBaseSystem}\n\n${s.body}`
+              : _replBaseSystem;
+            logger.info(chalk.green(`output style → ${s.name}`));
+          }
+        }
+      } catch (err) {
+        logger.error(chalk.red(`/output-style failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/compact") {
       if (_compressor && messages.length > 3) {
         const { messages: compacted, stats } = await _compressor.compress(
@@ -1473,10 +1801,28 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // User-defined slash-command macros (.claude/commands/*.md), Claude-Code
+    // parity. resolveSlashMacro maps a leading /name to a command macro and
+    // expands its template; a non-match returns the line unchanged so a literal
+    // prompt like "/etc/hosts" still reaches the LLM. Wire is unit-tested.
+    let promptText = trimmed;
+    try {
+      const macro = await resolveSlashMacro(trimmed, { cwd: process.cwd() });
+      if (macro.matched) {
+        for (const w of macro.warnings) logger.info(chalk.yellow(`[@ref] ${w}`));
+        promptText = macro.promptText;
+        logger.log(
+          chalk.gray(`[/${macro.name}] macro expanded (${macro.scope})`),
+        );
+      }
+    } catch (err) {
+      logger.verbose(`[slash-macro] expansion skipped: ${err.message}`);
+    }
+
     // Fire UserPromptSubmit hook with rewrite/abort support.
     // Hooks may emit {"rewrittenPrompt": "..."} or {"abort": true, "reason": "..."}
     // via stdout JSON. Failures fall through to the original prompt.
-    const promptDirective = await fireUserPromptSubmit(_hookDb, trimmed, {
+    const promptDirective = await fireUserPromptSubmit(_hookDb, promptText, {
       sessionId,
       messageCount: messages.length,
     });
@@ -1490,7 +1836,7 @@ export async function startAgentRepl(options = {}) {
       return;
     }
     const effectivePrompt = promptDirective.prompt;
-    if (effectivePrompt !== trimmed) {
+    if (effectivePrompt !== promptText) {
       logger.verbose(`[hook] prompt rewritten by UserPromptSubmit hook`);
     }
 
@@ -1514,13 +1860,42 @@ export async function startAgentRepl(options = {}) {
       logger.verbose(`[@ref] expansion skipped: ${err.message}`);
     }
 
+    // settings.json UserPromptSubmit hooks (decision-capable; the DB hook above
+    // is observe-only). block → abort the turn; context → inject before the turn.
+    if (_settingsHooks) {
+      try {
+        const { runUserPromptSubmitHooks } = await import(
+          "../lib/settings-hook-events.cjs"
+        );
+        const ups = runUserPromptSubmitHooks(_settingsHooks, {
+          prompt: userContent,
+          cwd: process.cwd(),
+          sessionId,
+        });
+        if (ups.blocked) {
+          logger.info(
+            chalk.yellow(
+              `[hook] prompt blocked${ups.reason ? ": " + ups.reason : ""}`,
+            ),
+          );
+          prompt();
+          return;
+        }
+        if (ups.additionalContext) {
+          userContent += `\n\n[hook context]\n${ups.additionalContext}`;
+        }
+      } catch (_err) {
+        // settings hook dispatch is best-effort
+      }
+    }
+
     // Add user message
     messages.push({ role: "user", content: userContent });
 
     // Slot-filling: detect intent and fill missing parameters interactively
     try {
       const { CLISlotFiller } = await import("../lib/slot-filler.js");
-      const intent = CLISlotFiller.detectIntent(trimmed);
+      const intent = CLISlotFiller.detectIntent(promptText);
       if (intent) {
         const defs = CLISlotFiller.getSlotDefinitions(intent.type);
         const missing = defs.required.filter((s) => !intent.entities[s]);
@@ -1549,7 +1924,7 @@ export async function startAgentRepl(options = {}) {
 
     // Auto-select best model based on task type
     let activeModel = model;
-    const taskDetection = detectTaskType(trimmed);
+    const taskDetection = detectTaskType(promptText);
     if (taskDetection.confidence > 0.3) {
       const recommended = selectModelForTask(provider, taskDetection.taskType);
       if (recommended && recommended !== activeModel) {
@@ -1583,6 +1958,8 @@ export async function startAgentRepl(options = {}) {
       const { content: response, usageEvents } = await agentLoop(messages, {
         provider,
         model: activeModel,
+        thinking,
+        thinkingBudget,
         baseUrl,
         apiKey,
         contextEngine,
@@ -1594,6 +1971,9 @@ export async function startAgentRepl(options = {}) {
         checkpointSession: sessionId,
         prepareCall,
         approvalGate: _approvalGate,
+        permissionRules: _permissionRules,
+        permissionConfirm: _permissionConfirm,
+        settingsHooks: _settingsHooks,
         // MCP: --mcp-config (ad-hoc) wins; bundle MCP is the fallback. The 3
         // tool channels expose --mcp-config servers' tools to the LLM directly.
         mcpClient: _adhocMcp?.mcpClient || _bundleMcpClient || undefined,
@@ -1617,6 +1997,17 @@ export async function startAgentRepl(options = {}) {
         }
       }
 
+      // Feed the status line: the last usage event's input+output ≈ the tokens
+      // now resident in the context window (what the next call resends). Track
+      // the active model too, so the built-in readout reflects auto-switches.
+      _curModel = activeModel;
+      _turnCount += 1;
+      if (usageEvents?.length) {
+        const last = usageEvents[usageEvents.length - 1]?.usage || {};
+        const used = (last.input_tokens || 0) + (last.output_tokens || 0);
+        if (used > 0) _ctxUsedTokens = used;
+      }
+
       // Fire AssistantResponse hook with rewrite/suppress support
       const responseDirective = await fireAssistantResponse(
         _hookDb,
@@ -1710,7 +2101,7 @@ export async function startAgentRepl(options = {}) {
       // Store as episodic memory
       if (db) {
         try {
-          storeMemory(db, trimmed, { importance: 0.3, type: "episodic" });
+          storeMemory(db, promptText, { importance: 0.3, type: "episodic" });
         } catch (_e) {
           // Non-critical
         }
@@ -1742,6 +2133,22 @@ export async function startAgentRepl(options = {}) {
   });
 
   rl.on("close", async () => {
+    // settings.json SessionEnd hooks (observe-only) when the REPL exits.
+    if (_settingsHooks) {
+      try {
+        const { runObserveHooks } = await import(
+          "../lib/settings-hook-events.cjs"
+        );
+        runObserveHooks(
+          _settingsHooks,
+          "SessionEnd",
+          { reason: "exit", cwd: process.cwd(), session_id: sessionId },
+          { cwd: process.cwd() },
+        );
+      } catch (_err) {
+        // observe-only
+      }
+    }
     // Save session on exit
     if (sessionId) {
       try {
@@ -1819,6 +2226,14 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Kill any background run_shell tasks so a backgrounded command (e.g. a
+    // dev server) doesn't outlive the REPL session.
+    try {
+      killAllBackgroundShellTasks();
+    } catch (_e) {
+      // Non-critical
+    }
+
     // Shutdown runtime
     try {
       await shutdown();