pi-crew 0.11.51 → 0.11.52

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-crew",
-	"version": "0.11.51",
+	"version": "0.11.52",
 	"description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
 	"author": "baphuongna",
 	"license": "MIT",

package/src/extension/team-tool/cancel.ts

@@ -209,7 +209,21 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 		const retriedIds = new Set(matchingTasks.map((t) => t.id));
 		const tasks = fresh.tasks.map((task) => {
 			if (!retriedIds.has(task.id)) return task;
-			const { error: _error, finishedAt: _finishedAt, terminalEvidence: _terminalEvidence, ...rest } = task;
+			// FIX-2 (live catch, run team_20261030044630): also strip the stale
+			// liveness fields — heartbeat-watcher treats evidence older than the
+			// NEXT attempt's startedAt as inadmissible, but the persisted fields
+			// also feed OTHER consumers (UI gradients, reconciler). Attempt-2
+			// must not inherit attempt-1's heartbeat/agentProgress timestamps.
+			// (checkpoint.childPid has its own per-spawn reset semantics in
+			// state-helpers.ts — deliberately untouched here.)
+			const {
+				error: _error,
+				finishedAt: _finishedAt,
+				terminalEvidence: _terminalEvidence,
+				heartbeat: _heartbeat,
+				agentProgress: _agentProgress,
+				...rest
+			} = task;
 			return { ...rest, status: "queued" as const };
 		});
 		saveRunTasks(fresh.manifest, tasks);

package/src/runtime/background-runner.ts

@@ -48,6 +48,7 @@ import { writeAsyncStartMarker } from "./async-marker.ts";
 import { parseStdinBrokerPayload, readStdinFirstLine } from "./broker/stdin-handshake.ts";
 import { terminateActiveChildPiProcesses } from "./child-pi/child-pi.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
+import { startRunInterruptGuard } from "./foreground-control.ts";
 import { resolveCrewRuntime, runtimeResolutionState } from "./model/runtime-resolver.ts";
 import { registryFromModelContext } from "./model/session-model.ts";
 import { unregisterWorker } from "./orphan-worker-registry.ts";
@@ -227,86 +228,47 @@ export function installBackgroundRunnerSigintHandler(abortController: AbortContr
 	});
 }
 
