pi-crew 0.9.51 → 0.9.52

package/src/runtime/run-drift.ts

@@ -1,219 +0,0 @@
-/**
- * Runtime drift detectors — detect state anomalies in pi-crew runs.
- *
- * Pattern origin: GSD-2 ADR-017 drift detection & state reconciliation.
- * Each detector checks for a specific anomaly and returns a report.
- * Repair handlers are idempotent — safe to run multiple times.
- */
-
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { logInternalError } from "../utils/internal-error.ts";
-
-// ── Types ────────────────────────────────────────────────────────────────
-
-export type DriftKind =
-	| "stale-process" // Heartbeat timeout (existing)
-	| "orphaned-claim" // Task claim without task
-	| "orphaned-worktree" // Worktree dir without active run
-	| "missing-timestamps" // State files without timestamps
-	| "status-divergence" // Manifest status ≠ status file
-	| "unregistered-run"; // State dir but no manifest
-
-export interface DriftReport {
-	kind: DriftKind;
-	runId: string;
-	details: string;
-	repaired: boolean;
-	repairResult?: string;
-}
-
-export interface DriftContext {
-	/** Root directory for crew state (.crew/) */
-	crewRoot: string;
-	/** Active run IDs (from registry) */
-	activeRunIds: Set<string>;
-	/** Manifest content if available */
-	manifest?: {
-		runId: string;
-		status: string;
-		cwd: string;
-		[k: string]: unknown;
-	};
-}
-
-// ── Detectors ────────────────────────────────────────────────────────────
-
-/**
- * Detect task claims that reference tasks not in the manifest.
- */
-export function detectOrphanedClaim(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const claimsDir = path.join(ctx.crewRoot, "state", "task-claims");
-	if (!existsSync(claimsDir)) return null;
-
-	const claimFiles = readdirSync(claimsDir).filter((f) => f.endsWith(".json"));
-	for (const file of claimFiles) {
-		try {
-			const claim = JSON.parse(readFileSync(path.join(claimsDir, file), "utf-8"));
-			if (claim.runId === ctx.manifest.runId && claim.taskId) {
-				// Check if task exists in manifest tasks array
-				const tasks = (ctx.manifest as Record<string, unknown>).tasks;
-				if (Array.isArray(tasks) && !tasks.some((t: Record<string, unknown>) => t.id === claim.taskId)) {
-					return {
-						kind: "orphaned-claim",
-						runId: ctx.manifest.runId,
-						details: `Task claim '${claim.taskId}' references non-existent task`,
-						repaired: false,
-					};
-				}
-			}
-		} catch {
-			// Malformed claim file — skip
-		}
-	}
-	return null;
-}
-
-/**
- * Detect worktree directories that don't belong to any active run.
- */
-export function detectOrphanedWorktree(ctx: DriftContext): DriftReport | null {
-	const worktreesDir = path.join(ctx.crewRoot, "worktrees");
-	if (!existsSync(worktreesDir)) return null;
-
-	const dirs = readdirSync(worktreesDir, { withFileTypes: true })
-		.filter((d) => d.isDirectory())
-		.map((d) => d.name);
-
-	for (const dir of dirs) {
-		// Extract run ID from worktree dir name (format: <runId>-<taskId> or <runId>)
-		const runId = dir.split("-").slice(0, 5).join("-"); // heuristic: run IDs are timestamp-based
-		if (!ctx.activeRunIds.has(runId) && !ctx.activeRunIds.has(dir)) {
-			return {
-				kind: "orphaned-worktree",
-				runId: dir,
-				details: `Worktree '${dir}' has no active run`,
-				repaired: false,
-			};
-		}
-	}
-	return null;
-}
-
-/**
- * Detect state files missing required timestamps.
- */
-export function detectMissingTimestamps(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const stateDir = path.join(ctx.crewRoot, "state");
-	if (!existsSync(stateDir)) return null;
-
-	// Check manifest has createdAt/updatedAt
-	const m = ctx.manifest as Record<string, unknown>;
-	if (!m.createdAt && !m.updatedAt) {
-		return {
-			kind: "missing-timestamps",
-			runId: ctx.manifest.runId,
-			details: "Manifest missing createdAt/updatedAt timestamps",
-			repaired: false,
-		};
-	}
-	return null;
-}
-
-/**
- * Detect divergence between manifest status and individual task status files.
- */
-export function detectStatusDivergence(ctx: DriftContext): DriftReport | null {
-	if (!ctx.manifest) return null;
-	const statusPath = path.join(ctx.crewRoot, "state", `${ctx.manifest.runId}.status`);
-	if (!existsSync(statusPath)) return null;
-
-	try {
-		const status = readFileSync(statusPath, "utf-8").trim();
-		if (status !== ctx.manifest.status) {
-			return {
-				kind: "status-divergence",
-				runId: ctx.manifest.runId,
-				details: `Manifest says '${ctx.manifest.status}' but status file says '${status}'`,
-				repaired: false,
-			};
-		}
-	} catch {
-		// Can't read status file — not drift, might be permissions
-	}
-	return null;
-}
-
-/**
- * Detect state directories that have no corresponding manifest.
- */
-export function detectUnregisteredRun(ctx: DriftContext): DriftReport | null {
-	const runsDir = path.join(ctx.crewRoot, "runs");
-	if (!existsSync(runsDir)) return null;
-
-	const runDirs = readdirSync(runsDir, { withFileTypes: true })
-		.filter((d) => d.isDirectory())
-		.map((d) => d.name);
-
-	for (const runId of runDirs) {
-		if (!ctx.activeRunIds.has(runId)) {
-			// Check if it has state files (manifest exists)
-			const manifestPath = path.join(runsDir, runId, "manifest.json");
-			if (existsSync(manifestPath)) {
-				try {
-					const stat = statSync(manifestPath);
-					const ageMs = Date.now() - stat.mtimeMs;
-					// Only flag if older than 1 hour (might be in-progress)
-					if (ageMs > 60 * 60 * 1000) {
-						return {
-							kind: "unregistered-run",
-							runId,
-							details: `Run '${runId}' has manifest but is not in active registry (age: ${Math.round(ageMs / 60000)}m)`,
-							repaired: false,
-						};
-					}
-				} catch {
-					// Can't stat — skip
-				}
-			}
-		}
-	}
-	return null;
-}
-
-// ── Reconciliation Loop ─────────────────────────────────────────────────
-
-const ALL_DETECTORS = [detectOrphanedClaim, detectOrphanedWorktree, detectMissingTimestamps, detectStatusDivergence, detectUnregisteredRun];
-
-/**
- * Run all drift detectors and collect reports.
- * Capped at maxPasses repair attempts.
- *
- * Pattern origin: GSD-2 ADR-017 — capped at 2 retry passes.
- */
-export function runDriftDetection(ctx: DriftContext, maxPasses = 2): DriftReport[] {
-	const reports: DriftReport[] = [];
-
-	for (let pass = 0; pass < maxPasses; pass++) {
-		let newFindings = 0;
-
-		for (const detector of ALL_DETECTORS) {
-			try {
-				const report = detector(ctx);
-				if (report) {
-					reports.push(report);
-					newFindings++;
-				}
-			} catch (error) {
-				logInternalError("run-drift", error, `detector=${detector.name} runId=${ctx.manifest?.runId}`);
-			}
-		}
-
-		// If no new findings, stop early
-		if (newFindings === 0) break;
-	}
-
-	return reports;
-}

