pi-crew 0.2.3 → 0.2.5

package/src/runtime/event-stream-bridge.ts

@@ -1,92 +1,92 @@
-import { runEventBus } from "../ui/run-event-bus.ts";
-import { subprocessToolRegistry, type SubprocessToolEvent } from "./subprocess-tool-registry.ts";
-
-export interface StreamBridgeEvent {
-	runId: string;
-	taskId: string;
-	eventType: string;
-	toolName?: string;
-	toolArgs?: string;
-	intent?: string;
-	tokens?: number;
-	timestamp: number;
-	extractedToolData?: Record<string, unknown>;
-}
-
-const activeBridges = new Map<string, (event: StreamBridgeEvent) => void>();
-
-export function registerStreamBridge(runId: string): { handler: (event: StreamBridgeEvent) => void; dispose: () => void } {
-	const existing = activeBridges.get(runId);
-	if (existing) {
-		return { handler: existing, dispose: () => unregisterStreamBridge(runId) };
-	}
-
-	const handler = (event: StreamBridgeEvent) => {
-		runEventBus.emit({
-			type: "worker_status",
-			runId: event.runId,
-			taskId: event.taskId,
-			data: event,
-		});
-	};
-
-	activeBridges.set(runId, handler);
-	return { handler, dispose: () => unregisterStreamBridge(runId) };
-}
-
-export function unregisterStreamBridge(runId: string): void {
-	activeBridges.delete(runId);
-}
-
-export function bridgeEventFromJsonEvent(runId: string, taskId: string, event: unknown): StreamBridgeEvent | null {
-	if (!event || typeof event !== "object") return null;
-	const record = event as Record<string, unknown>;
-	const type = typeof record.type === "string" ? record.type : "";
-
-	const result: StreamBridgeEvent = {
-		runId,
-		taskId,
-		eventType: type,
-		timestamp: Date.now(),
-	};
-
-	if (typeof record.toolName === "string") result.toolName = record.toolName;
-	if (record.args && typeof record.args === "object") {
-		try {
-			const json = JSON.stringify(record.args);
-			// Truncate at a JSON boundary to avoid breaking structure
-			result.toolArgs = json.length > 200 ? json.slice(0, 197) + "..." : json;
-		} catch {
-			/* skip */
-		}
-	}
-	if (typeof record.intent === "string") result.intent = record.intent;
-
-	// Extract tokens from usage/message_end events
-	const usage = record.usage ?? (record.message as Record<string, unknown> | undefined)?.usage;
-	if (usage && typeof usage === "object") {
-		const u = usage as Record<string, unknown>;
-		const input = typeof u.input === "number" ? u.input : 0;
-		const output = typeof u.output === "number" ? u.output : 0;
-		if (input || output) result.tokens = input + output;
-	}
-
-	// Attach extracted tool data via subprocess tool registry
-	if (result.toolName && subprocessToolRegistry.hasHandler(result.toolName)) {
-		const handler = subprocessToolRegistry.getHandler(result.toolName);
-		if (handler?.extractData) {
-			const extracted = handler.extractData({
-				toolName: result.toolName,
-				toolCallId: (record.toolCallId as string) ?? "",
-				args: record.args as Record<string, unknown> | undefined,
-				result: record.result as SubprocessToolEvent["result"],
-				isError: record.isError as boolean | undefined,
-			});
-			if (extracted !== undefined) {
-				result.extractedToolData = { [result.toolName]: extracted };
-			}
-		}
-	}
-
-	return result;
-}
+import { runEventBus } from "../ui/run-event-bus.ts";
+import { subprocessToolRegistry, type SubprocessToolEvent } from "./subprocess-tool-registry.ts";
+
+export interface StreamBridgeEvent {
+	runId: string;
+	taskId: string;
+	eventType: string;
+	toolName?: string;
+	toolArgs?: string;
+	intent?: string;
+	tokens?: number;
+	timestamp: number;
+	extractedToolData?: Record<string, unknown>;
+}
+
+const activeBridges = new Map<string, (event: StreamBridgeEvent) => void>();
+
+export function registerStreamBridge(runId: string): { handler: (event: StreamBridgeEvent) => void; dispose: () => void } {
+	const existing = activeBridges.get(runId);
+	if (existing) {
+		return { handler: existing, dispose: () => unregisterStreamBridge(runId) };
+	}
+
+	const handler = (event: StreamBridgeEvent) => {
+		runEventBus.emit({
+			type: "worker_status",
+			runId: event.runId,
+			taskId: event.taskId,
+			data: event,
+		});
+	};
+
+	activeBridges.set(runId, handler);
+	return { handler, dispose: () => unregisterStreamBridge(runId) };
+}
+
+export function unregisterStreamBridge(runId: string): void {
+	activeBridges.delete(runId);
+}
+
+export function bridgeEventFromJsonEvent(runId: string, taskId: string, event: unknown): StreamBridgeEvent | null {
+	if (!event || typeof event !== "object") return null;
+	const record = event as Record<string, unknown>;
+	const type = typeof record.type === "string" ? record.type : "";
+
+	const result: StreamBridgeEvent = {
+		runId,
+		taskId,
+		eventType: type,
+		timestamp: Date.now(),
+	};
+
+	if (typeof record.toolName === "string") result.toolName = record.toolName;
+	if (record.args && typeof record.args === "object") {
+		try {
+			const json = JSON.stringify(record.args);
+			// Truncate at a JSON boundary to avoid breaking structure
+			result.toolArgs = json.length > 200 ? json.slice(0, 197) + "..." : json;
+		} catch {
+			/* skip */
+		}
+	}
+	if (typeof record.intent === "string") result.intent = record.intent;
+
+	// Extract tokens from usage/message_end events
+	const usage = record.usage ?? (record.message as Record<string, unknown> | undefined)?.usage;
+	if (usage && typeof usage === "object") {
+		const u = usage as Record<string, unknown>;
+		const input = typeof u.input === "number" ? u.input : 0;
+		const output = typeof u.output === "number" ? u.output : 0;
+		if (input || output) result.tokens = input + output;
+	}
+
+	// Attach extracted tool data via subprocess tool registry
+	if (result.toolName && subprocessToolRegistry.hasHandler(result.toolName)) {
+		const handler = subprocessToolRegistry.getHandler(result.toolName);
+		if (handler?.extractData) {
+			const extracted = handler.extractData({
+				toolName: result.toolName,
+				toolCallId: (record.toolCallId as string) ?? "",
+				args: record.args as Record<string, unknown> | undefined,
+				result: record.result as SubprocessToolEvent["result"],
+				isError: record.isError as boolean | undefined,
+			});
+			if (extracted !== undefined) {
+				result.extractedToolData = { [result.toolName]: extracted };
+			}
+		}
+	}
+
+	return result;
+}

