pi-crew 0.1.46 → 0.1.49

package/src/runtime/session-snapshot.ts

@@ -1,59 +1,59 @@
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-
-/**
- * Creates a lightweight snapshot of task state for event emission.
- * Prevents mutation-during-callback issues by copying relevant fields.
- */
-export function snapshotTaskState(task: TeamTaskState): Readonly<TeamTaskState> {
-	return {
-		...task,
-		dependsOn: [...task.dependsOn],
-		usage: task.usage ? { ...task.usage } : undefined,
-		agentProgress: task.agentProgress ? { ...task.agentProgress } : undefined,
-		heartbeat: task.heartbeat ? { ...task.heartbeat } : undefined,
-		modelAttempts: task.modelAttempts?.map((a) => ({ ...a })),
-		modelRouting: task.modelRouting ? { ...task.modelRouting } : undefined,
-		claim: task.claim ? { ...task.claim } : undefined,
-		checkpoint: task.checkpoint ? { ...task.checkpoint } : undefined,
-		attempts: task.attempts?.map((a) => ({ ...a })),
-		worktree: task.worktree ? { ...task.worktree } : undefined,
-	};
-}
-
-/**
- * Session state snapshot for persistence before session switches.
- * Captures the minimal set of data needed to resume operations.
- */
-export interface SessionStateSnapshot {
-	/** ISO timestamp of the snapshot */
-	capturedAt: string;
-	/** Active run IDs at time of snapshot */
-	activeRunIds: string[];
-	/** Number of pending deliveries */
-	pendingDeliveryCount: number;
-	/** Session generation counter */
-	sessionGeneration: number;
-	/** Summary of active tasks by status */
-	taskSummary: Record<string, number>;
-}
-
-/**
- * Create a session state snapshot for pre-switch persistence.
- */
-export function createSessionSnapshot(
-	activeRuns: TeamRunManifest[],
-	pendingDeliveryCount: number,
-	sessionGeneration: number,
-): SessionStateSnapshot {
-	const taskSummary: Record<string, number> = {};
-	for (const run of activeRuns) {
-		taskSummary[run.status] = (taskSummary[run.status] ?? 0) + 1;
-	}
-	return {
-		capturedAt: new Date().toISOString(),
-		activeRunIds: activeRuns.map((r) => r.runId),
-		pendingDeliveryCount,
-		sessionGeneration,
-		taskSummary,
-	};
-}
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+/**
+ * Creates a lightweight snapshot of task state for event emission.
+ * Prevents mutation-during-callback issues by copying relevant fields.
+ */
+export function snapshotTaskState(task: TeamTaskState): Readonly<TeamTaskState> {
+	return {
+		...task,
+		dependsOn: [...task.dependsOn],
+		usage: task.usage ? { ...task.usage } : undefined,
+		agentProgress: task.agentProgress ? { ...task.agentProgress } : undefined,
+		heartbeat: task.heartbeat ? { ...task.heartbeat } : undefined,
+		modelAttempts: task.modelAttempts?.map((a) => ({ ...a })),
+		modelRouting: task.modelRouting ? { ...task.modelRouting } : undefined,
+		claim: task.claim ? { ...task.claim } : undefined,
+		checkpoint: task.checkpoint ? { ...task.checkpoint } : undefined,
+		attempts: task.attempts?.map((a) => ({ ...a })),
+		worktree: task.worktree ? { ...task.worktree } : undefined,
+	};
+}
+
+/**
+ * Session state snapshot for persistence before session switches.
+ * Captures the minimal set of data needed to resume operations.
+ */
+export interface SessionStateSnapshot {
+	/** ISO timestamp of the snapshot */
+	capturedAt: string;
+	/** Active run IDs at time of snapshot */
+	activeRunIds: string[];
+	/** Number of pending deliveries */
+	pendingDeliveryCount: number;
+	/** Session generation counter */
+	sessionGeneration: number;
+	/** Summary of active tasks by status */
+	taskSummary: Record<string, number>;
+}
+
+/**
+ * Create a session state snapshot for pre-switch persistence.
+ */
+export function createSessionSnapshot(
+	activeRuns: TeamRunManifest[],
+	pendingDeliveryCount: number,
+	sessionGeneration: number,
+): SessionStateSnapshot {
+	const taskSummary: Record<string, number> = {};
+	for (const run of activeRuns) {
+		taskSummary[run.status] = (taskSummary[run.status] ?? 0) + 1;
+	}
+	return {
+		capturedAt: new Date().toISOString(),
+		activeRunIds: activeRuns.map((r) => r.runId),
+		pendingDeliveryCount,
+		sessionGeneration,
+		taskSummary,
+	};
+}

package/src/runtime/session-usage.ts

