pi-crew 0.1.11 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "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, "")) ?? [];
@@ -103,6 +104,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let currentCtx: ExtensionContext | undefined;
 	let rpcHandle: PiCrewRpcHandle | undefined;
 	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);
 
@@ -123,6 +125,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		widgetState.interval.unref?.();
 	});
 	pi.on("session_shutdown", () => {
+		for (const controller of foregroundControllers) controller.abort();
+		terminateActiveChildPiProcesses();
 		stopAsyncRunNotifier(notifierState);
 		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
 		clearPiCrewPowerbar(pi.events);
@@ -137,12 +141,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);
 }