pi-crew 0.9.56 → 0.9.57

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;
@@ -199,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

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

@@ -2,21 +2,21 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
-import { registerChildProcess, unregisterChildProcess } from "../extension/crew-cleanup.ts";
-import { atomicWriteFile } from "../state/atomic-write.ts";
-import type { WorkerExitStatus } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactSecretString } from "../utils/redaction.ts";
-import { getActiveBrokerIssuer } from "./broker-issuer.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { DEFAULT_CHILD_PI } from "../../config/defaults.ts";
+import { registerChildProcess, unregisterChildProcess } from "../../extension/crew-cleanup.ts";
+import { atomicWriteFile } from "../../state/atomic-write.ts";
+import type { WorkerExitStatus } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { redactSecretString } from "../../utils/redaction.ts";
+import { getActiveBrokerIssuer } from "../broker/broker-issuer.ts";
+import { BoundedTail } from "../compaction/compact-stages/bounded-tail.ts";
 import { FINAL_DRAIN_MS, HARD_KILL_MS, POST_EXIT_STDIO_GUARD_MS, RESPONSE_TIMEOUT_MS } from "./child-pi-constants.ts";
 import { clearHardKillTimer, killProcessTree, registerActiveChild, unregisterActiveChild } from "./child-pi-kill.ts";
 import { buildFinalChildPiSpawnOptions, prepareSpawnContext } from "./child-pi-spawn.ts";
 import { ChildPiSteeringController } from "./child-pi-steering.ts";
 // Internal helpers for active-child bookkeeping (extracted to child-pi-kill.ts).
 import { ChildPiLineObserver } from "./child-pi-streams.ts";
-import { BoundedTail } from "./compact-stages/bounded-tail.ts";
 
 // ── Re-exports from child-pi-kill.ts (H-7 decomposition step 2) ──
 // killProcessTree is internal (not previously exported) — keep that invariant.
@@ -33,10 +33,9 @@ export { buildChildPiSpawnOptions, buildFinalChildPiSpawnOptions } from "./child
 // ── Re-export from child-pi-streams.ts (H-7 decomposition step 4) ──
 export { ChildPiLineObserver } from "./child-pi-streams.ts";
 