package/src/runtime/run-tracker.ts

@@ -1,116 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { loadRunManifestById } from "../state/state-store.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { projectCrewRoot } from "../utils/paths.ts";
-import { isFinishedRunStatus } from "./process-status.ts";
-
-export interface ActiveRunPromise {
-	promise: Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }>;
-	resolve: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
-	reject: (reason: unknown) => void;
-}
-
-const activeRunPromises = new Map<string, ActiveRunPromise>();
-
-export function registerRunPromise(runId: string): ActiveRunPromise {
-	let resolve!: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
-	let reject!: (reason: unknown) => void;
-	const promise = new Promise<{
-		manifest: TeamRunManifest;
-		tasks: TeamTaskState[];
-	}>((res, rej) => {
-		resolve = res;
-		reject = rej;
-	});
-	const entry: ActiveRunPromise = { promise, resolve, reject };
-	activeRunPromises.set(runId, entry);
-	return entry;
-}
-
-export function resolveRunPromise(runId: string, result: { manifest: TeamRunManifest; tasks: TeamTaskState[] }): void {
-	const entry = activeRunPromises.get(runId);
-	if (entry) {
-		entry.resolve(result);
-		activeRunPromises.delete(runId);
-	}
-}
-
-export function rejectRunPromise(runId: string, reason: unknown): void {
-	const entry = activeRunPromises.get(runId);
-	if (entry) {
-		entry.reject(reason);
-		activeRunPromises.delete(runId);
-	}
-}
-
-/**
- * Wait for a team run to reach a terminal status.
- * - If the run is already finished on disk, returns immediately.
- * - If a foreground promise is registered for this runId, awaits it.
- * - Otherwise falls back to lightweight fs.watchFile-based waiting.
- */
-export async function waitForRun(
-	runId: string,
-	cwd: string,
-	options: { timeoutMs?: number; pollIntervalMs?: number } = {},
-): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
-	const { timeoutMs = 300_000, pollIntervalMs = 500 } = options;
-	const deadline = Date.now() + timeoutMs;
-
-	// Fast path: already terminal on disk
-	const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
-	if (loaded && isFinishedRunStatus(loaded.manifest.status)) {
-		return loaded;
-	}
-
-	// Medium path: foreground promise registered in this process
-	const entry = activeRunPromises.get(runId);
-	if (entry) {
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		const timeoutPromise = new Promise<never>((_, reject) => {
-			timer = setTimeout(() => reject(new Error(`waitForRun timed out after ${timeoutMs}ms`)), timeoutMs);
-		});
-		try {
-			return await Promise.race([entry.promise, timeoutPromise]);
-		} finally {
-			if (timer) clearTimeout(timer);
-		}
-	}
-
-	// Slow path: background run — poll with exponential backoff capped at pollIntervalMs
-	let attempt = 0;
-	while (Date.now() < deadline) {
-		if (attempt === 0) {
-			// Early exit: if the run directory doesn't exist, don't waste time polling.
-			// Use projectCrewRoot() to honour the .pi/teams/ fallback for .pi-based
-			// projects (see issue #29). Without this, the hardcoded `.crew/state/runs/`
-			// path never resolves in projects that use the `.pi/` layout, the throw
-			// escapes via subagent-manager.ts:281, and pi crashes with uncaughtException.
-			const runDir = path.join(projectCrewRoot(cwd), "state", "runs", runId);
-			if (!fs.existsSync(runDir)) {
-				throw new Error(`Run ${runId} not found. No run directory at ${runDir}`);
-			}
-		}
-		const fresh = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
-		if (fresh && isFinishedRunStatus(fresh.manifest.status)) {
-			return fresh;
-		}
-		const delay = Math.min(pollIntervalMs, 50 * 2 ** Math.min(attempt, 6)); // max ~3.2s
-		await new Promise((r) => setTimeout(r, delay));
-		attempt++;
-	}
-
-	throw new Error(`waitForRun timed out after ${timeoutMs}ms`);
-}
-
-export function hasActiveRunPromise(runId: string): boolean {
-	return activeRunPromises.has(runId);
-}
-
-export function clearRunPromisesForTest(): void {
-	for (const entry of activeRunPromises.values()) {
-		entry.reject(new Error("Cleared by test"));
-	}
-	activeRunPromises.clear();
-}

