@outerlayer/cli 0.24.0 → 0.25.0

package/dist/{chunk-ZFLOFAUG.js → chunk-VMF5LK3D.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { checkStarterFiles, contextIsGoverned, checkBuildSkill } from './chunk-XFGL53GU.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-RVYOOYOA.js';
-import { isLinkedRepository } from './chunk-V5Q3S4NM.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-X5LNCIZT.js';
+import { isLinkedRepository } from './chunk-6CNHXHI2.js';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
 import { checkFormerSkillNames } from './chunk-MQ743JX3.js';
-import { resolveGatewayCredentials, defaultFetch } from './chunk-FKXGQOF5.js';
-import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-755WXDBI.js';
+import { resolveGatewayCredentials, defaultFetch } from './chunk-M4B6QKNZ.js';
+import { sanitizeForContext, spoolDir, assessSyncHealth, readSyncStatus, SYNC_STALE_AFTER_MS, formatAgo, checkInstalledCliStaleness, workspaceRootOf, hookFiredMarkerPath, refreshCommand } from './chunk-K5WVK7IC.js';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-DXDF43YG.js';
 import { hookCommandEscapesControlPlane, CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
 import { findGitDirs } from './chunk-BJ3KTMDH.js';
@@ -1174,7 +1174,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-7Z5DHSGY.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-JJ3EO7SB.js');
   const configPath = defaultRunnerConfigPath();
   const checks = runDoctor({ runnerHost: hasRunnerBlock(configPath) });
   const credential = await credentialChecks();
@@ -1186,7 +1186,7 @@ async function gatherDoctorChecks() {
     const { runnerVmCheck } = await import('./doctor-53F2PYY7.js');
     checks.push(runnerVmCheck(configPath, { lima: realLima(), home: homeFromEnv(), instance: runnerVm.instance }));
   } else if (hasRunnerBlock(configPath)) {
-    const { runnerHostChecks } = await import('./doctor-DOAFZV4O.js');
+    const { runnerHostChecks } = await import('./doctor-73GNT4VV.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1221,7 +1221,7 @@ async function gatherDoctorChecks() {
       const { existsSync: existsSync3 } = await import('fs');
       if (process.platform !== "linux" || !existsSync3("/run/systemd/system")) return void 0;
       const { inspectService, realInspectProbes } = await import('./inspect-6UYAAXH7.js');
-      const { DEFAULT_UNIT_NAME } = await import('./install-ORQC26ZE.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-MPEJJ7X6.js');
       const { dirname: dirname2 } = await import('path');
       return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
     })();

package/dist/{chunk-VBEXKEBV.js → chunk-VNGENFOG.js}

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { MIN_ENGINE_MAJOR } from './chunk-GU4PKXN7.js';
-import { firecrackerArch, MICROVM_ARCHES, guestAssetsPinned } from './chunk-3W333NFO.js';
+import { MIN_ENGINE_MAJOR } from './chunk-XHXDCYSK.js';
+import { runnerImageVersion } from './chunk-5222PA6S.js';
+import { firecrackerArch, MICROVM_ARCHES, guestAssetsPinned } from './chunk-RGW7ERF3.js';
 import { spawnSync } from 'child_process';
 import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
 
@@ -53,17 +54,20 @@ function detectMachine(probes = {}) {
   const platform = platformOf(probes);
   const kvm = (probes.kvm ?? (() => detectKvm(probes.kvmDevice ?? "/dev/kvm")))();
   const arch = firecrackerArch(probes.nodeArch ?? process.arch);
+  const inImage = runnerImageVersion(probes.env ?? process.env) !== void 0 ? { inImage: true } : {};
   const version = (probes.dockerVersion ?? (() => docker(["version", "--format", "{{.Server.Version}}"])))();
   if (version === void 0) {
     const failure = (probes.dockerFailure ?? (probes.dockerVersion === void 0 ? dockerFailure : () => void 0))();
-    return { platform, docker: failure === void 0 ? { kind: "none" } : { kind: "unreachable", reason: failure }, kvm, arch };
+    return { platform, ...inImage, docker: failure === void 0 ? { kind: "none" } : { kind: "unreachable", reason: failure }, kvm, arch };
   }
   const system = (probes.dockerOperatingSystem ?? (() => docker(["info", "--format", "{{.OperatingSystem}}"])))() ?? "";
-  return { platform, docker: { kind: /docker desktop/i.test(system) ? "desktop" : "engine", version }, kvm, arch };
+  return { platform, ...inImage, docker: { kind: /docker desktop/i.test(system) ? "desktop" : "engine", version }, kvm, arch };
 }
 function supportsContainerBuilds(machine) {
   if (machine.platform !== "linux" && machine.platform !== "wsl2") return false;
-  return machine.docker.kind === "engine" && Number.parseInt(machine.docker.version ?? "", 10) >= MIN_ENGINE_MAJOR;
+  const { kind, version } = machine.docker;
+  if (kind !== "engine" && !(kind === "desktop" && machine.inImage === true)) return false;
+  return Number.parseInt(version ?? "", 10) >= MIN_ENGINE_MAJOR;
 }
 function supportsMicroVmBuilds(machine) {
   return machine.platform === "linux" && machine.kvm?.state === "usable" && supportsContainerBuilds(machine) && microVmAssetsPinned(machine);
@@ -81,7 +85,16 @@ function reachDockerStep(machine) {
 function describeMachineDocker(machine) {
   const { kind, version, reason } = machine.docker;
   const where = machine.platform === "windows" ? "Windows" : machine.platform === "darwin" ? "macOS" : machine.platform === "wsl2" ? "WSL2" : "Linux";
-  if (kind === "desktop") return `Docker Desktop ${version ?? ""} on ${where}, which cannot pass a Unix socket into a container`.replace("  ", " ");
+  if (kind === "desktop") {
+    const engine = version === void 0 ? "" : ` with engine ${version}`;
+    if (machine.inImage === true && (machine.platform === "linux" || machine.platform === "wsl2")) {
+      const major = Number.parseInt(version ?? "", 10);
+      if (Number.isNaN(major)) return `Docker Desktop${engine}, whose engine version is not readable`;
+      if (major < MIN_ENGINE_MAJOR) return `Docker Desktop${engine}, older than the ${MIN_ENGINE_MAJOR} that container builds need`;
+      return `Docker Desktop${engine}`;
+    }
+    return `Docker Desktop${engine} on ${where}, which a runner accepts only in the runner image`;
+  }
   if (kind === "none") return `no Docker on ${where}`;
   if (kind === "unreachable") {
     const problem = reason === "permission" ? "this user has no permission on its socket" : "its daemon is not running";

package/dist/{chunk-5ECUMU53.js → chunk-VPUNOGXO.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { isPlaceholderCommand } from './chunk-BOQY756V.js';
-import { describeCallFailure } from './chunk-TQ6Y7YV6.js';
-import { WorkCommandError, getJson } from './chunk-RVYOOYOA.js';
+import { isPlaceholderCommand } from './chunk-JKILLWZF.js';
+import { describeCallFailure } from './chunk-YMKQVCKC.js';
+import { WorkCommandError, getJson } from './chunk-X5LNCIZT.js';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
-import { builtinKind } from './chunk-D7X5ITVT.js';
-import { signerFor } from './chunk-PVRBE7S4.js';
-import { CLAUDE_CREDENTIAL_VARIABLES, claudeCredential } from './chunk-BN3CSI7S.js';
+import { builtinKind } from './chunk-JWRX5ZTT.js';
+import { signerFor } from './chunk-ZODVSFI4.js';
+import { CLAUDE_CREDENTIAL_VARIABLES, claudeCredential } from './chunk-2K3TCQHW.js';
 
 createRequire(import.meta.url);
 

package/dist/{chunk-RVYOOYOA.js → chunk-X5LNCIZT.js}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { detectActiveSession, autoConnect } from './chunk-F2W2IYNP.js';
-import { workPageUrl } from './chunk-V5Q3S4NM.js';
+import { detectActiveSession, autoConnect } from './chunk-HWEIFHSW.js';
+import { workPageUrl } from './chunk-6CNHXHI2.js';
 import { sanitizeTerminal } from './chunk-BUP5N3X6.js';
-import { resolveGatewayCredentials, unauthorizedMessage, defaultFetch } from './chunk-FKXGQOF5.js';
+import { resolveGatewayCredentials, unauthorizedMessage, defaultFetch } from './chunk-M4B6QKNZ.js';
 import { readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { resolveRepoIdentity } from './chunk-D4AMAEZ7.js';
 import { C } from './chunk-ANPNT6PM.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { signRunnerRequest } from './chunk-PVRBE7S4.js';
+import { signRunnerRequest } from './chunk-ZODVSFI4.js';
 
 createRequire(import.meta.url);
 
@@ -368,10 +368,11 @@ function issueLabel(subject) {
   if ("issue" in subject) return `issue ${sanitizeTerminal(subject.repository)}#${subject.issue}`;
   return `issue ${sanitizeTerminal(subject.key)}`;
 }
-function itemPageUrl(home, cwd, appId, workItemId) {
+function itemPageUrl(home, cwd, appId, workItemId, number) {
   const connection = readRepoConnection(cwd);
   if (connection === void 0 || connection.appId !== appId || typeof workItemId !== "string" || workItemId === "") return void 0;
-  return `${workPageUrl(home, connection.organization.name, connection.factory.name)}/${encodeURIComponent(workItemId)}`;
+  const segment = encodeURIComponent(number == null ? workItemId : String(number));
+  return `${workPageUrl(home, connection.organization.name, connection.factory.name)}/${segment}`;
 }
 async function runWorkBuild(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -416,7 +417,7 @@ async function runWorkBuild(opts) {
     ...facts
   };
   const { data } = await postJsonWithRetry(url, "/v1/work-items/build", apiKey, appId, body, fetchImpl, retries, sleep);
-  const page = itemPageUrl(home, cwd, appId, data.workItemId);
+  const page = itemPageUrl(home, cwd, appId, data.workItemId, data.number);
   const output = opts.json ? JSON.stringify(data) : `${C.green}\u2713${C.reset} build requested ${C.dim}\xB7${C.reset} ${itemLabel(data)}${"subject" in body ? ` (${issueLabel(body.subject)})` : ""} ${C.dim}\xB7${C.reset} by ${data.attestor}` + (page !== void 0 ? `
   ${page}` : "") + tokenWarning(data);
   if (!opts.quiet) process.stdout.write(output + "\n");
@@ -427,7 +428,7 @@ async function runWorkLinkSession(opts) {
     return await linkSession(opts);
   } catch (err) {
     if (opts.logFailures) {
-      const { logHookError } = await import('./hook-fast-3JL4PXLG.js');
+      const { logHookError } = await import('./hook-fast-NEELST6G.js');
       const reason = err instanceof Error ? err.message : String(err);
       logHookError(opts.home ?? homeFromEnv(opts.env ?? process.env), new Error(`work link-session #${opts.number} failed: ${reason}`));
     }
@@ -514,9 +515,17 @@ async function runWorkRemove(opts) {
   if (!opts.quiet) process.stdout.write(output + "\n");
   return { data, output };
 }
+function mergedUnverifiedLine(data) {
+  const block = data.gates?.block;
+  if (block?.mergedDespiteVerdict !== true) return "";
+  const at = typeof block.mergedAt === "string" ? ` at ${sanitizeTerminal(block.mergedAt)}` : "";
+  return `${C.yellow}Merged, unverified${C.reset}: the pull request merged${at} before its checks or review passed, so the stage stays at review.
+
+`;
+}
 function statusOutput(data, json) {
   if (json) return JSON.stringify(data);
-  const document = JSON.stringify(data, null, 2);
+  const document = mergedUnverifiedLine(data) + JSON.stringify(data, null, 2);
   const criteria = data.criteria;
   if (criteria === void 0) return document;
   if (criteria === null || !Array.isArray(criteria.items)) return `${document}

package/dist/{chunk-PDIM5T65.js → chunk-XGJUNNXL.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-BN3CSI7S.js';
+import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-2K3TCQHW.js';
 import { symlinkSync, unlinkSync } from 'fs';
 import { join } from 'path';
 

package/dist/{chunk-GU4PKXN7.js → chunk-XHXDCYSK.js}

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { readDefaultBranchHead, cloneRepository, buildRepositoryImage } from './chunk-TTLVQZSH.js';
+import { runnerImageVersion } from './chunk-5222PA6S.js';
+import { readDefaultBranchHead, cloneRepository, buildRepositoryImage } from './chunk-AXPCGD46.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-5XCAPBE2.js';
-import { RecipeError, CLAUDE_CODE_VERSION, firecrackerArch, MICROVM_ARCHES, DEFAULT_BASE_IMAGE, GUEST_HELPER_SHA256, GUEST_ASSETS_BASE_URL, GUEST_KERNEL_SHA256, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, FIRECRACKER_VERSION, GUEST_ASSETS_VERSION } from './chunk-3W333NFO.js';
-import { execCapture } from './chunk-LY2L3O2O.js';
-import { GUEST_CID } from './chunk-PDIM5T65.js';
-import { describeCallFailure, controlPlaneTokenFailure, refusalCode, resolveGoverningSource, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, shimScript } from './chunk-TQ6Y7YV6.js';
-import { WorkCommandError } from './chunk-RVYOOYOA.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-QUGYGO6L.js';
+import { 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, FIRECRACKER_VERSION, GUEST_ASSETS_VERSION, DEFAULT_BASE_IMAGE } from './chunk-RGW7ERF3.js';
+import { execCapture } from './chunk-7OWPLRJR.js';
+import { GUEST_CID } from './chunk-XGJUNNXL.js';
+import { describeCallFailure, controlPlaneTokenFailure, refusalCode, resolveGoverningSource, removeStagedContext, stageGovernedContext, pinnedSourceOf, commandWithShim, shimScript } from './chunk-YMKQVCKC.js';
+import { WorkCommandError } from './chunk-X5LNCIZT.js';
 import { hostAllowed } from './chunk-UXYLWVTQ.js';
 import { parseDuKilobytes } from './chunk-7RQ73DLO.js';
 import { sharedSkillNames, skillConflictMessage } from './chunk-VPEGE3QZ.js';
@@ -16,11 +17,12 @@ import { versionAtLeast, MINIMUM_CLAUDE_VERSION } from './chunk-HCVLP7XA.js';
 import { setCustomScrubbers, setLocalIdentity, setRepoRoot, parseTranscript, scrubDeep, scrubText } from './chunk-D4AMAEZ7.js';
 import { orderSessions, extractFacts, sessionsToTimeline } from './chunk-RKOTJQVG.js';
 import { downconvertSession } from './chunk-QZBXLLTV.js';
-import { rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, deliveryDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, RUNNER_DIR_MODE, SHIM_DIR, vmAssetsDir } from './chunk-KF37SUDM.js';
-import { repositoriesOf, primaryOf, RELAY_PORT, repositoryPath, CHECKOUT_DIR, lifecycleWorkdir, claudeCredential, buildEnvironment, startBuildServices, checkEnvironment, AGENT_CREDENTIAL_MISSING, checkoutPath, JOB_MOUNT } from './chunk-BN3CSI7S.js';
-import { RELAY_USER, RELAY_ID, UNKNOWN_TRANSPORT_REASON, MAX_MALFORMED_SESSIONS, MALFORMED_REASON, MAX_OPEN_STREAMS, STREAM_WINDOW, SESSION_WINDOW, targetOfPath } from './chunk-GISNHSYL.js';
-import { readFileSync, existsSync, mkdirSync, chmodSync, truncateSync, rmSync, writeFileSync, readdirSync, lstatSync, copyFileSync, accessSync, constants, statSync, rmdirSync, renameSync, unlinkSync, openSync, closeSync, mkdtempSync, createWriteStream, createReadStream } from 'fs';
+import { vmAssetsDir, RUNNER_DIR_MODE, rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, deliveryDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, SHIM_DIR } from './chunk-ZI2ZVWKT.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 { 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';
+import { isIP, createConnection, connect, createServer as createServer$1 } from 'net';
 import { spawnSync, spawn } from 'child_process';
 import { availableParallelism, networkInterfaces } from 'os';
 import { randomBytes, createHash } from 'crypto';
@@ -30,7 +32,6 @@ import { createServer, request } from 'http';
 import { request as request$1 } from 'https';
 import { pipeline, finished } from 'stream/promises';
 import { createGunzip, gunzipSync, constants as constants$1 } from 'zlib';
-import { isIP, connect, createServer as createServer$1 } from 'net';
 import { lookup } from 'dns/promises';
 
 createRequire(import.meta.url);
@@ -144,6 +145,101 @@ function realCgroupPort() {
     remove: (path) => removeBuildCgroup(fs, path)
   };
 }
+var SUPPORTED_HELPER_PROTOCOLS = [1];
+var HELPER_ENV = "OUTERLAYER_HELPER_SOCKET";
+var HelperRefusal = class extends Error {
+  constructor(code, reason) {
+    super(reason);
+    this.code = code;
+  }
+};
+function helperSocketPath(unitName) {
+  return `/run/${unitName}-helper/helper.sock`;
+}
+var START_TIMEOUT_MS = 12e4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MAX_REPLY_BYTES = 1024 * 1024;
+function ask(socketPath, request, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const conn = createConnection(socketPath);
+    let text = "";
+    let settled = false;
+    const settle = (finish) => {
+      if (settled) return;
+      settled = true;
+      conn.destroy();
+      finish();
+    };
+    conn.setTimeout(timeoutMs, () => settle(() => reject(new Error(`the helper at ${socketPath} did not answer within ${Math.round(timeoutMs / 1e3)} seconds`))));
+    conn.on("connect", () => conn.write(`${JSON.stringify(request)}
+`));
+    conn.on("data", (chunk) => {
+      text += chunk.toString("utf8");
+      if (text.length > MAX_REPLY_BYTES) return settle(() => reject(new Error(`the helper at ${socketPath} sent a reply that is too long`)));
+      const end = text.indexOf("\n");
+      if (end === -1) return;
+      settle(() => {
+        let reply;
+        try {
+          reply = JSON.parse(text.slice(0, end));
+        } catch {
+          return reject(new Error(`the helper at ${socketPath} sent a reply that is not JSON`));
+        }
+        if (reply.status === "refused") return reject(new HelperRefusal(String(reply.code ?? "refused"), String(reply.reason ?? "the helper refused the request")));
+        resolve(reply);
+      });
+    });
+    conn.on("error", (err) => settle(() => reject(new Error(`the helper at ${socketPath} did not answer: ${err.message}`))));
+    conn.on("close", () => settle(() => reject(new Error(`the helper at ${socketPath} closed the connection without a reply`))));
+  });
+}
+function helperClient(socketPath, options = {}) {
+  const REQUEST_TIMEOUT_MS = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  return {
+    async start({ build, kind }) {
+      const reply = await ask(socketPath, { v: 1, op: "start", build, kind }, START_TIMEOUT_MS);
+      return { unit: String(reply.unit), chroot: String(reply.chroot), vsock: String(reply.vsock) };
+    },
+    async stop(build) {
+      await ask(socketPath, { v: 1, op: "stop", build }, REQUEST_TIMEOUT_MS);
+    },
+    async state(build) {
+      const reply = await ask(socketPath, { v: 1, op: "state", build }, REQUEST_TIMEOUT_MS);
+      return { active: reply.active === true, oomKills: typeof reply.oomKills === "number" ? reply.oomKills : 0 };
+    },
+    async list() {
+      const reply = await ask(socketPath, { v: 1, op: "list" }, REQUEST_TIMEOUT_MS);
+      return Array.isArray(reply.builds) ? reply.builds.map(String) : [];
+    }
+  };
+}
+function reinstallMessage(protocol) {
+  const spoken = protocol === void 0 ? "a protocol it does not name" : `protocol ${protocol}`;
+  return `the root helper speaks ${spoken}, which this runner does not support, so microVM builds run without the jailer; run \`outerlayer runner install --service --replace\` to install the helper that goes with this release`;
+}
+async function probeHelper(socketPath, options = {}) {
+  if (socketPath === void 0 || socketPath === "") return { ok: false, reason: "absent", detail: `${HELPER_ENV} is not set, so this runner was not started by a service that has a helper` };
+  if (!(options.pinned ?? hostHelperPinned())) return { ok: false, reason: "unpinned", detail: "this release of the CLI pins no helper, so builds run without the jailer" };
+  try {
+    const reply = await ask(socketPath, { v: 1, op: "hello" }, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
+    const protocol = typeof reply.protocol === "number" ? reply.protocol : void 0;
+    if (protocol === void 0 || !SUPPORTED_HELPER_PROTOCOLS.includes(protocol)) return { ok: false, reason: "unsupported", detail: reinstallMessage(protocol) };
+    return { ok: true, client: helperClient(socketPath, { requestTimeoutMs: options.requestTimeoutMs }), firecracker: String(reply.firecracker ?? "") };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: "absent", unreachable: true, detail: message.includes(socketPath) ? message : `the helper at ${socketPath} did not answer: ${message}` };
+  }
+}
+function jailedAlive(unit, cgroupRoot = "/sys/fs/cgroup") {
+  try {
+    return /^populated 1$/m.test(readFileSync(join(cgroupRoot, "system.slice", `${unit}.service`, "cgroup.events"), "utf8"));
+  } catch {
+    return false;
+  }
+}
+function realHelperPort(env = process.env) {
+  return { probe: () => probeHelper(env[HELPER_ENV]), alive: (unit) => jailedAlive(unit) };
+}
 var BranchPrepareError = class extends Error {
 };
 var OWN_PREFIX = "outerlayer/";
@@ -353,7 +449,8 @@ function pinnedAssets(arch) {
     firecracker: {
       url: `${FIRECRACKER_RELEASES}/v${version}/firecracker-v${version}-${arch}.tgz`,
       sha256: FIRECRACKER_SHA256[arch],
-      binarySha256: FIRECRACKER_BINARY_SHA256[arch]
+      binarySha256: FIRECRACKER_BINARY_SHA256[arch],
+      jailerSha256: JAILER_BINARY_SHA256[arch]
     },
     kernel: { url: `${GUEST_ASSETS_BASE_URL}/vmlinux-${arch}`, sha256: GUEST_KERNEL_SHA256[arch] },
     helper: { url: `${GUEST_ASSETS_BASE_URL}/outerlayer-guest-${arch}`, sha256: GUEST_HELPER_SHA256[arch] }
@@ -392,14 +489,45 @@ async function ensureFile(dir, file, pin, fetchImpl, mode) {
   writeAtomic(path, bytes, mode);
   return path;
 }
-function extractWithTar(arch) {
-  const name = `firecracker-v${FIRECRACKER_VERSION}-${arch}`;
+function extractWithTar(arch, program = "firecracker") {
+  const name = `${program}-v${FIRECRACKER_VERSION}-${arch}`;
   return async (tarball, destDir) => {
     const result = spawnSync("tar", ["-xzf", tarball, "-C", destDir, "--strip-components=1", `release-v${FIRECRACKER_VERSION}-${arch}/${name}`], { encoding: "utf8" });
     if (result.status !== 0) throw new Error(`tar could not unpack ${tarball}: ${result.stderr.trim()}`);
     return join(destDir, name);
   };
 }
+async function ensureFirecracker(input) {
+  const { dir, arch, pins, fetchImpl } = input;
+  const firecracker = join(dir, "firecracker");
+  if (existsSync(firecracker)) {
+    const actual = sha256Of(readFileSync(firecracker));
+    if (actual !== pins.firecracker.binarySha256) throw pinProblem("firecracker", pins.firecracker.binarySha256, actual, `at ${firecracker}`);
+    return firecracker;
+  }
+  const tarballName = `firecracker-${arch}.tgz`;
+  const tarball = await ensureFile(dir, tarballName, pins.firecracker, fetchImpl, RUNNER_FILE_MODE);
+  const scratch = mkdtempSync(join(dir, ".extract-"));
+  try {
+    const extracted = await (input.extract ?? extractWithTar(arch))(tarball, scratch);
+    const bytes = readFileSync(extracted);
+    const actual = sha256Of(bytes);
+    if (actual !== pins.firecracker.binarySha256) throw pinProblem("firecracker", pins.firecracker.binarySha256, actual, `unpacked from ${tarballName}`);
+    writeAtomic(firecracker, bytes, 493);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+  return firecracker;
+}
+async function ensureFirecrackerAndJailer(options) {
+  const arch = options.arch ?? firecrackerArch(process.arch);
+  if (!MICROVM_ARCHES.includes(arch)) throw new AssetError("firecracker", `no Firecracker assets are pinned for ${arch}, so microVM builds run on ${MICROVM_ARCHES.join(" or ")} hosts only`);
+  const pins = options.pins ?? pinnedAssets(arch);
+  const dir = vmAssetsDir(options.runnerDir);
+  mkdirSync(dir, { recursive: true, mode: RUNNER_DIR_MODE });
+  const firecracker = await ensureFirecracker({ dir, arch, pins, fetchImpl: options.fetchImpl ?? fetch, extract: options.extractFirecracker });
+  return { firecracker, jailer: await ensureJailer(options) };
+}
 async function ensureAssets(options) {
   const arch = options.arch ?? firecrackerArch(process.arch);
   if (!MICROVM_ARCHES.includes(arch)) throw new AssetError("firecracker", `no Firecracker or guest assets are pinned for ${arch}, so microVM builds run on ${MICROVM_ARCHES.join(" or ")} hosts only`);
@@ -407,28 +535,40 @@ async function ensureAssets(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const dir = vmAssetsDir(options.runnerDir);
   mkdirSync(dir, { recursive: true, mode: RUNNER_DIR_MODE });
-  const firecracker = join(dir, "firecracker");
-  if (existsSync(firecracker)) {
-    const actual = sha256Of(readFileSync(firecracker));
-    if (actual !== pins.firecracker.binarySha256) throw pinProblem("firecracker", pins.firecracker.binarySha256, actual, `at ${firecracker}`);
-  } else {
-    const tarballName = `firecracker-${arch}.tgz`;
-    const tarball = await ensureFile(dir, tarballName, pins.firecracker, fetchImpl, RUNNER_FILE_MODE);
-    const scratch = mkdtempSync(join(dir, ".extract-"));
-    try {
-      const extracted = await (options.extractFirecracker ?? extractWithTar(arch))(tarball, scratch);
-      const bytes = readFileSync(extracted);
-      const actual = sha256Of(bytes);
-      if (actual !== pins.firecracker.binarySha256) throw pinProblem("firecracker", pins.firecracker.binarySha256, actual, `unpacked from ${tarballName}`);
-      writeAtomic(firecracker, bytes, 493);
-    } finally {
-      rmSync(scratch, { recursive: true, force: true });
-    }
-  }
+  const firecracker = await ensureFirecracker({ dir, arch, pins, fetchImpl, extract: options.extractFirecracker });
   const kernel = await ensureFile(dir, `vmlinux-${arch}`, pins.kernel, fetchImpl, RUNNER_FILE_MODE);
   const helper = await ensureFile(dir, `outerlayer-guest-${arch}`, pins.helper, fetchImpl, 493);
   return { firecracker, kernel, helper, helperSha256: pins.helper.sha256 };
 }
+async function ensureJailer(options) {
+  const arch = options.arch ?? firecrackerArch(process.arch);
+  if (!MICROVM_ARCHES.includes(arch)) throw new AssetError("jailer", `no Firecracker assets are pinned for ${arch}, so microVM builds run on ${MICROVM_ARCHES.join(" or ")} hosts only`);
+  const pins = options.pins ?? pinnedAssets(arch);
+  const expected = pins.firecracker.jailerSha256;
+  if (expected === void 0) throw new AssetError("jailer", "this release pins no hash for the jailer, so it cannot be had");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const dir = vmAssetsDir(options.runnerDir);
+  mkdirSync(dir, { recursive: true, mode: RUNNER_DIR_MODE });
+  const jailer = join(dir, "jailer");
+  if (existsSync(jailer)) {
+    const actual = sha256Of(readFileSync(jailer));
+    if (actual !== expected) throw pinProblem("jailer", expected, actual, `at ${jailer}`);
+    return jailer;
+  }
+  const tarballName = `firecracker-${arch}.tgz`;
+  const tarball = await ensureFile(dir, tarballName, pins.firecracker, fetchImpl, RUNNER_FILE_MODE);
+  const scratch = mkdtempSync(join(dir, ".extract-"));
+  try {
+    const extracted = await (options.extractJailer ?? extractWithTar(arch, "jailer"))(tarball, scratch);
+    const bytes = readFileSync(extracted);
+    const actual = sha256Of(bytes);
+    if (actual !== expected) throw pinProblem("jailer", expected, actual, `unpacked from ${tarballName}`);
+    writeAtomic(jailer, bytes, 493);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+  return jailer;
+}
 var STOP_GRACE_SECONDS = 15;
 function parseImageConfig(json) {
   const config = JSON.parse(json);
@@ -755,6 +895,7 @@ function createMicroVmPorts(over = {}) {
     rootfs: over.rootfs ?? createRootfsHost(),
     firecracker: over.firecracker ?? createFirecrackerHost(),
     cgroup: over.cgroup ?? realCgroupPort(),
+    helper: over.helper ?? realHelperPort(),
     exec: over.exec ?? execCapture
   };
 }
@@ -2343,6 +2484,7 @@ function createContainerRuntime(opts = {}) {
     tunnelOptions: opts.tunnelOptions,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
     hostEnv: opts.hostEnv ?? process.env,
+    platform: opts.platform ?? process.platform,
     credentials: opts.credentials ?? /* @__PURE__ */ new Map(),
     github: { gitUrl: opts.github?.gitUrl ?? "https://github.com", apiUrl: opts.github?.apiUrl ?? "https://api.github.com" },
     remoteFor,
@@ -2531,8 +2673,8 @@ async function provisionContainer(input) {
   if (!(Number.parseInt(engine, 10) >= MIN_ENGINE_MAJOR)) {
     return fail(`Docker Engine ${engine} is too old: container builds need Engine ${MIN_ENGINE_MAJOR} or later`);
   }
-  if (/docker desktop/i.test(await host.operatingSystem() ?? "")) {
-    return fail("Docker Desktop cannot pass the tunnel's socket into a container, so container builds need Docker Engine: install it (on Windows, inside WSL2) or use builtin:process");
+  if (/docker desktop/i.test(await host.operatingSystem() ?? "") && !(runnerImageVersion(runtime.hostEnv) !== void 0 && runtime.platform === "linux")) {
+    return fail(DOCKER_DESKTOP_REASON);
   }
   const governing = await resolveGoverningSource({ config, repository, fetchImpl: input.fetchImpl });
   if (!governing.ok) return fail(governing.reason);
@@ -2587,11 +2729,16 @@ async function provisionContainer(input) {
   if (env.skippedTokenVariables.length > 0) {
     log.line(`${tag} not passing ${env.skippedTokenVariables.join(", ")} from runner.build.variables into the build: its repository token comes from the runner`);
   }
+  const ignoredProperties = report.ignored.map(({ property, source }) => ({ property, source }));
+  if (report.docker) {
+    ignoredProperties.push({ property: "docker daemon", source: `feature ${DOCKER_FEATURE}` });
+    log.line(`${tag} container builds have no Docker daemon, so steps that run Docker will fail`);
+  }
   const environment = {
     isolation: "container",
     recipe: { sourceCommit: report.sourceCommit, key: report.recipeKey, path: report.recipe },
     imageId: report.imageId,
-    ignoredProperties: report.ignored.map(({ property, source }) => ({ property, source })),
+    ignoredProperties,
     variables: env.variables,
     cliVersion: input.cliVersion
   };
@@ -3157,4 +3304,4 @@ async function startCheckContainer(input) {
   };
 }
 
-export { ADDED_USER, AgentUserError, AssetError, DeliveryFailure, EVAL_INPUT_NAME, GH_CONFIG_YML, LEASE_SECONDS, MIN_ENGINE_MAJOR, cleanupContainer, containerCommandExec, containerJudgeEnvironment, containerSenderCommand, copyJudgeTree, copyTranscripts, copyTranscriptsFromContainer, createBuildDisk, createContainerRuntime, deleteBuildDisk, deliverContainerHooks, ensureRootfs, ensureTunnel, filesAreCopied, ghHostsYml, gitRemoteFor, isLiteralAddress, keepGhConfigCurrent, leaseExpiresAtMs, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, outOfMemoryReason, parseCpuList, prepareBranch, provisionContainer, resolveAgentUser, runBuildSteps, senderAliveScript, senderSignalScript, setUpRunnerCgroup, shellQuote, signalInContainer, startCheckContainer, startServicesFor, stopContainer, syncInContainer, writeEvalInput };
+export { ADDED_USER, AgentUserError, AssetError, DeliveryFailure, EVAL_INPUT_NAME, GH_CONFIG_YML, HelperRefusal, LEASE_SECONDS, MIN_ENGINE_MAJOR, cleanupContainer, containerCommandExec, containerJudgeEnvironment, containerSenderCommand, copyJudgeTree, copyTranscripts, copyTranscriptsFromContainer, createBuildDisk, createContainerRuntime, deleteBuildDisk, deliverContainerHooks, ensureFirecrackerAndJailer, ensureRootfs, ensureTunnel, filesAreCopied, ghHostsYml, gitRemoteFor, helperSocketPath, isLiteralAddress, keepGhConfigCurrent, leaseExpiresAtMs, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, outOfMemoryReason, parseCpuList, prepareBranch, probeHelper, provisionContainer, resolveAgentUser, runBuildSteps, senderAliveScript, senderSignalScript, setUpRunnerCgroup, shellQuote, signalInContainer, startCheckContainer, startServicesFor, stopContainer, syncInContainer, writeEvalInput };

package/dist/{chunk-NGZID7UI.js → chunk-XRYUJTAT.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-KF37SUDM.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { readFileSync, existsSync, rmSync, mkdirSync, writeFileSync, renameSync } from 'fs';
 import { join } from 'path';
 
@@ -11,6 +11,13 @@ function readPendingUpdate(runnerDirPath) {
     const raw = JSON.parse(readFileSync(join(runnerDirPath, FILE), "utf8"));
     if (typeof raw.version !== "string" || typeof raw.since !== "string") return void 0;
     const record = { version: raw.version, since: raw.since };
+    if (raw.via === "self-update" || raw.via === "install") record.via = raw.via;
+    if (Array.isArray(raw.waits)) {
+      record.waits = raw.waits.flatMap((entry) => {
+        const wait = entry;
+        return wait && typeof wait.item === "number" && typeof wait.reason === "string" ? [{ item: wait.item, reason: wait.reason }] : [];
+      });
+    }
     const holding = raw.holding;
     if (holding && Array.isArray(holding.builds) && typeof holding.since === "string") {
       record.holding = { builds: holding.builds.filter((n) => typeof n === "number"), since: holding.since };

package/dist/{chunk-TQ6Y7YV6.js → chunk-YMKQVCKC.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { WorkCommandError, postJson } from './chunk-RVYOOYOA.js';
-import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-E4OUL7ZP.js';
-import { signingFetchFor } from './chunk-FKXGQOF5.js';
+import { WorkCommandError, postJson } from './chunk-X5LNCIZT.js';
+import { defaultGitRunner, materializeContext, isStagingWriteFault, lookupGoverningSource } from './chunk-FXUVXSY2.js';
+import { signingFetchFor } from './chunk-M4B6QKNZ.js';
 import { unsupportedLayout, layoutRefusalReason, composeDelivery } from './chunk-VPEGE3QZ.js';
 import { SHIM_SCRIPT, GOVERNANCE_VARIABLE } from './chunk-HCVLP7XA.js';
 import { readDegraded, readContextManifest, readSourceCache } from './chunk-YQR6E6OV.js';
-import { signerFor } from './chunk-PVRBE7S4.js';
-import { SHIM_DIR, stagedContextDir, contextHomeDir, deliveryDir } from './chunk-KF37SUDM.js';
+import { signerFor } from './chunk-ZODVSFI4.js';
+import { SHIM_DIR, stagedContextDir, contextHomeDir, deliveryDir } from './chunk-ZI2ZVWKT.js';
 import { fstatSync, mkdirSync, writeFileSync, chmodSync, rmSync, lstatSync } from 'fs';
 import { relative, join, dirname } from 'path';
 

package/dist/{chunk-D7K446H6.js → chunk-YTTHDPWF.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { uploadSpooledSteps } from './chunk-F7Y2USIM.js';
+import { uploadSpooledSteps } from './chunk-IDJIWKTY.js';
 import { LaunchFilter } from './chunk-ESVW4MJY.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
 import { migrateLegacyArtifactSidecars, planArtifactUpload, artifactsStatePath, sanitizeTerminal, acquireArtifactSpoolLock, artifactBlobsDir, resolveArtifactTurnIndex, isArtifactTombstoned, ARTIFACT_RETRY_MAX_AGE_MS, writeArtifactSpoolState, reclaimUnneededArtifactBlobs, neededArtifactShas } from './chunk-BUP5N3X6.js';
-import { cliFetch, resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-FKXGQOF5.js';
-import { writeSyncStatus, spoolDir } from './chunk-755WXDBI.js';
+import { cliFetch, resolveGatewayCredentials, defaultFetch, unauthorizedMessage } from './chunk-M4B6QKNZ.js';
+import { writeSyncStatus, spoolDir } from './chunk-K5WVK7IC.js';
 import { readLatestProvenanceForSession, readContextProvenance } from './chunk-ZJSNLVCE.js';
 import { hookExecSpoolPath } from './chunk-DYEFPYME.js';
 import { applyReportedCost } from './chunk-BKO6JEZI.js';
@@ -18,7 +18,7 @@ import { cliInvocation } from './chunk-CRB3POP4.js';
 import { removeJournalHooks } from './chunk-TUSYOL2O.js';
 import { CAPTURE_TIERS, inferArtifactKind, bannedPathsForTier, downconvertSession, isHumanUserTurn, turnCountBound, EVENT_TYPES } from './chunk-QZBXLLTV.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { signerFor, signRunnerRequest } from './chunk-PVRBE7S4.js';
+import { signerFor, signRunnerRequest } from './chunk-ZODVSFI4.js';
 import { dirname, basename, join } from 'path';
 import { statSync, readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, existsSync, rmSync } from 'fs';
 import { execFileSync } from 'child_process';

package/dist/{chunk-LBCZXXOX.js → chunk-ZGMQQWCV.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { DEFAULT_UNIT_NAME } from './chunk-DG2ULWM6.js';
+import { DEFAULT_UNIT_NAME } from './chunk-IGRRD7PX.js';
 import { parseRunnerEnv } from './chunk-6MZSX4M7.js';
-import { RUNNER_FILE_MODE } from './chunk-KF37SUDM.js';
+import { RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from 'fs';
 import { join, dirname } from 'path';
 

package/dist/{chunk-KF37SUDM.js → chunk-ZI2ZVWKT.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { BUILD_HOME } from './chunk-BN3CSI7S.js';
+import { BUILD_HOME } from './chunk-2K3TCQHW.js';
 import { join, dirname } from 'path';
 
 createRequire(import.meta.url);

package/dist/{chunk-PVRBE7S4.js → chunk-ZODVSFI4.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-KF37SUDM.js';
+import { hostKeyPath, runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { generateKeyPairSync, createPrivateKey, createPublicKey, sign } from 'crypto';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 

package/dist/chunk-ZVB57WI6.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/job-state-format.ts
+var JOB_STATE_FORMAT = 1;
+var READ_JOB_STATE_FORMATS = [1];
+function jobStateFormatOf(job) {
+  return job.stateFormat ?? 1;
+}
+function readsJobState(job, formats) {
+  return formats.includes(jobStateFormatOf(job));
+}
+function jobStateFormatsAnswer() {
+  return { reads: [...READ_JOB_STATE_FORMATS], writes: JOB_STATE_FORMAT };
+}
+
+export { JOB_STATE_FORMAT, READ_JOB_STATE_FORMATS, jobStateFormatOf, jobStateFormatsAnswer, readsJobState };