pi-crew 0.5.1 → 0.5.2

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 {

package/src/runtime/pi-spawn.ts

@@ -8,6 +8,11 @@ export interface PiSpawnCommand {
 	args: string[];
 }
 
+const PI_PACKAGE_NAMES = [
+	"@earendil-works/pi-coding-agent",
+	"@mariozechner/pi-coding-agent",
+];
+
 function isRunnableNodeScript(filePath: string): boolean {
 	return fs.existsSync(filePath) && /\.(?:mjs|cjs|js)$/i.test(filePath);
 }
@@ -26,6 +31,7 @@ function isWithinAllowedPrefixes(resolvedPath: string): boolean {
 	try {
 		const execDir = path.dirname(fs.realpathSync.native(process.execPath));
 		allowedPrefixes.push(execDir.toLowerCase());
+		allowedPrefixes.push(path.join(path.dirname(execDir), "lib", "node_modules").toLowerCase());
 	} catch { /* ignore */ }
 
 	// npm global bin via APPDATA
@@ -33,6 +39,12 @@ function isWithinAllowedPrefixes(resolvedPath: string): boolean {
 		allowedPrefixes.push(path.join(process.env.APPDATA, "npm").toLowerCase());
 	}
 
+	const npmPrefix = process.env.npm_config_prefix ?? process.env.NPM_CONFIG_PREFIX;
+	if (npmPrefix) {
+		allowedPrefixes.push(path.resolve(npmPrefix).toLowerCase());
+		allowedPrefixes.push(path.join(path.resolve(npmPrefix), "lib", "node_modules").toLowerCase());
+	}
+
 	// Project-local node_modules/.bin
 	try {
 		const projectBin = path.resolve("node_modules", ".bin");
@@ -62,7 +74,7 @@ function resolvePiPackageRoot(): string | undefined {
 		while (dir !== path.dirname(dir)) {
 			try {
 				const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8")) as { name?: string };
-				if (pkg.name === "@mariozechner/pi-coding-agent") return dir;
+				if (pkg.name && PI_PACKAGE_NAMES.includes(pkg.name)) return dir;
 			} catch {
 				// Continue walking upward.
 			}
@@ -92,12 +104,15 @@ function findPiPackageJsonFrom(startDir: string): string | undefined {
 		const direct = path.join(dir, "package.json");
 		try {
 			const pkg = JSON.parse(fs.readFileSync(direct, "utf-8")) as { name?: string };
-			if (pkg.name === "@mariozechner/pi-coding-agent") return direct;
+			if (pkg.name && PI_PACKAGE_NAMES.includes(pkg.name)) return direct;
 		} catch {
 			// Continue searching upward and in node_modules.
 		}
-		const dependency = path.join(dir, "node_modules", "@mariozechner", "pi-coding-agent", "package.json");
-		if (fs.existsSync(dependency)) return dependency;
+		for (const pkgName of PI_PACKAGE_NAMES) {
+			const [scope, name] = pkgName.replace("@", "").split("/");
+			const dependency = path.join(dir, "node_modules", `@${scope}`, name, "package.json");
+			if (fs.existsSync(dependency)) return dependency;
+		}
 		dir = path.dirname(dir);
 	}
 	return undefined;
@@ -112,6 +127,7 @@ function resolvePiCliScript(): string | undefined {
 
 	const roots = [
 		resolvePiPackageRoot(),
+		process.env.APPDATA ? path.join(process.env.APPDATA, "npm", "node_modules", "@earendil-works", "pi-coding-agent") : undefined,
 		process.env.APPDATA ? path.join(process.env.APPDATA, "npm", "node_modules", "@mariozechner", "pi-coding-agent") : undefined,
 		path.dirname(fileURLToPath(import.meta.url)),
 		process.cwd(),

package/src/runtime/process-status.ts

@@ -77,8 +77,21 @@ export function isLikelyOrphanedActiveRun(run: TeamRunManifest, agents: CrewAgen
 }
 
 function hasDurableActiveAgentEvidence(agent: CrewAgentRecord): boolean {
-	if (agent.status !== "running" && agent.status !== "queued") return false;
-	return Boolean(agent.statusPath || agent.eventsPath || agent.outputPath || agent.progress || agent.toolUses || agent.jsonEvents);
+	if (agent.status === "running") {
+		// Running agents are actively executing — trust them.
+		// Activity evidence is only required for queued agents (zombie prevention).
+		return true;
+	}
+	if (agent.status === "queued") {
+		// Queued agents need actual activity evidence to distinguish from zombies:
+		// spawned-but-never-executed agents should not appear as active.
+		return Boolean(
+			(agent.progress && (agent.progress.toolCount > 0 || agent.progress.recentOutput.length > 0)) ||
+			(agent.jsonEvents && agent.jsonEvents > 0) ||
+			(agent.toolUses && agent.toolUses > 0),
+		);
+	}
+	return false;
 }
 
 export function hasStaleAsyncProcess(run: TeamRunManifest, now = Date.now()): boolean {

package/src/runtime/runtime-resolver.ts

@@ -38,7 +38,7 @@ export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJ
 	const probe = async (): Promise<{ available: boolean; reason?: string }> => {
 		try {
 			// LAZY: optional peer dependency — probe at runtime to avoid hard dependency.
-			const mod = await import("@mariozechner/pi-coding-agent");
+			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");

package/src/runtime/session-resources.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { logInternalError } from "../utils/internal-error.ts";
 
 /**

package/src/runtime/task-runner.ts

@@ -40,6 +40,7 @@ import { executeHook, appendHookEvent } from "../hooks/registry.ts";
 import { createVerificationEvidence } from "./green-contract.ts";
 import { createStartupEvidence } from "./worker-startup.ts";
 import { permissionForRole } from "./role-permission.ts";
+import { crewHooks } from "./crew-hooks.ts";
 import {
 	collectDependencyOutputContext,
 	renderDependencyOutputContext,
@@ -401,6 +402,7 @@ export async function runTeamTask(
 					modelAttempts: [...modelAttempts, pendingAttempt],
 				};
 				tasks = updateTask(tasks, task);
+				crewHooks.emit({ type: "task_started", timestamp: new Date().toISOString(), runId: manifest.runId, taskId: task.id, data: { role: task.role, model: model ?? "default" } });
 				upsertCrewAgent(
 					manifest,
 					recordFromTask(manifest, task, "child-process"),
@@ -808,7 +810,22 @@ export async function runTeamTask(
 			exitCode = live.exitCode;
 			error = live.error;
 			parsedOutput = live.parsedOutput;
-			resultArtifact = live.resultArtifact;
+			// Bug #21 fix: live-session may not produce structured output via submit_result,
+			// leaving finalText empty. Re-write resultArtifact with parsedOutput.finalText
+			// so downstream tasks that depend on this task can read meaningful output.
+			const liveText = cleanResultText(parsedOutput?.finalText);
+			if (liveText) {
+				// Re-write the artifact with the captured stdout — this is the content
+				// downstream tasks will read via task.resultArtifact.path.
+				resultArtifact = writeArtifact(manifest.artifactsRoot, {
+					kind: "result",
+					relativePath: `results/${task.id}.txt`,
+					content: liveText,
+					producer: task.id,
+				});
+			} else {
+				resultArtifact = live.resultArtifact;
+			}
 			logArtifact = live.logArtifact;
 			transcriptArtifact = live.transcriptArtifact;
 		} else {
@@ -855,6 +872,8 @@ export async function runTeamTask(
 					data: {
 						activityState: "needs_attention",
 						reason: "no_yield",
+						// Bug #21 fix: include result path so downstream tasks can read the output
+						resultPath: resultArtifact?.path,
 					},
 				});
 			}
@@ -1004,6 +1023,17 @@ export async function runTeamTask(
 			...(transcriptArtifact ? { transcriptArtifact } : {}),
 		};
 		tasks = updateTask(tasks, task);
+
+		// Emit task completion hooks (100% reliable, fire-and-forget)
+		const hookType = task.status === "completed" ? "task_completed" : task.status === "failed" ? "task_failed" : "task_started";
+		crewHooks.emit({
+			type: hookType,
+			timestamp: task.finishedAt ?? new Date().toISOString(),
+			runId: manifest.runId,
+			taskId: task.id,
+			data: { status: task.status, role: task.role, error: task.error, exitCode: task.exitCode, usage: task.usage },
+		});
+
 		const packetArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "metadata",
 			relativePath: `metadata/${task.id}.task-packet.json`,

package/src/runtime/team-runner.ts

@@ -28,6 +28,7 @@ import { executeWithRetry, DEFAULT_RETRY_POLICY, type RetryPolicy } from "./retr
 import { appendDeadletter } from "./deadletter.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { childCorrelation, withCorrelation } from "../observability/correlation.ts";
+import { crewHooks } from "./crew-hooks.ts";
 import { resolveBatchConcurrency } from "./concurrency.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { permissionForRole } from "./role-permission.ts";
@@ -279,6 +280,10 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		cleanupUsage();
 		// Terminate live agents for this run — agents are done when the run ends.
 		void terminateLiveAgentsForRun(manifest.runId, "completed", appendEvent, manifest.eventsPath).catch(() => {});
+
+		// Emit run completion hook (100% reliable, fire-and-forget)
+		crewHooks.emit({ type: "run_completed", timestamp: new Date().toISOString(), runId: manifest.runId, data: { status: result.manifest.status, taskCount: result.tasks.length } });
+
 		return result;
 	} catch (error) {
 		// P1: Catch unhandled errors — ensure manifest/tasks/agents are terminal so they don't stay "running" forever.
@@ -310,6 +315,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		}
 		const result = { manifest, tasks };
 		rejectRunPromise(manifest.runId, error instanceof Error ? error : new Error(message));
+		crewHooks.emit({ type: "run_failed", timestamp: new Date().toISOString(), runId: manifest.runId, data: { status: manifest.status, error: message } });
 		cleanupUsage();
 		return result;
 	}