@outerlayer/cli 0.23.0 → 0.25.0

package/dist/{chunk-TFGXOHF6.js → chunk-L2FZLBF7.js}

@@ -1,30 +1,32 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, provisionEnvironment, readProvisionOut, resolveHostBuild, workdirProblem, listenOnBroker, hostEnvironment, hostCommandEnvironment, execArgv, microVmCommandLine, runCommand, commandLogOffset, execCommandLine, startSender, startHostServices, finishJob, isContainerTracked, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, hookLimitsFor, AttemptLogBook, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, ALREADY_RELEASED } from './chunk-QSEPKZXR.js';
-import { writePendingUpdate } from './chunk-CQAEV3Z5.js';
-import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-UF5L4BAI.js';
+import { releaseLease, isUnfinished, setStage, jobEnv, runHook, describeHookEnd, provisionMicroVm, deliverCommitHooks, provisionProcess, provisionEnvironment, readProvisionOut, resolveHostBuild, workdirProblem, listenOnBroker, hostEnvironment, hostCommandEnvironment, execArgv, microVmCommandLine, runCommand, commandLogOffset, execCommandLine, startSender, startHostServices, finishJob, isContainerTracked, probeCommand, appendCommandLog, judgeProbe, EXIT_CODE_FILE, isGroupAlive, outcomeFromExitCode, isTimedOut, readCpuUsec, isIdle, stopOrphanedMicroVms, unfinishedJobs, listUnreadableJobs, listAdoptableJobs, retryFailedReleases, recoverLostJobs, hookLimitsFor, AttemptLogBook, needsRenew, renewLease, RENEW_INTERVAL_SECONDS, listTrackedJobs, restartSender, ALREADY_RELEASED, inTeardown } from './chunk-3I44PQ26.js';
+import { writePendingUpdate } from './chunk-XRYUJTAT.js';
+import { JOB_STATE_FORMAT, readsJobState, jobStateFormatOf } from './chunk-ZVB57WI6.js';
+import { readHousekeepingRecord, writeHousekeepingRecord } from './chunk-O2WYUIK7.js';
 import { decideInstalledSwitch } from './chunk-3JVYMD4G.js';
 import { fetchVersionMeta, npmVersion, npmSupportsProvenance, fetchTarballDigest, fetchProvenance, installVersion, auditSignatures } from './chunk-YETTWTAY.js';
-import { compareVersions, satisfiesRange } from './chunk-I2UOAV7X.js';
 import { RUNNER_PROTOCOL } from './chunk-TPKYTORP.js';
-import { currentSkillCommand, formerSkillProblem, placeholderQueues, placeholderProblem } from './chunk-G3LHWUBK.js';
+import { currentSkillCommand, formerSkillProblem, placeholderQueues, placeholderProblem } from './chunk-VPUNOGXO.js';
+import { writeMarker, readMarker, currentVersion, removeMarker, entryIn, versionDir, startedThroughCurrent, switchCurrent, isInLayout, cleanVersions, stagingDir } from './chunk-QMQC6JCO.js';
 import { freeBytes, formatBytes } from './chunk-YYYRBYWG.js';
-import { writeMarker, readMarker, currentVersion, removeMarker, entryIn, versionDir, startedThroughCurrent, switchCurrent, cleanVersions, isInLayout, stagingDir } from './chunk-276D7BJ7.js';
 import { RepoFilter } from './chunk-TBT347UY.js';
-import { LEASE_SECONDS, provisionContainer, leaseExpiresAtMs, deliverContainerHooks, lifecycleSteps, lifecycleFailureReason, prepareBranch, containerCommandExec, measureDisk, setUpRunnerCgroup, createContainerRuntime, parseCpuList, ensureTunnel, keepGhConfigCurrent, filesAreCopied } from './chunk-BOG4ENP7.js';
-import { checkFit } from './chunk-OBCFK4QD.js';
-import { claimPidFile, readPidFile, releasePidFile } from './chunk-XACXXKQ5.js';
+import { LEASE_SECONDS, provisionContainer, leaseExpiresAtMs, deliverContainerHooks, lifecycleSteps, lifecycleFailureReason, prepareBranch, containerCommandExec, measureDisk, setUpRunnerCgroup, createContainerRuntime, parseCpuList, ensureTunnel, keepGhConfigCurrent, filesAreCopied } from './chunk-XHXDCYSK.js';
+import { tagToPull, pullInstruction, imageTag, writeUpdateStatus } from './chunk-5222PA6S.js';
+import { isVersion, compareVersions, satisfiesRange } from './chunk-TQMI335S.js';
+import { checkFit } from './chunk-IGRRD7PX.js';
+import { claimPidFile, readPidFile, releasePidFile } from './chunk-DEBOL6ON.js';
 import { startTimeOf, isSameProcess } from './chunk-JBJTC3UU.js';
