pi-crew 0.2.20 → 0.2.21

package/docs/usage.md

@@ -48,6 +48,20 @@ Supported fields:
     "showModel": true,
     "showTokens": true,
     "showTools": true
+  },
+  "limits": {
+    "maxConcurrentWorkers": 4
+  },
+  "reliability": {
+    "autoRetry": false,
+    "autoRecover": false,
+    "deadletterThreshold": 3,
+    "retryPolicy": {
+      "maxAttempts": 3,
+      "initialDelayMs": 1000,
+      "backoffMultiplier": 2,
+      "maxDelayMs": 30000
+    }
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",
@@ -80,9 +80,11 @@
     "@sinclair/typebox": "^0.34.49",
     "cli-highlight": "^2.1.11",
     "diff": "^5.2.0",
-    "jiti": "^2.6.1"
+    "jiti": "^2.6.1",
+    "typebox": "^1.1.38"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
     "@mariozechner/pi-agent-core": "^0.65.0",
     "@mariozechner/pi-ai": "^0.65.0",
     "@mariozechner/pi-coding-agent": "^0.65.0",

package/src/adapters/export-util.ts

@@ -80,18 +80,24 @@ export type ExportableResource =
 	| { kind: "skill"; config: SkillDescriptor };
 
 export function resourcesToExportContent(resources: ExportableResource[]): ExportContent[] {
-	return resources.map((resource): ExportContent => {
+	const results: ExportContent[] = [];
+	for (const resource of resources) {
 		switch (resource.kind) {
 			case "agent":
-				return agentToExportContent(resource.config);
+				results.push(agentToExportContent(resource.config));
+				break;
 			case "team":
-				return teamToExportContent(resource.config);
+				results.push(teamToExportContent(resource.config));
+				break;
 			case "workflow":
-				return workflowToExportContent(resource.config);
+				results.push(workflowToExportContent(resource.config));
+				break;
 			case "skill":
-				return skillToExportContent(resource.config);
+				results.push(skillToExportContent(resource.config));
+				break;
 		}
-	});
+	}
+	return results;
 }
 
 export interface ToolExportResult {

package/src/agents/agent-config.ts

@@ -33,6 +33,8 @@ export interface AgentConfig {
 	contextMode?: "fresh" | "fork";
 	/** Maximum turns for this agent. Overrides runtime config if set. */
 	maxTurns?: number;
+	/** Tools to explicitly forbid for this agent. Takes precedence over allowedTools. */
+	disallowedTools?: string[];
 	disabled?: boolean;
 	override?: { source: "config"; path: string };
 }

package/src/config/defaults.ts

@@ -40,7 +40,7 @@ export const DEFAULT_CONCURRENCY = {
 };
 
 export const DEFAULT_EVENT_LOG = {
-	terminalEventTypes: ["run.blocked", "run.completed", "run.failed", "run.cancelled", "task.completed", "task.failed", "task.skipped", "task.cancelled"],
+	terminalEventTypes: ["run.blocked", "run.completed", "run.failed", "run.cancelled", "task.completed", "task.failed", "task.skipped", "task.cancelled", "task.needs_attention"],
 };
 
 export const DEFAULT_ARTIFACT_CLEANUP = {

package/src/config/markers.ts

@@ -85,29 +85,34 @@ function renderBlocks(blocks: GuidanceBlock[]): string {
  * Parse the inner marker content and return the set of block IDs present.
  */
 export function extractGuidanceIds(content: string): string[] {
-  const ids: string[] = [];
-  const regex = /<!-- PI-CREW:BLOCK:([^\s>]+) -->/g;
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(content)) !== null) {
-    ids.push(match[1]!);
-  }
-  return ids;
+	const ids: string[] = [];
+	const regex = /<!-- PI-CREW:BLOCK:([^\s>]+) -->/g;
+	let match: RegExpExecArray | null = regex.exec(content);
+	while (match !== null) {
+		const captured = match[1];
+		if (captured !== undefined) ids.push(captured);
+		match = regex.exec(content);
+	}
+	return ids;
 }
 
 /**
  * Parse existing blocks from marker content into a map of id → GuidanceBlock.
  */
 function parseExistingBlocks(inner: string): Map<string, GuidanceBlock> {
-  const map = new Map<string, GuidanceBlock>();
-  const regex =
-    /<!-- PI-CREW:BLOCK:([^\s>]+) -->\n([\s\S]*?)<!-- PI-CREW:\/BLOCK:\1 -->/g;
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(inner)) !== null) {
-    const id = match[1]!;
-    const content = match[2]!;
-    map.set(id, { id, content: content.replace(/\n$/, "") });
-  }
-  return map;
+	const map = new Map<string, GuidanceBlock>();
+	const regex =
+		/<!-- PI-CREW:BLOCK:([^\s>]+) -->\n([\s\S]*?)<!-- PI-CREW:\/BLOCK:\1 -->/g;
+	let match: RegExpExecArray | null = regex.exec(inner);
+	while (match !== null) {
+		const id = match[1];
+		const blockContent = match[2];
+		if (id !== undefined && blockContent !== undefined) {
+			map.set(id, { id, content: blockContent.replace(/\n$/, "") });
+		}
+		match = regex.exec(inner);
+	}
+	return map;
 }
 
 /**

package/src/config/resilient-parser.ts

@@ -3,7 +3,7 @@
  */
 
 import { PiTeamsConfigSchema } from "../schema/config-schema.ts";
