nolo-cli 0.213.0 → 0.222.0-alpha.2

package/{chunk-H4UOTUOX.js → chunk-KEN3N2TN.js}

@@ -4,9 +4,6 @@ import {
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
-import {
-  resolveNoloStateDir
-} from "./chunk-6UBGXX2W.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
@@ -16,6 +13,9 @@ import {
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
+import {
+  resolveNoloStateDir
+} from "./chunk-6UBGXX2W.js";
 
 // packages/agent-runtime/processTask.ts
 var PROCESS_TASK_TERMINAL_STATUSES = [
@@ -435,8 +435,9 @@ function getProcessRegistry() {
 }
 
 // packages/agent-runtime/workspaceShell.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createWriteStream, mkdirSync as mkdirSync2, rmSync } from "node:fs";
-import { dirname, join as join3, resolve } from "node:path";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { tmpdir } from "node:os";
@@ -594,9 +595,9 @@ function spawnToWebStreams(options) {
     env: options.env,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  const exited = new Promise((resolve2) => {
-    child.on("exit", (code) => resolve2(code ?? 1));
-    child.on("error", () => resolve2(127));
+  const exited = new Promise((resolve3) => {
+    child.on("exit", (code) => resolve3(code ?? 1));
+    child.on("error", () => resolve3(127));
   });
   const toWeb = (stream) => {
     if (!stream) return null;
@@ -691,6 +692,11 @@ function findWindowsPowerShellAlias(options = {}) {
   return null;
 }
 
+// packages/agent-runtime/processTaskResult.ts
+import { openSync, readSync, closeSync } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
 // packages/agent-runtime/toolSpillStore.ts
 import { createHash, randomUUID } from "node:crypto";
 import { constants, copyFileSync, createReadStream, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, renameSync, statSync as statSync3, unlinkSync, utimesSync, writeFileSync } from "node:fs";
@@ -722,11 +728,11 @@ function countLines(text) {
 var SPILL_PUBLICATION_GRACE_MS = 6e4;
 async function hashFileStreaming(path) {
   const hash = createHash("sha256");
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const stream = createReadStream(path);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
-    stream.on("end", () => resolve2());
+    stream.on("end", () => resolve3());
   });
   return hash.digest("hex");
 }
@@ -952,6 +958,41 @@ function formatToolOverflowMarker(args) {
 `;
 }
 
+// packages/agent-runtime/toolOutputSpillProjection.ts
+var TOOL_OUTPUT_SPILL_BYTES = 30 * 1024;
+var TOOL_OUTPUT_SPILL_LINES = 800;
+var HEAD_LINES = 30;
+var TAIL_LINES = 50;
+var PREVIEW_CHARS = 12 * 1024;
+var MARKER = /\[Omitted \d+ lines \([\d.]+ KB\)\. Full output saved to [^\n]+\]/;
+function isSpilledToolOutput(text) {
+  return MARKER.test(text) && text.length <= PREVIEW_CHARS * 2 + 2048;
+}
+function formatSpilledToolOutput(args) {
+  const headLines = args.head.split("\n").slice(0, HEAD_LINES);
+  const tailLines = args.tail.split("\n").slice(-TAIL_LINES);
+  const head = headLines.join("\n").slice(0, PREVIEW_CHARS);
+  const tail = tailLines.join("\n").slice(-PREVIEW_CHARS);
+  const omitted = Math.max(0, args.totalLines - headLines.length - tailLines.length);
+  return `${head}
+
+[Omitted ${omitted} lines (${(args.byteLength / 1024).toFixed(1)} KB). Full output saved to ${args.displayPath}]
+
+${tail}`;
+}
+function spillLargeToolOutput(content, toolName, workspaceRoot) {
+  if (isSpilledToolOutput(content)) return content;
+  const byteLength = Buffer.byteLength(content);
+  const totalLines = countLines(content);
+  if (byteLength <= TOOL_OUTPUT_SPILL_BYTES && totalLines <= TOOL_OUTPUT_SPILL_LINES) return content;
+  try {
+    const spill = spillToolOutput({ content, toolName, workspaceRoot });
+    return formatSpilledToolOutput({ head: content, tail: content, totalLines, byteLength, displayPath: spill.displayPath });
+  } catch {
+    return content;
+  }
+}
+
 // packages/agent-runtime/processTaskResult.ts
 var PROCESS_RESULT_CAPSULE_TAIL_CHARS = 4e3;
 var PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS = 2e4;
@@ -959,6 +1000,27 @@ function tailText(value, maxChars) {
   if (value.length <= maxChars) return { text: value, truncated: false };
   return { text: value.slice(-maxChars), truncated: true };
 }
+function reuseStreamSpill(text, workspaceRoot) {
+  const displayPath = /Full output saved to ([^\n]+?)\]/.exec(text)?.[1];
+  if (!displayPath) return void 0;
+  const path = isAbsolute2(displayPath) ? displayPath : workspaceRoot ? resolve(workspaceRoot, displayPath) : void 0;
+  if (!path) return void 0;
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(64 * 1024);
+    const decoder = new StringDecoder("utf8");
+    let totalChars = 0, newlines = 0;
+    const count = (chunk) => {
+      totalChars += chunk.length;
+      for (let i = chunk.indexOf("\n"); i >= 0; i = chunk.indexOf("\n", i + 1)) newlines++;
+    };
+    for (let bytes; (bytes = readSync(fd, buffer, 0, buffer.length, null)) > 0; ) count(decoder.write(buffer.subarray(0, bytes)));
+    count(decoder.end());
+    return { displayPath, totalChars, totalLines: totalChars ? newlines + 1 : 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
 function formatCapsuleStream(name, value) {
   return value.trim() ? `${name}:
 ${value.replace(/\n+$/, "")}` : "";
@@ -980,10 +1042,33 @@ function buildProcessTaskResultCapsule(args) {
   const stderrTail = tailText(stderrTailSource, tailChars);
   const inlineSize = stdout.length + stderr.length;
   const inlineTruncated = stdoutTail.truncated || stderrTail.truncated;
-  const truncated = inlineTruncated || ringEvicted || Boolean(captureError);
+  const truncated = inlineTruncated || ringEvicted || Boolean(captureError) || isSpilledToolOutput(stdout) || isSpilledToolOutput(stderr);
   const shouldSpill = truncated || inlineSize > spillThresholdChars;
   let spill;
-  if (shouldSpill) {
+  let streamSpills;
+  if (isSpilledToolOutput(stdout) || isSpilledToolOutput(stderr)) {
+    streamSpills = {};
+    for (const [name, text] of [["stdout", stdout], ["stderr", stderr]]) {
+      if (!text) continue;
+      try {
+        if (isSpilledToolOutput(text)) {
+          streamSpills[name] = reuseStreamSpill(text, args.workspaceRoot);
+        } else {
+          const result = spillToolOutput({ content: text, toolName: "execShell", workspaceRoot: args.workspaceRoot });
+          streamSpills[name] = { displayPath: result.displayPath, totalChars: result.totalChars, totalLines: result.totalLines };
+        }
+      } catch {
+      }
+    }
+    const primary = streamSpills.stdout ?? streamSpills.stderr;
+    if (primary) {
+      spill = {
+        displayPath: primary.displayPath,
+        totalChars: (streamSpills.stdout?.totalChars ?? 0) + (streamSpills.stderr?.totalChars ?? 0),
+        totalLines: (streamSpills.stdout?.totalLines ?? 0) + (streamSpills.stderr?.totalLines ?? 0)
+      };
+    }
+  } else if (shouldSpill) {
     try {
       const result = spillToolOutput({
         content: [
@@ -1011,11 +1096,16 @@ function buildProcessTaskResultCapsule(args) {
     ...durationMs !== void 0 ? { durationMs } : {},
     ...captureError ? { captureError } : {},
     truncated,
-    ...spill ? { spill } : {}
+    ...spill ? { spill } : {},
+    ...streamSpills ? { streamSpills } : {}
   };
 }
 
 // packages/agent-runtime/workspaceShell.ts
+var shellChildEnvironment = new AsyncLocalStorage();
+function withShellChildEnvironment(env, run) {
+  return shellChildEnvironment.run(env, run);
+}
 var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
 var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
 var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
@@ -1310,19 +1400,33 @@ function resolveDetachMs(override) {
   return parsed === void 0 ? DEFAULT_EXEC_SHELL_DETACH_MS : parsed;
 }
 function truncateToolOutput(value, limit = 2e4, options) {
+  if (isSpilledToolOutput(value)) return value;
   if (value.length <= limit) return value;
   let spillNote = "";
+  let spillPathOnly = "";
   try {
     const spill = spillToolOutput({
       content: value,
       toolName: options?.toolName ?? "execShell",
       workspaceRoot: options?.workspaceRoot
     });
-    spillNote = `; spillFile=${spill.displayPath}; totalLines=${spill.totalLines}`;
+    spillNote = `; spillFile=${spill.displayPath}; totalLines=${spill.totalLines}; hint=read a range, not the whole spill (readFile lines=A-B or sed -n 'A,Bp'); a full read re-injects ${spill.totalChars} chars`;
+    spillPathOnly = `; spillFile=${spill.displayPath}`;
   } catch {
   }
   const approxMarkerLen = 40 + spillNote.length;
-  if (limit <= approxMarkerLen) return value.slice(0, limit);
+  if (limit <= approxMarkerLen) {
+    const notice = `[... truncated ${value.length} chars]`;
+    const withFullNote = `[... truncated ${value.length} chars${spillNote} ...]`;
+    if (withFullNote.length <= limit) return withFullNote;
+    const withPath = `[... truncated ${value.length} chars${spillPathOnly} ...]`;
+    if (withPath.length <= limit) return withPath;
+    if (notice.length <= limit) {
+      const pathOmitted = " [... path omitted]";
+      return notice.length + pathOmitted.length <= limit ? notice + pathOmitted : notice;
+    }
+    return limit <= 0 ? "" : "\u2026";
+  }
   const remaining = limit - approxMarkerLen;
   const headSize = Math.floor(remaining * 0.3);
   const tailSize = remaining - headSize;
@@ -1352,6 +1456,9 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
   return new Promise((resolveStream, rejectStream) => {
     const chunks = [];
     let totalBytes = 0;
+    let observedBytes = 0;
+    let observedLines = 1;
+    let tail = Buffer.alloc(0);
     let settled = false;
     let captureResolved = false;
     const resolveCapture = (text) => {
@@ -1481,6 +1588,16 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
         await settleSpillRetention();
         if (captureResolved) return;
         let text = baseText;
+        if (truncatedNow && spillRetainedPath && sourceEnded && options.maxLines !== void 0) {
+          resolveCapture(formatSpilledToolOutput({
+            head: baseText,
+            tail: tail.toString("utf8"),
+            totalLines: observedLines,
+            byteLength: observedBytes,
+            displayPath: spillRetainedPath
+          }));
+          return;
+        }
         if (truncatedNow) {
           const notes = [`output exceeded ${formatLimit} buffer limit`];
           if (spillRetainedPath && sourceEnded) {
@@ -1548,11 +1665,16 @@ function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BY
     stream.on("data", (chunk) => {
       if (settled) return;
       const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      observedBytes += buf.length;
+      for (const byte of buf) if (byte === 10) observedLines++;
+      if (options.maxLines !== void 0) {
+        tail = Buffer.concat([tail, buf.subarray(Math.max(0, buf.length - maxBytes))]).subarray(-maxBytes);
+      }
       if (truncated) {
         writeToSink(buf);
         return;
       }
-      if (totalBytes + buf.length >= maxBytes) {
+      if (totalBytes + buf.length >= maxBytes || observedLines > (options.maxLines ?? Infinity)) {
         const remaining = Math.max(0, maxBytes - totalBytes);
         const headChunks = chunks.slice();
         if (remaining > 0) {
@@ -1644,7 +1766,8 @@ async function runWorkspaceCommand(args) {
   ];
   const spawnedAt = Date.now();
   const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
-    cwd: resolve(args.workspaceRoot),
+    cwd: resolve2(args.workspaceRoot),
+    env: { ...process.env, ...shellChildEnvironment.getStore() },
     stdio: [
       args.stdin === void 0 ? "ignore" : "pipe",
       "pipe",
@@ -1704,6 +1827,8 @@ async function runWorkspaceCommand(args) {
   let stderrIncomplete;
   const stdoutCapture = stdoutPromiseResult(
     readNodeStream(proc.stdout, {
+      maxBytes: TOOL_OUTPUT_SPILL_BYTES,
+      maxLines: TOOL_OUTPUT_SPILL_LINES,
       spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}.log`),
       spillRetention: "promote",
       spillWorkspaceRoot: args.workspaceRoot
@@ -1716,6 +1841,8 @@ async function runWorkspaceCommand(args) {
   ).then((result) => ({ ...result, error: result.error || stdoutIncomplete }));
   const stderrCapture = stdoutPromiseResult(
     readNodeStream(proc.stderr, {
+      maxBytes: TOOL_OUTPUT_SPILL_BYTES,
+      maxLines: TOOL_OUTPUT_SPILL_LINES,
       spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}-stderr.log`),
       spillRetention: "promote",
       spillWorkspaceRoot: args.workspaceRoot
@@ -1955,8 +2082,6 @@ ${stderr.trim()}` : "",
 }
 
 export {
-  spillToolOutput,
-  formatToolOverflowMarker,
   resolveExecutableOnPath,
   createGlob,
   spawnToWebStreams,
@@ -1964,7 +2089,12 @@ export {
   reportedTaskStatus,
   toProcessTaskView,
   getProcessRegistry,
+  spillToolOutput,
+  formatToolOverflowMarker,
+  isSpilledToolOutput,
+  spillLargeToolOutput,
   buildProcessTaskResultCapsule,
+  withShellChildEnvironment,
   extractActivity,
   findPowerShellExecutable,
   buildWorkspaceShellPlan,

package/{chunk-LEC5ALIN.js → chunk-KEPOVMF4.js}

@@ -1,6 +1,6 @@
 import {
   dialogMessageKey
-} from "./chunk-XJWWBO34.js";
+} from "./chunk-OJKUU3LP.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";

package/{chunk-UHJGXRJ4.js → chunk-KQSYAIZR.js}

@@ -5,15 +5,15 @@ import {
   ANTIGRAVITY_CLOUD_CODE_BASE_URL,
   isAntigravityCloudCodeBaseUrl,
   isAntigravityOAuthAgent
-} from "./chunk-KIM6CLW5.js";
+} from "./chunk-SY3C4SQ7.js";
 import {
   isOpenAiResponsesModel,
   resolvePlatformChatCompletionsEndpoint,
   resolvePlatformResponsesEndpoint
-} from "./chunk-YUA6OAH5.js";
+} from "./chunk-MDLS23JK.js";
 import {
   findModelConfig
-} from "./chunk-SM3NSZJV.js";
+} from "./chunk-2UCBGYO4.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";

package/{chunk-4VJAC32I.js → chunk-L5I543VB.js}

@@ -43,7 +43,7 @@ var normalizeLocale = (value) => {
   return language;
 };
 var resolveUserResponseLanguage = (input = {}) => {
-  const raw = asLocale(input.responseLanguage) || asLocale(input.language) || asLocale(input.fallbackLanguage) || "en-US";
+  const raw = asLocale(input.language) || "en-US";
   const locale = normalizeLocale(raw);
   return {
     locale,
@@ -80,7 +80,8 @@ var MEMORY_USE_GUIDANCE = `--- \u8BB0\u5FC6\u4F7F\u7528\u65B9\u5F0F ---
 - \u8BB0\u5FC6\u542B\u7528\u6237\u8EAB\u4EFD/\u79F0\u547C/\u5173\u7CFB/\u957F\u671F\u504F\u597D/\u9879\u76EE\u80CC\u666F\u65F6\uFF0C\u76F8\u5173\u5904\u81EA\u7136\u4F53\u73B0\uFF08\u5F00\u573A\u79F0\u547C\u3001\u4E0A\u4E0B\u6587\u786E\u8BA4\u3001\u56DE\u7B54\u7ED3\u6784\u3001\u53D6\u820D\u6807\u51C6\uFF09\uFF0C\u4E0D\u8981\u6BCF\u53E5\u673A\u68B0\u79F0\u547C\u7528\u6237\u3002
 - \u201C\u4E0A\u6B21/\u7EE7\u7EED/\u8FD9\u4E2A\u9879\u76EE\u201D\u7B49\u6307\u4EE3\u4F18\u5148\u6309\u5F53\u524D dialog/space/project/agent/sourceDialog \u7B49 KV \u8DEF\u5F84\u548C\u65F6\u95F4\u7EBF\u5B9A\u4F4D\uFF0C\u4E0D\u8981\u53EA\u6309\u8BED\u4E49\u76F8\u4F3C\u5EA6\u635E\u4E00\u6761\u3002
 - \u63A8\u65AD\u578B\u8BB0\u5FC6\uFF08inferred\uFF09\u53EA\u7528\u4E8E\u628A\u63E1\u8BED\u6C14\u3001\u72B6\u6001\u548C\u672A\u5B8C\u6210\u4E8B\u9879\uFF0C\u4E0D\u8981\u8BF4\u6210\u201C\u4F60\u660E\u786E\u544A\u8BC9\u8FC7\u6211\u201D\u6216\u5F53\u6210\u7528\u6237\u5DF2\u6388\u6743\u4FDD\u5B58\u7684\u4E8B\u5B9E\uFF1B\u51B2\u7A81\u6216\u573A\u666F\u4E0D\u660E\u65F6\u8BF4\u660E\u4F9D\u636E\u6216\u7B80\u77ED\u786E\u8BA4\uFF0C\u4E0D\u8981\u786C\u5957\u3002
-- \u7F6E\u4FE1\u5EA6\uFF08verified/stated/inferred\uFF09\u3001\u53EC\u56DE\u4E0A\u4E0B\u6587\u8981\u6C42\u4E0E\u964D\u6743/\u5220\u9664\u8FB9\u754C\u4EE5\u8BB0\u5FC6\u5DE5\u5177\uFF08rememberMemory / queryMemory / deleteMemory\uFF09schema \u4E3A\u51C6\u3002`;
+- \u7F6E\u4FE1\u5EA6\uFF08verified/stated/inferred\uFF09\u3001\u53EC\u56DE\u4E0A\u4E0B\u6587\u8981\u6C42\u4E0E\u964D\u6743/\u5220\u9664\u8FB9\u754C\u4EE5\u8BB0\u5FC6\u5DE5\u5177\uFF08rememberMemory / queryMemory / deleteMemory\uFF09schema \u4E3A\u51C6\u3002
+- \u7528\u6237\u660E\u786E\u8868\u8FBE**\u8DE8\u4F1A\u8BDD**\u7684\u6253\u6270\u5F3A\u5EA6\u504F\u597D\u65F6\uFF08\u5982\u300C\u4EE5\u540E\u90FD\u53EA\u62A5\u7ED3\u679C\u300D\u300C\u6BCF\u6B21\u90FD\u7ED9\u6211\u770B\u8BE6\u7EC6\u8FC7\u7A0B\u300D\uFF0C\u800C\u975E\u4E00\u6B21\u4EFB\u52A1\u91CC\u7684\u300C\u8FD9\u6B21\u522B\u70E6\u6211\u300D\uFF09\uFF0C\u7528 rememberMemory \u8BB0\u4E3A\u7528\u6237\u504F\u597D\uFF1B\u4E4B\u540E\u6309\u5B83\u8C03\u6574 ignore / FYI / important \u7684\u8BE6\u7565\u3002\u8BB0\u5FC6\u504F\u597D\u7EDD\u4E0D\u80FD\u53D6\u6D88 decision / blocked / failed \u4E09\u7C7B\u5FC5\u987B\u62A5\u7684\u5185\u5BB9\u3002`;
 
 export {
   buildUserResponseLanguageContext,

package/chunk-LKA64WH4.js

@@ -0,0 +1,227 @@
+import {
+  canonicalizeToolName
+} from "./chunk-6OVNSQHN.js";
+
+// packages/ai/tools/toolExecutionSemantics.ts
+var UNKNOWN_TOOL_EXECUTION_CONTRACT = {
+  replay: "unknown",
+  sideEffects: "unknown",
+  locality: "unknown",
+  interaction: "unknown",
+  concurrency: "exclusive",
+  durableWebForeground: false
+};
+var serverPureRead = (durableWebForeground) => ({
+  replay: "pure",
+  sideEffects: "none",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverExternalRead = (durableWebForeground) => ({
+  // Repeating the request should not mutate the target resource, but may spend
+  // provider quota/money and may observe newer remote state; it is not pure.
+  replay: "idempotent",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverConfirmedHandoffStep = () => ({
+  replay: "unsafe",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "handoff",
+  concurrency: "exclusive",
+  durableWebForeground: false
+});
+var TOOL_EXECUTION_CONTRACT = Object.freeze({
+  // Proven durable network reads. They execute on the server but touch external
+  // systems, so replay/cost semantics are intentionally not called "pure".
+  exa_search: serverExternalRead("read-only"),
+  fetchWebpage: serverExternalRead("read-only"),
+  // Proven durable server-hosted workspace reads/queries.
+  searchDialogMessages: serverPureRead("read-only"),
+  listDialogs: serverPureRead("read-only"),
+  readDialog: serverPureRead("read-only"),
+  queryDialogsBySubjectRef: serverPureRead("read-only"),
+  listAgents: serverPureRead("read-only"),
+  readAgent: serverPureRead("read-only"),
+  listSpaces: serverPureRead("read-only"),
+  readSpace: serverPureRead("read-only"),
+  readDoc: serverPureRead("read-only"),
+  readSkillDoc: serverPureRead("read-only"),
+  listTables: serverPureRead("read-only"),
+  queryTableRows: serverPureRead("read-only"),
+  list_cloud_resources: serverPureRead("read-only"),
+  cloud_probe: serverPureRead("read-only"),
+  // Audited execution against an owned cloud resource. Same class as execShell
+  // (arbitrary command, not replayable), except the executor itself runs on the
+  // server through the authorization/capability/audit gate. Never read-only.
+  cloud_exec: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  // Read-only presentation payload. Actions remain inert; this adds no submit or
+  // open-app authority to server-owned projection.
+  show_interaction: {
+    replay: "pure",
+    sideEffects: "none",
+    locality: "server",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: "read-only"
+  },
+  // Durable interactive boundary: the current execution ends and a later user
+  // choice starts a new execution. It is intentionally not modeled as a read.
+  ask_user: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "blocking",
+    concurrency: "exclusive",
+    durableWebForeground: "interactive"
+  },
+  // Confirmed human hand-off boundary for the media step family. These tools
+  // do not start work needing authorization: they return
+  // `{ status: "requires_confirmation", ... }` and the run must stop and wait
+  // for the user. Registered explicitly (rather than inferred from any status)
+  // so a random tool echoing the same status never pauses the run, and kept out
+  // of the durable Web foreground plane on purpose (media ServerTool admission
+  // is owned elsewhere).
+  transcribe: serverConfirmedHandoffStep(),
+  translate: serverConfirmedHandoffStep(),
+  exportDocument: serverConfirmedHandoffStep(),
+  readArtifact: serverConfirmedHandoffStep(),
+  // Representative explicitly non-durable execution classes. These entries
+  // make the reason machine-readable; unlisted tools remain UNKNOWN.
+  execShell: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "workspace",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  readFile: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  globFiles: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  createDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  updateDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  createHtmlArtifact: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: "mutating"
+  },
+  readHtmlArtifact: serverPureRead("read-only"),
+  updateHtmlArtifact: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: "mutating"
+  },
+  deleteDialogs: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "confirm",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  loadSkill: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  }
+});
+function resolveToolExecutionContract(toolName) {
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    return UNKNOWN_TOOL_EXECUTION_CONTRACT;
+  }
+  const canonicalName = canonicalizeToolName(toolName);
+  return TOOL_EXECUTION_CONTRACT[canonicalName] ?? UNKNOWN_TOOL_EXECUTION_CONTRACT;
+}
+function collectDurableWebToolNames(durableClass) {
+  return new Set(
+    Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.durableWebForeground === durableClass).map(([name]) => name)
+  );
+}
+var DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES = collectDurableWebToolNames("read-only");
+var DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES = collectDurableWebToolNames("interactive");
+var DURABLE_WEB_FOREGROUND_MUTATING_TOOL_NAMES = collectDurableWebToolNames("mutating");
+var DURABLE_WEB_FOREGROUND_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ...DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES,
+  ...DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES,
+  ...DURABLE_WEB_FOREGROUND_MUTATING_TOOL_NAMES
+]);
+var CONFIRMED_HANDOFF_TOOL_NAMES = new Set(
+  Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.interaction === "handoff").map(([name]) => name)
+);
+function hasProvenServerReadOnlySemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  return contract.durableWebForeground === "read-only" && (contract.replay === "pure" || contract.replay === "idempotent") && (contract.sideEffects === "none" || contract.sideEffects === "observable") && contract.locality === "server" && contract.interaction === "none";
+}
+function hasProvenServerMutatingSemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  return contract.durableWebForeground === "mutating" && (contract.replay === "unsafe" || contract.replay === "deduplicated") && contract.sideEffects === "mutation" && contract.locality === "server" && contract.interaction === "none";
+}
+function hasProvenDurableWebForegroundSemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  if (contract.durableWebForeground === "read-only") {
+    return hasProvenServerReadOnlySemantics(toolName);
+  }
+  if (contract.durableWebForeground === "interactive") {
+    return contract.locality === "server" && contract.interaction === "blocking" && contract.sideEffects === "observable";
+  }
+  if (contract.durableWebForeground === "mutating") {
+    return hasProvenServerMutatingSemantics(toolName);
+  }
+  return false;
+}
+
+export {
+  resolveToolExecutionContract,
+  DURABLE_WEB_FOREGROUND_TOOL_NAMES,
+  hasProvenDurableWebForegroundSemantics
+};

package/{chunk-QHPRUL4O.js → chunk-LVL6GFCM.js}

@@ -1,18 +1,18 @@
 import {
   fetchReferenceContents,
   resolveReferenceAssets
-} from "./chunk-TX5EYMGT.js";
+} from "./chunk-GYVCJABP.js";
 import {
   updateTokensAction
-} from "./chunk-ZXOUUDCG.js";
+} from "./chunk-MZLE5HQ3.js";
 import {
   applyUpdateTokensFulfilled
-} from "./chunk-OWYYDMGJ.js";
+} from "./chunk-S2NTVGA2.js";
 import {
   extractReasoningFromResponseOutput,
   extractTextFromResponseOutput,
   extractToolCallsFromResponseOutput
-} from "./chunk-H5HF7TJA.js";
+} from "./chunk-MAIITKBT.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";

package/{chunk-H5HF7TJA.js → chunk-MAIITKBT.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-E2BESSAW.js";
 import {
   getModelContextWindow
-} from "./chunk-7BT37FK3.js";
+} from "./chunk-RDH5CQ4T.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
@@ -18,7 +18,7 @@ import {
   PLATFORM_HOSTED_KIMI_K3_MODEL,
   isFireworksKimiModel,
   isNoloHostedProvider
-} from "./chunk-GOO6G4PY.js";
+} from "./chunk-CKG3PRZ7.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";