-import { writeJobFile, ensureRunnerIdentity, readJobFile, builderName, runnerLabelValue, ensureFailureCount, builderSpec, ensureBuilder, spawnRun, BUILD_LABEL, RUNNER_LABEL, readJobFileChecked } from './chunk-OGMZJWWD.js';
-import { describeCallFailure, retrySend, shortClaim, relativeToRunner, formatDuration, BuildTokens, classifyRefusal, refusalCode, createRunnerLog, formatClock } from './chunk-KGKFEONR.js';
-import { isSignatureRefusal, WorkCommandError, getJson, postJson } from './chunk-C64D7HR3.js';
-import { isBuiltinContainer, isBuiltinVm, isBuiltinProcess, loadRunnerConfig, checkHooks, builtinKind, DEFAULT_UPDATE_MAX_WAIT_HOURS } from './chunk-V5CG75NX.js';
+import { writeJobFile, ensureRunnerIdentity, readJobFile, builderName, runnerLabelValue, ensureFailureCount, builderSpec, ensureBuilder, spawnRun, BUILD_LABEL, RUNNER_LABEL, readJobFileChecked } from './chunk-QUGYGO6L.js';
+import { describeCallFailure, retrySend, shortClaim, relativeToRunner, formatDuration, BuildTokens, classifyRefusal, refusalCode, createRunnerLog, formatClock } from './chunk-YMKQVCKC.js';
+import { isSignatureRefusal, WorkCommandError, getJson, postJson } from './chunk-X5LNCIZT.js';
+import { isBuiltinContainer, isBuiltinVm, isBuiltinProcess, loadRunnerConfig, checkHooks, builtinKind, DEFAULT_UPDATE_MAX_WAIT_HOURS } from './chunk-JWRX5ZTT.js';
 import { exceedsDisk } from './chunk-7RQ73DLO.js';
 import { resolveVersion } from './chunk-RA3O54FC.js';
-import { loadHostKey, ensureHostKey, signerFor } from './chunk-OW52QLK3.js';
-import { RUNNER_DIR_MODE, runnerDir, buildDir, attemptStamp, jobDir, RUNNER_FILE_MODE, jobsDir, pidFilePath, spoolDir, rootfsDir } from './chunk-IHNQWF6F.js';
-import { parseClaimIdentity, parseClaimedRepositories, parseUnreachable, repositoriesOf, primaryOf, sharedUserEnvironment, JOB_MOUNT, claudeCredential } from './chunk-URWYRAIC.js';
-import { COMMAND_LOST_REASON, CONTAINER_STOPPED_REASON } from './chunk-GISNHSYL.js';
+import { loadHostKey, ensureHostKey, signerFor } from './chunk-ZODVSFI4.js';
+import { RUNNER_DIR_MODE, runnerDir, buildDir, attemptStamp, jobDir, RUNNER_FILE_MODE, jobsDir, pidFilePath, spoolDir, rootfsDir } from './chunk-ZI2ZVWKT.js';
+import { parseClaimIdentity, parseClaimedRepositories, parseUnreachable, repositoriesOf, primaryOf, sharedUserEnvironment, JOB_MOUNT, claudeCredential } from './chunk-2K3TCQHW.js';
+import { COMMAND_LOST_REASON, CONTAINER_STOPPED_REASON } from './chunk-JGD5TWQ2.js';
 import { randomBytes } from 'crypto';
 import { mkdirSync, existsSync, chmodSync, writeFileSync, renameSync, statSync, readdirSync, readFileSync, rmSync, closeSync, openSync, constants, lstatSync } from 'fs';
 import { join, dirname } from 'path';
