pi-crew 0.9.68 → 0.10.2

package/src/extension/register.ts

@@ -21,6 +21,7 @@ import { loadConfig } from "../config/config.ts";
 import { startRuntimeWarmup } from "../runtime/model/runtime-warmup.ts";
 import { primePeerDep } from "../runtime/peer-dep.ts";
 import { deployBundledThemes } from "../ui/deploy-bundled-themes.ts";
+import { installChildProcessAbortShield } from "../utils/child-process-shield.ts";
 import { resetTimings, time } from "../utils/timings.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
 import { registerContextStatusInjection } from "./context-status-injection.ts";
@@ -52,6 +53,13 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	resetTimings();
 	time("register:start");
 
+	// MUST run before any team run can start: guarantees every signal-spawned
+	// child in the process has an 'error' listener so Node's abort-after-exit
+	// AbortError dispatches instead of being rethrown on the next tick as an
+	// uncaughtException that kills pi (see child-process-shield.ts for the
+	// full crash chain — /crew-view mid-run crash).
+	installChildProcessAbortShield();
+
 	startRuntimeWarmup();
 	primePeerDep().catch(() => undefined);
 	deployBundledThemes();

package/src/extension/registration/command-registration.ts

@@ -31,6 +31,7 @@ export function registerPiCommands(pi: ExtensionAPI, ctx: RegistrationContext):
 		getManifestCache: ctx.getManifestCache,
 		getRunSnapshotCache: ctx.getRunSnapshotCache,
 		getMetricRegistry: () => ctx.observabilityState.metricRegistry,
+		getCurrentSessionFile: () => ctx.currentCtx?.sessionManager?.getSessionFile?.(),
 		uiState: ctx.uiState,
 		dismissNotifications: () => {
 			ctx.widgetState.notificationCount = 0;

package/src/extension/registration/commands/dashboard.ts

@@ -0,0 +1,158 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../../../config/config.ts";
+import { DEFAULT_UI } from "../../../config/defaults.ts";
+import { readCrewAgents } from "../../../runtime/crew-agent-records.ts";
+import { loadRunManifestById } from "../../../state/stores/state-store.ts";
+import { requestRenderTarget } from "../../../ui/pi-ui-compat.ts";
+import { suggestRunIds, suggestTaskIds } from "../../command-completions.ts";
+import { commandText, notifyCommandResult } from "../command-utils.ts";
+import { openTranscriptViewer, selectAgentTask } from "../viewers.ts";
+import type { RegisterTeamCommandsDeps } from "./shared.ts";
+import { handleTeamTool, openTeamDashboard, teamCommandContext, ui } from "./shared.ts";
+
+export function registerDashboardCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
+	pi.registerCommand("team-result", {
+		description: "Open a pi-crew agent result viewer: <runId> [taskId]",
+		getArgumentCompletions: async (argumentPrefix: string) => {
+			const parts = argumentPrefix.trim().split(/\s+/);
+			return parts.length <= 1 ? suggestRunIds(parts[0] ?? "") : suggestTaskIds(parts[0] ?? "", parts[1] ?? "");
+		},
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const [runId, rawTaskId] = args.trim().split(/\s+/).filter(Boolean);
+			const selected = await selectAgentTask(ctx, runId, rawTaskId);
+			const loaded = selected ? loadRunManifestById(ctx.cwd, selected.runId) : undefined; // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+			if (ctx.hasUI && loaded) {
+				const agent =
+					readCrewAgents(loaded.manifest).find((item) => item.taskId === selected?.taskId || item.id === selected?.taskId) ??
+					readCrewAgents(loaded.manifest)[0];
+				const resultText = agent?.resultArtifactPath
+					? commandText(
+							await handleTeamTool(
+								{
+									action: "api",
+									runId: selected?.runId ?? "",
+									config: {
+										operation: "read-agent-output",
+										agentId: agent.taskId,
+										maxBytes: 64_000,
+									},
+								},
+								teamCommandContext(ctx),
+							),
+						)
+					: "(no result)";
+				const { DurableTextViewer } = await ui();
+				await ctx.ui.custom<undefined>(
+					(_tui, theme, _keybindings, done) =>
+						new DurableTextViewer(
+							"pi-crew result",
+							`${selected?.runId ?? ""}:${agent?.taskId ?? "unknown"}`,
+							resultText.split(/\r?\n/),
+							theme,
+							done,
+						),
+					{
+						overlay: true,
+						overlayOptions: {
+							width: "90%",
+							maxHeight: "85%",
+							anchor: "center",
+						},
+					},
+				);
+				return;
+			}
+			const result = await handleTeamTool(
+				{
+					action: "api",
+					runId,
+					config: {
+						operation: "read-agent-output",
+						agentId: rawTaskId,
+						maxBytes: 64_000,
+					},
+				},
+				teamCommandContext(ctx),
+			);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-transcript", {
+		description: "Open a pi-crew transcript viewer: <runId> [taskId]",
+		getArgumentCompletions: async (argumentPrefix: string) => {
+			const parts = argumentPrefix.trim().split(/\s+/);
+			return parts.length <= 1 ? suggestRunIds(parts[0] ?? "") : suggestTaskIds(parts[0] ?? "", parts[1] ?? "");
+		},
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const [runId, taskId] = args.trim().split(/\s+/).filter(Boolean);
+			if (await openTranscriptViewer(ctx, runId, taskId)) return;
+			const result = await handleTeamTool(
+				{
+					action: "api",
+					runId,
+					config: {
+						operation: "read-agent-transcript",
+						agentId: taskId,
+					},
+				},
+				teamCommandContext(ctx),
+			);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-dashboard", {
+		description: "Open a pi-crew run dashboard overlay",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			await openTeamDashboard(ctx);
+		},
+	});
+
+	pi.registerCommand("team-mascot", {
+		description: "Show an animated mascot splash",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			if (!ctx.hasUI) return;
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const uiConfig = loadConfig(ctx.cwd).config.ui;
+			const styleArg = tokens.find((t) => t === "cat" || t === "armin");
+			const effectArg = tokens.find((t) =>
+				["random", "none", "typewriter", "scanline", "rain", "fade", "crt", "glitch", "dissolve"].includes(t),
+			);
+			const style = (styleArg as "cat" | "armin" | undefined) ?? uiConfig?.mascotStyle ?? DEFAULT_UI.mascotStyle;
+			const effect =
+				(effectArg as
+					| "random"
+					| "none"
+					| "typewriter"
+					| "scanline"
+					| "rain"
+					| "fade"
+					| "crt"
+					| "glitch"
+					| "dissolve"
+					| undefined) ??
+				uiConfig?.mascotEffect ??
+				DEFAULT_UI.mascotEffect;
+			const { AnimatedMascot } = await ui();
+			await ctx.ui.custom<undefined>(
+				(tui, theme, _keybindings, done) =>
+					new AnimatedMascot(theme, () => done(undefined), {
+						frameIntervalMs: style === "armin" ? 100 : 180,
+						autoCloseMs: 7000,
+						requestRender: () => requestRenderTarget(tui),
+						style,
+						effect,
+					}),
+				{
+					overlay: true,
+					overlayOptions: {
+						width: style === "armin" ? 48 : 62,
+						maxHeight: "85%",
+						anchor: "center",
+					},
+				},
+			);
+		},
+	});
+}

