pi-crew 0.9.55 → 0.9.57

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

@@ -2,16 +2,17 @@ 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 { appendBoundedTail, clearHardKillTimer, killProcessTree, registerActiveChild, unregisterActiveChild } from "./child-pi-kill.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).
@@ -32,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
@@ -420,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",
@@ -431,8 +436,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					ts: new Date().toISOString(),
 				});
 			}
-			let stdout = "";
-			let stderr = "";
+			// P0-1: O(1)-amortized bounded accumulators (segment ring) — replaces the O(n²)
+			// appendBoundedTail rebuild-per-line pattern that re-scanned 512 KiB every line.
+			const stdoutTail = new BoundedTail();
+			const stderrTail = new BoundedTail();
 			let settled = false;
 			let childExited = false;
 			let postExitGuardCleanup: (() => void) | undefined;
@@ -473,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
@@ -526,6 +502,8 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				if (noResponseTimer) clearTimeout(noResponseTimer);
 				noResponseTimer = setTimeout(() => {
 					responseTimeoutHit = true;
+					// P0-1: snapshot the bounded stderr accumulator once for this timer fire.
+					const stderr = stderrTail.value();
 					// Capture stderr at timeout moment for debugging
 					// SEC-1: redact secrets before embedding in lifecycle event so
 					// worker-emitted secrets (API keys etc.) don't bypass redaction.
@@ -569,8 +547,8 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 							const timeoutErr = `Child Pi produced no new output for ${responseTimeoutMs}ms; killed but did not exit within ${SAFETY_SETTLE_MS}ms (possible zombie).`;
 							void settle({
 								exitCode: null,
-								stdout,
-								stderr,
+								stdout: stdoutTail.value(),
+								stderr: stderrTail.value(),
 								error: timeoutErr,
 								exitStatus: {
 									exitCode: null,
@@ -600,26 +578,19 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				...input,
 				onStdoutLine: (line) => {
 					if (!steeringController.isHardAbortInitiated()) restartNoResponseTimer();
-					stdout = appendBoundedTail(stdout, `${line}\n`);
+					stdoutTail.push(`${line}\n`);
 					input.onStdoutLine?.(line);
 				},
 				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
@@ -913,15 +884,16 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			});
 			child.stderr?.on("data", (chunk: Buffer) => {
 				if (!steeringController.isHardAbortInitiated()) restartNoResponseTimer();
-				stderr = appendBoundedTail(stderr, chunk.toString("utf-8"));
+				stderrTail.push(chunk.toString("utf-8"));
 			});
 			child.on("error", (error) => {
-				// Reject pending operations with process error context
+				// P0-1: snapshot the bounded accumulators once for this handler.
+				const stdout = stdoutTail.value();
+				const stderr = stderrTail.value();
 				// 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",
@@ -956,6 +928,8 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				});
 			});
 			child.on("exit", (code, signal) => {
+				// P0-1: snapshot the bounded stderr accumulator once for this handler.
+				const stderr = stderrTail.value();
 				if (child.pid) {
 					unregisterActiveChild(child.pid);
 					clearHardKillTimer(child.pid);
@@ -975,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
@@ -1017,6 +988,9 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				}
 			});
 			child.on("close", (exitCode) => {
+				// P0-1: snapshot the bounded accumulators once for this handler.
+				const stdout = stdoutTail.value();
+				const stderr = stderrTail.value();
 				if (child.pid) {
 					unregisterActiveChild(child.pid);
 					clearHardKillTimer(child.pid);
@@ -1059,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.
@@ -1080,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/compaction/compact-stages/bounded-tail.ts

@@ -0,0 +1,84 @@
+/**
+ * BoundedTail — O(1)-amortized bounded string accumulator (segment ring + running
+ * byte counter).
+ *
+ * Replaces the O(n²) `appendBoundedTail` rebuild-per-line pattern on the child stdout/stderr
+ * hot path. The defect (P0-1, verified 2026-07-29): the old accumulator did
+ * `new TailCaptureStage(...).apply(current + chunk)` on EVERY output line, so once the
+ * buffer filled to the 512 KiB cap each line re-scanned the whole buffer with
+ * `Buffer.byteLength` AND ran a per-character `while(...) tail = tail.slice(0,-1)` trim
+ * — 2.3 s (ASCII) to 112 s (multi-byte) of main-thread block per task.
+ *
+ * `push(chunk)` is O(chunk): it appends the segment and shifts whole leading segments
+ * while over cap, recomputing byte length only for the dropped segment — never the full
+ * buffer, never per-character. The single byte-exact boundary trim runs ONCE, in
+ * `value()`, which is read only at result-build / error time (rare).
+ *
+ * Output parity with the old `TailCaptureStage`-based path is preserved: under cap →
+ * 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";
+
+const DEFAULT_MAX_BYTES = DEFAULT_CHILD_PI.maxCaptureBytes;
+
+/** Default marker, identical to the old appendBoundedTail/TailCaptureStage wording. */
+function defaultMarker(maxBytes: number): string {
+	return `[pi-crew captured output truncated to last ${Math.round(maxBytes / 1024)} KiB]`;
+}
+
+export class BoundedTail {
+	readonly #maxBytes: number;
+	readonly #marker: string;
+	#segs: string[] = [];
+	#bytes = 0;
+	#dropped = false;
+	#cached: string | undefined;
+	#dirty = false;
+
+	constructor(maxBytes: number = DEFAULT_MAX_BYTES, marker?: string) {
+		if (!(maxBytes > 0)) throw new Error(`BoundedTail: maxBytes must be > 0, got ${maxBytes}`);
+		this.#maxBytes = maxBytes;
+		this.#marker = marker ?? defaultMarker(maxBytes);
+	}
+
+	/** Append a chunk. O(chunk) amortized; never scans the full buffer. */
+	push(chunk: string): this {
+		if (!chunk) return this;
+		this.#segs.push(chunk);
+		this.#bytes += Buffer.byteLength(chunk, "utf-8");
+		// Drop whole leading segments while over cap. Stop at length 1 so a single
+		// oversized segment is trimmed exactly once in value() instead of per-char.
+		while (this.#bytes > this.#maxBytes && this.#segs.length > 1) {
+			const dropped = this.#segs.shift() as string;
+			this.#bytes -= Buffer.byteLength(dropped, "utf-8");
+			this.#dropped = true;
+		}
+		this.#dirty = true;
+		return this;
+	}
+
+	/** Materialize the bounded string. Computed at most once per push; cached otherwise. */
+	value(): string {
+		if (!this.#dirty && this.#cached !== undefined) return this.#cached;
+		const body = this.#segs.join("");
+		const result = this.#bound(body);
+		this.#cached = result;
+		this.#dirty = false;
+		return result;
+	}
+
+	/** Byte-exact bound with marker parity vs the old TailCaptureStage path. */
+	#bound(body: string): string {
+		if (Buffer.byteLength(body, "utf-8") <= this.#maxBytes) {
+			// Under cap: add the marker only if we dropped earlier segments.
+			return this.#dropped ? `${this.#marker}\n${body}` : body;
+		}
+		// Over cap (single segment larger than max, or a boundary segment): keep the
+		// last ≤maxBytes bytes snapped forward past any UTF-8 continuation bytes.
+		const buf = Buffer.from(body, "utf-8");
+		let start = Math.max(0, buf.length - this.#maxBytes);
+		while (start < buf.length && (buf[start] & 0xc0) === 0x80) start++;
+		return `${this.#marker}\n${buf.subarray(start).toString("utf-8")}`;
+	}
+}

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/crew-agent-records.ts

@@ -26,14 +26,39 @@ export function agentStateDir(manifest: TeamRunManifest, taskId: string): string
 	return path.join(agentsRoot(manifest), safeAgentTaskId(taskId));
 }
 
+// P1-5: per-task path memoization. The agent state dir + file paths cannot
+// change within a task, so the mkdir/lstat/resolveRealContainedPath validation
+// (≈30 syscalls each, incl. a full ancestor walk) only needs to run ONCE per
+// task — not on every event/output line (was ~60 syscalls/event for the double
+// ensureAgentStateDir call alone). FIFO-bounded so the cache can't grow with
+// run count.
+const ensuredAgentDirs = new Map<string, string>();
+const resolvedAgentFiles = new Map<string, string>();
+const AGENT_PATH_CACHE_MAX = 512;
+
+function bumpAgentPathCache(): void {
+	if (ensuredAgentDirs.size > AGENT_PATH_CACHE_MAX) {
+		const oldest = ensuredAgentDirs.keys().next().value;
+		if (oldest !== undefined) ensuredAgentDirs.delete(oldest);
+	}
+	if (resolvedAgentFiles.size > AGENT_PATH_CACHE_MAX) {
+		const oldest = resolvedAgentFiles.keys().next().value;
+		if (oldest !== undefined) resolvedAgentFiles.delete(oldest);
+	}
+}
+
 export function ensureAgentStateDir(manifest: TeamRunManifest, taskId: string): string {
 	const root = agentsRoot(manifest);
+	const dir = agentStateDir(manifest, taskId);
+	const cachedDir = ensuredAgentDirs.get(dir);
+	if (cachedDir !== undefined) return cachedDir;
 	fs.mkdirSync(root, { recursive: true });
 	if (fs.lstatSync(root).isSymbolicLink()) throw new Error(`Invalid agents root: ${root}`);
-	const dir = agentStateDir(manifest, taskId);
 	fs.mkdirSync(dir, { recursive: true });
 	if (fs.lstatSync(dir).isSymbolicLink()) throw new Error(`Invalid agent state directory: ${dir}`);
 	resolveRealContainedPath(root, path.basename(dir));
+	ensuredAgentDirs.set(dir, dir);
+	bumpAgentPathCache();
 	return dir;
 }
 
@@ -45,8 +70,26 @@ function safeExistingAgentFile(manifest: TeamRunManifest, taskId: string, fileNa
 }
 
 export function agentStateFile(manifest: TeamRunManifest, taskId: string, fileName: string): string {
+	const dir = agentStateDir(manifest, taskId);
+	const cacheKey = `${dir}\0${fileName}`;
+	const cached = resolvedAgentFiles.get(cacheKey);
+	if (cached !== undefined) return cached;
 	ensureAgentStateDir(manifest, taskId);
-	return safeExistingAgentFile(manifest, taskId, fileName);
+	const resolved = safeExistingAgentFile(manifest, taskId, fileName);
+	resolvedAgentFiles.set(cacheKey, resolved);
+	bumpAgentPathCache();
+	return resolved;
+}
+
+/** @internal Test-only: clear the path memoization cache. */
+export function __test_clearAgentPathCache(): void {
+	ensuredAgentDirs.clear();
+	resolvedAgentFiles.clear();
+}
+
+/** @internal Test-only: inspect cache occupancy (regression guard for P1-5). */
+export function __test_agentPathCacheStats(): { dirs: number; files: number } {
+	return { dirs: ensuredAgentDirs.size, files: resolvedAgentFiles.size };
 }
 
 export function agentStatusPath(manifest: TeamRunManifest, taskId: string): string {
@@ -250,6 +293,9 @@ export async function readCrewAgentsAsync(manifest: TeamRunManifest): Promise<Cr
 }
 
 export function saveCrewAgents(manifest: TeamRunManifest, records: CrewAgentRecord[]): void {
+	// P0-3: flush any pending coalesced (best-effort) write first so a stale
+	// debounced progress snapshot can't clobber this durable write.
+	flushPendingAgentWrites();
 	withAgentsLock(manifest, () => {
 		fs.mkdirSync(manifest.stateRoot, { recursive: true });
 		const filePath = agentsPath(manifest);

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,14 +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 { readEvents, 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";
 
@@ -92,7 +93,7 @@ export async function exportDiagnostic(
 	if (!loaded) throw new Error(`Run '${runId}' not found.`);
 	const exportedAt = new Date().toISOString();
 	const safeTimestamp = exportedAt.replace(/[:.]/g, "-");
-	const recentEvents = readEvents(loaded.manifest.eventsPath).slice(-200);
+	const recentEvents = readJsonlTail<TeamEvent>(loaded.manifest.eventsPath, 256 * 1024).items.slice(-200);
 	const metricsSnapshot = options.registry?.snapshot();
 	const taskDiagnostics: Record<string, Record<string, unknown>> = {};
 	const terminalEvidence: Record<string, TeamTaskState["terminalEvidence"]> = {};

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;

package/src/runtime/{dynamic-workflow-context.ts → goal-workflow/dynamic-workflow-context.ts}

@@ -24,23 +24,23 @@
 
 import { randomBytes } from "node:crypto";
 import type { TSchema } from "@sinclair/typebox";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { appendMailboxMessage, readMailbox } from "../state/mailbox.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../worktree/worktree-manager.ts";
-import type { DwfCheckpointState } from "./dwf-state-store.ts";
-import { mapConcurrent } from "./parallel-utils.ts";
-import { parsePiJsonOutput } from "./pi-json-output.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { allAgents, discoverAgents } from "../../agents/discover-agents.ts";
+import { appendMailboxMessage, readMailbox } from "../../state/coordination/mailbox.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import type { TeamRunManifest } from "../../state/types.ts";
+import type { TeamConfig } from "../../teams/team-config.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../../worktree/worktree-manager.ts";
+import type { DwfCheckpointState } from "../dwf-state-store.ts";
+import { parsePiJsonOutput } from "../output/pi-json-output.ts";
+import { extractStructuredResult } from "../output/result-extractor.ts";
+import { executeWithRetry } from "../recovery/retry-executor.ts";
+import { runWorker } from "../run-worker.ts";
+import { mapConcurrent } from "../scheduling/parallel-utils.ts";
+import { Semaphore } from "../scheduling/semaphore.ts";
 import { renderPlanTemplate } from "./plan-templates.ts";
-import { extractStructuredResult } from "./result-extractor.ts";
-import { executeWithRetry } from "./retry-executor.ts";
-import { runWorker } from "./run-worker.ts";
-import { Semaphore } from "./semaphore.ts";
 
 export interface AgentCallOpts {
 	prompt: string;

package/src/runtime/{dynamic-workflow-runner.ts → goal-workflow/dynamic-workflow-runner.ts}

@@ -20,22 +20,22 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { transformSync } from "esbuild";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { packageRoot, projectCrewRoot, userPiRoot } from "../utils/paths.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import type { DynamicWorkflowConfig } from "../workflows/workflow-config.ts";
-import { assertDeterministicScript, isDeterminismCheckEnabled } from "./deterministic-ast.ts";
-import { DwfStore } from "./dwf-state-store.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { packageRoot, projectCrewRoot, userPiRoot } from "../../utils/paths.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import type { DynamicWorkflowConfig } from "../../workflows/workflow-config.ts";
+import { assertDeterministicScript, isDeterminismCheckEnabled } from "../deterministic-ast.ts";
+import { DwfStore } from "../dwf-state-store.ts";
 import { getWorkflowFinalResult, getWorkflowPhaseState, makeWorkflowCtx } from "./dynamic-workflow-context.ts";
 
 export interface RunDynamicWorkflowInput {
 	manifest: TeamRunManifest;
 	workflow: DynamicWorkflowConfig;
 	/** Optional team for role resolution (G4 tier 2). */
-	team?: import("../teams/team-config.ts").TeamConfig;
+	team?: import("../../teams/team-config.ts").TeamConfig;
 	signal: AbortSignal;
 	concurrency?: number;
 	modelOverride?: string;

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

@@ -18,9 +18,9 @@
  *     without breaking a legitimately-no-op run.
  */
 import { spawnSync } from "node:child_process";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { findRepoRoot } from "../utils/paths.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { findRepoRoot } from "../../utils/paths.ts";
+import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
 
 /**
  * Roles whose job is to EDIT project source/test files (changes that appear in