reasonix 0.46.1 → 0.47.1

package/dist/cli/{chunk-ZOQHVQON.js → chunk-JBH5RM7X.js}

@@ -3,7 +3,7 @@ import { createRequire as __cr } from 'node:module'; if (typeof globalThis.requi
 import {
   MemoryStore,
   sanitizeMemoryName
-} from "./chunk-DHRVZJ2D.js";
+} from "./chunk-BQ6HC66J.js";
 import {
   countTokens,
   countTokensBounded,
@@ -12,23 +12,23 @@ import {
 } from "./chunk-6OWJV3YW.js";
 import {
   Usage
-} from "./chunk-MIIZJD5O.js";
+} from "./chunk-DWPAKZTY.js";
 import {
   applyEdit,
   applyMultiEdit,
   pauseGate
-} from "./chunk-JVFEJAJX.js";
+} from "./chunk-TRSAHHCL.js";
 import {
   NEGATIVE_CLAIM_RULE,
   PROJECT_MEMORY_FILES,
   PROJECT_MEMORY_MAX_CHARS,
   TUI_FORMATTING_RULES,
   memoryEnabled
-} from "./chunk-TEUDEGX2.js";
+} from "./chunk-FY4S7TJZ.js";
 import {
   formatHookOutcomeMessage,
   runHooks
-} from "./chunk-C72TNHDE.js";
+} from "./chunk-GH7DC2Y5.js";
 import {
   ignoredByLayers,
   loadGitignoreAt,
@@ -41,25 +41,26 @@ import {
   loadSessionMeta,
   rewriteSession,
   timestampSuffix
-} from "./chunk-E7TAHQ4A.js";
+} from "./chunk-RRXUIPWG.js";
 import {
   DEEPSEEK_CONTEXT_TOKENS,
   DEFAULT_CONTEXT_TOKENS,
   SessionStats
-} from "./chunk-M4E5JK6S.js";
+} from "./chunk-QCFLPSPH.js";
 import {
   t
-} from "./chunk-6VANO7KB.js";
+} from "./chunk-NRQ5UP5T.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   addProjectPathAllowed,
   loadMemoryTypeRegistry,
   loadMetasoApiKey,
   loadProjectPathAllowed,
+  loadTavilyApiKey,
   require_picomatch,
   webSearchEndpoint,
   webSearchEngine