package/src/extension/registration/commands/index.ts

@@ -0,0 +1,35 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { printTimings, time } from "../../../utils/timings.ts";
+import { registerDashboardCommands } from "./dashboard.ts";
+import { registerManageCommands } from "./manage.ts";
+import { registerRunCommands } from "./run.ts";
+import type { RegisterTeamCommandsDeps } from "./shared.ts";
+import { setTeamCommandsDeps } from "./shared.ts";
+import { registerStatusCommands } from "./status.ts";
+
+/**
+ * Register every pi-crew slash command on the ExtensionAPI.
+ *
+ * Phase 2.1 split: the former monolith `src/extension/registration/commands.ts`
+ * is now a re-export shim over this directory. Registration wiring lives here;
+ * the command handlers live in run.ts / status.ts / manage.ts / dashboard.ts,
+ * and cross-category module state + helpers (handleTeamTool, the UI cache,
+ * the overlays) live in shared.ts.
+ */
+export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
+	setTeamCommandsDeps(deps);
+	registerStatusCommands(pi, deps);
+	registerRunCommands(pi, deps);
+	registerManageCommands(pi, deps);
+	registerDashboardCommands(pi, deps);
+	time("register.commands");
+	printTimings();
+}
+
+export type { RegisterTeamCommandsDeps } from "./shared.ts";
+// Re-export the shared seam + overlay entry points (and the deps type) so the
+// original `./commands.ts` path keeps resolving every named export consumers
+// rely on: __test__setHandleTeamTool (commands-handler.test.ts),
+// openTeamSettingsOverlay + openTeamDashboard (crew-shortcuts.ts LAZY dynamic
+// imports), RegisterTeamCommandsDeps (type).
+export { __test__setHandleTeamTool, openTeamDashboard, openTeamSettingsOverlay } from "./shared.ts";

package/src/extension/registration/commands/manage.ts

