pi-crew 0.9.16 → 0.9.18

package/src/runtime/delivery-coordinator.ts

@@ -63,7 +63,13 @@ export class DeliveryCoordinator {
 				logInternalError("delivery-coordinator.deliverResult", error, `runId=${runId}`);
 			}
 		}
-		if (!this.flushing) this.enqueue({ runId, payload: result, timestamp: Date.now(), type: "result" });
+		if (!this.flushing)
+			this.enqueue({
+				runId,
+				payload: result,
+				timestamp: Date.now(),
+				type: "result",
+			});
 	}
 
 	deliverNotification(notification: NotificationDescriptor): void {
@@ -80,11 +86,19 @@ export class DeliveryCoordinator {
 			if (this.deps.emit) {
 				try {
 					this.deps.emit("pi-crew:notification", notification);
-				} catch { /* secondary delivery, ignore errors */ }
+				} catch {
+					/* secondary delivery, ignore errors */
+				}
 			}
 			return;
 		}
-		if (!this.flushing) this.enqueue({ runId: notification.runId ?? "", payload: notification, timestamp: Date.now(), type: "notification" });
+		if (!this.flushing)
+			this.enqueue({
+				runId: notification.runId ?? "",
+				payload: notification,
+				timestamp: Date.now(),
+				type: "notification",
+			});
 	}
 
 	deliverSteer(runId: string, message: string): void {
@@ -96,7 +110,13 @@ export class DeliveryCoordinator {
 				logInternalError("delivery-coordinator.deliverSteer", error, `runId=${runId}`);
 			}
 		}
-		if (!this.flushing) this.enqueue({ runId, payload: message, timestamp: Date.now(), type: "steer" });
+		if (!this.flushing)
+			this.enqueue({
+				runId,
+				payload: message,
+				timestamp: Date.now(),
+				type: "steer",
+			});
 	}
 
 	flushQueuedResults(): void {
@@ -115,10 +135,17 @@ export class DeliveryCoordinator {
 					continue;
 				}
 				try {
-					if (!this.deliverQueued(delivery)) retryLater.push({ ...delivery, generation: this.generation });
+					if (!this.deliverQueued(delivery))
+						retryLater.push({
+							...delivery,
+							generation: this.generation,
+						});
 				} catch (error) {
 					logInternalError("delivery-coordinator.flush", error, `runId=${delivery.runId} type=${delivery.type}`);
-					retryLater.push({ ...delivery, generation: this.generation });
+					retryLater.push({
+						...delivery,
+						generation: this.generation,
+					});
 				}
 			}
 			this.pending.unshift(...retryLater);
@@ -181,4 +208,4 @@ export class DeliveryCoordinator {
 			logInternalError("delivery-coordinator.evict", undefined, `evicted=${evicted} remaining=${this.pending.length}`);
 		}
 	}
-}
+}

package/src/runtime/delta-conflict.ts

