pi-crew 0.10.3 → 0.10.4

package/src/extension/team-tool.ts

@@ -23,14 +23,10 @@ import { listRecentRuns } from "./run-index.ts";
 import type { PiTeamsToolResult } from "./tool-result.ts";
 
 type ExecuteTeamRunFn = typeof _executeTeamRunFn;
-let _cachedExecuteTeamRun: ExecuteTeamRunFn | undefined;
 async function executeTeamRun(...args: Parameters<ExecuteTeamRunFn>): Promise<Awaited<ReturnType<ExecuteTeamRunFn>>> {
-	if (_cachedExecuteTeamRun === undefined) {
-		// LAZY: heavy runtime — defer 1.4s import cost until team run actually executes.
-		const mod = await import("../runtime/team-runner.ts");
-		_cachedExecuteTeamRun = mod.executeTeamRun;
-	}
-	return _cachedExecuteTeamRun(...args);
+	// LAZY: heavy runtime — defer 1.4s import cost until team run actually executes.
+	const mod = await import("../runtime/team-runner.ts");
+	return mod.executeTeamRun(...args);
 }
 
 import { directTeamAndWorkflowFromRun } from "../runtime/direct-run.ts";
@@ -44,14 +40,10 @@ import { buildParentContext, formatScoped, result, type TeamContext } from "./te
 import type { handleRun as _handleRunFn } from "./team-tool/run.ts";
 
 type HandleRunFn = typeof _handleRunFn;
-let _cachedHandleRun: HandleRunFn | undefined;
 async function handleRun(...args: Parameters<HandleRunFn>): Promise<Awaited<ReturnType<HandleRunFn>>> {
-	if (_cachedHandleRun === undefined) {
-		// LAZY: run.ts pulls in spawnBackgroundTeamRun + resolveCrewRuntime; also avoids jiti import race in child-process contexts.
-		const mod = await import("./team-tool/run.ts");
-		_cachedHandleRun = mod.handleRun;
-	}
-	return _cachedHandleRun(...args);
+	// LAZY: run.ts pulls in spawnBackgroundTeamRun + resolveCrewRuntime; also avoids jiti import race in child-process contexts.
+	const mod = await import("./team-tool/run.ts");
+	return mod.handleRun(...args);
 }
 
 import { t } from "../i18n.ts";

package/src/hooks/registry.ts

