stitchkit 0.119.0 → 0.121.0

package/dist/index-qaqxdbxf.js

@@ -0,0 +1,2857 @@
+import {
+  NativeCommandError2
+} from "./index-72xtvcvr.js";
+import {
+  CommandStopped,
+  startNativeCommand
+} from "./index-j95jp7ee.js";
+import {
+  ScanStopped,
+  ContainedScanBudget,
+  readContainedUtf8Handle,
+  scanContainedFiles
+} from "./index-s9a0fjh3.js";
+import {
+  writeContainedFile
+} from "./index-aqmadanx.js";
+import {
+  openPinnedDirectory,
+  openContainedDirectory,
+  missingContainedDirectories,
+  misspelledContainedSegment,
+  UnapprovedContainedDirectoryError,
+  openContainedParent,
+  openContainedFile,
+  ContainedPathChangedError,
+  assertContainedFileCurrent,
+  assertContainedParentCurrent,
+  containedEntryMetadata,
+  openContainedParentFile
+} from "./index-eeahxwvg.js";
+import {
+  withSignalDeadline
+} from "./index-9tqbxv5p.js";
+import {
+  defineRuntimeTool2
+} from "./index-aqwg2dm5.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
+import {
+  MAX_TIMER_MS
+} from "./index-eemvahkc.js";
+import {
+  AppError2,
+  forbidden2,
+  conflict2,
+  STITCH_ERROR_STATUS2
+} from "./index-qcn84byh.js";
+
+// src/agent-runtime/coding-tool-contract.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/coding-search-limits.ts
+import { z } from "zod";
+var MAX_DIRECTORY_ENTRIES = 2147483647;
+var AgentCodingSearchLimitsSchema = z.object({
+  maxSearchResults: z.int().positive(),
+  maxSearchFiles: z.int().positive(),
+  maxSearchDepth: z.int().nonnegative(),
+  maxSearchDirectories: z.int().positive(),
+  maxSearchEntries: z.int().positive().max(MAX_DIRECTORY_ENTRIES),
+  maxSearchBytes: z.int().positive(),
+  maxSearchOutputBytes: z.int().min(1024),
+  searchTimeoutMs: z.int().positive().max(MAX_TIMER_MS)
+}).strict();
+
+// src/agent-runtime/coding-tool-contract.ts
+var AgentCodingToolLimitsSchema2 = z2.object({
+  maxPathBytes: z2.int().positive(),
+  maxReadBytes: z2.int().positive(),
+  maxWriteBytes: z2.int().positive(),
+  maxShellArguments: z2.int().positive(),
+  maxShellArgumentBytes: z2.int().positive(),
+  maxShellOutputBytes: z2.int().positive(),
+  maxArtifactBytes: z2.int().positive(),
+  maxListEntries: z2.int().positive(),
+  ...AgentCodingSearchLimitsSchema.shape,
+  shellTimeoutMs: z2.int().positive(),
+  shellTerminationGraceMs: z2.int().positive()
+}).strict();
+var AgentCodingToolAuthorizationSchema2 = z2.discriminatedUnion("operation", [
+  z2.object({ operation: z2.literal("read"), path: z2.string().min(1) }).strict(),
+  z2.object({
+    operation: z2.literal("write"),
+    path: z2.string().min(1),
+    bytes: z2.int().nonnegative(),
+    overwrite: z2.boolean(),
+    createsDirectories: z2.array(z2.string().min(1))
+  }).strict(),
+  z2.object({
+    operation: z2.literal("search"),
+    query: z2.string().min(1),
+    mode: z2.enum(["path", "content"])
+  }).strict(),
+  z2.object({
+    operation: z2.literal("edit"),
+    path: z2.string().min(1),
+    baseSha256: z2.string().length(64),
+    resultSha256: z2.string().length(64),
+    resultBytes: z2.int().nonnegative(),
+    replacements: z2.int().positive(),
+    dryRun: z2.boolean()
+  }).strict(),
+  z2.object({ operation: z2.literal("list"), path: z2.string().min(1) }).strict(),
+  z2.object({
+    operation: z2.literal("glob"),
+    pattern: z2.string().min(1),
+    path: z2.string().min(1)
+  }).strict(),
+  z2.object({
+    operation: z2.literal("artifact-read"),
+    reference: z2.string().min(1),
+    offset: z2.int().nonnegative(),
+    maxBytes: z2.int().positive()
+  }).strict(),
+  z2.object({
+    operation: z2.literal("artifact-search"),
+    reference: z2.string().min(1),
+    query: z2.string().min(1),
+    maxMatches: z2.int().positive()
+  }).strict(),
+  z2.object({
+    operation: z2.literal("shell"),
+    executable: z2.string().min(1),
+    args: z2.array(z2.string()),
+    cwd: z2.string().min(1)
+  }).strict()
+]);
+var AgentCodingToolPathAuthorizationSchema2 = z2.object({ path: z2.string().min(1) }).strict();
+var CodingDeniedEntrySchema = z2.object({
+  path: z2.string().min(1),
+  kind: z2.enum(["file", "directory", "symlink", "other"])
+}).strict();
+var FileReadInputSchema = z2.object({
+  path: z2.string().min(1),
+  offset: z2.int().nonnegative().default(0),
+  maxBytes: z2.int().positive().optional()
+}).strict();
+var FileReadOutputSchema = z2.object({
+  path: z2.string().min(1),
+  text: z2.string(),
+  bytes: z2.int().nonnegative(),
+  sha256: z2.string().length(64),
+  truncated: z2.boolean(),
+  nextOffset: z2.int().nonnegative().optional()
+}).strict();
+var FileWriteInputSchema = z2.object({
+  path: z2.string().min(1),
+  content: z2.string(),
+  overwrite: z2.boolean().default(false)
+}).strict();
+var FileWriteOutputSchema = z2.object({
+  path: z2.string().min(1),
+  bytes: z2.int().nonnegative(),
+  createdDirectories: z2.array(z2.string().min(1))
+}).strict();
+function createShellInputSchema(executableNames) {
+  if (executableNames.length === 0) {
+    throw new Error("A command tool requires at least one executable alias");
+  }
+  return z2.object({
+    executable: z2.enum(executableNames),
+    args: z2.array(z2.string()).default([]),
+    cwd: z2.string().min(1).default(".")
+  }).strict();
+}
+var ShellInputSchema = z2.object({
+  executable: z2.string().min(1),
+  args: z2.array(z2.string()).default([]),
+  cwd: z2.string().min(1).default(".")
+}).strict();
+var ShellOutputSchema = z2.object({
+  executable: z2.string().min(1),
+  exitCode: z2.int().nullable(),
+  signal: z2.string().nullable(),
+  stdout: z2.string(),
+  stderr: z2.string(),
+  outcome: z2.enum(["exited", "timeout", "output-limit", "cancelled"]),
+  artifact: z2.object({
+    reference: z2.string().min(1),
+    bytes: z2.int().nonnegative(),
+    truncated: z2.boolean(),
+    headBytes: z2.int().nonnegative(),
+    tailBytes: z2.int().nonnegative(),
+    omittedBytes: z2.int().nonnegative()
+  }).strict().optional()
+}).strict();
+var DEFAULT_LIMITS = {
+  maxPathBytes: 4096,
+  maxReadBytes: 262144,
+  maxWriteBytes: 262144,
+  maxShellArguments: 128,
+  maxShellArgumentBytes: 65536,
+  maxShellOutputBytes: 262144,
+  maxArtifactBytes: 4194304,
+  maxListEntries: 500,
+  maxSearchResults: 100,
+  maxSearchFiles: 1e4,
+  maxSearchDepth: 32,
+  maxSearchDirectories: 1000,
+  maxSearchEntries: 20000,
+  maxSearchBytes: 16777216,
+  maxSearchOutputBytes: 65536,
+  searchTimeoutMs: 5000,
+  shellTimeoutMs: 30000,
+  shellTerminationGraceMs: 250
+};
+function resolveCodingToolLimits(input) {
+  return AgentCodingToolLimitsSchema2.parse({ ...DEFAULT_LIMITS, ...input });
+}
+
+// src/agent-runtime/sandbox.ts
+import { z as z3 } from "zod";
+var AgentSandboxRestrictionSchema2 = z3.enum([
+  "network-denied",
+  "write-contained",
+  "secrets-hidden",
+  "process-contained"
+]);
+var AgentSandboxGradeSchema2 = z3.discriminatedUnion("grade", [
+  z3.object({ grade: z3.literal("full"), restrictions: z3.array(AgentSandboxRestrictionSchema2) }).strict(),
+  z3.object({
+    grade: z3.literal("partial"),
+    restrictions: z3.array(AgentSandboxRestrictionSchema2),
+    gaps: z3.array(AgentSandboxRestrictionSchema2)
+  }).strict(),
+  z3.object({ grade: z3.literal("unavailable"), reason: z3.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-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) {
+  refuseChangedPath(error, relative);
+  const code = errnoOf(error);
+  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" || code === "ENXIO" || code === "EOPNOTSUPP") {
+    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+      hint: "Use list_directory to see what is here."
+    });
+  }
+  throw error;
+}
+function refuseUnopenableCodingDirectory(error, relative) {
+  const code = errnoOf(error);
+  if (code === "ENOENT") {
+    codingPathRefusal("NOT_FOUND", "This directory does not exist", relative, {
+      hint: "List a parent directory to see what is there."
+    });
+  }
+  if (code === "ENOTDIR" || code === "ELOOP") {
+    codingPathRefusal("BAD_REQUEST", "This path is not a directory; symlinks are not followed", relative, {
+      hint: "Name a real directory by its workspace-relative path; list the parent to see what is there."
+    });
+  }
+  return refuseMissingCodingPath(error, relative);
+}
+function refuseChangedPath(error, relative) {
+  if (error instanceof ContainedPathChangedError) {
+    codingPathRefusal("CONFLICT", "This path changed while it was being authorized", relative, {
+      hint: "Read it again and retry."
+    });
+  }
+}
+function refuseWriteConflict(error, relative, details = {}) {
+  refuseChangedPath(error, relative);
+  const code = errnoOf(error);
+  if (code === "ENOENT") {
+    codingPathRefusal("CONFLICT", "This path changed while it was being written", relative, {
+      details,
+      hint: "Read it again and retry."
+    });
+  }
+  if (code === "ENOTDIR") {
+    codingPathRefusal("CONFLICT", "A segment of this path is not a directory", relative, {
+      details,
+      hint: "Write under a different path, or remove the file blocking it."
+    });
+  }
+  if (code === "ELOOP") {
+    codingPathRefusal("FORBIDDEN", "This path is a symlink, which is not followed", relative, {
+      details,
+      hint: "Write to the target directly, by its own workspace-relative path."
+    });
+  }
+  if (code === "EISDIR") {
+    codingPathRefusal("CONFLICT", "This path is a directory", relative, {
+      details,
+      hint: "Write to a file path inside it, or choose another name."
+    });
+  }
+  if (code === "EEXIST") {
+    codingPathRefusal("CONFLICT", "This file already exists", relative, {
+      details,
+      hint: "Pass overwrite: true to replace it, or edit_file to change part of it."
+    });
+  }
+  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-tools.ts
+import path5 from "node:path";
+import { z as z8 } from "zod";
+
+// src/agent-runtime/coding-tool-files.ts
+import { createHash } from "node:crypto";
+
+// src/agent-runtime/coding-tool-paths.ts
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+function within(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function inputPath(root, requested, maxPathBytes) {
+  if (new TextEncoder().encode(requested).byteLength > maxPathBytes) {
+    codingRefusal("BAD_REQUEST", `Path exceeds the ${maxPathBytes}-byte limit`, {
+      details: { maxPathBytes },
+      hint: "Use a shorter workspace-relative path."
+    });
+  }
+  if (path.isAbsolute(requested)) {
+    const relative = path.relative(root, requested);
+    const recoveryPath = within(root, requested) ? relative.split(path.sep).join("/") || "." : undefined;
+    codingRefusal("BAD_REQUEST", "Paths must be relative to the workspace root", {
+      details: { path: requested, ...recoveryPath && { recoveryPath } },
+      hint: recoveryPath ? `Use the workspace-relative path \`${recoveryPath}\`.` : "Pass a path relative to the workspace root; absolute paths outside it have no workspace-relative equivalent."
+    });
+  }
+  const resolved = path.resolve(root, requested);
+  if (!within(root, resolved)) {
+    codingRefusal("FORBIDDEN", "Path escapes the workspace root", {
+      details: { path: requested },
+      hint: "Stay inside the workspace; `..` segments that leave the root are refused."
+    });
+  }
+  return resolved;
+}
+function boundedCodingRelativePath(root, requested, maxPathBytes) {
+  if (requested.includes("\x00")) {
+    codingRefusal("BAD_REQUEST", "Path segments cannot contain a NUL byte", {
+      details: { path: requested },
+      hint: "Pass the exact workspace-relative entry name without NUL bytes."
+    });
+  }
+  if (path.isAbsolute(requested))
+    inputPath(root, requested, maxPathBytes);
+  if (requested.includes("\\")) {
+    codingRefusal("FORBIDDEN", "Path separators must be `/`", {
+      details: { path: requested },
+      hint: "Use `/` between segments; a backslash is refused because the workspace walk reads it as a separator."
+    });
+  }
+  const segments = requested.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    codingRefusal("FORBIDDEN", "Path segments must name real entries under the root", {
+      details: { path: requested },
+      hint: "Pass a plain workspace-relative path — `.`, `..` and empty segments are refused."
+    });
+  }
+  inputPath(root, requested, maxPathBytes);
+  return requested;
+}
+async function authorizeCodingTool(config, request) {
+  const parsed = AgentCodingToolAuthorizationSchema2.parse(request);
+  if (!await config.authorize(parsed))
+    forbidden2("Coding tool permission denied");
+}
+async function isCodingPathAuthorized(config, path2) {
+  if (!config.authorizePath)
+    return true;
+  const parsed = AgentCodingToolPathAuthorizationSchema2.parse({ path: path2 });
+  return await config.authorizePath(parsed);
+}
+async function authorizeCodingPath(config, path2) {
+  if (!await isCodingPathAuthorized(config, path2)) {
+    codingRefusal("FORBIDDEN", "Coding tool path permission denied", {
+      details: { path: path2 },
+      hint: "The host policy refused this path or a directory above it."
+    });
+  }
+}
+async function authorizeCodingPathChain(config, relative, root, budget) {
+  if (relative !== ".") {
+    const misspelled = await misspelledContainedSegment(root, relative, budget && {
+      check: () => budget.check(),
+      directory: () => budget.directory(),
+      entry: () => budget.entry(),
+      remainingEntries: () => budget.remainingEntries(),
+      wait: (operation, dispose) => budget.wait(operation, dispose)
+    });
+    if (misspelled !== undefined) {
+      codingPathRefusal("BAD_REQUEST", "This path differs from the name stored on disk", relative, {
+        hint: "Use list_directory to see the stored spelling."
+      });
+    }
+  }
+  if (!config.authorizePath)
+    return;
+  const segments = relative === "." ? ["."] : relative.split("/");
+  for (let depth = 1;depth <= segments.length; depth += 1) {
+    const authorize = () => authorizeCodingPath(config, segments.slice(0, depth).join("/"));
+    if (budget)
+      await budget.wait(authorize);
+    else
+      await authorize();
+  }
+}
+var codingPathLocks = new Map;
+async function withCodingPathLock(root, relative, work) {
+  const identity = await root.stat();
+  const target = `${identity.dev}:${identity.ino}:${relative}`;
+  const previous = codingPathLocks.get(target) ?? Promise.resolve();
+  let release = () => {
+    return;
+  };
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const queued = previous.then(() => current);
+  codingPathLocks.set(target, queued);
+  await previous;
+  try {
+    return await work();
+  } finally {
+    release();
+    if (codingPathLocks.get(target) === queued)
+      codingPathLocks.delete(target);
+  }
+}
+function textOccurrences(source, search) {
+  let count = 0;
+  let offset = 0;
+  while (offset <= source.length - search.length) {
+    const found = source.indexOf(search, offset);
+    if (found < 0)
+      break;
+    count += 1;
+    offset = found + search.length;
+  }
+  return count;
+}
+async function withCodingRoot(configured, work) {
+  const canonical = await realpath(configured);
+  const root = await openPinnedDirectory(canonical);
+  try {
+    return await work(root, canonical);
+  } finally {
+    await root.close();
+  }
+}
+
+// src/agent-runtime/coding-tool-utf8.ts
+function sequenceLength(lead) {
+  if (lead < 128)
+    return 1;
+  if ((lead & 224) === 192)
+    return 2;
+  if ((lead & 240) === 224)
+    return 3;
+  if ((lead & 248) === 240)
+    return 4;
+  return;
+}
+function utf8AlignedEnd(data, start, limit) {
+  const safe = Math.max(start, Math.min(start + limit, data.byteLength));
+  for (let back = 1;back <= 4 && safe - back >= start; back += 1) {
+    const byte = data[safe - back];
+    if ((byte & 192) === 128)
+      continue;
+    const length = sequenceLength(byte);
+    if (length === undefined)
+      return safe;
+    if (back >= length)
+      return safe;
+    const sequenceEnd = safe - back + length;
+    return sequenceEnd <= data.byteLength ? sequenceEnd : safe - back;
+  }
+  return safe;
+}
+function utf8AlignedStart(data, start, end) {
+  let safe = Math.max(0, Math.min(start, end));
+  while (safe < end && (data[safe] & 192) === 128)
+    safe += 1;
+  return safe;
+}
+
+// src/agent-runtime/coding-tool-files.ts
+async function digestFile(handle, size) {
+  const hash = createHash("sha256");
+  const chunk = Buffer.alloc(Math.min(64 * 1024, Math.max(1, size)));
+  for (let position = 0;position < size; ) {
+    const length = Math.min(chunk.byteLength, size - position);
+    const { bytesRead } = await handle.read(chunk, 0, length, position);
+    if (bytesRead === 0)
+      break;
+    hash.update(chunk.subarray(0, bytesRead));
+    position += bytesRead;
+  }
+  return hash.digest("hex");
+}
+async function openAuthorizedWriteParent(root, relative, createsDirectories) {
+  return openContainedParent(root, relative, { createDirectories: createsDirectories }).catch((error) => {
+    if (error instanceof UnapprovedContainedDirectoryError) {
+      codingPathRefusal("CONFLICT", "The directory creation plan changed during authorization", relative, {
+        details: { createsDirectories },
+        hint: "Retry the write so the host can authorize the current directories."
+      });
+    }
+    refuseWriteConflict(error, relative, { createsDirectories });
+  });
+}
+function createFileCodingTools(config, limits) {
+  const read = defineRuntimeTool2({
+    name: "read_file",
+    description: "Read a bounded UTF-8 slice from a host-authorized workspace file.",
+    identity: { serviceName: "coding", action: "read-file", method: "POST" },
+    input: FileReadInputSchema,
+    output: FileReadOutputSchema,
+    transports: ["AGENT"],
+    handler: async ({ input }) => withCodingRoot(config.root, async (root, rootPath) => {
+      const relative = boundedCodingRelativePath(rootPath, input.path, limits.maxPathBytes);
+      await authorizeCodingPathChain(config, relative, root);
+      const handle = await openContainedFile(root, relative).catch((error) => refuseMissingCodingPath(error, relative));
+      const maximum = Math.min(input.maxBytes ?? limits.maxReadBytes, limits.maxReadBytes);
+      let selected;
+      let start = input.offset;
+      let size;
+      let sha256;
+      try {
+        await authorizeCodingTool(config, { operation: "read", path: relative });
+        await assertContainedFileCurrent(root, relative, handle).catch((error) => refuseMissingCodingPath(error, relative));
+        const metadata = await handle.stat();
+        if (!metadata.isFile()) {
+          codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+            hint: "Use list_directory to see what is here."
+          });
+        }
+        size = metadata.size;
+        const length = Math.min(maximum + 4, Math.max(0, size - input.offset));
+        selected = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(selected, 0, length, input.offset);
+        selected = selected.subarray(0, bytesRead);
+        if (input.offset > 0) {
+          const aligned = utf8AlignedStart(selected, 0, selected.byteLength);
+          start = input.offset + aligned;
+          selected = selected.subarray(aligned);
+        }
+        if (selected.byteLength > maximum) {
+          selected = selected.subarray(0, utf8AlignedEnd(selected, 0, maximum));
+        }
+        sha256 = await digestFile(handle, size);
+      } finally {
+        await handle.close();
+      }
+      let text;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(selected);
+      } catch {
+        codingPathRefusal("BAD_REQUEST", "The selected file bytes are not valid UTF-8", relative, {
+          details: { reason: "invalid_utf8" },
+          hint: "Use a binary-capable reader or convert the file to UTF-8."
+        });
+      }
+      const end = start + selected.byteLength;
+      const truncated = end < size;
+      return {
+        path: relative,
+        text,
+        bytes: selected.byteLength,
+        sha256,
+        truncated,
+        ...truncated && { nextOffset: end }
+      };
+    })
+  });
+  const write = defineRuntimeTool2({
+    name: "write_file",
+    description: "Write bounded UTF-8 content to a host-authorized workspace file.",
+    identity: { serviceName: "coding", action: "write-file", method: "POST" },
+    input: FileWriteInputSchema,
+    output: FileWriteOutputSchema,
+    transports: ["AGENT"],
+    handler: async ({ input }) => withCodingRoot(config.root, async (root, rootPath) => {
+      const relative = boundedCodingRelativePath(rootPath, input.path, limits.maxPathBytes);
+      await authorizeCodingPathChain(config, relative, root);
+      const bytes = Buffer.byteLength(input.content);
+      if (bytes > limits.maxWriteBytes) {
+        codingPathRefusal("BAD_REQUEST", `The content is ${bytes} bytes, over the ${limits.maxWriteBytes}-byte limit`, relative, {
+          details: { bytes, maxWriteBytes: limits.maxWriteBytes },
+          hint: "Write a smaller file, or split it."
+        });
+      }
+      const createsDirectories = await missingContainedDirectories(root, relative).catch((error) => refuseWriteConflict(error, relative));
+      await authorizeCodingTool(config, {
+        operation: "write",
+        path: relative,
+        bytes,
+        overwrite: input.overwrite,
+        createsDirectories
+      });
+      await withCodingPathLock(root, relative, async () => {
+        const parent = await openAuthorizedWriteParent(root, relative, createsDirectories);
+        try {
+          await assertContainedParentCurrent(root, relative, parent.handle).catch((error) => refuseWriteConflict(error, relative));
+          const current = await containedEntryMetadata(parent);
+          if (input.overwrite) {
+            if (current?.isSymbolicLink()) {
+              codingPathRefusal("FORBIDDEN", "This path is a symlink", relative, {
+                hint: "Coding tools never write through symlinks; write to the target directly."
+              });
+            }
+            await writeContainedFile({
+              parent,
+              content: input.content,
+              replace: true,
+              ...current && { mode: current.mode }
+            }).catch((error) => refuseWriteConflict(error, relative));
+          } else {
+            if (current) {
+              codingPathRefusal("CONFLICT", "This file already exists", relative, {
+                hint: "Pass overwrite: true to replace it, or edit_file to change part of it."
+              });
+            }
+            await writeContainedFile({
+              parent,
+              content: input.content,
+              replace: false
+            }).catch((error) => refuseWriteConflict(error, relative));
+          }
+        } finally {
+          await parent.handle.close();
+        }
+      });
+      return { path: relative, bytes, createdDirectories: createsDirectories };
+    })
+  });
+  return [read, write];
+}
+
+// src/agent-runtime/coding-tool-listing.ts
+import path2 from "node:path";
+import { z as z5 } from "zod";
+
+// src/agent-runtime/coding-discovery.ts
+function discoveryRun(config, limits, path, include, symlinks) {
+  const started = performance.now();
+  const budget = new ContainedScanBudget({
+    maxDirectories: limits.maxSearchDirectories,
+    maxEntries: limits.maxSearchEntries,
+    maxBytes: limits.maxSearchBytes,
+    deadline: started + limits.searchTimeoutMs
+  });
+  const coverage = {
+    complete: true,
+    reasons: [],
+    scope: {
+      path,
+      include,
+      excludedDirectories: config.search?.excludeDirectories ? "configured" : "default",
+      symlinks
+    },
+    visitedDirectories: 0,
+    visitedEntries: 0,
+    readBytes: 0,
+    elapsedMs: 0
+  };
+  return {
+    budget,
+    coverage,
+    async run(caller, work) {
+      if (caller?.aborted) {
+        budget.reasons.add("cancelled");
+        return;
+      }
+      try {
+        await withSignalDeadline(limits.searchTimeoutMs, caller, () => "discovery-timeout", async (signal) => {
+          budget.limits.signal = signal;
+          budget.directory();
+          const root = await budget.wait(() => openPinnedDirectory(config.root), (handle) => {
+            handle.close().catch(() => {
+              return;
+            });
+          });
+          try {
+            budget.check();
+            await work(root);
+          } finally {
+            await root.close();
+          }
+        });
+      } catch (error) {
+        if (!(error instanceof ScanStopped))
+          throw error;
+      }
+    },
+    refresh() {
+      coverage.complete = budget.reasons.size === 0;
+      coverage.reasons = [...budget.reasons];
+      coverage.visitedDirectories = budget.visitedDirectories;
+      coverage.visitedEntries = budget.visitedEntries;
+      coverage.readBytes = budget.readBytes;
+      coverage.elapsedMs = Math.round((performance.now() - started) * 100) / 100;
+    }
+  };
+}
+function discoveryCollector(output, budget, maximum) {
+  const reserve = Buffer.byteLength(JSON.stringify(output)) + 512;
+  if (reserve > maximum)
+    codingRefusal("BAD_REQUEST", "Discovery output budget cannot hold its coverage envelope", {
+      hint: "Increase maxSearchOutputBytes or shorten the path/pattern."
+    });
+  let bytes = reserve;
+  return (item) => {
+    budget.check();
+    const next = Buffer.byteLength(JSON.stringify(item)) + 1;
+    if (bytes + next > maximum)
+      budget.stop("max-output-bytes");
+    bytes += next;
+  };
+}
+
+// src/agent-runtime/coding-search-output.ts
+function boundSearchDiagnostics(output, budget, maxBytes) {
+  const canContinue = () => {
+    try {
+      budget.check();
+      return true;
+    } catch (error) {
+      if (!(error instanceof ScanStopped))
+        throw error;
+      return false;
+    }
+  };
+  canContinue();
+  const denied = output.denied;
+  const errors = output.errors;
+  if (denied)
+    output.denied = [];
+  if (errors)
+    output.errors = [];
+  const available = maxBytes - Buffer.byteLength(JSON.stringify(output)) - 256;
+  let used = 0;
+  const take = (items, truncated) => {
+    const admitted = [];
+    for (const item of items) {
+      if (!canContinue()) {
+        truncated();
+        break;
+      }
+      const bytes = Buffer.byteLength(JSON.stringify(item)) + 1;
+      if (used + bytes > available) {
+        budget.reasons.add("max-output-bytes");
+        truncated();
+        break;
+      }
+      used += bytes;
+      admitted.push(item);
+    }
+    return admitted;
+  };
+  if (denied)
+    output.denied = take(denied, () => {
+      output.deniedTruncated = true;
+    });
+  if (errors)
+    output.errors = take(errors, () => {
+      output.errorsTruncated = true;
+    });
+}
+
+// src/agent-runtime/contained-scan-contract.ts
+import { z as z4 } from "zod";
+var ScanStopReasonSchema = z4.enum([
+  "max-files",
+  "max-depth",
+  "max-directories",
+  "max-entries",
+  "max-bytes",
+  "max-results",
+  "max-output-bytes",
+  "cancelled",
+  "timeout",
+  "denied",
+  "unreadable",
+  "max-file-bytes",
+  "max-line-bytes"
+]);
+var DiscoveryCoverageSchema = z4.object({
+  complete: z4.boolean(),
+  reasons: z4.array(ScanStopReasonSchema),
+  scope: z4.object({
+    path: z4.string(),
+    include: z4.string(),
+    excludedDirectories: z4.enum(["default", "configured"]),
+    symlinks: z4.enum(["skip", "list"])
+  }).strict(),
+  visitedDirectories: z4.int().nonnegative(),
+  visitedEntries: z4.int().nonnegative(),
+  readBytes: z4.int().nonnegative(),
+  elapsedMs: z4.number().nonnegative()
+}).strict();
+
+// src/agent-runtime/workspace-glob.ts
+function compileWorkspaceGlob(pattern, check) {
+  let operations = 0;
+  const checkpoint = () => {
+    if (++operations % 128 === 0)
+      check?.();
+  };
+  const states = [{ epsilon: [], edges: [] }];
+  const add = () => {
+    states.push({ epsilon: [], edges: [] });
+    return states.length - 1;
+  };
+  let current = 0;
+  for (let index = 0;index < pattern.length; index += 1) {
+    checkpoint();
+    const state = states[current];
+    if (!state)
+      throw new Error("Missing glob state");
+    const character = pattern[index];
+    const next = add();
+    if (character === "*" && pattern[index + 1] === "*") {
+      state.epsilon.push(next);
+      if (pattern[index + 2] === "/") {
+        const segment = add();
+        state.edges.push({ kind: "segment", next: segment });
+        states[segment]?.edges.push({ kind: "segment", next: segment }, { kind: "literal", value: "/", next: current });
+        index += 2;
+      } else {
+        state.edges.push({ kind: "dot", next: current });
+        index += 1;
+      }
+    } else if (character === "*") {
+      state.epsilon.push(next);
+      state.edges.push({ kind: "segment", next: current });
+    } else {
+      state.edges.push(character === "?" ? { kind: "segment", next } : { kind: "literal", value: character, next });
+    }
+    current = next;
+  }
+  const accepting = current;
+  const closure = (initial) => {
+    const reached = new Set(initial);
+    for (const index of reached) {
+      checkpoint();
+      for (const next of states[index]?.epsilon ?? [])
+        reached.add(next);
+    }
+    return reached;
+  };
+  const advance = (active, character) => {
+    const next = new Set;
+    for (const index of active) {
+      checkpoint();
+      for (const edge of states[index]?.edges ?? []) {
+        if (edge.kind === "literal" ? character === edge.value : edge.kind === "segment" ? character !== "/" : !`
+\r\u2028\u2029`.includes(character)) {
+          next.add(edge.next);
+        }
+      }
+    }
+    return closure(next);
+  };
+  const consume = (value) => {
+    let active = closure([0]);
+    for (let index = 0;index < value.length && active.size > 0; index += 1) {
+      active = advance(active, value.charAt(index));
+    }
+    return active;
+  };
+  return {
+    test: (value) => consume(value).has(accepting),
+    mayContain: (directory) => {
+      const active = consume(`${directory}/`);
+      return [...active].some((index) => states[index]?.edges.some((edge) => edge.kind !== "literal" || edge.value !== "/"));
+    }
+  };
+}
+
+// src/agent-runtime/coding-tool-listing.ts
+var DEFAULT_EXCLUDED_DIRECTORIES = [
+  ".git",
+  ".next",
+  ".stitchkit",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+];
+var ListInputSchema = z5.object({ path: z5.string().min(1).default(".") }).strict();
+var diagnostics = {
+  denied: z5.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z5.boolean().optional(),
+  errors: z5.array(z5.object({ path: z5.string(), operation: z5.string(), code: z5.string() }).strict()).optional(),
+  errorsTruncated: z5.boolean().optional(),
+  coverage: DiscoveryCoverageSchema
+};
+var ListOutputSchema = z5.object({
+  path: z5.string().min(1),
+  entries: z5.array(z5.object({
+    name: z5.string().min(1),
+    kind: z5.enum(["file", "directory", "symlink", "other"]),
+    bytes: z5.int().nonnegative().optional(),
+    excluded: z5.boolean().optional()
+  }).strict()),
+  truncated: z5.boolean(),
+  ...diagnostics
+}).strict();
+var GlobInputSchema = z5.object({ pattern: z5.string().min(1).max(4096), path: z5.string().min(1).default(".") }).strict();
+var GlobOutputSchema = z5.object({
+  paths: z5.array(z5.string().min(1)),
+  truncated: z5.boolean(),
+  resultTruncated: z5.boolean(),
+  skippedDirectories: z5.int().nonnegative(),
+  scannedFiles: z5.int().nonnegative(),
+  ...diagnostics
+}).strict();
+function createListingCodingTools(config, limits) {
+  const excluded = new Set(config.search?.excludeDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES);
+  const relativePath = (requested) => requested === "." ? "." : boundedCodingRelativePath(path2.resolve(config.root), requested, limits.maxPathBytes);
+  const dispose = (handle) => {
+    handle.close().catch(() => {
+      return;
+    });
+  };
+  const list = defineRuntimeTool2({
+    name: "list_directory",
+    description: "List bounded direct workspace entries with explicit coverage.",
+    identity: { serviceName: "coding", action: "list-directory", method: "POST" },
+    input: ListInputSchema,
+    output: ListOutputSchema,
+    transports: ["AGENT"],
+    handler: async ({ input, signal }) => {
+      const relative = relativePath(input.path);
+      const run = discoveryRun(config, limits, relative, "*", "list");
+      const { budget } = run;
+      budget.limits.maxEntries = Math.min(limits.maxListEntries, limits.maxSearchEntries);
+      const output = {
+        path: relative,
+        entries: [],
+        truncated: false,
+        coverage: run.coverage
+      };
+      const retain = discoveryCollector(output, budget, limits.maxSearchOutputBytes);
+      await run.run(signal, async (root) => {
+        await budget.wait(() => authorizeCodingPathChain(config, relative, root, budget));
+        await budget.wait(() => authorizeCodingTool(config, { operation: "list", path: relative }));
+        const directory = await budget.wait(() => openContainedDirectory(root, relative, () => budget.directory()), dispose).catch((error) => refuseUnopenableCodingDirectory(error, relative));
+        try {
+          const scan = await scanContainedFiles({
+            root: directory,
+            basePath: relative,
+            budget,
+            maxDepth: 0,
+            maxFiles: limits.maxSearchFiles,
+            symlinks: "skip",
+            skipUnreadable: true,
+            maxDiagnostics: limits.maxListEntries,
+            authorizePath: (candidate) => isCodingPathAuthorized(config, candidate),
+            visitEntry: async (parent, entry) => {
+              if (output.entries.length >= limits.maxListEntries)
+                budget.stop("max-results");
+              const metadata = entry.kind === "file" ? await budget.wait(() => containedEntryMetadata({ handle: parent, basename: entry.name })) : null;
+              const item = {
+                ...entry,
+                ...metadata?.size !== undefined && { bytes: metadata.size },
+                ...entry.kind === "directory" && excluded.has(entry.name) && { excluded: true }
+              };
+              retain(item);
+              output.entries.push(item);
+              return false;
+            }
+          });
+          if (scan.denied.length) {
+            output.denied = scan.denied.map(({ relative, kind }) => ({
+              path: relative,
+              kind
+            }));
+            output.deniedTruncated = scan.deniedTruncated;
+          }
+          if (scan.errors.length) {
+            output.errors = scan.errors;
+            output.errorsTruncated = scan.errorsTruncated;
+          }
+        } finally {
+          await directory.close();
+        }
+      });
+      output.entries.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "directory" ? -1 : b.kind === "directory" ? 1 : 0);
+      run.refresh();
+      boundSearchDiagnostics(output, budget, limits.maxSearchOutputBytes);
+      run.refresh();
+      output.truncated = !output.coverage.complete;
+      return output;
+    }
+  });
+  const glob = defineRuntimeTool2({
+    name: "glob",
+    description: "List bounded workspace files matching **/*/? with explicit coverage.",
+    identity: { serviceName: "coding", action: "glob", method: "POST" },
+    input: GlobInputSchema,
+    output: GlobOutputSchema,
+    transports: ["AGENT"],
+    handler: async ({ input, signal }) => {
+      const relative = relativePath(input.path);
+      const run = discoveryRun(config, limits, relative, input.pattern, "skip");
+      const { budget } = run;
+      const output = {
+        paths: [],
+        truncated: false,
+        resultTruncated: false,
+        skippedDirectories: 0,
+        scannedFiles: 0,
+        coverage: run.coverage
+      };
+      const retain = discoveryCollector(output, budget, limits.maxSearchOutputBytes);
+      await run.run(signal, async (root) => {
+        const matcher = compileWorkspaceGlob(input.pattern, () => budget.check());
+        await budget.wait(() => authorizeCodingPathChain(config, relative, root, budget));
+        await budget.wait(() => authorizeCodingTool(config, {
+          operation: "glob",
+          pattern: input.pattern,
+          path: relative
+        }));
+        const directory = await budget.wait(() => openContainedDirectory(root, relative, () => budget.directory()), dispose).catch((error) => refuseUnopenableCodingDirectory(error, relative));
+        const prefix = relative === "." ? "" : `${relative}/`;
+        try {
+          const scan = await scanContainedFiles({
+            root: directory,
+            basePath: relative,
+            budget,
+            maxDepth: limits.maxSearchDepth,
+            maxFiles: limits.maxSearchFiles,
+            symlinks: "skip",
+            skipUnreadable: true,
+            maxDiagnostics: limits.maxSearchResults,
+            excludeDirectory: (directory) => directory.split("/").some((segment) => excluded.has(segment)) || !matcher.mayContain(directory.slice(prefix.length)),
+            authorizePath: (candidate) => isCodingPathAuthorized(config, candidate),
+            visitFile: (file) => {
+              if (!matcher.test(file.relative.slice(prefix.length)))
+                return true;
+              if (output.paths.length >= limits.maxSearchResults) {
+                output.resultTruncated = true;
+                budget.stop("max-results");
+              }
+              retain(file.relative);
+              output.paths.push(file.relative);
+              if (output.paths.length >= limits.maxSearchResults) {
+                output.resultTruncated = true;
+                budget.stop("max-results");
+              }
+              return true;
+            }
+          });
+          output.scannedFiles = scan.scannedFiles;
+          output.skippedDirectories = scan.skippedDirectories;
+          if (scan.denied.length) {
+            output.denied = scan.denied.map(({ relative, kind }) => ({
+              path: relative,
+              kind
+            }));
+            output.deniedTruncated = scan.deniedTruncated;
+          }
+          if (scan.errors.length) {
+            output.errors = scan.errors;
+            output.errorsTruncated = scan.errorsTruncated;
+          }
+        } finally {
+          await directory.close();
+        }
+      });
+      output.paths.sort();
+      run.refresh();
+      boundSearchDiagnostics(output, budget, limits.maxSearchOutputBytes);
+      run.refresh();
+      output.truncated = !output.coverage.complete;
+      return output;
+    }
+  });
+  return [list, glob];
+}
+
+// src/agent-runtime/coding-tool-search-patch.ts
+import { createHash as createHash2 } from "node:crypto";
+import { z as z7 } from "zod";
+
+// src/agent-runtime/coding-tool-search.ts
+import path3 from "node:path";
+
+// src/agent-runtime/coding-search-contract.ts
+import { z as z6 } from "zod";
+var SearchInputSchema = z6.object({
+  query: z6.string().min(1).max(8192),
+  mode: z6.enum(["path", "content"]).default("content"),
+  regex: z6.boolean().default(false).describe("Treat `query` as a JavaScript regular expression without flags, run in linear time: groups, alternation, classes, anchors, quantifiers and (?ims:) modifiers; no backreferences or lookaround."),
+  context: z6.int().nonnegative().max(10).default(0),
+  include: z6.string().min(1).max(4096).describe("Anchored `**`/`*`/`?` pattern matched against the whole workspace-relative path. `*` does not cross `/`; use `**/` to include matching files in subdirectories.").optional()
+}).strict();
+var SearchMatchSchema = z6.object({
+  path: z6.string().min(1),
+  line: z6.int().positive().optional(),
+  text: z6.string().optional(),
+  before: z6.array(z6.string()).optional(),
+  after: z6.array(z6.string()).optional()
+}).strict();
+var SearchOutputSchema = z6.object({
+  matches: z6.array(SearchMatchSchema),
+  truncated: z6.boolean(),
+  scannedFiles: z6.int().nonnegative().describe("Files admitted by include and host authorization that reached path or content comparison."),
+  skippedDirectories: z6.int().nonnegative(),
+  skippedSymlinks: z6.int().nonnegative(),
+  denied: z6.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z6.boolean().optional(),
+  errors: z6.array(z6.object({ path: z6.string(), operation: z6.string(), code: z6.string() }).strict()).optional(),
+  errorsTruncated: z6.boolean().optional(),
+  hint: z6.string().min(1).optional(),
+  coverage: DiscoveryCoverageSchema
+}).strict();
+
+// src/agent-runtime/coding-search-case-fold.ts
+var MAX_UNIT = 65535;
+var foldedUnits;
+var hex = (unit) => `\\u${unit.toString(16).padStart(4, "0")}`;
+function folded() {
+  if (!foldedUnits) {
+    const canonical = new Int32Array(MAX_UNIT + 1);
+    const variants = new Map;
+    for (let unit = 0;unit <= MAX_UNIT; unit += 1) {
+      const upper = String.fromCharCode(unit).toUpperCase();
+      let key = upper.length !== 1 || unit >= 128 && upper.charCodeAt(0) < 128 ? unit : upper.charCodeAt(0);
+      if (key !== unit && !new RegExp(hex(unit), "i").test(String.fromCharCode(key)))
+        key = unit;
+      canonical[unit] = key;
+      const group = variants.get(key) ?? [];
+      group.push(unit);
+      variants.set(key, group);
+    }
+    foldedUnits = { canonical, variants };
+  }
+  return foldedUnits;
+}
+function caseVariants(code) {
+  const { canonical, variants } = folded();
+  return variants.get(canonical[code] ?? code) ?? [code];
+}
+var cased;
+function casedUnits() {
+  cased ??= [...folded().variants.values()].filter((group) => group.length > 1).flat();
+  return cased;
+}
+
+// src/agent-runtime/coding-search-class-ranges.ts
+var MAX_UNIT2 = 65535;
+var CONTROL_ESCAPES = { b: 8, t: 9, n: 10, v: 11, f: 12, r: 13 };
+var classEscapes;
+function classEscape(name) {
+  if (!classEscapes) {
+    classEscapes = new Map;
+    for (const letter of ["d", "D", "w", "W", "s", "S"]) {
+      const expression = new RegExp(`\\${letter}`);
+      const ranges = [];
+      for (let unit = 0;unit <= MAX_UNIT2; unit += 1) {
+        if (!expression.test(String.fromCharCode(unit)))
+          continue;
+        const last = ranges.at(-1);
+        if (last && last[1] === unit - 1)
+          last[1] = unit;
+        else
+          ranges.push([unit, unit]);
+      }
+      classEscapes.set(letter, ranges);
+    }
+  }
+  return classEscapes.get(name) ?? [];
+}
+function merge(ranges) {
+  const sorted = [...ranges].sort((left, right) => left[0] - right[0]);
+  const merged = [];
+  for (const [low, high] of sorted) {
+    const last = merged.at(-1);
+    if (last && low <= last[1] + 1)
+      last[1] = Math.max(last[1], high);
+    else
+      merged.push([low, high]);
+  }
+  return merged;
+}
+function complement(ranges) {
+  const result = [];
+  let next = 0;
+  for (const [low, high] of ranges) {
+    if (low > next)
+      result.push([next, low - 1]);
+    next = high + 1;
+  }
+  if (next <= MAX_UNIT2)
+    result.push([next, MAX_UNIT2]);
+  return result;
+}
+function classItem(body, start) {
+  if (body[start] !== "\\")
+    return { unit: body.charCodeAt(start), length: 1 };
+  const name = body.charAt(start + 1);
+  if ("dDwWsS".includes(name))
+    return { set: classEscape(name), length: 2 };
+  if (name in CONTROL_ESCAPES)
+    return { unit: CONTROL_ESCAPES[name], length: 2 };
+  const hex = (digits) => body.slice(start + 2, start + 2 + digits);
+  if (name === "x" && /^[0-9A-Fa-f]{2}$/.test(hex(2)))
+    return { unit: Number.parseInt(hex(2), 16), length: 4 };
+  if (name === "u" && /^[0-9A-Fa-f]{4}$/.test(hex(4)))
+    return { unit: Number.parseInt(hex(4), 16), length: 6 };
+  if (name === "c") {
+    const letter = body.charAt(start + 2);
+    return /[A-Za-z0-9_]/.test(letter) ? { unit: letter.charCodeAt(0) % 32, length: 3 } : { unit: 92, length: 1 };
+  }
+  if (/[0-7]/.test(name)) {
+    const digits = /^[0-7]+/.exec(body.slice(start + 1, start + (name <= "3" ? 4 : 3)))?.[0] ?? name;
+    return { unit: Number.parseInt(digits, 8), length: 1 + digits.length };
+  }
+  if (name === "")
+    return;
+  return { unit: body.charCodeAt(start + 1), length: 2 };
+}
+function parsed(source) {
+  let body = source.slice(1, -1);
+  const negated = body.startsWith("^");
+  if (negated)
+    body = body.slice(1);
+  const ranges = [];
+  const add = (item) => {
+    if (item.set)
+      ranges.push(...item.set);
+    else if (item.unit !== undefined)
+      ranges.push([item.unit, item.unit]);
+  };
+  for (let index = 0;index < body.length; ) {
+    const first = classItem(body, index);
+    if (!first)
+      return;
+    index += first.length;
+    if (body[index] !== "-" || index + 1 >= body.length) {
+      add(first);
+      continue;
+    }
+    const second = classItem(body, index + 1);
+    if (!second)
+      return;
+    index += 1 + second.length;
+    if (first.unit !== undefined && second.unit !== undefined) {
+      ranges.push([first.unit, second.unit]);
+      continue;
+    }
+    add(first);
+    add({ unit: 45 });
+    add(second);
+  }
+  return { positive: merge(ranges), negated };
+}
+function caseFolded(positive) {
+  const inside = (unit) => contains(positive, unit);
+  const added = [];
+  for (const unit of casedUnits()) {
+    if (!inside(unit) && caseVariants(unit).some(inside))
+      added.push([unit, unit]);
+  }
+  return added.length > 0 ? merge([...positive, ...added]) : positive;
+}
+function contains(ranges, unit) {
+  let low = 0;
+  let high = ranges.length - 1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    const range = ranges[middle];
+    if (!range)
+      return false;
+    if (unit < range[0])
+      high = middle - 1;
+    else if (unit > range[1])
+      low = middle + 1;
+    else
+      return true;
+  }
+  return false;
+}
+function classRanges(source, ignoreCase = false) {
+  const found = parsed(source);
+  if (!found)
+    return;
+  const positive = ignoreCase ? caseFolded(found.positive) : found.positive;
+  const ranges = found.negated ? complement(positive) : positive;
+  const expression = new RegExp(source, ignoreCase ? "i" : "");
+  const inside = (unit) => contains(ranges, unit);
+  for (const [low, high] of ranges.length > 0 ? ranges : [[0, MAX_UNIT2]]) {
+    for (const unit of [low - 1, low, low + high >> 1, high, high + 1]) {
+      if (unit < 0 || unit > MAX_UNIT2)
+        continue;
+      if (expression.test(String.fromCharCode(unit)) !== inside(unit))
+        return;
+    }
+  }
+  return ranges;
+}
+
+// src/agent-runtime/coding-search-regex-syntax.ts
+class UnsupportedRegexSyntax extends Error {
+}
+var MAX_REGEX_REPEAT = 1000;
+var QUANTIFIER = /^\{(\d+)(?:(,)(\d*))?\}/;
+var MODIFIERS = /^\(\?([ims]*)(?:-([ims]*))?:/;
+var CONTROL_ESCAPES2 = { t: 9, n: 10, v: 11, f: 12, r: 13 };
+function escapedUnit(source) {
+  const name = source.charAt(1);
+  if ("dDwWsS".includes(name))
+    return;
+  if (name in CONTROL_ESCAPES2)
+    return CONTROL_ESCAPES2[name];
+  if (source.length > 2 && (name === "x" || name === "u"))
+    return Number.parseInt(source.slice(2), 16);
+  if (name === "0")
+    return Number.parseInt(source.slice(1), 8);
+  if (name === "c")
+    return source.charCodeAt(2) % 32;
+  return source.charCodeAt(1);
+}
+function parseSearchRegex(pattern, check) {
+  let index = 0;
+  let modifiers = { ignoreCase: false, multiline: false, dotAll: false };
+  const atoms = new Map;
+  const unit = (key, create) => {
+    let atom = atoms.get(key);
+    if (!atom) {
+      atom = { key, ...create() };
+      atoms.set(key, atom);
+    }
+    return { kind: "unit", atom };
+  };
+  const native = (source, ranges) => {
+    const flags = `${modifiers.ignoreCase ? "i" : ""}${modifiers.dotAll ? "s" : ""}`;
+    return unit(`${flags}/${source}`, () => {
+      const expression = new RegExp(source, flags);
+      return {
+        ...ranges && { ranges },
+        matches: (code) => expression.test(String.fromCharCode(code))
+      };
+    });
+  };
+  const literal = (code) => {
+    const units = modifiers.ignoreCase ? caseVariants(code) : [code];
+    return unit(`=${units.join(",")}`, () => ({
+      ranges: units.map((value) => [value, value]),
+      matches: (other) => units.includes(other)
+    }));
+  };
+  const namedGroups = /\(\?<(?![=!])/.test(pattern);
+  const classEnd = (start) => {
+    let cursor = start + 1;
+    if (pattern[cursor] === "^")
+      cursor += 1;
+    while (cursor < pattern.length && pattern[cursor] !== "]") {
+      cursor += pattern[cursor] === "\\" ? 2 : 1;
+    }
+    return cursor + 1;
+  };
+  const escapeLength = (start) => {
+    const next = pattern[start + 1] ?? "";
+    if (/[1-9]/.test(next) || next === "k" && namedGroups) {
+      throw new UnsupportedRegexSyntax("backreference");
+    }
+    if (next === "0") {
+      const digits = /^[0-7]{0,2}/.exec(pattern.slice(start + 2))?.[0] ?? "";
+      return 2 + digits.length;
+    }
+    if (next === "c")
+      return /[A-Za-z]/.test(pattern[start + 2] ?? "") ? 3 : 0;
+    if (next === "x" && /^[0-9A-Fa-f]{2}$/.test(pattern.slice(start + 2, start + 4)))
+      return 4;
+    if (next === "u" && /^[0-9A-Fa-f]{4}$/.test(pattern.slice(start + 2, start + 6)))
+      return 6;
+    return 2;
+  };
+  const group = () => {
+    if (/^\(\?(?:=|!|<=|<!)/.test(pattern.slice(index))) {
+      throw new UnsupportedRegexSyntax("lookaround");
+    }
+    const outer = modifiers;
+    const modified = MODIFIERS.exec(pattern.slice(index));
+    if (modified) {
+      const on = modified[1] ?? "";
+      const off = modified[2] ?? "";
+      const flag = (name, current) => on.includes(name) ? true : off.includes(name) ? false : current;
+      modifiers = {
+        ignoreCase: flag("i", outer.ignoreCase),
+        multiline: flag("m", outer.multiline),
+        dotAll: flag("s", outer.dotAll)
+      };
+      index += modified[0].length;
+    } else if (pattern.startsWith("(?<", index))
+      index = pattern.indexOf(">", index) + 1;
+    else
+      index += 1;
+    const body = alternation();
+    modifiers = outer;
+    index += 1;
+    return body;
+  };
+  const assertion = (character) => {
+    index += 1;
+    if (character === "^")
+      return { kind: "assert", at: modifiers.multiline ? "line-start" : "start" };
+    return { kind: "assert", at: modifiers.multiline ? "line-end" : "end" };
+  };
+  let atomsRead = 0;
+  const atom = () => {
+    if (++atomsRead % 16 === 0)
+      check();
+    const character = pattern[index] ?? "";
+    if (character === "(")
+      return group();
+    if (character === "^" || character === "$")
+      return assertion(character);
+    if (character === "\\") {
+      const next = pattern[index + 1];
+      if (next === "b" || next === "B") {
+        index += 2;
+        return { kind: "assert", at: next === "b" ? "word" : "not-word" };
+      }
+      const length = escapeLength(index);
+      if (length === 0) {
+        index += 1;
+        return literal(92);
+      }
+      const source = pattern.slice(index, index + length);
+      index += length;
+      const code = escapedUnit(source);
+      if (code !== undefined && new RegExp(`^${source}$`).test(String.fromCharCode(code))) {
+        return literal(code);
+      }
+      return native(source, classRanges(`[${source}]`, modifiers.ignoreCase));
+    }
+    if (character === "[") {
+      const end = classEnd(index);
+      const source = pattern.slice(index, end);
+      index = end;
+      return native(source, classRanges(source, modifiers.ignoreCase));
+    }
+    index += 1;
+    if (character === ".") {
+      return native(".", classRanges(modifiers.dotAll ? "[\\s\\S]" : "[^\\n\\r\\u2028\\u2029]"));
+    }
+    return literal(character.charCodeAt(0));
+  };
+  const quantified = (body) => {
+    const character = pattern[index];
+    let min;
+    let max;
+    if (character === "*" || character === "+" || character === "?") {
+      min = character === "+" ? 1 : 0;
+      max = character === "?" ? 1 : Number.POSITIVE_INFINITY;
+      index += 1;
+    } else {
+      const counted = character === "{" ? QUANTIFIER.exec(pattern.slice(index)) : null;
+      if (!counted)
+        return body;
+      min = Number(counted[1]);
+      max = counted[2] === undefined ? min : counted[3] ? Number(counted[3]) : Number.POSITIVE_INFINITY;
+      if (min > MAX_REGEX_REPEAT || Number.isFinite(max) && max > MAX_REGEX_REPEAT) {
+        throw new UnsupportedRegexSyntax(`repetition beyond ${MAX_REGEX_REPEAT}`);
+      }
+      index += counted[0].length;
+    }
+    if (pattern[index] === "?")
+      index += 1;
+    return { kind: "repeat", body, min, max };
+  };
+  const sequence = () => {
+    const items = [];
+    while (index < pattern.length && pattern[index] !== "|" && pattern[index] !== ")") {
+      items.push(quantified(atom()));
+    }
+    if (items.length === 0)
+      return { kind: "empty" };
+    return items.length === 1 && items[0] ? items[0] : { kind: "sequence", items };
+  };
+  function alternation() {
+    const options = [sequence()];
+    while (pattern[index] === "|") {
+      index += 1;
+      options.push(sequence());
+    }
+    return options.length === 1 && options[0] ? options[0] : { kind: "alternation", options };
+  }
+  return alternation();
+}
+
+// src/agent-runtime/coding-search-unit-classes.ts
+var Ahead = { End: 0, Word: 1, LineTerminator: 2, Other: 3 };
+var isWord = (unit) => unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122 || unit === 95;
+var isLineTerminator = (unit) => unit === 10 || unit === 13 || unit === 8232 || unit === 8233;
+var classify = (unit) => isWord(unit) ? Ahead.Word : isLineTerminator(unit) ? Ahead.LineTerminator : Ahead.Other;
+var MAX_RANGE_MEMBERSHIPS = 1 << 22;
+var MAX_NATIVE_ATOMS = 64;
+var UNITS = 65536;
+function contains2(sorted, value) {
+  let low = 0;
+  let high = sorted.length - 1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    const found = sorted[middle] ?? 0;
+    if (found === value)
+      return true;
+    if (found < value)
+      low = middle + 1;
+    else
+      high = middle - 1;
+  }
+  return false;
+}
+function partition(ranged, check) {
+  const boundaries = new Set([0, UNITS]);
+  for (const atom of ranged) {
+    for (const [low, high] of atom.ranges ?? []) {
+      boundaries.add(low);
+      boundaries.add(high + 1);
+    }
+  }
+  const points = [...boundaries].sort((left, right) => left - right);
+  const segmentOf = new Int32Array(UNITS);
+  const starts = new Map;
+  const ends = new Map;
+  for (const [index, atom] of ranged.entries()) {
+    for (const [low, high] of atom.ranges ?? []) {
+      const opening = starts.get(low) ?? [];
+      opening.push(index);
+      starts.set(low, opening);
+      const closing = ends.get(high + 1) ?? [];
+      closing.push(index);
+      ends.set(high + 1, closing);
+    }
+  }
+  const active = new Set;
+  const members = [];
+  let memberships = 0;
+  for (let segment = 0;segment + 1 < points.length; segment += 1) {
+    const from = points[segment] ?? 0;
+    const to = points[segment + 1] ?? UNITS;
+    for (const index of ends.get(from) ?? [])
+      active.delete(index);
+    for (const index of starts.get(from) ?? [])
+      active.add(index);
+    memberships += active.size;
+    if (memberships > MAX_RANGE_MEMBERSHIPS) {
+      throw new UnsupportedRegexSyntax("character sets that overlap too much");
+    }
+    if (segment % 128 === 0)
+      check();
+    members.push(Int32Array.from(active).sort());
+    segmentOf.fill(segment, from, to);
+  }
+  return { segmentOf, members };
+}
+function unitClasses(atoms, check) {
+  const ranged = [];
+  const natives = [];
+  const indexOf = new Map;
+  for (const atom of atoms) {
+    if (indexOf.has(atom))
+      continue;
+    const list = atom.ranges ? ranged : natives;
+    indexOf.set(atom, { ranged: list === ranged, index: list.push(atom) - 1 });
+  }
+  if (natives.length > MAX_NATIVE_ATOMS) {
+    throw new UnsupportedRegexSyntax(`more than ${MAX_NATIVE_ATOMS} character classes the engine must evaluate unit by unit`);
+  }
+  const { segmentOf, members } = partition(ranged, check);
+  const words = Math.ceil(natives.length / 32);
+  const classOfUnit = new Int32Array(UNITS).fill(-1);
+  const known = new Map;
+  const classes = [];
+  let evaluations = 0;
+  const classOf = (unit) => {
+    const cached = classOfUnit[unit] ?? -1;
+    if (cached >= 0)
+      return cached;
+    const kind = classify(unit);
+    const segment = segmentOf[unit] ?? 0;
+    const native = new Uint32Array(words);
+    for (const [index, atom] of natives.entries()) {
+      if (++evaluations % 128 === 0)
+        check();
+      if (atom.matches(unit))
+        native[index >> 5] = (native[index >> 5] ?? 0) | 1 << (index & 31);
+    }
+    const key = `${kind}:${segment}:${native.join(",")}`;
+    let found = known.get(key);
+    if (found === undefined) {
+      found = classes.push({ kind, ranged: members[segment] ?? new Int32Array, native }) - 1;
+      known.set(key, found);
+    }
+    classOfUnit[unit] = found;
+    return found;
+  };
+  const nativeBit = (found, index) => ((found.native[index >> 5] ?? 0) & 1 << (index & 31)) !== 0;
+  return {
+    classOf,
+    kindOf: (unitClass) => classes[unitClass]?.kind ?? Ahead.Other,
+    atomsOf: (unitClass) => {
+      const found = classes[unitClass];
+      if (!found)
+        return [];
+      found.atoms ??= [
+        ...Array.from(found.ranged, (index) => ranged[index]),
+        ...natives.filter((_, index) => nativeBit(found, index))
+      ].filter((atom) => atom !== undefined);
+      return found.atoms;
+    },
+    matches: (atom, unitClass) => {
+      const place = indexOf.get(atom);
+      const found = classes[unitClass];
+      if (!place || !found)
+        return false;
+      return place.ranged ? contains2(found.ranged, place.index) : nativeBit(found, place.index);
+    }
+  };
+}
+
+// src/agent-runtime/coding-search-automaton.ts
+var MAX_REGEX_STATES = 16384;
+var MAX_BUILD_STEPS = 4 * MAX_REGEX_STATES;
+var MAX_CACHED_STATES = 4096;
+var MAX_CACHED_TRANSITIONS = 65536;
+function buildAutomaton(tree, check) {
+  const states = [{ kind: "accept" }];
+  let steps = 0;
+  const add = (state) => {
+    if (states.length >= MAX_REGEX_STATES) {
+      throw new UnsupportedRegexSyntax(`more than ${MAX_REGEX_STATES} matcher states`);
+    }
+    states.push(state);
+    return states.length - 1;
+  };
+  const build = (node, next) => {
+    if (++steps > MAX_BUILD_STEPS) {
+      throw new UnsupportedRegexSyntax(`more than ${MAX_BUILD_STEPS} construction steps`);
+    }
+    if (steps % 128 === 0)
+      check();
+    switch (node.kind) {
+      case "empty":
+        return next;
+      case "unit":
+        return add({ kind: "unit", atom: node.atom, next });
+      case "assert":
+        return add({ kind: "assert", at: node.at, next });
+      case "sequence":
+        return node.items.reduceRight((after, item) => build(item, after), next);
+      case "alternation":
+        return add({ kind: "split", next: node.options.map((option) => build(option, next)) });
+      case "repeat": {
+        let tail = next;
+        if (node.max === Number.POSITIVE_INFINITY) {
+          const loop = { kind: "split", next: [] };
+          tail = add(loop);
+          loop.next.push(build(node.body, tail), next);
+        } else {
+          for (let optional = node.min;optional < node.max; optional += 1) {
+            tail = add({ kind: "split", next: [build(node.body, tail), next] });
+          }
+        }
+        for (let required = 0;required < node.min; required += 1)
+          tail = build(node.body, tail);
+        return tail;
+      }
+    }
+  };
+  return { states, start: build(tree, 0) };
+}
+var holds = (at, atStart, behind, ahead) => {
+  switch (at) {
+    case "start":
+      return atStart;
+    case "end":
+      return ahead === Ahead.End;
+    case "line-start":
+      return atStart || behind === Ahead.LineTerminator;
+    case "line-end":
+      return ahead === Ahead.End || ahead === Ahead.LineTerminator;
+    case "word":
+      return behind === Ahead.Word !== (ahead === Ahead.Word);
+    case "not-word":
+      return behind === Ahead.Word === (ahead === Ahead.Word);
+  }
+};
+var KINDS = [Ahead.End, Ahead.Word, Ahead.LineTerminator, Ahead.Other];
+var contextOf = (atStart, behind, ahead) => (atStart ? 16 : 0) + behind * 4 + ahead;
+function lazyMatcher({ states, start }, check) {
+  let interned = new Map;
+  const initial = new Map;
+  const starts = new Map;
+  const startsByUnits = new Map;
+  let startKernels = new Map;
+  let transitions = 0;
+  let operations = 0;
+  let flushes = 0;
+  let simulating = false;
+  const flush = () => {
+    interned = new Map;
+    initial.clear();
+    startKernels = new Map;
+    transitions = 0;
+    if (++flushes >= 2)
+      simulating = true;
+  };
+  const classes = unitClasses(states.flatMap((state) => state.kind === "unit" ? [state.atom] : []), check);
+  const seen = new Int32Array(states.length);
+  let generation = 0;
+  const closure = (kernel, context) => {
+    const atStart = context >= 16;
+    const behind = KINDS[context >> 2 & 3] ?? Ahead.Other;
+    const ahead = KINDS[context & 3] ?? Ahead.Other;
+    generation += 1;
+    const units = [];
+    let accepts = false;
+    const pending = [...kernel];
+    for (let index = pending.pop();index !== undefined; index = pending.pop()) {
+      if (seen[index] === generation)
+        continue;
+      seen[index] = generation;
+      if (++operations % 128 === 0)
+        check();
+      const state = states[index];
+      if (state?.kind === "unit")
+        units.push(index);
+      else if (state?.kind === "accept")
+        accepts = true;
+      else if (state?.kind === "split")
+        pending.push(...state.next);
+      else if (state && holds(state.at, atStart, behind, ahead))
+        pending.push(state.next);
+    }
+    return { units, accepts };
+  };
+  const sorted = (units) => units.sort((left, right) => left - right);
+  const startOf = (context) => {
+    let found = starts.get(context);
+    if (!found) {
+      const { units, accepts } = closure([start], context);
+      sorted(units);
+      const key = `${accepts ? 1 : 0}:${units.join(",")}`;
+      found = startsByUnits.get(key);
+      if (!found) {
+        const byAtom = new Map;
+        for (const index of units) {
+          const state = states[index];
+          if (state?.kind !== "unit")
+            continue;
+          const next = byAtom.get(state.atom) ?? [];
+          next.push(state.next);
+          byAtom.set(state.atom, next);
+        }
+        found = { id: startsByUnits.size, units, accepts, byAtom };
+        startsByUnits.set(key, found);
+      }
+      starts.set(context, found);
+    }
+    return found;
+  };
+  const enter = (kernel, context) => {
+    const own = closure(kernel, context);
+    sorted(own.units);
+    const opening = startOf(context);
+    const accepts = own.accepts || opening.accepts;
+    const key = `${opening.id}:${accepts ? 1 : 0}:${own.units.join(",")}`;
+    let found = interned.get(key);
+    if (!found) {
+      if (interned.size >= MAX_CACHED_STATES)
+        flush();
+      found = { start: opening, own: own.units, accepts, next: new Map };
+      interned.set(key, found);
+    }
+    return found;
+  };
+  const begin = (ahead) => {
+    let found = initial.get(ahead);
+    if (!found) {
+      found = enter([], contextOf(true, Ahead.End, ahead));
+      initial.set(ahead, found);
+    }
+    return found;
+  };
+  const startKernel = (opening, unitClass) => {
+    let byClass = startKernels.get(opening.id);
+    if (!byClass) {
+      byClass = new Map;
+      startKernels.set(opening.id, byClass);
+    }
+    let found = byClass.get(unitClass);
+    if (!found) {
+      const matching = classes.atomsOf(unitClass);
+      found = [];
+      if (matching.length < opening.byAtom.size) {
+        for (const atom of matching)
+          found.push(...opening.byAtom.get(atom) ?? []);
+      } else {
+        for (const [atom, next] of opening.byAtom) {
+          if (++operations % 128 === 0)
+            check();
+          if (classes.matches(atom, unitClass))
+            found.push(...next);
+        }
+      }
+      byClass.set(unitClass, found);
+      transitions += 1;
+    }
+    return found;
+  };
+  const advance = (opening, own, unitClass) => {
+    const kernel = [...startKernel(opening, unitClass)];
+    for (const index of own) {
+      const state = states[index];
+      if (state?.kind === "unit" && classes.matches(state.atom, unitClass))
+        kernel.push(state.next);
+    }
+    return kernel;
+  };
+  const step = (from, unitClass, ahead) => {
+    const key = unitClass * 4 + ahead;
+    const kernel = advance(from.start, from.own, unitClass);
+    const reached = enter(kernel, contextOf(false, classes.kindOf(unitClass), ahead));
+    if (++transitions > MAX_CACHED_TRANSITIONS)
+      flush();
+    from.next.set(key, reached);
+    return reached;
+  };
+  const { classOf } = classes;
+  const simulate = (text) => {
+    const length = text.length;
+    let context = contextOf(true, Ahead.End, length === 0 ? Ahead.End : classify(text.charCodeAt(0)));
+    let own = [];
+    let accepts = startOf(context).accepts;
+    for (let position = 0;; position += 1) {
+      if (accepts)
+        return true;
+      if (position === length)
+        return false;
+      if ((position & 4095) === 4095)
+        check();
+      const after = position + 1;
+      const ahead = after === length ? Ahead.End : classify(text.charCodeAt(after));
+      const unitClass = classOf(text.charCodeAt(position));
+      const kernel = advance(startOf(context), own, unitClass);
+      context = contextOf(false, classes.kindOf(unitClass), ahead);
+      const reached = closure(kernel, context);
+      own = reached.units;
+      accepts = reached.accepts || startOf(context).accepts;
+    }
+  };
+  return {
+    test(text) {
+      if (simulating)
+        return simulate(text);
+      const length = text.length;
+      let current = begin(length === 0 ? Ahead.End : classify(text.charCodeAt(0)));
+      for (let position = 0;; position += 1) {
+        if (current.accepts)
+          return true;
+        if (position === length)
+          return false;
+        if ((position & 4095) === 4095)
+          check();
+        const after = position + 1;
+        const ahead = after === length ? Ahead.End : classify(text.charCodeAt(after));
+        const unitClass = classOf(text.charCodeAt(position));
+        current = current.next.get(unitClass * 4 + ahead) ?? step(current, unitClass, ahead);
+      }
+    }
+  };
+}
+
+// src/agent-runtime/coding-search-matcher.ts
+var MAX_NATIVE_LINE_WORK = 2 ** 24;
+var LONGEST_LINE = 8192;
+function disjointUnits(options) {
+  const ranges = [];
+  for (const option of options) {
+    if (option.kind !== "unit" || !option.atom.ranges)
+      return false;
+    ranges.push(...option.atom.ranges);
+  }
+  ranges.sort((left, right) => left[0] - right[0]);
+  return ranges.every((range, index) => index === 0 || range[0] > (ranges[index - 1]?.[1] ?? -1));
+}
+function matchesEmpty(node) {
+  switch (node.kind) {
+    case "empty":
+    case "assert":
+      return true;
+    case "unit":
+      return false;
+    case "repeat":
+      return node.min === 0 || matchesEmpty(node.body);
+    case "sequence":
+      return node.items.every(matchesEmpty);
+    case "alternation":
+      return node.options.some(matchesEmpty);
+  }
+}
+function backtrackingWork(node, units) {
+  switch (node.kind) {
+    case "empty":
+      return { paths: 1, length: 0 };
+    case "unit":
+    case "assert":
+      return { paths: 1, length: 1 };
+    case "repeat": {
+      const body = backtrackingWork(node.body, units);
+      const empty = matchesEmpty(node.body);
+      const min = empty ? node.min : Math.min(node.min, units);
+      const max = Math.min(node.max, empty ? node.min + units : units);
+      let paths = 1;
+      let optional = 1;
+      for (let count = 0;count < max && paths * optional <= MAX_NATIVE_LINE_WORK; count += 1) {
+        if (count < min)
+          paths *= body.paths;
+        else
+          optional = 1 + body.paths * optional;
+      }
+      return { paths: paths * optional, length: max * Math.max(body.length, 1) };
+    }
+    case "sequence":
+      return node.items.reduce((total, item) => {
+        const part = backtrackingWork(item, units);
+        return { paths: total.paths * part.paths, length: total.length + part.length };
+      }, { paths: 1, length: 0 });
+    case "alternation":
+      if (disjointUnits(node.options))
+        return { paths: 1, length: node.options.length };
+      return node.options.reduce((total, option) => {
+        const part = backtrackingWork(option, units);
+        return {
+          paths: total.paths + part.paths,
+          length: Math.max(total.length, part.length)
+        };
+      }, { paths: 0, length: 0 });
+  }
+}
+function groupCount(pattern) {
+  let groups = 0;
+  let inClass = false;
+  for (let index = 0;index < pattern.length; index += 1) {
+    const character = pattern[index];
+    if (character === "\\")
+      index += 1;
+    else if (inClass)
+      inClass = character !== "]";
+    else if (character === "[")
+      inClass = true;
+    else if (character === "(")
+      groups += 1;
+  }
+  return groups;
+}
+function validated(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    codingRefusal("BAD_REQUEST", "This pattern is not a valid regular expression", {
+      details: { pattern, reason: error instanceof Error ? error.message : String(error) },
+      hint: "Fix the expression, or use regex: false.",
+      cause: error
+    });
+  }
+}
+function refuseUnsupported(error) {
+  if (!(error instanceof UnsupportedRegexSyntax))
+    throw error;
+  codingRefusal("BAD_REQUEST", `Search regex cannot use ${error.message}`, {
+    hint: "Groups, alternation, classes, modifiers and quantifiers are supported; backreferences and lookaround are not. Rewrite the pattern or use regex: false.",
+    cause: error
+  });
+}
+function compileSearchRegex(pattern, check) {
+  const expression = validated(pattern);
+  try {
+    const tree = parseSearchRegex(pattern, check);
+    const nativeUpTo = new Map;
+    const groups = groupCount(pattern);
+    const native = (length) => {
+      let bucket = 16;
+      while (bucket < length)
+        bucket *= 2;
+      let found = nativeUpTo.get(bucket);
+      if (found === undefined) {
+        const work = backtrackingWork(tree, bucket);
+        found = work.paths * Math.max(work.length, 1) * bucket * (groups + 1) <= MAX_NATIVE_LINE_WORK;
+        nativeUpTo.set(bucket, found);
+      }
+      return found;
+    };
+    let automaton = native(LONGEST_LINE) ? undefined : lazyMatcher(buildAutomaton(tree, check), check);
+    return {
+      test(text) {
+        if (native(text.length)) {
+          check();
+          return expression.test(text);
+        }
+        automaton ??= lazyMatcher(buildAutomaton(tree, check), check);
+        return automaton.test(text);
+      }
+    };
+  } catch (error) {
+    refuseUnsupported(error);
+  }
+}
+
+// src/agent-runtime/coding-tool-search.ts
+var jsonBytes = (value) => Buffer.byteLength(JSON.stringify(value));
+var YIELD_EVERY_MS = 16;
+function collectMatches(input, limits, budget, output, availableBytes) {
+  const matcher = input.regex ? compileSearchRegex(input.query, () => budget.check()) : null;
+  let usedBytes = 0;
+  const hit = (text) => {
+    budget.check();
+    if (Buffer.byteLength(text) > 8192) {
+      budget.reasons.add("max-line-bytes");
+      return false;
+    }
+    return matcher ? matcher.test(text) : text.includes(input.query);
+  };
+  const append = (match) => {
+    const bytes = jsonBytes(match) + 1;
+    if (usedBytes + bytes > availableBytes)
+      budget.stop("max-output-bytes");
+    output.matches.push(match);
+    usedBytes += bytes;
+    if (output.matches.length >= limits.maxSearchResults)
+      budget.stop("max-results");
+  };
+  let since = performance.now();
+  const yieldBetweenLines = async () => {
+    if (performance.now() - since < YIELD_EVERY_MS)
+      return;
+    await new Promise((resolve) => setImmediate(resolve));
+    since = performance.now();
+    budget.check();
+  };
+  return async (file) => {
+    if (input.mode === "path") {
+      if (hit(file.relative))
+        append({ path: file.relative });
+      return true;
+    }
+    if (file.content === undefined)
+      return true;
+    const lines = file.content.text.split(`
+`);
+    for (let index = 0;index < lines.length; index += 1) {
+      await yieldBetweenLines();
+      const line = lines[index];
+      if (line === undefined || !hit(line))
+        continue;
+      append({
+        path: file.relative,
+        line: index + 1,
+        text: line,
+        ...input.context > 0 && {
+          before: lines.slice(Math.max(0, index - input.context), index),
+          after: lines.slice(index + 1, index + 1 + input.context)
+        }
+      });
+    }
+    return true;
+  };
+}
+async function searchFiles(config, limits, input, caller) {
+  const started = performance.now();
+  const budget = new ContainedScanBudget({
+    maxDirectories: limits.maxSearchDirectories,
+    maxEntries: limits.maxSearchEntries,
+    maxBytes: limits.maxSearchBytes,
+    deadline: started + limits.searchTimeoutMs
+  });
+  const output = {
+    matches: [],
+    truncated: false,
+    scannedFiles: 0,
+    skippedDirectories: 0,
+    skippedSymlinks: 0,
+    coverage: {
+      complete: true,
+      reasons: [],
+      scope: {
+        path: ".",
+        include: input.include ?? "**",
+        excludedDirectories: config.search?.excludeDirectories ? "configured" : "default",
+        symlinks: "skip"
+      },
+      visitedDirectories: 0,
+      visitedEntries: 0,
+      readBytes: 0,
+      elapsedMs: 0
+    }
+  };
+  const minimumBytes = jsonBytes(output);
+  if (minimumBytes + 512 > limits.maxSearchOutputBytes) {
+    codingRefusal("BAD_REQUEST", "The search output budget cannot hold its coverage envelope", {
+      hint: "Increase maxSearchOutputBytes or shorten include."
+    });
+  }
+  const visitFile = collectMatches(input, limits, budget, output, limits.maxSearchOutputBytes - minimumBytes - 512);
+  const excluded = new Set(config.search?.excludeDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES);
+  let rejectedByInclude = 0;
+  let prunedByInclude = 0;
+  if (caller?.aborted)
+    budget.reasons.add("cancelled");
+  else {
+    try {
+      await withSignalDeadline(limits.searchTimeoutMs, caller, () => "search-timeout", async (signal) => {
+        budget.limits.signal = signal;
+        const included = input.include ? compileWorkspaceGlob(input.include, () => budget.check()) : undefined;
+        budget.directory();
+        const root = await budget.wait(() => openPinnedDirectory(config.root), (handle) => {
+          handle.close().catch(() => {
+            return;
+          });
+        });
+        try {
+          await budget.wait(() => authorizeCodingTool(config, {
+            operation: "search",
+            query: input.query,
+            mode: input.mode
+          }));
+          await budget.wait(() => authorizeCodingPath(config, "."));
+          const scan = await scanContainedFiles({
+            root,
+            maxDepth: limits.maxSearchDepth,
+            maxFiles: limits.maxSearchFiles,
+            symlinks: "skip",
+            skipUnreadable: true,
+            budget,
+            visitFile,
+            maxDiagnostics: limits.maxSearchResults,
+            ...input.mode === "content" && { readMaxBytes: limits.maxReadBytes },
+            excludeDirectory: (relative) => {
+              if (relative.split(path3.sep).some((segment) => excluded.has(segment)))
+                return true;
+              if (included && !included.mayContain(relative)) {
+                prunedByInclude += 1;
+                return true;
+              }
+              return false;
+            },
+            includeFile: (candidate) => {
+              if (included && !included.test(candidate)) {
+                rejectedByInclude += 1;
+                return false;
+              }
+              return true;
+            },
+            authorizePath: (candidate) => isCodingPathAuthorized(config, candidate)
+          });
+          output.scannedFiles = scan.scannedFiles;
+          output.skippedDirectories = scan.skippedDirectories;
+          output.skippedSymlinks = scan.skippedSymlinks;
+          if (scan.denied.length > 0) {
+            output.denied = scan.denied.slice(0, limits.maxSearchResults).map(({ relative, kind }) => ({ path: relative, kind }));
+            output.deniedTruncated = scan.deniedTruncated || scan.denied.length > output.denied.length;
+          }
+          if (scan.errors.length > 0) {
+            output.errors = scan.errors.slice(0, limits.maxSearchResults);
+            output.errorsTruncated = scan.errorsTruncated || scan.errors.length > output.errors.length;
+          }
+        } finally {
+          await root.close();
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof ScanStopped))
+        throw error;
+    }
+  }
+  if (input.include && output.scannedFiles === 0 && (rejectedByInclude > 0 || prunedByInclude > 0) && budget.reasons.size === 0) {
+    output.hint = "The anchored include rejected the reached files or pruned incompatible directories. `*` does not cross `/`; use `**/` for subdirectories.";
+  }
+  const refresh = () => {
+    output.coverage.reasons = [...budget.reasons];
+    output.coverage.complete = budget.reasons.size === 0;
+    output.truncated = !output.coverage.complete;
+    output.coverage.visitedDirectories = budget.visitedDirectories;
+    output.coverage.visitedEntries = budget.visitedEntries;
+    output.coverage.readBytes = budget.readBytes;
+    output.coverage.elapsedMs = Math.round((performance.now() - started) * 100) / 100;
+  };
+  refresh();
+  boundSearchDiagnostics(output, budget, limits.maxSearchOutputBytes);
+  refresh();
+  if (jsonBytes(output) > limits.maxSearchOutputBytes)
+    throw new Error("Search coverage envelope exceeded its reserved budget");
+  return output;
+}
+function createSearchCodingTool(config, limits) {
+  return defineRuntimeTool2({
+    name: "search_files",
+    description: "Search bounded relative paths or UTF-8 file content under the workspace root; coverage explains incomplete results.",
+    identity: { serviceName: "coding", action: "search", method: "POST" },
+    input: SearchInputSchema,
+    output: SearchOutputSchema,
+    transports: ["AGENT"],
+    handler: ({ input, signal }) => searchFiles(config, limits, input, signal)
+  });
+}
+
+// src/agent-runtime/coding-tool-search-patch.ts
+var EditInputSchema = z7.object({
+  path: z7.string().min(1),
+  oldText: z7.string().min(1),
+  newText: z7.string(),
+  replaceAll: z7.boolean().default(false),
+  expectedSha256: z7.string().length(64).optional(),
+  dryRun: z7.boolean().default(false)
+}).strict();
+var EditOutputSchema = z7.object({
+  path: z7.string().min(1),
+  baseSha256: z7.string().length(64),
+  sha256: z7.string().length(64),
+  replacements: z7.int().positive(),
+  bytes: z7.int().nonnegative(),
+  applied: z7.boolean()
+}).strict();
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+async function editFile(config, limits, input) {
+  return withCodingRoot(config.root, async (root, rootPath) => {
+    const relative = boundedCodingRelativePath(rootPath, input.path, limits.maxPathBytes);
+    await authorizeCodingPathChain(config, relative, root);
+    const parent = await openContainedParent(root, relative).catch((error) => refuseMissingCodingPath(error, relative));
+    try {
+      return await withCodingPathLock(root, relative, async () => {
+        const readCurrent = async () => {
+          const handle = await openContainedParentFile(parent).catch((error) => refuseMissingCodingPath(error, relative));
+          return readContainedUtf8Handle(handle, limits.maxWriteBytes).finally(() => handle.close());
+        };
+        await authorizeCodingTool(config, { operation: "read", path: relative });
+        const read = await readCurrent();
+        const source = read.text;
+        const baseSha256 = sha256(source);
+        if (input.expectedSha256 !== undefined && baseSha256 !== input.expectedSha256) {
+          conflict2("The file changed since it was read", {
+            message: "The file changed since it was read",
+            path: relative,
+            expectedSha256: input.expectedSha256,
+            actualSha256: baseSha256
+          });
+        }
+        const count = textOccurrences(source, input.oldText);
+        if (count === 0) {
+          codingPathRefusal("NOT_FOUND", "oldText does not appear in this file", relative, {
+            details: { occurrences: 0 },
+            hint: "Read the file and copy the snippet exactly, including indentation."
+          });
+        }
+        if (!input.replaceAll && count !== 1) {
+          codingPathRefusal("CONFLICT", `oldText appears ${count} times, so the edit is ambiguous`, relative, {
+            details: { occurrences: count },
+            hint: "Lengthen the snippet until it is unique, or pass replaceAll: true."
+          });
+        }
+        const replacements = input.replaceAll ? count : 1;
+        const literalReplacement = () => input.newText;
+        const changed = input.replaceAll ? source.replaceAll(input.oldText, literalReplacement) : source.replace(input.oldText, literalReplacement);
+        const bytes = Buffer.byteLength(changed);
+        const resultSha256 = sha256(changed);
+        if (bytes > limits.maxWriteBytes) {
+          codingPathRefusal("BAD_REQUEST", `The result would be ${bytes} bytes, over the ${limits.maxWriteBytes}-byte limit`, relative, {
+            details: { bytes, maxWriteBytes: limits.maxWriteBytes },
+            hint: "Make a smaller edit, or split the file."
+          });
+        }
+        await authorizeCodingTool(config, {
+          operation: "edit",
+          path: relative,
+          baseSha256,
+          resultSha256,
+          resultBytes: bytes,
+          replacements,
+          dryRun: input.dryRun
+        });
+        await assertContainedParentCurrent(root, relative, parent.handle).catch((error) => refuseWriteConflict(error, relative));
+        if (!input.dryRun) {
+          if (sha256((await readCurrent()).text) !== baseSha256) {
+            conflict2("The file changed since it was read", {
+              message: "The file changed since it was read",
+              path: relative
+            });
+          }
+          await writeContainedFile({
+            parent,
+            content: changed,
+            replace: true,
+            mode: read.mode
+          }).catch((error) => refuseWriteConflict(error, relative));
+        }
+        return {
+          path: relative,
+          baseSha256,
+          sha256: resultSha256,
+          replacements,
+          bytes,
+          applied: !input.dryRun
+        };
+      });
+    } finally {
+      await parent.handle.close();
+    }
+  });
+}
+function createSearchAndPatchCodingTools(config, limits) {
+  const edit = defineRuntimeTool2({
+    name: "edit_file",
+    description: "Replace an exact snippet in one workspace file.",
+    identity: { serviceName: "coding", action: "edit-file", method: "POST" },
+    input: EditInputSchema,
+    output: EditOutputSchema,
+    transports: ["AGENT"],
+    handler: ({ input }) => editFile(config, limits, input)
+  });
+  return [createSearchCodingTool(config, limits), edit];
+}
+
+// src/agent-runtime/coding-tool-shell.ts
+import { fstatSync, statSync } from "node:fs";
+import { realpath as realpath2, stat } from "node:fs/promises";
+import path4 from "node:path";
+
+// src/agent-runtime/coding-shell-process.ts
+function preview(data, budget) {
+  if (data.byteLength <= budget) {
+    return { data, headBytes: data.byteLength, tailBytes: 0, omittedBytes: 0 };
+  }
+  const headEnd = utf8AlignedEnd(data, 0, Math.ceil(budget / 2));
+  const tailStart = Math.max(headEnd, utf8AlignedStart(data, data.byteLength - Math.floor(budget / 2), data.byteLength));
+  const tailBytes = data.byteLength - tailStart;
+  return {
+    data: Buffer.concat([data.subarray(0, headEnd), data.subarray(tailStart)]),
+    headBytes: headEnd,
+    tailBytes,
+    omittedBytes: data.byteLength - headEnd - tailBytes
+  };
+}
+function retainedPreview(data) {
+  const end = utf8AlignedEnd(data, 0, data.byteLength);
+  return {
+    data: data.subarray(0, end),
+    headBytes: end,
+    tailBytes: 0,
+    omittedBytes: data.byteLength - end
+  };
+}
+async function runCodingShell(input) {
+  const stdoutHeader = Buffer.from(`--- stdout ---
+`);
+  const stderrHeader = Buffer.from(`
+--- stderr ---
+`);
+  const artifactPayloadLimit = input.maxArtifactBytes - stdoutHeader.byteLength - stderrHeader.byteLength;
+  if (input.artifacts && artifactPayloadLimit < 0)
+    throw new Error("maxArtifactBytes is smaller than the shell artifact envelope");
+  if (input.signal?.aborted) {
+    return ShellOutputSchema.parse({
+      executable: input.executableName,
+      exitCode: null,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      outcome: "cancelled"
+    });
+  }
+  const stdout = [];
+  const stderr = [];
+  const artifactStdout = [];
+  const artifactStderr = [];
+  let retained = 0;
+  let artifactBytes = 0;
+  let outcome = "exited";
+  let child;
+  let exitCode = null;
+  let signal = null;
+  const outputLimit = new Error("Coding command output retention budget exceeded");
+  const launch = input.spawn;
+  const retain = (target, artifactTarget, chunk) => {
+    const remaining = Math.max(0, input.maxOutputBytes - retained);
+    if (remaining > 0) {
+      const kept = Buffer.from(chunk.subarray(0, remaining));
+      target.push(kept);
+      retained += kept.byteLength;
+    }
+    if (input.artifacts) {
+      const artifactRemaining = Math.max(0, artifactPayloadLimit - artifactBytes);
+      if (artifactRemaining > 0) {
+        const kept = Buffer.from(chunk.subarray(0, artifactRemaining));
+        artifactTarget.push(kept);
+        artifactBytes += kept.byteLength;
+      }
+      if (chunk.byteLength > artifactRemaining)
+        throw outputLimit;
+    } else if (chunk.byteLength > remaining)
+      throw outputLimit;
+  };
+  const command = startNativeCommand({
+    executable: input.executable,
+    args: [...input.args],
+    cwd: input.cwd,
+    env: { ...input.environment },
+    envPolicy: "declared-only",
+    signal: input.signal ?? new AbortController().signal,
+    stop: { target: "group", graceMs: 0 },
+    descendants: "terminate-after-leader",
+    onOutput: (bytes, channel) => retain(channel === "stdout" ? stdout : stderr, channel === "stdout" ? artifactStdout : artifactStderr, bytes),
+    onLeaderSettled: (event) => {
+      if (event.kind === "error")
+        return;
+      exitCode = event.exitCode;
+      signal = event.signal;
+    }
+  }, (started) => {
+    child = started;
+  }, {
+    group: process.platform !== "win32",
+    force: true,
+    timeoutMs: input.timeoutMs,
+    cleanupTimeoutMs: input.terminationGraceMs,
+    closeTimeoutMs: input.terminationGraceMs,
+    ...launch ? {
+      launch: () => {
+        child = launch();
+        return child;
+      }
+    } : {},
+    maxBufferedBytes: Math.max(64 * 1024, input.maxOutputBytes, input.artifacts ? artifactPayloadLimit : 0),
+    ...input.cwdDescriptor !== undefined && { cwdDescriptor: input.cwdDescriptor }
+  });
+  try {
+    const result = await command.result;
+    exitCode = result.exitCode;
+    signal = result.signal;
+  } catch (error) {
+    if (error === outputLimit)
+      outcome = "output-limit";
+    else if (input.signal?.aborted && error === input.signal.reason)
+      outcome = "cancelled";
+    else if (error instanceof NativeCommandError2 && error.code === "COMMAND_LIMIT" && (error.reason === "deadline" || error.reason === "output-budget"))
+      outcome = error.reason === "deadline" ? "timeout" : "output-limit";
+    else if (error instanceof CommandStopped)
+      outcome = "cancelled";
+    else
+      throw error;
+  }
+  const hasArtifact = input.artifacts && artifactBytes > input.maxOutputBytes;
+  const completeStdout = Buffer.concat(artifactStdout);
+  const completeStderr = Buffer.concat(artifactStderr);
+  const artifactData = hasArtifact ? Buffer.concat([stdoutHeader, completeStdout, stderrHeader, completeStderr]) : undefined;
+  const stdoutBudget = completeStderr.byteLength === 0 ? input.maxOutputBytes : Math.ceil(input.maxOutputBytes / 2);
+  const stderrBudget = completeStdout.byteLength === 0 ? input.maxOutputBytes : Math.floor(input.maxOutputBytes / 2);
+  const stdoutPreview = hasArtifact ? preview(completeStdout, stdoutBudget) : retainedPreview(Buffer.concat(stdout));
+  const stderrPreview = hasArtifact ? preview(completeStderr, stderrBudget) : retainedPreview(Buffer.concat(stderr));
+  const persisted = hasArtifact ? await input.artifacts?.write({
+    mediaType: "text/plain; charset=utf-8",
+    data: artifactData ?? new Uint8Array,
+    ...input.authorization && { authorization: input.authorization }
+  }) : undefined;
+  return ShellOutputSchema.parse({
+    executable: input.executableName,
+    exitCode,
+    signal,
+    stdout: stdoutPreview.data.toString("utf8"),
+    stderr: stderrPreview.data.toString("utf8"),
+    outcome,
+    ...persisted && {
+      artifact: {
+        reference: persisted.reference,
+        bytes: artifactData?.byteLength ?? 0,
+        truncated: outcome === "output-limit",
+        headBytes: stdoutPreview.headBytes + stderrPreview.headBytes,
+        tailBytes: stdoutPreview.tailBytes + stderrPreview.tailBytes,
+        omittedBytes: stdoutPreview.omittedBytes + stderrPreview.omittedBytes
+      }
+    }
+  });
+}
+
+// src/agent-runtime/coding-tool-shell.ts
+function createShellCodingTool(config, limits) {
+  const executables = config.executables ?? {};
+  const executableNames = Object.keys(executables).sort();
+  return defineRuntimeTool2({
+    name: "run_command",
+    description: "Run a finite host-declared executable with bounded arguments, time and output.",
+    identity: { serviceName: "coding", action: "shell", method: "POST" },
+    input: createShellInputSchema(executableNames),
+    output: ShellOutputSchema,
+    transports: ["AGENT"],
+    handler: async ({ input, signal }) => {
+      if (input.args.length > limits.maxShellArguments) {
+        throw new Error("Coding tool shell arguments exceed maxShellArguments");
+      }
+      const argumentBytes = input.args.reduce((total, argument) => total + Buffer.byteLength(argument), 0);
+      if (argumentBytes > limits.maxShellArgumentBytes) {
+        throw new Error("Coding tool shell arguments exceed maxShellArgumentBytes");
+      }
+      const executable = executables[input.executable];
+      if (!executable)
+        throw new Error("Coding tool executable is not declared");
+      return withCommandDirectory(config.root, input.cwd, limits.maxPathBytes, async (cwd) => {
+        const assertSandboxCwd = cwd.assertCurrent;
+        const shellAuthorization = {
+          operation: "shell",
+          executable: input.executable,
+          args: input.args,
+          cwd: cwd.relative
+        };
+        await authorizeCodingTool(config, shellAuthorization);
+        let executablePath = executable;
+        let executableArgs = input.args;
+        let environment = config.environment ?? {};
+        if (config.sandbox) {
+          assertSandboxCwd();
+          const probed = await probeAgentProcessSandboxOutcome(config.sandbox.adapter);
+          const grade = probed.grade;
+          if (grade.grade === "unavailable") {
+            codingRefusal("SANDBOX_UNAVAILABLE", "The configured process sandbox is unavailable", {
+              details: { reason: grade.reason },
+              ...probed.cause !== undefined && { cause: probed.cause }
+            });
+          }
+          const missing = missingSandboxRestrictions2(grade, config.sandbox.required);
+          if (missing.length > 0) {
+            codingRefusal("SANDBOX_INSUFFICIENT", "The process sandbox lacks required restrictions", {
+              details: { missing, grade: grade.grade }
+            });
+          }
+          try {
+            const prepared = await config.sandbox.adapter.prepare({
+              required: config.sandbox.required,
+              executable,
+              args: input.args,
+              cwd: cwd.absolute,
+              environment
+            });
+            executablePath = prepared.executable;
+            executableArgs = [...prepared.args];
+            environment = prepared.environment ?? environment;
+          } catch (error) {
+            const refreshed = await probeAgentProcessSandboxOutcome(config.sandbox.adapter, {
+              refresh: true
+            });
+            codingRefusal("SANDBOX_UNAVAILABLE", "The process sandbox failed while preparing a command", {
+              details: { grade: refreshed.grade.grade, reason: "sandbox prepare failed" },
+              cause: refreshed.cause === undefined ? error : new AggregateError([error, refreshed.cause], "Sandbox prepare failed and probing it again failed")
+            });
+          }
+        }
+        if (config.sandbox || cwd.descriptor === undefined)
+          assertSandboxCwd();
+        const ordinary = !config.sandbox?.adapter.spawn && cwd.descriptor !== undefined;
+        const linkedCwd = ordinary && process.platform === "linux" ? `/proc/${process.pid}/fd/${cwd.descriptor}` : undefined;
+        return await runCodingShell({
+          ...ordinary && linkedCwd === undefined && cwd.descriptor !== undefined && { cwdDescriptor: cwd.descriptor },
+          ...config.sandbox?.adapter.spawn && {
+            spawn: () => {
+              const adapter = config.sandbox?.adapter;
+              if (!adapter?.spawn)
+                throw new Error("Sandbox launcher is unavailable");
+              assertSandboxCwd();
+              return adapter.spawn({
+                executable: executablePath,
+                args: executableArgs,
+                cwd: cwd.absolute,
+                environment
+              });
+            }
+          },
+          executableName: input.executable,
+          executable: executablePath,
+          args: executableArgs,
+          cwd: linkedCwd ?? cwd.absolute,
+          environment,
+          ...signal && { signal },
+          timeoutMs: limits.shellTimeoutMs,
+          terminationGraceMs: limits.shellTerminationGraceMs,
+          maxOutputBytes: limits.maxShellOutputBytes,
+          maxArtifactBytes: limits.maxArtifactBytes,
+          ...config.artifacts && { artifacts: config.artifacts },
+          authorization: shellAuthorization
+        });
+      });
+    }
+  });
+}
+async function withCommandDirectory(configuredRoot, requested, maxPathBytes, work) {
+  const shaped = (root) => requested === "." ? "." : boundedCodingRelativePath(root, requested, maxPathBytes);
+  if (process.platform !== "linux" && process.platform !== "darwin") {
+    const root = await realpath2(configuredRoot);
+    const relative = shaped(root);
+    const absolute = path4.resolve(root, relative);
+    const resolved = await realpath2(absolute).catch((error) => refuseUnopenableCodingDirectory(error, relative));
+    const identity = await stat(resolved);
+    if (!identity.isDirectory() || resolved !== absolute) {
+      refuseUnopenableCodingDirectory(Object.assign(new Error("not a directory"), { code: "ENOTDIR" }), relative);
+    }
+    const found = { relative, absolute };
+    return work({
+      ...found,
+      assertCurrent: () => {
+        const current = statSync(found.absolute);
+        if (identity.dev !== current.dev || identity.ino !== current.ino)
+          codingRefusal("CONFLICT", "Command directory changed during authorization");
+      }
+    });
+  }
+  return withCodingRoot(configuredRoot, async (root, rootPath) => {
+    const relative = shaped(rootPath);
+    const directory = await openContainedDirectory(root, relative).catch((error) => refuseUnopenableCodingDirectory(error, relative));
+    try {
+      const absolute = path4.resolve(rootPath, relative);
+      return await work({
+        relative,
+        absolute,
+        descriptor: directory.fd,
+        assertCurrent: () => {
+          const expected = fstatSync(directory.fd);
+          const current = statSync(absolute);
+          if (expected.dev !== current.dev || expected.ino !== current.ino)
+            codingRefusal("CONFLICT", "Command directory changed during authorization");
+        }
+      });
+    } finally {
+      await directory.close();
+    }
+  });
+}
+
+// src/agent-runtime/coding-tools.ts
+var AGENT_CODING_TOOL_NAMES = {
+  editFile: "edit_file",
+  glob: "glob",
+  listDirectory: "list_directory",
+  readFile: "read_file",
+  readOutput: "read_output",
+  searchOutput: "search_output",
+  runCommand: "run_command",
+  searchFiles: "search_files",
+  writeFile: "write_file"
+};
+function createAgentCodingTools2(config) {
+  if (!path5.isAbsolute(config.root))
+    throw new Error("Coding tool root must be absolute");
+  for (const executable of Object.values(config.executables ?? {})) {
+    if (!path5.isAbsolute(executable)) {
+      throw new Error("Coding tool executables must be absolute paths");
+    }
+  }
+  const limits = resolveCodingToolLimits(config.limits);
+  const artifactTools = [];
+  if (config.artifacts) {
+    const artifacts = config.artifacts;
+    artifactTools.push(defineRuntimeTool2({
+      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: z8.object({
+        reference: z8.string().min(1),
+        offset: z8.int().nonnegative().default(0),
+        maxBytes: z8.int().positive().optional()
+      }).strict(),
+      output: z8.object({
+        reference: z8.string().min(1),
+        offset: z8.int().nonnegative(),
+        text: z8.string(),
+        bytes: z8.int().nonnegative(),
+        totalBytes: z8.int().nonnegative().optional()
+      }).strict(),
+      transports: ["AGENT"],
+      handler: async ({ input }) => {
+        const maxBytes = Math.min(input.maxBytes ?? limits.maxReadBytes, limits.maxReadBytes);
+        await authorizeCodingTool(config, {
+          operation: "artifact-read",
+          reference: input.reference,
+          offset: input.offset,
+          maxBytes
+        });
+        const originAuthorization = await artifacts.authorization?.(input.reference);
+        if (originAuthorization)
+          await authorizeCodingTool(config, originAuthorization);
+        const result = await artifacts.read({
+          reference: input.reference,
+          offset: input.offset,
+          maxBytes
+        });
+        if (result.data.byteLength > maxBytes)
+          throw new Error("Coding artifact store exceeded the requested byte budget");
+        if (result.totalBytes !== undefined && result.totalBytes < input.offset + result.data.byteLength) {
+          throw new Error("Coding artifact store returned inconsistent totalBytes");
+        }
+        return {
+          reference: input.reference,
+          offset: input.offset,
+          text: new TextDecoder("utf-8", { fatal: true }).decode(result.data),
+          bytes: result.data.byteLength,
+          ...result.totalBytes !== undefined && { totalBytes: result.totalBytes }
+        };
+      }
+    }));
+    if (artifacts.search) {
+      const search = artifacts.search;
+      artifactTools.push(defineRuntimeTool2({
+        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: z8.object({
+          reference: z8.string().min(1),
+          query: z8.string().min(1),
+          maxMatches: z8.int().positive().max(limits.maxSearchResults).default(20)
+        }).strict(),
+        output: z8.object({
+          reference: z8.string(),
+          matches: z8.array(z8.object({ line: z8.int().positive(), text: z8.string() }))
+        }).strict(),
+        transports: ["AGENT"],
+        handler: async ({ input }) => {
+          await authorizeCodingTool(config, {
+            operation: "artifact-search",
+            reference: input.reference,
+            query: input.query,
+            maxMatches: input.maxMatches
+          });
+          const originAuthorization = await artifacts.authorization?.(input.reference);
+          if (originAuthorization)
+            await authorizeCodingTool(config, originAuthorization);
+          return {
+            reference: input.reference,
+            matches: [
+              ...await search({
+                reference: input.reference,
+                query: input.query,
+                maxMatches: input.maxMatches
+              })
+            ]
+          };
+        }
+      }));
+    }
+  }
+  const commandTools = Object.keys(config.executables ?? {}).length ? [createShellCodingTool(config, limits)] : [];
+  return [
+    ...createFileCodingTools(config, limits),
+    ...createListingCodingTools(config, limits),
+    ...createSearchAndPatchCodingTools(config, limits),
+    ...commandTools,
+    ...artifactTools
+  ];
+}
+
+export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, ShellOutputSchema, AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, refuseUnknownSpillReference, AGENT_CODING_TOOL_NAMES, createAgentCodingTools2 };