@outerlayer/cli 0.24.0 → 0.25.0

package/dist/{chunk-6GSA2SKT.js → chunk-3I44PQ26.js}

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { senderPidfile } from './chunk-W7O4LA4E.js';
-import { DOCKERD_LOG, HELPER_PATH, HELPER_RECORD } from './chunk-A62QFN2M.js';
-import { writeDockerClientConfig } from './chunk-CZUH2SLQ.js';
-import { installScrubContext } from './chunk-D7K446H6.js';
-import { ADDED_USER, AssetError, obtainImage, ensureRootfs, gitRemoteFor, startServicesFor, createBuildDisk, machineConfig, resolveAgentUser, AgentUserError, runBuildSteps, shellQuote, LEASE_SECONDS, createContainerRuntime, stopContainer, cleanupContainer, outOfMemoryReason, containerSenderCommand, signalInContainer, syncInContainer, copyTranscriptsFromContainer, senderAliveScript, GH_CONFIG_YML, ghHostsYml, isLiteralAddress, deleteBuildDisk, startCheckContainer, lifecycleSteps, lifecycleFailureReason, writeEvalInput, DeliveryFailure, EVAL_INPUT_NAME, copyTranscripts, senderSignalScript, containerJudgeEnvironment, copyJudgeTree } from './chunk-GU4PKXN7.js';
-import { readBranchHead, fetchCommit, diffBetween } from './chunk-TTLVQZSH.js';
+import { readsJobState, READ_JOB_STATE_FORMATS, jobStateFormatOf } from './chunk-ZVB57WI6.js';
+import { senderPidfile } from './chunk-34ANPNVB.js';
+import { DOCKERD_LOG, HELPER_PATH, HELPER_RECORD } from './chunk-2N72GPS2.js';
+import { writeDockerClientConfig } from './chunk-UNF7MWEL.js';
+import { installScrubContext } from './chunk-YTTHDPWF.js';
+import { ADDED_USER, AssetError, obtainImage, ensureRootfs, gitRemoteFor, startServicesFor, createBuildDisk, machineConfig, resolveAgentUser, AgentUserError, runBuildSteps, shellQuote, LEASE_SECONDS, createContainerRuntime, stopContainer, cleanupContainer, outOfMemoryReason, containerSenderCommand, signalInContainer, syncInContainer, copyTranscriptsFromContainer, senderAliveScript, HelperRefusal, GH_CONFIG_YML, ghHostsYml, isLiteralAddress, deleteBuildDisk, startCheckContainer, lifecycleSteps, lifecycleFailureReason, writeEvalInput, DeliveryFailure, EVAL_INPUT_NAME, copyTranscripts, senderSignalScript, containerJudgeEnvironment, copyJudgeTree } from './chunk-XHXDCYSK.js';
+import { readBranchHead, fetchCommit, diffBetween } from './chunk-AXPCGD46.js';
 import { isSameProcess, startTimeOf } from './chunk-JBJTC3UU.js';
-import { HASH_ARGV, parseProgramHash, JUDGE_PROGRAM, writeJobFile, readJobFile, COMMAND_DIR, childEnvironment, judgeCommand, JUDGE_MAX_TURNS, MAX_REPORT_BYTES, JUDGE_DIR } from './chunk-5XCAPBE2.js';
-import { CLAUDE_CODE_VERSION } from './chunk-3W333NFO.js';
-import { waitForAgent, vmExecArgs } from './chunk-LY2L3O2O.js';
-import { socketPathProblem, vsockLinks, linkVsockSockets } from './chunk-PDIM5T65.js';
-import { describeCallFailure, resolveGoverningSource, refusalCode, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, logStamp, createRunnerLog, formatDuration, retrySend, formatClock } from './chunk-TQ6Y7YV6.js';
-import { WorkCommandError, postJson, isSignatureRefusal, getJson } from './chunk-RVYOOYOA.js';
+import { HASH_ARGV, parseProgramHash, JUDGE_PROGRAM, writeJobFile, readJobFile, COMMAND_DIR, childEnvironment, judgeCommand, JUDGE_MAX_TURNS, MAX_REPORT_BYTES, JUDGE_DIR } from './chunk-QUGYGO6L.js';
+import { CLAUDE_CODE_VERSION } from './chunk-RGW7ERF3.js';
+import { waitForAgent, vmExecArgs } from './chunk-7OWPLRJR.js';
+import { socketPathProblem, vsockLinks, linkVsockSockets } from './chunk-XGJUNNXL.js';
+import { describeCallFailure, resolveGoverningSource, refusalCode, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, logStamp, createRunnerLog, formatDuration, retrySend, formatClock } from './chunk-YMKQVCKC.js';
+import { WorkCommandError, postJson, isSignatureRefusal, getJson } from './chunk-X5LNCIZT.js';
 import { planArtifactUpload } from './chunk-BUP5N3X6.js';
-import { isBuiltinContainer, isBuiltinProcess, isBuiltinVm, DEFAULT_CHECK_TIME_LIMIT_MINUTES } from './chunk-D7X5ITVT.js';
+import { isBuiltinContainer, isBuiltinProcess, isBuiltinVm, DEFAULT_CHECK_TIME_LIMIT_MINUTES } from './chunk-JWRX5ZTT.js';
 import { parseSize } from './chunk-7RQ73DLO.js';
 import { scrubText } from './chunk-D4AMAEZ7.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';
