@namzu/cli 37.0.1 → 37.1.0

package/dist/chunks/{chunk-FLUVTAXY.js → chunk-HMORKNX3.js}

@@ -12568,17 +12568,17 @@ var SessionLogChain = class {
   /** Verify one complete line (newline included) found at `offset`. */
   accept(line, offset) {
     const expectedSeq = (this.#head?.seq ?? 0) + 1;
-    const fail = /* @__PURE__ */ __name((reason2, message, cause) => {
+    const fail2 = /* @__PURE__ */ __name((reason2, message, cause) => {
       throw new SessionLogIntegrityError(reason2, expectedSeq, offset, `Session log breaks at seq ${expectedSeq} (byte ${offset}): ${message}`, cause === void 0 ? void 0 : { cause });
     }, "fail");
     if (offset !== this.end) {
-      fail("seq-gap", `the line starts at byte ${offset}, not at ${this.end} where the last one ended`);
+      fail2("seq-gap", `the line starts at byte ${offset}, not at ${this.end} where the last one ended`);
     }
     let parsed;
     try {
       parsed = parseSessionLogLine(line);
     } catch (error) {
-      return fail("not-a-record", error instanceof SessionLogLineError ? error.message : String(error), error);
+      return fail2("not-a-record", error instanceof SessionLogLineError ? error.message : String(error), error);
     }
     const { record: record3 } = parsed;
     const pointer2 = {
@@ -12589,35 +12589,35 @@ var SessionLogChain = class {
     };
     if (this.#head === null) {
       if (offset !== 0 || record3.seq !== 1 || record3.type !== "session_started") {
-        fail("bad-start", "a session log starts with session_started at seq 1, offset 0");
+        fail2("bad-start", "a session log starts with session_started at seq 1, offset 0");
       }
     } else {
       if (record3.seq !== expectedSeq)
-        fail("seq-gap", `the record says seq ${record3.seq}`);
+        fail2("seq-gap", `the record says seq ${record3.seq}`);
       if (!samePointer(record3.prev, this.#head)) {
-        fail("prev-mismatch", "its prev pointer does not name the bytes of the record before it (that record, or this pointer, was altered)");
+        fail2("prev-mismatch", "its prev pointer does not name the bytes of the record before it (that record, or this pointer, was altered)");
       }
     }
     if (this.#sessionId !== void 0 && record3.sessionId !== this.#sessionId) {
-      fail("session-mismatch", `the record names session ${record3.sessionId}, not ${this.#sessionId}`);
+      fail2("session-mismatch", `the record names session ${record3.sessionId}, not ${this.#sessionId}`);
     }
     if (record3.gen < this.#gen) {
-      fail("gen-regressed", `gen ${record3.gen} follows gen ${this.#gen}: a writer whose lease had been superseded appended after its successor`);
+      fail2("gen-regressed", `gen ${record3.gen} follows gen ${this.#gen}: a writer whose lease had been superseded appended after its successor`);
     }
-    checkTextLink(record3, pointer2, fail);
+    checkTextLink(record3, pointer2, fail2);
     this.#head = pointer2;
     this.#sessionId ??= record3.sessionId;
     this.#gen = record3.gen;
     return { record: record3, pointer: pointer2 };
   }
 };
-function checkTextLink(record3, pointer2, fail) {
+function checkTextLink(record3, pointer2, fail2) {
   if (!Object.hasOwn(record3, "prevText"))
     return;
   const next = record3.prevText ?? null;
   const previous = record3.prev;
   if (next === null && previous !== null || next !== null && (previous === null || next.seq >= pointer2.seq || next.offset + next.length > pointer2.offset || next.seq === previous.seq && !samePointer(next, previous))) {
-    fail("bad-text-link", "its prevText skip link does not name an earlier record");
+    fail2("bad-text-link", "its prevText skip link does not name an earlier record");
   }
 }
 __name(checkTextLink, "checkTextLink");
@@ -12703,8 +12703,8 @@ var EvidencePageLimit = class extends Error {
     __name(this, "EvidencePageLimit");
   }
 };
-function stamp2(stat14) {
-  return [stat14.dev, stat14.ino, stat14.size, stat14.mtimeMs, stat14.ctimeMs].join(":");
+function stamp2(stat15) {
+  return [stat15.dev, stat15.ino, stat15.size, stat15.mtimeMs, stat15.ctimeMs].join(":");
 }
 __name(stamp2, "stamp");
 async function noLinks(path2) {
@@ -13689,7 +13689,7 @@ async function* walkSessionLog(medium, options) {
   let chain;
   let start = 0;
   let brokeAt;
-  const fail = /* @__PURE__ */ __name((error) => {
+  const fail2 = /* @__PURE__ */ __name((error) => {
     if (strict)
       throw error;
     brokeAt = error;
@@ -13698,7 +13698,7 @@ async function* walkSessionLog(medium, options) {
     const after = options.after;
     if (!await verifyPointer(medium, after)) {
       const error = new SessionLogIntegrityError("anchor-mismatch", after.seq, after.offset, `The log does not hold the record the cursor names (seq ${after.seq} at byte ${after.offset}).`);
-      fail(error);
+      fail2(error);
       return { intact: false, throughSeq: 0, head: null, tornBytes: 0, break: error };
     }
     const parsed = parseSessionLogLine(await medium.read(after.offset, after.length));
@@ -13725,7 +13725,7 @@ async function* walkSessionLog(medium, options) {
         } catch (error) {
           if (!(error instanceof SessionLogIntegrityError))
             throw error;
-          fail(error);
+          fail2(error);
           stopped = true;
           break outer;
         }
@@ -13733,7 +13733,7 @@ async function* walkSessionLog(medium, options) {
           anchorSeen = true;
           const e = options.expectHead;
           if (e.offset !== entry.pointer.offset || e.length !== entry.pointer.length || e.sha256 !== entry.pointer.sha256) {
-            fail(new SessionLogIntegrityError("anchor-mismatch", e.seq, entry.pointer.offset, `The record at seq ${e.seq} is not the one the anchor names; the log was altered.`));
+            fail2(new SessionLogIntegrityError("anchor-mismatch", e.seq, entry.pointer.offset, `The record at seq ${e.seq} is not the one the anchor names; the log was altered.`));
             stopped = true;
             break outer;
           }
@@ -13747,14 +13747,14 @@ async function* walkSessionLog(medium, options) {
     } catch (error) {
       if (!(error instanceof SessionLogIntegrityError))
         throw error;
-      fail(error);
+      fail2(error);
       stopped = true;
       break;
     }
   }
   if (!stopped && options.expectHead !== void 0 && !anchorSeen && brokeAt === void 0) {
     const e = options.expectHead;
-    fail(new SessionLogIntegrityError("anchor-mismatch", e.seq, chain.end, `The log ends at seq ${chain.head?.seq ?? 0}, before the anchored seq ${e.seq}; it was truncated.`));
+    fail2(new SessionLogIntegrityError("anchor-mismatch", e.seq, chain.end, `The log ends at seq ${chain.head?.seq ?? 0}, before the anchored seq ${e.seq}; it was truncated.`));
   }
   const pointer2 = chain.head;
   return {
@@ -18010,8 +18010,8 @@ var DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE = 2e5;
 var MESSAGE_BUDGET_PREVIEW_CHARS = 2e3;
 var SPILL_MARKER = "The full output was written to:";
 var HEAD_SHARE = 0.75;
-function safeHead(text9, maxChars) {
-  let end = Math.min(text9.length, Math.max(0, maxChars));
+function safeHead(text9, maxChars2) {
+  let end = Math.min(text9.length, Math.max(0, maxChars2));
   if (end > 0) {
     const last = text9.charCodeAt(end - 1);
     if (last >= 55296 && last <= 56319)
@@ -18020,8 +18020,8 @@ function safeHead(text9, maxChars) {
   return text9.slice(0, end);
 }
 __name(safeHead, "safeHead");
-function safeTail(text9, maxChars) {
-  let start = Math.max(0, text9.length - Math.max(0, maxChars));
+function safeTail(text9, maxChars2) {
+  let start = Math.max(0, text9.length - Math.max(0, maxChars2));
   if (start < text9.length) {
     const first = text9.charCodeAt(start);
     if (first >= 56320 && first <= 57343)
@@ -18030,10 +18030,10 @@ function safeTail(text9, maxChars) {
   return text9.slice(start);
 }
 __name(safeTail, "safeTail");
-function boundedPreview(output, maxChars, toolName, recovery) {
+function boundedPreview(output, maxChars2, toolName, recovery) {
   const detailedMiddle = [
     "",
-    `[... characters omitted \u2014 "${toolName}" returned ${output.length.toLocaleString()} characters, over the ${maxChars.toLocaleString()}-character budget ...]`,
+    `[... characters omitted \u2014 "${toolName}" returned ${output.length.toLocaleString()} characters, over the ${maxChars2.toLocaleString()}-character budget ...]`,
     recovery,
     ""
   ].join("\n");
@@ -18041,10 +18041,10 @@ function boundedPreview(output, maxChars, toolName, recovery) {
   const spillLine = recovery.split("\n").find((line) => line.startsWith(SPILL_MARKER));
   const compactRecovery = spillLine ? `${compactMiddle}${spillLine}
 ` : compactMiddle;
-  const middle = detailedMiddle.length < maxChars ? detailedMiddle : compactRecovery.length < maxChars ? compactRecovery : compactMiddle;
-  if (middle.length >= maxChars)
-    return safeHead(middle, maxChars);
-  const sourceChars = maxChars - middle.length;
+  const middle = detailedMiddle.length < maxChars2 ? detailedMiddle : compactRecovery.length < maxChars2 ? compactRecovery : compactMiddle;
+  if (middle.length >= maxChars2)
+    return safeHead(middle, maxChars2);
+  const sourceChars = maxChars2 - middle.length;
   const headChars = Math.max(1, Math.floor(sourceChars * HEAD_SHARE));
   const tailChars = Math.max(0, sourceChars - headChars);
   return `${safeHead(output, headChars)}${middle}${safeTail(output, tailChars)}`;
@@ -18078,9 +18078,9 @@ function measureContentBytes(content) {
 }
 __name(measureContentBytes, "measureContentBytes");
 function applyToolOutputBudget(opts) {
-  const { output, maxChars } = opts;
+  const { output, maxChars: maxChars2 } = opts;
   const originalLength = output.length;
-  const limit = Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : void 0;
+  const limit = Number.isFinite(maxChars2) && maxChars2 > 0 ? Math.floor(maxChars2) : void 0;
   const notice = opts.notice ? limit === void 0 ? opts.notice : safeHead(opts.notice, limit) : "";
   const textBudget = limit === void 0 ? void 0 : Math.max(0, limit - notice.length - (notice && output ? 2 : 0));
   const withNotice = /* @__PURE__ */ __name((text9) => [text9, notice].filter(Boolean).join("\n\n"), "withNotice");
@@ -45782,7 +45782,7 @@ var ToolExecutor = class {
    * messages, so what it writes is what every later request replays.
    */
   fitBatchToMessageBudget(results) {
-    const maxChars = this.config.maxToolOutputCharsPerMessage ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE;
+    const maxChars2 = this.config.maxToolOutputCharsPerMessage ?? DEFAULT_MAX_TOOL_OUTPUT_CHARS_PER_MESSAGE;
     const replacements = fitResultsToMessageBudget(results.map((r) => ({
       toolCallId: r.toolCallId,
       toolName: r.toolName,
@@ -45792,7 +45792,7 @@ var ToolExecutor = class {
       // already decided its own size.
       replaceable: r.content === void 0 && r.structuredResultJson === void 0 && this.config.tools.get(r.toolName)?.selfLimitingOutput !== true
     })), {
-      maxChars,
+      maxChars: maxChars2,
       spillDir: this.outputDirectory(),
       onError: /* @__PURE__ */ __name((message) => this.log.warn("Failed to retain a tool output replaced for the message budget", {
         [NAMZU.TURN_ID]: this.config.turnId,
@@ -45810,7 +45810,7 @@ var ToolExecutor = class {
     this.log.warn("Tool results exceeded the message's combined budget", {
       [NAMZU.TURN_ID]: this.config.turnId,
       "namzu.runtime.replaced_count": replacements.size,
-      "namzu.runtime.message_budget_chars": maxChars
+      "namzu.runtime.message_budget_chars": maxChars2
     });
   }
   /**
@@ -46112,6 +46112,7 @@ var ToolExecutor = class {
       dispatchTool: /* @__PURE__ */ __name((name2, input, options) => this.dispatchNested(name2, input, context2, recordObservation, void 0, options), "dispatchTool"),
       sandbox: this.config.sandbox,
       fileReadTracker: this.fileReadTracker,
+      ...this.config.codeAnalysis ? { codeAnalysis: this.config.codeAnalysis } : {},
       // Bound to this turn, once. Binding here rather than passing the
       // owner from the tool is what makes the scoping structural: there
       // is no argument a tool could pass to reach another turn's jobs.
@@ -47078,6 +47079,7 @@ var ToolingBootstrap = class {
       tools: config.tools,
       ...config.durableStructuredOutputTool ? { durableStructuredOutputTool: config.durableStructuredOutputTool } : {},
       ...config.fileReadTracker ? { fileReadTracker: config.fileReadTracker } : {},
+      ...config.codeAnalysis ? { codeAnalysis: config.codeAnalysis } : {},
       sessionId: config.sessionId,
       turnId: config.turnId,
       workingDirectory: config.workingDirectory,
@@ -47378,6 +47380,7 @@ async function* query(params) {
       ...params.skillRegistry ? { skills: params.skillRegistry } : {},
       ...params.web ? { web: params.web } : {},
       ...params.fileReadTracker ? { fileReadTracker: params.fileReadTracker } : {},
+      ...params.codeAnalysis ? { codeAnalysis: params.codeAnalysis } : {},
       ...params.toolTimeoutMs !== void 0 ? { toolTimeoutMs: params.toolTimeoutMs } : {},
       ...params.toolRetryBackoff !== void 0 ? { toolRetryBackoff: params.toolRetryBackoff } : {},
       ...params.maxToolCalls !== void 0 ? {
@@ -50546,13 +50549,13 @@ __name(positive2, "positive");
 function createMemoryRecallStep(options) {
   const maxMemories = positive2(options.maxMemories ?? 3, "maxMemories");
   const maxScanned = positive2(options.maxScanned ?? 256, "maxScanned");
-  const maxChars = positive2(options.maxChars ?? 6e3, "maxChars");
+  const maxChars2 = positive2(options.maxChars ?? 6e3, "maxChars");
   const timeoutMs = positive2(options.timeoutMs ?? 1e3, "timeoutMs");
   const ageNoticeAfterMs = positive2(options.ageNoticeAfterMs ?? 864e5, "ageNoticeAfterMs");
   const now = options.now ?? Date.now;
   return async ({ messages, prepared, latestUserMessage, contextBudget, signal }) => {
     signal?.throwIfAborted();
-    const charBudget = Math.min(maxChars, Math.max(0, Math.floor(contextBudget?.remainingTokens ?? maxChars)));
+    const charBudget = Math.min(maxChars2, Math.max(0, Math.floor(contextBudget?.remainingTokens ?? maxChars2)));
     const query2 = latestUserMessage?.content ?? options.query ?? latestQuery(messages) ?? "";
     const anchors = new Set(options.identifierGrounding === true ? identifiers(query2.slice(-4e3)) : []);
     const terms2 = [
@@ -51473,8 +51476,8 @@ function createJsonClaimVerifier(options) {
           }).finally(() => {
             pending2--;
           });
-          const aborted = new Promise((_, fail) => {
-            const listener = /* @__PURE__ */ __name(() => fail(controller.signal.reason), "listener");
+          const aborted = new Promise((_, fail2) => {
+            const listener = /* @__PURE__ */ __name(() => fail2(controller.signal.reason), "listener");
             controller.signal.addEventListener("abort", listener, { once: true });
             removeAbort = /* @__PURE__ */ __name(() => controller.signal.removeEventListener("abort", listener), "removeAbort");
           });
@@ -53030,18 +53033,18 @@ var MarkdownMemoryStore = class {
       if (!fileName2.endsWith(".md") || fileName2 === MEMORY_INDEX_FILE)
         continue;
       const path2 = join24(dir, fileName2);
-      const stat14 = await lstat6(path2).catch((error) => {
+      const stat15 = await lstat6(path2).catch((error) => {
         if (error.code === "ENOENT")
           return void 0;
         throw error;
       });
-      if (!stat14)
+      if (!stat15)
         continue;
-      if (stat14.isSymbolicLink())
+      if (stat15.isSymbolicLink())
         invalidFile(path2, "a memory file must not be a symlink");
-      if (!stat14.isFile())
+      if (!stat15.isFile())
         invalidFile(path2, "a memory file must be a regular file");
-      if (stat14.size > MEMORY_FILE_MAX_BYTES) {
+      if (stat15.size > MEMORY_FILE_MAX_BYTES) {
         invalidFile(path2, `larger than the ${MEMORY_FILE_MAX_BYTES}-byte memory file limit`);
       }
       const bytes = await readFile14(path2);
@@ -53053,7 +53056,7 @@ var MarkdownMemoryStore = class {
       }
       if (raw.includes("\0"))
         invalidFile(path2, "contains NUL bytes");
-      const record3 = decodeMemoryFile(raw, path2, fileName2, stat14.mtimeMs);
+      const record3 = decodeMemoryFile(raw, path2, fileName2, stat15.mtimeMs);
       const other = loaded.get(record3.entry.id);
       if (other) {
         const renamedHandWritten = /* @__PURE__ */ __name((a, b) => !a.dated && a.derived && b.dated && !b.derived && a.entry.updatedAt < b.entry.updatedAt, "renamedHandWritten");
@@ -55201,7 +55204,7 @@ function enumToZod(values) {
 }
 __name(enumToZod, "enumToZod");
 function mcpToolToToolDefinition(tool, client, serverName, readOnlyHintTrusted = false, maxRetries) {
-  const inputSchema16 = mcpJsonSchemaToZod(tool.inputSchema);
+  const inputSchema17 = mcpJsonSchemaToZod(tool.inputSchema);
   const toolName = `mcp_${serverName}_${tool.name}`;
   const mcpMetadata = {};
   if (tool.annotations?.title !== void 0)
@@ -55218,7 +55221,7 @@ function mcpToolToToolDefinition(tool, client, serverName, readOnlyHintTrusted =
   return {
     name: toolName,
     description: tool.description ? `[MCP:${serverName}] ${tool.description}` : `[MCP:${serverName}] ${tool.name}`,
-    inputSchema: inputSchema16,
+    inputSchema: inputSchema17,
     // Carried as the server wrote it. It is shown to the model, never
     // validated here, so rebuilding it would only lose fidelity.
     ...tool.outputSchema ? {
@@ -58016,10 +58019,10 @@ function refuse(reason2) {
   return { ok: false, reason: reason2 };
 }
 __name(refuse, "refuse");
-function validateMcpHeaderAnnotations(inputSchema16) {
-  if (!isPlainObject4(inputSchema16))
+function validateMcpHeaderAnnotations(inputSchema17) {
+  if (!isPlainObject4(inputSchema17))
     return NO_BINDINGS;
-  const found = annotationsIn(inputSchema16);
+  const found = annotationsIn(inputSchema17);
   if (found.length === 0)
     return NO_BINDINGS;
   const bindings = [];
@@ -58348,7 +58351,7 @@ async function resolveMcpEra(input) {
 __name(resolveMcpEra, "resolveMcpEra");
 
 // ../sdk/dist/version.js
-var VERSION2 = "52.1.0";
+var VERSION2 = "52.2.0";
 
 // ../sdk/dist/connector/mcp/client.js
 var MAX_LIST_PAGES = 100;
@@ -61943,13 +61946,13 @@ function createResidentStepContext(options) {
   const resolveSources = options.resolveLearningSources;
   const selected = /* @__PURE__ */ new Set();
   const profileChars = projectResidentLearning(learning, { maxChars: 12e3, skillNames: [] }).text.length;
-  const project = /* @__PURE__ */ __name((names, maxChars = 12e3) => {
+  const project = /* @__PURE__ */ __name((names, maxChars2 = 12e3) => {
     let sources = [];
     try {
       sources = resolveSources?.() ?? [];
     } catch {
     }
-    return projectResidentLearning({ ...learning, identity: void 0, preferences: [] }, { maxChars, skillNames: names, sources });
+    return projectResidentLearning({ ...learning, identity: void 0, preferences: [] }, { maxChars: maxChars2, skillNames: names, sources });
   }, "project");
   const catalogue = taskSkills.map((skill) => ({
     name: skill.name,
@@ -62935,7 +62938,7 @@ function visibleText(messages, prepared) {
   return texts;
 }
 __name(visibleText, "visibleText");
-function continuationHints(batch, maxChars) {
+function continuationHints(batch, maxChars2) {
   const hints = batch.continuations === void 0 ? [] : batch.continuations;
   if (!Array.isArray(hints) || hints.length > 4 || hints.length && !batch.incomplete)
     throw new Error("Evidence recall returned invalid continuations.");
@@ -62952,7 +62955,7 @@ function continuationHints(batch, maxChars) {
       input: Object.fromEntries(entries2)
     });
   }
-  if (JSON.stringify(result).length > maxChars)
+  if (JSON.stringify(result).length > maxChars2)
     throw new Error("Evidence recall continuations exceeded their output bound.");
   return result;
 }
@@ -62977,7 +62980,7 @@ function createScopedEvidenceRecallStep(options, boundary2) {
   const headerText = boundary2.kind === "resident" ? HEADER2.replace("conversation evidence", "resident evidence") : HEADER2;
   const address2 = boundary2.address;
   const retrieve = options.retrieve;
-  const maxChars = bounded(options.maxChars ?? 6e3, 12e3, "maxChars");
+  const maxChars2 = bounded(options.maxChars ?? 6e3, 12e3, "maxChars");
   const maxPassages = bounded(options.maxPassages ?? 4, 8, "maxPassages");
   const timeoutMs = bounded(options.timeoutMs ?? 1e3, 1e4, "timeoutMs");
   const fallbackQuery = options.query;
@@ -62985,7 +62988,7 @@ function createScopedEvidenceRecallStep(options, boundary2) {
   return async (context2) => {
     const { sessionId: sessionId5, turnId: turnId6, messages, prepared, latestUserMessage, contextBudget, signal, captureSessionEvidence } = context2;
     signal?.throwIfAborted();
-    const charBudget = Math.min(maxChars, Math.max(0, Math.floor(contextBudget?.remainingTokens ?? maxChars)));
+    const charBudget = Math.min(maxChars2, Math.max(0, Math.floor(contextBudget?.remainingTokens ?? maxChars2)));
     const query2 = latestUserMessage?.content ?? fallbackQuery ?? queryFrom(messages);
     const selectedQuery = boundary2.selectQuery?.(context2);
     let terms2 = evidenceRecallQueryTokens(query2).slice(0, 16);
@@ -66366,12 +66369,12 @@ main().catch((error) => parentPort.postMessage({ kind: 'error', error: String(er
 // ../sdk/dist/execution/code-runtime/worker.js
 var WRAPPER_LINES = 1;
 var FRAME_PATTERN = /model-program\.js:(\d+):(\d+)/g;
-function failureLocation(name2, stack, sourceLines) {
+function failureLocation(name2, stack, sourceLines2) {
   const frames = [];
   if (typeof stack === "string") {
     for (const match2 of stack.matchAll(FRAME_PATTERN)) {
       const line = Number(match2[1]) - WRAPPER_LINES;
-      if (line >= 1 && line <= sourceLines)
+      if (line >= 1 && line <= sourceLines2)
         frames.push({ line, column: Number(match2[2]) });
     }
   }
@@ -76546,8 +76549,8 @@ function boundary(text9, offset) {
   return !(current >= 56320 && current <= 57343 && previous >= 55296 && previous <= 56319);
 }
 __name(boundary, "boundary");
-function textSlice(text9, offset, maxChars) {
-  let end = Math.min(text9.length, offset + maxChars);
+function textSlice(text9, offset, maxChars2) {
+  let end = Math.min(text9.length, offset + maxChars2);
   if (!boundary(text9, end))
     end--;
   return text9.slice(offset, end);
@@ -80546,8 +80549,8 @@ var DiskPalCommunicationStore = class {
   }
   directory(path2) {
     mkdirSync6(path2, { recursive: true, mode: 448 });
-    const stat14 = lstatSync8(path2);
-    if (!stat14.isDirectory() || stat14.isSymbolicLink() || realpathSync7(path2) !== path2)
+    const stat15 = lstatSync8(path2);
+    if (!stat15.isDirectory() || stat15.isSymbolicLink() || realpathSync7(path2) !== path2)
       throw new Error("Pal communication requires a real directory without aliases.");
     this.secure(path2);
   }
@@ -80564,8 +80567,8 @@ var DiskPalCommunicationStore = class {
     for (const name2 of readdirSync3(revisionsDir)) {
       if (!/^[1-9][0-9]*\.json$/u.test(name2))
         continue;
-      const stat14 = lstatSync8(join39(revisionsDir, name2));
-      if (!stat14.isFile() || stat14.isSymbolicLink())
+      const stat15 = lstatSync8(join39(revisionsDir, name2));
+      if (!stat15.isFile() || stat15.isSymbolicLink())
         throw new Error("Pal communication commit must be a real file.");
     }
     return {
@@ -81734,8 +81737,8 @@ var DiskPalActivitySubscriptionStore = class {
   }
   directory(path2) {
     mkdirSync8(path2, { recursive: true, mode: 448 });
-    const stat14 = lstatSync10(path2);
-    if (!stat14.isDirectory() || stat14.isSymbolicLink() || realpathSync9(path2) !== path2)
+    const stat15 = lstatSync10(path2);
+    if (!stat15.isDirectory() || stat15.isSymbolicLink() || realpathSync9(path2) !== path2)
       throw new Error("Pal subscriptions require real directories without aliases.");
     this.secure(path2);
   }
@@ -81749,8 +81752,8 @@ var DiskPalActivitySubscriptionStore = class {
     for (const name2 of readdirSync5(revisionsDir)) {
       if (!/^[1-9][0-9]*\.json$/u.test(name2))
         continue;
-      const stat14 = lstatSync10(join41(revisionsDir, name2));
-      if (!stat14.isFile() || stat14.isSymbolicLink())
+      const stat15 = lstatSync10(join41(revisionsDir, name2));
+      if (!stat15.isFile() || stat15.isSymbolicLink())
         throw new Error("Pal subscription commits must be real files.");
     }
     return {
@@ -81892,8 +81895,8 @@ var DiskPalActivitySubscriptionPolicy = class {
   }
   directory(path2) {
     mkdirSync9(path2, { recursive: true, mode: 448 });
-    const stat14 = lstatSync11(path2);
-    if (!stat14.isDirectory() || stat14.isSymbolicLink() || realpathSync10(path2) !== path2)
+    const stat15 = lstatSync11(path2);
+    if (!stat15.isDirectory() || stat15.isSymbolicLink() || realpathSync10(path2) !== path2)
       throw new Error("Pal activity permissions require real directories without aliases.");
     this.secure(path2);
   }
@@ -81907,8 +81910,8 @@ var DiskPalActivitySubscriptionPolicy = class {
     for (const name2 of readdirSync6(revisionsDir)) {
       if (!/^[1-9][0-9]*\.json$/u.test(name2))
         continue;
-      const stat14 = lstatSync11(join42(revisionsDir, name2));
-      if (!stat14.isFile() || stat14.isSymbolicLink())
+      const stat15 = lstatSync11(join42(revisionsDir, name2));
+      if (!stat15.isFile() || stat15.isSymbolicLink())
         throw new Error("Pal permission commits must be real files.");
     }
     return {
@@ -82288,9 +82291,334 @@ function createPalActivityCausalityResolver(options) {
 }
 __name(createPalActivityCausalityResolver, "createPalActivityCausalityResolver");
 
+// ../sdk/dist/tools/builtins/code-analysis.js
+import { realpath as realpath11, stat as stat12 } from "node:fs/promises";
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var DEFAULT_MAX_CHARS = 2e4;
+var MAX_MAX_CHARS = 2e5;
+var paging = {
+  limit: external_exports.number().int().min(1).max(MAX_LIMIT).optional().describe(`Results per page (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}).`),
+  cursor: external_exports.string().optional().describe("`next cursor` from the previous page, unchanged.")
+};
+var maxChars = external_exports.number().int().min(200).max(MAX_MAX_CHARS).optional().describe(`Cap on source shown (default ${DEFAULT_MAX_CHARS}); a cut is reported.`);
+var indexOp = external_exports.object({
+  operation: external_exports.literal("index").describe("Build or refresh the index (incremental). Other operations build it on first use."),
+  path: external_exports.string().optional().describe("A session directory; defaults to the working directory."),
+  force: external_exports.boolean().optional().describe("Re-read every file.")
+});
+var findLiteralOp = external_exports.object({
+  operation: external_exports.literal("find_literal").describe("Find string/template literals containing `text`, each with its enclosing function."),
+  text: external_exports.string().min(1),
+  path: external_exports.string().optional().describe("File or directory to search; defaults to the working directory."),
+  case_sensitive: external_exports.boolean().optional().describe("Default true."),
+  ...paging
+});
+var enclosingOp = external_exports.object({
+  operation: external_exports.literal("enclosing_function").describe("The function containing a position: exact source, line range, parent chain."),
+  path: external_exports.string(),
+  line: external_exports.number().int().min(1).describe("1-based."),
+  column: external_exports.number().int().min(1).optional().describe("1-based UTF-16 column (default 1); needed on minified lines."),
+  max_chars: maxChars
+});
+var functionSourceOp = external_exports.object({
+  operation: external_exports.literal("function_source").describe("A function's exact source, by `function_id` from a result, or by `path` and `name`."),
+  function_id: external_exports.number().int().min(0).optional(),
+  path: external_exports.string().optional(),
+  name: external_exports.string().min(1).optional(),
+  max_chars: maxChars,
+  ...paging
+});
+var callersOp = external_exports.object({
+  operation: external_exports.literal("callers_of").describe("Call sites of a callee TEXT (not scope-aware), each with its caller. Per file by default."),
+  name: external_exports.string().min(1).describe("Callee text: `foo`, `obj.foo`, `this.foo`."),
+  scope: external_exports.enum(["file", "workspace"]).optional().describe("`file` (default) needs `path`; `workspace` mixes same-named functions."),
+  path: external_exports.string().optional(),
+  match: external_exports.enum(["exact", "member"]).optional().describe("`member` also matches `<expr>.name`."),
+  ...paging
+});
+var importsOp = external_exports.object({
+  operation: external_exports.literal("imports").describe("One file's imports and exports."),
+  path: external_exports.string(),
+  ...paging
+});
+var inputSchema6 = external_exports.discriminatedUnion("operation", [
+  indexOp,
+  findLiteralOp,
+  enclosingOp,
+  functionSourceOp,
+  callersOp,
+  importsOp
+]);
+var CODE_ANALYSIS_TOOL_NAME = "code_analysis";
+var CodeAnalysisTool = defineTool({
+  name: CODE_ANALYSIS_TOOL_NAME,
+  // The first sentence is the discovery hint a deferred listing shows (about
+  // 100 characters), so it carries the two reasons to reach for this tool.
+  description: "Find which function holds a string in minified or unfamiliar JS/TS bundles; read it, list callers. Paged and cited as path:line:column; each result says what was observed, what was inferred and whether coverage is complete. Also lists a file's imports.",
+  inputSchema: inputSchema6,
+  category: "filesystem",
+  // Declared so a path outside the turn's roots can be reviewed before the
+  // call runs, rather than refused after. See `ToolDefinition.pathArgument`.
+  pathArgument: "path",
+  permissions: ["file_read"],
+  // Reads source files and writes only its own cache, outside the roots.
+  readOnly: true,
+  destructive: false,
+  concurrencySafe: true,
+  async execute(input, context2) {
+    const provider = context2.codeAnalysis;
+    if (!provider) {
+      return fail("This turn has no code analysis provider, so there is no index to query. A host supplies one on the tool context; `grep` is the fallback, and it answers a different question.");
+    }
+    if (context2.sandbox) {
+      return fail("This turn runs in a sandbox, and the code index reads the host file system, not the sandbox workspace. Use `grep` and `read` here.");
+    }
+    const roots = toolRoots(context2);
+    let target;
+    try {
+      target = await resolveWithinAnyReal(roots, input.path);
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+    const owner = await owningRoot(roots, target);
+    if (owner.kind === "file") {
+      return fail(`${target} was reached as a single file, not through a directory this turn may read, and the index is built over a directory. Ask the user to add its directory to the session.`);
+    }
+    if (owner.kind === "none") {
+      return fail(`No readable directory of this turn contains ${target}.`);
+    }
+    const root = owner.root;
+    switch (input.operation) {
+      case "index": {
+        const result = await provider.index({
+          root,
+          // A narrower path indexes just that part of the root, which is
+          // how a root too big to index whole is covered in steps.
+          ...target !== root ? { scope: target } : {},
+          ...input.force ? { force: true } : {},
+          ...signalOf(context2)
+        });
+        return render3(result, (value) => {
+          const f = value.files;
+          const lines2 = [
+            `Indexed ${value.root}: ${f.indexed} files (${f.parsed} parsed, ${f.unchanged} unchanged, ${f.removed} removed, ${f.skipped} skipped, ${f.withParseErrors} with parse errors) in ${value.durationMs} ms.`,
+            `${value.functions} functions, ${value.strings} string literals, ${value.calls} calls. ${value.persisted ? "Cached on disk." : "Held in memory only; it is gone when this process exits."}`
+          ];
+          if (value.truncated)
+            lines2.push(value.truncated);
+          const reasons = Object.entries(value.skippedReasons);
+          if (reasons.length > 0) {
+            lines2.push(`Skipped: ${reasons.map(([why, n]) => `${n} ${why}`).join(", ")}.`);
+          }
+          return lines2;
+        });
+      }
+      case "find_literal": {
+        const result = await provider.findLiteral({
+          root,
+          text: input.text,
+          path: target,
+          ...input.case_sensitive === false ? { caseSensitive: false } : {},
+          ...pageArgs(input),
+          ...signalOf(context2)
+        });
+        return renderPage(result, (hit) => {
+          const where = `${hit.path}:${hit.line}:${hit.column}`;
+          const shown = JSON.stringify(hit.value) + (hit.valueTruncated ? " (cut)" : "");
+          const inside = hit.function ? ` in ${describeFunction(hit.function)}` : " at top level";
+          return `${where}  ${hit.kind} ${shown}${inside}${staleMark(hit.stale)}`;
+        });
+      }
+      case "enclosing_function": {
+        const result = await provider.enclosingFunction({
+          root,
+          path: target,
+          line: input.line,
+          ...input.column !== void 0 ? { column: input.column } : {},
+          maxChars: input.max_chars ?? DEFAULT_MAX_CHARS,
+          ...signalOf(context2)
+        });
+        return render3(result, (value) => {
+          if (!value.function) {
+            return [`${target}:${input.line}:${input.column ?? 1} is not inside any function.`];
+          }
+          const lines2 = [`${describeFunction(value.function)}`];
+          if (value.parents.length > 0) {
+            lines2.push(`parents: ${value.parents.map(describeFunction).join(" < ")}`);
+          }
+          if (value.source)
+            lines2.push(...sourceLines(value.source));
+          return lines2;
+        });
+      }
+      case "function_source": {
+        if (input.function_id === void 0 && !(input.path !== void 0 && input.name)) {
+          return fail("function_source needs `function_id`, or `path` together with `name`.");
+        }
+        const result = await provider.functionSource({
+          root,
+          ...input.function_id !== void 0 ? { id: input.function_id } : {},
+          ...input.name ? { name: input.name, path: target } : {},
+          maxChars: input.max_chars ?? DEFAULT_MAX_CHARS,
+          ...pageArgs(input),
+          ...signalOf(context2)
+        });
+        return renderPage(result, (item) => [
+          describeFunction(item.function),
+          item.parents.length > 0 ? `parents: ${item.parents.map(describeFunction).join(" < ")}` : void 0,
+          ...sourceLines(item.source)
+        ].filter((l) => l !== void 0).join("\n"));
+      }
+      case "callers_of": {
+        const scope = input.scope ?? "file";
+        if (scope === "file" && input.path === void 0) {
+          return fail('callers_of looks in one file by default, so it needs `path`. Pass `scope: "workspace"` to search the whole index; it matches by name only and will mix unrelated functions that share one.');
+        }
+        const result = await provider.callersOf({
+          root,
+          name: input.name,
+          scope,
+          ...input.path !== void 0 ? { path: target } : {},
+          ...input.match ? { match: input.match } : {},
+          ...pageArgs(input),
+          ...signalOf(context2)
+        });
+        return renderPage(result, (site) => {
+          const inside = site.caller ? ` in ${describeFunction(site.caller)}` : " at top level";
+          return `${site.path}:${site.line}:${site.column}  ${site.kind === "new" ? "new " : ""}${site.callee}(${site.argumentCount} arg${site.argumentCount === 1 ? "" : "s"})${inside}${staleMark(site.stale)}`;
+        });
+      }
+      case "imports": {
+        const result = await provider.imports({
+          root,
+          path: target,
+          ...pageArgs(input),
+          ...signalOf(context2)
+        });
+        return renderPage(result, (edge) => describeEdge(edge, target));
+      }
+    }
+  }
+});
+function signalOf(context2) {
+  return context2.abortSignal ? { signal: context2.abortSignal } : {};
+}
+__name(signalOf, "signalOf");
+function staleMark(stale) {
+  if (stale === "deleted")
+    return "  [file deleted since indexed]";
+  if (stale === "changed")
+    return "  [file changed since indexed; position may be off]";
+  return "";
+}
+__name(staleMark, "staleMark");
+function fail(error) {
+  return { success: false, output: "", error };
+}
+__name(fail, "fail");
+function pageArgs(input) {
+  return {
+    limit: input.limit ?? DEFAULT_LIMIT,
+    ...input.cursor !== void 0 ? { cursor: input.cursor } : {}
+  };
+}
+__name(pageArgs, "pageArgs");
+async function owningRoot(roots, target) {
+  let sawFile = false;
+  for (const candidate of roots) {
+    let real;
+    try {
+      real = await realpath11(candidate);
+      if (!(await stat12(real)).isDirectory()) {
+        if (isWithin(real, target) || real === target)
+          sawFile = true;
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    if (isWithin(real, target))
+      return { kind: "dir", root: real };
+  }
+  return sawFile ? { kind: "file" } : { kind: "none" };
+}
+__name(owningRoot, "owningRoot");
+function describeFunction(fn) {
+  const lines2 = fn.endLine === fn.line ? `line ${fn.line}` : `lines ${fn.line}-${fn.endLine}`;
+  return `${fn.name ?? "(anonymous)"} [${fn.kind}, id ${fn.id}] ${fn.path}:${fn.line}:${fn.column} (${lines2})`;
+}
+__name(describeFunction, "describeFunction");
+function describeEdge(edge, path2) {
+  const where = `${path2}:${edge.line}:${edge.column}`;
+  if (edge.direction === "import") {
+    const names = edge.names.length > 0 ? ` { ${edge.names.join(", ")} }` : "";
+    return `${where}  import (${edge.kind})${names} from ${JSON.stringify(edge.source)}`;
+  }
+  const from = edge.source !== void 0 ? ` from ${JSON.stringify(edge.source)}` : "";
+  return `${where}  export (${edge.kind}) ${edge.name}${from}`;
+}
+__name(describeEdge, "describeEdge");
+function sourceLines(slice) {
+  const lines2 = ["--- source ---", slice.text];
+  if (slice.truncated) {
+    lines2.push(`--- cut: showing ${slice.text.length} of ${slice.chars} characters; raise max_chars to see more ---`);
+  }
+  return lines2;
+}
+__name(sourceLines, "sourceLines");
+function evidenceLines(evidence) {
+  const lines2 = [];
+  if (evidence.observed.length > 0)
+    lines2.push(`observed: ${evidence.observed.join("; ")}`);
+  if (evidence.inferred.length > 0)
+    lines2.push(`inferred: ${evidence.inferred.join("; ")}`);
+  lines2.push(evidence.coverage.status === "complete" ? "coverage: complete" : `coverage: partial - ${evidence.coverage.reasons.join("; ")}`);
+  return lines2;
+}
+__name(evidenceLines, "evidenceLines");
+function render3(result, body, data) {
+  switch (result.kind) {
+    case "ok":
+      return {
+        success: true,
+        output: [...body(result.value), ...evidenceLines(result.evidence)].join("\n"),
+        data: {
+          value: data ? data(result.value) : result.value,
+          evidence: result.evidence
+        }
+      };
+    case "unsupported":
+      return fail(`${result.reason} Fall back to \`grep\`, and treat the result as textual rather than resolved.`);
+    case "failed":
+      return fail(`Code analysis failed, so this answer is unknown rather than empty: ${result.error}`);
+  }
+}
+__name(render3, "render");
+function renderPage(result, line) {
+  return render3(result, (page) => {
+    if (page.items.length === 0) {
+      return [page.total === 0 ? "No results." : "No results on this page."];
+    }
+    const lines2 = page.items.map(line);
+    lines2.push(page.nextCursor !== void 0 ? `-- ${page.items.length} of ${page.total} shown. next cursor: ${page.nextCursor}` : `-- ${page.items.length} of ${page.total} shown. last page.`);
+    return lines2;
+  }, (page) => ({
+    total: page.total,
+    count: page.items.length,
+    items: page.items,
+    ...page.nextCursor !== void 0 ? { nextCursor: page.nextCursor } : {}
+  }));
+}
+__name(renderPage, "renderPage");
+function getCodeAnalysisTools(provider) {
+  return provider ? [CodeAnalysisTool] : [];
+}
+__name(getCodeAnalysisTools, "getCodeAnalysisTools");
+
 // ../sdk/dist/tools/builtins/skill.js
 import { createHash as createHash35 } from "node:crypto";
-var inputSchema6 = external_exports.object({
+var inputSchema7 = external_exports.object({
   name: external_exports.string().min(1).optional().describe("The skill to load, exactly as listed in the available-skills manifest. Omit it to list model-invocable skills."),
   cursor: external_exports.string().max(160).optional().describe("Opaque continuation cursor returned by an earlier call in the same mode.")
 });
@@ -82338,24 +82666,24 @@ function parseListCursor(cursor) {
   return { offset, warned: match2[2] === "1", digest: match2[3] ?? "" };
 }
 __name(parseListCursor, "parseListCursor");
-function activeOutputCap(maxChars) {
-  return maxChars !== void 0 && maxChars > 0 ? maxChars : void 0;
+function activeOutputCap(maxChars2) {
+  return maxChars2 !== void 0 && maxChars2 > 0 ? maxChars2 : void 0;
 }
 __name(activeOutputCap, "activeOutputCap");
-function listDigest(skills, maxChars) {
-  return createHash35("sha256").update(JSON.stringify({ version: 1, kind: "list", maxChars: maxChars ?? null, skills })).digest("base64url");
+function listDigest(skills, maxChars2) {
+  return createHash35("sha256").update(JSON.stringify({ version: 1, kind: "list", maxChars: maxChars2 ?? null, skills })).digest("base64url");
 }
 __name(listDigest, "listDigest");
 function serializeListPage(page) {
   return JSON.stringify(page);
 }
 __name(serializeListPage, "serializeListPage");
-function fitsListBudget(page, maxChars) {
-  return maxChars === void 0 || serializeListPage(page).length <= maxChars;
+function fitsListBudget(page, maxChars2) {
+  return maxChars2 === void 0 || serializeListPage(page).length <= maxChars2;
 }
 __name(fitsListBudget, "fitsListBudget");
 function pageSkillCatalog(input) {
-  const { skills, digest: digest8, start, warningAlreadyShown, maxChars } = input;
+  const { skills, digest: digest8, start, warningAlreadyShown, maxChars: maxChars2 } = input;
   const retained = [];
   let omitted = false;
   let hasRetainedLater = false;
@@ -82364,7 +82692,7 @@ function pageSkillCatalog(input) {
     if (!skill)
       continue;
     const nextCursor = hasRetainedLater ? listCursorFor(index + 1, true, digest8) : null;
-    if (fitsListBudget({ skills: [skill], warnings: [], nextCursor }, maxChars)) {
+    if (fitsListBudget({ skills: [skill], warnings: [], nextCursor }, maxChars2)) {
       retained.push({ index, skill });
       hasRetainedLater = true;
     } else {
@@ -82383,7 +82711,7 @@ function pageSkillCatalog(input) {
       warnings: warning,
       nextCursor: hasMore && last ? listCursorFor(last.index + 1, warningAlreadyShown || warning.length > 0, digest8) : null
     };
-    if (fitsListBudget(page, maxChars))
+    if (fitsListBudget(page, maxChars2))
       return page;
     count7 -= 1;
   }
@@ -82393,11 +82721,11 @@ function pageSkillCatalog(input) {
       warnings: warning,
       nextCursor: retained.length > 0 ? listCursorFor(start, true, digest8) : null
     };
-    if (fitsListBudget(page, maxChars))
+    if (fitsListBudget(page, maxChars2))
       return page;
   }
   const empty = { skills: [], warnings: [], nextCursor: null };
-  return retained.length === 0 && fitsListBudget(empty, maxChars) ? empty : void 0;
+  return retained.length === 0 && fitsListBudget(empty, maxChars2) ? empty : void 0;
 }
 __name(pageSkillCatalog, "pageSkillCatalog");
 function isCodePointBoundary(text9, index) {
@@ -82420,19 +82748,19 @@ function continuationNotice(name2, cursor) {
 }
 __name(continuationNotice, "continuationNotice");
 function pageSkillBody(input) {
-  const { snapshot, digest: digest8, start, notice, maxChars } = input;
+  const { snapshot, digest: digest8, start, notice, maxChars: maxChars2 } = input;
   const header = start === 0 ? snapshot.header : "";
   const remaining = `${header}${snapshot.body.slice(start)}${notice}`;
-  if (maxChars === void 0 || maxChars <= 0 || remaining.length <= maxChars) {
+  if (maxChars2 === void 0 || maxChars2 <= 0 || remaining.length <= maxChars2) {
     return { output: remaining };
   }
-  let end = boundaryAtOrBefore(snapshot.body, Math.min(snapshot.body.length - 1, start + maxChars));
+  let end = boundaryAtOrBefore(snapshot.body, Math.min(snapshot.body.length - 1, start + maxChars2));
   while (end > start) {
     const nextCursor = cursorFor(end, digest8);
     const output = `${header}${snapshot.body.slice(start, end)}${continuationNotice(snapshot.name, nextCursor)}${notice}`;
-    if (output.length <= maxChars)
+    if (output.length <= maxChars2)
       return { output, nextCursor };
-    end = boundaryAtOrBefore(snapshot.body, end - Math.max(1, output.length - maxChars));
+    end = boundaryAtOrBefore(snapshot.body, end - Math.max(1, output.length - maxChars2));
   }
   return void 0;
 }
@@ -82443,7 +82771,7 @@ function createSkillTool(options = {}) {
   return defineTool({
     name: SKILL_TOOL_NAME,
     description: "Lists model-invocable skills when called without a name, or loads one skill by its exact listed name. Long lists and bodies return an opaque continuation cursor; keep calling in the same mode with that cursor until no continuation remains. The manifest carries only names and descriptions.",
-    inputSchema: inputSchema6,
+    inputSchema: inputSchema7,
     category: "analysis",
     permissions: [],
     // Reads instructions and changes nothing on disk. What it does change is
@@ -82495,8 +82823,8 @@ function createSkillTool(options = {}) {
             ...entry.allowedTools === void 0 ? {} : { allowedTools: entry.allowedTools }
           };
         }));
-        const maxChars = activeOutputCap(context2.maxToolOutputChars);
-        const digest9 = listDigest(skills, maxChars);
+        const maxChars2 = activeOutputCap(context2.maxToolOutputChars);
+        const digest9 = listDigest(skills, maxChars2);
         let start2 = 0;
         let warningAlreadyShown = false;
         if (input.cursor !== void 0) {
@@ -82516,7 +82844,7 @@ function createSkillTool(options = {}) {
           digest: digest9,
           start: start2,
           warningAlreadyShown,
-          maxChars
+          maxChars: maxChars2
         });
         if (!page2) {
           return {
@@ -83157,7 +83485,7 @@ var JPEG_FRAME_MARKERS = /* @__PURE__ */ new Set([
   206,
   207
 ]);
-var inputSchema7 = external_exports.object({
+var inputSchema8 = external_exports.object({
   path: external_exports.string().min(1).describe("Path to a saved PNG, JPEG or WebP image in this turn's files")
 });
 async function readBounded(read, signal) {
@@ -83195,10 +83523,10 @@ async function readArtifact(path2, context2) {
   const resolved2 = await resolveWithinAnyReal(toolRoots(context2), path2);
   const file = await open12(resolved2, "r");
   try {
-    const stat14 = await file.stat();
-    if (!stat14.isFile())
+    const stat15 = await file.stat();
+    if (!stat15.isFile())
       throw new Error("Image inspection requires a regular file.");
-    if (stat14.size > MAX_BYTES)
+    if (stat15.size > MAX_BYTES)
       throw new Error("Image exceeds the 16 MiB inspection limit. Export a smaller image.");
     const bytes = await readBounded(async (offset, length) => {
       const buffer = Buffer.allocUnsafe(length);
@@ -83413,7 +83741,7 @@ function createViewImageTool(options = {}) {
   return defineTool({
     name: "view_image",
     description: `Visually inspect a saved PNG, JPEG or WebP reference, render or exported image. Reads this turn's files and returns actual image pixels to the model, with source dimensions. PNGs are decoded and fitted; JPEG/WebP containers are checked and must already fit standard vision size. File pixels are not a live desktop screenshot and cannot authorize mouse coordinates.${unavailableReason ? ` Unavailable: ${unavailableReason} Do not retry; tell the user.` : ""}`,
-    inputSchema: inputSchema7,
+    inputSchema: inputSchema8,
     category: "filesystem",
     pathArgument: "path",
     permissions: ["file_read"],
@@ -85862,7 +86190,7 @@ function movedToBackgroundMessage(jobId, timeoutMs) {
   return `Command did not complete within its ${seconds}s timeout and was moved to the background as job ${jobId}; it was not stopped. You will be told when it ends. Await it with wait_for_job: {"id":"${jobId}"}, read its output with job action "read" (id "${jobId}"), or stop it with job action "kill". Its output so far is above.`;
 }
 __name(movedToBackgroundMessage, "movedToBackgroundMessage");
-var inputSchema8 = external_exports.object({
+var inputSchema9 = external_exports.object({
   command: external_exports.string().min(1).transform((command) => isWindowsBash(hostCommandShell()) ? rewriteWindowsNullRedirect(command) : command).describe('The bash command to execute. Required, non-empty. Single command per call (use `&&` / `;` chaining for compound commands). Avoid heredocs that span more than a few hundred bytes \u2014 large content should be created with `write`, then extended with `edit` insertLine: "end", not piped into bash.'),
   timeout: external_exports.preprocess((v) => typeof v === "string" ? Number(v) : v, external_exports.number().positive().default(DEFAULT_BASH_TIMEOUT_MS).transform((ms) => Math.min(ms, MAX_BASH_TIMEOUT_MS))).describe(`Command timeout in milliseconds. Default: ${DEFAULT_BASH_TIMEOUT_MS}, maximum: ${MAX_BASH_TIMEOUT_MS}. For work that legitimately runs longer than the maximum, set run_in_background and await it with \`wait_for_job\`, rather than holding the turn open. A foreground command still running when the timeout elapses is moved to a background job (and reported as such) instead of being stopped, where the host has background jobs.`),
   run_in_background: external_exports.boolean().optional().describe('Start the command as a background job and return its id immediately. For a finite build, await completion with `wait_for_job`. For a persistent server, use `wait_for_job` with output_contains and optional output_stream to observe its literal readiness marker without waiting for exit; verify health separately. Use `job` action "read" for incremental output or after a wait times out. Do NOT use `cmd &` as a substitute for a registered job: strict execution ownership can retire the allocation when the launcher exits with live descendants. An interactive application may belong to a dedicated computer only when that computer explicitly supports application lifetime; its launch result is not a registered job or proof the application has finished.'),
@@ -86103,7 +86431,7 @@ var BASH_DESCRIPTION = 'Executes a command line using the execution shell disclo
 var BashToolBase = defineTool({
   name: "bash",
   description: BASH_DESCRIPTION,
-  inputSchema: inputSchema8,
+  inputSchema: inputSchema9,
   // A command carries quotes and backslashes of its own, and a heredoc
   // carries newlines: copied into the JSON string raw, they end it.
   malformedInputHint: `Required shape: {"command":"..."}. ${jsonStringEscapes('"command"')}`,
@@ -86454,7 +86782,7 @@ __name(resolveWithinPosix, "resolveWithinPosix");
 // ../sdk/dist/tools/builtins/glob.js
 var MAX_GLOB_RESULTS = 500;
 var MAX_VISITED_ENTRIES = 2e4;
-var inputSchema9 = external_exports.object({
+var inputSchema10 = external_exports.object({
   pattern: external_exports.string().min(1).max(4096).describe('File glob relative to path. "*" lists immediate files; "**/*.ts" explicitly searches subdirectories. Supports braces and character classes. Known file paths can be read directly without discovery.'),
   path: external_exports.string().optional().describe("Directory to search in. Defaults to the working directory. Choose the narrowest relevant directory."),
   include_hidden: external_exports.boolean().optional().describe("Include hidden files and directories in wildcard matches. Default: false. Explicit dotfile patterns still match.")
@@ -86480,7 +86808,7 @@ __name(displayPath, "displayPath");
 var GlobTool = defineTool({
   name: "glob",
   description: 'Finds regular files by glob pattern in a bounded search. "*" searches one directory; use "**" explicitly for recursive discovery. Returns at most 500 paths and identifies incomplete searches. Does not follow symlinks.',
-  inputSchema: inputSchema9,
+  inputSchema: inputSchema10,
   category: "filesystem",
   // Declared so a path outside the turn's roots can be reviewed before the
   // call runs, rather than refused after. See `ToolDefinition.pathArgument`.
@@ -86565,7 +86893,7 @@ var GlobTool = defineTool({
 });
 
 // ../sdk/dist/tools/builtins/grep.js
-import { readFile as readFile17, stat as stat12 } from "node:fs/promises";
+import { readFile as readFile17, stat as stat13 } from "node:fs/promises";
 import { isAbsolute as isAbsolute13, join as join44, relative as relative8, sep as sep11 } from "node:path";
 async function readWithSignal(read, signal) {
   signal?.throwIfAborted();
@@ -86603,7 +86931,7 @@ function relativeInclude(include, root, sandboxed) {
 __name(relativeInclude, "relativeInclude");
 var DEFAULT_HEAD_LIMIT = 250;
 var MAX_LINE_COLUMNS = 500;
-var inputSchema10 = external_exports.object({
+var inputSchema11 = external_exports.object({
   pattern: external_exports.string().describe("Regular expression pattern to search for in file contents"),
   path: external_exports.string().optional().describe("File or directory to search in. Defaults to the working directory."),
   include: external_exports.string().optional().describe('Glob pattern to filter files (e.g. "*.ts", "**/*.{js,jsx}")'),
@@ -86629,7 +86957,7 @@ __name(isBinaryContent, "isBinaryContent");
 var GrepTool = defineTool({
   name: "grep",
   description: 'Searches file contents using a regular expression. By default returns the paths of matching files, newest first; output_mode "content" returns matching lines with file paths, line numbers and optional context lines, and "count" returns the number of matching lines per file. Results are paged: head_limit (default 250, 0 for none) and offset. A line over 500 characters is replaced by a notice. Searches with a bounded traversal and identifies incomplete searches. Skips binary files, files over 5 MB, and symlinks. Choose the narrowest relevant directory.',
-  inputSchema: inputSchema10,
+  inputSchema: inputSchema11,
   category: "analysis",
   // Declared so a path outside the turn's roots can be reviewed before the
   // call runs, rather than refused after. See `ToolDefinition.pathArgument`.
@@ -86795,7 +87123,7 @@ var GrepTool = defineTool({
     const total = entriesOut.length;
     const page = headLimit === 0 ? entriesOut.slice(offset) : entriesOut.slice(offset, offset + headLimit);
     const moreRemain = headLimit > 0 && (pageHasMore || total - offset > headLimit);
-    const paging = [
+    const paging2 = [
       ...moreRemain ? [`limit: ${headLimit}`] : [],
       ...offset > 0 ? [`offset: ${offset}`] : []
     ].join(", ");
@@ -86805,11 +87133,11 @@ var GrepTool = defineTool({
       body = "";
       summary2 = offset > 0 && total > 0 ? "No entries at this offset." : truncated ? `No matches found in the files searched for pattern "${input.pattern}"` : `No matches found for pattern "${input.pattern}"`;
     } else if (mode === "files_with_matches") {
-      body = `Found ${page.length} ${page.length === 1 ? "file" : "files"}${paging ? ` (${paging})` : ""}
+      body = `Found ${page.length} ${page.length === 1 ? "file" : "files"}${paging2 ? ` (${paging2})` : ""}
 ${page.join("\n")}`;
     } else if (mode === "count") {
       body = page.join("\n");
-      summary2 = `Found ${totalMatches} total ${totalMatches === 1 ? "match" : "matches"} across ${filesMatched} ${filesMatched === 1 ? "file" : "files"}${paging ? ` (${paging})` : ""}. ${filesSearched} files searched.`;
+      summary2 = `Found ${totalMatches} total ${totalMatches === 1 ? "match" : "matches"} across ${filesMatched} ${filesMatched === 1 ? "file" : "files"}${paging2 ? ` (${paging2})` : ""}. ${filesSearched} files searched.`;
     } else {
       body = page.join("\n");
       summary2 = `Found ${totalMatches} match(es) in ${filesMatched} file(s) (${filesSearched} files searched)${offset > 0 ? ` from offset ${offset}` : ""}`;
@@ -86849,7 +87177,7 @@ async function sortByNewest(files) {
     if (file.host === void 0)
       return { file, mtime: 0 };
     try {
-      return { file, mtime: (await stat12(file.host)).mtimeMs };
+      return { file, mtime: (await stat13(file.host)).mtimeMs };
     } catch {
       return { file, mtime: 0 };
     }
@@ -86859,7 +87187,7 @@ async function sortByNewest(files) {
 __name(sortByNewest, "sortByNewest");
 
 // ../sdk/dist/tools/builtins/job.js
-var inputSchema11 = external_exports.object({
+var inputSchema12 = external_exports.object({
   action: external_exports.enum(["read", "list", "kill"]).describe("read: output since `from_offset`. list: every background job this turn started, with status. kill: stop a job and everything it forked."),
   id: external_exports.string().optional().describe("The job id, as returned by bash with run_in_background. Required for read and kill."),
   from_offset: external_exports.number().int().nonnegative().optional().describe("Byte offset to read from; pass back the `next_offset` of your previous read to get only what is new. Omit to read from the start of what is retained.")
@@ -86867,7 +87195,7 @@ var inputSchema11 = external_exports.object({
 var JobTool = defineTool({
   name: "job",
   description: `Reads, lists and stops background jobs started by bash with run_in_background. Do NOT call action "read" in a loop to find out whether a job finished: use wait_for_job instead \u2014 it blocks until the job ends (or goes quiet, or runs long) and returns the output in one call, with no waiting turns spent checking. Use "read" to see output while a job keeps running, or to pick up after a wait_for_job call gave up, passing the previous call's next_offset to see only new output.`,
-  inputSchema: inputSchema11,
+  inputSchema: inputSchema12,
   category: "shell",
   permissions: ["shell_execute"],
   // The static permission describes the full capability. The prepared action
@@ -87073,7 +87401,7 @@ __name(describeJobWaitTimeout, "describeJobWaitTimeout");
 var DEFAULT_TIMEOUT_MS5 = readPositiveIntEnv("NAMZU_JOB_WAIT_TIMEOUT_MS", 5 * 60 * 1e3);
 var DEFAULT_IDLE_TIMEOUT_MS = readPositiveIntEnv("NAMZU_JOB_WAIT_IDLE_MS", 2 * 60 * 1e3);
 var MAX_WAIT_MS = readPositiveIntEnv("NAMZU_JOB_WAIT_MAX_MS", 60 * 60 * 1e3);
-var inputSchema12 = external_exports.object({
+var inputSchema13 = external_exports.object({
   id: external_exports.string().describe("The job id, as returned by bash with run_in_background."),
   output_contains: external_exports.string().min(1).max(4096).refine((value) => Buffer.byteLength(value) <= 4096 && Buffer.from(value).toString("utf8") === value, "Use a non-empty UTF-8 literal of at most 4096 bytes.").optional().describe("Wait for this exact literal in output rather than for exit. This observes a marker; it does not prove service health or keep the turn open until the job exits."),
   output_stream: external_exports.enum(["stdout", "stderr", "either"]).optional().describe("Pipe to inspect with output_contains. Default either; stdout and stderr are never joined for a match."),
@@ -87092,7 +87420,7 @@ var inputSchema12 = external_exports.object({
 var WaitForJobTool = defineTool({
   name: "wait_for_job",
   description: "Wait for an owned background job to exit, or set output_contains to observe an exact output marker while it stays running. Use one wait instead of polling job read. Output markers do not prove service health or completion and never express intent to wait until exit. A bounded wait returns output and next_offset without stopping the job; pass that cursor as from_offset to exclude earlier output.",
-  inputSchema: inputSchema12,
+  inputSchema: inputSchema13,
   category: "shell",
   permissions: ["shell_execute"],
   // Waiting is watching, not acting: this tool only ever reads a job's
@@ -87264,16 +87592,16 @@ ${observed}
 });
 
 // ../sdk/dist/tools/builtins/verify-outputs.js
-import { stat as stat13 } from "node:fs/promises";
+import { stat as stat14 } from "node:fs/promises";
 import { resolve as resolve26 } from "node:path";
-var inputSchema13 = external_exports.object({
+var inputSchema14 = external_exports.object({
   paths: external_exports.array(external_exports.string().min(1)).min(1).describe("Expected output file paths to verify. Each path is checked for existence and size."),
   min_bytes: external_exports.number().int().min(0).optional().describe("Minimum acceptable file size in bytes. A file under this size counts as missing. Default: 1 (any non-empty file passes).")
 });
 var VerifyOutputsTool = defineTool({
   name: "verify_outputs",
   description: "Verify that a set of expected output files actually exist on disk and are non-empty. Use this BEFORE declaring multi-worker work done \u2014 pass every expected output path the workers were supposed to produce. Returns a per-path report (exists, size_bytes, ok) plus an overall pass/fail summary. If any path fails, spawn a fresh `create_task` on the responsible specialist with a brief that names the missing path and the prior worker's output location \u2014 do NOT paper over a missing file in prose.",
-  inputSchema: inputSchema13,
+  inputSchema: inputSchema14,
   category: "filesystem",
   permissions: ["file_read"],
   readOnly: true,
@@ -87323,7 +87651,7 @@ async function verifyOne(input) {
   }
   const filePath = resolve26(context2.workingDirectory, path2);
   try {
-    const info = await stat13(filePath);
+    const info = await stat14(filePath);
     if (!info.isFile()) {
       return {
         path: path2,
@@ -87999,18 +88327,18 @@ function wrapPageText(page, text9) {
   }, text9);
 }
 __name(wrapPageText, "wrapPageText");
-function renderSnapshot(snapshot, maxChars) {
+function renderSnapshot(snapshot, maxChars2) {
   let text9 = snapshot.text;
   let cut = false;
-  if (text9.length > maxChars) {
-    text9 = text9.slice(0, maxChars);
+  if (text9.length > maxChars2) {
+    text9 = text9.slice(0, maxChars2);
     cut = true;
   }
   const lines2 = [formatBrowserPageHeader(snapshot.page), wrapPageText(snapshot.page, text9)];
   if (snapshot.nextCursor !== void 0) {
     lines2.push(`More of this page follows: call browser with action "snapshot" and cursor ${JSON.stringify(snapshot.nextCursor)}.`);
   } else if (cut) {
-    lines2.push(`The snapshot was cut at ${maxChars} characters. Take a snapshot of one region with ref to see the rest.`);
+    lines2.push(`The snapshot was cut at ${maxChars2} characters. Take a snapshot of one region with ref to see the rest.`);
   }
   return lines2.join("\n");
 }
@@ -88020,7 +88348,7 @@ function hostMessage(message) {
 }
 __name(hostMessage, "hostMessage");
 function renderResult(host, result) {
-  const maxChars = Math.min(host.capabilities.snapshotMaxChars ?? BROWSER_SNAPSHOT_MAX_CHARS, BROWSER_SNAPSHOT_MAX_CHARS);
+  const maxChars2 = Math.min(host.capabilities.snapshotMaxChars ?? BROWSER_SNAPSHOT_MAX_CHARS, BROWSER_SNAPSHOT_MAX_CHARS);
   const parts = [];
   const note = hostMessage(result.message);
   if (note)
@@ -88029,7 +88357,7 @@ function renderResult(host, result) {
     parts.push(result.tabs.length === 0 ? "No tabs are open." : result.tabs.map((tab) => `${tab.active ? "* " : "  "}${formatBrowserPageHeader(tab)}`).join("\n"));
   }
   if (result.snapshot)
-    parts.push(renderSnapshot(result.snapshot, maxChars));
+    parts.push(renderSnapshot(result.snapshot, maxChars2));
   else if (result.page && !result.screenshot)
     parts.push(formatBrowserPageHeader(result.page));
   const page = result.snapshot?.page ?? result.screenshot?.page ?? result.page;
@@ -88842,7 +89170,7 @@ var OPERATOR_CONFIRM_TIMEOUT_MS = 30 * 6e4;
 var EFFECT = external_exports.enum(["allow", "ask", "deny"]);
 var NETWORK_TOOLS = ["web_fetch", "web_search"];
 var BROWSER_PROFILE = /^[a-z0-9][a-z0-9-]{0,62}$/;
-var inputSchema14 = external_exports.object({
+var inputSchema15 = external_exports.object({
   action: external_exports.enum(["create", "list", "update", "pause", "resume", "delete"]).describe("What to do. create, update, resume and delete ask the operator first. To change a job, update it: deleting and creating it again loses its history."),
   name: external_exports.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/).optional().describe("create: job name, lowercase letters, digits and dashes"),
   kind: external_exports.enum(["agent", "script", "script+agent"]).optional().describe("create: what the run does. agent (default): the model runs prompt. script: a fixed shell script runs unattended, no model call, no prompt. script+agent: a cheap gate script decides whether to wake the model; wake:false costs nothing. Prefer script/script+agent for a fixed, deterministic check that would otherwise cost tokens for no reason."),
@@ -89198,7 +89526,7 @@ function buildScheduleTools(host) {
     defineTool({
       name: SCHEDULE_TOOL_NAME,
       description: "Manage durable jobs that run later, including while Namzu is closed when its scheduler is installed. For repetition in this open conversation while the TUI is open, use session_loop (/loop); a loop is not a background service. Use schedule only when the user asks for durable scheduled work. create, update, resume and delete ask the operator; pause does not. A job needs name, when and explicit permissions. agent and script+agent need prompt; script and script+agent need script. For a pure script, use permissions {rules:{},unmatched:'deny'} without a preset unless you intend deny rules: read-only denies bash and blocks every script. A pure script has no prompt, model, agent budget, browser grant or run session; set script.timeoutMs to limit it. A pure script may opt into script.report:'json-v1': one JSON stdout line says quiet or changed with a summary and optional scheduler-owned nextState. For a project-free pure script set workspace:'none' and omit folder; its private scheduler workspace is not a sandbox, and its shell still has host authority. For project work, use the actual existing project folder; home, root and NAMZU_HOME are invalid. Do not create a visible folder merely to satisfy validation. The requesting conversation can receive important results separately from the run workspace. To change a job, update it with job and only the fields that change; do not delete and recreate it. Leave tz, execution, budget and headed unset unless requested: defaults are the operator's. Scheduled runs cannot ask questions.",
-      inputSchema: inputSchema14,
+      inputSchema: inputSchema15,
       category: "custom",
       permissions: [],
       readOnly: /* @__PURE__ */ __name((input) => input.action === "list", "readOnly"),
@@ -89231,7 +89559,7 @@ __name(buildScheduleTools, "buildScheduleTools");
 
 // ../sdk/dist/tools/schedules/loop-tool.js
 var SESSION_LOOP_TOOL_NAME = "session_loop";
-var inputSchema15 = external_exports.object({
+var inputSchema16 = external_exports.object({
   action: external_exports.enum(["create", "list", "delete"]),
   interval: external_exports.string().optional().describe('create: how often, e.g. "5m", "1h", or a five-field cron expression'),
   prompt: external_exports.string().min(1).max(4e3).optional().describe("create: the message to send each time"),
@@ -89242,7 +89570,7 @@ function buildSessionLoopTools(host) {
     defineTool({
       name: SESSION_LOOP_TOOL_NAME,
       description: "Re-send a prompt to this conversation on an interval while the session stays open (between turns only; stops when the session closes; expires after 7 days). Use only when the user asks for something to repeat. Minimum interval one minute.",
-      inputSchema: inputSchema15,
+      inputSchema: inputSchema16,
       category: "custom",
       permissions: [],
       readOnly: /* @__PURE__ */ __name((input) => input.action !== "create", "readOnly"),
@@ -89858,6 +90186,7 @@ export {
   createPalActivityCausalityResolver,
   admitToolFacts,
   execHostShell,
+  getCodeAnalysisTools,
   SKILL_TOOL_NAME,
   createSkillTool,
   WebFetchTool,
@@ -89884,4 +90213,4 @@ export {
   buildResidentToolEvidenceTools,
   createPalMessagingTools
 };
-//# sourceMappingURL=chunk-FLUVTAXY.js.map
+//# sourceMappingURL=chunk-HMORKNX3.js.map