pi-crew 0.1.46 → 0.1.49

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

@@ -1,125 +1,125 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { listRecentRuns } from "../run-index.ts";
-import type { ArtifactDescriptor, TeamRunManifest } from "../../state/types.ts";
-
-export interface RegisterCompactionGuardOptions {
-	foregroundControllers: Set<AbortController>;
-}
-
-const TRIGGER_RATIO = 0.75;
-const HARD_RATIO = 0.95;
-const DEFAULT_CONTEXT_WINDOW = 200_000;
-const MAX_ARTIFACT_INDEX_RUNS = 10;
-const MAX_ARTIFACT_INDEX_ITEMS = 80;
-
-function contextWindow(ctx: { model?: { contextWindow?: number } }): number {
-	const value = ctx.model?.contextWindow;
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_CONTEXT_WINDOW;
-}
-
-function usageRatio(ctx: { getContextUsage(): { tokens: number | null } | undefined; model?: { contextWindow?: number } }): number | undefined {
-	const tokens = ctx.getContextUsage()?.tokens;
-	if (tokens === null || tokens === undefined || !Number.isFinite(tokens)) return undefined;
-	return tokens / contextWindow(ctx);
-}
-
-interface CrewArtifactIndexEntry {
-	runId: string;
-	status: TeamRunManifest["status"];
-	team: string;
-	workflow?: string;
-	goal: string;
-	artifact: Pick<ArtifactDescriptor, "kind" | "path" | "producer" | "sizeBytes" | "createdAt">;
-}
-
-function collectCrewArtifactIndex(cwd: string): CrewArtifactIndexEntry[] {
-	const entries: CrewArtifactIndexEntry[] = [];
-	for (const run of listRecentRuns(cwd, MAX_ARTIFACT_INDEX_RUNS)) {
-		for (const artifact of run.artifacts) {
-			entries.push({
-				runId: run.runId,
-				status: run.status,
-				team: run.team,
-				workflow: run.workflow,
-				goal: run.goal,
-				artifact: {
-					kind: artifact.kind,
-					path: artifact.path,
-					producer: artifact.producer,
-					sizeBytes: artifact.sizeBytes,
-					createdAt: artifact.createdAt,
-				},
-			});
-			if (entries.length >= MAX_ARTIFACT_INDEX_ITEMS) return entries;
-		}
-	}
-	return entries;
-}
-
-function formatCrewArtifactIndex(entries: CrewArtifactIndexEntry[]): string {
-	if (!entries.length) return "";
-	const lines = ["", "# pi-crew artifact index", "Preserve these run artifact references in the compaction summary:"];
-	for (const entry of entries) {
-		lines.push(`- ${entry.artifact.kind}: ${entry.artifact.path} (run=${entry.runId}, status=${entry.status}, team=${entry.team}, workflow=${entry.workflow ?? "none"}, producer=${entry.artifact.producer})`);
-	}
-	return lines.join("\n");
-}
-
-export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompactionGuardOptions): void {
-	let pendingCompactReason: string | null = null;
-	let compactionInProgress = false;
-
-	const startCompact = (ctx: ExtensionContext, reason: string): void => {
-		if (compactionInProgress) return;
-		compactionInProgress = true;
-		const artifactIndex = collectCrewArtifactIndex(ctx.cwd);
-		if (artifactIndex.length > 0) {
-			pi.appendEntry("crew:artifact-index", {
-				reason,
-				createdAt: new Date().toISOString(),
-				artifacts: artifactIndex,
-			});
-		}
-		ctx.compact({
-			customInstructions: `Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.${formatCrewArtifactIndex(artifactIndex)}`,
-			onComplete: () => {
-				compactionInProgress = false;
-				ctx.ui.notify(reason === "deferred" ? "Deferred compaction completed" : "Auto-compacted context during team run", "info");
-			},
-			onError: (error) => {
-				compactionInProgress = false;
-				ctx.ui.notify(`${reason === "deferred" ? "Deferred" : "Auto"} compaction failed: ${error.message}`, "error");
-			},
-		});
-	};
-
-	// Phase 1.2: Defer compaction during foreground runs unless context is critically full.
-	pi.on("session_before_compact", async (_event, ctx) => {
-		if (options.foregroundControllers.size === 0) return;
-		const ratio = usageRatio(ctx);
-		if (ratio !== undefined && ratio >= HARD_RATIO) {
-			ctx.ui.notify("Compaction allowed despite foreground run: context is critically full", "warning");
-			return;
-		}
-		pendingCompactReason = "deferred-during-foreground-run";
-		ctx.ui.notify("Compaction deferred: foreground team run in progress", "info");
-		return { cancel: true };
-	});
-
-	// Phase 2.1: Proactive compaction with dynamic threshold based on model context window.
-	pi.on("turn_end", (_event, ctx) => {
-		if (compactionInProgress) return;
-		if (options.foregroundControllers.size === 0 && pendingCompactReason) {
-			pendingCompactReason = null;
-			startCompact(ctx, "deferred");
-			return;
-		}
-		const ratio = usageRatio(ctx);
-		if (ratio === undefined || ratio < TRIGGER_RATIO) return;
-		if (options.foregroundControllers.size > 0) {
-			pendingCompactReason = "threshold-during-foreground-run";
-			return;
-		}
-		startCompact(ctx, "threshold");
-	});
-}
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { listRecentRuns } from "../run-index.ts";
+import type { ArtifactDescriptor, TeamRunManifest } from "../../state/types.ts";
+
+export interface RegisterCompactionGuardOptions {
+	foregroundControllers: Map<string | symbol, AbortController>;
+}
+
+const TRIGGER_RATIO = 0.75;
+const HARD_RATIO = 0.95;
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const MAX_ARTIFACT_INDEX_RUNS = 10;
+const MAX_ARTIFACT_INDEX_ITEMS = 80;
+
+function contextWindow(ctx: { model?: { contextWindow?: number } }): number {
+	const value = ctx.model?.contextWindow;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_CONTEXT_WINDOW;
+}
+
+function usageRatio(ctx: { getContextUsage(): { tokens: number | null } | undefined; model?: { contextWindow?: number } }): number | undefined {
+	const tokens = ctx.getContextUsage()?.tokens;
+	if (tokens === null || tokens === undefined || !Number.isFinite(tokens)) return undefined;
+	return tokens / contextWindow(ctx);
+}
+
+interface CrewArtifactIndexEntry {
+	runId: string;
+	status: TeamRunManifest["status"];
+	team: string;
+	workflow?: string;
+	goal: string;
+	artifact: Pick<ArtifactDescriptor, "kind" | "path" | "producer" | "sizeBytes" | "createdAt">;
+}
+
+function collectCrewArtifactIndex(cwd: string): CrewArtifactIndexEntry[] {
+	const entries: CrewArtifactIndexEntry[] = [];
+	for (const run of listRecentRuns(cwd, MAX_ARTIFACT_INDEX_RUNS)) {
+		for (const artifact of run.artifacts) {
+			entries.push({
+				runId: run.runId,
+				status: run.status,
+				team: run.team,
+				workflow: run.workflow,
+				goal: run.goal,
+				artifact: {
+					kind: artifact.kind,
+					path: artifact.path,
+					producer: artifact.producer,
+					sizeBytes: artifact.sizeBytes,
+					createdAt: artifact.createdAt,
+				},
+			});
+			if (entries.length >= MAX_ARTIFACT_INDEX_ITEMS) return entries;
+		}
+	}
+	return entries;
+}
+
+function formatCrewArtifactIndex(entries: CrewArtifactIndexEntry[]): string {
+	if (!entries.length) return "";
+	const lines = ["", "# pi-crew artifact index", "Preserve these run artifact references in the compaction summary:"];
+	for (const entry of entries) {
+		lines.push(`- ${entry.artifact.kind}: ${entry.artifact.path} (run=${entry.runId}, status=${entry.status}, team=${entry.team}, workflow=${entry.workflow ?? "none"}, producer=${entry.artifact.producer})`);
+	}
+	return lines.join("\n");
+}
+
+export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompactionGuardOptions): void {
+	let pendingCompactReason: string | null = null;
+	let compactionInProgress = false;
+
+	const startCompact = (ctx: ExtensionContext, reason: string): void => {
+		if (compactionInProgress) return;
+		compactionInProgress = true;
+		const artifactIndex = collectCrewArtifactIndex(ctx.cwd);
+		if (artifactIndex.length > 0) {
+			pi.appendEntry("crew:artifact-index", {
+				reason,
+				createdAt: new Date().toISOString(),
+				artifacts: artifactIndex,
+			});
+		}
+		ctx.compact({
+			customInstructions: `Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.${formatCrewArtifactIndex(artifactIndex)}`,
+			onComplete: () => {
+				compactionInProgress = false;
+				ctx.ui.notify(reason === "deferred" ? "Deferred compaction completed" : "Auto-compacted context during team run", "info");
+			},
+			onError: (error) => {
+				compactionInProgress = false;
+				ctx.ui.notify(`${reason === "deferred" ? "Deferred" : "Auto"} compaction failed: ${error.message}`, "error");
+			},
+		});
+	};
+
+	// Phase 1.2: Defer compaction during foreground runs unless context is critically full.
+	pi.on("session_before_compact", async (_event, ctx) => {
+		if (options.foregroundControllers.size === 0) return;
+		const ratio = usageRatio(ctx);
+		if (ratio !== undefined && ratio >= HARD_RATIO) {
+			ctx.ui.notify("Compaction allowed despite foreground run: context is critically full", "warning");
+			return;
+		}
+		pendingCompactReason = "deferred-during-foreground-run";
+		ctx.ui.notify("Compaction deferred: foreground team run in progress", "info");
+		return { cancel: true };
+	});
+
+	// Phase 2.1: Proactive compaction with dynamic threshold based on model context window.
+	pi.on("turn_end", (_event, ctx) => {
+		if (compactionInProgress) return;
+		if (options.foregroundControllers.size === 0 && pendingCompactReason) {
+			pendingCompactReason = null;
+			startCompact(ctx, "deferred");
+			return;
+		}
+		const ratio = usageRatio(ctx);
+		if (ratio === undefined || ratio < TRIGGER_RATIO) return;
+		if (options.foregroundControllers.size > 0) {
+			pendingCompactReason = "threshold-during-foreground-run";
+			return;
+		}
+		startCompact(ctx, "threshold");
+	});
+}

