pi-crew 0.9.55 → 0.9.57

package/src/runtime/background-runner.ts

@@ -3,9 +3,9 @@ import * as path from "node:path";
 import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { loadConfig } from "../config/config.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { withRunLockSync } from "../state/locks.ts";
-import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/state-store.ts";
+import { withRunLockSync } from "../state/coordination/locks.ts";
+import { appendEvent, appendEventFireAndForget } from "../state/event-log/event-log.ts";
+import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { errorMessage } from "../utils/guards.ts";
@@ -35,7 +35,7 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 		// FIX (split-scope install): prime the ESM peer dep BEFORE team-runner is
 		// imported, so its transitive skill-instructions.ts can read getAgentDir()
 		// from the primed cache instead of crashing on `Cannot find module`.
-		await primePeerDep().catch(() => {});
+		await primePeerDep().catch(() => undefined);
 		// LAZY: avoid pulling team-runner into background-runner at module load time.
 		const mod = await import("./team-runner.ts");
 		_cachedExecuteTeamRun = mod.executeTeamRun;
@@ -45,12 +45,12 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 
 import { logInternalError } from "../utils/internal-error.ts";
 import { writeAsyncStartMarker } from "./async-marker.ts";
-import { terminateActiveChildPiProcesses } from "./child-pi.ts";
+import { terminateActiveChildPiProcesses } from "./child-pi/child-pi.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
+import { resolveCrewRuntime, runtimeResolutionState } from "./model/runtime-resolver.ts";
 import { unregisterWorker } from "./orphan-worker-registry.ts";
-import { expandParallelResearchWorkflow } from "./parallel-research.ts";
 import { startParentGuard, stopParentGuard } from "./parent-guard.ts";
