@zq-silk/yui 0.14.0 → 0.14.2

package/dist/task/nextAction.js

@@ -1,17 +1,15 @@
 import { createHash } from "node:crypto";
-import { isDeepStrictEqual } from "node:util";
-import { changeSetDeliverySettled, governingChangeSets } from "../integration/deliveryObligation.js";
-import { isAcceptedTaskReviewBaselineFromEvidence } from "../review/reviewAcceptance.js";
-import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
+import { governingWorkItemDeliveries, workItemDeliverySettled } from "../integration/deliveryObligation.js";
+import { isCompletedTaskReviewEvidenceFromTurns } from "../review/reviewAcceptance.js";
 import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
-import { candidateConvergenceDisagreement, candidateConvergenceEvidenceSufficient, candidateConvergenceStageResultsValid } from "../execution/candidateConvergence.js";
-import { executionStageSpendClosed, routeExecutionStage } from "../execution/resourceBroker.js";
 import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
-import { currentWorkItemCandidate, currentWorkItemExecutionGroup, governingWorkItemCandidate } from "../workItem/workItem.js";
+import { draftWorkItemDependencyIssue } from "./draftPlan.js";
+import { currentWorkItemCandidate, governingWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
     const { task } = facts;
+    const deliveryWorkItems = facts.workItems.filter(({ status }) => status !== "retired");
     if (task.status !== "active" && task.status !== "draft") {
         return buildAction(facts, {
             kind: "complete-task",
@@ -73,6 +71,46 @@ export function projectNextAction(facts) {
         });
     }
     if (task.status === "draft") {
+        const dependencyIssue = draftWorkItemDependencyIssue(facts.workItems);
+        if (dependencyIssue !== undefined) {
+            const refs = [
+                ref("work-item", dependencyIssue.workItemId),
+                ref("work-item", dependencyIssue.dependencyId)
+            ];
+            return buildAction(facts, {
+                kind: "repair-protocol-inconsistency",
+                reason: dependencyIssue.kind === "cycle"
+                    ? `Draft Work Item dependency cycle includes ${dependencyIssue.workItemId}/${dependencyIssue.dependencyId}. Edit the Draft before activation.`
+                    : `Draft Work Item ${dependencyIssue.workItemId} depends on ${dependencyIssue.dependencyId}, which is missing or retired. Edit the Draft before activation.`,
+                refs,
+                conflicts: refs,
+                preconditions: [
+                    {
+                        fact: `Draft dependency ${dependencyIssue.dependencyId} is valid`,
+                        satisfied: false,
+                        ref: refs[1]
+                    }
+                ],
+                recommendedCommand: `yui task work edit ${task.id}/${dependencyIssue.workItemId} --clear-dependencies`
+            });
+        }
+        const draftWork = selectOpenWorkItem(facts.workItems);
+        if (draftWork.kind === "blocked") {
+            const refs = [
+                ref("work-item", draftWork.itemId),
+                ref("work-item", draftWork.blockedBy)
+            ];
+            return buildAction(facts, {
+                kind: "repair-protocol-inconsistency",
+                reason: `Draft Work Item ${draftWork.itemId} depends on ${draftWork.blockedBy}, which is missing, retired, or not completed. Edit the Draft before activation.`,
+                refs,
+                conflicts: refs,
+                preconditions: [
+                    { fact: `Draft dependency ${draftWork.blockedBy} is valid`, satisfied: false, ref: refs[1] }
+                ],
+                recommendedCommand: `yui task work edit ${task.id}/${draftWork.itemId} --clear-dependencies`
+            });
+        }
         return buildAction(facts, {
             kind: "implement-current-work-item",
             reason: `Task ${task.id} is still a Draft; activate it before dispatching, integrating, reviewing, or completing work.`,
@@ -87,27 +125,12 @@ export function projectNextAction(facts) {
         .find((item) => item.status === "awaiting_acceptance");
     if (candidateReady !== undefined) {
         const candidate = currentWorkItemCandidate(candidateReady);
-        if (candidate !== undefined && isEmptyDirectCandidate(candidate)) {
-            const candidateRef = ref("candidate", `${candidateReady.id}/${candidate.id}`);
-            return buildAction(facts, {
-                kind: "repair-protocol-inconsistency",
-                reason: `Candidate ${candidate.id} is a Task-main delivery with base==head (no commits); reject it and re-dispatch real work.`,
-                refs: [ref("work-item", candidateReady.id), candidateRef],
-                conflicts: [candidateRef],
-                preconditions: [
-                    { fact: "Direct Candidate contains at least one commit", satisfied: false, ref: candidateRef }
-                ],
-                recommendedCommand: `yui task work reject ${task.id}/${candidateReady.id} --summary \"empty base==head candidate\"`
-            });
-        }
         const activeReview = latestActiveWorkItemReview(facts.reviewRounds, candidateReady, candidate);
         if (activeReview !== undefined) {
             const reviewRef = ref("review-round", activeReview.id);
             if (activeReview.status === "running") {
-                if (reviewGroupAwaitingResolution(activeReview)) {
-                    return buildResolveReviewGroupAction(facts, activeReview);
-                }
-                if (activeReview.reviewerTurnId === undefined) {
+                if (activeReview.reviewerTurnId === undefined
+                    && activeReview.executionGroup === undefined) {
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
                         reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Turn.`,
@@ -120,26 +143,28 @@ export function projectNextAction(facts) {
                 }
                 const reviewRun = activeReviewRoundRun(activeReview, facts.activeTurns);
                 if (reviewRun === undefined) {
-                    if (reviewGroupHasResourceQueue(activeReview)) {
+                    if (reviewGroupNeedsDispatch(activeReview, facts.activeTurns)) {
                         return buildAction(facts, {
                             kind: "resume-review",
-                            reason: `ReviewRound ${activeReview.id} has Reviewer Lanes waiting for Resource Broker capacity.`,
+                            reason: `ReviewRound ${activeReview.id} has Review Producer Lanes ready for dispatch or retry.`,
                             refs: [reviewRef],
                             preconditions: [
-                                { fact: "A Reviewer Lane is durably queued", satisfied: true, ref: reviewRef },
-                                { fact: "Resource capacity is available", satisfied: false }
+                                { fact: "A Review Producer Lane is open", satisfied: true, ref: reviewRef }
                             ],
                             recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
+                                + reviewLaneRoleOptions(activeReview)
                         });
                     }
-                    const runRef = ref("turn", activeReview.reviewerTurnId);
+                    const runRef = activeReview.reviewerTurnId === undefined
+                        ? reviewRef
+                        : ref("turn", activeReview.reviewerTurnId);
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
-                        reason: `ReviewRound ${activeReview.id} references Reviewer Turn ${activeReview.reviewerTurnId}, but that Turn is not active.`,
+                        reason: `ReviewRound ${activeReview.id} has no active Producer or main Reviewer Turn.`,
                         refs: [reviewRef, runRef],
                         conflicts: [reviewRef, runRef],
                         preconditions: [
-                            { fact: "Reviewer Turn is active", satisfied: false, ref: runRef }
+                            { fact: "Review execution is active or ready to dispatch", satisfied: false, ref: runRef }
                         ]
                     });
                 }
@@ -174,6 +199,26 @@ export function projectNextAction(facts) {
                     { fact: "Reviewer Turn exists", satisfied: false }
                 ],
                 recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
+                    + reviewLaneRoleOptions(activeReview)
+            });
+        }
+        const unintegrated = governingWorkItemDeliveries([candidateReady])
+            .find((delivery) => !workItemDeliverySettled(delivery, facts.integrations));
+        if (unintegrated !== undefined) {
+            return buildAction(facts, {
+                kind: "integrate-work-item",
+                reason: `Work Item ${candidateReady.id} result for Project ${unintegrated.projectId} has not passed a Leader-owned Integration.`,
+                refs: [ref("work-item", candidateReady.id)],
+                preconditions: [
+                    {
+                        fact: "Committed Integration records the exact WorkItem result",
+                        satisfied: false,
+                        ref: ref("work-item", candidateReady.id)
+                    }
+                ],
+                recommendedCommand: `yui task integration start ${task.id} --work-item ${candidateReady.id} `
+                    + `--project ${unintegrated.projectId} --strategy cherry-pick`,
+                judgmentRequired: "Leader must choose fast-forward, cherry-pick, merge, manual application, or an explicit no-op result."
             });
         }
         const refs = [
@@ -225,34 +270,15 @@ export function projectNextAction(facts) {
     const failedWork = facts.workItems.find((item) => item.status === "failed");
     if (failedWork !== undefined) {
         const failedReview = latestFailedReviewFor(facts.reviewRounds, failedWork.id);
-        if (failedReview !== undefined) {
-            return buildAction(facts, {
-                kind: "route-review-findings",
-                reason: `Work Item ${failedWork.id} failed with Review ${failedReview.id}; route its open findings into a repair wave.`,
-                refs: [ref("work-item", failedWork.id), ref("review-round", failedReview.id)],
-                preconditions: [
-                    { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) },
-                    { fact: "Review Round is failed", satisfied: true, ref: ref("review-round", failedReview.id) }
-                ],
-                recommendedCommand: `yui task review finding repair-wave ${task.id} --create`
-            });
-        }
-        const explorationStop = exhaustedExplorationReason(failedWork, facts.executionGroups);
-        if (explorationStop !== undefined) {
-            return buildAction(facts, {
-                kind: "implement-current-work-item",
-                reason: explorationStop,
-                refs: [ref("work-item", failedWork.id)],
-                preconditions: [
-                    { fact: "Work Item exploration cannot continue", satisfied: true, ref: ref("work-item", failedWork.id) }
-                ],
-                recommendedCommand: `yui task work retire ${task.id}/${failedWork.id} --summary \"<reason>\"`
-            });
-        }
         return buildAction(facts, {
             kind: "implement-current-work-item",
-            reason: `Work Item ${failedWork.id} failed without a Review verdict; retry implementation.`,
-            refs: [ref("work-item", failedWork.id)],
+            reason: failedReview === undefined
+                ? `Work Item ${failedWork.id} failed; retry implementation after Leader diagnosis.`
+                : `Work Item ${failedWork.id} failed after Review ${failedReview.id}; the Leader must read its exact Reviewer Turn result and choose the repair.`,
+            refs: [
+                ref("work-item", failedWork.id),
+                ...(failedReview === undefined ? [] : [ref("review-round", failedReview.id)])
+            ],
             preconditions: [
                 { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) }
             ],
@@ -279,9 +305,6 @@ export function projectNextAction(facts) {
     }
     if (openWork?.kind === "ready") {
         const item = openWork.item;
-        const stageAction = buildExecutionStageAction(facts, item);
-        if (stageAction !== null)
-            return stageAction;
         const refs = [ref("work-item", item.id)];
         return buildAction(facts, {
             kind: "implement-current-work-item",
@@ -306,7 +329,7 @@ export function projectNextAction(facts) {
             judgmentRequired: "Leader must choose the execution path: direct execution, a native subagent, or managed Task Role dispatch."
         });
     }
-    if (facts.workItems.length === 0
+    if (deliveryWorkItems.length === 0
         && !taskFinalReviewRequired(facts)
         && !facts.reviewRounds.some((round) => ((round.scope ?? "work-item") === "task"
             && (round.status === "pending" || round.status === "running")))) {
@@ -339,103 +362,70 @@ export function projectNextAction(facts) {
                     : "Leader must choose the smallest useful topology from the Project-defined Task intent, then decide whether the frozen result warrants Review."
         });
     }
-    const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
-    if (uncaptured !== undefined) {
-        return buildAction(facts, {
-            kind: "capture-change-set",
-            reason: `Work Item ${uncaptured.id} is completed but has no ChangeSet; capture its delivery boundary.`,
-            refs: [ref("work-item", uncaptured.id)],
-            preconditions: [
-                { fact: "Work Item is completed", satisfied: true, ref: ref("work-item", uncaptured.id) },
-                { fact: "ChangeSet exists for the Work Item", satisfied: false }
-            ],
-            recommendedCommand: `yui task work capture ${task.id}/${uncaptured.id}`
-        });
-    }
-    const unintegrated = governingChangeSets(facts.workItems, facts.changeSets)
-        .find((changeSet) => !changeSetDeliverySettled(changeSet, facts.integrations, facts.integrationQueueEntries));
+    const unintegrated = governingWorkItemDeliveries(facts.workItems)
+        .find((delivery) => !workItemDeliverySettled(delivery, facts.integrations));
     if (unintegrated !== undefined) {
         return buildAction(facts, {
-            kind: "integrate-change-set",
-            reason: `ChangeSet ${unintegrated.id} has no committed Integration.`,
-            refs: [ref("change-set", unintegrated.id)],
+            kind: "integrate-work-item",
+            reason: `Work Item ${unintegrated.workItemId} result for Project ${unintegrated.projectId} has no committed Integration.`,
+            refs: [ref("work-item", unintegrated.workItemId)],
             preconditions: [
-                { fact: "ChangeSet exists", satisfied: true, ref: ref("change-set", unintegrated.id) },
-                { fact: "Committed Integration references the ChangeSet", satisfied: false }
+                {
+                    fact: "Committed Integration records the exact WorkItem result",
+                    satisfied: false,
+                    ref: ref("work-item", unintegrated.workItemId)
+                }
             ],
-            recommendedCommand: `yui task integration start ${task.id} --project ${unintegrated.projectId} --change-set ${unintegrated.id}`
+            recommendedCommand: `yui task integration start ${task.id} --work-item ${unintegrated.workItemId} `
+                + `--project ${unintegrated.projectId} --strategy cherry-pick`,
+            judgmentRequired: "Leader must choose fast-forward, cherry-pick, merge, manual application, or an explicit no-op result."
         });
     }
     const finalReviewRequired = taskFinalReviewRequired(facts);
     const finalReviewContract = taskFinalReviewContract(facts);
     const failedFinal = latestTaskFinalReview(facts.reviewRounds, finalReviewContract);
-    const failedFinalOutcome = failedFinal === undefined
-        ? null
-        : classifyReviewRoundOutcome(failedFinal, nextActionReviewOutcomeEvidence(facts));
     if (finalReviewRequired
-        && failedFinal !== undefined && failedFinalOutcome?.kind === "non-semantic") {
+        && failedFinal?.status === "failed") {
+        const reviewerTurn = failedFinal.reviewerTurnId === undefined
+            ? undefined
+            : facts.reviewOutcomeEvidence?.turns.find(({ id }) => id === failedFinal.reviewerTurnId);
+        const sameRoundCommand = failedFinal.reviewerTurnId === undefined
+            ? `yui task review retry ${task.id}/${failedFinal.id}`
+            : reviewerTurn?.status === "failed"
+                ? `yui task turn retry ${task.id}/${reviewerTurn.id}`
+                : undefined;
         return buildAction(facts, {
             kind: "resume-review",
-            reason: `Task-final Review ${failedFinal.id} ended before a semantic review was proven.`,
-            refs: [ref("review-round", failedFinal.id)],
+            reason: `Task-final Review ${failedFinal.id} failed during execution: ${failedFinal.failure?.message ?? "unknown Core failure"}.`,
+            refs: [
+                ref("review-round", failedFinal.id),
+                ...(reviewerTurn?.status === "failed" ? [ref("turn", reviewerTurn.id)] : [])
+            ],
             preconditions: [
-                { fact: "Task-final Review has semantic evidence", satisfied: false, ref: ref("review-round", failedFinal.id) }
+                {
+                    fact: "Task-final Review has one exact completed Reviewer Turn",
+                    satisfied: false,
+                    ref: ref("review-round", failedFinal.id)
+                }
             ],
-            recommendedCommand: `yui task review force-fresh ${task.id}/${failedFinal.id}`
+            ...(sameRoundCommand === undefined ? {} : { recommendedCommand: sameRoundCommand })
         });
     }
     if (finalReviewRequired
-        && failedFinal !== undefined && failedFinalOutcome?.kind === "ambiguous") {
+        && failedFinal?.status === "completed"
+        && !isCompletedTaskReviewEvidenceFromTurns(failedFinal, facts.reviewOutcomeEvidence?.turns ?? [])) {
         return buildAction(facts, {
             kind: "repair-protocol-inconsistency",
-            reason: `Task-final Review ${failedFinal.id} has ambiguous semantic and infrastructure evidence: ${failedFinalOutcome.reason}`,
+            reason: `Task-final Review ${failedFinal.id} is completed without one exact completed main Reviewer Turn.`,
             refs: [ref("review-round", failedFinal.id)],
             conflicts: [ref("review-round", failedFinal.id)],
             preconditions: [
-                { fact: "Review outcome is unambiguously semantic or non-semantic", satisfied: false, ref: ref("review-round", failedFinal.id) }
-            ]
-        });
-    }
-    if (finalReviewRequired
-        && failedFinal !== undefined
-        && failedFinalOutcome?.kind === "semantic"
-        && failedFinal.deltaRecheck?.disposition === "requires-full-review") {
-        return buildAction(facts, {
-            kind: "request-final-review",
-            reason: `Delta Recheck ${failedFinal.id} could not establish equivalence; Yui recorded the result and left the next Review action to the Leader.`,
-            refs: [ref("review-round", failedFinal.id)],
-            preconditions: [
-                { fact: "Current frozen head has accepting final Review evidence", satisfied: false }
-            ],
-            alternatives: [
                 {
-                    kind: "request-full-review",
-                    reason: "Request a full Review when independent evidence is still required.",
-                    recommendedCommand: `yui task review request ${task.id} --role ${failedFinal.reviewerRoleName}`,
-                    refs: [ref("review-round", failedFinal.id)]
-                },
-                {
-                    kind: "continue-leader-work",
-                    reason: "Inspect directly, change the candidate, or choose another Reviewer as Task risk requires.",
-                    refs: [ref("review-round", failedFinal.id)]
+                    fact: "ReviewRound and exact main Reviewer Turn agree",
+                    satisfied: false,
+                    ref: ref("review-round", failedFinal.id)
                 }
-            ],
-            judgmentRequired: "Leader must choose full Review, another Reviewer, direct inspection, or more development; Core will not auto-escalate."
-        });
-    }
-    if (finalReviewRequired
-        && failedFinal !== undefined
-        && failedFinalOutcome?.kind === "semantic"
-        && ((failedFinal.checks ?? []).some(({ outcome }) => outcome === "failed")
-            || failedFinal.deltaRecheck?.disposition === "finding")) {
-        return buildAction(facts, {
-            kind: "route-review-findings",
-            reason: `Task-final Review ${failedFinal.id} delivered semantic negative evidence; route its open findings into a repair wave on one frozen head.`,
-            refs: [ref("review-round", failedFinal.id)],
-            preconditions: [
-                { fact: "Task-final Review is failed", satisfied: true, ref: ref("review-round", failedFinal.id) }
-            ],
-            recommendedCommand: `yui task review finding repair-wave ${task.id} --create`
+            ]
         });
     }
     const activeFinal = latestTaskFinalReview(facts.reviewRounds, finalReviewContract);
@@ -443,10 +433,8 @@ export function projectNextAction(facts) {
         && (activeFinal.status === "pending" || activeFinal.status === "running")) {
         const reviewRef = ref("review-round", activeFinal.id);
         if (activeFinal.status === "running") {
-            if (reviewGroupAwaitingResolution(activeFinal)) {
-                return buildResolveReviewGroupAction(facts, activeFinal);
-            }
-            if (activeFinal.reviewerTurnId === undefined) {
+            if (activeFinal.reviewerTurnId === undefined
+                && activeFinal.executionGroup === undefined) {
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
                     reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Turn.`,
@@ -459,26 +447,28 @@ export function projectNextAction(facts) {
             }
             const reviewRun = activeReviewRoundRun(activeFinal, facts.activeTurns);
             if (reviewRun === undefined) {
-                if (reviewGroupHasResourceQueue(activeFinal)) {
+                if (reviewGroupNeedsDispatch(activeFinal, facts.activeTurns)) {
                     return buildAction(facts, {
                         kind: "resume-review",
-                        reason: `Task-final ReviewRound ${activeFinal.id} has Reviewer Lanes waiting for Resource Broker capacity.`,
+                        reason: `Task-final ReviewRound ${activeFinal.id} has Review Producer Lanes ready for dispatch or retry.`,
                         refs: [reviewRef],
                         preconditions: [
-                            { fact: "A Reviewer Lane is durably queued", satisfied: true, ref: reviewRef },
-                            { fact: "Resource capacity is available", satisfied: false }
+                            { fact: "A Review Producer Lane is open", satisfied: true, ref: reviewRef }
                         ],
                         recommendedCommand: `yui task review request ${task.id} --role ${activeFinal.reviewerRoleName}`
+                            + reviewLaneRoleOptions(activeFinal)
                     });
                 }
-                const runRef = ref("turn", activeFinal.reviewerTurnId);
+                const runRef = activeFinal.reviewerTurnId === undefined
+                    ? reviewRef
+                    : ref("turn", activeFinal.reviewerTurnId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Task-final ReviewRound ${activeFinal.id} references Reviewer Turn ${activeFinal.reviewerTurnId}, but that Turn is not active.`,
+                    reason: `Task-final ReviewRound ${activeFinal.id} has no active Producer or main Reviewer Turn.`,
                     refs: [reviewRef, runRef],
                     conflicts: [reviewRef, runRef],
                     preconditions: [
-                        { fact: "Reviewer Turn is active", satisfied: false, ref: runRef }
+                        { fact: "Review execution is active or ready to dispatch", satisfied: false, ref: runRef }
                     ]
                 });
             }
@@ -526,7 +516,8 @@ export function projectNextAction(facts) {
                 { fact: "Task-final ReviewRound is pending", satisfied: true, ref: reviewRef },
                 { fact: "Reviewer Turn exists", satisfied: false }
             ],
-            recommendedCommand: `yui task review retry ${task.id}/${activeFinal.id}`
+            recommendedCommand: `yui task review request ${task.id} --role ${activeFinal.reviewerRoleName}`
+                + reviewLaneRoleOptions(activeFinal)
         });
     }
     if (task.projectBindings.length > 0
@@ -535,40 +526,37 @@ export function projectNextAction(facts) {
         const reviewerRole = taskFinalReviewRole(facts);
         return buildAction(facts, {
             kind: "request-final-review",
-            reason: facts.workItems.length === 0
+            reason: deliveryWorkItems.length === 0
                 ? "This Task already owns a final-Review obligation; completion must prepare or resume a Review of its frozen Task head."
                 : "All WorkItems are integrated but no valid Task-final Review attests the frozen Task result.",
             refs: [ref("task", task.id)],
-            preconditions: facts.workItems.length === 0
+            preconditions: deliveryWorkItems.length === 0
                 ? [{ fact: "Valid established Task-final Review at the direct head", satisfied: false }]
                 : [
                     { fact: "All Work Items are terminal", satisfied: true },
-                    { fact: "Every governing ChangeSet is settled", satisfied: true },
+                    { fact: "Every governing WorkItem result is integrated", satisfied: true },
                     { fact: "Valid Task-final Review at the integrated head", satisfied: false }
                 ],
-            recommendedCommand: facts.workItems.length === 0
+            recommendedCommand: deliveryWorkItems.length === 0
                 ? `yui task complete ${task.id} --summary-file -`
                 : `yui task review request ${task.id} --role ${reviewerRole ?? "<reviewer-role>"}`
         });
     }
     const finalReviewOptional = !finalReviewRequired
         && !hasValidFinalReview(facts);
-    const unresolvedDelta = failedFinal?.deltaRecheck?.disposition === "requires-full-review";
     const optionalReviewer = facts.reviewConfig?.roleName
-        ?? (unresolvedDelta ? failedFinal?.reviewerRoleName : undefined);
+        ?? failedFinal?.reviewerRoleName;
     const finalReviewAlternative = finalReviewOptional && optionalReviewer !== undefined
         ? [{
                 kind: "request-final-review",
-                reason: unresolvedDelta
-                    ? `Delta Recheck ${failedFinal.id} returned requires-full-review; request full independent evidence when the Leader judges it necessary.`
-                    : "Request an independent Task-final Review when the Leader wants extra assurance before completion.",
+                reason: "Request an independent Task-final Review when the Leader wants extra assurance before completion.",
                 recommendedCommand: `yui task review request ${task.id} --role ${optionalReviewer}`,
                 refs: [ref("task", task.id)]
             }]
         : [];
     return buildAction(facts, {
         kind: "complete-task",
-        reason: facts.workItems.length === 0
+        reason: deliveryWorkItems.length === 0
             ? "The Leader-owned Task result and its established obligations are ready; complete it without creating successor work."
             : "Every independent delivery unit is integrated; complete the Task instead of creating successor work.",
         refs: [ref("task", task.id)],
@@ -576,10 +564,10 @@ export function projectNextAction(facts) {
             { fact: "All Work Items are terminal", satisfied: true },
             ...(task.projectBindings.length === 0
                 ? []
-                : facts.workItems.length === 0
+                : deliveryWorkItems.length === 0
                     ? [{ fact: "Task main is clean, committed, and verified", satisfied: false }]
                     : [
-                        { fact: "Every governing ChangeSet is settled", satisfied: true },
+                        { fact: "Every governing WorkItem result is integrated", satisfied: true },
                         ...(finalReviewRequired
                             ? [{
                                     fact: "Valid Task-final Review at the integrated head",
@@ -592,9 +580,7 @@ export function projectNextAction(facts) {
         ...(!finalReviewOptional
             ? {}
             : {
-                judgmentRequired: unresolvedDelta
-                    ? "Leader must route the non-accepting Delta result: full Review, another Reviewer, direct inspection, more development, or completion when policy permits."
-                    : "Leader must decide whether the frozen Task result is safe to complete or needs one optional Task-final Review."
+                judgmentRequired: "Leader must decide whether the frozen Task result is safe to complete or needs one optional Task-final Review."
             }),
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
@@ -619,30 +605,6 @@ function buildExecutionLaneRecoveryAction(facts, lane) {
         recommendedCommand: `yui task turn retry ${facts.task.id}/${lane.turnId}`
     });
 }
-function exhaustedExplorationReason(item, executionGroups) {
-    const group = currentWorkItemExecutionGroup(item);
-    if (group?.stage === undefined || group.resolution === undefined)
-        return undefined;
-    if (group.resolution.decision === "reject") {
-        return `Work Item ${item.id} exploration was rejected and has no legal continuation; retire it explicitly.`;
-    }
-    if (group.resolution.decision === "retry"
-        && group.stage.stage === "resolve"
-        && group.stage.round >= group.stage.maxRounds) {
-        return `Work Item ${item.id} exhausted its exploration round budget; retire it explicitly.`;
-    }
-    const resources = executionGroups?.find(({ groupId }) => groupId === group.id)?.resources;
-    if ((group.resolution.decision === "retry" || group.resolution.decision === "blocked")
-        && resources !== undefined
-        && executionStageSpendClosed(resources)) {
-        return `Work Item ${item.id} cannot retry its frozen exploration resource budget; retire it explicitly or replace it with a newly authorized delivery boundary.`;
-    }
-    if ((group.resolution.decision === "retry" || group.resolution.decision === "blocked")
-        && group.stage.stageAttempt >= group.stage.budget.maxAttempts) {
-        return `Work Item ${item.id} exhausted its ${group.stage.stage} stage attempt budget; retire it explicitly.`;
-    }
-    return undefined;
-}
 /**
  * Stable fingerprint of the durable delivery position. It changes exactly
  * when a delivery record changes, so the semantic-progress budget can compare
@@ -683,156 +645,6 @@ function buildAction(facts, input) {
         fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
     };
 }
-function buildExecutionStageAction(facts, item) {
-    const group = currentWorkItemExecutionGroup(item);
-    if (group?.stage?.resources === undefined || group.resolution !== undefined)
-        return null;
-    const projected = facts.executionGroups?.find(({ groupId }) => groupId === group.id);
-    const resources = projected?.resources;
-    if (resources === undefined)
-        return null;
-    const usableLaneIds = group.lanes.filter(({ status }) => status === "completed").map(({ id }) => id);
-    const stageResultsValid = candidateConvergenceStageResultsValid(group);
-    const disagreement = candidateConvergenceDisagreement(group);
-    const routing = routeExecutionStage({
-        group,
-        resources,
-        evidenceSufficient: candidateConvergenceEvidenceSufficient(item, group, usableLaneIds),
-        disagreement
-    });
-    const refs = [ref("work-item", item.id), ref("execution-group", group.id)];
-    const resolveCommand = (decision, suffix = "") => (`yui task work group resolve ${facts.task.id}/${item.id}`
-        + ` --decision ${decision} --summary \"<stage decision>\"${suffix}`);
-    if (routing.action === "blocked") {
-        return buildAction(facts, {
-            kind: "resolve-execution-stage",
-            reason: `${routing.reason}; dispatch would preserve the same pending Lanes without starting them.`,
-            refs,
-            preconditions: [
-                { fact: "Execution stage is unresolved", satisfied: true, ref: refs[1] },
-                {
-                    fact: "Stage deadline or hard budget is exhausted",
-                    satisfied: executionStageSpendClosed(resources),
-                    ref: refs[1]
-                },
-                { fact: "Acceptance-level evidence is sufficient", satisfied: false, ref: refs[1] }
-            ],
-            recommendedCommand: resolveCommand("blocked"),
-            judgmentRequired: "Leader must record the resource-blocked stage, then retire or replace the delivery boundary; the frozen budget cannot be reopened by redispatch."
-        });
-    }
-    if (routing.action === "expand-parallel") {
-        return buildAction(facts, {
-            kind: "resolve-execution-stage",
-            reason: routing.reason,
-            refs,
-            preconditions: [
-                {
-                    fact: "Stage quorum is open or structured results show material disagreement",
-                    satisfied: !resources.quorumMet || disagreement === "high",
-                    ref: refs[1]
-                },
-                {
-                    fact: "Adaptive Lane capacity remains",
-                    satisfied: group.strategy.mode === "adaptive"
-                        && group.lanes.length < group.strategy.max,
-                    ref: refs[1]
-                }
-            ],
-            recommendedCommand: `yui task work dispatch ${facts.task.id}/${item.id} --lane-role <independent-role>`,
-            ...(resources.quorumMet
-                ? {
-                    alternatives: [{
-                            kind: "deepen-sequential",
-                            reason: "Resolve the current evidence and deepen sequentially when another independent Lane has lower value.",
-                            recommendedCommand: resolveCommand("accept"),
-                            refs
-                        }]
-                }
-                : {}),
-            judgmentRequired: resources.quorumMet
-                ? "Leader must choose an unused compatible Task Role for expansion or deliberately select the sequential alternative."
-                : "Leader must choose an unused compatible Task Role so the frozen stage can satisfy quorum."
-        });
-    }
-    if (routing.action === "deepen-sequential") {
-        const resolveRequestsNextRound = group.stage.stage === "resolve";
-        const decision = usableLaneIds.length === 0
-            || !stageResultsValid
-            || !resources.quorumMet
-            || resolveRequestsNextRound
-            ? "retry"
-            : "accept";
-        return buildAction(facts, {
-            kind: "resolve-execution-stage",
-            reason: resolveRequestsNextRound
-                ? "Resolve evidence does not establish a Candidate; begin another bounded exploration round."
-                : !resources.quorumMet
-                    ? "The stage exhausted its Lane capacity before quorum; resolve it as a bounded retry."
-                    : decision === "retry"
-                        ? "The stage has no structurally usable output; resolve it as a bounded retry before redispatch."
-                        : routing.reason,
-            refs,
-            preconditions: [
-                { fact: "No stage Lane remains active or queued", satisfied: true, ref: refs[1] },
-                { fact: "Current stage has structurally usable output", satisfied: stageResultsValid, ref: refs[1] },
-                { fact: "Stage quorum is met", satisfied: resources.quorumMet, ref: refs[1] }
-            ],
-            recommendedCommand: resolveCommand(decision),
-            judgmentRequired: resolveRequestsNextRound
-                ? "Leader must judge whether the frozen round budget permits another exploration round or the WorkItem should be retired."
-                : decision === "retry"
-                    ? "Leader must judge whether the frozen attempt budget permits one retry or the WorkItem should be retired."
-                    : "Leader must select the usable stage evidence before advancing to the next bounded stage."
-        });
-    }
-    if (routing.action === "resolve") {
-        const earlyStop = routing.cancelPendingLaneIds.length === 0
-            ? ""
-            : " --early-stop <observed-marginal-value>";
-        return buildAction(facts, {
-            kind: "resolve-execution-stage",
-            reason: routing.reason,
-            refs,
-            preconditions: [
-                { fact: "Stage quorum is met", satisfied: resources.quorumMet, ref: refs[1] },
-                { fact: "Acceptance-level evidence is sufficient", satisfied: true, ref: refs[1] }
-            ],
-            recommendedCommand: resolveCommand("accept", earlyStop),
-            judgmentRequired: routing.cancelPendingLaneIds.length === 0
-                ? "Leader must select and accept the evidence that satisfies the stage contract."
-                : "Leader must record the observed marginal value before skipping never-started pending Lanes."
-        });
-    }
-    if (resources.pendingLaneIds.length > 0 && resources.activeLaneIds.length === 0) {
-        return buildAction(facts, {
-            kind: "implement-current-work-item",
-            reason: `ExecutionGroup ${group.id} has queued Lanes and an open resource budget; retry Broker admission after the capacity wake.`,
-            refs,
-            preconditions: [
-                { fact: "At least one Lane is durably queued", satisfied: true, ref: refs[1] },
-                {
-                    fact: "Stage deadline and hard budgets remain open",
-                    satisfied: !executionStageSpendClosed(resources),
-                    ref: refs[1]
-                }
-            ],
-            recommendedCommand: `yui task work dispatch ${facts.task.id}/${item.id}`
-        });
-    }
-    if (resources.activeLaneIds.length > 0) {
-        return buildAction(facts, {
-            kind: "repair-protocol-inconsistency",
-            reason: `ExecutionGroup ${group.id} retains active Lanes but no delegated Turn is active.`,
-            refs,
-            conflicts: refs,
-            preconditions: [
-                { fact: "Every active Lane has an active exact Turn", satisfied: false, ref: refs[1] }
-            ]
-        });
-    }
-    return null;
-}
 function latestActiveWorkItemReview(rounds, item, candidate) {
     if (candidate === undefined)
         return undefined;
@@ -843,97 +655,41 @@ function latestActiveWorkItemReview(rounds, item, candidate) {
         && (round.status === "pending" || round.status === "running")));
 }
 function activeReviewRoundRun(round, activeTurns) {
-    if (round.executionGroup !== undefined) {
-        for (const lane of round.executionGroup.lanes) {
-            if (lane.status !== "running"
-                || lane.reviewRoundId !== round.id
-                || lane.turnId === undefined) {
-                continue;
-            }
-            const run = activeTurns.find((candidate) => (candidate.id === lane.turnId && candidate.roleName === lane.roleName));
-            if (run !== undefined)
-                return run;
-        }
-        return undefined;
+    if (round.reviewerTurnId !== undefined) {
+        const main = activeTurns.find((run) => (run.id === round.reviewerTurnId && run.roleName === round.reviewerRoleName));
+        if (main !== undefined)
+            return main;
     }
-    if (round.reviewerTurnId === undefined)
-        return undefined;
-    return activeTurns.find((run) => (run.id === round.reviewerTurnId && run.roleName === round.reviewerRoleName));
-}
-const TERMINAL_REVIEW_LANE_STATUSES = new Set(["completed", "failed"]);
-function isPanelReviewRound(round) {
-    return round.executionGroup !== undefined
-        && (round.executionGroup.lanes.length > 1
-            || round.executionGroup.strategy.mode === "adaptive");
+    for (const lane of round.executionGroup?.lanes ?? []) {
+        if (lane.disposition !== "open" || lane.currentTurnId === undefined)
+            continue;
+        const run = activeTurns.find((candidate) => (candidate.id === lane.currentTurnId && candidate.roleName === lane.roleName));
+        if (run !== undefined)
+            return run;
+    }
+    return undefined;
 }
-function reviewGroupAwaitingResolution(round) {
-    return round.status === "running"
-        && round.executionGroup !== undefined
-        && round.executionGroup.resolution === undefined
-        && isPanelReviewRound(round)
-        && round.executionGroup.lanes.every((lane) => TERMINAL_REVIEW_LANE_STATUSES.has(lane.status));
+function reviewLaneRoleOptions(round) {
+    return round.executionGroup?.lanes
+        .map(({ roleName }) => ` --lane-role ${roleName}`)
+        .join("") ?? "";
 }
-function reviewGroupHasResourceQueue(round) {
-    return round.executionGroup !== undefined
-        && round.executionGroup.resolution === undefined
-        && round.executionGroup.lanes.some((lane) => (lane.status === "pending"
-            && lane.turnId === undefined));
-}
-function buildResolveReviewGroupAction(facts, round) {
-    const group = round.executionGroup;
-    const refs = [
-        ref("review-round", round.id),
-        ref("execution-group", group.id)
-    ];
-    const resolveCommand = (decision) => `yui task review group resolve ${facts.task.id}/${round.id}`
-        + ` --decision ${decision} --summary \"<decision>\"`;
-    return buildAction(facts, {
-        kind: "resolve-review-group",
-        reason: `Reviewer panel ${group.id} has finished every Lane; the Leader must resolve ReviewRound ${round.id}.`,
-        refs,
-        preconditions: [
-            { fact: "ReviewRound is running", satisfied: true, ref: refs[0] },
-            { fact: "Every Reviewer Lane is terminal", satisfied: true, ref: refs[1] },
-            { fact: "Leader has resolved the Review ExecutionGroup", satisfied: false, ref: refs[1] }
-        ],
-        recommendedCommand: resolveCommand("<accept|reject|blocked>"),
-        alternatives: [
-            {
-                kind: "accept-review-group",
-                reason: "Accept the usable Lane outputs when their evidence satisfies the Task objective.",
-                recommendedCommand: resolveCommand("accept"),
-                refs
-            },
-            {
-                kind: "reject-review-group",
-                reason: "Reject the panel evidence when it does not support the delivery.",
-                recommendedCommand: resolveCommand("reject"),
-                refs
-            },
-            {
-                kind: "block-review-group",
-                reason: "Block the Review when a material dependency or external fact prevents a sound decision.",
-                recommendedCommand: resolveCommand("blocked"),
-                refs
-            }
-        ],
-        judgmentRequired: `Leader must judge Review panel ${group.id} against the Task objective, acceptance criteria, and delivery risk.`
-    });
+function reviewGroupNeedsDispatch(round, turns) {
+    return round.executionGroup?.lanes.some((lane) => (lane.disposition === "open"
+        && (lane.currentTurnId === undefined
+            || turns.find(({ id }) => id === lane.currentTurnId)?.status === "failed"))) === true;
 }
 function reviewRoundConflict(round, activeTurns) {
     const reviewRef = ref("review-round", round.id);
     if (round.status === "running") {
-        if (reviewGroupAwaitingResolution(round)) {
-            return null;
-        }
-        if (round.reviewerTurnId === undefined) {
+        if (round.reviewerTurnId === undefined && round.executionGroup === undefined) {
             return {
-                reason: `ReviewRound ${round.id} is running but has no Reviewer Turn.`,
+                reason: `ReviewRound ${round.id} is running but has no execution unit.`,
                 conflicts: [reviewRef]
             };
         }
         if (activeReviewRoundRun(round, activeTurns) === undefined) {
-            if (reviewGroupHasResourceQueue(round))
+            if (round.reviewerTurnId === undefined && round.executionGroup !== undefined)
                 return null;
             const runRef = ref("turn", round.reviewerTurnId);
             return {
@@ -944,7 +700,7 @@ function reviewRoundConflict(round, activeTurns) {
     }
     if (round.status === "pending") {
         const launchedTurnId = round.reviewerTurnId
-            ?? round.executionGroup?.lanes.find((lane) => lane.turnId !== undefined)?.turnId;
+            ?? round.executionGroup?.lanes.find((lane) => lane.currentTurnId !== undefined)?.currentTurnId;
         if (launchedTurnId !== undefined) {
             const runRef = ref("turn", launchedTurnId);
             return {
@@ -962,7 +718,7 @@ function selectOpenWorkItem(workItems) {
         return { kind: "none" };
     const eligible = openItems.find((item) => (item.dependsOn.every((dependencyId) => {
         const status = byId.get(dependencyId)?.status;
-        return status === "completed" || status === "retired";
+        return status === "completed";
     })));
     if (eligible !== undefined)
         return { kind: "ready", item: eligible };
@@ -975,7 +731,7 @@ function selectOpenWorkItem(workItems) {
         visited.add(current.id);
         const blockedBy = current.dependsOn.find((dependencyId) => {
             const status = byId.get(dependencyId)?.status;
-            return status !== "completed" && status !== "retired";
+            return status !== "completed";
         });
         if (blockedBy === undefined)
             return { kind: "ready", item: current };
@@ -1004,12 +760,6 @@ function taskFinalReviewRole(facts) {
 function ref(kind, id) {
     return { kind, id };
 }
-function isEmptyDirectCandidate(candidate) {
-    const snapshot = candidate.taskMainSnapshot;
-    if (snapshot === undefined)
-        return false;
-    return snapshot.projects.every((project) => project.baseCommit === project.headCommit);
-}
 function latestFailedReviewFor(rounds, workItemId) {
     return [...rounds]
         .reverse()
@@ -1021,64 +771,17 @@ function latestTaskFinalReview(rounds, contract) {
         .find((round) => ((round.scope ?? "work-item") === "task"
         && (contract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, contract))));
 }
-function needsChangeSetCapture(facts, item) {
-    if (item.status !== "completed")
-        return false;
-    if (governingChangeSets([item], facts.changeSets).length > 0)
-        return false;
-    const candidate = item.candidates.at(-1);
-    if (candidate === undefined)
-        return false;
-    // A metadata-only Task-main Candidate has no WorkItem Develop
-    // workspace to capture; its boundary is the Task-main head itself.
-    if (candidate.workspace === undefined
-        && candidate.gitSnapshot === undefined
-        && candidate.taskMainSnapshot !== undefined) {
-        return false;
-    }
-    return candidate.workspace !== undefined || candidate.gitSnapshot !== undefined;
-}
 function hasValidFinalReview(facts) {
     const contract = taskFinalReviewContract(facts);
     const final = [...facts.reviewRounds]
         .reverse()
         .find((round) => ((round.scope ?? "work-item") === "task"
         && (contract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, contract))));
-    if (final === undefined || !isAcceptedTaskReviewBaselineFromEvidence(final, nextActionReviewOutcomeEvidence(facts)))
-        return false;
-    if (facts.currentTaskReviewCandidate !== undefined) {
-        return facts.currentTaskReviewCandidate !== null
-            && isDeepStrictEqual(final.taskCandidate, facts.currentTaskReviewCandidate);
-    }
-    const reviewedCommits = new Set((final.taskCandidate?.projects ?? []).map((project) => project.commit));
-    if (reviewedCommits.size === 0)
+    if (final === undefined || !isCompletedTaskReviewEvidenceFromTurns(final, facts.reviewOutcomeEvidence?.turns ?? []))
         return false;
-    const integratedHeads = new Set(facts.integrations
-        .filter((attempt) => attempt.status === "committed")
-        .flatMap((attempt) => facts.changeSets
-        .filter((changeSet) => attempt.changeSetIds.includes(changeSet.id))
-        .map((changeSet) => changeSet.headCommit)));
-    if (integratedHeads.size === 0)
-        return facts.workItems.length === 0;
-    for (const head of integratedHeads) {
-        if (!reviewedCommits.has(head))
-            return false;
-    }
-    return true;
-}
-/** Adapts the serializable next-action evidence bundle to the shared classifier. */
-export function nextActionReviewOutcomeEvidence(facts) {
-    const evidence = facts.reviewOutcomeEvidence;
-    if (evidence === undefined)
-        return undefined;
-    return {
-        listTurns: () => evidence.turns,
-        listReviewFindings: () => evidence.reviewFindings,
-        listEvents: () => evidence.events
-    };
+    return final.taskCandidate !== undefined;
 }
 function detectProtocolInconsistency(facts) {
-    const changeSetIds = new Set(facts.changeSets.map((changeSet) => changeSet.id));
     const workItemById = new Map(facts.workItems.map((item) => [item.id, item]));
     try {
         taskFinalReviewContractResolution(facts);
@@ -1108,14 +811,13 @@ function detectProtocolInconsistency(facts) {
     for (const attempt of facts.integrations) {
         if (attempt.status !== "committed")
             continue;
-        const dangling = attempt.changeSetIds
-            .filter((id) => !changeSetIds.has(id));
-        if (dangling.length > 0) {
+        if (attempt.source.kind === "work-item"
+            && !workItemById.has(attempt.source.workItemId)) {
             return {
-                reason: `Committed Integration ${attempt.id} references missing ChangeSet(s): ${dangling.join(", ")}.`,
+                reason: `Committed Integration ${attempt.id} references missing WorkItem ${attempt.source.workItemId}.`,
                 conflicts: [
                     ref("integration-attempt", attempt.id),
-                    ...dangling.map((id) => ref("change-set", id))
+                    ref("work-item", attempt.source.workItemId)
                 ]
             };
         }