pi-crew 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/extension/register.ts

@@ -15,6 +15,7 @@ import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerb
 import { DurableTextViewer, DurableTranscriptViewer } from "../ui/transcript-viewer.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { terminateActiveChildPiProcesses } from "../runtime/child-pi.ts";
 
 function parseRunArgs(args: string): TeamToolParamsValue {
 	const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -99,14 +100,38 @@ function setNestedConfig(config: Record<string, unknown>, key: string, value: un
 }
 
 export function registerPiTeams(pi: ExtensionAPI): void {
+	const globalStore = globalThis as Record<string, unknown>;
+	const runtimeCleanupStoreKey = "__piCrewRuntimeCleanup";
+	const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];
+	if (typeof previousRuntimeCleanup === "function") {
+		try { previousRuntimeCleanup(); } catch {}
+	}
 	const notifierState: AsyncNotifierState = { seenFinishedRunIds: new Set() };
 	let currentCtx: ExtensionContext | undefined;
 	let rpcHandle: PiCrewRpcHandle | undefined;
+	let cleanedUp = false;
 	const widgetState: CrewWidgetState = { frame: 0 };
+	const foregroundControllers = new Set<AbortController>();
 	registerAutonomousPolicy(pi);
 	rpcHandle = registerPiCrewRpc((pi as unknown as { events?: Parameters<typeof registerPiCrewRpc>[0] }).events, () => currentCtx);
+	const cleanupRuntime = (): void => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		for (const controller of foregroundControllers) controller.abort();
+		foregroundControllers.clear();
+		terminateActiveChildPiProcesses();
+		stopAsyncRunNotifier(notifierState);
+		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
+		clearPiCrewPowerbar(pi.events);
+		rpcHandle?.unsubscribe();
+		rpcHandle = undefined;
+		currentCtx = undefined;
+		if (globalStore[runtimeCleanupStoreKey] === cleanupRuntime) delete globalStore[runtimeCleanupStoreKey];
+	};
+	globalStore[runtimeCleanupStoreKey] = cleanupRuntime;
 
 	pi.on("session_start", (_event, ctx) => {
+		cleanedUp = false;
 		currentCtx = ctx;
 		notifyActiveRuns(ctx);
 		const loadedConfig = loadConfig(ctx.cwd);
@@ -123,12 +148,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		widgetState.interval.unref?.();
 	});
 	pi.on("session_shutdown", () => {
-		stopAsyncRunNotifier(notifierState);
-		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
-		clearPiCrewPowerbar(pi.events);
-		currentCtx = undefined;
-		rpcHandle?.unsubscribe();
-		rpcHandle = undefined;
+		cleanupRuntime();
 	});
 
 	const tool: ToolDefinition = {
@@ -137,12 +157,21 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		description: "Coordinate Pi teams. Use proactively for complex multi-file work, planning, implementation, tests, reviews, security audits, research, async/background runs, and worktree-isolated execution. Use action='recommend' when unsure which team/workflow to choose. Destructive actions require explicit user confirmation.",
 		promptSnippet: "Use the team tool proactively for coordinated multi-agent work. If unsure, call { action: 'recommend', goal } first, then run or plan with the suggested team/workflow.",
 		parameters: TeamToolParams as never,
-		async execute(_id, params, _signal, _onUpdate, ctx) {
-			const output = await handleTeamTool(params as TeamToolParamsValue, ctx);
-			const config = loadConfig(ctx.cwd).config.ui;
-			updateCrewWidget(ctx, widgetState, config);
-			updatePiCrewPowerbar(pi.events, ctx.cwd, config);
-			return output;
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const controller = new AbortController();
+			foregroundControllers.add(controller);
+			const abort = (): void => controller.abort();
+			signal?.addEventListener("abort", abort, { once: true });
+			try {
+				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal });
+				const config = loadConfig(ctx.cwd).config.ui;
+				updateCrewWidget(ctx, widgetState, config);
+				updatePiCrewPowerbar(pi.events, ctx.cwd, config);
+				return output;
+			} finally {
+				signal?.removeEventListener("abort", abort);
+				foregroundControllers.delete(controller);
+			}
 		},
 	};
 

package/src/extension/run-maintenance.ts

@@ -12,7 +12,7 @@ function isFinished(run: TeamRunManifest): boolean {
 }
 
 export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
