pi-crew 0.1.46 → 0.1.49

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/help.ts

@@ -11,6 +11,7 @@ export function piTeamsHelp(): string {
 		"- /team-summary <runId>",
 		"- /team-resume <runId>",
 		"- /team-cancel <runId>",
+	"- /team-retry <runId> [taskId]",
 		"",
 		"Inspection:",
 		"- /team-events <runId>",

package/src/extension/management.ts

@@ -6,6 +6,8 @@ import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import type { TeamToolDetails } from "./team-tool-types.ts";
 import { toolResult, type PiTeamsToolResult } from "./tool-result.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
+import type { PiTeamsConfig } from "../config/config.ts";
+import { enforceDestructiveIntent } from "./team-tool/intent-policy.ts";
 import type { TeamConfig, TeamRole } from "../teams/team-config.ts";
 import { serializeTeam } from "../teams/team-serializer.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
@@ -17,6 +19,7 @@ import { hasOwn, parseConfigObject, requireString, sanitizeName } from "../utils
 
 interface ManagementContext {
 	cwd: string;
+	config?: PiTeamsConfig;
 }
 
 type MutableSource = "user" | "project";
@@ -359,6 +362,8 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 }
 
 export function handleDelete(params: TeamToolParamsValue, ctx: ManagementContext): PiTeamsToolResult {
+	const intentError = enforceDestructiveIntent("delete", params, ctx.config);
+	if (intentError) return intentError;
 	if (!params.confirm) return result("delete requires confirm: true.", "error", true);
 	const resolved = resolveMutable(ctx, params);
 	if (resolved.error) return resolved.error;

package/src/extension/register.ts

@@ -9,7 +9,7 @@ import { notifyActiveRuns } from "./session-summary.ts";
 import { LiveRunSidebar } from "../ui/live-run-sidebar.ts";
 import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.ts";
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
-import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerbar } from "../ui/powerbar-publisher.ts";
+import { clearPiCrewPowerbar, disposePowerbarCoalescer, registerPiCrewPowerbarSegments, requestPowerbarUpdate, 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";
@@ -37,7 +37,7 @@ import { createMetricFileSink, type MetricSink } from "../observability/metric-s
 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 { cancelOrphanedRuns, detectInterruptedRuns, purgeStaleActiveRunIndex } 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";
@@ -113,7 +113,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			if (currentCtx) {
 				const uiConfig = loadConfig(currentCtx.cwd).config.ui;
 				updateCrewWidget(currentCtx, widgetState, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd));
-				updatePiCrewPowerbar(pi.events, currentCtx.cwd, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
+				requestPowerbarUpdate(pi.events, currentCtx.cwd, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
 			}
 		});
 	};
@@ -236,12 +236,12 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			pi.events?.emit?.(event, payload);
 		},
 	);
-	const foregroundControllers = new Set<AbortController>();
+	const foregroundControllers = new Map<string | symbol, 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();
+		for (const controller of foregroundControllers.values()) controller.abort();
 		foregroundControllers.clear();
 		subagentManager.abortAll();
 		terminateActiveChildPiProcesses();
@@ -277,7 +277,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string): void => {
 		const ownerGeneration = captureSessionGeneration();
 		const controller = new AbortController();
-		foregroundControllers.add(controller);
+		const key = runId ?? Symbol();
+		foregroundControllers.set(key, controller);
 		if (ctx.hasUI) {
 			setWorkingIndicator(ctx, { frames: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"], intervalMs: 80 });
 			ctx.ui.setWorkingMessage(runId ? `pi-crew foreground run ${runId}...` : "pi-crew foreground run...");
@@ -295,9 +296,10 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 						}
 					}
 					if (isContextCurrent(ctx, ownerGeneration)) ctx.ui.notify(`pi-crew foreground run failed: ${message}`, "error");
+				else logInternalError("register.foreground-run-failure", error, `runId=${runId} context disposed`);
 				})
 				.finally(() => {
-					foregroundControllers.delete(controller);
+					foregroundControllers.delete(key);
 					const ownerCurrent = isContextCurrent(ctx, ownerGeneration);
 					if (ownerCurrent && ctx.hasUI) {
 						setWorkingIndicator(ctx);
@@ -334,7 +336,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 					if (ownerCurrent && currentCtx) {
 						const config = loadConfig(currentCtx.cwd).config.ui;
 						updateCrewWidget(currentCtx, widgetState, config, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd));
-						updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
+						requestPowerbarUpdate(pi.events, currentCtx.cwd, config, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
 					}
 				});
 		});
