chainlesschain 0.162.71 → 0.162.72

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/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 };
+}