pi-crew 0.1.41 → 0.1.44

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: 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");
+	});
+}

package/src/extension/registration/subagent-tools.ts

@@ -7,6 +7,7 @@ import { readPersistedSubagentRecord, savePersistedSubagentRecord, type Subagent
 import { loadConfig } from "../../config/config.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { __test__subagentSpawnParams, formatSubagentRecord, readSubagentRunResult, refreshPersistedSubagentRecord, subagentToolResult } from "./subagent-helpers.ts";
+import { t } from "../../i18n.ts";
 
 export interface SubagentToolRegistrationOptions {
 	ownerSessionGeneration?: () => number;
@@ -37,7 +38,7 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 			if (!permission.allowed) return subagentToolResult(permission.reason ?? "Current role cannot spawn subagents.", { role: currentRole, mode: permission.mode }, true);
 			const spawnOptions = __test__subagentSpawnParams(params as Record<string, unknown>, ctx);
 			spawnOptions.ownerSessionGeneration = options.ownerSessionGeneration?.();
-			if (!spawnOptions.prompt.trim()) return subagentToolResult("Agent requires prompt.", {}, true);
+			if (!spawnOptions.prompt.trim()) return subagentToolResult(t("agent.requiresPrompt"), {}, true);
 			const runner = async (currentOptions: SubagentSpawnOptions, childSignal?: AbortSignal) => handleTeamTool({ action: "run", agent: currentOptions.type, goal: currentOptions.prompt, model: currentOptions.model, async: currentOptions.background, config: currentOptions.maxTurns ? { runtime: { maxTurns: currentOptions.maxTurns } } : undefined } as TeamToolParamsValue, currentOptions.background ? { ...ctx, signal: childSignal } : { ...ctx, signal: childSignal });
 			const record = subagentManager.spawn(spawnOptions, runner, spawnOptions.background ? undefined : signal);
 			if (spawnOptions.background || record.status === "queued") {
@@ -45,11 +46,11 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 				// Phase 1.6: Record was terminated for telemetry.
 				record.terminated = true;
 				savePersistedSubagentRecord(ctx.cwd, record);
-				return { ...subagentToolResult([`Agent ${record.status === "queued" ? "queued" : "started"}.`, `Agent ID: ${record.id}`, `Type: ${record.type}`, `Description: ${record.description}`, "Use get_subagent_result to retrieve output. Do not duplicate this agent's work."].join("\n"), { agentId: record.id, status: record.status }), terminate: true };
+				return { ...subagentToolResult([t("agent.started", { state: record.status === "queued" ? "queued" : "started" }), t("agent.id", { id: record.id }), t("agent.type", { type: record.type }), t("agent.description", { description: record.description }), t("agent.retrieveHint")].join("\n"), { agentId: record.id, status: record.status }), terminate: true };
 			}
 			await record.promise;
-			const output = readSubagentRunResult(ctx, record) ?? record.result ?? "No output.";
-			const foregroundResult = subagentToolResult([`Agent ${record.id} ${record.status}.`, "", output].join("\n"), { agentId: record.id, runId: record.runId, status: record.status }, record.status === "failed" || record.status === "error");
+			const output = readSubagentRunResult(ctx, record) ?? record.result ?? t("agent.noOutput");
+			const foregroundResult = subagentToolResult([t("agent.foregroundStatus", { id: record.id, status: record.status }), "", output].join("\n"), { agentId: record.id, runId: record.runId, status: record.status }, record.status === "failed" || record.status === "error");
 			if (loadConfig(ctx.cwd).config.tools?.terminateOnForeground === true) {
 				record.terminated = true;
 				savePersistedSubagentRecord(ctx.cwd, record);
@@ -66,14 +67,14 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 		parameters: Type.Object({ agent_id: Type.String({ description: "Agent ID returned by Agent." }), wait: Type.Optional(Type.Boolean({ description: "Wait for completion before returning." })), verbose: Type.Optional(Type.Boolean({ description: "Include status metadata before output." })) }) as never,
 		async execute(_id, params, signal, _onUpdate, ctx) {
 			const p = params as { agent_id?: string; wait?: boolean; verbose?: boolean };
-			if (!p.agent_id) return subagentToolResult("get_subagent_result requires agent_id.", {}, true);
+			if (!p.agent_id) return subagentToolResult(t("result.requiresAgentId"), {}, true);
 			const inMemory = subagentManager.getRecord(p.agent_id);
 			const record = inMemory ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id);
-			if (!record) return subagentToolResult(`Agent not found: ${p.agent_id}`, {}, true);
+			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id }), {}, true);
 			let current = refreshPersistedSubagentRecord(ctx, record);
 			if (inMemory && current !== inMemory) Object.assign(inMemory, current);
 			if (!inMemory && !current.runId && (current.status === "running" || current.status === "queued")) {
-				current = { ...current, status: "error", error: "Subagent was interrupted before its durable run id was recorded; it cannot be recovered after restart.", completedAt: current.completedAt ?? Date.now() };
+				current = { ...current, status: "error", error: t("result.unrecoverable"), completedAt: current.completedAt ?? Date.now() };
 				savePersistedSubagentRecord(ctx.cwd, current);
 			}
 			if (p.wait && (current.status === "running" || current.status === "queued")) {
@@ -83,16 +84,24 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 					current.resultConsumed = false;
 					if (inMemory) inMemory.resultConsumed = false;
 					savePersistedSubagentRecord(ctx.cwd, current);
-				}
-				else while (current.status === "running" || current.status === "queued") {
-					if (signal?.aborted) {
-						current = { ...current, status: "error", error: "Waiting for subagent result was aborted.", completedAt: Date.now() };
-						savePersistedSubagentRecord(ctx.cwd, current);
-						break;
+				} else {
+					const waitStartMs = Date.now();
+					const maxWaitMs = 300_000; // 5 minutes
+					while (current.status === "running" || current.status === "queued") {
+						if (signal?.aborted) {
+							current = { ...current, status: "error", error: t("result.waitAborted"), completedAt: Date.now() };
+							savePersistedSubagentRecord(ctx.cwd, current);
+							break;
+						}
+						if (Date.now() - waitStartMs > maxWaitMs) {
+							current = { ...current, status: "error", error: t("result.waitTimeout"), completedAt: Date.now() };
+							savePersistedSubagentRecord(ctx.cwd, current);
+							break;
+						}
+						await new Promise((resolve) => setTimeout(resolve, 1000));
+						current = refreshPersistedSubagentRecord(ctx, current);
+						if (!current.runId) break;
 					}
-					await new Promise((resolve) => setTimeout(resolve, 1000));
-					current = refreshPersistedSubagentRecord(ctx, current);
-					if (!current.runId) break;
 				}
 			}
 			const output = readSubagentRunResult(ctx, current);
