stitchkit 0.110.1 → 0.110.2

package/dist/entrypoints/agent-runtime.js

@@ -1,3 +1,11 @@
+import {
+  AgentSandboxRestrictionSchema2,
+  AgentSandboxGradeSchema2,
+  probeAgentProcessSandbox2,
+  missingSandboxRestrictions2,
+  recordAgentSandboxProbe2,
+  refuseUnknownSpillReference
+} from "../index-bm180f2d.js";
 import {
   AgentRecordIdSchema2,
   AgentRecordVersionSchema2,
@@ -36,6 +44,9 @@ import {
   AgentRunMetricsSchema2
 } from "../index-8kzct1d6.js";
 import {
+  BranchAgentConversationInputSchema2,
+  AgentConversationBranchReceiptSchema2,
+  AgentConversationBranchResultSchema2,
   AgentConversationPurgeInputSchema2,
   AgentConversationPurgeResultSchema2,
   AgentConversationPurgedError2,
@@ -47,7 +58,7 @@ import {
   AgentHistoryMutationSchema2,
   ACTIVE_AGENT_RUN_STATES2,
   createAgentRuntimeStore2
-} from "../index-d2h99n7d.js";
+} from "../index-s2bgwsyr.js";
 import {
   AgentStoreEventKindSchema2,
   AgentStoreEventEnvelopeSchema2,
@@ -79,7 +90,7 @@ import {
   decodeAgentConversationArchive2,
   isAssistantHistoryEvidence2,
   isCompleteAgentHistoryTurn
-} from "../index-0gs4ymfj.js";
+} from "../index-6qeqdz0z.js";
 import"../index-5w6t91ze.js";
 import {
   AgentRuntimeConflictError2,
@@ -111,7 +122,7 @@ import {
   agentGoalStateSlot2,
   agentTodoStateSlot2,
   createAgentRuntime2
-} from "../index-924500c3.js";
+} from "../index-79zxnh52.js";
 import {
   AgentConversationSummarySchema2,
   AgentConversationPageSchema2,
@@ -127,7 +138,7 @@ import"../index-ghwntn9n.js";
 import {
   mountAgent2,
   buildToolManifest2
-} from "../index-8rstkvcf.js";
+} from "../index-7c046kxr.js";
 import {
   createBoundedSinkManager
 } from "../index-qaet40b2.js";
@@ -172,21 +183,18 @@ import {
   StepAbortedError2,
   ParkRecordDecodeError2,
   ParkAbortedError2
-} from "../index-c17xcx4k.js";
-import {
-  AgentSandboxRestrictionSchema2,
-  AgentSandboxGradeSchema2,
-  probeAgentProcessSandbox2,
-  missingSandboxRestrictions2,
-  recordAgentSandboxProbe2,
-  refuseUnknownSpillReference
-} from "../index-8ks9b85e.js";
+} from "../index-snef22zr.js";
+import"../index-56yx8dxp.js";
+import"../index-2kbysk9s.js";
+import"../index-84bf5spd.js";
 import {
   createMemoryAgentRuntimeStore2
-} from "../index-5p55xreg.js";
+} from "../index-e9rbhw1s.js";
 import {
   createAgentRuntimeEventSink2
 } from "../index-616xh7f2.js";
+import"../index-e1sjcjfy.js";
+import"../index-zrtrjkbf.js";
 import {
   MAX_TIMER_MS
 } from "../index-eemvahkc.js";
@@ -202,7 +210,6 @@ import {
   createTraceContext2,
   childSpan2
 } from "../index-yex7eg1v.js";
-
 // src/agent-runtime/child-tools.ts
 import { z as z2 } from "zod";
 
