pi-crew 0.11.42 → 0.11.44

package/package.json

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

package/src/extension/session-summary.ts

@@ -1,9 +1,34 @@
+import { existsSync, readFileSync } from "node:fs";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
-import { isDisplayActiveRun } from "../runtime/process-status.ts";
+import { heartbeatLiveForDisplay, isDisplayActiveRun } from "../runtime/process-status.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
 import { extractSessionId } from "../utils/session-utils.ts";
 import { listRuns } from "./run-index.ts";
 
+/** Tasks-read TTL for the one-shot toast's heartbeat check (coalesced, live-run-sidebar pattern). */
+const SUMMARY_TASKS_READ_TTL_MS = 1000;
+
+/**
+ * Wave 16 (residual render wiring, GAP-4): coalesced tasks.json read for the
+ * active-runs toast — clones agents-jobs-browser's readLegacyRunTasks. Returns
+ * undefined on unreadable so a broken tasks.json can NEVER fabricate liveness
+ * evidence (fail-closed).
+ */
+function readSummaryRunTasks(run: TeamRunManifest): TeamTaskState[] | undefined {
+	const parse = (): TeamTaskState[] => {
+		if (!existsSync(run.tasksPath)) return [];
+		const parsed = JSON.parse(readFileSync(run.tasksPath, "utf-8")) as unknown;
+		return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
+	};
+	try {
+		return readJsonFileCoalesced(run.tasksPath, SUMMARY_TASKS_READ_TTL_MS, parse);
+	} catch {
+		return undefined;
+	}
+}
+
 export function notifyActiveRuns(ctx: ExtensionContext): void {
 	const sid = extractSessionId(ctx);
 	const active = listRuns(ctx.cwd)
@@ -15,7 +40,12 @@ export function notifyActiveRuns(ctx: ExtensionContext): void {
 			// Use the same display filter as the widget/powerbar — runs without
 			// real agent evidence (e.g. integration test fixtures) must not appear.
 			const agents = readCrewAgents(run);
-			return isDisplayActiveRun(run, agents);
+			if (isDisplayActiveRun(run, agents)) return true;
+			// Wave 16: this is a ONE-SHOT toast, so the lazy coalesced tasks read is
+			// in-pattern I/O — fetched ONLY when the display predicate is about to
+			// call the run inactive, so a manifest frozen mid-long-tool (fresh task
+			// heartbeats, no agent progress) still gets advertised.
+			return heartbeatLiveForDisplay(run, readSummaryRunTasks(run));
 		})
 		.slice(0, 5);
 	if (active.length === 0) return;

package/src/extension/team-tool/health-monitor.ts

@@ -5,7 +5,12 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
-import { hasStaleAsyncProcess, isActiveRunStatus, isLikelyOrphanedActiveRun } from "../../runtime/process-status.ts";
+import {
+	hasFreshTaskHeartbeatEvidence,
+	hasStaleAsyncProcess,
+	isActiveRunStatus,
+	isLikelyOrphanedActiveRun,
+} from "../../runtime/process-status.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { loadTasksWithRecovery } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
@@ -374,10 +379,15 @@ export function buildHealthReport(
 			continue;
 		}
 
-		// 3. Stuck task detection for active runs
+		// 3. Stuck task detection for active runs. Wave 16 (residual render
+		// wiring): the tasks loaded here are HOISTED — step 6 reuses them so the
+		// orphan guard consults fresh task heartbeats with ZERO extra disk reads
+		// (parity with run-dashboard's stale predicate).
+		let tasks: TeamTaskState[] | undefined;
 		if (isActiveRunStatus(run.status)) {
-			const stuck = detectStuckTasks(run, now);
-			allStuck.push(...stuck);
+			const loaded = readRunTasks(run.stateRoot);
+			tasks = loaded;
+			allStuck.push(...stuckTasksFromRecords(loaded, run.runId, now));
 		}
 
 		// 4. Only check orphan status for active runs
@@ -393,9 +403,12 @@ export function buildHealthReport(
 			continue;
 		}
 
