pi-crew 0.2.7 → 0.2.9

package/agents/verifier.md

@@ -6,10 +6,10 @@ systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false
 tools: read, grep, find, ls, bash
-maxTurns: 6
+maxTurns: 15
 ---
 
-You are a verification specialist. Your job is to run tests ONCE, cache the results, then analyze against findings. You have at most **6 turns**.
+You are a verification specialist. Your job is to run tests ONCE, cache the results, then analyze against findings. You have at most **15 turns**.
 
 ## Strategy
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/config/defaults.ts

@@ -14,7 +14,7 @@ export const DEFAULT_CHILD_PI = {
 
 export const DEFAULT_LIVE_SESSION = {
 	/** Maximum wall-clock time for a single live-session task before abort (ms). */
-	responseTimeoutMs: 5 * 60_000,
+	responseTimeoutMs: 10 * 60_000,  // 10 minutes - increased from 5min for complex verification
 	/** Maximum yield reminder attempts before accepting no-yield. */
 	maxYieldRetries: 3,
 	/** Polling interval for session idle check during yield enforcement (ms). */

package/src/runtime/async-runner.ts

@@ -120,11 +120,18 @@ export interface SpawnBackgroundTeamRunResult {
 }
 
 export function buildBackgroundSpawnOptions(manifest: TeamRunManifest, logFd: number): SpawnOptions {
+	// NOTE: Do NOT set PI_CREW_PARENT_PID for the background runner.
+	// The background runner is a top-level worker spawned by the team tool.
+	// When the team tool finishes, its process exits, and the background runner
+	// would incorrectly detect a "dead parent" and self-terminate.
+	// Child workers spawned BY the background runner will have the background
+	// runner as their parent, so they correctly die when the runner exits.
+	const { PI_CREW_PARENT_PID: _, ...envWithoutParentPid } = process.env;
 	return {
 		cwd: manifest.cwd,
 		detached: true,
 		stdio: ["ignore", logFd, logFd],
-		env: { ...process.env, PI_CREW_PARENT_PID: String(process.pid) },
+		env: envWithoutParentPid,
 		windowsHide: true,
 	};
 }

package/src/runtime/background-runner.ts

@@ -58,6 +58,36 @@ function startInterruptGuard(manifest: { runId: string; stateRoot: string; event
 	return () => clearInterval(interval);
 }
 
+/**
+ * CRITICAL: Node.js v24 throws on unhandled rejections by default.
+ * Without this handler, any unhandled promise rejection (e.g., from cleanupTempDir,
+ * terminateLiveAgentsForRun, or other async cleanup) will crash the background runner
+ * BEFORE async.completed is written to the event log.
+ * This causes the async notifier to falsely detect a stuck run after quietMs expires.
+ */
+function setupUnhandledRejectionGuard(state: { cwd?: string; runId?: string; eventsPath?: string }): void {
+	process.on("unhandledRejection", (reason, promise) => {
+		const message = reason instanceof Error ? reason.message : String(reason);
+		console.error("[background-runner] UNHANDLED REJECTION:", reason);
+		try {
+			// Try to write async.failed event if we have the necessary state
+			if (state.eventsPath && state.runId) {
+				appendEvent(state.eventsPath, {
+					type: "async.failed",
+					runId: state.runId,
+					message: `Unhandled rejection: ${message}`,
+					data: { reason: String(reason), handled: false },
+				});
+			}
+		} catch (appendErr) {
+			console.error("[background-runner] Failed to write async.failed event:", appendErr);
+		}
+		process.exitCode = 1;
+		// Give async operations a moment to flush before exit
+		setTimeout(() => process.exit(1), 100);
+	});
+}
+
 async function main(): Promise<void> {
 	// Scrub macOS malloc vars BEFORE anything else — must be clean for all child processes
 	scrubProcessEnv();
@@ -73,6 +103,12 @@ async function main(): Promise<void> {
 	const loaded = loadRunManifestById(cwd, runId);
 	if (!loaded) throw new Error(`Run '${runId}' not found.`);
 	let { manifest, tasks } = loaded;
+
+	// Setup unhandled rejection guard EARLY — must be before any async operations
+	// that might produce unhandled rejections during cleanup.
+	const rejectionGuardState = { cwd, runId, eventsPath: loaded.manifest.eventsPath };
+	setupUnhandledRejectionGuard(rejectionGuardState);
+
 	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
 	writeAsyncStartMarker(manifest, { pid: process.pid, startedAt: new Date().toISOString() });
 	const stopInterruptGuard = startInterruptGuard(manifest);