@outerlayer/cli 0.26.3 → 0.27.0

package/dist/{chunk-J7BXZLSO.js → chunk-WSYXLLA5.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { WorkCommandError, postJson } from './chunk-UKCNOAO6.js';
-import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-W3NVHOCS.js';
-import { signingFetchFor } from './chunk-QRZLUUNN.js';
-import { unsupportedLayout, layoutRefusalReason, composeDelivery } from './chunk-VPEGE3QZ.js';
+import { WorkCommandError, postJson } from './chunk-55GNQPO6.js';
+import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-BPKO76QR.js';
+import { signingFetchFor } from './chunk-BWH36FOC.js';
+import { unsupportedLayout, layoutRefusalReason, composeDelivery } from './chunk-6TRNCUM4.js';
 import { SHIM_SCRIPT, GOVERNANCE_VARIABLE } from './chunk-HCVLP7XA.js';
 import { readDegraded, readContextManifest, readSourceCache } from './chunk-YQR6E6OV.js';
-import { signerFor } from './chunk-F6DIHHBS.js';
-import { SHIM_DIR, stagedContextDir, contextHomeDir, deliveryDir } from './chunk-L4CW6LZQ.js';
-import { fstatSync, mkdirSync, writeFileSync, chmodSync, rmSync, lstatSync } from 'fs';
+import { signerFor } from './chunk-Y4OKEFAX.js';
+import { SHIM_DIR, stagedContextDir, contextHomeDir, deliveryDir, keptContextDir } from './chunk-RHAGBUL5.js';
+import { fstatSync, mkdirSync, writeFileSync, chmodSync, rmSync, cpSync, readFileSync, existsSync, lstatSync } from 'fs';
 import { relative, join, dirname } from 'path';
 
 createRequire(import.meta.url);
@@ -464,6 +464,27 @@ async function controlPlaneAccess(ask, candidates, repository, log, tag) {
 function removeStagedContext(buildDir) {
   rmSync(stagedContextDir(buildDir), { recursive: true, force: true });
 }
+function keepStagedContext(staged, jobDir) {
+  const kept = keptContextDir(jobDir);
+  rmSync(kept, { recursive: true, force: true });
+  const tree = join(staged.dir, "tree");
+  cpSync(tree, join(kept, "tree"), { recursive: true, verbatimSymlinks: true, filter: (source) => source !== join(tree, ".git") });
+  writeFileSync(join(kept, "kept.json"), JSON.stringify({ schemaVersion: 1, repository: staged.repository, sha: staged.sha }) + "\n");
+}
+function keptContextTree(jobDir, governing) {
+  const kept = keptContextDir(jobDir);
+  let record;
+  try {
+    record = JSON.parse(readFileSync(join(kept, "kept.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (governing === void 0 || record.sha !== governing.commit || String(record.repository).toLowerCase() !== governing.repository.toLowerCase()) return void 0;
+  return existsSync(join(kept, "tree")) ? join(kept, "tree") : void 0;
+}
+function removeKeptContext(jobDir) {
+  rmSync(keptContextDir(jobDir), { recursive: true, force: true });
+}
 
 // src/runner/governing-source.ts
 var unavailable2 = (why) => ({ ok: false, reason: `context_unavailable: ${why}` });
@@ -494,4 +515,4 @@ async function imageTargetFor(input) {
   return { ok: true, repository: resolved.source.repository, pinned: { commit: resolved.source.sha, ref: resolved.source.ref } };
 }
 
-export { BuildTokens, classifyRefusal, commandWithShim, controlPlaneTokenFailure, createRunnerLog, describeCallFailure, formatClock, formatDuration, imageTargetFor, logStamp, pinnedSourceOf, refusalCode, relativeToRunner, removeStagedContext, resolveGoverningSource, retrySend, shimScript, shortClaim, stageGovernedContext };
+export { BuildTokens, classifyRefusal, commandWithShim, controlPlaneTokenFailure, createRunnerLog, describeCallFailure, formatClock, formatDuration, imageTargetFor, keepStagedContext, keptContextTree, logStamp, pinnedSourceOf, refusalCode, relativeToRunner, removeKeptContext, removeStagedContext, resolveGoverningSource, retrySend, shimScript, shortClaim, stageGovernedContext };

package/dist/{chunk-WX2WEERU.js → chunk-WUL2OP5A.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { retiredSkillPaths, removeRetiredSkills } from './chunk-MQ743JX3.js';
+import { isAgentsMdLayout, discoverOuterlayerPaths, isForeignTree, toRepoRelative } from './chunk-LOKSLO25.js';
+import { retiredSkillPaths, removeRetiredSkills } from './chunk-MHX7YX7Y.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-7OUOLGUV.js';
 import { C } from './chunk-ANPNT6PM.js';
-import { isAgentsMdLayout, discoverOuterlayerPaths, isForeignTree, toRepoRelative } from './chunk-JKNYTNYD.js';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { emitTree, generatedHeaderSource, parseOuterlayerConfig, classifyTree } from './chunk-RKOTJQVG.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, unlinkSync, rmdirSync, readdirSync } from 'fs';

package/dist/{chunk-ZPXI7LMG.js → chunk-WVDP6HVZ.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { isPlaceholderCommand } from './chunk-W7LGHNXT.js';
-import { describeCallFailure } from './chunk-J7BXZLSO.js';
-import { WorkCommandError, getJson } from './chunk-UKCNOAO6.js';
+import { isPlaceholderCommand } from './chunk-QIVOTQOQ.js';
+import { describeCallFailure } from './chunk-WSYXLLA5.js';
+import { WorkCommandError, getJson } from './chunk-55GNQPO6.js';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
-import { builtinKind } from './chunk-JWRX5ZTT.js';
-import { signerFor } from './chunk-F6DIHHBS.js';
-import { CLAUDE_CREDENTIAL_VARIABLES, claudeCredential } from './chunk-2K3TCQHW.js';
+import { builtinKind } from './chunk-EPPIISRD.js';
+import { signerFor } from './chunk-Y4OKEFAX.js';
+import { CLAUDE_CREDENTIAL_VARIABLES, claudeCredential } from './chunk-2I3LIRZP.js';
 
 createRequire(import.meta.url);
 

package/dist/{chunk-MXTN35XN.js → chunk-XBPUTQ7E.js}

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

package/dist/{chunk-UNF7MWEL.js → chunk-XS3FDWSZ.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RELAY_PORT, BUILD_HOME } from './chunk-2K3TCQHW.js';
+import { RELAY_PORT, BUILD_HOME } from './chunk-2I3LIRZP.js';
 import { createServer, connect } from 'net';
 
 createRequire(import.meta.url);

package/dist/{chunk-VJBFQP3H.js → chunk-XZ6Q6ZNR.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { resolvePackRoot, OUTERLAYER_SKILLS_BASE, loadTemplateFiles, AGENTS_SKILLS_BASE, loadMaintainedFiles, rewriteSkillPaths, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS, MACHINE_SKILL_PATH } from './chunk-7OUOLGUV.js';
 import { C } from './chunk-ANPNT6PM.js';
-import { resolvePackRoot, OUTERLAYER_SKILLS_BASE, loadTemplateFiles, loadMaintainedFiles, rewriteSkillPaths, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-HBISTTG3.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { linkedAgentsPath } from './chunk-VWFOKRYS.js';
 import { resolvePackageVersion } from './chunk-RA3O54FC.js';
@@ -31,7 +31,7 @@ function installStarterPack(opts) {
   const linked = base.startsWith(".agents/") ? linkedAgentsPath(opts.repoRoot) : void 0;
   if (linked !== void 0) throw new StarterPackError(`${linked} is a link, and a write there would land outside the repository; replace it with a folder and run this again`);
   const templateFiles = loadTemplateFiles(packRoot, version, base);
-  const maintainedFiles = loadMaintainedFiles(packRoot, version, base);
+  const maintainedFiles = base === AGENTS_SKILLS_BASE ? [] : loadMaintainedFiles(packRoot, version, base);
   const validatorFiles = VALIDATOR_FILES.map(({ name }) => ({
     path: `${VALIDATORS_DIR}/${name}`,
     content: rewriteSkillPaths(readFileSync(join(packRoot, "validators", name), "utf8"), base)
@@ -94,9 +94,13 @@ function formatStarterPackOutput(result) {
       result.kept.includes(skill) ? `  ${C.dim}kept${C.reset} ${skillDir(skill, base)}/ ${C.dim}(already exists, left exactly as it is)${C.reset}` : `  ${skillFile(skill, base)}`
     );
   }
-  const rewriter = base === OUTERLAYER_SKILLS_BASE ? "emit" : "`init --update`";
-  lines.push("", `Rewritten on every ${rewriter} \u2014 edits are overwritten by the installed CLI:`);
-  for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill, base)}`);
+  if (base === OUTERLAYER_SKILLS_BASE) {
+    lines.push("", "Rewritten on every emit \u2014 edits are overwritten by the installed CLI:");
+    for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill, base)}`);
+  } else {
+    lines.push("", `Kept once per machine, not in this repository. \`${cliInvocation()} init\` installs them, and every later command keeps them at its own version:`);
+    for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill, MACHINE_SKILL_PATH)}`);
+  }
   lines.push(
     "",
     result.policy === "written" ? `${C.green}\u2713${C.reset} Wrote ${POLICY_PATH} (review required)` : `${C.dim}${POLICY_PATH} already exists \u2014 left as it is${C.reset}`,

package/dist/{chunk-F6DIHHBS.js → chunk-Y4OKEFAX.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { hostKeyPath, runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-L4CW6LZQ.js';
+import { hostKeyPath, runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-RHAGBUL5.js';
 import { generateKeyPairSync, createPrivateKey, createPublicKey, sign } from 'crypto';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 

package/dist/{chunk-XDHYZWEK.js → chunk-Y7ZCHBYB.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { LiveUploader } from './chunk-2AKDF6C2.js';
-import { spoolDir } from './chunk-FO7F6QSV.js';
+import { LiveUploader } from './chunk-VS27BP3E.js';
+import { spoolDir } from './chunk-DJHNEGNM.js';
 import { CaptureDaemon } from './chunk-QE3UQAHK.js';
 import { parseWorkItemEnv } from './chunk-T2Q7ISPE.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';

package/dist/chunk-YB3CSYXX.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { spawn } from 'child_process';
+
+createRequire(import.meta.url);
+var FD_STORE_ENV = "OUTERLAYER_FD_STORE";
+var MIN_SYSTEMD = 254;
+var LISTEN_FDS_START = 3;
+var FD_SLOTS_PER_BUILD = 64;
+function fdName(buildId, socket) {
+  return `ol-${buildId}-${socket}`;
+}
+function listenFdOf(server) {
+  const handle = server._handle;
+  return typeof handle?.fd === "number" && handle.fd >= 0 ? handle.fd : void 0;
+}
+function parseListenFds(env, pid) {
+  const found = /* @__PURE__ */ new Map();
+  if (env.LISTEN_PID !== String(pid)) return found;
+  const count = Number(env.LISTEN_FDS);
+  if (!Number.isInteger(count) || count <= 0) return found;
+  const names = (env.LISTEN_FDNAMES ?? "").split(":");
+  for (let index = 0; index < count; index++) {
+    const name = names[index];
+    if (name !== void 0 && name !== "" && name !== "stored") found.set(name, LISTEN_FDS_START + index);
+  }
+  return found;
+}
+function listenOnFd(server, fd) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen({ fd }, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
+function run(spawnFn, command, args, fd) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let child;
+    try {
+      child = spawnFn(command, args, { stdio: ["ignore", "pipe", "pipe", ...fd === void 0 ? [] : [fd]] });
+    } catch (err) {
+      resolve({ status: null, stdout, stderr: err instanceof Error ? err.message : String(err) });
+      return;
+    }
+    child.stdout?.on("data", (chunk) => stdout += chunk.toString("utf8"));
+    child.stderr?.on("data", (chunk) => stderr += chunk.toString("utf8"));
+    child.on("error", (err) => resolve({ status: null, stdout, stderr: err.message }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
+  });
+}
+function systemdVersion(ran) {
+  const match = /^systemd (\d+)/.exec(ran.stdout);
+  return ran.status === 0 && match !== null ? Number(match[1]) : void 0;
+}
+function realFdStorePort(options = {}) {
+  const env = options.env ?? process.env;
+  const pid = options.pid ?? process.pid;
+  const command = options.command ?? "systemd-notify";
+  const spawnFn = options.spawn ?? spawn;
+  let inherited;
+  let version;
+  return {
+    async status() {
+      if (env.NOTIFY_SOCKET === void 0 || env.NOTIFY_SOCKET === "") return { ok: false, reason: "NOTIFY_SOCKET is not set, so this runner was not started by a service that accepts descriptors" };
+      const size = Number(env[FD_STORE_ENV]);
+      if (!Number.isInteger(size) || size <= 0) return { ok: false, reason: `${FD_STORE_ENV} is not set, so the service's unit keeps no descriptor store` };
+      version ??= run(spawnFn, command, ["--version"]).then(systemdVersion);
+      const found = await version;
+      if (found === void 0) return { ok: false, reason: `${command} could not be run, so no descriptor can be stored` };
+      if (found < MIN_SYSTEMD) return { ok: false, reason: `systemd ${found} cannot store a descriptor sent from a child process: it needs systemd ${MIN_SYSTEMD} or later` };
+      return { ok: true };
+    },
+    async push(name, server) {
+      const fd = listenFdOf(server);
+      if (fd === void 0) throw new Error(`${name} has no descriptor to store`);
+      const ran = await run(spawnFn, command, [`--fd=${LISTEN_FDS_START}`, `--fdname=${name}`, "FDSTORE=1"], fd);
+      if (ran.status !== 0) throw new Error(`storing ${name} failed${ran.status === null ? "" : ` (exit ${ran.status})`}: ${ran.stderr.trim().split("\n")[0] ?? ""}`);
+    },
+    async remove(name) {
+      const ran = await run(spawnFn, command, [`--fdname=${name}`, "FDSTOREREMOVE=1"]);
+      if (ran.status !== 0) throw new Error(`removing ${name} from the store failed${ran.status === null ? "" : ` (exit ${ran.status})`}: ${ran.stderr.trim().split("\n")[0] ?? ""}`);
+    },
+    inherited() {
+      inherited ??= parseListenFds(env, pid);
+      return inherited;
+    },
+    listenOn: listenOnFd
+  };
+}
+
+export { FD_SLOTS_PER_BUILD, FD_STORE_ENV, fdName, realFdStorePort };

package/dist/{chunk-VHVFU6QU.js → chunk-YF56R4DV.js}

@@ -1,24 +1,25 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runnerImageVersion } from './chunk-665QWBNW.js';
-import { readDefaultBranchHead, cloneRepository, buildRepositoryImage } from './chunk-7LVF4E5V.js';
+import { keepStagedContext, describeCallFailure, controlPlaneTokenFailure, refusalCode, resolveGoverningSource, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, shimScript } from './chunk-WSYXLLA5.js';
+import { runnerImageVersion } from './chunk-M3MHHIUW.js';
+import { realFdStorePort } from './chunk-YB3CSYXX.js';
+import { readDefaultBranchHead, cloneRepository, buildRepositoryImage } from './chunk-24ID7EQ2.js';
 import { startTimeOf, isSameProcess } from './chunk-JBJTC3UU.js';
 import { currentCliBuild } from './chunk-OGFGZQA3.js';
-import { createDockerHost, builderSpec, runnerLabelValue, RUNNER_LABEL, BUILD_LABEL, prepareRunArgs, containerRunArgs, HASH_ARGV, parseProgramHash, JUDGE_PROGRAM, containerExecArgs, childEnvironment, JUDGE_DIR, JUDGE_REPORT, MAX_REPORT_BYTES, spawnRun } from './chunk-ZLEXMZFW.js';
-import { FIRECRACKER_VERSION, hostHelperPinned, firecrackerArch, MICROVM_ARCHES, RecipeError, DOCKER_FEATURE, CLAUDE_CODE_VERSION, GUEST_HELPER_SHA256, GUEST_ASSETS_BASE_URL, GUEST_KERNEL_SHA256, JAILER_BINARY_SHA256, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, GUEST_ASSETS_VERSION, DEFAULT_BASE_IMAGE } from './chunk-TSW4DGV2.js';
-import { execCapture } from './chunk-MXTN35XN.js';
-import { GUEST_CID } from './chunk-XLC7KEUV.js';
-import { describeCallFailure, controlPlaneTokenFailure, refusalCode, resolveGoverningSource, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, shimScript } from './chunk-J7BXZLSO.js';
-import { WorkCommandError } from './chunk-UKCNOAO6.js';
+import { createDockerHost, builderSpec, runnerLabelValue, RUNNER_LABEL, BUILD_LABEL, prepareRunArgs, containerRunArgs, HASH_ARGV, parseProgramHash, JUDGE_PROGRAM, containerExecArgs, childEnvironment, JUDGE_DIR, JUDGE_REPORT, MAX_REPORT_BYTES, spawnRun } from './chunk-JH2GQU5T.js';
+import { FIRECRACKER_VERSION, hostHelperPinned, firecrackerArch, MICROVM_ARCHES, RecipeError, DOCKER_FEATURE, CLAUDE_CODE_VERSION, GUEST_HELPER_SHA256, GUEST_ASSETS_BASE_URL, GUEST_KERNEL_SHA256, JAILER_BINARY_SHA256, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, GUEST_ASSETS_VERSION, DEFAULT_BASE_IMAGE } from './chunk-B6K7R5UY.js';
+import { execCapture } from './chunk-XBPUTQ7E.js';
+import { GUEST_CID } from './chunk-GLUKDQS4.js';
+import { WorkCommandError } from './chunk-55GNQPO6.js';
 import { hostAllowed } from './chunk-UXYLWVTQ.js';
-import { parseDuKilobytes } from './chunk-7RQ73DLO.js';
-import { sharedSkillNames, skillConflictMessage } from './chunk-VPEGE3QZ.js';
+import { readDu } from './chunk-YJLHUKYS.js';
+import { sharedSkillNames, skillConflictMessage } from './chunk-6TRNCUM4.js';
 import { versionAtLeast, MINIMUM_CLAUDE_VERSION } from './chunk-HCVLP7XA.js';
 import { setCustomScrubbers, setLocalIdentity, setRepoRoot, parseTranscript, scrubDeep, scrubText } from './chunk-QE3UQAHK.js';
 import { orderSessions, extractFacts, sessionsToTimeline } from './chunk-RKOTJQVG.js';
 import { downconvertSession } from './chunk-QZBXLLTV.js';
-import { vmAssetsDir, RUNNER_DIR_MODE, rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, deliveryDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, SHIM_DIR } from './chunk-L4CW6LZQ.js';
-import { repositoriesOf, primaryOf, RELAY_PORT, repositoryPath, CHECKOUT_DIR, lifecycleWorkdir, claudeCredential, buildEnvironment, startBuildServices, checkEnvironment, AGENT_CREDENTIAL_MISSING, checkoutPath, JOB_MOUNT } from './chunk-2K3TCQHW.js';
+import { vmAssetsDir, RUNNER_DIR_MODE, rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, deliveryDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, SHIM_DIR } from './chunk-RHAGBUL5.js';
+import { repositoriesOf, primaryOf, RELAY_PORT, repositoryPath, CHECKOUT_DIR, lifecycleWorkdir, claudeCredential, buildEnvironment, startBuildServices, checkEnvironment, AGENT_CREDENTIAL_MISSING, checkoutPath, JOB_MOUNT } from './chunk-2I3LIRZP.js';
 import { RELAY_USER, RELAY_ID, UNKNOWN_TRANSPORT_REASON, DOCKER_DESKTOP_REASON, MAX_MALFORMED_SESSIONS, MALFORMED_REASON, MAX_OPEN_STREAMS, STREAM_WINDOW, SESSION_WINDOW, targetOfPath } from './chunk-JGD5TWQ2.js';
 import { readFileSync, mkdirSync, existsSync, mkdtempSync, rmSync, chmodSync, truncateSync, writeFileSync, readdirSync, lstatSync, copyFileSync, accessSync, constants, statSync, rmdirSync, renameSync, unlinkSync, openSync, closeSync, createWriteStream, createReadStream } from 'fs';
 import { join, dirname, basename } from 'path';
@@ -210,6 +211,9 @@ function helperClient(socketPath, options = {}) {
     async list() {
       const reply = await ask(socketPath, { v: 1, op: "list" }, REQUEST_TIMEOUT_MS);
       return Array.isArray(reply.builds) ? reply.builds.map(String) : [];
+    },
+    async relink(build) {
+      await ask(socketPath, { v: 1, op: "relink", build }, REQUEST_TIMEOUT_MS);
     }
   };
 }
@@ -815,6 +819,13 @@ async function createBuildDisk(input) {
 function deleteBuildDisk(path) {
   rmSync(path, { force: true });
 }
+var clearBit = (bit) => `0b${"x".repeat(31 - bit)}0${"x".repeat(bit)}`;
+var CPU_TEMPLATE = {
+  cpuid_modifiers: [
+    { leaf: "0x1", subleaf: "0x0", flags: 0, modifiers: [{ register: "ecx", bitmap: clearBit(5) }] },
+    { leaf: "0x80000001", subleaf: "0x0", flags: 0, modifiers: [{ register: "ecx", bitmap: clearBit(2) }] }
+  ]
+};
 var MIB = 1024 ** 2;
 var INIT = "/opt/outerlayer/bin/outerlayer-guest";
 function machineConfig(limits2, paths) {
@@ -842,7 +853,8 @@ function machineConfig(limits2, paths) {
       { drive_id: "build", path_on_host: paths.buildDisk, is_root_device: false, is_read_only: false }
     ],
     "machine-config": { vcpu_count: limits2.cpus, mem_size_mib: Math.max(1, Math.floor(limits2.memoryBytes / MIB)), smt: false },
-    vsock: { guest_cid: GUEST_CID, uds_path: paths.vsock }
+    vsock: { guest_cid: GUEST_CID, uds_path: paths.vsock },
+    "cpu-config": CPU_TEMPLATE
   };
 }
 function firecrackerCommand(input) {
@@ -907,6 +919,7 @@ function createMicroVmPorts(over = {}) {
     firecracker: over.firecracker ?? createFirecrackerHost(),
     cgroup: over.cgroup ?? realCgroupPort(),
     helper: over.helper ?? realHelperPort(),
+    fdStore: over.fdStore ?? realFdStorePort(),
     exec: over.exec ?? execCapture
   };
 }
@@ -1048,6 +1061,11 @@ async function runBuildSteps(input) {
       const delivered = await deliver(input, staged);
       if (!delivered.ok) return delivered;
       controlPlane = { repository: staged.repository, commit: staged.sha };
+      try {
+        if (input.keepIn !== void 0) keepStagedContext(staged, input.keepIn);
+      } catch (err) {
+        log.error(`${tag} the governed context could not be kept for the host's checks: ${describeCallFailure(err)} \xB7 they fetch it again`);
+      }
       log.line(`${tag} governed context ${staged.sha.slice(0, 7)} delivered to ${deliveryDir(staged.repository, staged.sha)} (${staged.files.length} files)`);
     } finally {
       input.removeStagedContext();
@@ -2090,6 +2108,9 @@ var V4 = [
   ["private", "10.0.0.0/8"],
   ["private", "172.16.0.0/12"],
   ["private", "192.168.0.0/16"],
+  ["protocol-assignments", "192.0.0.0/24"],
+  ["benchmarking", "198.18.0.0/15"],
+  ["azure-wireserver", "168.63.129.16/32"],
   ["link-local", "169.254.0.0/16"],
   ["shared-address", "100.64.0.0/10"],
   ["multicast", "224.0.0.0/4"],
@@ -2100,6 +2121,8 @@ var V6 = [
   ["loopback", "::1/128"],
   ["ipv4-mapped", "::ffff:0:0/96"],
   ["nat64", "64:ff9b::/96"],
+  // The location of an embedded IPv4 address depends on the translator's prefix length, so the whole prefix is refused.
+  ["nat64-local", "64:ff9b:1::/48"],
   ["ipv4-compatible", "::/96"],
   ["link-local", "fe80::/10"],
   ["unique-local", "fc00::/7"],
@@ -2164,6 +2187,12 @@ function build6() {
 var RANGES_4 = build4();
 var RANGES_6 = build6();
 [...RANGES_4, ...RANGES_6].map(({ name, cidr }) => ({ name, cidr }));
+function carried6to4(address) {
+  const v6 = parseV6(address);
+  if (v6 === void 0 || v6 >> BigInt(112) !== BigInt(8194)) return void 0;
+  const v4 = Number(v6 >> BigInt(80) & BigInt(4294967295));
+  return [v4 >>> 24, v4 >>> 16 & 255, v4 >>> 8 & 255, v4 & 255].join(".");
+}
 function classifyAddress(address) {
   const v4 = parseV4(address);
   if (v4 !== void 0) {
@@ -2175,6 +2204,11 @@ function classifyAddress(address) {
   }
   const v6 = parseV6(address);
   if (v6 === void 0) return UNPARSEABLE;
+  const carries = carried6to4(address);
+  if (carries !== void 0) {
+    const inner = classifyAddress(carries);
+    return inner === void 0 ? void 0 : { ...inner, carries };
+  }
   for (const range of RANGES_6) {
     const shift = BigInt(128 - range.bits);
     if (v6 >> shift === range.base >> shift) return { name: range.name, cidr: range.cidr };
@@ -2309,13 +2343,15 @@ async function startTunnel(socketPath, opts = {}) {
     const own = new Set(ownAddresses().map(normalize));
     let firstRefusal;
     for (const { address: address2 } of addresses) {
-      const range = own.has(normalize(address2)) ? { name: "host-address", cidr: address2 } : classifyAddress(address2);
+      const carried = carried6to4(address2);
+      const range = own.has(normalize(address2)) || carried !== void 0 && own.has(carried) ? { name: "host-address", cidr: address2, ...carried === void 0 ? {} : { carries: carried } } : classifyAddress(address2);
       if (range === void 0) return { ok: true, address: address2 };
-      firstRefusal ??= { address: address2, name: range.name, cidr: range.cidr };
+      firstRefusal ??= { address: address2, name: range.name, cidr: range.cidr, carries: range.carries };
     }
-    const { address, name, cidr } = firstRefusal;
+    const { address, name, cidr, carries } = firstRefusal;
     refused2(host, address, name);
-    return { ok: false, status: 403, body: `refused: ${host} is ${address}, in the ${name} range ${cidr}
+    const via = carries === void 0 ? "" : `, which carries ${carries}`;
+    return { ok: false, status: 403, body: `refused: ${host} is ${address}${via}, in the ${name} range ${cidr}
 ` };
   }
   const sockets = /* @__PURE__ */ new Set();
@@ -2432,12 +2468,16 @@ ${body}`);
     req.pipe(upstream);
   }
   if (opts.socket !== false) {
-    if (existsSync(socketPath)) unlinkSync(socketPath);
-    await new Promise((resolveListen, reject) => {
-      server.once("error", reject);
-      server.listen(socketPath, () => resolveListen());
-    });
-    chmodSync(socketPath, 438);
+    if (opts.listenOn !== void 0) {
+      await opts.listenOn(server);
+    } else {
+      if (existsSync(socketPath)) unlinkSync(socketPath);
+      await new Promise((resolveListen, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => resolveListen());
+      });
+      chmodSync(socketPath, 438);
+    }
   }
   const tcpServers = [];
   return {
@@ -2445,6 +2485,7 @@ ${body}`);
     record,
     destinationUsed,
     acceptStream: (stream) => void server.emit("connection", stream),
+    listener: () => opts.socket === false ? void 0 : server,
     async listenTcp(address) {
       const tcp = createServer$1((socket) => server.emit("connection", socket));
       await new Promise((resolveListen, reject) => {
@@ -2883,7 +2924,8 @@ async function provisionContainer(input) {
       const delivered = await deliverJobFiles(runtime, state, ["context"], secrets);
       return delivered.ok ? delivered : { ok: false, reason: `context_unavailable: ${delivered.reason}` };
     },
-    removeStagedContext: () => removeStagedContext(buildDir2)
+    removeStagedContext: () => removeStagedContext(buildDir2),
+    keepIn: jobDir
   });
   if (!steps.ok) return bail(steps.reason, steps.aborted === true);
   state.startCommit = steps.startCommit;
@@ -2972,16 +3014,28 @@ async function stopContainer(runtime, state) {
   await runtime.host.stop(state.container);
   state.stopped = true;
 }
+var DISK_CHECK_MS = 12e4;
 async function measureDisk(runtime, state) {
-  const result = await runtime.host.exec({
-    container: state.container,
-    user: state.agentUser ?? ADDED_USER,
-    env: NO_ENV,
-    argv: ["du", "-skx", "/build"]
+  let timer;
+  const late = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ failure: "du ran past 2 minutes" }), DISK_CHECK_MS);
   });
-  return result.status === 0 ? parseDuKilobytes(result.stdout) : void 0;
+  try {
+    const run = runtime.host.exec(
+      {
+        container: state.container,
+        user: state.agentUser ?? ADDED_USER,
+        env: { literals: { LC_ALL: "C" }, passed: {} },
+        argv: ["du", "-skx", "/build"]
+      },
+      { timeoutMs: DISK_CHECK_MS + 1e4 }
+    ).then(readDu, (err) => ({ failure: `docker exec did not run: ${err instanceof Error ? err.message.slice(0, 200) : "unknown error"}` }));
+    return await Promise.race([run, late]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
-async function startServicesFor(runtime, config, buildDir2, jobDir, itemKey, builtIns, gitRemote, serve = "socket", lease) {
+async function startServicesFor(runtime, config, buildDir2, jobDir, itemKey, builtIns, gitRemote, serve = "socket", lease, inherit) {
   return startBuildServices({
     startTunnel: runtime.startTunnel,
     tunnelOptions: { ...runtime.tunnelOptions, ...gitRemote === void 0 ? {} : { gitRemote } },
@@ -2991,6 +3045,7 @@ async function startServicesFor(runtime, config, buildDir2, jobDir, itemKey, bui
     allowHosts: config.build?.allowHosts,
     serve,
     ...lease === void 0 ? {} : { lease },
+    ...inherit === void 0 ? {} : { inherit },
     ...builtIns ? { builtIns: { gatewayUrl: config.url, itemKey, claudeUpstream: runtime.claudeUpstream } } : {},
     hostEnv: runtime.hostEnv,
     destinationOptions: runtime.destinationOptions

package/dist/chunk-YJLHUKYS.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/container/disk.ts
+var UNITS = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+function parseSize(text) {
+  const match = /^(\d+(?:\.\d+)?)([kKmMgG]?)$/.exec(text);
+  if (match === null) return void 0;
+  const bytes = Number(match[1]) * UNITS[match[2].toLowerCase()];
+  return bytes > 0 ? bytes : void 0;
+}
+function exceedsDisk(usedKilobytes, limit) {
+  const bytes = parseSize(limit);
+  return usedKilobytes * 1024 > (bytes ?? Number.POSITIVE_INFINITY);
+}
+var TOTAL = /^(\d+)\t\/build$/;
+var GONE = /: No such file or directory$/;
+var LINE_MAX = 200;
+function readDu(result) {
+  const stdoutLines = result.stdout.split("\n");
+  const totalAt = stdoutLines.map((line) => TOTAL.test(line)).lastIndexOf(true);
+  const kib = totalAt === -1 ? void 0 : Number(TOTAL.exec(stdoutLines[totalAt])[1]);
+  const lines = [...result.stderr.split("\n"), ...stdoutLines.filter((_, index) => index !== totalAt)].map((line) => line.trim()).filter((line) => line !== "");
+  const other = lines.find((line) => !GONE.test(line));
+  if (kib !== void 0 && result.status === 0) return { kib };
+  if (kib !== void 0 && other === void 0 && lines.length > 0) return { kib };
+  const detail = other === void 0 ? "" : `: ${cut(other.replace(/[\u0000-\u001f\u007f]/g, " "))}`;
+  return { ...kib === void 0 ? {} : { kib }, failure: `docker exec exited ${result.status}${detail}` };
+}
+function cut(line) {
+  const head = line.slice(0, LINE_MAX);
+  const last = head.charCodeAt(head.length - 1);
+  return last >= 55296 && last <= 56319 ? head.slice(0, -1) : head;
+}
+
+export { exceedsDisk, parseSize, readDu };