pi-crew 0.2.6 → 0.2.8

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.6",
+  "version": "0.2.8",
   "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/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);

package/src/runtime/process-status.ts

@@ -8,7 +8,13 @@ export interface ProcessLiveness {
 	detail: string;
 }
 
-const ORPHANED_ACTIVE_RUN_MS = 10 * 60 * 1000;
+/**
+ * How long (ms) a foreground team run with status "running" but no active agents
+ * survives before being flagged as orphaned. Reduced from 10min to 2min to
+ * improve UX: stuck foreground runs (e.g. planner with 0 tool calls) no longer
+ * linger for 10min before the dashboard shows them as stale.
+ */
+const ORPHANED_ACTIVE_RUN_MS = 2 * 60 * 1000;
 /** How long a completed run stays visible in the widget after completion. */
 const COMPLETED_VISIBILITY_GRACE_MS = 8000;
 /** Maximum age (ms) for an active run before it's considered stale.
@@ -39,13 +45,35 @@ export function isFinishedRunStatus(status: string): boolean {
 	return status === "completed" || status === "failed" || status === "cancelled" || status === "blocked";
 }
 
+/**
+ * Secondary threshold: runs that have been "running" for more than this without
+ * any active agents (all queued, no progress) are also considered orphaned.
+ * This catches foreground team runs where the planner got stuck with 0 tool calls.
+ */
+const ORPHANED_NO_PROGRESS_MS = 5 * 60 * 1000;
+
 export function isLikelyOrphanedActiveRun(run: TeamRunManifest, agents: CrewAgentRecord[] = [], now = Date.now(), staleMs = ORPHANED_ACTIVE_RUN_MS): boolean {
 	if (!isActiveRunStatus(run.status)) return false;
 	if (run.async?.pid !== undefined) return false;
 	const updatedAt = new Date(run.updatedAt).getTime();
-	if (!Number.isFinite(updatedAt) || now - updatedAt < staleMs) return false;
-	if (agents.length === 0) return run.summary === "Creating workflow prompts and placeholder results.";
-	return agents.every((agent) => agent.status === "queued" && !agent.completedAt && !agent.progress);
+	if (!Number.isFinite(updatedAt)) return false;
+
+	// Primary check: run hasn't been updated in a while
+	if (now - updatedAt >= staleMs) {
+		if (agents.length === 0) return run.summary === "Creating workflow prompts and placeholder results.";
+		return agents.every((agent) => agent.status === "queued" && !agent.completedAt && !agent.progress);
+	}
+
+	// Secondary check: run has been running without any progress for too long
+	if (now - updatedAt >= ORPHANED_NO_PROGRESS_MS) {
+		// If no agent is "running" or has made progress, the run is likely stuck
+		const hasActiveAgent = agents.some((agent) => agent.status === "running" || agent.progress || agent.toolUses);
+		if (!hasActiveAgent && agents.length > 0) {
+			return true;
+		}
+	}
+
+	return false;
 }
 
 function hasDurableActiveAgentEvidence(agent: CrewAgentRecord): boolean {