pi-crew 0.2.20 → 0.2.22

package/src/runtime/manifest-cache.ts

@@ -157,7 +157,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 	}
 
 	function loadManifest(runId: string, rootsToCheck: string[]): CachedManifest | undefined {
-		let cached = manifestIndex.get(runId);
+		const cached = manifestIndex.get(runId);
 		if (!isSafePathId(runId)) return undefined;
 		const activeEntry = activeRunEntries().find((entry) => entry.runId === runId);
 		if (activeEntry) {
@@ -211,7 +211,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 
 
 		const runs = [...unique.values()].filter((value): value is CachedManifest => value !== undefined).map((value) => value.manifest);
-		const sorted = runs.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+		const sorted = runs.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
 		const limited = sorted.slice(0, Math.max(0, limit));
 		if (manifestIndex.size > maxEntries) {
 			const removeCount = manifestIndex.size - maxEntries;

package/src/runtime/model-fallback.ts

@@ -161,9 +161,10 @@ export function resolveModelCandidate(
 }
 
 const RETRYABLE_MODEL_FAILURE_PATTERNS = [
-	/rate\s*limit/i,
+	/rate.?limit/i,
 	/too many requests/i,
 	/\b429\b/,
+	/rate_limit_error/i,
 	/quota/i,
 	/provider.*unavailable/i,
 	/model.*unavailable/i,

package/src/runtime/phase-progress.ts

@@ -48,7 +48,7 @@ export interface RunProgress {
 // Helpers
 // ---------------------------------------------------------------------------
 
-const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "skipped"]);
+const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "skipped", "needs_attention"]);
 
 /**
  * Extract the phase label for a task.

package/src/runtime/pi-args.ts

@@ -99,8 +99,10 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 	}
 
 	if (input.agent.tools?.length) args.push("--tools", input.agent.tools.join(","));
+	// Always add --no-extensions before --extension to prevent user extensions from being auto-loaded.
+	// User extensions in ~/.pi/agent/extensions/ may fail due to missing dependencies.
+	args.push("--no-extensions");
 	if (input.agent.extensions !== undefined) {
-		args.push("--no-extensions");
 		for (const extension of [PROMPT_RUNTIME_EXTENSION_PATH, ...input.agent.extensions]) args.push("--extension", extension);
 	} else {
 		args.push("--extension", PROMPT_RUNTIME_EXTENSION_PATH);

package/src/runtime/pi-spawn.ts

@@ -160,8 +160,14 @@ export function getPiSpawnCommand(args: string[]): PiSpawnCommand {
 		}
 	}
 	if (process.platform === "win32") {
+		// Windows: resolve via resolvePiCliScript to find the bundled .js entry point
 		const script = resolvePiCliScript();
 		if (script) return { command: process.execPath, args: [script, ...args] };
 	}
+	// Linux/macOS: also resolve the full path so child processes can find 'pi' even if
+	// PATH is minimal (e.g. in detached background-runner processes). Fall back to "pi"
+	// only if resolution fails.
+	const script = resolvePiCliScript();
+	if (script) return { command: process.execPath, args: [script, ...args] };
 	return { command: "pi", args };
 }

package/src/runtime/prose-compressor.ts

@@ -17,7 +17,7 @@ const PROTECTED_PATTERNS: readonly RegExp[] = [
 	/```[\s\S]*?```/g,                                    // fenced code blocks
 	/`[^`\n]+`/g,                                         // inline code
 	/\bhttps?:\/\/\S+/gi,                                 // URLs
-	/\b[\w.-]*[\/\\][\w.\/\\\-]+/g,                       // paths with / or \
+	/\b[\w.-]*[/\\][\w./\\-]+/g,                       // paths with / or \
 	/\b[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)+\b/g,           // CONSTANT_CASE
 	/\b\w+(?:\.\w+)+\(\)/g,                               // dotted.method() calls
 	/[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*\)/g,                // function calls: name(args)

package/src/runtime/result-extractor.ts

@@ -81,7 +81,6 @@ function tryMarkerExtraction(text: string): unknown | undefined {
 					try {
 						return JSON.parse(after.slice(0, jsonEnd));
 					} catch {
-						continue;
 					}
 				}
 			}

package/src/runtime/retry-executor.ts

@@ -39,7 +39,7 @@ function isRetryable(error: Error, policy: RetryPolicy): boolean {
 }
 
 export function calculateRetryDelay(attempt: number, policy: RetryPolicy = DEFAULT_RETRY_POLICY, random = Math.random): number {
-	const base = policy.backoffMs * Math.pow(policy.exponentialFactor, Math.max(0, attempt - 1));
+	const base = policy.backoffMs * policy.exponentialFactor ** Math.max(0, attempt - 1);
 	const jitter = (random() * 2 - 1) * policy.jitterRatio * base;
 	return Math.max(0, base + jitter);
 }

package/src/runtime/runtime-resolver.ts

@@ -71,13 +71,18 @@ export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.Proc
 	if (requestedMode === "child-process") return childCaps(requestedMode);
 	// When a child-process mock is active (tests), force auto-mode to child-process where the mock is active.
 	if (requestedMode === "auto" && env.PI_TEAMS_MOCK_CHILD_PI) return childCaps(requestedMode, "PI_TEAMS_MOCK_CHILD_PI mock forces child-process runtime in auto mode.");
-	if (requestedMode === "live-session" || requestedMode === "auto") {
+	if (requestedMode === "live-session") {
 		const live = await isLiveSessionRuntimeAvailable(1500, env);
 		if (live.available) return liveCaps(requestedMode);
-		if (requestedMode === "live-session" && config.runtime?.allowChildProcessFallback === false)
+		if (config.runtime?.allowChildProcessFallback === false)
 			return scaffoldCaps(requestedMode, live.reason, "blocked");
 		return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
 	}
+	// auto mode: use child-process unless preferLiveSession is explicitly enabled
+	if (requestedMode === "auto" && config.runtime?.preferLiveSession === true) {
+		const live = await isLiveSessionRuntimeAvailable(1500, env);
+		if (live.available) return liveCaps(requestedMode);
+	}
 	return childCaps(requestedMode);
 }
 
@@ -86,7 +91,7 @@ function scaffoldCaps(requestedMode: CrewRuntimeMode, reason?: string, safety: C
 }
 
 function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
-	return { kind: "child-process", requestedMode, available: true, steer: false, resume: false, liveToolActivity: false, transcript: true, safety: "trusted", ...(reason ? { reason } : {}) };
+	return { kind: "child-process", requestedMode, available: true, steer: true, resume: false, liveToolActivity: false, transcript: true, safety: "trusted", ...(reason ? { reason } : {}) };
 }
 
 function liveCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {

package/src/runtime/skill-instructions.ts

@@ -142,7 +142,6 @@ function readSkillMarkdown(cwd: string, name: string): { path: string; source: "
 			const stat = fs.statSync(filePath);
 			return rememberSkill(cacheKey, { path: filePath, source: entry.source, content: fs.readFileSync(filePath, "utf-8"), mtimeMs: stat.mtimeMs, size: stat.size });
 		} catch {
-			continue;
 		}
 	}
 	return undefined;

package/src/runtime/stale-reconciler.ts

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { checkProcessLiveness } from "./process-status.ts";
 import { recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
@@ -30,7 +32,7 @@ function checkResultFile(
 ): { found: boolean; repaired: boolean } {
 	// Check if all tasks already have terminal status (result was written but manifest wasn't updated)
 	const allTerminal = tasks.length > 0 && tasks.every(
-		(t) => t.status === "completed" || t.status === "failed" || t.status === "cancelled" || t.status === "skipped",
+		(t) => t.status === "completed" || t.status === "failed" || t.status === "cancelled" || t.status === "skipped" || t.status === "needs_attention",
 	);
 	if (allTerminal) {
 		// Sync agent records even when tasks are already terminal
@@ -45,8 +47,12 @@ function checkResultFile(
 
 /**
  * Phase 2: Check PID liveness.
+ * Uses process.kill(pid, 0) for the authoritative check, but also checks
+ * the heartbeat file as corroborating evidence. If a heartbeat was recently
+ * written, treat the PID as alive even if process.kill returns false
+ * (handles SIGKILL race where PID hasn't been recycled yet).
  */
-function checkPidLiveness(pid: number | undefined): {
+function checkPidLiveness(pid: number | undefined, stateRoot?: string): {
 	alive: boolean;
 	detail: string;
 } {
@@ -54,6 +60,27 @@ function checkPidLiveness(pid: number | undefined): {
 		return { alive: false, detail: "no pid recorded" };
 	}
 	const liveness = checkProcessLiveness(pid);
+	// If process is alive per kill(0), we're done.
+	if (liveness.alive) return { alive: true, detail: liveness.detail };
+	// Process is dead per kill(0). Check heartbeat as corroborating evidence.
+	if (stateRoot) {
+		const heartbeatPath = path.join(stateRoot, "heartbeat.json");
+		try {
+			if (fs.existsSync(heartbeatPath)) {
+				const hb = JSON.parse(fs.readFileSync(heartbeatPath, "utf-8")) as { pid?: number; at?: number };
+				if (hb?.pid === pid && hb?.at) {
+					const ageMs = Date.now() - hb.at;
+					// Heartbeat written < 5 min ago → process was alive recently.
+					// Don't repair yet; let the next reconciliation cycle catch it.
+					if (ageMs < 5 * 60_000) {
+						return { alive: true, detail: `process dead but heartbeat ${Math.round(ageMs / 1000)}s old` };
+					}
+				}
+			}
+		} catch {
+			/* ignore — best-effort */
+		}
+	}
 	return { alive: liveness.alive, detail: liveness.detail };
 }
 
@@ -143,7 +170,7 @@ export function reconcileStaleRun(
 
 	// Phase 2: Check PID liveness
 	const pid = manifest.async?.pid;
-	const pidStatus = checkPidLiveness(pid);
+	const pidStatus = checkPidLiveness(pid, manifest.stateRoot);
 
 	if (pidStatus.detail === "no pid recorded") {
 		// No async PID may be a foreground/live run. Preserve it if task heartbeat

package/src/runtime/subagent-manager.ts

@@ -45,6 +45,8 @@ export interface SubagentRecord {
 	turnCount?: number;
 	terminated?: boolean;
 	durationMs?: number;
+	/** Lifetime token usage accumulated via message_end events. Survives compaction. */
+	lifetimeUsage?: { input: number; output: number; cacheWrite: number };
 }
 
 type SpawnRunner = (options: SubagentSpawnOptions, signal?: AbortSignal) => Promise<PiTeamsToolResult>;

package/src/runtime/task-display.ts

@@ -31,7 +31,7 @@ export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): stri
 export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
 	if (tasks.length === 0) return ["- (none)"];
 	return tasks.map((task) => {
-		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
+		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : task.status === "needs_attention" ? "⚠" : "◦";
 		const wait = waitingReason(task, tasks);
 		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
 	});

package/src/runtime/task-graph-scheduler.ts

@@ -43,7 +43,7 @@ function withQueue(task: TeamTaskState, index: TaskGraphIndex): TeamTaskState {
 	if (task.status === "running") {
 		return { ...task, graph: task.graph ? { ...task.graph, queue: "running" } : task.graph };
 	}
-	if (task.status === "completed" || task.status === "skipped") {
+	if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
 		return { ...task, graph: task.graph ? { ...task.graph, queue: "done" } : task.graph };
 	}
 	return { ...task, graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph };

package/src/runtime/task-runner/live-executor.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import type { AgentConfig } from "../../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../../config/config.ts";
 import { writeArtifact } from "../../state/artifact-store.ts";
@@ -7,6 +8,7 @@ import { loadRunManifestById } from "../../state/state-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../worker-heartbeat.ts";
 import { createStartupEvidence, type WorkerStartupEvidence } from "../worker-startup.ts";
 import { runLiveSessionTask } from "../live-session-runtime.ts";
 import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "../progress-event-coalescer.ts";
@@ -64,6 +66,7 @@ export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskO
 	});
 	let lastAgentRecordPersistedAt = 0;
 	let lastRunProgressPersistedAt = 0;
+	let lastHeartbeatPersistedAt = 0;
 	let lastRunProgressSummary: ProgressEventSummary | undefined;
 	const persistLiveProgress = (event: unknown, force = false): void => {
 		if (!isCurrent()) return;
@@ -72,6 +75,18 @@ export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskO
 			upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
 			lastAgentRecordPersistedAt = now;
 		}
+		// Bug #5 fix: also persist heartbeat to tasks.json so heartbeat-watcher can detect live-session activity
+		if (force || now - lastHeartbeatPersistedAt >= 1000) {
+			task = {
+				...task,
+				heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id)),
+			};
+			tasks = updateTask(tasks, task);
+			// Persist to tasks.json using the same pattern as task-runner.ts
+			const tasksPath = path.join(manifest.stateRoot, "tasks.json");
+			try { fs.writeFileSync(tasksPath, JSON.stringify({ ...loaded, tasks }, null, 2)); } catch {}
+			lastHeartbeatPersistedAt = now;
+		}
 		const summary = progressEventSummary(task, event);
 		const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
 		if (decision.shouldAppend) {

package/src/runtime/task-runner/tail-read.ts

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+
+/**
+ * Read the tail of a file, capped at maxBytes.
+ * If the file exceeds maxBytes, reads only the last maxBytes and snaps
+ * to the nearest newline boundary to avoid partial JSONL lines.
+ */
+export function tailReadWithLineSnap(
+	filePath: string,
+	maxBytes: number,
+	fallbackContent: string,
+): string {
+	if (!fs.existsSync(filePath)) return fallbackContent;
+	const stat = fs.statSync(filePath);
+	if (stat.size <= maxBytes) return fs.readFileSync(filePath, "utf-8");
+	const fd = fs.openSync(filePath, "r");
+	try {
+		const buf = Buffer.alloc(maxBytes);
+		const bytesRead = fs.readSync(fd, buf, 0, maxBytes, stat.size - maxBytes);
+		const raw = buf.slice(0, bytesRead).toString("utf-8");
+		const firstNewline = raw.indexOf("\n");
+		return firstNewline >= 0 ? raw.slice(firstNewline + 1) : raw;
+	} finally {
+		fs.closeSync(fd);
+	}
+}