-		// 6. Orphaned: non-async active run with no recent update
+		// 6. Orphaned: non-async active run with no recent update. Wave 16: a
+		// run whose manifest froze mid-long-tool (worker busy, event-driven
+		// writes paused) keeps stamping task heartbeats — fresh evidence
+		// suppresses the stale-no-progress label (run-dashboard parity).
 		const agents = readCrewAgents(run as TeamRunManifest);
-		if (isLikelyOrphanedActiveRun(run as TeamRunManifest, agents, now)) {
+		if (isLikelyOrphanedActiveRun(run as TeamRunManifest, agents, now) && !hasFreshTaskHeartbeatEvidence(tasks, now)) {
 			orphaned.push({
 				runId: run.runId,
 				reason: "stale-no-progress",

package/src/runtime/process-status.ts

@@ -1,4 +1,4 @@
-import type { TeamRunManifest } from "../state/types.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
 
 export { hasAsyncStartMarker } from "./async-marker.ts";
@@ -92,6 +92,49 @@ export function hasRecentAgentActivityEvidence(agent: CrewAgentRecord, now = Dat
 	return Number.isFinite(at) && now - at < livenessMs;
 }
 
+/**
+ * Wave 15 (F1, GAP-0): does any running/waiting task carry FRESH live
+ * evidence — a `heartbeat.lastSeenAt` (with `alive !== false`) or the
+ * `agentProgress.lastActivityAt` fallback — within `ttlMs`? Behavioral
+ * mirror of the watchdog's private helper (foreground-watchdog.ts) and
+ * hasRecentActiveEvidence (stale-reconciler.ts), so watchdog, reconciler
+ * and display stop growing a third divergent private copy. PURE (GAP-4:
+ * the shared display predicates keep their signatures — call sites that
+ * already hold the tasks OR this in). Default TTL 5 min keeps the constant
+ * family aligned (AGENT_ACTIVITY_LIVENESS_MS = TASK_HEARTBEAT_EVIDENCE_MS
+ * = ACTIVE_EVIDENCE_TTL_MS). Undefined/empty/all-terminal ⇒ false.
+ */
+export function hasFreshTaskHeartbeatEvidence(
+	tasks: TeamTaskState[] | undefined,
+	now = Date.now(),
+	ttlMs = AGENT_ACTIVITY_LIVENESS_MS,
+): boolean {
+	if (!Array.isArray(tasks)) return false;
+	return 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 <= ttlMs) return true;
+		const activityAt = task.agentProgress?.lastActivityAt ? new Date(task.agentProgress.lastActivityAt).getTime() : Number.NaN;
+		return Number.isFinite(activityAt) && now - activityAt <= ttlMs;
+	});
+}
+
+/**
+ * Wave 16 (residual render wiring, GAP-4): tight heartbeat-liveness guard for
+ * ACTIVE display — mirrors the orphan predicate's own preconditions (active
+ * status, non-async) so a terminal or async run is never resurrected by a
+ * heartbeat. A healthy direct run mid-long-tool freezes manifest `updatedAt`
+ * and agent progress (event-driven writes) but keeps stamping
+ * `task.heartbeat.lastSeenAt`, so fresh evidence means the run is alive.
+ * Single home for the guard that run-dashboard previously kept private and
+ * agents-jobs-browser inlined; call sites OR this in ONLY — every non-stale
+ * branch and layout stays untouched. PURE: takes the tasks the caller already
+ * holds in scope (no disk read here).
+ */
+export function heartbeatLiveForDisplay(run: TeamRunManifest, tasks: TeamTaskState[] | undefined, now = Date.now()): boolean {
+	return isActiveRunStatus(run.status) && !run.async && hasFreshTaskHeartbeatEvidence(tasks, now);
+}
+
 export function isLikelyOrphanedActiveRun(
 	run: TeamRunManifest,
 	agents: CrewAgentRecord[] = [],

package/src/ui/agents-jobs-browser.ts

@@ -49,7 +49,7 @@
  * dashboard overlay, so headless sessions never reach it.
  */
 
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { matchesKey } from "@earendil-works/pi-tui";
@@ -60,13 +60,14 @@ import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import type { LiveAgentHandle } from "../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import { createManifestCache } from "../runtime/manifest-cache.ts";
-import { isDisplayActiveRun } from "../runtime/process-status.ts";
+import { heartbeatLiveForDisplay, isDisplayActiveRun } from "../runtime/process-status.ts";
 import type { ScheduledJob } from "../runtime/scheduling/scheduler.ts";
 import { surfaceGateEnvSnapshot } from "../runtime/surface/resolve-surface.ts";
 import { getTaskUsage } from "../runtime/usage-tracker.ts";
 import { readJsonFile } from "../state/atomic-write.ts";
 import { loadRunManifestById } from "../state/stores/state-store.ts";
-import type { TeamRunManifest } from "../state/types.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { formatRelativeTime } from "../utils/relative-time.ts";
 import { pad, sanitizeLine, truncate, visibleWidth } from "../utils/visual.ts";
@@ -202,6 +203,28 @@ function watchAgentTranscriptScript(): string | undefined {
 	return candidates.find((c) => existsSync(c));
 }
 
+/** Tasks-read TTL for the legacy-discovery heartbeat check (coalesced, live-run-sidebar pattern). */
+const LEGACY_TASKS_READ_TTL_MS = 1000;
+
+/**
+ * Wave 15 (F2, GAP-0): coalesced tasks.json read for the legacy-discovery
+ * loop — mirrors run-dashboard/live-run-sidebar's readRunTasks. Returns
+ * undefined on unreadable so a broken tasks.json can NEVER fabricate
+ * liveness evidence (fail-closed).
+ */
+function readLegacyRunTasks(run: TeamRunManifest): TeamTaskState[] | undefined {
+	const parse = (): TeamTaskState[] => {
+		if (!existsSync(run.tasksPath)) return [];
+		const parsed = JSON.parse(readFileSync(run.tasksPath, "utf-8")) as unknown;
+		return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
+	};
+	try {
+		return readJsonFileCoalesced(run.tasksPath, LEGACY_TASKS_READ_TTL_MS, parse);
+	} catch {
+		return undefined;
+	}
+}
+
 /** tok/s for record-based entries (no live handle in this process). */
 function recordTokPerSec(record: CrewAgentRecord, nowMs: number): number | undefined {
 	if (record.status !== "running") return undefined;
@@ -476,7 +499,13 @@ export class AgentsJobsBrowser {
 				if (run.status !== "running" && run.status !== "queued") continue;
 				try {
 					const agents = readCrewAgents(run);
-					if (isDisplayActiveRun(run, agents, nowMs)) runs.push({ run, agents });
+					// Wave 15 (F2, GAP-0): tight heartbeat guard — a legacy-uncovered run
+					// whose manifest froze mid-long-tool stays listed while its task
+					// heartbeats are fresh (this loop already does per-run I/O — one more
+					// coalesced read is in-pattern). Terminal/async runs are never
+					// resurrected (isActiveRunStatus && !run.async).
+					const heartbeatLive = heartbeatLiveForDisplay(run, readLegacyRunTasks(run), nowMs);
+					if (isDisplayActiveRun(run, agents, nowMs) || heartbeatLive) runs.push({ run, agents });
 				} catch {
 					/* unreadable — skip */
 				}

package/src/ui/powerbar-publisher.ts

@@ -5,7 +5,7 @@ import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { listLiveAgents, listLiveAgentsByWorkspace } from "../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
-import { isDisplayActiveRun } from "../runtime/process-status.ts";
+import { heartbeatLiveForDisplay, isDisplayActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
@@ -307,7 +307,11 @@ class PowerbarPublisher {
 				}
 				return { run, agents, tasks: readTasks(run.tasksPath), snapshot };
 			})
-			.filter((item) => isDisplayActiveRun(item.run, item.agents));
+			// Wave 16 (residual render wiring): item.tasks is already in scope
+			// (snapshot.tasks | readTasks fallback) — OR-ing the heartbeat guard in
+			// adds ZERO extra disk reads; a frozen-manifest run stays in the
+			// powerbar while its task heartbeats stay fresh.
+			.filter((item) => isDisplayActiveRun(item.run, item.agents) || heartbeatLiveForDisplay(item.run, item.tasks));
 		if (!active.length) {
 			this.#lastActiveKey = undefined;
 			this.#lastProgressKey = undefined;

package/src/ui/run-dashboard.ts

@@ -10,7 +10,7 @@ import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { getLiveAgentContextPercent } from "../runtime/live-session/live-agent-manager.ts";
 import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
-import { isActiveRunStatus, isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
+import { heartbeatLiveForDisplay, isActiveRunStatus, isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
 import type { ScheduledJob } from "../runtime/scheduling/scheduler.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -467,7 +467,9 @@ function runLabel(
 	resolve?: SnapshotResolver,
 ): string {
 	const agents = agentsFor(run, snapshotCache, resolve);
-	const stale = isLikelyOrphanedActiveRun(run, agents);
+	// Wave 15 (F2): a stale-manifest verdict is VETOED by fresh task-heartbeat
+	// evidence (lazy read — only consulted when the orphan predicate fires).
+	const stale = isLikelyOrphanedActiveRun(run, agents) && !heartbeatLiveForDisplay(run, readRunTasks(run, snapshotCache, resolve));
 	const running = agents.find((agent) => agent.status === "running");
 	const queued = agents.find((agent) => agent.status === "queued");
 	const step = stale
@@ -523,7 +525,12 @@ function resolveRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache,
 		const snapshot = resolve ? resolve(run) : snapshotFor(run, snapshotCache);
 		const agents = snapshot?.agents ?? agentsFor(run, snapshotCache, resolve);
 		const displayRun = snapshot?.manifest ?? run;
-		const status: RunStatus = isLikelyOrphanedActiveRun(displayRun, agents) ? "stale" : (displayRun.status as RunStatus);
+		// Wave 15 (F2): fresh task heartbeats veto the "stale" label.
+		const status: RunStatus =
+			isLikelyOrphanedActiveRun(displayRun, agents) &&
+			!heartbeatLiveForDisplay(displayRun, snapshot?.tasks ?? readRunTasks(run, snapshotCache, resolve))
+				? "stale"
+				: (displayRun.status as RunStatus);
 		map.set(run.runId, { manifest: run, snapshot, agents, status });
 	}
 	return map;
@@ -536,12 +543,19 @@ function groupedRuns(
 ): Array<{ label: string; run?: TeamRunManifest }> {
 	const resolved = resolveRuns(runs, snapshotCache, resolve);
 	const rows: Array<{ label: string; run?: TeamRunManifest }> = [];
-	const active = runs.filter((run) =>
-		isDisplayActiveRun(resolved.get(run.runId)?.snapshot?.manifest ?? run, resolved.get(run.runId)?.agents ?? []),
-	);
-	const rest = runs.filter(
-		(run) => !isDisplayActiveRun(resolved.get(run.runId)?.snapshot?.manifest ?? run, resolved.get(run.runId)?.agents ?? []),
-	);
+	// Wave 15 (F2): a run with fresh task-heartbeat evidence stays display-active
+	// even when the manifest froze mid-long-tool (tight guard — never resurrects
+	// terminal/async runs).
+	const displayActive = (run: TeamRunManifest): boolean => {
+		const entry = resolved.get(run.runId);
+		const displayRun = entry?.snapshot?.manifest ?? run;
+		return (
+			isDisplayActiveRun(displayRun, entry?.agents ?? []) ||
+			heartbeatLiveForDisplay(displayRun, entry?.snapshot?.tasks ?? readRunTasks(run, snapshotCache, resolve))
+		);
+	};
+	const active = runs.filter((run) => displayActive(run));
+	const rest = runs.filter((run) => !displayActive(run));
 	if (active.length) rows.push({ label: "Active" }, ...active.map((run) => ({ label: run.runId, run })));
 	if (rest.length) rows.push({ label: "Recent" }, ...rest.map((run) => ({ label: run.runId, run })));
 	return rows;
@@ -754,7 +768,10 @@ export class RunDashboard implements DashboardComponent {
 				const snapshot = resolve ? resolve(run) : snapshotFor(run, this.options.snapshotCache);
 				const displayRun = snapshot?.manifest ?? run;
 				const agents = snapshot?.agents ?? agentsFor(run, this.options.snapshotCache, resolve);
-				const stale = isLikelyOrphanedActiveRun(displayRun, agents);
+				// Wave 15 (F2): fresh task heartbeats veto the "stale" label.
+				const stale =
+					isLikelyOrphanedActiveRun(displayRun, agents) &&
+					!heartbeatLiveForDisplay(displayRun, snapshot?.tasks ?? readRunTasks(run, this.options.snapshotCache, resolve));
 				const status: RunStatus = stale ? "stale" : (displayRun.status as RunStatus);
 				if (status === "running" || agents.some((agent) => agent.status === "running")) hasRunning = true;
 				return snapshot?.signature ?? `${displayRun.runId}:${displayRun.status}:${displayRun.updatedAt}:${status}`;
@@ -963,7 +980,15 @@ export class RunDashboard implements DashboardComponent {
 							const snap = snapshotOnce(rowItem.run);
 							const run = snap?.manifest ?? rowItem.run;
 							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache, snapshotOnce);
-							const status: RunStatus = isLikelyOrphanedActiveRun(run, agents) ? "stale" : (run.status as RunStatus);
+							// Wave 15 (F2): fresh task heartbeats veto the "stale" label (status line).
+							const status: RunStatus =
+								isLikelyOrphanedActiveRun(run, agents) &&
+								!heartbeatLiveForDisplay(
+									run,
+									snap?.tasks ?? readRunTasks(rowItem.run, this.options.snapshotCache, snapshotOnce),
+								)
+									? "stale"
+									: (run.status as RunStatus);
 							const label = runLabel(run, idx === this.selected, this.options.snapshotCache, budget, snapshotOnce);
 							lines.push(row(applyStatusColor(this.theme, status, label)));
 						}
@@ -977,7 +1002,15 @@ export class RunDashboard implements DashboardComponent {
 							const snap = snapshotOnce(rowItem.run);
 							const run = snap?.manifest ?? rowItem.run;
 							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache, snapshotOnce);
-							const status: RunStatus = isLikelyOrphanedActiveRun(run, agents) ? "stale" : (run.status as RunStatus);
+							// Wave 15 (F2): fresh task heartbeats veto the "stale" label (windowed status line).
+							const status: RunStatus =
+								isLikelyOrphanedActiveRun(run, agents) &&
+								!heartbeatLiveForDisplay(
+									run,
+									snap?.tasks ?? readRunTasks(rowItem.run, this.options.snapshotCache, snapshotOnce),
+								)
+									? "stale"
+									: (run.status as RunStatus);
 							const label = runLabel(run, gi === this.selected, this.options.snapshotCache, budget, snapshotOnce);
 							lines.push(row(applyStatusColor(this.theme, status, label)));
 						}
@@ -996,8 +1029,12 @@ export class RunDashboard implements DashboardComponent {
 						const snap = snapshotOnce(selectedRun);
 						const r = snap?.manifest ?? selectedRun;
 						const agents = snap?.agents ?? agentsFor(selectedRun, this.options.snapshotCache, snapshotOnce);
-						const statusStr: RunStatus = isLikelyOrphanedActiveRun(r, agents) ? "stale" : (r.status as RunStatus);
 						const selectedTasks = snap?.tasks ?? readRunTasks(r, this.options.snapshotCache, snapshotOnce);
+						// Wave 15 (F2): fresh task heartbeats veto the "stale" label (detail header).
+						const statusStr: RunStatus =
+							isLikelyOrphanedActiveRun(r, agents) && !heartbeatLiveForDisplay(r, selectedTasks)
+								? "stale"
+								: (r.status as RunStatus);
 						lines.push(section("run"));
 						lines.push(row(`${fg("accent", "▸")} ${truncate(sanitizeUntrustedLine(r.goal), budget - 4)}`));
 						// L-2: surface the failure/cancellation reason inline for terminal runs.

package/src/ui/widget/widget-model.ts

@@ -9,7 +9,7 @@ import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import { evictStaleLiveAgentHandles } from "../../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../../runtime/manifest-cache.ts";
-import { isDisplayActiveRun } from "../../runtime/process-status.ts";
+import { heartbeatLiveForDisplay, isDisplayActiveRun } from "../../runtime/process-status.ts";
 import { reconcileAllStaleRuns } from "../../runtime/recovery/crash-recovery.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { goalFlagSuffix } from "../goal-flag.ts";
@@ -61,42 +61,55 @@ export function activeWidgetRuns(
 	// workspaceId stays in scope: crash recovery below is still session-scoped.
 	const runs = preloadedManifests ?? (manifestCache ? manifestCache.list(20) : listRecentRuns(cwd, 20));
 
-	return runs
-		.map((run) => {
-			try {
-				// U7 (spec 2026-10-09): prefer the committed-state read when the
-				// cache exposes it. `readForRender` returns the SAME cached
-				// snapshot `get` would (identical render — parity), but a lapsed
-				// TTL schedules the coalesced ASYNC refresh (80ms batch → stamp
-				// check → rebuild only when files changed) instead of waiting for
-				// an external poller to notice. Structural check: legacy callers
-				// and test doubles may implement only `get`.
-				const committed = snapshotCache as
-					| { readForRender?: (runId: string) => RunUiSnapshot | undefined; get?: (runId: string) => RunUiSnapshot | undefined }
-					| undefined;
-				const snapshot =
-					typeof committed?.readForRender === "function" ? committed.readForRender(run.runId) : snapshotCache?.get(run.runId);
-				if (snapshot) {
-					return {
-						run: snapshot.manifest,
-						agents: snapshot.agents,
-						snapshot,
-					};
+	return (
+		runs
+			.map((run) => {
+				try {
+					// U7 (spec 2026-10-09): prefer the committed-state read when the
+					// cache exposes it. `readForRender` returns the SAME cached
+					// snapshot `get` would (identical render — parity), but a lapsed
+					// TTL schedules the coalesced ASYNC refresh (80ms batch → stamp
+					// check → rebuild only when files changed) instead of waiting for
+					// an external poller to notice. Structural check: legacy callers
+					// and test doubles may implement only `get`.
+					const committed = snapshotCache as
+						| {
+								readForRender?: (runId: string) => RunUiSnapshot | undefined;
+								get?: (runId: string) => RunUiSnapshot | undefined;
+						  }
+						| undefined;
+					const snapshot =
+						typeof committed?.readForRender === "function" ? committed.readForRender(run.runId) : snapshotCache?.get(run.runId);
+					if (snapshot) {
+						return {
+							run: snapshot.manifest,
+							agents: snapshot.agents,
+							snapshot,
+						};
+					}
+					// P0-6: render from snapshots only — never read disk on every
+					// render tick. When the snapshot cache is provided but hasn't
+					// populated yet (first frame after `updateCrewWidget`), drop the
+					// run from the result so the widget paints "(loading…)" instead
+					// of calling `agentsFor(run) → readCrewAgents`. Legacy callers
+					// (no snapshotCache) keep the disk-read fallback for tests/dev.
+					if (snapshotCache) return null;
+					return { run, agents: agentsFor(run) };
+				} catch {
+					if (snapshotCache) return null;
+					return { run, agents: agentsFor(run) };
 				}
-				// P0-6: render from snapshots only — never read disk on every
-				// render tick. When the snapshot cache is provided but hasn't
-				// populated yet (first frame after `updateCrewWidget`), drop the
-				// run from the result so the widget paints "(loading…)" instead
-				// of calling `agentsFor(run) → readCrewAgents`. Legacy callers
-				// (no snapshotCache) keep the disk-read fallback for tests/dev.
-				if (snapshotCache) return null;
-				return { run, agents: agentsFor(run) };
-			} catch {
-				if (snapshotCache) return null;
-				return { run, agents: agentsFor(run) };
-			}
-		})
-		.filter((item): item is WidgetRun => item !== null && isDisplayActiveRun(item.run, item.agents));
+			})
+			// Wave 16 (residual render wiring): the dock's high-frequency tick NEVER
+			// gains a disk read here — only the snapshot the render path already
+			// holds. OR-in ONLY: a run hidden because its manifest froze mid-long-tool
+			// stays visible while its task heartbeats are fresh (GAP-4 mix-A).
+			.filter(
+				(item): item is WidgetRun =>
+					item !== null &&
+					(isDisplayActiveRun(item.run, item.agents, now) || heartbeatLiveForDisplay(item.run, item.snapshot?.tasks, now)),
+			)
+	);
 }
 
 /**