-	const finished = listRuns(cwd).filter(isFinished).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const finished = listRuns(cwd).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 	const kept = finished.slice(0, keep).map((run) => run.runId);
 	const removed: string[] = [];
 	for (const run of finished.slice(keep)) {

package/src/extension/team-tool.ts

@@ -56,6 +56,7 @@ type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext
 	modelRegistry?: unknown;
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
+	signal?: AbortSignal;
 };
 
 function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {
@@ -306,7 +307,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
 	const executeWorkers = runtime.kind === "child-process";
 	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
-	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 });
+	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, signal: ctx.signal });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,
@@ -429,7 +430,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		const executeWorkers = runtime.kind === "child-process";
-		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry });
+		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, signal: ctx.signal });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});
 }

package/src/runtime/child-pi.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
@@ -8,6 +8,29 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 const POST_EXIT_STDIO_GUARD_MS = 3000;
 const FINAL_DRAIN_MS = 5000;
 const HARD_KILL_MS = 3000;
+const activeChildProcesses = new Map<number, ChildProcess>();
+
+function killProcessTree(pid: number | undefined): void {
+	if (!pid || !Number.isInteger(pid) || pid <= 0) return;
+	try {
+		if (process.platform === "win32") {
+			spawn("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+			return;
+		}
+		try { process.kill(-pid, "SIGTERM"); } catch { process.kill(pid, "SIGTERM"); }
+		setTimeout(() => {
+			try { process.kill(-pid, "SIGKILL"); } catch { try { process.kill(pid, "SIGKILL"); } catch {} }
+		}, HARD_KILL_MS).unref?.();
+	} catch {
+		// Ignore shutdown races.
+	}
+}
+
+export function terminateActiveChildPiProcesses(): number {
+	const pids = [...activeChildProcesses.keys()];
+	for (const pid of pids) killProcessTree(pid);
+	return pids.length;
+}
 
 export interface ChildPiRunInput {
 	cwd: string;
@@ -118,7 +141,9 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				cwd: input.cwd,
 				env: { ...process.env, ...built.env },
 				stdio: ["ignore", "pipe", "pipe"],
+				detached: process.platform !== "win32",
 			});
+			if (child.pid) activeChildProcesses.set(child.pid, child);
 			let stdout = "";
 			let stderr = "";
 			let settled = false;
@@ -167,6 +192,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			};
 
 			const abort = (): void => {
+				killProcessTree(child.pid);
 				try {
 					child.kill(process.platform === "win32" ? undefined : "SIGTERM");
 				} catch {
@@ -187,6 +213,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				settle({ exitCode: null, stdout, stderr, error: error.message });
 			});
 			child.on("exit", () => {
+				if (child.pid) activeChildProcesses.delete(child.pid);
 				childExited = true;
 				clearFinalDrainTimers();
 				postExitGuard = setTimeout(() => {
@@ -196,6 +223,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				postExitGuard.unref?.();
 			});
 			child.on("close", (exitCode) => {
+				if (child.pid) activeChildProcesses.delete(child.pid);
 				settle({ exitCode, stdout, stderr, ...(forcedFinalDrain && !stderr.trim() ? { error: `Child Pi did not exit within ${finalDrainMs}ms after final assistant message; termination was requested.` } : {}) });
 			});
 		});

package/src/runtime/process-status.ts

@@ -38,6 +38,13 @@ export function isLikelyOrphanedActiveRun(run: TeamRunManifest, agents: CrewAgen
 	return agents.every((agent) => agent.status === "queued" && !agent.completedAt && !agent.progress);
 }
 
+function hasDurableActiveAgentEvidence(agent: CrewAgentRecord): boolean {
+	if (agent.status !== "running" && agent.status !== "queued") return false;
+	return Boolean(agent.statusPath || agent.eventsPath || agent.outputPath || agent.progress || agent.toolUses || agent.jsonEvents);
+}
+
 export function isDisplayActiveRun(run: TeamRunManifest, agents: CrewAgentRecord[] = [], now = Date.now()): boolean {
-	return isActiveRunStatus(run.status) && !isLikelyOrphanedActiveRun(run, agents, now);
+	if (!isActiveRunStatus(run.status) || isLikelyOrphanedActiveRun(run, agents, now)) return false;
+	if (agents.length === 0) return true;
+	return agents.some(hasDurableActiveAgentEvidence);
 }

