pi-crew 0.1.43 → 0.1.44

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,6 +37,9 @@ 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 };
@@ -83,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();
@@ -148,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);
@@ -207,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();
@@ -314,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);
@@ -328,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();
@@ -360,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) {
@@ -382,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;
@@ -405,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.
@@ -435,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/team-tool.ts

@@ -17,6 +17,7 @@ export interface RegisterTeamToolDeps {
 	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
 	getMetricRegistry?: () => MetricRegistry | undefined;
 	widgetState: CrewWidgetState;
+	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
 
 export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
@@ -38,7 +39,7 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 					const runLabel = resolved.team ?? resolved.agent ?? "direct";
 					pi.setSessionName(`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`);
 				}
-				const output = await handleTeamTool(resolved, { ...ctx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId) });
+				const output = await handleTeamTool(resolved, { ...ctx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId), onJsonEvent: deps.onJsonEvent });
 				if (resolved.action === "run") {
 					pi.appendEntry("crew:run-started", {
 						runId: output.details?.runId,

package/src/extension/run-index.ts

@@ -55,3 +55,22 @@ export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
 	return mergeRuns(roots.map((root) => collectRuns(root, max)), max);
 }
+
+/**
+ * List runs filtered to a specific scope.
+ * - "project": only runs in the project crew root
+ * - "user": only runs in the user crew root
+ * - "all" (default): merge both scopes (current behavior)
+ */
+export function listRunsByScope(cwd: string, scope: "project" | "user" | "all" = "all", max?: number): TeamRunManifest[] {
+	const projectRoot = findRepoRoot(cwd);
+	switch (scope) {
+		case "project":
+			return projectRoot ? collectRuns(projectCrewRoot(cwd), max) : [];
+		case "user":
+			return collectRuns(userCrewRoot(), max);
+		case "all":
+		default:
+			return max !== undefined ? listRecentRuns(cwd, max) : listRuns(cwd);
+	}
+}

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

@@ -110,7 +110,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 				const approval = current.manifest.planApproval;
 				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 				const now = new Date().toISOString();
-				const tasks = current.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: now, error: "Plan approval was cancelled." } : task);
+				const tasks = current.tasks.map((task) => task.status === "queued" || task.status === "running" || task.status === "waiting" ? { ...task, status: "cancelled" as const, finishedAt: now, error: "Plan approval was cancelled." } : task);
 				let manifest: typeof current.manifest = { ...current.manifest, updatedAt: now, planApproval: { ...approval, status: "cancelled" as const, cancelledAt: now, updatedAt: now } };
 				saveRunManifest(manifest);
 				saveRunTasks(manifest, tasks);

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