+/**
+ * Process-wide (detached-runner) variant of the interrupt guard. Thin wrapper
+ * over the extracted core in ./foreground-control.ts (FIX-1, live catch run
+ * team_20261030044630): the polling/ack/event semantics live there; THIS
+ * wrapper owns the process-wide consequences only the detached runner may
+ * take (kill ALL child-pi processes, stop the parent guard, exit 130). The
+ * INLINE core (executeBackgroundRun) uses startRunInterruptGuard directly
+ * with a run-scoped onInterrupt instead — it must NEVER take these actions
+ * inside a host process that may own sibling runs.
+ *
+ * Kept exported from background-runner.ts so existing imports/tests
+ * (interrupt-guard-ack.test.ts) keep working unchanged.
+ */
 export function startInterruptGuard(
 	manifest: { runId: string; stateRoot: string; eventsPath: string },
 	abortController: AbortController,
 	stopParentGuard: () => void,
 ): () => void {
-	const controlPath = path.join(manifest.stateRoot, "foreground-control.json");
-	// FIX: Made configurable via PI_CREW_INTERRUPT_GUARD_INTERVAL_MS env var.
-	// PERF (2026-08-24): default 1000ms. Each tick does existsSync + readFileSync
-	// + JSON.parse for the whole background run, and the guard is best-effort
-	// interrupt LATENCY, not a correctness deadline — verified by reading the
-	// trigger body below: a late trigger merely delays the SIGTERM (children are
-	// SIGKILLed after HARD_KILL_MS=3s regardless) and no state machine aborts on
-	// a deadline when the guard fires late. Nothing downstream requires the old
-	// 250ms cadence, so trade up to 4×/s of fs+parse churn for 1×/s.
-	const interruptGuardInterval = Number(getCrewEnv("PI_CREW_INTERRUPT_GUARD_INTERVAL_MS")) || 1000;
-	// RT-4 FIX: Module-local gate so the interrupt body runs only once per
-	// interrupt request. Without this, the guard re-fires every
-	// interruptGuardInterval — each tick does a full
-	// terminateActiveChildPiProcesses sweep + sync appendEvent. The ack write
-	// stops the re-fire; this gate is defense-in-depth if
-	// the ack write fails (e.g. transient fs error).
-	let interruptHandled = false;
-	const interval = setInterval(() => {
-		try {
-			if (!fs.existsSync(controlPath)) return;
-			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as {
-				requests?: Array<{ type: string; acknowledged?: boolean }>;
-			};
-			const last = parsed.requests?.at(-1);
-			if (last?.type === "interrupt" && last?.acknowledged !== true) {
-				// RT-4 FIX: Gate ensures the interrupt body runs only once even if
-				// the synchronous ack write below fails.
-				if (interruptHandled) return;
-				interruptHandled = true;
-
-				// RT-4 FIX: Write acknowledged:true back to foreground-control.json
-				// SYNCHRONOUSLY. This stops the guard from re-firing on the next tick
-				// (interruptGuardInterval). Must be sync because this is a setInterval
-				// polling callback — we cannot await in a polling callback.
-				try {
-					const reqs = parsed.requests ?? [];
-					if (reqs.length > 0) {
-						reqs[reqs.length - 1].acknowledged = true;
-						atomicWriteFile(controlPath, JSON.stringify(parsed, null, 2));
-					}
-				} catch {
-					/* best-effort ack — interruptHandled gate prevents re-fire */
-				}
-
-				appendEventBuffered(manifest.eventsPath, {
-					type: "async.interrupt_detected",
-					runId: manifest.runId,
-					message: "Background runner detected foreground interrupt — killing child processes and exiting.",
-				}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.interrupt_detected"));
-				// FIX: Terminate ALL child-pi processes IMMEDIATELY before exiting.
-				// Previously this was missing, causing orphaned child processes to run forever
-				// after the background-runner exited. terminateActiveChildPiProcesses sends
-				// SIGTERM then SIGKILL (after HARD_KILL_MS=3s) to every active child.
-				const killed = terminateActiveChildPiProcesses();
-				console.log(`[background-runner] interrupt: killed ${killed} child processes`);
-				// Also abort the run signal so executeTeamRun exits quickly via its signal check.
-				abortController.abort();
-				// Call stopParentGuard() explicitly in addition to the finally block in
-				// main() — defense-in-depth ensures the guard is torn down promptly.
-				stopParentGuard();
-				// CORE-7 fix: Do NOT call process.exit() — it skips the finally block in
-				// main() (which runs unregisterWorker + stopParentGuard), leaving a stale
-				// orphan registry entry. Setting exitCode lets the event loop drain and
-				// main()'s finally block run cleanup before the process exits naturally
-				// with code 130.
-				process.exitCode = 130;
-			} else if (last) {
-				console.warn(`[background-runner] Ignoring unknown foreground control request: ${last.type}`);
-			}
-		} catch {
-			/* ignore read/parse errors */
-		}
-	}, interruptGuardInterval);
-	interval.unref();
-	return () => clearInterval(interval);
+	return startRunInterruptGuard({
+		manifest,
+		eventMessage: "Background runner detected foreground interrupt — killing child processes and exiting.",
+		onInterrupt: () => {
+			// FIX: Terminate ALL child-pi processes IMMEDIATELY before exiting.
+			// Previously this was missing, causing orphaned child processes to run forever
+			// after the background-runner exited. terminateActiveChildPiProcesses sends
+			// SIGTERM then SIGKILL (after HARD_KILL_MS=3s) to every active child.
+			const killed = terminateActiveChildPiProcesses();
+			console.log(`[background-runner] interrupt: killed ${killed} child processes`);
+			// Also abort the run signal so executeTeamRun exits quickly via its signal check.
+			abortController.abort();
+			// Call stopParentGuard() explicitly in addition to the finally block in
+			// main() — defense-in-depth ensures the guard is torn down promptly.
+			stopParentGuard();
+			// CORE-7 fix: Do NOT call process.exit() — it skips the finally block in
+			// main() (which runs unregisterWorker + stopParentGuard), leaving a stale
+			// orphan registry entry. Setting exitCode lets the event loop drain and
+			// main()'s finally block run cleanup before the process exits naturally
+			// with code 130.
+			process.exitCode = 130;
+		},
+	});
 }
 
 /**
@@ -421,7 +383,15 @@ function runCleanup(
 let exitDueToRejection = false;
 
 export interface ExecuteBackgroundRunOptions {
-	/** Abort signal — the detached runner passes its controller's signal (SIGINT/SIGTERM/watchdog); the inline test seam passes none. */
+	/**
+	 * Abort signal — the detached runner passes its controller's signal
+	 * (SIGINT/SIGTERM/watchdog); the inline test seam passes none.
+	 *
+	 * FIX-1 guard ownership: passing a signal means the HOST owns interrupt
+	 * consumption (detached main() mounts the process-wide guard). Passing
+	 * NONE makes executeBackgroundRun mount its own run-scoped guard and
+	 * abort THIS run on a foreground-control interrupt (see wrapper doc).
+	 */
 	signal?: AbortSignal;
 	/**
 	 * Set PI_CREW_BACKGROUND_MODE=1 (detached-runner observability marker).
@@ -449,19 +419,65 @@ export interface ExecuteBackgroundRunOptions {
  * first-spawn stall (no second process to come up inside a test deadline)
  * and the orphan-tmpdir leak (the run dies with the test process — nothing
  * detached survives to write state after the test's rmSync).
+ *
+ * FIX-1 (live catch, run team_20261030044630_3935473bc4886682): INTERRUPT
+ * GUARD OWNERSHIP. When the host passes opts.signal (the detached runner
+ * does — it mounts the process-wide guard at :959 and forwards its
+ * controller's signal), the host owns interrupt consumption and this core
+ * mounts NOTHING (no double guard on one run). When NO signal is passed
+ * (inline execution in the owner session process), THIS core owns it: it
+ * mounts a run-scoped guard (startRunInterruptGuard) that acks the request,
+ * appends async.interrupt_detected and aborts the run's own controller — and
+ * NEVER sweeps the process (terminateActiveChildPiProcesses would murder
+ * sibling runs' children in the same process; the abort's own cancellation
+ * ladder SIGTERMs this run's children scoped). The guard is stopped in the
+ * finally — no leaked interval, whatever the outcome.
  */
 export async function executeBackgroundRun(
 	input: { manifest: TeamRunManifest; tasks: TeamTaskState[] },
 	opts: ExecuteBackgroundRunOptions = {},
+): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+	let signal: AbortSignal;
+	let stopRunInterruptGuard: (() => void) | undefined;
+	if (opts.signal) {
+		// Host-provided signal ⇒ host owns the interrupt guard (detached
+		// main() mounts the process-wide variant). Pass through unchanged.
+		signal = opts.signal;
+	} else {
+		// Inline execution ⇒ this core owns interrupt consumption for its run.
+		// Retain the controller so the guard can abort THIS run only.
+		const runController = new AbortController();
+		signal = runController.signal;
+		stopRunInterruptGuard = startRunInterruptGuard({
+			manifest: input.manifest,
+			eventMessage: `Inline background run detected foreground interrupt — aborting run ${input.manifest.runId}.`,
+			onInterrupt: () => {
+				// INLINE SAFETY: run-scoped abort ONLY. No
+				// terminateActiveChildPiProcesses() (kills EVERY child-pi in the
+				// process — sibling runs in the same owner session would be
+				// murdered), no stopParentGuard (host owns it), no exitCode
+				// (this is not the process's decision). The run's cancellation
+				// ladder SIGTERMs this run's children scoped to the controller.
+				runController.abort();
+			},
+		});
+	}
+	try {
+		return await executeBackgroundRunCore(input, opts, signal);
+	} finally {
+		stopRunInterruptGuard?.();
+	}
+}
+
+async function executeBackgroundRunCore(
+	input: { manifest: TeamRunManifest; tasks: TeamTaskState[] },
+	opts: ExecuteBackgroundRunOptions,
+	signal: AbortSignal,
 ): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
 	const log = opts.log ?? ((message: string) => console.log(message));
 	let manifest = input.manifest;
 	let tasks = input.tasks;
 	const cwd = manifest.cwd;
