@zq-silk/yui 0.10.0 → 0.11.0

package/dist/commands/taskCommands.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createRunAssignment } from "../context/runContextContract.js";
-import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeExecutionStageContextSnapshot, freezeReviewStageContextSnapshot, freezeRunContextSnapshot } from "../context/runContextPack.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -23,7 +23,7 @@ import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchAct
 import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
 import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
-import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryRunningReviewExecutionLane, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
@@ -34,7 +34,7 @@ import { runPublicationCommand } from "./taskPublicationCommands.js";
 import { enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { mailboxHasWork as workMailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { blockingProviderContinuations, projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
+import { blockingProviderContinuations, projectProviderContinuations, runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
@@ -42,8 +42,11 @@ import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publica
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
-import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
-import { addExecutionLane, createExecutionGroup, resolveExecutionGroup, restartExecutionLane, updateExecutionLane } from "../execution/executionGroup.js";
+import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, planWorkItemExplorationStage, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
+import { addExecutionLane, createExecutionGroup, queueExecutionLaneRetry, resolveExecutionGroup, restartExecutionLane, skipPendingExecutionLanes, updateExecutionLane, WORK_ITEM_EXECUTION_MODES } from "../execution/executionGroup.js";
+import { executionStageSpendClosed, observedExecutionResourceUsage, planResourceAdmissions, projectExecutionStageResources, resolveResourceBrokerPolicy, routeExecutionStage } from "../execution/resourceBroker.js";
+import { resolveContextBudget, resolveControllerTaskConcurrency, resolveRuntimeHealth } from "../config/yuiConfig.js";
+import { assertIndependentVerificationRoles, candidateConvergenceEvidenceSufficient, candidateConvergenceDirective, validateCandidateConvergenceResolution } from "../execution/candidateConvergence.js";
 import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { classifyReviewRoundOutcome, isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT, createTaskFinalReviewContractRebind, resolveRecordedTaskFinalReviewContract, taskFinalReviewContractRebindPayload } from "../review/taskFinalReviewContractRebind.js";
@@ -62,7 +65,7 @@ import { taskActor as resolveTaskActor, taskLeaderActionRunId } from "./taskActo
 import { createTaskTerminalNotification } from "../scheduler/operatorNotification.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
-import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition } from "../scheduler/actionability.js";
+import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition, projectQueuedResourceLaneIdentities } from "../scheduler/actionability.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { buildTaskOverview, parseTaskListOptions, renderTaskOverview } from "./taskOverviewCommand.js";
 const LEADER_ROLE = "leader";
@@ -277,30 +280,76 @@ export function normalizedExecutionLaneRoles(assignee, requestedRoles, expanding
         ? [...requestedRoles]
         : [assignee, ...requestedRoles];
 }
+/** A bounded same-stage retry repeats the frozen topology and Lane owners. */
+export function resolvedExecutionStageRetryGroup(group) {
+    if (group?.stage === undefined || group.resolution === undefined)
+        return undefined;
+    if (group.resolution.decision !== "retry"
+        && group.resolution.decision !== "blocked")
+        return undefined;
+    return group.stage.stage === "resolve" && group.resolution.decision === "retry"
+        ? undefined
+        : group;
+}
 /** Derive the complete Worker Lane plan once for both preflight and mutation. */
 export function normalizedExecutionLanePlan(input) {
     const retry = input.phase === "retry" || input.retryLaneId !== undefined;
-    const expanding = !retry && input.status === "running" && input.existingGroup !== undefined;
+    const queued = !retry && input.status === "running" && input.existingGroup !== undefined
+        && input.requestedRoles.length === 0
+        ? input.existingGroup.lanes.filter(({ status, effective }) => (status === "pending" && effective !== undefined))
+        : [];
+    const resumingQueued = queued.length > 0;
+    const expanding = !retry
+        && !resumingQueued
+        && input.status === "running"
+        && input.existingGroup !== undefined;
     const roles = retry
         ? []
-        : normalizedExecutionLaneRoles(input.assignee, input.requestedRoles, expanding);
+        : resumingQueued
+            ? queued.map(({ roleName }) => roleName)
+            : input.resolvedRetryGroup !== undefined && input.requestedRoles.length === 0
+                ? input.resolvedRetryGroup.lanes.map(({ roleName }) => roleName)
+                : normalizedExecutionLaneRoles(input.assignee, input.requestedRoles, expanding);
     const strategy = input.existingGroup?.strategy
         ?? input.requestedStrategy
+        ?? input.resolvedRetryGroup?.strategy
         ?? { mode: "fixed", count: roles.length };
     const capacity = strategy.mode === "fixed" ? strategy.count : strategy.max;
     const requestedCount = retry
         ? input.existingGroup?.lanes.length ?? 0
-        : expanding
-            ? input.existingGroup.lanes.length + roles.length
-            : roles.length;
+        : resumingQueued
+            ? input.existingGroup.lanes.length
+            : expanding
+                ? input.existingGroup.lanes.length + roles.length
+                : roles.length;
     const laneIds = input.retryLaneId !== undefined
         ? [input.retryLaneId]
         : retry
             ? []
-            : input.existingGroup === undefined
-                ? roles.map((_, index) => `${input.nextGroupId}-lane-${index + 1}`)
-                : roles.map((_, index) => `${input.existingGroup.id}-lane-${input.existingGroup.lanes.length + index + 1}`);
-    return { expanding, roles, strategy, capacity, requestedCount, laneIds };
+            : resumingQueued
+                ? queued.map(({ id }) => id)
+                : input.existingGroup === undefined
+                    ? roles.map((_, index) => `${input.nextGroupId}-lane-${index + 1}`)
+                    : roles.map((_, index) => `${input.existingGroup.id}-lane-${input.existingGroup.lanes.length + index + 1}`);
+    return { expanding, resumingQueued, roles, strategy, capacity, requestedCount, laneIds };
+}
+function activeResourceLaneIdentities(store) {
+    return store.listActiveTaskIds().flatMap((taskId) => (store.listAgentRuns(taskId).flatMap((run) => {
+        if (run.status !== "active"
+            || run.executionGroupId === undefined
+            || run.executionLaneId === undefined)
+            return [];
+        return [{
+                taskId,
+                ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+                executionGroupId: run.executionGroupId,
+                executionLaneId: run.executionLaneId,
+                providerId: run.effective.adapterId,
+                agentId: run.effective.agentId,
+                ...(run.effective.model === undefined ? {} : { model: run.effective.model }),
+                requestedAt: run.createdAt
+            }];
+    })));
 }
 function taskProjectCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -2007,13 +2056,45 @@ function updateWork(args, store, options) {
     });
 }
 function dispatchWork(args, store, options) {
-    const usage = "Task work dispatch usage: yui task work dispatch <task>/<work> [--input <text>] [--strategy fixed:<count>|adaptive:<max>] [--lane-role <role> ...].";
-    const parsed = parseMultiValueTail(args, new Set(["--input", "--strategy"]), new Set(["--lane-role"]), usage);
+    const usage = "Task work dispatch usage: yui task work dispatch <task>/<work> [--input <text>] [--strategy fixed:<count>|adaptive:<max>] [--lane-role <role> ...] [--mode <single|parallel-diverse|ensemble-replicated|adversarial|adaptive-exploration>] [--max-rounds <count>] [--stage-max-attempts <count>] [--stage-max-tokens <count>] [--stage-max-tool-calls <count>] [--stage-max-seconds <count>] [--stage-quorum <count>] [--stage-straggler-seconds <count>] [--stage-min-marginal-value <0-100>].";
+    const parsed = parseMultiValueTail(args, new Set([
+        "--input",
+        "--strategy",
+        "--mode",
+        "--max-rounds",
+        "--stage-max-attempts",
+        "--stage-max-tokens",
+        "--stage-max-tool-calls",
+        "--stage-max-seconds",
+        "--stage-quorum",
+        "--stage-straggler-seconds",
+        "--stage-min-marginal-value"
+    ]), new Set(["--lane-role"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const requestedStrategy = parseExecutionStrategy(parsed.options.get("--strategy"), usage);
     const requestedLaneRoles = parsed.multiOptions.get("--lane-role") ?? [];
+    const requestedMode = parseWorkItemExecutionMode(parsed.options.get("--mode"), usage);
+    const requestedMaxRounds = parseOptionalPositiveInteger(parsed.options.get("--max-rounds"), "--max-rounds", usage);
+    const requestedStageMaxAttempts = parseOptionalPositiveInteger(parsed.options.get("--stage-max-attempts"), "--stage-max-attempts", usage);
+    const requestedStageMaxTokens = parseOptionalPositiveInteger(parsed.options.get("--stage-max-tokens"), "--stage-max-tokens", usage);
+    const requestedStageMaxToolCalls = parseOptionalPositiveInteger(parsed.options.get("--stage-max-tool-calls"), "--stage-max-tool-calls", usage);
+    const requestedStageMaxSeconds = parseOptionalPositiveInteger(parsed.options.get("--stage-max-seconds"), "--stage-max-seconds", usage);
+    const requestedStageQuorum = parseOptionalPositiveInteger(parsed.options.get("--stage-quorum"), "--stage-quorum", usage);
+    const requestedStageStragglerSeconds = parseOptionalPositiveInteger(parsed.options.get("--stage-straggler-seconds"), "--stage-straggler-seconds", usage);
+    const requestedStageMinMarginalValue = parseOptionalPercentage(parsed.options.get("--stage-min-marginal-value"), "--stage-min-marginal-value", usage);
+    const requestedResourceOptions = [
+        requestedStageMaxTokens,
+        requestedStageMaxToolCalls,
+        requestedStageMaxSeconds,
+        requestedStageQuorum,
+        requestedStageStragglerSeconds,
+        requestedStageMinMarginalValue
+    ];
+    const explorationMode = requestedMode === undefined || requestedMode === "single"
+        ? undefined
+        : requestedMode;
     const now = clock(options);
-    const runs = store.transaction((tx) => {
+    const dispatch = store.transaction((tx) => {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, item.taskId);
         if (task.status !== "active") {
@@ -2023,10 +2104,44 @@ function dispatchWork(args, store, options) {
         const existingGroup = currentGroup?.resolution === undefined
             ? currentGroup
             : undefined;
+        if (item.status === "failed" && existingGroup !== undefined) {
+            throw usageError(`Work Item ${item.id} retains unresolved ExecutionGroup ${existingGroup.id}; `
+                + "retry the exact failed AgentRun so completed Lane results remain reusable.");
+        }
         const expanding = item.status === "running" && existingGroup !== undefined;
-        if (!expanding && item.status !== "pending" && item.status !== "failed") {
+        const continuingExploration = currentGroup?.stage !== undefined
+            && currentGroup.resolution !== undefined
+            && (item.status === "running" || item.status === "failed");
+        const resolvedRetryGroup = resolvedExecutionStageRetryGroup(currentGroup);
+        const startingExploration = item.executionGroups.length === 0
+            && explorationMode !== undefined;
+        if (!expanding
+            && !continuingExploration
+            && item.status !== "pending"
+            && item.status !== "failed") {
             throw usageError(`Work item ${item.id} cannot be dispatched from ${item.status}.`);
         }
+        if (requestedMode === "single" && currentGroup?.stage !== undefined) {
+            throw usageError("An exploration WorkItem cannot return to single mode.");
+        }
+        if (explorationMode !== undefined
+            && item.executionGroups.length > 0
+            && currentGroup?.stage === undefined) {
+            throw usageError("A WorkItem cannot enter exploration after single-mode ExecutionGroups.");
+        }
+        if (!startingExploration
+            && !continuingExploration
+            && (requestedMaxRounds !== undefined
+                || requestedStageMaxAttempts !== undefined
+                || requestedResourceOptions.some((value) => value !== undefined))) {
+            throw usageError("Exploration limits require an explicit non-single --mode.");
+        }
+        if (existingGroup !== undefined && (requestedMode !== undefined
+            || requestedMaxRounds !== undefined
+            || requestedStageMaxAttempts !== undefined
+            || requestedResourceOptions.some((value) => value !== undefined))) {
+            throw usageError(`Execution stage configuration is frozen: ${existingGroup.id}.`);
+        }
         if (item.assignee === undefined) {
             throw usageError(`Work Item has no Task Role assignee: ${item.id}. `
                 + `The Task Leader must run "yui task work update ${item.id} running", `
@@ -2066,6 +2181,7 @@ function dispatchWork(args, store, options) {
             requestedRoles: requestedLaneRoles,
             requestedStrategy,
             existingGroup,
+            resolvedRetryGroup,
             status: item.status,
             nextGroupId: `execution-group-${tx.peekNextAgentRunId(task.id)}`,
             retryLaneId: undefined,
@@ -2088,7 +2204,10 @@ function dispatchWork(args, store, options) {
         if (requestedCount > available) {
             throw usageError(`ExecutionGroup Lane count ${requestedCount} exceeds its ${strategy.mode} capacity ${available}.`);
         }
-        if (strategy.mode === "fixed" && !expanding && laneRoles.length !== strategy.count) {
+        if (strategy.mode === "fixed"
+            && !lanePlan.expanding
+            && !lanePlan.resumingQueued
+            && laneRoles.length !== strategy.count) {
             throw usageError(`fixed:${strategy.count} requires exactly ${strategy.count} --lane-role values.`);
         }
         const roles = laneRoles.map((name) => requireRole(tx, task.id, name));
@@ -2103,36 +2222,121 @@ function dispatchWork(args, store, options) {
         });
         let group = existingGroup;
         if (group === undefined) {
-            group = createExecutionGroup(`execution-group-${plans[0].runId}`, task.id, {
+            const groupId = `execution-group-${plans[0].runId}`;
+            const stage = !startingExploration && !continuingExploration
+                ? undefined
+                : (() => {
+                    const config = tx.getConfig();
+                    const contextBudget = resolveContextBudget(config.contextBudget);
+                    const health = resolveRuntimeHealth(config.runtimeHealth);
+                    const maxWallClockSeconds = requestedStageMaxSeconds
+                        ?? Math.floor(health.stallWindowMs / 1_000);
+                    const quorum = requestedStageQuorum
+                        ?? (strategy.mode === "fixed" ? strategy.count : 1);
+                    if (quorum > available) {
+                        throw usageError(`Execution stage quorum ${quorum} exceeds Lane capacity ${available}.`);
+                    }
+                    return planWorkItemExplorationStage(item, {
+                        ...(explorationMode === undefined ? {} : { mode: explorationMode }),
+                        ...(requestedMaxRounds === undefined ? {} : { maxRounds: requestedMaxRounds }),
+                        ...(requestedStageMaxAttempts === undefined
+                            ? {}
+                            : { maxAttempts: requestedStageMaxAttempts }),
+                        ...(startingExploration
+                            ? { convergence: { schemaVersion: 1 } }
+                            : {}),
+                        resourceBudget: {
+                            maxTokens: requestedStageMaxTokens ?? contextBudget.hardTokens * available,
+                            maxToolCalls: requestedStageMaxToolCalls ?? 100 * available,
+                            maxWallClockSeconds
+                        },
+                        resources: {
+                            schemaVersion: 1,
+                            quorum,
+                            deadlineAt: new Date(now.getTime() + maxWallClockSeconds * 1_000).toISOString(),
+                            stragglerAfterSeconds: requestedStageStragglerSeconds
+                                ?? Math.floor(health.quietAfterMs / 1_000),
+                            minimumMarginalValuePercent: requestedStageMinMarginalValue ?? 10
+                        },
+                        strategy,
+                        contextSnapshotRef: contextSnapshotRef(freezeExecutionStageContextSnapshot(tx, {
+                            taskId: task.id,
+                            workItemId: item.id,
+                            executionGroupId: groupId
+                        }, now))
+                    });
+                })();
+            group = createExecutionGroup(groupId, task.id, {
                 purpose: "execution",
                 target: executionTargetForWorkItem(task.id, item.id, item.revision, item, workspace),
                 strategy,
-                lanes: laneRoles.map((roleName) => ({ roleName }))
+                lanes: laneRoles.map((roleName) => ({ roleName })),
+                ...(stage === undefined ? {} : { stage })
             }, now);
         }
-        else if (expanding) {
+        else if (lanePlan.expanding) {
             for (const roleName of laneRoles) {
                 group = addExecutionLane(group, { roleName }, now);
             }
         }
-        const lanes = expanding
-            ? group.lanes.slice(-plans.length)
-            : group.lanes.slice(0, plans.length);
+        if (group.stage !== undefined) {
+            assertIndependentVerificationRoles(item, group.stage, laneRoles);
+        }
+        const lanes = lanePlan.resumingQueued
+            ? lanePlan.laneIds.map((laneId) => group.lanes.find(({ id }) => id === laneId))
+            : lanePlan.expanding
+                ? group.lanes.slice(-plans.length)
+                : group.lanes.slice(0, plans.length);
         if (lanes.length !== plans.length)
             throw new Error(`ExecutionGroup Lane planning drift: ${group.id}.`);
         const createdRuns = [];
+        const queuedAdmissions = [];
         let runningGroup = group;
+        const config = tx.getConfig();
+        const controllerConcurrency = resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
+        const brokerPolicy = resolveResourceBrokerPolicy({
+            maxActiveLanes: controllerConcurrency,
+            maxActiveLanesPerProvider: controllerConcurrency,
+            maxQueuedLanesPerGroup: Math.max(controllerConcurrency, available)
+        });
+        const activeResources = activeResourceLaneIdentities(tx);
+        const queuedResources = projectQueuedResourceLaneIdentities(tx, now);
+        const stageResources = group.stage === undefined
+            ? undefined
+            : projectExecutionStageResources({
+                group,
+                stageGroups: [...item.executionGroups, group],
+                usage: observedExecutionResourceUsage({
+                    group,
+                    stageGroups: [...item.executionGroups, group],
+                    runs: tx.listAgentRuns(task.id),
+                    events: tx.listEvents(task.id)
+                }),
+                now
+            });
+        const stageSpendClosed = stageResources !== undefined
+            && executionStageSpendClosed(stageResources);
         for (let index = 0; index < plans.length; index += 1) {
             const plan = plans[index];
             const lane = lanes[index];
             const laneIsolated = plans.length > 1 || group.lanes.length > 1 || group.strategy.mode === "adaptive";
+            const storedLaneWorkspace = laneIsolated
+                ? tx.getManagedWorkspace({
+                    type: "execution-lane",
+                    taskId: task.id,
+                    executionGroupId: group.id,
+                    executionLaneId: lane.id,
+                    purpose: "execution",
+                    workItemId: item.id
+                }) ?? undefined
+                : undefined;
             const laneManagedWorkspace = laneIsolated
-                ? options.executionLaneWorkspaces?.get(lane.id)
+                ? options.executionLaneWorkspaces?.get(lane.id) ?? storedLaneWorkspace
                 : runWorkspace;
             if (laneIsolated && laneManagedWorkspace === undefined && options.yuiHome !== undefined) {
                 throw usageError(`Execution Lane workspace preflight is missing: ${group.id}/${lane.id}.`);
             }
-            const effective = resolveEffectiveLaunch({
+            const effective = lane.effective ?? resolveEffectiveLaunch({
                 role: plan.role,
                 purpose: "execution",
                 ...(laneManagedWorkspace === undefined ? {} : { workspace: laneManagedWorkspace }),
@@ -2146,19 +2350,56 @@ function dispatchWork(args, store, options) {
                     root: laneManagedWorkspace.root,
                     writableProjectIds: [...item.writeProjectIds]
                 };
+            const request = {
+                taskId: task.id,
+                workItemId: item.id,
+                executionGroupId: group.id,
+                executionLaneId: lane.id,
+                providerId: effective.adapterId,
+                agentId: effective.agentId,
+                ...(effective.model === undefined ? {} : { model: effective.model }),
+                requestedAt: lane.effective === undefined ? now.toISOString() : lane.updatedAt
+            };
+            const admission = planResourceAdmissions({
+                policy: brokerPolicy,
+                active: activeResources,
+                queued: queuedResources.filter(({ taskId, executionGroupId, executionLaneId }) => !(taskId === request.taskId
+                    && executionGroupId === request.executionGroupId
+                    && executionLaneId === request.executionLaneId)),
+                requests: [request]
+            })[0];
+            const frozenDirective = lane.directive ?? rawInput;
+            if (stageSpendClosed || admission.decision !== "admitted") {
+                if (lane.effective === undefined || lane.directive === undefined) {
+                    runningGroup = updateExecutionLane(runningGroup, lane.id, {
+                        effective,
+                        workspace: laneWorkspace,
+                        directive: frozenDirective
+                    }, now);
+                }
+                queuedAdmissions.push(stageSpendClosed
+                    ? `${lane.id}: stage budget/deadline reached`
+                    : `${lane.id}: ${admission.reason}`);
+                if (!queuedResources.some(({ taskId, executionGroupId, executionLaneId }) => (taskId === request.taskId
+                    && executionGroupId === request.executionGroupId
+                    && executionLaneId === request.executionLaneId)))
+                    queuedResources.push(request);
+                continue;
+            }
+            activeResources.push(request);
             const runningLane = lane.status === "failed"
-                || lane.status === "yielded"
-                || lane.status === "completed"
                 ? restartExecutionLane(runningGroup, lane.id, {
                     runId: plan.runId,
                     effective,
-                    workspace: laneWorkspace
+                    workspace: laneWorkspace,
+                    directive: frozenDirective
                 }, now)
                 : updateExecutionLane(runningGroup, lane.id, {
                     status: "running",
                     runId: plan.runId,
                     effective,
-                    workspace: laneWorkspace
+                    workspace: laneWorkspace,
+                    directive: frozenDirective
                 }, now);
             runningGroup = runningLane;
             const assignment = createRunAssignment({
@@ -2172,7 +2413,16 @@ function dispatchWork(args, store, options) {
                     executionGroupId: runningGroup.id,
                     executionLaneId: lane.id
                 },
-                directive: `${rawInput}\nFrozen target: ${group.target.fingerprint}.`,
+                directive: `${frozenDirective}\nFrozen target: ${group.target.fingerprint}.`
+                    + (group.stage === undefined
+                        ? ""
+                        : `\nExploration stage: ${group.stage.stage}; round=${group.stage.round}; attempt=${group.stage.stageAttempt}.`
+                            + (group.stage.resources === undefined
+                                ? ""
+                                : `\nResource budget: tokens=${group.stage.budget.maxTokens}; tools=${group.stage.budget.maxToolCalls}; wall=${group.stage.budget.maxWallClockSeconds}s; quorum=${group.stage.resources.quorum}; deadline=${group.stage.resources.deadlineAt}; straggler=${group.stage.resources.stragglerAfterSeconds}s.`)
+                            + (group.stage.convergence === undefined
+                                ? ""
+                                : `\n${candidateConvergenceDirective(group.stage)}`)),
                 deltaRefIds: []
             });
             createdRuns.push(createAgentRun(plan.runId, task.id, plan.role.name, dispatchMode, assignment, now, {
@@ -2237,10 +2487,10 @@ function dispatchWork(args, store, options) {
                 roleName: unboundRun.roleName,
                 purpose: "execution",
                 workItemId: item.id
-            }, now);
+            }, now, "controller", runningGroup.stage?.contextSnapshotRef);
             const runWithLineage = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
             createdRuns[index] = runWithLineage;
-            const role = plans[index].role;
+            const role = requireRole(tx, task.id, unboundRun.roleName);
             tx.saveAgentRun(runWithLineage);
             tx.saveActiveAgentRun(runWithLineage);
             tx.saveRole(task.id, updateRoleStatus(role, "running", now));
@@ -2250,22 +2500,29 @@ function dispatchWork(args, store, options) {
             ]);
             recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(runWithLineage), now);
         }
-        return createdRuns;
+        return { runs: createdRuns, queuedAdmissions, group: runningGroup };
     });
-    for (const run of runs)
+    for (const run of dispatch.runs) {
         notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
-    const first = runs[0];
-    return `Dispatch queued for ${first.taskId}/${first.roleName} (${first.id})${runs.length > 1 ? `; ${runs.length} Lanes` : ""}\n`;
+    }
+    const backpressure = dispatch.queuedAdmissions.length === 0
+        ? ""
+        : `; ${dispatch.queuedAdmissions.length} Lane(s) retained pending by Resource Broker`;
+    const first = dispatch.runs[0];
+    return first === undefined
+        ? `No Lane admitted; ${dispatch.queuedAdmissions.join("; ")}\n`
+        : `Dispatch queued for ${first.taskId}/${first.roleName} (${first.id})${dispatch.runs.length > 1 ? `; ${dispatch.runs.length} Lanes` : ""}${backpressure}\n`;
 }
 function resolveWorkExecutionGroup(args, store, options) {
-    const usage = "Task work group resolve usage: yui task work group resolve <task>/<work> --decision <accept|reject|blocked> --summary <text> [--lane <lane-id> ...].";
+    const usage = "Task work group resolve usage: yui task work group resolve <task>/<work> --decision <accept|reject|retry|blocked> --summary <text> [--lane <lane-id> ...] [--early-stop <marginal-value-percent>].";
     if (args[0] !== "resolve")
         throw usageError(usage);
-    const parsed = parseMultiValueTail(args.slice(1), new Set(["--decision", "--summary"]), new Set(["--lane"]), usage);
+    const parsed = parseMultiValueTail(args.slice(1), new Set(["--decision", "--summary", "--early-stop"]), new Set(["--lane"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const decision = parseExecutionResolutionDecision(parsed.options.get("--decision"), usage);
     const summary = requiredOption(parsed.options, "--summary");
     const selectedLaneIds = parsed.multiOptions.get("--lane");
+    const earlyStopMarginalValue = parseOptionalPercentage(parsed.options.get("--early-stop"), "--early-stop", usage);
     const now = clock(options);
     const result = store.transaction((tx) => {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
@@ -2275,19 +2532,73 @@ function resolveWorkExecutionGroup(args, store, options) {
         if (taskActor(options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may resolve an ExecutionGroup.");
         }
-        const group = currentWorkItemExecutionGroup(item);
+        let group = currentWorkItemExecutionGroup(item);
         if (group === undefined
-            || (group.lanes.length < 2 && group.strategy.mode !== "adaptive")) {
+            || (group.stage === undefined
+                && group.lanes.length < 2
+                && group.strategy.mode !== "adaptive")) {
             throw usageError(`Work Item ${item.id} has no resolvable ExecutionGroup.`);
         }
         if (item.status !== "running") {
             throw usageError(`Work Item ${item.id} cannot resolve from ${item.status}.`);
         }
+        if (decision !== "accept" && group.stage?.resources !== undefined) {
+            const activeLaneIds = group.lanes
+                .filter(({ status }) => status === "running")
+                .map(({ id }) => id);
+            if (activeLaneIds.length > 0) {
+                throw usageError(`Active Lanes must settle before ${decision}; Resource Broker will not kill them: ${activeLaneIds.join(", ")}.`);
+            }
+            group = skipPendingExecutionLanes(group, group.lanes.filter(({ status }) => status === "pending").map(({ id }) => id), `Leader resolved the stage as ${decision} before queued Lanes started.`, now);
+        }
         const acceptedLaneIds = decision === "accept"
             ? selectedLaneIds ?? group.lanes
                 .filter((lane) => lane.status === "yielded" || lane.status === "completed")
                 .map(({ id }) => id)
             : undefined;
+        if (earlyStopMarginalValue !== undefined) {
+            if (decision !== "accept" || acceptedLaneIds === undefined) {
+                throw usageError("--early-stop requires --decision accept.");
+            }
+            if (group.stage?.resources === undefined) {
+                throw usageError("--early-stop requires a T6 resource-scheduled exploration stage.");
+            }
+            const resources = projectExecutionStageResources({
+                group,
+                stageGroups: item.executionGroups,
+                usage: observedExecutionResourceUsage({
+                    group,
+                    stageGroups: item.executionGroups,
+                    runs: tx.listAgentRuns(task.id),
+                    events: tx.listEvents(task.id)
+                }),
+                now
+            });
+            const routing = routeExecutionStage({
+                group,
+                resources,
+                evidenceSufficient: candidateConvergenceEvidenceSufficient(item, group, acceptedLaneIds),
+                disagreement: "unknown",
+                marginalValuePercent: earlyStopMarginalValue
+            });
+            if (!routing.earlyTerminationAllowed) {
+                throw usageError("Early termination is forbidden until quorum and acceptance-level evidence are sufficient.");
+            }
+            if (routing.action !== "resolve" && routing.retainActiveLaneIds.length === 0) {
+                throw usageError(routing.reason);
+            }
+            group = skipPendingExecutionLanes(group, routing.cancelPendingLaneIds, `Stopped after quorum and sufficient evidence; observed marginal value ${earlyStopMarginalValue}%.`, now);
+            if (routing.retainActiveLaneIds.length > 0) {
+                const waiting = updateWorkItemExecutionGroup(item, group, now);
+                tx.saveWorkItem(task.id, waiting);
+                return {
+                    item: waiting,
+                    group,
+                    reviewDispatch: null,
+                    waitingForStragglers: true
+                };
+            }
+        }
         const resolutionSummary = acceptedLaneIds === undefined
             ? summary
             : aggregateExecutionLaneSummary(summary, group, acceptedLaneIds);
@@ -2298,6 +2609,7 @@ function resolveWorkExecutionGroup(args, store, options) {
                 ? { selectedLaneIds: acceptedLaneIds }
                 : selectedLaneIds === undefined ? {} : { selectedLaneIds })
         }, now);
+        validateCandidateConvergenceResolution(item, resolved);
         const groupedItem = updateWorkItemExecutionGroup(item, resolved, now);
         tx.saveWorkItem(task.id, groupedItem);
         if (decision !== "accept") {
@@ -2306,7 +2618,23 @@ function resolveWorkExecutionGroup(args, store, options) {
             enqueueWork(tx, leaderMailbox(task.id), "work-group-resolved", now, [
                 workItemRef(task.id, item.id)
             ]);
-            return { item: failed, group: resolved, reviewDispatch: null };
+            return {
+                item: failed,
+                group: resolved,
+                reviewDispatch: null,
+                waitingForStragglers: false
+            };
+        }
+        if (resolved.stage !== undefined && resolved.stage.stage !== "resolve") {
+            enqueueWork(tx, leaderMailbox(task.id), "work-group-resolved", now, [
+                workItemRef(task.id, item.id)
+            ]);
+            return {
+                item: groupedItem,
+                group: resolved,
+                reviewDispatch: null,
+                waitingForStragglers: false
+            };
         }
         const eligible = resolved.lanes
             .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
@@ -2346,8 +2674,16 @@ function resolveWorkExecutionGroup(args, store, options) {
             runRef(task.id, eligible.id),
             workItemRef(task.id, item.id)
         ]);
-        return { item: candidate, group: resolved, reviewDispatch };
+        return {
+            item: candidate,
+            group: resolved,
+            reviewDispatch,
+            waitingForStragglers: false
+        };
     });
+    if (result.waitingForStragglers) {
+        return output(`Stopped pending spend for ${result.group.id}; active stragglers are retained until they settle: ${result.group.lanes.filter(({ status }) => status === "running").map(({ id }) => id).join(", ")}\n`, { workItem: result.item, executionGroup: result.group });
+    }
     if (result.reviewDispatch?.run !== null && result.reviewDispatch?.run !== undefined) {
         notifyReviewMailbox(options, options.runtime, roleMailbox(result.reviewDispatch.run.taskId, result.reviewDispatch.run.roleName), result.reviewDispatch.run.taskId);
     }
@@ -2728,7 +3064,12 @@ function reviewWork(args, store, options) {
             && round.candidateId === candidate.id
             && (round.status === "pending" || round.status === "running")))).at(-1);
         if (activeRound !== undefined) {
-            if (activeRound.status === "pending" && activeRound.reviewerRunId === undefined) {
+            const resourceQueued = activeRound.executionGroup !== undefined
+                && activeRound.executionGroup.resolution === undefined
+                && activeRound.executionGroup.lanes.some((lane) => (lane.status === "pending"
+                    && lane.runId === undefined));
+            if ((activeRound.status === "pending" && activeRound.reviewerRunId === undefined)
+                || (activeRound.status === "running" && resourceQueued)) {
                 return { round: activeRound, run: null, resumed: true };
             }
             throw usageError(`ReviewRound is already active: ${activeRound.id}/${activeRound.status}.`);
@@ -2740,7 +3081,7 @@ function reviewWork(args, store, options) {
         notifyReviewMailbox(options, options.runtime, roleMailbox(result.run.taskId, result.run.roleName), result.run.taskId);
     }
     if (result.resumed) {
-        return output(`Review request ${result.round.id} is pending; resuming dispatch.\n`, { reviewRound: result.round });
+        return output(`Review request ${result.round.id} has pending Lanes; resuming dispatch.\n`, { reviewRound: result.round });
     }
     return result.round.status === "failed"
         ? output(`Review could not start for ${result.round.workItemId}: ${result.round.summary}\n`, { reviewRound: result.round })
@@ -3206,6 +3547,10 @@ function requestTaskReviewRound(args, store, options) {
             }
             assertNoConflictingTaskReviewRound(taskRounds, exact.id);
             if (requestedLaneRoles.length === 0) {
+                if (exact.status === "running"
+                    && exact.executionGroup?.resolution === undefined
+                    && exact.executionGroup?.lanes.some((lane) => (lane.status === "pending" && lane.runId === undefined)))
+                    return exact;
                 assertTaskReviewRequestLane(tx, task.id, reviewerRoleName, exact);
                 return exact;
             }
@@ -4022,6 +4367,15 @@ function retryRun(args, store, options) {
         const task = requireTask(tx, previous.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
+        if (runOwnsBlockingProviderContinuation(tx.listEvents(task.id), {
+            taskId: previous.taskId,
+            roleName: previous.roleName,
+            runId: previous.id,
+            agentId: previous.effective.agentId
+        })) {
+            throw usageError(`Run ${previous.id} still owns an unsettled Provider continuation; `
+                + "reconcile it before retrying the Lane.");
+        }
         const role = requireRole(tx, task.id, previous.roleName);
         if (tx.getActiveAgentRun(task.id, role.name) !== null) {
             throw usageError(`${task.id}/${role.name} already has an active run.`);
@@ -4041,10 +4395,21 @@ function retryRun(args, store, options) {
         const currentRetryGroup = retryItem === null
             ? undefined
             : currentWorkItemExecutionGroup(retryItem);
+        const retriesExecutionLane = previous.executionGroupId !== undefined;
+        const exactCurrentLane = !retriesExecutionLane || (retryItem !== null
+            && currentRetryGroup !== undefined
+            && currentRetryGroup.id === previous.executionGroupId
+            && currentRetryGroup.resolution === undefined
+            && retryLaneBefore !== undefined
+            && retryLaneBefore.id === previous.executionLaneId
+            && retryLaneBefore.status === "failed"
+            && retryLaneBefore.runId === previous.id);
+        if (!exactCurrentLane) {
+            throw usageError(`Run ${previous.id} no longer owns the current failed Execution Lane.`);
+        }
         const groupedRunningRetry = retryItem?.status === "running"
-            && currentRetryGroup?.id === previous.executionGroupId
-            && (currentRetryGroup?.lanes.length ?? 0) > 1
-            && retryLaneBefore?.status === "failed";
+            && retriesExecutionLane
+            && exactCurrentLane;
         if (retryItem !== null && retryItem.status !== "failed" && !groupedRunningRetry) {
             throw usageError(`Work Item ${retryItem.id} is not retryable from ${retryItem.status}.`);
         }
@@ -4053,7 +4418,6 @@ function retryRun(args, store, options) {
                 ? tx.getTaskWorkspace(task.id)
                 : tx.getWorkItemWorkspace(task.id, retryItem.id))
             ?? undefined;
-        const runId = tx.nextAgentRunId(task.id);
         const retryGroup = retryItem === null || previous.executionGroupId === undefined
             ? undefined
             : workItemExecutionGroupById(retryItem, previous.executionGroupId);
@@ -4077,20 +4441,81 @@ function retryRun(args, store, options) {
             ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
             ...(retryItem === null ? {} : { workItemWriteProjectIds: retryItem.writeProjectIds })
         });
+        const laneWorkspace = retryManagedWorkspace === undefined
+            ? undefined
+            : {
+                root: retryManagedWorkspace.root,
+                writableProjectIds: [...(retryItem?.writeProjectIds ?? [])]
+            };
+        const retryDirective = retryLane?.directive
+            ?? previous.assignment.directive
+            ?? retryItem?.objective
+            ?? `Retry Run ${previous.id}.`;
+        let queuedReason;
+        if (retryGroup !== undefined && retryLane !== undefined && retryItem !== null) {
+            const config = tx.getConfig();
+            const controllerConcurrency = resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
+            const capacity = retryGroup.strategy.mode === "fixed"
+                ? retryGroup.strategy.count
+                : retryGroup.strategy.max;
+            const policy = resolveResourceBrokerPolicy({
+                maxActiveLanes: controllerConcurrency,
+                maxActiveLanesPerProvider: controllerConcurrency,
+                maxQueuedLanesPerGroup: Math.max(controllerConcurrency, capacity)
+            });
+            if (retryGroup.stage !== undefined) {
+                const stageGroups = retryItem.executionGroups;
+                const resources = projectExecutionStageResources({
+                    group: retryGroup,
+                    stageGroups,
+                    usage: observedExecutionResourceUsage({
+                        group: retryGroup,
+                        stageGroups,
+                        runs: tx.listAgentRuns(task.id),
+                        events: tx.listEvents(task.id)
+                    }),
+                    now
+                });
+                if (executionStageSpendClosed(resources)) {
+                    throw usageError(`Execution stage budget/deadline is exhausted; resolve Group ${retryGroup.id} instead of retrying.`);
+                }
+            }
+            const admission = planResourceAdmissions({
+                policy,
+                active: activeResourceLaneIdentities(tx),
+                queued: projectQueuedResourceLaneIdentities(tx, now),
+                requests: [{
+                        taskId: task.id,
+                        workItemId: retryItem.id,
+                        executionGroupId: retryGroup.id,
+                        executionLaneId: retryLane.id,
+                        providerId: effective.adapterId,
+                        agentId: effective.agentId,
+                        ...(effective.model === undefined ? {} : { model: effective.model }),
+                        requestedAt: now.toISOString()
+                    }]
+            })[0];
+            if (admission.decision === "blocked") {
+                throw usageError(`Execution Lane retry queue is full: ${admission.reason}.`);
+            }
+            if (admission.decision === "queued")
+                queuedReason = admission.reason;
+        }
+        const runId = queuedReason === undefined ? tx.nextAgentRunId(task.id) : undefined;
         const runningGroup = retryGroup === undefined || retryLane === undefined
             ? undefined
-            : restartExecutionLane(retryGroup, retryLane.id, {
-                runId,
-                effective,
-                ...(retryManagedWorkspace === undefined
-                    ? {}
-                    : {
-                        workspace: {
-                            root: retryManagedWorkspace.root,
-                            writableProjectIds: [...(retryItem?.writeProjectIds ?? [])]
-                        }
-                    })
-            }, now);
+            : queuedReason === undefined
+                ? restartExecutionLane(retryGroup, retryLane.id, {
+                    runId: runId,
+                    effective,
+                    ...(laneWorkspace === undefined ? {} : { workspace: laneWorkspace }),
+                    directive: retryDirective
+                }, now)
+                : queueExecutionLaneRetry(retryGroup, retryLane.id, {
+                    effective,
+                    ...(laneWorkspace === undefined ? {} : { workspace: laneWorkspace }),
+                    directive: retryDirective
+                }, now);
         // Restart the bound lane and reopen the failed WorkItem as two ordered
         // single-step record revisions, matching the dispatch path. Folding both
         // transforms into one save would move the WorkItem two revisions at once,
@@ -4111,14 +4536,23 @@ function retryRun(args, store, options) {
                 tx.saveWorkItem(task.id, retriedItemWithGroup);
             }
         }
+        if (queuedReason !== undefined) {
+            return {
+                kind: "queued",
+                taskId: task.id,
+                roleName: role.name,
+                laneId: retryLane.id,
+                reason: queuedReason
+            };
+        }
         const retrySnapshot = freezeRunContextSnapshot(tx, {
             taskId: task.id,
             roleName: role.name,
             purpose: "execution",
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId })
-        }, now);
+        }, now, "controller", retryGroup?.stage?.contextSnapshotRef);
         const assignment = createRunAssignment({
-            runId,
+            runId: runId,
             roleName: role.name,
             purpose: previous.assignment.purpose,
             action: previous.workItemId === undefined ? previous.assignment.action : "repair-work-item",
@@ -4164,6 +4598,9 @@ function retryRun(args, store, options) {
         }, now);
         return { kind: "run", run: created };
     });
+    if (retried.kind === "queued") {
+        return output(`Retry retained pending for ${retried.taskId}/${retried.laneId}: ${retried.reason}\n`);
+    }
     notifyMailbox(options.runtime, roleMailbox(retried.run.taskId, retried.run.roleName), retried.run.taskId);
     return output(`Retry queued as ${retried.run.id} for ${retried.run.taskId}/${retried.run.roleName}\n`);
 }
@@ -4504,6 +4941,15 @@ function retryFailedReviewRun(previous, store, options, now) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
+        if (runOwnsBlockingProviderContinuation(tx.listEvents(task.id), {
+            taskId: run.taskId,
+            roleName: run.roleName,
+            runId: run.id,
+            agentId: run.effective.agentId
+        })) {
+            throw usageError(`Review Run ${run.id} still owns an unsettled Provider continuation; `
+                + "reconcile it before retrying the Lane.");
+        }
         if (taskActor(options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may retry a failed final review Run.");
         }
@@ -4515,6 +4961,25 @@ function retryFailedReviewRun(previous, store, options, now) {
             throw usageError(`Review Run ${run.id} is not a Task-final review; request a new WorkItem review `
                 + "for a new Candidate.");
         }
+        const retryLane = run.executionLaneId === undefined
+            ? undefined
+            : round.executionGroup?.lanes.find(({ id }) => id === run.executionLaneId);
+        if (run.executionGroupId !== undefined && (round.executionGroup?.id !== run.executionGroupId
+            || retryLane === undefined
+            || retryLane.runId !== run.id
+            || retryLane.roleName !== run.roleName)) {
+            throw usageError(`Review Run ${run.id} no longer owns its exact Review Lane attempt.`);
+        }
+        const panelGroup = round.executionGroup !== undefined
+            && (round.executionGroup.lanes.length > 1
+                || round.executionGroup.strategy.mode === "adaptive");
+        const runningPanelLaneRetry = round.status === "running"
+            && panelGroup
+            && retryLane?.status === "failed";
+        if (round.status === "running" && panelGroup && !runningPanelLaneRetry) {
+            throw usageError(`Review Run ${run.id} is not the current failed Lane attempt in running Round ${round.id}.`);
+        }
+        const retryReviewerRoleName = retryLane?.roleName ?? round.reviewerRoleName;
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
         if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)) {
             throw usageError(`Task final-review contract does not match ReviewRound ${round.id}.`);
@@ -4539,23 +5004,23 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (laterRound !== undefined && !isSameTaskReviewCandidate(laterRound.taskCandidate, round.taskCandidate)) {
             throw usageError(`A newer final Task candidate already has ReviewRound ${laterRound.id}.`);
         }
-        const allReviewerRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id).filter((entry) => (entry.reviewerRoleName === round.reviewerRoleName)));
+        const allReviewerRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id).filter((entry) => (entry.reviewerRoleName === retryReviewerRoleName)));
         assertNoConflictingTaskReviewRound(tx.listReviewRounds(task.id), round.id);
         const activeRound = allReviewerRounds.find((entry) => (entry.id !== round.id
             && (entry.status === "pending" || entry.status === "running")));
         if (activeRound !== undefined) {
             throw usageError(`Reviewer already has an active review round for this candidate: ${activeRound.id}.`);
         }
-        const reviewerMailboxTarget = roleMailbox(task.id, round.reviewerRoleName);
+        const reviewerMailboxTarget = roleMailbox(task.id, retryReviewerRoleName);
         const reviewerMailbox = tx.getWorkMailbox(reviewerMailboxTarget);
         const reviewerPending = reviewerMailbox === null ? null : nextPendingBatch(reviewerMailbox);
         const runtimeMailbox = tx.getWorkMailbox(runtimeLifecycleTarget({
             scope: "task",
             taskId: task.id,
-            roleName: round.reviewerRoleName
+            roleName: retryReviewerRoleName
         }));
         const hasMailboxWork = (mailbox) => (mailbox !== null && workMailboxHasWork(mailbox));
-        const reviewer = requireRole(tx, task.id, round.reviewerRoleName);
+        const reviewer = requireRole(tx, task.id, retryReviewerRoleName);
         const activePointer = tx.getActiveAgentRun(task.id, reviewer.name);
         const activeReviewerRuns = tx.listAgentRuns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
         // Issue 06: a completed same-Round retry is a no-write idempotent result.
@@ -4571,7 +5036,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         // Issue 06: a running same Round is reusable only with its exact active
         // Run and mailbox execution. A stranded Run (no active pointer) falls
         // through and resets the Round after the identity fences below.
-        if (round.status === "running") {
+        if (round.status === "running" && !runningPanelLaneRetry) {
             const reviewerRunId = round.reviewerRunId;
             const activeMatches = reviewerRunId !== undefined
                 && activePointer !== null
@@ -4640,6 +5105,16 @@ function retryFailedReviewRun(previous, store, options, now) {
             }
             settleExactWorkExecution(tx, reviewerMailboxTarget, exactOldRunRef);
         }
+        if (runningPanelLaneRetry) {
+            const resetRound = retryRunningReviewExecutionLane(round, retryLane.id, run.id, now);
+            tx.saveReviewRound(task.id, resetRound);
+            recordTaskEvent(tx, task.id, "run.review-retried", {
+                runId: run.id,
+                reviewRoundId: round.id,
+                executionLaneId: retryLane.id
+            }, now);
+            return { round: resetRound, previousRun: run, created: true };
+        }
         // Terminalize the old stranded Round only after every identity and mailbox
         // fence has passed. The outer transaction rolls back if Round creation fails.
         let roundToReset = round;
@@ -4657,7 +5132,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         // Issue 06: infra retry resets the same semantic Round to pending instead
         // of manufacturing a new Round, so Round count and finding identity stay
         // stable across execution-attempt failures.
-        const resetRound = retryTaskReviewRound(roundToReset);
+        const resetRound = retryTaskReviewRound(roundToReset, run.executionLaneId);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "run.review-retried", {
             runId: run.id,
@@ -5121,12 +5596,13 @@ function yieldRun(args, store, options) {
                 throw dataError(`Work item not found for run ${active.id}: ${active.workItemId}.`);
             const currentGroup = currentWorkItemExecutionGroup(item);
             const multiLaneGroup = currentGroup !== undefined
-                && (currentGroup.lanes.length > 1
+                && (currentGroup.stage !== undefined
+                    || currentGroup.lanes.length > 1
                     || currentGroup.strategy.mode === "adaptive")
                 && currentGroup.resolution === undefined;
             if (multiLaneGroup) {
                 executionGroupPending = true;
-                executionGroupReady = currentGroup.lanes.every(({ status }) => (["yielded", "completed", "failed"].includes(status)));
+                executionGroupReady = currentGroup.lanes.every(({ status }) => (["yielded", "completed", "failed", "skipped"].includes(status)));
                 if (executionGroupReady) {
                     recordTaskEvent(tx, task.id, "execution-group-ready", {
                         workItemId: item.id,
@@ -5262,7 +5738,7 @@ function leaderYieldReceipt(tx, task, terminal, now) {
         if (projection === null)
             return null;
         const disposition = deriveLeaderRunDisposition(projection.status, task.status);
-        const digest = computeActionabilityDigest(collectTaskActionability(tx, task.id));
+        const digest = computeActionabilityDigest(collectTaskActionability(tx, task.id, now));
         const waitReason = disposition === "waiting" || disposition === "blocked"
             ? leaderWaitReason(projection)
             : undefined;
@@ -5465,13 +5941,6 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             }
             throw roleNotFound(round.reviewerRoleName);
         }
-        if (tx.getActiveAgentRun(taskId, reviewer.name) !== null) {
-            const message = `Reviewer Role already has an active run: ${reviewer.name}.`;
-            if ((round.scope ?? "work-item") === "task") {
-                throw new TaskFinalReviewDispatchDriftError(message);
-            }
-            throw usageError(message);
-        }
         const storedWorkspace = tx.getReviewRoundWorkspace(taskId, round.id);
         if (storedWorkspace === null
             || !isDeepStrictEqual(storedWorkspace, round.workspace)
@@ -5603,17 +6072,35 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             return laneReviewer;
         });
         const createdRuns = [];
+        const config = tx.getConfig();
+        const controllerConcurrency = resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
+        const capacity = runningGroup.strategy.mode === "fixed"
+            ? runningGroup.strategy.count
+            : runningGroup.strategy.max;
+        const brokerPolicy = resolveResourceBrokerPolicy({
+            maxActiveLanes: controllerConcurrency,
+            maxActiveLanesPerProvider: controllerConcurrency,
+            maxQueuedLanesPerGroup: Math.max(controllerConcurrency, capacity)
+        });
+        const activeResources = activeResourceLaneIdentities(tx);
+        const queuedResources = projectQueuedResourceLaneIdentities(tx, now);
+        const reviewBaseline = dispatchLanes.length === 0
+            ? undefined
+            : freezeReviewStageContextSnapshot(tx, {
+                taskId,
+                reviewRoundId: round.id,
+                executionGroupId: runningGroup.id
+            }, now);
         for (let index = 0; index < reviewers.length; index += 1) {
             const lane = dispatchLanes[index];
             const laneReviewer = reviewers[index];
-            const runId = tx.nextAgentRunId(taskId);
             const laneManagedWorkspace = runningGroup.lanes.length > 1 || runningGroup.strategy.mode === "adaptive"
                 ? options.executionLaneWorkspaces?.get(lane.id)
                 : round.workspace;
             if (laneManagedWorkspace === undefined && options.yuiHome !== undefined) {
                 throw usageError(`Review Lane workspace preflight is missing: ${runningGroup.id}/${lane.id}.`);
             }
-            const effective = resolveEffectiveLaunch({
+            const effective = lane.effective ?? resolveEffectiveLaunch({
                 role: laneReviewer,
                 purpose: "review",
                 workspace: laneManagedWorkspace ?? round.workspace,
@@ -5629,6 +6116,40 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                         .filter(({ access }) => access === "write")
                         .map(({ projectId }) => projectId)
                 };
+            const request = {
+                taskId,
+                ...(item === undefined ? {} : { workItemId: item.id }),
+                executionGroupId: runningGroup.id,
+                executionLaneId: lane.id,
+                providerId: effective.adapterId,
+                agentId: effective.agentId,
+                ...(effective.model === undefined ? {} : { model: effective.model }),
+                requestedAt: lane.effective === undefined ? now.toISOString() : lane.updatedAt
+            };
+            const admission = planResourceAdmissions({
+                policy: brokerPolicy,
+                active: activeResources,
+                queued: queuedResources.filter(({ taskId: queuedTaskId, executionGroupId, executionLaneId }) => !(queuedTaskId === request.taskId
+                    && executionGroupId === request.executionGroupId
+                    && executionLaneId === request.executionLaneId)),
+                requests: [request]
+            })[0];
+            if (admission.decision !== "admitted") {
+                if (lane.effective === undefined) {
+                    runningGroup = updateExecutionLane(runningGroup, lane.id, {
+                        reviewRoundId: round.id,
+                        effective,
+                        workspace: laneWorkspace
+                    }, now);
+                }
+                if (!queuedResources.some(({ taskId: queuedTaskId, executionGroupId, executionLaneId }) => (queuedTaskId === request.taskId
+                    && executionGroupId === request.executionGroupId
+                    && executionLaneId === request.executionLaneId)))
+                    queuedResources.push(request);
+                continue;
+            }
+            activeResources.push(request);
+            const runId = tx.nextAgentRunId(taskId);
             const assignment = createRunAssignment({
                 runId,
                 roleName: laneReviewer.name,
@@ -5664,7 +6185,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         const roundWithGroup = round.executionGroup === undefined
             ? attachReviewExecutionGroup(round, runningGroup)
             : updateReviewExecutionGroup(round, runningGroup);
-        const persistedRound = round.status === "pending"
+        const persistedRound = round.status === "pending" && createdRuns.length > 0
             ? startReviewRound(roundWithGroup, createdRuns[0].id)
             : roundWithGroup;
         // Save the aggregate before adopting prepared Lane workspaces.  The
@@ -5691,10 +6212,12 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 purpose: "review",
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 reviewRoundId: round.id
-            }, now);
+            }, now, "controller", reviewBaseline === undefined
+                ? undefined
+                : contextSnapshotRef(reviewBaseline));
             const created = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
             createdRuns[index] = created;
-            const laneReviewer = reviewers[index];
+            const laneReviewer = requireRole(tx, taskId, unboundRun.roleName);
             tx.saveAgentRun(created);
             tx.saveActiveAgentRun(created);
             tx.saveRole(taskId, updateRoleStatus(laneReviewer, "running", now));
@@ -5709,7 +6232,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
     for (const run of runs) {
         notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
     }
-    return runs[0];
+    return runs[0] ?? null;
 }
 export function failPendingReviewRound(taskId, reviewRoundId, summary, store, options = {}) {
     const now = clock(options);
@@ -6730,6 +7253,32 @@ function parseExecutionStrategy(value, usage) {
     }
     throw usageError(`Invalid execution strategy: ${value}. Use fixed:<count> or adaptive:<max>.`, usage);
 }
+function parseWorkItemExecutionMode(value, usage) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (WORK_ITEM_EXECUTION_MODES.includes(normalized))
+        return normalized;
+    throw usageError(`Invalid WorkItem execution mode: ${value}. Use ${WORK_ITEM_EXECUTION_MODES.join(", ")}.`, usage);
+}
+function parseOptionalPositiveInteger(value, label, usage) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw usageError(`${label} must be a positive integer.`, usage);
+    }
+    return parsed;
+}
+function parseOptionalPercentage(value, label, usage) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 100) {
+        throw usageError(`${label} must be an integer from 0 to 100.`, usage);
+    }
+    return parsed;
+}
 function sameExecutionStrategy(left, right) {
     return left.mode === right.mode
         && (left.mode === "fixed"
@@ -6737,9 +7286,10 @@ function sameExecutionStrategy(left, right) {
             : right.mode === "adaptive" && left.max === right.max);
 }
 function parseExecutionResolutionDecision(value, usage) {
-    if (value === "accept" || value === "reject" || value === "blocked")
+    if (value === "accept" || value === "reject" || value === "retry" || value === "blocked") {
         return value;
-    throw usageError("--decision must be accept, reject, or blocked.", usage);
+    }
+    throw usageError("--decision must be accept, reject, retry, or blocked.", usage);
 }
 function trimmed(value) {
     const normalized = value?.trim();