pi-crew 0.9.16 → 0.9.18

package/src/extension/run-import.ts

@@ -1,11 +1,11 @@
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as crypto from "node:crypto";
-import { assertRunBundle } from "./run-bundle-schema.ts";
-import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { type ConflictReport, detectImportConflicts } from "../runtime/delta-conflict.ts";
+import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { detectImportConflicts, type ConflictReport } from "../runtime/delta-conflict.ts";
+import { assertRunBundle } from "./run-bundle-schema.ts";
 
 export interface ImportedRunBundleInfo {
 	runId: string;
@@ -29,8 +29,16 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 	// Path containment: use resolveRealContainedPath for canonical real-path check
 	// to prevent symlink/../ bypass of the startsWith string comparison.
 	const allowedBases: string[] = [];
-	try { allowedBases.push(userCrewRoot()); } catch { /* ignore */ }
-	try { allowedBases.push(projectCrewRoot(cwd)); } catch { /* ignore */ }
+	try {
+		allowedBases.push(userCrewRoot());
+	} catch {
+		/* ignore */
+	}
+	try {
+		allowedBases.push(projectCrewRoot(cwd));
+	} catch {
+		/* ignore */
+	}
 	allowedBases.push(cwd); // always include cwd last (highest priority)
 	let isContained = false;
 	for (const base of allowedBases) {
@@ -38,7 +46,9 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 			resolveRealContainedPath(base, resolvedPath);
 			isContained = true;
 			break;
-		} catch { /* not contained — try next base */ }
+		} catch {
+			/* not contained — try next base */
+		}
 	}
 	if (!isContained) throw new Error(`Import path must be within project directory or crew root: ${resolvedPath}`);
 	const raw = JSON.parse(fs.readFileSync(resolvedPath, "utf-8")) as unknown;
@@ -46,12 +56,19 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 
 	// Integrity check: verify SHA-256 hash if present in manifest
 	const bundleJson = fs.readFileSync(resolvedPath, "utf-8");