package/src/extension/registration/team-tool.ts

@@ -14,8 +14,9 @@ import { withSessionId } from "../team-tool/context.ts";
 import { toolResult } from "../tool-result.ts";
 
 export interface RegisterTeamToolDeps {
-	foregroundControllers: Set<AbortController>;
+	foregroundControllers: Map<string | symbol, AbortController>;
 	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
+	abortForegroundRun: (runId: string) => boolean;
 	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
 	getManifestCache: (cwd: string) => ReturnType<typeof createManifestCache>;
 	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
@@ -46,7 +47,8 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 		parameters: TeamToolParams as never,
 		async execute(_id, params, signal, _onUpdate, ctx) {
 			const controller = new AbortController();
-			deps.foregroundControllers.add(controller);
+			const toolKey = Symbol();
+			deps.foregroundControllers.set(toolKey, controller);
 			const abort = (): void => controller.abort();
 			signal?.addEventListener("abort", abort, { once: true });
 			try {
@@ -59,7 +61,7 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 					const runLabel = resolved.team ?? resolved.agent ?? "direct";
 					pi.setSessionName(`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`);
 				}
-				const output = await handleTeamTool(resolved, { ...toolCtx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(toolCtx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(toolCtx, runId), onJsonEvent: deps.onJsonEvent });
+				const output = await handleTeamTool(resolved, { ...toolCtx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(toolCtx, runner, runId), abortForegroundRun: deps.abortForegroundRun, onRunStarted: (runId) => deps.openLiveSidebar(toolCtx, runId), onJsonEvent: deps.onJsonEvent });
 				if (resolved.action === "run" && !output.isError && typeof output.details?.runId === "string") {
 					pi.appendEntry("crew:run-started", {
 						runId: output.details.runId,
@@ -79,7 +81,7 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 				return output;
 			} finally {
 				signal?.removeEventListener("abort", abort);
-				deps.foregroundControllers.delete(controller);
+				deps.foregroundControllers.delete(toolKey);
 			}
 		},
 	};

package/src/extension/run-bundle-schema.ts

@@ -1,89 +1,89 @@
-import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
-import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import type { ExportedRunBundle } from "./run-export.ts";
-
-export interface BundleValidationResult {
-	ok: boolean;
-	errors: string[];
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
-	if (!isRecord(value)) {
-		errors.push(`manifest.artifacts[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
-	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
-	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
-	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
-	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
-	return errors.length === before;
-}
-
-function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
-	if (!isRecord(value)) {
-		errors.push("manifest must be an object.");
-		return false;
-	}
-	const before = errors.length;
-	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
-	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
-		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
-	}
-	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
-	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
-	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
-	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
-	return errors.length === before;
-}
-
-function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
-	if (!isRecord(value)) {
-		errors.push(`tasks[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
-		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
-	}
-	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
-	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
-	return errors.length === before;
-}
-
-function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
-	if (!isRecord(value)) {
-		errors.push(`events[${index}] must be an object.`);
-		return false;
-	}
-	const before = errors.length;
-	for (const field of ["time", "type", "runId"] as const) {
-		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
-	}
-	return errors.length === before;
-}
-
-export function validateRunBundle(value: unknown): BundleValidationResult {
-	const errors: string[] = [];
-	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
-	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
-	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
-	validateManifest(value.manifest, errors);
-	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
-	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
-	if (!Array.isArray(value.events)) errors.push("events must be an array.");
-	else value.events.forEach((event, index) => validateEvent(event, index, errors));
-	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
-	return { ok: errors.length === 0, errors };
-}
-
-export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
-	const validation = validateRunBundle(value);
-	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
-}
+import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
+import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
+import type { TeamEvent } from "../state/event-log.ts";
+import type { ExportedRunBundle } from "./run-export.ts";
+
+export interface BundleValidationResult {
+	ok: boolean;
+	errors: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function validateArtifact(value: unknown, index: number, errors: string[]): value is ArtifactDescriptor {
+	if (!isRecord(value)) {
+		errors.push(`manifest.artifacts[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	if (typeof value.kind !== "string") errors.push(`manifest.artifacts[${index}].kind must be a string.`);
+	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
+	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
+	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
+	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
+	return errors.length === before;
+}
+
+function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
+	if (!isRecord(value)) {
+		errors.push("manifest must be an object.");
+		return false;
+	}
+	const before = errors.length;
+	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
+	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
+		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
+	}
+	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
+	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
+	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
+	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
+	return errors.length === before;
+}
+
+function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
+	if (!isRecord(value)) {
+		errors.push(`tasks[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["id", "runId", "role", "agent", "title", "cwd"] as const) {
+		if (typeof value[field] !== "string") errors.push(`tasks[${index}].${field} must be a string.`);
+	}
+	if (!isTeamTaskStatus(value.status)) errors.push(`tasks[${index}].status is invalid.`);
+	if (!Array.isArray(value.dependsOn)) errors.push(`tasks[${index}].dependsOn must be an array.`);
+	return errors.length === before;
+}
+
+function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
+	if (!isRecord(value)) {
+		errors.push(`events[${index}] must be an object.`);
+		return false;
+	}
+	const before = errors.length;
+	for (const field of ["time", "type", "runId"] as const) {
+		if (typeof value[field] !== "string") errors.push(`events[${index}].${field} must be a string.`);
+	}
+	return errors.length === before;
+}
+
+export function validateRunBundle(value: unknown): BundleValidationResult {
+	const errors: string[] = [];
+	if (!isRecord(value)) return { ok: false, errors: ["bundle must be an object."] };
+	if (value.schemaVersion !== 1) errors.push("schemaVersion must be 1.");
+	if (typeof value.exportedAt !== "string") errors.push("exportedAt must be a string.");
+	validateManifest(value.manifest, errors);
+	if (!Array.isArray(value.tasks)) errors.push("tasks must be an array.");
+	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
+	if (!Array.isArray(value.events)) errors.push("events must be an array.");
+	else value.events.forEach((event, index) => validateEvent(event, index, errors));
+	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
+	return { ok: errors.length === 0, errors };
+}
+
+export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
+	const validation = validateRunBundle(value);
+	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
+}

package/src/extension/run-index.ts

@@ -5,8 +5,12 @@ 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 {
@@ -14,23 +18,25 @@ function readManifest(filePath: string): TeamRunManifest | undefined {
 	}
 }
 
-function collectRuns(root: string, maxEntries?: number): TeamRunManifest[] {
+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;
-	return selected
-		.map((entry) => {
-			try {
-				return readManifest(path.join(resolveRealContainedPath(runsRoot, entry), DEFAULT_PATHS.state.manifestFile));
-			} catch {
-				return undefined;
-			}
-		})
-		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
+	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) results.push(manifest);
+		} catch { /* skip unreadable manifests */ }
+	}
+	return results;
 }
 
 function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[] {
@@ -54,14 +60,14 @@ function collectActiveRuns(): TeamRunManifest[] {
 		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
 }
 
-export function listRuns(cwd: string): TeamRunManifest[] {
+export function listRuns(cwd: string, signal?: AbortSignal): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
-	return mergeRuns([...roots.map((root) => collectRuns(root)), collectActiveRuns()]);
+	return mergeRuns([...roots.map((root) => collectRuns(root, undefined, signal)), collectActiveRuns()]);
 }
 
-export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
+export function listRecentRuns(cwd: string, max = 20, signal?: AbortSignal): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
-	return mergeRuns([...roots.map((root) => collectRuns(root, max)), collectActiveRuns()], max);
+	return mergeRuns([...roots.map((root) => collectRuns(root, max, signal)), collectActiveRuns()], max);
 }
 
 /**
@@ -70,15 +76,15 @@ export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
  * - "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): TeamRunManifest[] {
+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) : [];
+			return projectRoot ? collectRuns(projectCrewRoot(cwd), max, signal) : [];
 		case "user":
-			return collectRuns(userCrewRoot(), max);
+			return collectRuns(userCrewRoot(), max, signal);
 		case "all":
 		default:
-			return max !== undefined ? listRecentRuns(cwd, max) : listRuns(cwd);
+			return max !== undefined ? listRecentRuns(cwd, max, signal) : listRuns(cwd, signal);
 	}
 }