pi-crew 0.9.16 → 0.9.18

package/src/extension/team-tool/lifecycle-actions.ts

@@ -1,7 +1,12 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
+import { removeGuidance } from "../../config/markers.ts";
+import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEvent } from "../../state/event-log.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
+import { projectCrewRoot, userCrewRoot, userPiRoot } from "../../utils/paths.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import { cleanupRunWorktrees } from "../../worktree/cleanup.ts";
 import { listImportedRuns } from "../import-index.ts";
 import { exportRunBundle } from "../run-export.ts";
@@ -9,26 +14,42 @@ import { importRunBundle } from "../run-import.ts";
 import { pruneFinishedRuns } from "../run-maintenance.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
-import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
-import { executeHook, appendHookEvent } from "../../hooks/registry.ts";
-import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
-import { projectCrewRoot, userCrewRoot, userPiRoot } from "../../utils/paths.ts";
-import { removeGuidance } from "../../config/markers.ts";
-import * as path from "node:path";
+import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 export function handleWorktrees(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	if (!params.runId) return result("Worktrees requires runId.", { action: "worktrees", status: "error" }, true);
 	const loaded = loadRunManifestById(ctx.cwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "worktrees", status: "error" }, true);
 	const withWorktrees = loaded.tasks.filter((task) => task.worktree);
