pi-crew 0.1.45 → 0.1.49

package/src/runtime/code-summary.ts

@@ -0,0 +1,247 @@
+/**
+ * Structural code summary — regex-based summarizer that elides function bodies,
+ * long arrays, block comments, and import groups, keeping signatures.
+ * Pure TypeScript fallback (no tree-sitter / Rust native dependency).
+ */
+
+// ── Public types ──
+
+export interface SummarySegment {
+	kind: "kept" | "elided";
+	startLine: number;
+	endLine: number;
+	/** Verbatim text for kept segments; absent for elided */
+	text?: string;
+}
+
+export interface SummaryResult {
+	language: string | null;
+	totalLines: number;
+	elided: boolean;
+	segments: SummarySegment[];
+	rendered: string;
+}
+
+export interface SummaryOptions {
+	minBodyLines?: number;    // default 4
+	minCommentLines?: number; // default 6
+}
+
+// ── Language detection ──
+
+const EXT_MAP: ReadonlyMap<string, string> = new Map([
+	[".ts", "typescript"], [".tsx", "typescript"],
+	[".js", "javascript"], [".jsx", "javascript"],
+	[".mjs", "javascript"], [".cjs", "javascript"],
+	[".py", "python"], [".rs", "rust"],
+]);
+
+export function detectLanguage(filePath: string): string | null {
+	const dot = filePath.lastIndexOf(".");
+	if (dot === -1) return null;
+	return EXT_MAP.get(filePath.slice(dot).toLowerCase()) ?? null;
+}
+
+// ── Internal range helpers ──
+
+interface Range { start: number; end: number; }
+
+function mergeRanges(ranges: Range[]): Range[] {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged: Range[] = [sorted[0]];
+	for (let i = 1; i < sorted.length; i++) {
+		const last = merged[merged.length - 1];
+		if (sorted[i].start <= last.end + 1) last.end = Math.max(last.end, sorted[i].end);
+		else merged.push({ ...sorted[i] });
+	}
+	return merged;
+}
+
+// ── Brace-based elision (TS/JS/Rust) ──
+// NOTE: This is a regex heuristic, not a parser. Braces inside string literals,
+// template strings, regex, and comments are counted, which can produce incorrect
+// elision for edge cases like `const s = "{...}"` or `${expr}`. Acceptable for
+// summaries; do not use for correctness-sensitive parsing.
+
+function findBraceRanges(lines: string[], openPattern: RegExp, minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (!openPattern.test(lines[i])) continue;
+		let depth = 0;
+		let foundOpen = false;
+		const start = i;
+		for (let j = i; j < lines.length; j++) {
+			for (const ch of lines[j]) {
+				if (ch === "{") { depth++; foundOpen = true; }
+				else if (ch === "}") { depth--; }
+			}
+			if (foundOpen && depth <= 0) {
+				if (j - start - 1 >= minBody) ranges.push({ start: start + 1, end: j - 1 });
+				break;
+			}
+		}
+	}
+	return ranges;
+}
+
+// ── TypeScript / JavaScript ──
+
+const TS_FN_SIG =
+	/^\s*(export\s+)?(async\s+)?function\s|^\s*(export\s+)?(static\s+|get\s+|set\s+|private\s+|public\s+|protected\s+|readonly\s+)*\*?\s*\w+\s*[\(<]/;
+const TS_CLASS_SIG = /^\s*(export\s+)?(default\s+)?(abstract\s+)?class\s/;
+const TS_STRUCT_SIG = /^\s*(export\s+)?(default\s+)?(const|let|var)\s+\w+\s*=\s*(\[[\s]*$|\{[\s]*$)/;
+
+function tsRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, TS_FN_SIG, minBody),
+		...findBraceRanges(lines, TS_CLASS_SIG, minBody),
+		...findBraceRanges(lines, TS_STRUCT_SIG, minBody),
+	];
+}
+
+// ── Block comments ──
+
+function blockCommentRanges(lines: string[], minComment: number): Range[] {
+	const ranges: Range[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const idx = lines[i].indexOf("/*");
+		if (idx === -1 || lines[i].includes("*/", idx + 2)) { i++; continue; }
+		const openLine = i;
+		let j = i + 1;
+		while (j < lines.length && !lines[j].includes("*/")) j++;
+		if (j < lines.length && j - openLine - 1 >= minComment)
+			ranges.push({ start: openLine + 1, end: j - 1 });
+		i = j + 1;
+	}
+	return ranges;
+}
+
+// ── Import groups ──
+
+const IMPORT_RE = /^\s*import\s/;
+const PY_IMPORT_RE = /^\s*(import\s|from\s+\S+\s+import\s)/;
+
+function importGroupRanges(lines: string[], pattern: RegExp): Range[] {
+	const groups: Array<{ start: number; end: number }> = [];
+	let gs = -1, last = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (pattern.test(lines[i])) { if (gs === -1) gs = i; last = i; }
+		else if (gs !== -1 && i > last) { groups.push({ start: gs, end: last }); gs = -1; last = -1; }
+	}
+	if (gs !== -1) groups.push({ start: gs, end: last });
+	const ranges: Range[] = [];
+	for (const g of groups) {
+		if (g.end - g.start >= 2) ranges.push({ start: g.start + 1, end: g.end - 1 });
+	}
+	return ranges;
+}
+
+// ── Python ──
+
+function pythonRanges(lines: string[], minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		const m = /^(\s*)(async\s+)?def\s/.exec(lines[i]) || /^(\s*)class\s/.exec(lines[i]);
+		if (!m) continue;
+		const base = m[1].length;
+		let bs = -1, be = -1;
+		for (let j = i + 1; j < lines.length; j++) {
+			if (lines[j].trim() === "") continue;
+			const indent = lines[j].length - lines[j].trimStart().length;
+			if (indent <= base) break;
+			if (bs === -1) bs = j;
+			be = j;
+		}
+		if (bs !== -1 && be - bs + 1 >= minBody) ranges.push({ start: bs, end: be });
+	}
+	ranges.push(...importGroupRanges(lines, PY_IMPORT_RE));
+	return ranges;
+}
+
+// ── Rust ──
+
+const RS_FN_SIG = /^\s*(pub\s+)?(async\s+)?(unsafe\s+)?fn\s/;
+const RS_STRUCT_SIG = /^\s*(pub\s+)?struct\s+\w+.*\{$/;
+const RS_ENUM_SIG = /^\s*(pub\s+)?enum\s+\w+.*\{$/;
+const RS_MOD_SIG = /^\s*(pub\s+)?mod\s+\w+.*\{$/;
+
+function rustRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, RS_FN_SIG, minBody),
+		...findBraceRanges(lines, RS_STRUCT_SIG, minBody),
+		...findBraceRanges(lines, RS_ENUM_SIG, minBody),
+		...findBraceRanges(lines, RS_MOD_SIG, minBody),
+	];
+}
+
+// ── Main entry ──
+
+function fullResult(language: string | null, totalLines: number, code: string): SummaryResult {
+	return {
+		language, totalLines, elided: false,
+		segments: [{ kind: "kept", startLine: 1, endLine: totalLines, text: code }],
+		rendered: code,
+	};
+}
+
+export function summarizeCode(
+	code: string,
+	language: string | null,
+	options?: SummaryOptions,
+): SummaryResult {
+	const minBody = options?.minBodyLines ?? 4;
+	const minComment = options?.minCommentLines ?? 6;
+
+	if (!code || code.trim() === "") {
+		return { language, totalLines: 0, elided: false, segments: [], rendered: "" };
+	}
+
+	const lines = code.split("\n");
+	const totalLines = lines.length;
+
+	if (!language) return fullResult(null, totalLines, code);
+
+	const rawRanges: Range[] = [];
+	switch (language) {
+		case "typescript":
+		case "javascript":
+			rawRanges.push(...tsRanges(lines, minBody), ...blockCommentRanges(lines, minComment), ...importGroupRanges(lines, IMPORT_RE));
+			break;
+		case "python":
+			rawRanges.push(...pythonRanges(lines, minBody));
+			break;
+		case "rust":
+			rawRanges.push(...rustRanges(lines, minBody), ...blockCommentRanges(lines, minComment));
+			break;
+		default:
+			return fullResult(language, totalLines, code);
+	}
+
+	const ranges = mergeRanges(rawRanges);
+	if (ranges.length === 0) return fullResult(language, totalLines, code);
+
+	// Build segments
+	const segments: SummarySegment[] = [];
+	let cursor = 0;
+	for (const r of ranges) {
+		if (cursor < r.start) {
+			segments.push({ kind: "kept", startLine: cursor + 1, endLine: r.start, text: lines.slice(cursor, r.start).join("\n") });
+		}
+		segments.push({ kind: "elided", startLine: r.start + 1, endLine: r.end + 1 });
+		cursor = r.end + 1;
+	}
+	if (cursor < totalLines) {
+		segments.push({ kind: "kept", startLine: cursor + 1, endLine: totalLines, text: lines.slice(cursor).join("\n") });
+	}
+
+	// Render
+	const parts: string[] = [];
+	for (const seg of segments) {
+		if (seg.kind === "kept") parts.push(seg.text ?? "");
+		else parts.push(`  ... ${seg.endLine - seg.startLine + 1} lines elided ...`);
+	}
+
+	return { language, totalLines, elided: true, segments, rendered: parts.join("\n") };
+}

