pi-crew 0.1.45 → 0.1.49

package/src/extension/project-init.ts

@@ -1,10 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { packageRoot, projectCrewRoot } from "../utils/paths.ts";
+import { configPath as globalConfigPath } from "../config/config.ts";
+import { DEFAULT_UI } from "../config/defaults.ts";
+import { packageRoot, projectCrewRoot, projectPiRoot } from "../utils/paths.ts";
 
 export interface ProjectInitOptions {
 	copyBuiltins?: boolean;
 	overwrite?: boolean;
+	configScope?: "global" | "project" | "none";
 }
 
 export interface ProjectInitResult {
@@ -13,6 +16,10 @@ export interface ProjectInitResult {
 	skippedFiles: string[];
 	gitignorePath: string;
 	gitignoreUpdated: boolean;
+	configPath: string;
+	configScope: "global" | "project" | "none";
+	configCreated: boolean;
+	configSkipped: boolean;
 }
 
 function ensureDir(dir: string, createdDirs: string[]): void {
@@ -24,6 +31,44 @@ function ensureDir(dir: string, createdDirs: string[]): void {
 	}
 }
 
+const DEFAULT_PI_CREW_CONFIG = {
+	// Keep generated config non-invasive: do not set runtime/limits defaults here.
+	// Those are provided by pi-crew internals and should not make a normal workflow block.
+	autonomous: {
+		enabled: true,
+		injectPolicy: true,
+		preferAsyncForLongTasks: false,
+		allowWorktreeSuggestion: true,
+	},
+	agents: {
+		overrides: {
+			explorer: { model: false, thinking: "off" },
+			writer: { model: false, thinking: "off" },
+			planner: { model: false, thinking: "medium" },
+			analyst: { model: false, thinking: "off" },
+			critic: { model: false, thinking: "low" },
+			executor: { model: false, thinking: "medium" },
+			reviewer: { model: false, thinking: "off" },
+			"security-reviewer": { model: false, thinking: "medium" },
+			"test-engineer": { model: false, thinking: "low" },
+			verifier: { model: false, thinking: "off" },
+		},
+	},
+	ui: {
+		widgetPlacement: DEFAULT_UI.widgetPlacement,
+		widgetMaxLines: DEFAULT_UI.widgetMaxLines,
+		powerbar: DEFAULT_UI.powerbar,
+		dashboardPlacement: DEFAULT_UI.dashboardPlacement,
+		dashboardWidth: DEFAULT_UI.dashboardWidth,
+		dashboardLiveRefreshMs: DEFAULT_UI.dashboardLiveRefreshMs,
+		autoOpenDashboard: DEFAULT_UI.autoOpenDashboard,
+		autoOpenDashboardForForegroundRuns: DEFAULT_UI.autoOpenDashboardForForegroundRuns,
+		showModel: DEFAULT_UI.showModel,
+		showTokens: DEFAULT_UI.showTokens,
+		showTools: DEFAULT_UI.showTools,
+	},
+};
+
 function copyBuiltinDir(kind: "agents" | "teams" | "workflows", targetDir: string, overwrite: boolean, copiedFiles: string[], skippedFiles: string[]): void {
 	const sourceDir = path.join(packageRoot(), kind);
 	if (!fs.existsSync(sourceDir)) return;
@@ -50,11 +95,26 @@ export function initializeProject(cwd: string, options: ProjectInitOptions = {})
 	const agentsDir = path.join(crewRoot, "agents");
 	const teamsDir = path.join(crewRoot, "teams");
 	const workflowsDir = path.join(crewRoot, "workflows");
+	const configScope = options.configScope ?? "global";
+	const configPath = configScope === "project" ? path.join(projectPiRoot(cwd), "pi-crew.json") : configScope === "global" ? globalConfigPath() : "";
 	ensureDir(agentsDir, createdDirs);
 	ensureDir(teamsDir, createdDirs);
 	ensureDir(workflowsDir, createdDirs);
 	ensureDir(path.join(crewRoot, "imports"), createdDirs);
 
+	let configCreated = false;
+	let configSkipped = false;
+	if (configPath) {
+		if (configScope === "project") ensureDir(path.dirname(configPath), createdDirs);
+		else fs.mkdirSync(path.dirname(configPath), { recursive: true });
+		if (!fs.existsSync(configPath) || options.overwrite === true) {
+			fs.writeFileSync(configPath, `${JSON.stringify(DEFAULT_PI_CREW_CONFIG, null, 2)}\n`, "utf-8");
+			configCreated = true;
+		} else {
+			configSkipped = true;
+		}
+	}
+
 	if (options.copyBuiltins) {
 		copyBuiltinDir("agents", agentsDir, options.overwrite === true, copiedFiles, skippedFiles);
 		copyBuiltinDir("teams", teamsDir, options.overwrite === true, copiedFiles, skippedFiles);
@@ -72,5 +132,5 @@ export function initializeProject(cwd: string, options: ProjectInitOptions = {})
 		gitignoreUpdated = true;
 	}
 
-	return { createdDirs, copiedFiles, skippedFiles, gitignorePath, gitignoreUpdated };
+	return { createdDirs, copiedFiles, skippedFiles, gitignorePath, gitignoreUpdated, configPath, configScope, configCreated, configSkipped };
 }

package/src/extension/register.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import { loadConfig } from "../config/config.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
 import { startAsyncRunNotifier, stopAsyncRunNotifier, type AsyncNotifierState } from "./async-notifier.ts";
@@ -8,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";
@@ -36,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";
@@ -112,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);
 			}
 		});
 	};
