chainlesschain 0.162.70 → 0.162.72

package/src/lib/hook-manager.js

@@ -4,6 +4,7 @@
  */
 
 import crypto from "crypto";
+import { execSync } from "child_process";
 
 /**
  * Hook priority levels — lower values run first.
@@ -256,8 +257,8 @@ export async function executeHook(hook, context = {}) {
     const type = hook.type || HookType.SYNC;
 
     if (type === HookType.COMMAND || type === HookType.SCRIPT) {
-      // Command/script hooks execute a shell command
-      const { execSync } = await import("child_process");
+      // Command/script hooks execute a shell command (execSync hoisted to a
+      // top-level import — this runs per hook on the tool-use hot path).
       const cmd = hook.handler || "";
       if (!cmd) {
         return {

package/src/lib/micro-compact.js

@@ -0,0 +1,52 @@
+/**
+ * Micro-compaction (Claude-Code `/microcompact` parity). Where full compaction
+ * summarizes the whole history when it grows large, micro-compaction is
+ * surgical: it trims the bulkiest OLD items — large tool results — in place,
+ * keeping the conversation flow and the most-recent messages verbatim. Because
+ * it only SHORTENS a tool message's content (never removes the message), it can
+ * never orphan a tool_call→tool_result pair, so it's safe to run any time.
+ *
+ * Pure → unit-testable.
+ */
+
+const DEFAULT_KEEP_RECENT = 6; // last N messages kept verbatim
+const DEFAULT_MAX_TOOL_CHARS = 400; // trim older tool results longer than this
+
+/**
+ * @param {Array} messages  OpenAI-shaped messages ({role, content, …}).
+ * @param {object} [opts]    { keepRecent, maxToolChars }
+ * @returns {{ messages: Array, stats: {trimmed:number, saved:number, kept:number} }}
+ *          A NEW array (originals untouched); `saved` ≈ characters freed.
+ */
+export function microCompact(messages, opts = {}) {
+  if (!Array.isArray(messages)) {
+    return { messages, stats: { trimmed: 0, saved: 0, kept: 0 } };
+  }
+  const keepRecent = Number.isFinite(opts.keepRecent)
+    ? opts.keepRecent
+    : DEFAULT_KEEP_RECENT;
+  const maxChars = Number.isFinite(opts.maxToolChars)
+    ? opts.maxToolChars
+    : DEFAULT_MAX_TOOL_CHARS;
+  // messages at index >= cutoff are "recent" and never touched.
+  const cutoff = Math.max(0, messages.length - keepRecent);
+
+  let trimmed = 0;
+  let saved = 0;
+  const out = messages.map((m, i) => {
+    if (i >= cutoff) return m; // recent → verbatim
+    if (!m || m.role !== "tool") return m; // only old tool results
+    const content = typeof m.content === "string" ? m.content : "";
+    if (content.length <= maxChars) return m; // small enough already
+    trimmed += 1;
+    saved += content.length - maxChars;
+    const head = content.slice(0, maxChars);
+    return {
+      ...m,
+      content: `${head}\n… [tool result trimmed — ${content.length} chars; older context dropped to save space]`,
+      _microCompacted: true,
+    };
+  });
+
+  return { messages: out, stats: { trimmed, saved, kept: keepRecent } };
+}

package/src/lib/permission-rules.cjs

