@zq-silk/yui 0.6.1 → 0.6.2

package/dist/commands/deliveryGuardPreflight.js

@@ -17,11 +17,6 @@ export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
     if (options.budget === true) {
         const budget = evaluateSemanticBudget(facts);
         if (budget.exhausted) {
-            if (mode === "enforce") {
-                throw usageError(`Semantic progress budget exhausted: ${budget.reason} `
-                    + `Evidence: ${budget.evidence.join(", ")}. `
-                    + "Record a diagnosis/yield and wait for new facts instead of creating more records.");
-            }
             warnings.push(`Semantic progress budget: ${budget.reason}`);
         }
     }

package/dist/commands/taskCommands.js

@@ -2442,13 +2442,20 @@ function reviewWork(args, store, options) {
             && round.candidateId === candidate.id
             && (round.status === "pending" || round.status === "running")))).at(-1);
         if (activeRound !== undefined) {
+            if (activeRound.status === "pending" && activeRound.reviewerRunId === undefined) {
+                return { round: activeRound, run: null, resumed: true };
+            }
             throw usageError(`ReviewRound is already active: ${activeRound.id}/${activeRound.status}.`);
         }
-        return queueReviewRound(tx, item, config, "leader", now);
+        const queued = queueReviewRound(tx, item, config, "leader", now);
+        return { ...queued, resumed: false };
     });
     if (result.run !== null) {
         notifyReviewMailbox(options, options.runtime, roleMailbox(result.run.taskId, result.run.roleName), result.run.taskId);
     }
+    if (result.resumed) {
+        return output(`Review request ${result.round.id} is pending; resuming dispatch.\n`, { reviewRound: result.round });
+    }
     return result.round.status === "failed"
         ? output(`Review could not start for ${result.round.workItemId}: ${result.round.summary}\n`, { reviewRound: result.round })
         : output(`Review requested as ${result.round.id}\n`, { reviewRound: result.round });

package/dist/commands/taskContextCommand.js

