@odla-ai/harness 0.11.11 → 0.11.13

package/dist/code-runtime-cli.cjs

@@ -3,7 +3,7 @@
 
 // src/code-runtime-cli.ts
 var import_node_os4 = require("os");
-var import_promises15 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 
 // src/code-runtime-client-validation.ts
 var import_code = require("@odla-ai/camel/code");
@@ -452,7 +452,7 @@ async function withOverloadRetry(call, wait2, onRetry = () => void 0, retryable
 }
 
 // src/code-runtime-reconciler.ts
-var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 var POST_ACK_RETRY_TICKS = 40;
 var CodeRuntimeReconciler = class {
   constructor(control, engine, onDiagnostic, options = {}) {
@@ -554,12 +554,12 @@ function retryableControlFailure(value) {
   return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
 }
 function wait(ms, signal) {
-  return new Promise((resolve7) => {
-    if (signal?.aborted) return resolve7();
-    const timer = setTimeout(resolve7, ms);
+  return new Promise((resolve8) => {
+    if (signal?.aborted) return resolve8();
+    const timer = setTimeout(resolve8, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve7();
+      resolve8();
     }, { once: true });
   });
 }
@@ -981,12 +981,12 @@ async function restoreCodeWorkspaceCheckpoint(input) {
 // src/code-verifier.ts
 var import_node_crypto3 = require("crypto");
 var import_node_fs2 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_promises7 = require("fs/promises");
+var import_node_path8 = require("path");
 var import_code3 = require("@odla-ai/camel/code");
 
 // src/recipe-container.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_process2 = require("process");
 var import_node_crypto = require("crypto");
 
@@ -1044,7 +1044,7 @@ async function selectContainerEngine(requested = "auto", options = {}) {
   throw new TypeError("no supported container engine found");
 }
 function inspectRootlessPodman() {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     (0, import_node_child_process3.execFile)(
       "podman",
       ["info", "--format", "{{.Host.Security.Rootless}}"],
@@ -1054,7 +1054,7 @@ function inspectRootlessPodman() {
           reject(new TypeError("could not verify that the active Podman service is rootless"));
           return;
         }
-        resolve7(stdout.trim() === "true");
+        resolve8(stdout.trim() === "true");
       }
     );
   });
@@ -1072,12 +1072,89 @@ async function verifyContainerEngineBoundary(engine, options = {}) {
   if (!rootless) throw new TypeError("the active Podman service is not rootless; refusing to run the harness");
 }
 
+// src/code-recipe-dependencies.ts
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
+var RESERVED_MOUNTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+function assertLentPath(mountAs) {
+  const parts = mountAs.split("/");
+  if ((0, import_node_path5.isAbsolute)(mountAs) || mountAs.includes("\\") || parts.some((part) => !part || part === "." || part === "..")) {
+    throw new TypeError(`recipe dependencies must mount inside the workspace, not at "${mountAs}"`);
+  }
+}
+function assertReservedMount(mountAs) {
+  assertLentPath(mountAs);
+  if (!RESERVED_MOUNTS.has(mountAs.split("/").at(-1))) {
+    throw new TypeError(`recipe dependencies must mount at a reserved name, not "${mountAs}"`);
+  }
+}
+function lentDirectories(dependencies) {
+  return [{ source: dependencies.source, mountAs: dependencies.mountAs ?? "node_modules" }, ...dependencies.nested ?? []];
+}
+
+// src/recipe-container-lending.ts
+var import_node_child_process4 = require("child_process");
+var import_promises5 = require("fs/promises");
+var import_node_path6 = require("path");
+var RUN_ID = /^[A-Za-z0-9_.-]{1,64}$/;
+function copy(args) {
+  return new Promise((accept, reject) => {
+    const child = (0, import_node_child_process4.spawn)("cp", args, { shell: false, stdio: "ignore" });
+    child.once("error", reject);
+    child.once("exit", (code) => accept(code ?? 1));
+  });
+}
+async function cloneTree(source, target, platform = process.platform) {
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(target), { recursive: true });
+  const fast = platform === "darwin" ? ["-Rc", source, target] : platform === "linux" ? ["-R", "--reflink=auto", source, target] : null;
+  if (fast && await copy(fast) === 0) return;
+  await (0, import_promises5.rm)(target, { recursive: true, force: true });
+  if (await copy(["-R", source, target]) !== 0) throw new Error(`could not clone ${source}`);
+}
+async function lendDependencies(dependencies, runId) {
+  if (!dependencies?.runsDir) return { dependencies, release: async () => void 0 };
+  if (!RUN_ID.test(runId)) throw new TypeError("run id is not a safe directory name");
+  const treeRoot = (0, import_node_path6.dirname)(dependencies.source);
+  for (const entry of lentDirectories(dependencies)) {
+    if (entry.source !== (0, import_node_path6.join)(treeRoot, entry.mountAs)) {
+      throw new TypeError("every directory of a cloned set must lie under its tree root at its mount path");
+    }
+  }
+  const runDir = (0, import_node_path6.join)(dependencies.runsDir, runId);
+  await cloneTree(treeRoot, runDir);
+  const rebase = (entry) => ({ source: (0, import_node_path6.join)(runDir, entry.mountAs), mountAs: entry.mountAs });
+  return {
+    dependencies: {
+      ...dependencies,
+      source: (0, import_node_path6.join)(runDir, dependencies.mountAs ?? "node_modules"),
+      nested: (dependencies.nested ?? []).map(rebase),
+      writable: true
+    },
+    release: () => (0, import_promises5.rm)(runDir, { recursive: true, force: true })
+  };
+}
+async function lendBuildProducts(products, workspaceDir) {
+  const root = (0, import_node_path6.resolve)(workspaceDir);
+  const lent = [];
+  for (const product of products) {
+    assertLentPath(product.mountAs);
+    if (SECRET_WORKSPACE_FILE.test(product.mountAs.split("/").at(-1))) throw new TypeError("a secret is never a build product");
+    const target = (0, import_node_path6.resolve)(root, product.mountAs);
+    if (!target.startsWith(`${root}${import_node_path6.sep}`)) throw new TypeError("build product escapes the workspace");
+    if (await (0, import_promises5.stat)(target).catch(() => null)) continue;
+    if (!await (0, import_promises5.stat)((0, import_node_path6.join)(root, product.within ?? (0, import_node_path6.dirname)(product.mountAs))).catch(() => null)) continue;
+    await cloneTree(product.source, target);
+    lent.push(product.mountAs);
+  }
+  return lent;
+}
+
 // src/recipe-container.ts
 var ARTIFACT_PATH = /^[A-Za-z0-9_@+.,-]+(?:\/[A-Za-z0-9_@+.,-]+)*$/;
 var PRIVATE_ARTIFACT_PART = /^(?:\.git|\.odla|\.wrangler|\.env(?:\..+)?|\.dev\.vars|credentials(?:\..+)?\.json)$/i;
 function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-recipe-${(0, import_node_crypto.randomUUID)().slice(0, 12)}`, dependencies = null) {
   assertCodeBuildRecipe(recipe2);
-  const mounts = dependencies ? [dependencyMount(engine, dependencies)] : [];
+  const mounts = dependencies ? dependencyMounts(engine, dependencies) : [];
   if (/[,\r\n]/.test(workspaceDir)) throw new TypeError("workspace path contains unsupported mount characters");
   const uid = typeof import_node_process2.getuid === "function" ? (0, import_node_process2.getuid)() : 1e3;
   const gid = typeof import_node_process2.getgid === "function" ? (0, import_node_process2.getgid)() : 1e3;
@@ -1103,6 +1180,7 @@ function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-re
       ...mounts,
       "--workdir=/workspace",
       "--env=CI=1",
+      "--env=HOME=/tmp",
       recipe2.image,
       ...recipe2.command
     ];
@@ -1125,26 +1203,34 @@ function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-re
     ...mounts,
     "--workdir=/workspace",
     "--env=CI=1",
+    "--env=HOME=/tmp",
     recipe2.image,
     ...recipe2.command
   ];
 }
-var LENDABLE = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
-function dependencyMount(engine, dependencies) {
-  const mountAs = dependencies.mountAs ?? "node_modules";
-  if (!dependencies.source.startsWith("/") || /[,\r\n]/.test(dependencies.source)) {
-    throw new TypeError("recipe dependency source must be an absolute path without mount separators");
-  }
-  if (!LENDABLE.has(mountAs)) throw new TypeError(`recipe dependencies must mount at a reserved name, not "${mountAs}"`);
-  return engine === "container" ? `--mount=type=bind,source=${dependencies.source},target=/workspace/${mountAs},readonly` : `--mount=type=bind,src=${dependencies.source},dst=/workspace/${mountAs},readonly`;
+function dependencyMounts(engine, dependencies) {
+  const readonly = dependencies.writable ? "" : ",readonly";
+  return lentDirectories(dependencies).map(({ source, mountAs }) => {
+    if (!source.startsWith("/") || /[,\r\n]/.test(source)) {
+      throw new TypeError("recipe dependency source must be an absolute path without mount separators");
+    }
+    assertReservedMount(mountAs);
+    return engine === "container" ? `--mount=type=bind,source=${source},target=/workspace/${mountAs}${readonly}` : `--mount=type=bind,src=${source},dst=/workspace/${mountAs}${readonly}`;
+  });
 }
 function createContainerRecipeExecutor(engine, options = {}) {
   return {
     async run(input) {
       await verifyContainerEngineBoundary(engine);
       const name = `odla-recipe-${(0, import_node_crypto.randomUUID)().slice(0, 12)}`;
-      const args = buildRecipeContainerArgs(engine, input.workspaceDir, input.recipe, name, options.dependencies ?? null);
-      return execute(engine, args, name, input.recipe, input.signal);
+      const lent = await lendDependencies(options.dependencies ?? null, name);
+      try {
+        if (lent.dependencies?.products?.length) await lendBuildProducts(lent.dependencies.products, input.workspaceDir);
+        const args = buildRecipeContainerArgs(engine, input.workspaceDir, input.recipe, name, lent.dependencies);
+        return await execute(engine, args, name, input.recipe, input.signal);
+      } finally {
+        await lent.release();
+      }
     }
   };
 }
@@ -1166,10 +1252,14 @@ function parseMemory(value) {
 function execute(engine, args, name, recipe2, signal) {
   return runContainerCommand(engine, args, name, { timeoutMs: recipe2.timeoutMs, maxOutputBytes: recipe2.maxOutputBytes }, signal);
 }
+var CONTAINER_PROGRESS = /^\[\d+\/\d+\] .*$/gm;
+function recipeOutput(engine, stderr) {
+  return engine === "container" ? stderr.replace(CONTAINER_PROGRESS, "").replace(/^\n+/, "") : stderr;
+}
 function runContainerCommand(engine, args, name, recipe2, signal) {
   return new Promise((accept, reject) => {
     const started = Date.now();
-    const child = (0, import_node_child_process4.spawn)(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const child = (0, import_node_child_process5.spawn)(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
     const stdout = [];
     const stderr = [];
     let bytes = 0;
@@ -1182,7 +1272,7 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
       timedOut = reason === "timeout";
       outputLimitExceeded = reason === "output";
       const remove = engine === "container" ? ["delete", "--force", name] : ["rm", "-f", name];
-      const killer = (0, import_node_child_process4.spawn)(engine, remove, { shell: false, stdio: "ignore" });
+      const killer = (0, import_node_child_process5.spawn)(engine, remove, { shell: false, stdio: "ignore" });
       killer.unref();
       child.kill("SIGTERM");
     };
@@ -1208,7 +1298,7 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
       accept({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdout).toString("utf8"),
-        stderr: Buffer.concat(stderr).toString("utf8"),
+        stderr: recipeOutput(engine, Buffer.concat(stderr).toString("utf8")),
         durationMs: Date.now() - started,
         outputLimitExceeded,
         timedOut
@@ -1219,27 +1309,27 @@ function runContainerCommand(engine, args, name, recipe2, signal) {
 
 // src/workspace-digest.ts
 var import_node_crypto2 = require("crypto");
-var import_promises4 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_promises6 = require("fs/promises");
+var import_node_path7 = require("path");
 async function digestStagedWorkspace(root, limits) {
   const files = [];
   const walk = async (directory) => {
-    const entries = await (0, import_promises4.readdir)(directory, { withFileTypes: true });
+    const entries = await (0, import_promises6.readdir)(directory, { withFileTypes: true });
     for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
       if (entry.isSymbolicLink()) throw new TypeError("workspace digest refuses symbolic links");
-      const target = (0, import_node_path5.resolve)(directory, entry.name);
+      const target = (0, import_node_path7.resolve)(directory, entry.name);
       if (entry.isDirectory()) await walk(target);
       else if (entry.isFile()) {
-        files.push({ path: (0, import_node_path5.relative)(root, target).split("\\").join("/"), target });
+        files.push({ path: (0, import_node_path7.relative)(root, target).split("\\").join("/"), target });
         if (files.length > limits.maxFiles) throw new TypeError("workspace digest exceeds its file bound");
       }
     }
   };
-  await walk((0, import_node_path5.resolve)(root));
+  await walk((0, import_node_path7.resolve)(root));
   const hash = (0, import_node_crypto2.createHash)("sha256");
   let bytes = 0;
   for (const file of files.sort((left, right) => left.path.localeCompare(right.path))) {
-    const content = await (0, import_promises4.readFile)(file.target);
+    const content = await (0, import_promises6.readFile)(file.target);
     bytes += Buffer.byteLength(file.path) + content.byteLength;
     if (bytes > limits.maxBytes) throw new TypeError("workspace digest exceeds its byte bound");
     hash.update(`${Buffer.byteLength(file.path)}:${file.path}:${content.byteLength}:`);
@@ -1357,8 +1447,8 @@ async function inspectArtifacts(workspaceDir, recipe2) {
   const receipts = [];
   for (const artifact of recipe2.expectedArtifacts ?? []) {
     try {
-      const path = (0, import_node_path6.join)(workspaceDir, artifact.path);
-      const info = await (0, import_promises5.lstat)(path);
+      const path = (0, import_node_path8.join)(workspaceDir, artifact.path);
+      const info = await (0, import_promises7.lstat)(path);
       if (!info.isFile() || info.isSymbolicLink()) {
         receipts.push({ artifactId: artifact.id, status: "invalid", bytes: null, digest: null });
       } else if (info.size > artifact.maximumBytes) {
@@ -1689,15 +1779,15 @@ async function prepareRuntimeLocalSource(input) {
 }
 
 // src/code-runtime-source.ts
-var import_promises8 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_os3 = require("os");
-var import_node_path9 = require("path");
+var import_node_path11 = require("path");
 
 // src/code-runtime-archive.ts
 var import_node_zlib = require("zlib");
-var import_promises6 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_node_os2 = require("os");
-var import_node_path7 = require("path");
+var import_node_path9 = require("path");
 var RESERVED2 = /* @__PURE__ */ new Set([".git", ".odla", ".wrangler", "node_modules", "dist", "coverage"]);
 var SECRET2 = /^(?:\.env(?:\..+)?|\.dev\.vars|credentials(?:\..+)?\.json|dev-token(?:\..+)?\.json)$/i;
 var MAX_NUL_SHARE = 0.1;
@@ -1715,9 +1805,9 @@ async function materializeCodeRuntimeArchive(archive, visiblePaths, tempRoot = (
     throw new TypeError("Code source archive exceeds its decompressed byte bound");
   }
   const entries = parseTar(bytes, archive.limits);
-  const root = await (0, import_promises6.mkdtemp)((0, import_node_path7.join)(tempRoot, "odla-code-archive-"));
-  const sourceDir = (0, import_node_path7.join)(root, "source");
-  await (0, import_promises6.mkdir)(sourceDir);
+  const root = await (0, import_promises8.mkdtemp)((0, import_node_path9.join)(tempRoot, "odla-code-archive-"));
+  const sourceDir = (0, import_node_path9.join)(root, "source");
+  await (0, import_promises8.mkdir)(sourceDir);
   let visible = 0;
   try {
     for (const entry of entries) {
@@ -1730,16 +1820,16 @@ async function materializeCodeRuntimeArchive(archive, visiblePaths, tempRoot = (
         continue;
       }
       if (nulShare(content) > MAX_NUL_SHARE) continue;
-      const target = (0, import_node_path7.resolve)(sourceDir, entry.path);
-      if (!target.startsWith(`${(0, import_node_path7.resolve)(sourceDir)}${import_node_path7.sep}`)) throw new TypeError("Code source path escapes its root");
-      await (0, import_promises6.mkdir)((0, import_node_path7.dirname)(target), { recursive: true });
-      await (0, import_promises6.writeFile)(target, content, { flag: "wx", mode: 420 });
+      const target = (0, import_node_path9.resolve)(sourceDir, entry.path);
+      if (!target.startsWith(`${(0, import_node_path9.resolve)(sourceDir)}${import_node_path9.sep}`)) throw new TypeError("Code source path escapes its root");
+      await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(target), { recursive: true });
+      await (0, import_promises8.writeFile)(target, content, { flag: "wx", mode: 420 });
       visible += 1;
     }
     if (!visible && !visiblePaths) throw new TypeError("GitHub commit has no Code-visible text source");
-    return { sourceDir, cleanup: () => (0, import_promises6.rm)(root, { recursive: true, force: true }) };
+    return { sourceDir, cleanup: () => (0, import_promises8.rm)(root, { recursive: true, force: true }) };
   } catch (cause) {
-    await (0, import_promises6.rm)(root, { recursive: true, force: true });
+    await (0, import_promises8.rm)(root, { recursive: true, force: true });
     throw cause;
   }
 }
@@ -1934,8 +2024,8 @@ function nulShare(content) {
 }
 
 // src/code-runtime-selected-source.ts
-var import_promises7 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_promises9 = require("fs/promises");
+var import_node_path10 = require("path");
 function selectedSourceSet(payload) {
   if (!payload.sourceSet) return null;
   const set = payload.sourceSet && typeof payload.sourceSet === "object" && !Array.isArray(payload.sourceSet) ? payload.sourceSet : null;
@@ -1972,9 +2062,9 @@ async function attachReferenceDirectories(workspace, references) {
   for (const reference of references) {
     validateAlias(reference.alias);
     for (const root of [workspace.baselineDir, workspace.workspaceDir]) {
-      const target = (0, import_node_path8.join)(root, ".odla-references", reference.alias);
-      await (0, import_promises7.mkdir)((0, import_node_path8.dirname)(target), { recursive: true });
-      await (0, import_promises7.cp)(reference.sourceDir, target, { recursive: true, errorOnExist: true, force: false });
+      const target = (0, import_node_path10.join)(root, ".odla-references", reference.alias);
+      await (0, import_promises9.mkdir)((0, import_node_path10.dirname)(target), { recursive: true });
+      await (0, import_promises9.cp)(reference.sourceDir, target, { recursive: true, errorOnExist: true, force: false });
       await makeTreeReadOnly(target);
     }
   }
@@ -1985,10 +2075,10 @@ function validateAlias(alias) {
   }
 }
 async function makeTreeReadOnly(root) {
-  for (const entry of await (0, import_promises7.readdir)(root, { withFileTypes: true })) {
-    const target = (0, import_node_path8.join)(root, entry.name);
+  for (const entry of await (0, import_promises9.readdir)(root, { withFileTypes: true })) {
+    const target = (0, import_node_path10.join)(root, entry.name);
     if (entry.isDirectory()) await makeTreeReadOnly(target);
-    else if (entry.isFile()) await (0, import_promises7.chmod)(target, 292);
+    else if (entry.isFile()) await (0, import_promises9.chmod)(target, 292);
   }
 }
 
@@ -2000,9 +2090,9 @@ var SOURCE_MAX_BYTES = 80 * 1024 * 1024;
 var SOURCE_SET_MAX_BYTES = 480 * 1024 * 1024;
 async function materializeCodeRuntimeSource(snapshot, tempRoot = (0, import_node_os3.tmpdir)()) {
   if (!snapshot.files.length || snapshot.files.length > SOURCE_MAX_FILES) throw new TypeError("Code source file count is invalid");
-  const root = await (0, import_promises8.mkdtemp)((0, import_node_path9.join)(tempRoot, "odla-code-source-"));
-  const sourceDir = (0, import_node_path9.join)(root, "source");
-  await (0, import_promises8.mkdir)(sourceDir);
+  const root = await (0, import_promises10.mkdtemp)((0, import_node_path11.join)(tempRoot, "odla-code-source-"));
+  const sourceDir = (0, import_node_path11.join)(root, "source");
+  await (0, import_promises10.mkdir)(sourceDir);
   const seen = /* @__PURE__ */ new Set();
   let bytes = 0;
   try {
@@ -2012,10 +2102,10 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = (0, import_node
       seen.add(file.path);
       bytes += Buffer.byteLength(file.path) + Buffer.byteLength(file.content);
       if (bytes > SOURCE_MAX_BYTES) throw new TypeError("Code source exceeds its byte bound");
-      const target = (0, import_node_path9.resolve)(sourceDir, file.path);
-      if (!target.startsWith(`${(0, import_node_path9.resolve)(sourceDir)}${import_node_path9.sep}`)) throw new TypeError("Code source path escapes its root");
-      await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(target), { recursive: true });
-      await (0, import_promises8.writeFile)(target, file.content, { flag: "wx", mode: 420 });
+      const target = (0, import_node_path11.resolve)(sourceDir, file.path);
+      if (!target.startsWith(`${(0, import_node_path11.resolve)(sourceDir)}${import_node_path11.sep}`)) throw new TypeError("Code source path escapes its root");
+      await (0, import_promises10.mkdir)((0, import_node_path11.dirname)(target), { recursive: true });
+      await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 420 });
     }
     for (const reference of snapshot.references ?? []) {
       validateAlias2(reference.alias);
@@ -2027,15 +2117,15 @@ async function materializeCodeRuntimeSource(snapshot, tempRoot = (0, import_node
         seen.add(path);
         bytes += Buffer.byteLength(path) + Buffer.byteLength(file.content);
         if (bytes > SOURCE_SET_MAX_BYTES) throw new TypeError("Code source set exceeds its byte bound");
-        const target = (0, import_node_path9.resolve)(sourceDir, path);
-        if (!target.startsWith(`${(0, import_node_path9.resolve)(sourceDir)}${import_node_path9.sep}`)) throw new TypeError("Code reference path escapes its root");
-        await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(target), { recursive: true });
-        await (0, import_promises8.writeFile)(target, file.content, { flag: "wx", mode: 292 });
+        const target = (0, import_node_path11.resolve)(sourceDir, path);
+        if (!target.startsWith(`${(0, import_node_path11.resolve)(sourceDir)}${import_node_path11.sep}`)) throw new TypeError("Code reference path escapes its root");
+        await (0, import_promises10.mkdir)((0, import_node_path11.dirname)(target), { recursive: true });
+        await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 292 });
       }
     }
-    return { sourceDir, cleanup: () => (0, import_promises8.rm)(root, { recursive: true, force: true }) };
+    return { sourceDir, cleanup: () => (0, import_promises10.rm)(root, { recursive: true, force: true }) };
   } catch (cause) {
-    await (0, import_promises8.rm)(root, { recursive: true, force: true });
+    await (0, import_promises10.rm)(root, { recursive: true, force: true });
     throw cause;
   }
 }
@@ -2054,10 +2144,10 @@ async function attachCodeRuntimeReferences(workspace, references) {
       bytes += Buffer.byteLength(path) + Buffer.byteLength(file.content);
       if (bytes > SOURCE_SET_MAX_BYTES - SOURCE_MAX_BYTES) throw new TypeError("Code reference set exceeds its byte bound");
       for (const root of [workspace.baselineDir, workspace.workspaceDir]) {
-        const target = (0, import_node_path9.resolve)(root, path);
-        if (!target.startsWith(`${(0, import_node_path9.resolve)(root)}${import_node_path9.sep}`)) throw new TypeError("Code reference path escapes its root");
-        await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(target), { recursive: true });
-        await (0, import_promises8.writeFile)(target, file.content, { flag: "wx", mode: 292 });
+        const target = (0, import_node_path11.resolve)(root, path);
+        if (!target.startsWith(`${(0, import_node_path11.resolve)(root)}${import_node_path11.sep}`)) throw new TypeError("Code reference path escapes its root");
+        await (0, import_promises10.mkdir)((0, import_node_path11.dirname)(target), { recursive: true });
+        await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 292 });
       }
     }
   }
@@ -2503,7 +2593,7 @@ Finish with a concise, non-empty answer to the owner. Do not call tools or promi
 }
 
 // src/code-runtime-session-skills.ts
-var sleep2 = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
+var sleep2 = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 function createCodeRuntimeSessionSkillLoader(control, options = {}) {
   const wait2 = options.wait ?? sleep2;
   const load = control.collaborationSkills?.bind(control);
@@ -2562,7 +2652,7 @@ var inferWithBackoff = (infer, wait2, onRetry) => withOverloadRetry(infer, wait2
 async function handleCodeRuntimeInference(input) {
   const { command, request, state } = input;
   const startedAt = Date.now();
-  const wait2 = input.wait ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms)));
+  const wait2 = input.wait ?? ((ms) => new Promise((resolve8) => setTimeout(resolve8, ms)));
   const response2 = await inferWithBackoff(
     () => input.control.infer(command.sessionId, {
       requestId: request.requestId,
@@ -2760,7 +2850,10 @@ function toolFailureReason(response2) {
   if (response2.ok) return void 0;
   const supplied = response2.details?.failureReason;
   const reason = typeof supplied === "string" && supplied || DEFAULT_FAILURE_REASON[response2.content] || response2.content || "tool request failed; inspect the tool input and workspace state";
-  return reason.slice(0, MAX_FAILURE_REASON);
+  if (reason.length <= MAX_FAILURE_REASON) return reason;
+  const head = reason.slice(0, 60);
+  const gap = " \u2026 ";
+  return `${head}${gap}${reason.slice(-(MAX_FAILURE_REASON - head.length - gap.length))}`;
 }
 var DEFAULT_FAILURE_REASON = {
   "tool denied by CaMeL policy": "tool denied by CaMeL policy",
@@ -3073,18 +3166,18 @@ function response(request, ok, content, details) {
 }
 
 // src/code-tool-edit.ts
-var import_promises10 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 
 // src/code-tool-graph.ts
-var import_promises9 = require("fs/promises");
-var import_node_path10 = require("path");
+var import_promises11 = require("fs/promises");
+var import_node_path12 = require("path");
 var import_graph = require("@odla-ai/graph");
 var import_code4 = require("@odla-ai/graph/code");
 var cache = /* @__PURE__ */ new Map();
 function workspaceGraphs(workspaceDir, paths2) {
   const existing = cache.get(workspaceDir);
   if (existing) return existing;
-  const read2 = (path) => (0, import_promises9.readFile)((0, import_node_path10.join)(workspaceDir, path), "utf8");
+  const read2 = (path) => (0, import_promises11.readFile)((0, import_node_path12.join)(workspaceDir, path), "utf8");
   const built = (async () => ({
     // No knownTables: a staged workspace may not carry migrations, and a filter
     // that silently drops every table is worse than an unfiltered one. Callers
@@ -3160,7 +3253,7 @@ async function editCodeFile(workspaceDir, path, oldText, newText) {
   }
   if (oldText.includes("\0") || newText.includes("\0")) throw new TypeError("edit text contains NUL bytes; use plain text");
   const target = resolveCodePath(workspaceDir, path);
-  const current = await (0, import_promises10.readFile)(target, "utf8");
+  const current = await (0, import_promises12.readFile)(target, "utf8");
   const found = occurrences(current, oldText);
   if (found === 0) {
     throw new TypeError(`oldText was not found in "${path}"; sandbox.read the current lines and copy them exactly, including indentation and blank lines`);
@@ -3169,7 +3262,7 @@ async function editCodeFile(workspaceDir, path, oldText, newText) {
     throw new TypeError(`oldText occurs ${found} times in "${path}"; include more of the surrounding lines so it matches exactly once`);
   }
   const at = current.indexOf(oldText);
-  await (0, import_promises10.writeFile)(target, `${current.slice(0, at)}${newText}${current.slice(at + oldText.length)}`, "utf8");
+  await (0, import_promises12.writeFile)(target, `${current.slice(0, at)}${newText}${current.slice(at + oldText.length)}`, "utf8");
   return { deletions: oldText.split("\n").length, additions: newText.split("\n").length };
 }
 async function edit(context, request, options, policy, registry) {
@@ -3194,8 +3287,8 @@ async function edit(context, request, options, policy, registry) {
 }
 
 // src/code-tool-write.ts
-var import_promises11 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_promises13 = require("fs/promises");
+var import_node_path13 = require("path");
 var MAX_WRITE_BYTES = 256 * 1024;
 var lines = (text2) => text2 === "" ? [] : text2.replace(/\n$/, "").split("\n");
 function writeAsDiff(path, current, content) {
@@ -3220,8 +3313,8 @@ async function writeCodeFile(workspaceDir, path, content, current) {
   }
   if (content.includes("\0")) throw new TypeError("content contains NUL bytes; use plain text");
   const target = resolveCodePath(workspaceDir, path);
-  await (0, import_promises11.mkdir)((0, import_node_path11.dirname)(target), { recursive: true });
-  await (0, import_promises11.writeFile)(target, content, "utf8");
+  await (0, import_promises13.mkdir)((0, import_node_path13.dirname)(target), { recursive: true });
+  await (0, import_promises13.writeFile)(target, content, "utf8");
   return { created: current === null, deletions: current === null ? 0 : lines(current).length, additions: lines(content).length };
 }
 async function write(context, request, options, policy, registry) {
@@ -3232,7 +3325,7 @@ async function write(context, request, options, policy, registry) {
     throw new TypeError("write targets a read-only reference source");
   }
   const exists = (await registry.files(context.workspaceDir)).includes(path);
-  const current = exists ? await (0, import_promises11.readFile)(resolveCodePath(context.workspaceDir, path), "utf8") : null;
+  const current = exists ? await (0, import_promises13.readFile)(resolveCodePath(context.workspaceDir, path), "utf8") : null;
   const patch2 = writeAsDiff(path, current, content);
   const allowed = await policy.write(policyContext(context, request, options, { patch: patch2 }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
@@ -3248,12 +3341,12 @@ async function write(context, request, options, policy, registry) {
 }
 
 // src/code-tool-reads.ts
-var import_promises13 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 
 // src/code-tool-discovery.ts
-var import_node_child_process5 = require("child_process");
-var import_promises12 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_node_child_process6 = require("child_process");
+var import_promises14 = require("fs/promises");
+var import_node_path14 = require("path");
 var DEFAULT_MAX_FILES = 2e4;
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_FILE_BYTES = 512 * 1024;
@@ -3278,13 +3371,13 @@ function createWorkspaceFileRegistry(limit = DEFAULT_MAX_FILES, enumerate = regi
 async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
   const paths2 = [];
   const walk = async (directory) => {
-    for (const entry of await (0, import_promises12.readdir)(directory, { withFileTypes: true })) {
+    for (const entry of await (0, import_promises14.readdir)(directory, { withFileTypes: true })) {
       if (SKIP_WORKSPACE_DIRS.has(entry.name)) continue;
       if (entry.isSymbolicLink()) throw new TypeError("workspace contains a symbolic link");
-      const target = (0, import_node_path12.resolve)(directory, entry.name);
+      const target = (0, import_node_path14.resolve)(directory, entry.name);
       if (entry.isDirectory()) await walk(target);
       else if (entry.isFile()) {
-        const path = (0, import_node_path12.relative)(root, target).split("\\").join("/");
+        const path = (0, import_node_path14.relative)(root, target).split("\\").join("/");
         try {
           validateRelativePath(path);
         } catch {
@@ -3295,7 +3388,7 @@ async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
       }
     }
   };
-  await walk((0, import_node_path12.resolve)(root));
+  await walk((0, import_node_path14.resolve)(root));
   return paths2.sort();
 }
 function listWorkspace(paths2, options = {}) {
@@ -3357,7 +3450,7 @@ function nativeSearchBatch(root, paths2, options, remaining) {
       options.query,
       ...paths2
     ];
-    const child = (0, import_node_child_process5.spawn)("rg", args, {
+    const child = (0, import_node_child_process6.spawn)("rg", args, {
       cwd: root,
       stdio: ["ignore", "pipe", "ignore"],
       ...options.signal ? { signal: options.signal } : {}
@@ -3409,7 +3502,7 @@ async function fallbackSearch(root, scoped, options) {
     if (matches.length >= options.maxResults) break;
     let source;
     try {
-      source = await (0, import_promises12.readFile)((0, import_node_path12.resolve)(root, path));
+      source = await (0, import_promises14.readFile)((0, import_node_path14.resolve)(root, path));
     } catch {
       continue;
     }
@@ -3448,11 +3541,11 @@ async function read(context, request, options, policy, registry) {
   const allowed = await policy.read(policyContext(context, request, options, { paths: paths2, path, startLine, endLine }));
   if (!allowed) return response(request, false, "tool denied by CaMeL policy");
   const target = resolveCodePath(context.workspaceDir, path);
-  const info = await (0, import_promises13.stat)(target);
+  const info = await (0, import_promises15.stat)(target);
   if (!info.isFile() || info.size > Math.max(options.maxReadBytes ?? 128 * 1024, 2 * 1024 * 1024)) {
     throw new TypeError("file is not a bounded regular source file");
   }
-  const source = await (0, import_promises13.readFile)(target);
+  const source = await (0, import_promises15.readFile)(target);
   if (source.includes(0)) throw new TypeError("binary files are not readable through this tool");
   const lines2 = source.toString("utf8").split("\n");
   const content = lines2.slice(startLine - 1, endLine).join("\n");
@@ -3977,8 +4070,8 @@ var runtimeErrorMessage = (value) => value instanceof Error ? value.message : St
 function codeRuntimeAcknowledgementGate(signal) {
   let settle;
   let settled = false;
-  const ready = new Promise((resolve7) => {
-    settle = resolve7;
+  const ready = new Promise((resolve8) => {
+    settle = resolve8;
   });
   const release = (run) => {
     if (settled) return;
@@ -4044,8 +4137,8 @@ function observeCodeRuntimeSessionSkills(command, skills, emit) {
 }
 
 // src/code-repository-recipes.ts
-var import_promises14 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_promises16 = require("fs/promises");
+var import_node_path15 = require("path");
 var REPOSITORY_RECIPES_FILE = "odla.recipes.json";
 var MAX_RECIPES = 16;
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -4106,7 +4199,7 @@ function parseRepositoryRecipes(text2, envelope) {
 async function readRepositoryRecipes(baselineDir, envelope) {
   let text2;
   try {
-    text2 = await (0, import_promises14.readFile)((0, import_node_path13.join)(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
+    text2 = await (0, import_promises16.readFile)((0, import_node_path15.join)(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
   } catch (cause) {
     if (cause.code === "ENOENT") return null;
     throw cause;
@@ -4486,7 +4579,7 @@ function parse(argv) {
   };
 }
 async function readPolicy(path) {
-  const value = JSON.parse(await (0, import_promises15.readFile)(path, "utf8"));
+  const value = JSON.parse(await (0, import_promises17.readFile)(path, "utf8"));
   if (!value || Object.keys(value).some((key) => !["recipes", "recipeAuthorization"].includes(key)) || !Array.isArray(value.recipes) || !value.recipes.length || value.recipeAuthorization !== void 0 && value.recipeAuthorization !== "registered_recipe" && value.recipeAuthorization !== "exact_approval") throw new TypeError("invalid Code build policy file");
   const recipes = value.recipes;
   for (const recipe2 of recipes) assertCodeBuildRecipe(recipe2);