@@ -1,79 +1,79 @@
-import * as fs from "node:fs";
-import type { UsageState } from "../state/types.ts";
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
-	for (const key of keys) {
-		const value = obj[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-	return undefined;
-}
-
-function usageFromValue(value: unknown): UsageState | undefined {
-	const obj = asRecord(value);
-	if (!obj) return undefined;
-	const direct: UsageState = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
-		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
-		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = usageFromValue(obj[key]);
-		if (nested) return nested;
-	}
-	const message = asRecord(obj.message);
-	return message ? usageFromValue(message.usage) : undefined;
-}
-
-function addUsage(total: UsageState, usage: UsageState): UsageState {
-	return {
-		input: (total.input ?? 0) + (usage.input ?? 0),
-		output: (total.output ?? 0) + (usage.output ?? 0),
-		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
-		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
-		cost: (total.cost ?? 0) + (usage.cost ?? 0),
-		turns: (total.turns ?? 0) + (usage.turns ?? 0),
-	};
-}
-
-function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
-	if (foundKeys.size === 0) return undefined;
-	const compact: UsageState = {};
-	for (const key of foundKeys) compact[key] = total[key];
-	return compact;
-}
-
-export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
-	let total: UsageState = {};
-	const foundKeys = new Set<keyof UsageState>();
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
-			if (!usage) continue;
-			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
-			total = addUsage(total, usage);
-		} catch {
-			// Session JSONL can contain partial/corrupt lines after interrupted workers.
-		}
-	}
-	return compactUsage(total, foundKeys);
-}
-
-export function parseSessionUsage(filePath: string): UsageState | undefined {
-	try {
-		if (!fs.existsSync(filePath)) return undefined;
-		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
-	} catch {
-		return undefined;
-	}
-}
+import * as fs from "node:fs";
+import type { UsageState } from "../state/types.ts";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = obj[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return undefined;
+}
+
+function usageFromValue(value: unknown): UsageState | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: UsageState = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+		const nested = usageFromValue(obj[key]);
+		if (nested) return nested;
+	}
+	const message = asRecord(obj.message);
+	return message ? usageFromValue(message.usage) : undefined;
+}
+
+function addUsage(total: UsageState, usage: UsageState): UsageState {
+	return {
+		input: (total.input ?? 0) + (usage.input ?? 0),
+		output: (total.output ?? 0) + (usage.output ?? 0),
+		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
+		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+		cost: (total.cost ?? 0) + (usage.cost ?? 0),
+		turns: (total.turns ?? 0) + (usage.turns ?? 0),
+	};
+}
+
+function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
+	if (foundKeys.size === 0) return undefined;
+	const compact: UsageState = {};
+	for (const key of foundKeys) compact[key] = total[key];
+	return compact;
+}
+
+export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
+	let total: UsageState = {};
+	const foundKeys = new Set<keyof UsageState>();
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
+			if (!usage) continue;
+			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
+			total = addUsage(total, usage);
+		} catch {
+			// Session JSONL can contain partial/corrupt lines after interrupted workers.
+		}
+	}
+	return compactUsage(total, foundKeys);
+}
+
+export function parseSessionUsage(filePath: string): UsageState | undefined {
+	try {
+		if (!fs.existsSync(filePath)) return undefined;
+		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return undefined;
+	}
+}

package/src/runtime/sidechain-output.ts

@@ -1,29 +1,29 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { redactSecrets } from "../utils/redaction.ts";
-
-export interface SidechainEntry {
-	isSidechain: true;
-	agentId: string;
-	type: string;
-	message: unknown;
-	timestamp: string;
-	cwd: string;
-}
-
-export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`, "utf-8");
-}
-
-export function sidechainOutputPath(stateRoot: string, taskId: string): string {
-	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
-}
-
-export function eventToSidechainType(event: unknown): string | undefined {
-	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
-	const type = (event as { type?: unknown }).type;
-	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
-	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
-	return typeof type === "string" ? type : undefined;
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { redactSecrets } from "../utils/redaction.ts";
+
+export interface SidechainEntry {
+	isSidechain: true;
+	agentId: string;
+	type: string;
+	message: unknown;
+	timestamp: string;
+	cwd: string;
+}
+
+export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`, "utf-8");
+}
+
+export function sidechainOutputPath(stateRoot: string, taskId: string): string {
+	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
+}
+
+export function eventToSidechainType(event: unknown): string | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const type = (event as { type?: unknown }).type;
+	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
+	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
+	return typeof type === "string" ? type : undefined;
+}

package/src/runtime/stream-preview.ts

