pi-crew 0.1.0

package/src/extension/register.ts

@@ -0,0 +1,349 @@
+import type { ExtensionAPI, ExtensionCommandContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { loadConfig } from "../config/config.ts";
+import { registerAutonomousPolicy } from "./autonomous-policy.ts";
+import { TeamToolParams, type TeamToolParamsValue } from "../schema/team-tool-schema.ts";
+import { startAsyncRunNotifier, stopAsyncRunNotifier, type AsyncNotifierState } from "./async-notifier.ts";
+import { notifyActiveRuns } from "./session-summary.ts";
+import { piTeamsHelp } from "./help.ts";
+import { handleTeamManagerCommand } from "./team-manager-command.ts";
+import { handleTeamTool, type TeamToolDetails } from "./team-tool.ts";
+import { listRuns } from "./run-index.ts";
+import { RunDashboard, type RunDashboardSelection } from "../ui/run-dashboard.ts";
+
+function parseRunArgs(args: string): TeamToolParamsValue {
+	const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
+	const params: TeamToolParamsValue = { action: "run" };
+	const goalParts: string[] = [];
+	for (const token of tokens) {
+		if (token === "--async") params.async = true;
+		else if (token === "--worktree") params.workspaceMode = "worktree";
+		else if (token.startsWith("--team=")) params.team = token.slice("--team=".length);
+		else if (token.startsWith("--workflow=")) params.workflow = token.slice("--workflow=".length);
+		else if (token.startsWith("--agent=")) params.agent = token.slice("--agent=".length);
+		else if (token.startsWith("--role=")) params.role = token.slice("--role=".length);
+		else if (!params.team && goalParts.length === 0 && !token.startsWith("--")) params.team = token;
+		else goalParts.push(token);
+	}
+	params.goal = goalParts.join(" ").trim() || undefined;
+	return params;
+}
+
+function commandText(result: { content?: Array<{ type: string; text?: string }> }): string {
+	return result.content?.map((item) => item.text ?? "").join("\n") ?? "";
+}
+
+async function notifyCommandResult(ctx: ExtensionCommandContext, text: string): Promise<void> {
+	ctx.ui.notify(text.length > 800 ? `${text.slice(0, 797)}...` : text, "info");
+}
+
+function parseScalar(raw: string): unknown {
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (/^-?\d+$/.test(raw)) return Number(raw);
+	if (raw.includes(",")) return raw.split(",").map((entry) => entry.trim()).filter(Boolean);
+	return raw;
+}
+
+function pushUnset(config: Record<string, unknown>, key: string): void {
+	const current = Array.isArray(config.unset) ? config.unset : [];
+	current.push(key);
+	config.unset = current;
+}
+
+function setNestedConfig(config: Record<string, unknown>, key: string, value: unknown): void {
+	const parts = key.split(".").filter(Boolean);
+	if (parts.length === 0) return;
+	let target = config;
+	for (const part of parts.slice(0, -1)) {
+		const current = target[part];
+		if (!current || typeof current !== "object" || Array.isArray(current)) target[part] = {};
+		target = target[part] as Record<string, unknown>;
+	}
+	target[parts[parts.length - 1]!] = value;
+}
+
+export function registerPiTeams(pi: ExtensionAPI): void {
+	const notifierState: AsyncNotifierState = { seenFinishedRunIds: new Set() };
+	registerAutonomousPolicy(pi);
+
+	pi.on("session_start", (_event, ctx) => {
+		notifyActiveRuns(ctx);
+		const loadedConfig = loadConfig(ctx.cwd);
+		startAsyncRunNotifier(ctx, notifierState, loadedConfig.config.notifierIntervalMs ?? 5000);
+	});
+	pi.on("session_shutdown", () => {
+		stopAsyncRunNotifier(notifierState);
+	});
+
+	const tool: ToolDefinition = {
+		name: "team",
+		label: "Team",
+		description: "Coordinate Pi teams. Use proactively for complex multi-file work, planning, implementation, tests, reviews, security audits, research, async/background runs, and worktree-isolated execution. Use action='recommend' when unsure which team/workflow to choose. Destructive actions require explicit user confirmation.",
+		promptSnippet: "Use the team tool proactively for coordinated multi-agent work. If unsure, call { action: 'recommend', goal } first, then run or plan with the suggested team/workflow.",
+		parameters: TeamToolParams as never,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return await handleTeamTool(params as TeamToolParamsValue, ctx);
+		},
+	};
+
+	pi.registerTool(tool);
+
+	pi.registerCommand("teams", {
+		description: "List pi-crew teams, workflows, and agents",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool({ action: "list" }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-run", {
+		description: "Manually start a pi-crew run (agent may also use the team tool autonomously)",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool(parseRunArgs(args), ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-status", {
+		description: "Show pi-crew run status",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "status", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-resume", {
+		description: "Resume a pi-crew run by re-queueing failed/cancelled/skipped/running tasks",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "resume", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-summary", {
+		description: "Show pi-crew run summary",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "summary", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-events", {
+		description: "Show full pi-crew event log for a run",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "events", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-artifacts", {
+		description: "List pi-crew artifacts for a run",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "artifacts", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-worktrees", {
+		description: "List pi-crew worktrees for a run",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "worktrees", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-api", {
+		description: "Run safe pi-crew API interop operations: <runId> <operation> [key=value]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.find((token) => !token.includes("=") && !token.startsWith("--"));
+			const operation = tokens.find((token) => token !== runId && !token.includes("=") && !token.startsWith("--")) ?? "read-manifest";
+			const config: Record<string, unknown> = { operation };
+			for (const token of tokens.filter((item) => item.includes("="))) {
+				const [key, ...rest] = token.split("=");
+				if (key) config[key] = rest.join("=");
+			}
+			const result = await handleTeamTool({ action: "api", runId, config }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-imports", {
+		description: "List imported pi-crew run bundles",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool({ action: "imports" }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-import", {
+		description: "Import a pi-crew run-export.json bundle into local imports",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const pathArg = tokens.find((token) => !token.startsWith("--"));
+			const scope = tokens.includes("--user") ? "user" : "project";
+			const result = await handleTeamTool({ action: "import", config: { path: pathArg, scope } }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-export", {
+		description: "Export a pi-crew run bundle to artifacts/export",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "export", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-prune", {
+		description: "Prune old finished pi-crew runs, keeping the newest N",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const keepToken = tokens.find((token) => token.startsWith("--keep="));
+			const keep = keepToken ? Number.parseInt(keepToken.slice("--keep=".length), 10) : undefined;
+			const confirm = tokens.includes("--confirm");
+			const result = await handleTeamTool({ action: "prune", keep, confirm }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-forget", {
+		description: "Forget a pi-crew run by deleting its state and artifacts",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.find((token) => !token.startsWith("--"));
+			const force = tokens.includes("--force");
+			const confirm = tokens.includes("--confirm");
+			const result = await handleTeamTool({ action: "forget", runId, force, confirm }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-cleanup", {
+		description: "Clean up pi-crew worktrees for a run",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.find((token) => !token.startsWith("--"));
+			const force = tokens.includes("--force");
+			const result = await handleTeamTool({ action: "cleanup", runId, force }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-manager", {
+		description: "Open a simple pi-crew interactive manager",
+		handler: handleTeamManagerCommand,
+	});
+
+	pi.registerCommand("team-dashboard", {
+		description: "Open a pi-crew run dashboard overlay",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			for (;;) {
+				const runs = listRuns(ctx.cwd).slice(0, 50);
+				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, _theme, _keybindings, done) => new RunDashboard(runs, done), {
+					overlay: true,
+					overlayOptions: { width: "90%", maxHeight: "80%", anchor: "center" },
+				});
+				if (!selection) return;
+				if (selection.action === "reload") continue;
+				const result = selection.action === "api"
+					? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, ctx)
+					: await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
+				await notifyCommandResult(ctx, commandText(result));
+				return;
+			}
+		},
+	});
+
+	pi.registerCommand("team-init", {
+		description: "Initialize project-local pi-crew directories and gitignore entries",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const result = await handleTeamTool({ action: "init", config: { copyBuiltins: tokens.includes("--copy-builtins"), overwrite: tokens.includes("--overwrite") } }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-autonomy", {
+		description: "Show or toggle pi-crew autonomous delegation policy: status|on|off",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const mode = tokens[0]?.toLowerCase();
+			const config = mode === "on" ? { profile: "suggested", enabled: true, injectPolicy: true }
+				: mode === "off" ? { profile: "manual", enabled: false }
+				: mode === "manual" || mode === "suggested" || mode === "assisted" || mode === "aggressive" ? { profile: mode, enabled: mode !== "manual", injectPolicy: mode !== "manual" }
+				: {
+					preferAsyncForLongTasks: tokens.includes("--prefer-async") ? true : undefined,
+					allowWorktreeSuggestion: tokens.includes("--no-worktree-suggest") ? false : undefined,
+				};
+			const result = await handleTeamTool({ action: "autonomy", config }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-config", {
+		description: "Show or update pi-crew config. Use key=value [--project] to update.",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			if (tokens.length === 0) {
+				const result = await handleTeamTool({ action: "config" }, ctx);
+				await notifyCommandResult(ctx, commandText(result));
+				return;
+			}
+			const config: Record<string, unknown> = { scope: tokens.includes("--project") ? "project" : "user" };
+			for (const token of tokens) {
+				if (token.startsWith("--unset=")) {
+					pushUnset(config, token.slice("--unset=".length));
+					continue;
+				}
+				if (!token.includes("=")) continue;
+				const [key, ...rest] = token.split("=");
+				if (!key) continue;
+				const raw = rest.join("=");
+				if (raw === "unset" || raw === "null") pushUnset(config, key);
+				else setNestedConfig(config, key, parseScalar(raw));
+			}
+			const result = await handleTeamTool({ action: "config", config }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-validate", {
+		description: "Validate pi-crew agents, teams, and workflows",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool({ action: "validate" }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-help", {
+		description: "Show pi-crew command help",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			await notifyCommandResult(ctx, piTeamsHelp());
+		},
+	});
+
+	pi.registerCommand("team-cancel", {
+		description: "Cancel a pi-crew run",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			const result = await handleTeamTool({ action: "cancel", runId }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-doctor", {
+		description: "Check pi-crew installation and discovery readiness",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const result = await handleTeamTool({ action: "doctor" }, ctx);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+}

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

@@ -0,0 +1,85 @@
+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;
+	}
+	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;
+}
+
+function validateManifest(value: unknown, errors: string[]): value is TeamRunManifest {
+	if (!isRecord(value)) {
+		errors.push("manifest must be an object.");
+		return false;
+	}
+	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 true;
+}
+
+function validateTask(value: unknown, index: number, errors: string[]): value is TeamTaskState {
+	if (!isRecord(value)) {
+		errors.push(`tasks[${index}] must be an object.`);
+		return false;
+	}
+	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;
+}
+
+function validateEvent(value: unknown, index: number, errors: string[]): value is TeamEvent {
+	if (!isRecord(value)) {
+		errors.push(`events[${index}] must be an object.`);
+		return false;
+	}
+	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;
+}
+
+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-export.ts

@@ -0,0 +1,59 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import { readEvents, type TeamEvent } from "../state/event-log.ts";
+
+export interface ExportedRunBundle {
+	schemaVersion: 1;
+	exportedAt: string;
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	events: TeamEvent[];
+	artifactPaths: string[];
+}
+
+export function exportRunBundle(manifest: TeamRunManifest, tasks: TeamTaskState[]): { jsonPath: string; markdownPath: string } {
+	const events = readEvents(manifest.eventsPath);
+	const bundle: ExportedRunBundle = {
+		schemaVersion: 1,
+		exportedAt: new Date().toISOString(),
+		manifest,
+		tasks,
+		events,
+		artifactPaths: manifest.artifacts.map((artifact) => artifact.path),
+	};
+	const json = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "export/run-export.json",
+		producer: "run-export",
+		content: `${JSON.stringify(bundle, null, 2)}\n`,
+	});
+	const markdown = writeArtifact(manifest.artifactsRoot, {
+		kind: "summary",
+		relativePath: "export/run-export.md",
+		producer: "run-export",
+		content: [
+			`# pi-crew export ${manifest.runId}`,
+			"",
+			`Exported: ${bundle.exportedAt}`,
+			`Status: ${manifest.status}`,
+			`Team: ${manifest.team}`,
+			`Workflow: ${manifest.workflow ?? "(none)"}`,
+			`Goal: ${manifest.goal}`,
+			"",
+			"## Tasks",
+			...tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
+			"",
+			"## Artifacts",
+			...(manifest.artifacts.length ? manifest.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path}`) : ["- (none)"]),
+			"",
+			"## Recent Events",
+			...(events.slice(-20).map((event) => `- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`)),
+			"",
+		].join("\n"),
+	});
+	// Ensure artifact dirs are materialized before returning paths on filesystems with delayed metadata.
+	fs.statSync(path.dirname(json.path));
+	return { jsonPath: json.path, markdownPath: markdown.path };
+}

package/src/extension/run-import.ts

@@ -0,0 +1,46 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { assertRunBundle } from "./run-bundle-schema.ts";
+import { projectPiRoot, userPiRoot } from "../utils/paths.ts";
+
+export interface ImportedRunBundleInfo {
+	runId: string;
+	importedAt: string;
+	bundlePath: string;
+	summaryPath: string;
+}
+
+function importRoot(cwd: string, scope: "project" | "user"): string {
+	return scope === "project"
+		? path.join(projectPiRoot(cwd), "teams", "imports")
+		: path.join(userPiRoot(), "extensions", "pi-crew", "imports");
+}
+
+export function importRunBundle(cwd: string, bundlePath: string, scope: "project" | "user" = "project"): ImportedRunBundleInfo {
+	const resolvedPath = path.isAbsolute(bundlePath) ? bundlePath : path.resolve(cwd, bundlePath);
+	const raw = JSON.parse(fs.readFileSync(resolvedPath, "utf-8")) as unknown;
+	assertRunBundle(raw);
+	const runId = raw.manifest.runId;
+	const importedAt = new Date().toISOString();
+	const root = path.join(importRoot(cwd, scope), runId);
+	fs.mkdirSync(root, { recursive: true });
+	const targetJson = path.join(root, "run-export.json");
+	const targetSummary = path.join(root, "README.md");
+	fs.writeFileSync(targetJson, `${JSON.stringify({ ...raw, importedAt, importedFrom: resolvedPath }, null, 2)}\n`, "utf-8");
+	fs.writeFileSync(targetSummary, [
+		`# Imported pi-crew run ${runId}`,
+		"",
+		`Imported: ${importedAt}`,
+		`Source: ${resolvedPath}`,
+		`Original export: ${raw.exportedAt}`,
+		`Status: ${raw.manifest.status}`,
+		`Team: ${raw.manifest.team}`,
+		`Workflow: ${raw.manifest.workflow ?? "(none)"}`,
+		`Goal: ${raw.manifest.goal}`,
+		"",
+		"## Tasks",
+		...raw.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
+		"",
+	].join("\n"), "utf-8");
+	return { runId, importedAt, bundlePath: targetJson, summaryPath: targetSummary };
+}

package/src/extension/run-index.ts

@@ -0,0 +1,28 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeamRunManifest } from "../state/types.ts";
+import { projectPiRoot, userPiRoot } from "../utils/paths.ts";
+
+function readManifest(filePath: string): TeamRunManifest | undefined {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as TeamRunManifest;
+	} catch {
+		return undefined;
+	}
+}
+
+function collectRuns(root: string): TeamRunManifest[] {
+	const runsRoot = path.join(root, "state", "runs");
+	if (!fs.existsSync(runsRoot)) return [];
+	return fs.readdirSync(runsRoot)
+		.map((entry) => readManifest(path.join(runsRoot, entry, "manifest.json")))
+		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
+}
+
+export function listRuns(cwd: string): TeamRunManifest[] {
+	const projectRuns = collectRuns(path.join(projectPiRoot(cwd), "teams"));
+	const userRuns = collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs"));
+	const byId = new Map<string, TeamRunManifest>();
+	for (const run of [...userRuns, ...projectRuns]) byId.set(run.runId, run);
+	return [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}

package/src/extension/run-maintenance.ts

@@ -0,0 +1,24 @@
+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(isFinished).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 };
+}

package/src/extension/session-summary.ts

@@ -0,0 +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");
+}