@@ -235,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();
@@ -253,18 +254,18 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const openLiveSidebar = (ctx: ExtensionContext, runId: string): void => {
 		const uiConfig = loadConfig(ctx.cwd).config.ui;
 		const autoOpen = uiConfig?.autoOpenDashboard === true;
-		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns !== false;
-		if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? "right") !== "right") return;
+		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns ?? DEFAULT_UI.autoOpenDashboardForForegroundRuns;
+		if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? DEFAULT_UI.dashboardPlacement) !== "right") return;
 		if (liveSidebarRunId === runId) return;
 		liveSidebarRunId = runId;
-		const widgetPlacement = uiConfig?.widgetPlacement ?? "aboveEditor";
+		const widgetPlacement = uiConfig?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 		setExtensionWidget(ctx, "pi-crew", undefined, { placement: widgetPlacement });
 		setExtensionWidget(ctx, "pi-crew-active", undefined, { placement: widgetPlacement });
 		widgetState.lastVisibility = "hidden";
 		widgetState.lastPlacement = widgetPlacement;
 		widgetState.lastKey = "pi-crew-active";
 		widgetState.model = undefined;
-		const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56));
+		const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? DEFAULT_UI.dashboardWidth));
 		void showCustom<undefined>(ctx, (_tui, theme, _keybindings, done) => new LiveRunSidebar({ cwd: ctx.cwd, runId, done, theme, config: uiConfig, snapshotCache: getRunSnapshotCache(ctx.cwd) }), {
 			overlay: true,
 			overlayOptions: { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 }, visible: (termWidth: number) => termWidth >= 100 },
@@ -276,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...");
@@ -294,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);
@@ -333,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);
 					}
 				});
 		});
@@ -349,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();
@@ -393,12 +408,36 @@ 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);
 		configureObservability(ctx);
 		configureDeliveryCoordinator();
-		const sessionId = (ctx as unknown as Record<string, unknown>).sessionId;
+		const sessionId = ctx.sessionManager?.getSessionId?.() ?? (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);
@@ -460,7 +499,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			const snapshotCache = lastFrameSnapshotCache ?? getRunSnapshotCache(currentCtx.cwd);
 			const manifests = lastPreloadedManifests.length > 0 ? lastPreloadedManifests : activeCache.list(20);
 			if (liveSidebarRunId) {
-				const placement = config?.widgetPlacement ?? "aboveEditor";
+				const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 				if (widgetState.lastVisibility !== "hidden" || widgetState.lastPlacement !== placement) {
 					setExtensionWidget(currentCtx, "pi-crew", undefined, { placement });
 					setExtensionWidget(currentCtx, "pi-crew-active", undefined, { placement });
@@ -473,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) {
@@ -500,7 +539,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			}
 		};
 