@@ -0,0 +1,177 @@
+// ─── Streaming Preview ───────────────────────────────────────────────────────
+// Captures incremental worker output during task execution for live preview.
+// Used by the UI layer to show partial results before task completion.
+
+import type { ParsedPiUsage } from "./pi-json-output.ts";
+
+export interface ToolCallPreview {
+	toolName: string;
+	inputPreview: string;
+	startedAt: number;
+}
+
+export interface StreamPreview {
+	taskId: string;
+	runId: string;
+	/** Cumulative text output captured so far */
+	textBuffer: string;
+	/** Current tool call in progress (if any) */
+	activeToolCall: ToolCallPreview | null;
+	/** Completed tool calls count */
+	toolCallCount: number;
+	/** Current turn number (incremented per assistant message) */
+	turnCount: number;
+	/** Token usage snapshot */
+	usage: Partial<ParsedPiUsage> | null;
+	/** Wall-clock start time */
+	startedAt: number;
+	/** Last update timestamp */
+	lastUpdatedAt: number;
+	/** Whether the task has completed */
+	finished: boolean;
+}
+
+export function createStreamPreview(taskId: string, runId: string): StreamPreview {
+	const now = Date.now();
+	return {
+		taskId,
+		runId,
+		textBuffer: "",
+		activeToolCall: null,
+		toolCallCount: 0,
+		turnCount: 0,
+		usage: null,
+		startedAt: now,
+		lastUpdatedAt: now,
+		finished: false,
+	};
+}
+
+/** Max text buffer size — drop oldest content when exceeded */
+const MAX_TEXT_BUFFER = 16_384;
+/** Max tool input preview length */
+const MAX_INPUT_PREVIEW = 512;
+
+const asRecord = (value: unknown): Record<string, unknown> | undefined =>
+	value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+
+function truncateWithEllipsis(text: string, maxLength: number): string {
+	if (text.length <= maxLength) return text;
+	return text.slice(0, maxLength - 3) + "...";
+}
+
+function extractTextFromContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const part of content) {
+		const obj = asRecord(part);
+		if (!obj) continue;
+		if (obj.type === "text" && typeof obj.text === "string") parts.push(obj.text);
+		else if (typeof obj.content === "string") parts.push(obj.content);
+	}
+	return parts.join("");
+}
+
+/**
+ * Feed a JSON event from Pi's stdout into the preview, updating it in place.
+ * Returns true if the preview was modified.
+ */
+export function feedJsonEvent(preview: StreamPreview, event: unknown): boolean {
+	const obj = asRecord(event);
+	if (!obj) return false;
+
+	let modified = false;
+	preview.lastUpdatedAt = Date.now();
+
+	// Detect tool calls
+	if (obj.type === "tool_call" || obj.type === "tool_use" || obj.type === "toolCall") {
+		const toolName = typeof obj.name === "string" ? obj.name : typeof obj.tool === "string" ? obj.tool : "unknown";
+		const rawInput = obj.input ?? obj.arguments ?? obj.params ?? "";
+		const inputStr = typeof rawInput === "string" ? rawInput : JSON.stringify(rawInput);
+		preview.activeToolCall = {
+			toolName,
+			inputPreview: truncateWithEllipsis(inputStr, MAX_INPUT_PREVIEW),
+			startedAt: Date.now(),
+		};
+		preview.toolCallCount++;
+		modified = true;
+	}
+
+	// Detect tool results (clear active tool call)
+	if (obj.type === "tool_result" || obj.type === "toolResult" || obj.type === "result") {
+		preview.activeToolCall = null;
+		modified = true;
+	}
+
+	// Detect assistant text output
+	const message = asRecord(obj.message);
+	if (message?.role === "assistant" || obj.role === "assistant") {
+		preview.turnCount++;
+		const text = extractTextFromContent(message?.content ?? obj.content);
+		if (text) {
+			const appended = preview.textBuffer.length > 0 ? preview.textBuffer + "\n" + text : text;
+			preview.textBuffer = appended.length > MAX_TEXT_BUFFER ? appended.slice(appended.length - MAX_TEXT_BUFFER) : appended;
+		}
+		modified = true;
+	}
+
+	// Detect direct text/final output
+	if (typeof obj.text === "string" && obj.text.trim()) {
+		const appended = preview.textBuffer.length > 0 ? preview.textBuffer + "\n" + obj.text : obj.text;
+		preview.textBuffer = appended.length > MAX_TEXT_BUFFER ? appended.slice(appended.length - MAX_TEXT_BUFFER) : appended;
+		modified = true;
+	}
+
+	// Detect usage
+	const rawUsage = obj.usage ?? obj.tokenUsage ?? obj.tokens ?? obj.stats;
+	if (rawUsage && typeof rawUsage === "object") {
+		const u = asRecord(rawUsage);
+		if (u) {
+			preview.usage = {
+				input: typeof u.input === "number" ? u.input : preview.usage?.input,
+				output: typeof u.output === "number" ? u.output : preview.usage?.output,
+				cacheRead: typeof u.cacheRead === "number" ? u.cacheRead : preview.usage?.cacheRead,
+				cacheWrite: typeof u.cacheWrite === "number" ? u.cacheWrite : preview.usage?.cacheWrite,
+				cost: typeof u.cost === "number" ? u.cost : preview.usage?.cost,
+				turns: typeof u.turns === "number" ? u.turns : preview.usage?.turns,
+			};
+			modified = true;
+		}
+	}
+
+	return modified;
+}
+
+/** Mark preview as finished */
+export function finishStreamPreview(preview: StreamPreview): void {
+	preview.finished = true;
+	preview.activeToolCall = null;
+	preview.lastUpdatedAt = Date.now();
+}
+
+/** Render a compact one-line status for the preview */
+export function renderPreviewStatus(preview: StreamPreview): string {
+	const elapsed = Math.round((Date.now() - preview.startedAt) / 1000);
+	const parts: string[] = [];
+
+	if (preview.finished) {
+		parts.push("✓ done");
+	} else if (preview.activeToolCall) {
+		parts.push(`⚙ ${preview.activeToolCall.toolName}`);
+	} else {
+		parts.push("⟳ thinking");
+	}
+
+	parts.push(`T${preview.turnCount}`);
+	parts.push(`${preview.toolCallCount} tools`);
+
+	if (preview.usage?.input) {
+		const inK = Math.round(preview.usage.input / 1024);
+		parts.push(`${inK}k in`);
+	}
+
+	parts.push(`${elapsed}s`);
+
+	return parts.join(" | ");
+}

