pi-crew 0.11.2 → 0.11.4

package/src/extension/team-tool/goal.ts

@@ -16,6 +16,7 @@
 
 import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
 import { GoalStore } from "../../runtime/goal-workflow/goal-state-store.ts";
+import { captureRunModelContext } from "../../runtime/model/session-model.ts";
 import { snapshotManifests } from "../../runtime/verification/verification-integrity.ts";
 import { isWorkspaceBusy } from "../../runtime/workspace-lock.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
@@ -173,6 +174,12 @@ async function handleStart(input: GoalSubActionInput): Promise<ReturnType<typeof
 		// runs/<goalId>/ → "Run not found" → silent death. (Review #2 F1.)
 		const paths = createRunPaths(cwd, goalId);
 		const now2 = new Date().toISOString();
+		// Finding #1 (battery 2026-09-29): the goal-loop manifest is loaded by the
+		// DETACHED background-runner (no ExtensionContext). Persist the parent
+		// session's model routing so goal-loop turns restore it instead of falling
+		// back to the default chain (minimax 402 incident family). goalState keeps
+		// workerModel/evaluatorModel as the explicit per-role picks.
+		const modelContext = captureRunModelContext(ctx, typeof params.model === "string" ? params.model : undefined);
 		const goalLoopManifest: TeamRunManifest = {
 			schemaVersion: 1,
 			runId: goalId, // paths.runId === goalId by construction
@@ -192,6 +199,7 @@ async function handleStart(input: GoalSubActionInput): Promise<ReturnType<typeof
 			artifacts: [],
 			ownerSessionId,
 			runKind: "goal-loop",
+			...(modelContext ? { modelContext } : {}),
 		};
 		await saveRunManifestAsync(goalLoopManifest);
 		await appendEventAsync(paths.eventsPath, {
@@ -449,6 +457,9 @@ async function handleResume(input: GoalSubActionInput): Promise<ReturnType<typeo
 	// Re-spawn the background loop. The loop checks goal.state === "running" before each
 	// turn; since we just set it to running, it proceeds.
 	try {
+		// Finding #1: re-capture at resume time (same battery) — the resuming
+		// session's live model is authoritative for subsequent turns.
+		const modelContext = captureRunModelContext(ctx, typeof params.model === "string" ? params.model : undefined);
 		const manifest: TeamRunManifest = {
 			schemaVersion: 1,
 			runId: goalId,
@@ -468,6 +479,7 @@ async function handleResume(input: GoalSubActionInput): Promise<ReturnType<typeo
 			artifacts: [],
 			ownerSessionId: existing.ownerSessionId,
 			runKind: "goal-loop",
+			...(modelContext ? { modelContext } : {}),
 		};
 		const spawned = await spawnBackgroundTeamRun(manifest);
 		return result(

package/src/extension/team-tool/parallel-dispatch.ts

@@ -10,6 +10,7 @@ import { discoverAgents } from "../../agents/discover-agents.ts";
 import { loadConfig } from "../../config/config.ts";
 import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
 import { resolveCrewRuntime } from "../../runtime/model/runtime-resolver.ts";
+import { captureRunModelContext } from "../../runtime/model/session-model.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEventAsync } from "../../state/event-log/event-log.ts";
 import { createRunManifest } from "../../state/stores/state-store.ts";
@@ -66,13 +67,23 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 
 	const runtime = await resolveCrewRuntime(config.config);
 
+	// Finding #1 (full battery 2026-09-29): parallel-dispatched runs re-enter
+	// through the detached background-runner, which has no ExtensionContext.
+	// Without a persisted modelContext, restoredModelRouting() returns {} and
+	// every worker silently falls back to the DEFAULT chain (live: 3 runs died
+	// on minimax/MiniMax-M3 402 while the parent session ran zai/glm-5.3).
+	// Captured ONCE here (in the parent session's process) so resolveParentModel()
+	// sees the live session model; undefined when nothing is worth persisting
+	// (older manifests stay byte-identical).
+	const modelContext = captureRunModelContext(ctx, typeof params.model === "string" ? params.model : undefined);
+
 	const launched: Array<{ runId: string; goal: string; agent: string }> = [];
 	const errors: Array<{ goal: string; error: string }> = [];
 
 	// C1: Enforce concurrency limit with batched spawning
 	for (let batchStart = 0; batchStart < tasksParam.length; batchStart += concurrency) {
 		const batch = tasksParam.slice(batchStart, batchStart + concurrency);
-		const batchPromises = batch.map((task) => spawnSingleTask(task, ctx, allAgentsList, team, workflow, runtime));
+		const batchPromises = batch.map((task) => spawnSingleTask(task, ctx, allAgentsList, team, workflow, runtime, modelContext));
 		const batchResults = await Promise.allSettled(batchPromises);
 		for (const res of batchResults) {
 			if (res.status === "fulfilled" && res.value.ok) {
@@ -121,6 +132,7 @@ async function spawnSingleTask(
 	team: TeamConfig,
 	workflow: WorkflowConfig,
 	runtime: { available: boolean; kind: string },
+	modelContext: ReturnType<typeof captureRunModelContext>,
 ): Promise<SpawnResult> {
 	try {
 		const taskRec = task as Record<string, unknown>;
@@ -163,6 +175,9 @@ async function spawnSingleTask(
 			// skipped and any session can cancel/retry parallel-dispatched runs.
 			ownerSessionId: ctx.sessionId,
 			runKind: "team-run",
+			// Finding #1: persist the parent session's model routing so the detached
+			// runner restores it instead of default-chaining (see handleParallel).
+			modelContext,
 		});
 
 		await appendEventAsync(created.manifest.eventsPath, {

package/src/extension/team-tool/run-intent.ts

@@ -73,7 +73,7 @@ const MAX_ANALYSIS_BYTES = 100_000;
 var crewInitPromise: Promise<typeof import("../../state/crew-init.ts")> | undefined;
 function loadCrewInit(): Promise<typeof import("../../state/crew-init.ts")> {
 	if (!crewInitPromise) {
-		crewInitPromise = import("../../state/crew-init.ts");
+		crewInitPromise = import("../../state/crew-init.ts"); // LAZY: defer crew-init until first run intent
 	}
 	return crewInitPromise;
 }

package/src/extension/team-tool/run.ts

@@ -61,7 +61,7 @@ import type { RuntimeResolutionState, TeamRunManifest, TeamTaskState } from "../
 var crewInitPromise: Promise<typeof import("../../state/crew-init.ts")> | undefined;
 function loadCrewInit(): Promise<typeof import("../../state/crew-init.ts")> {
 	if (!crewInitPromise) {
-		crewInitPromise = import("../../state/crew-init.ts");
+		crewInitPromise = import("../../state/crew-init.ts"); // LAZY: defer crew-init until first run intent
 	}
 	return crewInitPromise;
 }

package/src/runtime/async-runner.ts

@@ -240,6 +240,16 @@ export const BACKGROUND_RUNNER_ENV_ALLOWLIST: string[] = [
 	"HERDR_SOCKET_PATH",
 	"HERDR_WORKSPACE_ID",
 	"HERDR_PING_TIMEOUT_MS",
+	// Model-selection control vars (Finding #1, full battery 2026-09-29): the
+	// detached runner resolves subagent model routing from env (PI_CREW_MODEL →
+	// resolveDefaultSubagentModel; PI_CREW_MODEL_FALLBACK_ORDER →
+	// resolveModelFallbackPolicy) for manifests without a persisted modelContext
+	// (older manifests) and as a user override channel. Stripping them made
+	// every async run silently fall back to the DEFAULT chain (live: 3 parallel
+	// runs died on minimax/MiniMax-M3 402 while the parent ran zai/glm-5.3).
+	// PI_CREW_MODEL_REQUIRE_CREDENTIALS is NOT here — see forwardModelControlEnv.
+	"PI_CREW_MODEL",
+	"PI_CREW_MODEL_FALLBACK_ORDER",
 ];
 
 /**
@@ -256,6 +266,29 @@ export function buildBackgroundRunnerEnv(env: NodeJS.ProcessEnv): NodeJS.Process
 	return { ...env, PI_CREW_ASYNC_RUN: "1" };
 }
 
+/**
+ * Model-selection control vars that CANNOT live on
+ * {@link BACKGROUND_RUNNER_ENV_ALLOWLIST}: isSecretKey() matches the
+ * "_CREDENTIALS" suffix of PI_CREW_MODEL_REQUIRE_CREDENTIALS (keyword
+ * "credential"), and sanitizeEnvSecrets THROWS on secret-looking allowlist
+ * entries that are absent from the spawning env — so allowlisting it would
+ * break EVERY async spawn whenever the flag is unset. It is a declared
+ * control flag (config/env-vars.ts, read by resolveModelFallbackPolicy),
+ * never a secret, so we forward it explicitly when set instead.
+ * Exported pure so tests pin the contract (async-runner.test.ts).
+ */
+export const MODEL_CONTROL_ENV_EXPLICIT: readonly string[] = ["PI_CREW_MODEL_REQUIRE_CREDENTIALS"];
+
+/** Copy the explicitly-forwarded model control vars (set ones only). */
+export function forwardModelControlEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	const forwarded: NodeJS.ProcessEnv = {};
+	for (const key of MODEL_CONTROL_ENV_EXPLICIT) {
+		const value = env[key];
+		if (value !== undefined) forwarded[key] = value;
+	}
+	return forwarded;
+}
+
 /** F4 v2: the ONE line written to the background-runner's stdin carrying
  * PER-TASK compound broker tokens (see stdin-handshake.ts for why compound —
  * ADR-0 item 6 rejects bare-runId tokens for wait.*). Kept pure + exported so
@@ -377,6 +410,9 @@ export async function spawnBackgroundTeamRun(manifest: TeamRunManifest): Promise
 	const childEnv = buildBackgroundRunnerEnv({
 		...(peerDepDir ? { ...filteredEnv, [PEER_DEP_DIR_ENV]: peerDepDir } : filteredEnv),
 		PI_CREW_BACKGROUND_RUNNER_ENTRY: "1",
+		// Finding #1: model control vars that cannot ride the allowlist (see
+		// forwardModelControlEnv). Copied from the ORIGINAL env, post-sanitize.
+		...forwardModelControlEnv(process.env),
 	});
 
 	const loader = resolveTypeScriptLoader();

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,