@@ -101,7 +110,7 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 				if (inMemory) inMemory.resultConsumed = true;
 				savePersistedSubagentRecord(ctx.cwd, current);
 			}
-			const text = [p.verbose ? formatSubagentRecord(current) : undefined, output ? `${p.verbose ? "\n" : ""}${output}` : current.status === "running" || current.status === "queued" ? "Agent is still running. Use wait=true or check again later." : current.error ?? "No output."].filter((line): line is string => Boolean(line)).join("\n");
+			const text = [p.verbose ? formatSubagentRecord(current) : undefined, output ? `${p.verbose ? "\n" : ""}${output}` : current.status === "running" || current.status === "queued" ? t("result.stillRunning") : current.error ?? t("agent.noOutput")].filter((line): line is string => Boolean(line)).join("\n");
 			return subagentToolResult(text, { agentId: current.id, runId: current.runId, status: current.status }, current.status === "failed" || current.status === "error");
 		},
 	};
@@ -114,8 +123,8 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			const p = params as { agent_id?: string; message?: string };
 			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id) : undefined;
-			if (!record) return subagentToolResult(`Agent not found: ${p.agent_id ?? ""}`, {}, true);
-			return subagentToolResult([`Steering request noted for ${record.id}.`, "Current default pi-crew backend is child-process, so mid-turn session.steer is not available yet.", record.runId ? `Use team cancel runId=${record.runId} if the agent must be interrupted.` : undefined].filter((line): line is string => Boolean(line)).join("\n"), { agentId: record.id, runId: record.runId, status: record.status });
+			if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id ?? "" }), {}, true);
+			return subagentToolResult([t("steer.noted", { id: record.id }), t("steer.unavailable"), record.runId ? t("steer.cancelHint", { runId: record.runId }) : undefined].filter((line): line is string => Boolean(line)).join("\n"), { agentId: record.id, runId: record.runId, status: record.status });
 		},
 	};
 

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

