pi-crew 0.6.3 → 0.7.1

package/src/extension/team-tool/handle-settings.ts

@@ -4,6 +4,11 @@ import { configPatchFromConfig } from "../team-tool/config-patch.ts";
 import { result } from "../team-tool/context.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { suggestConfigKey } from "../../config/suggestions.ts";
+import {
+	formatThemesListing,
+	discoverPiThemes,
+	setPiTheme,
+} from "../../ui/theme-discovery.ts";
 
 // ---------------------------------------------------------------------------
 // Effective defaults — values used when config key is not set
@@ -244,6 +249,8 @@ const USAGE = [
 	"  json                  Show full effective config as JSON",
 	"  schema                Show all known config keys (schema reference)",
 	"  paths                 Show config file paths (user + project)",
+	"  themes                Browse theme gallery (Pi UI themes)",
+	"  theme <name>          Switch the Pi UI theme (applies live, no restart)",
 	"  get <key>             Get a specific config value",
 	"  set <key> <value>     Set a config value",
 	"  unset <key>           Remove a config value",
@@ -319,6 +326,56 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 		return result(lines.join("\n"), { ...OK, path: loaded.path } as never);
 	}
 
+	// team-settings themes — browse the theme gallery
+	if (args === "themes" || args === "theme-gallery") {
+		return result(formatThemesListing(), { ...OK } as never);
+	}
+
+	// team-settings theme <name> — switch the Pi UI theme
+	if (args === "theme" || args.startsWith("theme ")) {
+		const name = args === "theme" ? "" : args.slice(6).trim();
+		if (!name) {
+			const available = discoverPiThemes().map((t) => t.name).join(", ");
+			return result(
+				`Usage: team-settings theme <name>\n\nAvailable Pi themes: ${available}\n\nBrowse all: team-settings themes`,
+				{ ...ERR },
+				true,
+			);
+		}
+		const available = discoverPiThemes();
+		const exists = available.some((t) => t.name === name);
+		if (!exists) {
+			const hint = available.map((t) => t.name).join(", ");
+			return result(
+				`Unknown Pi theme: ${name}\n\nAvailable: ${hint}\n\nCustom themes live in ~/.pi/agent/themes/<name>.json`,
+				{ ...ERR },
+				true,
+			);
+		}
+		try {
+			const savedTo = setPiTheme(name);
+			return result(
+				[
+					`✓ Pi theme set to '${name}'`,
+					`  Written to: ${savedTo}`,
+					`  Applied live — no restart needed.`,
+				].join("\n"),
+				{ ...OK, theme: name } as never,
+			);
+		} catch (error) {
+			return result(error instanceof Error ? error.message : String(error), { ...ERR }, true);
+		}
+	}
+
+	// team-settings shiki <name> — removed (Shiki highlighting dropped)
+	if (args === "shiki" || args === "shiki-theme" || args.startsWith("shiki ") || args.startsWith("shiki-theme ")) {
+		return result(
+			`Shiki syntax highlighting has been removed from pi-crew.\nUse 'team-settings theme <name>' to switch the Pi UI theme, which drives code-block colors.`,
+			{ ...ERR },
+			true,
+		);
+	}
+
 	// team-settings scope [user|project]
 	if (args === "scope" || args.startsWith("scope ")) {
 		const scopeArg = args === "scope" ? "" : args.slice(6).trim();

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

@@ -1,7 +1,7 @@
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { readEvents } from "../../state/event-log.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
-import { aggregateUsage, formatUsage } from "../../state/usage.ts";
+import { aggregateUsage, formatUsage, formatCostReport } from "../../state/usage.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { locateRunCwd } from "../team-tool.ts";
 import { result, type TeamContext } from "./context.ts";
@@ -41,6 +41,9 @@ export function handleSummary(params: TeamToolParamsValue, ctx: TeamContext): Pi
 		`Workflow: ${loaded.manifest.workflow ?? "(none)"}`,
 		`Goal: ${loaded.manifest.goal}`,
 		`Usage: ${formatUsage(usage)}`,
+		"",
+		formatCostReport(loaded.tasks),
+		"",
 		"Tasks:",
 		...loaded.tasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
 	];

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

