pi-crew 0.1.41 → 0.1.44

package/src/config/config.ts

@@ -80,6 +80,7 @@ export interface AgentOverrideConfig {
 	fallbackModels?: string[] | false;
 	thinking?: string | false;
 	tools?: string[] | false;
+	skills?: string[] | false;
 }
 
 export interface CrewAgentsConfig {
@@ -189,6 +190,14 @@ export function projectConfigPath(cwd: string): string {
 	return path.join(projectCrewRoot(cwd), "config.json");
 }
 
+/**
+ * Alternative project config path: `.pi/pi-crew.json` in the project root.
+ * This is a convenience path alongside the standard `config.json` in crewRoot.
+ */
+export function projectPiCrewJsonPath(cwd: string): string {
+	return path.join(cwd, ".pi", "pi-crew.json");
+}
+
 function withoutUndefined<T extends Record<string, unknown>>(value: T): Partial<T> {
 	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as Partial<T>;
 }
@@ -331,7 +340,7 @@ function mergeConfig(base: PiTeamsConfig, override: PiTeamsConfig): PiTeamsConfi
 			...withoutUndefined((override.agents ?? {}) as Record<string, unknown>),
 			overrides: {
 				...(base.agents?.overrides ?? {}),
-				...(override.agents?.overrides ?? {}),
+				...withoutUndefined((override.agents?.overrides ?? {}) as Record<string, unknown>) as Record<string, AgentOverrideConfig>,
 			},
 		};
 	}
@@ -421,7 +430,7 @@ function parseStringList(value: unknown): string[] | undefined {
 
 function parseStringArrayOrFalse(value: unknown): string[] | false | undefined {
 	if (value === false) return false;
-	if (typeof value === "string") return parseStringList(value.split(","));
+	if (typeof value === "string") return value.trim() === "" ? [] : parseStringList(value.split(","));
 	return parseStringList(value);
 }
 
@@ -536,6 +545,7 @@ function parseAgentOverride(value: unknown): AgentOverrideConfig | undefined {
 		fallbackModels: parseStringArrayOrFalse(obj.fallbackModels),
 		thinking: parseWithSchema(Type.Union([Type.String(), Type.Literal(false)]), obj.thinking),
 		tools: parseStringArrayOrFalse(obj.tools),
+		skills: parseStringArrayOrFalse(obj.skills),
 	};
 	return Object.values(override).some((entry) => entry !== undefined) ? override : undefined;
 }
@@ -649,9 +659,14 @@ function parseReliabilityConfig(value: unknown): CrewReliabilityConfig | undefin
 function parseOtlpConfig(value: unknown): CrewOtlpConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
-	const headers: Record<string, string> = {};
+	const headers: Record<string, string> = Object.create(null);
 	const rawHeaders = asRecord(obj.headers);