package/src/runtime/foreground-control.ts

@@ -1,82 +1,82 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
-import { readCrewAgents } from "./crew-agent-records.ts";
-
-export type ForegroundControlRequestType = "interrupt" | "status";
-
-export interface ForegroundControlStatus {
-	runId: string;
-	status: TeamRunManifest["status"];
-	active: boolean;
-	asyncPid?: number;
-	asyncAlive?: boolean;
-	runningTasks: string[];
-	runningAgents: string[];
-	controlPath: string;
-	lastRequest?: ForegroundControlRequest;
-}
-
-export interface ForegroundControlRequest {
-	id: string;
-	type: ForegroundControlRequestType;
-	createdAt: string;
-	reason: string;
-	acknowledged: boolean;
-}
-
-export function foregroundControlPath(manifest: TeamRunManifest): string {
-	return path.join(manifest.stateRoot, "foreground-control.json");
-}
-
-function readLastRequest(controlPath: string): ForegroundControlRequest | undefined {
-	if (!fs.existsSync(controlPath)) return undefined;
-	try {
-		const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
-		return parsed.requests?.at(-1);
-	} catch {
-		return undefined;
-	}
-}
-
-export function readForegroundControlStatus(manifest: TeamRunManifest, tasks: TeamTaskState[]): ForegroundControlStatus {
-	const controlPath = foregroundControlPath(manifest);
-	const asyncAlive = manifest.async?.pid !== undefined ? checkProcessLiveness(manifest.async.pid).alive : undefined;
-	return {
-		runId: manifest.runId,
-		status: manifest.status,
-		active: isActiveRunStatus(manifest.status),
-		asyncPid: manifest.async?.pid,
-		asyncAlive,
-		runningTasks: tasks.filter((task) => task.status === "running").map((task) => task.id),
-		runningAgents: readCrewAgents(manifest).filter((agent) => agent.status === "running").map((agent) => agent.id),
-		controlPath,
-		lastRequest: readLastRequest(controlPath),
-	};
-}
-
-export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reason = "User requested foreground interrupt."): ForegroundControlRequest {
-	const controlPath = foregroundControlPath(manifest);
-	let requests: ForegroundControlRequest[] = [];
-	if (fs.existsSync(controlPath)) {
-		try {
-			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
-			requests = Array.isArray(parsed.requests) ? parsed.requests : [];
-		} catch {
-			requests = [];
-		}
-	}
-	const request: ForegroundControlRequest = {
-		id: `fg_${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 10)}`,
-		type: "interrupt",
-		createdAt: new Date().toISOString(),
-		reason,
-		acknowledged: false,
-	};
-	fs.mkdirSync(path.dirname(controlPath), { recursive: true });
-	fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
-	appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
-	return request;
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
+import { readCrewAgents } from "./crew-agent-records.ts";
+
+export type ForegroundControlRequestType = "interrupt" | "status";
+
+export interface ForegroundControlStatus {
+	runId: string;
+	status: TeamRunManifest["status"];
+	active: boolean;
+	asyncPid?: number;
+	asyncAlive?: boolean;
+	runningTasks: string[];
+	runningAgents: string[];
+	controlPath: string;
+	lastRequest?: ForegroundControlRequest;
+}
+
+export interface ForegroundControlRequest {
+	id: string;
+	type: ForegroundControlRequestType;
+	createdAt: string;
+	reason: string;
+	acknowledged: boolean;
+}
+
+export function foregroundControlPath(manifest: TeamRunManifest): string {
+	return path.join(manifest.stateRoot, "foreground-control.json");
+}
+
+function readLastRequest(controlPath: string): ForegroundControlRequest | undefined {
+	if (!fs.existsSync(controlPath)) return undefined;
+	try {
+		const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+		return parsed.requests?.at(-1);
+	} catch {
+		return undefined;
+	}
+}
+
+export function readForegroundControlStatus(manifest: TeamRunManifest, tasks: TeamTaskState[]): ForegroundControlStatus {
+	const controlPath = foregroundControlPath(manifest);
+	const asyncAlive = manifest.async?.pid !== undefined ? checkProcessLiveness(manifest.async.pid).alive : undefined;
+	return {
+		runId: manifest.runId,
+		status: manifest.status,
+		active: isActiveRunStatus(manifest.status),
+		asyncPid: manifest.async?.pid,
+		asyncAlive,
+		runningTasks: tasks.filter((task) => task.status === "running").map((task) => task.id),
+		runningAgents: readCrewAgents(manifest).filter((agent) => agent.status === "running").map((agent) => agent.id),
+		controlPath,
+		lastRequest: readLastRequest(controlPath),
+	};
+}
+
+export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reason = "User requested foreground interrupt."): ForegroundControlRequest {
+	const controlPath = foregroundControlPath(manifest);
+	let requests: ForegroundControlRequest[] = [];
+	if (fs.existsSync(controlPath)) {
+		try {
+			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+			requests = Array.isArray(parsed.requests) ? parsed.requests : [];
+		} catch {
+			requests = [];
+		}
+	}
+	const request: ForegroundControlRequest = {
+		id: `fg_${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 10)}`,
+		type: "interrupt",
+		createdAt: new Date().toISOString(),
+		reason,
+		acknowledged: false,
+	};
+	fs.mkdirSync(path.dirname(controlPath), { recursive: true });
+	fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
+	appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
+	return request;
+}