package/src/runtime/crash-recovery.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { appendEvent, scanSequence } from "../state/event-log.ts";
 import { withRunLockSync } from "../state/locks.ts";
@@ -8,6 +9,8 @@ import { isWorkerHeartbeatStale } from "./worker-heartbeat.ts";
 import type { ManifestCache } from "./manifest-cache.ts";
 import { checkProcessLiveness } from "./process-status.ts";
 import { reconcileStaleRun, type ReconcileResult } from "./stale-reconciler.ts";
+import { executeHook, appendHookEvent } from "../hooks/registry.ts";
+import { activeRunEntries, unregisterActiveRun, readActiveRunRegistry } from "../state/active-run-registry.ts";
 
 export interface RecoveryPlan {
 	runId: string;
@@ -43,6 +46,14 @@ export function detectInterruptedRuns(cwd: string, manifestCache: ManifestCache,
 export async function applyRecoveryPlan(plan: RecoveryPlan, ctx: Pick<ExtensionContext, "cwd">, registry?: MetricRegistry): Promise<void> {
 	const loaded = loadRunManifestById(ctx.cwd, plan.runId);
 	if (!loaded) throw new Error(`Run '${plan.runId}' not found.`);
+
+	const hookReport = await executeHook("run_recovery", { runId: plan.runId, cwd: ctx.cwd });
+	appendHookEvent(loaded.manifest, hookReport);
+	if (hookReport.outcome === "block") {
+		appendEvent(loaded.manifest.eventsPath, { type: "crew.run.recovery_blocked", runId: plan.runId, message: `Recovery blocked by hook: ${hookReport.reason ?? "run_recovery hook blocked the operation."}`, data: { hookOutcome: "block", reason: hookReport.reason } });
+		return;
+	}
+
 	const reset = new Set(plan.resumableTasks);
 	const tasks = loaded.tasks.map((task) => reset.has(task.id) ? { ...task, status: "queued" as const, startedAt: undefined, finishedAt: undefined, error: undefined, heartbeat: undefined } : task);
 	saveRunTasks(loaded.manifest, tasks);
@@ -62,6 +73,176 @@ export function declineRecoveryPlan(plan: RecoveryPlan, ctx: Pick<ExtensionConte
  * Run 3-phase stale reconciliation on all active runs.
  * Returns results for each reconciled run.
  */
+/**
+ * Auto-cancel orphaned runs whose owner session no longer exists.
+ *
+ * When a Pi session dies (crash, force-close, Ctrl+C), `session_shutdown`
+ * does not fire and child workers are not terminated. The next Pi session
+ * must detect these orphaned runs and cancel them.
+ *
+ * Criteria for orphan detection:
+ * 1. Manifest status is "running"
+ * 2. Manifest has an `ownerSessionId` that is NOT the current session
+ * 3. The owner session's process is no longer alive (PID check)
+ * 4. No recent heartbeat activity (task heartbeat or agent progress within threshold)
+ *
+ * Returns the number of runs cancelled.
+ */
+export function cancelOrphanedRuns(
+	cwd: string,
+	manifestCache: ManifestCache,
+	currentSessionId: string,
+	staleThresholdMs = 300_000,
+	now = Date.now(),
+): { cancelled: string[]; skipped: string[] } {
+	const cancelled: string[] = [];
+	const skipped: string[] = [];
+
+	// Phase 1: Scan project-level manifests via manifestCache
+	for (const manifest of manifestCache.list(50)) {
+		if (manifest.status !== "running") continue;
+
+		// Only consider runs owned by a different session
+		const ownerId = manifest.ownerSessionId;
+		if (!ownerId || ownerId === currentSessionId) continue;
+
+		// Check if the owner process is still alive
+		const ownerPid = manifest.async?.pid;
+		if (ownerPid !== undefined && checkProcessLiveness(ownerPid).alive) {
+			skipped.push(manifest.runId);
+			continue;
+		}
+
+		// Check for recent heartbeat activity
+		const loaded = loadRunManifestById(cwd, manifest.runId);
+		if (!loaded) continue;
+
+		const hasRecentActivity = loaded.tasks.some((task) => {
+			if (task.status !== "running" && task.status !== "waiting") return false;
+			const heartbeatAt = task.heartbeat?.lastSeenAt ? new Date(task.heartbeat.lastSeenAt).getTime() : Number.NaN;
+			if (task.heartbeat?.alive !== false && Number.isFinite(heartbeatAt) && now - heartbeatAt <= staleThresholdMs) return true;
+			const activityAt = task.agentProgress?.lastActivityAt ? new Date(task.agentProgress.lastActivityAt).getTime() : Number.NaN;
+			return Number.isFinite(activityAt) && now - activityAt <= staleThresholdMs;
+		});
+
+		if (hasRecentActivity) {
+			skipped.push(manifest.runId);
+			continue;
+		}
+
+		// Orphan confirmed — cancel all running tasks
+		withRunLockSync(loaded.manifest, () => {
+			const fresh = loadRunManifestById(cwd, manifest.runId);
+			if (!fresh || fresh.manifest.status !== "running") return;
+
+			const now_iso = new Date(now).toISOString();
+			const repairedTasks = fresh.tasks.map((task) => {
+				if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+					return { ...task, status: "cancelled" as const, finishedAt: now_iso, error: `Orphaned run: owner session ${ownerId} no longer exists` };
+				}
+				return task;
+			});
+
+			saveRunTasks(fresh.manifest, repairedTasks);
+			updateRunStatus(fresh.manifest, "cancelled", `Orphaned run: owner session ${ownerId} no longer exists`);
+			appendEvent(fresh.manifest.eventsPath, { type: "crew.run.orphan_cancelled", runId: manifest.runId, message: `Auto-cancelled orphaned run (owner: ${ownerId})`, data: { ownerSessionId: ownerId, cancelledTasks: repairedTasks.filter((t) => t.status === "cancelled").length } });
+			cancelled.push(manifest.runId);
+		});
+	}
+
+	return { cancelled, skipped };
+}
+
+/**
+ * Purge the global active-run-index of entries whose manifest is no longer active.
+ *
+ * This scans every entry in active-run-index.json and removes any whose:
+ * - manifest file no longer exists, OR
+ * - manifest status is terminal (completed/failed/cancelled/blocked), OR
+ * - manifest cwd directory no longer exists (e.g. temp test dirs)
+ *
+ * Also removes entries where the manifest is still "running" but:
+ * - The cwd has been deleted (temp dir cleanup)
+ * - The async worker PID is dead AND no heartbeat for > threshold
+ *
+ * This is the **global** cleanup that cancelOrphanedRuns (project-scoped)
+ * cannot reach.
+ */
+export function purgeStaleActiveRunIndex(staleThresholdMs = 300_000, now = Date.now()): { purged: string[]; kept: string[] } {
+	const purged: string[] = [];
+	const kept: string[] = [];
+	const entries = readActiveRunRegistry();
+
+	for (const entry of entries) {
+		// 1. Manifest file gone → definitely stale
+		if (!fs.existsSync(entry.manifestPath)) {
+			unregisterActiveRun(entry.runId);
+			purged.push(entry.runId);
+			continue;
+		}
+
+		// 2. CWD gone → temp dir cleaned up
+		if (!fs.existsSync(entry.cwd)) {
+			unregisterActiveRun(entry.runId);
+			purged.push(entry.runId);
+			continue;
+		}
+
+		// 3. Read manifest status
+		let manifest: { status?: string; async?: { pid?: number }; ownerSessionId?: string } | undefined;
+		try {
+			manifest = JSON.parse(fs.readFileSync(entry.manifestPath, "utf-8"));
+		} catch {
+			unregisterActiveRun(entry.runId);
+			purged.push(entry.runId);
+			continue;
+		}
+
+		// 4. Terminal status → no longer active
+		const terminalStatuses = new Set(["completed", "failed", "cancelled", "blocked"]);
+		if (manifest && terminalStatuses.has(manifest.status ?? "")) {
+			unregisterActiveRun(entry.runId);
+			purged.push(entry.runId);
+			continue;
+		}
+
+		// 5. Still "running" — check if worker PID is dead and no heartbeat
+		if (manifest?.status === "running" && manifest.async?.pid !== undefined) {
+			const pidAlive = checkProcessLiveness(manifest.async.pid).alive;
+			if (!pidAlive) {
+				// Check age — if manifest hasn't been updated in > threshold, it's stale
+				const updatedAt = new Date(entry.updatedAt).getTime();
+				if (Number.isFinite(updatedAt) && now - updatedAt > staleThresholdMs) {
+					// Dead PID + stale update → cancel the manifest and unregister
+					try {
+						const fullLoaded = loadRunManifestById(entry.cwd, entry.runId);
+						if (fullLoaded) {
+							const now_iso = new Date(now).toISOString();
+							const repairedTasks = fullLoaded.tasks.map((task) => {
+								if (task.status === "running" || task.status === "queued" || task.status === "waiting") {
+									return { ...task, status: "cancelled" as const, finishedAt: now_iso, error: "Orphaned run: worker process dead and no recent activity" };
+								}
+								return task;
+							});
+							saveRunTasks(fullLoaded.manifest, repairedTasks);
+							updateRunStatus(fullLoaded.manifest, "cancelled", "Orphaned run: worker process dead and no recent activity");
+						}
+					} catch {
+						// Best-effort manifest cleanup
+					}
+					unregisterActiveRun(entry.runId);
+					purged.push(entry.runId);
+					continue;
+				}
+			}
+		}
+
+		kept.push(entry.runId);
+	}
+
+	return { purged, kept };
+}
+
 export function reconcileAllStaleRuns(cwd: string, manifestCache: ManifestCache, now = Date.now()): ReconcileResult[] {
 	const results: ReconcileResult[] = [];
 	for (const manifest of manifestCache.list(50)) {
@@ -75,6 +256,7 @@ export function reconcileAllStaleRuns(cwd: string, manifestCache: ManifestCache,
 			if (!fresh || fresh.manifest.status !== "running") return;
 			const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
 			if (result.repaired) {
+				if (result.repairedTasks) saveRunTasks(fresh.manifest, result.repairedTasks);
 				updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
 				appendEvent(fresh.manifest.eventsPath, { type: "crew.run.reconciled_stale", runId: manifest.runId, message: result.detail, data: { verdict: result.verdict } });
 			}

package/src/runtime/crew-agent-records.ts

@@ -61,33 +61,93 @@ export function agentOutputPath(manifest: TeamRunManifest, taskId: string): stri
 }
 
 const AGENT_READER_TTL_MS = 200;
+const ASYNC_AGENT_READER_CACHE_MAX_ENTRIES = 128;
+
+const asyncAgentReaderCache = new Map<string, { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }>();
+
+function setAsyncAgentReaderCache(filePath: string, entry: { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }): void {
+	const now = Date.now();
+	for (const [key, cached] of asyncAgentReaderCache) {
+		if (cached.expiresAt <= now && !cached.inFlight) asyncAgentReaderCache.delete(key);
+	}
+	if (asyncAgentReaderCache.has(filePath)) asyncAgentReaderCache.delete(filePath);
+	asyncAgentReaderCache.set(filePath, entry);
+	while (asyncAgentReaderCache.size > ASYNC_AGENT_READER_CACHE_MAX_ENTRIES) {
+		const oldest = asyncAgentReaderCache.keys().next().value;
+		if (!oldest) break;
+		asyncAgentReaderCache.delete(oldest);
+	}
+}
 
 export function readCrewAgents(manifest: TeamRunManifest): CrewAgentRecord[] {
 	try {
-		return readJsonFileCoalesced(agentsPath(manifest), AGENT_READER_TTL_MS, () => readJsonFile<CrewAgentRecord[]>(agentsPath(manifest)) ?? []);
+		const records = readJsonFileCoalesced(agentsPath(manifest), AGENT_READER_TTL_MS, () => readJsonFile<CrewAgentRecord[]>(agentsPath(manifest)) ?? []);
+		// Validate schema and deduplicate by id to handle concurrent write conflicts
+		const seen = new Set<string>();
+		const deduped = records.filter((r) => {
+			if (!r || typeof r.id !== "string" || typeof r.taskId !== "string") return false;
+			if (seen.has(r.id)) return false;
+			seen.add(r.id);
+			return true;
+		});
+		if (deduped.length !== records.length) {
+			// Schema mismatch or duplicates detected — save corrected state
+			saveCrewAgents(manifest, deduped);
+		}
+		return deduped;
 	} catch {
 		return [];
 	}
 }
 
 export async function readCrewAgentsAsync(manifest: TeamRunManifest): Promise<CrewAgentRecord[]> {
-	try {
-		return JSON.parse(await fs.promises.readFile(agentsPath(manifest), "utf-8")) as CrewAgentRecord[];
-	} catch {
-		return [];
-	}
+	const filePath = agentsPath(manifest);
+	const now = Date.now();
+	const cached = asyncAgentReaderCache.get(filePath);
+	if (cached && cached.expiresAt > now) return cached.records;
+	if (cached?.inFlight) return cached.inFlight;
+	const inFlight = (async (): Promise<CrewAgentRecord[]> => {
+		try {
+			const parsed = JSON.parse(await fs.promises.readFile(filePath, "utf-8")) as unknown;
+			const raw = Array.isArray(parsed) ? redactSecrets(parsed) as CrewAgentRecord[] : [];
+			// Deduplicate by id to handle concurrent write conflicts
+			const seen = new Set<string>();
+			const deduped = raw.filter((r) => {
+				if (!r || typeof r.id !== "string" || typeof r.taskId !== "string") return false;
+				if (seen.has(r.id)) return false;
+				seen.add(r.id);
+				return true;
+			});
+			if (deduped.length !== raw.length) {
+				try { saveCrewAgents(manifest, deduped); } catch { /* best-effort */ }
+			}
+			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records: deduped });
+			return deduped;
+		} catch {
+			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records: [] });
+			return [];
+		}
+	})();
+	setAsyncAgentReaderCache(filePath, { expiresAt: now + AGENT_READER_TTL_MS, records: cached?.records ?? [], inFlight });
+	return inFlight;
 }
 
 export function saveCrewAgents(manifest: TeamRunManifest, records: CrewAgentRecord[]): void {
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
-	atomicWriteJson(agentsPath(manifest), redactSecrets(records));
+	const filePath = agentsPath(manifest);
+	atomicWriteJson(filePath, redactSecrets(records));
+	asyncAgentReaderCache.delete(filePath);
 	for (const record of records) writeCrewAgentStatus(manifest, record);
 }
 
 export function upsertCrewAgent(manifest: TeamRunManifest, record: CrewAgentRecord): void {
-	const records = readCrewAgents(manifest).filter((item) => item.id !== record.id);
-	records.push(record);
-	saveCrewAgents(manifest, records);
+	// Read current state
+	const existing = readCrewAgents(manifest);
+	// Deduplicate by id: keep newer record when same id appears
+	const idIndex = new Map(existing.map((item, i) => [item.id, i]));
+	const merged: CrewAgentRecord[] = existing.map((item) => item.id === record.id ? record : item);
+	if (!idIndex.has(record.id)) merged.push(record);
+	saveCrewAgents(manifest, merged);
 	writeCrewAgentStatus(manifest, record);
 }
 

package/src/runtime/crew-agent-runtime.ts

@@ -23,6 +23,7 @@ export interface CrewAgentProgress {
 	lastActivityAt?: string;
 	activityState?: CrewActivityState;
 	failedTool?: string;
+	consecutiveFailures?: number;
 }
 
 export interface CrewAgentRecord {