pi-crew 0.11.2 → 0.11.5

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

@@ -28,7 +28,7 @@ import { withRunLockSync } from "../../state/coordination/locks.ts";
 import { appendMailboxMessageAsync, type MailboxMessage, registerMailboxAppendObserver } from "../../state/coordination/mailbox.ts";
 import { appendEventAsync } from "../../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunManifest, saveRunTasks } from "../../state/stores/state-store.ts";
-import type { TeamTaskState } from "../../state/types.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import { runEventBus } from "../../ui/run-event-bus.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { BrokerError, encodeBrokerFrame, MAX_BROKER_FRAME_BYTES, NdjsonDecoder } from "../../utils/ndjson.ts";
@@ -40,11 +40,12 @@ import { resolveCrewMaxDepth } from "../model/pi-args.ts";
 import { NestedSlotBudget } from "../scheduling/nested-slots.ts";
 import { evaluateDelegateAdmission } from "../spawn-policy.ts";
 import { type BrokerToken, BrokerTokenRegistry } from "./crew-broker-tokens.ts";
-import { recordDelegateEvent } from "./delegate/delegate-event.ts";
+import { type DelegateEventTarget, type DelegateEventType, recordDelegateEvent } from "./delegate/delegate-event.ts";
 import { promoteShadowToRunning } from "./delegate/shadow-lifecycle.ts";
 import { fanoutMailboxMessage } from "./mailbox-observer/mailbox-fanout.ts";
 import type { CrewBrokerOptions, ServerConnection } from "./protocol/connection-state.ts";
 import { handleEventsSince } from "./protocol/events-replay.ts";