-import { classifyProcessCrash } from "./crash-classification.ts";
-import { checkCrewDepth, cleanupTempDir } from "./pi-args.ts";
-
-import { attachPostExitStdioGuard, trySignalChild } from "./post-exit-stdio-guard.ts";
+import { checkCrewDepth, cleanupTempDir } from "../model/pi-args.ts";
+import { attachPostExitStdioGuard, trySignalChild } from "../process/post-exit-stdio-guard.ts";
+import { classifyProcessCrash } from "../recovery/crash-classification.ts";
 
 /** Maximum size (bytes) for the ChildPiLineObserver's line accumulation buffer.
  * When exceeded, the buffer is force-flushed to prevent unbounded memory growth
@@ -421,10 +420,15 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					pid: child.pid,
 					ts: new Date().toISOString(),
 				});
-				// Register with cleanup handler for graceful shutdown
-				if (input.runId && input.agentId) {
-					registerChildProcess(child.pid, input.runId, input.agentId);
-				}
+				// Register with cleanup handler for graceful shutdown (RT-11):
+				// ALWAYS register — every spawned child must be visible to host-SIGTERM
+				// cleanup. Use synthetic IDs when the caller omitted runId/agentId so the
+				// PID is still tracked for killProcessPid on session shutdown.
+				registerChildProcess(
+					child.pid,
+					input.runId ?? `untracked-run-${child.pid}`,
+					input.agentId ?? `untracked-agent-${child.pid}`,
+				);
 			} else {
 				input.onLifecycleEvent?.({
 					type: "spawn_error",
@@ -476,37 +480,6 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			let hardKilled = false;
 			const cleanupErrors: string[] = [];
 			const steeringController = new ChildPiSteeringController(input.maxTurns, input.graceTurns);
-			// Track in-flight operations for proper rejection on unexpected exit
-			interface PendingOperation {
-				id: string;
-				type: "prompt" | "steer" | "json_event";
-				startedAt: number;
-			}
-			const pendingOperations = new Map<string, PendingOperation>();
-			let operationIdCounter = 0;
-
-			const startOperation = (type: PendingOperation["type"]): string => {
-				const id = `op-${++operationIdCounter}`;
-				pendingOperations.set(id, { id, type, startedAt: Date.now() });
-				return id;
-			};
-
-			const completeOperation = (id: string): void => {
-				pendingOperations.delete(id);
-			};
-
-			const rejectPendingOperations = (error: Error): void => {
-				pendingOperations.forEach((op, id) => {
-					logInternalError(
-						"child-pi.pending-operation-rejected",
-						error,
-						`opId=${id} type=${op.type} elapsed=${Date.now() - op.startedAt}ms`,
-					);
-				});
-				pendingOperations.clear();
-			};
-
-			const steerInjectionFailed = false;
 			let abortDueToParentSignal = false;
 			// CP-1: track whether the turn-limit hard-abort has been initiated. Once
 			// true, we must NOT restart the no-response timer — the child is already
@@ -610,21 +583,14 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				},
 				onJsonEvent: (event) => {
 					if (!steeringController.isHardAbortInitiated()) restartNoResponseTimer();
-					const eventOpId = startOperation("json_event");
-					try {
-						// Turn-count-based steering: soft limit steer + hard abort after graceTurns
-						if (event && typeof event === "object" && !Array.isArray(event)) {
-							const obj = event as Record<string, unknown>;
-							if (obj.type === "turn_end") {
-								// H-7 step 5: steering state machine extracted to ChildPiSteeringController.
-								const action = steeringController.onTurnEnd(child.pid, child, input.steeringFile);
-								if (action.kind === "hardAbort") killProcessTree(action.pid, action.child);
-							}
+					// Turn-count-based steering: soft limit steer + hard abort after graceTurns
+					if (event && typeof event === "object" && !Array.isArray(event)) {
+						const obj = event as Record<string, unknown>;
+						if (obj.type === "turn_end") {
+							// H-7 step 5: steering state machine extracted to ChildPiSteeringController.
+							const action = steeringController.onTurnEnd(child.pid, child, input.steeringFile);
+							if (action.kind === "hardAbort") killProcessTree(action.pid, action.child);
 						}
-						completeOperation(eventOpId);
-					} catch (err) {
-						completeOperation(eventOpId);
-						throw err;
 					}
 					// F12: capture monotonic timestamp BEFORE dispatching — any stdout
 					// JSON event counts as activity. This lets the quiet-window
@@ -924,12 +890,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				// P0-1: snapshot the bounded accumulators once for this handler.
 				const stdout = stdoutTail.value();
 				const stderr = stderrTail.value();
-				// Reject pending operations with process error context
 				// SEC-1: redact stderr secrets embedded in the error message + excerpt.
 				const processError = new Error(
 					`Child Pi process error: ${error.message}. Stderr: ${redactStderrExcerpt(stderr, 500) || "(none)"}`,
 				);
-				rejectPendingOperations(processError);
 				try {
 					input.onLifecycleEvent?.({
 						type: "spawn_error",
@@ -985,9 +949,6 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 								`Stderr: ${redactStderrExcerpt(stderr, 1000) || "(none)"}`,
 						)
 					: null;
-				if (exitError) {
-					rejectPendingOperations(exitError);
-				}
 				try {
 					// Phase-0 diagnostic (HB-003a): capture signal + drain timing in the
 					// exit lifecycle event so the exit-null race is diagnosable instead of
@@ -1072,10 +1033,6 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					steeringController.getTurnCount() >=
 						(steeringController.getMaxTurns() ?? 0) + (steeringController.getGraceTurns() ?? 5);
 				const wasParentAborted = abortDueToParentSignal && !wasGraceAborted;
-				// steerInjectionFailed is now always false (Phase-1 fix: steer backpressure
-				// is logged, not fatal). The steerError branch is retained for safety in
-				// case a future change reintroduces a fatal steer path.
-				const steerError = steerInjectionFailed ? "Steer injection failed due to stdin backpressure; process killed" : undefined;
 				// P0 crash taxonomy: classify the exit so callers/dashboards can bucket
 				// failure modes (timeout vs cancel vs native panic vs signal …).
 				// The classifier is a pure function; this is the single integration point.
@@ -1093,7 +1050,6 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					stdout,
 					stderr,
 					...(timeoutError ? { error: timeoutError.error } : {}),
-					...(steerError ? { error: steerError } : {}),
 					aborted: wasGraceAborted || wasParentAborted,
 					steered: steeringController.isSoftLimitReached() && !wasGraceAborted,
 					exitStatus: {

package/src/runtime/{compact-stages → compaction/compact-stages}/bounded-tail.ts

@@ -18,7 +18,7 @@
  * verbatim; over cap → `[pi-crew captured output truncated to last X KiB]\n` + the last
  * ≤maxBytes bytes snapped to a UTF-8 char boundary.
  */
