@odla-ai/harness 0.11.11 → 0.11.12

package/dist/node.cjs

@@ -40,11 +40,14 @@ __export(node_exports, {
   applyPatchDialectToDiff: () => applyPatchDialectToDiff,
   assertCodeBuildRecipe: () => assertCodeBuildRecipe,
   assertDisjointPlan: () => assertDisjointPlan,
+  assertLentPath: () => assertLentPath,
   assertPinnedImage: () => assertPinnedImage,
+  assertReservedMount: () => assertReservedMount,
   attachCodeRuntimeReferences: () => attachCodeRuntimeReferences,
   buildContainerRunArgs: () => buildContainerRunArgs,
   buildRecipeContainerArgs: () => buildRecipeContainerArgs,
   chooseStrategy: () => chooseStrategy,
+  cloneTree: () => cloneTree,
   codeSkill: () => codeSkill,
   createCodeRuntimeControlClient: () => createCodeRuntimeControlClient,
   createCodeRuntimeInference: () => createCodeRuntimeInference,
@@ -61,17 +64,23 @@ __export(node_exports, {
   feedbackIsActionable: () => feedbackIsActionable,
   hasContextFreeHunk: () => hasContextFreeHunk,
   hazardFromAttempt: () => hazardFromAttempt,
+  hostBuildProducts: () => hostBuildProducts,
   installedDependencies: () => installedDependencies,
   integrateSubGoals: () => integrateSubGoals,
   isCheckpointEffectCompleted: () => isCheckpointEffectCompleted,
+  lendBuildProducts: () => lendBuildProducts,
+  lendDependencies: () => lendDependencies,
+  lentDirectories: () => lentDirectories,
   materializeCodeRuntimeArchive: () => materializeCodeRuntimeArchive,
   materializeCodeRuntimeSource: () => materializeCodeRuntimeSource,
   materializeCommandWorkspace: () => materializeCommandWorkspace,
   materializeGitTree: () => materializeGitTree,
+  npmFailureSummary: () => npmFailureSummary,
   outcomeCloses: () => outcomeCloses,
   outcomeMemory: () => outcomeMemory,
   parseRepositoryRecipes: () => parseRepositoryRecipes,
   patchPaths: () => patchPaths,
+  pinnedNpmVersion: () => pinnedNpmVersion,
   planReachCollisions: () => planReachCollisions,
   prepareContainerDependencies: () => prepareContainerDependencies,
   prepareRuntimeCheckpoint: () => prepareRuntimeCheckpoint,
@@ -110,7 +119,8 @@ __export(node_exports, {
   verifyCodeCandidate: () => verifyCodeCandidate,
   verifyContainerEngineBoundary: () => verifyContainerEngineBoundary,
   withProofRecipes: () => withProofRecipes,
-  withRecipeDependencies: () => withRecipeDependencies
+  withRecipeDependencies: () => withRecipeDependencies,
+  workspaceDirs: () => workspaceDirs
 });
 module.exports = __toCommonJS(node_exports);
 
@@ -250,7 +260,7 @@ async function selectContainerEngine(requested = "auto", options = {}) {
   throw new TypeError("no supported container engine found");
 }
 function inspectRootlessPodman() {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     (0, import_node_child_process.execFile)(
       "podman",
       ["info", "--format", "{{.Host.Security.Rootless}}"],
@@ -260,7 +270,7 @@ function inspectRootlessPodman() {
           reject(new TypeError("could not verify that the active Podman service is rootless"));
           return;
         }
-        resolve8(stdout.trim() === "true");
+        resolve9(stdout.trim() === "true");
       }
     );
   });
@@ -1361,7 +1371,7 @@ async function withOverloadRetry(call, wait2, onRetry = () => void 0, retryable
 }
 
 // src/code-runtime-reconciler.ts
-var sleep = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+var sleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 var POST_ACK_RETRY_TICKS = 40;
 var CodeRuntimeReconciler = class {
   constructor(control, engine, onDiagnostic, options = {}) {
@@ -1463,12 +1473,12 @@ function retryableControlFailure(value) {
   return failure.status === 408 || failure.status === 425 || failure.status === 429 || failure.status >= 500;
 }
 function wait(ms, signal) {
-  return new Promise((resolve8) => {
-    if (signal?.aborted) return resolve8();
-    const timer = setTimeout(resolve8, ms);
+  return new Promise((resolve9) => {
+    if (signal?.aborted) return resolve9();
+    const timer = setTimeout(resolve9, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve8();
+      resolve9();
     }, { once: true });
   });
 }
@@ -1700,19 +1710,127 @@ function isCheckpointEffectCompleted(checkpoint, effectId, actionDigest) {
 // src/code-verifier.ts
 var import_node_crypto3 = require("crypto");
 var import_node_fs2 = require("fs");
-var import_promises7 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_promises9 = require("fs/promises");
+var import_node_path9 = require("path");
 var import_code3 = require("@odla-ai/camel/code");
 
 // src/recipe-container.ts
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var import_node_process2 = require("process");
 var import_node_crypto2 = require("crypto");
+
+// src/code-recipe-dependencies.ts
+var import_promises7 = require("fs/promises");
+var import_node_path7 = require("path");
+var RESERVED_MOUNTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+function assertLentPath(mountAs) {
+  const parts = mountAs.split("/");
+  if ((0, import_node_path7.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 ?? []];
+}
+function withRecipeDependencies(executor, dependencies) {
+  const lent = lentDirectories(dependencies);
+  for (const entry of lent) {
+    if (!(0, import_node_path7.isAbsolute)(entry.source)) {
+      throw new TypeError("recipe dependency source must be an absolute path");
+    }
+    assertReservedMount(entry.mountAs);
+  }
+  return {
+    run: async (input) => {
+      const linked = [];
+      try {
+        for (const entry of lent) {
+          const target = (0, import_node_path7.join)(input.workspaceDir, entry.mountAs);
+          if (await (0, import_promises7.lstat)(target).catch(() => null)) continue;
+          await (0, import_promises7.symlink)(entry.source, target, "dir").then(() => linked.push(target), () => void 0);
+        }
+        return await executor.run(input);
+      } finally {
+        for (const target of linked) await (0, import_promises7.rm)(target, { force: true, recursive: false }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function installedDependencies(repoRoot) {
+  const source = (0, import_node_path7.join)(repoRoot, "node_modules");
+  const info = await (0, import_promises7.lstat)(source).catch(() => null);
+  return info?.isDirectory() ? { source } : null;
+}
+
+// src/recipe-container-lending.ts
+var import_node_child_process5 = require("child_process");
+var import_promises8 = require("fs/promises");
+var import_node_path8 = 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_process5.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_promises8.mkdir)((0, import_node_path8.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_promises8.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_path8.dirname)(dependencies.source);
+  for (const entry of lentDirectories(dependencies)) {
+    if (entry.source !== (0, import_node_path8.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_path8.join)(dependencies.runsDir, runId);
+  await cloneTree(treeRoot, runDir);
+  const rebase = (entry) => ({ source: (0, import_node_path8.join)(runDir, entry.mountAs), mountAs: entry.mountAs });
+  return {
+    dependencies: {
+      ...dependencies,
+      source: (0, import_node_path8.join)(runDir, dependencies.mountAs ?? "node_modules"),
+      nested: (dependencies.nested ?? []).map(rebase),
+      writable: true
+    },
+    release: () => (0, import_promises8.rm)(runDir, { recursive: true, force: true })
+  };
+}
+async function lendBuildProducts(products, workspaceDir) {
+  const root = (0, import_node_path8.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_path8.resolve)(root, product.mountAs);
+    if (!target.startsWith(`${root}${import_node_path8.sep}`)) throw new TypeError("build product escapes the workspace");
+    if (await (0, import_promises8.stat)(target).catch(() => null)) continue;
+    if (!await (0, import_promises8.stat)((0, import_node_path8.join)(root, product.within ?? (0, import_node_path8.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_crypto2.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;
@@ -1738,6 +1856,7 @@ function buildRecipeContainerArgs(engine, workspaceDir, recipe2, name = `odla-re
       ...mounts,
       "--workdir=/workspace",
       "--env=CI=1",
+      "--env=HOME=/tmp",
       recipe2.image,
       ...recipe2.command
     ];
@@ -1760,26 +1879,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_crypto2.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();
+      }
     }
   };
 }
@@ -1804,7 +1931,7 @@ function execute(engine, args, name, recipe2, signal) {
 function runContainerCommand(engine, args, name, recipe2, signal) {
   return new Promise((accept, reject) => {
     const started = Date.now();
-    const child = (0, import_node_child_process5.spawn)(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    const child = (0, import_node_child_process6.spawn)(engine, args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
     const stdout = [];
     const stderr = [];
     let bytes = 0;
@@ -1817,7 +1944,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_process5.spawn)(engine, remove, { shell: false, stdio: "ignore" });
+      const killer = (0, import_node_child_process6.spawn)(engine, remove, { shell: false, stdio: "ignore" });
       killer.unref();
       child.kill("SIGTERM");
     };
@@ -1961,8 +2088,8 @@ async function inspectArtifacts(workspaceDir, recipe2) {
   const receipts = [];
   for (const artifact of recipe2.expectedArtifacts ?? []) {
     try {
-      const path = (0, import_node_path7.join)(workspaceDir, artifact.path);
-      const info = await (0, import_promises7.lstat)(path);
+      const path = (0, import_node_path9.join)(workspaceDir, artifact.path);
+      const info = await (0, import_promises9.lstat)(path);
       if (!info.isFile() || info.isSymbolicLink()) {
         receipts.push({ artifactId: artifact.id, status: "invalid", bytes: null, digest: null });
       } else if (info.size > artifact.maximumBytes) {
@@ -2293,15 +2420,15 @@ async function prepareRuntimeLocalSource(input) {
 }
 
 // src/code-runtime-source.ts
-var import_promises10 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 var import_node_os4 = require("os");
-var import_node_path10 = require("path");
+var import_node_path12 = require("path");
 
 // src/code-runtime-archive.ts
 var import_node_zlib = require("zlib");
-var import_promises8 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_os3 = require("os");
-var import_node_path8 = require("path");
+var import_node_path10 = 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;
@@ -2319,9 +2446,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_promises8.mkdtemp)((0, import_node_path8.join)(tempRoot, "odla-code-archive-"));
-  const sourceDir = (0, import_node_path8.join)(root, "source");
-  await (0, import_promises8.mkdir)(sourceDir);
+  const root = await (0, import_promises10.mkdtemp)((0, import_node_path10.join)(tempRoot, "odla-code-archive-"));
+  const sourceDir = (0, import_node_path10.join)(root, "source");
+  await (0, import_promises10.mkdir)(sourceDir);
   let visible = 0;
   try {
     for (const entry of entries) {
@@ -2334,16 +2461,16 @@ async function materializeCodeRuntimeArchive(archive, visiblePaths, tempRoot = (
         continue;
       }
       if (nulShare(content) > MAX_NUL_SHARE) continue;
-      const target = (0, import_node_path8.resolve)(sourceDir, entry.path);
-      if (!target.startsWith(`${(0, import_node_path8.resolve)(sourceDir)}${import_node_path8.sep}`)) throw new TypeError("Code source path escapes its root");
-      await (0, import_promises8.mkdir)((0, import_node_path8.dirname)(target), { recursive: true });
-      await (0, import_promises8.writeFile)(target, content, { flag: "wx", mode: 420 });
+      const target = (0, import_node_path10.resolve)(sourceDir, entry.path);
+      if (!target.startsWith(`${(0, import_node_path10.resolve)(sourceDir)}${import_node_path10.sep}`)) throw new TypeError("Code source path escapes its root");
+      await (0, import_promises10.mkdir)((0, import_node_path10.dirname)(target), { recursive: true });
+      await (0, import_promises10.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_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;
   }
 }
@@ -2538,8 +2665,8 @@ function nulShare(content) {
 }
 
 // src/code-runtime-selected-source.ts
-var import_promises9 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_promises11 = require("fs/promises");
+var import_node_path11 = 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;
@@ -2576,9 +2703,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_path9.join)(root, ".odla-references", reference.alias);
-      await (0, import_promises9.mkdir)((0, import_node_path9.dirname)(target), { recursive: true });
-      await (0, import_promises9.cp)(reference.sourceDir, target, { recursive: true, errorOnExist: true, force: false });
+      const target = (0, import_node_path11.join)(root, ".odla-references", reference.alias);
+      await (0, import_promises11.mkdir)((0, import_node_path11.dirname)(target), { recursive: true });
+      await (0, import_promises11.cp)(reference.sourceDir, target, { recursive: true, errorOnExist: true, force: false });
       await makeTreeReadOnly(target);
     }
   }
@@ -2589,10 +2716,10 @@ function validateAlias(alias) {
   }
 }
 async function makeTreeReadOnly(root) {
-  for (const entry of await (0, import_promises9.readdir)(root, { withFileTypes: true })) {
-    const target = (0, import_node_path9.join)(root, entry.name);
+  for (const entry of await (0, import_promises11.readdir)(root, { withFileTypes: true })) {
+    const target = (0, import_node_path11.join)(root, entry.name);
     if (entry.isDirectory()) await makeTreeReadOnly(target);
-    else if (entry.isFile()) await (0, import_promises9.chmod)(target, 292);
+    else if (entry.isFile()) await (0, import_promises11.chmod)(target, 292);
   }
 }
 
@@ -2604,9 +2731,9 @@ var SOURCE_MAX_BYTES = 80 * 1024 * 1024;
 var SOURCE_SET_MAX_BYTES = 480 * 1024 * 1024;
 async function materializeCodeRuntimeSource(snapshot, tempRoot = (0, import_node_os4.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_promises10.mkdtemp)((0, import_node_path10.join)(tempRoot, "odla-code-source-"));
-  const sourceDir = (0, import_node_path10.join)(root, "source");
-  await (0, import_promises10.mkdir)(sourceDir);
+  const root = await (0, import_promises12.mkdtemp)((0, import_node_path12.join)(tempRoot, "odla-code-source-"));
+  const sourceDir = (0, import_node_path12.join)(root, "source");
+  await (0, import_promises12.mkdir)(sourceDir);
   const seen = /* @__PURE__ */ new Set();
   let bytes = 0;
   try {
@@ -2616,10 +2743,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_path10.resolve)(sourceDir, file.path);
-      if (!target.startsWith(`${(0, import_node_path10.resolve)(sourceDir)}${import_node_path10.sep}`)) throw new TypeError("Code source path escapes its root");
-      await (0, import_promises10.mkdir)((0, import_node_path10.dirname)(target), { recursive: true });
-      await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 420 });
+      const target = (0, import_node_path12.resolve)(sourceDir, file.path);
+      if (!target.startsWith(`${(0, import_node_path12.resolve)(sourceDir)}${import_node_path12.sep}`)) throw new TypeError("Code source path escapes its root");
+      await (0, import_promises12.mkdir)((0, import_node_path12.dirname)(target), { recursive: true });
+      await (0, import_promises12.writeFile)(target, file.content, { flag: "wx", mode: 420 });
     }
     for (const reference of snapshot.references ?? []) {
       validateAlias2(reference.alias);
@@ -2631,15 +2758,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_path10.resolve)(sourceDir, path);
-        if (!target.startsWith(`${(0, import_node_path10.resolve)(sourceDir)}${import_node_path10.sep}`)) throw new TypeError("Code reference path escapes its root");
-        await (0, import_promises10.mkdir)((0, import_node_path10.dirname)(target), { recursive: true });
-        await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 292 });
+        const target = (0, import_node_path12.resolve)(sourceDir, path);
+        if (!target.startsWith(`${(0, import_node_path12.resolve)(sourceDir)}${import_node_path12.sep}`)) throw new TypeError("Code reference path escapes its root");
+        await (0, import_promises12.mkdir)((0, import_node_path12.dirname)(target), { recursive: true });
+        await (0, import_promises12.writeFile)(target, file.content, { flag: "wx", mode: 292 });
       }
     }
-    return { sourceDir, cleanup: () => (0, import_promises10.rm)(root, { recursive: true, force: true }) };
+    return { sourceDir, cleanup: () => (0, import_promises12.rm)(root, { recursive: true, force: true }) };
   } catch (cause) {
-    await (0, import_promises10.rm)(root, { recursive: true, force: true });
+    await (0, import_promises12.rm)(root, { recursive: true, force: true });
     throw cause;
   }
 }
@@ -2658,10 +2785,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_path10.resolve)(root, path);
-        if (!target.startsWith(`${(0, import_node_path10.resolve)(root)}${import_node_path10.sep}`)) throw new TypeError("Code reference path escapes its root");
-        await (0, import_promises10.mkdir)((0, import_node_path10.dirname)(target), { recursive: true });
-        await (0, import_promises10.writeFile)(target, file.content, { flag: "wx", mode: 292 });
+        const target = (0, import_node_path12.resolve)(root, path);
+        if (!target.startsWith(`${(0, import_node_path12.resolve)(root)}${import_node_path12.sep}`)) throw new TypeError("Code reference path escapes its root");
+        await (0, import_promises12.mkdir)((0, import_node_path12.dirname)(target), { recursive: true });
+        await (0, import_promises12.writeFile)(target, file.content, { flag: "wx", mode: 292 });
       }
     }
   }
@@ -3107,7 +3234,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((resolve8) => setTimeout(resolve8, ms));
+var sleep2 = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 function createCodeRuntimeSessionSkillLoader(control, options = {}) {
   const wait2 = options.wait ?? sleep2;
   const load = control.collaborationSkills?.bind(control);
@@ -3166,7 +3293,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((resolve8) => setTimeout(resolve8, ms)));
+  const wait2 = input.wait ?? ((ms) => new Promise((resolve9) => setTimeout(resolve9, ms)));
   const response2 = await inferWithBackoff(
     () => input.control.infer(command.sessionId, {
       requestId: request.requestId,
@@ -3677,18 +3804,18 @@ function response(request, ok, content, details) {
 }
 
 // src/code-tool-edit.ts
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 
 // src/code-tool-graph.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 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_promises11.readFile)((0, import_node_path11.join)(workspaceDir, path), "utf8");
+  const read2 = (path) => (0, import_promises13.readFile)((0, import_node_path13.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
@@ -3764,7 +3891,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_promises12.readFile)(target, "utf8");
+  const current = await (0, import_promises14.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`);
@@ -3773,7 +3900,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_promises12.writeFile)(target, `${current.slice(0, at)}${newText}${current.slice(at + oldText.length)}`, "utf8");
+  await (0, import_promises14.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) {
@@ -3798,8 +3925,8 @@ async function edit(context, request, options, policy, registry) {
 }
 
 // src/code-tool-write.ts
-var import_promises13 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_promises15 = require("fs/promises");
+var import_node_path14 = require("path");
 var MAX_WRITE_BYTES = 256 * 1024;
 var lines = (text2) => text2 === "" ? [] : text2.replace(/\n$/, "").split("\n");
 function writeAsDiff(path, current, content) {
@@ -3824,8 +3951,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_promises13.mkdir)((0, import_node_path12.dirname)(target), { recursive: true });
-  await (0, import_promises13.writeFile)(target, content, "utf8");
+  await (0, import_promises15.mkdir)((0, import_node_path14.dirname)(target), { recursive: true });
+  await (0, import_promises15.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) {
@@ -3836,7 +3963,7 @@ async function write(context, request, options, policy, registry) {
     throw new TypeError("write targets a read-only reference source");
   }
   const exists2 = (await registry.files(context.workspaceDir)).includes(path);
-  const current = exists2 ? await (0, import_promises13.readFile)(resolveCodePath(context.workspaceDir, path), "utf8") : null;
+  const current = exists2 ? await (0, import_promises15.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");
@@ -3852,12 +3979,12 @@ async function write(context, request, options, policy, registry) {
 }
 
 // src/code-tool-reads.ts
-var import_promises15 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 
 // src/code-tool-discovery.ts
-var import_node_child_process6 = require("child_process");
-var import_promises14 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_child_process7 = require("child_process");
+var import_promises16 = require("fs/promises");
+var import_node_path15 = require("path");
 var DEFAULT_MAX_FILES = 2e4;
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_FILE_BYTES = 512 * 1024;
@@ -3882,13 +4009,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_promises14.readdir)(directory, { withFileTypes: true })) {
+    for (const entry of await (0, import_promises16.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_path13.resolve)(directory, entry.name);
+      const target = (0, import_node_path15.resolve)(directory, entry.name);
       if (entry.isDirectory()) await walk(target);
       else if (entry.isFile()) {
-        const path = (0, import_node_path13.relative)(root, target).split("\\").join("/");
+        const path = (0, import_node_path15.relative)(root, target).split("\\").join("/");
         try {
           validateRelativePath(path);
         } catch {
@@ -3899,7 +4026,7 @@ async function registeredFiles(root, limit = DEFAULT_MAX_FILES) {
       }
     }
   };
-  await walk((0, import_node_path13.resolve)(root));
+  await walk((0, import_node_path15.resolve)(root));
   return paths2.sort();
 }
 function listWorkspace(paths2, options = {}) {
@@ -3961,7 +4088,7 @@ function nativeSearchBatch(root, paths2, options, remaining) {
       options.query,
       ...paths2
     ];
-    const child = (0, import_node_child_process6.spawn)("rg", args, {
+    const child = (0, import_node_child_process7.spawn)("rg", args, {
       cwd: root,
       stdio: ["ignore", "pipe", "ignore"],
       ...options.signal ? { signal: options.signal } : {}
@@ -4013,7 +4140,7 @@ async function fallbackSearch(root, scoped, options) {
     if (matches.length >= options.maxResults) break;
     let source;
     try {
-      source = await (0, import_promises14.readFile)((0, import_node_path13.resolve)(root, path));
+      source = await (0, import_promises16.readFile)((0, import_node_path15.resolve)(root, path));
     } catch {
       continue;
     }
@@ -4052,11 +4179,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_promises15.stat)(target);
+  const info = await (0, import_promises17.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_promises15.readFile)(target);
+  const source = await (0, import_promises17.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");
@@ -4604,8 +4731,8 @@ var runtimeErrorMessage = (value) => value instanceof Error ? value.message : St
 function codeRuntimeAcknowledgementGate(signal) {
   let settle;
   let settled = false;
-  const ready = new Promise((resolve8) => {
-    settle = resolve8;
+  const ready = new Promise((resolve9) => {
+    settle = resolve9;
   });
   const release = (run) => {
     if (settled) return;
@@ -4671,8 +4798,8 @@ function observeCodeRuntimeSessionSkills(command, skills, emit) {
 }
 
 // src/code-repository-recipes.ts
-var import_promises16 = require("fs/promises");
-var import_node_path14 = require("path");
+var import_promises18 = require("fs/promises");
+var import_node_path16 = require("path");
 var REPOSITORY_RECIPES_FILE = "odla.recipes.json";
 var MAX_RECIPES = 16;
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -4733,7 +4860,7 @@ function parseRepositoryRecipes(text2, envelope) {
 async function readRepositoryRecipes(baselineDir, envelope) {
   let text2;
   try {
-    text2 = await (0, import_promises16.readFile)((0, import_node_path14.join)(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
+    text2 = await (0, import_promises18.readFile)((0, import_node_path16.join)(baselineDir, REPOSITORY_RECIPES_FILE), "utf8");
   } catch (cause) {
     if (cause.code === "ENOENT") return null;
     throw cause;
@@ -5334,82 +5461,58 @@ function chooseStrategy(signals = {}) {
 }
 var feedbackIsActionable = actionable;
 
-// src/code-recipe-dependencies.ts
-var import_promises17 = require("fs/promises");
-var import_node_path15 = require("path");
-var RESERVED_MOUNTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
-function withRecipeDependencies(executor, dependencies) {
-  const mountAs = dependencies.mountAs ?? "node_modules";
-  if (!(0, import_node_path15.isAbsolute)(dependencies.source)) {
-    throw new TypeError("recipe dependency source must be an absolute path");
-  }
-  if (!RESERVED_MOUNTS.has(mountAs)) {
-    throw new TypeError(`recipe dependencies must mount at a reserved name, not "${mountAs}"`);
-  }
-  return {
-    run: async (input) => {
-      const target = (0, import_node_path15.join)(input.workspaceDir, mountAs);
-      let linked = false;
-      try {
-        const existing = await (0, import_promises17.lstat)(target).catch(() => null);
-        if (!existing) {
-          await (0, import_promises17.symlink)(dependencies.source, target, "dir");
-          linked = true;
-        }
-        return await executor.run(input);
-      } finally {
-        if (linked) await (0, import_promises17.rm)(target, { force: true, recursive: false }).catch(() => void 0);
-      }
-    }
-  };
-}
-async function installedDependencies(repoRoot) {
-  const source = (0, import_node_path15.join)(repoRoot, "node_modules");
-  const info = await (0, import_promises17.lstat)(source).catch(() => null);
-  return info?.isDirectory() ? { source } : null;
-}
-
 // src/code-recipe-dependency-cache.ts
 var import_node_crypto5 = require("crypto");
-var import_promises18 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_node_process3 = require("process");
-var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 var DEPENDENCY_INSTALL_TIMEOUT_MS = 20 * 6e4;
 var OUTPUT_CAP = 4 * 1024 * 1024;
-var exists = async (path) => Boolean(await (0, import_promises18.stat)(path).catch(() => null));
-async function dependencyCacheKey(repoRoot, image, arch = process.arch) {
-  const lock = await (0, import_promises18.readFile)((0, import_node_path16.join)(repoRoot, "package-lock.json")).catch(() => null);
+var EXACT_VERSION = /^\d+\.\d+\.\d+$/;
+var exists = async (path) => Boolean(await (0, import_promises19.stat)(path).catch(() => null));
+async function pinnedNpmVersion(repoRoot) {
+  const manifest = await (0, import_promises19.readFile)((0, import_node_path17.join)(repoRoot, "package.json"), "utf8").catch(() => null);
+  if (!manifest) return null;
+  const engines = JSON.parse(manifest).engines;
+  return typeof engines?.npm === "string" && EXACT_VERSION.test(engines.npm) ? engines.npm : null;
+}
+async function dependencyCacheKey(repoRoot, image, arch = process.arch, npmVersion = null) {
+  const lock = await (0, import_promises19.readFile)((0, import_node_path17.join)(repoRoot, "package-lock.json")).catch(() => null);
   if (!lock) return null;
-  return (0, import_node_crypto5.createHash)("sha256").update(lock).update("\n").update(image).update("\n").update(arch).digest("hex").slice(0, 32);
+  return (0, import_node_crypto5.createHash)("sha256").update(lock).update("\n").update(image).update("\n").update(arch).update("\n").update(npmVersion ?? "image").digest("hex").slice(0, 32);
+}
+async function workspaceDirs(repoRoot) {
+  const root = JSON.parse(await (0, import_promises19.readFile)((0, import_node_path17.join)(repoRoot, "package.json"), "utf8"));
+  const globs = Array.isArray(root.workspaces) ? root.workspaces : root.workspaces?.packages ?? [];
+  const dirs = [];
+  for (const glob of globs) {
+    const found = glob.endsWith("/*") ? (await (0, import_promises19.readdir)((0, import_node_path17.join)(repoRoot, glob.slice(0, -2)), { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => `${glob.slice(0, -2)}/${entry.name}`) : [glob];
+    for (const dir of found) if (await exists((0, import_node_path17.join)(repoRoot, dir, "package.json"))) dirs.push(dir);
+  }
+  return dirs;
 }
 async function stageManifests(repoRoot, stageDir) {
-  await (0, import_promises18.mkdir)(stageDir, { recursive: true });
+  await (0, import_promises19.mkdir)(stageDir, { recursive: true });
   const staged = [];
   for (const name of ["package.json", "package-lock.json", ".npmrc"]) {
-    if (!await exists((0, import_node_path16.join)(repoRoot, name))) continue;
-    await (0, import_promises18.copyFile)((0, import_node_path16.join)(repoRoot, name), (0, import_node_path16.join)(stageDir, name));
+    if (!await exists((0, import_node_path17.join)(repoRoot, name))) continue;
+    await (0, import_promises19.copyFile)((0, import_node_path17.join)(repoRoot, name), (0, import_node_path17.join)(stageDir, name));
     staged.push(name);
   }
-  const root = JSON.parse(await (0, import_promises18.readFile)((0, import_node_path16.join)(repoRoot, "package.json"), "utf8"));
-  const globs = Array.isArray(root.workspaces) ? root.workspaces : root.workspaces?.packages ?? [];
-  for (const glob of globs) {
-    const dirs = glob.endsWith("/*") ? (await (0, import_promises18.readdir)((0, import_node_path16.join)(repoRoot, glob.slice(0, -2)), { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => `${glob.slice(0, -2)}/${entry.name}`) : [glob];
-    for (const dir of dirs) {
-      const manifest = (0, import_node_path16.join)(repoRoot, dir, "package.json");
-      if (!await exists(manifest)) continue;
-      await (0, import_promises18.mkdir)((0, import_node_path16.join)(stageDir, dir), { recursive: true });
-      await (0, import_promises18.copyFile)(manifest, (0, import_node_path16.join)(stageDir, dir, "package.json"));
-      staged.push(`${dir}/package.json`);
-    }
+  for (const dir of await workspaceDirs(repoRoot)) {
+    await (0, import_promises19.mkdir)((0, import_node_path17.join)(stageDir, dir), { recursive: true });
+    await (0, import_promises19.copyFile)((0, import_node_path17.join)(repoRoot, dir, "package.json"), (0, import_node_path17.join)(stageDir, dir, "package.json"));
+    staged.push(`${dir}/package.json`);
   }
   return staged;
 }
-function dependencyInstallArgs(engine, image, stageDir, name) {
+function dependencyInstallArgs(engine, image, stageDir, name, npmVersion = null) {
   if (/[,\r\n]/.test(stageDir)) throw new TypeError("stage path contains unsupported mount characters");
   const uid = typeof import_node_process3.getuid === "function" ? (0, import_node_process3.getuid)() : 1e3;
   const gid = typeof import_node_process3.getgid === "function" ? (0, import_node_process3.getgid)() : 1e3;
   const mount = engine === "container" ? `--mount=type=bind,source=${stageDir},target=/workspace` : `--mount=type=bind,src=${stageDir},dst=/workspace`;
-  const npm = ["npm", "ci", "--no-audit", "--no-fund", "--ignore-scripts", "--engine-strict=false"];
+  const install = ["ci", "--no-audit", "--no-fund", "--ignore-scripts", "--engine-strict=false"];
+  const npm = npmVersion ? ["npx", "--yes", `npm@${npmVersion}`, ...install] : ["npm", ...install];
   return [
     "run",
     "--rm",
@@ -5428,34 +5531,79 @@ function dependencyInstallArgs(engine, image, stageDir, name) {
     ...npm
   ];
 }
+function npmFailureSummary(stderr) {
+  const lines2 = stderr.split("\n").map((line) => line.trim()).filter((line) => line && line !== "npm error");
+  const at = lines2.findIndex((line) => /^npm error code /.test(line));
+  return (at >= 0 ? lines2.slice(at, at + 3) : lines2.slice(-3)).join(" | ").slice(0, 400);
+}
+async function nestedTrees(treeRoot, dirs) {
+  const nested = [];
+  for (const dir of dirs) {
+    if (await exists((0, import_node_path17.join)(treeRoot, dir, "node_modules"))) nested.push({ source: (0, import_node_path17.join)(treeRoot, dir, "node_modules"), mountAs: `${dir}/node_modules` });
+  }
+  return nested;
+}
 async function prepareContainerDependencies(input) {
-  const key = await dependencyCacheKey(input.repoRoot, input.image);
+  const npmVersion = await pinnedNpmVersion(input.repoRoot);
+  const key = await dependencyCacheKey(input.repoRoot, input.image, process.arch, npmVersion);
   if (!key) return null;
-  const dir = (0, import_node_path16.join)(input.cacheRoot, key);
-  const tree = (0, import_node_path16.join)(dir, "node_modules");
-  const stage = (0, import_node_path16.join)(dir, "stage");
-  if (await exists(tree)) return { source: tree };
+  const dir = (0, import_node_path17.join)(input.cacheRoot, key);
+  const tree = (0, import_node_path17.join)(dir, "tree");
+  const stage = (0, import_node_path17.join)(dir, "stage");
+  const runsDir = (0, import_node_path17.join)(dir, "runs");
+  await (0, import_promises19.rm)(runsDir, { recursive: true, force: true });
+  const dirs = await workspaceDirs(input.repoRoot);
+  const lend = async () => ({ source: (0, import_node_path17.join)(tree, "node_modules"), nested: await nestedTrees(tree, dirs), runsDir });
+  if (await exists((0, import_node_path17.join)(tree, "node_modules"))) return lend();
   const run = input.run ?? runContainerCommand;
-  await (0, import_promises18.rm)(stage, { recursive: true, force: true });
+  await (0, import_promises19.rm)(stage, { recursive: true, force: true });
   const staged = await stageManifests(input.repoRoot, stage);
-  input.log?.(`installing ${key.slice(0, 12)}: ${staged.length} manifests, npm ci in ${input.image}`);
+  input.log?.(`installing ${key.slice(0, 12)}: ${staged.length} manifests, npm${npmVersion ? `@${npmVersion}` : ""} ci in ${input.image}`);
   const name = `odla-deps-${key.slice(0, 12)}`;
   const result = await run(
     input.engine,
-    dependencyInstallArgs(input.engine, input.image, stage, name),
+    dependencyInstallArgs(input.engine, input.image, stage, name, npmVersion),
     name,
     { timeoutMs: DEPENDENCY_INSTALL_TIMEOUT_MS, maxOutputBytes: OUTPUT_CAP }
   );
-  if (result.exitCode !== 0 || result.timedOut || !await exists((0, import_node_path16.join)(stage, "node_modules"))) {
-    input.log?.(`install failed (exit ${result.exitCode}${result.timedOut ? ", timed out" : ""}): ${result.stderr.trim().split("\n").slice(-3).join(" | ").slice(0, 400)}`);
-    await (0, import_promises18.rm)(stage, { recursive: true, force: true });
+  if (result.exitCode !== 0 || result.timedOut || !await exists((0, import_node_path17.join)(stage, "node_modules"))) {
+    input.log?.(`install failed (exit ${result.exitCode}${result.timedOut ? ", timed out" : ""}): ${npmFailureSummary(result.stderr)}`);
+    await (0, import_promises19.rm)(stage, { recursive: true, force: true });
     return null;
   }
-  await (0, import_promises18.rename)((0, import_node_path16.join)(stage, "node_modules"), tree);
-  await (0, import_promises18.rm)(stage, { recursive: true, force: true });
-  await (0, import_promises18.writeFile)((0, import_node_path16.join)(dir, "manifest.json"), JSON.stringify({ image: input.image, key, createdAt: Date.now() }, null, 2));
-  input.log?.(`installed ${key.slice(0, 12)} in ${Math.round(result.durationMs / 1e3)}s`);
-  return { source: tree };
+  await (0, import_promises19.rm)(tree, { recursive: true, force: true });
+  await (0, import_promises19.rename)(stage, tree);
+  await (0, import_promises19.writeFile)((0, import_node_path17.join)(dir, "manifest.json"), JSON.stringify({ image: input.image, key, npmVersion, createdAt: Date.now() }, null, 2));
+  const lent = await lend();
+  input.log?.(`installed ${key.slice(0, 12)} in ${Math.round(result.durationMs / 1e3)}s, ${lent.nested?.length ?? 0} nested tree(s)`);
+  return lent;
+}
+
+// src/code-recipe-build-products.ts
+var import_node_child_process8 = require("child_process");
+var import_promises20 = require("fs/promises");
+var import_node_path18 = require("path");
+function gitIgnoredFiles(repoRoot) {
+  return new Promise((accept) => {
+    const child = (0, import_node_child_process8.spawn)("git", ["-C", repoRoot, "ls-files", "--others", "--ignored", "--exclude-standard", "-z"], { shell: false, stdio: ["ignore", "pipe", "ignore"] });
+    const chunks = [];
+    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    child.once("error", () => accept([]));
+    child.once("exit", (code) => accept(code === 0 ? Buffer.concat(chunks).toString("utf8").split("\0").filter(Boolean) : []));
+  });
+}
+async function hostBuildProducts(repoRoot) {
+  const dirs = await workspaceDirs(repoRoot);
+  const within = (path) => dirs.find((dir) => path.startsWith(`${dir}/`)) ?? ".";
+  const products = [];
+  for (const dir of dirs) {
+    const source = (0, import_node_path18.join)(repoRoot, dir, "dist");
+    if ((await (0, import_promises20.stat)(source).catch(() => null))?.isDirectory()) products.push({ source, mountAs: `${dir}/dist`, within: dir });
+  }
+  for (const path of await gitIgnoredFiles(repoRoot)) {
+    if (allowedWorkspacePath(path)) products.push({ source: (0, import_node_path18.join)(repoRoot, path), mountAs: path, within: within(path) });
+  }
+  return products;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -5479,11 +5627,14 @@ async function prepareContainerDependencies(input) {
   applyPatchDialectToDiff,
   assertCodeBuildRecipe,
   assertDisjointPlan,
+  assertLentPath,
   assertPinnedImage,
+  assertReservedMount,
   attachCodeRuntimeReferences,
   buildContainerRunArgs,
   buildRecipeContainerArgs,
   chooseStrategy,
+  cloneTree,
   codeSkill,
   createCodeRuntimeControlClient,
   createCodeRuntimeInference,
@@ -5500,17 +5651,23 @@ async function prepareContainerDependencies(input) {
   feedbackIsActionable,
   hasContextFreeHunk,
   hazardFromAttempt,
+  hostBuildProducts,
   installedDependencies,
   integrateSubGoals,
   isCheckpointEffectCompleted,
+  lendBuildProducts,
+  lendDependencies,
+  lentDirectories,
   materializeCodeRuntimeArchive,
   materializeCodeRuntimeSource,
   materializeCommandWorkspace,
   materializeGitTree,
+  npmFailureSummary,
   outcomeCloses,
   outcomeMemory,
   parseRepositoryRecipes,
   patchPaths,
+  pinnedNpmVersion,
   planReachCollisions,
   prepareContainerDependencies,
   prepareRuntimeCheckpoint,
@@ -5549,6 +5706,7 @@ async function prepareContainerDependencies(input) {
   verifyCodeCandidate,
   verifyContainerEngineBoundary,
   withProofRecipes,
-  withRecipeDependencies
+  withRecipeDependencies,
+  workspaceDirs
 });
 //# sourceMappingURL=node.cjs.map