-	if (rawHeaders) for (const [key, entry] of Object.entries(rawHeaders)) if (typeof entry === "string") headers[key] = entry;
+	if (rawHeaders) for (const [key, entry] of Object.entries(rawHeaders)) {
+		if (typeof entry !== "string") continue;
+		// Prevent prototype pollution via __proto__ / constructor / prototype keys.
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		headers[key] = entry;
+	}
 	const otlp: CrewOtlpConfig = {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 		endpoint: parseWithSchema(Type.String({ minLength: 1 }), obj.endpoint),
@@ -726,6 +741,15 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 			const projectSafeConfig = sanitizeProjectConfig(projectPath, config, projectConfig.config);
 			warnings.push(...projectConfig.warnings.map((warning) => `${projectPath}: ${warning}`), ...projectSafeConfig.warnings);
 			config = mergeConfig(config, projectSafeConfig.config);
+			// Also load .pi/pi-crew.json from project root if it exists
+			const piCrewJsonPath = projectPiCrewJsonPath(cwd);
+			if (fs.existsSync(piCrewJsonPath)) {
+				const piCrewJsonConfig = parseConfigWithWarnings(readConfigRecord(piCrewJsonPath));
+				const piCrewJsonSafeConfig = sanitizeProjectConfig(piCrewJsonPath, config, piCrewJsonConfig.config);
+				warnings.push(...piCrewJsonConfig.warnings.map((warning) => `${piCrewJsonPath}: ${warning}`), ...piCrewJsonSafeConfig.warnings);
+				config = mergeConfig(config, piCrewJsonSafeConfig.config);
+				paths.push(piCrewJsonPath);
+			}
 		}
 		return { path: filePath, paths, config, warnings: warnings.length > 0 ? warnings : undefined };
 	} catch (error) {

package/src/extension/cross-extension-rpc.ts

@@ -1,82 +1,82 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { handleTeamTool } from "./team-tool.ts";
-import { parseLiveControlRealtimeMessage, publishLiveControlRealtime } from "../runtime/live-control-realtime.ts";
-
-export interface EventBusLike {
-	on(event: string, handler: (data: unknown) => void): (() => void) | void;
-	emit(event: string, data: unknown): void;
-}
-
-export type RpcReply<T = unknown> = { success: true; data?: T } | { success: false; error: string };
-export const PI_CREW_RPC_VERSION = 1;
-
-export interface PiCrewRpcHandle {
-	unsubscribe(): void;
-}
-
-function requestId(raw: unknown): string | undefined {
-	return raw && typeof raw === "object" && !Array.isArray(raw) && typeof (raw as { requestId?: unknown }).requestId === "string" ? (raw as { requestId: string }).requestId : undefined;
-}
-
-function reply(events: EventBusLike, channel: string, id: string | undefined, payload: RpcReply): void {
-	if (!id) return;
-	events.emit(`${channel}:reply:${id}`, payload);
-}
-
-function textOf(result: Awaited<ReturnType<typeof handleTeamTool>>): string {
-	return result.content?.map((item) => item.type === "text" ? item.text : "").join("\n") ?? "";
-}
-
-function on(events: EventBusLike, channel: string, handler: (raw: unknown) => void): () => void {
-	const unsub = events.on(channel, handler);
-	return typeof unsub === "function" ? unsub : () => {};
-}
-
-export function registerPiCrewRpc(events: EventBusLike | undefined, getCtx: () => ExtensionContext | undefined): PiCrewRpcHandle | undefined {
-	if (!events) return undefined;
-	const unsubs = [
-		on(events, "pi-crew:rpc:ping", (raw) => reply(events, "pi-crew:rpc:ping", requestId(raw), { success: true, data: { version: PI_CREW_RPC_VERSION } })),
-		on(events, "pi-crew:rpc:run", async (raw) => {
-			const id = requestId(raw);
-			try {
-				const ctx = getCtx();
-				if (!ctx) throw new Error("No active pi-crew session context.");
-				const params: TeamToolParamsValue = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...(raw as object), action: "run" } as TeamToolParamsValue : { action: "run" };
-				const result = await handleTeamTool(params, ctx);
-				reply(events, "pi-crew:rpc:run", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: result.details });
-			} catch (error) {
-				reply(events, "pi-crew:rpc:run", id, { success: false, error: error instanceof Error ? error.message : String(error) });
-			}
-		}),
-		on(events, "pi-crew:rpc:status", async (raw) => {
-			const id = requestId(raw);
-			try {
-				const ctx = getCtx();
-				if (!ctx) throw new Error("No active pi-crew session context.");
-				const runId = raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as { runId?: string }).runId : undefined;
-				const result = await handleTeamTool({ action: "status", runId }, ctx);
-				reply(events, "pi-crew:rpc:status", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
-			} catch (error) {
-				reply(events, "pi-crew:rpc:status", id, { success: false, error: error instanceof Error ? error.message : String(error) });
-			}
-		}),
-		on(events, "pi-crew:live-control", (raw) => {
-			const request = parseLiveControlRealtimeMessage(raw);
-			if (request) publishLiveControlRealtime(request);
-		}),
-		on(events, "pi-crew:rpc:live-control", async (raw) => {
-			const id = requestId(raw);
-			try {
-				const ctx = getCtx();
-				if (!ctx) throw new Error("No active pi-crew session context.");
-				const obj = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
-				const result = await handleTeamTool({ action: "api", runId: typeof obj.runId === "string" ? obj.runId : undefined, config: { operation: typeof obj.operation === "string" ? obj.operation : "steer-agent", agentId: obj.agentId, message: obj.message, prompt: obj.prompt } }, ctx);
-				reply(events, "pi-crew:rpc:live-control", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
-			} catch (error) {
-				reply(events, "pi-crew:rpc:live-control", id, { success: false, error: error instanceof Error ? error.message : String(error) });
-			}
-		}),
-	];
-	return { unsubscribe: () => unsubs.forEach((unsub) => unsub()) };
-}
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
+import { handleTeamTool } from "./team-tool.ts";
+import { parseLiveControlRealtimeMessage, publishLiveControlRealtime } from "../runtime/live-control-realtime.ts";
+
+export interface EventBusLike {
+	on(event: string, handler: (data: unknown) => void): (() => void) | void;
+	emit(event: string, data: unknown): void;
+}
+
+export type RpcReply<T = unknown> = { success: true; data?: T } | { success: false; error: string };
+export const PI_CREW_RPC_VERSION = 1;
+
+export interface PiCrewRpcHandle {
+	unsubscribe(): void;
+}
+
+function requestId(raw: unknown): string | undefined {
+	return raw && typeof raw === "object" && !Array.isArray(raw) && typeof (raw as { requestId?: unknown }).requestId === "string" ? (raw as { requestId: string }).requestId : undefined;
+}
+
+function reply(events: EventBusLike, channel: string, id: string | undefined, payload: RpcReply): void {
+	if (!id) return;
+	events.emit(`${channel}:reply:${id}`, payload);
+}
+
+function textOf(result: Awaited<ReturnType<typeof handleTeamTool>>): string {
+	return result.content?.map((item) => item.type === "text" ? item.text : "").join("\n") ?? "";
+}
+
+function on(events: EventBusLike, channel: string, handler: (raw: unknown) => void): () => void {
+	const unsub = events.on(channel, handler);
+	return typeof unsub === "function" ? unsub : () => {};
+}
+
+export function registerPiCrewRpc(events: EventBusLike | undefined, getCtx: () => ExtensionContext | undefined): PiCrewRpcHandle | undefined {
+	if (!events) return undefined;
+	const unsubs = [
+		on(events, "pi-crew:rpc:ping", (raw) => reply(events, "pi-crew:rpc:ping", requestId(raw), { success: true, data: { version: PI_CREW_RPC_VERSION } })),
+		on(events, "pi-crew:rpc:run", async (raw) => {
+			const id = requestId(raw);
+			try {
+				const ctx = getCtx();
+				if (!ctx) throw new Error("No active pi-crew session context.");
+				const params: TeamToolParamsValue = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...(raw as object), action: "run" } as TeamToolParamsValue : { action: "run" };
+				const result = await handleTeamTool(params, ctx);
+				reply(events, "pi-crew:rpc:run", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: result.details });
+			} catch (error) {
+				reply(events, "pi-crew:rpc:run", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+			}
+		}),
+		on(events, "pi-crew:rpc:status", async (raw) => {
+			const id = requestId(raw);
+			try {
+				const ctx = getCtx();
+				if (!ctx) throw new Error("No active pi-crew session context.");
+				const runId = raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as { runId?: string }).runId : undefined;
+				const result = await handleTeamTool({ action: "status", runId }, ctx);
+				reply(events, "pi-crew:rpc:status", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
+			} catch (error) {
+				reply(events, "pi-crew:rpc:status", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+			}
+		}),
+		on(events, "pi-crew:live-control", (raw) => {
+			const request = parseLiveControlRealtimeMessage(raw);
+			if (request) publishLiveControlRealtime(request);
+		}),
+		on(events, "pi-crew:rpc:live-control", async (raw) => {
+			const id = requestId(raw);
+			try {
+				const ctx = getCtx();
+				if (!ctx) throw new Error("No active pi-crew session context.");
+				const obj = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+				const result = await handleTeamTool({ action: "api", runId: typeof obj.runId === "string" ? obj.runId : undefined, config: { operation: typeof obj.operation === "string" ? obj.operation : "steer-agent", agentId: obj.agentId, message: obj.message, prompt: obj.prompt } }, ctx);
+				reply(events, "pi-crew:rpc:live-control", id, result.isError ? { success: false, error: textOf(result) } : { success: true, data: { text: textOf(result), details: result.details } });
+			} catch (error) {
+				reply(events, "pi-crew:rpc:live-control", id, { success: false, error: error instanceof Error ? error.message : String(error) });
+			}
+		}),
+	];
+	return { unsubscribe: () => unsubs.forEach((unsub) => unsub()) };
+}