-} from "./chunk-DGA5QYFM.js";
+} from "./chunk-6CRPCJAU.js";
 import {
   __commonJS,
   __esm,
@@ -6124,11 +6125,42 @@ async function bridgeMcpTools(client, opts = {}) {
   return { ...result, env };
 }
 function flattenMcpResult(result, opts = {}) {
+  validateResultShape(result);
   const parts = result.content.map(blockToString);
   const joined = parts.join("\n").trim();
   const prefixed = result.isError ? `ERROR: ${joined || "(no error message from server)"}` : joined;
   return opts.maxChars ? truncateForModel(prefixed, opts.maxChars) : prefixed;
 }
+function validateResultShape(result) {
+  if (typeof result !== "object" || !result)
+    throw new Error(`MCP server returned non-object result: ${typeof result}`);
+  const { content, isError: _isError } = result;
+  if (!Array.isArray(content))
+    throw new Error(`MCP server returned result with non-array content: ${typeof content}`);
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
+    if (typeof block !== "object" || !block)
+      throw new Error(`MCP server returned result.content[${i}] is not an object`);
+    if (block.type !== "text" && block.type !== "image")
+      throw new Error(
+        `MCP server returned result.content[${i}] with unknown type ${JSON.stringify(block.type)}`
+      );
+    if (block.type === "text" && typeof block.text !== "string")
+      throw new Error(
+        `MCP server returned result.content[${i}] with non-string text (${typeof block.text})`
+      );
+    if (block.type === "image") {
+      if (typeof block.data !== "string")
+        throw new Error(
+          `MCP server returned result.content[${i}] with non-string data (${typeof block.data})`
+        );
+      if (typeof block.mimeType !== "string")
+        throw new Error(
+          `MCP server returned result.content[${i}] with non-string mimeType (${typeof block.mimeType})`
+        );
+    }
+  }
+}
 function truncateForModel(s, maxChars) {
   if (s.length <= maxChars) return s;
   const tailBudget = Math.min(1024, Math.floor(maxChars * 0.1));
@@ -6277,10 +6309,13 @@ var ToolRegistry = class {
   _autoFlatten;
   _planMode = false;
   _interceptor = null;
+  _interceptors = [];
   _auditListener = null;
   _resultAugmenter = null;
   /** Per-tool fingerprint of the last call that failed schema validation. Cleared by any successful validation for that tool. */
   _lastMalformed = /* @__PURE__ */ new Map();
+  /** Per-tool fingerprint of the last host-side interceptor rejection. */
+  _lastInterceptorRejection = /* @__PURE__ */ new Map();
   constructor(opts = {}) {
     this._autoFlatten = opts.autoFlatten !== false;
   }
@@ -6296,6 +6331,18 @@ var ToolRegistry = class {
   setToolInterceptor(fn) {
     this._interceptor = fn;
   }
+  /** Ordered host-side interceptors. They run before the legacy single interceptor. */
+  addToolInterceptor(id, fn) {
+    const normalized = id.trim();
+    if (!normalized) throw new Error("tool interceptor requires a non-empty id");
+    const existing = this._interceptors.findIndex((entry) => entry.id === normalized);
+    if (existing >= 0) this._interceptors.splice(existing, 1);
+    this._interceptors.push({ id: normalized, fn });
+    return () => {
+      const idx = this._interceptors.findIndex((entry) => entry.id === normalized);
+      if (idx >= 0) this._interceptors.splice(idx, 1);
+    };
+  }
   setAuditListener(fn) {
     this._auditListener = fn;
   }
@@ -6384,16 +6431,27 @@ var ToolRegistry = class {
         rejectedReason: "plan-mode"
       });
     }
-    if (this._interceptor) {
+    const chain = this._interceptor ? [...this._interceptors.map((entry) => entry.fn), this._interceptor] : this._interceptors.map((entry) => entry.fn);
+    for (const interceptor of chain) {
       try {
-        const short = await this._interceptor(name, args);
-        if (typeof short === "string") return short;
+        const short = await interceptor(name, args);
+        if (typeof short === "string") {
+          const guarded = this._noteInterceptorRejection(name, fingerprint, short);
+          return this._augmentResult(name, args, guarded);
+        }
       } catch (err) {
         return JSON.stringify({
           error: `${name}: interceptor failed \u2014 ${err.message}`
         });
       }
     }
+    this._lastInterceptorRejection.delete(name);
+    if (opts.signal?.aborted) {
+      return JSON.stringify({
+        error: `${name}: aborted before dispatch (user interrupt)`,
+        rejectedReason: "aborted"
+      });
+    }
     let finalResult;
     try {
       try {
@@ -6425,13 +6483,16 @@ var ToolRegistry = class {
         finalResult = JSON.stringify({ error: `${e.name}: ${e.message}` });
       }
     }
+    return this._augmentResult(name, args, finalResult);
+  }
+  _augmentResult(name, args, result) {
     if (this._resultAugmenter) {
       try {
-        return this._resultAugmenter(name, args, finalResult);
+        return this._resultAugmenter(name, args, result);
       } catch {
       }
     }
-    return finalResult;
+    return result;
   }
   /** Records the failed call's fingerprint; on the 2nd consecutive identical malformed call to the same tool, returns a sharper error that tells the model to stop retrying. */
   _noteMalformed(name, fingerprint, detail) {
@@ -6445,7 +6506,35 @@ var ToolRegistry = class {
     }
     return JSON.stringify({ error: `${name}: ${detail}` });
   }
+  _noteInterceptorRejection(name, fingerprint, result) {
+    const reason = rejectedReason(result);
+    if (!reason) {
+      this._lastInterceptorRejection.delete(name);
+      return result;
+    }
+    const key = `${reason}:${fingerprint}`;
+    const prev = this._lastInterceptorRejection.get(name);
+    this._lastInterceptorRejection.set(name, key);
+    if (prev === key) {
+      return JSON.stringify({
+        error: `${name}: same call was just rejected by ${reason} \u2014 do not retry identical args. Switch to read-only exploration, submit or revise the plan, or choose a different tool call.`,
+        rejectedReason: reason,
+        consecutiveInterceptorRejection: true
+      });
+    }
+    return result;
+  }
 };
+function rejectedReason(result) {
+  try {
+    const parsed = JSON.parse(result);
+    if (!parsed || typeof parsed !== "object") return null;
+    const reason = parsed.rejectedReason;
+    return typeof reason === "string" && reason ? reason : null;
+  } catch {
+    return null;
+  }
+}
 function isReadOnlyCall(tool, args) {
   if (tool.readOnlyCheck) {
     try {
@@ -7877,6 +7966,32 @@ ${reason}`
     }
     return userText;
   }
+  /** Rewind to the N-th user turn (0-indexed). Drops that turn + everything after. */
+  rewindToUserTurn(userTurnIndex) {
+    const entries = this.log.entries;
+    let count = 0;
+    let targetIdx = -1;
+    for (let i = 0; i < entries.length; i++) {
+      if (entries[i].role !== "user") continue;
+      if (count === userTurnIndex) {
+        targetIdx = i;
+        break;
+      }
+      count++;
+    }
+    if (targetIdx < 0) return null;
+    const raw = entries[targetIdx].content;
+    const userText = typeof raw === "string" ? raw : "";
+    const preserved = entries.slice(0, targetIdx).map((m) => ({ ...m }));
+    this.log.compactInPlace(preserved);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, preserved);
+      } catch {
+      }
+    }
+    return userText;
+  }
   async *step(userInput) {
     this._steerConsumed = false;
     if (this.budgetUsd !== null) {
@@ -8934,7 +9049,7 @@ function registerMemoryTools(registry, opts = {}) {
   }
   registry.register({
     name: "remember",
-    description: "Save a memory for future sessions. Use when the user states a preference, corrects your approach, shares a non-obvious fact about this project, or explicitly asks you to remember something. Don't remember transient task state \u2014 only things worth recalling next session. The memory is written now but won't re-load into the system prompt until the next `/new` or launch.",
+    description: "Save a memory for future sessions \u2014 preferences, corrections, non-obvious project facts. Not for transient task state. Loads into the system prompt on next `/new` or launch.",
     parameters: {
       type: "object",
       properties: {
@@ -8945,29 +9060,29 @@ function registerMemoryTools(registry, opts = {}) {
         scope: {
           type: "string",
           enum: ["global", "project"],
-          description: "'global' = applies across every project (preferences, tooling); 'project' = scoped to the current sandbox (decisions, local facts). Only available in `reasonix code`."
+          description: "global = across all projects; project = current sandbox only (needs `reasonix code`)."
         },
         name: {
           type: "string",
-          description: "filename-safe identifier, 3-40 chars, alnum + _ - . (no path separators, no leading dot)."
+          description: "Filename-safe id, 3-40 chars, alnum + _ - . (no separators, no leading dot)."
         },
         description: {
           type: "string",
-          description: "One-line summary shown in MEMORY.md (under ~150 chars)."
+          description: "\u2264150 char one-liner shown in MEMORY.md."
         },
         content: {
           type: "string",
-          description: "Full memory body in markdown. For feedback/project types, structure as: rule/fact, then **Why:** line, then **How to apply:** line."
+          description: "Markdown body. For feedback/project, structure as rule + **Why:** + **How to apply:**."
         },
         priority: {
           type: "string",
           enum: ["low", "medium", "high"],
-          description: "Optional per-memory priority. `high` injects the entry into a `# HIGH PRIORITY constraints` block at the top of the system prompt \u2014 use sparingly, only for hard rules the model must never violate."
+          description: "`high` injects entry into HIGH PRIORITY block \u2014 use sparingly."
         },
         expires: {
           type: "string",
           enum: ["project_end"],
-          description: "Optional lifecycle hint. `project_end` causes `/memory clear project` to also remove this entry even when it's stored at global scope."
+          description: "`project_end` lets /memory clear project remove this even at global scope."
         }
       },
       required: ["type", "scope", "name", "description", "content"]
@@ -9084,26 +9199,26 @@ function sanitizeOptions(raw) {
 function registerChoiceTool(registry, opts = {}) {
   registry.register({
     name: "ask_choice",
-    description: "Present 2\u20136 alternatives to the user. The principle: if the user is supposed to pick, the tool picks \u2014 you don't enumerate the choices as prose. Prose menus have no picker in this TUI, so the user gets a wall of text to scroll through and a letter to type, strictly worse than the magenta picker this tool renders. Call it whenever (a) the user has asked for options, (b) you've analyzed multiple approaches and the final call is theirs, or (c) it's a preference fork you can't resolve without them. Skip it when one option is clearly best (just do it, or submit_plan) or a free-form text answer fits (ask in prose). Keep option ids short and stable (A/B/C). Each option: title + optional summary. allowCustom=true when their real answer might not fit. Max 6 options \u2014 narrow first if more. A one-sentence lead-in before the call is fine; don't repeat the options in it.",
+    description: "Render an arrow-key picker with 2\u20136 alternatives. Use when the user is supposed to pick \u2014 never enumerate choices as prose. Skip when one option is clearly best (just do it) or a free-form text answer fits. Max 6 options; set `allowCustom:true` when their real answer might not fit.",
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         question: {
           type: "string",
-          description: "The question to put in front of the user. One sentence. Don't repeat the options in the question text \u2014 the picker renders them separately."
+          description: "One-sentence question. Don't repeat the options here \u2014 the picker renders them."
         },
         options: {
           type: "array",
-          description: "2\u20134 alternatives. Each needs a stable id and a short title; summary is optional.",
+          description: "2\u20136 alternatives. Each: stable id + short title; summary optional.",
           items: {
             type: "object",
             properties: {
-              id: { type: "string", description: "Short stable id (A, B, C, or option-1)." },
-              title: { type: "string", description: "One-line title shown as the option label." },
+              id: { type: "string", description: "Stable id (A, B, C or option-1)." },
+              title: { type: "string", description: "One-line label." },
               summary: {
                 type: "string",
-                description: "Optional. A second dimmed line with more detail. Keep under ~80 chars."
+                description: "Optional dimmed second line, \u226480 chars."
               }
             },
             required: ["id", "title"]
@@ -9111,7 +9226,7 @@ function registerChoiceTool(registry, opts = {}) {
         },
         allowCustom: {
           type: "boolean",
-          description: "If true, the picker shows a 'Let me type my own answer' escape hatch. Default false. Turn on when the user's real answer might not fit any of your pre-defined options."
+          description: "Shows a 'type my own answer' escape hatch. Default false."
         }
       },
       required: ["question", "options"]
@@ -9157,6 +9272,7 @@ 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";
+var TAVILY_ENDPOINT = "https://api.tavily.com/search";
 function searchStatusError(status) {
   if (status === 429) return t("webErrors.rateLimit429");
   if (status === 403) return t("webErrors.forbidden403");
@@ -9176,6 +9292,9 @@ async function webSearch(query, opts = {}) {
   if (opts.engine === "searxng") {
     return searchSearxng(query, opts);
   }
+  if (opts.engine === "tavily") {
+    return searchTavily(query, opts);
+  }
   return searchMojeek(query, opts);
 }
 async function searchMojeek(query, opts = {}) {
@@ -9310,6 +9429,55 @@ async function searchMetaso(query, opts = {}) {
     snippet: wp.snippet ?? wp.summary ?? ""
   }));
 }
+async function searchTavily(query, opts = {}) {
+  const topK = Math.max(1, Math.min(20, opts.topK ?? DEFAULT_TOPK));
+  const apiKey = loadTavilyApiKey();
+  if (!apiKey) throw new Error(t("webErrors.tavilyMissingKey"));
+  let resp;
+  try {
+    resp = await fetch(TAVILY_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify({
+        api_key: apiKey,
+        query,
+        search_depth: "basic",
+        max_results: topK,
+        include_answer: false,
+        include_raw_content: false,
+        include_images: false
+      }),
+      signal: opts.signal
+    });
+  } catch (err) {
+    if (err instanceof TypeError && err.message.includes("fetch")) {
+      throw new Error(t("webErrors.cannotReach", { endpoint: TAVILY_ENDPOINT }));
+    }
+    throw err;
+  }
+  if (!resp.ok) {
+    if (resp.status === 401 || resp.status === 403) {
+      throw new Error(t("webErrors.tavilyUnauthorized"));
+    }
+    if (resp.status === 429) throw new Error(t("webErrors.tavilyRateLimit"));
+    throw new Error(t("webErrors.tavilyServerError", { status: resp.status }));
+  }
+  let data;
+  try {
+    data = await resp.json();
+  } catch {
+    throw new Error(t("webErrors.tavilyParseError", { status: resp.status }));
+  }
+  const results = data.results ?? [];
+  return results.slice(0, topK).map((r) => ({
+    title: r.title,
+    url: r.url,
+    snippet: r.content ?? ""
+  }));
+}
 function parseSearxngHtmlResults(html) {
   const root = (0, import_node_html_parser.parse)(html);
   const results = [];
@@ -9528,7 +9696,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 /search-engine mojeek|searxng|metaso.",
+    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|tavily.",
     readOnly: true,
     parallelSafe: true,
     parameters: {
@@ -9543,8 +9711,8 @@ function registerWebTools(registry, opts = {}) {
       required: ["query"]
     },
     fn: async (args, ctx) => {
-      const engine = opts.webSearchEngine ?? webSearchEngine();
-      const endpoint = opts.webSearchEndpoint ?? webSearchEndpoint();
+      const engine = webSearchEngine();
+      const endpoint = webSearchEndpoint();
       const results = await webSearch(args.query, {
         topK: args.topK ?? defaultTopK,
         signal: ctx?.signal,
@@ -9600,13 +9768,13 @@ 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) {
+function findDirMemory(absDir, rootDir) {
   const root = resolve2(rootDir);
-  const target = resolve2(absPath);
+  const target = resolve2(absDir);
   const rel = relative2(root, target);
-  if (!rel || rel.startsWith("..")) return [];
+  if (rel.startsWith("..")) return [];
   const found = [];
-  let cur = dirname(target);
+  let cur = target;
   while (cur !== root) {
     const r = relative2(root, cur);
     if (!r || r.startsWith("..")) break;
@@ -9623,6 +9791,9 @@ function findSubdirMemoryAncestors(absPath, rootDir) {
   }
   return found;
 }
+function findSubdirMemoryAncestors(absPath, rootDir) {
+  return findDirMemory(dirname(resolve2(absPath)), rootDir);
+}
 function readSubdirMemoryContent(path) {
   let raw;
   try {
@@ -9891,6 +10062,129 @@ function formatOutline(entries) {
 // src/tools/fs/search.ts
 import { promises as fs2 } from "fs";
 import * as pathMod3 from "path";
+
+// src/tools/fs/regex-runner.ts
+import { Worker } from "worker_threads";
+var WORKER_SOURCE = `
+const { parentPort } = require("node:worker_threads");
+parentPort.on("message", (msg) => {
+  const { id, text, source, flags } = msg;
+  let re;
+  try {
+    re = new RegExp(source, flags);
+  } catch (err) {
+    parentPort.postMessage({ id, error: (err && err.message) ? err.message : String(err) });
+    return;
+  }
+  const lines = text.split(/\\r?\\n/);
+  const hits = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) hits.push(i);
+  }
+  parentPort.postMessage({ id, hits });
+});
+`;
+var DEFAULT_TIMEOUT_MS = 6e4;
+var RegexRunner = class {
+  worker = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  defaultTimeoutMs;
+  constructor(opts = {}) {
+    this.defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  testLines(text, source, flags, opts = {}) {
+    return new Promise((resolve5, reject) => {
+      if (opts.signal?.aborted) {
+        reject(new Error("regex evaluation aborted"));
+        return;
+      }
+      if (!this.worker) this.worker = this.spawn();
+      const id = this.nextId++;
+      const timeoutMs = opts.timeoutMs ?? this.defaultTimeoutMs;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        this.killWorker();
+        reject(new Error(`regex evaluation exceeded ${timeoutMs}ms`));
+      }, timeoutMs);
+      const entry = { resolve: resolve5, reject, timer };
+      if (opts.signal) {
+        entry.signal = opts.signal;
+        entry.onAbort = () => {
+          this.pending.delete(id);
+          clearTimeout(timer);
+          this.killWorker();
+          reject(new Error("regex evaluation aborted"));
+        };
+        opts.signal.addEventListener("abort", entry.onAbort, { once: true });
+      }
+      this.pending.set(id, entry);
+      this.worker.postMessage({ id, text, source, flags });
+    });
+  }
+  async shutdown() {
+    if (this.worker) {
+      const w = this.worker;
+      this.worker = null;
+      await w.terminate();
+    }
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      entry.reject(new Error("regex runner shut down"));
+    }
+    this.pending.clear();
+  }
+  spawn() {
+    const w = new Worker(WORKER_SOURCE, { eval: true });
+    w.on("message", (msg) => {
+      const entry = this.pending.get(msg.id);
+      if (!entry) return;
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      this.pending.delete(msg.id);
+      if (msg.error !== void 0) entry.reject(new Error(msg.error));
+      else entry.resolve(msg.hits ?? []);
+    });
+    w.on("error", (err) => {
+      if (this.worker !== w) return;
+      this.failPending(err);
+    });
+    w.on("exit", () => {
+      if (this.worker !== w) return;
+      this.worker = null;
+      if (this.pending.size > 0) this.failPending(new Error("regex worker exited"));
+    });
+    return w;
+  }
+  killWorker() {
+    if (!this.worker) return;
+    const w = this.worker;
+    this.worker = null;
+    void w.terminate();
+  }
+  failPending(err) {
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+      if (entry.onAbort && entry.signal) {
+        entry.signal.removeEventListener("abort", entry.onAbort);
+      }
+      entry.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+var _runner = null;
+function getRegexRunner() {
+  if (!_runner) _runner = new RegexRunner();
+  return _runner;
+}
+
+// src/tools/fs/search.ts
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
   throw new DOMException("search aborted by user", "AbortError");
@@ -9943,17 +10237,20 @@ async function searchFiles(ctx, startAbs, args) {
 }
 var MAX_HITS_PER_FILE = 30;
 var SUMMARY_MODE_TRIGGER_RATIO = 0.8;
+var WALK_DEADLINE_MS = 12e4;
 async function searchContent(ctx, startAbs, args) {
   throwIfAborted(args.signal);
   const caseSensitive = args.case_sensitive === true;
   const includeDeps = args.include_deps === true;
   const ctxLines = Math.max(0, Math.min(20, Math.floor(args.context ?? 0)));
   const summaryOnly = args.summary_only === true;
-  let re = null;
+  const reFlags = caseSensitive ? "" : "i";
+  let reSource = null;
   try {
-    re = new RegExp(args.pattern, caseSensitive ? "" : "i");
+    new RegExp(args.pattern, reFlags);
+    reSource = args.pattern;
   } catch {
-    re = null;
+    reSource = null;
   }
   const needle = caseSensitive ? args.pattern : args.pattern.toLowerCase();
   const matches = [];
@@ -9963,6 +10260,15 @@ async function searchContent(ctx, startAbs, args) {
   let summaryMode = summaryOnly;
   let summaryNoticeEmitted = false;
   const fileHitCounts = /* @__PURE__ */ new Map();
+  const regexSkippedFiles = [];
+  const t0 = Date.now();
+  const throwIfTimedOut = () => {
+    if (Date.now() - t0 > WALK_DEADLINE_MS) {
+      throw new Error(
+        `search_content exceeded ${WALK_DEADLINE_MS}ms \u2014 narrow the scope (path/glob) or simplify the pattern`
+      );
+    }
+  };
   const pushLine = (out) => {
     if (totalBytes + out.length + 1 > ctx.maxListBytes) {
       matches.push(`[\u2026 truncated at ${ctx.maxListBytes} bytes \u2014 refine pattern or path \u2026]`);
@@ -9997,6 +10303,7 @@ async function searchContent(ctx, startAbs, args) {
     for (const e of entries) {
       if (truncated) return;
       throwIfAborted(args.signal);
+      throwIfTimedOut();
       if (e.isDirectory()) {
         if (!includeDeps && ctx.skipDirNames.has(e.name)) continue;
         await walk2(pathMod3.join(dir, e.name));
@@ -10033,13 +10340,25 @@ async function searchContent(ctx, startAbs, args) {
       const text = raw.toString("utf8");
       const rel = displayRel2(ctx.rootDir, full);
       const lines = text.split(/\r?\n/);
-      const hits = [];
-      for (let li = 0; li < lines.length; li++) {
-        throwIfAborted(args.signal);
-        const line = lines[li];
-        const lineForCheck = caseSensitive ? line : line.toLowerCase();
-        const hit = re ? re.test(line) : lineForCheck.includes(needle);
-        if (hit) hits.push(li);
+      let hits;
+      if (reSource !== null) {
+        try {
+          hits = await getRegexRunner().testLines(text, reSource, reFlags, {
+            signal: args.signal
+          });
+        } catch (err) {
+          const reason = err.message;
+          if (reason.includes("aborted")) throw err;
+          regexSkippedFiles.push({ rel, reason });
+          continue;
+        }
+      } else {
+        hits = [];
+        for (let li = 0; li < lines.length; li++) {
+          throwIfAborted(args.signal);
+          const lineForCheck = caseSensitive ? lines[li] : lines[li].toLowerCase();
+          if (lineForCheck.includes(needle)) hits.push(li);
+        }
       }
       scanned++;
       if (hits.length === 0) continue;
@@ -10088,6 +10407,11 @@ async function searchContent(ctx, startAbs, args) {
     }
   };
   await walk2(startAbs);
+  if (regexSkippedFiles.length > 0) {
+    pushLine(
+      `[regex timed out on ${regexSkippedFiles.length} file${regexSkippedFiles.length === 1 ? "" : "s"} \u2014 pattern may have catastrophic backtracking; first: ${regexSkippedFiles[0].rel}]`
+    );
+  }
   if (matches.length === 0) {
     return scanned === 0 ? "(no files scanned \u2014 path empty or all files filtered out)" : `(no matches across ${scanned} file${scanned === 1 ? "" : "s"})`;
   }
@@ -10095,7 +10419,7 @@ async function searchContent(ctx, startAbs, args) {
 }
 
 // src/tools/filesystem.ts
-var DEFAULT_OUTLINE_THRESHOLD_BYTES = 512 * 1024;
+var DEFAULT_OUTLINE_THRESHOLD_BYTES = 64 * 1024;
 var DEFAULT_MAX_LIST_BYTES = 256 * 1024;
 var HARD_MAX_FILE_BYTES = 32 * 1024 * 1024;
 var OUTLINE_HEAD_LINES = 80;
@@ -10152,11 +10476,15 @@ function registerFilesystemTools(registry, opts) {
   const sessionApproved = /* @__PURE__ */ new Set();
   const shownSubdirMemory = /* @__PURE__ */ new Set();
   function withSubdirMemory(absPath, body) {
-    if (!memoryEnabled()) return body;
-    const ancestors = findSubdirMemoryAncestors(absPath, rootDir);
-    if (ancestors.length === 0) return body;
+    return prependMemorySections(findSubdirMemoryAncestors(absPath, rootDir), body);
+  }
+  function withDirMemory(absDir, body) {
+    return prependMemorySections(findDirMemory(absDir, rootDir), body);
+  }
+  function prependMemorySections(memPaths, body) {
+    if (!memoryEnabled() || memPaths.length === 0) return body;
     const sections = [];
-    for (const memPath of [...ancestors].reverse()) {
+    for (const memPath of [...memPaths].reverse()) {
       if (shownSubdirMemory.has(memPath)) continue;
       const content = readSubdirMemoryContent(memPath);
       if (!content) continue;
@@ -10233,11 +10561,7 @@ ${body}`;
   registry.register({
     name: "read_file",
     parallelSafe: true,
-    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.`,
+    description: `Read a file under the sandbox root. Default returns FULL CONTENT for files \u2264 ${Math.round(DEFAULT_OUTLINE_THRESHOLD_BYTES / 1024)} KiB. Optional scoping: head/tail (N lines), range "A-B" (1-indexed inclusive). Larger files auto-switch to outline mode (metadata + head + symbol outline for TS/JS/Python/Go/Rust/Markdown/Protobuf/text) \u2014 drill in with range or search_content. Files over ${Math.round(HARD_MAX_FILE_BYTES / (1024 * 1024))} MiB and binaries are refused \u2014 use get_file_info for stat.`,
     readOnly: true,
     stormExempt: true,
     parameters: {
@@ -10349,17 +10673,13 @@ ${slice.join("\n")}`);
       for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         lines.push(e.isDirectory() ? `${e.name}/` : e.name);
       }
-      return lines.join("\n") || "(empty directory)";
+      return withDirMemory(abs, lines.join("\n") || "(empty directory)");
     }
   });
   registry.register({
     name: "directory_tree",
     parallelSafe: true,
-    description: `Recursively list entries in a directory. Shows indented tree structure with directories marked '/'. Budget-aware by default:
-  - maxDepth defaults to 2 (root + one level). A depth-4 tree on a real repo blew ~5K tokens in one call. If you truly need deeper, pass maxDepth:N explicitly.
-  - Skips ${[...SKIP_DIR_NAMES].sort().join(", ")} unless include_deps:true. Traversing into node_modules / .git / dist is almost always token-waste.
-  - Large subtrees (>50 children) auto-collapse to "[N files, M dirs hidden \u2014 list_directory <path> to inspect]" so one huge folder can't dominate the output.
-Prefer \`list_directory\` for a single-level view, \`search_files\` to find specific paths, and \`search_content\` to find code.`,
+    description: `Recursively list entries with indented tree structure (dirs marked '/'). Budget-aware: maxDepth defaults to 2, large subtrees (>50 children) auto-collapse to "[N hidden \u2014 list_directory to inspect]", and ${[...SKIP_DIR_NAMES].sort().join(" / ")} are skipped unless include_deps:true. For single-level use list_directory; for path lookups use search_files; for code lookups use search_content.`,
     readOnly: true,
     parameters: {
       type: "object",
@@ -10460,38 +10780,38 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   registry.register({
     name: "search_content",
     parallelSafe: true,
-    description: "Recursively grep file CONTENTS for a substring or regex. This is the right tool for 'find all places that call X', 'where is Y referenced', 'what files contain Z'. Different from search_files (which matches FILE NAMES). Returns one match per line in 'path:line: text' format. Per-file hits are capped at 30 (a footer reports any extras); when the byte budget is mostly spent the remaining files switch to a 'rel: N matches' histogram so distribution stays visible instead of one popular file drowning the rest. Pass `summary_only:true` to skip line content entirely and get just the histogram. Skips dependency / VCS / build directories (node_modules, .git, dist, build, .next, target, .venv) and binary files by default.",
+    description: "Recursively grep file CONTENTS for a substring or regex \u2014 'where is X called', 'what files contain Y'. Returns one match per line as `path:line: text`. Per-file hit cap 30; when the byte budget is mostly spent, remaining files switch to a `rel: N matches` histogram. Pass `summary_only:true` for just the histogram. Skips dependency / VCS / build dirs and binary files. For file NAMES use search_files.",
     readOnly: true,
     parameters: {
       type: "object",
       properties: {
         pattern: {
           type: "string",
-          description: "Substring (or regex) to search file contents for."
+          description: "Substring or regex."
         },
         path: {
           type: "string",
-          description: "Directory to start the search at (default: sandbox root)."
+          description: "Search root (default: sandbox root)."
         },
         glob: {
           type: "string",
-          description: "Optional filename filter. Real glob when the value contains `*`, `?`, `{`, or `[` \u2014 e.g. '*.ts', '**/*.tsx', 'src/**/*.{ts,tsx}'. Plain substring otherwise \u2014 e.g. '.ts' (suffix), 'test' (anywhere in the name). Patterns containing `/` match against the path relative to the search root; otherwise just the basename."
+          description: "Filename filter. Glob when it contains `*`/`?`/`{`/`[`; otherwise substring. Patterns with `/` match the path relative to the search root."
         },
         case_sensitive: {
           type: "boolean",
-          description: "When true, match case exactly. Default false (case-insensitive)."
+          description: "Default false."
         },
         include_deps: {
           type: "boolean",
-          description: "When true, also search inside node_modules / .git / dist / build / etc. Off by default \u2014 most exploration questions are about the user's own code."
+          description: "Also search node_modules / .git / dist / build / etc. Default off."
         },
         context: {
           type: "integer",
-          description: "Lines of context to show around each match (both before and after). Default 0 (just the matching line). Capped at 20. Output uses ripgrep style: `:` after the line number on the matching line, `-` on context lines, `--` separating non-adjacent windows."
+          description: "Lines of context around each match (both sides). Default 0, capped 20. Ripgrep-style output."
         },
         summary_only: {
           type: "boolean",
-          description: "When true, skip line content and return one 'rel: N matches' line per matching file. Use for 'where does this exist at all' questions before drilling in with a targeted read_file."
+          description: "Skip line content, return `rel: N matches` per file. Use for 'where does this exist at all' before drilling in."
         }
       },
       required: ["pattern"]
@@ -10604,7 +10924,7 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
   });
   registry.register({
     name: "multi_edit",
-    description: "Apply N SEARCH/REPLACE edits across ONE OR MORE files in a single atomic call. Edits run sequentially in array order; for edits that touch the same file, a later edit can match text inserted by an earlier one. If ANY edit fails (search not found, ambiguous match, empty search, file unreadable), NO files are written \u2014 atomic at the validation layer. Same per-edit rules as edit_file: `search` is exact text (whitespace sensitive, no regex) and must be unique in its target file at the moment that edit applies. Use this for renames spanning multiple files, cross-file refactors, or any batch where you'd otherwise loop edit_file.",
+    description: "Apply N SEARCH/REPLACE edits across ONE OR MORE files in one call. Edits validate across the full batch before writing. Validation failures leave all files untouched; disk write failures trigger best-effort rollback of files that may have been modified. Per-file edits run in array order, so a later edit can match text inserted by an earlier one. Same per-edit rules as edit_file: `search` is exact text (whitespace sensitive, no regex) and must be unique in its target file at the moment that edit applies. Use this for renames spanning multiple files, cross-file refactors, or any batch where you'd otherwise loop edit_file.",
     parameters: {
       type: "object",
       properties: {
@@ -10746,19 +11066,33 @@ Prefer \`list_directory\` for a single-level view, \`search_files\` to find spec
 }
 
 // src/tools/plan-core.ts
-var SUBMIT_PLAN_DESCRIPTION = "Submit ONE concrete plan you've already decided on. Use this for tasks that warrant a review gate \u2014 multi-file refactors, architecture changes, anything that would be expensive or confusing to undo. Skip it for small fixes (one-line typo, obvious bug with a clear fix) \u2014 just make the change. The user will either approve (you then implement it), ask for refinement, or cancel. If the user has already enabled /plan mode, writes are blocked at dispatch and you MUST use this. CRITICAL: do NOT use submit_plan to present alternative routes (A/B/C, option 1/2/3) for the user to pick from \u2014 the picker only exposes approve/refine/cancel, so a menu plan strands the user with no way to choose. For branching decisions, call `ask_choice` instead; only call submit_plan once the user has picked a direction and you have a single actionable plan. Write the plan as markdown with a one-line summary, a bulleted list of files to touch and what will change, and any risks or open questions. STRONGLY PREFERRED: pass `steps` \u2014 an array of {id, title, action, risk?} \u2014 so the UI renders a structured step list above the approval picker and tracks per-step progress. Use risk='high' for steps that touch prod data / break public APIs / are hard to undo; 'med' for non-trivial but reversible (multi-file edits, schema tweaks); 'low' for safe local work. After each step, call `mark_step_complete` so the user sees progress ticks.";
-var MARK_STEP_COMPLETE_DESCRIPTION = "Mark one step of the approved plan as done. MANDATORY: call this exactly once after finishing each step, before starting the next one \u2014 skipping it leaves the user staring at `0/N done` on the resume banner even when the work is finished, and they have no way to know which steps actually ran. The TUI updates the plan card's progress in place; the count is persisted to disk so it survives session resume. After the FINAL step, write a brief reply summarizing what was done and end the turn. Pass the `stepId` from the plan's steps array, a short `result` (what you did), and optional `notes` for anything surprising (errors, scope changes, follow-ups). This tool doesn't change any files. Don't call it if the plan didn't include structured steps, and don't invent ids that weren't in the original plan. If you only realized at the end that you skipped marking steps, mark them then \u2014 late is still better than never.";
-var REVISE_PLAN_DESCRIPTION = "Surgically replace the REMAINING steps of an in-flight plan. Call this when the user has given feedback at a checkpoint that warrants a structured plan change \u2014 skip a step, swap two steps, add a new step, change risk, etc. Pass: `reason` (one sentence why), `remainingSteps` (the new tail of the plan, replacing whatever steps haven't been done yet), and optional `summary` (updated one-line plan summary). Done steps are NEVER touched \u2014 keep them out of `remainingSteps`. The TUI shows a diff (removed in red, kept in gray, added in green) and the user accepts or rejects. Don't call this for trivial mid-step adjustments \u2014 just keep executing. Don't call submit_plan for revisions either \u2014 that resets the whole plan including completed steps. Use submit_plan only when the entire approach has changed; use revise_plan when the tail needs editing.";
+var SUBMIT_PLAN_DESCRIPTION = "Submit ONE concrete plan for review. The user approves / refines / cancels \u2014 write a markdown plan body and (strongly preferred) a structured `steps` array. Use for multi-file refactors, architecture changes, anything expensive to undo. Skip for small fixes. Do NOT use for A/B/C menus \u2014 the picker has no branch selector, so a menu plan strands the user; call `ask_choice` for branching decisions. See the system prompt for fuller guidance.";
+var MARK_STEP_COMPLETE_DESCRIPTION = "Mark one approved-plan step as done. Call exactly once after finishing each step, before starting the next. After the FINAL step, write a brief reply summarizing what was done and end the turn. Skip if the plan didn't include structured steps.";
+var REVISE_PLAN_DESCRIPTION = "Replace the REMAINING steps of an in-flight plan when checkpoint feedback warrants a structural change. Pass `reason`, the new `remainingSteps` tail (done steps are untouched \u2014 keep them out), and optional updated `summary`. Don't call submit_plan for revisions \u2014 it resets the whole plan.";
 var STEP_ITEM_SCHEMA = {
   type: "object",
   properties: {
     id: { type: "string", description: "Stable id, e.g. step-1." },
     title: { type: "string", description: "Short imperative title." },
-    action: { type: "string", description: "One-sentence description of the concrete action." },
+    action: { type: "string", description: "One-sentence concrete action." },
     risk: {
       type: "string",
       enum: ["low", "med", "high"],
-      description: "Self-assessed risk. 'high' = hard-to-undo / touches prod / breaks API; 'med' = non-trivial but reversible; 'low' = safe local work. The UI shows a colored dot per step so the user knows where to focus review. Omit if you're unsure."
+      description: "high = hard-to-undo / prod / API break; med = reversible multi-file; low = safe local. Omit if unsure."
+    },
+    targets: {
+      type: "array",
+      description: "Optional. Files/dirs/modules this step touches.",
+      items: { type: "string" }
+    },
+    acceptance: {
+      type: "string",
+      description: "Optional. One-sentence completion criterion."
+    },
+    verification: {
+      type: "array",
+      description: "Optional. Verification commands/checks for this step.",
+      items: { type: "string" }
     }
   },
   required: ["id", "title", "action"]
@@ -10780,10 +11114,42 @@ function sanitizeSteps(raw) {
     const step = { id, title, action };
     const risk = sanitizeRisk(e.risk);
     if (risk) step.risk = risk;
+    const targets = sanitizeStringList(e.targets);
+    if (targets) step.targets = targets;
+    const acceptance = typeof e.acceptance === "string" ? e.acceptance.trim() : "";
+    if (acceptance) step.acceptance = acceptance;
+    const verification = sanitizeStringList(e.verification);
+    if (verification) step.verification = verification;
     steps.push(step);
   }
   return steps.length > 0 ? steps : void 0;
 }
+function sanitizeStringList(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = raw.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+  return out.length > 0 ? out : void 0;
+}
+function sanitizeEvidence(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const e = item;
+    const kind = e.kind;
+    if (kind !== "verification" && kind !== "diff" && kind !== "checkpoint" && kind !== "manual") {
+      continue;
+    }
+    const summary = typeof e.summary === "string" ? e.summary.trim() : "";
+    if (!summary) continue;
+    const evidence = { kind, summary };
+    const command = typeof e.command === "string" ? e.command.trim() : "";
+    if (command) evidence.command = command;
+    const paths = sanitizeStringList(e.paths);
+    if (paths) evidence.paths = paths;
+    out.push(evidence);
+  }
+  return out.length > 0 ? out : void 0;
+}
 function registerSubmitPlan(registry, opts) {
   registry.register({
     name: "submit_plan",
@@ -10794,16 +11160,16 @@ function registerSubmitPlan(registry, opts) {
       properties: {
         plan: {
           type: "string",
-          description: "Markdown-formatted plan. Lead with a one-sentence summary. Then a file-by-file breakdown of what you'll change and why. Flag any risks or open questions at the end so the user can weigh in before you start."
+          description: "Markdown plan: one-line summary, file-by-file breakdown, risks/open questions."
         },
         steps: {
           type: "array",
-          description: "Structured step list (strongly recommended). When provided, the UI renders a compact step list above the approval picker AND tracks per-step progress via `mark_step_complete`. Use stable ids (step-1, step-2, ...). Skip only for tiny one-step plans where the markdown body is enough.",
+          description: "Structured step list \u2014 strongly recommended for >1 step. Stable ids (step-1, step-2, ...).",
           items: STEP_ITEM_SCHEMA
         },
         summary: {
           type: "string",
-          description: "Optional. One-sentence human-friendly title for the plan, ~80 chars max. Surfaces in the PlanConfirm picker header and in /plans listings ('\u25B8 refactor auth into signed tokens \xB7 2/5 done'). Skip for trivial plans where the first line of the markdown body is already short and clear."
+          description: "Optional ~80-char plan title for the picker header and /plans listings."
         }
       },
       required: ["plan"]
@@ -10841,19 +11207,33 @@ function registerMarkStepComplete(registry, opts) {
       properties: {
         stepId: {
           type: "string",
-          description: "The id of the step being marked complete. Must match one from submit_plan's steps array."
+          description: "Step id from submit_plan's steps array."
         },
         title: {
           type: "string",
-          description: "Optional. The step's title, echoed back for the UI. If omitted, the UI falls back to the id."
+          description: "Optional. Echoed for the UI; falls back to id."
         },
         result: {
           type: "string",
-          description: "One-sentence summary of what was done for this step."
+          description: "One-sentence summary of what was done."
         },
         notes: {
           type: "string",
-          description: "Optional. Anything surprising \u2014 blockers hit, assumptions revised, follow-ups for later steps."
+          description: "Optional. Surprises \u2014 blockers, revised assumptions, follow-ups."
+        },
+        evidence: {
+          type: "array",
+          description: "Optional. Verification summary / diff / checkpoint ref / manual note.",
+          items: {
+            type: "object",
+            properties: {
+              kind: { type: "string", enum: ["verification", "diff", "checkpoint", "manual"] },
+              summary: { type: "string" },
+              command: { type: "string" },
+              paths: { type: "array", items: { type: "string" } }
+            },
+            required: ["kind", "summary"]
+          }
         }
       },
       required: ["stepId", "result"]
@@ -10871,9 +11251,15 @@ function registerMarkStepComplete(registry, opts) {
       }
       const title = typeof args?.title === "string" ? args.title.trim() || void 0 : void 0;
       const notes = typeof args?.notes === "string" ? args.notes.trim() || void 0 : void 0;
+      const evidence = sanitizeEvidence(args?.evidence);
+      const evidenceReason = opts.requireStepEvidence?.({ stepId, title });
+      if (evidenceReason && (!evidence || evidence.length === 0)) {
+        throw new Error(`mark_step_complete: evidence required \u2014 ${evidenceReason}`);
+      }
       const update = { kind: "step_completed", stepId, result };
       if (title) update.title = title;
       if (notes) update.notes = notes;
+      if (evidence) update.evidence = evidence;
       opts.onStepCompleted?.(update);
       const verdict = await (ctx?.confirmationGate ?? pauseGate).ask({
         kind: "plan_checkpoint",
@@ -10898,16 +11284,16 @@ function registerRevisePlan(registry, opts) {
       properties: {
         reason: {
           type: "string",
-          description: "One sentence explaining why you're revising \u2014 what the user asked for, what changed your assessment."
+          description: "One sentence \u2014 why you're revising / what the user asked for."
         },
         remainingSteps: {
           type: "array",
-          description: "The new tail of the plan \u2014 what should run from here on. Each entry: {id, title, action, risk?}. Use stable ids; reuse old ids when a step is just being adjusted, generate new ones for genuinely new steps.",
+          description: "New tail of the plan. Reuse old ids when adjusting; new ids for new steps.",
           items: STEP_ITEM_SCHEMA
         },
         summary: {
           type: "string",
-          description: "Optional. Updated one-line plan summary if the overall framing has shifted."
+          description: "Optional. Updated one-line summary when framing has shifted."
         }
       },
       required: ["reason", "remainingSteps"]
@@ -10945,7 +11331,7 @@ function registerPlanTool(registry, opts = {}) {
 }
 
 // src/tools/todo.ts
-var DESCRIPTION = 'In-session task tracker for multi-step work. NOT a plan \u2014 no approval gate, no checkpoint pauses, doesn\'t touch any files. The tool replaces the entire todo list every call (set semantics, NOT append). Pass the FULL list every time.\n\nWhen to use:\n\u2022 The task has 3+ distinct steps and you want to keep them straight as you work.\n\u2022 The user gave you a multi-part request ("do A, then B, then C").\n\u2022 You\'re partway through a long task and want to record where you are so a future you doesn\'t lose the thread.\n\nWhen NOT to use:\n\u2022 One-shot edits, single-question answers, single-tool tasks.\n\u2022 User-facing approval gates \u2192 that\'s `submit_plan`.\n\u2022 Branching choices \u2192 that\'s `ask_choice`.\n\nRules:\n\u2022 Exactly ONE todo may have status:"in_progress" at a time (or zero \u2014 between steps).\n\u2022 Mark a todo "completed" the moment it\'s actually done \u2014 don\'t batch.\n\u2022 Each todo: `content` (imperative, e.g. "Add tests"), `activeForm` (gerund shown while running, e.g. "Adding tests"), `status`.\n\u2022 Empty `todos:[]` is allowed \u2014 it clears the list when work is fully done.';
+var DESCRIPTION = "In-session task tracker for 3+ step work. NOT a plan \u2014 no approval gate, no checkpoint, no files touched. Each call REPLACES the entire list (set semantics) \u2014 pass the FULL list. Exactly one item may be in_progress at a time; flip to completed the moment that step's done. Pass `[]` to clear. For approval gates use submit_plan; for branching choices use ask_choice.";
 function validateTodos(raw) {
   if (!Array.isArray(raw)) {
     throw new Error("todo_write: `todos` must be an array");
@@ -11571,4 +11957,4 @@ export {
 he/he.js:
   (*! https://mths.be/he v1.2.0 by @mathias | MIT license *)
 */
-//# sourceMappingURL=chunk-ZOQHVQON.js.map
+//# sourceMappingURL=chunk-JBH5RM7X.js.map