chainlesschain 0.165.1 → 0.165.3

package/src/lib/background-agent-keeper-client.js

@@ -5,6 +5,8 @@ import {
   BACKGROUND_AGENT_KEEPER_ARM,
   BACKGROUND_AGENT_KEEPER_ARMED,
   BACKGROUND_AGENT_KEEPER_HELLO,
+  BACKGROUND_AGENT_KEEPER_HEARTBEAT,
+  BACKGROUND_AGENT_KEEPER_HEARTBEAT_INTERVAL_MS,
   BACKGROUND_AGENT_KEEPER_PROTOCOL_VERSION,
   BACKGROUND_AGENT_KEEPER_READY,
   BACKGROUND_AGENT_KEEPER_RETIRE,
@@ -76,11 +78,17 @@ export async function connectBackgroundAgentKeeper(options = {}) {
   const retireTimeoutMs = resolveBackgroundAgentKeeperRetireTimeoutMs(
     options.retireTimeoutMs,
   );
+  const heartbeatIntervalMs = Math.max(
+    10,
+    Number(options.heartbeatIntervalMs) ||
+      BACKGROUND_AGENT_KEEPER_HEARTBEAT_INTERVAL_MS,
+  );
   const socket = await connectWithDeadline(options.pipePath, connectTimeoutMs);
   const pending = new Map();
   let ready = false;
   let closing = false;
   let activeTurn = null;
+  let heartbeatTimer = null;
   let readyResolve;
   let readyReject;
   const readyPromise = new Promise((resolve, reject) => {
@@ -89,6 +97,8 @@ export async function connectBackgroundAgentKeeper(options = {}) {
   });
 
   const failPending = (error) => {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
     readyReject(error);
     for (const entry of pending.values()) {
       clearTimeout(entry.timer);
@@ -171,6 +181,23 @@ export async function connectBackgroundAgentKeeper(options = {}) {
   );
   helloTimer.unref?.();
   await readyPromise.finally(() => clearTimeout(helloTimer));
+  const sendHeartbeat = () => {
+    try {
+      writeMessage(
+        socket,
+        createBackgroundAgentKeeperMessage(BACKGROUND_AGENT_KEEPER_HEARTBEAT, {
+          id: hello.id,
+          workerGeneration: hello.workerGeneration,
+          workerPid: hello.workerPid,
+        }),
+      );
+    } catch (error) {
+      socket.destroy(error);
+    }
+  };
+  sendHeartbeat();
+  heartbeatTimer = setInterval(sendHeartbeat, heartbeatIntervalMs);
+  heartbeatTimer.unref?.();
 
   const request = (
     type,
@@ -241,6 +268,8 @@ export async function connectBackgroundAgentKeeper(options = {}) {
     close() {
       if (closing) return;
       closing = true;
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
       socket.end();
     },
     activeTurn: () => activeTurn,

package/src/lib/background-agent-keeper-protocol.js

@@ -1,15 +1,33 @@
 import { createHash } from "node:crypto";
 import { lstatSync, mkdirSync, rmdirSync } from "node:fs";
-import { posix } from "node:path";
+import { join, posix, resolve } from "node:path";
 
 export const BACKGROUND_AGENT_KEEPER_PROTOCOL_VERSION = 1;
 export const BACKGROUND_AGENT_KEEPER_HELLO = "background-agent-keeper-hello";
 export const BACKGROUND_AGENT_KEEPER_READY = "background-agent-keeper-ready";
+export const BACKGROUND_AGENT_KEEPER_HEARTBEAT =
+  "background-agent-keeper-heartbeat";
 export const BACKGROUND_AGENT_KEEPER_ARM = "background-agent-keeper-arm";
 export const BACKGROUND_AGENT_KEEPER_ARMED = "background-agent-keeper-armed";
 export const BACKGROUND_AGENT_KEEPER_RETIRE = "background-agent-keeper-retire";
 export const BACKGROUND_AGENT_KEEPER_RETIRED =
   "background-agent-keeper-retired";
+export const BACKGROUND_AGENT_KEEPER_LAUNCH_CLAIM =
+  "background-agent-keeper-launch-claim";
+export const BACKGROUND_AGENT_KEEPER_HEARTBEAT_INTERVAL_MS = 1_000;
+// Do not launch an OS process-identity probe while authenticated application
+// heartbeats are fresh. On Windows the cached WMIC/CIM fallback can otherwise
+// make 20 keepers synchronously spawn probe helpers together every ten seconds.
+export const BACKGROUND_AGENT_KEEPER_IDENTITY_PROBE_DELAY_MS = 15_000;
+// This application-level fence is a backstop for the rare case where Windows
+// retains both the named-pipe handle and an exact process object after worker
+// death. Normal death still closes the socket immediately; a stale channel
+// gets the delayed PID/start-time probe before this final fence. A 20-worker
+// hosted Windows launch has demonstrated
+// 37-second scheduling tails, so 15 seconds could kill a live, healthy worker
+// while it was merely descheduled. Keep the backstop bounded but above that
+// measured contention window.
+export const BACKGROUND_AGENT_KEEPER_HEARTBEAT_TIMEOUT_MS = 60_000;
 
 // RETIRE is the only keeper request that performs destructive OS cleanup. Its
 // deadline is deliberately independent from the short HELLO/ARM request
@@ -18,7 +36,7 @@ export const BACKGROUND_AGENT_KEEPER_RETIRED =
 //
 //   2 targets * (strict identity + taskkill + cleanup confirmation identity) +
 //   2 cleanup-critical persistence retry windows + cleanup confirmation +
-//   scheduling margin = 120 seconds.
+//   scheduling margin = 128 seconds.
 //
 // Keeping these limits in the shared protocol contract prevents either side
 // from silently reintroducing the old 10-second client / longer keeper race.
@@ -32,7 +50,12 @@ export const BACKGROUND_AGENT_KEEPER_IDENTITY_PROBE_TIMEOUT_MS =
 export const BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS = 5_000;
 export const BACKGROUND_AGENT_KEEPER_PERSIST_RETRY_TIMEOUT_MS =
   3 * BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS;
-export const BACKGROUND_AGENT_KEEPER_CLEANUP_CONFIRM_TIMEOUT_MS = 2_000;
+// A 20-Agent macOS formal run can leave successfully SIGKILLed process groups
+// observable for several seconds while launchd reaps their orphaned leaders.
+// Two seconds made that bounded kernel/reaper delay look like an escaped tree.
+// Ten seconds stays inside the formal observer's 150-second budget while
+// retaining a finite fail-closed confirmation window.
+export const BACKGROUND_AGENT_KEEPER_CLEANUP_CONFIRM_TIMEOUT_MS = 10_000;
 export const BACKGROUND_AGENT_KEEPER_RETIRE_TIMEOUT_MARGIN_MS = 8_000;
 export const BACKGROUND_AGENT_KEEPER_RETIRE_TIMEOUT_MS =
   BACKGROUND_AGENT_KEEPER_CLEANUP_TARGET_LIMIT *
@@ -88,6 +111,58 @@ function requiredTimestamp(value, label) {
   return normalized;
 }
 
+export function backgroundAgentKeeperLaunchClaimPath(
+  id,
+  keeperGeneration,
+  directory,
+) {
+  const safeId = requiredSafeString(id, "id");
+  const safeGeneration = requiredSafeString(
+    keeperGeneration,
+    "keeper generation",
+  );
+  const requestedDirectory =
+    typeof directory === "string" ? directory.trim() : "";
+  if (!requestedDirectory || requestedDirectory.includes("\0")) {
+    throw new TypeError("invalid background agent keeper state directory");
+  }
+  const stateDirectory = resolve(requestedDirectory);
+  return join(
+    stateDirectory,
+    `.${safeId}.keeper-${safeGeneration}.launch-claim.json`,
+  );
+}
+
+export function createBackgroundAgentKeeperLaunchClaim(binding = {}) {
+  return Object.freeze({
+    type: BACKGROUND_AGENT_KEEPER_LAUNCH_CLAIM,
+    protocolVersion: BACKGROUND_AGENT_KEEPER_PROTOCOL_VERSION,
+    id: requiredSafeString(binding.id, "id"),
+    workerGeneration: requiredSafeString(
+      binding.workerGeneration,
+      "worker generation",
+    ),
+    keeperGeneration: requiredSafeString(
+      binding.keeperGeneration,
+      "keeper generation",
+    ),
+    keeperPid: requiredPositiveInteger(binding.keeperPid, "keeper pid"),
+    token: requiredSafeString(binding.token, "token", SAFE_TOKEN),
+  });
+}
+
+export function matchesBackgroundAgentKeeperLaunchClaim(value, expected = {}) {
+  let actual;
+  let binding;
+  try {
+    actual = createBackgroundAgentKeeperLaunchClaim(value);
+    binding = createBackgroundAgentKeeperLaunchClaim(expected);
+  } catch {
+    return false;
+  }
+  return Object.keys(binding).every((key) => actual[key] === binding[key]);
+}
+
 function digestKeeperPath(value, length) {
   return createHash("sha256").update(value).digest("hex").slice(0, length);
 }

package/src/lib/background-agent-launch-barrier.js

@@ -0,0 +1,74 @@
+/**
+ * Read-only startup barrier shared by the detached background worker and its
+ * keeper. The launcher publishes both exact child PIDs in one state
+ * transaction before clearing `launchFinalizationUncertain`. Until then the
+ * children must not contend for the same state lock.
+ */
+
+export const BACKGROUND_AGENT_LAUNCH_BARRIER_TIMEOUT_MS = 30_000;
+
+const DEFAULT_POLL_MS = 25;
+const PID_FIELDS = new Set(["workerPid", "keeperPid"]);
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export async function waitForBackgroundAgentLaunchBarrier(options = {}) {
+  const id = String(options.id || "").trim();
+  const workerGeneration = String(options.workerGeneration || "").trim();
+  const expectedPid = Number(options.expectedPid);
+  const pidField = String(options.pidField || "");
+  const readState = options.readState;
+  const readyWhen = options.readyWhen;
+  const now = options.now || Date.now;
+  const sleep = options.sleep || delay;
+  const timeoutMs = Math.max(
+    1,
+    Number(options.timeoutMs) || BACKGROUND_AGENT_LAUNCH_BARRIER_TIMEOUT_MS,
+  );
+  const pollMs = Math.max(1, Number(options.pollMs) || DEFAULT_POLL_MS);
+
+  if (!id) {
+    throw new TypeError("background launch barrier id is required");
+  }
+  if (!PID_FIELDS.has(pidField)) {
+    throw new TypeError("background launch barrier pid field is invalid");
+  }
+  if (!Number.isSafeInteger(expectedPid) || expectedPid <= 0) {
+    throw new TypeError("background launch barrier pid is invalid");
+  }
+  if (typeof readState !== "function") {
+    throw new TypeError("background launch barrier state reader is required");
+  }
+  if (readyWhen !== undefined && typeof readyWhen !== "function") {
+    throw new TypeError("background launch barrier readiness check is invalid");
+  }
+
+  const deadline = now() + timeoutMs;
+  for (;;) {
+    const state = readState(id);
+    if (!state || state.status !== "running") {
+      return Object.freeze({ status: "terminal", state: state || null });
+    }
+    // Jobs written before generation fencing are allowed to observe an
+    // already-terminal record above, but can never enter a running record.
+    if (!workerGeneration || state.workerGeneration !== workerGeneration) {
+      return Object.freeze({ status: "terminal", state });
+    }
+    if (state.launchFinalizationUncertain !== true) {
+      if (Number(state[pidField]) !== expectedPid) {
+        return Object.freeze({ status: "identity-mismatch", state });
+      }
+      if (!readyWhen || readyWhen(state)) {
+        return Object.freeze({ status: "ready", state });
+      }
+    }
+
+    const remaining = deadline - now();
+    if (remaining <= 0) {
+      return Object.freeze({ status: "timeout", state });
+    }
+    await sleep(Math.min(pollMs, remaining));
+  }
+}

package/src/lib/background-agent-supervisor.js

@@ -79,6 +79,110 @@ export const PID_IDENTITY_TOLERANCE_MS = 60000;
 export const PROCESS_START_TIME_CACHE_TTL_MS = 10_000;
 export const PROCESS_START_TIME_CACHE_MAX_ENTRIES = 4_096;
 
+// Linux exposes these fields directly through procfs. `/proc/<pid>/stat`
+// reports starttime in USER_HZ units, which Linux defines as 100 ticks/second
+// for this userspace ABI independently of the kernel scheduler frequency.
+const LINUX_PROC_CLOCK_TICKS_PER_SECOND = 100;
+let linuxBootTimeMsCache;
+
+export function parseLinuxProcStat(text, bootTimeMs = null) {
+  const value = String(text || "").trim();
+  const open = value.indexOf("(");
+  const close = value.lastIndexOf(")");
+  if (open <= 0 || close <= open || value.charAt(close + 1) !== " ") {
+    return null;
+  }
+  const pid = Number(value.slice(0, open).trim());
+  const fields = value
+    .slice(close + 2)
+    .trim()
+    .split(/\s+/u);
+  const state = fields[0];
+  const processGroupId = Number(fields[2]);
+  const startTimeTicks = Number(fields[19]);
+  if (
+    !Number.isSafeInteger(pid) ||
+    pid <= 0 ||
+    !/^[A-Z]$/iu.test(state || "") ||
+    !Number.isSafeInteger(processGroupId) ||
+    processGroupId <= 0 ||
+    !Number.isFinite(startTimeTicks) ||
+    startTimeTicks < 0
+  ) {
+    return null;
+  }
+  const boot = Number(bootTimeMs);
+  return {
+    pid,
+    state: state.toUpperCase(),
+    processGroupId,
+    startTimeTicks,
+    startedAtMs:
+      Number.isFinite(boot) && boot > 0
+        ? boot + (startTimeTicks * 1000) / LINUX_PROC_CLOCK_TICKS_PER_SECOND
+        : null,
+  };
+}
+
+function linuxBootTimeMs() {
+  if (linuxBootTimeMsCache !== undefined) return linuxBootTimeMsCache;
+  try {
+    const match = /^btime\s+(\d+)\s*$/mu.exec(
+      readFileSync("/proc/stat", "utf8"),
+    );
+    const seconds = match ? Number(match[1]) : null;
+    linuxBootTimeMsCache =
+      Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : null;
+  } catch {
+    linuxBootTimeMsCache = null;
+  }
+  return linuxBootTimeMsCache;
+}
+
+function readLinuxProcProcess(pid) {
+  const target = Number(pid);
+  if (!Number.isSafeInteger(target) || target <= 0) {
+    return { status: "unknown", process: null };
+  }
+  try {
+    const parsed = parseLinuxProcStat(
+      readFileSync(`/proc/${target}/stat`, "utf8"),
+      linuxBootTimeMs(),
+    );
+    return parsed
+      ? { status: "present", process: parsed }
+      : { status: "unknown", process: null };
+  } catch (error) {
+    return ["ENOENT", "ESRCH"].includes(error?.code)
+      ? { status: "absent", process: null }
+      : { status: "unknown", process: null };
+  }
+}
+
+function readLinuxProcProcessGroupStates(pgid) {
+  const target = Number(pgid);
+  if (!Number.isSafeInteger(target) || target <= 0) return null;
+  let entries;
+  try {
+    entries = readdirSync("/proc");
+  } catch {
+    return null;
+  }
+  const states = [];
+  for (const entry of entries) {
+    if (!/^\d+$/u.test(entry)) continue;
+    const observed = readLinuxProcProcess(Number(entry));
+    if (observed.status === "unknown") return null;
+    if (
+      observed.status === "present" &&
+      observed.process.processGroupId === target
+    ) {
+      states.push(observed.process.state);
+    }
+  }
+  return states;
+}
+
 /**
  * A bounded FIFO/TTL cache for process creation-time probes.
  *
@@ -263,6 +367,13 @@ function defaultReadProcessStartTimeMs(pid) {
     }
     return null;
   }
+  if (process.platform === "linux") {
+    const observed = readLinuxProcProcess(target);
+    if (observed.status === "absent") return { status: "absent" };
+    if (Number.isFinite(observed.process?.startedAtMs)) {
+      return observed.process.startedAtMs;
+    }
+  }
   // POSIX: `ps -o lstart=` gives an absolute start timestamp on Linux + macOS
   // (procps and BSD ps both support it; busybox ps does not → null → open).
   try {
@@ -300,6 +411,12 @@ function defaultReadProcessState(pid) {
   ) {
     return null;
   }
+  if (process.platform === "linux") {
+    const observed = readLinuxProcProcess(target);
+    if (observed.status !== "unknown") {
+      return observed.process?.state || null;
+    }
+  }
   try {
     const result = runSupervisorCommand(
       "ps",
@@ -335,6 +452,10 @@ function defaultReadProcessGroupStates(pgid) {
   ) {
     return null;
   }
+  if (process.platform === "linux") {
+    const states = readLinuxProcProcessGroupStates(target);
+    if (Array.isArray(states)) return states;
+  }
   try {
     const result = runSupervisorCommand(
       "ps",
@@ -1128,7 +1249,7 @@ function mergeBackgroundAgentState(current, requested) {
   return next;
 }
 
-function persistBackgroundAgentState(target, next) {
+function persistBackgroundAgentState(target, next, options = {}) {
   // Multiple async state writers can run in one process; a pid-only temporary
   // name lets them overwrite each other's staging file. A unique suffix keeps
   // each atomic replacement independent. Windows scanners/readers can also
@@ -1136,6 +1257,21 @@ function persistBackgroundAgentState(target, next) {
   // transient class rather than surfacing a spurious EPERM background failure.
   const tmp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
   writeFileSync(tmp, JSON.stringify(next, null, 2), { mode: 0o600 });
+  try {
+    if (
+      typeof options.publishReleaseAfterPathRemoved === "function" &&
+      options.publishReleaseAfterPathRemoved(tmp) !== true
+    ) {
+      const error = new Error(
+        `Could not publish state-lock release handoff: ${target}`,
+      );
+      error.code = "STATE_LOCK_RELEASE_HANDOFF_FAILED";
+      throw error;
+    }
+  } catch (error) {
+    rmSync(tmp, { force: true });
+    throw error;
+  }
   for (let attempt = 0; ; attempt++) {
     try {
       renameSync(tmp, target);
@@ -1179,7 +1315,7 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
   const target = statePath(safe);
   return withFileLock(
     target,
-    () => {
+    ({ publishReleaseAfterPathRemoved }) => {
       const read = readBackgroundAgentStateResult(safe);
       if (read.error) throw read.error;
       if (read.missing && options.createIfMissing !== true) {
@@ -1193,7 +1329,9 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
         ...requested,
         id: safe,
       });
-      persistBackgroundAgentState(target, next);
+      persistBackgroundAgentState(target, next, {
+        publishReleaseAfterPathRemoved,
+      });
       return { applied: true, state: next, previous: read.state };
     },
     {
@@ -2976,8 +3114,14 @@ function recordedBackgroundProcessesAlive(state) {
   );
 }
 
-export function isBackgroundProcessTreeExecutionAlive(pid, startedAt) {
-  const identity = inspectDestructiveProcessIdentity(pid, startedAt);
+export function isBackgroundProcessTreeExecutionAlive(
+  pid,
+  startedAt,
+  options = {},
+) {
+  const identity = inspectDestructiveProcessIdentity(pid, startedAt, {
+    processGroup: options.processGroup !== false,
+  });
   // `unverifiable` includes a vanished/zombie POSIX leader whose process group
   // is still executable or whose group snapshot failed. Both must block
   // worktree deletion just as a verified live leader does.
@@ -3051,22 +3195,10 @@ function isDestructiveIdentityRetired(identity) {
   return ["dead", "reused"].includes(identity?.status);
 }
 
-function isRecoverableCreationTimeIdentityProbe(identity) {
-  // A one-shot `ps -o lstart=` failure is observational: it says nothing about
-  // whether the exact target is still present. Other unverifiable outcomes can
-  // mean a missing durable anchor, a vanished group owner, PID reuse with a
-  // surviving group, or an untrusted group snapshot; those remain immediately
-  // fail-closed rather than being promoted into the resend path.
-  return (
-    identity?.status === "unverifiable" &&
-    identity?.reason === "creation-time-probe-failed"
-  );
-}
-
-function isRecoverableInitialDestructiveIdentityProbe(identity) {
+function isRecoverableDestructiveIdentityProbe(identity) {
   // These outcomes come only from read-only OS observations. Retrying them
   // cannot address a process, and the caller still requires two consecutive
-  // fresh exact matches before it may issue the first signal.
+  // fresh exact matches before it may issue or reissue a signal.
   return (
     identity?.status === "unverifiable" &&
     ["creation-time-probe-failed", "process-group-state-probe-failed"].includes(
@@ -3137,7 +3269,7 @@ function retryRecoverableInitialPosixIdentity({
     }
     if (
       lastIdentity?.status !== "match" &&
-      !isRecoverableInitialDestructiveIdentityProbe(lastIdentity)
+      !isRecoverableDestructiveIdentityProbe(lastIdentity)
     ) {
       return outcome("failed", "preflight-identity");
     }
@@ -3154,7 +3286,7 @@ function retryRecoverableInitialPosixIdentity({
     }
     if (
       lastIdentity?.status !== "match" &&
-      !isRecoverableInitialDestructiveIdentityProbe(lastIdentity)
+      !isRecoverableDestructiveIdentityProbe(lastIdentity)
     ) {
       return outcome("failed", "preflight-identity");
     }
@@ -3172,8 +3304,9 @@ function retryRecoverableInitialPosixIdentity({
 
 /**
  * Recover from a transient POSIX EPERM without ever signalling from unknown
- * identity evidence. Probe-only waits may bridge a transient creation-time
- * lookup failure, but a resend requires two consecutive fresh exact matches.
+ * identity evidence. Probe-only waits may bridge a transient creation-time or
+ * process-group-state lookup failure, but a resend requires two consecutive
+ * fresh exact matches.
  */
 function retryExactPosixSignalAfterPermissionError({
   inspectIdentity,
@@ -3203,7 +3336,7 @@ function retryExactPosixSignalAfterPermissionError({
     }
     if (
       lastIdentity?.status !== "match" &&
-      !isRecoverableCreationTimeIdentityProbe(lastIdentity)
+      !isRecoverableDestructiveIdentityProbe(lastIdentity)
     ) {
       return outcome("failed", "identity");
     }
@@ -3226,7 +3359,7 @@ function retryExactPosixSignalAfterPermissionError({
     }
     if (
       lastIdentity?.status !== "match" &&
-      !isRecoverableCreationTimeIdentityProbe(lastIdentity)
+      !isRecoverableDestructiveIdentityProbe(lastIdentity)
     ) {
       return outcome("failed", "identity");
     }
@@ -3306,7 +3439,7 @@ function signalExactBackgroundProcessTree(
   if (lastIdentity.status !== "match") {
     if (
       platform === "win32" ||
-      !isRecoverableInitialDestructiveIdentityProbe(lastIdentity)
+      !isRecoverableDestructiveIdentityProbe(lastIdentity)
     ) {
       retryStoppedBy = "preflight-identity";
       throw failure(
@@ -3663,7 +3796,7 @@ export function stopBackgroundAgent(id) {
           identityProbeRetries: 0,
         };
         try {
-          const preflightIdentity = inspectIdentity();
+          let preflightIdentity = inspectIdentity();
           activeTerminationContext.lastIdentityStatus =
             preflightIdentity.status;
           activeTerminationContext.lastIdentityReason =
@@ -3681,14 +3814,55 @@ export function stopBackgroundAgent(id) {
             continue;
           }
           if (preflightIdentity.status !== "match") {
-            activeTerminationContext.retryStoppedBy = "preflight-identity";
-            throw new Error(
-              `destructive process identity is ${preflightIdentity.status}: ${preflightIdentity.reason || "unknown"}`,
-            );
+            if (
+              process.platform === "win32" ||
+              !isRecoverableDestructiveIdentityProbe(preflightIdentity)
+            ) {
+              activeTerminationContext.retryStoppedBy = "preflight-identity";
+              throw new Error(
+                `destructive process identity is ${preflightIdentity.status}: ${preflightIdentity.reason || "unknown"}`,
+              );
+            }
+            permissionRetryDeadline =
+              _deps.posixPermissionRetryNowMs() +
+              Math.max(0, Number(_deps.processExitWaitDeadlineMs) || 0);
+            const retry = retryRecoverableInitialPosixIdentity({
+              inspectIdentity,
+              initialIdentity: preflightIdentity,
+              deadline: permissionRetryDeadline,
+            });
+            activeTerminationContext.identityProbeRetries +=
+              retry.identityProbeRetries;
+            preflightIdentity = retry.lastIdentity;
+            activeTerminationContext.lastIdentityStatus =
+              preflightIdentity?.status;
+            activeTerminationContext.lastIdentityReason =
+              preflightIdentity?.reason || null;
+            activeTerminationContext.retryStoppedBy = retry.retryStoppedBy;
+            if (retry.status === "retired") {
+              if (
+                preflightIdentity?.status === "reused" &&
+                primaryWorker?.pid === target.pid &&
+                !signalledPids.has(target.pid)
+              ) {
+                workerPidReused = true;
+              }
+              target.retiredBeforeWait = true;
+              signalledPids.add(target.pid);
+              continue;
+            }
+            if (retry.status !== "matched") {
+              throw new Error(
+                `destructive process identity is ${preflightIdentity?.status || "unknown"}: ${preflightIdentity?.reason || "unknown"}`,
+              );
+            }
+          }
+          if (!(permissionRetryDeadline > 0)) {
+            permissionRetryDeadline =
+              _deps.posixPermissionRetryNowMs() +
+              Math.max(0, Number(_deps.processExitWaitDeadlineMs) || 0);
           }
-          permissionRetryDeadline =
-            _deps.posixPermissionRetryNowMs() +
-            Math.max(0, Number(_deps.processExitWaitDeadlineMs) || 0);
+          activeTerminationContext.retryStoppedBy = "initial-signal";
           target.signalledAsGroup = sendInitialSignal() === "process-group";
           signalledPids.add(target.pid);
         } catch (error) {

package/src/lib/background-turn-bootstrap-protocol.js

@@ -11,6 +11,10 @@ export const BACKGROUND_TURN_BOOTSTRAP_READY =
   "background-turn-bootstrap-ready";
 export const BACKGROUND_TURN_BOOTSTRAP_RELEASE =
   "background-turn-bootstrap-release";
+// The formal launch gate permits 120 seconds for a 20-worker hosted runner to
+// become ready. Keep the pre-main barrier alive for that same bounded window;
+// worker/IPC death still fails immediately through the disconnect listener.
+export const BACKGROUND_TURN_BOOTSTRAP_RELEASE_TIMEOUT_MS = 120_000;
 
 export const BACKGROUND_TURN_BOOTSTRAP_ENV = Object.freeze({
   nonce: "CC_BACKGROUND_TURN_BOOTSTRAP_NONCE",