reasonix 0.43.0 → 0.44.0

package/dist/index.js

@@ -47,8 +47,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve10, reject) => {
-    const timer = setTimeout(resolve10, ms);
+  return new Promise((resolve13, reject) => {
+    const timer = setTimeout(resolve13, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -93,12 +93,15 @@ var Usage = class _Usage {
   }
   static fromApi(raw) {
     const u = raw ?? {};
+    const promptTokens = u.prompt_tokens ?? 0;
+    const cacheHitTokens = u.prompt_cache_hit_tokens ?? 0;
+    const cacheMissTokens = u.prompt_cache_miss_tokens ?? Math.max(0, promptTokens - cacheHitTokens);
     return new _Usage(
-      u.prompt_tokens ?? 0,
+      promptTokens,
       u.completion_tokens ?? 0,
       u.total_tokens ?? 0,
-      u.prompt_cache_hit_tokens ?? 0,
-      u.prompt_cache_miss_tokens ?? 0
+      cacheHitTokens,
+      cacheMissTokens
     );
   }
 };
@@ -309,10 +312,10 @@ var PauseGate = class {
         `${kind}: no confirmation listener registered \u2014 cannot prompt the user. This tool can only be used inside an interactive Reasonix session.`
       );
     }
-    return new Promise((resolve10) => {
+    return new Promise((resolve13) => {
       const id = this._nextId++;
       const request = { id, kind, payload };
-      this._pending.set(id, { resolve: resolve10, request });
+      this._pending.set(id, { resolve: resolve13, request });
       for (const fn of this._listeners) {
         try {
           fn(request);
@@ -427,12 +430,12 @@ import { join as join2 } from "path";
 // src/config.ts
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname, isAbsolute, join, resolve } from "path";
 
 // src/cli/ui/theme/tokens.ts
 function card(fg, tone) {
   return {
-    user: { color: fg.meta, glyph: "\u25C7" },
+    user: { color: tone.brand, glyph: "\u25C7" },
     reasoning: { color: tone.accent, glyph: "\u25C6" },
     streaming: { color: tone.brand, glyph: "\u25C8" },
     task: { color: tone.warn, glyph: "\u25B6" },
@@ -772,6 +775,85 @@ var DEFAULT_INDEX_EXCLUDES = {
 };
 var DEFAULT_MAX_FILE_BYTES = 256 * 1024;
 
+// src/mcp/shell-split.ts
+function shellSplit(input) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  let i = 0;
+  const s = input;
+  while (i < s.length) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+        i++;
+        continue;
+      }
+      if (ch === "\\" && quote === '"' && i + 1 < s.length) {
+        cur += s[i + 1];
+        i += 2;
+        continue;
+      }
+      cur += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (cur.length > 0) {
+        tokens.push(cur);
+        cur = "";
+      }
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  if (quote) {
+    throw new Error(
+      `shellSplit: unterminated ${quote === '"' ? "double" : "single"} quote in input`
+    );
+  }
+  if (cur.length > 0) tokens.push(cur);
+  return tokens;
+}
+
+// src/mcp/spec.ts
+var NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_-]*)=(.*)$/;
+var HTTP_URL = /^https?:\/\//i;
+var STREAMABLE_PREFIX = /^streamable\+(https?:\/\/.+)$/i;
+function parseMcpSpec(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("empty MCP spec");
+  }
+  const nameMatch = NAME_PREFIX.exec(trimmed);
+  const name = nameMatch ? nameMatch[1] : null;
+  const body = (nameMatch ? nameMatch[2] : trimmed).trim();
+  if (!body) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const streamMatch = STREAMABLE_PREFIX.exec(body);
+  if (streamMatch) {
+    return { transport: "streamable-http", name, url: streamMatch[1] };
+  }
+  if (HTTP_URL.test(body)) {
+    return { transport: "sse", name, url: body };
+  }
+  const argv = shellSplit(body);
+  if (argv.length === 0) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const [command, ...args] = argv;
+  return { transport: "stdio", name, command, args };
+}
+
 // src/config.ts
 var BUILTIN_TYPE_DOCS = {
   user: "role / skills / preferences",
@@ -809,6 +891,13 @@ function memoryTypeDefaults(typeName, cfg = readConfig()) {
   if (found.expires) out.expires = found.expires;
   return out;
 }
+var DEFAULT_METASO_API_KEY = "mk-E384C1DD5E8501BB7EFE27C949AFDE5B";
+function loadMetasoApiKey(path2 = defaultConfigPath()) {
+  if (process.env.METASO_API_KEY) return process.env.METASO_API_KEY;
+  const cfg = readConfig(path2).metasoApiKey;
+  if (cfg && typeof cfg === "string" && cfg.trim()) return cfg.trim();
+  return DEFAULT_METASO_API_KEY;
+}
 function defaultConfigPath() {
   return join(homedir(), ".reasonix", "config.json");
 }
@@ -850,9 +939,44 @@ function saveBaseUrl(url, path2 = defaultConfigPath()) {
   }
   writeConfig(cfg, path2);
 }
+function resolveSkillPath(raw, baseDir) {
+  const homeExpanded = expandCurrentUserHome(raw.trim());
+  return resolve(isAbsolute(homeExpanded) ? homeExpanded : join(baseDir, homeExpanded));
+}
+function normalizeSkillPathEntries(paths, baseDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of paths) {
+    if (typeof value !== "string") continue;
+    const raw = value.trim();
+    if (!raw) continue;
+    const resolved = resolveSkillPath(raw, baseDir);
+    const key = skillPathKey(resolved);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ raw, resolved });
+  }
+  return out;
+}
+function resolveSkillPaths(paths, baseDir) {
+  return normalizeSkillPathEntries(paths, baseDir).map((entry) => entry.resolved);
+}
+function skillPathKey(path2) {
+  return process.platform === "win32" ? path2.toLowerCase() : path2;
+}
+function expandCurrentUserHome(path2) {
+  if (path2 === "~") return homedir();
+  if (path2.startsWith("~/") || path2.startsWith("~\\")) return join(homedir(), path2.slice(2));
+  return path2;
+}
+function loadResolvedSkillPaths(baseDir = process.cwd(), path2 = defaultConfigPath()) {
+  const raw = readConfig(path2).skills?.paths;
+  return Array.isArray(raw) ? resolveSkillPaths(raw, baseDir) : [];
+}
 function webSearchEngine(path2 = defaultConfigPath()) {
   const cfg = readConfig(path2).webSearchEngine;
   if (cfg === "searxng") return "searxng";
+  if (cfg === "metaso") return "metaso";
   return "mojeek";
 }
 function webSearchEndpoint(path2 = defaultConfigPath()) {
@@ -952,6 +1076,16 @@ var EN = {
     update: "Check for a newer Reasonix and install it.",
     index: "Build (or incrementally refresh) a local semantic search index."
   },
+  stats: {
+    usageHint: "run `reasonix chat`, `reasonix code`, or `reasonix run <task>` \u2014 every turn",
+    usageDetail: "appends one line to the log and `reasonix stats` will roll it up."
+  },
+  run: {
+    missingApiKey: "DEEPSEEK_API_KEY is not set and stdin is not a TTY (cannot prompt).\nSet the env var, or run `reasonix chat` once interactively to save a key.\n"
+  },
+  sessions: {
+    emptyHint: "no saved sessions yet \u2014 run `reasonix chat` (sessions are auto-saved unless --no-session)."
+  },
   ui: {
     welcome: "Run `reasonix` any time to start chatting \u2014 your settings are remembered.",
     taglineChat: "DeepSeek-native agent",
@@ -1183,8 +1317,8 @@ var EN = {
       argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]"
     },
     skill: {
-      description: "list / run user skills (<project>/.reasonix/skills + ~/.reasonix/skills)",
-      argsHint: "[list|show <name>|<name> [args]]"
+      description: "list / run user skills (project + custom + global + builtin)",
+      argsHint: "[list|paths|show <name>|<name> [args]]"
     },
     hooks: {
       description: "list active hooks (settings.json under .reasonix/) \xB7 reload re-reads from disk",
@@ -1226,6 +1360,10 @@ var EN = {
       argsHint: "[N]"
     },
     sessions: { description: "list saved sessions (current marked with \u25B8)" },
+    qq: {
+      description: "connect, inspect, or disconnect the QQ channel for this session",
+      argsHint: "[connect [appId appSecret [sandbox]]|status|disconnect]"
+    },
     setup: { description: "reminds you to exit and run `reasonix setup`" },
     semantic: {
       description: "show semantic_search status \u2014 built? Ollama installed? how to enable"
@@ -1289,8 +1427,8 @@ var EN = {
       argsHint: "<question>"
     },
     "search-engine": {
-      description: "switch web search backend \u2014 mojeek (default, no deps) or searxng (self-hosted)",
-      argsHint: "<mojeek|searxng> [<endpoint>]"
+      description: "switch web search backend \u2014 mojeek (default, no deps), searxng (self-hosted), or metaso (free quota 100/d)",
+      argsHint: "<mojeek|searxng|metaso> [<endpoint>]"
     }
   },
   wizard: {
@@ -1484,12 +1622,12 @@ var EN = {
     budgetExhausted: "session budget exhausted \u2014 spent ${spent} \u2265 cap ${cap}. Bump the cap with /budget <usd>, clear it with /budget off, or end the session.",
     budget80Pct: "\u25B2 budget 80% used \u2014 ${spent} of ${cap}. Next turn or two likely trips the cap.",
     proArmed: "\u21E7 /pro armed \u2014 this turn runs on deepseek-v4-pro (one-shot \xB7 disarms after turn)",
-    abortedAtIter: "aborted at iter {iter}/{cap} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)",
+    abortedAtIter: "aborted at iter {iter} \u2014 stopped without producing a summary (press \u2191 + Enter or /retry to resume)",
     toolUploadStatus: "tool result uploaded \xB7 model thinking before next response\u2026",
-    toolBudgetWarning: "{iter}/{cap} tool calls used \u2014 approaching budget. Press Esc to force a summary now.",
-    preflightFoldStatus: "preflight: context near full, attempting fold\u2026",
-    preflightFolded: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) \u2014 folded {beforeMessages} messages \u2192 {afterMessages} (summary {summaryChars} chars). Sending.",
-    preflightNoFold: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) and nothing left to fold \u2014 DeepSeek will likely 400. Run /clear or /new to start fresh.",
+    preflightTruncateStatus: "preflight: context near full, truncating oldest history\u2026",
+    preflightTruncated: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) \u2014 truncated {beforeMessages} messages \u2192 {afterMessages}. Sending.",
+    preflightTruncatedStillFull: "preflight: request still ~{estimate}/{ctxMax} tokens ({pct}%) after truncating {beforeMessages} messages \u2192 {afterMessages}. DeepSeek will likely 400. Run /clear or /new to start fresh.",
+    preflightNoFold: "preflight: request ~{estimate}/{ctxMax} tokens ({pct}%) and nothing left to truncate \u2014 DeepSeek will likely 400. Run /clear or /new to start fresh.",
     flashEscalation: "\u21E7 flash requested escalation \u2014 retrying this turn on {model}{reasonSuffix}",
     harvestStatus: "extracting plan state from reasoning\u2026",
     autoEscalation: "\u21E7 auto-escalating to {model} for the rest of this turn \u2014 flash hit {breakdown}. Next turn falls back to {fallback} unless /pro is armed.",
@@ -1518,11 +1656,9 @@ var EN = {
     reasonAborted: "[aborted by user (Esc) \u2014 summarizing what I found so far]",
     reasonContextGuard: "[context budget running low \u2014 summarizing before the next call would overflow]",
     reasonStuck: "[stuck on a repeated tool call \u2014 explaining what was tried and what's blocking progress]",
-    reasonBudget: "[tool-call budget ({iterCap}) reached \u2014 forcing summary from what I found]",
     labelAborted: "aborted by user",
     labelContextGuard: "context-guard triggered (prompt > 80% of window)",
-    labelStuck: "stuck (repeated tool call suppressed by storm-breaker)",
-    labelBudget: "tool-call budget ({iterCap}) reached"
+    labelStuck: "stuck (repeated tool call suppressed by storm-breaker)"
   },
   handlers: {
     basic: {
@@ -1832,11 +1968,13 @@ var EN = {
       usageMojeek: "  /search-engine mojeek            use Mojeek (default, no external deps)",
       usageSearxng: "  /search-engine searxng            use SearXNG at default endpoint",
       usageSearxngUrl: "  /search-engine searxng <url>      use SearXNG at custom endpoint",
+      usageMetaso: "  /search-engine metaso              use Metaso API (100/d free, configure your own API key for more)",
       alias: "Alias: /se",
       searxngInfo: "SearXNG is a self-hosted metasearch engine (https://github.com/searxng/searxng).",
       searxngInstall: "Install it with:  docker run -d -p 8080:8080 searxng/searxng",
       switched: 'Switched web search engine to "{engine}".{note}',
       switchedSearxngNote: " Make sure SearXNG is running at {endpoint}.",
+      switchedMetasoNote: " There is a daily quota of 100 (configure your own API key for higher limits).",
       confirmed: '\u2713 Web search engine set to "{engine}"{detail}. Next assistant turn will pick up the change.',
       confirmedDetail: " ({endpoint})"
     },
@@ -1856,7 +1994,17 @@ var EN = {
       runInfo: "\u25B8 running skill: {name}{args}",
       newUsage: "usage: /skill new <name> [--global]",
       newCreated: "\u25B8 created skill: {name}\n  {path}\n  edit it, then `/skill {name}` to invoke",
-      newError: "\u25B2 /skill new failed: {reason}"
+      newError: "\u25B2 /skill new failed: {reason}",
+      pathsHeader: "Skill paths (priority order):",
+      pathsPriority: "Priority: project > custom paths in config order > global > builtin. Changes affect the system prompt on next /new or new session.",
+      pathsUsage: "usage: /skill paths [list]\n       /skill paths add <path>\n       /skill paths remove <path|N>",
+      pathsAddUsage: "usage: /skill paths add <path>",
+      pathsRemoveUsage: "usage: /skill paths remove <path|N>",
+      pathsAdded: "\u25B8 added custom skills path: {path}",
+      pathsAlready: "\u25B8 custom skills path already configured: {path}",
+      pathsRemoved: "\u25B8 removed custom skills path: {path}",
+      pathsRemoveNotFound: "\u25B8 no custom skills path matches: {target}",
+      pathsRestartHint: "The current session's system prompt is unchanged; run /new or start a new session to refresh the skills index."
     }
   },
   statusBar: {
@@ -1903,7 +2051,8 @@ var EN = {
     editorNoRawMode: "external editor unavailable \u2014 stdin doesn't support raw-mode toggling on this terminal",
     editorFailed: "external editor:",
     editorMissing: "no $EDITOR / $VISUAL / $GIT_EDITOR set \u2014 export one (e.g. `export EDITOR=nano`) and retry",
-    editorExited: "editor exited with code {code}"
+    editorExited: "editor exited with code {code}",
+    typeaheadStaged: "\u25B8 {count} line(s) staged \xB7 esc recall"
   },
   pathConfirm: {
     title: "Outside-sandbox path",
@@ -2073,6 +2222,12 @@ var EN = {
     endpointMustBeHttp: "web_search: SearXNG endpoint must be http(s), got {protocol} \u2014 try: set a valid URL with /search-endpoint http://host:port",
     cannotReach: "web_search: Cannot reach SearXNG server at {endpoint} \u2014 try: install and start SearXNG (https://github.com/searxng/searxng, e.g. `docker run -d -p 8080:8080 searxng/searxng`), or switch to the default engine with /search-engine mojeek",
     searxngNoResults: "web_search: 0 results but SearXNG response doesn't look like an empty results page ({chars} chars) \u2014 try: rephrase the query with simpler terms, or switch engine with /search-engine mojeek",
+    metasoDailyLimit: "web_search: daily search limit reached for the default API key \u2014 set your own METASO_API_KEY env var or get one at https://metaso.cn/search-api/playground",
+    metasoUnauthorized: "web_search: Metaso API key rejected \u2014 check METASO_API_KEY or get one at https://metaso.cn/search-api/playground",
+    metasoRateLimit: "web_search: Metaso rate-limited \u2014 wait and retry, or get your own API key at https://metaso.cn/search-api/playground",
+    metasoServerError: "web_search: Metaso server error ({status}) \u2014 try again later, or switch engine with /search-engine mojeek",
+    metasoParseError: "web_search: Metaso returned unparseable response (HTTP {status}) \u2014 try again later",
+    metasoApiError: "web_search: Metaso API error (code {code}: {message}) \u2014 try again later",
     fetchStatus: "web_fetch {status} for {url} \u2014 try: confirm the URL resolves in a browser; status suggests the host returned an error page",
     fetchRateLimit429: "web_fetch 429 for {url} \u2014 try: wait 10s before retrying; the host is rate-limiting this client",
     fetchForbidden403: "web_fetch 403 for {url} \u2014 try: the host is blocking this client; the page may require login or block bots \u2014 use web_search snippets instead",
@@ -2333,6 +2488,16 @@ var zhCN = {
     update: "\u68C0\u67E5\u8F83\u65B0\u7248\u672C\u7684 Reasonix \u5E76\u5B89\u88C5\u3002",
     index: "\u6784\u5EFA\uFF08\u6216\u589E\u91CF\u5237\u65B0\uFF09\u672C\u5730\u8BED\u4E49\u641C\u7D22\u7D22\u5F15\u3002"
   },
+  stats: {
+    usageHint: "\u8FD0\u884C `reasonix chat`\u3001`reasonix code` \u6216 `reasonix run <task>` \u2014 \u6BCF\u6B21\u5BF9\u8BDD\u90FD\u4F1A\u8BB0\u5F55",
+    usageDetail: "\u6BCF\u6B21\u5BF9\u8BDD\u5728\u65E5\u5FD7\u4E2D\u8FFD\u52A0\u4E00\u884C\uFF0C`reasonix stats` \u4F1A\u5C06\u5176\u6C47\u603B\u7EDF\u8BA1\u3002"
+  },
+  run: {
+    missingApiKey: "\u672A\u8BBE\u7F6E DEEPSEEK_API_KEY \u4E14\u6807\u51C6\u8F93\u5165\u4E0D\u662F TTY\uFF08\u65E0\u6CD5\u4EA4\u4E92\u5F0F\u8F93\u5165\uFF09\u3002\n\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF\uFF0C\u6216\u5148\u8FD0\u884C `reasonix chat` \u4EA4\u4E92\u4E00\u6B21\u4EE5\u4FDD\u5B58\u5BC6\u94A5\u3002\n"
+  },
+  sessions: {
+    emptyHint: "\u6682\u65E0\u5DF2\u4FDD\u5B58\u7684\u4F1A\u8BDD \u2014 \u8FD0\u884C `reasonix chat`\uFF08\u4F1A\u8BDD\u4F1A\u81EA\u52A8\u4FDD\u5B58\uFF0C\u9664\u975E\u4F7F\u7528\u4E86 --no-session\uFF09\u3002"
+  },
   ui: {
     welcome: "\u968F\u65F6\u8FD0\u884C `reasonix` \u5F00\u59CB\u804A\u5929 \u2014 \u60A8\u7684\u8BBE\u7F6E\u5C06\u88AB\u8BB0\u4F4F\u3002",
     taglineChat: "DeepSeek \u539F\u751F\u667A\u80FD\u4F53",
@@ -2561,8 +2726,8 @@ var zhCN = {
       argsHint: "[list|show <name>|forget <name>|clear <scope> confirm]"
     },
     skill: {
-      description: "\u5217\u51FA / \u8FD0\u884C\u7528\u6237\u6280\u80FD\uFF08<project>/.reasonix/skills + ~/.reasonix/skills\uFF09",
-      argsHint: "[list|show <name>|<name> [args]]"
+      description: "\u5217\u51FA / \u8FD0\u884C\u7528\u6237\u6280\u80FD\uFF08\u9879\u76EE + \u81EA\u5B9A\u4E49 + \u5168\u5C40 + \u5185\u7F6E\uFF09",
+      argsHint: "[list|paths|show <name>|<name> [args]]"
     },
     hooks: {
       description: "\u5217\u51FA\u6D3B\u8DC3\u7684 hooks\uFF08.reasonix/ \u4E0B\u7684 settings.json\uFF09\xB7 reload \u4ECE\u78C1\u76D8\u91CD\u65B0\u8BFB\u53D6",
@@ -2606,6 +2771,10 @@ var zhCN = {
       argsHint: "[N]"
     },
     sessions: { description: "\u5217\u51FA\u5DF2\u4FDD\u5B58\u7684\u4F1A\u8BDD\uFF08\u5F53\u524D\u6807\u8BB0\u4E3A \u25B8\uFF09" },
+    qq: {
+      description: "\u8FDE\u63A5\u3001\u67E5\u770B\u6216\u65AD\u5F00\u5F53\u524D\u4F1A\u8BDD\u7684 QQ \u901A\u9053",
+      argsHint: "[connect [appId appSecret [sandbox]]|status|disconnect]"
+    },
     setup: { description: "\u63D0\u9192\u60A8\u9000\u51FA\u5E76\u8FD0\u884C `reasonix setup`" },
     semantic: {
       description: "\u663E\u793A semantic_search \u72B6\u6001 \u2014 \u5DF2\u6784\u5EFA\uFF1FOllama \u5DF2\u5B89\u88C5\uFF1F\u5982\u4F55\u542F\u7528"
@@ -2671,8 +2840,8 @@ var zhCN = {
       argsHint: "<question>"
     },
     "search-engine": {
-      description: "\u5207\u6362\u7F51\u7EDC\u641C\u7D22\u540E\u7AEF \u2014 mojeek\uFF08\u9ED8\u8BA4\uFF0C\u65E0\u4F9D\u8D56\uFF09\u6216 searxng\uFF08\u81EA\u6258\u7BA1\uFF09",
-      argsHint: "<mojeek|searxng> [<endpoint>]"
+      description: "\u5207\u6362\u7F51\u7EDC\u641C\u7D22\u540E\u7AEF \u2014 mojeek\uFF08\u9ED8\u8BA4\uFF0C\u65E0\u4F9D\u8D56\uFF09\u3001searxng\uFF08\u81EA\u6258\u7BA1\uFF09\u6216 metaso\uFF08\u6BCF\u65E5 100 \u6B21\u514D\u8D39\u989D\u5EA6\uFF09",
+      argsHint: "<mojeek|searxng|metaso> [<endpoint>]"
     }
   },
   wizard: {
@@ -2866,12 +3035,12 @@ var zhCN = {
     budgetExhausted: "\u4F1A\u8BDD\u9884\u7B97\u5DF2\u7528\u5B8C \u2014 \u5DF2\u82B1\u8D39 ${spent} \u2265 \u4E0A\u9650 ${cap}\u3002\u7528 /budget <usd> \u63D0\u9AD8\u4E0A\u9650\uFF0C/budget off \u6E05\u9664\u4E0A\u9650\uFF0C\u6216\u7ED3\u675F\u4F1A\u8BDD\u3002",
     budget80Pct: "\u25B2 \u9884\u7B97\u5DF2\u7528 80% \u2014 ${spent} / ${cap}\u3002\u4E0B\u4E00\u4E24\u8F6E\u53EF\u80FD\u5C31\u89E6\u9876\u3002",
     proArmed: "\u21E7 /pro \u5DF2\u88C5\u5907 \u2014 \u672C\u8F6E\u4F7F\u7528 deepseek-v4-pro\uFF08\u4E00\u6B21\u6027 \xB7 \u672C\u8F6E\u540E\u81EA\u52A8\u89E3\u9664\uFF09",
-    abortedAtIter: "\u5728\u7B2C {iter}/{cap} \u6B21\u5DE5\u5177\u8C03\u7528\u5904\u4E2D\u65AD \u2014 \u672A\u751F\u6210\u603B\u7ED3\u5373\u505C\u6B62\uFF08\u6309 \u2191 + Enter \u6216 /retry \u6062\u590D\uFF09",
+    abortedAtIter: "\u5728\u7B2C {iter} \u6B21\u5DE5\u5177\u8C03\u7528\u5904\u4E2D\u65AD \u2014 \u672A\u751F\u6210\u603B\u7ED3\u5373\u505C\u6B62\uFF08\u6309 \u2191 + Enter \u6216 /retry \u6062\u590D\uFF09",
     toolUploadStatus: "\u5DE5\u5177\u7ED3\u679C\u5DF2\u4E0A\u4F20 \xB7 \u6A21\u578B\u5728\u751F\u6210\u4E0B\u4E00\u6761\u54CD\u5E94\u524D\u601D\u8003\u4E2D\u2026",
-    toolBudgetWarning: "\u5DF2\u7528 {iter}/{cap} \u6B21\u5DE5\u5177\u8C03\u7528 \u2014 \u63A5\u8FD1\u4E0A\u9650\u3002\u6309 Esc \u7ACB\u5373\u5F3A\u5236\u603B\u7ED3\u3002",
-    preflightFoldStatus: "\u9884\u68C0\uFF1A\u4E0A\u4E0B\u6587\u63A5\u8FD1\u4E0A\u9650\uFF0C\u5C1D\u8BD5\u6298\u53E0\u2026",
-    preflightFolded: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u2014 \u5DF2\u6298\u53E0 {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages}\uFF08\u603B\u7ED3 {summaryChars} \u5B57\uFF09\u3002\u53D1\u9001\u4E2D\u3002",
-    preflightNoFold: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u4E14\u6CA1\u6709\u53EF\u6298\u53E0\u7684\u5185\u5BB9 \u2014 DeepSeek \u5927\u6982\u7387\u4F1A\u8FD4\u56DE 400\u3002\u8BF7\u8FD0\u884C /clear \u6216 /new \u91CD\u65B0\u5F00\u59CB\u3002",
+    preflightTruncateStatus: "\u9884\u68C0\uFF1A\u4E0A\u4E0B\u6587\u63A5\u8FD1\u4E0A\u9650\uFF0C\u6B63\u5728\u88C1\u526A\u6700\u65E9\u5386\u53F2\u2026",
+    preflightTruncated: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u2014 \u5DF2\u88C1\u526A {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages}\u3002\u53D1\u9001\u4E2D\u3002",
+    preflightTruncatedStillFull: "\u9884\u68C0\uFF1A\u88C1\u526A {beforeMessages} \u6761\u6D88\u606F \u2192 {afterMessages} \u540E\uFF0C\u8BF7\u6C42\u4ECD\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u2014 DeepSeek \u5927\u6982\u7387\u4F1A\u8FD4\u56DE 400\u3002\u8BF7\u8FD0\u884C /clear \u6216 /new \u91CD\u65B0\u5F00\u59CB\u3002",
+    preflightNoFold: "\u9884\u68C0\uFF1A\u8BF7\u6C42\u7EA6 {estimate}/{ctxMax} tokens\uFF08{pct}%\uFF09\u4E14\u6CA1\u6709\u53EF\u88C1\u526A\u7684\u5185\u5BB9 \u2014 DeepSeek \u5927\u6982\u7387\u4F1A\u8FD4\u56DE 400\u3002\u8BF7\u8FD0\u884C /clear \u6216 /new \u91CD\u65B0\u5F00\u59CB\u3002",
     flashEscalation: "\u21E7 flash \u8BF7\u6C42\u5347\u7EA7 \u2014 \u672C\u8F6E\u6539\u7528 {model}{reasonSuffix}",
     harvestStatus: "\u6B63\u5728\u4ECE\u63A8\u7406\u8FC7\u7A0B\u63D0\u53D6\u8BA1\u5212\u72B6\u6001\u2026",
     autoEscalation: "\u21E7 \u672C\u8F6E\u5269\u4F59\u8C03\u7528\u81EA\u52A8\u5347\u7EA7\u5230 {model} \u2014 flash \u547D\u4E2D {breakdown}\u3002\u4E0B\u4E00\u8F6E\u56DE\u9000\u5230 {fallback}\uFF0C\u9664\u975E\u5DF2\u88C5\u5907 /pro\u3002",
@@ -2900,11 +3069,9 @@ var zhCN = {
     reasonAborted: "[\u7528\u6237\u5DF2\u4E2D\u65AD\uFF08Esc\uFF09 \u2014 \u6B63\u5728\u603B\u7ED3\u5230\u76EE\u524D\u4E3A\u6B62\u7684\u53D1\u73B0]",
     reasonContextGuard: "[\u4E0A\u4E0B\u6587\u989D\u5EA6\u5373\u5C06\u8017\u5C3D \u2014 \u5728\u4E0B\u4E00\u6B21\u8C03\u7528\u6EA2\u51FA\u4E4B\u524D\u5148\u603B\u7ED3]",
     reasonStuck: "[\u5361\u5728\u91CD\u590D\u7684\u5DE5\u5177\u8C03\u7528\u4E0A \u2014 \u8BF4\u660E\u5DF2\u5C1D\u8BD5\u7684\u65B9\u6CD5\u4EE5\u53CA\u963B\u585E\u70B9]",
-    reasonBudget: "[\u5DE5\u5177\u8C03\u7528\u914D\u989D\uFF08{iterCap}\uFF09\u5DF2\u7528\u5C3D \u2014 \u57FA\u4E8E\u5DF2\u53D1\u73B0\u7684\u5185\u5BB9\u5F3A\u5236\u603B\u7ED3]",
     labelAborted: "\u7528\u6237\u4E2D\u65AD",
     labelContextGuard: "\u89E6\u53D1\u4E0A\u4E0B\u6587\u4FDD\u62A4\uFF08prompt > 80% \u7A97\u53E3\uFF09",
-    labelStuck: "\u5361\u6B7B\uFF08\u91CD\u590D\u5DE5\u5177\u8C03\u7528\u88AB\u53CD\u98CE\u66B4\u673A\u5236\u6291\u5236\uFF09",
-    labelBudget: "\u5DE5\u5177\u8C03\u7528\u914D\u989D\uFF08{iterCap}\uFF09\u5DF2\u7528\u5C3D"
+    labelStuck: "\u5361\u6B7B\uFF08\u91CD\u590D\u5DE5\u5177\u8C03\u7528\u88AB\u53CD\u98CE\u66B4\u673A\u5236\u6291\u5236\uFF09"
   },
   handlers: {
     basic: {
@@ -3214,11 +3381,13 @@ var zhCN = {
       usageMojeek: "  /search-engine mojeek            \u4F7F\u7528 Mojeek\uFF08\u9ED8\u8BA4\uFF0C\u65E0\u5916\u90E8\u4F9D\u8D56\uFF09",
       usageSearxng: "  /search-engine searxng            \u4F7F\u7528 SearXNG \u9ED8\u8BA4\u7AEF\u70B9",
       usageSearxngUrl: "  /search-engine searxng <url>      \u4F7F\u7528 SearXNG \u81EA\u5B9A\u4E49\u7AEF\u70B9",
+      usageMetaso: "  /search-engine metaso              \u4F7F\u7528 Metaso API\uFF08\u6BCF\u5929 100 \u6B21\u514D\u8D39\uFF0C\u914D\u7F6E\u4F60\u81EA\u5DF1\u7684 API \u5BC6\u94A5\u53EF\u63D0\u5347\u9650\u989D\uFF09",
       alias: "\u522B\u540D\uFF1A/se",
       searxngInfo: "SearXNG \u662F\u4E00\u4E2A\u81EA\u6258\u7BA1\u7684\u5143\u641C\u7D22\u5F15\u64CE\uFF08https://github.com/searxng/searxng\uFF09\u3002",
       searxngInstall: "\u5B89\u88C5\u547D\u4EE4\uFF1A  docker run -d -p 8080:8080 searxng/searxng",
       switched: '\u5DF2\u5207\u6362\u7F51\u9875\u641C\u7D22\u5F15\u64CE\u4E3A "{engine}"\u3002{note}',
       switchedSearxngNote: " \u8BF7\u786E\u4FDD SearXNG \u5728 {endpoint} \u8FD0\u884C\u3002",
+      switchedMetasoNote: " \u6BCF\u65E5\u9650\u989D 100 \u6B21\uFF08\u914D\u7F6E\u4F60\u81EA\u5DF1\u7684 API \u5BC6\u94A5\u53EF\u63D0\u5347\u9650\u989D\uFF09\u3002",
       confirmed: '\u2713 \u7F51\u9875\u641C\u7D22\u5F15\u64CE\u5DF2\u8BBE\u4E3A "{engine}"{detail}\u3002\u4E0B\u4E00\u8F6E\u6A21\u578B\u8C03\u7528\u5C06\u751F\u6548\u3002',
       confirmedDetail: "\uFF08{endpoint}\uFF09"
     },
@@ -3238,7 +3407,17 @@ var zhCN = {
       runInfo: "\u25B8 \u6B63\u5728\u8FD0\u884C\u6280\u80FD\uFF1A{name}{args}",
       newUsage: "\u7528\u6CD5\uFF1A/skill new <name> [--global]",
       newCreated: "\u25B8 \u5DF2\u521B\u5EFA\u6280\u80FD\uFF1A{name}\n  {path}\n  \u7F16\u8F91\u540E\u7528 `/skill {name}` \u8C03\u7528",
-      newError: "\u25B2 /skill new \u5931\u8D25\uFF1A{reason}"
+      newError: "\u25B2 /skill new \u5931\u8D25\uFF1A{reason}",
+      pathsHeader: "\u6280\u80FD\u8DEF\u5F84\uFF08\u6309\u4F18\u5148\u7EA7\uFF09\uFF1A",
+      pathsPriority: "\u4F18\u5148\u7EA7\uFF1A\u9879\u76EE > \u914D\u7F6E\u987A\u5E8F\u4E2D\u7684\u81EA\u5B9A\u4E49\u8DEF\u5F84 > \u5168\u5C40 > \u5185\u7F6E\u3002\u66F4\u6539\u4F1A\u5728\u4E0B\u6B21 /new \u6216\u65B0\u4F1A\u8BDD\u5237\u65B0\u7CFB\u7EDF\u63D0\u793A\u8BCD\u65F6\u751F\u6548\u3002",
+      pathsUsage: "\u7528\u6CD5\uFF1A/skill paths [list]\n       /skill paths add <path>\n       /skill paths remove <path|N>",
+      pathsAddUsage: "\u7528\u6CD5\uFF1A/skill paths add <path>",
+      pathsRemoveUsage: "\u7528\u6CD5\uFF1A/skill paths remove <path|N>",
+      pathsAdded: "\u25B8 \u5DF2\u6DFB\u52A0\u81EA\u5B9A\u4E49\u6280\u80FD\u8DEF\u5F84\uFF1A{path}",
+      pathsAlready: "\u25B8 \u81EA\u5B9A\u4E49\u6280\u80FD\u8DEF\u5F84\u5DF2\u5B58\u5728\uFF1A{path}",
+      pathsRemoved: "\u25B8 \u5DF2\u79FB\u9664\u81EA\u5B9A\u4E49\u6280\u80FD\u8DEF\u5F84\uFF1A{path}",
+      pathsRemoveNotFound: "\u25B8 \u6CA1\u6709\u5339\u914D\u7684\u81EA\u5B9A\u4E49\u6280\u80FD\u8DEF\u5F84\uFF1A{target}",
+      pathsRestartHint: "\u5F53\u524D\u4F1A\u8BDD\u7684\u7CFB\u7EDF\u63D0\u793A\u8BCD\u4E0D\u4F1A\u70ED\u66F4\u65B0\uFF1B\u8FD0\u884C /new \u6216\u542F\u52A8\u65B0\u4F1A\u8BDD\u4EE5\u5237\u65B0\u6280\u80FD\u7D22\u5F15\u3002"
     }
   },
   statusBar: {
@@ -3285,7 +3464,8 @@ var zhCN = {
     editorNoRawMode: "\u5916\u90E8\u7F16\u8F91\u5668\u4E0D\u53EF\u7528 \u2014 \u5F53\u524D\u7EC8\u7AEF\u4E0D\u652F\u6301 raw-mode \u5207\u6362",
     editorFailed: "\u5916\u90E8\u7F16\u8F91\u5668\uFF1A",
     editorMissing: "\u672A\u8BBE\u7F6E $EDITOR / $VISUAL / $GIT_EDITOR \u2014 \u8BF7\u5BFC\u51FA\u73AF\u5883\u53D8\u91CF\uFF08\u4F8B\u5982 `export EDITOR=nano`\uFF09\u540E\u91CD\u8BD5",
-    editorExited: "\u7F16\u8F91\u5668\u5F02\u5E38\u9000\u51FA\uFF0C\u8FD4\u56DE\u7801 {code}"
+    editorExited: "\u7F16\u8F91\u5668\u5F02\u5E38\u9000\u51FA\uFF0C\u8FD4\u56DE\u7801 {code}",
+    typeaheadStaged: "\u25B8 {count} \u884C\u5DF2\u6682\u5B58 \xB7 esc \u53EC\u56DE"
   },
   pathConfirm: {
     title: "\u6C99\u7BB1\u5916\u8DEF\u5F84",
@@ -3455,6 +3635,12 @@ var zhCN = {
     endpointMustBeHttp: "web_search: SearXNG \u7AEF\u70B9\u5FC5\u987B\u662F http(s) \u534F\u8BAE\uFF0C\u5F53\u524D\u4E3A {protocol} \u2014 try: \u4F7F\u7528 /search-endpoint http://host:port \u8BBE\u7F6E\u6709\u6548\u7684 URL",
     cannotReach: "web_search: \u65E0\u6CD5\u8BBF\u95EE SearXNG \u670D\u52A1\u5668 {endpoint} \u2014 try: \u5B89\u88C5\u5E76\u542F\u52A8 SearXNG\uFF08https://github.com/searxng/searxng\uFF0C\u4F8B\u5982 `docker run -d -p 8080:8080 searxng/searxng`\uFF09\uFF0C\u6216\u4F7F\u7528 /search-engine mojeek \u5207\u6362\u5230\u9ED8\u8BA4\u5F15\u64CE",
     searxngNoResults: "web_search: \u8FD4\u56DE 0 \u6761\u7ED3\u679C\u4F46 SearXNG \u54CD\u5E94\u770B\u8D77\u6765\u4E0D\u662F\u6B63\u5E38\u7A7A\u7ED3\u679C\u9875\uFF08{chars} \u5B57\u7B26\uFF09\u2014 try: \u4F7F\u7528\u66F4\u7B80\u5355\u7684\u5173\u952E\u8BCD\u6539\u5199\u67E5\u8BE2\uFF0C\u6216\u4F7F\u7528 /search-engine mojeek \u5207\u6362\u5F15\u64CE",
+    metasoDailyLimit: "web_search: \u9ED8\u8BA4 API \u5BC6\u94A5\u7684\u6BCF\u65E5\u641C\u7D22\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650 \u2014 \u8BBE\u7F6E METASO_API_KEY \u73AF\u5883\u53D8\u91CF\uFF0C\u6216\u5728 https://metaso.cn/search-api/playground \u83B7\u53D6\u81EA\u5DF1\u7684\u5BC6\u94A5",
+    metasoUnauthorized: "web_search: Metaso API \u5BC6\u94A5\u88AB\u62D2\u7EDD \u2014 \u68C0\u67E5 METASO_API_KEY\uFF0C\u6216\u5728 https://metaso.cn/search-api/playground \u83B7\u53D6\u5BC6\u94A5",
+    metasoRateLimit: "web_search: Metaso \u8BF7\u6C42\u9891\u7387\u9650\u5236 \u2014 \u7B49\u5F85\u540E\u91CD\u8BD5\uFF0C\u6216\u5728 https://metaso.cn/search-api/playground \u83B7\u53D6\u81EA\u5DF1\u7684\u5BC6\u94A5",
+    metasoServerError: "web_search: Metaso \u670D\u52A1\u5668\u9519\u8BEF\uFF08{status}\uFF09\u2014 \u7A0D\u540E\u91CD\u8BD5\uFF0C\u6216\u4F7F\u7528 /search-engine mojeek \u5207\u6362\u5F15\u64CE",
+    metasoParseError: "web_search: Metaso \u8FD4\u56DE\u65E0\u6CD5\u89E3\u6790\u7684\u54CD\u5E94\uFF08HTTP {status}\uFF09\u2014 \u7A0D\u540E\u91CD\u8BD5",
+    metasoApiError: "web_search: Metaso API \u9519\u8BEF\uFF08code {code}: {message}\uFF09\u2014 \u7A0D\u540E\u91CD\u8BD5",
     fetchStatus: "web_fetch {status} for {url} \u2014 try: \u5728\u6D4F\u89C8\u5668\u4E2D\u786E\u8BA4\u8BE5 URL \u80FD\u5426\u8BBF\u95EE\uFF1B\u8BE5\u72B6\u6001\u7801\u8868\u660E\u76EE\u6807\u4E3B\u673A\u8FD4\u56DE\u4E86\u9519\u8BEF\u9875\u9762",
     fetchRateLimit429: "web_fetch 429 for {url} \u2014 try: \u7B49\u5F85 10 \u79D2\u540E\u91CD\u8BD5\uFF1B\u76EE\u6807\u4E3B\u673A\u6B63\u5728\u5BF9\u8BE5\u5BA2\u6237\u7AEF\u8FDB\u884C\u9650\u6D41",
     fetchForbidden403: "web_fetch 403 for {url} \u2014 try: \u76EE\u6807\u4E3B\u673A\u62D2\u7EDD\u8BE5\u5BA2\u6237\u7AEF\u8BBF\u95EE\uFF1B\u8BE5\u9875\u9762\u53EF\u80FD\u9700\u8981\u767B\u5F55\u6216\u5C4F\u853D\u722C\u866B \u2014 \u6539\u7528 web_search \u6458\u8981",
@@ -3786,7 +3972,7 @@ function matchesTool(hook, toolName) {
 }
 var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve13) => {
     const child = spawn(input.command, {
       cwd: input.cwd,
       shell: true,
@@ -3831,7 +4017,7 @@ function defaultSpawner(input) {
     child.stderr.on("data", (chunk) => onChunk("stderr", chunk));
     child.once("error", (err) => {
       clearTimeout(timer);
-      resolve10({
+      resolve13({
         exitCode: null,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8"),
@@ -3842,7 +4028,7 @@ function defaultSpawner(input) {
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve10({
+      resolve13({
         exitCode: code,
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
         stderr: Buffer.concat(stderrChunks).toString("utf8").trim(),
@@ -4078,22 +4264,211 @@ function encode(text) {
 function countTokens(text) {
   return encode(text).length;
 }
-function estimateConversationTokens(messages) {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m.content === "string" && m.content) {
-      total += countTokens(m.content);
+var DEFAULT_BOUNDED_TOKENIZE_CHARS = 2 * 1024;
+function countTokensBounded(text, maxChars = DEFAULT_BOUNDED_TOKENIZE_CHARS) {
+  if (text.length === 0) return 0;
+  const cap = Math.floor(maxChars);
+  if (cap > 0 && text.length <= cap) return countTokens(text);
+  if (cap <= 0) return Math.max(1, Math.ceil(text.length * 0.3));
+  const headChars = Math.ceil(cap / 2);
+  const tailChars = Math.floor(cap / 2);
+  const head = text.slice(0, headChars);
+  const tail = tailChars > 0 ? text.slice(-tailChars) : "";
+  const sampleChars = head.length + tail.length;
+  const sampleTokens = countTokens(head) + countTokens(tail);
+  const ratio = sampleChars > 0 ? sampleTokens / sampleChars : 0.3;
+  return Math.max(1, Math.ceil(text.length * ratio));
+}
+var BOS = "<\uFF5Cbegin\u2581of\u2581sentence\uFF5C>";
+var EOS = "<\uFF5Cend\u2581of\u2581sentence\uFF5C>";
+var USER_SP = "<\uFF5CUser\uFF5C>";
+var ASSISTANT_SP = "<\uFF5CAssistant\uFF5C>";
+var THINK_START = "<think>";
+var THINK_END = "</think>";
+var DSML = "\uFF5CDSML\uFF5C";
+var TC_BEGIN = `<${DSML}tool_calls>`;
+var TC_END = `</${DSML}tool_calls>`;
+var INVOKE_BEGIN = `<${DSML}invoke name="`;
+var INVOKE_END = `</${DSML}invoke>`;
+var PARAM_TEMPLATE = `<${DSML}parameter name="{key}" string="{is_str}">{value}</${DSML}parameter>`;
+var TOOL_RESULT_TEMPLATE = "<tool_result>{content}</tool_result>";
+var toolsTemplateCache = /* @__PURE__ */ new WeakMap();
+function renderTools(tools) {
+  const cached2 = toolsTemplateCache.get(tools);
+  if (cached2 !== void 0) return cached2;
+  const schemas = tools.map((t2) => {
+    const fn = t2.function ?? t2;
+    return JSON.stringify(fn);
+  }).join("\n");
+  const rendered = `## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<${DSML}tool_calls>" block like the following:
+
+<${DSML}tool_calls>
+<${DSML}invoke name="$TOOL_NAME">
+<${DSML}parameter name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</${DSML}parameter>
+...
+</${DSML}invoke>
+<${DSML}invoke name="$TOOL_NAME2">
+...
+</${DSML}invoke>
+</${DSML}tool_calls>
+
+String parameters should be specified as is and set \`string="true"\`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set \`string="false"\`.
+
+If thinking_mode is enabled (triggered by ${THINK_START}), you MUST output your complete reasoning inside ${THINK_START}...${THINK_END} BEFORE any tool calls or final response.
+
+Otherwise, output directly after ${THINK_END} with tool calls or final response.
+
+### Available Tool Schemas
+
+${schemas}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.`;
+  toolsTemplateCache.set(tools, rendered);
+  return rendered;
+}
+function encodeArgumentsToDsml(argsJson) {
+  let args;
+  try {
+    args = JSON.parse(argsJson);
+  } catch {
+    args = { arguments: argsJson };
+  }
+  return Object.entries(args).map(
+    ([k, v]) => PARAM_TEMPLATE.replace("{key}", k).replace("{is_str}", typeof v === "string" ? "true" : "false").replace("{value}", typeof v === "string" ? v : JSON.stringify(v))
+  ).join("\n");
+}
+function renderToolCallsDsml(toolCalls) {
+  const invokes = toolCalls.map((tc) => {
+    const name = tc.function?.name ?? "";
+    const argsJson = tc.function?.arguments ?? "{}";
+    return `${INVOKE_BEGIN + name}">
+${encodeArgumentsToDsml(argsJson)}
+${INVOKE_END}`;
+  }).join("\n");
+  return `
+
+${TC_BEGIN}
+${invokes}
+${TC_END}`;
+}
+function mergeToolMessages(messages) {
+  const merged = [];
+  for (const msg of messages) {
+    const role = msg.role ?? "user";
+    if (role === "tool") {
+      const toolBlock = TOOL_RESULT_TEMPLATE.replace("{content}", msg.content ?? "");
+      const last = merged[merged.length - 1];
+      if (last && last.role === "user" && Array.isArray(last._toolBlocks) && Array.isArray(last._textParts)) {
+        last._toolBlocks.push(toolBlock);
+        last.content = `${last._textParts.join("\n\n")}
+
+${last._toolBlocks.join("\n")}`.replace(
+          /^\n\n/,
+          ""
+        );
+      } else {
+        merged.push({
+          role: "user",
+          content: toolBlock,
+          _textParts: [],
+          _toolBlocks: [toolBlock]
+        });
+      }
+    } else if (role === "user") {
+      const text = msg.content ?? "";
+      const last = merged[merged.length - 1];
+      if (last && last.role === "user" && Array.isArray(last._toolBlocks) && Array.isArray(last._textParts)) {
+        last._textParts.push(text);
+        last.content = `${last._textParts.join("\n\n")}
+
+${last._toolBlocks.join("\n\n")}`.replace(
+          /^\n\n/,
+          ""
+        );
+      } else {
+        merged.push({
+          ...msg,
+          role: "user",
+          content: text,
+          _textParts: [text],
+          _toolBlocks: []
+        });
+      }
+    } else {
+      merged.push({ ...msg });
     }
-    if (m.tool_calls && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
-      total += countTokens(JSON.stringify(m.tool_calls));
+  }
+  for (const m of merged) {
+    m._textParts = void 0;
+    m._toolBlocks = void 0;
+  }
+  return merged;
+}
+function dropThinkingMessages(messages) {
+  let lastUserIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const role = messages[i].role;
+    if (role === "user" || role === "developer") {
+      lastUserIdx = i;
+      break;
     }
   }
-  return total;
+  if (lastUserIdx < 0) return messages;
+  const result = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (i < lastUserIdx && msg.role === "developer") continue;
+    if (i < lastUserIdx && msg.role === "assistant") {
+      result.push({ ...msg, reasoning_content: null });
+    } else {
+      result.push(msg);
+    }
+  }
+  return result;
 }
-function estimateRequestTokens(messages, toolSpecs) {
-  let total = estimateConversationTokens(messages);
+function formatDeepSeekPrompt(messages, drop_thinking = false) {
+  if (messages.length === 0) return ASSISTANT_SP + THINK_END;
+  let msgs = messages;
+  if (drop_thinking) {
+    msgs = dropThinkingMessages(msgs);
+  }
+  const merged = mergeToolMessages(msgs);
+  let prompt = BOS;
+  for (let i = 0; i < merged.length; i++) {
+    const msg = merged[i];
+    const role = msg.role ?? "user";
+    const nextRole = i + 1 < merged.length ? merged[i + 1].role ?? "user" : null;
+    if (role === "system") {
+      prompt += msg.content ?? "";
+    } else if (role === "user") {
+      prompt += USER_SP + (msg.content ?? "");
+      if (nextRole === "assistant" || nextRole === null) {
+        prompt += ASSISTANT_SP + THINK_END;
+      }
+    } else if (role === "assistant") {
+      if (msg.reasoning_content) {
+        prompt += THINK_START + msg.reasoning_content + THINK_END;
+      }
+      if (msg.content) prompt += msg.content;
+      const tcs = msg.tool_calls;
+      if (Array.isArray(tcs) && tcs.length > 0) {
+        prompt += renderToolCallsDsml(tcs);
+      }
+      prompt += EOS;
+    }
+  }
+  return prompt;
+}
+function estimateConversationTokens(messages, drop_thinking = false) {
+  if (messages.length === 0) return 0;
+  return countTokensBounded(formatDeepSeekPrompt(messages, drop_thinking));
+}
+function estimateRequestTokens(messages, toolSpecs, drop_thinking = false) {
+  let total = estimateConversationTokens(messages, drop_thinking);
   if (toolSpecs && toolSpecs.length > 0) {
-    total += countTokens(JSON.stringify(toolSpecs));
+    total += countTokensBounded(renderTools(toolSpecs));
   }
   return total;
 }
@@ -4446,12 +4821,12 @@ async function waitForReady(ready, timeoutMs, serverName, signal) {
   let timer;
   let onAbort;
   try {
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve13, reject) => {
       ready.then(
         () => {
           if (settled) return;
           settled = true;
-          resolve10();
+          resolve13();
         },
         (err) => {
           if (settled) return;
@@ -4600,6 +4975,40 @@ function blockToString(block) {
   return `[unknown block: ${JSON.stringify(block)}]`;
 }
 
+// src/loop/thinking.ts
+function isThinkingModeModel(model) {
+  if (model.includes("reasoner")) return true;
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
+  return false;
+}
+function thinkingModeForModel(model) {
+  if (model === "deepseek-chat") return "disabled";
+  if (model.includes("reasoner")) return "enabled";
+  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return "enabled";
+  return void 0;
+}
+function stripHallucinatedToolMarkup(s) {
+  let out = s;
+  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
+  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
+  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
+  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
+  return out.trim();
+}
+
+// src/loop/messages.ts
+function buildAssistantMessage(content, toolCalls, producingModel, reasoningContent) {
+  const msg = { role: "assistant", content };
+  if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+  if (isThinkingModeModel(producingModel) || reasoningContent && reasoningContent.length > 0) {
+    msg.reasoning_content = reasoningContent ?? "";
+  }
+  return msg;
+}
+function buildSyntheticAssistantMessage(content, fallbackModel) {
+  return buildAssistantMessage(content, [], fallbackModel, "");
+}
+
 // src/memory/session.ts
 import { execFileSync } from "child_process";
 import {
@@ -4769,11 +5178,11 @@ function countLines(path2) {
 
 // src/telemetry/stats.ts
 var DEEPSEEK_PRICING = {
-  "deepseek-v4-flash": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
-  "deepseek-v4-pro": { inputCacheHit: 0.139, inputCacheMiss: 1.667, output: 3.333 },
+  "deepseek-v4-flash": { inputCacheHit: 28e-4, inputCacheMiss: 0.14, output: 0.28 },
+  "deepseek-v4-pro": { inputCacheHit: 3625e-6, inputCacheMiss: 0.435, output: 0.87 },
   // Compat aliases — priced as v4-flash per the deprecation notice.
-  "deepseek-chat": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 },
-  "deepseek-reasoner": { inputCacheHit: 0.028, inputCacheMiss: 0.139, output: 0.278 }
+  "deepseek-chat": { inputCacheHit: 28e-4, inputCacheMiss: 0.14, output: 0.28 },
+  "deepseek-reasoner": { inputCacheHit: 28e-4, inputCacheMiss: 0.14, output: 0.28 }
 };
 var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
 var DEEPSEEK_CONTEXT_TOKENS = {
@@ -4835,6 +5244,14 @@ var SessionStats = class {
       this._carryoverLastPromptTokens = opts.lastPromptTokens;
     }
   }
+  reset() {
+    this.turns.length = 0;
+    this._carryoverCost = 0;
+    this._carryoverTurns = 0;
+    this._carryoverCacheHit = 0;
+    this._carryoverCacheMiss = 0;
+    this._carryoverLastPromptTokens = 0;
+  }
   record(turn, model, usage) {
     const cost = costUsd(model, usage);
     const stats = {
@@ -4901,6 +5318,8 @@ var HISTORY_FOLD_AGGRESSIVE_TAIL_FRACTION = 0.1;
 var HISTORY_FOLD_MIN_SAVINGS_FRACTION = 0.3;
 var FORCE_SUMMARY_THRESHOLD = 0.8;
 var PREFLIGHT_EMERGENCY_THRESHOLD = 0.95;
+var PREFLIGHT_MECHANICAL_TARGET_FRACTION = 0.7;
+var HISTORY_FOLD_SUMMARY_TIMEOUT_MS = 15e3;
 var HISTORY_FOLD_MARKER = "[CONVERSATION HISTORY SUMMARY \u2014 earlier turns folded for context efficiency]\n\n";
 var SKILL_PIN_MEMO_HEADER = "[Active skill memos \u2014 preserved verbatim across the fold:]";
 var SKILL_PIN_REGEX = /<skill-pin name="([^"]+)">\n[\s\S]*?\n<\/skill-pin>/g;
@@ -4955,7 +5374,7 @@ var ContextManager = class {
   /** Local-side preflight before sending a request — catches oversized payloads early. */
   decidePreflight(messages, toolSpecs, model) {
     const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
-    const estimate = estimateRequestTokens(messages, toolSpecs ?? null);
+    const estimate = estimateRequestTokens(messages, toolSpecs ?? null, true);
     return {
       needsAction: estimate / ctxMax > PREFLIGHT_EMERGENCY_THRESHOLD,
       estimateTokens: estimate,
@@ -4974,7 +5393,7 @@ var ContextManager = class {
       summaryChars: 0
     };
     if (all.length === 0) return noop;
-    const tokenCounts = all.map((m) => estimateConversationTokens([m]));
+    const tokenCounts = all.map((m) => countTokensBounded(m.content ?? ""));
     const totalTokens = tokenCounts.reduce((a, b) => a + b, 0);
     let cumTokens = 0;
     let boundary = all.length;
@@ -4990,16 +5409,18 @@ var ContextManager = class {
     if (headTokens < totalTokens * HISTORY_FOLD_MIN_SAVINGS_FRACTION) return noop;
     const { stubbedHead, pinnedBodies } = extractPinnedSkills(head);
     const summary = await this.summarizeForFold(stubbedHead);
-    if (!summary) return noop;
+    if (!summary.content) return noop;
     const memoTail = pinnedBodies.length > 0 ? `
 
 ${SKILL_PIN_MEMO_HEADER}
 
 ${pinnedBodies.join("\n\n")}` : "";
-    const summaryMsg = {
-      role: "assistant",
-      content: HISTORY_FOLD_MARKER + summary + memoTail
-    };
+    const summaryMsg = buildAssistantMessage(
+      HISTORY_FOLD_MARKER + summary.content + memoTail,
+      [],
+      model,
+      summary.reasoningContent
+    );
     const replacement = [summaryMsg, ...tail];
     this.deps.log.compactInPlace(replacement);
     this.persistRewrite(replacement);
@@ -5007,7 +5428,51 @@ ${pinnedBodies.join("\n\n")}` : "";
       folded: true,
       beforeMessages: all.length,
       afterMessages: replacement.length,
-      summaryChars: summary.length
+      summaryChars: summary.content.length
+    };
+  }
+  /** Pure local emergency compaction for preflight: drop oldest log entries and keep a valid tail. */
+  mechanicalTruncate(model, opts) {
+    const ctxMax = DEEPSEEK_CONTEXT_TOKENS[model] ?? DEFAULT_CONTEXT_TOKENS;
+    const targetTokens = opts?.targetTokens ?? Math.floor(ctxMax * PREFLIGHT_MECHANICAL_TARGET_FRACTION);
+    const all = this.deps.log.toMessages();
+    const noop = {
+      folded: false,
+      beforeMessages: all.length,
+      afterMessages: all.length,
+      summaryChars: 0
+    };
+    if (all.length === 0) return noop;
+    const tokenCounts = all.map((m) => estimateConversationTokens([m], true));
+    let latestUserBoundary = -1;
+    for (let i = all.length - 1; i >= 0; i--) {
+      if (all[i].role === "user") {
+        latestUserBoundary = i;
+        break;
+      }
+    }
+    let cumTokens = 0;
+    let boundary = all.length;
+    let foundSafeBoundary = false;
+    for (let i = all.length - 1; i >= 0; i--) {
+      const next = cumTokens + tokenCounts[i];
+      if (next > targetTokens) break;
+      cumTokens = next;
+      if (all[i].role === "user") {
+        boundary = i;
+        foundSafeBoundary = true;
+      }
+    }
+    if (boundary <= 0) return noop;
+    const replacement = foundSafeBoundary ? all.slice(boundary) : opts?.allowEmpty ? [] : latestUserBoundary >= 0 ? all.slice(latestUserBoundary) : all;
+    if (replacement.length === all.length) return noop;
+    this.deps.log.compactInPlace(replacement);
+    this.persistRewrite(replacement);
+    return {
+      folded: true,
+      beforeMessages: all.length,
+      afterMessages: replacement.length,
+      summaryChars: 0
     };
   }
   /** Drop a trailing in-flight assistant-with-tool_calls before a forced summary. Tail-only mutation; prefix cache safe. */
@@ -5033,18 +5498,51 @@ ${pinnedBodies.join("\n\n")}` : "";
         content: "Summarize the conversation above as plain prose. This summary replaces the original turns to free context \u2014 make it self-contained."
       }
     ];
+    const turnSignal = this.deps.getAbortSignal();
+    const foldCtrl = new AbortController();
+    let cleanupAbort = () => {
+    };
+    let timeout;
     try {
-      const resp = await this.deps.client.chat({
-        model: summaryModel,
-        messages,
-        signal: this.deps.getAbortSignal(),
-        thinking: thinkingModeForModel(summaryModel),
-        reasoningEffort: "high"
+      const abortPromise = new Promise((_, reject) => {
+        const abort = () => {
+          foldCtrl.abort();
+          reject(new Error("fold-aborted"));
+        };
+        if (turnSignal.aborted) {
+          abort();
+        } else {
+          turnSignal.addEventListener("abort", abort, { once: true });
+          cleanupAbort = () => turnSignal.removeEventListener("abort", abort);
+        }
+      });
+      const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+          foldCtrl.abort();
+          reject(new Error("fold-timeout"));
+        }, HISTORY_FOLD_SUMMARY_TIMEOUT_MS);
       });
+      const resp = await Promise.race([
+        this.deps.client.chat({
+          model: summaryModel,
+          messages,
+          signal: foldCtrl.signal,
+          thinking: thinkingModeForModel(summaryModel),
+          reasoningEffort: "high"
+        }),
+        abortPromise,
+        timeoutPromise
+      ]);
       this.deps.stats.record(this.deps.getCurrentTurn(), summaryModel, resp.usage ?? new Usage());
-      return stripHallucinatedToolMarkup((resp.content ?? "").trim());
+      return {
+        content: stripHallucinatedToolMarkup((resp.content ?? "").trim()),
+        reasoningContent: resp.reasoningContent ?? ""
+      };
     } catch {
-      return "";
+      return { content: "", reasoningContent: "" };
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      cleanupAbort();
     }
   }
   persistRewrite(messages) {
@@ -5136,17 +5634,15 @@ function formatDeepSeek5xx(status, probe) {
   const action = probe?.reachable === false ? t("errors.deepseek5xxActionNetwork") : t("errors.deepseek5xxActionRetry");
   return `${head}${probeNote}${action}`;
 }
-function reasonPrefixFor(reason, iterCap) {
+function reasonPrefixFor(reason) {
   if (reason === "aborted") return t("errors.reasonAborted");
   if (reason === "context-guard") return t("errors.reasonContextGuard");
-  if (reason === "stuck") return t("errors.reasonStuck");
-  return t("errors.reasonBudget", { iterCap });
+  return t("errors.reasonStuck");
 }
-function errorLabelFor(reason, iterCap) {
+function errorLabelFor(reason) {
   if (reason === "aborted") return t("errors.labelAborted");
   if (reason === "context-guard") return t("errors.labelContextGuard");
-  if (reason === "stuck") return t("errors.labelStuck");
-  return t("errors.labelBudget", { iterCap });
+  return t("errors.labelStuck");
 }
 function extractDeepSeekErrorMessage(body) {
   const trimmed = body.trim();
@@ -5188,50 +5684,14 @@ function looksLikePartialEscalationMarker(buf) {
   return true;
 }
 
-// src/loop/thinking.ts
-function isThinkingModeModel(model) {
-  if (model.includes("reasoner")) return true;
-  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return true;
-  return false;
-}
-function thinkingModeForModel(model) {
-  if (model === "deepseek-chat") return "disabled";
-  if (model.includes("reasoner")) return "enabled";
-  if (model === "deepseek-v4-flash" || model === "deepseek-v4-pro") return "enabled";
-  return void 0;
-}
-function stripHallucinatedToolMarkup(s) {
-  let out = s;
-  out = out.replace(/<｜DSML｜function_calls>[\s\S]*?<\/?｜DSML｜function_calls>/g, "");
-  out = out.replace(/<\|DSML\|function_calls>[\s\S]*?<\/?\|DSML\|function_calls>/g, "");
-  out = out.replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "");
-  out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
-  return out.trim();
-}
-
-// src/loop/messages.ts
-function buildAssistantMessage(content, toolCalls, producingModel, reasoningContent) {
-  const msg = { role: "assistant", content };
-  if (toolCalls.length > 0) msg.tool_calls = toolCalls;
-  if (isThinkingModeModel(producingModel) || reasoningContent && reasoningContent.length > 0) {
-    msg.reasoning_content = reasoningContent ?? "";
-  }
-  return msg;
-}
-function buildSyntheticAssistantMessage(content, fallbackModel) {
-  return buildAssistantMessage(content, [], fallbackModel, "");
-}
-
 // src/loop/force-summary.ts
-var PAUSE_SUMMARY_MODEL = "deepseek-v4-flash";
-var PAUSE_SUMMARY_EFFORT = "high";
-async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
+async function* forceSummaryAfterIterLimit(ctx, opts) {
   try {
     yield { turn: ctx.turn, role: "status", content: t("summary.status") };
     const messages = ctx.buildMessages();
     messages.push({
       role: "user",
-      content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
+      content: "The turn is being force-summarized (context guard or stuck-state). Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
     });
     const summaryModel = "deepseek-v4-flash";
     const summaryEffort = "high";
@@ -5245,7 +5705,7 @@ async function* forceSummaryAfterIterLimit(ctx, opts = { reason: "budget" }) {
     const rawContent = resp.content?.trim() ?? "";
     const cleaned = stripHallucinatedToolMarkup(rawContent);
     const summary = cleaned || t("summary.hallucinatedFallback");
-    const reasonPrefix = reasonPrefixFor(opts.reason, ctx.maxToolIters);
+    const reasonPrefix = reasonPrefixFor(opts.reason);
     const annotated = `${reasonPrefix}
 
 ${summary}`;
@@ -5260,7 +5720,7 @@ ${summary}`;
     };
     yield { turn: ctx.turn, role: "done", content: summary };
   } catch (err) {
-    const label = errorLabelFor(opts.reason, ctx.maxToolIters);
+    const label = errorLabelFor(opts.reason);
     yield {
       turn: ctx.turn,
       role: "error",
@@ -5270,28 +5730,6 @@ ${summary}`;
     yield { turn: ctx.turn, role: "done", content: "" };
   }
 }
-async function summarizePartialProgress(ctx) {
-  try {
-    const messages = ctx.buildMessages();
-    messages.push({
-      role: "user",
-      content: "You're being paused at a checkpoint, not stopped. In 3-6 sentences of plain prose, tell the parent agent: (1) what you accomplished so far, (2) what's still left, (3) any blockers or open questions. Be concrete \u2014 mention specific files / functions / tool results \u2014 so the parent can decide whether to resume you or take over. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
-    });
-    const resp = await ctx.client.chat({
-      model: PAUSE_SUMMARY_MODEL,
-      messages,
-      signal: ctx.signal,
-      thinking: thinkingModeForModel(PAUSE_SUMMARY_MODEL),
-      reasoningEffort: PAUSE_SUMMARY_EFFORT
-    });
-    const cleaned = stripHallucinatedToolMarkup(resp.content?.trim() ?? "");
-    if (!cleaned) return null;
-    const stats = ctx.recordStats(PAUSE_SUMMARY_MODEL, resp.usage ?? new Usage());
-    return { summary: cleaned, stats };
-  } catch {
-    return null;
-  }
-}
 
 // src/loop/shrink.ts
 function looksLikeCompleteJson(s) {
@@ -5324,7 +5762,7 @@ function shrinkOversizedToolResultsByTokens(messages, maxTokens) {
     if (msg.role !== "tool") return msg;
     const content = typeof msg.content === "string" ? msg.content : "";
     if (content.length <= maxTokens) return msg;
-    const beforeTokens = countTokens(content);
+    const beforeTokens = countTokensBounded(content);
     if (beforeTokens <= maxTokens) return msg;
     const truncated = truncateForModelByTokens(content, maxTokens);
     const afterTokens = countTokens(truncated);
@@ -5758,11 +6196,16 @@ var StormBreaker = class {
 function repairTruncatedJson(input) {
   const notes = [];
   if (!input || !input.trim()) {
-    return { repaired: "{}", changed: input !== "{}", notes: ["empty input \u2192 {}"] };
+    return {
+      repaired: "{}",
+      changed: input !== "{}",
+      notes: ["empty input \u2192 {}"],
+      fallback: false
+    };
   }
   try {
     JSON.parse(input);
-    return { repaired: input, changed: false, notes: [] };
+    return { repaired: input, changed: false, notes: [], fallback: false };
   } catch {
   }
   const stack = [];
@@ -5817,10 +6260,12 @@ function repairTruncatedJson(input) {
   }
   try {
     JSON.parse(s);
-    return { repaired: s, changed: true, notes };
+    return { repaired: s, changed: s !== input, notes, fallback: false };
   } catch (err) {
+    const preview = input.length <= 500 ? input : `${input.slice(0, 500)} \u2026[+${input.length - 500} chars]`;
     notes.push(`fallback to {}: ${err.message}`);
-    return { repaired: "{}", changed: true, notes };
+    notes.push(`unrecoverable truncation \u2014 original args preview: ${preview}`);
+    return { repaired: "{}", changed: true, notes, fallback: true };
   }
 }
 
@@ -5867,9 +6312,16 @@ var ToolCallRepair = class {
       const args = call.function?.arguments ?? "";
       const r = repairTruncatedJson(args);
       if (r.changed) {
-        call.function.arguments = r.repaired;
-        report.truncationsFixed++;
-        report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
+        if (r.fallback) {
+          report.truncationsFixed++;
+          report.notes.push(
+            ...r.notes.map((n) => `[${call.function?.name}] \u26A0\uFE0F TRUNCATION UNRECOVERABLE: ${n}`)
+          );
+        } else {
+          call.function.arguments = r.repaired;
+          report.truncationsFixed++;
+          report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
+        }
       }
     }
     const filtered = [];
@@ -5891,12 +6343,10 @@ function signature(call) {
 
 // src/loop.ts
 var ESCALATION_MODEL = "deepseek-v4-pro";
-var PARENT_BUDGET_WARN_THRESHOLD = 5;
 var CacheFirstLoop = class {
   client;
   prefix;
   tools;
-  maxToolIters;
   log = new AppendOnlyLog();
   scratch = new VolatileScratch();
   stats = new SessionStats();
@@ -5911,7 +6361,6 @@ var CacheFirstLoop = class {
   /** One-shot 80% warning latch — cleared by setBudget so a bump re-arms at the new boundary. */
   _budgetWarned = false;
   sessionName;
-  onIterBudgetExhausted;
   hooks;
   hookCwd;
   /** PauseGate bridge — defaults to singleton, injectable for tests. */
@@ -5925,12 +6374,25 @@ var CacheFirstLoop = class {
   _turnAbort = new AbortController();
   /** Authoritative running-id set — UI cards consult this instead of trusting end-event delivery. Insert at dispatch entry, delete in finally. */
   _inflight = new InflightSet();
+  /** Typeahead steer message set by the UI; step() consumes it at the next iter boundary. */
+  _steer = null;
+  /** Set true when a steer was consumed this turn; cleared on next step() entry. */
+  _steerConsumed = false;
+  /** UI calls this to inject a mid-turn steer message without aborting the current turn.
+   *  New text resets steerConsumed — a fresh steer hasn't been consumed yet. */
+  steer(text) {
+    this._steer = text;
+    if (text !== null) this._steerConsumed = false;
+  }
+  /** True when a steer was consumed this turn (UI gate to avoid double-submit). */
+  get steerConsumed() {
+    return this._steerConsumed;
+  }
   _proArmedForNextTurn = false;
   _escalateThisTurn = false;
   _turnFailures;
   _turnSelfCorrected = false;
   _foldedThisTurn = false;
-  _toolDispatchesThisStep = 0;
   context;
   /** Subscribe API so UI hooks can derive `running` from finally-guaranteed insertions. */
   get inflight() {
@@ -5950,8 +6412,6 @@ var CacheFirstLoop = class {
     this._turnFailures = new TurnFailureTracker(
       resolveFailureThreshold(opts.failureThreshold, FAILURE_ESCALATION_THRESHOLD)
     );
-    this.maxToolIters = opts.maxToolIters ?? 64;
-    this.onIterBudgetExhausted = opts.onIterBudgetExhausted ?? "summarize";
     this.hooks = opts.hooks ?? [];
     this.hookCwd = opts.hookCwd ?? process.cwd();
     this.confirmationGate = opts.confirmationGate ?? pauseGate;
@@ -5972,23 +6432,6 @@ var CacheFirstLoop = class {
       stormThreshold: parsePositiveIntEnv(process.env.REASONIX_STORM_THRESHOLD),
       stormWindow: parsePositiveIntEnv(process.env.REASONIX_STORM_WINDOW)
     });
-    if (!this.tools.hasResultAugmenter) {
-      this.tools.setResultAugmenter((_name, _args, result) => {
-        this._toolDispatchesThisStep++;
-        const remaining = this.maxToolIters - this._toolDispatchesThisStep;
-        if (remaining <= 0) {
-          return `${result}
-
-[budget: 0 of ${this.maxToolIters} tool calls left this turn \u2014 finalize NOW; the next iter forces a summary]`;
-        }
-        if (remaining <= PARENT_BUDGET_WARN_THRESHOLD) {
-          return `${result}
-
-[budget: ${remaining} of ${this.maxToolIters} tool calls left this turn \u2014 wrap up soon]`;
-        }
-        return result;
-      });
-    }
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
@@ -6074,6 +6517,10 @@ var CacheFirstLoop = class {
     }
     this.scratch.reset();
     this._inflight.clear();
+    this.stats.reset();
+    this._turn = 0;
+    this._turnFailures.reset();
+    this._budgetWarned = false;
     let systemRebuilt = false;
     if (this._rebuildSystem) {
       try {
@@ -6083,6 +6530,29 @@ var CacheFirstLoop = class {
     }
     return { dropped, archived, systemRebuilt };
   }
+  /** `/cwd` follow-through — archives the previous session, drops in-memory state, repoints sessionName, and rebuilds the system prompt against whatever the rebuilder closure now resolves (the caller is expected to have already updated the root the closure reads). */
+  switchWorkspace(opts) {
+    const dropped = this.log.length;
+    let archived = null;
+    if (this.sessionName) {
+      try {
+        archived = archiveSession(this.sessionName);
+        if (archived === null) rewriteSession(this.sessionName, []);
+      } catch {
+      }
+    }
+    this.log.compactInPlace([]);
+    this.scratch.reset();
+    this._inflight.clear();
+    this.sessionName = opts.sessionName;
+    if (this._rebuildSystem) {
+      try {
+        this.prefix.replaceSystem(this._rebuildSystem());
+      } catch {
+      }
+    }
+    return { dropped, archived };
+  }
   configure(opts) {
     if (opts.model !== void 0) this.model = opts.model;
     if (opts.stream !== void 0) {
@@ -6238,6 +6708,7 @@ ${reason}`
     return userText;
   }
   async *step(userInput) {
+    this._steerConsumed = false;
     if (this.budgetUsd !== null) {
       const spent = this.stats.totalCost;
       if (spent >= this.budgetUsd) {
@@ -6271,7 +6742,6 @@ ${reason}`
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
-    this._toolDispatchesThisStep = 0;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
       this._escalateThisTurn = true;
@@ -6289,16 +6759,15 @@ ${reason}`
         content: t("loop.proArmed")
       };
     }
-    let pendingUser = userInput;
+    this.appendAndPersist({ role: "user", content: userInput });
+    let pendingUser = null;
     const toolSpecs = this.prefix.tools();
-    const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
-    let warnedForIterBudget = false;
-    for (let iter = 0; iter < this.maxToolIters; iter++) {
+    for (let iter = 0; ; iter++) {
       if (signal.aborted) {
         yield {
           turn: this._turn,
           role: "warning",
-          content: t("loop.abortedAtIter", { iter, cap: this.maxToolIters })
+          content: t("loop.abortedAtIter", { iter })
         };
         const stoppedMsg = "[aborted by user (Esc) \u2014 no summary produced. Ask again or /retry when ready; prior tool output is still in the log.]";
         this.appendAndPersist(buildSyntheticAssistantMessage(stoppedMsg, this.model));
@@ -6319,15 +6788,20 @@ ${reason}`
           content: t("loop.toolUploadStatus")
         };
       }
-      if (!warnedForIterBudget && iter >= warnAt) {
-        warnedForIterBudget = true;
+      let messages = this.buildMessages(pendingUser);
+      if (this._steer !== null) {
+        const steer = this._steer;
+        this._steer = null;
+        this._steerConsumed = true;
+        this.appendAndPersist({ role: "user", content: steer });
+        messages = this.buildMessages(pendingUser);
+        pendingUser = null;
         yield {
           turn: this._turn,
-          role: "warning",
-          content: t("loop.toolBudgetWarning", { iter, cap: this.maxToolIters })
+          role: "steer",
+          content: steer
         };
       }
-      let messages = this.buildMessages(pendingUser);
       {
         const decision2 = this.context.decidePreflight(messages, this.prefix.toolSpecs, this.model);
         if (decision2.needsAction) {
@@ -6335,23 +6809,29 @@ ${reason}`
           yield {
             turn: this._turn,
             role: "status",
-            content: t("loop.preflightFoldStatus")
+            content: t("loop.preflightTruncateStatus")
           };
-          const result = await this.context.fold(this.model);
+          const result = this.context.mechanicalTruncate(this.model, {
+            allowEmpty: pendingUser !== null
+          });
           if (result.folded) {
+            messages = this.buildMessages(pendingUser);
+            const after = this.context.decidePreflight(messages, this.prefix.toolSpecs, this.model);
+            const stillFull = after.needsAction;
             yield {
-              turn: this._turn,
-              role: "warning",
-              content: t("loop.preflightFolded", {
-                estimate: estimate.toLocaleString(),
-                ctxMax: ctxMax.toLocaleString(),
-                pct: Math.round(estimate / ctxMax * 100),
-                beforeMessages: result.beforeMessages,
-                afterMessages: result.afterMessages,
-                summaryChars: result.summaryChars
-              })
+              turn: this._turn,
+              role: "warning",
+              content: t(
+                stillFull ? "loop.preflightTruncatedStillFull" : "loop.preflightTruncated",
+                {
+                  estimate: after.estimateTokens.toLocaleString(),
+                  ctxMax: after.ctxMax.toLocaleString(),
+                  pct: Math.round(after.estimateTokens / after.ctxMax * 100),
+                  beforeMessages: result.beforeMessages,
+                  afterMessages: result.afterMessages
+                }
+              )
             };
-            messages = this.buildMessages(pendingUser);
           } else {
             yield {
               turn: this._turn,
@@ -6508,10 +6988,6 @@ ${reason}`
         this.modelForCurrentCall(),
         usage ?? new Usage()
       );
-      if (pendingUser !== null) {
-        this.appendAndPersist({ role: "user", content: pendingUser });
-        pendingUser = null;
-      }
       this.scratch.reasoning = reasoningContent || null;
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
@@ -6705,20 +7181,6 @@ ${reason}`
         }
       }
     }
-    if (this.onIterBudgetExhausted === "pause") {
-      const partial = await summarizePartialProgress(this.summaryContext());
-      yield {
-        turn: this._turn,
-        role: "paused",
-        content: "",
-        sessionName: this.sessionName ?? void 0,
-        pausedAtIter: this.maxToolIters,
-        partialSummary: partial?.summary
-      };
-      yield { turn: this._turn, role: "done", content: "" };
-      return;
-    }
-    yield* forceSummaryAfterIterLimit(this.summaryContext(), { reason: "budget" });
   }
   summaryContext() {
     return {
@@ -6727,8 +7189,7 @@ ${reason}`
       buildMessages: () => this.buildMessages(null),
       appendAndPersist: (m) => this.appendAndPersist(m),
       recordStats: (model, usage) => this.stats.record(this._turn, model, usage),
-      turn: this._turn,
-      maxToolIters: this.maxToolIters
+      turn: this._turn
     };
   }
   async run(userInput, onEvent) {
@@ -6763,7 +7224,7 @@ function resolveFailureThreshold(raw, fallback) {
 // src/at-mentions.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { readdir, stat } from "fs/promises";
-import { isAbsolute, join as join5, relative, resolve } from "path";
+import { isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2 } from "path";
 
 // src/gitignore.ts
 import { readFileSync as readFileSync5 } from "fs";
@@ -6818,7 +7279,7 @@ function listFilesSync(root, opts = {}) {
 function listFilesWithStatsSync(root, opts = {}) {
   const maxResults = Math.max(1, opts.maxResults ?? 2e3);
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
-  const rootAbs = resolve(root);
+  const rootAbs = resolve2(root);
   const respectGi = opts.respectGitignore !== false;
   const out = [];
   const walk2 = (dirAbs, dirRel, layers) => {
@@ -6882,7 +7343,7 @@ async function listFilesWithStatsAsync(root, opts = {}) {
 async function walkFilesStream(root, opts) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve(root);
+  const rootAbs = resolve2(root);
   const progressGap = Math.max(0, opts.progressIntervalMs ?? 100);
   let scanned = 0;
   let halted = false;
@@ -6960,10 +7421,10 @@ async function flushFiles(ents, dirAbs, dirRel, layers, emit) {
 async function listDirectory(root, relDir, opts = {}) {
   const ignoreDirs = new Set(opts.ignoreDirs ?? DEFAULT_PICKER_IGNORE_DIRS);
   const respectGi = opts.respectGitignore !== false;
-  const rootAbs = resolve(root);
-  const dirAbs = resolve(rootAbs, relDir);
+  const rootAbs = resolve2(root);
+  const dirAbs = resolve2(rootAbs, relDir);
   const rel = relative(rootAbs, dirAbs);
-  if (rel.startsWith("..") || isAbsolute(rel)) return [];
+  if (rel.startsWith("..") || isAbsolute2(rel)) return [];
   const layers = [];
   if (respectGi) {
     const segs = rel ? rel.split(/[\\/]/) : [];
@@ -7126,7 +7587,7 @@ function expandAtMentions(text, rootDir, opts = {}) {
   const maxBytes = opts.maxBytes ?? DEFAULT_AT_MENTION_MAX_BYTES;
   const maxDirEntries = Math.max(1, opts.maxDirEntries ?? DEFAULT_AT_DIR_MAX_ENTRIES);
   const fs5 = opts.fs ?? defaultFs;
-  const root = resolve(rootDir);
+  const root = resolve2(rootDir);
   const seen = /* @__PURE__ */ new Map();
   const expansions = [];
   const dirListings = /* @__PURE__ */ new Map();
@@ -7170,12 +7631,12 @@ ${blocks.join("\n\n")}`;
   return { text: augmented, expansions };
 }
 function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs5, dirListings) {
-  if (isAbsolute(rawPath)) {
+  if (isAbsolute2(rawPath)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
-  const resolved = resolve(root, rawPath);
+  const resolved = resolve2(root, rawPath);
   const rel = relative(root, resolved);
-  if (rel.startsWith("..") || isAbsolute(rel)) {
+  if (rel.startsWith("..") || isAbsolute2(rel)) {
     return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "escape" };
   }
   if (!fs5.exists(resolved)) {
@@ -7203,7 +7664,7 @@ function resolveMention(rawPath, root, maxBytes, maxDirEntries, fs5, dirListings
   return { token: `@${rawPath}`, path: rawPath, ok: false, skip: "not-file" };
 }
 function readSafe(root, rawPath, fs5) {
-  const resolved = resolve(root, rawPath);
+  const resolved = resolve2(root, rawPath);
   try {
     return fs5.read(resolved);
   } catch {
@@ -7313,7 +7774,7 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join8, resolve as resolve3 } from "path";
+import { join as join8, resolve as resolve4 } from "path";
 
 // src/frontmatter.ts
 var KEY_RE = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/;
@@ -7363,9 +7824,18 @@ function parseFrontmatter(raw) {
 }
 
 // src/skills.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import {
+  constants,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync8,
+  readdirSync as readdirSync3,
+  statSync as statSync4,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { accessSync } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join7, resolve as resolve2 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join7, resolve as resolve3 } from "path";
 
 // src/prompt-fragments.ts
 var TUI_FORMATTING_RULES = `Formatting (rendered in a TUI with a real markdown renderer):
@@ -7410,26 +7880,25 @@ function parseAllowedTools(raw) {
   const names = raw.split(",").map((s) => s.trim()).filter(Boolean);
   return names.length > 0 ? Object.freeze(names) : void 0;
 }
-function parseMaxToolIters(raw) {
-  if (raw === void 0) return void 0;
-  const n = Number.parseInt(raw.trim(), 10);
-  if (!Number.isFinite(n) || n < 1) return void 0;
-  return n;
-}
 var SkillStore = class {
   homeDir;
   projectRoot;
+  customSkillPaths;
   disableBuiltins;
   constructor(opts = {}) {
     this.homeDir = opts.homeDir ?? homedir4();
-    this.projectRoot = opts.projectRoot ? resolve2(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? resolve3(opts.projectRoot) : void 0;
+    const baseDir = this.projectRoot ?? process.cwd();
+    this.customSkillPaths = dedupePaths(
+      opts.customSkillPaths?.map((p) => resolveCustomSkillPath(p, baseDir, this.homeDir)) ?? []
+    );
     this.disableBuiltins = opts.disableBuiltins === true;
   }
   /** True iff this store was configured with a project root. */
   hasProjectScope() {
     return this.projectRoot !== void 0;
   }
-  /** Project scope first so per-repo skill overrides a global with the same name. */
+  /** Project scope first so per-repo skill overrides custom/global entries with the same name. */
   roots() {
     const out = [];
     if (this.projectRoot) {
@@ -7437,15 +7906,24 @@ var SkillStore = class {
         dir: join7(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
         scope: "project"
       });
+      out.push({
+        dir: join7(this.projectRoot, ".agents", SKILLS_DIRNAME),
+        scope: "project"
+      });
     }
+    for (const dir of this.customSkillPaths) out.push({ dir, scope: "custom" });
     out.push({ dir: join7(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
-    return out;
+    out.push({ dir: join7(this.homeDir, ".agents", SKILLS_DIRNAME), scope: "global" });
+    return out.map((root, priority) => ({ ...root, priority, status: skillPathStatus(root.dir) }));
+  }
+  customRoots() {
+    return this.roots().filter((root) => root.scope === "custom");
   }
-  /** Higher-priority root wins on collision (project > global > builtin); sorted for stable prefix hash. */
+  /** Higher-priority root wins on collision (project > custom > global > builtin); sorted for stable prefix hash. */
   list() {
     const byName = /* @__PURE__ */ new Map();
-    for (const { dir, scope } of this.roots()) {
-      if (!existsSync6(dir)) continue;
+    for (const { dir, scope, status } of this.roots()) {
+      if (status !== "ok") continue;
       let entries;
       try {
         entries = readdirSync3(dir, { withFileTypes: true });
@@ -7497,8 +7975,8 @@ var SkillStore = class {
   /** Resolve one skill by name. Returns `null` if not found or malformed. */
   read(name) {
     if (!isValidSkillName(name)) return null;
-    for (const { dir, scope } of this.roots()) {
-      if (!existsSync6(dir)) continue;
+    for (const { dir, scope, status } of this.roots()) {
+      if (status !== "ok") continue;
       const dirCandidate = join7(dir, name, SKILL_FILE);
       if (existsSync6(dirCandidate) && statSync4(dirCandidate).isFile()) {
         return this.parse(dirCandidate, name, scope);
@@ -7546,11 +8024,38 @@ var SkillStore = class {
       path: path2,
       allowedTools: parseAllowedTools(data["allowed-tools"]),
       runAs: parseRunAs(data.runAs),
-      model: data.model?.startsWith("deepseek-") ? data.model : void 0,
-      maxToolIters: parseMaxToolIters(data["max-iters"])
+      model: data.model?.startsWith("deepseek-") ? data.model : void 0
     };
   }
 };
+function dedupePaths(paths) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const path2 of paths) {
+    const key = process.platform === "win32" ? path2.toLowerCase() : path2;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(path2);
+  }
+  return out;
+}
+function resolveCustomSkillPath(path2, baseDir, homeDir) {
+  const trimmed = path2.trim();
+  const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? join7(homeDir, trimmed.slice(2)) : trimmed;
+  return resolve3(isAbsolute3(expanded) ? expanded : join7(baseDir, expanded));
+}
+function skillPathStatus(dir) {
+  try {
+    const stat2 = statSync4(dir);
+    if (!stat2.isDirectory()) return "not-directory";
+    accessSync(dir, constants.R_OK);
+    return "ok";
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return "missing";
+    return "unreadable";
+  }
+}
 function parseRunAs(raw) {
   return raw?.trim() === "subagent" ? "subagent" : "inline";
 }
@@ -7568,7 +8073,6 @@ Tips:
 - Reference tools by name (run_command, edit_file, search_content, ...)
 - Add \`runAs: subagent\` to frontmatter to spawn an isolated subagent loop
 - Add \`allowed-tools: read_file, search_content\` to scope a subagent's tools
-- Add \`max-iters: N\` to change the subagent's pause cadence (default 16). This isn't a budget \u2014 the parent resumes on pause, so N is how often the parent gets a checkpoint, not how much total work the subagent gets.
 `;
 }
 function skillIndexLine(s) {
@@ -7803,7 +8307,7 @@ function sanitizeMemoryName(raw) {
   return trimmed;
 }
 function projectHash(rootDir) {
-  const abs = resolve3(rootDir);
+  const abs = resolve4(rootDir);
   return createHash2("sha1").update(abs).digest("hex").slice(0, 16);
 }
 function scopeDir(opts) {
@@ -7853,7 +8357,7 @@ var MemoryStore = class {
   projectRoot;
   constructor(opts = {}) {
     this.homeDir = opts.homeDir ?? join8(homedir5(), ".reasonix");
-    this.projectRoot = opts.projectRoot ? resolve3(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? resolve4(opts.projectRoot) : void 0;
   }
   /** Directory this store writes `scope` files into, creating it if needed. */
   dir(scope) {
@@ -8094,11 +8598,17 @@ function applyUserMemory(basePrompt, opts = {}) {
   }
   return parts.join("\n");
 }
-function applyMemoryStack(basePrompt, rootDir) {
+function applyMemoryStack(basePrompt, rootDir, opts = {}) {
+  const homeDir = opts.homeDir;
+  const cfg = opts.cfg;
   const withProject = applyProjectMemory(basePrompt, rootDir);
-  const withGlobal = applyGlobalReasonixMemory(withProject);
-  const withMemory = applyUserMemory(withGlobal, { projectRoot: rootDir });
-  return applySkillsIndex(withMemory, { projectRoot: rootDir });
+  const withGlobal = applyGlobalReasonixMemory(
+    withProject,
+    homeDir ? join8(homeDir, ".reasonix") : void 0
+  );
+  const withMemory = applyUserMemory(withGlobal, { projectRoot: rootDir, homeDir, cfg });
+  const customSkillPaths = cfg?.skills?.paths ? resolveSkillPaths(cfg.skills.paths, rootDir) : loadResolvedSkillPaths(rootDir);
+  return applySkillsIndex(withMemory, { projectRoot: rootDir, homeDir, customSkillPaths });
 }
 
 // src/tools/filesystem.ts
@@ -8106,6 +8616,51 @@ import { promises as fs4 } from "fs";
 import * as pathMod5 from "path";
 import picomatch3 from "picomatch";
 
+// src/memory/subdir.ts
+import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, join as join9, relative as relative2, resolve as resolve5 } from "path";
+function findSubdirMemoryAncestors(absPath, rootDir) {
+  const root = resolve5(rootDir);
+  const target = resolve5(absPath);
+  const rel = relative2(root, target);
+  if (!rel || rel.startsWith("..")) return [];
+  const found = [];
+  let cur = dirname5(target);
+  while (cur !== root) {
+    const r = relative2(root, cur);
+    if (!r || r.startsWith("..")) break;
+    for (const name of PROJECT_MEMORY_FILES) {
+      const path2 = join9(cur, name);
+      if (existsSync8(path2)) {
+        found.push(path2);
+        break;
+      }
+    }
+    const parent = dirname5(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return found;
+}
+function readSubdirMemoryContent(path2) {
+  let raw;
+  try {
+    raw = readFileSync10(path2, "utf8");
+  } catch {
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.length <= PROJECT_MEMORY_MAX_CHARS) return trimmed;
+  return `${trimmed.slice(0, PROJECT_MEMORY_MAX_CHARS)}
+\u2026 (truncated ${trimmed.length - PROJECT_MEMORY_MAX_CHARS} chars)`;
+}
+function formatSubdirMemorySection(displayPath, content) {
+  return `[module memory: ${displayPath}]
+
+${content}`;
+}
+
 // src/tools/fs/edit.ts
 import { promises as fs } from "fs";
 import * as pathMod from "path";
@@ -8336,6 +8891,18 @@ var RUST_DECL_RE = /^(?:pub(?:\([^)]+\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(fn|str
 var RUST_IMPL_RE = /^(?:unsafe\s+)?impl(?:\s*<[^>]+>)?\s+(?:[^{]+\s+for\s+)?(\w+)/;
 var MD_HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
 var MD_FENCE_RE = /^```/;
+var PROTO_TOP_RE = /^(message|service|enum|extend)\s+(\w+)/;
+var PROTO_RPC_RE = /^\s+rpc\s+(\w+)/;
+var CN_NUM = "[\\d\u96F6\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341\u767E\u5343\u4E07\uFF10-\uFF19]+";
+var TXT_CHAPTER_PATTERNS = [
+  new RegExp(`^\u7B2C${CN_NUM}[\u7AE0\u8282\u56DE].{0,80}$`),
+  new RegExp(`^\u5377${CN_NUM}.{0,80}$`),
+  /^(?:序章|楔子|番外篇?|前言|后记|尾声|引子)(?:[\s\u3000：:、—\-.].{0,80})?$/,
+  /^Chapter\s+(?:\d+|[IVXLCDMivxlcdm]+|[A-Za-z]+)\b.{0,80}$/,
+  /^CHAPTER\s+.{1,80}$/,
+  /^Part\s+(?:\d+|[IVXLCDMivxlcdm]+)\b.{0,80}$/,
+  /^PART\s+.{1,80}$/
+];
 var EXT_TO_LANG = {
   ".ts": "ts",
   ".tsx": "ts",
@@ -8351,7 +8918,10 @@ var EXT_TO_LANG = {
   ".rs": "rust",
   ".md": "md",
   ".markdown": "md",
-  ".mdx": "md"
+  ".mdx": "md",
+  ".proto": "proto",
+  ".txt": "txt",
+  ".text": "txt"
 };
 function extractOutline(filename, lines) {
   const ext = pathMod3.extname(filename).toLowerCase();
@@ -8368,6 +8938,10 @@ function extractOutline(filename, lines) {
       return extractRust(lines);
     case "md":
       return extractMarkdown(lines);
+    case "proto":
+      return extractProto(lines);
+    case "txt":
+      return extractText(lines);
   }
 }
 function extractTs(lines) {
@@ -8419,6 +8993,36 @@ function extractRust(lines) {
   }
   return out;
 }
+function extractProto(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.startsWith(" ") && !line.startsWith("	")) {
+      const m = PROTO_TOP_RE.exec(line);
+      if (m) {
+        out.push({ line: i + 1, text: `${m[1]} ${m[2]}` });
+        continue;
+      }
+    }
+    const rpc = PROTO_RPC_RE.exec(line);
+    if (rpc) out.push({ line: i + 1, text: `rpc ${rpc[1]}` });
+  }
+  return out;
+}
+function extractText(lines) {
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.length > 100) continue;
+    for (const re of TXT_CHAPTER_PATTERNS) {
+      if (re.test(line)) {
+        out.push({ line: i + 1, text: line });
+        break;
+      }
+    }
+  }
+  return out;
+}
 function extractMarkdown(lines) {
   const out = [];
   let inFence = false;
@@ -8643,8 +9247,8 @@ async function searchContent(ctx, startAbs, args) {
           for (let i = realStart; i <= winEnd; i++) {
             const line = lines[i];
             const display = line.length > 200 ? `${line.slice(0, 200)}\u2026` : line;
-            const sep2 = hitSet.has(i) ? ":" : "-";
-            if (!pushLine(`${rel}:${i + 1}${sep2} ${display}`)) return;
+            const sep3 = hitSet.has(i) ? ":" : "-";
+            if (!pushLine(`${rel}:${i + 1}${sep3} ${display}`)) return;
           }
           prevWindowEnd = winEnd;
         }
@@ -8666,17 +9270,25 @@ async function searchContent(ctx, startAbs, args) {
 }
 
 // src/tools/filesystem.ts
-var DEFAULT_MAX_READ_BYTES = 2 * 1024 * 1024;
+var DEFAULT_OUTLINE_THRESHOLD_BYTES = 512 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
-var DEFAULT_AUTO_PREVIEW_LINES = 200;
-var AUTO_PREVIEW_HEAD_LINES = 80;
-var AUTO_PREVIEW_TAIL_LINES = 40;
-var OUTLINE_MAX_ENTRIES2 = 30;
+var HARD_MAX_FILE_BYTES = 32 * 1024 * 1024;
+var OUTLINE_HEAD_LINES = 80;
 var SKIP_DIR_NAMES = new Set(DEFAULT_INDEX_EXCLUDES.dirs);
 var BINARY_EXTENSIONS = new Set(DEFAULT_INDEX_EXCLUDES.exts);
 function displayRel4(rootDir, full) {
   return pathMod5.relative(rootDir, full).replaceAll("\\", "/");
 }
+function looksLikeAbsoluteSystemPath(raw) {
+  if (/^[A-Za-z]:[\\/]/.test(raw)) return true;
+  return /^\/(?:home|Users|etc|var|opt|tmp|usr|mnt|Library|Volumes|proc|sys|dev|run|srv|media|Applications|System|root|boot|private)(?:[/\\]|$)/.test(
+    raw
+  );
+}
+function pathIsUnder(child, parent) {
+  const rel = pathMod5.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !pathMod5.isAbsolute(rel);
+}
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
   if (!filter) return null;
@@ -8693,24 +9305,45 @@ function isLikelyBinaryByName(name) {
   if (dot < 0) return false;
   return BINARY_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
+function looksBinary(buf) {
+  const end = Math.min(buf.length, 8192);
+  for (let i = 0; i < end; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MiB`;
+  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GiB`;
+}
 function registerFilesystemTools(registry, opts) {
   const rootDir = pathMod5.resolve(opts.rootDir);
   const allowWriting = opts.allowWriting !== false;
-  const maxReadBytes = opts.maxReadBytes ?? DEFAULT_MAX_READ_BYTES;
+  const outlineThresholdBytes = opts.outlineThresholdBytes ?? DEFAULT_OUTLINE_THRESHOLD_BYTES;
   const maxListBytes = opts.maxListBytes ?? DEFAULT_MAX_LIST_BYTES;
   const normRoot = pathMod5.resolve(rootDir);
   const sessionApproved = /* @__PURE__ */ new Set();
-  const inflightGate = /* @__PURE__ */ new Map();
-  function pathIsUnder(child, parent) {
-    const rel = pathMod5.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !pathMod5.isAbsolute(rel);
-  }
-  function looksLikeAbsoluteSystemPath(raw) {
-    if (/^[A-Za-z]:[\\/]/.test(raw)) return true;
-    return /^\/(?:home|Users|etc|var|opt|tmp|usr|mnt|Library|Volumes|proc|sys|dev|run|srv|media|Applications|System|root|boot|private)(?:[/\\]|$)/.test(
-      raw
-    );
+  const shownSubdirMemory = /* @__PURE__ */ new Set();
+  function withSubdirMemory(absPath, body) {
+    if (!memoryEnabled()) return body;
+    const ancestors = findSubdirMemoryAncestors(absPath, rootDir);
+    if (ancestors.length === 0) return body;
+    const sections = [];
+    for (const memPath of [...ancestors].reverse()) {
+      if (shownSubdirMemory.has(memPath)) continue;
+      const content = readSubdirMemoryContent(memPath);
+      if (!content) continue;
+      shownSubdirMemory.add(memPath);
+      sections.push(formatSubdirMemorySection(displayRel4(rootDir, memPath), content));
+    }
+    if (sections.length === 0) return body;
+    return `${sections.join("\n\n")}
+
+${body}`;
   }
+  const inflightGate = /* @__PURE__ */ new Map();
   async function ensureOutsideSandboxAllowed(abs, intent, toolName, ctx) {
     for (const dir of loadProjectPathAllowed(rootDir)) {
       if (pathIsUnder(abs, dir)) return;
@@ -8775,11 +9408,11 @@ function registerFilesystemTools(registry, opts) {
   registry.register({
     name: "read_file",
     parallelSafe: true,
-    description: `Read a file under the sandbox root. To save context, PREFER to scope the read instead of pulling the whole file:
-  - head: N  \u2192 first N lines (imports, public API, small configs)
-  - tail: N  \u2192 last N lines (recently-added code, log tails)
-  - range: "A-B"  \u2192 inclusive line range A..B, 1-indexed (e.g. "120-180" around an edit site)
-When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_LINES} lines, the tool auto-returns a head+tail preview with an "N lines omitted" marker, plus a top-level symbol outline (TS/JS exports, Python def/class, Go func/type, Rust fn/struct/impl/trait, Markdown headings, with line numbers, capped at ${OUTLINE_MAX_ENTRIES2}) so you can pick a smart range without a follow-up grep. If you need the middle, re-call with a range. Prefer search_content to locate a symbol first only when the outline doesn't have what you want \u2014 one scoped read beats three full-file reads.`,
+    description: `Read a file under the sandbox root. Default behaviour returns FULL CONTENT for files at or under ${Math.round(DEFAULT_OUTLINE_THRESHOLD_BYTES / 1024)} KiB \u2014 trust the prompt cache, don't pre-truncate. Optional scoping:
+  - head: N  \u2192 first N lines (cheap probe of imports / config head)
+  - tail: N  \u2192 last N lines (recent-tail of a log)
+  - range: "A-B"  \u2192 inclusive 1-indexed range (e.g. "120-180" around an edit site)
+Files OVER the threshold auto-switch to outline mode: file metadata + first ${OUTLINE_HEAD_LINES} lines + a top-level symbol outline (TS/JS exports, Python def/class, Go func/type, Rust fn/struct/impl/trait, Markdown headings, Protobuf message/service/rpc, plain-text chapter markers) + concrete next-step commands. No middle bytes \u2014 drill in with range / search_content. Files over ${Math.round(HARD_MAX_FILE_BYTES / (1024 * 1024))} MiB are refused entirely (use grep / range). Binary files are refused \u2014 use get_file_info if you only need stat.`,
     readOnly: true,
     stormExempt: true,
     parameters: {
@@ -8797,22 +9430,31 @@ When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_L
     },
     fn: async (args, ctx) => {
       const abs = await safePath(args.path, "read_file", ctx);
+      const rel = displayRel4(rootDir, abs);
       const fh = await fs4.open(abs, "r");
       let raw;
+      let sizeBytes;
       try {
         const stat2 = await fh.stat();
         if (stat2.isDirectory()) {
           throw new Error(`not a file: ${args.path} (it's a directory)`);
         }
+        sizeBytes = stat2.size;
+        if (sizeBytes > HARD_MAX_FILE_BYTES) {
+          return [
+            `[refused: ${rel} is ${formatBytes(sizeBytes)} (> ${formatBytes(HARD_MAX_FILE_BYTES)} hard ceiling) \u2014 too large to load]`,
+            "Use one of:",
+            `  - search_content path:"${rel}" pattern:"<your regex>"  \u2014 grep within the file`,
+            `  - read_file path:"${rel}" range:"A-B"                   \u2014 read a specific 1-indexed line range`,
+            `  - read_file path:"${rel}" head:N  /  tail:N             \u2014 read N lines at the start or end`
+          ].join("\n");
+        }
         raw = await fh.readFile();
       } finally {
         await fh.close();
       }
-      if (raw.length > maxReadBytes) {
-        const headBytes = raw.slice(0, maxReadBytes).toString("utf8");
-        return `${headBytes}
-
-[\u2026truncated ${raw.length - maxReadBytes} bytes \u2014 file is ${raw.length} B, cap ${maxReadBytes} B. Retry with head/tail/range for targeted view.]`;
+      if (looksBinary(raw)) {
+        return `[refused: ${rel} appears to be binary (${formatBytes(sizeBytes)}) \u2014 read_file returns text only. Use get_file_info for stat.]`;
       }
       const text = raw.toString("utf8");
       let lines = text.split(/\r?\n/);
@@ -8824,8 +9466,8 @@ When none of these is given AND the file is longer than ${DEFAULT_AUTO_PREVIEW_L
         const end = Math.min(totalLines, Math.max(start, rawEnd ?? totalLines));
         const slice = lines.slice(start - 1, end);
         const label = `[range ${start}-${end} of ${totalLines} lines]`;
-        return `${label}
-${slice.join("\n")}`;
+        return withSubdirMemory(abs, `${label}
+${slice.join("\n")}`);
       }
       if (typeof args.head === "number" && args.head > 0) {
         const count = Math.min(args.head, totalLines);
@@ -8833,7 +9475,7 @@ ${slice.join("\n")}`;
         const marker = count < totalLines ? `
 
 [\u2026head ${count} of ${totalLines} lines \u2014 call again with range / tail for more]` : "";
-        return slice.join("\n") + marker;
+        return withSubdirMemory(abs, slice.join("\n") + marker);
       }
       if (typeof args.tail === "number" && args.tail > 0) {
         const count = Math.min(args.tail, totalLines);
@@ -8841,25 +9483,26 @@ ${slice.join("\n")}`;
         const marker = count < totalLines ? `[\u2026tail ${count} of ${totalLines} lines \u2014 call again with range / head for more]
 
 ` : "";
-        return marker + slice.join("\n");
+        return withSubdirMemory(abs, marker + slice.join("\n"));
       }
-      if (totalLines <= DEFAULT_AUTO_PREVIEW_LINES) return lines.join("\n");
-      const head = lines.slice(0, AUTO_PREVIEW_HEAD_LINES).join("\n");
-      const tail = lines.slice(totalLines - AUTO_PREVIEW_TAIL_LINES).join("\n");
-      const omitted = totalLines - AUTO_PREVIEW_HEAD_LINES - AUTO_PREVIEW_TAIL_LINES;
+      if (sizeBytes <= outlineThresholdBytes) return withSubdirMemory(abs, lines.join("\n"));
+      const head = lines.slice(0, Math.min(OUTLINE_HEAD_LINES, totalLines)).join("\n");
       const outline = formatOutline(extractOutline(abs, lines));
       const parts = [
-        `[auto-preview: head ${AUTO_PREVIEW_HEAD_LINES} + tail ${AUTO_PREVIEW_TAIL_LINES} of ${totalLines} lines]`,
+        `[large file: ${formatBytes(sizeBytes)}, ${totalLines} lines \u2014 outline mode (threshold ${formatBytes(outlineThresholdBytes)})]`,
+        "",
+        `[head ${Math.min(OUTLINE_HEAD_LINES, totalLines)} lines for orientation]`,
         head
       ];
       if (outline) parts.push("", outline);
       parts.push(
-        `
-[\u2026 ${omitted} lines omitted \u2014 call read_file again with range:"A-B" (1-indexed) or head / tail to get the middle]
-`,
-        tail
+        "",
+        "[to read more, call one of:",
+        `  - read_file path:"${rel}" range:"A-B"          \u2014 1-indexed line range`,
+        `  - read_file path:"${rel}" head:N  /  tail:N    \u2014 first/last N lines`,
+        `  - search_content path:"${rel}" pattern:"..."   \u2014 grep within this file]`
       );
-      return parts.join("\n");
+      return withSubdirMemory(abs, parts.join("\n"));
     }
   });
   registry.register({
@@ -9900,7 +10543,7 @@ var VERIFY_SYSTEM = `You are a verify subagent. Narrow check \u2014 return YES /
 How to operate:
 - Read only what's needed to verify the specific claim. No exploration past the claim.
 - Use search_content / read_file to confirm the exact behavior, type, or call site in question.
-- Cap at 6-8 tool calls. If you can't verify in that, return INCONCLUSIVE plus what's missing.
+- If a focused round of reads can't verify it, return INCONCLUSIVE plus what's missing \u2014 don't keep digging.
 
 Final answer:
 - Lead with VERIFIED / NOT VERIFIED / INCONCLUSIVE.
@@ -9911,8 +10554,8 @@ ${NEGATIVE_CLAIM_RULE}
 
 ${TUI_FORMATTING_RULES}`;
 var TYPES = {
-  explore: { system: EXPLORE_SYSTEM, maxToolIters: 20 },
-  verify: { system: VERIFY_SYSTEM, maxToolIters: 8 }
+  explore: { system: EXPLORE_SYSTEM },
+  verify: { system: VERIFY_SYSTEM }
 };
 var SUBAGENT_TYPE_NAMES = Object.freeze(
   Object.keys(TYPES)
@@ -9940,11 +10583,6 @@ ${NEGATIVE_CLAIM_RULE}
 
 ${TUI_FORMATTING_RULES}`;
 var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
-var DEFAULT_PAUSE_EVERY = 16;
-var BUDGET_WARN_THRESHOLD = 3;
-function budgetParagraph(maxToolIters) {
-  return `Tool budget: you have ${maxToolIters} tool call${maxToolIters === 1 ? "" : "s"} for this task. The cap is enforced from outside \u2014 the call after #${maxToolIters} is refused. Pace yourself: if you can't fully resolve the task within the budget, stop early and return what you have plus what's missing, rather than burning the budget on one branch.`;
-}
 var DEFAULT_SUBAGENT_MODEL = "deepseek-v4-flash";
 var DEFAULT_SUBAGENT_EFFORT = "high";
 var SUBAGENT_TOOL_NAME = "spawn_subagent";
@@ -9963,7 +10601,6 @@ function subagentBudgetHint(spawnCount, totalTokens) {
 }
 async function spawnSubagent(opts) {
   const model = opts.model ?? DEFAULT_SUBAGENT_MODEL;
-  const maxToolIters = opts.maxToolIters ?? DEFAULT_PAUSE_EVERY;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
   const skillName = opts.skillName;
@@ -10016,26 +10653,8 @@ async function spawnSubagent(opts) {
     new Set(opts.allowedTools),
     NEVER_INHERITED_TOOLS
   ) : forkRegistryExcluding(opts.parentRegistry, NEVER_INHERITED_TOOLS);
-  let dispatchCount = 0;
-  childTools.setResultAugmenter((_name, _args, result) => {
-    dispatchCount++;
-    const remaining = maxToolIters - dispatchCount;
-    if (remaining <= 0) {
-      return `${result}
-
-[budget: 0 of ${maxToolIters} tool calls left \u2014 finalize NOW; the next tool call will be refused]`;
-    }
-    if (remaining <= BUDGET_WARN_THRESHOLD) {
-      return `${result}
-
-[budget: ${remaining} of ${maxToolIters} tool call${remaining === 1 ? "" : "s"} left \u2014 wrap up soon]`;
-    }
-    return result;
-  });
   const childPrefix = new ImmutablePrefix({
-    system: `${opts.system}
-
-${budgetParagraph(maxToolIters)}`,
+    system: opts.system,
     toolSpecs: childTools.specs()
   });
   const childLoop = new CacheFirstLoop({
@@ -10047,11 +10666,9 @@ ${budgetParagraph(maxToolIters)}`,
     // task is already narrow by construction, and `high` cuts output
     // tokens substantially vs `max`.
     reasoningEffort: DEFAULT_SUBAGENT_EFFORT,
-    maxToolIters,
     hooks: [],
     stream: true,
-    session: sessionName,
-    onIterBudgetExhausted: "pause"
+    session: sessionName
   });
   const onParentAbort = () => childLoop.abort();
   if (opts.parentSignal?.aborted) {
@@ -10063,13 +10680,9 @@ ${budgetParagraph(maxToolIters)}`,
   let errorMessage;
   let toolIter = 0;
   let summarisingEmitted = false;
-  let paused = false;
-  let partialSummary;
-  const taskForLoop = opts.resumeSession ? `[Resume: your tool-call budget has been refreshed with ${maxToolIters} new calls. Earlier "wrap up" / "finalize NOW" budget hints in this conversation referred to the previous window \u2014 they no longer apply. Continue the work you were given.]
-
-${opts.task}` : opts.task;
+  let forcedSummaryFired = false;
   try {
-    for await (const ev of childLoop.step(taskForLoop)) {
+    for await (const ev of childLoop.step(opts.task)) {
       sink?.current?.({ kind: "inner", runId, task: taskPreview, skillName, model, inner: ev });
       if (ev.role === "tool") {
         toolIter++;
@@ -10099,7 +10712,12 @@ ${opts.task}` : opts.task;
       }
       if (ev.role === "assistant_final") {
         if (ev.forcedSummary) {
-          errorMessage = ev.content?.trim() || "subagent ended without producing an answer";
+          if (opts.parentSignal?.aborted) {
+            errorMessage = ev.content?.trim() || "subagent aborted before producing an answer";
+          } else {
+            final = ev.content ?? "";
+            forcedSummaryFired = true;
+          }
         } else {
           final = ev.content ?? "";
         }
@@ -10107,17 +10725,13 @@ ${opts.task}` : opts.task;
       if (ev.role === "error") {
         errorMessage = ev.error ?? "subagent error";
       }
-      if (ev.role === "paused") {
-        paused = true;
-        if (ev.partialSummary) partialSummary = ev.partialSummary;
-      }
     }
   } catch (err) {
     errorMessage = err.message;
   } finally {
     opts.parentSignal?.removeEventListener("abort", onParentAbort);
   }
-  if (!errorMessage && !final && !paused) {
+  if (!errorMessage && !final) {
     errorMessage = opts.parentSignal?.aborted ? "subagent aborted before producing an answer" : "subagent ended without producing an answer";
   }
   const elapsedMs = Date.now() - startedAt;
@@ -10142,7 +10756,7 @@ ${opts.task}` : opts.task;
     usage
   });
   return {
-    success: !errorMessage,
+    success: !errorMessage && !forcedSummaryFired,
     output: errorMessage ? "" : truncated,
     error: errorMessage,
     turns,
@@ -10152,9 +10766,7 @@ ${opts.task}` : opts.task;
     model,
     skillName,
     usage,
-    paused: paused || void 0,
-    pausedSession: paused ? sessionName : void 0,
-    partialSummary: paused ? partialSummary : void 0
+    forcedSummary: forcedSummaryFired || void 0
   };
 }
 function aggregateChildUsage(loop) {
@@ -10169,16 +10781,16 @@ function aggregateChildUsage(loop) {
   return agg;
 }
 function formatSubagentResult(r) {
-  if (r.paused) {
+  if (r.forcedSummary) {
     return JSON.stringify({
       success: false,
-      paused: true,
-      resume_session: r.pausedSession,
+      partial: true,
+      output: r.output,
+      turns: r.turns,
       tool_iters: r.toolIters,
       elapsed_ms: r.elapsedMs,
       cost_usd: r.costUsd,
-      partial_summary: r.partialSummary,
-      note: `Subagent reached its pause-every interval (${r.toolIters} tool calls) without producing a final answer. Read partial_summary above to see what was done / left / blocked, then decide: resume by calling spawn_subagent again with resume_session="${r.pausedSession}" (the task arg becomes a continuation nudge \u2014 e.g. "finish what you started"), or accept the partial work and proceed with what you already know.`
+      note: "Subagent was force-summarized (storm-breaker or context-guard fired). `output` carries the partial synthesis the model produced before being stopped \u2014 useful but not a complete answer. Decide whether to accept the partial, narrow the task and re-spawn, or fall back to direct tools."
     });
   }
   if (!r.success) {
@@ -10203,7 +10815,6 @@ function registerSubagentTool(parentRegistry, opts) {
   const baseSystem = opts.defaultSystem ?? SUBAGENT_BASE_SYSTEM;
   const defaultSystemBase = opts.projectRoot ? applyProjectMemory(baseSystem, opts.projectRoot) : baseSystem;
   const defaultModel = opts.defaultModel ?? DEFAULT_SUBAGENT_MODEL;
-  const maxToolIters = opts.maxToolIters ?? DEFAULT_PAUSE_EVERY;
   const maxResultChars = opts.maxResultChars ?? DEFAULT_MAX_RESULT_CHARS2;
   const sink = opts.sink;
   let sessionSpawnCount = 0;
@@ -10211,7 +10822,7 @@ function registerSubagentTool(parentRegistry, opts) {
   parentRegistry.register({
     name: SUBAGENT_TOOL_NAME,
     parallelSafe: true,
-    description: "Spawn an isolated subagent to handle a self-contained subtask in a fresh context, returning only its final answer. **Prefer direct tools.** Spawn primarily for parallel fan-out (2+ independent investigations issued in one tool batch) or when the work would otherwise need >10 file reads/searches whose trail you don't need to keep. Single greps, 1-3 file cross-references, and 'keep my context clean for one question' are NOT good reasons to spawn \u2014 direct tools are cheaper and let you reference the evidence later. Each fresh spawn pays a prefix-cache miss plus a full child loop. The subagent inherits your tools but runs in its own isolated message log; only the final assistant message comes back. **Pause/resume**: subagents yield back to you every `max_iters` tool calls. A paused result returns `{ paused: true, resume_session: \"...\" }` \u2014 you can either accept the partial state, or call spawn_subagent again with `resume_session` set to continue where it left off (cheap: the prior prefix is cached). Tasks expected to run much longer than 16 tool calls don't need a huge `max_iters` \u2014 just resume.",
+    description: "Spawn an isolated subagent to handle a self-contained subtask in a fresh context, returning only its final answer. **Prefer direct tools.** Spawn primarily for parallel fan-out (2+ independent investigations issued in one tool batch) or when the work would otherwise need >10 file reads/searches whose trail you don't need to keep. Single greps, 1-3 file cross-references, and 'keep my context clean for one question' are NOT good reasons to spawn \u2014 direct tools are cheaper and let you reference the evidence later. Each fresh spawn pays a prefix-cache miss plus a full child loop. The subagent inherits your tools but runs in its own isolated message log; only the final assistant message comes back. The subagent runs to completion \u2014 same stops as top-level chat (token-context guard, storm breaker, parent Esc cascade).",
     parameters: {
       type: "object",
       properties: {
@@ -10228,18 +10839,14 @@ function registerSubagentTool(parentRegistry, opts) {
           enum: ["deepseek-v4-flash", "deepseek-v4-pro"],
           description: "Which DeepSeek model the subagent runs on. Default is 'deepseek-v4-flash' \u2014 cheap and fast, fine for explore/research-style subtasks. Override to 'deepseek-v4-pro' (~12\xD7 more expensive) when the subtask genuinely needs the stronger model: cross-file architecture, subtle bug hunts, anything where flash has empirically underperformed."
         },
-        max_iters: {
-          type: "integer",
-          description: "How many tool calls the subagent runs before pausing back to you for a checkpoint. Default 16. This is checkpoint cadence, not a budget \u2014 work continues across pauses via `resume_session`. Pick what feels natural for the granularity of decisions you want to make: small (4-8) when you want frequent control, larger (32-64) when the subagent should mostly run autonomously."
-        },
         resume_session: {
           type: "string",
-          description: "Provide the `resume_session` value returned by a previous paused spawn to continue that subagent. When set, prior messages are loaded from disk and the original system prompt is reused (cache-friendly). `task` becomes a continuation nudge."
+          description: "Provide a previous subagent's session name to continue it. When set, prior messages are loaded from disk and the original system prompt is reused (cache-friendly). `task` becomes a continuation nudge."
         },
         type: {
           type: "string",
           enum: [...SUBAGENT_TYPE_NAMES],
-          description: "Optional persona shaping the system prompt and default iter budget. 'explore' = wide-net read-only investigation (20-iter budget, returns a distilled answer). 'verify' = narrow yes/no check with evidence (8-iter budget). Omit when supplying your own 'system' prompt or when the default generic persona fits. Caller-supplied 'system' / 'max_iters' override the type's defaults."
+          description: "Optional persona shaping the system prompt. 'explore' = wide-net read-only investigation, returns a distilled answer. 'verify' = narrow yes/no check with evidence. Omit when supplying your own 'system' or when the default generic persona fits."
         }
       },
       required: ["task"]
@@ -10256,7 +10863,6 @@ function registerSubagentTool(parentRegistry, opts) {
       const system = typeof args.system === "string" && args.system.trim().length > 0 ? args.system.trim() : typeSpec?.system ?? `${defaultSystemBase}
 
 ${escalationContract(model)}`;
-      const callerIters = parseMaxIters(args.max_iters);
       const resumeSession = typeof args.resume_session === "string" && args.resume_session.trim().length > 0 ? args.resume_session.trim() : void 0;
       const result = await spawnSubagent({
         client: opts.client,
@@ -10264,7 +10870,6 @@ ${escalationContract(model)}`;
         system,
         task,
         model,
-        maxToolIters: callerIters ?? typeSpec?.maxToolIters ?? maxToolIters,
         maxResultChars,
         sink,
         parentSignal: ctx?.signal,
@@ -10272,6 +10877,12 @@ ${escalationContract(model)}`;
       });
       sessionSpawnCount++;
       sessionSpawnTokens += result.usage.totalTokens;
+      if (opts.onSpawnComplete) {
+        try {
+          opts.onSpawnComplete(result);
+        } catch {
+        }
+      }
       const formatted = formatSubagentResult(result);
       const hint = subagentBudgetHint(sessionSpawnCount, sessionSpawnTokens);
       return hint ? `${formatted}
@@ -10280,11 +10891,6 @@ ${hint}` : formatted;
   });
   return parentRegistry;
 }
-function parseMaxIters(raw) {
-  if (typeof raw !== "number" || !Number.isFinite(raw)) return void 0;
-  const n = Math.floor(raw);
-  return n >= 1 ? n : void 0;
-}
 function forkRegistryExcluding(parent, exclude) {
   const child = new ToolRegistry();
   for (const spec of parent.specs()) {
@@ -10311,8 +10917,100 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
   return child;
 }
 
+// src/telemetry/subagent-distillation.ts
+function computeSpawnDistillation(result) {
+  const outputTokens = countTokensBounded(result.output);
+  const completionTokens = result.usage.completionTokens;
+  const savingsTokens = Math.max(0, completionTokens - outputTokens);
+  const compressionRatio = completionTokens > 0 ? outputTokens / completionTokens : 1;
+  return {
+    completionTokens,
+    outputTokens,
+    savingsTokens,
+    compressionRatio,
+    hasOutput: result.output.trim().length > 0,
+    costUsd: result.costUsd
+  };
+}
+function summarizeSubagentSession(spawns) {
+  const spawnCount = spawns.length;
+  if (spawnCount === 0) {
+    return {
+      spawnCount: 0,
+      usefulSpawnCount: 0,
+      successRate: 0,
+      totalCompletionTokens: 0,
+      totalOutputTokens: 0,
+      totalSavingsTokens: 0,
+      aggregateCompressionRatio: 1,
+      totalCostUsd: 0
+    };
+  }
+  let usefulSpawnCount = 0;
+  let totalCompletionTokens = 0;
+  let totalOutputTokens = 0;
+  let totalSavingsTokens = 0;
+  let totalCostUsd = 0;
+  for (const s of spawns) {
+    if (s.hasOutput) usefulSpawnCount++;
+    totalCompletionTokens += s.completionTokens;
+    totalOutputTokens += s.outputTokens;
+    totalSavingsTokens += s.savingsTokens;
+    totalCostUsd += s.costUsd;
+  }
+  const aggregateCompressionRatio = totalCompletionTokens > 0 ? totalOutputTokens / totalCompletionTokens : 1;
+  return {
+    spawnCount,
+    usefulSpawnCount,
+    successRate: usefulSpawnCount / spawnCount,
+    totalCompletionTokens,
+    totalOutputTokens,
+    totalSavingsTokens,
+    aggregateCompressionRatio,
+    totalCostUsd
+  };
+}
+var DEFAULT_SPAWN_STORM_THRESHOLD = 3;
+function countSpawnStorms(spawnsByTurn, threshold = DEFAULT_SPAWN_STORM_THRESHOLD) {
+  let storms = 0;
+  for (const turn of spawnsByTurn) {
+    if (turn.length >= threshold) storms++;
+  }
+  return storms;
+}
+var SubagentTelemetry = class {
+  _spawns = [];
+  _byTurn = [];
+  _currentTurn = 0;
+  /** Bound for ergonomic use as a callback. */
+  record = (result) => {
+    const d = computeSpawnDistillation(result);
+    this._spawns.push(d);
+    while (this._byTurn.length <= this._currentTurn) this._byTurn.push([]);
+    this._byTurn[this._currentTurn].push(d);
+    return d;
+  };
+  /** Mark the start of a new parent turn so subsequent records group into a new bucket — call from the parent loop when its turn counter advances. */
+  startTurn(turn) {
+    if (turn < 0) return;
+    this._currentTurn = turn;
+  }
+  get spawns() {
+    return this._spawns;
+  }
+  get spawnsByTurn() {
+    return this._byTurn;
+  }
+  get summary() {
+    return summarizeSubagentSession(this._spawns);
+  }
+  stormCount(threshold = DEFAULT_SPAWN_STORM_THRESHOLD) {
+    return countSpawnStorms(this._byTurn, threshold);
+  }
+};
+
 // src/tools/shell.ts
-import * as pathMod9 from "path";
+import * as pathMod10 from "path";
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
@@ -10561,16 +11259,16 @@ ${job.output.slice(start)}`;
     let wakeOutput = null;
     if (waitFor === "output-or-exit") {
       racers.push(
-        new Promise((resolve10) => {
-          wakeOutput = resolve10;
-          job.outputWaiters.add(resolve10);
+        new Promise((resolve13) => {
+          wakeOutput = resolve13;
+          job.outputWaiters.add(resolve13);
         })
       );
     }
     let timer = null;
     racers.push(
-      new Promise((resolve10) => {
-        timer = setTimeout(resolve10, timeoutMs);
+      new Promise((resolve13) => {
+        timer = setTimeout(resolve13, timeoutMs);
       })
     );
     await Promise.race(racers);
@@ -10679,8 +11377,8 @@ function latestOutputSince(before, after) {
 
 // src/tools/shell/exec.ts
 import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync8, statSync as statSync5 } from "fs";
-import * as pathMod8 from "path";
+import { existsSync as existsSync9, statSync as statSync5 } from "fs";
+import * as pathMod9 from "path";
 
 // src/tools/shell-chain.ts
 import { spawn as spawn3 } from "child_process";
@@ -11013,6 +11711,10 @@ async function runPipeGroup(segments, opts) {
         cwd: opts.cwd,
         shell: false,
         windowsHide: true,
+        // POSIX: detach so the child becomes its own process-group leader,
+        // allowing killProcessTree's neg-pid kill to terminate the whole
+        // pipe chain subtree instead of just the direct child.
+        detached: process.platform !== "win32",
         env,
         stdio: [stdinSpec, stdoutSpec, stderrSpec],
         ...spawnOverrides
@@ -11063,9 +11765,9 @@ async function runPipeGroup(segments, opts) {
     }
     const exits = await Promise.all(
       children.map(
-        (c) => new Promise((resolve10) => {
-          c.once("error", () => resolve10(null));
-          c.once("close", (code) => resolve10(code));
+        (c) => new Promise((resolve13) => {
+          c.once("error", () => resolve13(null));
+          c.once("close", (code) => resolve13(code));
         })
       )
     );
@@ -11109,6 +11811,8 @@ var OutputBuffer = class {
 };
 
 // src/tools/shell/parse.ts
+import { homedir as homedir6 } from "os";
+import * as pathMod8 from "path";
 var BUILTIN_ALLOWLIST = [
   // Repo inspection
   "git status",
@@ -11285,7 +11989,65 @@ function tailHasRisky(tail, risky) {
   }
   return false;
 }
-function isAllowed(cmd, extra = []) {
+var DEFAULT_SENSITIVE_PREFIXES = [
+  "~/.ssh",
+  "~/.aws",
+  "~/.gnupg",
+  "~/.kube",
+  "/etc/shadow",
+  "/etc/sudoers"
+];
+var DEFAULT_SENSITIVE_PATTERNS = [
+  "*.env",
+  "*.env.*",
+  "*.key",
+  "*.pem",
+  "id_rsa*",
+  "id_ed25519*",
+  "*credentials*",
+  "*secret*"
+];
+function resolveSensitivePath(token, projectRoot) {
+  if (!token || token.startsWith("-") || token.includes("://") || token.startsWith("$"))
+    return null;
+  let expanded = token;
+  if (expanded.startsWith("~")) {
+    expanded = pathMod8.join(homedir6(), expanded.slice(1));
+  }
+  return pathMod8.resolve(projectRoot, expanded);
+}
+function expandPrefix(prefix) {
+  if (prefix.startsWith("~")) return pathMod8.join(homedir6(), prefix.slice(1));
+  return pathMod8.resolve(prefix);
+}
+function pathStartsWithPrefix(normalized, prefix) {
+  return normalized === prefix || normalized.startsWith(`${prefix}${pathMod8.sep}`);
+}
+function matchesGlob(name, pattern) {
+  const regex = new RegExp(
+    `^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`,
+    "i"
+  );
+  return regex.test(name);
+}
+function hasSensitivePathArgs(argv, projectRoot, extraPrefixes = [], extraPatterns = []) {
+  const prefixes = [...DEFAULT_SENSITIVE_PREFIXES, ...extraPrefixes].map(expandPrefix);
+  const patterns = [...DEFAULT_SENSITIVE_PATTERNS, ...extraPatterns];
+  for (const token of argv) {
+    const resolved = resolveSensitivePath(token, projectRoot);
+    if (!resolved) continue;
+    const normalized = pathMod8.normalize(resolved);
+    for (const pfx of prefixes) {
+      if (pathStartsWithPrefix(normalized, pfx)) return true;
+    }
+    const base = pathMod8.basename(normalized);
+    for (const pat of patterns) {
+      if (matchesGlob(base, pat)) return true;
+    }
+  }
+  return false;
+}
+function isAllowed(cmd, extra = [], projectRoot, sensitivePathConfig) {
   let argv;
   try {
     argv = tokenizeCommand(cmd);
@@ -11307,19 +12069,26 @@ function isAllowed(cmd, extra = []) {
     if (!match) continue;
     const risky = RISKY_ARGS[prefix];
     if (risky && tailHasRisky(argv.slice(prefixTokens.length), risky)) return false;
+    if (projectRoot && hasSensitivePathArgs(
+      argv,
+      projectRoot,
+      sensitivePathConfig?.prefixes,
+      sensitivePathConfig?.patterns
+    ))
+      return false;
     return true;
   }
   return false;
 }
-function isCommandAllowed(cmd, extra = []) {
+function isCommandAllowed(cmd, extra = [], projectRoot, sensitivePathConfig) {
   let chain;
   try {
     chain = parseCommandChain(cmd);
   } catch {
     return false;
   }
-  if (chain === null) return isAllowed(cmd, extra);
-  return chainAllowed(chain, (seg) => isAllowed(seg, extra));
+  if (chain === null) return isAllowed(cmd, extra, projectRoot, sensitivePathConfig);
+  return chainAllowed(chain, (seg) => isAllowed(seg, extra, projectRoot, sensitivePathConfig));
 }
 
 // src/tools/shell/exec.ts
@@ -11366,8 +12135,15 @@ async function runCommand(cmd, opts) {
   const spawnOpts = {
     cwd: opts.cwd,
     shell: false,
-    // no shell-expansion — see header comment
     windowsHide: true,
+    // POSIX: detach so the child becomes its own process-group leader.
+    // Required for `process.kill(-pid, …)` in killProcessTree to
+    // terminate the whole subtree (child + grandchildren) instead of
+    // only the leader — without this grandchildren like npm→node→esbuild
+    // become orphaned.
+    // Windows: detached would spawn a new console window; leave the
+    // default and use taskkill /T for tree termination (see killProcessTree).
+    detached: process.platform !== "win32",
     // PYTHONIOENCODING + PYTHONUTF8 force any spawned Python child
     // (run_command running `python script.py`, etc.) to emit UTF-8
     // on stdout/stderr. Without this, Chinese-Windows defaults
@@ -11380,7 +12156,7 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv, { env: normalizedEnv });
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve10, reject) => {
+  return await new Promise((resolve13, reject) => {
     let child;
     try {
       child = spawn4(bin, args, effectiveSpawnOpts);
@@ -11434,7 +12210,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve10({ exitCode: code, output, timedOut });
+      resolve13({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -11456,16 +12232,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod8.isAbsolute(cmd)) return cmd;
-  if (pathMod8.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod9.isAbsolute(cmd)) return cmd;
+  if (pathMod9.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (getEnvCaseInsensitive(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod8.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod9.delimiter);
   const pathDirs = (getEnvCaseInsensitive(env, "PATH") ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod8.win32.join(dir, cmd + ext);
+      const full = pathMod9.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -11519,7 +12295,7 @@ function mergeWindowsPathLike(values, delimiter2) {
 }
 function defaultIsFile(full) {
   try {
-    return existsSync8(full) && statSync5(full).isFile();
+    return existsSync9(full) && statSync5(full).isFile();
   } catch {
     return false;
   }
@@ -11581,8 +12357,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod8.isAbsolute(s)) return false;
-  if (pathMod8.extname(s)) return false;
+  if (pathMod9.isAbsolute(s)) return false;
+  if (pathMod9.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -11603,7 +12379,7 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod9.resolve(opts.rootDir);
+  const rootDir = pathMod10.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const jobs = opts.jobs ?? new JobRegistry();
@@ -11623,7 +12399,7 @@ function registerShellTools(registry, opts) {
       if (isAllowAll()) return true;
       const cmd = typeof args?.command === "string" ? args.command.trim() : "";
       if (!cmd) return false;
-      return isCommandAllowed(cmd, getExtraAllowed());
+      return isCommandAllowed(cmd, getExtraAllowed(), rootDir, opts.sensitivePaths);
     },
     parameters: {
       type: "object",
@@ -11643,7 +12419,7 @@ function registerShellTools(registry, opts) {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_command: empty command");
       const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
-      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed())) {
+      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed(), rootDir, opts.sensitivePaths)) {
         const gate = ctx?.confirmationGate ?? pauseGate;
         const choice = await gate.ask({
           kind: "run_command",
@@ -11669,7 +12445,7 @@ function registerShellTools(registry, opts) {
   });
   registry.register({
     name: "run_background",
-    description: "Spawn a long-running process and detach. Waits up to `waitSec` for startup or a readiness signal ('Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. Tail logs with `job_output`, block on completion with `wait_for_job`, kill with `stop_job`, list with `list_jobs`.\n\nSingle process only \u2014 chains / redirects / `cd` work as in run_command, but a typical invocation is one binary. Use the binary's own --cwd / --prefix flag for subdirectories. Vite gotcha: npm's `--prefix` only finds package.json; vite's server root still uses process cwd \u2014 pass `vite <project-dir>` instead.\n\nUSE THIS \u2014 not run_command \u2014 for:\n- Dev servers / watchers: npm/yarn/pnpm dev, uvicorn / flask run, cargo watch, tsc --watch, webpack serve, anything with dev/serve/watch in the name.\n- One-shot long jobs: curl / wget large downloads, `huggingface-cli download`, multi-GB `pip install` / `npm install`, big `cargo build` / `docker build`. Start with `run_background`, then call `wait_for_job` once (default `waitFor: 'exit'`, timeoutMs up to 300_000) \u2014 the harness blocks server-side so a 5-minute download costs ONE tool call, not 30 polls.",
+    description: "Spawn a long-running process and detach. Waits up to `waitSec` for startup or a readiness signal ('Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. Tail logs with `job_output`, block on completion with `wait_for_job`, kill with `stop_job`, list with `list_jobs`.\n\nSingle process only \u2014 no chains / redirects. For subdirectories use the `cwd` parameter (workspace-relative or absolute, must stay inside the workspace root); do NOT write `cd X && cmd`, that gets rejected.\n\nUSE THIS \u2014 not run_command \u2014 for:\n- Dev servers / watchers: npm/yarn/pnpm dev, uvicorn / flask run, cargo watch, tsc --watch, webpack serve, anything with dev/serve/watch in the name.\n- One-shot long jobs: curl / wget large downloads, `huggingface-cli download`, multi-GB `pip install` / `npm install`, big `cargo build` / `docker build`. Start with `run_background`, then call `wait_for_job` once (default `waitFor: 'exit'`, timeoutMs up to 300_000) \u2014 the harness blocks server-side so a 5-minute download costs ONE tool call, not 30 polls.",
     parameters: {
       type: "object",
       properties: {
@@ -11677,6 +12453,10 @@ function registerShellTools(registry, opts) {
           type: "string",
           description: "Full command line. Same quoting rules as run_command (no pipes / redirects / chaining)."
         },
+        cwd: {
+          type: "string",
+          description: "Working directory for the spawn. Workspace-relative or absolute. Defaults to the workspace root. Must resolve inside the workspace \u2014 paths escaping the root are rejected."
+        },
         waitSec: {
           type: "integer",
           description: "Max seconds to wait for startup before returning. 0..30, default 3. A ready-signal match short-circuits this."
@@ -11687,11 +12467,12 @@ function registerShellTools(registry, opts) {
     fn: async (args, ctx) => {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_background: empty command");
-      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed())) {
+      const cwd = resolveCwdInsideRoot(rootDir, args.cwd);
+      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed(), rootDir, opts.sensitivePaths)) {
         const gate = ctx?.confirmationGate ?? pauseGate;
         const choice = await gate.ask({
           kind: "run_background",
-          payload: { command: cmd, cwd: rootDir, waitSec: args.waitSec }
+          payload: { command: cmd, cwd, waitSec: args.waitSec }
         });
         if (choice.type === "deny") {
           throw new Error(
@@ -11703,10 +12484,11 @@ function registerShellTools(registry, opts) {
         }
       }
       const result = await jobs.start(cmd, {
-        cwd: rootDir,
+        cwd,
         waitSec: args.waitSec,
         signal: ctx?.signal
       });
+      opts.onJobsChanged?.();
       return formatJobStart(result);
     }
   });
@@ -11768,6 +12550,7 @@ function registerShellTools(registry, opts) {
         waitFor: args.waitFor
       });
       if (!out) return `job ${args.jobId}: not found (use list_jobs)`;
+      if (out.exited) opts.onJobsChanged?.();
       return {
         jobId: args.jobId,
         exited: out.exited,
@@ -11788,6 +12571,7 @@ function registerShellTools(registry, opts) {
     },
     fn: async (args) => {
       const rec = await jobs.stop(args.jobId);
+      opts.onJobsChanged?.();
       if (!rec) return `job ${args.jobId}: not found`;
       return formatJobStop(rec);
     }
@@ -11807,6 +12591,18 @@ function registerShellTools(registry, opts) {
   });
   return registry;
 }
+function resolveCwdInsideRoot(rootDir, raw) {
+  const root = pathMod10.resolve(rootDir);
+  if (!raw || !raw.trim()) return root;
+  const resolved = pathMod10.resolve(root, raw);
+  const rel = pathMod10.relative(root, resolved);
+  if (rel.startsWith("..") || pathMod10.isAbsolute(rel)) {
+    throw new Error(
+      `run_background: cwd "${raw}" resolves outside the workspace root (${root}). Pass a workspace-relative path.`
+    );
+  }
+  return resolved;
+}
 function formatJobStart(r) {
   const header = r.stillRunning ? `[job ${r.jobId} started \xB7 pid ${r.pid ?? "?"} \xB7 ${r.readyMatched ? "READY signal matched" : "running (no ready signal yet)"}]` : r.exitCode !== null ? `[job ${r.jobId} exited during startup \xB7 exit ${r.exitCode}]` : `[job ${r.jobId} failed to start]`;
   return r.preview ? `${header}
@@ -11855,6 +12651,7 @@ var DEFAULT_TOPK = 5;
 var FETCH_MAX_BYTES = 10 * 1024 * 1024;
 var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 var MOJEEK_ENDPOINT = "https://www.mojeek.com/search";
+var METASO_ENDPOINT = "https://metaso.cn/api/v1";
 function searchStatusError(status) {
   if (status === 429) return t("webErrors.rateLimit429");
   if (status === 403) return t("webErrors.forbidden403");
@@ -11868,6 +12665,9 @@ function fetchStatusError(status, url) {
   return t("webErrors.fetchStatus", { status, url });
 }
 async function webSearch(query, opts = {}) {
+  if (opts.engine === "metaso") {
+    return searchMetaso(query, opts);
+  }
   if (opts.engine === "searxng") {
     return searchSearxng(query, opts);
   }
@@ -11943,6 +12743,68 @@ async function searchSearxng(query, opts = {}) {
   }
   return results;
 }
+async function searchMetaso(query, opts = {}) {
+  const topK = Math.max(1, Math.min(100, opts.topK ?? DEFAULT_TOPK));
+  const apiKey = loadMetasoApiKey();
+  let resp;
+  try {
+    resp = await fetch(`${METASO_ENDPOINT}/search`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        q: query,
+        scope: "webpage",
+        size: topK
+      }),
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof TypeError && err.message.includes("fetch")) {
+      throw new Error(t("webErrors.cannotReach", { endpoint: METASO_ENDPOINT }));
+    }
+    throw err;
+  }
+  const raw = await resp.text();
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error(t("webErrors.metasoParseError", { status: resp.status }));
+  }
+  if (!resp.ok) {
+    if (resp.status === 401 || resp.status === 403) {
+      throw new Error(t("webErrors.metasoUnauthorized"));
+    }
+    if (resp.status === 429) {
+      throw new Error(t("webErrors.metasoRateLimit"));
+    }
+    throw new Error(t("webErrors.metasoServerError", { status: resp.status }));
+  }
+  if (data.code === 3003) {
+    throw new Error(t("webErrors.metasoDailyLimit"));
+  }
+  if (data.code === 2005) {
+    throw new Error(t("webErrors.metasoUnauthorized"));
+  }
+  if (data.code && data.code !== 0) {
+    throw new Error(
+      t("webErrors.metasoApiError", { code: data.code, message: data.message ?? "" })
+    );
+  }
+  const webpages = data.webpages ?? [];
+  if (webpages.length === 0) {
+    return [];
+  }
+  return webpages.slice(0, topK).map((wp) => ({
+    title: wp.title,
+    url: wp.link,
+    snippet: wp.snippet ?? wp.summary ?? ""
+  }));
+}
 function parseSearxngHtmlResults(html) {
   const root = parseHtml(html);
   const results = [];
@@ -12161,7 +13023,7 @@ function registerWebTools(registry, opts = {}) {
   const maxFetchChars = opts.maxFetchChars ?? DEFAULT_FETCH_MAX_CHARS;
   registry.register({
     name: "web_search",
-    description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this. To change the backend, use /web-search-engine mojeek|searxng.",
+    description: "Search the public web. Returns ranked results with title, url, and snippet. Call this when the answer's correctness depends on current state \u2014 anything that changes over time (events, prices, releases, status of a thing in the real world). Composing such answers from training memory invents stale numbers; search first, then ground the answer in the results. For evergreen / definitional questions you don't need this. To change the backend, use /search-engine mojeek|searxng|metaso.",
     readOnly: true,
     parallelSafe: true,
     parameters: {
@@ -12226,12 +13088,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { resolve as resolve8 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve11 } from "path";
 function loadDotenv(path2 = ".env") {
   let raw;
   try {
-    raw = readFileSync10(resolve8(process.cwd(), path2), "utf8");
+    raw = readFileSync11(resolve11(process.cwd(), path2), "utf8");
   } catch {
     return;
   }
@@ -12250,7 +13112,7 @@ function loadDotenv(path2 = ".env") {
 }
 
 // src/transcript/log.ts
-import { createWriteStream, readFileSync as readFileSync11 } from "fs";
+import { createWriteStream, readFileSync as readFileSync12 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12293,7 +13155,7 @@ function openTranscriptFile(path2, meta) {
   return stream;
 }
 function readTranscript(path2) {
-  const raw = readFileSync11(path2, "utf8");
+  const raw = readFileSync12(path2, "utf8");
   return parseTranscript(raw);
 }
 function parseTranscript(raw) {
@@ -12680,25 +13542,25 @@ function truncate(s, n) {
 }
 
 // src/version.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname6, join as join12 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname7, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var LATEST_FETCH_TIMEOUT_MS = 2e3;
 function readPackageVersion() {
   try {
-    let dir = dirname6(fileURLToPath2(import.meta.url));
+    let dir = dirname7(fileURLToPath2(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join12(dir, "package.json");
-      if (existsSync9(p)) {
-        const pkg = JSON.parse(readFileSync12(p, "utf8"));
+      const p = join14(dir, "package.json");
+      if (existsSync10(p)) {
+        const pkg = JSON.parse(readFileSync13(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
           return pkg.version;
         }
       }
-      const parent = dirname6(dir);
+      const parent = dirname7(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -12708,11 +13570,11 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join12(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
+  return join14(homeDirOverride ?? homedir7(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
-    const raw = readFileSync12(cachePath(homeDirOverride), "utf8");
+    const raw = readFileSync13(cachePath(homeDirOverride), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
       return parsed;
@@ -12724,7 +13586,7 @@ function readCache(homeDirOverride) {
 function writeCache(entry, homeDirOverride) {
   try {
     const p = cachePath(homeDirOverride);
-    mkdirSync5(dirname6(p), { recursive: true });
+    mkdirSync5(dirname7(p), { recursive: true });
     writeFileSync5(p, JSON.stringify(entry), "utf8");
   } catch {
   }
@@ -12936,7 +13798,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve10, reject) => {
+    const promise = new Promise((resolve13, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -12945,7 +13807,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve10,
+        resolve: resolve13,
         reject,
         timeout
       });
@@ -13075,12 +13937,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve13, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve10();
+        else resolve13();
       });
     });
   }
@@ -13091,8 +13953,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve10) => {
-        this.waiters.push(resolve10);
+      const next = await new Promise((resolve13) => {
+        this.waiters.push(resolve13);
       });
       if (next === null) return;
       yield next;
@@ -13165,8 +14027,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve10, reject) => {
-      this.resolveEndpoint = resolve10;
+    this.endpointReady = new Promise((resolve13, reject) => {
+      this.resolveEndpoint = resolve13;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -13193,8 +14055,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve10) => {
-        this.waiters.push(resolve10);
+      const next = await new Promise((resolve13) => {
+        this.waiters.push(resolve13);
       });
       if (next === null) return;
       yield next;
@@ -13380,8 +14242,8 @@ var StreamableHttpTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve10) => {
-        this.waiters.push(resolve10);
+      const next = await new Promise((resolve13) => {
+        this.waiters.push(resolve13);
       });
       if (next === null) return;
       yield next;
@@ -13439,85 +14301,6 @@ var StreamableHttpTransport = class {
   }
 };
 
-// src/mcp/shell-split.ts
-function shellSplit(input) {
-  const tokens = [];
-  let cur = "";
-  let quote = null;
-  let i = 0;
-  const s = input;
-  while (i < s.length) {
-    const ch = s[i];
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-        i++;
-        continue;
-      }
-      if (ch === "\\" && quote === '"' && i + 1 < s.length) {
-        cur += s[i + 1];
-        i += 2;
-        continue;
-      }
-      cur += ch;
-      i++;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      i++;
-      continue;
-    }
-    if (ch === " " || ch === "	") {
-      if (cur.length > 0) {
-        tokens.push(cur);
-        cur = "";
-      }
-      i++;
-      continue;
-    }
-    cur += ch;
-    i++;
-  }
-  if (quote) {
-    throw new Error(
-      `shellSplit: unterminated ${quote === '"' ? "double" : "single"} quote in input`
-    );
-  }
-  if (cur.length > 0) tokens.push(cur);
-  return tokens;
-}
-
-// src/mcp/spec.ts
-var NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_-]*)=(.*)$/;
-var HTTP_URL = /^https?:\/\//i;
-var STREAMABLE_PREFIX = /^streamable\+(https?:\/\/.+)$/i;
-function parseMcpSpec(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("empty MCP spec");
-  }
-  const nameMatch = NAME_PREFIX.exec(trimmed);
-  const name = nameMatch ? nameMatch[1] : null;
-  const body = (nameMatch ? nameMatch[2] : trimmed).trim();
-  if (!body) {
-    throw new Error(`MCP spec has name but no command: ${input}`);
-  }
-  const streamMatch = STREAMABLE_PREFIX.exec(body);
-  if (streamMatch) {
-    return { transport: "streamable-http", name, url: streamMatch[1] };
-  }
-  if (HTTP_URL.test(body)) {
-    return { transport: "sse", name, url: body };
-  }
-  const argv = shellSplit(body);
-  if (argv.length === 0) {
-    throw new Error(`MCP spec has name but no command: ${input}`);
-  }
-  const [command, ...args] = argv;
-  return { transport: "stdio", name, command, args };
-}
-
 // src/mcp/inspect.ts
 async function inspectMcpServer(client) {
   const t0 = Date.now();
@@ -13553,18 +14336,18 @@ async function trySection(load) {
 // src/code/edit-blocks.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   fstatSync,
   ftruncateSync,
   mkdirSync as mkdirSync6,
   openSync as openSync2,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   readSync,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6,
   writeSync
 } from "fs";
-import { dirname as dirname7, resolve as resolve9 } from "path";
+import { dirname as dirname8, resolve as resolve12 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -13582,9 +14365,9 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve9(rootDir);
-  const absTarget = resolve9(absRoot, block.path);
-  if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
+  const absRoot = resolve12(rootDir);
+  const absTarget = resolve12(absRoot, block.path);
+  if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep2()}`)) {
     return {
       path: block.path,
       status: "path-escape",
@@ -13594,7 +14377,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync6(dirname7(absTarget), { recursive: true });
+      mkdirSync6(dirname8(absTarget), { recursive: true });
       const fd = openSync2(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -13670,19 +14453,19 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve9(rootDir);
+  const absRoot = resolve12(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve9(absRoot, b.path);
-    if (!existsSync10(abs)) {
+    const abs = resolve12(absRoot, b.path);
+    if (!existsSync11(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync13(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync14(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -13690,10 +14473,10 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve9(rootDir);
+  const absRoot = resolve12(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve9(absRoot, snap.path);
-    if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
+    const abs = resolve12(absRoot, snap.path);
+    if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep2()}`)) {
       return {
         path: snap.path,
         status: "path-escape",
@@ -13702,7 +14485,7 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync10(abs)) unlinkSync3(abs);
+        if (existsSync11(abs)) unlinkSync3(abs);
         return {
           path: snap.path,
           status: "applied",
@@ -13720,7 +14503,7 @@ function restoreSnapshots(snapshots, rootDir) {
     }
   });
 }
-function sep() {
+function sep2() {
   return process.platform === "win32" ? "\\" : "/";
 }
 function lineEndingOf(text) {
@@ -13728,8 +14511,8 @@ function lineEndingOf(text) {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
+import { join as join15 } from "path";
 var DEFAULT_CODE_MODEL = "deepseek-v4-flash";
 function codeSystemBase(modelId) {
   return CODE_SYSTEM_TEMPLATE.replace("__ESCALATION_CONTRACT__", escalationContract(modelId));
@@ -13976,12 +14759,12 @@ function codeSystemPrompt(rootDir, opts = {}) {
   const codeBase = codeSystemBase(opts.modelId ?? DEFAULT_CODE_MODEL);
   const base = opts.hasSemanticSearch ? `${codeBase}${SEMANTIC_SEARCH_ROUTING}` : codeBase;
   const withMemory = applyMemoryStack(base, rootDir);
-  const gitignorePath = join13(rootDir, ".gitignore");
+  const gitignorePath = join15(rootDir, ".gitignore");
   let result = withMemory;
-  if (existsSync11(gitignorePath)) {
+  if (existsSync12(gitignorePath)) {
     let content;
     try {
-      content = readFileSync14(gitignorePath, "utf8");
+      content = readFileSync15(gitignorePath, "utf8");
     } catch {
     }
     if (content !== void 0) {
@@ -14015,21 +14798,21 @@ ${appendParts.join("\n\n")}`;
 import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync3,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   fstatSync as fstatSync2,
   mkdirSync as mkdirSync7,
   openSync as openSync3,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readSync as readSync2,
   renameSync as renameSync2,
   statSync as statSync6,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname8, join as join14 } from "path";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname9, join as join16 } from "path";
 function defaultUsageLogPath(homeDirOverride) {
-  return join14(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
+  return join16(homeDirOverride ?? homedir8(), ".reasonix", "usage.jsonl");
 }
 var USAGE_COMPACTION_THRESHOLD_BYTES = 5 * 1024 * 1024;
 var USAGE_RETENTION_DAYS = 365;
@@ -14094,7 +14877,7 @@ function appendUsage(input) {
   if (input.subagent) record.subagent = input.subagent;
   const path2 = input.path ?? defaultUsageLogPath();
   try {
-    mkdirSync7(dirname8(path2), { recursive: true });
+    mkdirSync7(dirname9(path2), { recursive: true });
     appendFileSync2(path2, `${JSON.stringify(record)}
 `, "utf8");
     compactUsageLogIfLarge(path2, record.ts);
@@ -14103,10 +14886,10 @@ function appendUsage(input) {
   return record;
 }
 function readUsageLog(path2 = defaultUsageLogPath()) {
-  if (!existsSync12(path2)) return [];
+  if (!existsSync13(path2)) return [];
   let raw;
   try {
-    raw = readFileSync15(path2, "utf8");
+    raw = readFileSync16(path2, "utf8");
   } catch {
     return [];
   }
@@ -14213,7 +14996,7 @@ function aggregateUsage(records, opts = {}) {
   };
 }
 function formatLogSize(path2 = defaultUsageLogPath()) {
-  if (!existsSync12(path2)) return "";
+  if (!existsSync13(path2)) return "";
   try {
     const s = statSync6(path2);
     const bytes = s.size;
@@ -14236,6 +15019,7 @@ export {
   DEFAULT_MAX_RESULT_CHARS,
   DEFAULT_MAX_RESULT_TOKENS,
   DEFAULT_PICKER_IGNORE_DIRS,
+  DEFAULT_SPAWN_STORM_THRESHOLD,
   DeepSeekClient,
   HOOK_EVENTS,
   HOOK_SETTINGS_DIRNAME,
@@ -14259,6 +15043,7 @@ export {
   StdioTransport,
   StormBreaker,
   StreamableHttpTransport,
+  SubagentTelemetry,
   ToolCallRepair,
   ToolRegistry,
   USER_MEMORY_DIR,
@@ -14281,7 +15066,9 @@ export {
   codeSystemPrompt,
   compareVersions,
   computeReplayStats,
+  computeSpawnDistillation,
   costUsd,
+  countSpawnStorms,
   decideOutcome,
   defaultConfigPath,
   defaultUsageLogPath,
@@ -14324,6 +15111,7 @@ export {
   loadBaseUrl,
   loadDotenv,
   loadHooks,
+  loadMetasoApiKey,
   loadSessionMessages,
   matchesTool,
   memoryEnabled,
@@ -14374,6 +15162,7 @@ export {
   similarity,
   snapshotBeforeEdits,
   stripHallucinatedToolMarkup,
+  summarizeSubagentSession,
   tokenizeCommand,
   truncateForModel,
   truncateForModelByTokens,