@@ -1,31 +1,103 @@
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { withRunLockSync } from "../../state/locks.ts";
-import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
-import { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
-import { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
-import { logInternalError } from "../../utils/internal-error.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
-
-export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
-	return withRunLockSync(loaded.manifest, () => {
-		if (loaded.manifest.status === "completed" && !params.force) return result(`Run ${loaded.manifest.runId} is already completed; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-		const tasks = loaded.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." } : task);
-		saveRunTasks(loaded.manifest, tasks);
-		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
-		}
-		try {
-			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
-		}
-		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
-		return result(`Cancelled run ${updated.runId}.`, { action: "cancel", status: "ok", runId: updated.runId, artifactsRoot: updated.artifactsRoot });
-	});
-}
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { withRunLockSync } from "../../state/locks.ts";
+import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
+import { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
+import { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export interface AbortOwnedResult {
+	abortedIds: string[];
+	missingIds: string[];
+	foreignIds: string[];
+}
+
+/**
+ * Classify task IDs by ownership.
+ * - Tasks with status "queued" or "running" that belong to the current session → abortedIds
+ * - Task IDs not found in the run → missingIds
+ * - Tasks with status "queued" or "running" that belong to a different session → foreignIds
+ * - Tasks already completed/failed/cancelled → neither (not included in any list)
+ *
+ * Currently, task ownership is determined by the manifest's run-level ownership.
+ * Since tasks in a single run are all owned by the session that created the run,
+ * the ownerSessionId comes from the context. Foreign detection compares
+ * the requesting session against the run's creating session.
+ */
+export function abortOwned(
+	runId: string,
+	taskIds: string[] | undefined,
+	ctx: TeamContext,
+): AbortOwnedResult {
+	const loaded = loadRunManifestById(ctx.cwd, runId);
+	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
+
+	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
+	const taskMap = new Map(loaded.tasks.map((t) => [t.id, t] as const));
+	const targetIds = taskIds ?? loaded.tasks.map((t) => t.id);
+
+	for (const id of targetIds) {
+		const task = taskMap.get(id);
+		if (!task) {
+			result.missingIds.push(id);
+			continue;
+		}
+		if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") continue;
+		// All tasks in a run are owned by the session that created the run.
+		// Since cancel is always called within the session that created it,
+		// all cancellable tasks are abortable.
+		// Foreign detection is a placeholder for when tasks can be owned
+		// by different sessions (e.g., shared runs with session-scoped tasks).
+		result.abortedIds.push(id);
+	}
+
+	return result;
+}
+
+export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
+	return withRunLockSync(loaded.manifest, () => {
+		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+
+		// Classify tasks for foreign-aware cancellation
+		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx);
+		const cancellableIds = new Set(abortResult.abortedIds);
+
+		const tasks = loaded.tasks.map((task) => {
+			if (cancellableIds.has(task.id) && (task.status === "queued" || task.status === "running" || task.status === "waiting")) {
+				return { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." };
+			}
+			return task;
+		});
+		saveRunTasks(loaded.manifest, tasks);
+		try {
+			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
+		}
+		try {
+			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
+		}
+		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
+
+		// Build descriptive message including foreign/missing info
+		const parts = [`Cancelled run ${updated.runId}.`];
+		if (abortResult.foreignIds.length > 0) parts.push(` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`);
+		if (abortResult.missingIds.length > 0) parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
+
+		return result(parts.join(""), {
+			action: "cancel",
+			status: "ok",
+			runId: updated.runId,
+			artifactsRoot: updated.artifactsRoot,
+			abortedIds: abortResult.abortedIds,
+			missingIds: abortResult.missingIds,
+			foreignIds: abortResult.foreignIds,
+		});
+	});
+}

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

@@ -11,6 +11,7 @@ export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<Extension
 	signal?: AbortSignal;
 	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	onRunStarted?: (runId: string) => void;
+	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 };
 
 export function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {

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

@@ -0,0 +1,67 @@
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { withRunLockSync } from "../../state/locks.ts";
+import { loadRunManifestById, saveRunTasks } from "../../state/state-store.ts";
+import { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+/**
+ * Handle `respond` action: send a message to a waiting (interactive) task.
+ * The task must be in "waiting" status. The message is stored in the task's
+ * mailbox and the task is transitioned back to "running".
+ */
+export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Respond requires runId.", { action: "respond", status: "error" }, true);
+	if (!params.message && !params.taskId) return result("Respond requires taskId and/or message.", { action: "respond", status: "error" }, true);
+
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "respond", status: "error" }, true);
+
+	return withRunLockSync(loaded.manifest, () => {
+		const taskId = params.taskId;
+		const message = params.message ?? "";
+
+		// Find the waiting task(s)
+		const targetTasks = taskId
+			? loaded.tasks.filter((t) => t.id === taskId)
+			: loaded.tasks.filter((t) => t.status === "waiting");
+
+		if (targetTasks.length === 0) {
+			return result(
+				taskId ? `Task '${taskId}' not found or not in waiting state.` : `No waiting tasks in run ${loaded.manifest.runId}.`,
+				{ action: "respond", status: "error" },
+				true,
+			);
+		}
+
+		// Transition waiting tasks back to running
+		const updatedTasks = loaded.tasks.map((task) => {
+			if (task.status !== "waiting") return task;
+			if (taskId && task.id !== taskId) return task;
+			return {
+				...task,
+				status: "running" as const,
+				// Store the response in the task's adaptive field
+				adaptive: {
+					...task.adaptive,
+					phase: "resumed",
+					task: message || task.adaptive?.task || "",
+				},
+			};
+		});
+
+		saveRunTasks(loaded.manifest, updatedTasks);
+		try {
+			saveCrewAgents(loaded.manifest, updatedTasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+		} catch (error) {
+			logInternalError("team-tool.handleRespond.crewAgents", error, `runId=${loaded.manifest.runId}`);
+		}
+
+		const resumedIds = targetTasks.map((t) => t.id);
+		return result(
+			`Resumed ${resumedIds.length} task(s): ${resumedIds.join(", ")}. Message: ${message || "(no message)"}`,
+			{ action: "respond", status: "ok", runId: loaded.manifest.runId, resumedIds },
+		);
+	});
+}

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

@@ -136,7 +136,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	if (executeWorkers && ctx.startForegroundRun) {
 		ctx.onRunStarted?.(updatedManifest.runId);
 		ctx.startForegroundRun(async (signal) => {
-			await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry });
+			await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
 		}, updatedManifest.runId);
 		const text = [
 			`Started foreground pi-crew run ${updatedManifest.runId}.`,
@@ -152,7 +152,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		].join("\n");
 		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
 	}
-	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry });
+	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,

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

@@ -8,6 +8,7 @@ import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
 import { formatTaskGraphLines, waitingReason } from "../../runtime/task-display.ts";
+import { verifyTaskCompletion, formatOutputPreview } from "../../runtime/completion-guard.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
 
@@ -52,7 +53,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const totalUsage = aggregateUsage(tasks);
 	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
 	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
-	const waitingTasks = tasks.filter((task) => task.status === "queued");
+	const waitingTasks = tasks.filter((task) => task.status === "queued" || task.status === "waiting");
 	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState ? ` activityState=${agent.progress.activityState}` : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.outputPath ? ` output=${agent.outputPath}` : ""}${agent.transcriptPath ? ` transcript=${agent.transcriptPath}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
 	const lines = [
 		`Run: ${manifest.runId}`,
@@ -71,6 +72,11 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Tasks:",
 		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.modelRouting ? ` modelRouting=${task.modelRouting.requested ? `${task.modelRouting.requested}->` : ""}${task.modelRouting.resolved}${task.modelRouting.usedAttempt ? ` attempt=${task.modelRouting.usedAttempt + 1}` : ""}` : ""}${task.agentProgress?.activityState ? ` activityState=${task.agentProgress.activityState}` : ""}${attentionByTask.get(task.id)?.data?.reason ? ` attention=${String(attentionByTask.get(task.id)?.data?.reason)}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.resultArtifact ? ` result=${task.resultArtifact.path}` : ""}${task.transcriptArtifact ? ` transcript=${task.transcriptArtifact.path}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+		"Completion verification:",
+		...(tasks.filter((t) => t.status === "completed").length ? tasks.filter((t) => t.status === "completed").map((t) => {
+			const guard = verifyTaskCompletion(t, manifest);
+			return `- ${t.id} green=${guard.greenLevel}/3${guard.warnings.length ? ` warnings=[${guard.warnings.join(", ")}]` : ""}`;
+		}) : ["- (no completed tasks)"]),
 		"Active agents:",
 		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
 		"Waiting tasks:",

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

@@ -3,4 +3,8 @@ export interface TeamToolDetails {
 	status: "ok" | "error" | "planned";
 	runId?: string;
 	artifactsRoot?: string;
+	abortedIds?: string[];
+	missingIds?: string[];
+	foreignIds?: string[];
+	resumedIds?: string[];
 }

package/src/extension/team-tool.ts

@@ -44,6 +44,7 @@ import { handleStatus } from "./team-tool/status.ts";
 import { handleArtifacts, handleEvents, handleSummary } from "./team-tool/inspect.ts";
 import { handleCleanup, handleExport, handleForget, handleImport, handleImports, handlePrune, handleWorktrees } from "./team-tool/lifecycle-actions.ts";
 import { handleCancel } from "./team-tool/cancel.ts";
+import { handleRespond } from "./team-tool/respond.ts";
 import { handlePlan } from "./team-tool/plan.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
@@ -278,6 +279,7 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		case "run": return handleRun(params, ctx);
 		case "status": return handleStatus(params, ctx);
 		case "cancel": return handleCancel(params, ctx);
+		case "respond": return handleRespond(params, ctx);
 		case "plan": return handlePlan(params, ctx);
 		case "resume": return handleResume(params, ctx);
 		case "create": return handleCreate(params, ctx);

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

@@ -24,6 +24,9 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const mailboxCount = registry.counter("crew.mailbox.count", "Total mailbox messages by direction");
 	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task");
 	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
+	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
+	const waitingCount = registry.counter("crew.task.waiting_total", "Tasks entering waiting state");
+	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
 	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds");
 	const taskDuration = registry.histogram("crew.task.duration_ms", "Task duration, milliseconds");
@@ -38,6 +41,9 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		["crew.task.failed", () => taskCount.inc({ status: "failed" })],
 		["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") }); }],
+		["task.waiting", (data) => { const item = recordValue(data); waitingCount.inc({ taskId: stringValue(item.taskId, "unknown"), runId: stringValue(item.runId, "unknown") }); }],
+		["supervisor.contact", (data) => { const item = recordValue(data); supervisorContactCount.inc({ reason: stringValue(item.reason, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
 		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],
 		["crew.mailbox.message", (data) => { const item = recordValue(data); mailboxCount.inc({ direction: stringValue(item.direction, "unknown") }); }],