-import { type TSchema } from "@sinclair/typebox";
+import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import { suggestConfigKey } from "./suggestions.ts";
 import {

package/src/extension/async-notifier.ts

@@ -106,8 +106,10 @@ export function startAsyncRunNotifier(ctx: ExtensionContext, state: AsyncNotifie
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			if (message.includes("stale") || message.includes("session replacement") || message.includes("old ctx")) {
-				console.error(`[pi-crew] async notifier stale ctx detected; stopping notifier.`);
-				try { stopAsyncRunNotifier(state); } catch { /* ignore */ }
+				// Don't stop the interval — session_start will create a new notifier
+				// with the refreshed ctx. The isCurrent guard will make this old
+				// notifier dormant once sessionGeneration increments.
+				// Stopping here creates a race: old notifier dies before new one starts.
 				return;
 			}
 			console.error(`[pi-crew] async notifier error: ${message}`);

package/src/extension/management.ts

@@ -170,6 +170,24 @@ function findReferences(ctx: ManagementContext, resource: "agent" | "team" | "wo
 	return refs;
 }
 
+function escapeRegex(str: string): string {
+	return str.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+}
+
+function walkTsFiles(dir: string): string[] {
+	const results: string[] = [];
+	if (!fs.existsSync(dir)) return results;
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			results.push(...walkTsFiles(fullPath));
+		} else if (entry.name.endsWith(".ts") || entry.name.endsWith(".md")) {
+			results.push(fullPath);
+		}
+	}
+	return results;
+}
+
 function updateReferencesForRename(ctx: ManagementContext, resource: "agent" | "team" | "workflow", oldName: string, newName: string, scope: MutableSource, dryRun: boolean): string[] {
 	if (oldName === newName) return [];
 	if (resource !== "agent" && resource !== "workflow") return [];
@@ -193,6 +211,40 @@ function updateReferencesForRename(ctx: ManagementContext, resource: "agent" | "
 			fs.writeFileSync(team.filePath, serializeTeam(nextTeam), "utf-8");
 		}
 	}