package/src/runtime/runtime-policy.ts

@@ -1,29 +0,0 @@
-import type { CrewRuntimeConfig } from "../config/config.ts";
-import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
-import { currentCrewDepth } from "./pi-args.ts";
-
-/**
- * Resolve the effective runtime kind for a given task role using isolation policy.
- * - scaffold is never overridden — scaffold stays scaffold.
- * - If already nested (PI_CREW_DEPTH > 0), force child-process to avoid live-session nesting issues.
- * - If the role appears in `isolationPolicy.isolatedRoles`, use child-process (crash isolation).
- * - Otherwise, use `isolationPolicy.defaultRuntime` when configured, then fall back to globalKind.
- */
-export function resolveTaskRuntimeKind(
-	globalKind: CrewRuntimeKind,
-	role: string,
-	isolationPolicy: CrewRuntimeConfig["isolationPolicy"],
-	env: NodeJS.ProcessEnv = process.env,
-): CrewRuntimeKind {
-	if (globalKind === "scaffold") return "scaffold";
-	// Safety: when already inside a pi-crew worker (depth > 0), never nest live-session.
-	// Live-session creates in-process Pi agent sessions, which would recursively
-	// try to use pi-crew, leading to "Cannot read properties of undefined" errors.
-	// Exception: when PI_CREW_MOCK_LIVE_SESSION is set, we're in a test harness
-	// that mocks the live-session path — forcing child-process would spawn a real
-	// pi process and hang the test.
-	if (globalKind === "live-session" && currentCrewDepth(env) > 0 && env.PI_CREW_MOCK_LIVE_SESSION !== "success") return "child-process";
-	const isolatedRoles = isolationPolicy?.isolatedRoles ?? [];
-	if (isolatedRoles.includes(role)) return "child-process";
-	return isolationPolicy?.defaultRuntime ?? globalKind;
-}