-	// Inline seam passes no signal — a never-aborted dummy is behaviorally
-	// identical ("no cancellation source") for the goal-loop/dwf/team-run
-	// inputs below that require a non-optional AbortSignal.
-	const signal: AbortSignal = opts.signal ?? new AbortController().signal;
 	debugLog(`[background-runner] about to call discoverAgents`);
 	const agents = allAgents(discoverAgents(cwd));
 	debugLog(`[background-runner] discoverAgents done, ${agents.length} agents`);
@@ -641,7 +657,11 @@ export async function executeBackgroundRun(
 						...restoredModelRouting(manifest),
 						reliability: runConfig.reliability,
 						workspaceId: manifest.ownerSessionId ?? manifest.cwd,
-						signal: opts.signal,
+						// FIX-1: pass the RESOLVED run signal (host's, or the inline
+						// guard-owned controller). Was `signal: opts.signal` — the inline
+						// host got NO cancellation source, so a consumed interrupt could
+						// never abort the executing team run.
+						signal,
 						...(manifest.budgetTotal !== undefined ? { budgetTotal: manifest.budgetTotal } : {}),
 						...(manifest.budgetWarning !== undefined ? { budgetWarning: manifest.budgetWarning } : {}),
 						...(manifest.budgetAbort !== undefined ? { budgetAbort: manifest.budgetAbort } : {}),

package/src/runtime/foreground-control.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { getCrewEnv } from "../config/env-vars.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
-import { appendEvent } from "../state/event-log/event-log.ts";
+import { appendEvent, appendEventBuffered } from "../state/event-log/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { sleepSync } from "../utils/sleep.ts";
@@ -204,3 +205,96 @@ export function writeForegroundInterruptRequest(
 		releaseLock();
 	}
 }