+	// L12 fix: also update workflow step role references when renaming agents.
+	// Workflow files use `role:` to reference agent roles, not agent names.
+	for (const workflow of allWorkflows(discoverWorkflows(ctx.cwd)).filter((w) => w.source === scope)) {
+		let updated = false;
+		const newSteps = workflow.steps.map((step) => {
+			if (step.role === oldName) {
+				updated = true;
+				return { ...step, role: newName };
+			}
+			return step;
+		});
+		if (!updated) continue;
+		changed.push(workflow.filePath);
+		if (!dryRun) {
+			backupFile(workflow.filePath);
+			fs.writeFileSync(workflow.filePath, serializeWorkflow({ ...workflow, steps: newSteps }), "utf-8");
+		}
+	}
+	// L12 fix: update agent references in test fixtures.
+	const testDir = scope === "user" ? path.join(ctx.cwd, ".crew", "test") : path.join(ctx.cwd, "test", "fixtures");
+	if (fs.existsSync(testDir)) {
+		for (const fixture of walkTsFiles(testDir)) {
+			const content = fs.readFileSync(fixture, "utf-8");
+			if (!content.includes(oldName)) continue;
+			const agentPattern = new RegExp('(["\'\\`]agent[="\':\\s]*)' + escapeRegex(oldName) + '(["\'\\`]|\\s)', 'g');
+			const newContent = content.replace(agentPattern, `$1${newName}$2`);
+			if (newContent !== content) {
+				changed.push(fixture);
+				if (!dryRun) {
+					fs.writeFileSync(fixture, newContent, "utf-8");
+				}
+			}
+		}
+	}
 	return changed;
 }
 

package/src/extension/register.ts

@@ -441,6 +441,39 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		return undefined;
 	}
 	rpcHandle = registerPiCrewRpc(getPiEvents(), () => currentCtx);
