pi-crew 0.6.1 → 0.6.4

package/src/ui/live-run-sidebar.ts

@@ -109,7 +109,7 @@ export class LiveRunSidebar {
 
 	render(width: number): string[] {
 		const w = Math.max(36, width);
-		const loaded = loadRunManifestById(this.cwd, this.runId);
+		const loaded = loadRunManifestById(this.cwd, this.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		if (!loaded) {
 			return renderLines(
 				[

package/src/ui/loaders.ts

@@ -131,6 +131,10 @@ export class CountdownTimer {
 				this.emitExpire();
 			}
 		}, 1000);
+		// Defense-in-depth: never let the countdown timer keep the event loop
+		// alive. If dispose() is missed (e.g. UI unmount race), the timer must
+		// not block process exit.
+		if (typeof this.timer.unref === "function") this.timer.unref();
 	}
 
 	private emitExpire(): void {

package/src/ui/overlays/agent-picker-overlay.ts

@@ -15,7 +15,7 @@ export class AgentPickerOverlay {
 	private selected = 0;
 
 	constructor(opts: { cwd: string; runId: string; done: (selection: AgentPickerSelection | undefined) => void; theme?: unknown }) {
-		const loaded = loadRunManifestById(opts.cwd, opts.runId);
+		const loaded = loadRunManifestById(opts.cwd, opts.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		this.agents = loaded ? readCrewAgents(loaded.manifest) : [];
 		this.done = opts.done;
 		this.theme = asCrewTheme(opts.theme ?? {});

package/src/ui/overlays/mailbox-detail-overlay.ts

@@ -32,7 +32,7 @@ export class MailboxDetailOverlay {
 	}
 
 	private refresh(): void {
-		const loaded = loadRunManifestById(this.cwd, this.runId);
+		const loaded = loadRunManifestById(this.cwd, this.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		if (!loaded) return;
 		// Track task count changes to trigger re-render
 		const taskCount = loaded.tasks.length;

package/src/ui/powerbar-publisher.ts

@@ -10,7 +10,7 @@ import { listLiveAgents } from "../runtime/live-agent-manager.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
-import { notificationBadge } from "./crew-widget.ts";
+import { notificationBadge } from "./widget/widget-formatters.ts";
 import { RenderCoalescer } from "./render-coalescer.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";

package/src/ui/run-action-dispatcher.ts

@@ -81,7 +81,7 @@ export function dispatchHealthRecovery(ctx: ExtensionContext, runId: string): Pr
 
 export async function dispatchKillStaleWorkers(ctx: ExtensionContext, runId: string): Promise<RunActionResult> {
 	try {
-		const loaded = loadRunManifestById(ctx.cwd, runId);
+		const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		if (!loaded) return { ok: false, message: `Run '${runId}' not found.` };
 		const currentMs = Date.now();
 		const staleMs = 60_000;
@@ -113,7 +113,7 @@ export async function dispatchDiagnosticExport(ctx: ExtensionContext, runId: str
 
 /** @internal */
 function defaultNudgeAgentId(ctx: Pick<ExtensionContext, "cwd">, runId: string): string | undefined {
-	const loaded = loadRunManifestById(ctx.cwd, runId);
+	const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 	if (!loaded) return undefined;
 	return readCrewAgents(loaded.manifest).find((agent) => agent.status === "running" || agent.status === "queued")?.taskId;
 }

package/src/ui/run-snapshot-cache.ts

@@ -652,7 +652,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 	function build(runId: string, previous?: CacheEntry): CacheEntry {
 		let loaded: ReturnType<typeof loadRunManifestById>;
 		try {
-			loaded = loadRunManifestById(cwd, runId);
+			loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 		} catch {
 			if (previous) return previous;
 			throw new Error(`Run '${runId}' could not be parsed.`);

package/src/ui/status-colors.ts

@@ -1,6 +1,6 @@
 import type { CrewTheme, CrewThemeColor } from "./theme-adapter.ts";
 
-export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | (string & {});
+export type RunStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | "stale" | "needs_attention" | (string & {});
 
 export function colorForStatus(status: RunStatus): CrewThemeColor {
 	switch (status) {
@@ -17,6 +17,8 @@ export function colorForStatus(status: RunStatus): CrewThemeColor {
 		case "blocked":
 		case "stopped":
 			return "warning";
+		case "needs_attention":
+			return "warning";
 		case "queued":
 		default:
 			return "dim";
@@ -42,6 +44,8 @@ export function iconForStatus(status: RunStatus, options?: { runningGlyph?: stri
 			return "◦";
 		case "blocked":
 			return "⏸";
+		case "needs_attention":
+			return "⚠";
 		default:
 			return "·";
 	}

package/src/ui/theme-adapter.ts

@@ -9,9 +9,22 @@ export type CrewThemeColor =
 	| "muted"
 	| "dim"
 	| "text"
+	| "thinkingText"
+	// Tool rendering
+	| "toolTitle"
+	| "toolOutput"
 	| "toolDiffAdded"
 	| "toolDiffRemoved"
 	| "toolDiffContext"
+	// Markdown
+	| "mdHeading"
+	| "mdLink"
+	| "mdCode"
+	| "mdCodeBlock"
+	| "mdQuote"
+	| "mdHr"
+	| "mdListBullet"
+	// Syntax highlighting
 	| "syntaxKeyword"
 	| "syntaxString"
 	| "syntaxNumber"
@@ -21,15 +34,81 @@ export type CrewThemeColor =
 	| "syntaxType"
 	| "syntaxOperator"
 	| "syntaxPunctuation"
-	| "mdCodeBlock";
+	// Message display
+	| "userMessageText"
+	| "customMessageLabel"
+	// Thinking gradient (6 levels, low→high intensity)
+	| "thinkingOff"
+	| "thinkingMinimal"
+	| "thinkingLow"
+	| "thinkingMedium"
+	| "thinkingHigh"
+	| "thinkingXhigh"
+	// Special
+	| "bashMode";
 
 export type CrewThemeBg =
 	| "selectedBg"
 	| "userMessageBg"
+	| "customMessageBg"
 	| "toolPendingBg"
 	| "toolSuccessBg"
 	| "toolErrorBg";
 
+/** ANSI fallback values for theme color slots when the active theme doesn't define them. */
+export const THEME_COLOR_FALLBACKS: Record<CrewThemeColor, string> = {
+	accent: "\x1b[36m",
+	border: "\x1b[38;5;240m",
+	borderAccent: "\x1b[35m",
+	borderMuted: "\x1b[38;5;236m",
+	success: "\x1b[32m",
+	error: "\x1b[31m",
+	warning: "\x1b[33m",
+	muted: "\x1b[38;5;245m",
+	dim: "\x1b[38;5;240m",
+	text: "\x1b[39m",
+	thinkingText: "\x1b[38;5;245m",
+	toolTitle: "\x1b[36m",
+	toolOutput: "\x1b[38;5;245m",
+	toolDiffAdded: "\x1b[32m",
+	toolDiffRemoved: "\x1b[31m",
+	toolDiffContext: "\x1b[38;5;245m",
+	mdHeading: "\x1b[33m",
+	mdLink: "\x1b[35m",
+	mdCode: "\x1b[32m",
+	mdCodeBlock: "\x1b[39m",
+	mdQuote: "\x1b[38;5;245m",
+	mdHr: "\x1b[38;5;240m",
+	mdListBullet: "\x1b[36m",
+	syntaxKeyword: "\x1b[35m",
+	syntaxString: "\x1b[32m",
+	syntaxNumber: "\x1b[33m",
+	syntaxComment: "\x1b[38;5;245m",
+	syntaxFunction: "\x1b[36m",
+	syntaxVariable: "\x1b[39m",
+	syntaxType: "\x1b[35m",
+	syntaxOperator: "\x1b[35m",
+	syntaxPunctuation: "\x1b[35m",
+	userMessageText: "\x1b[39m",
+	customMessageLabel: "\x1b[35m",
+	thinkingOff: "\x1b[38;5;236m",
+	thinkingMinimal: "\x1b[38;5;245m",
+	thinkingLow: "\x1b[35m",
+	thinkingMedium: "\x1b[35m",
+	thinkingHigh: "\x1b[36m",
+	thinkingXhigh: "\x1b[35m",
+	bashMode: "\x1b[32m",
+};
+
+/** Map a thinking intensity level (0–5) to a theme color slot. */
+export function thinkingColorForLevel(level: number): CrewThemeColor {
+	const slots: CrewThemeColor[] = [
+		"thinkingOff", "thinkingMinimal", "thinkingLow",
+		"thinkingMedium", "thinkingHigh", "thinkingXhigh",
+	];
+	return slots[Math.min(Math.max(level, 0), 5)] ?? "thinkingOff";
+}
+
 export interface CrewTheme {
 	fg(color: CrewThemeColor, text: string): string;
 	bg?(color: CrewThemeBg, text: string): string;

package/src/ui/tool-progress-formatter.ts

@@ -48,12 +48,14 @@ function trimLine(value: string): string {
 
 function taskCounts(tasks: TeamTaskState[] | undefined): string | undefined {
 	if (!tasks || tasks.length === 0) return undefined;
+	const total = tasks.length;
+	const completed = tasks.filter((t) => t.status === "completed").length;
 	const buckets = new Map<string, number>();
 	for (const task of tasks) buckets.set(task.status, (buckets.get(task.status) ?? 0) + 1);
 	const summary = [...buckets.entries()]
 		.map(([status, count]) => `${status}=${count}`)
 		.join(" ");
-	return `tasks ${summary}`;
+	return `tasks ${completed}/${total} done ${summary}`;
 }
 
 /**
@@ -66,6 +68,9 @@ export function formatCompactToolProgress(input: ToolProgressInput): string {
 	const head = input.agentId ? `agent=${input.agentId}` : "agent";
 	const lines: string[] = [`${head} status=${input.status} elapsed=${elapsedSec}s`];
 
+	const counts = taskCounts(input.tasks);
+	if (counts) lines.push(`  ${counts}`);
+
 	const active = pickActiveAgent(input.agents);
 	if (active) {
 		const turns = active.progress?.turns ?? 0;
@@ -77,12 +82,11 @@ export function formatCompactToolProgress(input: ToolProgressInput): string {
 		}
 		const recent = active.progress?.recentOutput?.at(-1);
 		if (recent && recent.trim()) lines.push(`  ${trimLine(recent)}`);
-	} else if (input.runId) {
-		const counts = taskCounts(input.tasks);
-		lines.push(counts ? `  run=${input.runId} ${counts}` : `  run=${input.runId} (starting)`);
+	} else if (input.runId && !counts) {
+		lines.push(`  run=${input.runId} (starting)`);
 	} else if (input.error) {
 		lines.push(`  error: ${trimLine(input.error)}`);
-	} else {
+	} else if (!counts) {
 		lines.push("  waiting for run to start");
 	}
 	return lines.join("\n");

package/src/ui/tool-render.ts

@@ -1,4 +1,8 @@
 /**
+ * @deprecated Use tool-renderers/index.ts (teamToolRenderer/agentToolRenderer) instead.
+ * This file only exports shared utility functions (truncLine, formatTokens, formatDuration).
+ * The render functions below are kept for backward-compatible tests only.
+ *
  * Shared rendering for pi-crew's tool TUI display.
  * Ports logic from pi-subagent4 adapted for pi-crew's data model.
  * Uses @earendil-works/pi-tui Components (Container, Text, Spacer) directly.

package/src/ui/tool-renderers/brief-mode.ts

@@ -0,0 +1,207 @@
+/**
+ * Brief mode for tool result display.
+ *
+ * Inspired by @ayulab/pi-brief — shows one-line summaries instead of
+ * full output. Toggled via /crew-brief on|off, state persists across
+ * session reloads via pi.appendEntry().
+ */
+
+import type { CrewTheme } from "../theme-adapter.ts";
+import { formatTokens, formatDuration, truncLine } from "../tool-render.ts";
+import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
+
+// ── State ──────────────────────────────────────────────────────────────
+
+const BRIEF_ENTRY_TYPE = "pi-crew.brief-state";
+let briefEnabled = false;
+
+export function isBrief(): boolean {
+	return briefEnabled;
+}
+
+export function setBrief(on: boolean): void {
+	briefEnabled = on;
+}
+
+/** Entry type for persisting brief state across session reloads. */
+export interface BriefStateEntry {
+	readonly type: "custom";
+	readonly customType: typeof BRIEF_ENTRY_TYPE;
+	readonly data: { enabled: boolean };
+}
+
+export function makeBriefEntry(enabled: boolean): BriefStateEntry {
+	return { type: "custom", customType: BRIEF_ENTRY_TYPE, data: { enabled } };
+}
+
+export function restoreBriefState(entries: Iterable<unknown>): void {
+	for (const entry of entries) {
+		if (
+			typeof entry === "object" && entry !== null &&
+			"type" in entry && (entry as Record<string, unknown>).type === "custom" &&
+			"customType" in entry && (entry as Record<string, unknown>).customType === BRIEF_ENTRY_TYPE &&
+			"data" in entry
+		) {
+			const data = (entry as Record<string, unknown>).data;
+			if (typeof data === "object" && data !== null && "enabled" in data) {
+				briefEnabled = !!(data as Record<string, unknown>).enabled;
+			}
+		}
+	}
+}
+
+export { BRIEF_ENTRY_TYPE };
+
+// ── Brief renderers ────────────────────────────────────────────────────
+
+/** Brief summary for a single tool result. */
+export function briefToolResult(toolName: string, result: { content?: unknown[] }, theme: CrewTheme): string {
+	const text = extractText(result?.content);
+	switch (toolName) {
+		case "read": return briefRead(text, theme);
+		case "bash": return briefBash(text, theme);
+		case "edit": return briefEdit(text, theme);
+		case "write": return briefWrite(text, theme);
+		case "find": return briefFind(text, theme);
+		case "grep": return briefGrep(text, theme);
+		case "ls": return briefLs(text, theme);
+		case "team": return briefTeam(result, theme);
+		case "agent": return briefAgent(result, theme);
+		default: return briefDefault(text, theme);
+	}
+}
+
+function briefRead(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ empty");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} lines`);
+}
+
+function briefBash(text: string, theme: CrewTheme): string {
+	if (!text?.trim()) return theme.fg("dim", "→ done");
+	const lines = text.trim().split("\n");
+	if (lines.length === 1 && lines[0]!.length < 40) {
+		return theme.fg("muted", `→ ${lines[0]}`);
+	}
+	return theme.fg("muted", `→ ${lines.length} lines`);
+}
+
+function briefEdit(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ edited");
+	if (text.includes("Error") || text.includes("error")) {
+		return theme.fg("error", "→ failed");
+	}
+	const added = (text.match(/^\+ /gm) ?? []).length;
+	const removed = (text.match(/^- /gm) ?? []).length;
+	if (added === 0 && removed === 0) {
+		return theme.fg("success", "→ edited");
+	}
+	return theme.fg("success", "→ edited ") +
+		theme.fg("toolDiffAdded", `+${added} `) +
+		theme.fg("toolDiffRemoved", `-${removed}`);
+}
+
+function briefWrite(text: string, theme: CrewTheme): string {
+	if (text) return theme.fg("error", `→ ${text}`);
+	return theme.fg("success", "→ written");
+}
+
+function briefFind(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ none");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} files`);
+}
+
+function briefGrep(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ none");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} matches`);
+}
+
+function briefLs(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ empty");
+	const count = text.trim().split("\n").filter(Boolean).length;
+	return theme.fg("muted", `→ ${count} entries`);
+}
+
+function briefTeam(result: { content?: unknown[] }, theme: CrewTheme): string {
+	// Try to extract structured details
+	const details = (result as Record<string, unknown>).details ?? result;
+	const d = typeof details === "object" && details !== null ? details as Record<string, unknown> : {};
+	const status = typeof d.status === "string" ? d.status : "";
+	const runId = typeof d.runId === "string" ? d.runId : "";
+	const icon = status === "completed" ? theme.fg("success", "✓")
+		: status === "failed" ? theme.fg("error", "✗")
+		: status === "running" ? theme.fg("warning", "⟳")
+		: theme.fg("dim", "○");
+
+	// Agent records summary
+	const records = (d.agentRecords ?? d.results) as CrewAgentRecord[] | undefined;
+	if (records?.length) {
+		const completed = records.filter((r) => r.status === "completed").length;
+		const total = records.length;
+		const duration = computeTotalDuration(records);
+		const tokens = computeTotalTokens(records);
+		return `${icon} ${completed}/${total} tasks · ${formatDuration(duration)} · ${formatTokens(tokens)} tok`;
+	}
+
+	// Fallback: compact status line
+	const parts: string[] = [];
+	if (status) parts.push(status);
+	if (runId) parts.push(runId.slice(-8));
+	return `${icon} ${parts.join(" · ") || "done"}`;
+}
+
+function briefAgent(result: { content?: unknown[] }, theme: CrewTheme): string {
+	const d = (result as Record<string, unknown>).details ?? result;
+	const data = typeof d === "object" && d !== null ? d as Record<string, unknown> : {};
+	const status = typeof data.status === "string" ? data.status : "";
+	const agentId = typeof data.agentId === "string" ? data.agentId : "agent";
+	const icon = status === "completed" ? theme.fg("success", "\u2713")
+		: status === "failed" ? theme.fg("error", "\u2717")
+		: theme.fg("dim", "\u25CB");
+	// P3: Show duration and tokens when available
+	const parts: string[] = [agentId];
+	if (data.durationMs) parts.push(formatDuration(data.durationMs as number));
+	if (data.totalTokens) parts.push(`${formatTokens(data.totalTokens as number)} tok`);
+	return `${icon} ${parts.join(" \u00B7 ")}`;
+}
+
+function briefDefault(text: string, theme: CrewTheme): string {
+	if (!text) return theme.fg("dim", "→ done");
+	const first = text.split("\n")[0] ?? "";
+	return theme.fg("muted", `→ ${truncLine(first, 60)}`);
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+function extractText(content: unknown[] | undefined): string {
+	if (!content) return "";
+	if (!Array.isArray(content)) return String(content);
+	return content
+		.filter((c): c is Record<string, unknown> => typeof c === "object" && c !== null && (c as Record<string, unknown>).type === "text")
+		.map((c) => String((c as Record<string, unknown>).text ?? ""))
+		.join("\n");
+}
+
+function computeTotalDuration(records: CrewAgentRecord[]): number {
+	let total = 0;
+	for (const r of records) {
+		if (r.startedAt) {
+			const start = new Date(r.startedAt).getTime();
+			const end = r.completedAt ? new Date(r.completedAt).getTime() : Date.now();
+			if (Number.isFinite(start) && Number.isFinite(end)) total += Math.max(0, end - start);
+		}
+	}
+	return total;
+}
+
+function computeTotalTokens(records: CrewAgentRecord[]): number {
+	let total = 0;
+	for (const r of records) {
+		if (r.usage) {
+			total += (r.usage.input ?? 0) + (r.usage.output ?? 0) + (r.usage.cacheWrite ?? 0);
+		}
+	}
+	return total;
+}