@@ -350,8 +352,20 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		if (preloadTimer) { clearTimeout(preloadTimer); preloadTimer = undefined; }
 		stopSessionBoundSubagents();
 		stopAsyncRunNotifier(notifierState);
+
+		// P0: Purge all stale active-run-index entries on session cleanup.
+		// This handles: normal exit, SIGTERM, Ctrl+C — any case where cleanupRuntime fires.
+		// For SIGKILL / crash / SIGHUP (where cleanupRuntime does NOT fire),
+		// purgeStaleActiveRunIndex() runs at next session_start instead.
+		try {
+			purgeStaleActiveRunIndex();
+		} catch (error) {
+			logInternalError("register.cleanupRuntime.purgeStale", error);
+		}
+
 		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
 		clearPiCrewPowerbar(pi.events, currentCtx);
+		disposePowerbarCoalescer();
 		heartbeatWatcher?.dispose();
 		metricSink?.dispose();
 		eventMetricSub?.dispose();
@@ -394,6 +408,30 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		if (widgetState.interval) clearInterval(widgetState.interval);
 		widgetState.interval = undefined;
 		notifyActiveRuns(ctx);
+
+		// Auto-cancel orphaned runs from dead sessions
+		const currentSessionId = (ctx as unknown as Record<string, unknown>).sessionId as string | undefined;
+		if (currentSessionId) {
+			try {
+				const { cancelled } = cancelOrphanedRuns(ctx.cwd, getManifestCache(ctx.cwd), currentSessionId);
+				if (cancelled.length > 0) {
+					notifyOperator({ id: `orphan_cleanup`, severity: "info", source: "crash-recovery", title: `Cleaned up ${cancelled.length} orphaned run(s)`, body: `Runs from previous sessions were auto-cancelled: ${cancelled.join(", ")}` });
+				}
+			} catch (error) {
+				logInternalError("register.sessionStart.orphanCleanup", error);
+			}
+		}
+
+		// Global purge of stale active-run-index entries (temp dirs, dead workers, etc.)
+		try {
+			const { purged } = purgeStaleActiveRunIndex();
+			if (purged.length > 0) {
+				notifyOperator({ id: `active_index_purge`, severity: "info", source: "crash-recovery", title: `Purged ${purged.length} stale active-run-index entr${purged.length === 1 ? "y" : "ies"}`, body: `Cleaned up global active run index` });
+			}
+		} catch (error) {
+			logInternalError("register.sessionStart.globalIndexPurge", error);
+		}
+
 		const loadedConfig = loadConfig(ctx.cwd);
 		autoRecoveryLast.clear();
 		configureNotifications(ctx);
@@ -474,7 +512,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			} else {
 				updateCrewWidget(currentCtx, widgetState, config, activeCache, snapshotCache, manifests);
 			}
-			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, activeCache, snapshotCache, currentCtx, widgetState.notificationCount ?? 0, manifests);
+			requestPowerbarUpdate(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 manifests) {
@@ -541,6 +579,12 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		});
 	} catch { /* older Pi without resources_discover */ }
 
+	const abortForegroundRun = (runId: string): boolean => {
+		const controller = foregroundControllers.get(runId);
+		if (!controller) return false;
+		controller.abort();
+		return true;
+	};
 	registerCompactionGuard(pi, { foregroundControllers });
 
 	// Phase 1.4: Permission gate for destructive team actions.