+	time("register.globalRegistry");
+	// Register global RPC registry for cross-extension access (mirrors pi-subagents3's Symbol.for pattern)
+	// Uses lazy import to avoid pulling team-tool.ts into module load.
+	// Other extensions access via: const reg = globalThis[Symbol.for("pi-crew:registry")];
+	void import("./team-tool.ts").then(({ registerCrewGlobalRegistry }) => {
+		const manifestCacheForRegistry = getManifestCache(currentCtx?.cwd ?? process.cwd());
+		registerCrewGlobalRegistry({
+			version: 1,
+			getRecord: (runId) => manifestCacheForRegistry.get(runId),
+			listRuns: () => manifestCacheForRegistry.list(100).map((m) => ({ runId: m.runId, status: m.status, goal: m.goal })),
+			appendEvent: (runId, event) => {
+				const manifest = manifestCacheForRegistry.get(runId);
+				if (manifest) void import("../state/event-log.ts").then(({ appendEventFireAndForget }) => appendEventFireAndForget(manifest.eventsPath, event as Parameters<typeof appendEventFireAndForget>[1]));
+			},
+			waitForAll: async (runId) => {
+				const { loadRunManifestById } = await import("../state/state-store.ts");
+				const check = (): boolean => {
+					const loaded = loadRunManifestById(currentCtx?.cwd ?? process.cwd(), runId);
+					if (!loaded) return true;
+					return !loaded.tasks.some((t: { status: string }) => t.status === "running" || t.status === "queued");
+				};
+				while (!check()) await new Promise((resolve) => setTimeout(resolve, 500));
+			},
+			hasRunning: (runId) => {
+				const manifest = manifestCacheForRegistry.get(runId);
+				if (!manifest) return false;
+				const { loadRunManifestById } = require("../state/state-store.ts");
+				const loaded = loadRunManifestById(currentCtx?.cwd ?? process.cwd(), runId);
+				if (!loaded) return false;
+				return loaded.tasks.some((t: { status: string }) => t.status === "running" || t.status === "queued");
+			},
+		});
+	});
 
 	const cleanupRuntime = (): void => {
 		if (cleanedUp) return;
@@ -456,16 +489,20 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		stopAsyncRunNotifier(notifierState);
 
 		// Best-effort: kill any async background runners that are still alive.
-		// Foreground child processes (team run tasks) are handled above.
-		try {
-			for (const manifest of manifestCache.list(50)) {
-				if (manifest.async?.pid !== undefined && checkProcessLiveness(manifest.async.pid).alive) {
-					killProcessPid(manifest.async.pid);
-				}
-			}
-		} catch (error) {
-			logInternalError("register.cleanupRuntime.killAsync", error);
-		}
+		// NOTE: Background runners are designed to outlive the Pi session.
+		// Do NOT kill them on session_shutdown — they manage their own lifecycle.
+		// Only kill foreground child processes (handled above via abort controllers).
+		// See Bug #17: killing async runners on session_shutdown was the root cause
+		// of the "background runner dies at ~35s" bug.
+		// try {
+		// 	for (const manifest of manifestCache.list(50)) {
+		// 		if (manifest.async?.pid !== undefined && checkProcessLiveness(manifest.async.pid).alive) {
+		// 			killProcessPid(manifest.async.pid);
+		// 		}
+		// 	}
+		// } catch (error) {
+		// 	logInternalError("register.cleanupRuntime.killAsync", error);
+		// }
 
 		// P0: Purge all stale active-run-index entries on session cleanup.
 		// This handles: normal exit, SIGTERM, Ctrl+C — any case where cleanupRuntime fires.

package/src/extension/run-index.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { TeamRunManifest } from "../state/types.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
@@ -22,11 +23,16 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 	const runsRoot = path.join(root, DEFAULT_PATHS.state.runsSubdir);
 	if (!fs.existsSync(runsRoot)) return [];
 	if (signal?.aborted) return [];
+	// 2.19 — skip temp directories to avoid phantom runs from test/isolated workspaces.
+	// Runs in /tmp/ are typically from tests or isolated worktrees and should not
+	// appear in production dashboards unless the process is actually alive.
+	const tempDirs = [os.tmpdir(), "/var/tmp", "/tmp"];
+	const isTempRoot = tempDirs.some((t) => root.startsWith(t + path.sep));
 	const token = createCancellationToken({ signal });
 	const entries = fs.readdirSync(runsRoot, { withFileTypes: true })
 		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
 		.map((entry) => entry.name)
-		.sort((a, b) => b.localeCompare(a));
+		.sort((a, b) => (b ?? "").localeCompare(a ?? ""));
 	const selected = maxEntries !== undefined ? entries.slice(0, Math.max(0, maxEntries)) : entries;
 	const results: TeamRunManifest[] = [];
 	for (let i = 0; i < selected.length; i++) {
@@ -37,6 +43,18 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 			// Filter out ghost runs: active status but CWD no longer exists.
 			// These are deadletter/replay/temp runs whose temp dirs were cleaned up.
 			if ((manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning") && manifest.cwd && !fs.existsSync(manifest.cwd)) continue;
+			// 2.19 — for runs in temp directories, verify the background process is alive.
+			// Without this, runs that completed/crashed but left stale manifests will still show.
+			if (isTempRoot && (manifest.status === "running" || manifest.status === "queued" || manifest.status === "planning")) {
+				const asyncPidPath = path.join(path.dirname(manifest.stateRoot), "async.pid");
+				try {
+					const pidData = JSON.parse(fs.readFileSync(asyncPidPath, "utf-8"));
+					const pid = pidData?.pid;
+					if (pid && typeof pid === "number") {
+						try { process.kill(pid, 0); } catch { continue; } // PID dead, skip this run
+					}
+				} catch { /* no async.pid or parse error — keep the run */ }
+			}
 			results.push(manifest);
 		} catch { /* skip unreadable manifests */ }
 	}
@@ -46,7 +64,7 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[] {
 	const byId = new Map<string, TeamRunManifest>();
 	for (const runs of runSets) for (const run of runs) byId.set(run.runId, run);
-	const sorted = [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	const sorted = [...byId.values()].sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
 	return max !== undefined ? sorted.slice(0, Math.max(0, max)) : sorted;
 }
 

package/src/extension/run-maintenance.ts

@@ -50,7 +50,7 @@ function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string
 
 export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsOptions = {}): PruneRunsResult {
 	const token = createCancellationToken({ signal: options.signal });
-	const finished = listRuns(cwd, options.signal).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const finished = listRuns(cwd, options.signal).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
 	const kept = finished.slice(0, keep).map((run) => run.runId);
 	const removed: string[] = [];
 	const toRemove = finished.slice(keep);
@@ -129,7 +129,7 @@ export function pruneUserLevelRuns(keep: number): PruneRunsResult {
 	}
 
 	// Sort newest first, keep top N, remove the rest
-	finished.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	finished.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
 	const kept = finished.slice(0, keep).map((r) => r.runId);
 	const removed: string[] = [];
 	for (const run of finished.slice(keep)) {

package/src/extension/team-tool/parallel-dispatch.ts

@@ -145,7 +145,7 @@ async function spawnSingleTask(
 		});
 
 		if (runtime.available && runtime.kind === "child-process") {
-			spawnBackgroundTeamRun(created.manifest);
+			await spawnBackgroundTeamRun(created.manifest);
 		}
 
 		return { ok: true, value: { runId: created.manifest.runId, goal, agent: agentName } };

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

@@ -132,13 +132,10 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const executionManifest = { ...updatedManifest, runtimeResolution, runConfig: executedConfig, updatedAt: new Date().toISOString() };
 	atomicWriteJson(paths.manifestPath, executionManifest);
 	appendEvent(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } });
-	const runAsync = params.async ?? loadedConfig.config.asyncByDefault ?? false;
-	// Background runners are standalone Node processes — live-session (in-process Pi SDK)
-	// is only valid when tasks run inside the parent Pi agent session. Override to
-	// child-process for async runs so the background runner spawns child Pi workers.
+	const runAsync = params.async ?? executedConfig.asyncByDefault ?? false;
 	let effectiveRuntime = runtime;
 	if (runAsync && runtime.kind === "live-session") {
-		effectiveRuntime = { ...runtime, kind: "child-process", steer: false, resume: false, liveToolActivity: false, fallback: "child-process", reason: "Background runner cannot use live-session; falling back to child-process." };
+		effectiveRuntime = { ...runtime, kind: "child-process", steer: true, resume: false, liveToolActivity: false, fallback: "child-process", reason: "Background runner cannot use live-session; falling back to child-process." };
 	}
 	const effectiveRuntimeResolution = effectiveRuntime !== runtime ? runtimeResolutionState(effectiveRuntime) : runtimeResolution;
 	const effectiveManifest = effectiveRuntime !== runtime ? { ...executionManifest, runtimeResolution: effectiveRuntimeResolution, updatedAt: new Date().toISOString() } : executionManifest;
@@ -160,7 +157,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				`Env: PI_CREW_EXECUTE_WORKERS=${process.env.PI_CREW_EXECUTE_WORKERS ?? "<unset>"}, PI_TEAMS_EXECUTE_WORKERS=${process.env.PI_TEAMS_EXECUTE_WORKERS ?? "<unset>"}`,
 			].join("\n"), { action: "run", status: "error", runId: blocked.runId, artifactsRoot: blocked.artifactsRoot }, true);
 		}