package/src/extension/management.ts

@@ -41,7 +41,11 @@ function extensionFor(resource: "agent" | "team" | "workflow"): string {
 }
 
 function backupFile(filePath: string): string {
-	const backupPath = `${filePath}.bak-${new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}`;
+	// Include milliseconds and a short random suffix to prevent collision
+	// when multiple backups happen within the same second.
+	const ts = new Date().toISOString().replace(/[-:.TZ]/g, "");
+	const random = Math.random().toString(36).slice(2, 6);
+	const backupPath = `${filePath}.bak-${ts.slice(0, 17)}-${random}`;
 	fs.copyFileSync(filePath, backupPath);
 	return backupPath;
 }
@@ -83,7 +87,7 @@ function parseRoles(value: unknown): { roles?: TeamRole[]; error?: string } {
 			agent: sanitizeName(agent.value!),
 			description: typeof obj.description === "string" ? obj.description.trim() : undefined,
 			model: typeof obj.model === "string" ? obj.model.trim() : undefined,
-			maxConcurrency: typeof obj.maxConcurrency === "number" && Number.isInteger(obj.maxConcurrency) ? obj.maxConcurrency : undefined,
+			maxConcurrency: typeof obj.maxConcurrency === "number" && Number.isInteger(obj.maxConcurrency) && obj.maxConcurrency > 0 ? obj.maxConcurrency : undefined,
 		});
 	}
 	return { roles };
