reasonix 0.43.0 → 0.44.0

package/dist/cli/{chunk-2R4QCDOZ.js → chunk-OPFUUYHL.js}

@@ -3,28 +3,32 @@ import { createRequire as __cr } from 'node:module'; if (typeof globalThis.requi
 import {
   MemoryStore,
   sanitizeMemoryName
-} from "./chunk-5JJRUIPA.js";
+} from "./chunk-JNAQYELD.js";
 import {
   countTokens,
+  countTokensBounded,
   estimateConversationTokens,
   estimateRequestTokens
-} from "./chunk-PV55UMTO.js";
+} from "./chunk-6OWJV3YW.js";
 import {
   Usage
-} from "./chunk-2KDUS647.js";
+} from "./chunk-V26WPN3J.js";
 import {
   applyEdit,
   applyMultiEdit,
   pauseGate
-} from "./chunk-O52OLQL3.js";
+} from "./chunk-RDRC3XDT.js";
 import {
   NEGATIVE_CLAIM_RULE,
-  TUI_FORMATTING_RULES
-} from "./chunk-2K65GZBT.js";
+  PROJECT_MEMORY_FILES,
+  PROJECT_MEMORY_MAX_CHARS,
+  TUI_FORMATTING_RULES,
+  memoryEnabled
+} from "./chunk-TEUDEGX2.js";
 import {
   formatHookOutcomeMessage,
   runHooks
-} from "./chunk-7O5ALB4C.js";
+} from "./chunk-7CIGMZT3.js";
 import {
   ignoredByLayers,
   loadGitignoreAt,
@@ -38,23 +42,24 @@ import {
   rewriteSession,
   timestampSuffix
 } from "./chunk-6PBZN4VI.js";
+import {
+  DEEPSEEK_CONTEXT_TOKENS,
+  DEFAULT_CONTEXT_TOKENS,
+  SessionStats
+} from "./chunk-ZZYBBX5N.js";
 import {
   t
-} from "./chunk-RE4RAVFF.js";
+} from "./chunk-CGDR2ELH.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   addProjectPathAllowed,
   loadMemoryTypeRegistry,
+  loadMetasoApiKey,
   loadProjectPathAllowed,
   require_picomatch,
   webSearchEndpoint,
   webSearchEngine