@@ -17,6 +17,7 @@ export interface RegisterTeamToolDeps {
 	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
 	getMetricRegistry?: () => MetricRegistry | undefined;
 	widgetState: CrewWidgetState;
+	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
 
 export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
@@ -38,7 +39,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, { ...ctx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId) });
+				const output = await handleTeamTool(resolved, { ...ctx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => deps.openLiveSidebar(ctx, runId), onJsonEvent: deps.onJsonEvent });
 				if (resolved.action === "run") {
 					pi.appendEntry("crew:run-started", {
 						runId: output.details?.runId,

package/src/extension/result-watcher.ts

@@ -61,7 +61,7 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 			coalescer.schedule(file, RESULT_WATCHER_POLL_MS);
 			return;
 		}
-		const key = buildCompletionKey(payload as Record<string, unknown>, `file:${file}`);
+		const key = buildCompletionKey(payload && typeof payload === "object" && !Array.isArray(payload) ? payload as Record<string, unknown> : {}, `file:${file}`);
 		if (!markSeenWithTtl(seen, key, Date.now(), completionTtlMs)) {
 			events.emit(eventName, payload);
 		}
@@ -78,7 +78,7 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 	const startPolling = () => {
 		if (pollTimer) return;
 		pollTimer = setInterval(poll, RESULT_WATCHER_POLL_MS);
-		pollTimer.unref?.();
+		pollTimer.unref();
 		poll();
 	};
 	const stopPolling = () => {
@@ -98,7 +98,7 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 				logInternalError("result-watcher.restart", error, `resultsDir=${resultsDir}`);
 			}
 		}, RESULT_WATCHER_RESTART_MS);
-		restartTimer.unref?.();
+		restartTimer.unref();
 	};
 	const handle: ResultWatcherHandle = {
 		start() {
@@ -110,7 +110,7 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 				coalescer.schedule(fileName.toString());
 			}, scheduleRestart);
 			if (watcher) stopPolling();
-			watcher?.unref?.();
+			watcher?.unref();
 		},
 		prime() {
 			poll();

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

@@ -17,12 +17,13 @@ function validateArtifact(value: unknown, index: number, errors: string[]): valu
 		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 true;
+	return errors.length === before;
 }
 
 function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
