@zq-silk/yui 0.11.3 → 0.12.1

package/dist/commands/taskCommands.js

@@ -6,11 +6,12 @@ import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { createTaskRecordRetirement, isTaskRecordRetired, taskRecordRetirement } from "../task/taskRecordRetirement.js";
-import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
-import { createRoleSessionSet, retireTaskRoleSessionsForWorkspace, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, retireTaskRoleSessionsForWorkspace, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
+import { CONVERSATION_SWITCH_REQUESTED_EVENT, CONVERSATION_SWITCH_RESOLVED_EVENT, projectConversationSwitch, providerConversationGeneration, roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
@@ -18,13 +19,14 @@ import { renderRoleDetails } from "../output/rolePresentation.js";
 import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
-import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
 import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 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, retryRunningReviewExecutionLane, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
+import { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
+import { projectReviewerAvailability } from "../review/reviewerAvailability.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
@@ -36,7 +38,7 @@ import { mailboxHasWork as workMailboxHasWork, nextPendingBatch } from "../coord
 import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.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 { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
@@ -44,11 +46,11 @@ import { assertProjectActive, resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.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 { DEFAULT_EXECUTION_STAGE_TOKEN_BUDGET_PER_LANE, executionStageSpendClosed, observedExecutionResourceUsage, planResourceAdmissions, projectExecutionStageResources, resolveResourceBrokerPolicy, routeExecutionStage } from "../execution/resourceBroker.js";
+import { 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 { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
 import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT, createTaskFinalReviewContractRebind, resolveRecordedTaskFinalReviewContract, taskFinalReviewContractRebindPayload } from "../review/taskFinalReviewContractRebind.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { hasAgentConfigOptions, parseRoleOptions, patchRoleAgentBinding, roleOptionSpecs, roleProfilePatch } from "./roleConfiguration.js";
@@ -62,7 +64,7 @@ import { assertNoOpenInputRequests, isCurrentGlobalOperator, openInputRequestCou
 import { runGrantCommand } from "./grantCommands.js";
 import { runWorkflowCommand } from "./workflowCommands.js";
 import { taskActor as resolveTaskActor, taskLeaderActionRunId } from "./taskActor.js";
-import { createTaskTerminalNotification } from "../scheduler/operatorNotification.js";
+import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
 import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition, projectQueuedResourceLaneIdentities } from "../scheduler/actionability.js";
@@ -77,8 +79,6 @@ export class TaskFinalReviewDispatchDriftError extends CliError {
     }
 }
 /** Process-local command metadata; symbols never enter JSON output or durable state. */
-export const RESUMED_PENDING_FINAL_REVIEW = Symbol("resumed-pending-final-review");
-export const TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW = Symbol("terminalized-leader-before-final-review");
 function taskFinalReviewDispatchDrift(error) {
     return new TaskFinalReviewDispatchDriftError(error instanceof Error ? error.message : String(error), error instanceof CliError ? error : undefined);
 }
@@ -235,8 +235,8 @@ export function runTaskCommand(args, store, options = {}) {
         case "update": return output(updateTaskCommand(rest, store, options));
         case "list": return listTaskCommand(rest, store);
         case "show": return showTaskCommand(rest, store);
-        case "context": return runTaskContextCommand(rest, store);
-        case "next-action": return runTaskNextActionCommand(rest, store);
+        case "context": return runTaskContextCommand(rest, store, options.actualTaskReviewCandidate ?? null);
+        case "next-action": return runTaskNextActionCommand(rest, store, options.actualTaskReviewCandidate ?? null);
         case "activate": return output(activateTaskCommand(rest, store, options));
         case "complete": return completeTaskCommand(rest, store, options);
         case "reopen": return output(reopenTaskCommand(rest, store, options));
@@ -670,27 +670,34 @@ function showTaskCommand(args, store) {
 }
 function activateTaskCommand(args, store, options) {
     exactPositionals(args, 1, "Task activate usage: yui task activate <task>.");
-    const now = clock(options);
+    const activation = options.taskWorkspaceActivation;
     const result = store.transaction((tx) => {
         const task = requireTask(tx, args[0]);
         if (task.status === "archived")
             throw usageError(`Task is archived: ${task.id}.`);
+        if (task.status === "retired")
+            throw usageError(`Task is retired: ${task.id}.`);
         if (task.status === "completed") {
             throw usageError(`Task ${task.id} is completed; use task reopen before activating it.`);
         }
-        if (task.status === "active")
-            return { task, changed: false };
-        const active = activateTask(task, now);
-        tx.saveTask(active);
-        // Project-backed Tasks keep this durable wake pending until the
-        // Controller has prepared and recorded the Task workspace.
-        enqueueWork(tx, leaderMailbox(task.id), "task-created", now, [taskRef(task.id)]);
-        enqueueWork(tx, taskMailbox(task.id), "task-activated", now, [taskRef(task.id)]);
-        recordTaskEvent(tx, task.id, "task.activated", {
-            fromStatus: task.status,
-            status: active.status
-        }, now);
-        return { task: active, changed: true };
+        if (task.status === "active") {
+            if (activation === undefined)
+                return { task, changed: false };
+            const workspace = tx.getTaskWorkspace(task.id);
+            if (activation.taskId !== task.id
+                || activation.task.id !== task.id
+                || activation.task.status !== "active"
+                || !isDeepStrictEqual(activation.task.workspaceIdentity, task.workspaceIdentity)
+                || activation.path !== task.cwd
+                || workspace === null
+                || workspace.owner.type !== "task"
+                || workspace.owner.taskId !== task.id
+                || workspace.root !== task.cwd) {
+                throw usageError(`Task workspace activation proof does not match ${task.id}.`);
+            }
+            return { task, changed: activation.changed };
+        }
+        throw usageError(`Task ${task.id} activation requires atomic workspace adoption through the CLI preflight.`);
     });
     if (result.changed) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
@@ -754,7 +761,6 @@ function completeTaskCommand(args, store, options) {
         // readiness via projectCompletionReadiness.  The leader-Run check is
         // actor-dependent and stays here; every other blocker is re-validated by
         // the post-Review readiness fence below.
-        let terminalizedLeaderRun = false;
         const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
         if (leaderEntry !== undefined) {
             if (actor !== "leader") {
@@ -777,15 +783,11 @@ function completeTaskCommand(args, store, options) {
             if (terminal.disposition !== "applied") {
                 throw usageError(`Task Leader Run changed during completion: ${leaderEntry.run.id}/${terminal.reason}.`);
             }
-            terminalizedLeaderRun = true;
         }
         // A final (Task-scoped) review is the Task delivery policy: it reviews the
         // complete frozen Task heads, not a single WorkItem Candidate. If the
         // review config requests a final review, create the Task ReviewRound here
         // and return it for dispatch instead of completing the Task.
-        const pendingFinalReviewIds = new Set(tx.listReviewRounds(task.id)
-            .filter((round) => ((round.scope ?? "work-item") === "task" && round.status === "pending"))
-            .map(({ id }) => id));
         const finalReview = prepareFinalTaskReview(tx, task, now, taskFinalContract, options);
         if (finalReview !== null) {
             return {
@@ -794,8 +796,6 @@ function completeTaskCommand(args, store, options) {
                 runtimeCleanupTargets: [],
                 completionAdvisories: [],
                 finalReview,
-                resumedPendingFinalReview: pendingFinalReviewIds.has(finalReview.id),
-                terminalizedLeaderRun,
                 publishedTreeAuthorization: undefined
             };
         }
@@ -816,9 +816,6 @@ function completeTaskCommand(args, store, options) {
         tx.saveTask(completed);
         tx.clearPendingWakeup(task.id);
         tx.clearLeaderFailure(task.id);
-        tx.clearOperatorNotification(task.id);
-        tx.saveOperatorNotification(createTaskTerminalNotification(task.id, "completed", actor, summary, now));
-        enqueueWork(tx, { kind: "operator" }, "task-terminal", now, [taskRef(task.id)]);
         if (publishedTreeProof !== undefined) {
             recordTaskEvent(tx, task.id, "task.completion-published-tree-accepted", {
                 by: actor,
@@ -832,7 +829,7 @@ function completeTaskCommand(args, store, options) {
                 tree: publishedTreeProof.tree
             }, now);
         }
-        recordTaskEvent(tx, task.id, "task.completed", {
+        const terminalEvent = recordTaskEvent(tx, task.id, "task.completed", {
             by: actor,
             summary,
             ...(actualTaskCandidate === undefined
@@ -846,6 +843,7 @@ function completeTaskCommand(args, store, options) {
                 ? {}
                 : { cleanupAdvisories: String(readiness.advisories.length) })
         }, now);
+        enqueueOperatorEvent(tx, terminalEvent, "task-terminal", now);
         // A terminal Task must never leave a Task-lane signal that can wake it.
         // The durable records remain intact; only the derived mailbox work is
         // discarded at this lifecycle boundary.
@@ -863,8 +861,6 @@ function completeTaskCommand(args, store, options) {
             runtimeCleanupTargets,
             completionAdvisories: readiness.advisories,
             finalReview: undefined,
-            resumedPendingFinalReview: false,
-            terminalizedLeaderRun,
             publishedTreeAuthorization: undefined
         };
     });
@@ -893,9 +889,7 @@ function completeTaskCommand(args, store, options) {
             : `Final Task Review is blocked: ${result.finalReview.summary ?? result.finalReview.id}.`;
         return output(`${status}\n`, {
             task: result.task,
-            reviewRound: result.finalReview,
-            [RESUMED_PENDING_FINAL_REVIEW]: result.resumedPendingFinalReview,
-            [TERMINALIZED_LEADER_BEFORE_FINAL_REVIEW]: result.terminalizedLeaderRun
+            reviewRound: result.finalReview
         });
     }
     const completionOutput = result.changed
@@ -935,7 +929,6 @@ function reopenTaskCommand(args, store, options) {
                 throw usageError(`Task is not completed: ${task.id}.`);
             const active = reopenTask(task, now);
             tx.saveTask(active);
-            tx.clearOperatorNotification(task.id);
             const reopenedReason = wakeReason("task-reopened");
             enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
             enqueueWork(tx, taskMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
@@ -997,7 +990,6 @@ function archiveTaskCommand(args, store, options) {
         tx.saveTask(archived);
         tx.clearPendingWakeup(task.id);
         tx.clearLeaderFailure(task.id);
-        tx.clearOperatorNotification(task.id);
         for (const role of tx.listRoles(task.id)) {
             tx.removeWorkMailbox(roleMailbox(task.id, role.name));
         }
@@ -1095,20 +1087,18 @@ function retireTaskCommand(args, store, options) {
         }
         tx.clearPendingWakeup(task.id);
         tx.clearLeaderFailure(task.id);
-        tx.clearOperatorNotification(task.id);
         const retired = retireTask(task, {
             by: actor,
             summary,
             ...(replacementTaskId === undefined ? {} : { replacementTaskId })
         }, now);
         tx.saveTask(retired);
-        tx.saveOperatorNotification(createTaskTerminalNotification(task.id, "retired", actor, summary, now));
-        enqueueWork(tx, { kind: "operator" }, "task-terminal", now, [taskRef(task.id)]);
-        recordTaskEvent(tx, task.id, "task.retired", {
+        const terminalEvent = recordTaskEvent(tx, task.id, "task.retired", {
             by: actor,
             summary,
             ...(replacementTaskId === undefined ? {} : { replacementTaskId })
         }, now);
+        enqueueOperatorEvent(tx, terminalEvent, "task-terminal", now);
         return { task: retired, changed: true };
     });
     if (result.changed) {
@@ -1383,8 +1373,8 @@ function taskRoleCommand(args, store, options) {
         return output(bindTaskRole(rest, store, options));
     if (command === "unbind")
         return output(unbindTaskRole(rest, store, options));
-    if (command === "reset")
-        return resetTaskRole(rest, store, options);
+    if (command === "session")
+        return taskRoleSessionCommand(rest, store, options);
     if (command === "view")
         return viewTaskRole(rest, store);
     if (command === "takeover")
@@ -1395,29 +1385,78 @@ function taskRoleCommand(args, store, options) {
         ? "Task role command is required."
         : `Unknown command: task role ${command}`);
 }
-function resetTaskRole(args, store, options) {
-    const usage = "Task role reset usage: yui task role reset <task> <role> --reason <text>.";
+function taskRoleSessionCommand(args, store, options) {
+    const [command, ...rest] = args;
+    if (command === "switch")
+        return switchTaskRoleSession(rest, store, options);
+    throw usageError(command === undefined
+        ? "Task role session command is required."
+        : `Unknown command: task role session ${command}`);
+}
+function switchTaskRoleSession(args, store, options) {
+    const usage = "Task role session switch usage: yui task role session switch <task> <role> --reason <text>.";
     const parsed = parseTail(args, new Set(["--reason"]), usage);
     exactPositionals(parsed.positionals, 2, usage);
-    const reason = requiredOption(parsed.options, "--reason");
+    const reason = truncateEventNote(requiredOption(parsed.options, "--reason"));
     const now = clock(options);
-    let result;
-    try {
-        result = store.transaction((tx) => resetTaskRoleSessionGeneration(tx, parsed.positionals[0], parsed.positionals[1], reason, now));
-    }
-    catch (error) {
-        throw usageError(error instanceof Error ? error.message : String(error), usage);
-    }
-    const target = runtimeLifecycleTarget({
-        scope: "task",
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        if (task.status !== "active") {
+            throw usageError(inactiveTaskMessage(task, "switching a Provider Conversation"), usage);
+        }
+        const role = requireRole(tx, task.id, parsed.positionals[1]);
+        const requestedBy = taskActor(options, task.id);
+        const leaderRunId = requestedBy === "leader"
+            ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome)
+            : undefined;
+        if (requestedBy === "leader" && leaderRunId === undefined) {
+            throw usageError("Leader Conversation switching requires the exact current-Turn assertion.", usage);
+        }
+        const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+        const generation = providerConversationGeneration(sessions);
+        if (sessions === null || generation === null) {
+            throw usageError(`Task Role has no current Provider Conversation: ${task.id}/${role.name}.`, usage);
+        }
+        const events = tx.listEvents(task.id);
+        const previous = projectConversationSwitch(events, role.name, sessions);
+        if (previous?.status === "pending"
+            && previous.generation === generation
+            && previous.requestedBy === requestedBy
+            && previous.reason === reason) {
+            return { taskId: task.id, roleName: role.name, request: previous, replayed: true };
+        }
+        if (previous !== null && previous.resolvedAt === undefined) {
+            tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, CONVERSATION_SWITCH_RESOLVED_EVENT, {
+                requestId: previous.requestId,
+                roleName: role.name,
+                generation: previous.generation,
+                status: "obsolete"
+            }, now));
+        }
+        const requestId = tx.nextEventId(task.id);
+        const event = createTaskEvent(requestId, task.id, CONVERSATION_SWITCH_REQUESTED_EVENT, {
+            requestId,
+            roleName: role.name,
+            generation,
+            requestedBy,
+            reason,
+            ...(leaderRunId === undefined ? {} : { leaderRunId })
+        }, now);
+        tx.saveEvent(task.id, event);
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            request: projectConversationSwitch([...events, event], role.name, sessions),
+            replayed: false
+        };
+    });
+    options.runtime?.notifyStateChanged(result.taskId);
+    options.runtime?.notifyMailboxChanged?.({
+        kind: "role",
         taskId: result.taskId,
         roleName: result.roleName
     });
-    options.runtime?.notifyMailboxChanged?.(target);
-    notifyMailbox(options.runtime, result.roleName === LEADER_ROLE
-        ? { kind: "operator" }
-        : leaderMailbox(result.taskId), result.taskId);
-    return output(`Reset Task Role Session ${result.taskId}/${result.roleName}; runtime cleanup is pending.\n`, result);
+    return output(`${result.replayed ? "Reused" : "Recorded"} pending Provider Conversation switch ${result.request.requestId} for ${result.taskId}/${result.roleName}. The current Conversation remains authoritative until safe replacement binding.\n`, result);
 }
 function addTaskRole(args, store, options) {
     const usage = "Task role add usage: yui task role add <task> <name> [Role and Agent settings].";
@@ -2231,7 +2270,6 @@ function dispatchWork(args, store, options) {
                 ? undefined
                 : (() => {
                     const config = tx.getConfig();
-                    const contextBudget = resolveContextBudget(config.contextBudget);
                     const health = resolveRuntimeHealth(config.runtimeHealth);
                     const maxWallClockSeconds = requestedStageMaxSeconds
                         ?? Math.floor(health.stallWindowMs / 1_000);
@@ -2250,7 +2288,8 @@ function dispatchWork(args, store, options) {
                             ? { convergence: { schemaVersion: 1 } }
                             : {}),
                         resourceBudget: {
-                            maxTokens: requestedStageMaxTokens ?? contextBudget.hardTokens * available,
+                            maxTokens: requestedStageMaxTokens
+                                ?? DEFAULT_EXECUTION_STAGE_TOKEN_BUDGET_PER_LANE * available,
                             maxToolCalls: requestedStageMaxToolCalls ?? 100 * available,
                             maxWallClockSeconds
                         },
@@ -2347,7 +2386,7 @@ function dispatchWork(args, store, options) {
                 workItemWriteProjectIds: item.writeProjectIds
             });
             const sessions = tx.getTaskRoleSessionSet(task.id, plan.role.name);
-            const dispatchMode = roleAgentSessionResumeMode(sessions, effective.agentId, effective);
+            const dispatchMode = taskRoleDispatchMode(tx, task.id, plan.role.name, sessions, effective.agentId, effective);
             const laneWorkspace = laneManagedWorkspace === undefined
                 ? undefined
                 : {
@@ -3521,12 +3560,6 @@ function requestTaskReviewRound(args, store, options) {
         }
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
         if (deltaRecheckRequested) {
-            const reviewConfig = tx.getReviewConfig();
-            if (reviewConfig === null || reviewConfig.deltaRecheck !== "enabled") {
-                throw usageError("Delta-recheck is not enabled for this Project's review policy. "
-                    + "Set `yui config workflow set review --role <role> --trigger final --delta-recheck enabled` "
-                    + "or request a full Review.");
-            }
             if (taskFinalContract !== undefined) {
                 throw usageError("Delta-recheck is not supported with a Task-final review contract.");
             }
@@ -3541,15 +3574,24 @@ function requestTaskReviewRound(args, store, options) {
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id))
             .filter((entry) => (entry.scope ?? "work-item") === "task");
+        const latestNonAcceptingDelta = deltaRecheckRequested
+            ? undefined
+            : taskRounds.filter((entry) => (entry.reviewerRoleName === reviewerRoleName
+                && entry.deltaRecheck !== undefined
+                && deltaRecheckBlocksAcceptance(entry)
+                && isSameTaskReviewCandidate(entry.taskCandidate, provenance.candidate))).at(-1);
         const exact = taskRounds.filter((entry) => (entry.reviewerRoleName === reviewerRoleName
+            && (deltaRecheckRequested
+                ? entry.deltaRecheck !== undefined
+                : entry.deltaRecheck === undefined)
             && (taskFinalContract === undefined || sameTaskFinalReviewContract(entry.taskFinalReviewContract, taskFinalContract))
             && isSameTaskReviewCandidate(entry.taskCandidate, provenance.candidate))).at(-1);
+        if (exact?.status === "failed") {
+            throw usageError(`Explicit Task-final ReviewRound ${exact.id} is failed for this exact candidate; resolve it before requesting again.`);
+        }
         if (exact !== undefined
-            && (deltaRecheckRequested || !deltaRecheckBlocksAcceptance(exact))) {
-            if (exact.status === "failed") {
-                throw usageError(`Explicit Task-final ReviewRound ${exact.id} is failed for this exact candidate; resolve it before requesting again.`);
-            }
-            assertNoConflictingTaskReviewRound(taskRounds, exact.id);
+            && (exact.status === "pending" || exact.status === "running")) {
+            assertNoConflictingTaskReviewRound(taskRounds, exact.id, reviewerRoleName);
             if (requestedLaneRoles.length === 0) {
                 if (exact.status === "running"
                     && exact.executionGroup?.resolution === undefined
@@ -3579,9 +3621,8 @@ function requestTaskReviewRound(args, store, options) {
             if (exact.executionGroup.lanes.length + laneRoles.filter((role) => (!exact.executionGroup.lanes.some((lane) => lane.roleName === role))).length > strategy.max) {
                 throw usageError(`Reviewer Lane count exceeds adaptive capacity ${strategy.max}.`);
             }
-            let appended = exact.executionGroup;
             for (const laneRoleName of laneRoles) {
-                const existingLane = appended.lanes.find(({ roleName }) => roleName === laneRoleName);
+                const existingLane = exact.executionGroup.lanes.find(({ roleName }) => (roleName === laneRoleName));
                 if (existingLane !== undefined) {
                     if (existingLane.runId === undefined)
                         continue;
@@ -3601,29 +3642,32 @@ function requestTaskReviewRound(args, store, options) {
                     if (taskReviewProducerCollision(provenance, laneRoleName) !== null) {
                         throw usageError(`Reviewer Role must be separate from the Candidate producer: ${laneRoleName}.`);
                     }
-                    assertTaskReviewRequestLane(tx, task.id, laneRoleName);
-                    let laneRole = tx.getRole(task.id, laneRoleName);
-                    if (laneRole === null) {
-                        laneRole = createTaskRole(tx, task, laneRoleName, undefined, now, laneRoleName);
-                        tx.saveRole(task.id, laneRole);
-                    }
-                    appended = addExecutionLane(appended, {
-                        roleName: laneRole.name,
-                        reviewRoundId: exact.id
-                    }, now);
+                    const availability = projectReviewerAvailability(tx, task.id, laneRoleName);
+                    if (availability.kind === "busy")
+                        return availability;
+                }
+            }
+            let appended = exact.executionGroup;
+            for (const laneRoleName of laneRoles) {
+                if (appended.lanes.some(({ roleName }) => roleName === laneRoleName))
+                    continue;
+                let laneRole = tx.getRole(task.id, laneRoleName);
+                if (laneRole === null) {
+                    laneRole = createTaskRole(tx, task, laneRoleName, undefined, now, laneRoleName);
+                    tx.saveRole(task.id, laneRole);
                 }
+                appended = addExecutionLane(appended, {
+                    roleName: laneRole.name,
+                    reviewRoundId: exact.id
+                }, now);
             }
             const updated = updateReviewExecutionGroup(exact, appended);
             tx.saveReviewRound(task.id, updated);
             return updated;
         }
-        assertNoConflictingTaskReviewRound(taskRounds);
-        assertTaskReviewRequestLane(tx, task.id, reviewerRoleName);
-        let reviewer = tx.getRole(task.id, reviewerRoleName);
-        if (reviewer === null) {
-            reviewer = createTaskRole(tx, task, reviewerRoleName, undefined, now, reviewerRoleName);
-            tx.saveRole(task.id, reviewer);
-        }
+        const primaryAvailability = projectReviewerAvailability(tx, task.id, reviewerRoleName);
+        if (primaryAvailability.kind === "busy")
+            return primaryAvailability;
         const laneRoles = requestedLaneRoles.length === 0
             ? [reviewerRoleName]
             : requestedLaneRoles[0] === reviewerRoleName
@@ -3642,22 +3686,24 @@ function requestTaskReviewRound(args, store, options) {
             if (tx.getGlobalRole(laneRoleName) === null && tx.getRole(task.id, laneRoleName) === null) {
                 throw usageError(`Global Role not found: ${laneRoleName}.`);
             }
-            let laneRole = tx.getRole(task.id, laneRoleName);
-            if (laneRole === null) {
-                laneRole = createTaskRole(tx, task, laneRoleName, undefined, now, laneRoleName);
-                tx.saveRole(task.id, laneRole);
+            const availability = projectReviewerAvailability(tx, task.id, laneRoleName);
+            if (availability.kind === "busy")
+                return availability;
+            if (taskReviewProducerCollision(provenance, laneRoleName) !== null) {
+                throw usageError(`Reviewer Role must be separate from the Candidate producer: ${laneRoleName}.`);
             }
-            if (taskReviewProducerCollision(provenance, laneRole.name) !== null) {
-                throw usageError(`Reviewer Role must be separate from the Candidate producer: ${laneRole.name}.`);
+        }
+        for (const laneRoleName of laneRoles) {
+            if (tx.getRole(task.id, laneRoleName) === null) {
+                tx.saveRole(task.id, createTaskRole(tx, task, laneRoleName, undefined, now, laneRoleName));
             }
-            assertTaskReviewRequestLane(tx, task.id, laneRole.name);
         }
         let deltaRecord;
         if (deltaRecheckRequested) {
             if (requestedLaneRoles.length > 0 || requestedStrategy !== undefined) {
                 throw usageError("Delta-recheck supports only the default single Reviewer Lane.");
             }
-            deltaRecord = validateDeltaRecheckRequest(tx, task.id, reviewerRoleName, provenance.candidate, options.deltaRecheckPreflight);
+            deltaRecord = validateDeltaRecheckRequest(tx, task.id, provenance.candidate, options.deltaRecheckPreflight);
         }
         let created = deltaRecord === undefined
             ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract)
@@ -3675,15 +3721,14 @@ function requestTaskReviewRound(args, store, options) {
         tx.saveReviewRound(task.id, created);
         // Issue 07: when a full Review is created after a non-accepting delta
         // disposition, record the escalation lineage on the delta Round.
-        if (exact !== undefined
-            && deltaRecheckBlocksAcceptance(exact)
+        if (latestNonAcceptingDelta !== undefined
             && created.deltaRecheck === undefined
-            && exact.deltaRecheck !== undefined
-            && exact.deltaRecheck.escalatedToReviewRoundId === undefined) {
+            && latestNonAcceptingDelta.deltaRecheck !== undefined
+            && latestNonAcceptingDelta.deltaRecheck.escalatedToReviewRoundId === undefined) {
             tx.saveReviewRound(task.id, {
-                ...exact,
+                ...latestNonAcceptingDelta,
                 deltaRecheck: {
-                    ...exact.deltaRecheck,
+                    ...latestNonAcceptingDelta.deltaRecheck,
                     escalatedToReviewRoundId: created.id
                 }
             });
@@ -3703,11 +3748,20 @@ function requestTaskReviewRound(args, store, options) {
         }, now);
         return created;
     });
-    return output(round.status === "pending"
-        ? round.deltaRecheck === undefined
-            ? `Task-final Review requested as ${round.id}\n`
-            : `Task-final delta-recheck requested as ${round.id} (rechecks ${round.deltaRecheck.previousReviewRoundId})\n`
-        : `Task-final Review is already ${round.status}: ${round.id}\n`, { reviewRound: round });
+    if ("kind" in round && round.kind === "busy") {
+        return output(`Reviewer ${round.reviewerRoleName} is busy (${round.phase}`
+            + `${round.activeRunId === undefined ? "" : `; Run ${round.activeRunId}`}); `
+            + `${round.activeReviewRoundId === undefined
+                ? ""
+                : `active ReviewRound ${round.activeReviewRoundId}; `}`
+            + `retry after ${round.retryAfterSeconds}s or choose another Reviewer.\n`, { reviewRequest: round });
+    }
+    const requestedRound = round;
+    return output(requestedRound.status === "pending"
+        ? requestedRound.deltaRecheck === undefined
+            ? `Task-final Review requested as ${requestedRound.id}\n`
+            : `Task-final delta-recheck requested as ${requestedRound.id} (rechecks ${requestedRound.deltaRecheck.previousReviewRoundId})\n`
+        : `Task-final Review is already ${requestedRound.status}: ${requestedRound.id}\n`, { reviewRound: requestedRound });
 }
 const TASK_FINAL_FORCE_FRESH_EVENT = "review.task-final-force-fresh-requested";
 /**
@@ -3790,12 +3844,12 @@ function forceFreshTaskReviewRound(args, store, options) {
         if (sourceIndex < 0) {
             throw dataError(`Final ReviewRound is not in Task history: ${source.id}.`);
         }
-        const laterRound = taskRounds.slice(sourceIndex + 1).at(-1);
+        const laterRound = taskRounds.slice(sourceIndex + 1).find((entry) => (entry.reviewerRoleName === source.reviewerRoleName));
         if (laterRound !== undefined) {
             throw usageError(`A newer Task-final ReviewRound already exists after ${source.id}: `
                 + `${laterRound.id}/${laterRound.status}.`);
         }
-        assertNoConflictingTaskReviewRound(taskRounds, source.id);
+        assertNoConflictingTaskReviewRound(taskRounds, source.id, source.reviewerRoleName);
         assertTaskReviewRequestLane(tx, task.id, source.reviewerRoleName);
         let reviewer = tx.getRole(task.id, source.reviewerRoleName);
         if (reviewer === null) {
@@ -3853,22 +3907,17 @@ export function classifyForceFreshReviewRecovery(store, round) {
  * Review or an equivalent-and-accepted delta) so a delta never extends a
  * non-accepting disposition.
  */
-function validateDeltaRecheckRequest(store, taskId, reviewerRoleName, candidate, preflight) {
+function validateDeltaRecheckRequest(store, taskId, candidate, preflight) {
     if (preflight === undefined) {
         throw usageError("Delta-recheck assessment is missing; the CLI preflight did not run. "
             + "Request a full Review or retry with a current CLI.");
     }
     const previous = store.getReviewRound(taskId, preflight.record.previousReviewRoundId);
     if (previous === null
-        || (previous.scope ?? "work-item") !== "task"
-        || !isSemanticReviewRound(previous, store)) {
-        throw usageError(`Delta-recheck previous ReviewRound is not a semantic completed Task-final Review: `
+        || !isAcceptedTaskReviewBaseline(store, previous)) {
+        throw usageError(`Delta-recheck previous ReviewRound is not an accepted Task-final baseline: `
             + `${preflight.record.previousReviewRoundId}.`);
     }
-    if (previous.reviewerRoleName !== reviewerRoleName) {
-        throw usageError(`Delta-recheck Reviewer Role must match the previous acceptance: `
-            + `${previous.reviewerRoleName}.`);
-    }
     if (previous.reviewBaseCommit !== preflight.record.previousBaseCommit) {
         throw usageError("Delta-recheck previous base commit does not match the recorded acceptance.");
     }
@@ -3876,7 +3925,7 @@ function validateDeltaRecheckRequest(store, taskId, reviewerRoleName, candidate,
     if (previous.deltaRecheck !== undefined
         && previous.deltaRecheck.disposition !== "equivalent-and-accepted") {
         throw usageError(`Delta-recheck cannot extend ${previous.id}: its disposition is `
-            + `${previous.deltaRecheck.disposition}. Resolve it with a full Review first.`);
+            + `${previous.deltaRecheck.disposition}. The Leader must choose the next Review action.`);
     }
     if (candidate.projects[0].commit === preflight.record.previousBaseCommit) {
         throw usageError("Delta-recheck candidate head is unchanged; the previous acceptance already covers it.");
@@ -3986,12 +4035,12 @@ function retryFailedTaskReviewRound(args, store, options) {
         }
         // Issue 06: infra retries reuse the same semantic Round ID. Any later
         // Round supersedes this one; an active Round for the same Reviewer blocks.
-        const conflictingLater = reviewerRounds.slice(roundIndex + 1).at(-1);
+        const conflictingLater = reviewerRounds.slice(roundIndex + 1).find((entry) => (entry.reviewerRoleName === round.reviewerRoleName));
         if (conflictingLater !== undefined) {
             throw usageError(`A newer conflicting final ReviewRound already exists after ${round.id}: `
                 + `${conflictingLater.id}/${conflictingLater.status}.`);
         }
-        assertNoConflictingTaskReviewRound(reviewerRounds, round.id);
+        assertNoConflictingTaskReviewRound(reviewerRounds, round.id, round.reviewerRoleName);
         const activeRound = reviewerRounds.find((entry) => (entry.id !== round.id
             && entry.reviewerRoleName === round.reviewerRoleName
             && (entry.status === "pending" || entry.status === "running")));
@@ -4262,7 +4311,9 @@ function settleStaleFinalReviewRun(args, store, options) {
         if (validation.disposition !== "applied" || validation.round === null) {
             throw usageError(`Review Run ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
         }
-        const activeReviewerRun = tx.listAgentRuns(task.id).find((entry) => (entry.purpose === "review" && entry.status === "active"));
+        const activeReviewerRun = tx.listAgentRuns(task.id).find((entry) => (entry.purpose === "review"
+            && entry.roleName === round.reviewerRoleName
+            && entry.status === "active"));
         const activeRoleRun = tx.getActiveAgentRun(task.id, round.reviewerRoleName);
         if (activeReviewerRun !== undefined || activeRoleRun !== null) {
             const active = activeReviewerRun ?? activeRoleRun;
@@ -4274,7 +4325,7 @@ function settleStaleFinalReviewRun(args, store, options) {
         if (roundIndex < 0) {
             throw dataError(`Final ReviewRound is not in Task history: ${round.id}.`);
         }
-        const laterRound = taskRounds.slice(roundIndex + 1).at(-1);
+        const laterRound = taskRounds.slice(roundIndex + 1).find((entry) => (entry.reviewerRoleName === round.reviewerRoleName));
         if (laterRound !== undefined) {
             throw usageError(`A later final ReviewRound already exists: ${laterRound.id}/${laterRound.status}.`);
         }
@@ -4574,7 +4625,7 @@ function retryRun(args, store, options) {
             contextSnapshotRef: contextSnapshotRef(retrySnapshot),
             deltaRefIds: contextSnapshotDeltaRefIds(tx, retrySnapshot)
         });
-        const created = createAgentRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
+        const created = createAgentRun(runId, task.id, role.name, taskRoleDispatchMode(tx, task.id, role.name, sessions, effective.agentId, effective), assignment, now, {
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
             ...(runningGroup === undefined ? {} : {
                 executionGroupId: runningGroup.id,
@@ -4751,54 +4802,50 @@ function isSameTaskReviewCandidate(left, right) {
     return left !== undefined && isDeepStrictEqual(left, right);
 }
 /**
- * A Task can have at most one live Task-final ReviewRound. An exact existing
- * Round may be reused by an idempotent caller; every other pending/running
- * Round is a conflicting lane regardless of its Reviewer Role.
+ * One Reviewer Role has one live Task-final Review lane. Different Reviewer
+ * Roles own independent Session/Workspace slots and may review concurrently.
  */
-function assertNoConflictingTaskReviewRound(rounds, reusableRoundIds = []) {
+function assertNoConflictingTaskReviewRound(rounds, reusableRoundIds = [], reviewerRoleName) {
     const reusable = new Set(typeof reusableRoundIds === "string" ? [reusableRoundIds] : reusableRoundIds);
     const conflicting = rounds.find((entry) => (!reusable.has(entry.id)
         && (entry.scope ?? "work-item") === "task"
-        && (entry.status === "pending" || entry.status === "running")));
+        && (entry.status === "pending" || entry.status === "running")
+        && (reviewerRoleName === undefined || entry.reviewerRoleName === reviewerRoleName)));
     if (conflicting !== undefined) {
         throw usageError(`Another active Task-final ReviewRound already exists: ${conflicting.id}/${conflicting.reviewerRoleName}.`);
     }
 }
 /**
- * Queues a Task-scoped final ReviewRound. The reviewer Role must be separate
- * from the Candidate producer. Returns the round (pending or failed) so the
- * caller can surface it to the CLI for workspace preparation and dispatch.
+ * Queues a Task-scoped final ReviewRound only after the Reviewer lane passes
+ * its mechanical preflight. Busy or unavailable preparation never becomes a
+ * failed semantic ReviewRound.
  */
 function queueTaskReviewRound(store, task, config, taskCandidate, options, now, requestedBy = "policy", taskFinalContract) {
-    assertNoConflictingTaskReviewRound(store.listReviewRounds(task.id));
     const provenance = taskReviewProvenance(store, task, options, taskCandidate);
     if (!isSameTaskReviewCandidate(provenance.candidate, taskCandidate)) {
         throw usageError(`Task-final ReviewRound frozen Task heads changed before queueing.`);
     }
-    const pending = createTaskReviewRound(store.nextReviewRoundId(task.id), task.id, config.roleName, requestedBy, taskCandidate, now, taskFinalContract);
-    store.saveReviewRound(task.id, pending);
     const producerCollision = taskReviewProducerCollision(provenance, config.roleName);
     if (producerCollision !== null) {
-        const failed = finishReviewRound(pending, "failed", producerCollision, now);
-        store.saveReviewRound(task.id, failed);
-        return failed;
+        throw usageError(producerCollision);
+    }
+    const availability = projectReviewerAvailability(store, task.id, config.roleName);
+    if (availability.kind === "busy") {
+        throw usageError(`Reviewer ${config.roleName} is busy (${availability.phase}`
+            + `${availability.activeRunId === undefined ? "" : `; Run ${availability.activeRunId}`}); `
+            + `retry after ${availability.retryAfterSeconds}s.`);
     }
     let reviewer = store.getRole(task.id, config.roleName);
     if (reviewer === null) {
         const globalRole = store.getGlobalRole(config.roleName);
         if (globalRole === null) {
-            const failed = finishReviewRound(pending, "failed", `Global Role not found: ${config.roleName}.`, now);
-            store.saveReviewRound(task.id, failed);
-            return failed;
+            throw usageError(`Global Role not found: ${config.roleName}.`);
         }
         reviewer = createTaskRole(store, task, config.roleName, undefined, now, config.roleName);
         store.saveRole(task.id, reviewer);
     }
-    if (store.getActiveAgentRun(task.id, reviewer.name) !== null) {
-        const failed = finishReviewRound(pending, "failed", `Reviewer Role already has an active run: ${reviewer.name}.`, now);
-        store.saveReviewRound(task.id, failed);
-        return failed;
-    }
+    const pending = createTaskReviewRound(store.nextReviewRoundId(task.id), task.id, config.roleName, requestedBy, taskCandidate, now, taskFinalContract);
+    store.saveReviewRound(task.id, pending);
     return pending;
 }
 /**
@@ -4833,33 +4880,10 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
         // review evidence. Do not create duplicate rounds on repeated completion
         // attempts. A failed round remains a blocker until the Leader changes the
         // candidate or otherwise resolves the failed evidence explicitly.
-        // Issue 07: a completed delta-recheck that did not accept the head is not
-        // final evidence.  A `requires-full-review` disposition escalates to a new
-        // full Review; a `finding` disposition stays a blocker for the Leader.
-        if (latest.status === "completed"
-            && latest.deltaRecheck !== undefined
-            && latest.deltaRecheck.disposition === "requires-full-review") {
-            // Fall through to queue a full Review for the same candidate.
-            const escalated = queueTaskReviewRound(store, task, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
-            // Record the escalation lineage on the delta Round so the full Review
-            // is traceable from the non-accepting delta disposition.
-            if (latest.deltaRecheck.escalatedToReviewRoundId === undefined) {
-                store.saveReviewRound(task.id, {
-                    ...latest,
-                    deltaRecheck: {
-                        ...latest.deltaRecheck,
-                        escalatedToReviewRoundId: escalated.id
-                    }
-                });
-            }
-            return escalated;
-        }
-        else {
-            return latest.status === "completed"
-                && classifyReviewRoundOutcome(latest, store)?.kind === "semantic"
-                ? null
-                : latest;
-        }
+        // A non-accepting delta is durable evidence for the Leader, not an
+        // instruction for Core to manufacture a full Review. Completion remains
+        // blocked until the Leader explicitly chooses and obtains valid evidence.
+        return isAcceptedTaskReviewBaseline(store, latest) ? null : latest;
     }
     return queueTaskReviewRound(store, task, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
 }
@@ -4880,7 +4904,7 @@ function resumablePendingFinalTaskReview(store, task, round, config, taskCandida
     if (!isSameTaskReviewCandidate(round.taskCandidate, taskCandidate)) {
         throw usageError(`Final ReviewRound ${round.id} freezes a candidate that is no longer the current Task candidate.`);
     }
-    assertNoConflictingTaskReviewRound(store.listReviewRounds(task.id), round.id);
+    assertNoConflictingTaskReviewRound(store.listReviewRounds(task.id), round.id, round.reviewerRoleName);
     const reviewer = store.getRole(task.id, round.reviewerRoleName);
     if (reviewer === null || reviewer.name !== round.reviewerRoleName) {
         throw usageError(`Pending final ReviewRound Reviewer identity changed: ${round.id}.`);
@@ -5004,12 +5028,12 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (roundIndex < 0) {
             throw dataError(`Final ReviewRound is not in Task history: ${round.id}.`);
         }
-        const laterRound = taskRounds.slice(roundIndex + 1).at(-1);
+        const laterRound = taskRounds.slice(roundIndex + 1).find((entry) => (entry.reviewerRoleName === retryReviewerRoleName));
         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 === retryReviewerRoleName)));
-        assertNoConflictingTaskReviewRound(tx.listReviewRounds(task.id), round.id);
+        assertNoConflictingTaskReviewRound(tx.listReviewRounds(task.id), round.id, retryReviewerRoleName);
         const activeRound = allReviewerRounds.find((entry) => (entry.id !== round.id
             && (entry.status === "pending" || entry.status === "running")));
         if (activeRound !== undefined) {
@@ -5150,11 +5174,11 @@ function retryFailedReviewRun(previous, store, options, now) {
 }
 /**
  * Records one explicit Leader recovery decision against an exact live Run.
- * Retry and Session replacement remain requests: the Controller never sends
- * another input or changes a native generation from this command.
+ * Diagnose and retry remain same-Run requests: this command never changes a
+ * native Conversation generation.
  */
 function recoverRun(args, store, options) {
-    const usage = "Task run recover usage: yui task run recover <task>/<run> --action <diagnose|retry|replace-session|terminate> (--expected-progress-at <timestamp>|--from-next-action <fingerprint>) --provider-acceptance <accepted|rejected|ambiguous> --reason <text> [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
+    const usage = "Task run recover usage: yui task run recover <task>/<run> --action <diagnose|retry|terminate> (--expected-progress-at <timestamp>|--from-next-action <fingerprint>) --provider-acceptance <accepted|rejected|ambiguous> --reason <text> [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
     const parsed = parseTail(args, new Set([
         "--action",
         "--expected-progress-at",
@@ -5535,7 +5559,6 @@ function yieldRun(args, store, options) {
                 kind: "yield"
             }, now);
         }
-        clearMatchingLeaderStallAttention(tx, task.id, active.id);
         if (active.purpose === "review") {
             const round = active.reviewRoundId === undefined
                 ? null
@@ -5814,7 +5837,6 @@ function checkpointRun(args, store, options) {
                 kind: "checkpoint"
             }, now);
         }
-        clearMatchingLeaderStallAttention(tx, task.id, run.id);
         return progress;
     });
     return `Checkpoint recorded for ${parsed.positionals[0]} (${event.id}).\n`;
@@ -5957,9 +5979,13 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             throw usageError(message);
         }
         if (taskScope) {
+            const requestedReviewers = new Set(round.executionGroup?.lanes.map(({ roleName }) => roleName)
+                ?? [round.reviewerRoleName]);
             const conflicting = tx.listReviewRounds(task.id).find((entry) => (entry.id !== round.id
                 && (entry.scope ?? "work-item") === "task"
                 && (entry.status === "pending" || entry.status === "running")
+                && (entry.executionGroup?.lanes.some(({ roleName }) => requestedReviewers.has(roleName))
+                    ?? requestedReviewers.has(entry.reviewerRoleName))
                 && !(entry.status === "running"
                     && entry.reviewerRunId !== undefined
                     && tx.getAgentRun(task.id, entry.reviewerRunId)?.status === "failed")));
@@ -6003,8 +6029,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         let deltaContext = "";
         if (taskScope && round.deltaRecheck !== undefined) {
             const previousRound = tx.getReviewRound(taskId, round.deltaRecheck.previousReviewRoundId);
-            if (previousRound === null || !isSemanticReviewRound(previousRound, tx)) {
-                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck previous semantic ReviewRound is unavailable: ${round.deltaRecheck.previousReviewRoundId}.`);
+            if (previousRound === null || !isAcceptedTaskReviewBaseline(tx, previousRound)) {
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck accepted baseline is unavailable: ${round.deltaRecheck.previousReviewRoundId}.`);
             }
             const diffByProject = options.deltaRecheckDiff;
             if (diffByProject === undefined) {
@@ -6048,9 +6074,9 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             "Start from the user's core outcome and the WorkItem intent. The candidate summary is a pointer, not proof: inspect the complete relevant change, callers, and proportionate checks.",
             "Keep Yui Core lifecycle safety, generic Reviewer behavior, Project Policy/Knowledge, and the Task Contract separate. Follow Project Policy pointers from the dispatch context for project-specific checks.",
             ...(round.scope === "task" && round.deltaRecheck === undefined
-                ? ["This is the one final Task Review: inspect every bound Project at the frozen Task heads, and report only reachable, material, actionable P1/P2 findings or bounded verification gaps."]
+                ? ["This is a full Task Review: inspect every bound Project at the frozen Task heads, and report only reachable, material, actionable P1/P2 findings or bounded verification gaps."]
                 : []),
-            "You may freely edit source/tests, run local build or test commands, and optionally commit diagnostic evidence only inside this ReviewRound-owned workspace.",
+            "You may freely edit source/tests, run local build or test commands, and optionally commit diagnostic evidence only inside this stable Reviewer workspace at the exact ReviewRound snapshot.",
             "Do not push, integrate, mutate Task state, touch the Candidate or Worker workspace, another Task/workspace, a stable checkout, or the real Yui control-plane home.",
             "Use the exact --summary-file - body to report complete findings, evidence, checks actually run, uncertainty, and recommended next actions in clear Markdown or JSON. Yui preserves the full report; no fixed wording or field list is required. If you include evidenceCommit, it must match the managed Review workspace.",
             "Report reviewBaseCommit, exact checks/results, material findings, and uncertainty. Review yield completes only this Round and creates no Candidate or ChangeSet.",
@@ -6176,7 +6202,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 effective,
                 workspace: laneWorkspace
             }, now);
-            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
+            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, taskRoleDispatchMode(tx, taskId, laneReviewer.name, sessions, effective.agentId, effective), assignment, now, {
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 purpose: "review",
                 reviewRoundId: round.id,
@@ -6248,7 +6274,13 @@ export function failPendingReviewRound(taskId, reviewRoundId, summary, store, op
             return round;
         const terminal = finishReviewRound(round, "failed", summary, now);
         tx.saveReviewRound(taskId, terminal);
+        const event = recordTaskEventRecord(tx, taskId, "review.failed-to-start", {
+            reviewRoundId: terminal.id,
+            reviewerRoleName: terminal.reviewerRoleName,
+            reason: summary
+        }, now);
         enqueueWork(tx, leaderMailbox(taskId), "review-failed", now, [
+            eventRef(taskId, event.id),
             ...(round.workItemId === undefined ? [] : [workItemRef(taskId, round.workItemId)])
         ]);
         return terminal;
@@ -6334,7 +6366,7 @@ function appendMessage(store, taskId, body, kind, author, now, context = {}) {
     return message;
 }
 function recordTaskEvent(store, taskId, type, payload, now) {
-    recordTaskEventRecord(store, taskId, type, payload, now);
+    return recordTaskEventRecord(store, taskId, type, payload, now);
 }
 function leaderActionEventPayload(store, taskId, options) {
     const runId = taskLeaderActionRunId(store, taskId, options.environment, options.yuiHome);
@@ -6536,6 +6568,9 @@ function assertTaskOpen(task) {
 function taskActor(options, taskId) {
     return resolveTaskActor(options.environment, taskId);
 }
+function taskRoleDispatchMode(store, taskId, roleName, sessions, agentId, effective) {
+    return roleSessionDispatchModeWithConversationSwitch(sessions, store.listEvents(taskId), store.getWorkMailbox({ kind: "role", taskId, roleName }), roleName, agentId, effective);
+}
 function inactiveTaskMessage(task, action) {
     if (task.status === "draft") {
         return `Task ${task.id} is a Draft; activate it before ${action}.`;
@@ -6566,10 +6601,9 @@ function parseWorkStatus(value) {
 function parseRecoveryAction(value, usage) {
     if (value === "diagnose"
         || value === "retry"
-        || value === "replace-session"
         || value === "terminate")
         return value;
-    throw usageError("--action must be diagnose, retry, replace-session, or terminate.", usage);
+    throw usageError("--action must be diagnose, retry, or terminate.", usage);
 }
 function parseProviderAcceptance(value, usage) {
     if (value === "accepted" || value === "rejected" || value === "ambiguous")