-	const parsedForHash = JSON.parse(bundleJson) as { manifest?: { sha256?: string } };
+	const parsedForHash = JSON.parse(bundleJson) as {
+		manifest?: { sha256?: string };
+	};
 	if (parsedForHash.manifest?.sha256) {
 		const expectedHash = parsedForHash.manifest.sha256;
 		// Recompute hash by stringifying the bundle without the sha256 field
-		const { sha256: _sha256, ...manifestWithoutHash } = parsedForHash.manifest as Record<string, unknown> & { sha256?: string };
-		const bundleForHash = { ...parsedForHash, manifest: manifestWithoutHash };
+		const { sha256: _sha256, ...manifestWithoutHash } = parsedForHash.manifest as Record<string, unknown> & {
+			sha256?: string;
+		};
+		const bundleForHash = {
+			...parsedForHash,
+			manifest: manifestWithoutHash,
+		};
 		const recomputedHash = crypto.createHash("sha256").update(JSON.stringify(bundleForHash)).digest("hex");
 		if (recomputedHash !== expectedHash) {
 			throw new Error(`Integrity check failed: SHA-256 mismatch. Expected ${expectedHash}, got ${recomputedHash}`);
@@ -66,9 +83,15 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 	try {
 		const existingManifestPath = path.join(importRoot(cwd, scope), runId, "run-export.json");
 		if (fs.existsSync(existingManifestPath)) {
-			const existingRaw = JSON.parse(fs.readFileSync(existingManifestPath, "utf-8")) as { manifest?: Record<string, unknown>; tasks?: unknown[] };
+			const existingRaw = JSON.parse(fs.readFileSync(existingManifestPath, "utf-8")) as {
+				manifest?: Record<string, unknown>;
+				tasks?: unknown[];
+			};
 			conflictReport = detectImportConflicts(
-				{ manifest: raw.manifest as unknown as Record<string, unknown>, tasks: raw.tasks as unknown[] },
+				{
+					manifest: raw.manifest as unknown as Record<string, unknown>,
+					tasks: raw.tasks as unknown[],
+				},
 				{ manifest: existingRaw.manifest, tasks: existingRaw.tasks },
 			);
 		}
@@ -94,20 +117,32 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 		if (fs.existsSync(target) && fs.lstatSync(target).isSymbolicLink()) throw new Error(`Invalid import target: ${target}`);
 	}
 	fs.writeFileSync(targetJson, `${JSON.stringify({ ...raw, importedAt, importedFrom: resolvedPath }, null, 2)}\n`, "utf-8");
-	fs.writeFileSync(targetSummary, [
-		`# Imported pi-crew run ${runId}`,
-		"",
-		`Imported: ${importedAt}`,
-		`Source: ${resolvedPath}`,
-		`Original export: ${raw.exportedAt}`,
-		`Status: ${raw.manifest.status}`,
-		`Team: ${raw.manifest.team}`,
-		`Workflow: ${raw.manifest.workflow ?? "(none)"}`,
-		`Goal: ${raw.manifest.goal}`,
-		"",
-		"## Tasks",
-		...raw.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
-		"",
-	].join("\n"), "utf-8");
-	return { runId, importedAt, bundlePath: targetJson, summaryPath: targetSummary, ...(conflictReport?.hasConflicts ? { conflictReport } : {}) };
-}
+	fs.writeFileSync(
+		targetSummary,
+		[
+			`# Imported pi-crew run ${runId}`,
+			"",
+			`Imported: ${importedAt}`,
+			`Source: ${resolvedPath}`,
+			`Original export: ${raw.exportedAt}`,
+			`Status: ${raw.manifest.status}`,
+			`Team: ${raw.manifest.team}`,
+			`Workflow: ${raw.manifest.workflow ?? "(none)"}`,
+			`Goal: ${raw.manifest.goal}`,
+			"",
+			"## Tasks",
+			...raw.tasks.map(
+				(task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`,
+			),
+			"",
+		].join("\n"),
+		"utf-8",
+	);
+	return {
+		runId,
+		importedAt,
+		bundlePath: targetJson,
+		summaryPath: targetSummary,
+		...(conflictReport?.hasConflicts ? { conflictReport } : {}),
+	};
+}

package/src/extension/run-index.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { TeamRunManifest } from "../state/types.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { createCancellationToken } from "../runtime/cancellation-token.ts";
 import { activeRunEntries } from "../state/active-run-registry.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { sharedScanCache } from "../utils/scan-cache.ts";
-import { createCancellationToken } from "../runtime/cancellation-token.ts";
 
 function readManifest(filePath: string): TeamRunManifest | undefined {
 	const cached = sharedScanCache.readAndCache("manifests", filePath, filePath);
@@ -29,7 +29,8 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 	const tempDirs = [os.tmpdir(), "/var/tmp", "/tmp"];
 	const isTempRoot = tempDirs.some((t) => root.startsWith(t + path.sep));
 	const token = createCancellationToken({ signal });
-	const entries = fs.readdirSync(runsRoot, { withFileTypes: true })
+	const entries = fs
+		.readdirSync(runsRoot, { withFileTypes: true })
 		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
 		.map((entry) => entry.name)
 		.sort((a, b) => (b ?? "").localeCompare(a ?? ""));
@@ -42,7 +43,12 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 			if (!manifest) continue;
 			// Filter out ghost runs: active status but CWD no longer exists.
 			// These are deadletter/replay/temp runs whose temp dirs were cleaned up.
-			if ((manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning") && manifest.cwd && !fs.existsSync(manifest.cwd)) continue;
+			if (
+				(manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning") &&
+				manifest.cwd &&
+				!fs.existsSync(manifest.cwd)
+			)
+				continue;
 			// 2.19 — for runs in temp directories, verify the background process is alive.
 			// Without this, runs that completed/crashed but left stale manifests will still show.
 			if (isTempRoot && (manifest.status === "running" || manifest.status === "queued" || manifest.status === "planning")) {
@@ -51,12 +57,20 @@ function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): T
 					const pidData = JSON.parse(fs.readFileSync(asyncPidPath, "utf-8"));
 					const pid = pidData?.pid;
 					if (pid && typeof pid === "number") {
-						try { process.kill(pid, 0); } catch { continue; } // PID dead, skip this run
+						try {
+							process.kill(pid, 0);
+						} catch {
+							continue;
+						} // PID dead, skip this run
 					}
-				} catch { /* no async.pid or parse error — keep the run */ }
+				} catch {
+					/* no async.pid or parse error — keep the run */
+				}
 			}
 			results.push(manifest);
-		} catch { /* skip unreadable manifests */ }
+		} catch {
+			/* skip unreadable manifests */
+		}
 	}
 	return results;
 }
@@ -98,7 +112,12 @@ export function listRecentRuns(cwd: string, max = 20, signal?: AbortSignal): Tea
  * - "user": only runs in the user crew root
  * - "all" (default): merge both scopes (current behavior)
  */
-export function listRunsByScope(cwd: string, scope: "project" | "user" | "all" = "all", max?: number, signal?: AbortSignal): TeamRunManifest[] {
+export function listRunsByScope(
+	cwd: string,
+	scope: "project" | "user" | "all" = "all",
+	max?: number,
+	signal?: AbortSignal,
+): TeamRunManifest[] {
 	const projectRoot = findRepoRoot(cwd);
 	switch (scope) {
 		case "project":

package/src/extension/run-maintenance.ts

@@ -1,14 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { createCancellationToken } from "../runtime/cancellation-token.ts";
 import type { TeamRunManifest } from "../state/types.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
-import { listRuns } from "./run-index.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { redactSecrets } from "../utils/redaction.ts";
-import { createCancellationToken } from "../runtime/cancellation-token.ts";
-import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { isSafePathId } from "../utils/safe-paths.ts";
+import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { listRuns } from "./run-index.ts";
 
 export interface PruneRunsResult {
 	kept: string[];
@@ -50,7 +49,9 @@ function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string
 
 export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsOptions = {}): PruneRunsResult {
 	const token = createCancellationToken({ signal: options.signal });
-	const finished = listRuns(cwd, options.signal).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+	const finished = listRuns(cwd, options.signal)
+		.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[] = [];
 	const toRemove = finished.slice(keep);
@@ -58,14 +59,24 @@ export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsO
 		if (i % 5 === 0) token.heartbeat(`prune:${i}/${toRemove.length}`);
 		const run = toRemove[i];
 		if (!isSafeToPrune(cwd, run)) {
-			logInternalError("prune.path-unsafe", new Error(`Skipping unsafe prune: stateRoot=${run.stateRoot}, artifactsRoot=${run.artifactsRoot}`), `runId=${run.runId}`);
+			logInternalError(
+				"prune.path-unsafe",
+				new Error(`Skipping unsafe prune: stateRoot=${run.stateRoot}, artifactsRoot=${run.artifactsRoot}`),
+				`runId=${run.runId}`,
+			);
 			continue;
 		}
 		fs.rmSync(run.stateRoot, { recursive: true, force: true });
 		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
 		removed.push(run.runId);
 	}
-	const auditPath = appendPruneAudit(cwd, { action: "prune", keep, intent: options.intent, kept, removed });
+	const auditPath = appendPruneAudit(cwd, {
+		action: "prune",
+		keep,
+		intent: options.intent,
+		kept,
+		removed,
+	});
 	return { kept, removed, auditPath };
 }
 
@@ -85,9 +96,15 @@ export function pruneUserLevelRuns(keep: number): PruneRunsResult {
 
 	// Read all run directories, parse manifests, filter to finished
 	const MAX_DIRS = 500;
-	const finished: Array<{ runId: string; updatedAt: string; stateRoot: string; artifactsRoot: string }> = [];
+	const finished: Array<{
+		runId: string;
+		updatedAt: string;
+		stateRoot: string;
+		artifactsRoot: string;
+	}> = [];
 	const ghostRemoved: string[] = [];
-	const dirs = fs.readdirSync(runsRoot, { withFileTypes: true })
+	const dirs = fs
+		.readdirSync(runsRoot, { withFileTypes: true })
 		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
 		.slice(0, MAX_DIRS)
 		.map((entry) => entry.name);
@@ -105,7 +122,10 @@ export function pruneUserLevelRuns(keep: number): PruneRunsResult {
 		// These are deadletter/replay/temp runs from dead Pi sessions.
 		const isActive = manifest.status === "queued" || manifest.status === "running" || manifest.status === "planning";
 		if (isActive && manifest.cwd && !fs.existsSync(manifest.cwd)) {
-			fs.rmSync(path.join(runsRoot, dir), { recursive: true, force: true });
+			fs.rmSync(path.join(runsRoot, dir), {
+				recursive: true,
+				force: true,
+			});
 			ghostRemoved.push(manifest.runId);
 			continue;
 		}

package/src/extension/session-summary.ts

@@ -1,7 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import { listRuns } from "./run-index.ts";
-import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 
 export function notifyActiveRuns(ctx: ExtensionContext): void {
 	const active = listRuns(ctx.cwd)

package/src/extension/team-manager-command.ts

@@ -2,8 +2,12 @@ import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { listRuns } from "./run-index.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
+
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
-async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ctx: Parameters<typeof HandleTeamToolFn>[1]): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
+async function handleTeamTool(
+	params: Parameters<typeof HandleTeamToolFn>[0],
+	ctx: Parameters<typeof HandleTeamToolFn>[1],
+): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
 	if (!_cachedHandleTeamTool) {
 		// LAZY: team-tool.ts pulls in the entire runtime chain.
 		const mod = await import("./team-tool.ts");
@@ -11,6 +15,7 @@ async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ct
 	}
 	return _cachedHandleTeamTool(params, ctx);
 }
+
 import { isToolError, textFromToolResult } from "./tool-result.ts";
 
 async function notifyResult(ctx: ExtensionCommandContext, result: Awaited<ReturnType<typeof handleTeamTool>>): Promise<void> {
@@ -53,14 +58,48 @@ export async function handleTeamManagerCommand(_args: string, ctx: ExtensionComm
 		const avoidWhen = await ctx.ui.input("Avoid when (comma-separated)", "");
 		const cost = await ctx.ui.select("Cost", ["cheap", "free", "expensive"]);
 		const category = await ctx.ui.input("Category", "custom");
-		const baseConfig = { name, description, scope: "project", triggers, useWhen, avoidWhen, cost, category };
+		const baseConfig = {
+			name,
+			description,
+			scope: "project",
+			triggers,
+			useWhen,
+			avoidWhen,
+			cost,
+			category,
+		};
 		if (resource === "agent") {
 			const systemPrompt = isUpdate ? undefined : `You are ${name}.`;
-			await notifyResult(ctx, await handleTeamTool({ action: isUpdate ? "update" : "create", resource, agent: name, config: { ...baseConfig, systemPrompt } }, ctx));
+			await notifyResult(
+				ctx,
+				await handleTeamTool(
+					{
+						action: isUpdate ? "update" : "create",
+						resource,
+						agent: name,
+						config: { ...baseConfig, systemPrompt },
+					},
+					ctx,
+				),
+			);
 			return;
 		}
 		const agent = await ctx.ui.input("Role agent", "executor");
-		await notifyResult(ctx, await handleTeamTool({ action: isUpdate ? "update" : "create", resource, team: name, config: { ...baseConfig, roles: [{ name: "executor", agent: agent || "executor" }] } }, ctx));
+		await notifyResult(
+			ctx,
+			await handleTeamTool(
+				{
+					action: isUpdate ? "update" : "create",
+					resource,
+					team: name,
+					config: {
+						...baseConfig,
+						roles: [{ name: "executor", agent: agent || "executor" }],
+					},
+				},
+				ctx,
+			),
+		);
 		return;
 	}
 
@@ -71,7 +110,19 @@ export async function handleTeamManagerCommand(_args: string, ctx: ExtensionComm
 		if (!goal) return;
 		const asyncRun = await ctx.ui.confirm("Async run?", "Run in detached background mode?");
 		const worktree = await ctx.ui.confirm("Worktree mode?", "Use git worktrees for task workspaces? Requires a clean repo by default.");
-		await notifyResult(ctx, await handleTeamTool({ action: "run", team: team || "default", goal, async: asyncRun, workspaceMode: worktree ? "worktree" : "single" }, ctx));
+		await notifyResult(
+			ctx,
+			await handleTeamTool(
+				{
+					action: "run",
+					team: team || "default",
+					goal,
+					async: asyncRun,
+					workspaceMode: worktree ? "worktree" : "single",
+				},
+				ctx,
+			),
+		);
 		return;
 	}
 
@@ -80,7 +131,10 @@ export async function handleTeamManagerCommand(_args: string, ctx: ExtensionComm
 		ctx.ui.notify("No pi-crew runs found.", "info");
 		return;
 	}
-	const selected = await ctx.ui.select("Select run", runs.map((run) => `${run.runId} [${run.status}] ${run.team}/${run.workflow ?? "none"}`));
+	const selected = await ctx.ui.select(
+		"Select run",
+		runs.map((run) => `${run.runId} [${run.status}] ${run.team}/${run.workflow ?? "none"}`),
+	);
 	if (!selected) return;
 	const runId = selected.split(" ")[0];
 	if (!runId) return;
@@ -90,7 +144,10 @@ export async function handleTeamManagerCommand(_args: string, ctx: ExtensionComm
 		return;
 	}
 	if (action === "Cleanup run worktrees") {
-		const force = await ctx.ui.confirm("Force cleanup?", "Force may remove dirty worktrees. Choose false to preserve dirty worktrees and capture cleanup diffs.");
+		const force = await ctx.ui.confirm(
+			"Force cleanup?",
+			"Force may remove dirty worktrees. Choose false to preserve dirty worktrees and capture cleanup diffs.",
+		);
 		await notifyResult(ctx, await handleTeamTool({ action: "cleanup", runId, force }, ctx));
 	}
 }