+
+// ═══════════════════════════════════════════════════════════════════════════
+// FIX-1 (live catch, run team_20261030044630_3935473bc4886682): the
+// foreground-control interrupt CONSUMER. The guard used to live ONLY inside
+// background-runner's detached main(); runs executed INLINE in the owner
+// session process (executeBackgroundRun core — also the PI_CREW_TEST_ASYNC_INLINE
+// seam) never polled foreground-control.json, so cross-session cancels sat
+// acknowledged:false forever (two requests in that run) while the worker ran
+// ≥75s post-cancel with fresh heartbeats. Colocated with the PRODUCER
+// (writeForegroundInterruptRequest above) so the control-file contract has
+// one home.
+//
+// Polling/ack semantics carried over byte-identically from the previous
+// inline guard in background-runner.ts: existsSync+readFileSync+JSON.Parse
+// per tick, interval PI_CREW_INTERRUPT_GUARD_INTERVAL_MS (default 1000ms),
+// synchronous atomic ack write, once-per-request gate (defense-in-depth when
+// the ack write fails), appendEventBuffered("async.interrupt_detected"),
+// interval.unref().
+//
+// What an interrupt DOES is host-scoped via onInterrupt:
+//  - detached runner (background-runner.startInterruptGuard): process-wide
+//    sweep — terminateActiveChildPiProcesses + stopParentGuard + exitCode 130.
+//  - inline core (executeBackgroundRun with no host signal): abort ONLY this
+//    run's controller. NEVER sweep: the owner session process may host
+//    sibling runs whose child-pi processes would be murdered by a global
+//    terminateActiveChildPiProcesses() call.
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface RunInterruptGuardOptions {
+	manifest: { runId: string; stateRoot: string; eventsPath: string };
+	/**
+	 * Host-scoped interrupt action. Runs ONCE per unacknowledged request,
+	 * after the synchronous ack write. Keep it synchronous: this is a
+	 * setInterval polling callback — it cannot await.
+	 */
+	onInterrupt: () => void;
+	/** Message for the async.interrupt_detected event (hosts describe their own follow-up). */
+	eventMessage?: string;
+}
+
+export function startRunInterruptGuard(opts: RunInterruptGuardOptions): () => void {
+	const controlPath = path.join(opts.manifest.stateRoot, "foreground-control.json");
+	// PERF (2026-08-24, carried over verbatim): default 1000ms. Each tick does
+	// existsSync + readFileSync + JSON.parse for the whole run, and the guard
+	// is best-effort interrupt LATENCY, not a correctness deadline — a late
+	// trigger merely delays the SIGTERM (children are SIGKILLed after
+	// HARD_KILL_MS=3s regardless) and no state machine aborts on a deadline
+	// when the guard fires late. Nothing downstream requires a tighter cadence.
+	const interruptGuardInterval = Number(getCrewEnv("PI_CREW_INTERRUPT_GUARD_INTERVAL_MS")) || 1000;
+	// RT-4 FIX (carried over verbatim): local gate so the interrupt body runs
+	// only once per request. The ack write stops the re-fire; this gate is
+	// defense-in-depth if the ack write fails (e.g. transient fs error).
+	let interruptHandled = false;
+	const interval = setInterval(() => {
+		try {
+			if (!fs.existsSync(controlPath)) return;
+			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as {
+				requests?: Array<{ type: string; acknowledged?: boolean }>;
+			};
+			const last = parsed.requests?.at(-1);
+			if (last?.type === "interrupt" && last?.acknowledged !== true) {
+				if (interruptHandled) return;
+				interruptHandled = true;
+				// RT-4 FIX: write acknowledged:true back SYNCHRONOUSLY so the next
+				// tick does not re-fire. Sync because a polling callback cannot await.
+				try {
+					const reqs = parsed.requests ?? [];
+					if (reqs.length > 0) {
+						reqs[reqs.length - 1].acknowledged = true;
+						atomicWriteFile(controlPath, JSON.stringify(parsed, null, 2));
+					}
+				} catch {
+					/* best-effort ack — interruptHandled gate prevents re-fire */
+				}
+				appendEventBuffered(opts.manifest.eventsPath, {
+					type: "async.interrupt_detected",
+					runId: opts.manifest.runId,
+					message: opts.eventMessage ?? "Background runner detected foreground interrupt — killing child processes and exiting.",
+				}).catch((e) => logInternalError("interrupt-guard.buffered", e, "type=async.interrupt_detected"));
+				opts.onInterrupt();
+				// Cosmetic (verifier-flagged, live catch follow-up): an ALREADY-ACKED
+				// interrupt must not fall through to this branch — it used to warn
+				// "Ignoring unknown ... interrupt" every tick until guard stop.
+			} else if (last && !(last.type === "interrupt" && last.acknowledged === true)) {
+				console.warn(`[background-runner] Ignoring unknown foreground control request: ${last.type}`);
+			}
+		} catch {
+			/* ignore read/parse errors */
+		}
+	}, interruptGuardInterval);
+	interval.unref();
+	return () => clearInterval(interval);
+}

