pi-crew 0.9.56 → 0.9.57

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

@@ -1,25 +1,31 @@
 import { loadConfig } from "../../config/config.ts";
 import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
 import { extractCommandTrace } from "../../runtime/command-trace.ts";
-import { verifyTaskCompletion } from "../../runtime/completion-guard.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { evaluateRunEffectiveness } from "../../runtime/effectiveness.ts";
 import { computePhaseProgress } from "../../runtime/phase-progress.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
 import { formatTaskGraphLines, waitingReason } from "../../runtime/task-display.ts";
+import { verifyTaskCompletion } from "../../runtime/verification/completion-guard.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { appendEvent, readEvents } from "../../state/event-log.ts";
-import { readDeliveryState, readMailbox } from "../../state/mailbox.ts";
-import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
+import { readDeliveryState, readMailbox } from "../../state/coordination/mailbox.ts";
+import { appendEvent, readEvents } from "../../state/event-log/event-log.ts";
+import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
 import { aggregateUsage, formatCost, formatUsage } from "../../state/usage.ts";
 import { formatDuration } from "../../ui/format-helpers.ts";
 import { locateRunCwd } from "../team-tool.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
+import { paramRequired } from "./param-error.ts";
 import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Status requires runId.", { action: "status", status: "error" }, true);
+	if (!params.runId)
+		return result(
+			paramRequired("status", "runId", "{ action: 'status', runId: 'team_...' }"),
+			{ action: "status", status: "error" },
+			true,
+		);
 	const runCwd = locateRunCwd(params.runId, ctx.cwd);
 	if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "status", status: "error" }, true);
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency

package/src/extension/team-tool.ts

@@ -7,12 +7,12 @@ import { loadConfig } from "../config/config.ts";
 // executeTeamRun is only called when a team run actually executes.
 import type { executeTeamRun as _executeTeamRunFn } from "../runtime/team-runner.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
 import { TEAM_TERMINAL_TASK_STATUSES } from "../state/contracts.ts";
-import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
-import { withRunLock } from "../state/locks.ts";
-import { replayPendingMailboxMessages } from "../state/mailbox.ts";
-import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { withRunLock } from "../state/coordination/locks.ts";
+import { replayPendingMailboxMessages } from "../state/coordination/mailbox.ts";
+import { appendEvent, appendEventFireAndForget } from "../state/event-log/event-log.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
+import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatus } from "../state/stores/state-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
@@ -32,8 +32,8 @@ async function executeTeamRun(...args: Parameters<ExecuteTeamRunFn>): Promise<Aw
 }
 
 import { directTeamAndWorkflowFromRun } from "../runtime/direct-run.ts";
-import { parsePiJsonOutput } from "../runtime/pi-json-output.ts";
-import { resolveCrewRuntime, runtimeResolutionState } from "../runtime/runtime-resolver.ts";
+import { resolveCrewRuntime, runtimeResolutionState } from "../runtime/model/runtime-resolver.ts";
+import { parsePiJsonOutput } from "../runtime/output/pi-json-output.ts";
 import { effectiveRunConfig } from "./team-tool/config-patch.ts";
 import { buildParentContext, formatScoped, result, type TeamContext } from "./team-tool/context.ts";
 // Lazy-loaded: run.ts pulls in spawnBackgroundTeamRun, resolveCrewRuntime, etc.
@@ -51,6 +51,7 @@ async function handleRun(...args: Parameters<HandleRunFn>): Promise<Awaited<Retu
 	return _cachedHandleRun(...args);
 }
 
+import { t } from "../i18n.ts";
 import { waitForRun } from "../runtime/run-tracker.ts";
 import { normalizeSkillOverride } from "../runtime/skill-instructions.ts";
 import { formatActionSuggestion } from "./action-suggestions.ts";
@@ -638,10 +639,9 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 			return handleManageDomain(params, ctx);
 		case "automate":
 			return handleAutomateDomain(params, ctx);