@@ -22,11 +23,11 @@ import { resolvePackRoot } from './chunk-HBISTTG3.js';
 import { parsePolicy } from './chunk-RKOTJQVG.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { resolveVersion } from './chunk-RA3O54FC.js';
-import { signerFor } from './chunk-PVRBE7S4.js';
-import { RUNNER_FILE_MODE, runnerDir, buildDir, vsockPath } from './chunk-KF37SUDM.js';
-import { claudeCredential, repositoriesOf, primaryOf, buildEnvironment, JOB_MOUNT, CHECKOUT_DIR, parseIsolation, proxyEnvironment, withProxyWarningHidden, containerLocalAddress, destinationEnvironment, CLAUDE_CREDENTIAL_VARIABLES, builtInEnvironment, withHooksPath, startBuildServices, BUILT_IN_NAMES, AGENT_CREDENTIAL_MISSING, sharedUserEnvironment, headerVariables, authorEnvironment, withTunnelRecord, commitIdentityRecord, RELAY_PORT, repositoryPath, lifecycleWorkdir, checkEnvironment, EVAL_INPUT_DIR } from './chunk-BN3CSI7S.js';
-import { RUNNER_WORDED_REASONS, UNKNOWN_TRACKING_REASON } from './chunk-GISNHSYL.js';
-import { existsSync, statSync, appendFileSync, mkdirSync, chmodSync, writeFileSync, accessSync, constants, openSync, readFileSync, closeSync, rmSync, readdirSync, lstatSync, fstatSync, readSync, realpathSync } from 'fs';
+import { signerFor } from './chunk-ZODVSFI4.js';
+import { RUNNER_FILE_MODE, runnerDir, buildDir, vsockPath } from './chunk-ZI2ZVWKT.js';
+import { claudeCredential, repositoriesOf, primaryOf, buildEnvironment, JOB_MOUNT, CHECKOUT_DIR, parseIsolation, proxyEnvironment, withProxyWarningHidden, containerLocalAddress, destinationEnvironment, CLAUDE_CREDENTIAL_VARIABLES, builtInEnvironment, withHooksPath, startBuildServices, BUILT_IN_NAMES, AGENT_CREDENTIAL_MISSING, sharedUserEnvironment, headerVariables, authorEnvironment, withTunnelRecord, commitIdentityRecord, RELAY_PORT, repositoryPath, lifecycleWorkdir, checkEnvironment, EVAL_INPUT_DIR } from './chunk-2K3TCQHW.js';
+import { RUNNER_WORDED_REASONS, UNKNOWN_TRACKING_REASON } from './chunk-JGD5TWQ2.js';
+import { existsSync, statSync, appendFileSync, mkdirSync, chmodSync, writeFileSync, accessSync, constants, openSync, readFileSync, closeSync, rmSync, readdirSync, linkSync, lstatSync, fstatSync, readSync, realpathSync } from 'fs';
 import { join, isAbsolute, dirname, delimiter, sep } from 'path';
 import { spawn, spawnSync } from 'child_process';
 import { randomBytes, createHash } from 'crypto';
@@ -94,6 +95,61 @@ function judgeProbe(probe, missedBefore) {
   if (probe.alive) return { kind: "running" };
   return missedBefore ? { kind: "lost" } : { kind: "recheck" };
 }