-	const lines = [`Worktrees for ${loaded.manifest.runId}:`, ...(withWorktrees.length ? withWorktrees.map((task) => `- ${task.id}: ${task.worktree!.path} branch=${task.worktree!.branch} reused=${task.worktree!.reused ? "true" : "false"}`) : ["- (none)"])];
-	return result(lines.join("\n"), { action: "worktrees", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	const lines = [
+		`Worktrees for ${loaded.manifest.runId}:`,
+		...(withWorktrees.length
+			? withWorktrees.map(
+					(task) =>
+						`- ${task.id}: ${task.worktree!.path} branch=${task.worktree!.branch} reused=${task.worktree!.reused ? "true" : "false"}`,
+				)
+			: ["- (none)"]),
+	];
+	return result(lines.join("\n"), {
+		action: "worktrees",
+		status: "ok",
+		runId: loaded.manifest.runId,
+		artifactsRoot: loaded.manifest.artifactsRoot,
+	});
 }
 
 export function handleImports(_params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const imports = listImportedRuns(ctx.cwd);
-	const lines = ["Imported pi-crew runs:", ...(imports.length ? imports.map((entry) => `- ${entry.runId} (${entry.scope})${entry.status ? ` [${entry.status}]` : ""} ${entry.team ?? "unknown"}/${entry.workflow ?? "none"}: ${entry.goal ?? ""}\n  Bundle: ${entry.bundlePath}\n  Summary: ${entry.summaryPath}`) : ["- (none)"])];
+	const lines = [
+		"Imported pi-crew runs:",
+		...(imports.length
+			? imports.map(
+					(entry) =>
+						`- ${entry.runId} (${entry.scope})${entry.status ? ` [${entry.status}]` : ""} ${entry.team ?? "unknown"}/${entry.workflow ?? "none"}: ${entry.goal ?? ""}\n  Bundle: ${entry.bundlePath}\n  Summary: ${entry.summaryPath}`,
+				)
+			: ["- (none)"]),
+	];
 	return result(lines.join("\n"), { action: "imports", status: "ok" });
 }
 
@@ -39,7 +60,10 @@ export function handleImport(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const scope = cfg.scope === "user" ? "user" : "project";
 	try {
 		const imported = importRunBundle(ctx.cwd, bundlePath, scope);
-		return result([`Imported run bundle ${imported.runId}.`, `Bundle: ${imported.bundlePath}`, `Summary: ${imported.summaryPath}`].join("\n"), { action: "import", status: "ok" });
+		return result(
+			[`Imported run bundle ${imported.runId}.`, `Bundle: ${imported.bundlePath}`, `Summary: ${imported.summaryPath}`].join("\n"),
+			{ action: "import", status: "ok" },
+		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return result(`Import failed: ${message}`, { action: "import", status: "error" }, true);
@@ -56,18 +80,41 @@ export async function handleExport(params: TeamToolParamsValue, ctx: TeamContext
 	// Risk: exported bundles may contain sensitive data from another session's run.
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
 	if (foreignRun && !params.confirm) {
-		return result(`Run ${loaded.manifest.runId} belongs to another session. Use confirm: true to export anyway.`, { action: "export", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Run ${loaded.manifest.runId} belongs to another session. Use confirm: true to export anyway.`,
+			{ action: "export", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 
-	const hookReport = await executeHook("before_publish", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	const hookReport = await executeHook("before_publish", {
+		runId: loaded.manifest.runId,
+		cwd: ctx.cwd,
+	});
 	appendHookEvent(loaded.manifest, hookReport);
 	if (hookReport.outcome === "block") {
-		return result(`Export blocked by hook: ${hookReport.reason ?? "before_publish hook blocked the operation."}`, { action: "export", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Export blocked by hook: ${hookReport.reason ?? "before_publish hook blocked the operation."}`,
+			{ action: "export", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 
 	const exported = exportRunBundle(loaded.manifest, loaded.tasks);
-	appendEvent(loaded.manifest.eventsPath, { type: "run.exported", runId: loaded.manifest.runId, data: exported });
-	return result([`Exported run ${loaded.manifest.runId}.`, `JSON: ${exported.jsonPath}`, `Markdown: ${exported.markdownPath}`].join("\n"), { action: "export", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	appendEvent(loaded.manifest.eventsPath, {
+		type: "run.exported",
+		runId: loaded.manifest.runId,
+		data: exported,
+	});
+	return result(
+		[`Exported run ${loaded.manifest.runId}.`, `JSON: ${exported.jsonPath}`, `Markdown: ${exported.markdownPath}`].join("\n"),
+		{
+			action: "export",
+			status: "ok",
+			runId: loaded.manifest.runId,
+			artifactsRoot: loaded.manifest.artifactsRoot,
+		},
+	);
 }
 
 // Note: handlePrune has no ownership check — intentionally cross-session.
@@ -80,16 +127,35 @@ export async function handlePrune(params: TeamToolParamsValue, ctx: TeamContext)
 	const keep = params.keep ?? 20;
 	if (keep < 0 || !Number.isInteger(keep)) return result("keep must be an integer >= 0.", { action: "prune", status: "error" }, true);
 	const intent = intentFromConfig(params.config);
-	const pruned = pruneFinishedRuns(ctx.cwd, keep, { intent, signal: ctx.signal });
+	const pruned = pruneFinishedRuns(ctx.cwd, keep, {
+		intent,
+		signal: ctx.signal,
+	});
 	// Fire hook once with all removed run IDs for batch visibility
 	if (pruned.removed.length > 0) {
 		const sampleManifest = loadRunManifestById(ctx.cwd, pruned.removed[0])?.manifest;
 		if (sampleManifest) {
-			const hookReport = await executeHook("before_cleanup", { runId: sampleManifest.runId, cwd: ctx.cwd, data: { removedRunIds: pruned.removed, keptCount: pruned.kept.length } });
+			const hookReport = await executeHook("before_cleanup", {
+				runId: sampleManifest.runId,
+				cwd: ctx.cwd,
+				data: {
+					removedRunIds: pruned.removed,
+					keptCount: pruned.kept.length,
+				},
+			});
 			appendHookEvent(sampleManifest, hookReport);
 		}
 	}
-	return result([`Pruned finished pi-crew runs.`, `Kept: ${pruned.kept.length}`, `Removed: ${pruned.removed.length}`, ...(pruned.auditPath ? [`Audit: ${pruned.auditPath}`] : []), ...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : [])].join("\n"), { action: "prune", status: "ok", intent });
+	return result(
+		[
+			`Pruned finished pi-crew runs.`,
+			`Kept: ${pruned.kept.length}`,
+			`Removed: ${pruned.removed.length}`,
+			...(pruned.auditPath ? [`Audit: ${pruned.auditPath}`] : []),
+			...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : []),
+		].join("\n"),
+		{ action: "prune", status: "ok", intent },
+	);
 }
 
 export async function handleForget(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
@@ -102,25 +168,77 @@ export async function handleForget(params: TeamToolParamsValue, ctx: TeamContext
 
 	// Ownership check — prevent cross-session deletion unless force is set
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
-	if (foreignRun && !params.force) return result(`Run ${params.runId} belongs to another session. Use force: true to override.`, { action: "forget", status: "error", runId: loaded.manifest.runId }, true);
+	if (foreignRun && !params.force)
+		return result(
+			`Run ${params.runId} belongs to another session. Use force: true to override.`,
+			{ action: "forget", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 
-	const hookReport = await executeHook("before_forget", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	const hookReport = await executeHook("before_forget", {
+		runId: loaded.manifest.runId,
+		cwd: ctx.cwd,
+	});
 	appendHookEvent(loaded.manifest, hookReport);
 	if (hookReport.outcome === "block") {
-		return result(`Forget blocked by hook: ${hookReport.reason ?? "before_forget hook blocked the operation."}`, { action: "forget", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Forget blocked by hook: ${hookReport.reason ?? "before_forget hook blocked the operation."}`,
+			{ action: "forget", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
 	}
 
-	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force });
-	if (cleanup.preserved.length > 0 && !params.force) return result([`Run '${params.runId}' has preserved worktrees. Use force: true to forget anyway.`, ...cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`)].join("\n"), { action: "forget", status: "error", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot }, true);
+	const cleanup = cleanupRunWorktrees(loaded.manifest, {
+		force: params.force,
+	});
+	if (cleanup.preserved.length > 0 && !params.force)
+		return result(
+			[
+				`Run '${params.runId}' has preserved worktrees. Use force: true to forget anyway.`,
+				...cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`),
+			].join("\n"),
+			{
+				action: "forget",
+				status: "error",
+				runId: loaded.manifest.runId,
+				artifactsRoot: loaded.manifest.artifactsRoot,
+			},
+			true,
+		);
 	const intent = intentFromConfig(params.config);
-	appendEvent(loaded.manifest.eventsPath, { type: "run.forget_requested", runId: loaded.manifest.runId, message: "Run state and artifacts are being forgotten.", data: { force: params.force === true, removedWorktrees: cleanup.removed, preservedWorktrees: cleanup.preserved, intent } });
+	appendEvent(loaded.manifest.eventsPath, {
+		type: "run.forget_requested",
+		runId: loaded.manifest.runId,
+		message: "Run state and artifacts are being forgotten.",
+		data: {
+			force: params.force === true,
+			removedWorktrees: cleanup.removed,
+			preservedWorktrees: cleanup.preserved,
+			intent,
+		},
+	});
 	// Determine scope from manifest paths (project vs user-level runs)
-	const crewRoot = loaded.manifest.stateRoot.startsWith(userCrewRoot() + path.sep) ? userCrewRoot() : projectCrewRoot(loaded.manifest.cwd);
+	const crewRoot = loaded.manifest.stateRoot.startsWith(userCrewRoot() + path.sep)
+		? userCrewRoot()
+		: projectCrewRoot(loaded.manifest.cwd);
 	const resolvedStateRoot = resolveRealContainedPath(crewRoot, loaded.manifest.stateRoot);
 	const resolvedArtifactsRoot = resolveRealContainedPath(crewRoot, loaded.manifest.artifactsRoot);
 	fs.rmSync(resolvedStateRoot, { recursive: true, force: true });
 	fs.rmSync(resolvedArtifactsRoot, { recursive: true, force: true });
-	return result([`Forgot run ${loaded.manifest.runId}.`, `Removed state: ${loaded.manifest.stateRoot}`, `Removed artifacts: ${loaded.manifest.artifactsRoot}`, ...(cleanup.removed.length ? ["Removed worktrees:", ...cleanup.removed.map((item) => `- ${item}`)] : [])].join("\n"), { action: "forget", status: "ok", runId: loaded.manifest.runId, intent });
+	return result(
+		[
+			`Forgot run ${loaded.manifest.runId}.`,
+			`Removed state: ${loaded.manifest.stateRoot}`,
+			`Removed artifacts: ${loaded.manifest.artifactsRoot}`,
+			...(cleanup.removed.length ? ["Removed worktrees:", ...cleanup.removed.map((item) => `- ${item}`)] : []),
+		].join("\n"),
+		{
+			action: "forget",
+			status: "ok",
+			runId: loaded.manifest.runId,
+			intent,
+		},
+	);
 }
 
 export async function handleCleanup(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
@@ -180,11 +298,18 @@ function handleProjectCleanup(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	// 1. Remove the AGENTS.md guidance block (marker-delimited → user content preserved).
 	const guidancePath = path.join(cwd, "AGENTS.md");
 	const guidanceResult = dryRun
-		? { path: guidancePath, modified: fs.existsSync(guidancePath), added: [], removed: dryRunRemovedIds(guidancePath) }
+		? {
+				path: guidancePath,
+				modified: fs.existsSync(guidancePath),
+				added: [],
+				removed: dryRunRemovedIds(guidancePath),
+			}
 		: removeGuidance(guidancePath);
 	lines.push("AGENTS.md guidance block:");
 	if (guidanceResult.modified) {
-		lines.push(`  - ${dryRun ? "would remove" : "removed"}: ${guidanceResult.removed.length ? guidanceResult.removed.join(", ") : "(marker section)"}`);
+		lines.push(
+			`  - ${dryRun ? "would remove" : "removed"}: ${guidanceResult.removed.length ? guidanceResult.removed.join(", ") : "(marker section)"}`,
+		);
 	} else {
 		lines.push("  - (no pi-crew marker section found — nothing to do)");
 	}
@@ -196,7 +321,9 @@ function handleProjectCleanup(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	if (!crewExists) {
 		lines.push(`  - (not present at ${crewRoot} — nothing to do)`);
 	} else if (!removeState) {
-		lines.push(`  - present at ${crewRoot} (preserved — use force: true to remove; contains run history/artifacts/worktrees and is irreversible)`);
+		lines.push(
+			`  - present at ${crewRoot} (preserved — use force: true to remove; contains run history/artifacts/worktrees and is irreversible)`,
+		);
 	} else {
 		// SAFETY: realpath + contain-check before rmSync, so a crafted cwd can't
 		// trick us into deleting an arbitrary directory.
@@ -282,10 +409,15 @@ function handleUserCleanup(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 	if (fs.existsSync(crewStateDir)) {
 		try {
 			crewStateBytes = dirSize(crewStateDir);
-		} catch { /* best-effort size */ }
+		} catch {
+			/* best-effort size */
+		}
 		if (!dryRun) {
-			try { fs.rmSync(crewStateDir, { recursive: true, force: true }); }
-			catch (e) { lines.push(`  - ERROR removing: ${(e as Error).message}`); }
+			try {
+				fs.rmSync(crewStateDir, { recursive: true, force: true });
+			} catch (e) {
+				lines.push(`  - ERROR removing: ${(e as Error).message}`);
+			}
 		}
 		lines.push(`  - ${dryRun ? "would remove" : "removed"}: ${crewStateDir} (${formatBytes(crewStateBytes)})`);
 	} else {
@@ -303,8 +435,11 @@ function handleUserCleanup(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 		lines.push(`  - present at ${userConfigPath} (preserved — use force: true to remove; may hold your customized settings)`);
 	} else {
 		if (!dryRun) {
-			try { fs.rmSync(userConfigPath, { force: true }); }
-			catch (e) { lines.push(`  - ERROR removing: ${(e as Error).message}`); }
+			try {
+				fs.rmSync(userConfigPath, { force: true });
+			} catch (e) {
+				lines.push(`  - ERROR removing: ${(e as Error).message}`);
+			}
 		}
 		lines.push(`  - ${dryRun ? "would remove" : "removed"}: ${userConfigPath}`);
 	}
@@ -324,15 +459,20 @@ function handleUserCleanup(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 					bakJunk.push(path.join(agentsDir, entry));
 				}
 			}
-		} catch { /* best-effort scan */ }
+		} catch {
+			/* best-effort scan */
+		}
 	}
 	if (bakJunk.length === 0) {
 		lines.push("  - (no `*.md.bak-*` test backups found — nothing to do)");
 	} else {
 		for (const junk of bakJunk) {
 			if (!dryRun) {
-				try { fs.rmSync(junk, { force: true }); }
-				catch (e) { lines.push(`  - ERROR removing ${path.basename(junk)}: ${(e as Error).message}`); }
+				try {
+					fs.rmSync(junk, { force: true });
+				} catch (e) {
+					lines.push(`  - ERROR removing ${path.basename(junk)}: ${(e as Error).message}`);
+				}
 			}
 		}
 		lines.push(`  - ${dryRun ? "would remove" : "removed"}: ${bakJunk.length} backup file(s) (pattern *.md.bak-<timestamp>-<hex>)`);
@@ -354,15 +494,20 @@ function dirSize(dir: string): number {
 	while (stack.length > 0) {
 		const cur = stack.pop()!;
 		let entries: string[];
-		try { entries = fs.readdirSync(cur); }
-		catch { continue; }
+		try {
+			entries = fs.readdirSync(cur);
+		} catch {
+			continue;
+		}
 		for (const entry of entries) {
 			const full = path.join(cur, entry);
 			try {
 				const stat = fs.statSync(full);
 				if (stat.isDirectory()) stack.push(full);
 				else total += stat.size;
-			} catch { /* skip unreadable */ }
+			} catch {
+				/* skip unreadable */
+			}
 		}
 	}
 	return total;
@@ -378,20 +523,71 @@ function formatBytes(n: number): string {
 /** Per-run worktree cleanup (existing behavior, preserved). */
 async function handleRunCleanup(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const loaded = loadRunManifestById(ctx.cwd, params.runId!); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
-	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "cleanup", status: "error", runId: params.runId }, true);
+	if (!loaded)
+		return result(
+			`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`,
+			{ action: "cleanup", status: "error", runId: params.runId },
+			true,
+		);
 	// Ownership check — prevent cross-session worktree cleanup unless force is set
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
-	if (foreignRun && !params.force) return result(`Run ${params.runId} belongs to another session. Use force: true to override.`, { action: "cleanup", status: "error", runId: loaded.manifest.runId }, true);
+	if (foreignRun && !params.force)
+		return result(
+			`Run ${params.runId} belongs to another session. Use force: true to override.`,
+			{
+				action: "cleanup",
+				status: "error",
+				runId: loaded.manifest.runId,
+			},
+			true,
+		);
 
-	const hookReport = await executeHook("before_cleanup", { runId: loaded.manifest.runId, cwd: ctx.cwd });
+	const hookReport = await executeHook("before_cleanup", {
+		runId: loaded.manifest.runId,
+		cwd: ctx.cwd,
+	});
 	appendHookEvent(loaded.manifest, hookReport);
 	if (hookReport.outcome === "block") {
-		return result(`Cleanup blocked by hook: ${hookReport.reason ?? "before_cleanup hook blocked the operation."}`, { action: "cleanup", status: "error", runId: loaded.manifest.runId }, true);
+		return result(
+			`Cleanup blocked by hook: ${hookReport.reason ?? "before_cleanup hook blocked the operation."}`,
+			{
+				action: "cleanup",
+				status: "error",
+				runId: loaded.manifest.runId,
+			},
+			true,
+		);
 	}
 
-	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force, signal: ctx.signal });
+	const cleanup = cleanupRunWorktrees(loaded.manifest, {
+		force: params.force,
+		signal: ctx.signal,
+	});
 	const intent = intentFromConfig(params.config);
-	appendEvent(loaded.manifest.eventsPath, { type: "worktree.cleanup", runId: loaded.manifest.runId, data: { removed: cleanup.removed, preserved: cleanup.preserved, artifacts: cleanup.artifactPaths, intent } });
-	const lines = [`Worktree cleanup for ${loaded.manifest.runId}:`, "Removed:", ...(cleanup.removed.length ? cleanup.removed.map((item) => `- ${item}`) : ["- (none)"]), "Preserved:", ...(cleanup.preserved.length ? cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`) : ["- (none)"]), "Artifacts:", ...(cleanup.artifactPaths.length ? cleanup.artifactPaths.map((item) => `- ${item}`) : ["- (none)"])];
-	return result(lines.join("\n"), { action: "cleanup", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot, intent });
+	appendEvent(loaded.manifest.eventsPath, {
+		type: "worktree.cleanup",
+		runId: loaded.manifest.runId,
+		data: {
+			removed: cleanup.removed,
+			preserved: cleanup.preserved,
+			artifacts: cleanup.artifactPaths,
+			intent,
+		},
+	});
+	const lines = [
+		`Worktree cleanup for ${loaded.manifest.runId}:`,
+		"Removed:",
+		...(cleanup.removed.length ? cleanup.removed.map((item) => `- ${item}`) : ["- (none)"]),
+		"Preserved:",
+		...(cleanup.preserved.length ? cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`) : ["- (none)"]),
+		"Artifacts:",
+		...(cleanup.artifactPaths.length ? cleanup.artifactPaths.map((item) => `- ${item}`) : ["- (none)"]),
+	];
+	return result(lines.join("\n"), {
+		action: "cleanup",
+		status: "ok",
+		runId: loaded.manifest.runId,
+		artifactsRoot: loaded.manifest.artifactsRoot,
+		intent,
+	});
 }

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

@@ -6,16 +6,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
+import { resolveContainedPath } from "../../utils/safe-paths.ts";
 import {
 	buildAgentChain,
 	formatPlanOverview,
+	type OrchestratedStep,
 	parsePlanDocument,
 	parsePlanDocumentSimple,
-	type OrchestratedStep,
 } from "../plan-orchestrate.ts";
-import { resolveContainedPath } from "../../utils/safe-paths.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
 
 /**
  * Handle the orchestrate action.
@@ -25,10 +25,7 @@ import { resolveContainedPath } from "../../utils/safe-paths.ts";
  *
  * Usage: `team action='orchestrate' planPath='/path/to/plan.md'`
  */
-export function handleOrchestrate(
-	params: TeamToolParamsValue,
-	ctx: TeamContext,
-): PiTeamsToolResult {
+export function handleOrchestrate(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const planPath = params.planPath as string | undefined;
 
 	if (!planPath) {
@@ -44,19 +41,11 @@ export function handleOrchestrate(
 	try {
 		resolvedPath = resolveContainedPath(ctx.cwd, planPath);
 	} catch {
-		return result(
-			`planPath must be within project directory: ${planPath}`,
-			{ action: "orchestrate", status: "error" },
-			true,
-		);
+		return result(`planPath must be within project directory: ${planPath}`, { action: "orchestrate", status: "error" }, true);
 	}
 
 	if (!fs.existsSync(resolvedPath)) {
-		return result(
-			`Plan document not found: ${resolvedPath}`,
-			{ action: "orchestrate", status: "error" },
-			true,
-		);
+		return result(`Plan document not found: ${resolvedPath}`, { action: "orchestrate", status: "error" }, true);
 	}
 
 	// Try primary parser

package/src/extension/team-tool/parallel-dispatch.ts

@@ -8,18 +8,18 @@
  */
 import { discoverAgents } from "../../agents/discover-agents.ts";
 import { loadConfig } from "../../config/config.ts";
+import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { createRunManifest } from "../../state/state-store.ts";
 import { appendEvent } from "../../state/event-log.ts";
+import { createRunManifest } from "../../state/state-store.ts";
 import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
-import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
-import { resolveCwdOverride } from "../registration/team-tool.ts";
-import { result, type TeamContext } from "./context.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
 import { discoverTeams } from "../../teams/discover-teams.ts";
-import { discoverWorkflows } from "../../workflows/discover-workflows.ts";
 import type { TeamConfig } from "../../teams/team-config.ts";
+import { discoverWorkflows } from "../../workflows/discover-workflows.ts";
 import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
+import { resolveCwdOverride } from "../registration/team-tool.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
 
 const MAX_CONCURRENCY = 8;
 const DEFAULT_CONCURRENCY = 4;
@@ -32,10 +32,7 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 		return result("parallel action requires config.tasks: [{goal, agent?}]", { action: "parallel", status: "error" }, true);
 	}
 
-	const concurrency = Math.min(
-		Math.max(1, Math.floor((params.config?.concurrency as number) ?? DEFAULT_CONCURRENCY)),
-		MAX_CONCURRENCY,
-	);
+	const concurrency = Math.min(Math.max(1, Math.floor((params.config?.concurrency as number) ?? DEFAULT_CONCURRENCY)), MAX_CONCURRENCY);
 
 	const config = loadConfig(ctx.cwd);
 	const agentsResult = discoverAgents(ctx.cwd);
@@ -44,16 +41,16 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 	const workflows = discoverWorkflows(ctx.cwd);
 
 	const teamName = (params.config?.team as string) ?? DEFAULT_TEAM;
-	const team = teams.builtin.find((t) => t.name === teamName)
-		?? teams.user.find((t) => t.name === teamName)
-		?? teams.project.find((t) => t.name === teamName);
+	const team =
+		teams.builtin.find((t) => t.name === teamName) ??
+		teams.user.find((t) => t.name === teamName) ??
+		teams.project.find((t) => t.name === teamName);
 	if (!team) {
 		return result(`Team '${teamName}' not found`, { action: "parallel", status: "error" }, true);
 	}
 
 	// H2: Use team's defaultWorkflow, fall back to "fast-fix"
-	const workflow = workflows.builtin.find((w) => w.name === team.defaultWorkflow)
-		?? workflows.builtin.find((w) => w.name === "fast-fix");
+	const workflow = workflows.builtin.find((w) => w.name === team.defaultWorkflow) ?? workflows.builtin.find((w) => w.name === "fast-fix");
 	if (!workflow) {
 		return result("No suitable workflow found for parallel dispatch", { action: "parallel", status: "error" }, true);
 	}
@@ -75,15 +72,15 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 				errors.push(res.value.error);
 			} else {
 				const reason = (res as PromiseRejectedResult).reason;
-				errors.push({ goal: "(unknown)", error: reason instanceof Error ? reason.message : String(reason) });
+				errors.push({
+					goal: "(unknown)",
+					error: reason instanceof Error ? reason.message : String(reason),
+				});
 			}
 		}
 	}
 
-	const lines: string[] = [
-		`Parallel dispatch: ${launched.length}/${tasksParam.length} tasks launched (concurrency: ${concurrency})`,
-		"",
-	];
+	const lines: string[] = [`Parallel dispatch: ${launched.length}/${tasksParam.length} tasks launched (concurrency: ${concurrency})`, ""];
 	for (const l of launched) {
 		lines.push(`  ✅ ${l.runId} — ${l.agent}: ${l.goal.slice(0, 80)}`);
 	}
@@ -91,13 +88,20 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 		lines.push(`  ❌ ${e.goal.slice(0, 80)}: ${e.error}`);
 	}
 
-	return result(lines.join("\n"), {
-		action: "parallel",
-		status: errors.length === tasksParam.length ? "error" : "ok",
-	}, errors.length === tasksParam.length);
+	return result(
+		lines.join("\n"),
+		{
+			action: "parallel",
+			status: errors.length === tasksParam.length ? "error" : "ok",
+		},
+		errors.length === tasksParam.length,
+	);
 }
 
-type SpawnOk = { ok: true; value: { runId: string; goal: string; agent: string } };
+type SpawnOk = {
+	ok: true;
+	value: { runId: string; goal: string; agent: string };
+};
 type SpawnErr = { ok: false; error: { goal: string; error: string } };
 type SpawnResult = SpawnOk | SpawnErr;
 
@@ -116,12 +120,21 @@ async function spawnSingleTask(
 		const rawCwd = (taskRec.cwd as string) ?? undefined;
 
 		if (!goal) {
-			return { ok: false, error: { goal: "(missing)", error: "Each task must have a 'goal' field" } };
+			return {
+				ok: false,
+				error: {
+					goal: "(missing)",
+					error: "Each task must have a 'goal' field",
+				},
+			};
 		}
 
 		const agent = allAgentsList.find((a) => a.name === agentName);
 		if (!agent) {
-			return { ok: false, error: { goal, error: `Agent '${agentName}' not found` } };
+			return {
+				ok: false,
+				error: { goal, error: `Agent '${agentName}' not found` },
+			};
 		}
 
 		// H1: Validate taskCwd containment against project root
@@ -148,9 +161,18 @@ async function spawnSingleTask(
 			await spawnBackgroundTeamRun(created.manifest);
 		}
 
-		return { ok: true, value: { runId: created.manifest.runId, goal, agent: agentName } };
+		return {
+			ok: true,
+			value: { runId: created.manifest.runId, goal, agent: agentName },
+		};
 	} catch (error) {
 		const goal = ((task as Record<string, unknown>).goal as string) ?? "(unknown)";
-		return { ok: false, error: { goal, error: error instanceof Error ? error.message : String(error) } };
+		return {
+			ok: false,
+			error: {
+				goal,
+				error: error instanceof Error ? error.message : String(error),
+			},
+		};
 	}
 }