pi-crew 0.1.43 → 0.1.45

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/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,10 @@ 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 { createSessionSnapshot } from "../runtime/session-snapshot.ts";
 import { initI18n } from "../i18n.ts";
 
 export { __test__subagentSpawnParams };
@@ -83,6 +90,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 +157,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 +238,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 +346,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 +361,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 +397,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 +471,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 +499,46 @@ 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++;
+		const pendingCount = deliveryCoordinator?.getPendingCount() ?? 0;
+		try {
+			const activeRuns = currentCtx ? getManifestCache(currentCtx.cwd).list(50).filter((run) => run.status === "running" || run.status === "queued" || run.status === "blocked") : [];
+			const snapshot = createSessionSnapshot(activeRuns, pendingCount, sessionGeneration);
+			if (pendingCount > 0 || snapshot.activeRunIds.length > 0) logInternalError("register.session-before-switch", undefined, JSON.stringify(snapshot));
+		} catch (error) {
+			logInternalError("register.session-before-switch.snapshot", error);
+		}
+		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 +557,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

@@ -151,12 +151,28 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		} });
 	}
 
+	pi.registerCommand("team-respond", {
+		description: "Respond to a waiting pi-crew task: <runId> <taskId|--all> <message>",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.shift();
+			const taskToken = tokens[0] === "--all" ? tokens.shift() : tokens.shift();
+			const taskId = taskToken === "--all" ? undefined : taskToken;
+			const message = tokens.join(" ") || undefined;
+			const result = await handleTeamTool({ action: "respond", runId, taskId, message }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
 	pi.registerCommand("team-api", {
 		description: "Run safe pi-crew API interop operations: <runId> <operation> [key=value]",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const tokens = args.trim().split(/\s+/).filter(Boolean);
-			const runId = tokens.find((token) => !token.includes("=") && !token.startsWith("--"));
-			const operation = tokens.find((token) => token !== runId && !token.includes("=") && !token.startsWith("--")) ?? "read-manifest";
+			const positional = tokens.filter((token) => !token.includes("=") && !token.startsWith("--"));
+			const runIdLessOperations = new Set(["metrics-snapshot"]);
+			const first = positional[0];
+			const runId = first && runIdLessOperations.has(first) ? undefined : first;
+			const operation = runId ? (positional[1] ?? "read-manifest") : (first ?? "read-manifest");
 			const config: Record<string, unknown> = { operation };
 			for (const token of tokens.filter((item) => item.includes("="))) {
 				const [key, ...rest] = token.split("=");