+function unitNameFor(buildId) {
+  return `outerlayer-build-${buildId}`;
+}
+function linkIn(buildDir2, name, source) {
+  const target = join(buildDir2, name);
+  rmSync(target, { force: true });
+  try {
+    linkSync(source, target);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      throw new Error(`${source} and ${buildDir2} are on different file systems, so the build's files cannot be linked into its jail`);
+    }
+    throw err;
+  }
+  chmodSync(source, 292);
+}
+async function startJailed(input) {
+  linkIn(input.buildDir, "kernel", input.kernel);
+  linkIn(input.buildDir, "rootfs.ext4", input.rootfs);
+  for (const name of input.sockets) {
+    try {
+      chmodSync(join(input.buildDir, name), 438);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  return input.client.start({ build: input.buildId, kind: input.kind });
+}
+async function startJailedInto(state, input, save) {
+  state.jailed = { unit: unitNameFor(state.buildId), chroot: "" };
+  save();
+  try {
+    const started = await startJailed({ ...input, buildId: state.buildId, buildDir: state.buildDir });
+    state.jailed = { unit: started.unit, chroot: started.chroot };
+    state.vsockPath = started.vsock;
+  } catch (err) {
+    if (err instanceof HelperRefusal) {
+      delete state.jailed;
+      save();
+    }
+    throw err;
+  }
+  save();
+}
+async function stopJailed(helper, state) {
+  const probe = await helper.probe();
+  if (!probe.ok) throw new Error(`the build's unit ${state.jailed?.unit ?? unitNameFor(state.buildId)} could not be stopped, because there is no helper to ask: ${probe.detail}`);
+  try {
+    await probe.client.stop(state.buildId);
+  } catch (err) {
+    throw new Error(`the build's unit ${state.jailed?.unit ?? unitNameFor(state.buildId)} was not stopped: ${describeCallFailure(err)}`);
+  }
+}
+
+// src/runner/microvm/hooks.ts
 var DEFAULT_MEMORY = "8g";
 var DEFAULT_DISK = "40g";
 var DEFAULT_CPUS = 4;
@@ -147,6 +203,29 @@ async function unpackIntoGuest(runtime, state, dir, target, opts = {}) {
 async function deliverCommitHooks(input) {
   await unpackIntoGuest(input.runtime, input.state, input.hooksDir, GUEST_HOOKS_DIR);
 }
+function vmAlive(runtime, state) {
+  if (state.jailed !== void 0) return runtime.vm.helper.alive(state.jailed.unit);
+  return state.firecracker !== void 0 && runtime.vm.firecracker.alive(state.firecracker);
+}
+async function helperFor(runtime, log) {
+  const probe = await runtime.vm.helper.probe();
+  if (probe.ok) return probe.client;
+  if (probe.reason === "unsupported") log(probe.detail);
+  else if (probe.unreachable === true) log(`${probe.detail}, so this build runs without the jailer`);
+  return void 0;
+}
+function consoleNote(state, consolePath) {
+  return state.jailed === void 0 ? `its console is in ${consolePath}` : `its console output is in the journal of the unit ${state.jailed.unit}`;
+}
+async function helperKills(runtime, state) {
+  const probe = await runtime.vm.helper.probe();
+  return probe.ok ? (await probe.client.state(state.buildId)).oomKills : 0;
+}
+async function microVmOomKills(runtime, state) {
+  if (state.cgroup !== void 0 && runtime.vm.cgroup.oomKills(state.cgroup) > 0) return 1;
+  if (state.jailed !== void 0) return helperKills(runtime, state);
+  return 0;
+}
 async function provisionMicroVm(input) {
   const { config, runtime, item, itemKey, jobDir, log, tokens } = input;
   const { vm } = runtime;
@@ -224,9 +303,9 @@ async function provisionMicroVm(input) {
   input.save(state, environment);
   const bail = async (reason, aborted = false) => {
     let why = reason;
-    if (!aborted && state.cgroup !== void 0) {
+    if (!aborted && (state.cgroup !== void 0 || state.jailed !== void 0)) {
       try {
-        if (runtime.vm.cgroup.oomKills(state.cgroup) > 0) why = outOfMemoryReason(config.build?.memory);
+        if (await microVmOomKills(runtime, state) > 0) why = outOfMemoryReason(config.build?.memory);
       } catch (err) {
         log.error(`${tag} could not read the build's memory events: ${describeCallFailure(err)} \xB7 continuing`);
       }
@@ -266,8 +345,9 @@ async function provisionMicroVm(input) {
   };
   const links = vsockLinks({ destinations: config.build?.destinations?.length ?? 0, builtIns: true });
   const configPath = join(buildDir2, "vm.json");
+  const helper = await helperFor(runtime, (line) => log.line(`${tag} ${line}`));
   try {
-    linkVsockSockets({ buildDir: buildDir2, vsockPath: state.vsockPath, links });
+    if (helper === void 0) linkVsockSockets({ buildDir: buildDir2, vsockPath: state.vsockPath, links });
     await createBuildDisk({ host: vm.rootfs, runnerDir: runnerDirPath, bytes: limits.diskBytes, dest: state.buildDisk, memoryBytes: limits.memoryBytes });
     writeFileSync(
       configPath,
@@ -282,24 +362,34 @@ async function provisionMicroVm(input) {
     return bail(`the build's disk and machine could not be made: ${describeCallFailure(err)}`);
   }
   if (input.aborted()) return bail("", true);
-  try {
-    state.cgroup = vm.cgroup.create(buildId, limits.memoryBytes);
-  } catch (err) {
-    return bail(`the build's memory limit could not be set: ${describeCallFailure(err)}`);
+  if (helper === void 0) {
+    try {
+      state.cgroup = vm.cgroup.create(buildId, limits.memoryBytes);
+    } catch (err) {
+      return bail(`the build's memory limit could not be set: ${describeCallFailure(err)}`);
+    }
+    if (state.cgroup !== void 0) input.save(state, environment);
   }
-  if (state.cgroup !== void 0) input.save(state, environment);
   const consolePath = join(jobDir, "vm-console.log");
-  try {
-    state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath, cgroup: state.cgroup });
-  } catch (err) {
-    return bail(`Firecracker did not start: ${describeCallFailure(err)}`);
+  if (helper !== void 0) {
+    try {
+      await startJailedInto(state, { client: helper, kind: "build", kernel: assets.kernel, rootfs: state.rootfs, sockets: links.map((link) => link.socket) }, () => input.save(state, environment));
+    } catch (err) {
+      return bail(`the microVM did not start under the jailer: ${describeCallFailure(err)}`);
+    }
+  } else {
+    try {
+      state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath, cgroup: state.cgroup });
+    } catch (err) {
+      return bail(`Firecracker did not start: ${describeCallFailure(err)}`);
+    }
+    input.save(state, environment);
   }
-  input.save(state, environment);
   if (input.aborted()) return bail("", true);
   const ready = await waitForAgent(state.vsockPath, { attempts: BOOT_ATTEMPTS, delayMs: BOOT_POLL_MS, sleep: runtime.sleep });
   if (!ready) {
-    const why = vm.firecracker.alive(state.firecracker) ? "its exec agent did not answer" : "it exited before its exec agent answered";
-    return bail(`the microVM did not start: ${why}; its console is in ${consolePath}`);
+    const why = vmAlive(runtime, state) ? "its exec agent did not answer" : "it exited before its exec agent answered";
+    return bail(`the microVM did not start: ${why}; ${consoleNote(state, consolePath)}`);
   }
   let pushes = Promise.resolve();
   let firstWriteFailure;
@@ -325,7 +415,7 @@ async function provisionMicroVm(input) {
   }
   tokens.onRead((token) => {
     pushes = pushes.then(async () => {
-      if (state.firecracker === void 0 || !vm.firecracker.alive(state.firecracker)) return;
+      if (!vmAlive(runtime, state)) return;
       await writeGuestGhConfig(runtime, state, token);
     }, void 0).catch(reportWrite);
   });
@@ -467,7 +557,7 @@ function microVmSenderCommand(input) {
   return { command: process.execPath, args: [input.cli, "vm-exec", ...vmExecArgs(options)], env };
 }
 function isRunning(runtime, state) {
-  return state.firecracker !== void 0 && runtime.vm.firecracker.alive(state.firecracker);
+  return vmAlive(runtime, state);
 }
 async function syncInMicroVm(input) {
   const { runtime, job } = input;
@@ -549,7 +639,7 @@ function microVmJudgeEnvironment(input) {
   const state = job.microvm;
   const agentUser = state.agentUser ?? ADDED_USER;
   const needsVm = () => {
-    if (state.firecracker !== void 0 && !isRunning(runtime, state)) throw new Error("the build's microVM is gone");
+    if ((state.firecracker !== void 0 || state.jailed !== void 0) && !isRunning(runtime, state)) throw new Error("the build's microVM is gone");
   };
   return {
     stop: async () => {
@@ -681,8 +771,9 @@ async function startCheckMicroVm(input) {
   };
   const links = vsockLinks({ destinations: config.build?.destinations?.length ?? 0, builtIns: false });
   const configPath = join(buildDir2, "vm.json");
+  const helper = await helperFor(runtime, (line) => log.line(`${tag} ${line}`));
   try {
-    linkVsockSockets({ buildDir: buildDir2, vsockPath: state.vsockPath, links });
+    if (helper === void 0) linkVsockSockets({ buildDir: buildDir2, vsockPath: state.vsockPath, links });
     await createBuildDisk({ host: vm.rootfs, runnerDir: runnerDirPath, bytes: limits.diskBytes, dest: state.buildDisk, memoryBytes: limits.memoryBytes });
     writeFileSync(
       configPath,
@@ -697,24 +788,34 @@ async function startCheckMicroVm(input) {
     return fail(`the check environment's disk and machine could not be made: ${describeCallFailure(err)}`);
   }
   if (abandoned()) return fail(ABANDONED);
-  try {
-    state.cgroup = vm.cgroup.create(buildId, limits.memoryBytes);
-  } catch (err) {
-    return fail(`the check environment's memory limit could not be set: ${describeCallFailure(err)}`);
-  }
-  if (state.cgroup !== void 0) input.save(state);
-  const boot = async () => {
+  if (helper === void 0) {
     try {
-      state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath, cgroup: state.cgroup });
+      state.cgroup = vm.cgroup.create(buildId, limits.memoryBytes);
     } catch (err) {
-      return `Firecracker did not start: ${describeCallFailure(err)}`;
+      return fail(`the check environment's memory limit could not be set: ${describeCallFailure(err)}`);
+    }
+    if (state.cgroup !== void 0) input.save(state);
+  }
+  const boot = async () => {
+    if (helper !== void 0) {
+      try {
+        await startJailedInto(state, { client: helper, kind: "check", kernel: assets.kernel, rootfs: state.rootfs, sockets: links.map((link) => link.socket) }, () => input.save(state));
+      } catch (err) {
+        return `the microVM did not start under the jailer: ${describeCallFailure(err)}`;
+      }
+    } else {
+      try {
+        state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath, cgroup: state.cgroup });
+      } catch (err) {
+        return `Firecracker did not start: ${describeCallFailure(err)}`;
+      }
+      input.save(state);
     }
-    input.save(state);
     if (abandoned()) return ABANDONED;
     const ready = await waitForAgent(state.vsockPath, { attempts: BOOT_ATTEMPTS, delayMs: BOOT_POLL_MS, sleep: runtime.sleep });
     if (!ready) {
-      const why = vm.firecracker.alive(state.firecracker) ? "its exec agent did not answer" : "it exited before its exec agent answered";
-      return `the microVM did not start: ${why}; its console is in ${consolePath}`;
+      const why = vmAlive(runtime, state) ? "its exec agent did not answer" : "it exited before its exec agent answered";
+      return `the microVM did not start: ${why}; ${consoleNote(state, consolePath)}`;
     }
     if (built.docker === true) return waitForDocker(runtime, state, agentUser, () => /* @__PURE__ */ new Date());
     return void 0;
@@ -740,7 +841,8 @@ async function startCheckMicroVm(input) {
       },
       restart: async () => {
         try {
-          await vm.firecracker.stop(state.firecracker);
+          if (state.jailed !== void 0) await stopJailed(vm.helper, state);
+          else await vm.firecracker.stop(state.firecracker);
           rmSync(state.vsockPath, { force: true });
           if (await boot() !== void 0) return false;
           if (evalInput.delivered) await deliverEvalInput();
@@ -754,6 +856,10 @@ async function startCheckMicroVm(input) {
 }
 async function stopBuildMicroVm(runtime, state, jobDir) {
   await copyHookErrors(runtime, state, jobDir);
+  if (state.jailed !== void 0) {
+    await stopJailed(runtime.vm.helper, state);
+    return;
+  }
   if (state.firecracker === void 0) return;
   await runtime.vm.firecracker.stop(state.firecracker);
   if (runtime.vm.firecracker.alive(state.firecracker)) throw new Error(`the microVM (pid ${state.firecracker.pid}) is still running after it was stopped`);
@@ -761,6 +867,13 @@ async function stopBuildMicroVm(runtime, state, jobDir) {
 async function cleanupMicroVm(runtime, state, jobDir) {
   const failures = [];
   if (jobDir !== void 0) await copyHookErrors(runtime, state, jobDir);
+  if (state.jailed !== void 0) {
+    try {
+      await stopJailed(runtime.vm.helper, state);
+    } catch (err) {
+      failures.push(describeCallFailure(err));
+    }
+  }
   if (state.firecracker !== void 0) {
     try {
       await runtime.vm.firecracker.stop(state.firecracker);
@@ -786,6 +899,8 @@ async function cleanupMicroVm(runtime, state, jobDir) {
 }
 async function stopOrphanedMicroVms(input) {
   const stopped = [];
+  const report = (line) => input.onError?.(line);
+  const jailedByJobs = [];
   for (const { job } of input.jobs) {
     const states = [job.microvm, job.checkMicrovm].filter((state) => state !== void 0);
     if (states.length === 0) continue;
@@ -798,12 +913,38 @@ async function stopOrphanedMicroVms(input) {
       while (isSameProcess(job.pid, job.start) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 10));
     }
     for (const state of states) {
+      if (state.jailed !== void 0) jailedByJobs.push(state.jailed.unit);
       if (state.firecracker !== void 0 && input.runtime.vm.firecracker.alive(state.firecracker)) {
-        await input.runtime.vm.firecracker.stop(state.firecracker);
-        stopped.push(state.buildId);
+        try {
+          await input.runtime.vm.firecracker.stop(state.firecracker);
+          stopped.push(state.buildId);
+        } catch (err) {
+          report(`the microVM of build ${state.buildId} (pid ${state.firecracker.pid}) was not stopped: ${describeCallFailure(err)}`);
+        }
       }
     }
   }
+  const probe = await input.runtime.vm.helper.probe();
+  if (!probe.ok) {
+    if (jailedByJobs.length > 0) report(`the units ${jailedByJobs.join(", ")} could not be stopped, because there is no helper to ask: ${probe.detail}`);
+    return stopped;
+  }
+  let builds;
+  try {
+    builds = await probe.client.list();
+  } catch (err) {
+    report(`the helper's list of builds could not be read: ${describeCallFailure(err)}`);
+    return stopped;
+  }
+  for (const build of builds) {
+    try {
+      await probe.client.stop(build);
+    } catch (err) {
+      report(`the unit of build ${build} was not stopped: ${describeCallFailure(err)}`);
+      continue;
+    }
+    if (!stopped.includes(build)) stopped.push(build);
+  }
   return stopped;
 }
 function provisionEnvironment(base, input) {
@@ -2468,9 +2609,9 @@ async function finishJob(job, jobDirPath, outcome, config, deps, ending) {
     }
   }
   let outOfMemory;
-  if (vmBuild?.state.cgroup !== void 0 && outcome !== void 0 && outcome !== "ok" && ending?.reason === void 0) {
+  if ((vmBuild?.state.cgroup !== void 0 || vmBuild?.state.jailed !== void 0) && outcome !== void 0 && outcome !== "ok" && ending?.reason === void 0) {
     try {
-      if (vmBuild.runtime.vm.cgroup.oomKills(vmBuild.state.cgroup) > 0) {
+      if (await microVmOomKills(vmBuild.runtime, vmBuild.state) > 0) {
         outOfMemory = outOfMemoryReason(config.build?.memory);
       }
     } catch (err) {
@@ -2739,8 +2880,15 @@ function unfinishedJobs(jobsDirPath) {
 function isContainerTracked(job) {
   return job.container?.tracking === "container";
 }
+function isReadable(job) {
+  return readsJobState(job, READ_JOB_STATE_FORMATS);
+}
+function listUnreadableJobs(jobsDirPath) {
+  return unfinishedJobs(jobsDirPath).flatMap(({ dirPath, job }) => isReadable(job) ? [] : [{ dirPath, job, format: jobStateFormatOf(job) }]);
+}
 function listTrackedJobs(jobsDirPath) {
   return unfinishedJobs(jobsDirPath).flatMap(({ dirPath, job }) => {
+    if (!isReadable(job)) return [];
     const tracking = job.container?.tracking;
     if (tracking === void 0) return [];
     if (tracking === "container" && inTeardown(job)) return [];
@@ -2749,12 +2897,13 @@ function listTrackedJobs(jobsDirPath) {
 }
 function listAdoptableJobs(jobsDirPath) {
   return unfinishedJobs(jobsDirPath).filter(
-    ({ job }) => job.microvm === void 0 && job.pid !== void 0 && job.start !== void 0 && isSameProcess(job.pid, job.start)
+    ({ job }) => isReadable(job) && job.microvm === void 0 && job.pid !== void 0 && job.start !== void 0 && isSameProcess(job.pid, job.start)
   );
 }
 async function recoverLostJobs(jobsDirPath, config, deps) {
   const recovered = [];
   for (const { dirPath, job } of unfinishedJobs(jobsDirPath)) {
+    if (!isReadable(job)) continue;
     const tracking = job.container?.tracking;
     if (tracking !== void 0 && tracking !== "container") {
       recovered.push(await finishJob(job, dirPath, "interrupted", config, deps, { reason: UNKNOWN_TRACKING_REASON }));
@@ -2928,4 +3077,4 @@ async function stopSender(input) {
   }
 }
 
-export { ALREADY_RELEASED, AttemptLogBook, EXIT_CODE_FILE, RENEW_INTERVAL_SECONDS, appendCommandLog, commandLogOffset, deliverCommitHooks, describeHookEnd, execArgv, execCommandLine, finishJob, hookLimitsFor, hostCommandEnvironment, hostEnvironment, isContainerTracked, isGroupAlive, isIdle, isTimedOut, isUnfinished, jobEnv, judgeProbe, listAdoptableJobs, listTrackedJobs, listenOnBroker, microVmCommandLine, needsRenew, outcomeFromExitCode, probeCommand, provisionEnvironment, provisionMicroVm, provisionProcess, readCpuUsec, readProvisionOut, recoverLostJobs, releaseLease, renewLease, resolveHostBuild, restartSender, retryFailedReleases, runCommand, runHook, setStage, startHostServices, startSender, stopOrphanedMicroVms, unfinishedJobs, workdirProblem };
+export { ALREADY_RELEASED, AttemptLogBook, EXIT_CODE_FILE, RENEW_INTERVAL_SECONDS, appendCommandLog, commandLogOffset, deliverCommitHooks, describeHookEnd, execArgv, execCommandLine, finishJob, hookLimitsFor, hostCommandEnvironment, hostEnvironment, inTeardown, isContainerTracked, isGroupAlive, isIdle, isReadable, isTimedOut, isUnfinished, jobEnv, judgeProbe, listAdoptableJobs, listTrackedJobs, listUnreadableJobs, listenOnBroker, microVmCommandLine, needsRenew, outcomeFromExitCode, probeCommand, provisionEnvironment, provisionMicroVm, provisionProcess, readCpuUsec, readProvisionOut, recoverLostJobs, releaseLease, renewLease, resolveHostBuild, restartSender, retryFailedReleases, runCommand, runHook, setStage, startHostServices, startSender, stopOrphanedMicroVms, unfinishedJobs, workdirProblem };

package/dist/{chunk-WH2QV3UL.js → chunk-4S4VBDSO.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { runEmit } from './chunk-WX2WEERU.js';
 import { installStarterPack } from './chunk-VJBFQP3H.js';
-import { resolveGitCommonDir, defaultGitRunner } from './chunk-E4OUL7ZP.js';
+import { resolveGitCommonDir, defaultGitRunner } from './chunk-FXUVXSY2.js';
 import { addStdioMcpEntryIfAbsent, addDocsMcpEntryIfAbsent, DOCS_MCP_SERVER_NAME } from './chunk-YVZJ6GKF.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { AGENTS_MD_LAYOUT, declareAgentsMdLayout, linkClaudeSkills, SKILLS_LINK_PATH, describeSkillsLink, isAgentsMdLayout, holdsTodaysLayoutSources, discoverOuterlayerPaths } from './chunk-JKNYTNYD.js';

package/dist/{chunk-IDSHLKQA.js → chunk-5222PA6S.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { isVersion, compareVersions } from './chunk-TQMI335S.js';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-KF37SUDM.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'fs';
 import { join } from 'path';
 

package/dist/{chunk-V5Q3S4NM.js → chunk-6CNHXHI2.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
 import { DEFAULT_DASHBOARD } from './chunk-XSPA5ODY.js';
-import { cliFetch, resolveGatewayCredentials } from './chunk-FKXGQOF5.js';
+import { cliFetch, resolveGatewayCredentials } from './chunk-M4B6QKNZ.js';
 import { writeRepoConnection, findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { remoteLookupFailed } from './chunk-D4AMAEZ7.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';

package/dist/{chunk-LY2L3O2O.js → chunk-7OWPLRJR.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { EXEC_PORT } from './chunk-PDIM5T65.js';
+import { EXEC_PORT } from './chunk-XGJUNNXL.js';
 import { createConnection } from 'net';
 
 createRequire(import.meta.url);

package/dist/{chunk-HHXBOTRO.js → chunk-ATGHVEU4.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { currentLink } from './chunk-VV7ZD5LR.js';
+import { currentLink } from './chunk-QMQC6JCO.js';
 import { readFileSync, statSync, chmodSync, mkdirSync, writeFileSync, renameSync, rmSync, existsSync, lstatSync, accessSync, constants, realpathSync } from 'fs';
 import { randomBytes } from 'crypto';
 import { join, dirname, delimiter, resolve } from 'path';

package/dist/{chunk-TTLVQZSH.js → chunk-AXPCGD46.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { claimPidFile, RunnerAlreadyRunningError, releasePidFile } from './chunk-FWEWFW3F.js';
+import { claimPidFile, RunnerAlreadyRunningError, releasePidFile } from './chunk-DEBOL6ON.js';
 import { startTimeOf } from './chunk-JBJTC3UU.js';
-import { CLAUDE_CODE_VERSION, NODE_IMAGE, DEFAULT_BASE_IMAGE, RecipeError, locateRecipe, readRecipe, assertBuildable, TINI_VERSION, GH_VERSION, writeSanitizedRecipe, classifyProperties, GH_SHA256, TINI_SHA256, SANITIZED_NAME } from './chunk-3W333NFO.js';
-import { RUNNER_DIR_MODE, repoCacheDir, imagesDir, attemptStamp, runnerDir, rootfsPathFor, RUNNER_FILE_MODE } from './chunk-KF37SUDM.js';
-import { withGitConfig, tokenHeader, PROXY_WARNING_FLAG } from './chunk-BN3CSI7S.js';
-import { RELAY_ID, RELAY_USER } from './chunk-GISNHSYL.js';
+import { CLAUDE_CODE_VERSION, NODE_IMAGE, DEFAULT_BASE_IMAGE, RecipeError, locateRecipe, readRecipe, assertBuildable, TINI_VERSION, GH_VERSION, writeSanitizedRecipe, classifyProperties, GH_SHA256, TINI_SHA256, SANITIZED_NAME } from './chunk-RGW7ERF3.js';
+import { RUNNER_DIR_MODE, repoCacheDir, imagesDir, attemptStamp, runnerDir, rootfsPathFor, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
+import { withGitConfig, tokenHeader, PROXY_WARNING_FLAG } from './chunk-2K3TCQHW.js';
+import { RELAY_ID, RELAY_USER } from './chunk-JGD5TWQ2.js';
 import { mkdirSync, rmSync, existsSync, mkdtempSync, cpSync, readFileSync, writeFileSync, readdirSync, lstatSync, readlinkSync } from 'fs';
 import { tmpdir } from 'os';
 import { dirname, join } from 'path';

package/dist/{chunk-FWEWFW3F.js → chunk-DEBOL6ON.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { isSameProcess } from './chunk-JBJTC3UU.js';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-KF37SUDM.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { existsSync, readFileSync, rmSync, mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 

package/dist/{chunk-E4OUL7ZP.js → chunk-FXUVXSY2.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { removeRetiredSkills } from './chunk-MQ743JX3.js';
-import { defaultFetch, resolveGatewayCredentials } from './chunk-FKXGQOF5.js';
+import { defaultFetch, resolveGatewayCredentials } from './chunk-M4B6QKNZ.js';
 import { appendContextProvenance } from './chunk-ZJSNLVCE.js';
 import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { writeDegraded, writeSourceCache, SOURCE_CACHE_TTL_RETRY_MS, writeContextManifest, SOURCE_CACHE_TTL_SUCCESS_MS, readSourceCache, isSourceCacheFresh, clearDegraded } from './chunk-YQR6E6OV.js';
 import { normalizeRepoName, parseOuterlayerConfig, classifyTree, emitTree } from './chunk-RKOTJQVG.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { withTokenHeader } from './chunk-BN3CSI7S.js';
+import { withTokenHeader } from './chunk-2K3TCQHW.js';
 import { execFileSync } from 'child_process';
 import { existsSync, mkdirSync, writeFileSync, chmodSync, lstatSync, readFileSync, copyFileSync } from 'fs';
 import { isAbsolute, join, dirname } from 'path';

package/dist/{chunk-BUBCPP3F.js → chunk-HBLLZLOH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { autoConnect, detectActiveSession } from './chunk-F2W2IYNP.js';
-import { defaultFetch, unauthorizedMessage, resolveGatewayCredentials } from './chunk-FKXGQOF5.js';
+import { autoConnect, detectActiveSession } from './chunk-HWEIFHSW.js';
+import { defaultFetch, unauthorizedMessage, resolveGatewayCredentials } from './chunk-M4B6QKNZ.js';
 import { resolveRepoIdentity } from './chunk-D4AMAEZ7.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';

package/dist/{chunk-F2W2IYNP.js → chunk-HWEIFHSW.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { fetchFactories, selectFactory, saveFactoryConnection, autoConnectedLine } from './chunk-V5Q3S4NM.js';
-import { resolveGatewayCredentials } from './chunk-FKXGQOF5.js';
+import { fetchFactories, selectFactory, saveFactoryConnection, autoConnectedLine } from './chunk-6CNHXHI2.js';
+import { resolveGatewayCredentials } from './chunk-M4B6QKNZ.js';
 import { findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { resolveRepoIdentity } from './chunk-D4AMAEZ7.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';

package/dist/{chunk-F7Y2USIM.js → chunk-IDJIWKTY.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { launchRefusalForSession } from './chunk-ESVW4MJY.js';
-import { autoConnect, detectActiveSession } from './chunk-F2W2IYNP.js';
+import { autoConnect, detectActiveSession } from './chunk-HWEIFHSW.js';
 import { acquireSpoolLockAt } from './chunk-BUP5N3X6.js';
-import { resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-FKXGQOF5.js';
+import { resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-M4B6QKNZ.js';
 import { resolveRepoIdentity } from './chunk-D4AMAEZ7.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { launchedItemForSession } from './chunk-T2Q7ISPE.js';

package/dist/{chunk-DG2ULWM6.js → chunk-IGRRD7PX.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { builtinKind } from './chunk-D7X5ITVT.js';
+import { builtinKind } from './chunk-JWRX5ZTT.js';
 import { parseSize } from './chunk-7RQ73DLO.js';
-import { runnerDir } from './chunk-KF37SUDM.js';
+import { runnerDir } from './chunk-ZI2ZVWKT.js';
 import { dirname } from 'path';
 import { spawnSync } from 'child_process';
 
@@ -16,16 +16,19 @@ function escapeUnitPath(path) {
   return path.replace(/%/g, "%%").replace(/ /g, "\\x20");
 }
 function runnerUnit(unit) {
+  const helperService = unit.helper === void 0 ? void 0 : `${unit.helper.unit}.service`;
   return `${UNIT_MARKER}
 [Unit]
 Description=OuterLayer runner
-After=network-online.target${unit.docker ? " docker.service" : ""}
+After=network-online.target${unit.docker ? " docker.service" : ""}${helperService === void 0 ? "" : ` ${helperService}`}
 Wants=network-online.target
-${unit.docker ? "Requires=docker.service\n" : ""}
+${helperService === void 0 ? "" : `Wants=${helperService}
+`}${unit.docker ? "Requires=docker.service\n" : ""}
 [Service]
 User=${unit.user}
 ExecStart=${unit.execStart}
-EnvironmentFile=-${escapeUnitPath(`${unit.configDir}/runner.env`)}
+${unit.helper === void 0 ? "" : `Environment=OUTERLAYER_HELPER_SOCKET=${unit.helper.socket}
+`}EnvironmentFile=-${escapeUnitPath(`${unit.configDir}/runner.env`)}
 Restart=on-failure
 RestartForceExitStatus=75
 RestartSec=30
@@ -143,7 +146,8 @@ function installService(request, deps) {
     configDir: dirname(request.configPath),
     execStart: request.execStart,
     timeLimitMinutes: request.timeLimitMinutes,
-    docker: kind === "container" || kind === "vm" || builtinKind(request.hooks.cleanup) === "container" || builtinKind(request.hooks.cleanup) === "vm"
+    docker: kind === "container" || kind === "vm" || builtinKind(request.hooks.cleanup) === "container" || builtinKind(request.hooks.cleanup) === "vm",
+    ...request.helperSocket !== void 0 && request.helperUnit !== void 0 ? { helper: { unit: request.helperUnit, socket: request.helperSocket } } : {}
   });
   if (request.print === true) return outcome(true, "printed", [], unit);
   if (own) return outcome(false, "refused", [OWN_HOOKS]);
@@ -274,4 +278,4 @@ function uninstallService(request, deps) {
   return outcome(true, "removed", lines);
 }
 
-export { DEFAULT_UNIT_NAME, RUNNER_RESERVE_BYTES, VM_SERVICE_NAME, checkFit, installService, realTaskScheduler, uninstallService, unitPathFor };
+export { DEFAULT_UNIT_NAME, RUNNER_RESERVE_BYTES, UNIT_MARKER, VM_SERVICE_NAME, checkFit, installService, realTaskScheduler, uninstallService, unitPathFor };

package/dist/{chunk-GISNHSYL.js → chunk-JGD5TWQ2.js}

@@ -30,12 +30,14 @@ var UNKNOWN_TRANSPORT_REASON = "the runner cannot tell how this build reaches it
 var COMMAND_LOST_REASON = "the build's command ended without recording an exit code";
 var CONTAINER_STOPPED_REASON = "the build's container stopped while no runner was managing it";
 var UNKNOWN_TRACKING_REASON = "the runner cannot tell how this build is tracked";
+var DOCKER_DESKTOP_REASON = "Docker Desktop is accepted only for a runner in the runner image, so container builds here need Docker Engine: install it (on Windows, inside WSL2), run the runner image, or use builtin:process";
 var RUNNER_WORDED_REASONS = /* @__PURE__ */ new Set([
   MALFORMED_REASON,
   UNKNOWN_TRANSPORT_REASON,
   COMMAND_LOST_REASON,
   CONTAINER_STOPPED_REASON,
-  UNKNOWN_TRACKING_REASON
+  UNKNOWN_TRACKING_REASON,
+  DOCKER_DESKTOP_REASON
 ]);
 
-export { COMMAND_LOST_REASON, CONTAINER_STOPPED_REASON, JOIN_DIR, JOIN_SOCKET, JOIN_WAIT_MS, MALFORMED_REASON, MAX_MALFORMED_SESSIONS, MAX_OPEN_STREAMS, RELAY_ID, RELAY_USER, RUNNER_WORDED_REASONS, SESSION_WINDOW, STREAM_WINDOW, TARGET_CLAUDE, TARGET_GATEWAY, TARGET_LEASE, TARGET_TUNNEL, UNKNOWN_TRACKING_REASON, UNKNOWN_TRANSPORT_REASON, destinationTarget, targetOfPath };
+export { COMMAND_LOST_REASON, CONTAINER_STOPPED_REASON, DOCKER_DESKTOP_REASON, JOIN_DIR, JOIN_SOCKET, JOIN_WAIT_MS, MALFORMED_REASON, MAX_MALFORMED_SESSIONS, MAX_OPEN_STREAMS, RELAY_ID, RELAY_USER, RUNNER_WORDED_REASONS, SESSION_WINDOW, STREAM_WINDOW, TARGET_CLAUDE, TARGET_GATEWAY, TARGET_LEASE, TARGET_TUNNEL, UNKNOWN_TRACKING_REASON, UNKNOWN_TRANSPORT_REASON, destinationTarget, targetOfPath };