@@ -179,6 +179,9 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 }
 
 export function appendHookEvent(manifest: TeamRunManifest, report: HookExecutionReport): void {
+	// REVIEW FIX (2026-09-10): reverted M2b buffered conversion — hook.executed
+	// events are read back synchronously (recovery-hooks tests, hooks audit
+	// display) and are low-frequency (per hook execution).
 	appendEvent(manifest.eventsPath, {
 		type: "hook.executed",
 		runId: manifest.runId,

package/src/prompt/scratchpad-lifecycle.ts

@@ -32,7 +32,7 @@ import * as path from "node:path";
 import { type Static, Type } from "@sinclair/typebox";
 import { defineTool, type ExtensionAPI, type ToolDefinition } from "../extension/pi-api.ts";
 import { EngineManager, type ExecuteResult } from "../runtime/scratchpad/engine.ts";
-import { appendEventFireAndForget } from "../state/event-log/event-log.ts";
+import { appendEventBuffered, appendEventFireAndForget } from "../state/event-log/event-log.ts";
 // D5/MAJOR-S1: PI_CREW_PARENT_PID + PI_CREW_GUEST build the guest's zombie-
 // backstop env (PI_CREW_KIND_ENV is already exported above).
 import { type ArtifactWriteOptions, writeArtifact } from "../state/stores/artifact-store.ts";
@@ -84,12 +84,12 @@ function emitScratchpadMetric(
 	// never break the cell. The real appendEventFireAndForget already catches
 	// async; this guard also absorbs a sync throw from a bad writer.
 	try {
-		appendEvent(eventsPath, {
+		appendEventBuffered(eventsPath, {
 			type,
 			runId,
 			taskId: env[PI_CREW_TASK_ID_ENV],
 			data,
-		});
+		}).catch((e) => logInternalError("scratchpad_lifecycle.buffered", e, `type=${type}`));
 	} catch {
 		// Metric is best-effort — drop the event, never the cell.
 	}

package/src/runtime/background-runner.ts

@@ -5,7 +5,7 @@ import { loadConfig } from "../config/config.ts";
 import { getCrewEnv } from "../config/env-vars.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
 import { withRunLockSync } from "../state/coordination/locks.ts";
-import { appendEvent, appendEventFireAndForget } from "../state/event-log/event-log.ts";
+import { appendEvent, appendEventBuffered, appendEventFireAndForget } from "../state/event-log/event-log.ts";
 import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
@@ -18,8 +18,6 @@ import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows
 import { primePeerDep } from "./peer-dep.ts";
 import type { executeTeamRun as ExecuteTeamRunFn } from "./team-runner.ts";
 
-let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
-
 /** Maximum runtime for a single background run before the watchdog force-aborts
  *  it. Prevents zombie background-runner processes when a team run hangs forever
  *  (e.g. a hung child Pi process, a stuck lock, or a test that spawns a run
@@ -33,16 +31,13 @@ const MAX_BACKGROUND_RUN_MS = (() => {
 	return Number.isFinite(env) && env > 0 ? env : 2 * 60 * 60 * 1000;
 })();
 async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
-	if (!_cachedExecuteTeamRun) {
-		// FIX (split-scope install): prime the ESM peer dep BEFORE team-runner is
-		// imported, so its transitive skill-instructions.ts can read getAgentDir()
-		// from the primed cache instead of crashing on `Cannot find module`.
-		await primePeerDep().catch(() => undefined);
-		// LAZY: avoid pulling team-runner into background-runner at module load time.
-		const mod = await import("./team-runner.ts");
-		_cachedExecuteTeamRun = mod.executeTeamRun;
-	}
-	return _cachedExecuteTeamRun(...args);
+	// FIX (split-scope install): prime the ESM peer dep BEFORE team-runner is
+	// imported, so its transitive skill-instructions.ts can read getAgentDir()
+	// from the primed cache instead of crashing on `Cannot find module`.
+	await primePeerDep().catch(() => undefined);
+	// LAZY: avoid pulling team-runner into background-runner at module load time.
+	const mod = await import("./team-runner.ts");
+	return mod.executeTeamRun(...args);
 }
 
 import { logInternalError } from "../utils/internal-error.ts";
@@ -256,11 +251,11 @@ export function startInterruptGuard(
 					/* best-effort ack — interruptHandled gate prevents re-fire */
 				}
 
-				appendEvent(manifest.eventsPath, {
+				appendEventBuffered(manifest.eventsPath, {
 					type: "async.interrupt_detected",
 					runId: manifest.runId,
 					message: "Background runner detected foreground interrupt — killing child processes and exiting.",
-				});
+				}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.interrupt_detected"));
 				// FIX: Terminate ALL child-pi processes IMMEDIATELY before exiting.
 				// Previously this was missing, causing orphaned child processes to run forever
 				// after the background-runner exited. terminateActiveChildPiProcesses sends
@@ -311,7 +306,7 @@ function setupUnhandledRejectionGuard(
 		console.error("[background-runner] Stack:", reason instanceof Error ? reason.stack : "N/A");
 		try {
 			if (state.eventsPath && state.runId) {
-				appendEvent(state.eventsPath, {
+				appendEventBuffered(state.eventsPath, {
 					type: "async.failed",
 					runId: state.runId,
 					message: `Unhandled rejection: ${message}`,
@@ -320,7 +315,7 @@ function setupUnhandledRejectionGuard(
 						stack: reason instanceof Error ? reason.stack : undefined,
 						handled: false,
 					},
-				});
+				}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.failed source=unhandledRejection"));
 			}
 		} catch (appendErr) {
 			console.error("[background-runner] Failed to write async.failed event:", appendErr);
@@ -377,12 +372,12 @@ function runCleanup(
 		console.log(`[background-runner] runCleanup: unregisterWorker error: ${errorMessage(error)}`);
 		if (eventsPath) {
 			try {
-				appendEvent(eventsPath, {
+				appendEventBuffered(eventsPath, {
 					type: "background.unregister_worker_failed",
 					runId: argValue("--run-id") ?? "unknown",
 					message: `unregisterWorker failed: ${errorMessage(error)}`,
 					data: { pid: process.pid },
-				});
+				}).catch((e) => logInternalError("background-runner.buffered", e, "type=background.unregister_worker_failed"));
 			} catch {
 				/* best-effort */
 			}
@@ -538,12 +533,12 @@ async function main(): Promise<void> {
 		const runId = argValue("--run-id");
 		if (runId && manifest.eventsPath) {
 			try {
-				appendEvent(manifest.eventsPath, {
+				appendEventBuffered(manifest.eventsPath, {
 					type: "async.sigterm_received_graceful_shutdown",
 					runId,
 					message: `SIGTERM received, graceful shutdown via abort pid=${process.pid}`,
 					data: { pid: process.pid, ppid: process.ppid },
-				});
+				}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.sigterm_received_graceful_shutdown"));
 			} catch {
 				/* best-effort */
 			}
@@ -596,12 +591,12 @@ async function main(): Promise<void> {
 			const codeStr = code === undefined ? "<none>" : String(code);
 			if (runId2 && manifest.eventsPath) {
 				try {
-					appendEvent(manifest.eventsPath, {
+					appendEventBuffered(manifest.eventsPath, {
 						type: "async.exit",
 						runId: runId2,
 						message: `Background runner exit(${codeStr}) pid=${process.pid}`,
 						data: { code, pid: process.pid },
-					});
+					}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.exit"));
 				} catch {
 					/* best-effort */
 				}
@@ -635,11 +630,11 @@ async function main(): Promise<void> {
 	// NOTE: intentionally no unref() — the guard keeps the event loop alive
 	// to prevent premature worker exit. See parent-guard.ts:86 for rationale.
 
-	appendEvent(manifest.eventsPath, {
+	appendEventBuffered(manifest.eventsPath, {
 		type: "async.started",
 		runId: manifest.runId,
 		data: { pid: process.pid },
-	});
+	}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.started"));
 	debugLog(`[background-runner] async.started written, pid=${process.pid}`);
 	writeAsyncStartMarker(manifest, {
 		pid: process.pid,
@@ -663,12 +658,12 @@ async function main(): Promise<void> {
 	const watchdogTimer = setTimeout(() => {
 		console.error(`[background-runner] WATCHDOG: run ${runId} exceeded ${MAX_BACKGROUND_RUN_MS}ms — aborting (zombie prevention)`);
 		try {
-			appendEvent(manifest.eventsPath, {
+			appendEventBuffered(manifest.eventsPath, {
 				type: "async.watchdog_fired",
 				runId,
 				message: `Run exceeded ${MAX_BACKGROUND_RUN_MS}ms and was force-aborted to prevent a zombie background-runner process.`,
 				data: { maxRunMs: MAX_BACKGROUND_RUN_MS },
-			});
+			}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.watchdog_fired"));
 		} catch {
 			/* best-effort event log */
 		}
@@ -825,12 +820,12 @@ async function main(): Promise<void> {
 				updatedAt: new Date().toISOString(),
 			};
 			await saveRunManifestAsync(manifest);
-			appendEvent(manifest.eventsPath, {
+			appendEventBuffered(manifest.eventsPath, {
 				type: "runtime.resolved",
 				runId: manifest.runId,
 				message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`,
 				data: { runtimeResolution, async: true },
-			});
+			}).catch((e) => logInternalError("background-runner.buffered", e, "type=runtime.resolved"));
 			if (runtime.safety === "blocked")
 				throw new Error(runtime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
 			const executeWorkers = runtime.kind !== "scaffold";
@@ -890,11 +885,11 @@ async function main(): Promise<void> {
 		} // close if (!earlyResult) — team-run setup+execute done; earlyResult path skips to here
 		manifest = result!.manifest;
 		tasks = result!.tasks;
-		appendEvent(manifest.eventsPath, {
+		appendEventBuffered(manifest.eventsPath, {
 			type: "async.completed",
 			runId: manifest.runId,
 			data: { status: manifest.status, tasks: tasks.length },
-		});
+		}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.completed"));
 		console.log(`[background-runner] async.completed written, status=${manifest.status}`);
 		if (manifest.status === "failed" || manifest.status === "cancelled" || manifest.status === "blocked") process.exitCode = 1;
 	} catch (error) {
@@ -915,11 +910,11 @@ async function main(): Promise<void> {
 					const fresh = loaded?.manifest ?? manifest;
 					if (fresh) {
 						manifest = updateRunStatus(fresh, "failed", message);
-						appendEvent(manifest.eventsPath, {
+						appendEventBuffered(manifest.eventsPath, {
 							type: "async.failed",
 							runId: manifest.runId,
 							message,
-						});
+						}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.failed source=updateFailed"));
 					}
 					return fresh;
 				},
@@ -988,12 +983,12 @@ try {
 		const mRunId = argValue("--run-id");
 		if (mCwd && mRunId) {
 			const mEventsPath = createRunPaths(mCwd, mRunId).eventsPath;
-			appendEvent(mEventsPath, {
+			appendEventBuffered(mEventsPath, {
 				type: "async.failed",
 				runId: mRunId,
 				message: errorMessage(err),
 				data: { stack: err instanceof Error ? err.stack : undefined },
-			});
+			}).catch((e) => logInternalError("background-runner.buffered", e, "type=async.failed source=catch"));
 		}
 	} catch {
 		/* best-effort — don't let event-write failure mask the original error */