@@ -131,6 +135,8 @@ function findResource(ctx: ManagementContext, resource: "agent" | "team" | "work
 	return allWorkflows(discoverWorkflows(ctx.cwd)).filter(sourceMatches);
 }
 
+// Note: only checks agent→team references and defaultWorkflow. Does not detect
+// workflow-step→agent/team references or team name in workflow metadata.
 function findReferences(ctx: ManagementContext, resource: "agent" | "team" | "workflow", name: string): string[] {
 	const refs: string[] = [];
 	if (resource === "agent") {
@@ -231,7 +237,7 @@ export function handleCreate(params: TeamToolParamsValue, ctx: ManagementContext
 			roles: parsedRoles.roles!,
 			defaultWorkflow: typeof cfg.defaultWorkflow === "string" ? sanitizeName(cfg.defaultWorkflow) : undefined,
 			workspaceMode: cfg.workspaceMode === "worktree" ? "worktree" : "single",
-			maxConcurrency: typeof cfg.maxConcurrency === "number" && Number.isInteger(cfg.maxConcurrency) ? cfg.maxConcurrency : undefined,
+			maxConcurrency: typeof cfg.maxConcurrency === "number" && Number.isInteger(cfg.maxConcurrency) && cfg.maxConcurrency > 0 ? cfg.maxConcurrency : undefined,
 			routing: parseRouting(cfg),
 		});
 	} else {
@@ -248,7 +254,11 @@ export function handleCreate(params: TeamToolParamsValue, ctx: ManagementContext
 	}
 
 	if (params.dryRun) return result(`[dry-run] Would create ${params.resource} '${name}' at ${filePath}:\n\n${content}`);
-	fs.writeFileSync(filePath, content, "utf-8");
+	try {
+		fs.writeFileSync(filePath, content, "utf-8");
+	} catch (writeError) {
+		return result(`Failed to create ${params.resource}: ${writeError instanceof Error ? writeError.message : String(writeError)}`, "error", true);
+	}
 	return result(`Created ${params.resource} '${name}' at ${filePath}.`);
 }
 
@@ -301,7 +311,7 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 			roles,
 			defaultWorkflow: hasOwn(cfg, "defaultWorkflow") ? (typeof cfg.defaultWorkflow === "string" ? sanitizeName(cfg.defaultWorkflow) : undefined) : team.defaultWorkflow,
 			workspaceMode: cfg.workspaceMode === "worktree" ? "worktree" : cfg.workspaceMode === "single" ? "single" : team.workspaceMode,
-			maxConcurrency: typeof cfg.maxConcurrency === "number" && Number.isInteger(cfg.maxConcurrency) ? cfg.maxConcurrency : team.maxConcurrency,
+			maxConcurrency: typeof cfg.maxConcurrency === "number" && Number.isInteger(cfg.maxConcurrency) && cfg.maxConcurrency > 0 ? cfg.maxConcurrency : team.maxConcurrency,
 			routing: parseRouting(cfg, team.routing),
 		});
 	} else {
@@ -327,8 +337,23 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 		return result([`[dry-run] Would update ${params.resource} at ${current.filePath}:`, "", content, ...(referenceUpdates.length ? ["", "Would update references in:", ...referenceUpdates.map((filePath) => `- ${filePath}`)] : [])].join("\n"));
 	}
 	const backupPath = backupFile(current.filePath);
-	if (nextPath !== current.filePath) fs.renameSync(current.filePath, nextPath);
-	fs.writeFileSync(nextPath, content, "utf-8");
+	try {
+		if (nextPath !== current.filePath) {
+			try {
+				fs.renameSync(current.filePath, nextPath);
+			} catch (renameError) {
+				if ((renameError as NodeJS.ErrnoException).code === "EXDEV") {
+					fs.copyFileSync(current.filePath, nextPath);
+					fs.unlinkSync(current.filePath);
+				} else {
+					throw renameError;
+				}
+			}
+		}
+		fs.writeFileSync(nextPath, content, "utf-8");
+	} catch (updateError) {
+		return result(`Failed to update ${params.resource}: ${updateError instanceof Error ? updateError.message : String(updateError)}`, "error", true);
+	}
 	const updatedRefs = params.updateReferences ? updateReferencesForRename(ctx, params.resource!, current.name, nextName, source, false) : [];
 	return result([`Updated ${params.resource} at ${nextPath}. Backup: ${backupPath}.`, ...(updatedRefs.length ? ["Updated references:", ...updatedRefs.map((filePath) => `- ${filePath}`)] : [])].join("\n"));
 }