-		case undefined:
 		default:
 			return result(
-				`Unknown action: ${action}${formatActionSuggestion(String(action))}`,
+				t("team.unknownAction", { action: String(action) }) + formatActionSuggestion(String(action)),
 				{ action: "unknown", status: "error" },
 				true,
 			);
@@ -649,11 +649,15 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 }
 
 /**
- * Global RPC registry for cross-extension access to pi-crew's team orchestrator.
- * Uses Symbol.for() for cross-package singleton pattern (same as OpenTelemetry).
- * Extensions can access via: const reg = globalThis[Symbol.for("pi-crew:registry")];
+ * Module-scoped RPC registry for access to pi-crew's team orchestrator.
+ *
+ * EXT-9: Previously this used a `globalThis[Symbol.for("pi-crew:registry")]`
+ * singleton — fragile (cross-realm, no lifecycle, peer extensions could
+ * read/overwrite it). It is now a module-level variable: exactly one instance
+ * per extension load (one per pi session), invisible to peer extensions.
+ * Cross-extension consumers should use the `pi.events` RPC channel
+ * (`registerPiCrewRpc`) instead of poking globalThis.
  */
-const CREW_REGISTRY_KEY = Symbol.for("pi-crew:registry");
 interface CrewRegistry {
 	version: 2;
 	getRecord: (runId: string) => TeamRunManifest | undefined;
@@ -674,13 +678,16 @@ interface CrewRegistry {
 // discovery results with highest priority. The CrewRegistry interface exposes
 // registerAgent/unregisterAgent/listDynamicAgents for cross-extension access.
 
+// Module-scoped singleton instance — one per extension load (EXT-9).
+let crewRegistryInstance: CrewRegistry | undefined;
+
 export function registerCrewGlobalRegistry(registry: CrewRegistry): void {
-	(globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY] = registry;
+	crewRegistryInstance = registry;
 }
 
-/** @internal */
-function getCrewGlobalRegistry(): CrewRegistry | undefined {
-	return (globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY] as CrewRegistry | undefined;
+/** @internal — exported for lifecycle tests. */
+export function getCrewGlobalRegistry(): CrewRegistry | undefined {
+	return crewRegistryInstance;
 }
 
 /** Manifest cache shape needed to construct the global registry's read-side. */
@@ -744,7 +751,7 @@ export function installCrewGlobalRegistry(deps?: { manifestCache: ManifestCacheF
 	registerCrewGlobalRegistry(registry);
 }
 
-/** Remove the global CrewRegistry singleton. Call during session cleanup. */
+/** Remove the CrewRegistry singleton. Call during session cleanup. */
 export function uninstallCrewGlobalRegistry(): void {
-	delete (globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY];
+	crewRegistryInstance = undefined;
 }

package/src/hooks/registry.ts

@@ -1,4 +1,4 @@
-import { appendEvent } from "../state/event-log.ts";
+import { appendEvent } from "../state/event-log/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { runEventBus } from "../ui/run-event-bus.ts";
 import type { HookContext, HookDefinition, HookExecutionReport, HookName, HookResult } from "./types.ts";

package/src/i18n.ts

@@ -24,6 +24,13 @@ const fallback = {
 	"steer.noted": "Steering request noted for {id}.",
 	"steer.unavailable": "Current default pi-crew backend is child-process, so mid-turn session.steer is not available yet.",
 	"steer.cancelHint": "Use team cancel runId={runId} if the agent must be interrupted.",
+	// PR-F12 (EXT-12): team tool user-facing strings routed through t() for
+	// consistency with the subagent tools (Agent / get_subagent_result).
+	"team.run.created": "Created pi-crew run {runId}.",
+	"team.run.completed": "pi-crew run {status}: {runId} ({team})",
+	"team.run.allCompleted": "All tasks completed successfully.",
+	"team.run.tasksFailed": "{count} task(s) failed: {ids}. Consider retrying.",
+	"team.unknownAction": "Unknown action: {action}",
 } as const;
 
 type Key = keyof typeof fallback;
@@ -50,6 +57,11 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"steer.unavailable":
 			"El backend predeterminado actual de pi-crew es child-process, así que session.steer a mitad de turno aún no está disponible.",
 		"steer.cancelHint": "Usa team cancel runId={runId} si hay que interrumpir el agente.",
+		"team.run.created": "Ejecución de pi-crew creada {runId}.",
+		"team.run.completed": "Ejecución de pi-crew {status}: {runId} ({team})",
+		"team.run.allCompleted": "Todas las tareas se completaron con éxito.",
+		"team.run.tasksFailed": "{count} tarea(s) fallaron: {ids}. Considera reintentar.",
+		"team.unknownAction": "Acción desconocida: {action}",
 	},
 	fr: {
 		"agent.requiresPrompt": "Agent nécessite un prompt.",
@@ -71,6 +83,11 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"steer.unavailable":
 			"Le backend pi-crew par défaut actuel est child-process, donc session.steer en milieu de tour n'est pas encore disponible.",
 		"steer.cancelHint": "Utilisez team cancel runId={runId} si l'agent doit être interrompu.",
+		"team.run.created": "Exécution pi-crew créée {runId}.",
+		"team.run.completed": "Exécution pi-crew {status} : {runId} ({team})",
+		"team.run.allCompleted": "Toutes les tâches ont été effectuées avec succès.",
+		"team.run.tasksFailed": "{count} tâche(s) ont échoué : {ids}. Envisagez de réessayer.",
+		"team.unknownAction": "Action inconnue : {action}",
 	},
 	"pt-BR": {
 		"agent.requiresPrompt": "Agent requer prompt.",
@@ -92,6 +109,11 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"steer.unavailable":
 			"O backend padrão atual do pi-crew é child-process, então session.steer no meio do turno ainda não está disponível.",
 		"steer.cancelHint": "Use team cancel runId={runId} se o agente precisar ser interrompido.",
+		"team.run.created": "Execução do pi-crew criada {runId}.",
+		"team.run.completed": "Execução do pi-crew {status}: {runId} ({team})",
+		"team.run.allCompleted": "Todas as tarefas foram concluídas com sucesso.",
+		"team.run.tasksFailed": "{count} tarefa(s) falharam: {ids}. Considere tentar novamente.",
+		"team.unknownAction": "Ação desconhecida: {action}",
 	},
 };
 

package/src/observability/event-bus.ts

@@ -1,4 +1,4 @@
-import type { AgentProgress } from "../runtime/progress-tracker.ts";
+import type { AgentProgress } from "../runtime/output/progress-tracker.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
 export type CrewEventType = "agent:progress" | "agent:complete" | "agent:error" | "run:start" | "run:complete";

package/src/prompt/prompt-runtime.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { startChildBrokerClient } from "../runtime/crew-broker-child.ts";
+import { startChildBrokerClient } from "../runtime/broker/crew-broker-child.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 
@@ -362,7 +362,7 @@ export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
 	// already .unref()'d so it never blocks event-loop exit; errors are
 	// swallowed because teardown failures during shutdown are harmless.
 	pi.on("session_shutdown", () => {
-		void brokerHandle.close().catch(() => {});
+		void brokerHandle.close().catch(() => undefined);
 	});
 
 	// ── Prompt rewriting (existing) ────────────────────────────────────────

package/src/runtime/README.md

@@ -0,0 +1,35 @@
+# src/runtime/ — runtime cluster map
+
+This directory holds the team-run execution machinery. After the v0.9.x reorg, the largest
+clusters are extracted into subdirectories; the remaining files stay at the root.
+
+## Extracted subdirectories (navigable clusters)
+
+| Subdir | Phase | Cluster | Key files |
+|--------|-------|---------|-----------|
+| [`child-pi/`](./child-pi/) | B-1 | child Pi worker spawn/lifecycle/steering/transcript | `child-pi.ts`, `child-pi-spawn.ts`, `child-pi-kill.ts`, `child-pi-constants.ts`, `child-pi-steering.ts`, `child-pi-streams.ts`, `child-pi-transcript.ts`, `child-pi-pool.ts` |
+| [`broker/`](./broker/) | B-2 | crew broker server/client/auth (child-pi ↔ parent IPC) | `crew-broker.ts`, `crew-broker-client.ts`, `crew-broker-child.ts`, `crew-broker-tokens.ts`, `broker-issuer.ts` |
+| [`task-runner/`](./task-runner/) | (pre-existing) | per-task execution (pre-execution, child-executor) | `child-executor.ts`, `pre-execution.ts`, ... |
+| [`live-session/`](./live-session/) | 3 | live agent control/manager, session runtime, IRC, health, extension bridge | `live-session-runtime.ts`, `live-agent-manager.ts`, `live-agent-control.ts`, `live-control-realtime.ts`, `live-irc.ts`, `live-session-health.ts`, `live-extension-bridge.ts`, `intercom-bridge.ts` |
+| [`recovery/`](./recovery/) | 4 | crash recovery, retry, checkpoint | `crash-recovery.ts`, `crash-classification.ts`, `recovery-recipes.ts`, `overflow-recovery.ts`, `retry-executor.ts`, `retry-runner.ts`, `checkpoint.ts` |
+| [`scheduling/`](./scheduling/) | 5 | scheduler, concurrency, task-graph, batch-barrier, parallel utils | `scheduler.ts`, `semaphore.ts`, `concurrency.ts`, `task-graph.ts`, `task-graph-scheduler.ts`, `batch-barrier.ts`, `coalesce-tasks.ts`, `run-coalesced-task-group.ts`, `global-worker-cap.ts`, `parallel-research.ts`, `parallel-utils.ts` |
+| [`verification/`](./verification/) | 6a | verification gates, green-contract, post-checks, completion-guard | `verification-gates.ts`, `verification-integrity.ts`, `verification-worktree.ts`, `green-contract.ts`, `post-checks.ts`, `completion-guard.ts` |
+| [`model/`](./model/) | 6b | model fallback/resolver/scope, pi-args, runtime policy/resolver/warmup | `model-fallback.ts`, `model-resolver.ts`, `model-scope.ts`, `pi-args.ts`, `runtime-policy.ts`, `runtime-resolver.ts`, `runtime-warmup.ts` |
+| [`output/`](./output/) | 6c | streaming output, progress tracking, sidechain, result extraction | `streaming-output.ts`, `stream-preview.ts`, `output-validator.ts`, `pi-json-output.ts`, `tool-progress.ts`, `progress-event-coalescer.ts`, `progress-tracker.ts`, `result-extractor.ts`, `sidechain-output.ts` |
+| [`heartbeat/`](./heartbeat/) | 6d | heartbeat gradient/watcher, worker heartbeat/startup | `heartbeat-gradient.ts`, `heartbeat-watcher.ts`, `worker-heartbeat.ts`, `worker-startup.ts` |
+| [`process/`](./process/) | 6e | cancellation, process lifecycle, zombie scanner, stdio guard | `cancellation-token.ts`, `cancellation.ts`, `process-lifecycle.ts`, `zombie-scanner.ts`, `post-exit-stdio-guard.ts` |
+| [`goal-workflow/`](./goal-workflow/) | 6f | goal achievement/evaluation/loop, dynamic-workflow, adaptive plan | `goal-achievement.ts`, `goal-evaluator.ts`, `goal-loop-runner.ts`, `goal-state-store.ts`, `dynamic-workflow-context.ts`, `dynamic-workflow-runner.ts`, `adaptive-plan.ts`, `plan-templates.ts` |
+| [`compaction/`](./compaction/) | 6g | compaction pipeline, tool-output-pruner, important-line-classifier, compact-stages | `compact-pipeline.ts`, `compaction-summary.ts`, `tool-output-pruner.ts`, `important-line-classifier.ts`, [`compact-stages/`](./compaction/compact-stages/) |
+| [`custom-tools/`](./custom-tools/) | (pre-existing) | custom tool definitions | `irc-tool.ts`, `submit-result-tool.ts`, ... |
+| [`errors/`](./errors/) | (pre-existing) | error types | ... |
+
+## Remaining flat files at root (~77)
+
+- **team-runner** — `team-runner.ts` (the orchestrator) + `run-worker.ts`, `run-tracker.ts`
+- **chain/pipeline runners** — `chain-parser.ts`, `chain-runner.ts`, `pipeline-runner.ts`, `direct-run.ts`
+- **foreground/background runners** — `foreground-control.ts`, `foreground-watchdog.ts`, `async-runner.ts`, `background-runner.ts`
+- **crew agent** — `crew-agent-records.ts`, `crew-agent-runtime.ts`, `crew-hooks.ts`, `single-agent-compose.ts`
+- **observability** — `effectiveness.ts`, `agent-observability.ts`, `command-trace.ts`, `metric-parser.ts`
+- **misc** — `stale-reconciler.ts`, `parent-guard.ts`, `manifest-cache.ts`, `event-stream-bridge.ts`, `policy-engine.ts`, `role-permission.ts`, `workspace-lock.ts`, `workspace-tree.ts`, `session-*.ts`, ...
+
+See `docs/COVERAGE-ASSESSMENT-2026-08-01.md` § "Source reorganization" for the reorg history + remaining-cluster plan.

package/src/runtime/agent-control.ts

@@ -32,7 +32,7 @@ export function resolveCrewControlConfig(config: PiTeamsConfig | undefined): Cre
 		  })
 		| undefined;
 	return {
-		enabled: raw?.control?.enabled === false ? false : true,
+		enabled: raw?.control?.enabled !== false,
 		needsAttentionAfterMs: positiveInt(raw?.control?.needsAttentionAfterMs) ?? DEFAULT_NEEDS_ATTENTION_MS,
 		consecutiveFailureThreshold: positiveInt(raw?.control?.consecutiveFailureThreshold) ?? DEFAULT_CONSECUTIVE_FAILURE_THRESHOLD,
 		longRunningMinutes: positiveInt(raw?.control?.longRunningMinutes) ?? DEFAULT_LONG_RUNNING_MINUTES,

package/src/runtime/anchor-manager.ts

@@ -16,8 +16,6 @@ const MAX_HANDOFFS_PER_ANCHOR = 100;
  * - accumulateHandoff() adds handoffs to the anchor
  * - clearAnchor() finalizes and returns accumulated summaries
  * - getAnchorHandoff() retrieves accumulated summary without clearing
- *
- * @see docs/pi-boomerang-integration-plan.md
  */
 
 import type { HandoffSummary } from "./handoff-manager.ts";

package/src/runtime/async-runner.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { appendEventAsync } from "../state/event-log.ts";
+import { appendEventAsync } from "../state/event-log/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";

package/src/runtime/attention-events.ts

@@ -1,4 +1,4 @@
-import { appendEvent, type TeamEvent } from "../state/event-log.ts";
+import { appendEvent, type TeamEvent } from "../state/event-log/event-log.ts";
 import type { CrewAttentionEventData, TeamRunManifest } from "../state/types.ts";
 import { readJsonlTail } from "../utils/incremental-reader.ts";
 

package/src/runtime/auto-summarize.ts

@@ -5,8 +5,6 @@
  * - toggle() enables/disables auto-summarization
  * - shouldAutoSummarize() checks if task should auto-summarize
  * - Token and tool thresholds control when summarization triggers
- *
- * @see docs/pi-boomerang-integration-plan.md
  */
 
 import type { TaskPacket, TaskResult } from "./handoff-manager.ts";

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 });