package/src/runtime/runtime-resolver.ts

@@ -1,172 +0,0 @@
-import type { PiTeamsConfig } from "../config/config.ts";
-import type { RuntimeResolutionState } from "../state/types.ts";
-import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
-
-export type CrewRuntimeMode = "auto" | "scaffold" | "child-process" | "live-session";
-
-export type CrewRuntimeSafety = "trusted" | "explicit_dry_run" | "blocked";
-
-export interface CrewRuntimeCapabilities {
-	kind: CrewRuntimeKind;
-	requestedMode: CrewRuntimeMode;
-	available: boolean;
-	fallback?: CrewRuntimeKind;
-	steer: boolean;
-	resume: boolean;
-	liveToolActivity: boolean;
-	transcript: boolean;
-	reason?: string;
-	safety: CrewRuntimeSafety;
-}
-
-export function runtimeResolutionState(runtime: CrewRuntimeCapabilities, resolvedAt = new Date().toISOString()): RuntimeResolutionState {
-	return {
-		kind: runtime.kind,
-		requestedMode: runtime.requestedMode,
-		safety: runtime.safety,
-		available: runtime.available,
-		...(runtime.fallback ? { fallback: runtime.fallback } : {}),
-		...(runtime.reason ? { reason: runtime.reason } : {}),
-		resolvedAt,
-	};
-}
-
-export async function isLiveSessionRuntimeAvailable(
-	timeoutMs = 1500,
-	env: NodeJS.ProcessEnv = process.env,
-): Promise<{ available: boolean; reason?: string }> {
-	if (env.PI_CREW_MOCK_LIVE_SESSION === "success") {
-		return {
-			available: true,
-			reason: "Mock live-session runtime is enabled.",
-		};
-	}
-	const probe = async (): Promise<{
-		available: boolean;
-		reason?: string;
-	}> => {
-		try {
-			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
-			const mod = await import("@earendil-works/pi-coding-agent");
-			const api = mod as Record<string, unknown>;
-			const required = ["createAgentSession", "DefaultResourceLoader", "SessionManager", "SettingsManager"];
-			const missing = required.filter((name) => typeof api[name] === "undefined");
-			if (missing.length)
-				return {
-					available: false,
-					reason: `Pi SDK live-session exports missing: ${missing.join(", ")}.`,
-				};
-			return { available: true };
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return {
-				available: false,
-				reason: `Could not load optional Pi SDK live-session runtime: ${message}`,
-			};
-		}
-	};
-	let timer: NodeJS.Timeout | undefined;
-	try {
-		return await Promise.race([
-			probe(),
-			new Promise<{ available: boolean; reason: string }>((resolve) => {
-				timer = setTimeout(
-					() =>
-						resolve({
-							available: false,
-							reason: `Timed out probing optional Pi SDK live-session runtime after ${timeoutMs}ms.`,
-						}),
-					timeoutMs,
-				);
-				timer.unref();
-			}),
-		]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-
-export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.ProcessEnv = process.env): Promise<CrewRuntimeCapabilities> {
-	const requestedMode = config.runtime?.mode ?? "auto";
-	const workersDisabled = config.executeWorkers === false || env.PI_CREW_EXECUTE_WORKERS === "0" || env.PI_TEAMS_EXECUTE_WORKERS === "0";
-	if (requestedMode === "scaffold") return scaffoldCaps(requestedMode, undefined, "explicit_dry_run");
-	if (workersDisabled)
-		return scaffoldCaps(
-			requestedMode,
-			"Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.",
-			"blocked",
-		);
-	if (requestedMode === "child-process") return childCaps(requestedMode);
-	// When a child-process mock is active (tests), force auto-mode to child-process where the mock is active.
-	if (requestedMode === "auto" && env.PI_TEAMS_MOCK_CHILD_PI)
-		return childCaps(requestedMode, "PI_TEAMS_MOCK_CHILD_PI mock forces child-process runtime in auto mode.");
-	if (requestedMode === "live-session") {
-		const live = await isLiveSessionRuntimeAvailable(1500, env);
-		if (live.available) return liveCaps(requestedMode);
-		if (config.runtime?.allowChildProcessFallback === false) return scaffoldCaps(requestedMode, live.reason, "blocked");
-		return {
-			...childCaps(requestedMode),
-			fallback: "child-process",
-			reason: live.reason,
-		};
-	}
-	// auto mode: use child-process unless preferLiveSession is explicitly enabled
-	if (requestedMode === "auto") {
-		// Check for mock env var first (for testing)
-		if (env.PI_CREW_MOCK_LIVE_SESSION === "success") {
-			const live = await isLiveSessionRuntimeAvailable(1500, env);
-			if (live.available) return liveCaps(requestedMode);
-		}
-		// Then check explicit config preference
-		if (config.runtime?.preferLiveSession === true) {
-			const live = await isLiveSessionRuntimeAvailable(1500, env);
-			if (live.available) return liveCaps(requestedMode);
-		}
-	}
-	return childCaps(requestedMode);
-}
-
-function scaffoldCaps(
-	requestedMode: CrewRuntimeMode,
-	reason?: string,
-	safety: CrewRuntimeSafety = "explicit_dry_run",
-): CrewRuntimeCapabilities {
-	return {
-		kind: "scaffold",
-		requestedMode,
-		available: safety !== "blocked",
-		steer: false,
-		resume: false,
-		liveToolActivity: false,
-		transcript: false,
-		safety,
-		...(reason ? { reason } : {}),
-	};
-}
-
-function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
-	return {
-		kind: "child-process",
-		requestedMode,
-		available: true,
-		steer: true,
-		resume: false,
-		liveToolActivity: false,
-		transcript: true,
-		safety: "trusted",
-		...(reason ? { reason } : {}),
-	};
-}
-
-function liveCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {
-	return {
-		kind: "live-session",
-		requestedMode,
-		available: true,
-		steer: true,
-		resume: true,
-		liveToolActivity: true,
-		transcript: true,
-		safety: "trusted",
-	};
-}

package/src/runtime/runtime-warmup.ts

@@ -1,160 +0,0 @@
-/**
- * Runtime module-graph warmup — general fix for the cold-start race.
- *
- * Problem: when N in-process live-session subagents spawn CONCURRENTLY, the
- * tsx loader can race module-record instantiation, yielding
- * `Cannot read properties of undefined (reading '<binding>')` for ANY named
- * import in the hot graph (observed: `existsSync`, `validateWorkflowForTeam`).
- * v0.8.1's per-import latch covered only the peer-dep namespace; this is the
- * GENERAL fix.
- *
- * Root cause: under tsx, a named import `import { X } from "mod"` compiles to
- * `mod_1.X` — a namespace-property access at runtime. If `mod_1` (the module
- * namespace object) is observed mid-instantiation as `undefined`, the access
- * throws. ANY module in the graph is vulnerable, not just the peer dep. So
- * per-import latching doesn't scale.
- *
- * Fix: pre-warm the hot module graph during SINGLE-THREADED extension
- * registration (before any subagent can spawn), then `await` the warmup at
- * every spawn entry point. By the time concurrent subagents touch the graph,
- * every module record is fully instantiated → no race window.
- *
- * Why this is general (not per-import):
- *   - `startRuntimeWarmup()` fires `import()` for the ROOT modules of each
- *     hot execution path. ESM transitively instantiates their entire import
- *     graph, so one import per path warms the whole reachable subgraph.
- *   - `awaitRuntimeWarmup()` is the gate: spawn paths await it before
- *     touching any module, guaranteeing the graph is warm regardless of
- *     which specific binding races.
- *
- * The warmup runs during `registerPiTeams()` (single-threaded, before pi
- * accepts user input). It resolves in milliseconds (module loading only, no
- * I/O for local modules). The `await` at spawn boundaries is belt-and-
- * suspenders for pathological cases where a spawn races the warmup promise.
- *
- * @module runtime-warmup
- */
-
-/**
- * The modules whose transitive import graphs cover every hot execution path
- * a concurrent subagent can reach. Importing the ROOT of each path warms the
- * full subgraph (ESM instantiates imports eagerly during `import()`).
- *
- * - `./live-session-runtime.ts` — the in-process subagent spawn path
- *   (pulls in the peer dep + the entire runtime layer).
- * - `./task-runner.ts` — the child-process task dispatch path.
- * - `../extension/team-tool.ts` — the team tool (pulls in
- *   validate-resources → validate-workflow, the `validateWorkflowForTeam` site).
- * - `../extension/validate-resources.ts` — direct warm of the aggregator.
- * - `@earendil-works/pi-coding-agent` — the peer dep (the `existsSync` site;
- *   also latched in v0.8.1 — defense in depth).
- */
-const HOT_MODULE_SPECIFIERS = [
-	"./live-session-runtime.ts",
-	"./task-runner.ts",
-	"../extension/team-tool.ts",
-	"../extension/team-tool/run.ts", // handleRun path — latched in team-tool.ts but its static graph (config-patch, validate-workflow) still cold-start-races under concurrent fanout
-	"../extension/team-tool/config-patch.ts", // effectiveRunConfig (crash variant observed in repro)
-	"../extension/validate-resources.ts",
-	"../workflows/validate-workflow.ts", // validateWorkflowForTeam (crash variant observed across sessions)
-	"../state/crew-init.ts", // TDZ-prone top-level consts (CREW_README); dynamically imported by team-tool/run.ts
-] as const;
-
-/** Additional bare-specifier peer deps to warm. */
-const HOT_PEER_DEPS = ["@earendil-works/pi-coding-agent"] as const;
-
-let warmupPromise: Promise<void> | undefined;
-let warmupStarted = false;
-let warmupCompleted = false;
-let warmupDurationMs: number | undefined;
-let warmupError: string | undefined;
-
-/**
- * Start the runtime warmup (idempotent). Fires eager `import()` of the hot
- * module graph. Safe to call during single-threaded registration — the
- * promises resolve on the event loop before any subagent can spawn.
- *
- * Errors are swallowed: a failed warmup (e.g. peer dep absent) must never
- * block the extension from loading. The worst case is the old race returns
- * (which is no worse than before this fix).
- */
-export function startRuntimeWarmup(): void {
-	if (warmupStarted) return;
-	warmupStarted = true;
-	const startedAt = Date.now();
-	warmupPromise = (async (): Promise<void> => {
-		const imports: Array<Promise<unknown>> = [];
-		for (const spec of HOT_MODULE_SPECIFIERS) {
-			imports.push(
-				import(new URL(spec, import.meta.url).href).catch(() => {
-					// swallow — never block registration on a warmup failure
-				}),
-			);
-		}
-		for (const dep of HOT_PEER_DEPS) {
-			imports.push(
-				import(dep).catch(() => {
-					// peer dep may be absent (optional dep) — swallow
-				}),
-			);
-		}
-		await Promise.all(imports);
-	})()
-		.then(() => {
-			warmupCompleted = true;
-			warmupDurationMs = Date.now() - startedAt;
-		})
-		.catch((err: unknown) => {
-			// final safety net — warmup must never reject. Record for diagnostics.
-			warmupError = err instanceof Error ? err.message : String(err ?? "unknown");
-		});
-}
-
-/**
- * Await the runtime warmup at a spawn entry point. No-op if warmup hasn't
- * started (back-compat for callers that don't call startRuntimeWarmup) or has
- * already resolved. Guarantees the hot module graph is instantiated before
- * the caller touches any module — eliminating the concurrent cold-start race.
- */
-export async function awaitRuntimeWarmup(): Promise<void> {
-	if (warmupPromise) await warmupPromise;
-}
-
-/**
- * Test seam: reset the warmup state so tests can re-trigger it. Also lets
- * tests verify idempotency by calling startRuntimeWarmup() multiple times.
- */
-export function resetRuntimeWarmupForTest(): void {
-	warmupPromise = undefined;
-	warmupStarted = false;
-	warmupCompleted = false;
-	warmupDurationMs = undefined;
-	warmupError = undefined;
-}
-
-/** Test seam: has startRuntimeWarmup() been called? */
-export function isRuntimeWarmupStarted(): boolean {
-	return warmupStarted;
-}
-
-/**
- * Diagnostic snapshot of warmup state for `team doctor`. Surfaces whether the
- * v0.8.6 cold-start fix is active and how long the graph warmup took, so a
- * session can confirm the fix loaded (post-restart) and isn't pathologically
- * slow.
- */
-export interface RuntimeWarmupStatus {
-	started: boolean;
-	completed: boolean;
-	durationMs: number | undefined;
-	error: string | undefined;
-}
-
-export function getRuntimeWarmupStatus(): RuntimeWarmupStatus {
-	return {
-		started: warmupStarted,
-		completed: warmupCompleted,
-		durationMs: warmupDurationMs,
-		error: warmupError,
-	};
-}