@@ -343,6 +368,10 @@ export function handleDelete(params: TeamToolParamsValue, ctx: ManagementContext
 	}
 	if (params.dryRun) return result(`[dry-run] Would delete ${params.resource} at ${resolved.resource!.filePath}.${refs.length ? `\nReferences:\n${refs.map((ref) => `- ${ref}`).join("\n")}` : ""}`);
 	const backupPath = backupFile(resolved.resource!.filePath);
-	fs.unlinkSync(resolved.resource!.filePath);
+	try {
+		fs.unlinkSync(resolved.resource!.filePath);
+	} catch (deleteError) {
+		return result(`Failed to delete ${params.resource}: ${deleteError instanceof Error ? deleteError.message : String(deleteError)}`, "error", true);
+	}
 	return result(`Deleted ${params.resource} at ${resolved.resource!.filePath}. Backup: ${backupPath}.`);
 }

package/src/extension/notification-router.ts

@@ -66,8 +66,8 @@ export class NotificationRouter {
 		const withTime = { ...notification, timestamp: notification.timestamp ?? now };
 		try {
 			this.opts.sink?.(withTime);
-		} catch {
-			// Notification delivery must never crash the extension.
+		} catch (sinkError) {
+			process.stderr.write(`[pi-crew] notification-sink: ${sinkError instanceof Error ? sinkError.message : String(sinkError)}\n`);
 		}
 		const filter = this.opts.severityFilter ?? DEFAULT_SEVERITY_FILTER;
 		if (!filter.includes(withTime.severity)) return false;

package/src/extension/register.ts

@@ -1,4 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { loadConfig } from "../config/config.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
 import { startAsyncRunNotifier, stopAsyncRunNotifier, type AsyncNotifierState } from "./async-notifier.ts";
@@ -8,6 +10,7 @@ import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.t
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
 import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerbar } from "../ui/powerbar-publisher.ts";
 import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
+import type { TeamRunManifest } from "../state/types.ts";
 import { terminateActiveChildPiProcesses } from "../subagents/spawn.ts";
 import { SubagentManager } from "../subagents/manager.ts";
 import { __test__subagentSpawnParams, sendAgentWakeUp, sendFollowUp } from "./registration/subagent-helpers.ts";
@@ -34,10 +37,15 @@ import { OTLPExporter } from "../observability/exporters/otlp-exporter.ts";
 import { HeartbeatWatcher } from "../runtime/heartbeat-watcher.ts";
 import { appendDeadletter } from "../runtime/deadletter.ts";
 import { detectInterruptedRuns } from "../runtime/crash-recovery.ts";
+import { DeliveryCoordinator } from "../runtime/delivery-coordinator.ts";
+import { OverflowRecoveryTracker } from "../runtime/overflow-recovery.ts";
+import { tryRegisterSessionCleanup } from "../runtime/session-resources.ts";
+import { initI18n } from "../i18n.ts";
 
 export { __test__subagentSpawnParams };
 
 export function registerPiTeams(pi: ExtensionAPI): void {
+	const disposeI18n = initI18n(pi);
 	resetTimings();
 	time("register:start");
 	const globalStore = globalThis as Record<string, unknown>;
@@ -81,6 +89,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let metricSink: MetricSink | undefined;
 	let heartbeatWatcher: HeartbeatWatcher | undefined;
 	let otlpExporter: OTLPExporter | undefined;
+	let deliveryCoordinator: DeliveryCoordinator | undefined;
+	let overflowTracker: OverflowRecoveryTracker | undefined;
 	const configureNotifications = (ctx: ExtensionContext): void => {
 		notificationRouter?.dispose();
 		notificationSink?.dispose();
@@ -146,6 +156,28 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		}
 	};
 	const autoRecoveryLast = new Map<string, number>();