@@ -30,6 +31,7 @@ function validateManifest(value: unknown, errors: string[]): value is TeamRunMan
 		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.`);
@@ -38,7 +40,7 @@ function validateManifest(value: unknown, errors: string[]): value is TeamRunMan
 	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 true;
+	return errors.length === before;
 }
 
 function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
@@ -46,12 +48,13 @@ function validateTask(value: unknown, index: number, errors: string[]): value is
 		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 true;
+	return errors.length === before;
 }
 
 function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
@@ -59,10 +62,11 @@ function validateEvent(value: unknown, index: number, errors: string[]): value i
 		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 true;
+	return errors.length === before;
 }
 
 export function validateRunBundle(value: unknown): BundleValidationResult {

package/src/extension/run-import.ts

@@ -29,6 +29,10 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 	resolveRealContainedPath(path.dirname(importsRoot), path.basename(importsRoot));
 	const root = resolveContainedRelativePath(importsRoot, runId, "runId");
 	fs.mkdirSync(root, { recursive: true });
+	// TOCTOU note: mkdirSync would throw EEXIST if a symlink already existed.
+	// The lstatSync check catches a symlink swapped in between mkdirSync and the check
+	// (theoretically possible but requires local attacker with exact timing).
+	// resolveRealContainedPath provides an additional real-path containment barrier.
 	if (fs.lstatSync(root).isSymbolicLink()) throw new Error(`Invalid import directory: ${root}`);
 	resolveRealContainedPath(importsRoot, runId);
 	const targetJson = path.join(root, "run-export.json");

package/src/extension/run-index.ts

@@ -40,7 +40,10 @@ function mergeRuns(runSets: TeamRunManifest[][], max?: number): TeamRunManifest[
 }
 
 function scopedRunRoots(cwd: string): string[] {
-	return [findRepoRoot(cwd) ? projectCrewRoot(cwd) : userCrewRoot()];
+	const roots: string[] = [userCrewRoot()];
+	const projectRoot = findRepoRoot(cwd);
+	if (projectRoot) roots.unshift(projectCrewRoot(cwd));
+	return roots;
 }
 
 export function listRuns(cwd: string): TeamRunManifest[] {
@@ -52,3 +55,22 @@ export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
 	const roots = scopedRunRoots(cwd);
 	return mergeRuns(roots.map((root) => collectRuns(root, max)), 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): TeamRunManifest[] {
+	const projectRoot = findRepoRoot(cwd);
+	switch (scope) {
+		case "project":
+			return projectRoot ? collectRuns(projectCrewRoot(cwd), max) : [];
+		case "user":
+			return collectRuns(userCrewRoot(), max);
+		case "all":
+		default:
+			return max !== undefined ? listRecentRuns(cwd, max) : listRuns(cwd);
+	}
+}

package/src/extension/run-maintenance.ts

@@ -1,24 +1,43 @@
-import * as fs from "node:fs";
-import type { TeamRunManifest } from "../state/types.ts";
-import { listRuns } from "./run-index.ts";
-
-export interface PruneRunsResult {
-	kept: string[];
-	removed: string[];
-}
-
-function isFinished(run: TeamRunManifest): boolean {
-	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
-}
-
-export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
-	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)) {
-		fs.rmSync(run.stateRoot, { recursive: true, force: true });
-		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
-		removed.push(run.runId);
-	}
-	return { kept, removed };
-}
+import * as fs from "node:fs";
+import type { TeamRunManifest } from "../state/types.ts";
+import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+import { listRuns } from "./run-index.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+
+export interface PruneRunsResult {
+	kept: string[];
+	removed: string[];
+}
+
+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 = projectCrewRoot(cwd);
+		resolveRealContainedPath(crewRoot, run.stateRoot);
+		resolveRealContainedPath(crewRoot, run.artifactsRoot);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
+	const crewRoot = projectCrewRoot(cwd);
+	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)) {
+		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);
+	}
+	return { kept, removed };
+}

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

@@ -22,7 +22,7 @@ import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 
 function globMatch(value: string, pattern: string): boolean {
-	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\?/g, "\\?").replace(/\*/g, ".*");
 	return new RegExp(`^${escaped}$`).test(value);
 }
 
@@ -110,7 +110,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 				const approval = current.manifest.planApproval;
 				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 				const now = new Date().toISOString();
-				const tasks = current.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: now, error: "Plan approval was cancelled." } : task);
+				const tasks = current.tasks.map((task) => task.status === "queued" || task.status === "running" || task.status === "waiting" ? { ...task, status: "cancelled" as const, finishedAt: now, error: "Plan approval was cancelled." } : task);
 				let manifest: typeof current.manifest = { ...current.manifest, updatedAt: now, planApproval: { ...approval, status: "cancelled" as const, cancelledAt: now, updatedAt: now } };
 				saveRunManifest(manifest);
 				saveRunTasks(manifest, tasks);