pi-crew 0.1.46 → 0.1.49

package/src/runtime/effectiveness.ts

@@ -1,76 +1,81 @@
-import type { CrewRuntimeConfig } from "../config/config.ts";
-import type { PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-
-export type EffectivenessGuardMode = "off" | "warn" | "block" | "fail";
-export type WorkerExecutionState = "enabled" | "disabled/scaffold";
-export type RunEffectivenessSeverity = "ok" | "warning" | "blocked" | "failed";
-
-export interface RunEffectivenessSummary {
-	completed: number;
-	observable: number;
-	noObservedWorkTaskIds: string[];
-	needsAttentionTaskIds: string[];
-	workerExecution: WorkerExecutionState;
-	guardMode: EffectivenessGuardMode;
-	severity: RunEffectivenessSeverity;
-}
-
-export function taskHasObservableWorkerActivity(task: TeamTaskState): boolean {
-	return Boolean(
-		(task.agentProgress?.toolCount ?? 0) > 0
-		|| task.usage
-		|| task.transcriptArtifact
-		|| task.modelAttempts?.some((attempt) => attempt.success)
-		|| task.jsonEvents,
-	);
-}
-
-export function resolveEffectivenessGuardMode(runtimeConfig: CrewRuntimeConfig | undefined, manifest?: TeamRunManifest): EffectivenessGuardMode {
-	const configured = runtimeConfig?.effectivenessGuard;
-	if (configured === "off" || configured === "warn" || configured === "block" || configured === "fail") return configured;
-	if (manifest?.runtimeResolution?.safety === "explicit_dry_run") return "off";
-	return "warn";
-}
-
-export function evaluateRunEffectiveness(input: { manifest?: TeamRunManifest; tasks: TeamTaskState[]; executeWorkers: boolean; runtimeConfig?: CrewRuntimeConfig }): RunEffectivenessSummary {
-	const completedTasks = input.tasks.filter((task) => task.status === "completed");
-	const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task));
-	const needsAttentionTasks = input.tasks.filter((task) => task.agentProgress?.activityState === "needs_attention");
-	const workerExecution: WorkerExecutionState = input.executeWorkers ? "enabled" : "disabled/scaffold";
-	const guardMode = resolveEffectivenessGuardMode(input.runtimeConfig, input.manifest);
-	const observable = Math.max(0, completedTasks.length - noObservedWorkTasks.length - needsAttentionTasks.length);
-	let severity: RunEffectivenessSeverity = "ok";
-	if (input.executeWorkers && guardMode !== "off" && noObservedWorkTasks.length > 0) {
-		severity = guardMode === "fail" ? "failed" : guardMode === "block" ? "blocked" : "warning";
-	}
-	return {
-		completed: completedTasks.length,
-		observable,
-		noObservedWorkTaskIds: noObservedWorkTasks.map((task) => task.id),
-		needsAttentionTaskIds: needsAttentionTasks.map((task) => task.id),
-		workerExecution,
-		guardMode,
-		severity,
-	};
-}
-
-export function formatRunEffectivenessLines(summary: RunEffectivenessSummary): string[] {
-	return [
-		`Score: ${summary.observable}/${Math.max(1, summary.completed)} completed task(s) with observable worker activity`,
-		`Worker execution: ${summary.workerExecution}`,
-		`Guard: ${summary.guardMode} severity=${summary.severity}`,
-		`No observable worker activity: ${summary.noObservedWorkTaskIds.length ? summary.noObservedWorkTaskIds.join(", ") : "none"}`,
-		`Needs attention: ${summary.needsAttentionTaskIds.length ? summary.needsAttentionTaskIds.join(", ") : "none"}`,
-	];
-}
-
-export function effectivenessPolicyDecision(summary: RunEffectivenessSummary): PolicyDecision | undefined {
-	if (summary.severity !== "warning" && summary.severity !== "blocked" && summary.severity !== "failed") return undefined;
-	const action = summary.severity === "failed" ? "fail" : summary.severity === "blocked" ? "block" : "notify";
-	return {
-		action,
-		reason: "ineffective_worker",
-		message: `Run effectiveness guard ${summary.guardMode}: no observable worker activity for ${summary.noObservedWorkTaskIds.join(", ")}.`,
-		createdAt: new Date().toISOString(),
-	};
-}
+import { permissionForRole } from "./role-permission.ts";
+import type { CrewRuntimeConfig } from "../config/config.ts";
+import type { PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+export type EffectivenessGuardMode = "off" | "warn" | "block" | "fail";
+export type WorkerExecutionState = "enabled" | "disabled/scaffold";
+export type RunEffectivenessSeverity = "ok" | "warning" | "blocked" | "failed";
+
+export interface RunEffectivenessSummary {
+	completed: number;
+	observable: number;
+	noObservedWorkTaskIds: string[];
+	needsAttentionTaskIds: string[];
+	workerExecution: WorkerExecutionState;
+	guardMode: EffectivenessGuardMode;
+	severity: RunEffectivenessSeverity;
+}
+
+export function taskHasObservableWorkerActivity(task: TeamTaskState): boolean {
+	return Boolean(
+		(task.agentProgress?.toolCount ?? 0) > 0
+		|| task.usage
+		|| task.transcriptArtifact
+		|| task.modelAttempts?.some((attempt) => attempt.success)
+		|| task.jsonEvents,
+	);
+}
+
+export function resolveEffectivenessGuardMode(runtimeConfig: CrewRuntimeConfig | undefined, manifest?: TeamRunManifest): EffectivenessGuardMode {
+	const configured = runtimeConfig?.effectivenessGuard;
+	if (configured === "off" || configured === "warn" || configured === "block" || configured === "fail") return configured;
+	if (manifest?.runtimeResolution?.safety === "explicit_dry_run") return "off";
+	return "warn";
+}
+
+export function evaluateRunEffectiveness(input: { manifest?: TeamRunManifest; tasks: TeamTaskState[]; executeWorkers: boolean; runtimeConfig?: CrewRuntimeConfig }): RunEffectivenessSummary {
+	const completedTasks = input.tasks.filter((task) => task.status === "completed");
+	const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task));
+	const needsAttentionTasks = input.tasks.filter((task) => task.agentProgress?.activityState === "needs_attention");
+	const workerExecution: WorkerExecutionState = input.executeWorkers ? "enabled" : "disabled/scaffold";
+	const guardMode = resolveEffectivenessGuardMode(input.runtimeConfig, input.manifest);
+	const observable = Math.max(0, completedTasks.length - noObservedWorkTasks.length - needsAttentionTasks.length);
+	let severity: RunEffectivenessSeverity = "ok";
+	if (input.executeWorkers && guardMode !== "off" && noObservedWorkTasks.length > 0) {
+		severity = guardMode === "fail" ? "failed" : guardMode === "block" ? "blocked" : "warning";
+		// P0.1: default warn escalates to blocked for mutating-role tasks without observed work
+		if (severity === "warning" && noObservedWorkTasks.some((task) => permissionForRole(task.role) !== "read_only")) {
+			severity = "blocked";
+		}
+	}
+	return {
+		completed: completedTasks.length,
+		observable,
+		noObservedWorkTaskIds: noObservedWorkTasks.map((task) => task.id),
+		needsAttentionTaskIds: needsAttentionTasks.map((task) => task.id),
+		workerExecution,
+		guardMode,
+		severity,
+	};
+}
+
+export function formatRunEffectivenessLines(summary: RunEffectivenessSummary): string[] {
+	return [
+		`Score: ${summary.observable}/${Math.max(1, summary.completed)} completed task(s) with observable worker activity`,
+		`Worker execution: ${summary.workerExecution}`,
+		`Guard: ${summary.guardMode} severity=${summary.severity}`,
+		`No observable worker activity: ${summary.noObservedWorkTaskIds.length ? summary.noObservedWorkTaskIds.join(", ") : "none"}`,
+		`Needs attention: ${summary.needsAttentionTaskIds.length ? summary.needsAttentionTaskIds.join(", ") : "none"}`,
+	];
+}
+
+export function effectivenessPolicyDecision(summary: RunEffectivenessSummary): PolicyDecision | undefined {
+	if (summary.severity !== "warning" && summary.severity !== "blocked" && summary.severity !== "failed") return undefined;
+	const action = summary.severity === "failed" ? "fail" : summary.severity === "blocked" ? "block" : "notify";
+	return {
+		action,
+		reason: "ineffective_worker",
+		message: `Run effectiveness guard ${summary.guardMode}: no observable worker activity for ${summary.noObservedWorkTaskIds.join(", ")}.`,
+		createdAt: new Date().toISOString(),
+	};
+}

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

@@ -0,0 +1,90 @@
+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 {
+			result.toolArgs = JSON.stringify(record.args).slice(0, 200);
+		} 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,
+	};
+}