+	const configureDeliveryCoordinator = (): void => {
+		deliveryCoordinator?.dispose();
+		deliveryCoordinator = undefined;
+		overflowTracker?.dispose();
+		overflowTracker = undefined;
+		deliveryCoordinator = new DeliveryCoordinator({
+			emit: (event, data) => { pi.events?.emit?.(event, data); },
+			sendFollowUp: (title, body) => { sendFollowUp(pi, [title, body].filter((line): line is string => Boolean(line)).join("\n")); },
+			sendWakeUp: (message) => { sendAgentWakeUp(pi, message); },
+		});
+		overflowTracker = new OverflowRecoveryTracker({
+			onPhaseChange: (state, previousPhase) => {
+				if (metricRegistry) {
+					metricRegistry.counter("crew.task.overflow_recovery_total", "Overflow recovery phase transitions").inc({ phase: state.phase, previous_phase: previousPhase });
+				}
+				pi.events?.emit?.("crew.task.overflow", { runId: state.runId, taskId: state.taskId, phase: state.phase, previousPhase });
+			},
+			onTimeout: (state) => {
+				notifyOperator({ id: `overflow_timeout_${state.taskId}`, severity: "warning", source: "overflow-recovery", runId: state.runId, title: `Task ${state.taskId} overflow recovery timed out`, body: `Phase: ${state.phase}, compaction_count: ${state.compactionCount}, retry_count: ${state.retryCount}. The task may be stuck.` });
+			},
+		});
+	};
 	const notifyOperator = (notification: NotificationDescriptor): void => {
 		try {
 			notificationRouter?.enqueue(notification);
@@ -205,6 +237,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const foregroundControllers = new Set<AbortController>();
 	let liveSidebarRunId: string | undefined;
 	let renderScheduler: RenderScheduler | undefined;
+	let preloadTimer: ReturnType<typeof setTimeout> | undefined;
 	const stopSessionBoundSubagents = (): void => {
 		for (const controller of foregroundControllers) controller.abort();
 		foregroundControllers.clear();
@@ -312,6 +345,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const cleanupRuntime = (): void => {
 		if (cleanedUp) return;
 		cleanedUp = true;
+		if (preloadTimer) { clearTimeout(preloadTimer); preloadTimer = undefined; }
 		stopSessionBoundSubagents();
 		stopAsyncRunNotifier(notifierState);
 		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
@@ -326,6 +360,10 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		eventMetricSub = undefined;
 		otlpExporter = undefined;
 		metricRegistry = undefined;
+		deliveryCoordinator?.dispose();
+		overflowTracker?.dispose();
+		deliveryCoordinator = undefined;
+		overflowTracker = undefined;
 		manifestCache.dispose();
 		runSnapshotCache.dispose?.();
 		renderScheduler?.dispose();
@@ -337,6 +375,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		notificationSink = undefined;
 		rpcHandle?.unsubscribe();
 		rpcHandle = undefined;
+		disposeI18n();
 		sessionGeneration += 1;
 		currentCtx = undefined;
 		if (globalStore[runtimeCleanupStoreKey] === cleanupRuntime) delete globalStore[runtimeCleanupStoreKey];
@@ -357,16 +396,68 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		autoRecoveryLast.clear();
 		configureNotifications(ctx);
 		configureObservability(ctx);
+		configureDeliveryCoordinator();
+		const sessionId = (ctx as unknown as Record<string, unknown>).sessionId;
+		if (typeof sessionId === "string" && sessionId) deliveryCoordinator?.activate(sessionId);
+		tryRegisterSessionCleanup(pi, () => { terminateActiveChildPiProcesses(); cleanupRuntime(); });
 		registerPiCrewPowerbarSegments(pi.events, loadedConfig.config.ui);
 		startAsyncRunNotifier(ctx, notifierState, loadedConfig.config.notifierIntervalMs ?? DEFAULT_UI.notifierIntervalMs, { generation: ownerGeneration, isCurrent: (generation) => generation === sessionGeneration && currentCtx === ctx && !cleanedUp });
 		const cache = getManifestCache(ctx.cwd);
 		updateCrewWidget(ctx, widgetState, loadedConfig.config.ui, cache, getRunSnapshotCache(ctx.cwd));
 		updatePiCrewPowerbar(pi.events, ctx.cwd, loadedConfig.config.ui, cache, getRunSnapshotCache(ctx.cwd), ctx, widgetState.notificationCount ?? 0);
 		renderScheduler?.dispose();
+		// Phase 12: Async preloading — renderTick reads only a pre-computed frame
+		// from memory (zero fs I/O). Background preload refreshes the frame async.
+		let preloading = false;
+
+		let lastPreloadedConfig: ReturnType<typeof loadConfig> | undefined;
+		let lastPreloadedManifests: TeamRunManifest[] = [];
+		let lastFrameManifestCache: ReturnType<typeof createManifestCache> | undefined;
+		let lastFrameSnapshotCache: ReturnType<typeof createRunSnapshotCache> | undefined;
+
+		const buildFrame = async (): Promise<boolean> => {
+			if (!currentCtx) return false;
+			lastPreloadedConfig = loadConfig(currentCtx.cwd);
+			lastFrameManifestCache = getManifestCache(currentCtx.cwd);
+			lastFrameSnapshotCache = getRunSnapshotCache(currentCtx.cwd);
+			const manifests = lastFrameManifestCache.list(20);
+			lastPreloadedManifests = manifests;
+			const runIds = manifests.map((r) => r.runId);
+			await lastFrameSnapshotCache.preloadAllStale(runIds);
+			return true;
+		};
+
+		const backgroundPreload = (): void => {
+			if (!currentCtx || preloading) return;
+			preloading = true;
+			buildFrame()
+				.then((ok) => {
+					preloading = false;
+					if (ok) renderScheduler?.schedule();
+				})
+				.catch((error: unknown) => {
+					preloading = false;
+					logInternalError("register.backgroundPreload", error);
+				});
+		};
+
+		const startPreloadLoop = (intervalMs: number): void => {
+			if (preloadTimer) clearTimeout(preloadTimer);
+			const tick = (): void => {
+				backgroundPreload();
+				preloadTimer = setTimeout(tick, intervalMs);
+				preloadTimer.unref();
+			};
+			preloadTimer = setTimeout(tick, intervalMs);
+			preloadTimer.unref();
+		};
+
 		const renderTick = (): void => {
 			if (!currentCtx) return;
-			const config = loadConfig(currentCtx.cwd).config.ui;
-			const activeCache = getManifestCache(currentCtx.cwd);
+			const config = lastPreloadedConfig?.config.ui;
+			const activeCache = lastFrameManifestCache ?? getManifestCache(currentCtx.cwd);
+			const snapshotCache = lastFrameSnapshotCache ?? getRunSnapshotCache(currentCtx.cwd);
+			const manifests = lastPreloadedManifests.length > 0 ? lastPreloadedManifests : activeCache.list(20);
 			if (liveSidebarRunId) {
 				const placement = config?.widgetPlacement ?? "aboveEditor";
 				if (widgetState.lastVisibility !== "hidden" || widgetState.lastPlacement !== placement) {
@@ -379,13 +470,18 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				}
 				requestRender(currentCtx);
 			} else {
-				updateCrewWidget(currentCtx, widgetState, config, activeCache, getRunSnapshotCache(currentCtx.cwd));
+				updateCrewWidget(currentCtx, widgetState, config, activeCache, snapshotCache, manifests);
 			}
-			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, activeCache, getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
+			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, activeCache, snapshotCache, currentCtx, widgetState.notificationCount ?? 0, manifests);
+			// Health notifications: only warn about genuinely running runs
 			const now = Date.now();
-			for (const run of activeCache.list(20)) {
+			for (const run of manifests) {
+				if (run.status !== "running") continue;
 				try {
-					const snapshot = getRunSnapshotCache(currentCtx.cwd).refreshIfStale(run.runId);
+					const snapshot = snapshotCache.get(run.runId);
+					if (!snapshot) continue;
+					// Skip if snapshot shows run already completed/failed (stale cache)
+					if (snapshot.manifest.status !== "running") continue;
 					const summary = summarizeHeartbeats(snapshot, { now });
 					const maybeNotifyHealth = (kind: string, count: number, title: string, body: string): void => {
 						if (count <= 0) return;
@@ -402,18 +498,40 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				}
 			}
 		};
+
+		const fallbackMs = loadedConfig.config.ui?.dashboardLiveRefreshMs ?? 250;
 		renderScheduler = new RenderScheduler(pi.events, renderTick, {
-			fallbackMs: loadedConfig.config.ui?.dashboardLiveRefreshMs ?? 250,
+			fallbackMs,
 			onInvalidate: () => getRunSnapshotCache(ctx.cwd).invalidate(),
 		});
+		// Start async preload loop — refreshes snapshot cache in background
+		startPreloadLoop(fallbackMs);
 	});
 	pi.on("session_before_switch", () => {
 		sessionGeneration++;
+		// Phase 11b: Capture state before session switch
+		const pendingCount = deliveryCoordinator?.getPendingCount() ?? 0;
+		if (pendingCount > 0) {
+			logInternalError("register.session-before-switch", `Switching session with ${pendingCount} pending deliveries`);
+		}
+		deliveryCoordinator?.deactivate();
 		stopAsyncRunNotifier(notifierState);
 		stopSessionBoundSubagents();
 	});
 	pi.on("session_shutdown", () => cleanupRuntime());
 
+	// Phase 11a: Dynamic resource discovery — inject pi-crew skill paths.
+	try {
+		pi.on("resources_discover", () => {
+			const skillDir = path.resolve(process.cwd(), "skills");
+			const extSkillDir = path.resolve(__dirname, "..", "..", "skills");
+			const paths: string[] = [];
+			if (fs.existsSync(extSkillDir)) paths.push(extSkillDir);
+			if (skillDir !== extSkillDir && fs.existsSync(skillDir)) paths.push(skillDir);
+			return paths.length > 0 ? { skillPaths: paths } : {};
+		});
+	} catch { /* older Pi without resources_discover */ }
+
 	registerCompactionGuard(pi, { foregroundControllers });
 
 	// Phase 1.4: Permission gate for destructive team actions.
@@ -432,7 +550,11 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		};
 	});
 