-		const fallbackMs = loadedConfig.config.ui?.dashboardLiveRefreshMs ?? 250;
+		const fallbackMs = loadedConfig.config.ui?.dashboardLiveRefreshMs ?? DEFAULT_UI.refreshMs;
 		renderScheduler = new RenderScheduler(pi.events, renderTick, {
 			fallbackMs,
 			onInvalidate: () => getRunSnapshotCache(ctx.cwd).invalidate(),
@@ -530,8 +569,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	// 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 sessionCwd = currentCtx?.cwd ?? process.cwd();
+			const skillDir = path.resolve(sessionCwd, "skills");
+			const extSkillDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
 			const paths: string[] = [];
 			if (fs.existsSync(extSkillDir)) paths.push(extSkillDir);
 			if (skillDir !== extSkillDir && fs.existsSync(skillDir)) paths.push(skillDir);
@@ -539,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.
@@ -550,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);
@@ -565,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

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 import { handleTeamTool } from "../team-tool.ts";
+import { withSessionId } from "../team-tool/context.ts";
 import { piTeamsHelp } from "../help.ts";
 import { handleTeamManagerCommand } from "../team-manager-command.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
@@ -15,6 +16,7 @@ import { MailboxDetailOverlay, type MailboxAction } from "../../ui/overlays/mail
 import { MailboxComposeOverlay, type MailboxComposeResult } from "../../ui/overlays/mailbox-compose-overlay.ts";
 import { AgentPickerOverlay } from "../../ui/overlays/agent-picker-overlay.ts";
 import { dispatchDiagnosticExport, dispatchHealthRecovery, dispatchKillStaleWorkers, dispatchMailboxAck, dispatchMailboxAckAll, dispatchMailboxCompose, dispatchMailboxNudge } from "../../ui/run-action-dispatcher.ts";
+import { DEFAULT_UI } from "../../config/defaults.ts";
 import { listRecentDiagnostic } from "../../runtime/diagnostic-export.ts";
 import { commandText, notifyCommandResult, parseRunArgs, parseScalar, pushUnset, setNestedConfig } from "./command-utils.ts";
 import { openTranscriptViewer, selectAgentTask } from "./viewers.ts";
@@ -25,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>;
@@ -78,6 +81,10 @@ function depsNotify(ctx: ExtensionCommandContext, message: string, level: "info"
 	ctx.ui.notify(message, level);
 }
 
+function teamCommandContext(ctx: ExtensionCommandContext): ExtensionCommandContext & { sessionId?: string } {
+	return withSessionId(ctx);
+}
+
 async function handleHealthDashboardAction(ctx: ExtensionCommandContext, selection: RunDashboardSelection): Promise<void> {
 	const loaded = loadRunManifestById(ctx.cwd, selection.runId);
 	if (!loaded) {
@@ -121,7 +128,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	pi.registerCommand("teams", {
 		description: "List pi-crew teams, workflows, and agents",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
-			const result = await handleTeamTool({ action: "list" }, ctx);
+			const result = await handleTeamTool({ action: "list" }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});
@@ -129,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), { ...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));
 		},
 	});
@@ -146,11 +153,26 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	] as const) {
 		pi.registerCommand(name, { description, handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const runId = args.trim() || undefined;
-			const result = await handleTeamTool({ action, runId }, ctx);
+			const result = await handleTeamTool({ action, runId }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 		} });
 	}
 
+	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) => {
@@ -159,7 +181,23 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 			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);
+			const result = await handleTeamTool({ action: "respond", runId, taskId, message }, teamCommandContext(ctx));
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	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));
 		},
 	});