package/src/runtime/heartbeat/heartbeat-watcher.ts

@@ -109,22 +109,43 @@ export class HeartbeatWatcher {
 				activeKeys.add(key);
 				this.lastSeen.set(key, now);
 
-				// Check heartbeat staleness with lastActivityAt fallback
-				let elapsed = heartbeatAgeMs(task.heartbeat, now);
+				// FIX-2 (live catch, run team_20261030044630_3935473bc4886682):
+				// attempt-clamp. handleRetry re-queues tasks WITHOUT resetting
+				// liveness fields, so a retry attempt inherited attempt-1's stale
+				// heartbeat/agentProgress timestamps and this watcher fired
+				// heartbeat_dead 3× for a worker that was ALIVE (fresh heartbeats,
+				// active tool calls). Evidence predating the CURRENT attempt's
+				// task.startedAt is meaningless and must be ignored; startedAt is
+				// reset per attempt at dispatch (child-executor attemptStartedAt),
+				// so it is the authoritative attempt boundary.
+				const startedAtMs = task.startedAt !== undefined ? Date.parse(task.startedAt) : Number.NaN;
+				const attemptStartMs = Number.isFinite(startedAtMs) ? startedAtMs : undefined;
+				const evidenceUsable = (iso: string | undefined): boolean => {
+					if (iso === undefined) return false;
+					const ms = Date.parse(iso);
+					return Number.isFinite(ms) && (attemptStartMs === undefined || ms >= attemptStartMs);
+				};
+				// Check heartbeat staleness with lastActivityAt fallback (evidence
+				// older than startedAt is inadmissible — see clamp above).
+				let elapsed = evidenceUsable(task.heartbeat?.lastSeenAt) ? heartbeatAgeMs(task.heartbeat, now) : Number.POSITIVE_INFINITY;
 				// PR #6 partial: use lastActivityAt as fallback when heartbeat is stale
 				// If heartbeat is stale but lastActivityAt is fresher, use activity age instead.
 				// This prevents false-positive dead detection for live-session tasks during long operations.
-				if (task.agentProgress?.lastActivityAt) {
-					const activityAt = new Date(task.agentProgress.lastActivityAt).getTime();
-					if (Number.isFinite(activityAt)) {
-						const activityAge = now - activityAt;
-						// Use activity age if it's fresher than heartbeat age
-						// (no upper bound - if agent has recent activity, trust it even if old)
-						if (activityAge < elapsed) {
-							elapsed = activityAge;
-						}
+				if (evidenceUsable(task.agentProgress?.lastActivityAt)) {
+					const activityAge = now - new Date(task.agentProgress!.lastActivityAt!).getTime();
+					// Use activity age if it's fresher than heartbeat age
+					// (no upper bound - if agent has recent activity, trust it even if old)
+					if (activityAge < elapsed) {
+						elapsed = activityAge;
 					}
 				}
+				// No usable liveness evidence at all → compute elapsed from the
+				// attempt's own start: a task younger than deadMs can never be dead
+				// (previously a missing heartbeat meant elapsed=∞ → instant "dead").
+				// Tasks without startedAt keep the legacy ∞ (unclassifiable).
+				if (!Number.isFinite(elapsed) && attemptStartMs !== undefined) {
+					elapsed = Math.max(0, now - attemptStartMs);
+				}
 				// PID liveness gate: if the worker process is still alive, downgrade
 				// "dead" to "stale". This prevents false positives when the LLM spends
 				// a long time generating a response (>5 min) without tool calls.

package/src/runtime/task-runner/child-executor.ts

@@ -639,6 +639,13 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	let lastRunProgressPersistedAt = 0;
 	let lastTaskProgressPersistedAt = 0;
 	let lastRunProgressSummary: ProgressEventSummary | undefined;
+	// FIX-2 (live catch, run team_20261030044630): the current attempt's worker
+	// pid, pinned by onSpawn below (hoisted to task scope so the
+	// persistHeartbeat closure can pin it into task.heartbeat — see the touch
+	// below). Reset to undefined at the TOP of each model-fallback attempt:
+	// each iteration spawns a fresh worker process, and a dead prior-attempt
+	// pid must never masquerade as this attempt's liveness evidence.
+	let attemptWorkerPid: number | undefined;
 	const persistHeartbeat = (force = false): void => {
 		const now = Date.now();
 		// Skip disk write if throttled (unless forced).
@@ -657,9 +664,21 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			throw err;
 		}
 		// Now update in-memory heartbeat so it is always >= persisted state.
+		// FIX-2: pin the current attempt's worker pid so the heartbeat-watcher
+		// PID-liveness gate (heartbeat?.pid ?? checkpoint?.childPid — it
+		// downgrades dead→stale when the worker process is ALIVE) actually has
+		// something to read for child-process tasks. In the live run every
+		// task.heartbeat had pid:undefined, so a >5min-silent-but-alive worker
+		// could not be vindicated. Guarded: only overwrite when a pid is known —
+		// an unconditional spread would stamp pid:undefined over an
+		// already-pinned pid (call shapes pinned in
+		// child-executor-heartbeat-pid.test.ts).
 		task = {
 			...task,
-			heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id)),
+			heartbeat: touchWorkerHeartbeat(
+				task.heartbeat ?? createWorkerHeartbeat(task.id, attemptWorkerPid),
+				attemptWorkerPid !== undefined ? { pid: attemptWorkerPid } : {},
+			),
 		};
 		lastHeartbeatPersistedAt = now;
 	};