-	registerTeamTool(pi, { foregroundControllers, startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, getMetricRegistry: () => metricRegistry, widgetState });
+	registerTeamTool(pi, { foregroundControllers, startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, getMetricRegistry: () => metricRegistry, widgetState, onJsonEvent: (taskId, runId, event) => {
+		const record = event as Record<string, unknown>;
+		const eventType = typeof record.type === "string" ? record.type : undefined;
+		if (eventType) overflowTracker?.feedEvent(taskId, runId, eventType);
+	} });
 	registerSubagentTools(pi, subagentManager, { ownerSessionGeneration: captureSessionGeneration });
 	time("register.tools");
 

package/src/extension/registration/commands.ts

@@ -74,6 +74,7 @@ async function handleMailboxDashboardAction(ctx: ExtensionCommandContext, runId:
 }
 
 function depsNotify(ctx: ExtensionCommandContext, message: string, level: "info" | "warning" | "error"): void {
+	if (!ctx.hasUI) return;
 	ctx.ui.notify(message, level);
 }
 
@@ -200,14 +201,15 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
-	pi.registerCommand("team-cleanup", { description: "Clean up pi-crew worktrees for a run", handler: async (args: string, ctx: ExtensionCommandContext) => {
-		const tokens = args.trim().split(/\s+/).filter(Boolean);
-		const runId = tokens.find((token) => !token.startsWith("--"));
-		const result = await handleTeamTool({ action: "cleanup", runId, force: tokens.includes("--force") }, ctx);
-		await notifyCommandResult(ctx, commandText(result));
-	} });
+	pi.registerCommand("team-settings", {
+		description: "View or update pi-crew settings: [list|get <key>|set <key> <value>|unset <key>|path|scope]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool({ action: "settings", config: { args: args.trim() } }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
 
-	pi.registerCommand("team-manager", { description: "Open a simple pi-crew interactive manager", handler: handleTeamManagerCommand });
+	pi.registerCommand("team-cleanup", { description: "Open a simple pi-crew interactive manager", handler: handleTeamManagerCommand });
 
 	pi.registerCommand("team-result", { description: "Open a pi-crew agent result viewer: <runId> [taskId]", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const [runId, rawTaskId] = args.trim().split(/\s+/).filter(Boolean);
@@ -215,8 +217,8 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const loaded = selected ? loadRunManifestById(ctx.cwd, selected.runId) : undefined;
 		if (ctx.hasUI && loaded) {
 			const agent = readCrewAgents(loaded.manifest).find((item) => item.taskId === selected?.taskId || item.id === selected?.taskId) ?? readCrewAgents(loaded.manifest)[0];
-			const text = agent?.resultArtifactPath ? commandText(await handleTeamTool({ action: "api", runId: selected!.runId, config: { operation: "read-agent-output", agentId: agent.taskId, maxBytes: 64_000 } }, ctx)) : "(no result)";
-			await ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new DurableTextViewer("pi-crew result", `${selected!.runId}:${agent?.taskId ?? "unknown"}`, text.split(/\r?\n/), theme, done), { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
+			const resultText = agent?.resultArtifactPath ? commandText(await handleTeamTool({ action: "api", runId: selected?.runId ?? "", config: { operation: "read-agent-output", agentId: agent.taskId, maxBytes: 64_000 } }, ctx)) : "(no result)";
+			await ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new DurableTextViewer("pi-crew result", `${selected?.runId ?? ""}:${agent?.taskId ?? "unknown"}`, resultText.split(/\r?\n/), theme, done), { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
 			return;
 		}
 		const result = await handleTeamTool({ action: "api", runId, config: { operation: "read-agent-output", agentId: rawTaskId, maxBytes: 64_000 } }, ctx);