@@ -178,19 +216,19 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 				const [key, ...rest] = token.split("=");
 				if (key) config[key] = parseScalar(rest.join("="));
 			}
-			const result = await handleTeamTool({ action: "api", runId, config }, ctx);
+			const result = await handleTeamTool({ action: "api", runId, config }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});
 
 	pi.registerCommand("team-metrics", { description: "Show pi-crew metrics snapshot: [filter]", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const filter = args.trim() || undefined;
-		const result = await handleTeamTool({ action: "api", config: { operation: "metrics-snapshot", filter } }, { ...ctx, metricRegistry: deps.getMetricRegistry?.() });
+		const result = await handleTeamTool({ action: "api", config: { operation: "metrics-snapshot", filter } }, { ...teamCommandContext(ctx), metricRegistry: deps.getMetricRegistry?.() });
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
 	pi.registerCommand("team-imports", { description: "List imported pi-crew run bundles", handler: async (_args: string, ctx: ExtensionCommandContext) => {
-		const result = await handleTeamTool({ action: "imports" }, ctx);
+		const result = await handleTeamTool({ action: "imports" }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
@@ -198,7 +236,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const tokens = args.trim().split(/\s+/).filter(Boolean);
 		const pathArg = tokens.find((token) => !token.startsWith("--"));
 		const scope = tokens.includes("--user") ? "user" : "project";
-		const result = await handleTeamTool({ action: "import", config: { path: pathArg, scope } }, ctx);
+		const result = await handleTeamTool({ action: "import", config: { path: pathArg, scope } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
@@ -206,21 +244,21 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const tokens = args.trim().split(/\s+/).filter(Boolean);
 		const keepToken = tokens.find((token) => token.startsWith("--keep="));
 		const keep = keepToken ? Number.parseInt(keepToken.slice("--keep=".length), 10) : undefined;
-		const result = await handleTeamTool({ action: "prune", keep, confirm: tokens.includes("--confirm") }, ctx);
+		const result = await handleTeamTool({ action: "prune", keep, confirm: tokens.includes("--confirm") }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
 	pi.registerCommand("team-forget", { description: "Forget a pi-crew run by deleting its state and artifacts", 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: "forget", runId, force: tokens.includes("--force"), confirm: tokens.includes("--confirm") }, ctx);
+		const result = await handleTeamTool({ action: "forget", runId, force: tokens.includes("--force"), confirm: tokens.includes("--confirm") }, teamCommandContext(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);
+			const result = await handleTeamTool({ action: "settings", config: { args: args.trim() } }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});
@@ -233,18 +271,18 @@ 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 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)";
+			const resultText = agent?.resultArtifactPath ? commandText(await handleTeamTool({ action: "api", runId: selected?.runId ?? "", config: { operation: "read-agent-output", agentId: agent.taskId, maxBytes: 64_000 } }, teamCommandContext(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);
+		const result = await handleTeamTool({ action: "api", runId, config: { operation: "read-agent-output", agentId: rawTaskId, maxBytes: 64_000 } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
 	pi.registerCommand("team-transcript", { description: "Open a pi-crew transcript viewer: <runId> [taskId]", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const [runId, taskId] = args.trim().split(/\s+/).filter(Boolean);
 		if (await openTranscriptViewer(ctx, runId, taskId)) return;
-		const result = await handleTeamTool({ action: "api", runId, config: { operation: "read-agent-transcript", agentId: taskId } }, ctx);
+		const result = await handleTeamTool({ action: "api", runId, config: { operation: "read-agent-transcript", agentId: taskId } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
@@ -252,8 +290,8 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		for (;;) {
 			const runs = deps.getManifestCache(ctx.cwd).list(50);
 			const uiConfig = loadConfig(ctx.cwd).config.ui;
-			const rightPanel = uiConfig?.dashboardPlacement !== "center";
-			const width = rightPanel ? Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56)) : "90%";
+			const rightPanel = (uiConfig?.dashboardPlacement ?? DEFAULT_UI.dashboardPlacement) === "right";
+			const width = rightPanel ? Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? DEFAULT_UI.dashboardWidth)) : "90%";
 			const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { placement: rightPanel ? "right" : "center", showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools, snapshotCache: deps.getRunSnapshotCache?.(ctx.cwd), runProvider: () => deps.getManifestCache(ctx.cwd).list(50), registry: deps.getMetricRegistry?.() }), { overlay: true, overlayOptions: rightPanel ? { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 } } : { width, maxHeight: "90%", anchor: "center", margin: 2 } });
 			if (!selection) return;
 			if (selection.action === "reload") continue;
@@ -273,7 +311,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 				continue;
 			}
 			if (selection.action === "agent-transcript" && await openTranscriptViewer(ctx, selection.runId)) continue;
-			const result = selection.action === "api" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, ctx) : selection.action === "agents" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "agent-dashboard" } }, ctx) : selection.action === "mailbox" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-mailbox" } }, ctx) : selection.action === "agent-events" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-events", limit: 50 } }, ctx) : selection.action === "agent-output" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-output", maxBytes: 32_000 } }, ctx) : selection.action === "agent-transcript" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-transcript" } }, ctx) : await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
+			const result = selection.action === "api" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, teamCommandContext(ctx)) : selection.action === "agents" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "agent-dashboard" } }, teamCommandContext(ctx)) : selection.action === "mailbox" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-mailbox" } }, teamCommandContext(ctx)) : selection.action === "agent-events" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-events", limit: 50 } }, teamCommandContext(ctx)) : selection.action === "agent-output" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-output", maxBytes: 32_000 } }, teamCommandContext(ctx)) : selection.action === "agent-transcript" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-transcript" } }, teamCommandContext(ctx)) : await handleTeamTool({ action: selection.action, runId: selection.runId }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 			return;
 		}