@@ -85,6 +85,15 @@ export function runTaskContextCommand(args, store) {
         ...(nextAction.recommendedCommand === undefined
             ? []
             : [`  Recommended: ${nextAction.recommendedCommand}`]),
+        ...(nextAction.judgmentRequired === undefined
+            ? []
+            : [`  Judgment: ${nextAction.judgmentRequired}`]),
+        ...(nextAction.alternatives === undefined || nextAction.alternatives.length === 0
+            ? []
+            : [
+                "  Alternatives:",
+                ...nextAction.alternatives.map((alternative) => `    ${alternative.kind}: ${alternative.reason}`)
+            ]),
         ...(task.description === undefined ? [] : [`Description: ${compactText(task.description)}`]),
         ...(task.priority === undefined ? [] : [`Priority: ${task.priority}`]),
         ...(task.tags === undefined ? [] : [`Tags: ${task.tags.join(", ")}`]),

package/dist/commands/taskNextActionCommand.js

@@ -4,7 +4,8 @@ import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
  * Folds the existing durable records into exactly one protocol-level next
- * action with exact refs, preconditions, and the single recommended command.
+ * action with exact refs, preconditions, recommended command, alternatives, and
+ * the judgment that remains owned by the Leader.
  * The command never mutates state; when the action is `route-review-findings`
  * it also prints the minimal repair wave for the failing Review.
  */
@@ -69,6 +70,20 @@ function renderNextAction(action, repairWave) {
         ...(action.recommendedCommand === undefined
             ? []
             : [`Recommended: ${action.recommendedCommand}`]),
+        ...(action.judgmentRequired === undefined
+            ? []
+            : [`Judgment: ${action.judgmentRequired}`]),
+        ...(action.alternatives === undefined || action.alternatives.length === 0
+            ? []
+            : [
+                "Alternatives:",
+                ...action.alternatives.map((alternative) => {
+                    const command = alternative.recommendedCommand === undefined
+                        ? ""
+                        : ` — ${alternative.recommendedCommand}`;
+                    return `  ${alternative.kind}: ${alternative.reason}${command}`;
+                })
+            ]),
         ...(action.conflicts === undefined || action.conflicts.length === 0
             ? []
             : [

package/dist/config/yuiConfig.js

@@ -43,10 +43,12 @@ export function reconciliationIntervalMilliseconds(value) {
 }
 /**
  * Issue 07 (Leader convergence) feature mode. `display` only shows the
- * read-only next-action projection; `warn` additionally reports duplicate
- * deliveries; `enforce` hard-blocks exact duplicates and exhausted semantic
- * budgets. The mode is additive and optional — Homes without it keep the
- * `display` default, so no config migration is required.
+ * read-only next-action decision support; `warn` additionally reports
+ * duplicate deliveries and semantic-budget warnings; `enforce` hard-blocks
+ * only exact duplicates, while semantic-budget exhaustion remains a warning
+ * because it must not override Leader judgment. The mode is additive and
+ * optional — Homes without it keep the `display` default, so no config
+ * migration is required.
  */
 export const LEADER_NEXT_ACTION_MODES = ["display", "warn", "enforce"];
 export const DEFAULT_LEADER_NEXT_ACTION_MODE = "display";

package/dist/storage/sqliteStore.js

@@ -656,6 +656,7 @@ export class SqliteTaskStore {
             changeSets: this.#sortById(this.#listPayload("change_sets", "task_id = ?", [taskId]), (changeSet) => changeSet.id),
             integrations: this.#sortById(this.#listPayload("integration_attempts", "task_id = ?", [taskId]), (attempt) => attempt.id),
             reviewRounds: this.#sortById(this.#listPayload("review_rounds", "task_id = ?", [taskId]), (round) => round.id),
+            reviewConfig: this.getReviewConfig(),
             openInputRequests: this.#sortById(this.#listPayload("input_requests", "task_id = ? AND status = 'open'", [taskId]), (request) => request.id),
             activeRuns: runs.filter((run) => run.status === "active"),
             leaderRuns: runs.filter((run) => run.roleName === "leader")

package/dist/storage/taskStore.js

@@ -404,6 +404,7 @@ export class FileTaskStore {
             changeSets: values(aggregate.changeSets, "id"),
             integrations: values(aggregate.integrationAttempts, "id"),
             reviewRounds: values(aggregate.reviewRounds, "id"),
+            reviewConfig: this.getReviewConfig(),
             openInputRequests: values(aggregate.inputRequests, "id")
                 .filter((request) => request.status === "open"),
             activeRuns: agentRuns.filter((run) => run.status === "active"),

package/dist/task/nextAction.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { sameTaskFinalReviewContract, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { currentWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
@@ -47,6 +48,17 @@ export function projectNextAction(facts) {
             ]
         });
     }
+    if (task.status === "draft") {
+        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.`,
+            refs: [ref("task", task.id)],
+            preconditions: [
+                { fact: "Task is active", satisfied: false, ref: ref("task", task.id) }
+            ],
+            recommendedCommand: `yui task activate ${task.id}`
+        });
+    }
     const candidateReady = facts.workItems
         .find((item) => item.status === "awaiting_acceptance");
     if (candidateReady !== undefined) {
@@ -64,6 +76,70 @@ export function projectNextAction(facts) {
                 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.reviewerRunId === undefined) {
+                    return buildAction(facts, {
+                        kind: "repair-protocol-inconsistency",
+                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Run.`,
+                        refs: [reviewRef],
+                        conflicts: [reviewRef],
+                        preconditions: [
+                            { fact: "Running ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                        ]
+                    });
+                }
+                const reviewRun = activeReviewRoundRun(activeReview, facts.activeRuns);
+                if (reviewRun === undefined) {
+                    const runRef = ref("agent-run", activeReview.reviewerRunId);
+                    return buildAction(facts, {
+                        kind: "repair-protocol-inconsistency",
+                        reason: `ReviewRound ${activeReview.id} references Reviewer Run ${activeReview.reviewerRunId}, but that Run is not active.`,
+                        refs: [reviewRef, runRef],
+                        conflicts: [reviewRef, runRef],
+                        preconditions: [
+                            { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                        ]
+                    });
+                }
+                return buildAction(facts, {
+                    kind: "wait-for-owned-execution",
+                    reason: `Reviewer Run ${reviewRun.id} is evaluating Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"}.`,
+                    refs: [reviewRef, ref("agent-run", reviewRun.id)],
+                    preconditions: [
+                        { fact: "ReviewRound is running", satisfied: true, ref: reviewRef },
+                        { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                    ]
+                });
+            }
+            if (activeReview.reviewerRunId !== undefined) {
+                const runRef = ref("agent-run", activeReview.reviewerRunId);
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer Run ${activeReview.reviewerRunId}.`,
+                    refs: [reviewRef, runRef],
+                    conflicts: [reviewRef, runRef],
+                    preconditions: [
+                        { fact: "Pending ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                    ]
+                });
+            }
+            return buildAction(facts, {
+                kind: "resume-review",
+                reason: `ReviewRound ${activeReview.id} is pending and never launched; resume it before accepting or rejecting the Candidate.`,
+                refs: [reviewRef],
+                preconditions: [
+                    { fact: "ReviewRound is pending", satisfied: true, ref: reviewRef },
+                    { fact: "Reviewer Run exists", satisfied: false }
+                ],
+                recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
+            });
+        }
         const refs = [
             ref("work-item", candidateReady.id),
             ...(candidate === undefined ? [] : [ref("candidate", `${candidateReady.id}/${candidate.id}`)])
@@ -78,7 +154,25 @@ export function projectNextAction(facts) {
                     ? [{ fact: "Candidate record exists", satisfied: false }]
                     : [{ fact: "Candidate record exists", satisfied: true, ref: refs[1] }])
             ],
-            recommendedCommand: `yui task work accept ${task.id}/${candidateReady.id} --summary \"<decision>\"`
+            recommendedCommand: `yui task work accept ${task.id}/${candidateReady.id} --summary \"<decision>\"`,
+            alternatives: [
+                {
+                    kind: "reject-candidate",
+                    reason: "Reject when the Candidate does not satisfy the Task objective or acceptance criteria.",
+                    recommendedCommand: `yui task work reject ${task.id}/${candidateReady.id} --summary \"<reason>\"`,
+                    refs
+                },
+                ...(candidate?.reviewPolicy === undefined
+                    || candidate.reviewPolicy.trigger === "final"
+                    ? []
+                    : [{
+                            kind: "re-review-candidate",
+                            reason: "Request another WorkItem Review when the Leader needs independent evidence before disposition.",
+                            recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`,
+                            refs
+                        }])
+            ],
+            judgmentRequired: `Leader must judge Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"} against the Task objective, acceptance criteria, and delivery risk.`
         });
     }
     const activeWorkers = facts.activeRuns.filter((run) => run.roleName !== "leader");
@@ -101,7 +195,8 @@ export function projectNextAction(facts) {
                 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`
             });
         }
         return buildAction(facts, {
@@ -114,17 +209,46 @@ export function projectNextAction(facts) {
             recommendedCommand: `yui task work update ${task.id}/${failedWork.id} running`
         });
     }
-    const openWork = facts.workItems
-        .find((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
-    if (openWork !== undefined) {
+    const openWork = selectOpenWorkItem(facts.workItems);
+    if (openWork?.kind === "blocked") {
+        const refs = [
+            ref("work-item", openWork.itemId),
+            ref("work-item", openWork.blockedBy)
+        ];
+        return buildAction(facts, {
+            kind: "repair-protocol-inconsistency",
+            reason: `Work Item ${openWork.itemId} depends on ${openWork.blockedBy}, which is not completed or available.`,
+            refs,
+            conflicts: refs,
+            preconditions: [
+                { fact: `Dependency ${openWork.blockedBy} is completed`, satisfied: false, ref: refs[1] }
+            ]
+        });
+    }
+    if (openWork?.kind === "ready") {
+        const item = openWork.item;
+        const refs = [ref("work-item", item.id)];
         return buildAction(facts, {
             kind: "implement-current-work-item",
-            reason: `Work Item ${openWork.id} is ${openWork.status}; dispatch or continue its implementation.`,
-            refs: [ref("work-item", openWork.id)],
+            reason: `Work Item ${item.id} is ${item.status}; dispatch or continue its implementation.`,
+            refs,
             preconditions: [
-                { fact: `Work Item is ${openWork.status}`, satisfied: true, ref: ref("work-item", openWork.id) }
+                { fact: `Work Item is ${item.status}`, satisfied: true, ref: refs[0] }
+            ],
+            recommendedCommand: `yui task work dispatch ${task.id}/${item.id}`,
+            alternatives: [
+                {
+                    kind: "execute-directly",
+                    reason: "Execute the bounded Work Item directly when the Leader's current context and authority are sufficient.",
+                    refs
+                },
+                {
+                    kind: "native-subagent",
+                    reason: "Use one native implementer subagent when one bounded implementation pass benefits from parallel attention.",
+                    refs
+                }
             ],
-            recommendedCommand: `yui task work dispatch ${task.id}/${openWork.id}`
+            judgmentRequired: "Leader must choose the execution path: direct execution, a native subagent, or managed Task Role dispatch."
         });
     }
     if (facts.workItems.length === 0) {
@@ -136,9 +260,7 @@ export function projectNextAction(facts) {
                 { fact: "At least one Work Item exists", satisfied: false },
                 { fact: "Task is active", satisfied: task.status === "active" }
             ],
-            recommendedCommand: task.status === "draft"
-                ? `yui task activate ${task.id}`
-                : `yui task work create ${task.id} \"<objective>\"`
+            recommendedCommand: `yui task work create ${task.id} \"<objective>\"`
         });
     }
     const uncaptured = facts.workItems.find((item) => needsChangeSetCapture(facts, item));
@@ -176,10 +298,80 @@ export function projectNextAction(facts) {
             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);
+    if (activeFinal !== undefined
+        && (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.reviewerRunId === undefined) {
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Run.`,
+                    refs: [reviewRef],
+                    conflicts: [reviewRef],
+                    preconditions: [
+                        { fact: "Running Task-final ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                    ]
+                });
+            }
+            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeRuns);
+            if (reviewRun === undefined) {
+                const runRef = ref("agent-run", activeFinal.reviewerRunId);
+                return buildAction(facts, {
+                    kind: "repair-protocol-inconsistency",
+                    reason: `Task-final ReviewRound ${activeFinal.id} references Reviewer Run ${activeFinal.reviewerRunId}, but that Run is not active.`,
+                    refs: [reviewRef, runRef],
+                    conflicts: [reviewRef, runRef],
+                    preconditions: [
+                        { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                    ]
+                });
+            }
+            return buildAction(facts, {
+                kind: "wait-for-owned-execution",
+                reason: `Reviewer Run ${reviewRun.id} is executing Task-final Review ${activeFinal.id}.`,
+                refs: [reviewRef, ref("agent-run", reviewRun.id)],
+                preconditions: [
+                    { fact: "Task-final ReviewRound is running", satisfied: true, ref: reviewRef },
+                    { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                ]
+            });
+        }
+        if (activeFinal.reviewerRunId !== undefined) {
+            const runRef = ref("agent-run", activeFinal.reviewerRunId);
+            return buildAction(facts, {
+                kind: "repair-protocol-inconsistency",
+                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer Run ${activeFinal.reviewerRunId}.`,
+                refs: [reviewRef, runRef],
+                conflicts: [reviewRef, runRef],
+                preconditions: [
+                    { fact: "Pending Task-final ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                ]
+            });
+        }
+        return buildAction(facts, {
+            kind: "resume-review",
+            reason: `Task-final ReviewRound ${activeFinal.id} is pending and never launched; retry it under the same semantic Round.`,
+            refs: [reviewRef],
+            preconditions: [
+                { fact: "Task-final ReviewRound is pending", satisfied: true, ref: reviewRef },
+                { fact: "Reviewer Run exists", satisfied: false }
+            ],
+            recommendedCommand: `yui task review retry ${task.id}/${activeFinal.id}`
         });
     }
-    if (task.projectBindings.length > 0 && !hasValidFinalReview(facts)) {
+    const finalReviewRequired = taskFinalReviewRequired(facts);
+    if (task.projectBindings.length > 0
+        && finalReviewRequired
+        && !hasValidFinalReview(facts)) {
+        const reviewerRole = taskFinalReviewRole(facts);
         return buildAction(facts, {
             kind: "request-final-review",
             reason: "All Work Items are delivered but no valid Task-final Review attests the integrated head.",
@@ -189,9 +381,20 @@ export function projectNextAction(facts) {
                 { fact: "Every ChangeSet is committed", satisfied: true },
                 { fact: "Valid Task-final Review at the integrated head", satisfied: false }
             ],
-            recommendedCommand: `yui task review request ${task.id} --role <global-reviewer>`
+            recommendedCommand: `yui task review request ${task.id} --role ${reviewerRole ?? "<reviewer-role>"}`
         });
     }
+    const finalReviewOptional = task.projectBindings.length > 0
+        && !finalReviewRequired
+        && !hasValidFinalReview(facts);
+    const finalReviewAlternative = finalReviewOptional && facts.reviewConfig !== null
+        ? [{
+                kind: "request-final-review",
+                reason: "Request an independent Task-final Review when the Leader wants extra assurance before completion.",
+                recommendedCommand: `yui task review request ${task.id} --role ${facts.reviewConfig.roleName}`,
+                refs: [ref("task", task.id)]
+            }]
+        : [];
     return buildAction(facts, {
         kind: "complete-task",
         reason: "The delivery chain is complete; converge the Task instead of creating successor work.",
@@ -202,9 +405,18 @@ export function projectNextAction(facts) {
                 ? []
                 : [
                     { fact: "Every ChangeSet is committed", satisfied: true },
-                    { fact: "Valid Task-final Review at the integrated head", satisfied: true }
+                    {
+                        fact: "Valid Task-final Review at the integrated head",
+                        satisfied: hasValidFinalReview(facts)
+                    }
                 ])
         ],
+        ...(finalReviewAlternative.length === 0 ? {} : { alternatives: finalReviewAlternative }),
+        ...(!finalReviewOptional
+            ? {}
+            : {
+                judgmentRequired: "Leader must decide whether the integrated delivery is safe to complete directly or needs an optional Task-final Review."
+            }),
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
 }
@@ -237,10 +449,174 @@ function buildAction(facts, input) {
         ...(input.recommendedCommand === undefined
             ? {}
             : { recommendedCommand: input.recommendedCommand }),
+        ...(input.alternatives === undefined || input.alternatives.length === 0
+            ? {}
+            : { alternatives: input.alternatives }),
+        ...(input.judgmentRequired === undefined
+            ? {}
+            : { judgmentRequired: input.judgmentRequired }),
         ...(input.conflicts === undefined ? {} : { conflicts: input.conflicts }),
         fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
     };
 }
+function latestActiveWorkItemReview(rounds, item, candidate) {
+    if (candidate === undefined)
+        return undefined;
+    return [...rounds]
+        .reverse()
+        .find((round) => (round.workItemId === item.id
+        && round.candidateId === candidate.id
+        && (round.status === "pending" || round.status === "running")));
+}
+function activeReviewRoundRun(round, activeRuns) {
+    if (round.executionGroup !== undefined) {
+        for (const lane of round.executionGroup.lanes) {
+            if (lane.status !== "running"
+                || lane.reviewRoundId !== round.id
+                || lane.runId === undefined) {
+                continue;
+            }
+            const run = activeRuns.find((candidate) => (candidate.id === lane.runId && candidate.roleName === lane.roleName));
+            if (run !== undefined)
+                return run;
+        }
+        return undefined;
+    }
+    if (round.reviewerRunId === undefined)
+        return undefined;
+    return activeRuns.find((run) => (run.id === round.reviewerRunId && run.roleName === round.reviewerRoleName));
+}
+const TERMINAL_REVIEW_LANE_STATUSES = new Set(["yielded", "completed", "failed"]);
+function isPanelReviewRound(round) {
+    return round.executionGroup !== undefined
+        && (round.executionGroup.lanes.length > 1
+            || round.executionGroup.strategy.mode === "adaptive");
+}
+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 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 reviewRoundConflict(round, activeRuns) {
+    const reviewRef = ref("review-round", round.id);
+    if (round.status === "running") {
+        if (reviewGroupAwaitingResolution(round)) {
+            return null;
+        }
+        if (round.reviewerRunId === undefined) {
+            return {
+                reason: `ReviewRound ${round.id} is running but has no Reviewer Run.`,
+                conflicts: [reviewRef]
+            };
+        }
+        if (activeReviewRoundRun(round, activeRuns) === undefined) {
+            const runRef = ref("agent-run", round.reviewerRunId);
+            return {
+                reason: `ReviewRound ${round.id} references Reviewer Run ${round.reviewerRunId}, but that Run is not active.`,
+                conflicts: [reviewRef, runRef]
+            };
+        }
+    }
+    if (round.status === "pending") {
+        const launchedRunId = round.reviewerRunId
+            ?? round.executionGroup?.lanes.find((lane) => lane.runId !== undefined)?.runId;
+        if (launchedRunId !== undefined) {
+            const runRef = ref("agent-run", launchedRunId);
+            return {
+                reason: `Pending ReviewRound ${round.id} already references Reviewer Run ${launchedRunId}.`,
+                conflicts: [reviewRef, runRef]
+            };
+        }
+    }
+    return null;
+}
+function selectOpenWorkItem(workItems) {
+    const byId = new Map(workItems.map((item) => [item.id, item]));
+    const openItems = workItems.filter((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));
+    if (openItems.length === 0)
+        return { kind: "none" };
+    const eligible = openItems.find((item) => (item.dependsOn.every((dependencyId) => byId.get(dependencyId)?.status === "completed")));
+    if (eligible !== undefined)
+        return { kind: "ready", item: eligible };
+    let current = openItems[0];
+    const visited = new Set();
+    while (current !== undefined) {
+        if (visited.has(current.id)) {
+            return { kind: "blocked", itemId: current.id, blockedBy: current.id };
+        }
+        visited.add(current.id);
+        const blockedBy = current.dependsOn
+            .find((dependencyId) => byId.get(dependencyId)?.status !== "completed");
+        if (blockedBy === undefined)
+            return { kind: "ready", item: current };
+        const dependency = byId.get(blockedBy);
+        if (dependency === undefined || !OPEN_WORK_ITEM_STATUSES.has(dependency.status)) {
+            return { kind: "blocked", itemId: current.id, blockedBy };
+        }
+        current = dependency;
+    }
+    return { kind: "none" };
+}
+function taskFinalReviewContract(facts) {
+    const contract = facts.workItems
+        .flatMap((item) => item.candidates)
+        .map((candidate) => candidate.taskFinalReviewContract)
+        .find((contract) => contract !== undefined);
+    return contract === undefined ? undefined : validateTaskFinalReviewContract(contract);
+}
+function taskFinalReviewRequired(facts) {
+    return taskFinalReviewContract(facts) !== undefined
+        || latestTaskFinalReview(facts.reviewRounds) !== undefined
+        || facts.reviewConfig?.trigger === "final";
+}
+function taskFinalReviewRole(facts) {
+    return taskFinalReviewContract(facts)?.reviewerRoleName
+        ?? latestTaskFinalReview(facts.reviewRounds)?.reviewerRoleName
+        ?? (facts.reviewConfig?.trigger === "final" ? facts.reviewConfig.roleName : undefined);
+}
 function ref(kind, id) {
     return { kind, id };
 }
@@ -303,6 +679,25 @@ function hasValidFinalReview(facts) {
 function detectProtocolInconsistency(facts) {
     const changeSetIds = new Set(facts.changeSets.map((changeSet) => changeSet.id));
     const workItemById = new Map(facts.workItems.map((item) => [item.id, item]));
+    const contractedCandidates = facts.workItems
+        .flatMap((item) => item.candidates.map((candidate) => ({ item, candidate })))
+        .filter(({ candidate }) => candidate.taskFinalReviewContract !== undefined);
+    if (contractedCandidates.length > 1) {
+        const first = validateTaskFinalReviewContract(contractedCandidates[0].candidate.taskFinalReviewContract);
+        const conflict = contractedCandidates.find(({ candidate }) => (!sameTaskFinalReviewContract(first, candidate.taskFinalReviewContract)));
+        if (conflict !== undefined) {
+            const refs = contractedCandidates.map(({ item, candidate }) => ref("candidate", `${item.id}/${candidate.id}`));
+            return {
+                reason: "Task-final Review contracts conflict across Candidates; the completion gate is ambiguous.",
+                conflicts: refs
+            };
+        }
+    }
+    for (const round of facts.reviewRounds) {
+        const reviewConflict = reviewRoundConflict(round, facts.activeRuns);
+        if (reviewConflict !== null)
+            return reviewConflict;
+    }
     for (const attempt of facts.integrations) {
         if (attempt.status !== "committed")
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-leader/SKILL.md

@@ -100,6 +100,14 @@ unavailable external fact that blocks progress.
 
 ## Lead with judgment
 
+- `yui task next-action <task-id>` is decision support, not an autopilot. It
+  reads durable Task records and returns one recommended command, exact refs,
+  legitimate alternatives, and any `judgmentRequired` explanation. The Leader
+  still owns product priority, acceptance, risk, and the choice among legal
+  alternatives. Treat protocol inconsistencies, active Run ownership, open
+  InputRequests, Draft activation, exact duplicates, and durable final-review
+  contracts as hard boundaries; treat semantic-budget and suspected-duplicate
+  warnings as evidence rather than commands.
 - Keep the context layers distinct in every handoff: Yui Core supplies durable
   identity, lifecycle, access, workspace, and exact-yield safety; this generic
   role Skill supplies portable collaboration behavior; the bound Project's