-import { resolveCrewRuntime, runtimeResolutionState } from "./runtime-resolver.ts";
+import { expandParallelResearchWorkflow } from "./scheduling/parallel-research.ts";
 
 /**
  * Debug logger gated behind PI_CREW_DEBUG env var. Writes to background.log
@@ -110,7 +110,47 @@ function argValue(name: string): string | undefined {
 	return process.argv[index + 1];
 }
 
-function startInterruptGuard(
+/**
+ * Fire-and-forget event log for signal handlers. Extracted to module level
+ * (from inside main()) so the exported SIGINT handler installer (test seam)
+ * and the inline signal-handler loop inside main() can both use it.
+ * Pure function of its arguments — no closure captures from main().
+ */
+function signalLog(sig: string, eventsPath: string): void {
+	const runId = argValue("--run-id");
+	if (runId && eventsPath) {
+		appendEventFireAndForget(eventsPath, {
+			type: "async.failed",
+			runId,
+			message: `Background runner received ${sig} — exiting.`,
+			data: { signal: sig, pid: process.pid },
+		});
+	}
+}
+
+/**
+ * RT-2 SIGINT handler installer — exported as a test seam so integration tests
+ * can exercise the REAL handler logic (process.exitCode = 130, NOT
+ * process.exit(130)) without re-implementing it in a harness copy.
+ *
+ * Behavior is IDENTICAL to the previous inline handler in main() — pure
+ * extraction, zero logic change.
+ */
+export function installBackgroundRunnerSigintHandler(abortController: AbortController, eventsPath: string): void {
+	process.on("SIGINT", () => {
+		signalLog("SIGINT", eventsPath);
+		// RT-2 FIX: Mirror the CORE-7 pattern at the interrupt guard (:146-151).
+		// Do NOT call process.exit(130) — it bypasses the finally/runCleanup block
+		// in main(), orphaning child-pi workers (they have no parent-guard, see
+		// RT-19). Setting exitCode lets the event loop drain naturally so main()'s
+		// finally block runs terminateActiveChildPiProcesses + unregisterWorker.
+		abortController.abort();
+		stopParentGuard();
+		process.exitCode = 130;
+	});
+}
+
+export function startInterruptGuard(
 	manifest: { runId: string; stateRoot: string; eventsPath: string },
 	abortController: AbortController,
 	stopParentGuard: () => void,
@@ -119,6 +159,13 @@ function startInterruptGuard(
 	// FIX: Made configurable via PI_CREW_INTERRUPT_GUARD_INTERVAL_MS env var.
 	// Default 250ms balances fast SIGINT response against filesystem overhead.
 	const interruptGuardInterval = Number(process.env.PI_CREW_INTERRUPT_GUARD_INTERVAL_MS) || 250;
+	// RT-4 FIX: Module-local gate so the interrupt body runs only once per
+	// interrupt request. Without this, the guard re-fires every
+	// interruptGuardInterval (250ms) — each tick does a full
+	// terminateActiveChildPiProcesses sweep + sync appendEvent = ~4×/s steady
+	// state. 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;
@@ -127,6 +174,25 @@ function startInterruptGuard(
 			};
 			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
+				// (250ms). 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 */
+				}
+
 				appendEvent(manifest.eventsPath, {
 					type: "async.interrupt_detected",
 					runId: manifest.runId,
@@ -335,19 +401,8 @@ async function main(): Promise<void> {
 
 	// Scrub macOS malloc vars BEFORE anything else — must be clean for all child processes
 	scrubProcessEnv();
-	// Install signal handlers EARLY — log events before exiting so we can distinguish
-	// OOM/SIGKILL (no event) from SIGTERM/SIGINT (event written).
-	const signalLog = (sig: string, eventsPath: string): void => {
-		const runId = argValue("--run-id");
-		if (runId && eventsPath) {
-			appendEvent(eventsPath, {
-				type: "async.failed",
-				runId,
-				message: `Background runner received ${sig} — exiting.`,
-				data: { signal: sig, pid: process.pid },
-			});
-		}
-	};
+	// signalLog is now defined at module level (shared by the exported SIGINT
+	// handler installer and the inline signal-handler loop below).
 	// BUG #17 FIX: Compute exitCodePath at module load time using args,
 	// NOT by referencing `manifest` (declared inside main() and not in scope at module load).
 	const exitCodePath = ((): string | undefined => {
@@ -422,10 +477,7 @@ async function main(): Promise<void> {
 		// Trigger graceful shutdown via abort signal so finally block runs
 		abortController.abort();
 	});
-	process.on("SIGINT", () => {
-		signalLog("SIGINT", manifest.eventsPath);
-		process.exit(130);
-	});
+	installBackgroundRunnerSigintHandler(abortController, manifest.eventsPath);
 	// BUG #17: Catch ALL signals to identify what kills the background runner
 	for (const sig of [
 		"SIGHUP",
@@ -527,7 +579,7 @@ async function main(): Promise<void> {
 	// compilation of team-runner.ts, the event loop must not drain prematurely.
 	// The interval is always cleared in the finally block, so the delay is
 	// bounded by the 5s interval. The event loop exit is deferred at most 5s.
-	const keepAlive = setInterval(() => {}, 5000);
+	const keepAlive = setInterval(() => undefined, 5000);
 
 	// WATCHDOG (anti-zombie): if the run exceeds MAX_BACKGROUND_RUN_MS without
 	// completing, abort it and force-exit. Without this, a hung team run
@@ -598,9 +650,9 @@ async function main(): Promise<void> {
 			debugLog(`[background-runner] short-circuiting ${manifest.runKind} (synthetic team/workflow)`);
 			if (manifest.runKind === "goal-loop") {
 				// LAZY: defer dynamic import of ./goal-loop-runner.ts to its call site.
-				const { runGoalLoop } = await import("./goal-loop-runner.ts");
+				const { runGoalLoop } = await import("./goal-workflow/goal-loop-runner.ts");
 				// LAZY: defer dynamic import of ./goal-state-store.ts to its call site.
-				const { GoalStore } = await import("./goal-state-store.ts");
+				const { GoalStore } = await import("./goal-workflow/goal-state-store.ts");
 				// LAZY: defer dynamic import of ../agents/discover-agents.ts to its call site.
 				const { discoverAgents, allAgents } = await import("../agents/discover-agents.ts");
 				const store = new GoalStore(manifest.cwd);
@@ -639,7 +691,7 @@ async function main(): Promise<void> {
 				};
 			} else {
 				// LAZY: defer dynamic import of ./dynamic-workflow-runner.ts to its call site.
-				const { runDynamicWorkflow } = await import("./dynamic-workflow-runner.ts");
+				const { runDynamicWorkflow } = await import("./goal-workflow/dynamic-workflow-runner.ts");
 				// LAZY: defer dynamic import of ../workflows/discover-workflows.ts to its call site.
 				const { allWorkflows, discoverWorkflows } = await import("../workflows/discover-workflows.ts");
 				const wf = allWorkflows(discoverWorkflows(manifest.cwd)).find((w) => w.name === manifest.workflow);
@@ -774,7 +826,7 @@ async function main(): Promise<void> {
 			const manifestToUse = loaded?.manifest ?? manifest;
 			if (manifestToUse) {
 				// LAZY: live-agent-manager only needed on failure cleanup path; avoid module load at hot path.
-				const { terminateLiveAgentsForRun } = await import("./live-agent-manager.ts");
+				const { terminateLiveAgentsForRun } = await import("./live-session/live-agent-manager.ts");
 				void terminateLiveAgentsForRun(manifestToUse.runId, "failed", appendEvent, manifestToUse.eventsPath).catch((error) =>
 					logInternalError("background-runner.terminate", error, `runId=${manifestToUse.runId}`),
 				);
@@ -832,6 +884,27 @@ try {
 	// called process.exit(1) directly, bypassing the finally block and leaving
 	// orphaned child processes.
 	exitDueToRejection = true;
+	// RT-3 FIX: Startup failures (lock-fail, missing manifest, pre-try throws)
+	// previously wrote NO event and left exitCode at 0. The run stayed 'queued'
+	// until the stale reconciler reaped it. Now write async.failed so the
+	// notifier/foreground detects the failure immediately, and set exitCode=1
+	// so the process exits non-zero.
+	try {
+		const mCwd = argValue("--cwd");
+		const mRunId = argValue("--run-id");
+		if (mCwd && mRunId) {
+			const mEventsPath = createRunPaths(mCwd, mRunId).eventsPath;
+			appendEvent(mEventsPath, {
+				type: "async.failed",
+				runId: mRunId,
+				message: errorMessage(err),
+				data: { stack: err instanceof Error ? err.stack : undefined },
+			});
+		}
+	} catch {
+		/* best-effort — don't let event-write failure mask the original error */
+	}
+	process.exitCode = 1;
 	// FIX: Call stopParentGuard directly here as a safety net in case the
 	// finally block (which calls runCleanup→stopParentGuard) does not complete.
 	// This ensures the parent guard is stopped in ALL exit paths: normal

package/src/runtime/{crew-broker-child.ts → broker/crew-broker-child.ts}

@@ -41,7 +41,7 @@ export interface StartChildBrokerClientOptions {
 
 const NOOP_HANDLE: ChildBrokerClientHandle = {
 	active: false,
-	close: async () => {},
+	close: async () => undefined,
 };
 
 export function startChildBrokerClient(options: StartChildBrokerClientOptions = {}): ChildBrokerClientHandle {
@@ -75,7 +75,7 @@ export function startChildBrokerClient(options: StartChildBrokerClientOptions =
 	// Establish the persistent connection so the broker can push events. This
 	// is fire-and-forget: on any failure the client becomes sticky-fallback and
 	// the file-poll steering path remains fully functional.
-	void client.reconnect().catch(() => {});
+	void client.reconnect().catch(() => undefined);
 
 	return {
 		get active() {

package/src/runtime/{crew-broker-client.ts → broker/crew-broker-client.ts}

@@ -24,9 +24,9 @@
 import { randomUUID } from "node:crypto";
 import * as net from "node:net";
 
-import { logInternalError } from "../utils/internal-error.ts";
-import { BrokerError, encodeBrokerFrame, NdjsonDecoder } from "../utils/ndjson.ts";
-import { redactSecretString } from "../utils/redaction.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { BrokerError, encodeBrokerFrame, NdjsonDecoder } from "../../utils/ndjson.ts";
+import { redactSecretString } from "../../utils/redaction.ts";
 
 /** Shape of an unsolicited event frame pushed by the broker (mailbox.message,
  *  team.event, etc.). */
@@ -95,7 +95,6 @@ export class CrewBrokerClient {
 	private socket: net.Socket | null = null;
 	private decoder: NdjsonDecoder | null = null;
 	private readonly pending = new Map<string, PendingRequest>();
-	private attempts = 0;
 	/** Listeners attached to the current socket; kept for explicit close(). */
 	private readonly socketListeners: Array<{
 		event: string;
@@ -234,7 +233,6 @@ export class CrewBrokerClient {
 	async reconnect(): Promise<boolean> {
 		// Close the current socket if any.
 		this.teardownSocket();
-		this.attempts = 0;
 		this._mode = "unstarted";
 		const res = await this.request("ping", null);
 		return res.ok;
@@ -309,7 +307,6 @@ export class CrewBrokerClient {
 			if (this.closed) {
 				return { ok: false, fallback: true, errorCode: "closed" };
 			}
-			this.attempts = attempt + 1;
 			const result = await this.attemptHello(netModule);
 			if (result.ok) {
 				// Belt-and-suspenders: a successful hello can still race
@@ -460,7 +457,7 @@ export class CrewBrokerClient {
 						return;
 					}
 					// Hello ack: must include `result.ok === true` and matching id.
-					if (frame.id && frame.id.startsWith("hello-")) {
+					if (frame.id?.startsWith("hello-")) {
 						if (frame.error) {
 							const code = (frame.error as { code?: string }).code ?? "auth";
 							finish({ ok: false, fallback: true, errorCode: code });

package/src/runtime/{crew-broker.ts → broker/crew-broker.ts}

@@ -23,8 +23,6 @@
 
 import * as fsp from "node:fs/promises";
 import * as net from "node:net";
-
-import { readEventsCursor } from "../state/event-log.ts";
 import {
 	appendMailboxMessageAsync,
 	type MailboxMessage,
@@ -32,14 +30,15 @@ import {
 	type MailboxMessagePriority,
 	readMailbox,
 	registerMailboxAppendObserver,
-} from "../state/mailbox.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
-import { runEventBus } from "../ui/run-event-bus.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { BrokerError, encodeBrokerFrame, MAX_BROKER_FRAME_BYTES, NdjsonDecoder } from "../utils/ndjson.ts";
-import { redactSecretString } from "../utils/redaction.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { getBrokerSocketPath, prepareBrokerSocketDir, removeStaleBrokerSocket } from "../utils/socket-path.ts";
+} from "../../state/coordination/mailbox.ts";
+import { readEventsCursor } from "../../state/event-log/event-log.ts";
+import { loadRunManifestById } from "../../state/stores/state-store.ts";
+import { runEventBus } from "../../ui/run-event-bus.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { BrokerError, encodeBrokerFrame, MAX_BROKER_FRAME_BYTES, NdjsonDecoder } from "../../utils/ndjson.ts";
+import { redactSecretString } from "../../utils/redaction.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import { getBrokerSocketPath, prepareBrokerSocketDir, removeStaleBrokerSocket } from "../../utils/socket-path.ts";
 import { BrokerTokenRegistry } from "./crew-broker-tokens.ts";
 
 /** Protocol version negotiated at `hello` time. Bump on breaking change. */
@@ -103,7 +102,6 @@ export class CrewBroker {
 	private server: net.Server | null = null;
 	private resolvedSocketPath: string | null = null;
 	private stopped = false;
-	private starting = false;
 	private startingPromise: Promise<void> | null = null;
 	private readonly connections = new Set<ServerConnection>();
 	/** Connections indexed by runId for live message fanout (Phase 1.3). */
@@ -186,16 +184,10 @@ export class CrewBroker {
 		}
 		if (this.server) return Promise.resolve();
 		if (this.startingPromise) return this.startingPromise;
-		this.starting = true;
-		this.startingPromise = this.doStart()
-			.then(() => {
-				this.starting = false;
-			})
-			.catch((err) => {
-				this.starting = false;
-				this.startingPromise = null;
-				throw err;
-			});
+		this.startingPromise = this.doStart().catch((err) => {
+			this.startingPromise = null;
+			throw err;
+		});
 		return this.startingPromise;
 	}
 

package/src/runtime/chain-runner.ts

@@ -6,8 +6,6 @@
  * - Supports per-step overrides for model, skill, thinking
  * - Accumulates handoffs between steps
  * - Executes steps sequentially with context passing
- *
- * @see docs/pi-boomerang-integration-plan.md
  */
 
 import { errorMessage } from "../utils/guards.ts";
@@ -148,7 +146,7 @@ export class ChainRunner {
 			}
 		}
 
-		const stepStrings = chainString.split("->").map((s) => s.trim());
+		const stepStrings = this.splitChainSteps(chainString).map((s) => s.trim());
 
 		const steps: ChainStep[] = stepStrings.map((step, index) => {
 			return this.parseStep(step, index);
@@ -236,8 +234,8 @@ export class ChainRunner {
 
 				// Emit progress event if eventsPath provided
 				if (eventsPath) {
-					// LAZY: defer dynamic import of ../state/event-log.ts to its call site.
-					const { appendEventAsync } = await import("../state/event-log.ts");
+					// LAZY: defer dynamic import of ../state/event-log/event-log.ts to its call site.
+					const { appendEventAsync } = await import("../state/event-log/event-log.ts");
 					await appendEventAsync(eventsPath, {
 						type: "chain.step_completed",
 						runId: "chain",
@@ -277,6 +275,53 @@ export class ChainRunner {
 		};
 	}
 
+	/**
+	 * Split a chain string on top-level `->` arrows, ignoring arrows inside
+	 * quotes.  Prevents inline goals containing `->` (e.g. "Change A -> B")
+	 * from being incorrectly split into separate steps.
+	 */
+	private splitChainSteps(chainString: string): string[] {
+		const parts: string[] = [];
+		let current = "";
+		let inQuote = false;
+		let quoteChar = "";
+
+		for (let i = 0; i < chainString.length; i++) {
+			const ch = chainString[i]!;
+
+			// Handle escape sequences inside quotes (e.g. \" or \')
+			if (inQuote && ch === "\\" && i + 1 < chainString.length) {
+				current += ch + (chainString[i + 1] ?? "");
+				i++;
+				continue;
+			}
+
+			// Toggle quote state on unescaped quote characters
+			if (ch === '"' || ch === "'") {
+				if (!inQuote) {
+					inQuote = true;
+					quoteChar = ch;
+				} else if (ch === quoteChar) {
+					inQuote = false;
+				}
+				current += ch;
+				continue;
+			}
+
+			// Split on -> only when not inside quotes
+			if (!inQuote && ch === "-" && chainString[i + 1] === ">") {
+				parts.push(current);
+				current = "";
+				i++; // skip the '>'
+				continue;
+			}
+
+			current += ch;
+		}
+		parts.push(current);
+		return parts;
+	}
+
 	/**
 	 * Parse a single step from the chain string.
 	 * Includes type safety checks for ChainStep parsing (H3).

package/src/runtime/{child-pi-constants.ts → child-pi/child-pi-constants.ts}

@@ -8,7 +8,7 @@
  * and makes the timing budget configurable from one place.
  */
 
-import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
+import { DEFAULT_CHILD_PI } from "../../config/defaults.ts";
 
 /** Post-exit window during which stdio is guarded against late writes. */
 export const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;

package/src/runtime/{child-pi-kill.ts → child-pi/child-pi-kill.ts}

@@ -17,10 +17,10 @@
 
 import type { ChildProcess } from "node:child_process";
 import { spawn } from "node:child_process";
-import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
-import { logInternalError } from "../utils/internal-error.ts";
+import { DEFAULT_CHILD_PI } from "../../config/defaults.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { TailCaptureStage } from "../compaction/compact-stages/tail-capture-stage.ts";
 import { HARD_KILL_MS } from "./child-pi-constants.ts";
-import { TailCaptureStage } from "./compact-stages/tail-capture-stage.ts";
 
 const MAX_CAPTURE_BYTES = DEFAULT_CHILD_PI.maxCaptureBytes;
 

package/src/runtime/{child-pi-spawn.ts → child-pi/child-pi-spawn.ts}

@@ -19,12 +19,12 @@
 import type { SpawnOptions } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
-import { buildScopedAllowList, sanitizeEnvSecrets } from "../utils/env-filter.ts";
-import { logInternalError } from "../utils/internal-error.ts";
+import { WINDOWS_ESSENTIAL_ENV_VARS } from "../../utils/env-allowlist.ts";
+import { buildScopedAllowList, sanitizeEnvSecrets } from "../../utils/env-filter.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { buildPiWorkerArgs } from "../model/pi-args.ts";
+import { getPiSpawnCommand } from "../pi-spawn.ts";
 import type { ChildPiRunInput, ChildPiRunResult } from "./child-pi.ts";
-import { buildPiWorkerArgs } from "./pi-args.ts";
-import { getPiSpawnCommand } from "./pi-spawn.ts";
 
 // ── Env allowlist (base set always passed to children) ──────────────────
 // Provider API keys are injected dynamically via buildScopedAllowList() only
@@ -68,7 +68,8 @@ export const BASE_ALLOWLIST: string[] = [
  *   1. Validate cwd (realpath + isDirectory) — fall back to lexical path on ENOENT.
  *   2. Filter env vars to the allowlist (model-aware provider key scoping).
  *   3. Validate NODE_PATH against safe prefixes (/opt, /lib, /usr, /home).
- *   4. Add PI_CREW_PARENT_PID for the child-side parent-guard.
+ *   4. Add PI_CREW_PARENT_PID for the child-side parent-guard (currently UNUSED —
+ *      see note at the PI_CREW_PARENT_PID assignment below).
  */
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv, model?: string): SpawnOptions {
 	// SECURITY FIX (Issue #1): Validate cwd before passing to spawn.
@@ -131,17 +132,32 @@ export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv, mo
 
 	return {
 		cwd: validatedCwd,
-		env: { ...filteredEnv, PI_CREW_PARENT_PID: String(process.pid) },
+		env: {
+			...filteredEnv,
+			// PI_CREW_PARENT_PID is set so that child pi workers could theoretically
+			// run a parent-guard (parent-guard.ts). However, as of RT-19/RT-2, this
+			// env var has ZERO consumers: child workers are the external `pi` binary
+			// (@earendil-works/pi-coding-agent) which does NOT read
+			// PI_CREW_PARENT_PID or call startParentGuard (grep of Pi dist = 0 matches).
+			// The deeper fix (wiring startParentGuard into the pi worker entry point)
+			// is DEFERRED because workers are an external binary pi-crew doesn't control.
+			//
+			// Orphan-mitigation for this gap relies on:
+			//   1. The RT-2 SIGINT fix in background-runner.ts (abort + exitCode pattern
+			//      lets the finally/runCleanup block terminate child-pi processes).
+			//   2. The reactive zombie-scanner.ts sweep (finds workers whose
+			//      PI_CREW_PARENT_PID points at a dead PID).
+			PI_CREW_PARENT_PID: String(process.pid),
+		},
 		stdio: ["ignore", "pipe", "pipe"], // stdin=ignore: child doesn't wait for input; task comes via CLI args
 		detached: process.platform !== "win32",
 		setsid: true,
 		// NOTE: setsid creates a new session; the child process becomes the session leader
 		// and its parent becomes that session leader (still the team-runner in the same
-		// process group). PI_CREW_PARENT_PID is set before spawn using process.pid (team-runner).
-		// The parent-guard in the child checks direct parent liveness via process.kill(pid, 0) —
-		// it does NOT follow the lineage beyond the direct parent. If the team-runner's parent
-		// (the original pi session) dies, the team-runner becomes an orphan but the child still
-		// sees its direct parent (team-runner) as alive. This is correct for the parent-guard model.
+		// process group). PI_CREW_PARENT_PID is set before spawn using process.pid (team-runner),
+		// but see the comment above — child pi workers do NOT actually consume it. The
+		// parent-guard model would check direct parent liveness via process.kill(pid, 0),
+		// but this is only implemented in background-runner.ts, not in the worker binary.
 		windowsHide: true,
 	} as SpawnOptions;
 }

package/src/runtime/{child-pi-steering.ts → child-pi/child-pi-steering.ts}

@@ -13,7 +13,7 @@
  */
 
 import * as fs from "node:fs";
-import { logInternalError } from "../utils/internal-error.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
 import { killProcessTree } from "./child-pi-kill.ts";
 
 /** Action emitted by the controller when a `turn_end` event is processed. */

package/src/runtime/{child-pi-streams.ts → child-pi/child-pi-streams.ts}

@@ -8,11 +8,11 @@
  * child-pi-constants.ts (MAX_*_CHARS, MAX_LINE_BUFFER_BYTES).
  */
 
-import { logInternalError } from "../utils/internal-error.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { extractText } from "../output/pi-json-output.ts";
 import type { ChildPiRunInput } from "./child-pi.ts";
 import { MAX_ASSISTANT_TEXT_CHARS, MAX_LINE_BUFFER_BYTES, MAX_TOOL_INPUT_CHARS, MAX_TOOL_RESULT_CHARS } from "./child-pi-constants.ts";
 import { appendTranscript, compactString, compactValue, flushPendingTranscriptWrites } from "./child-pi-transcript.ts";
-import { extractText } from "./pi-json-output.ts";
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
@@ -87,6 +87,18 @@ function compactChildPiEvent(event: unknown): unknown | undefined {
 			stopReason: record.stopReason,
 		};
 	}
+	// P2-25: pass supervisor_contact events through with their full payload. The
+	// generic fallthrough below strips everything but `type`, which made the
+	// feature dead — the contact never reached recordSupervisorContact.
+	if (record.type === "supervisor_contact" || record.type === "crew_supervisor_contact") {
+		return {
+			type: record.type,
+			taskId: record.taskId,
+			reason: record.reason,
+			message: record.message,
+			data: record.data,
+		};
+	}
 	return record.type ? { type: record.type } : undefined;
 }
 
@@ -187,9 +199,16 @@ export class ChildPiLineObserver {
 				new Error(`Line buffer exceeded ${MAX_LINE_BUFFER_BYTES} bytes; force-flushing`),
 				`bufferLen=${this.buffer.length}`,
 			);
-			const line = this.buffer;
+			// RT-9: split on newlines first so each complete \n-delimited JSON event
+			// is emitted as its own line. Previously the ENTIRE buffer was flushed
+			// as one "line", merging all events → JSON.parse failure → usage/turn/
+			// transcript events lost. Now only the trailing partial (no terminating
+			// newline) is force-flushed; complete lines keep per-line identity. When
+			// there are no newlines at all (the original RT-F8 single-huge-line case)
+			// split yields a single element and behavior is unchanged.
+			const overflowLines = this.buffer.split(/\r?\n/);
 			this.buffer = "";
-			this.emitLine(line);
+			for (const line of overflowLines) this.emitLine(line);
 			return;
 		}
 		const lines = this.buffer.split(/\r?\n/);

package/src/runtime/{child-pi-transcript.ts → child-pi/child-pi-transcript.ts}

@@ -19,13 +19,13 @@
  */
 
 import * as fs from "node:fs";
-import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactJsonLine } from "../utils/redaction.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { DEFAULT_CHILD_PI } from "../../config/defaults.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { redactJsonLine } from "../../utils/redaction.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import { applyCompactPipeline } from "../compaction/compact-pipeline.ts";
+import { TruncationStage } from "../compaction/compact-stages/truncation-stage.ts";
 import type { ChildPiRunInput } from "./child-pi.ts";
-import { applyCompactPipeline } from "./compact-pipeline.ts";
-import { TruncationStage } from "./compact-stages/truncation-stage.ts";
 
 // ── Transcript batch buffer (OPT-PHASE3) ────────────────────────────────
 // Instead of open/write/close per line (3 syscalls × N), accumulate lines