@outerlayer/cli 0.5.1 → 0.7.0

package/dist/{chunk-RMAZ2NWA.js → chunk-DGAIVMMN.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { autoConnect } from './chunk-PUN7LMNS.js';
 import { detectActiveSession } from './chunk-BFESLKPP.js';
-import { sanitizeTerminal } from './chunk-WOBNRVQT.js';
-import { resolveRepoIdentity } from './chunk-EX6M5JPR.js';
+import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
+import { resolveRepoIdentity } from './chunk-D6FXM5OW.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
 import { defaultFetch } from './chunk-BCLJSQCV.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-BOLTI6LR.js';
@@ -79,6 +80,10 @@ function resolveCredentials(opts) {
   if (!resolved.ok) throw new WorkCommandError(resolved.message);
   return { url: resolved.url, apiKey: resolved.credential, appId: resolved.appId };
 }
+async function connectIfOneFits(opts) {
+  const refusal = await autoConnect(opts);
+  if (refusal !== void 0) throw new WorkCommandError(refusal);
+}
 function resolveRepository(repoFlag, cwd) {
   if (repoFlag) return repoFlag;
   const identity = resolveRepoIdentity(cwd);
@@ -299,6 +304,7 @@ async function runWorkBuild(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
   const home = opts.home ?? homeFromEnv(env);
+  await connectIfOneFits(opts);
   const { url, apiKey, appId } = resolveCredentials(opts);
   const fetchImpl = opts.fetchImpl ?? defaultFetch;
   const facts = environmentFacts({ cwd, env, home, sessionIdOverride: opts.sessionId });
@@ -337,6 +343,18 @@ async function runWorkBuild(opts) {
   return { data, output };
 }
 async function runWorkLinkSession(opts) {
+  try {
+    return await linkSession(opts);
+  } catch (err) {
+    if (opts.logFailures) {
+      const { logHookError } = await import('./hook-fast-XBOZ3N6L.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}`));
+    }
+    throw err;
+  }
+}
+async function linkSession(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
   const home = opts.home ?? homeFromEnv(env);
@@ -377,6 +395,7 @@ async function runWorkRemove(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
   const home = opts.home ?? homeFromEnv(env);
+  await connectIfOneFits(opts);
   const creds = resolveCredentials(opts);
   if (!opts.reason) {
     throw new WorkCommandError("--reason is required \u2014 a removal records why");
@@ -420,6 +439,7 @@ async function runWorkRemove(opts) {
 }
 async function runWorkStatus(opts) {
   const cwd = opts.cwd ?? process.cwd();
+  await connectIfOneFits(opts);
   const creds = resolveCredentials(opts);
   const fetchByItem = opts.item !== void 0 ? parsePositiveInt(opts.item, "--item") : void 0;
   if (fetchByItem !== void 0) {
@@ -449,6 +469,7 @@ async function runWorkStatus(opts) {
 }
 async function runWorkList(opts) {
   const cwd = opts.cwd ?? process.cwd();
+  await connectIfOneFits(opts);
   const { url, apiKey, appId } = resolveCredentials(opts);
   const fetchImpl = opts.fetchImpl ?? defaultFetch;
   const repository = opts.repo ?? resolveRepoIdentity(cwd).gitRepo;

package/dist/{chunk-3DD6AOWC.js → chunk-DTXOJDEH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { parseSize, MAX_ALLOW_HOSTS, allowHostProblem } from './chunk-F6GFZXZ3.js';
-import { isRefusedInConfig, resolveDestinations, isReservedVariable } from './chunk-AUFG23AA.js';
+import { isRefusedInConfig, resolveDestinations, isReservedVariable } from './chunk-OD2VTIHN.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { existsSync, statSync, accessSync, constants, readFileSync } from 'fs';
 import { hostname } from 'os';
@@ -30,6 +30,9 @@ var DEFAULT_CONCURRENCY = 1;
 var DEFAULT_POLL_SECONDS = 60;
 var DEFAULT_TIME_LIMIT_MINUTES = 480;
 var DEFAULT_IDLE_LIMIT_MINUTES = 30;
+var DEFAULT_CHECK_TIME_LIMIT_MINUTES = 10;
+var CHECKS_KEYS = ["timeLimitMinutes"];
+var MAX_CHECK_TIME_LIMIT_MINUTES = 240;
 var DEFAULT_BUILD = { memory: "8g", cpus: 4, pids: 4096, disk: "40g", variables: [] };
 var BUILD_KEYS = ["memory", "cpus", "pids", "disk", "variables", "destinations", "allowHosts"];
 var HOUSEKEEPING_KEYS = ["jobsKeepDays", "buildCacheMax", "minFreeDisk"];
@@ -81,6 +84,7 @@ var RUNNER_KEYS = [
   "hooks",
   "build",
   "housekeeping",
+  "checks",
   "autoUpdate"
 ];
 function runnerNumbers() {
@@ -199,6 +203,7 @@ function loadRunnerConfig(configPath) {
   checkBuiltinHooks(configPath, runner.hooks);
   const build = resolveBuild(configPath, runner.build);
   const housekeeping = resolveHousekeeping(configPath, runner.housekeeping, build.disk);
+  const checks = resolveChecks(configPath, runner.checks);
   if (config.scrub?.literals !== void 0 && !Array.isArray(config.scrub.literals)) {
     fail(configPath, "scrub.literals", "must be a list of strings");
   }
@@ -226,6 +231,7 @@ function loadRunnerConfig(configPath) {
     },
     build,
     housekeeping,
+    checks,
     // A host with executables of its own for provision and cleanup chose
     // its own environment, and an update could change what its hooks run
     // under; it opts in. The built-in hooks are the runner's own. Provision
@@ -275,6 +281,24 @@ function resolveHousekeeping(configPath, block, buildDisk) {
   if (minFreeDisk === void 0) fail(configPath, "runner.housekeeping.minFreeDisk", 'must be a size such as "40g"');
   return { jobsKeepDays: keys.jobsKeepDays ?? DEFAULT_JOBS_KEEP_DAYS, buildCacheMax, minFreeDisk };
 }
+function resolveChecks(configPath, block) {
+  const given = block ?? {};
+  if (typeof given !== "object" || Array.isArray(given)) fail(configPath, "runner.checks", "must be an object");
+  const keys = given;
+  for (const key of Object.keys(keys)) {
+    if (CHECKS_KEYS.includes(key)) continue;
+    const near = nearestKey(key, CHECKS_KEYS);
+    fail(configPath, `runner.checks.${key}`, near ? `is not a key this block accepts; did you mean ${near}?` : "is not a key this block accepts");
+  }
+  const limit = keys.timeLimitMinutes === void 0 ? DEFAULT_CHECK_TIME_LIMIT_MINUTES : keys.timeLimitMinutes;
+  if (!Number.isInteger(limit) || limit < 1) {
+    fail(configPath, "runner.checks.timeLimitMinutes", "must be a whole number of at least 1");
+  }
+  if (limit > MAX_CHECK_TIME_LIMIT_MINUTES) {
+    fail(configPath, "runner.checks.timeLimitMinutes", `must be at most ${MAX_CHECK_TIME_LIMIT_MINUTES}`);
+  }
+  return { timeLimitMinutes: limit };
+}
 function wholeBytes(bytes) {
   if (bytes === void 0) return void 0;
   const whole = Math.floor(bytes);
@@ -334,4 +358,4 @@ function resolveBuild(configPath, block) {
   };
 }
 
-export { RunnerConfigError, builtinKind, checkHooks, defaultRunnerConfigPath, hasRunnerBlock, isBuiltinContainer, isBuiltinProcess, isBuiltinVm, loadRunnerConfig, resolveBuild, runnerVmOf };
+export { DEFAULT_CHECK_TIME_LIMIT_MINUTES, RunnerConfigError, builtinKind, checkHooks, defaultRunnerConfigPath, hasRunnerBlock, isBuiltinContainer, isBuiltinProcess, isBuiltinVm, loadRunnerConfig, resolveBuild, runnerVmOf };

package/dist/{chunk-T52PKE2Y.js → chunk-E4PIFIC3.js}

@@ -1,29 +1,29 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { readDefaultBranchHead, cloneRepository, buildRepositoryImage, 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-Z62HNKEJ.js';
+import { readDefaultBranchHead, cloneRepository, buildRepositoryImage, 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-CEBIA5FD.js';
 import { startTimeOf, isSameProcess } from './chunk-N5FOE5PS.js';
 import { currentCliBuild } from './chunk-OGFGZQA3.js';
 import { createDockerHost, childEnvironment, spawnRun } from './chunk-774HEQL6.js';
 import { RecipeError } from './chunk-QOZKPLVJ.js';
-import { execCapture } from './chunk-W4SQCOZU.js';
-import { GUEST_CID } from './chunk-B2G7JHHB.js';
-import { WorkCommandError, postJson } from './chunk-RMAZ2NWA.js';
+import { execCapture } from './chunk-ZOAEPWGL.js';
+import { GUEST_CID } from './chunk-R7STSBLC.js';
+import { WorkCommandError, postJson } from './chunk-DGAIVMMN.js';
 import { parseDuKilobytes, hostAllowed } from './chunk-F6GFZXZ3.js';
-import { RELAY_PORT, CHECKOUT_DIR, JOB_MOUNT, claudeCredential, buildEnvironment, startBuildServices, AGENT_CREDENTIAL_MISSING, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT } from './chunk-AUFG23AA.js';
-import { defaultGitRunner, materializeContext } from './chunk-XDDW4FRS.js';
-import { readContextManifest, readSourceCache } from './chunk-WIOZAJ2W.js';
+import { RELAY_PORT, CHECKOUT_DIR, JOB_MOUNT, claudeCredential, buildEnvironment, startBuildServices, checkEnvironment, AGENT_CREDENTIAL_MISSING, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT } from './chunk-OD2VTIHN.js';
+import { defaultGitRunner, materializeContext } from './chunk-5FWNEQNZ.js';
+import { readContextManifest, readSourceCache } from './chunk-ZZXLM64C.js';
 import { signingFetchFor } from './chunk-BCLJSQCV.js';
 import { signerFor } from './chunk-M5POMKKW.js';
 import { rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, stagedContextDir, contextHomeDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, runnerDir, RUNNER_DIR_MODE, vmAssetsDir } from './chunk-ZM2IMMYN.js';
 import { relative, join, dirname, resolve, basename } from 'path';
+import { readFileSync, existsSync, mkdirSync, chmodSync, truncateSync, rmSync, writeFileSync, accessSync, constants, readdirSync, statSync, rmdirSync, realpathSync, renameSync, lstatSync, unlinkSync, openSync, closeSync, mkdtempSync, createWriteStream, createReadStream } from 'fs';
 import { spawnSync, spawn } from 'child_process';
 import { createHash, randomBytes } from 'crypto';
-import { existsSync, mkdirSync, chmodSync, truncateSync, rmSync, writeFileSync, realpathSync, renameSync, lstatSync, readFileSync, unlinkSync, readdirSync, openSync, closeSync, mkdtempSync, createWriteStream, statSync, createReadStream } from 'fs';
 import { createServer, request } from 'http';
 import { request as request$1 } from 'https';
 import { Transform } from 'stream';
 import { pipeline, finished } from 'stream/promises';
-import { createGunzip, gunzipSync, constants } from 'zlib';
+import { createGunzip, gunzipSync, constants as constants$1 } from 'zlib';
 import { isIP, connect, createServer as createServer$1 } from 'net';
 import { lookup } from 'dns/promises';
 import { networkInterfaces } from 'os';
@@ -255,6 +255,116 @@ var BuildTokens = class {
     );
   }
 };
+var BUILD_PREFIX = "build-";
+var LEAF = "runner";
+function serviceDirectory(selfCgroup, mount) {
+  const line = selfCgroup?.split("\n").find((l) => l.startsWith("0::"));
+  if (line === void 0) return void 0;
+  const path = line.slice(3).trim();
+  if (!path.endsWith(".service")) return void 0;
+  return join(mount, path);
+}
+function prepareRunnerCgroup(setup) {
+  if (setup.invocationId === void 0 || setup.invocationId === "") return void 0;
+  const root = serviceDirectory(setup.selfCgroup, setup.mount);
+  if (root === void 0) return void 0;
+  const { fs } = setup;
+  if (!fs.exists(root) || !fs.writable(join(root, "cgroup.procs"))) return void 0;
+  if (!(fs.read(join(root, "cgroup.controllers")) ?? "").split(/\s+/).includes("memory")) return void 0;
+  for (const name of fs.list(root)) {
+    if (!name.startsWith(BUILD_PREFIX)) continue;
+    try {
+      fs.rmdir(join(root, name));
+    } catch {
+    }
+  }
+  if (!fs.exists(join(root, LEAF))) fs.mkdir(join(root, LEAF));
+  fs.write(join(root, LEAF, "cgroup.procs"), String(setup.pid));
+  fs.write(join(root, "cgroup.subtree_control"), "+memory");
+  return { root };
+}
+var BUILD_RECLAIM_HEADROOM_BYTES = 256 * 1024 ** 2;
+var BUILD_KILL_HEADROOM_BYTES = 1024 ** 3;
+function createBuildCgroup(fs, root, buildId, buildMemoryBytes) {
+  const path = join(root, `${BUILD_PREFIX}${buildId}`);
+  fs.mkdir(path);
+  try {
+    fs.write(join(path, "memory.high"), String(buildMemoryBytes + BUILD_RECLAIM_HEADROOM_BYTES));
+    fs.write(join(path, "memory.max"), String(buildMemoryBytes + BUILD_KILL_HEADROOM_BYTES));
+    fs.write(join(path, "memory.swap.max"), "0");
+  } catch (err) {
+    removeBuildCgroup(fs, path);
+    throw err;
+  }
+  return path;
+}
+function outOfMemoryReason(memory) {
+  return `the build ran out of memory: the kernel killed its microVM at the limit of runner.build.memory (${memory ?? "8g"}) plus 1 GiB for Firecracker and its disks' page cache. Raise runner.build.memory, or lower runner.concurrency`;
+}
+function oomKills(fs, path) {
+  const match = /^oom_kill (\d+)$/m.exec(fs.read(join(path, "memory.events")) ?? "");
+  return match === null ? 0 : Number(match[1]);
+}
+function removeBuildCgroup(fs, path) {
+  try {
+    fs.rmdir(path);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function realCgroupFs() {
+  return {
+    exists: (path) => existsSync(path),
+    read: (path) => {
+      try {
+        return readFileSync(path, "utf8");
+      } catch {
+        return void 0;
+      }
+    },
+    write: (path, data) => writeFileSync(path, data),
+    mkdir: (path) => mkdirSync(path),
+    rmdir: (path) => rmdirSync(path),
+    list: (path) => readdirSync(path).filter((name) => statSync(join(path, name)).isDirectory()),
+    writable: (path) => {
+      try {
+        accessSync(path, constants.W_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var delegatedRoot;
+function setUpRunnerCgroup(over = {}) {
+  let selfCgroup;
+  try {
+    selfCgroup = readFileSync("/proc/self/cgroup", "utf8");
+  } catch {
+    selfCgroup = void 0;
+  }
+  let refusal;
+  try {
+    const prepared = prepareRunnerCgroup({ fs: realCgroupFs(), selfCgroup, pid: process.pid, invocationId: process.env.INVOCATION_ID, mount: "/sys/fs/cgroup", ...over });
+    delegatedRoot = prepared?.root;
+  } catch (err) {
+    delegatedRoot = void 0;
+    refusal = err instanceof Error ? err.message : String(err);
+  }
+  return { delegated: delegatedRoot !== void 0, ...refusal === void 0 ? {} : { refusal } };
+}
+function realCgroupPort() {
+  const fs = realCgroupFs();
+  return {
+    create: (buildId, bytes) => {
+      if (delegatedRoot === void 0) return void 0;
+      return createBuildCgroup(fs, delegatedRoot, buildId, bytes);
+    },
+    oomKills: (path) => oomKills(fs, path),
+    remove: (path) => removeBuildCgroup(fs, path)
+  };
+}
 var BranchPrepareError = class extends Error {
 };
 var OWN_PREFIX = "outerlayer/";
@@ -431,12 +541,12 @@ function containerRunArgs(input) {
       "--forward",
       `${DESTINATION_BASE_PORT + index}=${JOB_MOUNT}/dest-${index}.sock`
     ]).flat(),
-    ...[
+    ...input.builtIns === true ? [
       "--forward",
       `${GATEWAY_PORT}=${JOB_MOUNT}/${GATEWAY_SOCKET}`,
       "--forward",
       `${CLAUDE_PORT}=${JOB_MOUNT}/${CLAUDE_SOCKET}`
-    ] 
+    ] : []
   ];
 }
 function prepareRunArgs(input) {
@@ -747,7 +857,9 @@ function machineConfig(limits2, paths) {
   };
 }
 function firecrackerCommand(input) {
-  return { command: input.binary, args: ["--no-api", "--config-file", input.configPath] };
+  const args = ["--no-api", "--config-file", input.configPath];
+  if (input.cgroup === void 0) return { command: input.binary, args };
+  return { command: "sh", args: ["-c", 'echo $$ > "$1/cgroup.procs" && shift && exec "$@"', "sh", input.cgroup, input.binary, ...args] };
 }
 var STOP_WAIT_MS = 1e4;
 var POLL_MS = 20;
@@ -804,6 +916,7 @@ function createMicroVmPorts(over = {}) {
     assets: over.assets ?? ((runnerDir2) => ensureAssets({ runnerDir: runnerDir2 })),
     rootfs: over.rootfs ?? createRootfsHost(),
     firecracker: over.firecracker ?? createFirecrackerHost(),
+    cgroup: over.cgroup ?? realCgroupPort(),
     exec: over.exec ?? execCapture
   };
 }
@@ -1093,7 +1206,7 @@ function decode(prefix, gzip) {
   if (!gzip) return prefix;
   try {
     const { compressedWindow, inflatedBytes } = limits();
-    return gunzipSync(prefix.subarray(0, compressedWindow), { finishFlush: constants.Z_SYNC_FLUSH, maxOutputLength: inflatedBytes });
+    return gunzipSync(prefix.subarray(0, compressedWindow), { finishFlush: constants$1.Z_SYNC_FLUSH, maxOutputLength: inflatedBytes });
   } catch (err) {
     const code = err.code;
     if (code === "ERR_BUFFER_TOO_LARGE") return refused(TOO_LONG);
@@ -1429,6 +1542,11 @@ function createGitRemote(options) {
       req.resume();
       return plain(res, 404, "not found\n");
     }
+    if (options.readOnly === true && (route.kind === "receive-pack" || route.kind === "info-refs" && route.service === "git-receive-pack")) {
+      log(`push refused: this remote is read-only`);
+      req.resume();
+      return plain(res, 403, "this remote is read-only: a check cannot push\n");
+    }
     const own = isOwnRepository(options.repository, route.owner, route.name);
     if (own && route.kind === "receive-pack") return push(req, res, route);
     let kind = route.kind === "info-refs" && route.service === "git-receive-pack" ? "push" : "read";
@@ -1437,6 +1555,7 @@ function createGitRemote(options) {
       body = await readBody(req, maxLfsBodyBytes);
       if (body === void 0) return plain(res, 413, "the request is too large\n");
       kind = isLfsUpload(body) ? "push" : "read";
+      if (options.readOnly === true && kind === "push") return plain(res, 403, "this remote is read-only: a check cannot upload\n");
     }
     let authorization;
     if (own) {
@@ -1913,7 +2032,8 @@ function gitRemoteFor(runtime, input) {
     onWorkflowRefused: () => {
       input.tokens.reason = WORKFLOW_PERMISSION_REASON;
     },
-    log: input.log
+    log: input.log,
+    ...input.readOnly === true ? { readOnly: true } : {}
   });
 }
 function firstLine4(text) {
@@ -1997,7 +2117,8 @@ async function provisionContainer(input) {
     repository,
     imageId: report.imageId,
     containerEnv: report.apply.containerEnv,
-    builtIns: true
+    builtIns: true,
+    lifecycle: report.apply.lifecycle
   };
   const env = buildEnvironment({
     config,
@@ -2063,7 +2184,9 @@ async function provisionContainer(input) {
     image: report.imageId,
     user: ADDED_USER,
     limits: limits2,
-    destinations: config.build?.destinations?.length ?? 0};
+    destinations: config.build?.destinations?.length ?? 0,
+    builtIns: true
+  };
   const prepared = await host.run(prepareRunArgs(runInput), { logPath });
   if (prepared.status !== 0) return dockerFailed("preparing the build's volume", prepared);
   const started = await host.run(containerRunArgs(runInput), { logPath });
@@ -2149,6 +2272,40 @@ function containerCommandLine(input) {
     env: { ...childEnvironment(input.runtime.hostEnv), ...env.passed }
   };
 }
+function containerSenderCommand(input) {
+  const state = input.job.container;
+  const env = buildEnvironment({
+    config: input.config,
+    item: input.job.item,
+    itemKey: input.job.itemKey,
+    branch: input.job.branch,
+    repository: state.repository,
+    hostEnv: input.runtime.hostEnv,
+    containerEnv: state.containerEnv ?? {},
+    builtIns: state.builtIns === true,
+    identity: input.job.commitIdentity
+  });
+  const args = containerExecArgs({
+    container: state.container,
+    user: state.agentUser ?? ADDED_USER,
+    workdir: CHECKOUT_DIR,
+    env,
+    argv: ["outerlayer", "session-sender"]
+  });
+  return { command: "docker", args: ["exec", ...args], env: { ...childEnvironment(input.runtime.hostEnv), ...env.passed } };
+}
+function senderSignalScript(pidfile, signal) {
+  const file = shellQuote(pidfile);
+  return `p="$(cat ${file})" && [ -n "$p" ] && grep -qa session-sender "/proc/$p/cmdline" && kill -${signal} "$p"`;
+}
+async function signalInContainer(runtime, state, pidfile, signal) {
+  await runtime.host.exec({
+    container: state.container,
+    user: state.agentUser ?? ADDED_USER,
+    env: NO_ENV,
+    argv: ["/bin/sh", "-c", senderSignalScript(pidfile, signal)]
+  });
+}
 async function stopContainer(runtime, state) {
   await runtime.host.stop(state.container);
   state.stopped = true;
@@ -2246,5 +2403,75 @@ async function cleanupContainer(runtime, state, jobDir) {
   rmSync(state.buildDir, { recursive: true, force: true });
   if (failures.length > 0) throw new Error(failures.join("; "));
 }
+async function startCheckContainer(input) {
+  const { config, runtime, job, jobDir, tokens, log } = input;
+  const { host } = runtime;
+  const tag = `#${job.item}`;
+  const built = job.container;
+  const repository = built?.repository ?? job.repository;
+  if (built === void 0 || built.imageId === void 0 || repository === void 0 || job.branch === void 0) {
+    return { ok: false, reason: "the build's image, repository or branch is not recorded" };
+  }
+  const buildId = randomBytes(6).toString("hex");
+  const name = `outerlayer-check-${buildId}`;
+  const buildDir2 = buildDir(config.configPath, buildId);
+  const agentUser = built.agentUser ?? ADDED_USER;
+  const state = { buildId, container: name, volume: name, buildDir: buildDir2, repository, imageId: built.imageId, agentUser };
+  const checksDir = join(jobDir, "checks");
+  mkdirSync(checksDir, { recursive: true });
+  const logPath = join(checksDir, "environment.log");
+  input.save(state);
+  const fail = async (reason) => {
+    try {
+      await cleanupContainer(runtime, state);
+    } catch (err) {
+      log.error(`${tag} cleanup of the check environment failed: ${describeCallFailure(err)}`);
+    }
+    return { ok: false, reason };
+  };
+  const dockerFailed = (what, result) => fail(`${what} failed (exit ${result.status})${firstLine4(result.stderr) === "" ? "" : `: ${firstLine4(result.stderr)}`}`);
+  mkdirSync(buildDir2, { recursive: true });
+  chmodSync(buildDir2, 493);
+  try {
+    const gitRemote = gitRemoteFor(runtime, { repository, branch: job.branch, tokens, buildDir: buildDir2, log: (line) => log.line(`${tag} ${line}`), readOnly: true });
+    runtime.tunnels.set(buildId, await startServicesFor(runtime, config, buildDir2, checksDir, void 0, false, gitRemote));
+  } catch (err) {
+    return fail(`the tunnel could not start: ${describeCallFailure(err)}`);
+  }
+  const limits2 = { memory: config.build?.memory ?? "8g", cpus: config.build?.cpus ?? 4, pids: config.build?.pids ?? 4096 };
+  const runnerId = runnerLabelValue(config.configPath);
+  const volume = await host.createVolume(name, { [BUILD_LABEL]: buildId, [RUNNER_LABEL]: runnerId });
+  if (volume.status !== 0) return dockerFailed("creating the check environment's volume", volume);
+  const runInput = {
+    buildId,
+    runnerId,
+    container: name,
+    volume: name,
+    buildDir: buildDir2,
+    image: built.imageId,
+    user: ADDED_USER,
+    limits: limits2,
+    destinations: config.build?.destinations?.length ?? 0,
+    builtIns: false
+  };
+  const prepared = await host.run(prepareRunArgs(runInput), { logPath });
+  if (prepared.status !== 0) return dockerFailed("preparing the check environment's volume", prepared);
+  const started = await host.run(containerRunArgs(runInput), { logPath });
+  if (started.status !== 0) return dockerFailed("starting the check environment's container", started);
+  if (!await waitForRelay(runtime, state)) return fail("the relay in the check environment's container did not start");
+  const env = checkEnvironment({ config, item: job.item, repository, hostEnv: runtime.hostEnv, containerEnv: built.containerEnv ?? {} });
+  return {
+    ok: true,
+    container: {
+      state,
+      exec: (argv, workdir, opts) => host.exec({ container: name, user: agentUser, workdir, env, argv }, opts?.logPath === void 0 ? void 0 : { logPath: opts.logPath }),
+      restart: async () => {
+        await host.stop(name);
+        const again = await host.start(name);
+        return again.status === 0 && await waitForRelay(runtime, state);
+      }
+    }
+  };
+}
 
-export { ADDED_USER, AgentUserError, AssetError, BUILD_LABEL, BuildTokens, GH_CONFIG_YML, MIN_ENGINE_MAJOR, RUNNER_LABEL, classifyRefusal, cleanupContainer, containerCommandLine, createBuildDisk, createContainerRuntime, createRunnerLog, deleteBuildDisk, describeCallFailure, ensureRootfs, ensureTunnel, formatClock, formatDuration, ghHostsYml, gitRemoteFor, isLiteralAddress, keepGhConfigCurrent, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, prepareBranch, provisionContainer, refusalCode, relativeToRunner, removeStagedContext, resolveAgentUser, retrySend, runBuildSteps, runnerLabelValue, shellQuote, shortClaim, stageGovernedContext, startServicesFor, stopContainer, syncInContainer };
+export { ADDED_USER, AgentUserError, AssetError, BUILD_LABEL, BuildTokens, GH_CONFIG_YML, MIN_ENGINE_MAJOR, RUNNER_LABEL, classifyRefusal, cleanupContainer, containerCommandLine, containerSenderCommand, createBuildDisk, createContainerRuntime, createRunnerLog, deleteBuildDisk, describeCallFailure, ensureRootfs, ensureTunnel, formatClock, formatDuration, ghHostsYml, gitRemoteFor, isLiteralAddress, keepGhConfigCurrent, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, outOfMemoryReason, prepareBranch, provisionContainer, refusalCode, relativeToRunner, removeStagedContext, resolveAgentUser, retrySend, runBuildSteps, runnerLabelValue, senderSignalScript, setUpRunnerCgroup, shellQuote, shortClaim, signalInContainer, stageGovernedContext, startCheckContainer, startServicesFor, stopContainer, syncInContainer };

package/dist/{chunk-H5NCNVDA.js → chunk-EV3M3EH7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-EMY4I27X.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-VXLJORHL.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-7ZR5UPMB.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';
 

package/dist/chunk-FBTE2A2X.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/vm/service.ts
+var VM_SERVICE_NAME = "outerlayer-runner";
+var UNIT_MARKER = "# Written by outerlayer runner install --service; edit the runner config, not this file.";
+var STOP_MARGIN_MINUTES = 10;
+function escapeUnitPath(path) {
+  return path.replace(/%/g, "%%").replace(/ /g, "\\x20");
+}
+function runnerUnit(unit) {
+  return `${UNIT_MARKER}
+[Unit]
+Description=OuterLayer runner
+After=network-online.target${unit.docker ? " docker.service" : ""}
+Wants=network-online.target
+${unit.docker ? "Requires=docker.service\n" : ""}
+[Service]
+User=${unit.user}
+ExecStart=${unit.execStart}
+EnvironmentFile=-${escapeUnitPath(`${unit.configDir}/runner.env`)}
+Restart=on-failure
+RestartForceExitStatus=75
+RestartSec=30
+KillSignal=SIGTERM
+KillMode=mixed
+TimeoutStopSec=${unit.timeLimitMinutes + STOP_MARGIN_MINUTES}min
+OOMPolicy=continue
+Delegate=yes
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+
+export { UNIT_MARKER, VM_SERVICE_NAME, runnerUnit };

package/dist/{chunk-DVDEBNQJ.js → chunk-GQD22KKN.js}

@@ -27,7 +27,12 @@ function launchesPath(home) {
 }
 function appendLaunchRecord(input, home) {
   mkdirSync(join(home, ".outerlayer", "spool"), { recursive: true });
-  const record = { sessionId: input.sessionId, item: input.item, t: input.t ?? (/* @__PURE__ */ new Date()).toISOString() };
+  const record = {
+    sessionId: input.sessionId,
+    item: input.item,
+    ...input.job === void 0 ? {} : { job: input.job },
+    t: input.t ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
   appendFileSync(launchesPath(home), `${JSON.stringify(record)}
 `);
 }
@@ -75,22 +80,28 @@ function launchedItemsBySession(home, readImpl = readLaunchSpool) {
 }
 function readLaunchSpoolState(home, readImpl = readLaunchSpool) {
   const ids = /* @__PURE__ */ new Set();
+  const records = /* @__PURE__ */ new Map();
   const read = readImpl(launchesPath(home));
-  if (read.kind === "unreadable") return { ids, unreadable: read.reason };
-  if (read.kind === "absent") return { ids };
+  if (read.kind === "unreadable") return { ids, records, unreadable: read.reason };
+  if (read.kind === "absent") return { ids, records };
   let malformedLines = 0;
   for (const line of read.text.split("\n")) {
     const text = line.trim();
     if (!text) continue;
     try {
       const record = JSON.parse(text);
-      if (typeof record.sessionId === "string" && record.sessionId !== "") ids.add(record.sessionId);
-      else malformedLines += 1;
+      if (typeof record.sessionId === "string" && record.sessionId !== "") {
+        ids.add(record.sessionId);
+        records.set(record.sessionId, {
+          ...typeof record.item === "number" ? { item: record.item } : {},
+          ...typeof record.job === "string" ? { job: record.job } : {}
+        });
+      } else malformedLines += 1;
     } catch {
       malformedLines += 1;
     }
   }
-  return { ids, ...malformedLines > 0 ? { malformedLines } : {} };
+  return { ids, records, ...malformedLines > 0 ? { malformedLines } : {} };
 }
 
 export { appendLaunchRecord, launchStatusIsDecisive, launchedItemForSession, launchedItemsBySession, launchesPath, parseWorkItemEnv, readLaunchSpoolState };

package/dist/{chunk-BCJNHMZT.js → chunk-HHJDN6AU.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { readLaunchSpoolState, launchesPath } from './chunk-DVDEBNQJ.js';
+import { readLaunchSpoolState, launchesPath } from './chunk-GQD22KKN.js';
 
 createRequire(import.meta.url);
 
@@ -17,18 +17,33 @@ function launchRefusalForSession(sessionId, home) {
   return `this session was not launched with OUTERLAYER_WORK naming a work item, so nothing it produces may leave the machine. Start the session with OUTERLAYER_WORK set (for example OUTERLAYER_WORK=42), or run this from CI.`;
 }
 var LaunchFilter = class {
-  constructor(launchedSessionIds) {
+  /**
+   * `records`, when given, scopes a live sender:
+   * - a build sender (`build`) admits only a session launched for its item in its own job; a record with no job
+   *   is one an older hook wrote, which is admitted on the item alone;
+   * - any other live sender skips a session launched inside a runner job, which only that job's sender sends.
+   * `sync` passes no records and decides by the launch record's existence alone.
+   */
+  constructor(launchedSessionIds, records, build) {
     this.launchedSessionIds = launchedSessionIds;
+    this.records = records;
+    this.build = build;
     /** Sessions dropped for carrying no launch record — for the sync summary. */
     this.skippedTotal = 0;
   }
   /** True when the session should sync. Records skips for reporting. */
   allows(session) {
     const key = session.subagent?.parentSessionId ?? session.id;
-    const allowed = typeof key === "string" && this.launchedSessionIds.has(key);
+    const allowed = typeof key === "string" && this.launchedSessionIds.has(key) && this.inScope(this.records?.get(key));
     if (!allowed) this.skippedTotal += 1;
     return allowed;
   }
+  inScope(facts) {
+    if (this.build !== void 0) {
+      return facts !== void 0 && facts.item === this.build.item && (facts.job === void 0 || facts.job === this.build.jobDir);
+    }
+    return facts?.job === void 0;
+  }
 };
 
 export { LaunchFilter, launchRefusalForSession };