@@ -13,6 +13,11 @@
  *   Read(./src/**)        → read_file/list_dir on a path under <cwd>/src
  *   Edit(//etc/**)        → edit_file on an absolute path under /etc
  *   WebFetch(domain:example.com) → web_fetch of https://example.com/…
+ *   Bash(command:rm*)     → run_shell whose `command` arg matches `rm*` (CC
+ *                           2.1.178 `Tool(param:value)` — matches any named
+ *                           input parameter, incl. arbitrary MCP tool args;
+ *                           `*` crosses `/` here, unlike path globs)
+ *   mcp__db__query(table:users) → that MCP tool whose `table` arg is "users"
  *   Bash                  → every run_shell call
  *   *                     → every tool call (Claude-Code deny-all idiom)
  *   Bash(*)               → every run_shell call (lone-`*` pattern = match-all)
@@ -197,6 +202,30 @@ function matchUrl(pattern, url) {
   return globToRegExp(pattern).test(u);
 }
 
+/** Match a single named-parameter value — `Tool(param:value)`. `prefix:*` →
+ *  starts-with; otherwise glob/exact. Unlike path globs, `*` here crosses `/`
+ *  because param values are arbitrary strings (commands often embed paths),
+ *  not filesystem path segments. */
+function matchParamValue(pattern, value) {
+  const v = value == null ? "" : String(value);
+  if (pattern === "*" || pattern === "**") return true;
+  if (pattern.endsWith(":*")) {
+    const prefix = pattern.slice(0, -2).trim();
+    return v === prefix || v.startsWith(prefix);
+  }
+  if (pattern.includes("*") || pattern.includes("?")) {
+    const re =
+      "^" +
+      pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".") +
+      "$";
+    return new RegExp(re).test(v);
+  }
+  return v === pattern;
+}
+
 /**
  * Does `pattern` (the inside of `Tool(...)`, or null for a bare rule) match the
  * given tool call? `null` pattern always matches.
@@ -208,6 +237,15 @@ function matchPattern(pattern, actualTool, args, cwd) {
   // command/url/path containing `/` can't slip past a deny-all (globToRegExp's
   // `*` → `[^/]*` otherwise excludes slashes).
   if (pattern === "*" || pattern === "**") return true;
+  // Claude-Code 2.1.178: `Tool(param:value)` matches a NAMED input parameter,
+  // generalizing the positional command/path/url targets below. Treated as a
+  // param rule only when `param` is a bare identifier AND an actual key in the
+  // tool's args — so command idioms (`git push:*`) and `domain:host` (whose
+  // prefix is not an arg key) correctly fall through to the matching below.
+  const pv = pattern.match(/^([A-Za-z_]\w*):([\s\S]*)$/);
+  if (pv && Object.prototype.hasOwnProperty.call(args || {}, pv[1])) {
+    return matchParamValue(pv[2].trim(), (args || {})[pv[1]]);
+  }
   const target = extractTarget(actualTool, args, cwd);
   if (target.kind === "command") {
     return target.value ? matchCommand(pattern, target.value) : false;
@@ -328,6 +366,7 @@ module.exports = {
   extractTarget,
   matchCommand,
   matchUrl,
+  matchParamValue,
   matchPattern,
   evaluatePermissionRules,
   suggestAllowRule,

package/src/lib/skill-loader.js

@@ -78,6 +78,10 @@ export const LAYER_NAMES = [
   "workspace",
 ];
 
+/** Max directory depth to descend when scanning a skill layer for nested
+ *  `<group>/<skill>/SKILL.md` layouts (infinite-recursion / deep-tree guard). */
+export const MAX_SKILL_NEST_DEPTH = 5;
+
 /**
  * Simple YAML frontmatter parser (no dependencies)
  * Shared utility extracted from skill.js
@@ -348,54 +352,69 @@ export class CLISkillLoader {
    */
   _loadFromDir(dir, layer) {
     const skills = [];
-    if (!dir || !fs.existsSync(dir)) return skills;
+    this._collectSkills(dir, layer, skills, 0);
+    return skills;
+  }
 