@@ -0,0 +1,303 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getBuiltinTemplates, instantiateTemplate, listTemplates } from "../../../skills/skill-templates.ts";
+import { atomicWriteFile } from "../../../state/atomic-write.ts";
+import { suggestRunIds } from "../../command-completions.ts";
+import { handleTeamManagerCommand } from "../../team-manager-command.ts";
+import { commandText, notifyCommandResult, parseScalar, pushUnset, setNestedConfig } from "../command-utils.ts";
+import type { RegisterTeamCommandsDeps } from "./shared.ts";
+import { handleTeamTool, openTeamSettingsOverlay, teamCommandContext } from "./shared.ts";
+
+export function registerManageCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
+	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 result = await handleTeamTool(
+				{
+					action: "prune",
+					keep,
+					confirm: tokens.includes("--confirm"),
+				},
+				teamCommandContext(ctx),
+			);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-forget", {
+		description: "Forget a pi-crew run by deleting its state and artifacts",
+		getArgumentCompletions: (argumentPrefix: string) => suggestRunIds(argumentPrefix),
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const runId = tokens.find((token) => !token.startsWith("--"));
+			const result = await handleTeamTool(
+				{
+					action: "forget",
+					runId,
+					force: tokens.includes("--force"),
+					confirm: tokens.includes("--confirm"),
+				},
+				teamCommandContext(ctx),
+			);
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("team-settings", {
+		description: "View or update pi-crew settings: interactive UI or [list|get <key>|set <key> <value>|unset <key>|path|scope]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			if (ctx.hasUI && !args.trim()) {
+				await openTeamSettingsOverlay(ctx);
+				return;
+			}
+			const result = await handleTeamTool({ action: "settings", config: { args: args.trim() } }, teamCommandContext(ctx));
+			await notifyCommandResult(ctx, commandText(result));
+			// Live-switch hook: when the text subcommand 'theme <name>' succeeds,
+			// also apply the theme live via ctx.ui.setTheme() (no restart). The
+			// handler above only writes to settings.json.
+			const trimmed = args.trim();
+			if (trimmed.startsWith("theme ")) {
+				const themeName = trimmed.slice(6).trim();
+				if (themeName && typeof ctx.ui.setTheme === "function") {
+					const res = ctx.ui.setTheme(themeName);
+					if (res.success) ctx.ui.notify(`Theme: ${themeName} (applied live)`, "info");
+					else ctx.ui.notify(`Saved but live-switch failed: ${res.error ?? "unknown"}. Restart Pi.`, "warning");
+				}
+			}
+		},
+	});
+
+	pi.registerCommand("team-manager", {
+		description: "Open the pi-crew interactive menu (list/run/status/cleanup/manage resources/doctor)",
+		handler: handleTeamManagerCommand,
+	});
+	// Backward-compat alias: this command was originally registered as "team-cleanup"
+	// (the interactive menu predates the runId-targeted cleanup action). Keep both so
+
+	pi.registerCommand("team-cleanup-menu", {
+		description: "Alias for /team-manager (pi-crew interactive menu)",
+		handler: handleTeamManagerCommand,
+	});
+
+	pi.registerCommand("team-init", {
+		description: "Initialize pi-crew layout and global config. Use --project-config to write .pi/pi-crew.json.",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const configScope =
+				tokens.includes("--project-config") || tokens.includes("--project")
+					? "project"
+					: tokens.includes("--no-config")
+						? "none"
+						: "global";
+			const result = await handleTeamTool(
+				{
+					action: "init",
+					config: {
+						copyBuiltins: tokens.includes("--copy-builtins"),
+						overwrite: tokens.includes("--overwrite"),
+						configScope,
+					},
+				},
+				teamCommandContext(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 }, teamCommandContext(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" }, teamCommandContext(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 }, teamCommandContext(ctx));
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
+	pi.registerCommand("skill-list", {
+		description: "List available builtin skill templates. Use --json for machine-readable output.",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const asJson = args.trim().split(/\s+/).includes("--json");
+			const templates = listTemplates();
+			if (asJson) {
+				await notifyCommandResult(ctx, JSON.stringify(templates, null, 2));
+			} else {
+				const lines = ["Available builtin skill templates:", ""];
+				for (const t of templates) {
+					lines.push(`  ${t.id.padEnd(20)} ${t.description}`);
+					lines.push(
+						`    Variables: ${t.variables.map((v) => (v.required ? "[required] " : "[optional] ") + v.name).join(", ")}`,
+					);
+				}
+				lines.push("");
+				lines.push("Create a skill: /skill-create <template-id> --var key=value [--var ...]");
+				await notifyCommandResult(ctx, lines.join("\n"));
+			}
+		},
+	});
+
+	pi.registerCommand("skill-create", {
+		description: "Create a skill from a builtin template: <template-id> [--var key=value...] [--project]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			// LAZY: load withSessionId only when needed for skill-create command
+			const { withSessionId } = await import("../../team-tool/context.ts");
+			const sessionId = withSessionId(ctx);
+			const cwd =
+				(
+					ctx as unknown as {
+						workspaceFolder?: { uri: { fsPath: string } };
+					}
+				).workspaceFolder?.uri?.fsPath ?? process.cwd();
+			const tokens = args.trim().split(/\s+/).filter(Boolean);
+			const useProject = tokens.includes("--project");
+			const varEntries = tokens
+				.filter((t) => t.startsWith("--var=") || t.startsWith("--var "))
+				.map((t): [string, string] => {
+					const s = t.replace(/^--var(?:\s+|=)/, "");
+					const idx = s.indexOf("=");
+					return idx === -1 ? [s, ""] : [s.slice(0, idx), s.slice(idx + 1)];
+				});
+			const templateId = tokens.find((t) => !t.startsWith("--") && !t.includes("="));
+			if (!templateId) {
+				await notifyCommandResult(
+					ctx,
+					"Usage: /skill-create <template-id> [--var key=value...] [--project]\nRun /skill-list to see available templates.",
+				);
+				return;
+			}
+			const template = getBuiltinTemplates().find((t) => t.id === templateId);
+			if (!template) {
+				await notifyCommandResult(ctx, `Unknown template '${templateId}'. Run /skill-list to see available templates.`);
+				return;
+			}
+			const variables: Record<string, string> = {};
+			const errors: string[] = [];
+			for (const v of template.variables) {
+				const entry = varEntries.find(([k]) => k === v.name);
+				if (!entry) {
+					if (v.required) errors.push(`Missing required variable: ${v.name} (${v.description})`);
+					else if (v.defaultValue !== undefined) variables[v.name] = v.defaultValue;
+					continue;
+				}
+				const [, value] = entry;
+				if (v.options && !v.options.includes(value)) {
+					errors.push(`Invalid value '${value}' for '${v.name}'. Allowed: ${v.options.join(", ")}`);
+					continue;
+				}
+				variables[v.name] = value;
+			}
+			if (errors.length > 0) {
+				await notifyCommandResult(ctx, errors.join("\n"));
+				return;
+			}
+			let instantiated: { filename: string; content: string };
+			try {
+				instantiated = instantiateTemplate(template, variables);
+			} catch (error) {
+				await notifyCommandResult(ctx, error instanceof Error ? error.message : String(error));
+				return;
+			}
+			const skillsDir = path.resolve(
+				cwd,
+				useProject
+					? "skills"
+					: path.join(
+							path.dirname(
+								require.resolve("../../../../package.json", {
+									paths: [__dirname],
+								}),
+							),
+							"skills",
+						),
+			);
+			const skillDir = path.join(skillsDir, template.id);
+			const skillPath = path.join(skillDir, "SKILL.md");
+			try {
+				fs.mkdirSync(skillDir, { recursive: true });
+				atomicWriteFile(skillPath, instantiated.content);
+				await notifyCommandResult(
+					ctx,
+					`Created skill '${template.id}' at:\n${skillPath}\n\n${instantiated.content.slice(0, 200)}...`,
+				);
+			} catch (error) {
+				await notifyCommandResult(ctx, `Failed to write skill: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		},
+	});
+
+	pi.registerCommand("crew-brief", {
+		description: "Toggle brief tool output mode: on | off | status",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			// LAZY: defer dynamic import of ../../ui/tool-renderers/brief-mode.ts to its call site. Multi-line form breaks scripts/check-lazy-imports.mjs (which does `lines[lineNum - 2]`), so keep destructuring + await import on one line and place this LAZY marker directly above.
+			const { isBrief, setBrief, BRIEF_ENTRY_TYPE, makeBriefEntry } = await import("../../../ui/tool-renderers/brief-mode.ts");
+			const trimmed = args.trim();
+
+			if (trimmed === "on") {
+				setBrief(true);
+				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: true });
+				ctx.ui.notify("Brief mode: on — tool output will show compact summaries", "info");
+				return;
+			}
+			if (trimmed === "off") {
+				setBrief(false);
+				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: false });
+				ctx.ui.notify("Brief mode: off — full tool output restored", "info");
+				return;
+			}
+			// status (default)
+			ctx.ui.notify(`Brief mode: ${isBrief() ? "on" : "off"}`, "info");
+		},
+	});
+}