chainlesschain 0.162.71 → 0.162.73

package/src/repl/agent-repl.js

@@ -79,7 +79,7 @@ import {
   listBackgroundShellTasks,
 } from "../runtime/agent-core.js";
 import { formatBackgroundTasks } from "./tasks-status.js";
-import { expandFileRefs } from "../runtime/file-ref-expander.js";
+import { expandFileRefsAsync } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import {
   makeFallbackChatFn,
@@ -88,6 +88,13 @@ import {
 import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
+import { parseThinkCommand } from "./think-command.js";
+import { shouldStreamLive } from "./stream-decision.js";
+import {
+  parsePermissionTier,
+  describeTier,
+  nextTier,
+} from "./permission-tier.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -230,6 +237,13 @@ async function agentLoop(messages, options) {
       } else if (event.result?.success) {
         process.stdout.write(chalk.green(`  Done\n`));
       }
+    } else if (event.type === "thinking") {
+      // Intermediate-step reasoning (before a tool call) — dimmed, inline.
+      if (process.env.CC_REPL_THINKING !== "0" && event.text) {
+        process.stdout.write(
+          "\n" + chalk.dim("💭 " + event.text.replace(/\n/g, "\n   ")) + "\n",
+        );
+      }
     } else if (event.type === "token-usage") {
       usageEvents.push(event);
     } else if (event.type === "iteration-warning") {
@@ -239,7 +253,7 @@ async function agentLoop(messages, options) {
         chalk.red(`\n  [Budget Exhausted] ${event.budget}\n`),
       );
     } else if (event.type === "response-complete") {
-      return { content: event.content, usageEvents };
+      return { content: event.content, usageEvents, thinking: event.thinking };
     }
   }
   return { content: "", usageEvents };
@@ -252,10 +266,16 @@ 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
+  // the runtime policy into the agent-loop options below. Mutable so the
+  // `/think` · `/ultrathink` slash commands can toggle it mid-session (the
+  // per-turn agentLoop call below reads the current value). thinkingBudget
   // (--thinking-budget) is the companion legacy-model budget_tokens override.
-  const thinking = options.thinking || null;
+  let thinking = options.thinking || null;
   const thinkingBudget = options.thinkingBudget || null;
+  // Current ApprovalGate session tier (strict|trusted|autopilot), mirrored here
+  // so Shift+Tab can cycle it and `/permissions <tier>` can set it. Kept in sync
+  // with _approvalGate.setSessionPolicy below.
+  let _sessionTier = "strict";
   const baseUrl = options.baseUrl || "http://localhost:11434";
   const apiKey = options.apiKey || null;
   // Extra workspace roots (--add-dir): advertised in the system prompt and
@@ -325,6 +345,30 @@ export async function startAgentRepl(options = {}) {
   // Set hook DB reference for tool pipeline
   _hookDb = db;
 
+  // Live token streaming (Claude-Code parity): stream the answer (and reasoning)
+  // token-by-token as the LLM produces it, instead of replaying the finished
+  // text with a typewriter. ONLY safe when no AssistantResponse hook is
+  // registered — such a hook can rewrite/suppress the final answer, which is
+  // impossible once it's already on screen. CC_REPL_STREAM=0 forces the replay.
+  let _arHookCount = 0;
+  if (_hookDb) {
+    try {
+      const { listHooks } = await import("../lib/hook-manager.js");
+      _arHookCount = (
+        listHooks(_hookDb, {
+          event: "AssistantResponse",
+          enabledOnly: true,
+        }) || []
+      ).length;
+    } catch {
+      _arHookCount = -1; // unknown → shouldStreamLive treats as unsafe
+    }
+  }
+  const _streamLive = shouldStreamLive({
+    streamEnv: process.env.CC_REPL_STREAM,
+    arHookCount: _arHookCount,
+  });
+
   // Wire the persistent ApprovalGate singleton (approval-policies.json) with
   // a readline confirm prompt. agent-core's run_shell branch gates
   // MEDIUM/HIGH-risk commands against the session's policy tier
@@ -698,6 +742,9 @@ export async function startAgentRepl(options = {}) {
         sessionId,
         _bundleResolved.approvalPolicy.default,
       );
+      // Mirror it so Shift+Tab cycling starts from the real tier.
+      const applied = parsePermissionTier(_bundleResolved.approvalPolicy.default);
+      if (applied) _sessionTier = applied;
     } catch (_err) {
       // Non-critical — invalid policy value is silently ignored
     }
