pi-crew 0.2.3 → 0.2.5

package/src/extension/run-index.ts

@@ -1,94 +1,94 @@
-import * as fs from "node:fs";
-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 { activeRunEntries } from "../state/active-run-registry.ts";
-import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { sharedScanCache } from "../utils/scan-cache.ts";
-import { CancellationToken, createCancellationToken } from "../runtime/cancellation-token.ts";
-
-function readManifest(filePath: string): TeamRunManifest | undefined {
-	const cached = sharedScanCache.readAndCache("manifests", filePath, filePath);
-	if (cached) return cached.raw as TeamRunManifest;
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as TeamRunManifest;
-	} catch {
-		return undefined;
-	}
-}
-
-function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): TeamRunManifest[] {
-	const runsRoot = path.join(root, DEFAULT_PATHS.state.runsSubdir);
-	if (!fs.existsSync(runsRoot)) return [];
-	if (signal?.aborted) return [];
-	const token = createCancellationToken({ signal });
-	const entries = fs.readdirSync(runsRoot, { withFileTypes: true })
-		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
-		.map((entry) => entry.name)
-		.sort((a, b) => b.localeCompare(a));
-	const selected = maxEntries !== undefined ? entries.slice(0, Math.max(0, maxEntries)) : entries;
-	const results: TeamRunManifest[] = [];
-	for (let i = 0; i < selected.length; i++) {
-		if (i % 10 === 0) token.heartbeat(`collectRuns:${i}/${selected.length}`);
-		try {
-			const manifest = readManifest(path.join(resolveRealContainedPath(runsRoot, selected[i]), DEFAULT_PATHS.state.manifestFile));
-			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;
-			results.push(manifest);
-		} catch { /* skip unreadable manifests */ }
-	}
-	return results;
-}
-
-function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[] {
-	const byId = new Map<string, TeamRunManifest>();
-	for (const runs of runSets) for (const run of runs) byId.set(run.runId, run);
-	const sorted = [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-	return max !== undefined ? sorted.slice(0, Math.max(0, max)) : sorted;
-}
-
-function scopedRunRoots(cwd: string): string[] {
-	const roots = new Set<string>();
-	roots.add(userCrewRoot());
-	const projectRoot = findRepoRoot(cwd);
-	if (projectRoot) roots.add(projectCrewRoot(cwd));
-	return [...roots];
-}
-
-function collectActiveRuns(): TeamRunManifest[] {
-	return activeRunEntries()
-		.map((entry) => readManifest(entry.manifestPath))
-		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
-}
-
-export function listRuns(cwd: string, signal?: AbortSignal): TeamRunManifest[] {
-	const roots = scopedRunRoots(cwd);
-	return mergeRuns([...roots.map((root) => collectRuns(root, undefined, signal)), collectActiveRuns()]);
-}
-
-export function listRecentRuns(cwd: string, max = 20, signal?: AbortSignal): TeamRunManifest[] {
-	const roots = scopedRunRoots(cwd);
-	return mergeRuns([...roots.map((root) => collectRuns(root, max, signal)), collectActiveRuns()], max);
-}
-
-/**
- * List runs filtered to a specific scope.
- * - "project": only runs in the project crew root
- * - "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[] {
-	const projectRoot = findRepoRoot(cwd);
-	switch (scope) {
-		case "project":
-			return projectRoot ? collectRuns(projectCrewRoot(cwd), max, signal) : [];
-		case "user":
-			return collectRuns(userCrewRoot(), max, signal);
-		case "all":
-		default:
-			return max !== undefined ? listRecentRuns(cwd, max, signal) : listRuns(cwd, signal);
-	}
-}
+import * as fs from "node:fs";
+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 { activeRunEntries } from "../state/active-run-registry.ts";
+import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { sharedScanCache } from "../utils/scan-cache.ts";
+import { CancellationToken, createCancellationToken } from "../runtime/cancellation-token.ts";
+
+function readManifest(filePath: string): TeamRunManifest | undefined {
+	const cached = sharedScanCache.readAndCache("manifests", filePath, filePath);
+	if (cached) return cached.raw as TeamRunManifest;
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as TeamRunManifest;
+	} catch {
+		return undefined;
+	}
+}
+
+function collectRuns(root: string, maxEntries?: number, signal?: AbortSignal): TeamRunManifest[] {
+	const runsRoot = path.join(root, DEFAULT_PATHS.state.runsSubdir);
+	if (!fs.existsSync(runsRoot)) return [];
+	if (signal?.aborted) return [];
+	const token = createCancellationToken({ signal });
+	const entries = fs.readdirSync(runsRoot, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
+		.map((entry) => entry.name)
+		.sort((a, b) => b.localeCompare(a));
+	const selected = maxEntries !== undefined ? entries.slice(0, Math.max(0, maxEntries)) : entries;
+	const results: TeamRunManifest[] = [];
+	for (let i = 0; i < selected.length; i++) {
+		if (i % 10 === 0) token.heartbeat(`collectRuns:${i}/${selected.length}`);
+		try {
+			const manifest = readManifest(path.join(resolveRealContainedPath(runsRoot, selected[i]), DEFAULT_PATHS.state.manifestFile));
+			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;
+			results.push(manifest);
+		} catch { /* skip unreadable manifests */ }
+	}
+	return results;
+}
+
+function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[] {
+	const byId = new Map<string, TeamRunManifest>();
+	for (const runs of runSets) for (const run of runs) byId.set(run.runId, run);
+	const sorted = [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	return max !== undefined ? sorted.slice(0, Math.max(0, max)) : sorted;
+}
+
+function scopedRunRoots(cwd: string): string[] {
+	const roots = new Set<string>();
+	roots.add(userCrewRoot());
+	const projectRoot = findRepoRoot(cwd);
+	if (projectRoot) roots.add(projectCrewRoot(cwd));
+	return [...roots];
+}
+
+function collectActiveRuns(): TeamRunManifest[] {
+	return activeRunEntries()
+		.map((entry) => readManifest(entry.manifestPath))
+		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
+}
+
+export function listRuns(cwd: string, signal?: AbortSignal): TeamRunManifest[] {
+	const roots = scopedRunRoots(cwd);
+	return mergeRuns([...roots.map((root) => collectRuns(root, undefined, signal)), collectActiveRuns()]);
+}
+
+export function listRecentRuns(cwd: string, max = 20, signal?: AbortSignal): TeamRunManifest[] {
+	const roots = scopedRunRoots(cwd);
+	return mergeRuns([...roots.map((root) => collectRuns(root, max, signal)), collectActiveRuns()], max);
+}
+
+/**
+ * List runs filtered to a specific scope.
+ * - "project": only runs in the project crew root
+ * - "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[] {
+	const projectRoot = findRepoRoot(cwd);
+	switch (scope) {
+		case "project":
+			return projectRoot ? collectRuns(projectCrewRoot(cwd), max, signal) : [];
+		case "user":
+			return collectRuns(userCrewRoot(), max, signal);
+		case "all":
+		default:
+			return max !== undefined ? listRecentRuns(cwd, max, signal) : listRuns(cwd, signal);
+	}
+}

package/src/extension/run-maintenance.ts

@@ -1,142 +1,142 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-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 { 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";
-
-export interface PruneRunsResult {
-	kept: string[];
-	removed: string[];
-	auditPath?: string;
-}
-
-export interface PruneRunsOptions {
-	intent?: string;
-	signal?: AbortSignal;
-}
-
-function isFinished(run: TeamRunManifest): boolean {
-	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
-}
-
-function isSafeToPrune(cwd: string, run: TeamRunManifest): boolean {
-	try {
-		const crewRoot = run.stateRoot.startsWith(userCrewRoot() + path.sep) ? userCrewRoot() : projectCrewRoot(cwd);
-		resolveRealContainedPath(crewRoot, run.stateRoot);
-		resolveRealContainedPath(crewRoot, run.artifactsRoot);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string | undefined {
-	try {
-		const filePath = path.join(projectCrewRoot(cwd), "audit", "prune.jsonl");
-		fs.mkdirSync(path.dirname(filePath), { recursive: true });
-		fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ ...payload, auditedAt: new Date().toISOString() }))}\n`, "utf-8");
-		return filePath;
-	} catch (error) {
-		logInternalError("prune.audit-write", error, `cwd=${cwd}`);
-		return undefined;
-	}
-}
-
-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 kept = finished.slice(0, keep).map((run) => run.runId);
-	const removed: string[] = [];
-	const toRemove = finished.slice(keep);
-	for (let i = 0; i < toRemove.length; i++) {
-		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}`);
-			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 });
-	return { kept, removed, auditPath };
-}
-
-/**
- * Prune finished run directories at the user level (~/.pi/agent/extensions/pi-crew/state/runs/).
- *
- * This handles runs created without a project root (e.g. `team action='run'` from home directory)
- * that would otherwise accumulate forever.
- *
- * @param keep Number of most recent finished runs to retain
- * @returns kept and removed run IDs
- */
-export function pruneUserLevelRuns(keep: number): PruneRunsResult {
-	const crewRoot = userCrewRoot();
-	const runsRoot = path.join(crewRoot, DEFAULT_PATHS.state.runsSubdir);
-	if (!fs.existsSync(runsRoot)) return { kept: [], removed: [] };
-
-	// 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 ghostRemoved: string[] = [];
-	const dirs = fs.readdirSync(runsRoot, { withFileTypes: true })
-		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
-		.slice(0, MAX_DIRS)
-		.map((entry) => entry.name);
-
-	for (const dir of dirs) {
-		const manifestPath = path.join(runsRoot, dir, DEFAULT_PATHS.state.manifestFile);
-		let manifest: TeamRunManifest | undefined;
-		try {
-			manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as TeamRunManifest;
-		} catch {
-			continue;
-		}
-
-		// Ghost run cleanup: active status but CWD no longer exists.
-		// 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 });
-			ghostRemoved.push(manifest.runId);
-			continue;
-		}
-
-		if (!isFinished(manifest)) continue;
-
-		// Safety check: ensure stateRoot and artifactsRoot are contained within user crew root
-		try {
-			resolveRealContainedPath(crewRoot, manifest.stateRoot);
-			resolveRealContainedPath(crewRoot, manifest.artifactsRoot);
-		} catch {
-			continue;
-		}
-
-		finished.push({
-			runId: manifest.runId,
-			updatedAt: manifest.updatedAt,
-			stateRoot: manifest.stateRoot,
-			artifactsRoot: manifest.artifactsRoot,
-		});
-	}
-
-	// Sort newest first, keep top N, remove the rest
-	finished.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-	const kept = finished.slice(0, keep).map((r) => r.runId);
-	const removed: string[] = [];
-	for (const run of finished.slice(keep)) {
-		fs.rmSync(run.stateRoot, { recursive: true, force: true });
-		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
-		removed.push(run.runId);
-	}
-
-	return { kept, removed: [...removed, ...ghostRemoved] };
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+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 { 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";
+
+export interface PruneRunsResult {
+	kept: string[];
+	removed: string[];
+	auditPath?: string;
+}
+
+export interface PruneRunsOptions {
+	intent?: string;
+	signal?: AbortSignal;
+}
+
+function isFinished(run: TeamRunManifest): boolean {
+	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
+}
+
+function isSafeToPrune(cwd: string, run: TeamRunManifest): boolean {
+	try {
+		const crewRoot = run.stateRoot.startsWith(userCrewRoot() + path.sep) ? userCrewRoot() : projectCrewRoot(cwd);
+		resolveRealContainedPath(crewRoot, run.stateRoot);
+		resolveRealContainedPath(crewRoot, run.artifactsRoot);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function appendPruneAudit(cwd: string, payload: Record<string, unknown>): string | undefined {
+	try {
+		const filePath = path.join(projectCrewRoot(cwd), "audit", "prune.jsonl");
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ ...payload, auditedAt: new Date().toISOString() }))}\n`, "utf-8");
+		return filePath;
+	} catch (error) {
+		logInternalError("prune.audit-write", error, `cwd=${cwd}`);
+		return undefined;
+	}
+}
+
+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 kept = finished.slice(0, keep).map((run) => run.runId);
+	const removed: string[] = [];
+	const toRemove = finished.slice(keep);
+	for (let i = 0; i < toRemove.length; i++) {
+		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}`);
+			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 });
+	return { kept, removed, auditPath };
+}
+
+/**
+ * Prune finished run directories at the user level (~/.pi/agent/extensions/pi-crew/state/runs/).
+ *
+ * This handles runs created without a project root (e.g. `team action='run'` from home directory)
+ * that would otherwise accumulate forever.
+ *
+ * @param keep Number of most recent finished runs to retain
+ * @returns kept and removed run IDs
+ */
+export function pruneUserLevelRuns(keep: number): PruneRunsResult {
+	const crewRoot = userCrewRoot();
+	const runsRoot = path.join(crewRoot, DEFAULT_PATHS.state.runsSubdir);
+	if (!fs.existsSync(runsRoot)) return { kept: [], removed: [] };
+
+	// 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 ghostRemoved: string[] = [];
+	const dirs = fs.readdirSync(runsRoot, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory() && isSafePathId(entry.name))
+		.slice(0, MAX_DIRS)
+		.map((entry) => entry.name);
+
+	for (const dir of dirs) {
+		const manifestPath = path.join(runsRoot, dir, DEFAULT_PATHS.state.manifestFile);
+		let manifest: TeamRunManifest | undefined;
+		try {
+			manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as TeamRunManifest;
+		} catch {
+			continue;
+		}
+
+		// Ghost run cleanup: active status but CWD no longer exists.
+		// 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 });
+			ghostRemoved.push(manifest.runId);
+			continue;
+		}
+
+		if (!isFinished(manifest)) continue;
+
+		// Safety check: ensure stateRoot and artifactsRoot are contained within user crew root
+		try {
+			resolveRealContainedPath(crewRoot, manifest.stateRoot);
+			resolveRealContainedPath(crewRoot, manifest.artifactsRoot);
+		} catch {
+			continue;
+		}
+
+		finished.push({
+			runId: manifest.runId,
+			updatedAt: manifest.updatedAt,
+			stateRoot: manifest.stateRoot,
+			artifactsRoot: manifest.artifactsRoot,
+		});
+	}
+
+	// Sort newest first, keep top N, remove the rest
+	finished.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const kept = finished.slice(0, keep).map((r) => r.runId);
+	const removed: string[] = [];
+	for (const run of finished.slice(keep)) {
+		fs.rmSync(run.stateRoot, { recursive: true, force: true });
+		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
+		removed.push(run.runId);
+	}
+
+	return { kept, removed: [...removed, ...ghostRemoved] };
+}

package/src/extension/session-summary.ts

@@ -1,8 +1,8 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { listRuns } from "./run-index.ts";
-
-export function notifyActiveRuns(ctx: ExtensionContext): void {
-	const active = listRuns(ctx.cwd).filter((run) => run.status === "queued" || run.status === "planning" || run.status === "running").slice(0, 5);
-	if (active.length === 0) return;
-	ctx.ui.notify(`pi-crew active runs: ${active.map((run) => `${run.runId} [${run.status}]`).join(", ")}`, "info");
-}
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { listRuns } from "./run-index.ts";
+
+export function notifyActiveRuns(ctx: ExtensionContext): void {
+	const active = listRuns(ctx.cwd).filter((run) => run.status === "queued" || run.status === "planning" || run.status === "running").slice(0, 5);
+	if (active.length === 0) return;
+	ctx.ui.notify(`pi-crew active runs: ${active.map((run) => `${run.runId} [${run.status}]`).join(", ")}`, "info");
+}