@@ -552,14 +596,15 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		const action = typeof input.action === "string" ? input.action : undefined;
 		const destructiveActions = new Set(["delete", "forget", "prune", "cleanup"]);
 		if (!action || !destructiveActions.has(action)) return;
-		if (input.confirm === true || input.force === true) return;
+		const forceBypassesReferenceChecks = action === "delete" && input.force === true;
+		if (input.confirm === true || forceBypassesReferenceChecks) return;
 		return {
 			block: true,
-			reason: `Destructive action '${action}' requires confirm=true (or force=true to bypass reference checks).`,
+			reason: `Destructive action '${action}' requires confirm=true${action === "delete" ? " (or force=true to bypass reference checks)" : ""}.`,
 		};
 	});
 
-	registerTeamTool(pi, { foregroundControllers, startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, getMetricRegistry: () => metricRegistry, widgetState, onJsonEvent: (taskId, runId, event) => {
+	registerTeamTool(pi, { foregroundControllers, startForegroundRun, abortForegroundRun, 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);
@@ -567,7 +612,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	registerSubagentTools(pi, subagentManager, { ownerSessionGeneration: captureSessionGeneration });
 	time("register.tools");
 
-	registerTeamCommands(pi, { startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, getMetricRegistry: () => metricRegistry, dismissNotifications: () => {
+	registerTeamCommands(pi, { startForegroundRun, abortForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, getMetricRegistry: () => metricRegistry, dismissNotifications: () => {
 		widgetState.notificationCount = 0;
 		if (currentCtx) {
 			const uiConfig = loadConfig(currentCtx.cwd).config.ui;

package/src/extension/registration/commands.ts

@@ -27,6 +27,7 @@ import type { MetricRegistry } from "../../observability/metric-registry.ts";
 
 export interface RegisterTeamCommandsDeps {
 	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
+	abortForegroundRun: (runId: string) => boolean;
 	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
 	getManifestCache: (cwd: string) => { list(max?: number): TeamRunManifest[] };
 	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
@@ -135,7 +136,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	pi.registerCommand("team-run", {
 		description: "Manually start a pi-crew run (agent may also use the team tool autonomously)",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
-			const result = await handleTeamTool(parseRunArgs(args), { ...teamCommandContext(ctx), metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx as ExtensionContext, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx as ExtensionContext, runId) });
+			const result = await handleTeamTool(parseRunArgs(args), { ...teamCommandContext(ctx), metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx as ExtensionContext, runner, runId), abortForegroundRun: deps.abortForegroundRun, onRunStarted: (runId) => deps.openLiveSidebar(ctx as ExtensionContext, runId) });
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});
@@ -157,6 +158,21 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		} });
 	}
 
+	pi.registerCommand("team-retry", {
+		description: "Retry failed/cancelled pi-crew tasks: <runId> [taskId]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.shift();
+			const taskId = tokens.shift();
+			if (!runId) {
+				await notifyCommandResult(ctx, "Usage: /team-retry <runId> [taskId]");
+				return;
+			}
+			const retryResult = await handleTeamTool({ action: "retry", runId, taskId }, teamCommandContext(ctx));
+			await notifyCommandResult(ctx, commandText(retryResult));
+		},
+	});
+
 	pi.registerCommand("team-respond", {
 		description: "Respond to a waiting pi-crew task: <runId> <taskId|--all> <message>",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
@@ -170,6 +186,22 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		},
 	});
 
+	pi.registerCommand("team-follow-up", {
+		description: "Send a follow-up prompt to a pi-crew task: <runId> <taskId> <prompt>",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.shift();
+			const taskId = tokens.shift();
+			const prompt = tokens.join(" ") || undefined;
+			if (!runId || !taskId || !prompt) {
+				await notifyCommandResult(ctx, "Usage: /team-follow-up <runId> <taskId> <prompt>. Use /team-respond for waiting-task replies.");
+				return;
+			}
+			const result = await handleTeamTool({ action: "api", runId, config: { operation: "follow-up-agent", taskId, prompt } }, teamCommandContext(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) => {