@@ -237,6 +239,61 @@ function writeLastUpdate(configPath, update) {
 `, { mode: RUNNER_FILE_MODE });
   renameSync(temporary, path);
 }
+
+// src/runner/update/ask-formats.ts
+async function askJobStateFormats(runNode, entry, cwd) {
+  let result;
+  try {
+    result = await runNode([entry, "runner", "job-state-formats"], cwd);
+  } catch {
+    return void 0;
+  }
+  if (result.status !== 0) return void 0;
+  try {
+    const body = JSON.parse(result.stdout);
+    if (!Array.isArray(body.reads) || !body.reads.every((n) => Number.isInteger(n))) return void 0;
+    return body.reads;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/runner/update/survives-restart.ts
+function stageReason(job) {
+  if (job.stage === "command") return void 0;
+  if (!inTeardown(job)) return "is still in setup";
+  switch (job.stage) {
+    case "judge":
+      return "is running the criteria judge";
+    case "checks":
+      return "is running its checks";
+    default:
+      return `is finishing (${job.stage})`;
+  }
+}
+function ownReason({ job, ending }) {
+  if (job.microvm !== void 0) return "runs in a microVM, which does not carry on through a restart";
+  if (!isContainerTracked(job)) return "is not a container build tracked inside its container";
+  if (ending) return "is being ended";
+  return stageReason(job);
+}
+function buildBlockers(builds) {
+  return builds.flatMap((build) => {
+    const reason = ownReason(build);
+    return reason === void 0 ? [] : [{ item: build.job.item, reason }];
+  });
+}
+function restartBlockers(builds, reads) {
+  return builds.flatMap((build) => {
+    const reason = ownReason(build);
+    if (reason !== void 0) return [{ item: build.job.item, reason }];
+    if (reads === void 0) return [{ item: build.job.item, reason: "has job state the new version may not read: it did not say which formats it reads" }];
+    if (!readsJobState(build.job, reads)) {
+      return [{ item: build.job.item, reason: `has job-state format ${jobStateFormatOf(build.job)}, which the new version does not read` }];
+    }
+    return [];
+  });
+}
 var RELEASE_REPOSITORY = "https://github.com/outerlayerai/outerlayer";
 var RELEASE_WORKFLOW_PATH = ".github/workflows/outerlayer-release.yml";
 var UpdateStepError = class extends Error {
@@ -410,8 +467,8 @@ async function preflightUpdate(args) {
   const failure2 = await earlyFailure(args);
   return failure2 === void 0 ? void 0 : finish(args, failure2);
 }
-async function performUpdate(args) {
-  const { configPath, own, version, deps } = args;
+async function prepareUpdate(args) {
+  const { configPath, version, deps } = args;
   const early = await earlyFailure(args);
   if (early !== void 0) return finish(args, early);
   let verified;
@@ -423,24 +480,31 @@ async function performUpdate(args) {
   if (!verified.ok) return finish(args, { outcome: verified.outcome, reason: verified.reason });
   const staged = await deps.runNode([entryIn(verified.dir), "runner", "check", "--config", configPath], verified.dir);
   if (staged.status !== 0) {
-    try {
-      rmSync(verified.dir, { recursive: true, force: true });
-    } catch {
-    }
+    removeStaging(verified.dir);
     return finish(args, {
       outcome: "retrying",
       reason: `${version} failed \`runner check\` on this host (exit ${staged.status})`,
       detail: `${version} failed \`runner check\` on this host: ${(staged.stderr.trim() || staged.stdout.trim()).slice(0, 500)}`
     });
   }