@@ -285,14 +323,15 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const uiConfig = loadConfig(ctx.cwd).config.ui;
 		const styleArg = tokens.find((t) => t === "cat" || t === "armin");
 		const effectArg = tokens.find((t) => ["random", "none", "typewriter", "scanline", "rain", "fade", "crt", "glitch", "dissolve"].includes(t));
-		const style = (styleArg as "cat" | "armin" | undefined) ?? uiConfig?.mascotStyle ?? "cat";
-		const effect = (effectArg as "random" | "none" | "typewriter" | "scanline" | "rain" | "fade" | "crt" | "glitch" | "dissolve" | undefined) ?? uiConfig?.mascotEffect ?? "random";
+		const style = (styleArg as "cat" | "armin" | undefined) ?? uiConfig?.mascotStyle ?? DEFAULT_UI.mascotStyle;
+		const effect = (effectArg as "random" | "none" | "typewriter" | "scanline" | "rain" | "fade" | "crt" | "glitch" | "dissolve" | undefined) ?? uiConfig?.mascotEffect ?? DEFAULT_UI.mascotEffect;
 		await ctx.ui.custom<undefined>((tui, theme, _keybindings, done) => new AnimatedMascot(theme, () => done(undefined), { frameIntervalMs: style === "armin" ? 33 : 180, autoCloseMs: 7000, requestRender: () => requestRenderTarget(tui), style, effect }), { overlay: true, overlayOptions: { width: style === "armin" ? 48 : 62, maxHeight: "85%", anchor: "center" } });
 	} });
 