+import { DEFAULT_LOCK_BUSY_RETRY_DELAYS_MS, type LockBusyOutcome, withRunLockBusyRetry } from "./protocol/lock-busy.ts";
 import { loadRunForHello } from "./protocol/manifest-loader.ts";
 import { handleMsgInbox } from "./protocol/msg-inbox.ts";
 import {
@@ -104,6 +105,7 @@ export class CrewBroker {
 			| "grandchildSpawner"
 			| "modelCatalog"
 			| "serializeOnPathOverlap"
+			| "lockBusyRetryDelaysMs"
 		>;
 	private readonly tokens = new BrokerTokenRegistry();
 	/** Task 10 (mux-surface A1 §5.2): taskId → the compound token most
@@ -1332,28 +1334,31 @@ export class CrewBroker {
 	}
 
 	// WP-2/R2: wait.request / wait.resolve (ADR-0 2026-08-17-waiting-producer-ask)
+	// waitAuthError: imported directly from protocol/wait-auth.ts (M4/WI-4.1).
 
-	// waitAuthError: protocol/wait-auth.ts (M4/WI-4.1).
-	private waitAuthError(conn: ServerConnection): { code: string; message: string } | null {
-		return waitAuthError(conn);
-	}
-
-	// (The "ADR item 7" doc that used to dangle here documents
-	// recordWaitPolicyRejection — see wait-auth.ts, where it belongs.
-	// Removed 2026-09-10, review F6.)
 	// T3/R5 (ADR-5): delegate.request — governed-nesting admission + background
 	// grandchild spawn with durable mailbox delivery (WP-5 step 5).
-	// getDelegateNestedSlots: inlined at 4 call sites (5-line method; M4/WI-4.1).
+
+	/** ADR-5 §5: lazy singleton for the nested-slot budget — first use
+	 *  constructs it from the broker options (4 call sites previously
+	 *  inlined this IIFE). */
+	private nestedSlotBudget(): NestedSlotBudget {
+		if (!this.nestedSlots)
+			this.nestedSlots = new NestedSlotBudget(this.options.globalWorkerSemaphore ?? 4, this.options.nestingMaxSlots);
+		return this.nestedSlots;
+	}
+
+	/** RR-023 F4: bounded busy-retry around a run-locked RMW (see
+	 *  protocol/lock-busy.ts) — options override or the default schedule.
+	 *  A busy-exhausted result is the handler's cue to answer a typed `busy`
+	 *  frame (connection survives) instead of letting the throw kill it. */
+	private runLockBusyRetry<T>(manifest: TeamRunManifest, fn: () => T): Promise<LockBusyOutcome<T>> {
+		return withRunLockBusyRetry(manifest, this.options.lockBusyRetryDelaysMs ?? DEFAULT_LOCK_BUSY_RETRY_DELAYS_MS, fn);
+	}
 
 	private recordDelegateEvent(
-		manifest: { eventsPath: string; runId: string },
-		type:
-			| "delegate.requested"
-			| "delegate.admitted"
-			| "delegate.rejected"
-			| "delegate.completed"
-			| "delegate.timed_out"
-			| "delegate.rolled_up",
+		manifest: DelegateEventTarget,
+		type: DelegateEventType,
 		taskId: string,
 		data: Record<string, unknown>,
 	): void {
@@ -1434,7 +1439,8 @@ export class CrewBroker {
 		this.recordDelegateEvent(loaded.manifest, "delegate.requested", parentTaskId, { subId, role: requested.role ?? "explorer" });
 		// Admission: full spawn-policy matrix (ADR-5 §2-§7), parent state from
 		// the RECORD under the run lock — never the worker's env/self-report.
-		const admissionOutcome = withRunLockSync(loaded.manifest, () => {
+		// RR-023 F4: run-locked via bounded busy-retry (protocol/lock-busy.ts).
+		const admissionAttempt = await this.runLockBusyRetry(loaded.manifest, () => {
 			const fresh = loadRunManifestById(loaded.manifest.cwd, runId);
 			if (!fresh) return { code: "no-manifest" as const, message: `run '${runId}' not found` };
 			const task = fresh.tasks.find((t) => t.id === parentTaskId);
@@ -1474,11 +1480,7 @@ export class CrewBroker {
 					...(task.depth !== undefined ? { depth: task.depth } : {}),
 					...(task.allocation !== undefined ? { allocation: task.allocation } : {}),
 				},
-				slots: (() => {
-					if (!this.nestedSlots)
-						this.nestedSlots = new NestedSlotBudget(this.options.globalWorkerSemaphore ?? 4, this.options.nestingMaxSlots);
-					return this.nestedSlots;
-				})().snapshot(),
+				slots: this.nestedSlotBudget().snapshot(),
 				requested,
 				...(effectiveCatalog !== undefined ? { modelCatalog: effectiveCatalog } : {}),
 				// ADR-5 §12: the delegate surface is an escalation — trusted only by the
@@ -1498,28 +1500,11 @@ export class CrewBroker {
 				return { code: "policy-denied" as const, message: decision.message ?? decision.reason ?? "delegate denied" };
 			}
 			// Slot acquisition INSIDE the lock (no reserve-then-race refund window).
-			if (
-				!(() => {
-					if (!this.nestedSlots)
-						this.nestedSlots = new NestedSlotBudget(this.options.globalWorkerSemaphore ?? 4, this.options.nestingMaxSlots);
-					return this.nestedSlots;
-				})().tryAcquire(subId)
-			) {
+			if (!this.nestedSlotBudget().tryAcquire(subId)) {
 				this.recordDelegateEvent(fresh.manifest, "delegate.rejected", parentTaskId, { subId, reason: "slots-exhausted" });
 				return {
 					code: "policy-denied" as const,
-					message: `delegate rejected: nested spawn budget exhausted; ${
-						(
-							() => {
-								if (!this.nestedSlots)
-									this.nestedSlots = new NestedSlotBudget(
-										this.options.globalWorkerSemaphore ?? 4,
-										this.options.nestingMaxSlots,
-									);
-								return this.nestedSlots;
-							}
-						)().statusLine
-					}`,
+					message: `delegate rejected: nested spawn budget exhausted; ${this.nestedSlotBudget().statusLine}`,
 				};
 			}
 			// Reserve the requested budget pessimistically (ADR-5 §5): tokensSpent
@@ -1562,13 +1547,23 @@ export class CrewBroker {
 					startedAt: new Date().toISOString(),
 				} satisfies TeamTaskState,
 			]);
-			return { code: "ok" as const, decision, reserved, executionCwd };
+			// RR-023 F3: thread the parent's model out of the locked read (gc fallback).
+			return { code: "ok" as const, decision, reserved, executionCwd, parentModel: task.model };
 		});
+		// RR-023 F4 (finding #4): run.lock held by a live cross-process holder —
+		// degrade to a typed busy frame AND a delegate.rejected event (never
+		// silent); the connection survives (ping still answers).
+		if (!admissionAttempt.ok) {
+			this.recordDelegateEvent(loaded.manifest, "delegate.rejected", parentTaskId, { subId, reason: "run-lock-busy" });
+			this.sendError(conn, id, "busy", admissionAttempt.message);
+			return;
+		}
+		const admissionOutcome = admissionAttempt.value;
 		if (admissionOutcome.code !== "ok") {
 			this.sendError(conn, id, admissionOutcome.code, admissionOutcome.message);
 			return;
 		}
-		const { decision, reserved, executionCwd } = admissionOutcome;
+		const { decision, reserved, executionCwd, parentModel } = admissionOutcome;
 		this.recordDelegateEvent(loaded.manifest, "delegate.admitted", parentTaskId, {
 			subId,
 			childDepth: decision.childDepth,
@@ -1584,6 +1579,9 @@ export class CrewBroker {
 				: undefined;
 		// Return IMMEDIATELY (principle 7): the tool self-polls the mailbox.
 		this.sendResult(conn, id, { ok: true, grandchildTaskRef: subId, childDepth: decision.childDepth, timeoutSec: decision.timeoutSec });
+		// RR-023 F3 (finding #3, run team_20260929041427): model-less gc spawn fell
+		// through to the pi GLOBAL default — inherit the parent task's model.
+		const gcModel = requested.model ?? parentModel;
 		// Background grandchild lifecycle (ADR-5 §1/§6).
 		const spawner = this.options.grandchildSpawner ?? spawnDelegateGrandchild;
 		void (async () => {
@@ -1598,7 +1596,7 @@ export class CrewBroker {
 					eventsPath: loaded.manifest.eventsPath,
 					role: requested.role ?? "explorer",
 					...(grandchildCreds ? { brokerSpawn: grandchildCreds } : {}),
-					...(requested.model !== undefined ? { model: requested.model } : {}),
+					...(gcModel !== undefined ? { model: gcModel } : {}),
 					...(requested.maxTurns !== undefined ? { maxTurns: requested.maxTurns } : {}),
 					timeoutSec: decision.timeoutSec ?? 900,
 					depthOverride: decision.childDepth ?? 2,
@@ -1711,11 +1709,7 @@ export class CrewBroker {
 					}
 				}
 			} finally {
-				(() => {
-					if (!this.nestedSlots)
-						this.nestedSlots = new NestedSlotBudget(this.options.globalWorkerSemaphore ?? 4, this.options.nestingMaxSlots);
-					return this.nestedSlots;
-				})().release(subId);
+				this.nestedSlotBudget().release(subId);
 			}
 			this.recordDelegateEvent(loaded.manifest, outcome.timedOut ? "delegate.timed_out" : "delegate.completed", parentTaskId, {
 				subId,
@@ -1724,9 +1718,7 @@ export class CrewBroker {
 		})();
 	}
 
-	private recordWaitPolicyRejection(manifest: { eventsPath: string; runId: string }, taskId: string, method: string): void {
-		recordWaitPolicyRejection(manifest, taskId, method);
-	}
+	// recordWaitPolicyRejection: imported directly from protocol/wait-auth.ts.
 
 	/** WP-2/R2 step 4: park the calling task while its `ask` tool awaits a
 	 *  leader answer. Park = task.status "waiting" + task.waiting marker +
@@ -1741,7 +1733,7 @@ export class CrewBroker {
 			this.sendError(conn, id, "auth", "not authed");
 			return;
 		}
-		const authErr = this.waitAuthError(conn);
+		const authErr = waitAuthError(conn);
 		if (authErr) {
 			this.sendError(conn, id, authErr.code, authErr.message);
 			return;
@@ -1778,7 +1770,7 @@ export class CrewBroker {
 		// Capability gate (ADR item 7): fail-closed, NEVER silent — every
 		// rejection leaves a policy.action trace in the run's events.jsonl.
 		if (this.options.waitMethodsEnabled !== true) {
-			this.recordWaitPolicyRejection(loaded.manifest, conn.taskId, "wait.request");
+			recordWaitPolicyRejection(loaded.manifest, conn.taskId, "wait.request");
 			this.sendError(
 				conn,
 				id,
@@ -1796,7 +1788,8 @@ export class CrewBroker {
 		const deadline = Date.now() + clampSec * 1000;
 		const runId = conn.runId;
 		const taskId = conn.taskId;
-		const outcome = withRunLockSync(loaded.manifest, () => {
+		// RR-023 F4: run-locked via bounded busy-retry (protocol/lock-busy.ts).
+		const outcome = await this.runLockBusyRetry(loaded.manifest, () => {
 			// Fresh reload INSIDE the lock (respond.ts:42-43 discipline).
 			const fresh = loadRunManifestById(loaded.manifest.cwd, runId);
 			if (!fresh) return { code: "no-manifest" as const, message: `run '${runId}' not found` };
@@ -1829,8 +1822,14 @@ export class CrewBroker {
 			saveRunManifest(updatedManifest);
 			return { code: "ok" as const, message: "" };
 		});
-		if (outcome.code !== "ok") {
-			this.sendError(conn, id, outcome.code, outcome.message);
+		// RR-023 F4 (finding #4): run.lock held by a live cross-process holder
+		// (e.g. the detached runner) — typed busy frame, connection survives.
+		if (!outcome.ok) {
+			this.sendError(conn, id, "busy", outcome.message);
+			return;
+		}
+		if (outcome.value.code !== "ok") {
+			this.sendError(conn, id, outcome.value.code, outcome.value.message);
 			return;
 		}
 		// Events AFTER the run lock is released (the event-log lock is a
@@ -1895,7 +1894,7 @@ export class CrewBroker {
 			this.sendError(conn, id, "auth", "not authed");
 			return;
 		}
-		const authErr = this.waitAuthError(conn);
+		const authErr = waitAuthError(conn);
 		if (authErr) {
 			this.sendError(conn, id, authErr.code, authErr.message);
 			return;
@@ -1928,7 +1927,7 @@ export class CrewBroker {
 			return;
 		}
 		if (this.options.waitMethodsEnabled !== true) {
-			this.recordWaitPolicyRejection(loaded.manifest, conn.taskId, "wait.resolve");
+			recordWaitPolicyRejection(loaded.manifest, conn.taskId, "wait.resolve");
 			this.sendError(
 				conn,
 				id,

package/src/runtime/broker/delegate/delegate-event.ts

@@ -13,15 +13,19 @@ import { logInternalError } from "../../../utils/internal-error.ts";
 /** Fire-and-forget async append; an append failure is logged, never thrown
  *  (broker handlers must not block the event loop on the sync event-log lock).
  *  See `crew-broker.delegate.event` event scope conventions in ADR-5 §10. */
+export type DelegateEventType =
+	| "delegate.requested"
+	| "delegate.admitted"
+	| "delegate.rejected"
+	| "delegate.completed"
+	| "delegate.timed_out"
+	| "delegate.rolled_up";
+
+export type DelegateEventTarget = { eventsPath: string; runId: string };
+
 export function recordDelegateEvent(
-	manifest: { eventsPath: string; runId: string },
-	type:
-		| "delegate.requested"
-		| "delegate.admitted"
-		| "delegate.rejected"
-		| "delegate.completed"
-		| "delegate.timed_out"
-		| "delegate.rolled_up",
+	manifest: DelegateEventTarget,
+	type: DelegateEventType,
 	taskId: string,
 	data: Record<string, unknown>,
 ): void {

package/src/runtime/broker/protocol/connection-state.ts

@@ -55,6 +55,16 @@ export interface CrewBrokerOptions {
 	nestingTrustedEscalation?: boolean;
 	/** Global worker semaphore size, used to size the nested-slot budget. */
 	globalWorkerSemaphore?: number;
+	/** RR-023 F4 (2026-09-29 battery, finding #4): bounded retry schedule
+	 *  (ms) for run.lock contention in the wait.request / delegate.request
+	 *  handlers. A live cross-process holder (e.g. the detached runner
+	 *  persisting task state) makes acquireLockWithRetry throw; instead of
+	 *  letting that escape handleData → closeConnection, the handler retries
+	 *  on this schedule and then answers a typed `busy` error frame with the
+	 *  connection SURVIVING (plus a delegate.rejected event on the delegate
+	 *  path — never silent). Default DEFAULT_LOCK_BUSY_RETRY_DELAYS_MS
+	 *  (50/100/200/400/800). See protocol/lock-busy.ts. */
+	lockBusyRetryDelaysMs?: readonly number[];
 	/** Test seam / alternative spawner for delegate grandchildren. Production
 	 *  uses spawnDelegateGrandchild (direct runChildPi call-site, ADR-5 §2). */
 	grandchildSpawner?: (input: GrandchildSpawnInput) => Promise<GrandchildSpawnResult>;

package/src/runtime/broker/protocol/lock-busy.ts

@@ -0,0 +1,76 @@
+/**
+ * lock-busy.ts — RR-023 F4 (2026-09-29 full battery, finding #4).
+ *
+ * Broker-handler degradation for run.lock contention. Root cause: the
+ * wait.request / delegate.request handlers run their state RMW inside
+ * withRunLockSync; acquireLockWithRetry (locks.ts, canSteal=false) throws
+ * IMMEDIATELY when a live cross-process holder (e.g. the detached runner
+ * persisting task state) owns run.lock, and that throw escaped handleData →
+ * closeConnection — workers saw an untyped `code=close` socket death
+ * (evidence: team_20260929041005 ask-probe / team_20260929041020
+ * delegate-probe, both dead within ~5ms; the SYNC foreground run was the
+ * zero-contention control).
+ *
+ * Fix layer is the broker ONLY — locks.ts steal semantics are the v0.9.26
+ * lock-family invariant and stay untouched (a live holder is never stolen).
+ * Precedent: protocol/request-parsers.ts (M4/WI-4.1 extraction discipline).
+ */
+
+import { withRunLockSync } from "../../../state/coordination/locks.ts";
+import type { TeamRunManifest } from "../../../state/types.ts";
+
+/** Default bounded retry schedule for run.lock contention (ms). Five
+ *  back-off attempts (~1.55s total) absorb a transient holder — e.g. the
+ *  detached runner's state flush — without parking the request. */
+export const DEFAULT_LOCK_BUSY_RETRY_DELAYS_MS: readonly number[] = [50, 100, 200, 400, 800];
+
+/** Match the exact identity locks.ts throws for a LIVE holder on the
+ *  never-steal path (sync acquireLockWithRetry, its async twin, and the
+ *  lockCtx fallthrough): `Run '<basename>' is locked by another operation.`
+ *  Classification is by message identity — locks.ts exports no error class
+ *  (plain Error), and src/state must not be edited from the broker layer. */
+const RUN_LOCK_BUSY_MESSAGE = /^Run '[^']+' is locked by another operation\.$/;
+
+export function isRunLockBusyError(error: unknown): boolean {
+	return error instanceof Error && RUN_LOCK_BUSY_MESSAGE.test(error.message);
+}
+
+/** Result of a run-locked RMW under the busy-retry policy: either the body's
+ *  value, or the typed busy degradation (message derived from the underlying
+ *  lock error — it names run.lock, so it matches /run\.lock|busy/i). */
+export type LockBusyOutcome<T> = { ok: true; value: T } | { ok: false; message: string };
+
+/** Run `fn` under withRunLockSync with a bounded busy-retry.
+ *
+ *  Retry safety: the busy throw is raised by the lock ACQUIRE before `fn`
+ *  runs (locks.ts), and in the broker's wait/delegate bodies every nested
+ *  state write is lockCtx-reentrant (same-context nesting never re-acquires),
+ *  so a retry never re-executes a partially-run body. Any NON-busy error
+ *  propagates unchanged (previous handler behavior for real faults).
+ *  Waits use async sleep — the broker event loop keeps serving other
+ *  connections (and pings) between attempts. */
+export async function withRunLockBusyRetry<T>(
+	manifest: TeamRunManifest,
+	delaysMs: readonly number[],
+	fn: () => T,
+): Promise<LockBusyOutcome<T>> {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			return { ok: true, value: withRunLockSync(manifest, fn) };
+		} catch (error) {
+			if (!isRunLockBusyError(error)) throw error;
+			const delay = delaysMs[attempt];
+			if (delay === undefined) {
+				return {
+					ok: false,
+					message: `run.lock busy (bounded retry budget exhausted): ${(error as Error).message}`,
+				};
+			}
+			await sleep(delay);
+		}
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/runtime/delegate-spawn.ts

@@ -95,6 +95,21 @@ export function grandchildArtifactsRoot(cwd: string, runId: string, parentTaskId
 	return path.join(cwd, ".crew", "artifacts", runId, parentTaskId, "nested", subId);
 }
 
+/** RR-023 F3 (2026-09-29 battery finding #3): derive the relayed grandchild
+ *  result text from a ChildPiRunResult — pure so it is unit-testable without
+ *  spawning. Same precedence as the original inline expression at the capture
+ *  site: rawFinalText → stdout → stderr (failure only).
+ *  Diagnosability guard: exit 0 with ZERO assistant text (run
+ *  team_20260929041427: the model-less gc fell through to the pi global default
+ *  and returned empty completions) used to fence an EMPTY mailbox body —
+ *  indistinguishable from a relay bug. An explicit marker keeps the relay
+ *  honest; the real fix (parent-model inheritance) lives in the broker. */
+export function grandchildResultText(result: ChildPiRunResult): string {
+	const ok = result.exitCode === 0;
+	const text = (result.rawFinalText ?? result.stdout ?? "").trim() || (ok ? "" : result.stderr.trim());
+	return ok && text === "" ? "[grandchild exited 0 with no assistant output]" : text;
+}
+
 export async function spawnDelegateGrandchild(input: GrandchildSpawnInput): Promise<GrandchildSpawnResult> {
 	// RR-012 F03: single artifacts formula — grandchildArtifactsRoot(input.cwd, …).
 	// input.cwd is the PARENT TASK cwd threaded by the broker (the admitted
@@ -137,8 +152,7 @@ export async function spawnDelegateGrandchild(input: GrandchildSpawnInput): Prom
 			onSpawn: input.onSpawn,
 		});
 		const ok = result.exitCode === 0;
-		const text = (result.rawFinalText ?? result.stdout ?? "").trim() || (ok ? "" : result.stderr.trim());
-		return { ok, resultText: text, ...(usageTokens !== undefined ? { usageTokens } : {}) };
+		return { ok, resultText: grandchildResultText(result), ...(usageTokens !== undefined ? { usageTokens } : {}) };
 	} catch (error) {
 		const timedOut = abort.signal.aborted;
 		return {

package/src/runtime/deterministic-ast.ts

@@ -17,9 +17,21 @@
  * parse error downstream. We don't double-report parse errors.
  */
 
-import { parse } from "acorn";
+import { createRequire } from "node:module";
 import { getCrewEnv } from "../config/env-vars.ts";
 
+// RR-021 WI-2.1: acorn parses ONLY when the determinism check actually runs —
+// every dynamic-workflow-runner import was paying acorn's load cost up front.
+// Lazy sync accessor (model: ui/syntax-highlight.ts); acorn stays external in
+// the bundle and resolves through this shim on first use.
+const require = createRequire(import.meta.url);
+type AcornModule = typeof import("acorn");
+let cachedAcorn: AcornModule | undefined;
+function acorn(): AcornModule {
+	if (!cachedAcorn) cachedAcorn = require("acorn") as AcornModule;
+	return cachedAcorn;
+}
+
 const NONDETERMINISM_ERROR =
 	"Workflow scripts must be deterministic: Date.now()/Math.random()/new Date() are unavailable. These introduce non-reproducible behavior across runs. Use ctx.vars for cached state, or pass a fixed seed via ctx.setArgs(). To bypass this check (escape hatch), set PI_CREW_DWF_SKIP_DETERMINISM_CHECK=1.";
 
@@ -38,7 +50,7 @@ export class DeterminismError extends Error {
 export function assertDeterministicScript(script: string): void {
 	let ast: AstNode;
 	try {
-		ast = parse(script, {
+		ast = acorn().parse(script, {
 			ecmaVersion: "latest",
 			sourceType: "module",
 			allowAwaitOutsideFunction: true,

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