package/src/runtime/green-contract.ts

@@ -1,46 +1,46 @@
-import type { GreenLevel, VerificationContract, VerificationEvidence } from "../state/types.ts";
-
-const GREEN_ORDER: Record<GreenLevel, number> = {
-	none: 0,
-	targeted: 1,
-	package: 2,
-	workspace: 3,
-	merge_ready: 4,
-};
-
-export interface GreenContractOutcome {
-	requiredGreenLevel: GreenLevel;
-	observedGreenLevel: GreenLevel;
-	satisfied: boolean;
-}
-
-export function greenLevelSatisfies(observed: GreenLevel, required: GreenLevel): boolean {
-	return GREEN_ORDER[observed] >= GREEN_ORDER[required];
-}
-
-export function evaluateGreenContract(contract: VerificationContract, evidence?: VerificationEvidence): GreenContractOutcome {
-	const observedGreenLevel = evidence?.observedGreenLevel ?? "none";
-	return {
-		requiredGreenLevel: contract.requiredGreenLevel,
-		observedGreenLevel,
-		satisfied: greenLevelSatisfies(observedGreenLevel, contract.requiredGreenLevel),
-	};
-}
-
-export function inferGreenLevelFromTask(success: boolean, contract: VerificationContract): GreenLevel {
-	if (!success) return "none";
-	if (contract.requiredGreenLevel === "none") return "none";
-	return contract.allowManualEvidence ? contract.requiredGreenLevel : "targeted";
-}
-
-export function createVerificationEvidence(contract: VerificationContract, success: boolean, notes: string): VerificationEvidence {
-	const observedGreenLevel = inferGreenLevelFromTask(success, contract);
-	const outcome = evaluateGreenContract(contract, { requiredGreenLevel: contract.requiredGreenLevel, observedGreenLevel, satisfied: false, commands: [], notes });
-	return {
-		requiredGreenLevel: contract.requiredGreenLevel,
-		observedGreenLevel,
-		satisfied: outcome.satisfied,
-		commands: contract.commands.map((cmd) => ({ cmd, status: "not_run" as const })),
-		notes,
-	};
-}
+import type { GreenLevel, VerificationContract, VerificationEvidence } from "../state/types.ts";
+
+const GREEN_ORDER: Record<GreenLevel, number> = {
+	none: 0,
+	targeted: 1,
+	package: 2,
+	workspace: 3,
+	merge_ready: 4,
+};
+
+export interface GreenContractOutcome {
+	requiredGreenLevel: GreenLevel;
+	observedGreenLevel: GreenLevel;
+	satisfied: boolean;
+}
+
+export function greenLevelSatisfies(observed: GreenLevel, required: GreenLevel): boolean {
+	return GREEN_ORDER[observed] >= GREEN_ORDER[required];
+}
+
+export function evaluateGreenContract(contract: VerificationContract, evidence?: VerificationEvidence): GreenContractOutcome {
+	const observedGreenLevel = evidence?.observedGreenLevel ?? "none";
+	return {
+		requiredGreenLevel: contract.requiredGreenLevel,
+		observedGreenLevel,
+		satisfied: greenLevelSatisfies(observedGreenLevel, contract.requiredGreenLevel),
+	};
+}
+
+export function inferGreenLevelFromTask(success: boolean, contract: VerificationContract): GreenLevel {
+	if (!success) return "none";
+	if (contract.requiredGreenLevel === "none") return "none";
+	return contract.allowManualEvidence ? contract.requiredGreenLevel : "targeted";
+}
+
+export function createVerificationEvidence(contract: VerificationContract, success: boolean, notes: string): VerificationEvidence {
+	const observedGreenLevel = inferGreenLevelFromTask(success, contract);
+	const outcome = evaluateGreenContract(contract, { requiredGreenLevel: contract.requiredGreenLevel, observedGreenLevel, satisfied: false, commands: [], notes });
+	return {
+		requiredGreenLevel: contract.requiredGreenLevel,
+		observedGreenLevel,
+		satisfied: outcome.satisfied,
+		commands: contract.commands.map((cmd) => ({ cmd, status: "not_run" as const })),
+		notes,
+	};
+}