-	pi.registerCommand("team-init", { description: "Initialize project-local pi-crew directories and gitignore entries", handler: async (args: string, ctx: ExtensionCommandContext) => {
+	pi.registerCommand("team-init", { description: "Initialize pi-crew layout and global config. Use --project-config to write .pi/pi-crew.json.", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const tokens = args.trim().split(/\s+/).filter(Boolean);
-		const result = await handleTeamTool({ action: "init", config: { copyBuiltins: tokens.includes("--copy-builtins"), overwrite: tokens.includes("--overwrite") } }, ctx);
+		const configScope = tokens.includes("--project-config") || tokens.includes("--project") ? "project" : tokens.includes("--no-config") ? "none" : "global";
+		const result = await handleTeamTool({ action: "init", config: { copyBuiltins: tokens.includes("--copy-builtins"), overwrite: tokens.includes("--overwrite"), configScope } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
@@ -300,14 +339,14 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const tokens = args.trim().split(/\s+/).filter(Boolean);
 		const mode = tokens[0]?.toLowerCase();
 		const config = mode === "on" ? { profile: "suggested", enabled: true, injectPolicy: true } : mode === "off" ? { profile: "manual", enabled: false } : mode === "manual" || mode === "suggested" || mode === "assisted" || mode === "aggressive" ? { profile: mode, enabled: mode !== "manual", injectPolicy: mode !== "manual" } : { preferAsyncForLongTasks: tokens.includes("--prefer-async") ? true : undefined, allowWorktreeSuggestion: tokens.includes("--no-worktree-suggest") ? false : undefined };
-		const result = await handleTeamTool({ action: "autonomy", config }, ctx);
+		const result = await handleTeamTool({ action: "autonomy", config }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
 	pi.registerCommand("team-config", { description: "Show or update pi-crew config. Use key=value [--project] to update.", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const tokens = args.trim().split(/\s+/).filter(Boolean);
 		if (tokens.length === 0) {
-			const result = await handleTeamTool({ action: "config" }, ctx);
+			const result = await handleTeamTool({ action: "config" }, teamCommandContext(ctx));
 			await notifyCommandResult(ctx, commandText(result));
 			return;
 		}
@@ -324,7 +363,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 			if (raw === "unset" || raw === "null") pushUnset(config, key);
 			else setNestedConfig(config, key, parseScalar(raw));
 		}
-		const result = await handleTeamTool({ action: "config", config }, ctx);
+		const result = await handleTeamTool({ action: "config", config }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 
@@ -332,7 +371,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		["team-validate", "validate", "Validate pi-crew agents, teams, and workflows"],
 		["team-doctor", "doctor", "Check pi-crew installation and discovery readiness"],
 	] as const) pi.registerCommand(name, { description, handler: async (_args: string, ctx: ExtensionCommandContext) => {
-		const result = await handleTeamTool({ action }, ctx);
+		const result = await handleTeamTool({ action }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
 	} });
 

package/src/extension/registration/compaction-guard.ts

@@ -3,7 +3,7 @@ import { listRecentRuns } from "../run-index.ts";
 import type { ArtifactDescriptor, TeamRunManifest } from "../../state/types.ts";
 
 export interface RegisterCompactionGuardOptions {
-	foregroundControllers: Set<AbortController>;
+	foregroundControllers: Map<string | symbol, AbortController>;
 }
 
 const TRIGGER_RATIO = 0.75;

package/src/extension/registration/subagent-helpers.ts

@@ -81,6 +81,13 @@ export function subagentToolResult(text: string, details: Record<string, unknown
 	return { content: [{ type: "text" as const, text }], details, isError };
 }
 
+function parseSkillParam(value: unknown): string | string[] | false | undefined {
+	if (value === false) return false;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) return value;
+	return undefined;
+}
+
 export function __test__subagentSpawnParams(params: Record<string, unknown>, ctx: Pick<ExtensionContext, "cwd">): SubagentSpawnOptions {
 	return {
 		cwd: ctx.cwd,
@@ -89,6 +96,7 @@ export function __test__subagentSpawnParams(params: Record<string, unknown>, ctx
 		prompt: typeof params.prompt === "string" ? params.prompt : "",
 		background: params.run_in_background === true,
 		model: typeof params.model === "string" && params.model.trim() ? params.model.trim() : undefined,
+		skill: parseSkillParam(params.skill),
 		maxTurns: typeof params.max_turns === "number" && Number.isFinite(params.max_turns) ? params.max_turns : undefined,
 	};
 }