@@ -795,7 +814,9 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		//   evidence of an in-flight incarnation; touch (fail-open, bounded:
 		//   real spawns pin the pid within ms, and the reconciler's ESRCH
 		//   verdict can never be overridden by a fresh heartbeat).
-		let attemptWorkerPid: number | undefined;
+		// FIX-2: no `let` here — attemptWorkerPid is hoisted to task scope
+		// (persistHeartbeat pins it into task.heartbeat); reset per attempt.
+		attemptWorkerPid = undefined;
 		const heartbeatPulse = startWorkerHeartbeatPulse({
 			intervalMs: resolveHeartbeatPulseIntervalMs(),
 			isAlive: () => {

package/src/runtime/task-runner/live-executor.ts

@@ -207,6 +207,9 @@ export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskO
 		if (!isCurrent()) return;
 		const now = Date.now();
 		if (!force && now - lastHeartbeatPersistedAt < 1000) return;
+		// FIX-2 note: no pid at write time — live-session workers run IN this
+		// process (no child pid exists); the watcher PID-gate stays unarmed for
+		// live-session tasks (their activity stream is the liveness evidence).
 		task = {
 			...task,
 			heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id)),

package/src/runtime/task-runner/post-execution.ts

@@ -386,6 +386,9 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 			exitCode: null,
 			error: undefined,
 			claim: undefined,
+			// FIX-2 note: no pid at write time — this terminal touch only marks
+			// alive:false on the EXISTING heartbeat (worker already exited); a
+			// live pid is pinned at spawn by child-executor's persistHeartbeat.
 			heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), { alive: false }),
 			terminalEvidence: terminalEvidence.length ? [...(task.terminalEvidence ?? []), ...terminalEvidence] : task.terminalEvidence,
 			diagnostics: {
@@ -880,6 +883,8 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 		...(specGate ? { specGate } : {}),
 		resultArtifact,
 		claim: undefined,
+		// FIX-2 note: no pid at write time — terminal touch, worker already
+		// exited; the live pid was pinned at spawn (child-executor).
 		heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), { alive: false }),
 		terminalEvidence: terminalEvidence.length ? [...(task.terminalEvidence ?? []), ...terminalEvidence] : task.terminalEvidence,
 		...(logArtifact ? { logArtifact } : {}),