pi-crew 0.11.2 → 0.11.4

package/src/runtime/goal-workflow/dynamic-workflow-context.ts

@@ -906,67 +906,87 @@ function describeSchemaShape(schema: unknown, depth: number): string {
  * reject is checked first because a review can mention both "correctly" (describing existing code)
  * AND "critical bug" (the verdict) — the verdict signal must win.
  */
+// Precompiled review-outcome signals (module scope — compiled once, not per call).
+// RR-021 WI-1.1: these were previously string literals like "\baccept\b" compiled
+// per call — and "\b" in a TS string literal is a BACKSPACE character (U+0008),
+// so those two signals never matched anything. Regex literals here give real word
+// boundaries. No /g flags → no shared lastIndex state across .test() calls.
+const REJECT_SIGNAL_REGEXES: readonly RegExp[] = [
+	/\breject\b/,
+	/fundamentally/,
+	/completely broken/,
+	/totally broken/,
+	/critical bug/,
+	/critical issue/,
+	/critical flaw/,
+	/security vulnerability/,
+	/does not work/,
+	/doesn't work/,
+	/will not work/,
+	/fails to/,
+	/unacceptable/,
+	/must not be merged/,
+	/do not merge/,
+	/wrong approach/,
+	/logically incorrect/,
+	/incorrectly implements/,
+	/returns the opposite/,
+	/subtraction instead of addition/,
+	/opposite of its intended/,
+];
+const ACCEPT_SIGNAL_REGEXES: readonly RegExp[] = [
+	/\baccept\b/,
+	/looks good/,
+	/well done/,
+	/no issues/,
+	/no real issues/,
+	/no problems/,
+	/no concerns/,
+	/nothing to change/,
+	/ready to merge/,
+	/lgtm/,
+	/ship it/,
+	/correctly implements/,
+	/correctly returns/,
+	/works as expected/,
+	/works correctly/,
+	/no bugs/,
+	/no defects/,
+	/meets all requirements/,
+	/all requirements met/,
+	/passes all/,
+	/is correct/,
+	/are correct/,
+	/no changes needed/,
+	/no changes required/,
+	/no further changes/,
+	/nothing more to/,
+	/complete and correct/,
+	/sound implementation/,
+];
+// RR-021 WI-1.1 negation guard: phrases that NEGATE the bare "accept" signal.
+// "I cannot accept this" is a complaint, not approval — the accept hit must be
+// discarded so the outcome falls through to changes_requested (or reject if a
+// reject signal is also present).
+const NEGATED_ACCEPT_REGEXES: readonly RegExp[] = [
+	/\bcannot\s+accept\b/,
+	/\bcan'?t\s+accept\b/,
+	/\bdon'?t\s+accept\b/,
+	/\bwon'?t\s+accept\b/,
+	/\bdo\s+not\s+accept\b/,
+	/\bwill\s+not\s+accept\b/,
+	/\bunable\s+to\s+accept\b/,
+	/\bnot\s+accept(?:ed|ing|able)?\b/,
+];
+
 export function classifyReviewOutcome(prose: string): "accept" | "reject" | "changes_requested" {
 	const text = prose.toLowerCase();
-	// Strong negative signals → reject. These indicate fundamental/critical problems.
-	const rejectSignals = [
-		"\breject\b",
-		"fundamentally",
-		"completely broken",
-		"totally broken",
-		"critical bug",
-		"critical issue",
-		"critical flaw",
-		"security vulnerability",
-		"does not work",
-		"doesn't work",
-		"will not work",
-		"fails to",
-		"unacceptable",
-		"must not be merged",
-		"do not merge",
-		"wrong approach",
-		"logically incorrect",
-		"incorrectly implements",
-		"returns the opposite",
-		"subtraction instead of addition",
-		"opposite of its intended",
-	];
-	// Acceptance signals → accept. These indicate explicit approval with no real issues.
-	const acceptSignals = [
-		"\baccept\b",
-		"looks good",
-		"well done",
-		"no issues",
-		"no real issues",
-		"no problems",
-		"no concerns",
-		"nothing to change",
-		"ready to merge",
-		"lgtm",
-		"ship it",
-		"correctly implements",
-		"correctly returns",
-		"works as expected",
-		"works correctly",
-		"no bugs",
-		"no defects",
-		"meets all requirements",
-		"all requirements met",
-		"passes all",
-		"is correct",
-		"are correct",
-		"no changes needed",
-		"no changes required",
-		"no further changes",
-		"nothing more to",
-		"complete and correct",
-		"sound implementation",
-	];
-	const hasReject = rejectSignals.some((sig) => new RegExp(sig).test(text));
-	const hasAccept = acceptSignals.some((sig) => new RegExp(sig).test(text));
+	// Reject-first precedence: a review can mention both "correctly" (describing
+	// existing code) AND "critical bug" (the verdict) — the verdict signal must win.
+	const hasReject = REJECT_SIGNAL_REGEXES.some((re) => re.test(text));
 	if (hasReject) return "reject";
-	if (hasAccept) return "accept";
+	const hasAccept = ACCEPT_SIGNAL_REGEXES.some((re) => re.test(text));
+	if (hasAccept && !NEGATED_ACCEPT_REGEXES.some((re) => re.test(text))) return "accept";
 	return "changes_requested";
 }
 

package/src/runtime/goal-workflow/dynamic-workflow-runner.ts

@@ -18,8 +18,8 @@
  */
 
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { join } from "node:path";
-import { transformSync } from "esbuild";
 import { getCrewEnv } from "../../config/env-vars.ts";
 import { appendEvent } from "../../state/event-log/event-log.ts";
 import { writeArtifact } from "../../state/stores/artifact-store.ts";
@@ -33,6 +33,18 @@ import { assertDeterministicScript, isDeterminismCheckEnabled } from "../determi
 import { DwfStore } from "../dwf-state-store.ts";
 import { getWorkflowFinalResult, getWorkflowPhaseState, makeWorkflowCtx } from "./dynamic-workflow-context.ts";
 
+// RR-021 WI-2.1: esbuild is a heavy native dep (~35ms+ cold load) but is only
+// needed when a .dwf.ts script actually executes. Lazy-load via a synchronous
+// createRequire shim on first use (model: ui/syntax-highlight.ts) — call sites
+// stay sync. esbuild remains external in the bundle and resolves through here.
+const nodeRequire = createRequire(import.meta.url);
+type EsbuildModule = typeof import("esbuild");
+let cachedEsbuild: EsbuildModule | undefined;
+function esbuild(): EsbuildModule {
+	if (!cachedEsbuild) cachedEsbuild = nodeRequire("esbuild") as EsbuildModule;
+	return cachedEsbuild;
+}
+
 export interface RunDynamicWorkflowInput {
 	manifest: TeamRunManifest;
 	workflow: DynamicWorkflowConfig;
@@ -119,7 +131,7 @@ async function loadWorkflowModule(scriptPath: string): Promise<DynamicWorkflowSc
 		// DISC-1: acorn can only parse JavaScript, not TypeScript. Real .dwf.ts files
 		// contain type annotations/imports that cause a silent parse error, so the
 		// determinism check never runs. Transpile to JS via esbuild first.
-		const js = transformSync(scriptSource, { loader: "ts", format: "esm" }).code;
+		const js = esbuild().transformSync(scriptSource, { loader: "ts", format: "esm" }).code;
 		assertDeterministicScript(js);
 	}
 	// jiti is the same loader async-runner.ts uses (resolveTypeScriptLoader). We require it

package/src/runtime/goal-workflow/goal-loop-runner.ts

@@ -29,6 +29,7 @@ import type { TeamConfig } from "../../teams/team-config.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
 import { resolveCrewRuntime } from "../model/runtime-resolver.ts";
+import { registryFromModelContext } from "../model/session-model.ts";
 import { executeTeamRun } from "../team-runner.ts";
 import { compareSnapshot, snapshotManifests } from "../verification/verification-integrity.ts";
 import { acquireWorkspaceLock, type WorkspaceLockHandle } from "../workspace-lock.ts";
@@ -65,6 +66,29 @@ export interface RunGoalLoopResult {
 	goalState: GoalLoopState;
 }
 
+/**
+ * Finding #1 (battery 2026-09-29): re-hydrate the model routing inputs the
+ * OUTER goal-loop manifest persisted at dispatch time (captureRunModelContext
+ * in goal.ts / goal-wrap.ts). The detached goal-loop runs in the background
+ * runner with no ExtensionContext — without this, every turn's executeTeamRun
+ * resolves the DEFAULT chain (live: minimax/MiniMax-M3 402 while the parent
+ * session ran zai/glm-5.3). Mirrors background-runner's restoredModelRouting().
+ */
+function restoredTurnModelRouting(manifest: TeamRunManifest): {
+	modelOverride?: string;
+	parentModel?: string;
+	modelRegistry?: { getAvailable: () => unknown[] };
+} {
+	const context = manifest.modelContext;
+	if (!context) return {};
+	const modelRegistry = registryFromModelContext(context);
+	return {
+		...(context.override ? { modelOverride: context.override } : {}),
+		...(context.parentModel ? { parentModel: context.parentModel } : {}),
+		...(modelRegistry ? { modelRegistry } : {}),
+	};
+}
+
 /**
  * The placeholder evaluator for P0: always returns {achieved:false}.
  * Kept for unit tests of the loop's max_turns exit path. The production loop
@@ -630,6 +654,10 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				workspaceMode: "single",
 				ownerSessionId: goal.ownerSessionId,
 				runKind: "team-run", // §0a v2 note: turns are normal team-runs; the OUTER loop is goal-loop
+				// Finding #1: turns execute in the detached process — carry the outer
+				// manifest's model routing snapshot onto each turn manifest too, so
+				// status/resume paths see the same routing the turn was dispatched with.
+				...(manifest.modelContext ? { modelContext: manifest.modelContext } : {}),
 			});
 			goal =
 				store.patch(
@@ -689,6 +717,10 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 					limits: turnExecutedConfig.limits,
 					runtime: turnRuntime,
 					runtimeConfig: turnExecutedConfig.runtime,
+					// Finding #1: restore the dispatch-time model routing (see
+					// restoredTurnModelRouting) — executeTeamRun in THIS process has no
+					// ExtensionContext to inherit the session model from.
+					...restoredTurnModelRouting(manifest),
 					reliability: turnExecutedConfig.reliability,
 					workspaceId: goal.ownerSessionId ?? goal.cwd,
 					signal,

package/src/runtime/group-join.ts

@@ -59,9 +59,17 @@ export function deliverGroupJoin(input: {
 }): CrewGroupJoinDelivery | undefined {
 	if (!shouldGroupJoin(input.mode, input.batch)) return undefined;
 	const taskIds = input.batch.map((task) => task.id);
-	const latest = taskIds
-		.map((id) => input.allTasks.find((task) => task.id === id))
-		.filter((task): task is TeamTaskState => Boolean(task));
+	// RR-021 WI-4.3d: first-wins Map — the old taskIds.map(id => allTasks.find())
+	// was O(batch×allTasks). NOT a raw input.batch pass-through: callers may
+	// hold stale batch snapshots, and the only audited production caller
+	// (team-runner closeout) passes fresh references — but the Map keeps the
+	// exact `.find` first-match semantics for every caller (incl. tests) while
+	// staying O(n+m). Batch order is preserved (map follows taskIds).
+	const taskById = new Map<string, TeamTaskState>();
+	for (const task of input.allTasks) {
+		if (!taskById.has(task.id)) taskById.set(task.id, task);
+	}
+	const latest = taskIds.map((id) => taskById.get(id)).filter((task): task is TeamTaskState => Boolean(task));
 	const completed = statusList(latest, "completed");
 	const failed = statusList(latest, "failed");
 	const skipped = statusList(latest, "skipped");

package/src/runtime/live-session/live-session-runtime.ts

@@ -96,7 +96,7 @@ let liveSessionModulePromise: Promise<LiveSessionModule> | undefined;
 let experimentalWarned = false;
 function loadLiveSessionModule(): Promise<LiveSessionModule> {
 	if (!liveSessionModulePromise) {
-		liveSessionModulePromise = import("@earendil-works/pi-coding-agent") as unknown as Promise<LiveSessionModule>;
+		liveSessionModulePromise = import("@earendil-works/pi-coding-agent") as unknown as Promise<LiveSessionModule>; // LAZY: defer pi-coding-agent live-session module until first use
 	}
 	return liveSessionModulePromise;
 }

package/src/runtime/model/runtime-warmup.ts

@@ -124,6 +124,7 @@ export function startRuntimeWarmup(): void {
 		for (const spec of HOT_MODULE_SPECIFIERS) {
 			imports.push(
 				import(new URL(spec, import.meta.url).href).catch(() => {
+					// LAZY: best-effort warmup import, failures tolerated
 					// swallow — never block registration on a warmup failure
 				}),
 			);
@@ -131,6 +132,7 @@ export function startRuntimeWarmup(): void {
 		for (const dep of HOT_PEER_DEPS) {
 			imports.push(
 				import(dep).catch(() => {
+					// LAZY: best-effort warmup import, failures tolerated
 					// peer dep may be absent (optional dep) — swallow
 				}),
 			);

package/src/runtime/output/output-validator.ts

@@ -123,10 +123,15 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  *
  * A trimmed non-empty line counts as log noise ONLY if it matches one of:
  *  1. a bracket-tag extension log line: `[oc-go] ...`, `[pi-qwen-mm] ...`,
- *     `[pi-qwen-mm] [core] [stderr] ...` — the leading tag is a lowercase
- *     identifier (deliberately excludes capitalized bracketed prose like
- *     `[Note] ...`), optionally followed by known sub-tags
- *     (core/mcp/stderr/stdout/warn/info/error/debug);
+ *     `[pi-qwen-mm] [core] [stderr] ...`, and — Finding #2 (2026-09-29
+ *     battery) — colon-bearing extension tags like
+ *     `[pi-crew:crash-recovery.reconcileStaleRuns] ...` or
+ *     `[pi-crew:crew-vibes.publish-quota-status] ...`. The leading tag
+ *     starts with a lowercase char (deliberately excludes capitalized
+ *     bracketed prose like `[Note] ...` / `[Note: ...]`); the rest of the tag
+ *     may carry `:`, `-`, `_`, `.`, digits, and inner capitals (extension
+ *     subsystem names are camelCase, e.g. `reconcileStaleRuns`), optionally
+ *     followed by known sub-tags (core/mcp/stderr/stdout/warn/info/error/debug);
  *  2. a Python `warnings.warn(` line (deprecation-warning continuation);
  *  3. a timestamped logging line: `2026-08-15 21:49:02,986 WARNING ...`.
  *
@@ -137,7 +142,7 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  * (post-execution.ts) applies the two-gate rule (authoritative output
  * sources empty AND artifact log-noise-only) before failing a task.
  */
-const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-z0-9_.-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
+const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-zA-Z0-9_.:\-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
 const PYTHON_WARNING_LINE = /(?:^|\s)warnings\.warn\(/;
 const TIMESTAMPED_LOG_LINE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:[.,]\d{1,6})?(?:Z|[+-]\d{2}:?\d{2})?\s+[A-Za-z]+\b/;
 

package/src/runtime/plan-approval.ts

@@ -70,7 +70,20 @@ export async function ensurePlanApprovalRequested(manifest: TeamRunManifest, tas
 	const assessTask = tasks.find((task) => task.stepId === "assess" && task.status === "completed");
 	// ROADMAP T1.2: for non-adaptive workflows, fall back to the most recent
 	// completed read-only (planning) task as the plan reference.
-	const planTask = assessTask ?? [...tasks].reverse().find((t) => t.status === "completed" && !isMutatingTask(t));
+	// RR-021 WI-4.3e: allocation-free reverse scan — the old
+	// [...tasks].reverse().find() copied the whole array per call.
+	// (findLast needs an ES2023 lib bump, which breaks tsgo's RequestInfo
+	// ambient resolution — see WI-4.3 evidence note.)
+	let planTask = assessTask;
+	if (!planTask) {
+		for (let i = tasks.length - 1; i >= 0; i--) {
+			const t = tasks[i];
+			if (t?.status === "completed" && !isMutatingTask(t)) {
+				planTask = t;
+				break;
+			}
+		}
+	}
 	const now = new Date().toISOString();
 
 	// T2/R4 (ADR-4 §6 producer 3 + §8 dual-write): make sure a PlanRecord

package/src/runtime/recovery/crash-recovery.ts

@@ -4,10 +4,16 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_PATHS } from "../../config/defaults.ts";
 import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
-import { discoverRunLockFiles, sweepStaleLocks, withRunLockSync } from "../../state/coordination/locks.ts";
+import { discoverRunLockFiles, sweepStaleLocks, withRunLock, withRunLockSync } from "../../state/coordination/locks.ts";
 import { appendEvent, scanSequence } from "../../state/event-log/event-log.ts";
 import { readActiveRunRegistry, unregisterActiveRun } from "../../state/stores/active-run-registry.ts";
-import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
+import {
+	loadRunManifestById,
+	loadRunManifestByIdAsync,
+	saveRunManifest,
+	saveRunTasks,
+	updateRunStatus,
+} from "../../state/stores/state-store.ts";
 import type { TeamTaskState } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
@@ -18,6 +24,7 @@ import { isWorkerHeartbeatStale } from "../heartbeat/worker-heartbeat.ts";
 import { terminateLiveAgentsForRun } from "../live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../manifest-cache.ts";
 import { checkProcessLiveness } from "../process-status.ts";
+import { mapConcurrent } from "../scheduling/parallel-utils.ts";
 import { isIntentionalWait, isPlanApprovalPendingEffective, type ReconcileResult, reconcileStaleRun } from "../stale-reconciler.ts";
 
 export interface RecoveryPlan {
@@ -690,13 +697,12 @@ export function purgeStaleActiveRunIndex(
 	return { purged, kept };
 }
 
-export function reconcileAllStaleRuns(
+export async function reconcileAllStaleRuns(
 	cwd: string,
 	manifestCache: ManifestCache,
 	now = Date.now(),
 	currentSessionId?: string,
-): ReconcileResult[] {
-	const results: ReconcileResult[] = [];
+): Promise<ReconcileResult[]> {
 	// Capture runIds to reconcile BEFORE acquiring locks — avoids TOCTOU between cache iteration and lock acquisition.
 	const runIds = manifestCache
 		.list(50)
@@ -708,56 +714,73 @@ export function reconcileAllStaleRuns(
 			return true;
 		})
 		.map((m) => m.runId);
-	for (const runId of runIds) {
-		const cached = manifestCache.get(runId);
-		if (!cached) continue;
-		const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
-		if (!loaded) continue;
-		// Use lock to prevent race with cancel/status handlers modifying the same run
-		withRunLockSync(loaded.manifest, () => {
-			// Re-read inside lock to get freshest data
-			const fresh = loadRunManifestById(cwd, runId); // NOTE: inside withRunLockSync - consistent read
-			if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
-			// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
-			// may have flipped to blocked+plan-approval between cache-list and lock
-			// acquisition — re-check the freshest manifest under the lock.
-			if (isPlanApprovalPendingEffective(fresh.manifest)) {
-				results.push({
-					runId,
-					verdict: "blocked_awaiting_approval",
-					repaired: false,
-					detail: "Plan approval is pending; stale reconciliation skipped",
-				});
-				return;
-			}
-			const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
-			if (result.repaired || result.verdict === "result_exists") {
-				if (result.repairedTasks) {
-					saveRunTasks(fresh.manifest, result.repairedTasks);
-					for (const task of result.repairedTasks) {
-						try {
-							upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
-						} catch {
-							/* non-critical */
+	// RR-021 WI-1.5 (audit C3): serial reconcile → mapConcurrent bound 4.
+	// Each runId acquires its OWN run lock file (lockPath() is per-run), so the
+	// acquisitions are independent; bound 4 caps fs/CPU contention. Results keep
+	// input (snapshot) order — mapConcurrent indexes by item — and per-run
+	// semantics (re-read inside lock, plan-approval re-check) are unchanged.
+	const perRun = await mapConcurrent(runIds, 4, async (runId): Promise<ReconcileResult[]> => {
+		// RR-021 review remediation: per-run error isolation — one corrupt run
+		// must not reject the whole sweep (serial baseline threw too, but the
+		// SPEC's "independent per-run" intent requires continue-on-error).
+		try {
+			const cached = manifestCache.get(runId);
+			if (!cached) return [];
+			const loaded = await loadRunManifestByIdAsync(cwd, runId); // NOTE: best-effort only; concurrent writes may cause inconsistency
+			if (!loaded) return [];
+			const out: ReconcileResult[] = [];
+			// Use lock to prevent race with cancel/status handlers modifying the same run.
+			// Same v0.9.26 lock family as the old sync acquisition — interop-safe.
+			await withRunLock(loaded.manifest, async () => {
+				// Re-read inside lock to get freshest data
+				const fresh = await loadRunManifestByIdAsync(cwd, runId); // NOTE: inside withRunLock - consistent read
+				if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
+				// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
+				// may have flipped to blocked+plan-approval between cache-list and lock
+				// acquisition — re-check the freshest manifest under the lock.
+				if (isPlanApprovalPendingEffective(fresh.manifest)) {
+					out.push({
+						runId,
+						verdict: "blocked_awaiting_approval",
+						repaired: false,
+						detail: "Plan approval is pending; stale reconciliation skipped",
+					});
+					return;
+				}
+				const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
+				if (result.repaired || result.verdict === "result_exists") {
+					if (result.repairedTasks) {
+						saveRunTasks(fresh.manifest, result.repairedTasks);
+						for (const task of result.repairedTasks) {
+							try {
+								upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+							} catch {
+								/* non-critical */
+							}
 						}
 					}
+					updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
+					void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
+						logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
+					);
+					appendEvent(fresh.manifest.eventsPath, {
+						type: "crew.run.reconciled_stale",
+						runId,
+						message: result.detail,
+						data: { verdict: result.verdict },
+					});
 				}
-				updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
-				void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
-					logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
-				);
-				appendEvent(fresh.manifest.eventsPath, {
-					type: "crew.run.reconciled_stale",
-					runId,
-					message: result.detail,
-					data: { verdict: result.verdict },
-				});
-			}
-			if (result.verdict !== "healthy") {
-				results.push(result);
-			}
-		});
-	}
+				if (result.verdict !== "healthy") {
+					out.push(result);
+				}
+			});
+			return out;
+		} catch (error) {
+			logInternalError("crash-recovery.reconcileStaleRuns", error, `runId=${runId}`, "warn");
+			return [];
+		}
+	});
+	const results = perRun.flat();
 	// US-002 (2026-09-22): structured stale-lock sweep. Runs after reconciliation
 	// so locks whose holder died (kill -9 / crash) do not linger. The sweep is
 	// strictly safer than acquire-time steal (stale AND holder-dead only), so a

package/src/runtime/subagent-manager.ts

@@ -342,16 +342,43 @@ export class SubagentManager {
 		}
 	}
 
-	async waitForRecord(id: string): Promise<SubagentRecord | undefined> {
+	async waitForRecord(id: string, timeoutMs = 300_000): Promise<SubagentRecord | undefined> {
+		// RR-021 WI-4.3i: bounded wait. A record with no promise whose status
+		// stays running/blocked used to spin forever (100ms sleep loop). On
+		// deadline expiry we return the CURRENT record — never undefined, which
+		// would be ambiguous with 'no such record'. Callers can inspect
+		// record.status to see the wait timed out on a still-active record.
+		const deadline = Date.now() + timeoutMs;
 		while (true) {
 			const record = this.records.get(id);
 			if (!record) return undefined;
 			if (record.status !== "running" && record.status !== "queued") return record;
-			if (record.promise)
-				await record.promise.catch((error) => {
-					logInternalError("subagent-manager.waitForRecord", error, `id=${id}`);
-				});
-			else await new Promise((resolve) => setTimeout(resolve, 100));
+			if (Date.now() > deadline) return record;
+			if (record.promise) {
+				// Race the run promise against the remaining deadline — a wedged
+				// promise must not block the deadline check.
+				const remaining = deadline - Date.now();
+				let timer: NodeJS.Timeout | undefined;
+				try {
+					await Promise.race([
+						record.promise.catch((error) => {
+							logInternalError("subagent-manager.waitForRecord", error, `id=${id}`);
+						}),
+						// RR-021 review remediation: this timer MUST stay ref'd. unref() let the
+						// event loop drain before the deadline fired (node:test then cancels the
+						// awaiting test — "Promise resolution is still pending but the event loop
+						// has already resolved"). Always clearTimeout'd in the finally below, so
+						// ref'ing cannot leak (knowledge.md OwnedProcess timer guidance).
+						new Promise<void>((resolve) => {
+							timer = setTimeout(resolve, remaining);
+						}),
+					]);
+				} finally {
+					if (timer !== undefined) clearTimeout(timer);
+				}
+			} else {
+				await new Promise((resolve) => setTimeout(resolve, Math.min(100, Math.max(1, deadline - Date.now()))));
+			}
 		}
 	}
 
@@ -477,19 +504,22 @@ export class SubagentManager {
 	}
 
 	private async pollRunToTerminal(cwd: string, record: SubagentRecord): Promise<void> {
-		// Safety: max 30 minutes (1800 polls at 1s interval) to prevent infinite
-		// polling if manifest file is deleted or run state becomes unrecoverable.
-		const MAX_POLL_COUNT = 1800;
-		let pollCount = 0;
+		// Safety: max 30 minutes of WALL-CLOCK polling to prevent infinite
+		// polling if the manifest file is deleted or run state becomes unrecoverable.
+		// (RR-021 WI-4.3h: was MAX_POLL_COUNT=1800, which silently assumed a 1s
+		// pollIntervalMs — but the interval is configurable, so a 5s interval
+		// polled for 2.5h while a 200ms interval timed out after 6 minutes.)
+		const POLL_DEADLINE_MS = 30 * 60 * 1000;
+		const pollDeadline = Date.now() + POLL_DEADLINE_MS;
 		while (record.runId && (record.status === "running" || record.status === "blocked")) {
-			if (++pollCount > MAX_POLL_COUNT) {
+			if (Date.now() > pollDeadline) {
 				logInternalError(
 					"subagent-manager.poll-timeout",
-					new Error(`pollRunToTerminal exceeded ${MAX_POLL_COUNT} polls for runId=${record.runId}`),
+					new Error(`pollRunToTerminal exceeded ${POLL_DEADLINE_MS}ms wall-clock for runId=${record.runId}`),
 					`id=${record.id}`,
 				);
 				record.status = "error";
-				record.error = `Poll timeout: run did not reach terminal state after ${MAX_POLL_COUNT} seconds`;
+				record.error = `Poll timeout: run did not reach terminal state after ${POLL_DEADLINE_MS}ms (wall-clock)`;
 				record.completedAt = Date.now();
 				savePersistedSubagentRecord(cwd, record);
 				return;

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

@@ -68,7 +68,7 @@ import { DEFAULT_RETRY_POLICY } from "../recovery/retry-executor.ts";
 import { runWorker } from "../run-worker.ts";
 import { parseSessionUsage } from "../session-usage.ts";
 import { recordSupervisorContact, supervisorContactFromEvent } from "../supervisor-contact.ts";
-import type { TaskExecutionResult } from "./post-execution.ts";
+import type { ResultSource, TaskExecutionResult } from "./post-execution.ts";
 import type { StreamBridgeHandle, TaskExecutionContext } from "./pre-execution.ts";
 import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
 import { cleanResultText, isFinalChildEvent } from "./result-utils.ts";
@@ -987,6 +987,20 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			});
 		}
 	}
+	// Finding #2 (2026-09-29 battery): tag WHICH fallback branch produced the
+	// artifact so post-execution can fail stderr/none-sourced results
+	// deterministically — the noise classifier alone is not a verdict oracle.
+	// Order/semantics are identical to the previous `??` chain: first branch
+	// whose cleaned text is non-empty wins; otherwise the placeholder ("none").
+	const resultCandidates: ReadonlyArray<{ source: ResultSource; text: string | undefined }> = [
+		{ source: "rawFinalText", text: cleanResultText(rawFinalText) },
+		{ source: "finalText", text: cleanResultText(parsedOutput?.finalText) },
+		{ source: "stdout", text: cleanResultText(finalStdout) },
+		{ source: "stderr", text: cleanResultText(finalStderr) },
+		{ source: "findings", text: cleanResultText(intermediateFindings) },
+	];
+	const usedResult = resultCandidates.find((candidate) => candidate.text);
+	const resultSource: ResultSource = usedResult?.source ?? "none";
 	const resultArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "result",
 		relativePath: `results/${task.id}.txt`,
@@ -995,14 +1009,10 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			// transcript's 16K compaction — this is the authoritative worker output.
 			// Fall back to transcript-derived finalText, then stdout/stderr, so a
 			// missing raw capture (mock/error path) never yields empty/garbage.
-			cleanResultText(rawFinalText) ??
-			cleanResultText(parsedOutput?.finalText) ??
-			cleanResultText(finalStdout) ??
-			cleanResultText(finalStderr) ??
+			usedResult?.text ??
 			// #7 hardening: if all real output paths are empty (worker exhausted
 			// budget on tool calls, no assistant text), use intermediate findings.
 			// intermediateFindings captures the last N tool-result display lines.
-			cleanResultText(intermediateFindings) ??
 			"(no output)",
 		producer: task.id,
 	});
@@ -1094,6 +1104,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		parsedOutput,
 		finalStdout,
 		rawFinalText,
+		resultSource,
 		transcriptPath,
 		terminalEvidence,
 		startupEvidence,