-		const spawned = spawnBackgroundTeamRun(effectiveManifest);
+		const spawned = await spawnBackgroundTeamRun(effectiveManifest);
 		const asyncManifest = { ...effectiveManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
 		appendEvent(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });

package/src/extension/team-tool.ts

@@ -28,10 +28,11 @@ import type { PiTeamsToolResult } from "./tool-result.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 // Heavy runtime — lazy-loaded to avoid 1.4s import cost at extension registration.
 // executeTeamRun is only called when a team run actually executes.
-import type { executeTeamRun as ExecuteTeamRunFn } from "../runtime/team-runner.ts";
-let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
-async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
-	if (!_cachedExecuteTeamRun) {
+import type { executeTeamRun as _executeTeamRunFn } from "../runtime/team-runner.ts";
+type ExecuteTeamRunFn = typeof _executeTeamRunFn;
+let _cachedExecuteTeamRun: ExecuteTeamRunFn | undefined = undefined;
+async function executeTeamRun(...args: Parameters<ExecuteTeamRunFn>): Promise<Awaited<ReturnType<ExecuteTeamRunFn>>> {
+	if (_cachedExecuteTeamRun === undefined) {
 		// LAZY: heavy runtime — defer 1.4s import cost until team run actually executes.
 		const mod = await import("../runtime/team-runner.ts");
 		_cachedExecuteTeamRun = mod.executeTeamRun;
@@ -51,10 +52,11 @@ import { autonomousPatchFromConfig, configPatchFromConfig, effectiveRunConfig, f
 import { handleApi } from "./team-tool/api.ts";
 // Lazy-loaded: run.ts pulls in spawnBackgroundTeamRun, resolveCrewRuntime, etc.
 // Static import fails silently in some jiti contexts (child-process), leaving handleRun undefined.
-import type { handleRun as HandleRunFn } from "./team-tool/run.ts";
-let _cachedHandleRun: typeof HandleRunFn | undefined;
-async function handleRun(...args: Parameters<typeof HandleRunFn>): Promise<Awaited<ReturnType<typeof HandleRunFn>>> {
-	if (!_cachedHandleRun) {
+import type { handleRun as _handleRunFn } from "./team-tool/run.ts";
+type HandleRunFn = typeof _handleRunFn;
+let _cachedHandleRun: HandleRunFn | undefined = undefined;
+async function handleRun(...args: Parameters<HandleRunFn>): Promise<Awaited<ReturnType<HandleRunFn>>> {
+	if (_cachedHandleRun === undefined) {
 		// LAZY: run.ts pulls in spawnBackgroundTeamRun + resolveCrewRuntime; also avoids jiti import race in child-process contexts.
 		const mod = await import("./team-tool/run.ts");
 		_cachedHandleRun = mod.handleRun;
@@ -156,15 +158,29 @@ function artifactKey(artifact: ArtifactDescriptor): string {
 function recoverCheckpointedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[]): { manifest: TeamRunManifest; tasks: TeamTaskState[]; recovered: string[] } {
 	const recovered: string[] = [];
 	let nextManifest = manifest;
-	let nextTasks = tasks.map((task) => {
+	const nextTasks = tasks.map((task) => {
 		if (task.status !== "running" || !task.checkpoint) return task;
 		if (task.checkpoint.phase === "artifact-written" && task.resultArtifact) {
 			recovered.push(task.id);
 			return { ...task, status: "completed" as const, finishedAt: task.finishedAt ?? task.checkpoint.updatedAt, error: undefined, claim: undefined };
 		}
 		if (task.checkpoint.phase === "child-stdout-final") {
-			const transcriptPath = path.join(manifest.artifactsRoot, "transcripts", `${task.id}.jsonl`);
-			if (!fs.existsSync(transcriptPath)) return task;
+			// transcripts are written with .attempt-${i}.jsonl suffix; find the most recent one
+			const transcriptsDir = path.join(manifest.artifactsRoot, "transcripts");
+			let transcriptPath: string | undefined;
+			if (fs.existsSync(transcriptsDir)) {
+				const files = fs.readdirSync(transcriptsDir).filter((f) => f.startsWith(`${task.id}.attempt-`) && f.endsWith(".jsonl"));
+				if (files.length > 0) {
+					// Sort by attempt index descending to get the most recent
+					files.sort((a, b) => {
+						const idxA = parseInt(a.match(/\.attempt-(\d+)\./)?.[1] ?? "0");
+						const idxB = parseInt(b.match(/\.attempt-(\d+)\./)?.[1] ?? "0");
+						return idxB - idxA;
+					});
+					transcriptPath = path.join(transcriptsDir, files[0]);
+				}
+			}
+			if (!transcriptPath) return task;
 			const transcript = fs.readFileSync(transcriptPath, "utf-8");
 			const parsed = parsePiJsonOutput(transcript);
 			if (!parsed.finalText && !parsed.usage) return task;
@@ -242,6 +258,22 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 	});
 }
 
+export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const { runId, taskId, message } = params;
+	if (!runId || !taskId || !message) {
+		return result("steer requires runId, taskId, and message", { action: "steer", status: "error" }, true);
+	}
+	const loaded = loadRunManifestById(ctx.cwd, runId);
+	if (!loaded) return result(`Run '${runId}' not found`, { action: "steer", status: "error" }, true);
+	const task = loaded.tasks.find(t => t.id === taskId);
+	if (!task) return result(`Task '${taskId}' not found`, { action: "steer", status: "error" }, true);
+	if (!task.pendingSteers) task.pendingSteers = [];
+	task.pendingSteers.push(message);
+	saveRunTasks(loaded.manifest, loaded.tasks);
+	appendEvent(loaded.manifest.eventsPath, { type: "task.steer_queued", runId, taskId, data: { message } });
+	return result(`Steer queued for task '${taskId}'. It will be delivered when the task's session is ready.`, { action: "steer", status: "ok" });
+}
+
 export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const action = params.action ?? "list";
 	switch (action) {
@@ -339,6 +371,30 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		case "create": return handleCreate(params, ctx);
 		case "update": return handleUpdate(params, ctx);
 		case "delete": return handleDelete(params, ctx);
+		case "steer": return handleSteer(params, ctx);
 		default: return result(`Unknown action: ${action}`, { action: "unknown", status: "error" }, true);
 	}
 }
+
+/**
+ * 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")];
+ */
+const CREW_REGISTRY_KEY = Symbol.for("pi-crew:registry");
+interface CrewRegistry {
+	version: 1;
+	getRecord: (runId: string) => TeamRunManifest | undefined;
+	listRuns: () => Array<{ runId: string; status: string; goal: string }>;
+	appendEvent: (runId: string, event: Record<string, unknown>) => void;
+	waitForAll: (runId: string) => Promise<void>;
+	hasRunning: (runId: string) => boolean;
+}
+
+export function registerCrewGlobalRegistry(registry: CrewRegistry): void {
+	(globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY] = registry;
+}
+
+export function getCrewGlobalRegistry(): CrewRegistry | undefined {
+	return (globalThis as Record<symbol | string, unknown>)[CREW_REGISTRY_KEY] as CrewRegistry | undefined;
+}

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

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { MetricRegistry } from "./metric-registry.ts";
+import type { MetricRegistry } from "./metric-registry.ts";
 
 function recordValue(value: unknown): Record<string, unknown> {
 	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
@@ -46,6 +46,7 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		["crew.run.cancelled", (data) => { const item = recordValue(data); runCount.inc({ status: "cancelled", reason: cancellationReasonLabel(item.reason) }); }],
 		["crew.task.completed", (data) => { const item = recordValue(data); taskCount.inc({ status: "completed" }); taskDuration.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.durationMs)); tokenUsage.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.tokens)); }],
 		["crew.task.failed", () => taskCount.inc({ status: "failed" })],
+		["crew.task.needs_attention", () => taskCount.inc({ status: "needs_attention" })],
 		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.task.deadletter", (data) => { const item = recordValue(data); deadletterCount.inc({ reason: stringValue(item.reason, "unknown") }); }],
 		["crew.task.overflow", (data) => { const item = recordValue(data); overflowCount.inc({ phase: stringValue(item.phase, "unknown"), previous_phase: stringValue(item.previousPhase, "none") }); }],