@outerlayer/cli 0.5.0 → 0.6.0

package/dist/{chunk-EGABNHZG.js → chunk-UMFWVGJO.js}

@@ -1,29 +1,104 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { applyContextProvenance, installScrubContext, prepareSessionForUpload, wholeSessionCounts, sliceTurnIo } from './chunk-ZOC7JSYC.js';
-import { LaunchFilter } from './chunk-BCJNHMZT.js';
+import { LaunchFilter } from './chunk-HHJDN6AU.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
 import { hookExecSpoolPath } from './chunk-F7CU5ABH.js';
 import { applyReportedCost } from './chunk-BKO6JEZI.js';
-import { migrateLegacyArtifactSidecars, planArtifactUpload, artifactsStatePath, sanitizeTerminal, artifactBlobsDir, resolveArtifactTurnIndex, isArtifactTombstoned, ARTIFACT_RETRY_MAX_AGE_MS, writeArtifactSpoolState, reclaimUnneededArtifactBlobs, neededArtifactShas } from './chunk-WOBNRVQT.js';
-import { tailTranscript, enrichSessionRepo, CAPTURE_TIERS, scanAll, setRepoRoot, resolveRepoIdentity, inferArtifactKind, bannedPathsForTier, sessionIdFromPath, SOURCE_ADAPTERS, EVENT_TYPES } from './chunk-EX6M5JPR.js';
+import { migrateLegacyArtifactSidecars, planArtifactUpload, artifactsStatePath, sanitizeTerminal, artifactBlobsDir, resolveArtifactTurnIndex, isArtifactTombstoned, ARTIFACT_RETRY_MAX_AGE_MS, writeArtifactSpoolState, reclaimUnneededArtifactBlobs, neededArtifactShas } from './chunk-3DEVYTNQ.js';
+import { setCustomScrubbers, setLocalIdentity, tailTranscript, enrichSessionRepo, CAPTURE_TIERS, scanAll, setRepoRoot, resolveRepoIdentity, inferArtifactKind, bannedPathsForTier, sessionIdFromPath, scrubDeep, downconvertSession, isHumanUserTurn, turnCountBound, SOURCE_ADAPTERS, EVENT_TYPES } from './chunk-ANK2B36Y.js';
 import { C } from './chunk-YRYMNBGQ.js';
-import { readLaunchSpoolState, launchStatusIsDecisive, launchedItemsBySession, launchesPath } from './chunk-DVDEBNQJ.js';
+import { readLaunchSpoolState, launchStatusIsDecisive, launchedItemsBySession, launchesPath } from './chunk-GQD22KKN.js';
 import { readLatestProvenanceForSession, readContextProvenance } from './chunk-ZJSNLVCE.js';
 import { defaultFetch } from './chunk-BCLJSQCV.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-BOLTI6LR.js';
 import { readCloudConfig, cloudConfigPath, writeCloudConfig } from './chunk-EABW6AJQ.js';
 import { signerFor, signRunnerRequest } from './chunk-M5POMKKW.js';