+  /**
+   * Recursively collect skills under `dir`. A directory containing a SKILL.md
+   * is a skill (a leaf — we do NOT descend into its asset/script subdirs); a
+   * directory WITHOUT one is treated as a grouping/category folder and is
+   * descended into, so nested layouts like `.claude/skills/<group>/<skill>/`
+   * load too (Claude-Code 2.1.178 nested-skills parity). Depth-capped.
+   */
+  _collectSkills(dir, layer, out, depth) {
+    if (!dir || !fs.existsSync(dir)) return;
+    let entries;
     try {
-      const dirs = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of dirs) {
-        if (!entry.isDirectory()) continue;
-
-        const skillMd = path.join(dir, entry.name, "SKILL.md");
-        if (!fs.existsSync(skillMd)) continue;
-
-        try {
-          const content = fs.readFileSync(skillMd, "utf-8");
-          const { data, body } = parseSkillMd(content);
-
-          skills.push({
-            id: data.name || entry.name,
-            displayName: data.displayName || entry.name,
-            description: data.description || "",
-            version: data.version || "1.0.0",
-            category: data.category || "uncategorized",
-            activation: data.activation || "manual",
-            tags: data.tags || [],
-            userInvocable: data.userInvocable !== false,
-            handler: data.handler || null,
-            capabilities: data.capabilities || [],
-            os: data.os || [],
-            // CLI pack extended fields
-            executionMode: data.executionMode || null,
-            cliDomain: data.cliDomain || null,
-            cliVersionHash: data.cliVersionHash || null,
-            dirName: entry.name,
-            hasHandler: fs.existsSync(path.join(dir, entry.name, "handler.js")),
-            body,
-            // Skill-Embedded MCP: inline server declarations in a
-            // ```mcp-servers fenced code block. Empty array if absent.
-            mcpServers: parseSkillMcpServers(body),
-            source: layer,
-            skillDir: path.join(dir, entry.name),
-          });
-        } catch {
-          // Skip malformed skill files
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return; // Directory unreadable
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillDir = path.join(dir, entry.name);
+      const skillMd = path.join(skillDir, "SKILL.md");
+      if (!fs.existsSync(skillMd)) {
+        // Grouping folder → descend (bounded) to find nested skills.
+        if (depth < MAX_SKILL_NEST_DEPTH) {
+          this._collectSkills(skillDir, layer, out, depth + 1);
         }
+        continue;
+      }
+      try {
+        const content = fs.readFileSync(skillMd, "utf-8");
+        const { data, body } = parseSkillMd(content);
+
+        out.push({
+          id: data.name || entry.name,
+          displayName: data.displayName || entry.name,
+          description: data.description || "",
+          version: data.version || "1.0.0",
+          category: data.category || "uncategorized",
+          activation: data.activation || "manual",
+          tags: data.tags || [],
+          userInvocable: data.userInvocable !== false,
+          handler: data.handler || null,
+          capabilities: data.capabilities || [],
+          os: data.os || [],
+          // CLI pack extended fields
+          executionMode: data.executionMode || null,
+          cliDomain: data.cliDomain || null,
+          cliVersionHash: data.cliVersionHash || null,
+          dirName: entry.name,
+          hasHandler: fs.existsSync(path.join(skillDir, "handler.js")),
+          body,
+          // Skill-Embedded MCP: inline server declarations in a
+          // ```mcp-servers fenced code block. Empty array if absent.
+          mcpServers: parseSkillMcpServers(body),
+          source: layer,
+          skillDir,
+        });
+      } catch {
+        // Skip malformed skill files
       }
-    } catch {
-      // Directory unreadable
     }
-
-    return skills;
   }
 
   /**

package/src/lib/workflow-state-reader.js

@@ -19,7 +19,16 @@ import fs from "fs";
 import path from "path";
 
 function safeId(id) {
-  if (!id || typeof id !== "string" || !/^[A-Za-z0-9._-]+$/.test(id)) {
+  // Charset blocks path separators; the explicit "."/".." check closes the
+  // remaining single-component traversal (e.g. `..` would join to the parent
+  // of the sessions dir and read files outside it).
+  if (
+    !id ||
+    typeof id !== "string" ||
+    !/^[A-Za-z0-9._-]+$/.test(id) ||
+    id === "." ||
+    id === ".."
+  ) {
     throw new Error(`Invalid sessionId: "${id}"`);
   }
   return id;

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");
       }