@@ -2614,6 +2621,8 @@ export {
   AgentContextOverflowError2 as AgentContextOverflowError,
   AgentControlPartSchema2 as AgentControlPartSchema,
   AgentConversationArchiveSchema2 as AgentConversationArchiveSchema,
+  AgentConversationBranchReceiptSchema2 as AgentConversationBranchReceiptSchema,
+  AgentConversationBranchResultSchema2 as AgentConversationBranchResultSchema,
   AgentConversationMessagePageSchema2 as AgentConversationMessagePageSchema,
   AgentConversationPageSchema2 as AgentConversationPageSchema,
   AgentConversationPurgeInputSchema2 as AgentConversationPurgeInputSchema,
@@ -2702,6 +2711,7 @@ export {
   AgentUsageSchema2 as AgentUsageSchema,
   AgentUsageValueSchema2 as AgentUsageValueSchema,
   AppendAgentStoreEventSchema2 as AppendAgentStoreEventSchema,
+  BranchAgentConversationInputSchema2 as BranchAgentConversationInputSchema,
   CheckpointRunAssistantSchema2 as CheckpointRunAssistantSchema,
   CommitRunTerminalSchema2 as CommitRunTerminalSchema,
   CompletionInvocationInputSchema2 as CompletionInvocationInputSchema,

package/dist/entrypoints/tools.js

@@ -1,9 +1,11 @@
 import {
-  EffectUnresolvedError2,
+  EffectUnresolvedError2
+} from "../index-snef22zr.js";
+import {
   createLocalStepDurability2,
   AgentToolError2,
   isAgentToolError2
-} from "../index-c17xcx4k.js";
+} from "../index-56yx8dxp.js";
 import {
   normalizeError2
 } from "../index-fynr93w4.js";
@@ -31,7 +33,7 @@ import {
   mountAgent2,
   describeToolCatalog2,
   buildToolManifest2
-} from "../index-8rstkvcf.js";
+} from "../index-7c046kxr.js";
 import"../index-m38ej7e5.js";
 import {
   ALL_TRANSPORTS2,

package/dist/{index-c17xcx4k.js → index-56yx8dxp.js}

@@ -1,3 +1,19 @@
+import {
+  DURABILITY_STEP_EVENT_KIND2,
+  DURABILITY_PARK_EVENT_KIND,
+  DURABILITY_EVENT_EVENT_KIND,
+  DURABILITY_EFFECT_EVENT_KIND,
+  StepEventPayloadSchema,
+  ParkEventPayloadSchema,
+  DeliveredEventPayloadSchema,
+  EffectEventPayloadSchema,
+  StepResultDecodeError2,
+  StepResultNotSerializableError2,
+  StepAbortedError2,
+  EffectUnresolvedError2,
+  ParkRecordDecodeError2,
+  ParkAbortedError2
+} from "./index-snef22zr.js";
 import {
   raceAbort
 } from "./index-b0kddvzw.js";
@@ -8,102 +24,9 @@ import {
   MAX_TIMER_MS
 } from "./index-eemvahkc.js";
 
-// src/durability/contract.ts
-import { z } from "zod";
-var DURABILITY_STEP_EVENT_KIND2 = "durability/step";
-var DURABILITY_PARK_EVENT_KIND = "durability/park";
-var DURABILITY_EVENT_EVENT_KIND = "durability/event";
-var DURABILITY_EFFECT_EVENT_KIND = "durability/effect";
-var StepEventPayloadSchema = z.object({
-  runId: z.string().min(1),
-  stepName: z.string().min(1),
-  encoded: z.string()
-});
-var SleepParkSchema = z.object({
-  runId: z.string().min(1),
-  kind: z.literal("sleep"),
-  name: z.string().min(1),
-  deadline: z.number()
-});
-var WaitParkSchema = z.object({
-  runId: z.string().min(1),
-  kind: z.literal("wait"),
-  event: z.string().min(1),
-  id: z.string().min(1)
-});
-var ParkEventPayloadSchema = z.discriminatedUnion("kind", [
-  SleepParkSchema,
-  WaitParkSchema
-]);
-var DeliveredEventPayloadSchema = z.object({
-  runId: z.string().min(1),
-  event: z.string().min(1),
-  id: z.string().min(1),
-  encoded: z.string()
-});
-var EffectIdentity = { runId: z.string().min(1), effectName: z.string().min(1) };
-var EffectEventPayloadSchema = z.discriminatedUnion("phase", [
-  z.object({ ...EffectIdentity, phase: z.literal("intent") }),
-  z.object({
-    ...EffectIdentity,
-    phase: z.literal("accepted"),
-    encoded: z.string(),
-    via: z.enum(["run", "reconcile"])
-  }),
-  z.object({ ...EffectIdentity, phase: z.literal("uncertain") })
-]);
-
-class StepResultDecodeError2 extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "StepResultDecodeError";
-  }
-}
-
-class StepResultNotSerializableError2 extends Error {
-  constructor(stepName, cause) {
-    super(`Step "${stepName}" returned a value that is not JSON-serializable`, {
-      cause
-    });
-    this.name = "StepResultNotSerializableError";
-  }
-}
-
-class StepAbortedError2 extends Error {
-  constructor(stepName) {
-    super(`Step "${stepName}" was aborted before it started`);
-    this.name = "StepAbortedError";
-  }
-}
-
-class EffectUnresolvedError2 extends Error {
-  effectName;
-  reason;
-  constructor(effectName, reason, options) {
-    super(`Effect "${effectName}" is unresolved (${reason}); its intent stands`, options);
-    this.effectName = effectName;
-    this.reason = reason;
-    this.name = "EffectUnresolvedError";
-  }
-}
-
-class ParkRecordDecodeError2 extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ParkRecordDecodeError";
-  }
-}
-
-class ParkAbortedError2 extends Error {
-  constructor(park) {
-    super(`Park "${park}" was aborted before it was satisfied`);
-    this.name = "ParkAbortedError";
-  }
-}
-
 // src/durability/json.ts