-import { writeSyncStatus, spoolDir } from './chunk-UFFXNXLQ.js';
+import { writeSyncStatus, spoolDir } from './chunk-FA2BOX4O.js';
 import { removeJournalHooks } from './chunk-XCCLFVXM.js';
 import { readRepoConnection, findGitDirs } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { dirname, basename, join } from 'path';
 import { statSync, readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, existsSync, rmSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { hostname, userInfo } from 'os';
 import { fileURLToPath } from 'url';
 import { createRequire as createRequire$1 } from 'module';
 
 createRequire(import.meta.url);
+function detectCi(env = process.env) {
+  return env.CI === "true" || env.CI === "1" || !!env.JENKINS_URL;
+}
+function gitGlobalConfig(key) {
+  try {
+    return execFileSync("git", ["config", "--global", key], { encoding: "utf8", timeout: 2e3 }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function installScrubContext(home, scrub) {
+  setCustomScrubbers(scrub);
+  setLocalIdentity({
+    name: gitGlobalConfig("user.name"),
+    email: gitGlobalConfig("user.email"),
+    username: (() => {
+      try {
+        return userInfo().username;
+      } catch {
+        return void 0;
+      }
+    })(),
+    hostname: (() => {
+      try {
+        return hostname();
+      } catch {
+        return void 0;
+      }
+    })(),
+    home
+  });
+}
+function applyContextProvenance(session, record) {
+  if (!record) return;
+  if (record.repository !== void 0) session.env.contextSourceRepo = record.repository;
+  if (record.ref !== void 0) session.env.contextSourceRef = record.ref;
+  if (record.sha !== null) session.env.contextSourceSha = record.sha;
+  session.env.contextSourceVerification = record.verification;
+}
+function prepareSessionForUpload(session, tier, envVars = process.env) {
+  setRepoRoot(resolveRepoIdentity(session.env.cwd).repoRoot);
+  scrubDeep(session);
+  session.workerKind ??= detectCi(envVars) ? "ci" : "seat";
+  return downconvertSession(session, tier);
+}
+var MAX_TOOL_IO_CHARS = 64e3;
+function sliceToolIo(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  if (typeof text !== "string" || text.length <= MAX_TOOL_IO_CHARS) return value;
+  return `${text.slice(0, MAX_TOOL_IO_CHARS)}\u2026[sliced: ${text.length} chars exceeded the sync per-call cap]`;
+}
+function sliceTurnIo(turn) {
+  return {
+    ...turn,
+    toolCalls: (turn.toolCalls ?? []).map((call) => ({
+      ...call,
+      ...call.input !== void 0 ? { input: sliceToolIo(call.input) } : {},
+      ...call.output !== void 0 ? { output: sliceToolIo(call.output) } : {}
+    }))
+  };
+}
+function wholeSessionCounts(turns) {
+  const allCalls = turns.flatMap((t) => t.toolCalls ?? []);
+  return {
+    // An index BOUND (`1 + max(turn.index)`), not the shipped turn count —
+    // turn indexes are not guaranteed dense from zero, and a late artifact
+    // anchored at its real turn index must still validate against the
+    // summary row this produces (see turnCountBound).
+    turns: turnCountBound(turns),
+    toolCalls: allCalls.length,
+    errors: allCalls.filter((c) => c.status === "error").length,
+    userTurns: turns.filter(isHumanUserTurn).length
+  };
+}
 var IRRELEVANT = /* @__PURE__ */ new Set(["__tests__", "__mocks__", "node_modules"]);
 function newestSourceMs(dir) {
   let newest = 0;
@@ -481,6 +556,8 @@ function retryAfterMs(response) {
 }
 var LiveUploader = class {
   constructor(opts) {
+    /** Set by `stop()`: no more debounce or retry waits, so what is pending is sent once and given up on. */
+    this.stopping = false;
     this.cycles = /* @__PURE__ */ new Map();
     /** Sessions this sender is done with: ended, or permanently rejected. The
      * daemon keeps mirroring a transcript after its session closes, and every
@@ -491,12 +568,31 @@ var LiveUploader = class {
      * every session, so the sender stops entirely for the rest of this
      * process rather than retrying session by session. */
     this.stopped = false;
+    this.warned = /* @__PURE__ */ new Set();
     this.home = opts.home;
     this.fetchImpl = opts.fetchImpl ?? fetch;
     this.sleepImpl = opts.sleepImpl ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     this.debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
     this.env = opts.env ?? process.env;
     this.stderr = opts.stderr ?? ((s) => void process.stderr.write(s));
+    this.build = opts.build;
+    this.onUnauthorized = opts.onUnauthorized;
+  }
+  /**
+   * Final pass for a build sender: sends what is pending now, without waiting out the debounce and without
+   * retrying a failed send, and resolves once every cycle has finished or `timeoutMs` has passed.
+   */
+  async stop(timeoutMs) {
+    this.stopping = true;
+    let timer;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(resolve, timeoutMs);
+    });
+    try {
+      await Promise.race([this.flush(), expired]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
   /** Called for every daemon `mirrored` event. Cheap and synchronous — the
    * actual read/send work happens on the debounced cycle. */
@@ -536,7 +632,7 @@ var LiveUploader = class {
       for (; ; ) {
         for (; ; ) {
           const generationAtWaitStart = cycle.generation;
-          await this.sleepImpl(this.debounceMs);
+          if (!this.stopping) await this.sleepImpl(this.debounceMs);
           if (cycle.generation !== generationAtWaitStart) continue;
           break;
         }
@@ -562,8 +658,21 @@ var LiveUploader = class {
     const priorEntry = state.sessions[key];
     if (priorEntry?.ended || priorEntry?.failed) return true;
     const cloudConfig = readCloudConfig(this.home);
-    if (cloudConfig.autoSync === false) return false;
-    if (!cloudConfig.url || !(cloudConfig.apiKey || cloudConfig.accountToken)) return false;
+    let destination;
+    if (this.build === void 0) {
+      if (cloudConfig.autoSync === false) return false;
+      if (!cloudConfig.url || !(cloudConfig.apiKey || cloudConfig.accountToken)) return false;
+    } else {
+      const url = this.env.OUTERLAYER_URL;
+      const credential = this.env.OUTERLAYER_API_KEY;
+      const appId = this.env.OUTERLAYER_APP_ID;
+      if (!url || !credential || !appId) {
+        this.warnOnce("incomplete", `live upload is idle: this build's environment lacks ${[!url && "OUTERLAYER_URL", !credential && "OUTERLAYER_API_KEY", !appId && "OUTERLAYER_APP_ID"].filter(Boolean).join(", ")}, so nothing streams until \`outerlayer sync\` runs.
+`);
+        return false;
+      }
+      destination = { ok: true, url, credential, appId, kind: "key" };
+    }
     const info = subagentInfo(mirrorPath);
     const tail = tailTranscript(mirrorPath, void 0, {
       isSubagent: info.isSubagent,
@@ -573,17 +682,16 @@ var LiveUploader = class {
     if (!tail.session) return false;
     const session = tail.session;
     enrichSessionRepo(session);
-    const destination = resolveGatewayCredentials({ home: this.home, env: {}, cwd: session.env.cwd ?? "/" });
+    destination ??= resolveGatewayCredentials({ home: this.home, env: {}, cwd: session.env.cwd ?? "/" });
     if (!destination.ok) return false;
-    const repoFilter = new RepoFilter(cloudConfig.repos);
-    if (!repoFilter.allows(session.env.gitRepo)) return false;
+    if (this.build === void 0 && !new RepoFilter(cloudConfig.repos).allows(session.env.gitRepo)) return false;
     const launchSpool = readLaunchSpoolState(this.home);
     if (!launchStatusIsDecisive(launchSpool)) return false;
-    const launchFilter = new LaunchFilter(launchSpool.ids);
+    const launchFilter = new LaunchFilter(launchSpool.ids, launchSpool.records, this.build);
     if (!launchFilter.allows(session)) return false;
     let tier;
     try {
-      tier = resolveTier(cloudConfig.tier);
+      tier = resolveTier(this.build === void 0 ? cloudConfig.tier : this.env.OUTERLAYER_TIER ?? cloudConfig.tier);
     } catch (err) {
       if (err instanceof SyncConfigError) return false;
       throw err;
@@ -613,6 +721,7 @@ var LiveUploader = class {
       const outcome = await this.sendWithRetry(endpoint, destination.credential, destination.appId, prepared.id, payload);
       if (outcome === "unauthorized") {
         this.stopped = true;
+        this.onUnauthorized?.();
         this.stderr(
           destination.credential.startsWith("olu_") ? `live upload stopped: the login was refused (expired or revoked). No session streams from this daemon until you run \`outerlayer login\` and it restarts.
 ` : `live upload stopped: the API key was refused. No session streams from this daemon until it restarts with a valid key.
@@ -620,8 +729,9 @@ var LiveUploader = class {
         );
         return true;
       }
+      if (outcome === "unreachable") return false;
       if (outcome === "rejected") {
-        const reason = "the server refused this delta permanently";
+        const reason = `the server refused this delta permanently${this.lastRejectStatus === void 0 ? "" : ` (HTTP ${this.lastRejectStatus})`}`;
         this.mergeSessionState(key, {
           ackedTurnIndex: currentAcked,
           failed: true,
@@ -654,6 +764,7 @@ var LiveUploader = class {
    * key bound to a host key is refused on every route unless that key signed the request. A login token is
    * never signed: only the saved factory key is bound to a host key. */
   async signatureHeaders(endpoint, body, credential) {
+    if (this.build !== void 0) return {};
     if (readCloudConfig(this.home).apiKey !== credential) return {};
     let signer;
     try {
@@ -664,6 +775,12 @@ var LiveUploader = class {
     if (signer === void 0) return {};
     return { ...await signRunnerRequest({ method: "POST", url: endpoint, body: new TextEncoder().encode(body), signer }) };
   }
+  /** Writes `message` the first time `key` is seen, so a condition that holds on every fire logs once. */
+  warnOnce(key, message) {
+    if (this.warned.has(key)) return;
+    this.warned.add(key);
+    this.stderr(message);
+  }
   /** Sends one request, retrying a network error or a retryable 5xx forever
    * with exponential backoff (2s → 60s cap) — the daemon runs unattended, so
    * there is no bounded attempt count. A 401 or a permanent 4xx/rejection
@@ -673,6 +790,7 @@ var LiveUploader = class {
     let delayMs = RETRY_BASE_DELAY_MS;
     for (; ; ) {
       let response;
+      let failure = "";
       try {
         const signature = await this.signatureHeaders(endpoint, body, apiKey);
         response = await this.fetchImpl(endpoint, {
@@ -685,18 +803,30 @@ var LiveUploader = class {
           },
           body
         });
-      } catch {
+      } catch (err) {
         response = void 0;
+        failure = err instanceof Error ? err.message : String(err);
       }
       if (response) {
         if (response.status === 401) return "unauthorized";
         if (response.ok) {
           const accepted = await acceptedSessionIds(response);
-          if (accepted) return accepted.includes(sessionId) ? "accepted" : "rejected";
+          if (accepted) {
+            if (accepted.includes(sessionId)) return "accepted";
+            this.lastRejectStatus = void 0;
+            return "rejected";
+          }
         } else if (!RETRYABLE_STATUSES.has(response.status)) {
+          this.lastRejectStatus = response.status;
           return "rejected";
         }
       }
+      if (this.build !== void 0) {
+        const why = response === void 0 ? failure : `the gateway answered ${response.status}`;
+        this.stderr(`live upload of session ${sessionId} failed: ${why}${this.stopping ? "" : " \xB7 retrying"}
+`);
+      }
+      if (this.stopping) return "unreachable";
       await this.sleepImpl(Math.max(retryAfterMs(response), delayMs));
       delayMs = Math.min(delayMs * 2, RETRY_MAX_DELAY_MS);
     }
@@ -1683,4 +1813,4 @@ ${C.yellow}!${C.reset} batch ${shippedBatches + 1}/${batches.length} accounting
   }
 }
 
-export { CHUNK_PART_TARGET_BYTES, LiveUploader, RETRYABLE_STATUSES, SyncConfigError, SyncTransportError, isLoopbackUrl, resolveTier, runSync, staleBuildRefusal, staleBuildWarning };
+export { CHUNK_PART_TARGET_BYTES, LiveUploader, RETRYABLE_STATUSES, SyncConfigError, SyncTransportError, detectCi, installScrubContext, isLoopbackUrl, resolveTier, runSync, staleBuildRefusal, staleBuildWarning };

package/dist/{chunk-RWOTHXYE.js → chunk-VMJ3MMBX.js}

@@ -1,27 +1,29 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
+import { writeJobFile, readJobFile } from './chunk-T6OIJQRT.js';
+import { senderPidfile } from './chunk-ZILGTTY6.js';
 import { DOCKERD_LOG } from './chunk-CBPPJSAR.js';
-import { installScrubContext } from './chunk-ZOC7JSYC.js';
-import { AssetError, describeCallFailure, obtainImage, ensureRootfs, gitRemoteFor, startServicesFor, createBuildDisk, machineConfig, refusalCode, resolveAgentUser, AgentUserError, runBuildSteps, removeStagedContext, stageGovernedContext, shellQuote, ADDED_USER, createRunnerLog, createContainerRuntime, stopContainer, syncInContainer, formatDuration, cleanupContainer, retrySend, formatClock, GH_CONFIG_YML, ghHostsYml, isLiteralAddress, deleteBuildDisk } from './chunk-4NMBDRBS.js';
+import { installScrubContext } from './chunk-UMFWVGJO.js';
+import { AssetError, describeCallFailure, obtainImage, ensureRootfs, gitRemoteFor, startServicesFor, createBuildDisk, machineConfig, refusalCode, resolveAgentUser, AgentUserError, runBuildSteps, removeStagedContext, stageGovernedContext, shellQuote, createRunnerLog, createContainerRuntime, stopContainer, syncInContainer, formatDuration, cleanupContainer, retrySend, formatClock, containerSenderCommand, GH_CONFIG_YML, ghHostsYml, ADDED_USER, isLiteralAddress, signalInContainer, deleteBuildDisk, senderSignalScript } from './chunk-RZSF5B46.js';
 import { CLAUDE_CODE_VERSION } from './chunk-Z62HNKEJ.js';
 import { isSameProcess, startTimeOf } from './chunk-N5FOE5PS.js';
 import { childEnvironment } from './chunk-774HEQL6.js';
 import { waitForAgent, vmExecArgs } from './chunk-W4SQCOZU.js';
 import { socketPathProblem, vsockLinks, linkVsockSockets } from './chunk-B2G7JHHB.js';
-import { WorkCommandError, postJson, isSignatureRefusal, getJson } from './chunk-RMAZ2NWA.js';
-import { planArtifactUpload } from './chunk-WOBNRVQT.js';
-import { scrubText } from './chunk-EX6M5JPR.js';
-import { isBuiltinContainer, isBuiltinProcess, isBuiltinVm } from './chunk-5Y3QQRUH.js';
+import { WorkCommandError, postJson, isSignatureRefusal, getJson } from './chunk-BNMCXPG7.js';
+import { planArtifactUpload } from './chunk-3DEVYTNQ.js';
+import { scrubText } from './chunk-ANK2B36Y.js';
+import { isBuiltinContainer, isBuiltinProcess, isBuiltinVm } from './chunk-3DD6AOWC.js';
 import { parseSize } from './chunk-F6GFZXZ3.js';
 import { claudeCredential, buildEnvironment, JOB_MOUNT, CHECKOUT_DIR, parseIsolation, proxyEnvironment, containerLocalAddress, destinationEnvironment, CLAUDE_CREDENTIAL_VARIABLES, builtInEnvironment, withHooksPath, startBuildServices, BUILT_IN_NAMES, AGENT_CREDENTIAL_MISSING, sharedUserEnvironment, headerVariables, authorEnvironment, withTunnelRecord, commitIdentityRecord, RELAY_PORT } from './chunk-AUFG23AA.js';
 import { readCloudConfig } from './chunk-EABW6AJQ.js';
 import { resolveVersion } from './chunk-RA3O54FC.js';
 import { signerFor } from './chunk-M5POMKKW.js';
-import { runnerDir, buildDir, vsockPath, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZM2IMMYN.js';
+import { runnerDir, buildDir, vsockPath, RUNNER_FILE_MODE } from './chunk-ZM2IMMYN.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { spawn, spawnSync } from 'child_process';
 import { randomBytes } from 'crypto';
-import { mkdirSync, chmodSync, writeFileSync, appendFileSync, statSync, accessSync, constants, existsSync, readFileSync, openSync, closeSync, rmSync, readdirSync } from 'fs';
+import { mkdirSync, chmodSync, writeFileSync, appendFileSync, statSync, accessSync, constants, openSync, existsSync, readFileSync, closeSync, rmSync, readdirSync } from 'fs';
 import { join, isAbsolute, dirname, delimiter } from 'path';
 
 createRequire(import.meta.url);
@@ -192,9 +194,15 @@ async function provisionMicroVm(input) {
     return bail(`the build's disk and machine could not be made: ${describeCallFailure(err)}`);
   }
   if (input.aborted()) return bail("", true);
+  try {
+    state.cgroup = vm.cgroup.create(buildId, limits.memoryBytes);
+  } catch (err) {
+    return bail(`the build's memory limit could not be set: ${describeCallFailure(err)}`);
+  }
+  if (state.cgroup !== void 0) input.save(state, environment);
   const consolePath = join(jobDir, "vm-console.log");
   try {
-    state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath });
+    state.firecracker = await vm.firecracker.spawn({ binary: assets.firecracker, configPath, consolePath, cgroup: state.cgroup });
   } catch (err) {
     return bail(`Firecracker did not start: ${describeCallFailure(err)}`);
   }
@@ -315,7 +323,7 @@ function agentVersionOf(toolsJson) {
   }
   return CLAUDE_CODE_VERSION;
 }
-function microVmCommandLine(input) {
+function vmExecFor(input, argv) {
   const state = input.job.microvm;
   const env = buildEnvironment({
     config: input.config,
@@ -334,13 +342,17 @@ function microVmCommandLine(input) {
     cwd: CHECKOUT_DIR,
     env: { ...state.imageEnv, ...env.literals },
     pass: Object.keys(env.passed).filter((name) => env.passed[name] !== void 0),
-    argv: ["/bin/sh", "-c", input.cmdline]
-  };
-  return {
-    line: [process.execPath, input.cli, "vm-exec", ...vmExecArgs(options)].map(shellQuote).join(" "),
-    options,
-    env: { ...childEnvironment(input.runtime.hostEnv), ...env.passed }
+    argv
   };
+  return { options, env: { ...childEnvironment(input.runtime.hostEnv), ...env.passed } };
+}
+function microVmCommandLine(input) {
+  const { options, env } = vmExecFor(input, ["/bin/sh", "-c", input.cmdline]);
+  return { line: [process.execPath, input.cli, "vm-exec", ...vmExecArgs(options)].map(shellQuote).join(" "), options, env };
+}
+function microVmSenderCommand(input) {
+  const { options, env } = vmExecFor(input, ["outerlayer", "session-sender"]);
+  return { command: process.execPath, args: [input.cli, "vm-exec", ...vmExecArgs(options)], env };
 }
 function isRunning(runtime, state) {
   return state.firecracker !== void 0 && runtime.vm.firecracker.alive(state.firecracker);
@@ -391,6 +403,13 @@ async function cleanupMicroVm(runtime, state, jobDir) {
       failures.push(`the microVM (pid ${state.firecracker.pid}) was not stopped: ${describeCallFailure(err)}`);
     }
   }
+  if (state.cgroup !== void 0) {
+    try {
+      runtime.vm.cgroup.remove(state.cgroup);
+    } catch (err) {
+      failures.push(`the build's cgroup ${state.cgroup} was not removed: ${describeCallFailure(err)}`);
+    }
+  }
   if (state.buildDisk !== void 0) deleteBuildDisk(state.buildDisk);
   const tunnel = runtime.tunnels.get(state.buildId);
   if (tunnel !== void 0) {
@@ -410,6 +429,8 @@ async function stopOrphanedMicroVms(input) {
         process.kill(-job.pid, "SIGKILL");
       } catch {
       }
+      const deadline = Date.now() + 2e3;
+      while (isSameProcess(job.pid, job.start) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 10));
     }
     if (state.firecracker !== void 0 && input.runtime.vm.firecracker.alive(state.firecracker)) {
       await input.runtime.vm.firecracker.stop(state.firecracker);
@@ -581,60 +602,6 @@ async function closeHostBuild(runtime, build) {
   rmSync(build.buildDir, { recursive: true, force: true });
   if (build.workDir !== void 0) rmSync(build.workDir, { recursive: true, force: true });
 }
-function readJobFile(path) {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeJobFile(path, job) {
-  mkdirSync(dirname(path), { recursive: true, mode: RUNNER_DIR_MODE });
-  writeFileSync(path, JSON.stringify(job, null, 2), { mode: RUNNER_FILE_MODE });
-}
-var ENDED = "ended before provision finished";
-async function provisionProcess(input) {
-  const { config, runtime, item, jobDir } = input;
-  if (claudeCredential(runtime.hostEnv) === void 0) return { ok: false, reason: AGENT_CREDENTIAL_MISSING };
-  const repository = item.specRepository;
-  if (repository === void 0 || repository === null || repository === "") {
-    return { ok: false, reason: "the work item names no repository to clone" };
-  }
-  const buildId = randomBytes(6).toString("hex");
-  const buildDir2 = buildDir(config.configPath, buildId);
-  const workDir = join(jobDir, "work");
-  const state = { buildId, buildDir: buildDir2, workDir };
-  const environment = sharedUserEnvironment(input.cliVersion);
-  input.save(state, environment);
-  const bail = async (reason) => {
-    try {
-      await cleanupProcess(runtime, state);
-    } catch (err) {
-      input.log.error(`#${item.number} cleanup failed: ${describeCallFailure(err)}`);
-    }
-    return { ok: false, reason };
-  };
-  if (input.aborted()) return bail(ENDED);
-  mkdirSync(buildDir2, { recursive: true });
-  chmodSync(buildDir2, 493);
-  try {
-    await startHostServices({ runtime, config, build: state, jobDir, itemKey: input.itemKey, process: true });
-  } catch (err) {
-    return bail(`the tunnel could not start: ${describeCallFailure(err)}`);
-  }
-  input.save(state, environment);
-  if (input.aborted()) return bail(ENDED);
-  const checkout = join(workDir, "checkout");
-  const remote = runtime.remoteFor?.(repository) ?? `https://github.com/${repository}.git`;
-  const cloned = await runtime.clone({ remote, dest: checkout });
-  if (!cloned.ok) return bail(cloned.reason);
-  if (input.aborted()) return bail(ENDED);
-  return { ok: true, workdir: checkout, state, environment };
-}
-function cleanupProcess(runtime, state) {
-  return closeHostBuild(runtime, state);
-}
 
 // src/runner/verdict.ts
 var VERDICT_SETTLE_MS = 5 * 6e4;
@@ -708,6 +675,48 @@ async function settleVerdict(deps) {
     await deps.sleep(everyMs);
   }
 }
+var ENDED = "ended before provision finished";
+async function provisionProcess(input) {
+  const { config, runtime, item, jobDir } = input;
+  if (claudeCredential(runtime.hostEnv) === void 0) return { ok: false, reason: AGENT_CREDENTIAL_MISSING };
+  const repository = item.specRepository;
+  if (repository === void 0 || repository === null || repository === "") {
+    return { ok: false, reason: "the work item names no repository to clone" };
+  }
+  const buildId = randomBytes(6).toString("hex");
+  const buildDir2 = buildDir(config.configPath, buildId);
+  const workDir = join(jobDir, "work");
+  const state = { buildId, buildDir: buildDir2, workDir };
+  const environment = sharedUserEnvironment(input.cliVersion);
+  input.save(state, environment);
+  const bail = async (reason) => {
+    try {
+      await cleanupProcess(runtime, state);
+    } catch (err) {
+      input.log.error(`#${item.number} cleanup failed: ${describeCallFailure(err)}`);
+    }
+    return { ok: false, reason };
+  };
+  if (input.aborted()) return bail(ENDED);
+  mkdirSync(buildDir2, { recursive: true });
+  chmodSync(buildDir2, 493);
+  try {
+    await startHostServices({ runtime, config, build: state, jobDir, itemKey: input.itemKey, process: true });
+  } catch (err) {
+    return bail(`the tunnel could not start: ${describeCallFailure(err)}`);
+  }
+  input.save(state, environment);
+  if (input.aborted()) return bail(ENDED);
+  const checkout = join(workDir, "checkout");
+  const remote = runtime.remoteFor?.(repository) ?? `https://github.com/${repository}.git`;
+  const cloned = await runtime.clone({ remote, dest: checkout });
+  if (!cloned.ok) return bail(cloned.reason);
+  if (input.aborted()) return bail(ENDED);
+  return { ok: true, workdir: checkout, state, environment };
+}
+function cleanupProcess(runtime, state) {
+  return closeHostBuild(runtime, state);
+}
 
 // src/runner/job.ts
 var LEASE_SECONDS = 900;
@@ -1155,6 +1164,11 @@ async function finishJob(job, jobDirPath, outcome, config, deps, ending) {
   const jobFilePath = join(jobDirPath, "job.json");
   const logPath = join(jobDirPath, "command.log");
   const tag = `#${job.item}`;
+  if (job.sender !== void 0) {
+    await stopSender({ job, deps: { spawnFn, runtime: deps.container, log } });
+    delete job.sender;
+    writeJobFile(jobFilePath, job);
+  }
   const build = job.container === void 0 ? void 0 : { state: job.container, runtime: deps.container ?? createContainerRuntime() };
   const vmBuild = job.microvm === void 0 ? void 0 : { state: job.microvm, runtime: deps.container ?? createContainerRuntime() };
   if (build !== void 0 && job.pid !== void 0 && isGroupAlive(job.pid)) {
@@ -1177,6 +1191,20 @@ async function finishJob(job, jobDirPath, outcome, config, deps, ending) {
     job.reason = scrubReason(ending.reason, config);
     writeJobFile(jobFilePath, job);
   }
+  let outOfMemory;
+  if (vmBuild?.state.cgroup !== void 0 && outcome !== void 0 && outcome !== "ok" && ending?.reason === void 0) {
+    try {
+      if (vmBuild.runtime.vm.cgroup.oomKills(vmBuild.state.cgroup) > 0) {
+        outOfMemory = `the build ran out of memory: the kernel killed its microVM at the limit of runner.build.memory (${config.build?.memory ?? "8g"}) plus 256 MiB for Firecracker. Raise runner.build.memory, or lower runner.concurrency`;
+      }
+    } catch (err) {
+      log.error(`${tag} could not read the build's memory events: ${describeCallFailure(err)} \xB7 continuing`);
+    }
+    if (outOfMemory !== void 0) {
+      job.reason = scrubReason(outOfMemory, config);
+      writeJobFile(jobFilePath, job);
+    }
+  }
   const hookLimits = () => hookLimitsFor(config, now().getTime(), deps.now);
   let tunnelRecord;
   if (!job.cleanupRan) {
@@ -1340,6 +1368,8 @@ async function finishJob(job, jobDirPath, outcome, config, deps, ending) {
     const fromHook = readReasonLine(jobDirPath, config);
     if (verdictReason !== void 0) {
       job.reason = verdictReason;
+    } else if (outOfMemory !== void 0) {
+      job.reason = scrubReason(outOfMemory, config);
     } else if (ending?.reason === void 0) {
       job.reason = (outcome === "ok" ? void 0 : held?.reason) ?? (isolated ? fromHook ?? job.reason : fromHook);
     }
@@ -1458,4 +1488,109 @@ async function recoverLostJobs(jobsDirPath, config, deps) {
   return recovered;
 }
 
-export { LEASE_SECONDS, RENEW_INTERVAL_SECONDS, deliverCommitHooks, describeHookEnd, execArgv, execCommandLine, finishJob, hookLimitsFor, hostCommandEnvironment, hostEnvironment, isGroupAlive, isIdle, isTimedOut, isUnfinished, jobEnv, listAdoptableJobs, listenOnBroker, microVmCommandLine, needsRenew, outcomeFromExitCode, provisionEnvironment, provisionMicroVm, provisionProcess, readCpuUsec, readJobFile, readProvisionOut, recoverLostJobs, releaseLease, renewLease, resolveHostBuild, retryFailedReleases, runCommand, runHook, setStage, startHostServices, stopOrphanedMicroVms, unfinishedJobs, workdirProblem, writeJobFile };
+// src/runner/sender.ts
+var STOP_WAIT_MS = 3e4;
+var POLL_MS = 200;
+var BUILD_HOME = "/build/home";
+async function startSender(input) {
+  const { config, job, jobDir, deps } = input;
+  const tag = `#${job.item}`;
+  if (job.itemKey === void 0) return void 0;
+  const spawnFn = deps.spawnFn ?? spawn;
+  try {
+    const launch = launchFor(config, job, jobDir, deps);
+    const fd = openSync(join(jobDir, "sender.log"), "a", RUNNER_FILE_MODE);
+    let pid;
+    try {
+      const child = spawnFn(launch.command, launch.args, { env: launch.env, cwd: launch.cwd, detached: true, stdio: ["ignore", fd, fd] });
+      child.on("error", (err) => deps.log.error(`${tag} session sender failed: ${describeCallFailure(err)}`));
+      child.on("exit", (code, signal) => deps.log.line(`${tag} session sender exited \xB7 ${signal ?? `code ${code}`} \xB7 see sender.log`));
+      child.unref?.();
+      pid = child.pid;
+    } finally {
+      closeSync(fd);
+    }
+    if (pid === void 0) {
+      deps.log.line(`${tag} session sender did not start: no pid`);
+      return void 0;
+    }
+    deps.log.line(`${tag} session sender started \xB7 pid ${pid}`);
+    return { pid, start: startTimeOf(pid) ?? void 0 };
+  } catch (err) {
+    deps.log.error(`${tag} session sender did not start: ${describeCallFailure(err)} \xB7 continuing`);
+    return void 0;
+  }
+}
+function launchFor(config, job, jobDir, deps) {
+  if (job.microvm !== void 0) {
+    const runtime = deps.runtime ?? createContainerRuntime();
+    const cli = deps.cliPath ?? join(runtime.cliBuild().distDir, "index.js");
+    return { ...microVmSenderCommand({ job, runtime, config, cli }), cwd: jobDir };
+  }
+  if (job.container !== void 0) {
+    return { ...containerSenderCommand({ job, runtime: deps.runtime ?? createContainerRuntime(), config }), cwd: jobDir };
+  }
+  const env = jobEnv(config, job.item, job.itemKey, jobDir, process.env, job.branch, job.commitIdentity?.author);
+  const build = job.build;
+  const hostEnv = build === void 0 ? env : hostCommandEnvironment(env, build, config, job.commitIdentity?.hooksPath);
+  if (build?.exec !== void 0) {
+    return { command: build.exec, args: execArgv(job.workdir, ["outerlayer", "session-sender"]), env: hostEnv, cwd: jobDir };
+  }
+  return { command: process.execPath, args: [deps.cliPath ?? process.argv[1] ?? "outerlayer", "session-sender"], env: hostEnv, cwd: job.workdir ?? jobDir };
+}
+function isLive(sender) {
+  if (sender.start !== void 0) return isSameProcess(sender.pid, sender.start);
+  try {
+    process.kill(sender.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function signalHost(sender, signal) {
+  if (!isLive(sender)) return;
+  try {
+    process.kill(-sender.pid, signal);
+  } catch {
+    try {
+      process.kill(sender.pid, signal);
+    } catch {
+    }
+  }
+}
+async function signalInGuest(runtime, state, pidfile, signal) {
+  await runtime.vm.exec(state.vsockPath, {
+    argv: ["/bin/sh", "-c", senderSignalScript(pidfile, signal)],
+    user: state.agentUser ?? ADDED_USER,
+    cwd: "/",
+    env: { PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" }
+  });
+}
+async function stopSender(input) {
+  const { job, deps } = input;
+  const sender = job.sender;
+  if (sender === void 0) return;
+  const tag = `#${job.item}`;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const inContainer = job.container === void 0 ? void 0 : { state: job.container, runtime: deps.runtime ?? createContainerRuntime(), pidfile: senderPidfile(BUILD_HOME, Number(job.item)) };
+  const inGuest = job.microvm === void 0 ? void 0 : { state: job.microvm, runtime: deps.runtime ?? createContainerRuntime(), pidfile: senderPidfile(BUILD_HOME, Number(job.item)) };
+  const signalInside = async (signal) => {
+    if (inContainer !== void 0) await signalInContainer(inContainer.runtime, inContainer.state, inContainer.pidfile, signal).catch(() => void 0);
+    if (inGuest !== void 0) await signalInGuest(inGuest.runtime, inGuest.state, inGuest.pidfile, signal).catch(() => void 0);
+  };
+  try {
+    if (inContainer !== void 0 || inGuest !== void 0) await signalInside("TERM");
+    else signalHost(sender, "SIGTERM");
+    const deadline = (deps.waitMs ?? STOP_WAIT_MS) / POLL_MS;
+    for (let waited = 0; isLive(sender) && waited < deadline; waited += 1) await sleep(POLL_MS);
+    if (isLive(sender)) {
+      deps.log.error(`${tag} session sender did not stop in time \xB7 killing it`);
+      await signalInside("KILL");
+      signalHost(sender, "SIGKILL");
+    }
+  } catch (err) {
+    deps.log.error(`${tag} stopping the session sender failed: ${describeCallFailure(err)} \xB7 continuing`);
+  }
+}
+
+export { ALREADY_RELEASED, LEASE_SECONDS, RENEW_INTERVAL_SECONDS, deliverCommitHooks, describeHookEnd, execArgv, execCommandLine, finishJob, hookLimitsFor, hostCommandEnvironment, hostEnvironment, isGroupAlive, isIdle, isTimedOut, isUnfinished, jobEnv, listAdoptableJobs, listenOnBroker, microVmCommandLine, needsRenew, outcomeFromExitCode, provisionEnvironment, provisionMicroVm, provisionProcess, readCpuUsec, readProvisionOut, recoverLostJobs, releaseLease, renewLease, resolveHostBuild, retryFailedReleases, runCommand, runHook, setStage, startHostServices, startSender, stopOrphanedMicroVms, unfinishedJobs, workdirProblem };