+  return { kind: "prepared", dir: verified.dir };
+}
+function removeStaging(dir) {
+  try {
+    rmSync(dir, { recursive: true });
+  } catch {
+  }
+}
+function installPrepared(args, stagedDir) {
+  const { configPath, own, version } = args;
   try {
     if (version !== own) rmSync(versionDir(configPath, version), { recursive: true, force: true });
-    renameSync(verified.dir, versionDir(configPath, version));
+    renameSync(stagedDir, versionDir(configPath, version));
     writeMarker(configPath, { from: own, to: version, starts: 0 });
     switchCurrent(configPath, version);
   } catch (err) {
     try {
-      rmSync(verified.dir, { recursive: true, force: true });
+      rmSync(stagedDir, { recursive: true, force: true });
       if (currentVersion(configPath) !== version) removeMarker(configPath);
     } catch {
     }
@@ -454,6 +518,10 @@ async function performUpdate(args) {
   args.log.line(`updating ${own} -> ${version} \xB7 restarting`);
   return { kind: "switched" };
 }
+async function performUpdate(args) {
+  const prepared = await prepareUpdate(args);
+  return prepared.kind === "prepared" ? installPrepared(args, prepared.dir) : prepared;
+}
 function rollBack(configPath, marker, reason, detail, now, log) {
   try {
     writeLastUpdate(configPath, { from: marker.from, to: marker.to, outcome: "rolled_back", reason, at: isoAt(now) });
@@ -1165,6 +1233,10 @@ function selfUpdateBlocker(configPath, entryPath, own) {
   return void 0;
 }
 function considerNamedVersion(state, named) {
+  if (state.deps.image !== void 0) {
+    considerNamedImage(state, named);
+    return;
+  }
   const update = state.deps.update;
   if (update === void 0 || named === void 0) return;
   const configPath = state.config.configPath;
@@ -1187,6 +1259,34 @@ function considerNamedVersion(state, named) {
     logOf(state).line(`this runner cannot update itself to ${named}: ${blocker}`);
   }
 }
+function considerNamedImage(state, named) {
+  if (named !== void 0 && !isVersion(named)) named = void 0;
+  if (named !== void 0) state.imageNamed = named;
+  recordImageStatus(state);
+  const own = ownVersionOf(state.deps);
+  if (named === void 0 || state.imageLogged === named || (compareVersions(own, named) ?? 0) >= 0) return;
+  state.imageLogged = named;
+  logOf(state).line(`the factory names ${named}, newer than the ${own} this image runs \xB7 ${pullInstruction(imageTag(named))}`);
+}
+function recordImageStatus(state) {
+  if (state.deps.image === void 0) return;
+  const named = state.imageNamed;
+  const record = {
+    own: ownVersionOf(state.deps),
+    ...named === void 0 ? {} : { named, tag: imageTag(named) },
+    upgradeRequired: state.upgradeRefused === true,
+    at: nowOf(state).toISOString()
+  };
+  const key = JSON.stringify({ ...record, at: void 0 });
+  if (state.imageRecord === key) return;
+  try {
+    writeUpdateStatus(runnerDir(state.config.configPath), record);
+    state.imageRecord = key;
+    reportRepeating(state, "the update-status.json record", void 0);
+  } catch (err) {
+    reportRepeating(state, "the update-status.json record", `could not write update-status.json (${describeCallFailure(err)}): \`runner status\` will not name the image to pull`);
+  }
+}
 function adoptUpdateWait(state, version, nowMs) {
   const previous = state.updateWait;
   const wait = { version, sinceMs: previous?.sinceMs ?? nowMs, holdSinceMs: previous?.holdSinceMs };
@@ -1209,12 +1309,20 @@ function updateArgsOf(state, update, version) {
 function dropPendingUpdate(state) {
   state.pendingUpdate = void 0;
   state.preflightedUpdate = void 0;
+  discardPrepared(state);
   clearUpdateWait(state);
 }
+function discardPrepared(state) {
+  if (state.preparedUpdate === void 0) return;
+  removeStaging(state.preparedUpdate.dir);
+  state.preparedUpdate = void 0;
+}
 function clearUpdateWait(state) {
   state.updateWait = void 0;
   state.updateLogged = void 0;
   state.upgradeRefused = false;
+  if (state.installWait !== void 0) return;
+  state.waitsLogged = void 0;
   recordPendingUpdate(state, void 0);
 }
 function recordPendingUpdate(state, record) {
@@ -1238,7 +1346,7 @@ function runningItems(state) {
   const numbers = [...state.jobs.values()].map((entry) => Number(entry.job.item)).filter((n) => Number.isFinite(n));
   return numbers.sort((a, b) => a - b);
 }
-function holdForUpdate(state, version, mayHold = true) {
+function holdForUpdate(state, version, mayHold = true, waits = []) {
   const log = logOf(state);
   const nowMs = nowOf(state).getTime();
   const wait = adoptUpdateWait(state, version, nowMs);
@@ -1253,6 +1361,11 @@ function holdForUpdate(state, version, mayHold = true) {
   const maxWaitMs = (state.config.update?.maxWaitHours ?? DEFAULT_UPDATE_MAX_WAIT_HOURS) * 60 * 6e4;
   const holding = mayHold && (state.upgradeRefused === true || nowMs - wait.sinceMs >= maxWaitMs);
   const record = { version, since: new Date(wait.sinceMs).toISOString() };
+  if (waits.length > 0) {
+    record.via = "self-update";
+    record.waits = recordedWaits(waits);
+  }
+  noteWaits(state, version, waits);
   if (holding) {
     wait.holdSinceMs ??= nowMs;
     const builds = runningItems(state);
@@ -1269,6 +1382,16 @@ function holdForUpdate(state, version, mayHold = true) {
   recordPendingUpdate(state, record);
   return holding;
 }
+function recordedWaits(waits) {
+  return waits.flatMap((wait) => Number.isFinite(Number(wait.item)) ? [{ item: Number(wait.item), reason: wait.reason }] : []);
+}
+function noteWaits(state, version, waits) {
+  const phrase = waits.map((wait) => `#${wait.item} ${wait.reason}`).join("; ");
+  const key = waits.length === 0 ? void 0 : `${version}:${phrase}`;
+  if (state.waitsLogged === key) return;
+  state.waitsLogged = key;
+  if (key !== void 0) logOf(state).line(`update to ${version} waits: ${phrase}`);
+}
 function buildsPhrase(builds) {
   return builds.length === 0 ? "the running builds" : builds.map((n) => `#${n}`).join(", ");
 }
@@ -1292,7 +1415,7 @@ function installedSwitchOf(state, update) {
     installed: current !== void 0 && existsSync(entryIn(versionDir(configPath, current)))
   });
 }
-function restartOntoInstalled(state) {
+async function restartOntoInstalled(state) {
   const update = state.deps.update;
   if (update === void 0) return false;
   const configPath = state.config.configPath;
@@ -1300,6 +1423,8 @@ function restartOntoInstalled(state) {
   const decision = installedSwitchOf(state, update);
   if (decision.kind === "none") {
     state.installedSwitch = void 0;
+    state.installedFormats = void 0;
+    state.installWait = void 0;
     return false;
   }
   const said = `${decision.kind}:${decision.to}`;
@@ -1315,8 +1440,14 @@ function restartOntoInstalled(state) {
     return false;
   }
   if (state.jobs.size > 0) {
-    if (first) log.line(`${decision.to} is installed \xB7 taking no new work, restarting onto it once ${state.jobs.size} running build(s) finish`);
-    return true;
+    const waits = await installBlockers(state, update, decision.to);
+    if (waits.length > 0) {
+      if (first) log.line(`${decision.to} is installed \xB7 taking no new work, restarting onto it once ${state.jobs.size} running build(s) finish`);
+      const wait = state.installWait = state.installWait?.version === decision.to ? state.installWait : { version: decision.to, sinceMs: nowOf(state).getTime() };
+      noteWaits(state, decision.to, waits);
+      recordPendingUpdate(state, { version: decision.to, since: new Date(wait.sinceMs).toISOString(), via: "install", waits: recordedWaits(waits) });
+      return true;
+    }
   }
   try {
     writeMarker(configPath, { from: own, to: decision.to, starts: 0 });
@@ -1327,10 +1458,66 @@ function restartOntoInstalled(state) {
   (state.exitForUpdate ?? (() => update.exit(RESTART_EXIT_STATUS)))();
   return true;
 }
+function runningBuilds(state) {
+  return [...state.jobs.values()].map((active) => ({ job: active.job, ending: active.ending }));
+}
+async function installBlockers(state, update, to) {
+  const stage = buildBlockers(runningBuilds(state));
+  if (stage.length > 0) return stage;
+  if (state.installedFormats?.version !== to) {
+    const dir = versionDir(state.config.configPath, to);
+    state.installedFormats = { version: to, reads: await askJobStateFormats(update.runNode, entryIn(dir), dir) };
+  }
+  return restartBlockers(runningBuilds(state), state.installedFormats.reads);
+}
+function formatBlocked(builds, reads) {
+  const byStage = new Set(buildBlockers(builds).map((blocker) => blocker.item));
+  return restartBlockers(builds, reads).some((blocker) => !byStage.has(blocker.item));
+}
+async function restartNow(state, update, version) {
+  const early = buildBlockers(runningBuilds(state));
+  if (early.length > 0) return { kind: "waiting", waits: early };
+  if (state.preparedUpdate !== void 0 && state.preparedUpdate.version !== version) discardPrepared(state);
+  const args = updateArgsOf(state, update, version);
+  let reads;
+  const declined = state.declinedFormats?.has(version) === true;
+  if (state.preparedUpdate !== void 0) {
+    reads = state.preparedUpdate.reads;
+  } else if (declined && restartBlockers(runningBuilds(state), state.declinedFormats.get(version)).length > 0) {
+    reads = state.declinedFormats.get(version);
+  } else {
+    const prepared = await prepareUpdate(args);
+    if (prepared.kind !== "prepared") {
+      dropPendingUpdate(state);
+      reportUpdateResult(state, version, prepared);
+      return { kind: "failed" };
+    }
+    reads = await askJobStateFormats(update.runNode, entryIn(prepared.dir), prepared.dir);
+    if (formatBlocked(runningBuilds(state), reads)) {
+      removeStaging(prepared.dir);
+      (state.declinedFormats ??= /* @__PURE__ */ new Map()).set(version, reads);
+    } else {
+      state.preparedUpdate = { version, dir: prepared.dir, reads };
+    }
+  }
+  const waits = restartBlockers(runningBuilds(state), reads);
+  if (waits.length > 0) return { kind: "waiting", waits };
+  const staged = state.preparedUpdate;
+  state.preparedUpdate = void 0;
+  dropPendingUpdate(state);
+  const result = installPrepared(args, staged.dir);
+  if (result.kind === "switched") {
+    (state.exitForUpdate ?? (() => update.exit(RESTART_EXIT_STATUS)))();
+    return { kind: "restarted" };
+  }
+  reportUpdateResult(state, version, result);
+  return { kind: "failed" };
+}
 async function updateWhenIdle(state) {
   const update = state.deps.update;
   const version = state.pendingUpdate;
   if (update === void 0 || version === void 0) {
+    discardPrepared(state);
     recordPendingUpdate(state, void 0);
     return false;
   }
@@ -1356,6 +1543,12 @@ async function updateWhenIdle(state) {
       }
       state.preflightedUpdate = version;
     }
+    if (update.underService === true) {
+      const outcome = await restartNow(state, update, version);
+      if (outcome.kind === "restarted") return true;
+      if (outcome.kind === "failed") return false;
+      return holdForUpdate(state, version, true, outcome.waits);
+    }
     return holdForUpdate(state, version);
   }
   dropPendingUpdate(state);
@@ -1488,8 +1681,9 @@ async function housekeepingPass(state) {
 async function runTick(state) {
   state.restarting = false;
   state.holdingForUpdate = false;
+  if (state.draining === true) return;
   reloadConfig(state);
-  if (restartOntoInstalled(state)) {
+  if (await restartOntoInstalled(state)) {
     state.restarting = true;
     return;
   }
@@ -1552,7 +1746,7 @@ var CLAIM_REFUSAL_CODES = new Set(
   "pull_request_from_fork pull_request_on_default_branch pull_request_ambiguous pull_request_repository_not_connected repository_not_reachable branch_claimed_elsewhere".split(" ")
 );
 async function tryClaimAndStart(state, item, queue) {
-  const { postJson: postJson2 } = await import('./work-cmd-FMPDXPU6.js');
+  const { postJson: postJson2 } = await import('./work-cmd-LRAXUOJV.js');
   const log = logOf(state);
   const hostKey = await loadHostKey(state.config.configPath);
   const claim = await retrySend(
@@ -1589,14 +1783,21 @@ async function tryClaimAndStart(state, item, queue) {
       return { kind: "signature" };
     }
     if (claim.code === "runner_upgrade_required") {
-      reportRepeating(state, "the runner protocol", claim.message ?? claim.reason);
+      const tag = tagToPull(state.imageNamed);
+      reportRepeating(
+        state,
+        "the runner protocol",
+        state.deps.image === void 0 ? claim.message ?? claim.reason : `${claim.message ?? claim.reason} \xB7 ${pullInstruction(tag)}`
+      );
       state.upgradeRefused = true;
+      recordImageStatus(state);
       return { kind: "outdated" };
     }
     return { kind: "error", reason: `${claim.reason} (${claim.attempts} attempt(s))` };
   }
   reportRepeating(state, "the runner protocol", void 0);
   state.upgradeRefused = false;
+  recordImageStatus(state);
   reportRepeating(state, "the request signature", void 0);
   const { data } = claim.value;
   const claimId = data.id === void 0 || data.id === null ? "" : String(data.id);
@@ -1605,7 +1806,7 @@ async function tryClaimAndStart(state, item, queue) {
   }
   if (wasExtended(data)) {
     log.line(
-      `#${item.number} skipped: the claim extended a live lease under host "${state.config.host}" \xB7 set a distinct runner.host per config file`
+      `#${item.number} skipped: the claim extended a live lease under the runner name "${state.config.host}" \xB7 set a distinct runner.name per config file`
     );
     return { kind: "held" };
   }
@@ -1695,6 +1896,7 @@ async function startJob(state, item, queue, claimId, itemKey, branch, identity,
   const runnerRoot = runnerDir(state.config.configPath);
   const jobFilePath = join(dirPath, "job.json");
   let job = {
+    stateFormat: state.deps.jobStateFormat ?? JOB_STATE_FORMAT,
     item: item.number,
     queue,
     claimId,
@@ -2514,6 +2716,13 @@ async function finishTrackedWhileAway(state, dirPath, job, where) {
     `recovered job ${finished.queue} #${finished.item} (claim ${shortClaim(finished.claimId)}) as ${outcome}: ${code === void 0 ? `its container ${where === "missing" ? "is gone" : "stopped"} and its volume ${read.readable ? "holds no exit code" : "could not be read"}` : `its command recorded exit ${code}`}`
   );
 }
+async function logUnusableHelper(config, runtime, log) {
+  if (!isBuiltinVm(config.hooks.provision)) return;
+  const helper = await runtime.vm.helper.probe();
+  if (helper.ok) return;
+  if (helper.reason === "unsupported") log.line(helper.detail);
+  else if (helper.unreachable === true) log.line(`${helper.detail}, so microVM builds run without the jailer`);
+}
 async function start(configPath, deps = { fetchImpl: fetch }) {
   const log = deps.log ??= createRunnerLog(deps.now ?? (() => /* @__PURE__ */ new Date()));
   const update = deps.update;
@@ -2521,7 +2730,7 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
     const outcome = await onStartUnderMarker({
       configPath,
       own: ownVersionOf(deps),
-      check: update.check ? () => update.check(configPath) : async () => (await import('./check-3CGLWMHM.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl }),
+      check: update.check ? () => update.check(configPath) : async () => (await import('./check-EPYRTE3R.js')).runRunnerCheck(configPath, { fetchImpl: deps.fetchImpl }),
       now: () => (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime(),
       log
     });
@@ -2560,12 +2769,16 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
   const state = { config, jobs: /* @__PURE__ */ new Map(), deps, configMtimeMs };
   log.line(`runner ${config.host} started \xB7 config ${configPath} \xB7 ${describeConfig(config)}`);
   const nowMs = () => deps.now ? deps.now().getTime() : Date.now();
-  const runningMicroVms = await stopOrphanedMicroVms({ jobs: unfinishedJobs(jobsDir(configPath)), runtime: runtimeOf(state) }).catch((err) => {
+  await logUnusableHelper(config, runtimeOf(state), log);
+  const runningMicroVms = await stopOrphanedMicroVms({ jobs: unfinishedJobs(jobsDir(configPath)), runtime: runtimeOf(state), onError: (line) => log.error(line) }).catch((err) => {
     log.error(`a microVM an earlier runner left could not be stopped: ${describeCallFailure(err)}`);
     return [];
   });
   for (const buildId of runningMicroVms) log.line(`stopped microVM build ${buildId}, left running by an earlier runner`);
   const attemptLogs = attemptLogsOf(state);
+  for (const { job, format } of listUnreadableJobs(jobsDir(configPath))) {
+    log.error(`leaving job ${job.queue} #${job.item} alone: its job-state format ${format} is not one this version reads`);
+  }
   for (const { dirPath, job } of listAdoptableJobs(jobsDir(configPath))) {
     const adopted = { job, dirPath, lastRenewAtMs: nowMs(), cmd: null, cpuSample: null, ending: false };
     state.jobs.set(dirPath, adopted);
@@ -2625,8 +2838,9 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
   const probeTimer = setInterval(() => {
     for (const active of state.jobs.values()) void probeBuild(state, active);
   }, deps.probeIntervalMs ?? PROBE_INTERVAL_MS);
-  const onSigterm = () => void drain();
+  const onSigterm = () => deps.image === void 0 ? void drain() : leave();
   const onSigusr1 = () => void stopNow();
+  const onSigusr2 = () => drainKeepingUp();
   const onSigint = () => {
     interrupts++;
     if (interrupts === 1) {
@@ -2639,6 +2853,7 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
   const detachSignals = () => {
     process.off("SIGTERM", onSigterm);
     process.off("SIGUSR1", onSigusr1);
+    process.off("SIGUSR2", onSigusr2);
     process.off("SIGINT", onSigint);
   };
   const stopIntake = () => {
@@ -2685,6 +2900,19 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
     }
     finish2();
   };
+  const drainKeepingUp = () => {
+    if (state.draining === true) return;
+    state.draining = true;
+    stopIntake();
+    log.line(`stopping: taking no more work, ${state.jobs.size} build(s) still managed \xB7 docker stop ends this container`);
+  };
+  const leave = () => {
+    if (exited) return;
+    log.line(`stopping: leaving ${state.jobs.size} running build(s) for the next runner to adopt`);
+    state.draining = true;
+    finish2();
+    deps.image?.exit?.(0);
+  };
   const stopNow = async () => {
     if (stopping) return;
     stopping = true;
@@ -2705,6 +2933,7 @@ async function start(configPath, deps = { fetchImpl: fetch }) {
   const handle = { state, drain, stopNow, close };
   process.on("SIGTERM", onSigterm);
   process.on("SIGUSR1", onSigusr1);
+  if (deps.image !== void 0) process.on("SIGUSR2", onSigusr2);
   process.on("SIGINT", onSigint);
   deps.onReady?.();
   await tick(state);
@@ -2717,7 +2946,8 @@ function describeWaiting(active, nowMs) {
 }
 var RunnerStartError = class extends Error {
 };
-async function requestStop(configPath, stopNow = false, pollMs = 5e3) {
+async function requestStop(configPath, stopNow = false, pollMs = 5e3, options = {}) {
+  const kill = options.kill ?? ((pid, signal2) => process.kill(pid, signal2));
   const entry = readPidFile(pidFilePath(configPath));
   if (!entry) {
     process.stdout.write("no runner is running on this config\n");
@@ -2729,9 +2959,9 @@ async function requestStop(configPath, stopNow = false, pollMs = 5e3) {
 `);
     return;
   }
-  const signal = stopNow ? "SIGUSR1" : "SIGTERM";
+  const signal = stopNow ? "SIGUSR1" : options.image === true ? "SIGUSR2" : "SIGTERM";
   try {
-    process.kill(entry.pid, signal);
+    kill(entry.pid, signal);
   } catch (err) {
     const code = err?.code;
     if (code === "EPERM") {
@@ -2744,6 +2974,14 @@ async function requestStop(configPath, stopNow = false, pollMs = 5e3) {
 `);
     return;
   }
+  if (signal === "SIGUSR2") {
+    process.stdout.write(
+      `sent SIGUSR2 to runner pid ${entry.pid}: it takes no more work and keeps managing its builds.
+The container stays up. Run \`outerlayer runner status\` to see what is left, then \`docker stop\` the container once nothing is.
+`
+    );
+    return;
+  }
   process.stdout.write(
     stopNow ? `sent SIGUSR1 to runner pid ${entry.pid}, stopping now
 ` : `sent SIGTERM to runner pid ${entry.pid}, draining
@@ -2777,4 +3015,4 @@ function runnerProcessState(configPath) {
   return isSameProcess(entry.pid, entry.start) ? { state: "running", pid: entry.pid } : { state: "stale", pid: entry.pid };
 }
 
-export { RunnerStartError, listJobFiles, probeBuild, probeCredentials, requestStop, runnerProcessState, start, tick, watchTick };
+export { RunnerStartError, listJobFiles, logUnusableHelper, probeBuild, probeCredentials, requestStop, runnerProcessState, start, tick, watchTick };

package/dist/{chunk-QS43O4DR.js → chunk-M4B6QKNZ.js}

@@ -5,7 +5,7 @@ import { readCloudConfig, cloudConfigPath } from './chunk-EABW6AJQ.js';
 import { cliInvocation } from './chunk-CRB3POP4.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { resolvePackageVersion } from './chunk-RA3O54FC.js';
-import { signRunnerRequest, signerFor } from './chunk-OW52QLK3.js';
+import { signRunnerRequest, signerFor } from './chunk-ZODVSFI4.js';
 
 createRequire(import.meta.url);
 

package/dist/{chunk-UF5L4BAI.js → chunk-O2WYUIK7.js}

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

package/dist/{chunk-276D7BJ7.js → chunk-QMQC6JCO.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-IHNQWF6F.js';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZI2ZVWKT.js';
 import { readlinkSync, realpathSync, mkdirSync, unlinkSync, symlinkSync, renameSync, readFileSync, writeFileSync, rmSync, existsSync, readdirSync } from 'fs';
 import { join, basename, sep, resolve } from 'path';
 

package/dist/{chunk-OGMZJWWD.js → chunk-QUGYGO6L.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { RecipeError, BUILDKIT_IMAGE } from './chunk-3W333NFO.js';
+import { RecipeError, BUILDKIT_IMAGE } from './chunk-RGW7ERF3.js';
 import { parseSize } from './chunk-7RQ73DLO.js';
-import { compareVersions } from './chunk-CBCKD6DO.js';
-import { ensureHostKey } from './chunk-OW52QLK3.js';
-import { RUNNER_DIR_MODE, RUNNER_FILE_MODE, runnerDir, jobsDir } from './chunk-IHNQWF6F.js';
-import { CLAUDE_PORT, JOB_MOUNT, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_SOCKET, RELAY_PORT, DESTINATION_BASE_PORT } from './chunk-URWYRAIC.js';
-import { JOIN_DIR, RELAY_ID, JOIN_SOCKET, TARGET_GATEWAY, TARGET_CLAUDE, destinationTarget, RELAY_USER } from './chunk-GISNHSYL.js';
+import { compareVersions } from './chunk-D4AMAEZ7.js';
+import { ensureHostKey } from './chunk-ZODVSFI4.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE, runnerDir, jobsDir } from './chunk-ZI2ZVWKT.js';
+import { CLAUDE_PORT, JOB_MOUNT, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_SOCKET, RELAY_PORT, DESTINATION_BASE_PORT } from './chunk-2K3TCQHW.js';
+import { JOIN_DIR, RELAY_ID, JOIN_SOCKET, TARGET_GATEWAY, TARGET_CLAUDE, destinationTarget, RELAY_USER } from './chunk-JGD5TWQ2.js';
 import { StringDecoder } from 'string_decoder';
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, mkdirSync, createWriteStream, rmSync, chmodSync, writeFileSync, realpathSync, readdirSync, renameSync } from 'fs';

package/dist/{chunk-JV4YGAAW.js → chunk-QXNJWSTM.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { compareVersions } from './chunk-I2UOAV7X.js';
-import { launcherPath, writeLauncher, LauncherWriteError, pathNotes } from './chunk-EFB3FGLC.js';
-import { currentVersion, currentLink, isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-276D7BJ7.js';
-import { RUNNER_DIR_MODE } from './chunk-IHNQWF6F.js';
+import { launcherPath, writeLauncher, LauncherWriteError, pathNotes } from './chunk-ATGHVEU4.js';
+import { currentVersion, currentLink, isInLayout, packageRootIn, versionDir, switchCurrent, execStartLine } from './chunk-QMQC6JCO.js';
+import { compareVersions } from './chunk-TQMI335S.js';
+import { RUNNER_DIR_MODE } from './chunk-ZI2ZVWKT.js';
 import { realpathSync, readFileSync, mkdirSync, rmSync, cpSync, existsSync } from 'fs';
 import { dirname, sep, join } from 'path';
 
@@ -92,7 +92,7 @@ function launcherSummary(launcher) {
 }
 function restartNote(result) {
   if (result.previous === void 0 || result.previous === result.version) return void 0;
-  return `current moved from ${result.previous} to ${result.version}: a runner its service started takes no new work, waits for its running builds to finish, then restarts on ${result.version}. A runner started by hand keeps running until you restart it`;
+  return `current moved from ${result.previous} to ${result.version}: a runner its service started restarts on ${result.version} at once when its running builds are container builds that carry on through the restart. Otherwise it takes no new work and waits for them to finish. A runner started by hand keeps running until you restart it`;
 }
 
 export { RunnerDowngradeError, RunnerInstallError, launcherSummary, restartNote, runRunnerInstall };