@@ -4,6 +4,7 @@ import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
+import { composeSingleAgentPrompt } from "../../runtime/single-agent-compose.ts";
 
 export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const teamName = params.team ?? "default";
@@ -14,6 +15,12 @@ export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 	if (!workflow) return result(`Workflow '${workflowName}' not found.`, { action: "plan", status: "error" }, true);
 	const errors = validateWorkflowForTeam(workflow, team);
 	if (errors.length > 0) return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...errors.map((error) => `- ${error}`)].join("\n"), { action: "plan", status: "error" }, true);
-	const lines = [`Team plan: ${team.name}`, `Workflow: ${workflow.name}`, `Goal: ${params.goal ?? params.task ?? "(not provided)"}`, "", "Steps:", ...workflow.steps.map((step, index) => `${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`)];
+	const goal = params.goal ?? params.task ?? "(not provided)";
+	// ROADMAP T2.2: single-agent composition mode (cliff hedge).
+	if (params.singleAgent) {
+		const composed = composeSingleAgentPrompt(workflow, goal);
+		return result([`Single-agent plan for ${team.name} / ${workflow.name} (${composed.stepCount} phases composed into one sequential prompt):`, "", composed.prompt, "", "This prompt can be handed to a single agent to execute the entire workflow sequentially — pi-crew's cliff-resilient mode (survives single-agent domination)."].join("\n"), { action: "plan", status: "ok" });
+	}
+	const lines = [`Team plan: ${team.name}`, `Workflow: ${workflow.name}`, `Goal: ${goal}`, "", "Steps:", ...workflow.steps.map((step, index) => `${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`)];
 	return result(lines.join("\n"), { action: "plan", status: "ok" });
 }

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

@@ -254,6 +254,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		const asyncManifest = { ...effectiveManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
 		void appendEventAsync(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
+		ctx.onRunStarted?.(effectiveManifest.runId);
 		scheduleBackgroundEarlyExitGuard(resolvedCtx.cwd, effectiveManifest.runId, spawned.pid, spawned.logPath);
 		// Wait for the async run to complete and return actual results.
 		try {
@@ -341,7 +342,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			}
 
 			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot, metrics }, runFailed);
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -474,7 +475,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			}
 
 			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot, metrics }, runFailed);
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -514,5 +515,5 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				? "Experimental live-session worker execution was enabled."
 				: "Safe scaffold mode: child Pi workers were not launched because runtime.mode=scaffold or executeWorkers=false was configured.",
 	].join("\n");
-	return result(text, { action: "run", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
+	return result(text, { action: "run", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot, metrics: collectRunMetrics(resolvedCtx.cwd, executed.manifest.runId) }, executed.manifest.status === "failed");
 }

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

@@ -10,6 +10,8 @@ export interface TeamToolDetails {
 	resumedIds?: string[];
 	retriedTaskIds?: string[];
 	mailboxIds?: string[];
+	/** Run metrics for compact display in TUI tool result rendering. */
+	metrics?: { taskCount?: number; completedCount?: number; totalTokens?: number; totalCost?: number; durationMs?: number; consistencyScore?: number };
 	/** Structured data for programmatic consumption (e.g. TUI widgets). */
 	data?: Record<string, unknown>;
 }

package/src/runtime/intercom-bridge.ts

@@ -51,6 +51,10 @@ const MAX_QUEUE_SIZE = 100;
 export class IntercomQueue {
 	private pending = new Map<string, PendingMessage>();
 	private queue: IntercomMessage[] = [];
+	/** Monotonic sequence counter — guarantees unique IDs even when many
+	 * messages enqueue within the same millisecond (avoids Date.now()
+	 * collision + weak Math.random birthday-paradox flakes under load). */
+	private seq = 0;
 
 	/**
 	 * Enqueue a message and return a promise that resolves when the
@@ -63,7 +67,7 @@ export class IntercomQueue {
 			if (firstKey) this.evict(firstKey, "queue_full");
 		}
 
-		const id = `icm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+		const id = `icm-${Date.now().toString(36)}-${(this.seq++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 
 		return new Promise<IntercomResponse>((resolve) => {
 			const entry: PendingMessage = { message, id, resolve };