pi-crew 0.5.0 → 0.5.2

package/src/extension/team-tool.ts

@@ -129,12 +129,15 @@ async function handleRun(
 import { waitForRun } from "../runtime/run-tracker.ts";
 import { normalizeSkillOverride } from "../runtime/skill-instructions.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { searchAgents, searchTeams } from "../utils/bm25-search.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
 import {
 	type CacheControlDeps,
 	invalidateSnapshot,
 } from "./team-tool/cache-control.ts";
 import { handleCancel, handleRetry } from "./team-tool/cancel.ts";
 import { handleDoctor } from "./team-tool/doctor.ts";
+import { handleExplain } from "./team-tool/explain.ts";
 import { handleHealthMonitor } from "./team-tool/health-monitor.ts";
 import {
 	handleArtifacts,
@@ -150,8 +153,21 @@ import {
 	handlePrune,
 	handleWorktrees,
 } from "./team-tool/lifecycle-actions.ts";
+import {
+	getCachedRun,
+	computeRunCacheKey,
+	getCacheStats,
+} from "../state/run-cache.ts";
+import {
+	loadRunGraph,
+	listRunGraphs,
+} from "../state/run-graph.ts";
+import { FileCheckpointStore } from "../runtime/checkpoint.ts";
+import { buildTeamOnboarding } from "./team-onboard.ts";
 import { handleParallel } from "./team-tool/parallel-dispatch.ts";
+import { handleSchedule, handleListScheduled } from "./team-tool/handle-schedule.ts";
 import { handlePlan } from "./team-tool/plan.ts";
+import { handleOrchestrate } from "./team-tool/orchestrate.ts";
 import { handleRespond } from "./team-tool/respond.ts";
 import { handleStatus } from "./team-tool/status.ts";
 
@@ -173,10 +189,12 @@ export {
 	handlePrune,
 	handleWorktrees,
 } from "./team-tool/lifecycle-actions.ts";
+export { handleSchedule } from "./team-tool/handle-schedule.ts";
 export { handlePlan } from "./team-tool/plan.ts";
 export { handleStatus } from "./team-tool/status.ts";
 export type { TeamToolDetails } from "./team-tool-types.ts";
 export { handleRun };
+export { handleOrchestrate } from "./team-tool/orchestrate.ts";
 
 export function handleList(
 	params: TeamToolParamsValue,
@@ -1075,6 +1093,8 @@ export async function handleTeamTool(
 			return await handleParallel(params, ctx);
 		case "plan":
 			return handlePlan(params, ctx);
+		case "orchestrate":
+			return handleOrchestrate(params, ctx);
 		case "resume":
 			return handleResume(params, ctx);
 		case "create":
@@ -1089,6 +1109,101 @@ export async function handleTeamTool(
 			return handleHealthMonitor(ctx, params);
 		case "wait":
 			return handleWait(params, ctx);
+		case "graph": {
+			if (params.runId) {
+				const graph = loadRunGraph(ctx.cwd, params.runId);
+				return result(
+					graph ? JSON.stringify(graph, null, 2) : "No graph found for this run.",
+					{ action: "graph", status: graph ? "ok" : "error" },
+					!graph,
+				);
+			}
+			const graphs = listRunGraphs(ctx.cwd);
+			return result(
+				graphs.length ? `Available graphs:\n${graphs.join("\n")}` : "No graphs available.",
+				{ action: "graph", status: "ok" },
+			);
+		}
+		case "search": {
+			const query = params.goal ?? params.task ?? "";
+			if (!query) {
+				return result("Search requires goal or task query.", { action: "search", status: "error" }, true);
+			}
+			try {
+				const [agentResults, teamResults] = await Promise.all([
+					searchAgents(query, { limit: 5 }),
+					searchTeams(query, { limit: 3 }),
+				]);
+				const lines: string[] = [];
+				if (teamResults.length) {
+					lines.push("## Teams");
+					for (const r of teamResults) {
+						lines.push(`- [${r.team.name}] score=${r.score.toFixed(2)}: ${r.team.description ?? "(no description)"}`);
+					}
+				}
+				if (agentResults.length) {
+					lines.push("## Agents");
+					for (const r of agentResults) {
+						lines.push(`- [${r.agent.name}] score=${r.score.toFixed(2)}: ${r.agent.description ?? "(no description)"}`);
+					}
+				}
+				return result(lines.length ? lines.join("\n") : "No results found.", { action: "search", status: "ok" });
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return result(`Search failed: ${msg}`, { action: "search", status: "error" }, true);
+			}
+		}
+		case "schedule":
+			return handleSchedule(params, ctx);
+		case "scheduled":
+			return handleListScheduled(params, ctx);
+		case "onboard": {
+			const team = params.team ?? "default";
+			const onboarding = buildTeamOnboarding(team, ctx.cwd);
+			return result(onboarding, { action: "onboard", status: "ok" });
+		}
+		case "explain": {
+			const explainResult = handleExplain(params, ctx.cwd);
+			return result(explainResult.text, { action: "explain", status: explainResult.isError ? "error" : "ok" }, explainResult.isError);
+		}
+		case "cache": {
+			if (params.goal) {
+				const key = computeRunCacheKey(
+					params.goal,
+					params.team ?? "default",
+					params.workflow ?? "default",
+					ctx.cwd,
+				);
+				const cached = getCachedRun(ctx.cwd, key);
+				if (cached) {
+					return result(
+						`Cached run found (${new Date(cached.cachedAt).toISOString()}): runId=${cached.runId}, status=${cached.status}, ${cached.tasks.length} tasks`,
+						{ action: "cache", status: "ok", data: { cacheKey: key, cacheHit: true, runId: cached.runId, status: cached.status, taskCount: cached.tasks.length } },
+					);
+				}
+				return result(`No cached result for key: ${key}`, { action: "cache", status: "ok", data: { cacheKey: key, cacheHit: false } });
+			}
+			const stats = getCacheStats(ctx.cwd);
+			return result(
+				`Cache stats: ${stats.entries} entries, ${stats.sizeBytes} bytes`,
+				{ action: "cache", status: "ok" },
+			);
+		}
+		case "checkpoint": {
+			if (!params.runId || !params.taskId) {
+				return result("Checkpoint requires runId and taskId.", { action: "checkpoint", status: "error" }, true);
+			}
+			const stateRoot = path.join(projectCrewRoot(ctx.cwd), "state", "runs", params.runId);
+			const store = new FileCheckpointStore(stateRoot);
+			const checkpoint = store.load(params.runId, params.taskId);
+			if (!checkpoint) {
+				return result("No checkpoint found.", { action: "checkpoint", status: "error" }, true);
+			}
+			return result(
+				`Checkpoint: step=${checkpoint.step}, progress=${checkpoint.progress}, savedAt=${new Date(checkpoint.savedAt).toISOString()}`,
+				{ action: "checkpoint", status: "ok", data: { checkpoint } },
+			);
+		}
 		default:
 			return result(
 				`Unknown action: ${action}`,

package/src/extension/tool-result.ts

@@ -1,4 +1,4 @@
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { TeamToolDetails } from "./team-tool-types.ts";
 
 export type PiTeamsToolResult<TDetails = TeamToolDetails> = AgentToolResult<TDetails> & { isError?: boolean };

package/src/i18n.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 type Params = Record<string, string | number>;
 

package/src/observability/event-to-metric.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "./metric-registry.ts";
 
 function recordValue(value: unknown): Record<string, unknown> {

package/src/prompt/prompt-runtime.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";

package/src/runtime/background-runner.ts

@@ -19,6 +19,7 @@ async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Pro
 	return _cachedExecuteTeamRun(...args);
 }
 import { resolveCrewRuntime, runtimeResolutionState } from "./runtime-resolver.ts";
+import { terminateActiveChildPiProcesses } from "./child-pi.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
 import { expandParallelResearchWorkflow } from "./parallel-research.ts";
 import { writeAsyncStartMarker } from "./async-marker.ts";
@@ -67,7 +68,7 @@ function argValue(name: string): string | undefined {
 	return process.argv[index + 1];
 }
 
-function startInterruptGuard(manifest: { runId: string; stateRoot: string; eventsPath: string }): () => void {
+function startInterruptGuard(manifest: { runId: string; stateRoot: string; eventsPath: string }, abortController: AbortController): () => void {
 	const controlPath = path.join(manifest.stateRoot, "foreground-control.json");
 	const interval = setInterval(() => {
 		try {
@@ -75,13 +76,21 @@ function startInterruptGuard(manifest: { runId: string; stateRoot: string; event
 			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: Array<{ type: string; acknowledged?: boolean }> };
 			const last = parsed.requests?.at(-1);
 			if (last?.type === "interrupt" && last?.acknowledged !== true) {
-				appendEvent(manifest.eventsPath, { type: "async.interrupt_detected", runId: manifest.runId, message: "Background runner detected foreground interrupt request — exiting." });
+				appendEvent(manifest.eventsPath, { type: "async.interrupt_detected", runId: manifest.runId, message: "Background runner detected foreground interrupt — killing child processes and exiting." });
+				// FIX: Terminate ALL child-pi processes IMMEDIATELY before exiting.
+				// Previously this was missing, causing orphaned child processes to run forever
+				// after the background-runner exited. terminateActiveChildPiProcesses sends
+				// SIGTERM then SIGKILL (after HARD_KILL_MS=3s) to every active child.
+				const killed = terminateActiveChildPiProcesses();
+				console.log(`[background-runner] interrupt: killed ${killed} child processes`);
+				// Also abort the run signal so executeTeamRun exits quickly via its signal check.
+				abortController.abort();
 				process.exit(130);
 			}
 		} catch {
 			/* ignore read/parse errors */
 		}
-	}, 3_000);
+	}, 500);  // FIX: Reduced from 3000ms to 500ms for faster cancel response
 	interval.unref();
 	return () => clearInterval(interval);
 }
@@ -238,8 +247,13 @@ async function main(): Promise<void> {
 	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
 	console.log(`[background-runner] DEBUG: async.started written, pid=${process.pid}`);
 	writeAsyncStartMarker(manifest, { pid: process.pid, startedAt: new Date().toISOString() });
+	// FIX: Create AbortController EARLY so interrupt guard can use it.
+	// abortController.signal flows through: executeTeamRun → runTeamTask → runChildPi.
+	// When interrupt guard detects cancel, abortController.abort() fires the abort
+	// handler in runChildPi which kills child processes immediately.
+	const abortController = new AbortController();
 	const stopHeartbeat = startHeartbeat(manifest.stateRoot, manifest.eventsPath, manifest.runId);
-	const stopInterruptGuard = startInterruptGuard(manifest);
+	const stopInterruptGuard = startInterruptGuard(manifest, abortController);
 	console.log(`[background-runner] DEBUG: heartbeat+interrupt guard started`);
 	// BUG #17: Keep-alive interval prevents event loop from exiting during
 	// jiti compilation. Pure empty interval (no I/O to avoid io_uring issues).
@@ -278,10 +292,13 @@ async function main(): Promise<void> {
 		// BUG #17: Keep-alive interval (NOT unref'd) prevents event loop from exiting
 		// during jiti compilation of team-runner.ts. Without this, the event loop
 		// can drain when import() blocks, causing the process to exit prematurely.
+		// NOTE: abortController is already created above (before heartbeat/interrupt guard start)
+		// so it is available here and its signal is passed through to executeTeamRun → child-pi.
+
 		console.log(`[background-runner] DEBUG: calling executeTeamRun`);
 		let result;
 		try {
-			result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: runConfig.limits, runtime, runtimeConfig: runConfig.runtime, skillOverride: manifest.skillOverride, reliability: runConfig.reliability, workspaceId: manifest.ownerSessionId ?? manifest.cwd });
+			result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: runConfig.limits, runtime, runtimeConfig: runConfig.runtime, skillOverride: manifest.skillOverride, reliability: runConfig.reliability, workspaceId: manifest.ownerSessionId ?? manifest.cwd, signal: abortController.signal });
 			console.log(`[background-runner] DEBUG: executeTeamRun returned, status=${result.manifest.status}`);
 		} catch (execError) {
 			console.log(`[background-runner] DEBUG: executeTeamRun THREW: ${execError instanceof Error ? execError.message : String(execError)}`);
@@ -314,6 +331,11 @@ async function main(): Promise<void> {
 		stopParentGuard();
 		stopHeartbeat();
 		clearInterval(keepAlive);
+		// FIX: Always kill child processes on exit. executeTeamRun's terminateLiveAgentsForRun
+		// only handles live-session agents, not child-pi processes. Without this, child-pi
+		// processes can become orphaned if executeTeamRun throws before completing.
+		const killed = terminateActiveChildPiProcesses();
+		console.log(`[background-runner] finally: killed ${killed} child processes`);
 	}
 }
 

package/src/runtime/crash-recovery.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { appendEvent, scanSequence } from "../state/event-log.ts";

package/src/runtime/crew-hooks.ts

@@ -0,0 +1,240 @@
+/**
+ * Crew Hook System — a hook-based observation system for pi-crew runtime.
+ *
+ * Provides a reliable, fire-and-forget event system for observing crew lifecycle events.
+ * Hooks are executed synchronously without blocking the emitter.
+ *
+ * @example
+ * ```typescript
+ * import { crewHooks } from './runtime/crew-hooks.ts';
+ *
+ * // Register a hook
+ * const myHook = (event) => {
+ *   console.log(`Event: ${event.type}`, event);
+ * };
+ * crewHooks.register('task_started', myHook);
+ *
+ * // Emit an event
+ * crewHooks.emit({ type: 'task_started', timestamp: new Date().toISOString(), runId: 'run-123', taskId: 'task-1' });
+ *
+ * // Unregister when done
+ * crewHooks.unregister('task_started', myHook);
+ * ```
+ */
+
+/** Valid hook event types in the crew lifecycle. */
+export type CrewHookEventType =
+	| 'task_started'
+	| 'task_completed'
+	| 'task_failed'
+	| 'run_completed'
+	| 'run_failed';
+
+/**
+ * A hook event emitted by the crew runtime.
+ */
+export interface CrewHookEvent {
+	/** The type of event being emitted. */
+	type: CrewHookEventType;
+	/** ISO timestamp of when the event occurred. */
+	timestamp: string;
+	/** The unique identifier of the run that generated this event. */
+	runId: string;
+	/** Optional task identifier (present for task-scoped events). */
+	taskId?: string;
+	/** Optional additional event data. */
+	data?: Record<string, unknown>;
+}
+
+/**
+ * A hook function that can be registered to receive crew events.
+ * May be synchronous or return a Promise (async hooks are fire-and-forget).
+ */
+export type CrewHook = (event: CrewHookEvent) => void | Promise<void>;
+
+/**
+ * Type guard to check if a value is a valid CrewHookEventType.
+ */
+export function isValidEventType(type: string): type is CrewHookEventType {
+	return (
+		type === 'task_started' ||
+		type === 'task_completed' ||
+		type === 'task_failed' ||
+		type === 'run_completed' ||
+		type === 'run_failed'
+	);
+}
+
+/**
+ * Type guard to check if an object is a valid CrewHookEvent.
+ */
+export function isHookEvent(obj: unknown): obj is CrewHookEvent {
+	if (typeof obj !== 'object' || obj === null) return false;
+	const event = obj as Record<string, unknown>;
+	return (
+		typeof event.type === 'string' &&
+		isValidEventType(event.type) &&
+		typeof event.timestamp === 'string' &&
+		typeof event.runId === 'string' &&
+		(event.taskId === undefined || typeof event.taskId === 'string') &&
+		(event.data === undefined || typeof event.data === 'object')
+	);
+}
+
+/**
+ * Registry for managing and emitting crew lifecycle hooks.
+ *
+ * Hooks are stored in Sets for efficient insertion, deletion, and iteration.
+ * The emit() method executes all registered hooks synchronously without awaiting
+ * async completions, ensuring 100% reliable event firing without blocking.
+ */
+export class HookRegistry {
+	private readonly hooks: Map<CrewHookEventType, Set<CrewHook>>;
+
+	constructor() {
+		this.hooks = new Map();
+		// Initialize with empty Sets for all event types
+		const eventTypes: CrewHookEventType[] = [
+			'task_started',
+			'task_completed',
+			'task_failed',
+			'run_completed',
+			'run_failed',
+		];
+		for (const type of eventTypes) {
+			this.hooks.set(type, new Set());
+		}
+	}
+
+	/**
+	 * Register a hook to be called when the specified event type is emitted.
+	 *
+	 * @param eventType - The type of event to listen for
+	 * @param hook - The hook function to register
+	 */
+	register(eventType: CrewHookEventType, hook: CrewHook): void {
+		const hooksForType = this.hooks.get(eventType);
+		if (hooksForType) {
+			hooksForType.add(hook);
+		}
+	}
+
+	/**
+	 * Unregister a previously registered hook.
+	 *
+	 * @param eventType - The type of event the hook was registered for
+	 * @param hook - The hook function to remove
+	 */
+	unregister(eventType: CrewHookEventType, hook: CrewHook): void {
+		const hooksForType = this.hooks.get(eventType);
+		if (hooksForType) {
+			hooksForType.delete(hook);
+		}
+	}
+
+	/**
+	 * Emit an event to all registered hooks for that event type.
+	 *
+	 * This method executes all hooks synchronously and does not await async hooks.
+	 * Errors thrown by hooks are caught and logged but do not prevent other hooks
+	 * from executing or block the caller.
+	 *
+	 * @param event - The event to emit
+	 */
+	emit(event: CrewHookEvent): void {
+		// Validate event type using type guard
+		if (!isValidEventType(event.type)) {
+			console.warn(`[crew-hooks] Unknown event type: ${event.type}`);
+			return;
+		}
+
+		const hooksForType = this.hooks.get(event.type);
+		if (!hooksForType || hooksForType.size === 0) {
+			return;
+		}
+
+		// Execute all hooks - fire-and-forget pattern
+		// We iterate over a snapshot to allow safe modification during iteration
+		const hooksSnapshot = Array.from(hooksForType);
+		for (const hook of hooksSnapshot) {
+			try {
+				const result = hook(event);
+				// If the hook returns a Promise, we intentionally do NOT await it.
+				// This is the "fire-and-forget" pattern - async hooks run in background.
+				if (result instanceof Promise) {
+					// Attach a silent catch to prevent unhandled rejection warnings
+					result.catch((err) => {
+						console.error(`[crew-hooks] Async hook error for ${event.type}:`, err);
+					});
+				}
+			} catch (err) {
+				// Catch synchronous errors but don't let them block other hooks
+				console.error(`[crew-hooks] Hook error for ${event.type}:`, err);
+			}
+		}
+	}
+
+	/**
+	 * Get all hooks registered for a specific event type.
+	 *
+	 * Returns a snapshot of the current hooks. The returned array is a new copy,
+	 * so modifications to it won't affect the registry.
+	 *
+	 * @param eventType - The event type to query
+	 * @returns Array of registered hooks (may be empty)
+	 */
+	hooksFor(eventType: CrewHookEventType): CrewHook[] {
+		const hooksForType = this.hooks.get(eventType);
+		if (!hooksForType) {
+			return [];
+		}
+		return Array.from(hooksForType);
+	}
+
+	/**
+	 * Get the count of hooks registered for a specific event type.
+	 *
+	 * @param eventType - The event type to query
+	 * @returns Number of registered hooks
+	 */
+	count(eventType: CrewHookEventType): number {
+		const hooksForType = this.hooks.get(eventType);
+		return hooksForType?.size ?? 0;
+	}
+
+	/**
+	 * Remove all hooks for a specific event type.
+	 *
+	 * @param eventType - The event type to clear
+	 */
+	clear(eventType: CrewHookEventType): void {
+		const hooksForType = this.hooks.get(eventType);
+		if (hooksForType) {
+			hooksForType.clear();
+		}
+	}
+
+	/**
+	 * Remove all registered hooks across all event types.
+	 */
+	clearAll(): void {
+		for (const hooksForType of this.hooks.values()) {
+			hooksForType.clear();
+		}
+	}
+}
+
+/**
+ * Global singleton instance of HookRegistry for use throughout pi-crew.
+ *
+ * @example
+ * ```typescript
+ * import { crewHooks } from './runtime/crew-hooks.ts';
+ *
+ * // Simple logging hook
+ * crewHooks.register('task_completed', (event) => {
+ *   console.log(`Task ${event.taskId} completed in run ${event.runId}`);
+ * });
+ * ```
+ */
+export const crewHooks = new HookRegistry();

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

@@ -12,7 +12,7 @@
  * for routing messages between in-process workers.
  */
 
-import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@sinclair/typebox";
 import { listLiveAgents, sendIrcMessage, broadcastIrcMessage } from "../live-agent-manager.ts";
 import type { IrcMessage } from "../live-irc.ts";

package/src/runtime/custom-tools/submit-result-tool.ts

@@ -9,7 +9,7 @@
  * and TypeBox schemas for validation.
  */
 
-import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "@sinclair/typebox";
 import type { YieldResult } from "../yield-handler.ts";
 

package/src/runtime/diagnostic-export.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+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 * as fs from "node:fs";
@@ -10,6 +10,7 @@ import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { summarizeHeartbeats, type HeartbeatSummary } from "../ui/heartbeat-aggregator.ts";
 import type { RunUiSnapshot } from "../ui/snapshot-types.ts";
 import { redactSecrets } from "../utils/redaction.ts";
+import { buildRecoveryLedger, type RecoveryLedgerEntry } from "./recovery-recipes.ts";
 export { redactSecrets } from "../utils/redaction.ts";
 
 export interface DiagnosticReport {
@@ -23,6 +24,17 @@ export interface DiagnosticReport {
 	agents: unknown[];
 	envRedacted: Record<string, string>;
 	metricsSnapshot?: MetricSnapshot[];
+	// Layer 8: task diagnostics
+	taskDiagnostics: Record<string, Record<string, unknown>>;
+	// Layer 9: terminal evidence
+	terminalEvidence: Record<string, TeamTaskState["terminalEvidence"]>;
+	// Layer 10: model attempts and routing
+	modelAttempts: { taskId: string; attempts: TeamTaskState["modelAttempts"]; routing: TeamTaskState["modelRouting"] }[];
+	// Layer 11: pending mailbox
+	pendingMailbox: { taskId: string; pendingSteers: TeamTaskState["pendingSteers"] }[];
+	runMailboxUnread: RunUiSnapshot["mailbox"];
+	// Layer 12: recovery ledger
+	recoveryLedger: RecoveryLedgerEntry[];
 }
 
 const SECRET_KEY_PATTERN = /(token|key|password|secret|credential|auth)/i;
@@ -69,6 +81,24 @@ export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId
 	const safeTimestamp = exportedAt.replace(/[:.]/g, "-");
 	const recentEvents = readEvents(loaded.manifest.eventsPath).slice(-200);
 	const metricsSnapshot = options.registry?.snapshot();
+	const taskDiagnostics: Record<string, Record<string, unknown>> = {};
+	const terminalEvidence: Record<string, TeamTaskState["terminalEvidence"]> = {};
+	const modelAttempts: { taskId: string; attempts: TeamTaskState["modelAttempts"]; routing: TeamTaskState["modelRouting"] }[] = [];
+	const pendingMailbox: { taskId: string; pendingSteers: TeamTaskState["pendingSteers"] }[] = [];
+	for (const task of loaded.tasks) {
+		if (task.diagnostics) taskDiagnostics[task.id] = task.diagnostics;
+		if (task.terminalEvidence) terminalEvidence[task.id] = task.terminalEvidence;
+		if (task.modelAttempts || task.modelRouting) {
+			modelAttempts.push({ taskId: task.id, attempts: task.modelAttempts, routing: task.modelRouting });
+		}
+		if (task.pendingSteers) {
+			pendingMailbox.push({ taskId: task.id, pendingSteers: task.pendingSteers });
+		}
+	}
+	const recoveryLedger = loaded.manifest.policyDecisions
+		? buildRecoveryLedger(loaded.manifest.policyDecisions).entries
+		: [];
+	const snapshot = buildSnapshot(loaded.manifest, loaded.tasks);
 	const report: DiagnosticReport = {
 		...(metricsSnapshot ? { schemaVersion: 2 } : {}),
 		runId,
@@ -76,10 +106,16 @@ export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId
 		manifest: redactSecrets(loaded.manifest) as TeamRunManifest,
 		tasks: redactSecrets(loaded.tasks) as TeamTaskState[],
 		recentEvents: redactSecrets(recentEvents) as TeamEvent[],
-		heartbeat: summarizeHeartbeats(buildSnapshot(loaded.manifest, loaded.tasks)),
+		heartbeat: summarizeHeartbeats(snapshot),
 		agents: redactSecrets(readCrewAgents(loaded.manifest)) as unknown[],
 		envRedacted: envRedacted(),
 		...(metricsSnapshot ? { metricsSnapshot: redactSecrets(metricsSnapshot) as MetricSnapshot[] } : {}),
+		taskDiagnostics,
+		terminalEvidence,
+		modelAttempts,
+		pendingMailbox,
+		runMailboxUnread: snapshot.mailbox,
+		recoveryLedger,
 	};
 	const dir = path.join(loaded.manifest.artifactsRoot, "diagnostic");
 	fs.mkdirSync(dir, { recursive: true });

package/src/runtime/foreground-watchdog.ts

@@ -11,7 +11,7 @@
  *    is automatically notified — no manual sleep+check needed.
  * 3. Cleans up after itself when the run completes or the session ends.
  */
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadRunManifestById } from "../state/state-store.ts";
 import { readCrewAgents } from "./crew-agent-records.ts";
 import { isActiveRunStatus, isLikelyOrphanedActiveRun } from "./process-status.ts";

package/src/runtime/live-session-runtime.ts

@@ -336,7 +336,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 	const availability = await isLiveSessionRuntimeAvailable();
 	if (!availability.available) return { available: true, exitCode: 1, stdout: "", stderr: availability.reason ?? "Live-session runtime unavailable.", jsonEvents: 0, error: availability.reason };
 	// LAZY: optional peer dependency — only loaded when live-session runtime is chosen.
-	const mod = await import("@mariozechner/pi-coding-agent") as LiveSessionModule;
+	const mod = await import("@earendil-works/pi-coding-agent") as unknown as LiveSessionModule;
 	if (typeof mod.createAgentSession !== "function") return { available: true, exitCode: 1, stdout: "", stderr: "createAgentSession export is unavailable.", jsonEvents: 0, error: "createAgentSession export is unavailable." };
 	let session: LiveSessionLike | undefined;
 	let unsubscribe: (() => void) | undefined;

package/src/runtime/mcp-proxy.ts

@@ -16,7 +16,7 @@
  * when proxying from the parent.
  */
 
-import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type Static, type TSchema } from "@sinclair/typebox";
 
 export interface McpProxyConfig {