pi-crew 0.11.2 → 0.11.4

package/src/runtime/task-runner/post-execution.ts

@@ -85,8 +85,18 @@ export interface TaskExecutionResult {
 	transcriptPath: string | undefined;
 	terminalEvidence: OperationTerminalEvidence[];
 	startupEvidence: import("../heartbeat/worker-startup.ts").WorkerStartupEvidence;
+	/** Which child-executor fallback branch produced the result artifact
+	 *  content (rawFinalText → finalText → stdout → stderr → findings →
+	 *  "(no output)"). Finding #2 (2026-09-29 battery): "stderr"/"none" mean
+	 *  every authoritative worker output source was empty — finalizeTaskResult
+	 *  fails those DETERMINISTICALLY; the stderr-noise classifier stays a
+	 *  defense layer, never the verdict oracle. */
+	resultSource?: ResultSource;
 }
 
+/** Result-artifact provenance tags (see {@link TaskExecutionResult.resultSource}). */
+export type ResultSource = "rawFinalText" | "finalText" | "stdout" | "stderr" | "findings" | "none";
+
 /** Final persisted task state returned by finalizeTaskResult. */
 export interface FinalTaskResult {
 	manifest: TeamRunManifest;
@@ -328,24 +338,39 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 	//            result ALWAYS surfaces in at least one authoritative source);
 	//   gate 2 — the persisted artifact is empty/'(no output)'/whitespace OR
 	//            isStderrOnlyResult says every line is strict log noise.
-	// A read error on the artifact is NOT a failure (conservative). Mirrors the
-	// mutation-guard fail-mode precedent: error marker + exitCode bump + last
-	// modelAttempt success:false → status flips to "failed" (retryable).
+	// Finding #2 (2026-09-29 battery): gate 2 alone is not a verdict oracle —
+	// the strict-noise classifier missed colon-bearing/camelCase extension
+	// tags (`[pi-crew:crash-recovery.reconcileStaleRuns]`, lock-contention
+	// noise about a SIBLING run), so attempts whose stderr carried them
+	// completed tasks with 100%-noise artifacts while sibling attempts on the
+	// same runs failed — verdict divergence depended on per-attempt stderr
+	// composition. The child-executor fallback chain now tags the winning
+	// branch (resultSource); "stderr"/"none"-sourced artifacts fail
+	// UNCONDITIONALLY (classifier-independent), making empty/stderr-only
+	// results never complete a task, uniformly across roles.
+	// A read error on the artifact is NOT a failure (conservative) — unless
+	// the source tag already proves the artifact is stderr/none-sourced.
+	// Mirrors the mutation-guard fail-mode precedent: error marker + exitCode
+	// bump + last modelAttempt success:false → status flips to "failed" (retryable).
 	if (!error) {
 		const finalTextEmpty = !parsedOutput?.finalText?.trim();
 		const finalStdoutEmpty = !finalStdout?.trim();
-		if (finalTextEmpty && finalStdoutEmpty && resultArtifact?.path) {
+		const resultSource = execResult.resultSource;
+		const degradedResultSource = resultSource === "stderr" || resultSource === "none";
+		if (finalTextEmpty && finalStdoutEmpty && (resultArtifact?.path || degradedResultSource)) {
 			let artifactContent: string | undefined;
-			try {
-				artifactContent = readFileSync(resultArtifact.path, "utf8");
-			} catch {
-				artifactContent = undefined; // unreadable artifact — do not fail on read errors
+			if (resultArtifact?.path) {
+				try {
+					artifactContent = readFileSync(resultArtifact.path, "utf8");
+				} catch {
+					artifactContent = undefined; // unreadable artifact — do not fail on read errors
+				}
 			}
-			if (artifactContent !== undefined) {
-				const trimmedArtifact = artifactContent.trim();
+			if (artifactContent !== undefined || degradedResultSource) {
+				const trimmedArtifact = (artifactContent ?? "").trim();
 				const emptyArtifact = trimmedArtifact === "" || trimmedArtifact === "(no output)";
-				const stderrOnlyArtifact = !emptyArtifact && isStderrOnlyResult(artifactContent);
-				if (emptyArtifact || stderrOnlyArtifact) {
+				const stderrOnlyArtifact = !emptyArtifact && isStderrOnlyResult(artifactContent ?? "");
+				if (degradedResultSource || emptyArtifact || stderrOnlyArtifact) {
 					error = "Result artifact is empty or stderr-only (failureCause: empty-or-stderr-only-result)";
 					exitCode = exitCode === 0 ? 1 : exitCode;
 					if (modelAttempts?.length) {
@@ -359,7 +384,11 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 						structurePreserved: false,
 						issues: [
 							`empty-or-stderr-only-result: ${
-								emptyArtifact ? "result artifact is empty" : "result artifact contains only stderr/session-log noise"
+								degradedResultSource && !emptyArtifact && !stderrOnlyArtifact
+									? `result artifact was sourced from the ${resultSource} fallback (no authoritative worker output)`
+									: emptyArtifact
+										? "result artifact is empty"
+										: "result artifact contains only stderr/session-log noise"
 							}`,
 						],
 					};
@@ -373,7 +402,8 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 							structurePreserved: false,
 							issues: outputValidation.issues,
 							failureCause: "empty-or-stderr-only-result",
-							resultPath: resultArtifact.path,
+							...(resultSource ? { resultSource } : {}),
+							resultPath: resultArtifact?.path,
 						},
 					});
 				}

package/src/runtime/task-runner/prompt-builder.ts

@@ -248,6 +248,14 @@ export async function computeStablePrefixComponents(
 
 	const components: StableComponents = { treeBlock, suggestedFilesBlock, knowledgeFragment };
 	stableComponentCache.set(cacheKey, components);
+	// RR-021 WI-4.3f: same insertion-order eviction cap as the stableIOCache
+	// sibling below — stableComponentCache had NO cap (unbounded across a
+	// long session with many distinct runIds: the key includes runId).
+	while (stableComponentCache.size > 256) {
+		const oldest = stableComponentCache.keys().next().value;
+		if (oldest === undefined) break;
+		stableComponentCache.delete(oldest);
+	}
 	// Populate the cross-run cache. Clamp size to avoid unbounded growth across
 	// long sessions with many distinct (cwd, step) combos.
 	stableIOCache.set(ioKey, { ...components, at: now });

package/src/runtime/task-runner/retrieval-orchestrator.ts

@@ -160,6 +160,9 @@ interface RipgrepAvailable {
 }
 
 let cachedRgCheck: RipgrepAvailable | undefined;
+/** RR-021 WI-1.3: memoize the in-flight detection so concurrent first calls
+ * spawn rg at most once instead of one process per caller. */
+let inFlightRgCheck: Promise<RipgrepAvailable> | undefined;
 
 /**
  * PERF round 3: per-cwd cache of the rg discovery result (relative paths,
@@ -196,45 +199,64 @@ function storeDiscovered(cwd: string, files: string[]): void {
  * Detect ripgrep availability once per process. Uses `rg --version` and
  * catches ENOENT or non-zero exit. Cached so the cost (one spawn) is
  * paid only on the first retrieval cycle.
+ *
+ * RR-021 WI-1.3 hardening: a spawned-but-wedged rg no longer hangs detection
+ * forever — a 3s unref'd SIGKILL timer defaults to `{ available: false }`.
  */
 export async function detectRipgrep(): Promise<RipgrepAvailable> {
 	if (cachedRgCheck !== undefined) return cachedRgCheck;
-	return await new Promise<RipgrepAvailable>((resolve) => {
+	if (inFlightRgCheck !== undefined) return inFlightRgCheck;
+	inFlightRgCheck = new Promise<RipgrepAvailable>((resolve) => {
 		let settled = false;
+		let killTimer: NodeJS.Timeout | undefined;
+		const settle = (result: RipgrepAvailable): void => {
+			if (settled) return;
+			settled = true;
+			if (killTimer !== undefined) clearTimeout(killTimer);
+			cachedRgCheck = result;
+			resolve(result);
+		};
 		try {
 			const child = spawn("rg", ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
+			// 3s hard deadline. unref'd so the timer never holds the event loop open.
+			killTimer = setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					// already dead — the close handler settles the result
+				}
+				settle({ available: false });
+			}, 3000);
+			killTimer.unref();
 			let stdout = "";
 			child.stdout?.on("data", (chunk) => {
 				stdout += chunk.toString("utf-8");
 			});
 			child.on("error", () => {
-				if (settled) return;
-				settled = true;
-				cachedRgCheck = { available: false };
-				resolve(cachedRgCheck);
+				settle({ available: false });
 			});
 			child.on("close", (code) => {
-				if (settled) return;
-				settled = true;
 				if (code === 0) {
-					cachedRgCheck = { available: true, version: stdout.split("\n")[0] ?? undefined };
+					settle({ available: true, version: stdout.split("\n")[0] ?? undefined });
 				} else {
-					cachedRgCheck = { available: false };
+					settle({ available: false });
 				}
-				resolve(cachedRgCheck);
 			});
 		} catch {
-			if (settled) return;
-			settled = true;
-			cachedRgCheck = { available: false };
-			resolve(cachedRgCheck);
+			settle({ available: false });
 		}
 	});
+	try {
+		return await inFlightRgCheck;
+	} finally {
+		inFlightRgCheck = undefined;
+	}
 }
 
 /** @internal Test-only: reset the ripgrep detection cache. */
 export function __test_resetRipgrepCache(): void {
 	cachedRgCheck = undefined;
+	inFlightRgCheck = undefined;
 }
 
 /** @internal Test-only: reset the discovery cache. */

package/src/runtime/task-runner.ts

@@ -147,6 +147,11 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		// branch. Leaving them undefined preserves those branches' behavior.
 		let surfaceLost: TaskExecutionResult["surfaceLost"];
 		let rawFinalText: string | undefined;
+		// Finding #2 (2026-09-29 battery): result-artifact provenance tag from the
+		// child-executor fallback chain — MUST be forwarded like surfaceLost/
+		// rawFinalText above, or finalizeTaskResult's deterministic
+		// stderr/none-source gate silently degrades to classifier-only.
+		let resultSource: TaskExecutionResult["resultSource"];
 		if (runtimeKind === "child-process") {
 			// CORE-5 extraction 4: the entire child-process branch (model routing +
 			// model-fallback attempt loop, runWorker callbacks, R3 listener-leak
@@ -169,6 +174,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			startupEvidence = child.startupEvidence;
 			surfaceLost = child.surfaceLost;
 			rawFinalText = child.rawFinalText;
+			resultSource = child.resultSource;
 		} else if (runtimeKind === "live-session") {
 			// LAZY: live-executor is only needed for live-session runtime branches.
 			const { runLiveTask } = await import("./task-runner/live-executor.ts");
@@ -237,6 +243,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			startupEvidence,
 			surfaceLost,
 			rawFinalText,
+			resultSource,
 		};
 		return await finalizeTaskResult(ctx, execResult);
 	} finally {

package/src/runtime/team-runner.ts

@@ -1170,7 +1170,10 @@ async function executeTeamRunCore(
 			// sync spin-lock (Atomics.wait) doesn't block the event loop every batch.
 			// The terminal saveCrewAgents at closeout remains durable + flushes this.
 			saveCrewAgentsCoalesced(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
-			const completedBatch = tasks.filter((t) => settledTaskIds.includes(t.id));
+			// RR-021 WI-4.3a: Set lookup — settledTaskIds.includes() inside filter is
+			// O(n*m) on every settled batch.
+			const settledSet = new Set(settledTaskIds);
+			const completedBatch = tasks.filter((t) => settledSet.has(t.id));
 			const batchArtifact = writeArtifact(manifest.artifactsRoot, {
 				kind: "summary",
 				relativePath: `batches/${batchSummarySlug(settledTaskIds)}.md`,

package/src/runtime/verification/verification-worktree.ts

@@ -66,6 +66,7 @@ export function checkWorktreeSandboxAvailable(cwd: string): { available: true; c
 			cwd,
 			stdio: ["ignore", "pipe", "pipe"],
 			encoding: "utf-8",
+			timeout: 5000,
 		}).trim();
 		if (!toplevel)
 			return {
@@ -77,6 +78,7 @@ export function checkWorktreeSandboxAvailable(cwd: string): { available: true; c
 			cwd,
 			stdio: ["ignore", "pipe", "pipe"],
 			encoding: "utf-8",
+			timeout: 5000,
 		}).trim();
 		if (!commitSha)
 			return {
@@ -92,6 +94,7 @@ export function checkWorktreeSandboxAvailable(cwd: string): { available: true; c
 			cwd,
 			stdio: ["ignore", "pipe", "pipe"],
 			encoding: "utf-8",
+			timeout: 5000,
 		}).trim();
 		if (status.length > 0)
 			return {

package/src/state/coordination/mailbox.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_MAILBOX } from "../../config/defaults.ts";
@@ -726,7 +727,9 @@ export function appendMailboxMessage(
 	else ensureRunMailbox(manifest);
 	const createdAt = new Date().toISOString();
 	const complete: MailboxMessage = {
-		id: message.id ?? `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+		// RR-021 WI-4.3j: randomUUID instead of Date.now()+Math.random() —
+		// collision-free under the msg_ prefix, no clock-ordering leakage.
+		id: message.id ?? `msg_${randomUUID()}`,
 		runId: manifest.runId,
 		direction: message.direction,
 		from: message.from,
@@ -854,7 +857,9 @@ export async function appendMailboxMessageAsync(
 	else ensureRunMailbox(manifest);
 	const createdAt = new Date().toISOString();
 	const complete: MailboxMessage = {
-		id: message.id ?? `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+		// RR-021 WI-4.3j: randomUUID instead of Date.now()+Math.random() —
+		// collision-free under the msg_ prefix, no clock-ordering leakage.
+		id: message.id ?? `msg_${randomUUID()}`,
 		runId: manifest.runId,
 		direction: message.direction,
 		from: message.from,

package/src/state/stores/state-store.ts

@@ -21,7 +21,7 @@ import {
 import { canTransitionRunStatus } from "../contracts.ts";
 import { withRunLock, withRunLockSync } from "../coordination/locks.ts";
 import { appendEvent } from "../event-log/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../types.ts";
+import type { RunModelContext, TeamRunManifest, TeamTaskState } from "../types.ts";
 import { CURRENT_SCHEMA_VERSION } from "../types.ts";
 import { unregisterActiveRun } from "./active-run-registry.ts";
 import { extractTaskArray, loadTasksWithRecovery, loadTasksWithRecoveryAsync, quarantineCorruptFile } from "./manifest-io.ts";
@@ -438,6 +438,12 @@ export function createRunManifest(params: {
 	 * Defaults preserve current behavior (generated id, wall clock). */
 	runId?: string;
 	now?: () => Date;
+	/** Model routing snapshot (Finding #1, battery 2026-09-29): detached runs
+	 * re-enter through background-runner with no ExtensionContext, so the
+	 * caller's model override / inherited session model / auth-filtered
+	 * catalogue must be persisted on the manifest at creation time.
+	 * Omitted when undefined so old manifests stay byte-identical. */
+	modelContext?: RunModelContext;
 }): { manifest: TeamRunManifest; tasks: TeamTaskState[]; paths: RunPaths } {
 	const paths = createRunPaths(params.cwd, params.runId);
 	const now = (params.now ? params.now() : new Date()).toISOString();
@@ -462,6 +468,7 @@ export function createRunManifest(params: {
 		...(params.ownerSessionId ? { ownerSessionId: params.ownerSessionId } : {}),
 		runKind: params.runKind ?? "team-run",
 		...(params.args !== undefined ? { args: params.args } : {}),
+		...(params.modelContext ? { modelContext: params.modelContext } : {}),
 	};
 	fs.mkdirSync(paths.stateRoot, { recursive: true });
 	fs.mkdirSync(paths.artifactsRoot, { recursive: true });

package/src/ui/dashboard-panes/agents-pane.ts

@@ -116,13 +116,16 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 	// One pinned clock (D6-T4) for the whole pane render.
 	const nowMs = options.nowMs ?? Date.now();
 
-	const realAgents = snapshot.agents.filter((a) =>
-		isRealAgent(
-			a,
-			liveForRun.find((h) => h.taskId === a.taskId),
-			nowMs,
-		),
-	);
+	// RR-021 WI-4.3c: first-wins Map keyed by taskId — the two `.find` sites
+	// below (real-agent filter + per-agent handle) must keep seeing the SAME
+	// (first) matching handle, so the build guards with has() instead of set()
+	// overwriting later duplicates.
+	const liveByTaskId = new Map<string, (typeof liveForRun)[number]>();
+	for (const handle of liveForRun) {
+		if (!liveByTaskId.has(handle.taskId)) liveByTaskId.set(handle.taskId, handle);
+	}
+
+	const realAgents = snapshot.agents.filter((a) => isRealAgent(a, liveByTaskId.get(a.taskId), nowMs));
 	const lineCount = Math.min(realAgents.length, 12);
 	const label =
 		realAgents.length !== snapshot.agents.length
@@ -135,7 +138,7 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 	lines.push(`${completed}/${total} tasks · ${label}`);
 
 	for (const agent of realAgents.slice(0, 12)) {
-		const liveHandle = liveForRun.find((h) => h.taskId === agent.taskId);
+		const liveHandle = liveByTaskId.get(agent.taskId);
 		const icon = agentGlyph(agent.status, agent.taskId);
 		const role = `${agent.role ?? "?"}`;
 

package/src/ui/inline-panel/index.ts

@@ -277,7 +277,7 @@ export function installInlinePanel(pi: ExtensionAPI, ctx: ExtensionContext, uiCo
 					// (lazy import: viewers.ts pulls the state-store chain and must stay
 					// off this module's startup path — AGENTS.md lazy boundary).
 					onOpenBrowser: () => {
-						void import("../../extension/registration/viewers.ts").then((m) => m.openAgentsJobsBrowser(ctx));
+						void import("../../extension/registration/viewers.ts").then((m) => m.openAgentsJobsBrowser(ctx)); // LAZY: defer agents-jobs browser until opened
 					},
 				});
 			});

package/src/ui/render-diff.ts

@@ -1,7 +1,20 @@
-import * as Diff from "diff";
+import { createRequire } from "node:module";
+import type { Change } from "diff";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme } from "./theme-adapter.ts";
 
+// RR-021 WI-2.1: the `diff` package was eagerly imported module-scope with a
+// wildcard (pulling the whole namespace into every UI load). Only diffWords is
+// used at runtime — lazy sync accessor on first use (model: ui/syntax-highlight.ts).
+// `Change` is a type-only import (erased at compile time, zero runtime cost).
+const require = createRequire(import.meta.url);
+type DiffModule = typeof import("diff");
+let cachedDiff: DiffModule | undefined;
+function diffModule(): DiffModule {
+	if (!cachedDiff) cachedDiff = require("diff") as DiffModule;
+	return cachedDiff;
+}
+
 interface ParsedDiffLine {
 	prefix: string;
 	lineNum: string;
@@ -36,8 +49,8 @@ const WORD_DIFF_MIN_SIM = 0.15;
  * characters relative to the longer of the two strings, using word-level
  * diff to identify the common (unchanged) parts. Returns a value in [0, 1].
  */
-function computeSimilarity(oldContent: string, newContent: string, wordDiff?: Diff.Change[]): number {
-	const parts = wordDiff ?? Diff.diffWords(oldContent, newContent);
+function computeSimilarity(oldContent: string, newContent: string, wordDiff?: Change[]): number {
+	const parts = wordDiff ?? diffModule().diffWords(oldContent, newContent);
 	let commonChars = 0;
 	for (const part of parts) {
 		if (!part.removed && !part.added) {
@@ -53,9 +66,9 @@ function renderIntraLineDiff(
 	theme: CrewTheme,
 	oldContent: string,
 	newContent: string,
-	wordDiff?: Diff.Change[],
+	wordDiff?: Change[],
 ): { removedLine: string; addedLine: string } {
-	const parts = wordDiff ?? Diff.diffWords(oldContent, newContent);
+	const parts = wordDiff ?? diffModule().diffWords(oldContent, newContent);
 	let removedLine = "";
 	let addedLine = "";
 	let isFirstRemoved = true;
@@ -137,7 +150,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 				const newContent = replaceTabs(addedLines[0]!.content);
 				// PERF (2026-08-24): diffWords is the expensive call and was run
 				// TWICE on identical inputs (similarity + render). One pass, shared.
-				const wordDiff = Diff.diffWords(oldContent, newContent);
+				const wordDiff = diffModule().diffWords(oldContent, newContent);
 				const similarity = computeSimilarity(oldContent, newContent, wordDiff);
 				if (similarity >= WORD_DIFF_MIN_SIM) {
 					const { removedLine, addedLine } = renderIntraLineDiff(theme, oldContent, newContent, wordDiff);

package/src/ui/run-dashboard.ts

@@ -248,7 +248,17 @@ function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?:
 	if (snapshotCache) return ["Progress: (loading…)"];
 	// Legacy fallback: tests/dev paths without a snapshot cache still read the
 	// progress artifact directly so existing assertions keep working.
-	const progress = [...run.artifacts].reverse().find((artifact) => artifact.kind === "progress");
+	// RR-021 WI-4.3e: allocation-free reverse scan — the old
+	// [...run.artifacts].reverse().find() copied the whole array per render.
+	// (findLast needs an ES2023 lib bump, which breaks tsgo's RequestInfo
+	// ambient resolution — see WI-4.3 evidence note.)
+	let progress: (typeof run.artifacts)[number] | undefined;
+	for (let i = run.artifacts.length - 1; i >= 0; i--) {
+		if (run.artifacts[i]?.kind === "progress") {
+			progress = run.artifacts[i];
+			break;
+		}
+	}
 	if (!progress) return ["Progress: (none)"];
 	try {
 		const progressPath = resolveRealContainedPath(run.artifactsRoot, progress.path);

package/src/ui/run-snapshot-cache.ts

@@ -692,9 +692,15 @@ async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentReco
 }
 
 function cancellationReasonFromEvents(events: TeamEvent[]): string | undefined {
-	return [...events].reverse().find((event) => event.type === "run.cancelled" && typeof event.data?.reason === "string")?.data?.reason as
-		| string
-		| undefined;
+	// RR-021 WI-4.3e: allocation-free reverse scan — the old
+	// [...events].reverse().find() copied the whole array on every call.
+	// (findLast needs an ES2023 lib bump, which breaks tsgo's RequestInfo
+	// ambient resolution — see WI-4.3 evidence note.)
+	for (let i = events.length - 1; i >= 0; i--) {
+		const event = events[i];
+		if (event?.type === "run.cancelled" && typeof event.data?.reason === "string") return event.data.reason;
+	}
+	return undefined;
 }
 
 type SliceSignatures = NonNullable<RunUiSnapshot["sliceSignatures"]>;

package/src/ui/widget/task-list.ts

@@ -126,10 +126,12 @@ function runningSuffix(task: TeamTaskState): string {
 
 /** `› blocked by #2, #3` for queued tasks — open (non-completed)
  *  dependencies only, named by task number (pi-tasks display rule). */
-function blockedSuffix(task: TeamTaskState, tasks: readonly TeamTaskState[], numberById: Map<string, number>): string {
+function blockedSuffix(task: TeamTaskState, taskById: Map<string, TeamTaskState>, numberById: Map<string, number>): string {
 	if (task.status !== "queued") return "";
+	// RR-021 WI-4.3b: Map lookup — tasks.find() per dependency was O(deps×tasks)
+	// on every queued row render.
 	const openDeps = (task.dependsOn ?? [])
-		.map((depId) => tasks.find((entry) => entry.id === depId))
+		.map((depId) => taskById.get(depId))
 		.filter((dep): dep is TeamTaskState => dep !== undefined && dep.status !== "completed");
 	if (openDeps.length === 0) return "";
 	const labels = openDeps.map((dep) => `#${numberById.get(dep.id) ?? "?"}`);
@@ -139,9 +141,9 @@ function blockedSuffix(task: TeamTaskState, tasks: readonly TeamTaskState[], num
 /** One line per task: `#n title` behind its status glyph — pi-tasks style.
  *  Completed titles are dimmed and struck through. Returns the ROW CONTENT:
  *  the rail glyph (`┃ `) is owned by `railLine`. */
-function taskRow(task: TeamTaskState, taskNumber: number, tasks: readonly TeamTaskState[], numberById: Map<string, number>): string {
+function taskRow(task: TeamTaskState, taskNumber: number, taskById: Map<string, TeamTaskState>, numberById: Map<string, number>): string {
 	const title = taskTitle(task);
-	const suffix = task.status === "running" ? runningSuffix(task) : blockedSuffix(task, tasks, numberById);
+	const suffix = task.status === "running" ? runningSuffix(task) : blockedSuffix(task, taskById, numberById);
 	if (task.status === "completed") {
 		const struck = `${STRIKE_ON}${DIM_ON}#${taskNumber} ${title}${DIM_OFF}${STRIKE_OFF}`;
 		return `${taskStatusIcon(task)} ${struck}`;
@@ -182,6 +184,7 @@ export function buildTaskListLines(runs: readonly WidgetRun[], width: number, th
 
 	const budget = Math.max(8, width - 2);
 	const numberById = new Map(tasks.map((task, index) => [task.id, index + 1]));
+	const taskById = new Map(tasks.map((task) => [task.id, task]));
 	const done = tasks.filter((task) => task.status === "completed").length;
 	const dead = tasks.filter((task) => isDoneStatus(task.status) && task.status !== "completed").length;
 	const inProgress = tasks.filter(
@@ -211,7 +214,7 @@ export function buildTaskListLines(runs: readonly WidgetRun[], width: number, th
 
 	const visible = visibleTasks(tasks);
 	for (const task of visible) {
-		lines.push(railLine(RAIL.body, "border", taskRow(task, numberById.get(task.id) ?? 0, tasks, numberById), theme, budget));
+		lines.push(railLine(RAIL.body, "border", taskRow(task, numberById.get(task.id) ?? 0, taskById, numberById), theme, budget));
 	}
 	const hidden = tasks.length - visible.length;
 	if (hidden > 0) {

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

@@ -46,7 +46,9 @@ export function activeWidgetRuns(
 	if (now - lastStaleReconcileAt > STALE_RECONCILE_INTERVAL_MS && manifestCache) {
 		lastStaleReconcileAt = now;
 		try {
-			reconcileAllStaleRuns(cwd, manifestCache, Date.now(), workspaceId);
+			void reconcileAllStaleRuns(cwd, manifestCache, Date.now(), workspaceId).catch(() => {
+				/* non-critical */
+			});
 		} catch {
 			/* non-critical */
 		}

package/tsconfig.json

@@ -9,6 +9,8 @@
     "skipLibCheck": true,
     "allowImportingTsExtensions": true,
     "noEmit": true,
+    "incremental": true,
+    "tsBuildInfoFile": "node_modules/.cache/pi-crew/tsconfig.tsbuildinfo",
     "types": ["node"],
     "verbatimModuleSyntax": true,
     "noUncheckedSideEffectImports": true