-import { z as z2 } from "zod";
-var DurableJsonSchema = z2.custom((value) => isJsonData(value, {
+import { z } from "zod";
+var DurableJsonSchema = z.custom((value) => isJsonData(value, {
   maxDepth: 100,
   maxNodes: Number.MAX_SAFE_INTEGER,
   omitObjectUndefined: false
@@ -653,4 +576,4 @@ function resolveToolDurability(context, callId, signal) {
   return contexts.get(context)?.(callId, signal);
 }
 
-export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };
+export { createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };

package/dist/{index-0gs4ymfj.js → index-6qeqdz0z.js}

@@ -16,6 +16,8 @@ import {
 import { z } from "zod";
 var AgentStoreEventKindSchema2 = z.enum([
   "runtime/baseline",
+  "runtime/branched",
+  "runtime/branch-observation",
   "runtime/transition",
   "invocation/started",
   "invocation/finished",
@@ -188,7 +190,11 @@ var AgentStoreTransitionSchema2 = z3.discriminatedUnion("type", [
   z3.object({ type: z3.literal("checkpoint"), input: CheckpointRunAssistantSchema2 }).strict(),
   z3.object({ type: z3.literal("operation"), input: RecordRunOperationSchema2 }).strict(),
   z3.object({ type: z3.literal("interrupt"), input: RequestRunInterruptSchema2 }).strict(),
-  z3.object({ type: z3.literal("recover"), input: RecoverAgentRunSchema2 }).strict(),
+  z3.object({
+    type: z3.literal("recover"),
+    input: RecoverAgentRunSchema2,
+    assistant: AgentMessageSchema2.optional()
+  }).strict(),
   z3.object({ type: z3.literal("terminal"), input: CommitRunTerminalSchema2 }).strict(),
   z3.object({ type: z3.literal("compact"), input: ReplaceCompactedRangeSchema2 }).strict(),
   z3.object({ type: z3.literal("seed"), input: SeedConversationInputSchema2 }).strict()

package/dist/{index-924500c3.js → index-79zxnh52.js}

@@ -22,7 +22,7 @@ import {
   createLocalStepDurability2,
   isAgentToolError2,
   createToolDurabilityContext
-} from "./index-c17xcx4k.js";
+} from "./index-56yx8dxp.js";
 import {
   canonicalAgentJson2,
   createToolChronology,
@@ -31,7 +31,7 @@ import {
   isAssistantHistoryEvidence2,
   isCompleteAgentHistoryTurn,
   assistantStatus
-} from "./index-0gs4ymfj.js";
+} from "./index-6qeqdz0z.js";
 import {
   messageOf
 } from "./index-g149e9pk.js";

package/dist/{index-8rstkvcf.js → index-7c046kxr.js}

@@ -10,7 +10,7 @@ import {
 import {
   AgentToolError2,
   resolveToolDurability
-} from "./index-c17xcx4k.js";
+} from "./index-56yx8dxp.js";
 import {
   collectToolSurface
 } from "./index-0d8m0kee.js";

package/dist/{index-tjdsyrys.js → index-bm180f2d.js}

@@ -4,13 +4,6 @@ import {
 import {
   NativeCommandError2
 } from "./index-84bf5spd.js";
-import {
-  probeAgentProcessSandboxOutcome,
-  missingSandboxRestrictions2,
-  codingRefusal,
-  codingPathRefusal,
-  refuseMissingCodingPath
-} from "./index-8ks9b85e.js";
 import {
   CommandStopped,
   startNativeCommand
@@ -36,8 +29,10 @@ import {
   defineRuntimeTool2
 } from "./index-636mggad.js";
 import {
+  AppError2,
   forbidden2,
-  conflict2
+  conflict2,
+  STITCH_ERROR_STATUS2
 } from "./index-j9gxbztg.js";
 
 // src/agent-runtime/coding-tool-contract.ts
@@ -183,9 +178,80 @@ function resolveCodingToolLimits(input) {
   return AgentCodingToolLimitsSchema2.parse({ ...DEFAULT_LIMITS, ...input });
 }
 
+// src/agent-runtime/sandbox.ts
+import { z as z2 } from "zod";
+var AgentSandboxRestrictionSchema2 = z2.enum([
+  "network-denied",
+  "write-contained",
+  "secrets-hidden",
+  "process-contained"
+]);
+var AgentSandboxGradeSchema2 = z2.discriminatedUnion("grade", [
+  z2.object({ grade: z2.literal("full"), restrictions: z2.array(AgentSandboxRestrictionSchema2) }).strict(),
+  z2.object({
+    grade: z2.literal("partial"),
+    restrictions: z2.array(AgentSandboxRestrictionSchema2),
+    gaps: z2.array(AgentSandboxRestrictionSchema2)
+  }).strict(),
+  z2.object({ grade: z2.literal("unavailable"), reason: z2.string().min(1) }).strict()
+]);
+var probes = new WeakMap;
+var PROBE_FAILED = "sandbox probe failed";
+var PROBE_INVALID = "sandbox probe returned no valid grade";
+async function runProbe(sandbox) {
+  let value;
+  try {
+    value = await sandbox.probe();
+  } catch (cause) {
+    return { grade: { grade: "unavailable", reason: PROBE_FAILED }, cause };
+  }
+  const parsed = AgentSandboxGradeSchema2.safeParse(value);
+  if (parsed.success)
+    return { grade: parsed.data };
+  return { grade: { grade: "unavailable", reason: PROBE_INVALID }, cause: parsed.error };
+}
+function probeAgentProcessSandboxOutcome(sandbox, options = {}) {
+  if (options.refresh)
+    probes.delete(sandbox);
+  const present = probes.get(sandbox);
+  if (present)
+    return present;
+  const pending = runProbe(sandbox);
+  probes.set(sandbox, pending);
+  return pending;
+}
+async function probeAgentProcessSandbox2(sandbox, options = {}) {
+  const fresh = options.refresh === true || !probes.has(sandbox);
+  const outcome = await probeAgentProcessSandboxOutcome(sandbox, options);
+  if (fresh && outcome.cause !== undefined) {
+    process.emitWarning(new Error("Sandbox probe failed", { cause: outcome.cause }));
+  }
+  return outcome.grade;
+}
+function missingSandboxRestrictions2(grade, required) {
+  if (grade.grade === "unavailable")
+    return required;
+  const present = new Set(grade.restrictions);
+  return required.filter((restriction) => !present.has(restriction));
+}
+async function recordAgentSandboxProbe2(input) {
+  const grade = await probeAgentProcessSandbox2(input.sandbox);
+  const missing = missingSandboxRestrictions2(grade, input.required);
+  await input.store.appendEvent({
+    conversationId: input.conversationId,
+    kind: "sandbox/probed",
+    payload: {
+      result: grade,
+      required: [...input.required],
+      missing: [...missing]
+    }
+  });
+  return grade;
+}
+
 // src/agent-runtime/coding-tools.ts
 import path5 from "node:path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/agent-runtime/coding-tool-files.ts
 import { createHash } from "node:crypto";
@@ -194,6 +260,60 @@ import { realpath as realpath2 } from "node:fs/promises";
 // src/agent-runtime/coding-tool-paths.ts
 import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
+
+// src/agent-runtime/coding-tool-refusals.ts
+function codingRefusal(code, message, options = {}) {
+  throw new AppError2(code, {
+    message,
+    status: STITCH_ERROR_STATUS2[code],
+    details: { message, ...options.details },
+    hint: options.hint,
+    ..."cause" in options && { cause: options.cause }
+  });
+}
+function codingPathRefusal(code, message, path, options = {}) {
+  codingRefusal(code, message, {
+    details: { path, ...options.details },
+    ...options.hint && { hint: options.hint }
+  });
+}
+function refuseMissingCodingPath(error, relative) {
+  const code = error?.code;
+  if (error instanceof Error && error.message.includes("is not a regular file")) {
+    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+      hint: "Use list_directory to see what is here."
+    });
+  }
+  if (code === "ENOENT") {
+    codingPathRefusal("NOT_FOUND", "This path does not exist", relative, {
+      hint: "Use list_directory or glob to find the right path."
+    });
+  }
+  if (code === "ENOTDIR") {
+    codingPathRefusal("BAD_REQUEST", "A segment of this path is not a directory", relative, {
+      hint: "Check the path with list_directory."
+    });
+  }
+  if (code === "ELOOP") {
+    codingPathRefusal("FORBIDDEN", "This path is a symlink, which is not followed", relative, {
+      hint: "Read or write the target directly, by its own workspace-relative path."
+    });
+  }
+  if (code === "EISDIR") {
+    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+      hint: "Use list_directory to see what is here."
+    });
+  }
+  throw error;
+}
+function refuseUnknownSpillReference(reference) {
+  codingRefusal("SPILL_REFERENCE_UNKNOWN", `No spilled output is held under \`${reference}\``, {
+    details: { reference },
+    hint: "Use the reference returned by the command that spilled its output, not a session or call id."
+  });
+}
+
+// src/agent-runtime/coding-tool-paths.ts
 function within(root, target) {
   const relative = path.relative(root, target);
   return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
@@ -579,7 +699,7 @@ function createFileCodingTools(config, limits) {
 // src/agent-runtime/coding-tool-listing.ts
 import { realpath as realpath3 } from "node:fs/promises";
 import path3 from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var DEFAULT_EXCLUDED_DIRECTORIES = [
   ".git",
   ".next",
@@ -589,28 +709,28 @@ var DEFAULT_EXCLUDED_DIRECTORIES = [
   "dist",
   "node_modules"
 ];
-var ListInputSchema = z2.object({ path: z2.string().min(1).default(".") }).strict();
-var ListOutputSchema = z2.object({
-  path: z2.string().min(1),
-  entries: z2.array(z2.object({
-    name: z2.string().min(1),
-    kind: z2.enum(["file", "directory", "symlink", "other"]),
-    bytes: z2.int().nonnegative().optional(),
-    excluded: z2.boolean().optional()
+var ListInputSchema = z3.object({ path: z3.string().min(1).default(".") }).strict();
+var ListOutputSchema = z3.object({
+  path: z3.string().min(1),
+  entries: z3.array(z3.object({
+    name: z3.string().min(1),
+    kind: z3.enum(["file", "directory", "symlink", "other"]),
+    bytes: z3.int().nonnegative().optional(),
+    excluded: z3.boolean().optional()
   }).strict()),
-  truncated: z2.boolean(),
-  denied: z2.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z2.boolean().optional()
+  truncated: z3.boolean(),
+  denied: z3.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z3.boolean().optional()
 }).strict();
-var GlobInputSchema = z2.object({ pattern: z2.string().min(1), path: z2.string().min(1).default(".") }).strict();
-var GlobOutputSchema = z2.object({
-  paths: z2.array(z2.string().min(1)),
-  truncated: z2.boolean(),
-  resultTruncated: z2.boolean(),
-  skippedDirectories: z2.int().nonnegative(),
-  scannedFiles: z2.int().nonnegative(),
-  denied: z2.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z2.boolean().optional()
+var GlobInputSchema = z3.object({ pattern: z3.string().min(1), path: z3.string().min(1).default(".") }).strict();
+var GlobOutputSchema = z3.object({
+  paths: z3.array(z3.string().min(1)),
+  truncated: z3.boolean(),
+  resultTruncated: z3.boolean(),
+  skippedDirectories: z3.int().nonnegative(),
+  scannedFiles: z3.int().nonnegative(),
+  denied: z3.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z3.boolean().optional()
 }).strict();
 function compileWorkspaceGlob(pattern) {
   let source = "";
@@ -743,29 +863,29 @@ function createListingCodingTools(config, limits) {
 import { createHash as createHash2 } from "node:crypto";
 import { realpath as realpath4 } from "node:fs/promises";
 import path4 from "node:path";
-import { z as z3 } from "zod";
-var SearchInputSchema = z3.object({
-  query: z3.string().min(1),
-  mode: z3.enum(["path", "content"]).default("content"),
-  regex: z3.boolean().default(false),
-  context: z3.int().nonnegative().max(10).default(0),
-  include: z3.string().min(1).describe("Anchored `**`/`*`/`?` pattern matched against the whole workspace-relative path. `*` does not cross `/`; use `**/` to include matching files in subdirectories.").optional()
+import { z as z4 } from "zod";
+var SearchInputSchema = z4.object({
+  query: z4.string().min(1),
+  mode: z4.enum(["path", "content"]).default("content"),
+  regex: z4.boolean().default(false),
+  context: z4.int().nonnegative().max(10).default(0),
+  include: z4.string().min(1).describe("Anchored `**`/`*`/`?` pattern matched against the whole workspace-relative path. `*` does not cross `/`; use `**/` to include matching files in subdirectories.").optional()
 }).strict();
-var SearchOutputSchema = z3.object({
-  matches: z3.array(z3.object({
-    path: z3.string().min(1),
-    line: z3.int().positive().optional(),
-    text: z3.string().optional(),
-    before: z3.array(z3.string()).optional(),
-    after: z3.array(z3.string()).optional()
+var SearchOutputSchema = z4.object({
+  matches: z4.array(z4.object({
+    path: z4.string().min(1),
+    line: z4.int().positive().optional(),
+    text: z4.string().optional(),
+    before: z4.array(z4.string()).optional(),
+    after: z4.array(z4.string()).optional()
   }).strict()),
-  truncated: z3.boolean(),
-  scannedFiles: z3.int().nonnegative().describe("Files admitted by include and host authorization that reached path or content comparison."),
-  skippedDirectories: z3.int().nonnegative(),
-  skippedSymlinks: z3.int().nonnegative(),
-  denied: z3.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z3.boolean().optional(),
-  hint: z3.string().min(1).optional()
+  truncated: z4.boolean(),
+  scannedFiles: z4.int().nonnegative().describe("Files admitted by include and host authorization that reached path or content comparison."),
+  skippedDirectories: z4.int().nonnegative(),
+  skippedSymlinks: z4.int().nonnegative(),
+  denied: z4.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z4.boolean().optional(),
+  hint: z4.string().min(1).optional()
 }).strict();
 function compileSearchRegex(pattern) {
   if (/\\[1-9]/.test(pattern) || /\(\?<?[=!]/.test(pattern)) {
@@ -784,21 +904,21 @@ function compileSearchRegex(pattern) {
   }
 }
 var MAX_SEARCHED_LINE_BYTES = 8192;
-var EditInputSchema = z3.object({
-  path: z3.string().min(1),
-  oldText: z3.string().min(1),
-  newText: z3.string(),
-  replaceAll: z3.boolean().default(false),
-  expectedSha256: z3.string().length(64).optional(),
-  dryRun: z3.boolean().default(false)
+var EditInputSchema = z4.object({
+  path: z4.string().min(1),
+  oldText: z4.string().min(1),
+  newText: z4.string(),
+  replaceAll: z4.boolean().default(false),
+  expectedSha256: z4.string().length(64).optional(),
+  dryRun: z4.boolean().default(false)
 }).strict();
-var EditOutputSchema = z3.object({
-  path: z3.string().min(1),
-  baseSha256: z3.string().length(64),
-  sha256: z3.string().length(64),
-  replacements: z3.int().positive(),
-  bytes: z3.int().nonnegative(),
-  applied: z3.boolean()
+var EditOutputSchema = z4.object({
+  path: z4.string().min(1),
+  baseSha256: z4.string().length(64),
+  sha256: z4.string().length(64),
+  replacements: z4.int().positive(),
+  bytes: z4.int().nonnegative(),
+  applied: z4.boolean()
 }).strict();
 function sha256(value) {
   return createHash2("sha256").update(value).digest("hex");
@@ -1278,17 +1398,17 @@ function createAgentCodingTools2(config) {
       name: AGENT_CODING_TOOL_NAMES.readOutput,
       description: "Read a bounded byte slice from one opaque coding output artifact.",
       identity: { serviceName: "coding", action: "read-artifact", method: "POST" },
-      input: z4.object({
-        reference: z4.string().min(1),
-        offset: z4.int().nonnegative().default(0),
-        maxBytes: z4.int().positive().optional()
+      input: z5.object({
+        reference: z5.string().min(1),
+        offset: z5.int().nonnegative().default(0),
+        maxBytes: z5.int().positive().optional()
       }).strict(),
-      output: z4.object({
-        reference: z4.string().min(1),
-        offset: z4.int().nonnegative(),
-        text: z4.string(),
-        bytes: z4.int().nonnegative(),
-        totalBytes: z4.int().nonnegative().optional()
+      output: z5.object({
+        reference: z5.string().min(1),
+        offset: z5.int().nonnegative(),
+        text: z5.string(),
+        bytes: z5.int().nonnegative(),
+        totalBytes: z5.int().nonnegative().optional()
       }).strict(),
       transports: ["AGENT"],
       handler: async ({ input }) => {
@@ -1327,14 +1447,14 @@ function createAgentCodingTools2(config) {
         name: AGENT_CODING_TOOL_NAMES.searchOutput,
         description: "Search a durable spilled output without loading it into context.",
         identity: { serviceName: "coding", action: "search-artifact", method: "POST" },
-        input: z4.object({
-          reference: z4.string().min(1),
-          query: z4.string().min(1),
-          maxMatches: z4.int().positive().max(limits.maxSearchResults).default(20)
+        input: z5.object({
+          reference: z5.string().min(1),
+          query: z5.string().min(1),
+          maxMatches: z5.int().positive().max(limits.maxSearchResults).default(20)
         }).strict(),
-        output: z4.object({
-          reference: z4.string(),
-          matches: z4.array(z4.object({ line: z4.int().positive(), text: z4.string() }))
+        output: z5.object({
+          reference: z5.string(),
+          matches: z5.array(z5.object({ line: z5.int().positive(), text: z5.string() }))
         }).strict(),
         transports: ["AGENT"],
         handler: async ({ input }) => {
@@ -1371,4 +1491,4 @@ function createAgentCodingTools2(config) {
   ];
 }
 
-export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, createAgentCodingTools2 };
+export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, ShellOutputSchema, AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, refuseUnknownSpillReference, AGENT_CODING_TOOL_NAMES, createAgentCodingTools2 };