-import { DEFAULT_CHILD_PI } from "../../config/defaults.ts";
+import { DEFAULT_CHILD_PI } from "../../../config/defaults.ts";
 
 const DEFAULT_MAX_BYTES = DEFAULT_CHILD_PI.maxCaptureBytes;
 

package/src/runtime/{compact-stages → compaction/compact-stages}/index.ts

@@ -1,8 +1,8 @@
 /**
  * Barrel re-exports for the compact-stages module.
  *
- * Callers import from `../../runtime/compact-stages/index.ts` (or just
- * `../../runtime/compact-stages/`) rather than reaching into individual
+ * Callers import from `../../runtime/compaction/compact-stages/index.ts` (or just
+ * `../../runtime/compaction/compact-stages/`) rather than reaching into individual
  * stage files, so internal refactors do not break the public surface.
  */
 export { ANSI_STRIP_STAGE, AnsiStripStage } from "./ansi-strip-stage.ts";

package/src/runtime/{compaction-summary.ts → compaction/compaction-summary.ts}

@@ -14,9 +14,9 @@ class GiantLineFallbackError extends Error {
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { readJsonFile } from "../state/atomic-write.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { readJsonFile } from "../../state/atomic-write.ts";
+import type { TeamEvent } from "../../state/event-log/event-log.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 
 /** Maximum number of events to read from the tail of events.jsonl. */
 const MAX_TAIL_EVENTS = 100;

package/src/runtime/{tool-output-pruner.ts → compaction/tool-output-pruner.ts}

@@ -90,7 +90,7 @@ export interface PruneResult {
 // Token estimation (rough char/4 heuristic, matching gajae-code)
 // ---------------------------------------------------------------------------
 
-import { countTokens } from "../utils/token-counter.ts";
+import { countTokens } from "../../utils/token-counter.ts";
 
 function estimateTokens(text: string): number {
 	return countTokens(text);

package/src/runtime/custom-tools/irc-tool.ts

@@ -14,8 +14,8 @@
 
 import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "@sinclair/typebox";
-import { broadcastIrcMessage, listLiveAgents, respondAsBackground, sendIrcMessage } from "../live-agent-manager.ts";
-import type { IrcMessage } from "../live-irc.ts";
+import { broadcastIrcMessage, listLiveAgents, respondAsBackground, sendIrcMessage } from "../live-session/live-agent-manager.ts";
+import type { IrcMessage } from "../live-session/live-irc.ts";
 
 const IrcParams = Type.Object({
 	op: Type.Union(

package/src/runtime/delivery-coordinator.ts

@@ -28,21 +28,18 @@ export class DeliveryCoordinator {
 	private readonly deps: DeliveryCoordinatorDeps;
 	private ttlTimer: ReturnType<typeof setInterval> | undefined;
 	private timerStarted = false;
-	private ownerSessionId: string | undefined = undefined;
 
 	constructor(deps: DeliveryCoordinatorDeps) {
 		this.deps = deps;
 	}
 
 	activate(sessionId: string): void {
-		this.ownerSessionId = sessionId;
 		this.active = true;
 		this.flushQueuedResults();
 	}
 
 	deactivate(): void {
 		this.active = false;
-		this.ownerSessionId = undefined;
 		this.generation += 1;
 	}
 

package/src/runtime/diagnostic-export.ts

@@ -4,15 +4,15 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import type { MetricSnapshot } from "../observability/metrics-primitives.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
+import type { TeamEvent } from "../state/event-log/event-log.ts";
+import { loadRunManifestById } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { type HeartbeatSummary, summarizeHeartbeats } from "../ui/heartbeat-aggregator.ts";
 import type { RunUiSnapshot } from "../ui/snapshot-types.ts";
 import { readJsonlTail } from "../utils/incremental-reader.ts";
 import { isSecretKey, redactSecrets } from "../utils/redaction.ts";
 import { readCrewAgents } from "./crew-agent-records.ts";
-import { buildRecoveryLedger, type RecoveryLedgerEntry } from "./recovery-recipes.ts";
+import { buildRecoveryLedger, type RecoveryLedgerEntry } from "./recovery/recovery-recipes.ts";
 
 export { isSecretKey, redactSecrets } from "../utils/redaction.ts";
 

package/src/runtime/foreground-control.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { atomicWriteFile } from "../state/atomic-write.ts";
-import { appendEvent } from "../state/event-log.ts";
+import { appendEvent } 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";

package/src/runtime/foreground-watchdog.ts

@@ -12,7 +12,7 @@
  * 3. Cleans up after itself when the run completes or the session ends.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { loadRunManifestById } from "../state/stores/state-store.ts";
 import { readCrewAgents } from "./crew-agent-records.ts";
 import { isActiveRunStatus, isLikelyOrphanedActiveRun } from "./process-status.ts";
 

package/src/runtime/{adaptive-plan.ts → goal-workflow/adaptive-plan.ts}

@@ -15,14 +15,14 @@
 // `__test__parseAdaptivePlan` and `__test__repairAdaptivePlan` are re-exported
 // from team-runner.ts so existing test imports keep working.
 import * as fs from "node:fs";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEventAsync, appendEventFireAndForget } from "../state/event-log.ts";
-import { saveRunManifestAsync } from "../state/state-store.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { appendEventAsync, appendEventFireAndForget } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import { saveRunManifestAsync } from "../../state/stores/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { TeamConfig } from "../../teams/team-config.ts";
+import type { WorkflowConfig, WorkflowStep } from "../../workflows/workflow-config.ts";
+import { refreshTaskGraphQueues } from "../scheduling/task-graph-scheduler.ts";
 import { getPlanTemplate, renderPlanTemplate } from "./plan-templates.ts";
-import { refreshTaskGraphQueues } from "./task-graph-scheduler.ts";
 
 export interface AdaptivePlanTask {
 	role: string;
@@ -557,7 +557,7 @@ export async function injectAdaptivePlanIfReady(input: InjectAdaptivePlanInput):
 
 // Test compatibility: original team-runner.ts exposed these names. Keep
 // matching exports here; team-runner.ts re-exports them so existing test
-// imports (`import { __test__parseAdaptivePlan } from "../../src/runtime/team-runner.ts"`)
+// imports (`import { __test__parseAdaptivePlan } from "../../../src/runtime/team-runner.ts"`)
 // keep working without churn.
 export const __test__parseAdaptivePlan = parseAdaptivePlan;
 export const __test__repairAdaptivePlan = repairAdaptivePlan;