package/src/runtime/subagent-manager.ts

@@ -208,7 +208,7 @@ export class SubagentManager {
 			const record = this.records.get(id);
 			if (!record) return undefined;
 			if (record.status !== "running" && record.status !== "queued") return record;
-			if (record.promise) await record.promise;
+			if (record.promise) await record.promise.catch(() => { /* status already set to error */ });
 			else await new Promise((resolve) => setTimeout(resolve, 100));
 		}
 	}
@@ -235,7 +235,7 @@ export class SubagentManager {
 				if (result.isError) {
 					record.status = "error";
 					record.error = record.result;
-					return;
+					throw new Error(record.error);
 				}
 				if (record.runId) await this.pollRunToTerminal(options.cwd, record);
 				else record.status = "completed";
@@ -246,6 +246,7 @@ export class SubagentManager {
 				}
 				record.status = "error";
 				record.error = error instanceof Error ? error.message : String(error);
+				throw error; // H4: Propagate rejection so callers awaiting record.promise see the error
 			} finally {
 				this.cleanupRunSignal(record.id);
 				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);

package/src/runtime/subprocess-tool-registry.ts

@@ -0,0 +1,67 @@
+export interface SubprocessToolEvent {
+	toolName: string;
+	toolCallId: string;
+	args?: Record<string, unknown>;
+	result?: { content: Array<{ type: string; text?: string }>; details?: unknown };
+	isError?: boolean;
+}
+
+export interface SubprocessToolHandler<TData = unknown> {
+	extractData?: (event: SubprocessToolEvent) => TData | undefined;
+	shouldTerminate?: (event: SubprocessToolEvent) => boolean;
+}
+
+export interface SubprocessToolRegistry {
+	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
+	getHandler(toolName: string): SubprocessToolHandler | undefined;
+	hasHandler(toolName: string): boolean;
+	getRegisteredTools(): string[];
+	extractAll(event: SubprocessToolEvent): Record<string, unknown>;
+	/** H3: Clear all registered handlers (for test isolation). */
+	clear(): void;
+}
+
+class SubprocessToolRegistryImpl implements SubprocessToolRegistry {
+	private readonly handlers = new Map<string, SubprocessToolHandler>();
+
+	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void {
+		this.handlers.set(toolName, handler as SubprocessToolHandler);
+	}
+
+	getHandler(toolName: string): SubprocessToolHandler | undefined {
+		return this.handlers.get(toolName);
+	}
+
+	hasHandler(toolName: string): boolean {
+		return this.handlers.has(toolName);
+	}
+
+	getRegisteredTools(): string[] {
+		return [...this.handlers.keys()];
+	}
+
+	extractAll(event: SubprocessToolEvent): Record<string, unknown> {
+		const extracted: Record<string, unknown> = {};
+		for (const [toolName, handler] of this.handlers) {
+			if (handler.extractData) {
+				const data = handler.extractData(event);
+				if (data !== undefined) {
+					extracted[toolName] = data;
+				}
+			}
+		}
+		return extracted;
+	}
+
+	/** H3: Clear all registered handlers (for test isolation). */
+	clear(): void {
+		this.handlers.clear();
+	}
+}
+
+export const subprocessToolRegistry: SubprocessToolRegistry = new SubprocessToolRegistryImpl();
+
+/** H3: Reset the global singleton registry (for test isolation). */
+export function resetSubprocessToolRegistry(): void {
+	subprocessToolRegistry.clear();
+}