-} from "./chunk-XPDVG52A.js";
-import {
-  DEEPSEEK_CONTEXT_TOKENS,
-  DEFAULT_CONTEXT_TOKENS,
-  SessionStats
-} from "./chunk-YQ6NTIIE.js";
+} from "./chunk-AVFXO2EZ.js";
 import {
   __commonJS,
   __esm,
@@ -2591,10 +2596,10 @@ var require_helpers = __commonJS({
         return !arr.includes(node, i + 1);
       });
       nodes.sort(function(a, b) {
-        var relative5 = compareDocumentPosition(a, b);
-        if (relative5 & DocumentPosition.PRECEDING) {
+        var relative6 = compareDocumentPosition(a, b);
+        if (relative6 & DocumentPosition.PRECEDING) {
           return -1;
-        } else if (relative5 & DocumentPosition.FOLLOWING) {
+        } else if (relative6 & DocumentPosition.FOLLOWING) {
           return 1;
         }
         return 0;
@@ -6044,12 +6049,12 @@ async function waitForReady(ready, timeoutMs, serverName, signal) {
   let timer;
   let onAbort;
   try {
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       ready.then(
         () => {
           if (settled) return;
           settled = true;
-          resolve4();
+          resolve5();
         },
         (err) => {
           if (settled) return;
@@ -6584,6 +6589,40 @@ var VolatileScratch = class {
   }
 };
 
+// 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/context-manager.ts
 var HISTORY_FOLD_THRESHOLD = 0.5;
 var HISTORY_FOLD_TAIL_FRACTION = 0.2;
@@ -6592,6 +6631,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;
@@ -6646,7 +6687,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,
@@ -6665,7 +6706,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;
@@ -6681,16 +6722,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);
@@ -6698,7 +6741,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. */
@@ -6724,18 +6811,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) {
@@ -6827,17 +6947,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();
@@ -6879,50 +6997,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";
@@ -6936,7 +7018,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}`;
@@ -6951,7 +7033,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",
@@ -6961,28 +7043,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) {
@@ -7015,7 +7075,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);
@@ -7341,11 +7401,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 = [];
@@ -7400,10 +7465,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 };
   }
 }
 
@@ -7450,9 +7517,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 = [];
@@ -7474,12 +7548,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();
@@ -7494,7 +7566,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. */
@@ -7508,12 +7579,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() {
@@ -7533,8 +7617,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;
@@ -7555,23 +7637,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);
@@ -7657,6 +7722,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 {
@@ -7666,6 +7735,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) {
@@ -7821,6 +7913,7 @@ ${reason}`
     return userText;
   }
   async *step(userInput) {
+    this._steerConsumed = false;
     if (this.budgetUsd !== null) {
       const spent = this.stats.totalCost;
       if (spent >= this.budgetUsd) {
@@ -7854,7 +7947,6 @@ ${reason}`
     this._turnSelfCorrected = false;
     this._escalateThisTurn = false;
     this._foldedThisTurn = false;
-    this._toolDispatchesThisStep = 0;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
       this._escalateThisTurn = true;
@@ -7872,16 +7964,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));
@@ -7902,15 +7993,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) {
@@ -7918,23 +8014,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
-              })
+              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,
@@ -8091,10 +8193,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,
@@ -8288,20 +8386,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 {
@@ -8310,8 +8394,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) {
@@ -9144,6 +9227,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");
@@ -9157,6 +9241,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);
   }
@@ -9232,6 +9319,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 = (0, import_node_html_parser.parse)(html);
   const results = [];
@@ -9450,7 +9599,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: {
@@ -9519,6 +9668,51 @@ var import_picomatch2 = __toESM(require_picomatch(), 1);
 import { promises as fs3 } from "fs";
 import * as pathMod4 from "path";
 
+// src/memory/subdir.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2, relative as relative2, resolve as resolve2 } from "path";
+function findSubdirMemoryAncestors(absPath, rootDir) {
+  const root = resolve2(rootDir);
+  const target = resolve2(absPath);
+  const rel = relative2(root, target);
+  if (!rel || rel.startsWith("..")) return [];
+  const found = [];
+  let cur = dirname(target);
+  while (cur !== root) {
+    const r = relative2(root, cur);
+    if (!r || r.startsWith("..")) break;
+    for (const name of PROJECT_MEMORY_FILES) {
+      const path = join2(cur, name);
+      if (existsSync2(path)) {
+        found.push(path);
+        break;
+      }
+    }
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return found;
+}
+function readSubdirMemoryContent(path) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "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/glob.ts
 var import_picomatch = __toESM(require_picomatch(), 1);
 import { promises as fs } from "fs";
@@ -9593,6 +9787,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",
@@ -9608,7 +9814,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 = pathMod2.extname(filename).toLowerCase();
@@ -9625,6 +9834,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) {
@@ -9676,6 +9889,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;
@@ -9923,17 +10166,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 displayRel3(rootDir, full) {
   return pathMod4.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 = pathMod4.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !pathMod4.isAbsolute(rel);
+}
 var GLOB_METACHARS = /[*?{[]/;
 function compileNameFilter(filter) {
   if (!filter) return null;
@@ -9950,24 +10201,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 = pathMod4.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 = pathMod4.resolve(rootDir);
   const sessionApproved = /* @__PURE__ */ new Set();
-  const inflightGate = /* @__PURE__ */ new Map();
-  function pathIsUnder(child, parent) {
-    const rel = pathMod4.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !pathMod4.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(displayRel3(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;
@@ -10032,11 +10304,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: {
@@ -10054,22 +10326,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 = displayRel3(rootDir, abs);
       const fh = await fs3.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/);
@@ -10081,8 +10362,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);
@@ -10090,7 +10371,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);
@@ -10098,25 +10379,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({
@@ -10857,7 +11139,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.
@@ -10868,8 +11150,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)
@@ -10893,18 +11175,12 @@ ${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";
 var NEVER_INHERITED_TOOLS = /* @__PURE__ */ new Set([SUBAGENT_TOOL_NAME, "submit_plan"]);
 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;
@@ -10957,26 +11233,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({
@@ -10988,11 +11246,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) {
@@ -11004,13 +11260,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++;
@@ -11040,7 +11292,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 ?? "";
         }
@@ -11048,17 +11305,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;
@@ -11083,7 +11336,7 @@ ${opts.task}` : opts.task;
     usage
   });
   return {
-    success: !errorMessage,
+    success: !errorMessage && !forcedSummaryFired,
     output: errorMessage ? "" : truncated,
     error: errorMessage,
     turns,
@@ -11093,9 +11346,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) {
@@ -11110,16 +11361,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) {
@@ -11169,18 +11420,18 @@ function forkRegistryWithAllowList(parent, allow, alsoExclude) {
 // src/code/edit-blocks.ts
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   fstatSync,
   ftruncateSync,
   mkdirSync,
   openSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   readSync,
   unlinkSync,
   writeFileSync,
   writeSync
 } from "fs";
-import { dirname as dirname2, resolve as resolve3 } from "path";
+import { dirname as dirname3, resolve as resolve4 } 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 = [];
@@ -11198,8 +11449,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve3(rootDir);
-  const absTarget = resolve3(absRoot, block.path);
+  const absRoot = resolve4(rootDir);
+  const absTarget = resolve4(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -11210,7 +11461,7 @@ function applyEditBlock(block, rootDir) {
   const searchEmpty = block.search.length === 0;
   if (searchEmpty) {
     try {
-      mkdirSync(dirname2(absTarget), { recursive: true });
+      mkdirSync(dirname3(absTarget), { recursive: true });
       const fd = openSync(absTarget, "wx");
       try {
         writeSync(fd, block.replace);
@@ -11286,11 +11537,11 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function toWholeFileEditBlock(path, content, rootDir) {
-  const abs = resolve3(rootDir, path);
+  const abs = resolve4(rootDir, path);
   let search = "";
-  if (existsSync2(abs)) {
+  if (existsSync3(abs)) {
     try {
-      search = readFileSync2(abs, "utf8");
+      search = readFileSync3(abs, "utf8");
     } catch {
       search = "";
     }
@@ -11298,19 +11549,19 @@ function toWholeFileEditBlock(path, content, rootDir) {
   return { path, search, replace: content, offset: 0 };
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve3(rootDir);
+  const absRoot = resolve4(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 = resolve3(absRoot, b.path);
-    if (!existsSync2(abs)) {
+    const abs = resolve4(absRoot, b.path);
+    if (!existsSync3(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync2(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync3(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -11318,9 +11569,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve3(rootDir);
+  const absRoot = resolve4(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve3(absRoot, snap.path);
+    const abs = resolve4(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -11330,7 +11581,7 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync2(abs)) unlinkSync(abs);
+        if (existsSync3(abs)) unlinkSync(abs);
         return {
           path: snap.path,
           status: "applied",
@@ -11369,6 +11620,8 @@ export {
   detectAtPicker,
   rankPickerCandidates,
   expandAtMentions,
+  looksLikeAbsoluteSystemPath,
+  pathIsUnder,
   registerFilesystemTools,
   registerMemoryTools,
   registerChoiceTool,
@@ -11389,4 +11642,4 @@ export {
 he/he.js:
   (*! https://mths.be/he v1.2.0 by @mathias | MIT license *)
 */
-//# sourceMappingURL=chunk-2R4QCDOZ.js.map
+//# sourceMappingURL=chunk-OPFUUYHL.js.map