@@ -98,10 +98,7 @@ export interface ExistingState {
  * - **resource_deleted**: referenced agent/team/workflow in import does not exist
  *   in the current state.
  */
-export function detectImportConflicts(
-	importBundle: ImportBundle,
-	existingState: ExistingState,
-): ConflictReport {
+export function detectImportConflicts(importBundle: ImportBundle, existingState: ExistingState): ConflictReport {
 	const conflicts: Conflict[] = [];
 	const { manifest: incoming, tasks: incomingTasks } = importBundle;
 	const { manifest: current, tasks: currentTasks } = existingState;
@@ -110,11 +107,7 @@ export function detectImportConflicts(
 	if (current) {
 		const incomingVersion = incoming.schemaVersion;
 		const currentVersion = current.schemaVersion;
-		if (
-			typeof incomingVersion !== "undefined" &&
-			typeof currentVersion !== "undefined" &&
-			incomingVersion !== currentVersion
-		) {
+		if (typeof incomingVersion !== "undefined" && typeof currentVersion !== "undefined" && incomingVersion !== currentVersion) {
 			conflicts.push({
 				kind: "schema_drift",
 				path: "manifest.schemaVersion",
@@ -156,9 +149,7 @@ export function detectImportConflicts(
 
 	// ── State mismatch (task status differences) ─────────────────────
 	if (currentTasks && currentTasks.length > 0) {
-		const currentTaskMap = new Map(
-			extractTaskLikes(currentTasks).map((t) => [t.id, t]),
-		);
+		const currentTaskMap = new Map(extractTaskLikes(currentTasks).map((t) => [t.id, t]));
 		const incomingTaskList = extractTaskLikes(incomingTasks);
 
 		for (const inTask of incomingTaskList) {
@@ -257,10 +248,7 @@ export interface CurrentState {
  * - **file_overwrite**: files changed since suspension.
  * - **state_mismatch**: task statuses changed externally.
  */
-export function detectResumeConflicts(
-	suspendedState: SuspendedState,
-	currentState: CurrentState,
-): ConflictReport {
+export function detectResumeConflicts(suspendedState: SuspendedState, currentState: CurrentState): ConflictReport {
 	const conflicts: Conflict[] = [];
 	const { tasks: suspendedTasks, artifacts: suspendedArtifacts } = suspendedState;
 	const { changedFiles, taskStatuses } = currentState;
@@ -310,17 +298,17 @@ export function detectResumeConflicts(
  * - **merge**: attempt merge — resolves `state_mismatch` with merged status;
  *   resolves others conditionally.
  */
-export function resolveConflict(
-	conflict: Conflict,
-	strategy: ConflictStrategy,
-): ConflictResolution {
+export function resolveConflict(conflict: Conflict, strategy: ConflictStrategy): ConflictResolution {
 	switch (strategy) {
 		case "skip":
 			return { resolved: true, action: `Skipped ${conflict.path}` };
 
 		case "overwrite":
 			if (conflict.kind === "file_overwrite" || conflict.kind === "schema_drift") {
-				return { resolved: true, action: `Overwritten ${conflict.path} with incoming value` };
+				return {
+					resolved: true,
+					action: `Overwritten ${conflict.path} with incoming value`,
+				};
 			}
 			return {
 				resolved: false,

package/src/runtime/deterministic-ast.ts

@@ -158,4 +158,4 @@ function staticStringOf(node: AstNode | undefined): string | undefined {
 		if (left !== undefined && right !== undefined) return left + right;
 	}
 	return undefined;
-}
+}

package/src/runtime/diagnostic-export.ts

@@ -1,17 +1,18 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import type { MetricSnapshot } from "../observability/metrics-primitives.ts";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { readCrewAgents } from "./crew-agent-records.ts";
 import { readEvents, type TeamEvent } from "../state/event-log.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { summarizeHeartbeats, type HeartbeatSummary } from "../ui/heartbeat-aggregator.ts";
+import { type HeartbeatSummary, summarizeHeartbeats } from "../ui/heartbeat-aggregator.ts";
 import type { RunUiSnapshot } from "../ui/snapshot-types.ts";
-import { redactSecrets, isSecretKey } from "../utils/redaction.ts";
+import { isSecretKey, redactSecrets } from "../utils/redaction.ts";
+import { readCrewAgents } from "./crew-agent-records.ts";
 import { buildRecoveryLedger, type RecoveryLedgerEntry } from "./recovery-recipes.ts";
-export { redactSecrets, isSecretKey } from "../utils/redaction.ts";
+
+export { isSecretKey, redactSecrets } from "../utils/redaction.ts";
 
 export interface DiagnosticReport {
 	schemaVersion?: number;
@@ -29,15 +30,23 @@ export interface DiagnosticReport {
 	// Layer 9: terminal evidence
 	terminalEvidence: Record<string, TeamTaskState["terminalEvidence"]>;
 	// Layer 10: model attempts and routing
-	modelAttempts: { taskId: string; attempts: TeamTaskState["modelAttempts"]; routing: TeamTaskState["modelRouting"] }[];
+	modelAttempts: {
+		taskId: string;
+		attempts: TeamTaskState["modelAttempts"];
+		routing: TeamTaskState["modelRouting"];
+	}[];
 	// Layer 11: pending mailbox
-	pendingMailbox: { taskId: string; pendingSteers: TeamTaskState["pendingSteers"] }[];
+	pendingMailbox: {
+		taskId: string;
+		pendingSteers: TeamTaskState["pendingSteers"];
+	}[];
 	runMailboxUnread: RunUiSnapshot["mailbox"];
 	// Layer 12: recovery ledger
 	recoveryLedger: RecoveryLedgerEntry[];
 }
 
-const ENV_DEBUG_ALLOWLIST = /^(PI_CREW_|PI_TEAMS_|PI_.*HOME|NODE_ENV|NODE_VERSION|OS|PROCESSOR|TERM|LANG|HOME|USERPROFILE|APPDATA|PLATFORM|ARCH|WIN32|DOCKER|CI|VERBOSE|DEBUG|NO_COLOR|FORCE_COLOR|NPM_CONFIG|npm_)/i;
+const ENV_DEBUG_ALLOWLIST =
+	/^(PI_CREW_|PI_TEAMS_|PI_.*HOME|NODE_ENV|NODE_VERSION|OS|PROCESSOR|TERM|LANG|HOME|USERPROFILE|APPDATA|PLATFORM|ARCH|WIN32|DOCKER|CI|VERBOSE|DEBUG|NO_COLOR|FORCE_COLOR|NPM_CONFIG|npm_)/i;
 
 function envRedacted(): Record<string, string> {
 	const output: Record<string, string> = {};
@@ -73,7 +82,11 @@ function buildSnapshot(manifest: TeamRunManifest, tasks: TeamTaskState[]): RunUi
 	};
 }
 
-export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId: string, options: { registry?: MetricRegistry } = {}): Promise<{ path: string; report: DiagnosticReport }> {
+export async function exportDiagnostic(
+	ctx: Pick<ExtensionContext, "cwd">,
+	runId: string,
+	options: { registry?: MetricRegistry } = {},
+): Promise<{ path: string; report: DiagnosticReport }> {
 	const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 	if (!loaded) throw new Error(`Run '${runId}' not found.`);
 	const exportedAt = new Date().toISOString();
@@ -82,21 +95,33 @@ export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId
 	const metricsSnapshot = options.registry?.snapshot();
 	const taskDiagnostics: Record<string, Record<string, unknown>> = {};
 	const terminalEvidence: Record<string, TeamTaskState["terminalEvidence"]> = {};
-	const modelAttempts: { taskId: string; attempts: TeamTaskState["modelAttempts"]; routing: TeamTaskState["modelRouting"] }[] = [];
-	const pendingMailbox: { taskId: string; pendingSteers: TeamTaskState["pendingSteers"] }[] = [];
+	const modelAttempts: {
+		taskId: string;
+		attempts: TeamTaskState["modelAttempts"];
+		routing: TeamTaskState["modelRouting"];
+	}[] = [];
+	const pendingMailbox: {
+		taskId: string;
+		pendingSteers: TeamTaskState["pendingSteers"];
+	}[] = [];
 	for (const task of loaded.tasks) {
 		if (task.diagnostics) taskDiagnostics[task.id] = task.diagnostics;
 		if (task.terminalEvidence) terminalEvidence[task.id] = task.terminalEvidence;
 		if (task.modelAttempts || task.modelRouting) {
-			modelAttempts.push({ taskId: task.id, attempts: task.modelAttempts, routing: task.modelRouting });
+			modelAttempts.push({
+				taskId: task.id,
+				attempts: task.modelAttempts,
+				routing: task.modelRouting,
+			});
 		}
 		if (task.pendingSteers) {
-			pendingMailbox.push({ taskId: task.id, pendingSteers: task.pendingSteers });
+			pendingMailbox.push({
+				taskId: task.id,
+				pendingSteers: task.pendingSteers,
+			});
 		}
 	}
-	const recoveryLedger = loaded.manifest.policyDecisions
-		? buildRecoveryLedger(loaded.manifest.policyDecisions).entries
-		: [];
+	const recoveryLedger = loaded.manifest.policyDecisions ? buildRecoveryLedger(loaded.manifest.policyDecisions).entries : [];
 	const snapshot = buildSnapshot(loaded.manifest, loaded.tasks);
 	const report: DiagnosticReport = {
 		...(metricsSnapshot ? { schemaVersion: 2 } : {}),
@@ -108,7 +133,11 @@ export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId
 		heartbeat: summarizeHeartbeats(snapshot),
 		agents: redactSecrets(readCrewAgents(loaded.manifest)) as unknown[],
 		envRedacted: envRedacted(),
-		...(metricsSnapshot ? { metricsSnapshot: redactSecrets(metricsSnapshot) as MetricSnapshot[] } : {}),
+		...(metricsSnapshot
+			? {
+					metricsSnapshot: redactSecrets(metricsSnapshot) as MetricSnapshot[],
+				}
+			: {}),
 		taskDiagnostics,
 		terminalEvidence,
 		modelAttempts,
@@ -126,9 +155,13 @@ export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId
 export function listRecentDiagnostic(dir: string, windowMs: number, now = Date.now()): string | undefined {
 	try {
 		if (!fs.existsSync(dir)) return undefined;
-		return fs.readdirSync(dir)
+		return fs
+			.readdirSync(dir)
 			.filter((file) => file.startsWith("diagnostic-") && file.endsWith(".json"))
-			.map((file) => ({ file, mtimeMs: fs.statSync(path.join(dir, file)).mtimeMs }))
+			.map((file) => ({
+				file,
+				mtimeMs: fs.statSync(path.join(dir, file)).mtimeMs,
+			}))
 			.filter((entry) => now - entry.mtimeMs < windowMs)
 			.sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.file;
 	} catch {

package/src/runtime/direct-run.ts

@@ -7,7 +7,11 @@ export function isDirectRun(manifest: Pick<TeamRunManifest, "team" | "workflow">
 	return manifest.workflow === "direct-agent";
 }
 
-export function directTeamAndWorkflowFromRun(manifest: TeamRunManifest, tasks: TeamTaskState[], agents: AgentConfig[]): { team: TeamConfig; workflow: WorkflowConfig } | undefined {
+export function directTeamAndWorkflowFromRun(
+	manifest: TeamRunManifest,
+	tasks: TeamTaskState[],
+	agents: AgentConfig[],
+): { team: TeamConfig; workflow: WorkflowConfig } | undefined {
 	if (!isDirectRun(manifest)) return undefined;
 	const firstTask = tasks[0];
 	const agentName = firstTask?.agent ?? (manifest.team.replace(/^direct-/, "") || "executor");
@@ -20,7 +24,13 @@ export function directTeamAndWorkflowFromRun(manifest: TeamRunManifest, tasks: T
 			description: `Direct subagent run for ${agentName}`,
 			source: "builtin",
 			filePath: "<generated>",
-			roles: [{ name: role, agent: agentName, description: agent?.description }],
+			roles: [
+				{
+					name: role,
+					agent: agentName,
+					description: agent?.description,
+				},
+			],
 			defaultWorkflow: "direct-agent",
 			workspaceMode: manifest.workspaceMode,
 		},

package/src/runtime/dwf-state-store.ts

@@ -15,7 +15,7 @@
  * are expected to be idempotent-ish.
  */
 
-import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { atomicWriteJson } from "../state/atomic-write.ts";
 import { logInternalError } from "../utils/internal-error.ts";