@@ -848,6 +895,7 @@ export async function startAgentRepl(options = {}) {
       "/ide",
       "/mcp",
       "/memory",
+      "/microcompact",
       "/model",
       "/output-style",
       "/permissions",
@@ -869,6 +917,8 @@ export async function startAgentRepl(options = {}) {
       "/tasks",
       "/terminal-setup",
       "/theme",
+      "/think",
+      "/ultrathink",
       "/vim",
     ],
     getIdeOpenFiles: async () => {
@@ -967,6 +1017,38 @@ export async function startAgentRepl(options = {}) {
         return;
       }
 
+      // 1.5) Shift+Tab cycles the session approval tier (Claude-Code mode
+      // cycling): strict → trusted → autopilot → strict. Drives the existing
+      // ApprovalGate.setSessionPolicy seam; intercepted before vim/completion.
+      const isShiftTab =
+        (k.name === "tab" && k.shift) || k.sequence === "\u001b[Z";
+      if (isShiftTab) {
+        if (
+          _approvalGate &&
+          sessionId &&
+          typeof _approvalGate.setSessionPolicy === "function"
+        ) {
+          const next = nextTier(_sessionTier);
+          try {
+            _approvalGate.setSessionPolicy(sessionId, next);
+            _sessionTier = next;
+            process.stdout.write(
+              "\n" +
+                chalk.cyan(`⇥ approval: ${next}`) +
+                " " +
+                chalk.gray(`(${describeTier(next)})`) +
+                "\n",
+            );
+            if (!_turnAbort) prompt();
+          } catch {
+            process.stdout.write("\x07"); // bell on failure
+          }
+        } else {
+          process.stdout.write("\x07"); // no gate this session
+        }
+        return;
+      }
+
       // 2) Vim mode: modal editing on the current input line.
       if (_vimEnabled && !_turnAbort) {
         if (!_vim) {
@@ -1208,6 +1290,9 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/model")}      Show/change model (/model <name>)`,
       );
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
+      logger.log(
+        `  ${chalk.cyan("/think")}      Extended thinking on/off (/think [on|off|ultra]; /ultrathink = max; Anthropic)`,
+      );
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(
         `  ${chalk.cyan("/vim")}        Toggle vim-mode line editing (/vim [on|off]; Esc → NORMAL)`,
@@ -1240,7 +1325,7 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (per model & category)`,
       );
       logger.log(
-        `  ${chalk.cyan("/permissions")} Allow/ask/deny rules in effect this session`,
+        `  ${chalk.cyan("/permissions")} Allow/ask/deny rules; set/cycle tier (/permissions <tier> · Shift+Tab cycles)`,
       );
       logger.log(
         `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
@@ -1260,6 +1345,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/microcompact")} Trim large OLD tool results in place (keeps recent + flow)`,
+      );
       logger.log(
         `  ${chalk.cyan("/task")}       Set task objective (/task <objective>)`,
       );
@@ -1454,6 +1542,21 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // Extended-thinking toggle (Anthropic extended thinking; ignored by other
+    // providers). Mutates `thinking`, read by the next turn's agentLoop call.
+    {
+      const think = parseThinkCommand(trimmed);
+      if (think) {
+        thinking = think.thinking;
+        const note = think.anthropic
+          ? " " + chalk.gray("(Anthropic only; applies next turn)")
+          : "";
+        logger.info(`Extended thinking: ${chalk.cyan(think.label)}${note}`);
+        prompt();
+        return;
+      }
+    }
+
     if (trimmed === "/clear") {
       messages.length = 1; // Keep system prompt
       _checkpointMarks.length = 0; // checkpoint marks no longer map to anything
@@ -1780,6 +1883,27 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // Micro-compaction: surgically trim large OLD tool results in place (keeps
+    // recent messages + the conversation flow). Safe (never orphans a tool
+    // pair); cheaper + less lossy than a full /compact.
+    if (trimmed === "/microcompact") {
+      const { microCompact } = await import("../lib/micro-compact.js");
+      const { messages: mc, stats } = microCompact(messages);
+      if (stats.trimmed > 0) {
+        messages.length = 0;
+        messages.push(...mc);
+        logger.info(
+          `Micro-compacted: trimmed ${stats.trimmed} old tool result(s), ~${stats.saved} chars freed (recent messages kept).`,
+        );
+      } else {
+        logger.info(
+          "Nothing to micro-compact — no large old tool results in context.",
+        );
+      }
+      prompt();
+      return;
+    }
+
     // Task commands
     if (trimmed.startsWith("/task")) {
       const taskArg = trimmed.slice(5).trim();
@@ -2646,7 +2770,39 @@ export async function startAgentRepl(options = {}) {
 
     // `/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 ") {
+    if (trimmed === "/permissions" || trimmed.startsWith("/permissions ")) {
+      const arg = trimmed.slice("/permissions".length).trim();
+      if (arg) {
+        // Set this session's approval tier mid-session (Claude-Code
+        // permission-mode / Shift+Tab parity; mirrors `cc session policy --set`).
+        const tier = parsePermissionTier(arg);
+        if (!tier) {
+          logger.info(
+            "Usage: /permissions [strict|trusted|autopilot]  " +
+              "(aliases: default · accept-edits · bypass). No arg = show rules.",
+          );
+        } else if (
+          !_approvalGate ||
+          !sessionId ||
+          typeof _approvalGate.setSessionPolicy !== "function"
+        ) {
+          logger.info(
+            "Approval gate not available this session — can't change the tier.",
+          );
+        } else {
+          try {
+            _approvalGate.setSessionPolicy(sessionId, tier);
+            _sessionTier = tier;
+            logger.info(
+              `Approval policy → ${chalk.cyan(tier)} ${chalk.gray(`(${describeTier(tier)})`)}`,
+            );
+          } catch (_err) {
+            logger.info("Could not set the approval policy.");
+          }
+        }
+        prompt();
+        return;
+      }
       let files = [];
       try {
         const { loadSettings } = await import("../lib/settings-loader.cjs");
@@ -2656,6 +2812,11 @@ export async function startAgentRepl(options = {}) {
       }
       const { renderPermissions } = await import("./permissions-status.js");
       logger.log(renderPermissions(_permissionRules, { files }));
+      logger.log(
+        chalk.gray(
+          "  Set tier mid-session: /permissions <strict|trusted|autopilot>",
+        ),
+      );
       prompt();
       return;
     }
@@ -2821,7 +2982,9 @@ export async function startAgentRepl(options = {}) {
     // about and left as-is.
     let userContent = effectivePrompt;
     try {
-      const fileRefs = expandFileRefs(effectivePrompt, { cwd: process.cwd() });
+      const fileRefs = await expandFileRefsAsync(effectivePrompt, {
+        cwd: process.cwd(),
+      });
       userContent = fileRefs.prompt;
       for (const w of fileRefs.warnings) {
         logger.info(chalk.yellow(`[@ref] ${w}`));
@@ -2951,7 +3114,35 @@ export async function startAgentRepl(options = {}) {
         /* goal binding is best-effort — fall back to defaultPrepareCall */
       }
       _turnAbort = new AbortController();
-      const { content: response, usageEvents } = await agentLoop(messages, {
+      // Live streaming hooks: write the answer token-by-token, and stream the
+      // reasoning dimmed before it. Skipped (left undefined) in replay mode.
+      let _liveStreamed = false;
+      let _liveThinkStarted = false;
+      const liveOpts = _streamLive
+        ? {
+            onToken: (t) => {
+              // Separate the answer from the dimmed reasoning above it (once).
+              if (!_liveStreamed && _liveThinkStarted) process.stdout.write("\n");
+              _liveStreamed = true;
+              process.stdout.write(t);
+            },
+            onThinking: (t) => {
+              if (process.env.CC_REPL_THINKING === "0") return;
+              if (!_liveThinkStarted) {
+                process.stdout.write(chalk.dim("💭 "));
+                _liveThinkStarted = true;
+              }
+              process.stdout.write(chalk.dim(t));
+            },
+          }
+        : {};
+      if (_streamLive) process.stdout.write("\n");
+      const {
+        content: response,
+        usageEvents,
+        thinking: reasoning,
+      } = await agentLoop(messages, {
+        ...liveOpts,
         signal: _turnAbort.signal,
         provider,
         model: activeModel,
@@ -3032,19 +3223,36 @@ export async function startAgentRepl(options = {}) {
         effectiveResponse = responseDirective.response;
       }
 
+      // Extended-thinking reasoning (Anthropic, when /think is on): shown dimmed
+      // BEFORE the answer. Not subject to the AssistantResponse rewrite/suppress
+      // hook (that governs the answer text only). CC_REPL_THINKING=0 hides it.
+      // In live mode it already streamed via onThinking, so skip the replay.
+      if (reasoning && !_streamLive && process.env.CC_REPL_THINKING !== "0") {
+        process.stdout.write(
+          "\n" + chalk.dim("💭 " + reasoning.replace(/\n/g, "\n   ")) + "\n",
+        );
+      }
+
       if (effectiveResponse) {
-        // Phase G #2 — route through StreamRouter so REPL / WS / future
-        // streaming providers share one StreamEvent protocol.
-        const { streamAgentResponse } = await import("../lib/agent-stream.js");
-        process.stdout.write("\n");
-        const noStream = options.noStream === true;
-        const streamResult = await streamAgentResponse(effectiveResponse, {
-          noStream,
-          writer: noStream ? null : (chunk) => process.stdout.write(chunk),
-        });
-        if (noStream) process.stdout.write(streamResult.text);
-        process.stdout.write("\n\n");
-        messages.push({ role: "assistant", content: streamResult.text });
+        if (_streamLive && _liveStreamed) {
+          // Already streamed live token-by-token during the turn (no
+          // AssistantResponse hook to rewrite it) — just terminate + record.
+          process.stdout.write("\n\n");
+          messages.push({ role: "assistant", content: effectiveResponse });
+        } else {
+          // Phase G #2 — route through StreamRouter so REPL / WS / future
+          // streaming providers share one StreamEvent protocol.
+          const { streamAgentResponse } = await import("../lib/agent-stream.js");
+          process.stdout.write("\n");
+          const noStream = options.noStream === true;
+          const streamResult = await streamAgentResponse(effectiveResponse, {
+            noStream,
+            writer: noStream ? null : (chunk) => process.stdout.write(chunk),
+          });
+          if (noStream) process.stdout.write(streamResult.text);
+          process.stdout.write("\n\n");
+          messages.push({ role: "assistant", content: streamResult.text });
+        }
       } else if (!responseDirective.suppress) {
         process.stdout.write("\n");
       }

package/src/repl/chat-repl.js

@@ -12,7 +12,7 @@ import readline from "readline";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
-import { expandFileRefs } from "../runtime/file-ref-expander.js";
+import { expandFileRefsAsync } from "../runtime/file-ref-expander.js";
 import {
   streamOllama,
   streamOpenAI,
@@ -159,7 +159,9 @@ export async function startChatRepl(options = {}) {
     // content; the JSONL log keeps the original line for readability.
     let userContent = trimmed;
     try {
-      const fileRefs = expandFileRefs(trimmed, { cwd: process.cwd() });
+      const fileRefs = await expandFileRefsAsync(trimmed, {
+        cwd: process.cwd(),
+      });
       userContent = fileRefs.prompt;
       for (const w of fileRefs.warnings) {
         logger.info(chalk.yellow(`[@ref] ${w}`));

package/src/repl/permission-tier.js

@@ -0,0 +1,60 @@
+/**
+ * Map a `/permissions <arg>` tier alias to an ApprovalGate session-policy tier
+ * (strict | trusted | autopilot), or null when the arg is not a known tier.
+ * Pure → unit-testable. Mirrors `cc session policy --set` and the headless
+ * --permission-mode mapping (default → strict, acceptEdits → trusted,
+ * bypassPermissions → autopilot), giving the interactive REPL a mid-session
+ * permission-mode toggle (Claude-Code Shift+Tab mode-cycling parity).
+ */
+const TIER_ALIASES = {
+  // strict — every risky action asks (the default)
+  strict: "strict",
+  default: "strict",
+  normal: "strict",
+  off: "strict",
+  // trusted — low/medium-risk auto-approved, high-risk still asks (acceptEdits)
+  trusted: "trusted",
+  accept: "trusted",
+  "accept-edits": "trusted",
+  acceptedits: "trusted",
+  // autopilot — everything auto-approved (bypassPermissions)
+  autopilot: "autopilot",
+  bypass: "autopilot",
+  bypasspermissions: "autopilot",
+  yolo: "autopilot",
+};
+
+/** Cycle order for Shift+Tab mode cycling (Claude-Code parity). */
+export const TIER_CYCLE = Object.freeze(["strict", "trusted", "autopilot"]);
+
+/**
+ * Next tier in the Shift+Tab cycle: strict → trusted → autopilot → strict.
+ * An unrecognized current tier resets to the first (strict).
+ */
+export function nextTier(current) {
+  const i = TIER_CYCLE.indexOf(current);
+  return TIER_CYCLE[(i + 1) % TIER_CYCLE.length];
+}
+
+export function parsePermissionTier(arg) {
+  const a = String(arg == null ? "" : arg)
+    .trim()
+    .toLowerCase();
+  return Object.prototype.hasOwnProperty.call(TIER_ALIASES, a)
+    ? TIER_ALIASES[a]
+    : null;
+}
+
+/** One-line description of what a tier auto-approves. */
+export function describeTier(tier) {
+  switch (tier) {
+    case "autopilot":
+      return "everything auto-approved (no prompts)";
+    case "trusted":
+      return "low/medium-risk auto-approved; high-risk still asks";
+    case "strict":
+      return "every risky action asks";
+    default:
+      return "";
+  }
+}

package/src/repl/stream-decision.js

@@ -0,0 +1,16 @@
+/**
+ * Decide whether the REPL may stream the answer live (token-by-token) instead of
+ * replaying the finished text. Pure → unit-testable.
+ *
+ * Safety invariant: live streaming is ONLY allowed when no AssistantResponse
+ * hook is registered. Such a hook can rewrite or suppress the final answer, and
+ * once tokens are on screen they can't be un-printed. If we can't determine the
+ * hook count (a query error → pass arHookCount < 0), we stay safe (no streaming).
+ * `CC_REPL_STREAM=0` forces the replay regardless.
+ */
+export function shouldStreamLive({ streamEnv, arHookCount = 0 } = {}) {
+  if (streamEnv === "0") return false;
+  // 0 → no rewrite/suppress hook → safe. Anything else (hooks present, or -1 for
+  // "unknown") → fall back to the replay.
+  return arHookCount === 0;
+}

package/src/repl/think-command.js

@@ -0,0 +1,36 @@
+/**
+ * Pure parser for the REPL `/think` · `/ultrathink` extended-thinking toggle.
+ * Maps the slash-command string to the next `thinking` value the agent loop
+ * reads (true | "ultra" | <level> | null) plus a human label. Returns null when
+ * the input is not a think command, so the REPL falls through to its other
+ * handlers. vscode/readline-free → unit-testable (mirrors the chat panel's
+ * /think; extended thinking is Anthropic-only, ignored by other providers).
+ *
+ *   /think            → on (default budget)      /think off  → off
+ *   /think ultra      → max budget               /think <level> → that level
+ *   /think-off        → off (panel-style alias)
+ *   /ultrathink       → max budget (alias)
+ */
+export function parseThinkCommand(trimmed) {
+  const t = String(trimmed == null ? "" : trimmed).trim();
+  const isThink =
+    t === "/think" || t.startsWith("/think ") || t.startsWith("/think-");
+  const isUltra = t === "/ultrathink" || t.startsWith("/ultrathink ");
+  if (!isThink && !isUltra) return null;
+
+  const arg = isUltra
+    ? "ultra"
+    : t.slice(6).replace(/^-+/, "").trim().toLowerCase();
+
+  if (arg === "ultra") {
+    return { thinking: "ultra", label: "ultra (max budget)", anthropic: true };
+  }
+  if (arg === "off" || arg === "false" || arg === "0" || arg === "none") {
+    return { thinking: null, label: "off", anthropic: false };
+  }
+  if (!arg || arg === "on" || arg === "true") {
+    return { thinking: true, label: "on", anthropic: true };
+  }
+  // An explicit effort level (low/medium/high/…) — passed through to the engine.
+  return { thinking: arg, label: arg, anthropic: true };
+}

package/src/runtime/agent-core.js

@@ -2658,6 +2658,7 @@ export async function chatWithTools(rawMessages, options) {
         { "x-api-key": key, "anthropic-version": "2023-06-01" },
         options.onToken,
         signal,
+        options.onThinking,
       );
     }
 
@@ -2899,7 +2900,7 @@ function _anthropicInitState() {
   return { text: "", blocks: {}, inputTokens: 0, outputTokens: 0 };
 }
 
-function _anthropicReduceLine(state, raw, onToken) {
+function _anthropicReduceLine(state, raw, onToken, onThinking) {
   const line = (raw || "").trim();
   if (!line.startsWith("data:")) return state;
   const payload = line.slice(5).trim();
@@ -2939,6 +2940,13 @@ function _anthropicReduceLine(state, raw, onToken) {
     } else if (d.type === "thinking_delta" && state.blocks[obj.index]) {
       state.blocks[obj.index].thinking =
         (state.blocks[obj.index].thinking || "") + (d.thinking || "");
+      if (typeof onThinking === "function" && d.thinking) {
+        try {
+          onThinking(d.thinking);
+        } catch {
+          // a failing UI hook must never break the run
+        }
+      }
     } else if (d.type === "signature_delta" && state.blocks[obj.index]) {
       state.blocks[obj.index].signature =
         (state.blocks[obj.index].signature || "") + (d.signature || "");
@@ -2994,9 +3002,10 @@ function _anthropicFinalize(state) {
 }
 
 /** Pure reducer over Anthropic SSE lines — exported for tests (no HTTP). */
-export function _accumulateAnthropicStream(lines, onToken) {
+export function _accumulateAnthropicStream(lines, onToken, onThinking) {
   const state = _anthropicInitState();
-  for (const line of lines) _anthropicReduceLine(state, line, onToken);
+  for (const line of lines)
+    _anthropicReduceLine(state, line, onToken, onThinking);
   return _anthropicFinalize(state);
 }
 
@@ -3006,6 +3015,7 @@ async function _chatAnthropicStreaming(
   extraHeaders,
   onToken,
   signal,
+  onThinking,
 ) {
   const response = await fetch(apiUrl, {
     method: "POST",
@@ -3026,9 +3036,10 @@ async function _chatAnthropicStreaming(
     buf += decoder.decode(value, { stream: true });
     const lines = buf.split("\n");
     buf = lines.pop() || "";
-    for (const line of lines) _anthropicReduceLine(state, line, onToken);
+    for (const line of lines)
+      _anthropicReduceLine(state, line, onToken, onThinking);
   }
-  if (buf.trim()) _anthropicReduceLine(state, buf, onToken);
+  if (buf.trim()) _anthropicReduceLine(state, buf, onToken, onThinking);
   return _anthropicFinalize(state);
 }
 
@@ -3576,12 +3587,32 @@ export async function* agentLoop(messages, options) {
       try {
         const compactor = await _getAutoCompactor(options);
         if (compactor && compactor.shouldAutoCompact(messages)) {
+          // Cheap surgical pre-pass (Claude-Code microcompact parity): trim old
+          // large tool results IN PLACE before the disruptive full
+          // summarization. If the trim brings the context back under threshold,
+          // the full compaction below is skipped this round — so heavy-tool
+          // conversations rarely hit a full summarize. Opt out:
+          // autoMicroCompact: false.
+          if (options.autoMicroCompact !== false) {
+            try {
+              const { microCompact } = await import("../lib/micro-compact.js");
+              const mc = microCompact(messages);
+              if (mc.stats.trimmed > 0) {
+                messages.splice(0, messages.length, ...mc.messages);
+                yield { type: "micro-compaction", runId, stats: mc.stats };
+              }
+            } catch {
+              // microcompact is best-effort — never break the run
+            }
+          }
+          // After the trim, is the full (disruptive) compaction still needed?
+          const needFull = compactor.shouldAutoCompact(messages);
           // settings.json PreCompact hooks: a `block` decision SKIPS this
           // compaction round (e.g. the hook archived / owns the history). Fires
           // right before the history would be compacted.
           let preCompactBlocked = false;
           let preCompactReason = null;
-          if (options.settingsHooks) {
+          if (needFull && options.settingsHooks) {
             try {
               const pc = runObserveHooks(
                 options.settingsHooks,
@@ -3608,9 +3639,10 @@ export async function* agentLoop(messages, options) {
               reason: preCompactReason,
             };
           }
-          const { messages: compacted, stats } = preCompactBlocked
-            ? { messages, stats: { saved: 0 } }
-            : await compactor.compress(messages, { preserveToolPairs: true });
+          const { messages: compacted, stats } =
+            !needFull || preCompactBlocked
+              ? { messages, stats: { saved: 0 } }
+              : await compactor.compress(messages, { preserveToolPairs: true });
           if (stats.saved > 0 && compacted.length < messages.length) {
             messages.splice(0, messages.length, ...compacted);
             // Persist the compaction so a later --resume rebuilds from the
@@ -3699,7 +3731,20 @@ export async function* agentLoop(messages, options) {
     const toolCalls = msg.tool_calls;
 
     if (!toolCalls || toolCalls.length === 0) {
-      yield { type: "response-complete", content: msg.content || "" };
+      // Surface the final answer's extended-thinking reasoning (Anthropic, when
+      // --think is on) so non-streaming consumers (the REPL) can show it. The
+      // streaming path forwards reasoning live via onThinking instead.
+      const _thinking = Array.isArray(msg._thinkingBlocks)
+        ? msg._thinkingBlocks
+            .map((b) => b.thinking || "")
+            .join("")
+            .trim()
+        : "";
+      yield {
+        type: "response-complete",
+        content: msg.content || "",
+        ...(_thinking ? { thinking: _thinking } : {}),
+      };
       // settings.json Stop hooks: a `block` decision FORCES the agent to keep
       // going instead of stopping — the reason is injected as a new instruction.
       // `stop_hook_active` lets the hook avoid an infinite loop; the iteration
@@ -3741,6 +3786,18 @@ export async function* agentLoop(messages, options) {
       return;
     }
 
+    // Intermediate-step reasoning (Anthropic, --think): the model's reasoning
+    // before it chose these tool calls. Streaming consumers already get it live
+    // via onThinking, so only surface it as an event for non-streaming consumers
+    // (the REPL) — keeps it out of the --include-partial-messages stream.
+    if (!options.onThinking && Array.isArray(msg._thinkingBlocks)) {
+      const _stepThinking = msg._thinkingBlocks
+        .map((b) => b.thinking || "")
+        .join("")
+        .trim();
+      if (_stepThinking) yield { type: "thinking", text: _stepThinking };
+    }
+
     // Add assistant message with tool calls
     messages.push(msg);