package/src/runtime/team-runner.ts

@@ -160,6 +160,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		if (failed) {
 			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
 			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
 			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
 			return { manifest, tasks };
 		}
@@ -169,6 +170,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		if (readyBatch.length === 0) {
 			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
 			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
 			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
 			return { manifest, tasks };
 		}

package/src/ui/crew-widget.ts

@@ -108,9 +108,18 @@ function activeWidgetRuns(cwd: string): WidgetRun[] {
 }
 
 function statusSummary(runs: WidgetRun[]): string {
-	const runningAgents = runs.flatMap((item) => item.agents).filter((agent) => agent.status === "running").length;
-	const queuedAgents = runs.flatMap((item) => item.agents).filter((agent) => agent.status === "queued").length;
-	return `● pi-crew · runs=${runs.length} agents=${runningAgents} running${queuedAgents ? ` · ${queuedAgents} queued` : ""} · /team-dashboard`;
+	const agents = runs.flatMap((item) => item.agents);
+	const runningAgents = agents.filter((agent) => agent.status === "running").length;
+	const queuedAgents = agents.filter((agent) => agent.status === "queued").length;
+	const completedAgents = agents.filter((agent) => agent.status === "completed").length;
+	const parts = [`${runningAgents} running`];
+	if (queuedAgents) parts.push(`${queuedAgents} queued`);
+	if (completedAgents) parts.push(`${completedAgents}/${agents.length} done`);
+	return `⚙ pi-crew · ${parts.join(" · ")} · /team-dashboard`;
+}
+
+function shortRunLabel(run: TeamRunManifest): string {
+	return `${run.team}/${run.workflow ?? "none"}`;
 }
 
 export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8): string[] {
@@ -119,15 +128,12 @@ export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8): stri
 	const runningGlyph = SPINNER[frame % SPINNER.length] ?? "⠋";
 	const lines: string[] = [statusSummary(runs)];
 	for (const { run, agents } of runs) {
-		const running = agents.find((agent) => agent.status === "running");
-		const queued = agents.find((agent) => agent.status === "queued");
-		const step = running?.taskId ?? queued?.taskId ?? run.status;
-		const completed = agents.filter((agent) => agent.status === "completed").length;
-		lines.push(`${glyph(run.status, runningGlyph)} ${run.runId.slice(-8)} ${run.team}/${run.workflow ?? "none"} · ${step} · ${completed}/${agents.length} done`);
 		const activeAgents = agents.filter((item) => item.status === "running" || item.status === "queued");
+		const completed = agents.filter((agent) => agent.status === "completed").length;
+		lines.push(`${glyph(run.status, runningGlyph)} ${shortRunLabel(run)} · ${completed}/${agents.length} done · ${run.runId.slice(-8)}`);
 		for (const agent of activeAgents.slice(0, 3)) {
 			const stats = agentStats(agent);
-			lines.push(`  ${glyph(agent.status, runningGlyph)} ${agent.taskId} ${agent.role}→${agent.agent} · ${agentActivity(agent)}${stats ? ` · ${stats}` : ""}`);
+			lines.push(`  ${glyph(agent.status, runningGlyph)} ${agent.agent} (${agent.role}) · ${agentActivity(agent)}${stats ? ` · ${stats}` : ""}`);
 		}
 		if (activeAgents.length > 3) lines.push(`  … +${activeAgents.length - 3} more agents`);
 		if (lines.length >= maxLines) break;
@@ -153,7 +159,7 @@ class CrewWidgetComponent implements WidgetComponent {
 		const bold = this.theme.bold?.bind(this.theme) ?? ((text: string) => text);
 		return buildCrewWidgetLines(this.cwd, this.frame, this.maxLines).map((line, index) => {
 			const colored = index === 0
-				? line.replace("● pi-crew", `${fg("accent", "●")} ${bold("pi-crew")}`)
+				? line.replace("⚙ pi-crew", `${fg("accent", "⚙")} ${bold("pi-crew")}`)
 				: line.replace(/^\s*([⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏▶◦✓✗■·])/, (match, icon: string) => match.replace(icon, fg(icon === "✓" ? "success" : icon === "✗" ? "error" : icon === "◦" ? "dim" : "accent", icon)));
 			return truncate(colored, width);
 		});