@zq-silk/yui 0.15.7 → 0.15.9

package/dist/task/nextAction.js

@@ -1,12 +1,12 @@
 import { createHash } from "node:crypto";
 import { governingWorkItemDeliveries, workItemDeliverySettled } from "../integration/deliveryObligation.js";
-import { isCompletedTaskReviewEvidenceFromTurns } from "../review/reviewAcceptance.js";
+import { isCompletedTaskReviewEvidenceFromRuns } from "../review/reviewAcceptance.js";
 import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
 import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
 import { draftWorkItemDependencyIssue } from "./draftPlan.js";
-import { currentWorkItemCandidate, governingWorkItemCandidate } from "../workItem/workItem.js";
-const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
+import { currentWorkItemCandidate, currentWorkItemExecutionGroup, governingWorkItemCandidate } from "../workItem/workItem.js";
+const OPEN_WORK_ITEM_STATUSES = new Set(["open"]);
 export function projectNextAction(facts) {
     const { task } = facts;
     const deliveryWorkItems = facts.workItems.filter(({ status }) => status !== "retired");
@@ -55,18 +55,18 @@ export function projectNextAction(facts) {
         });
     }
     const laneRecovery = actionableExecutionLaneRecoveries(facts.executionGroups ?? [])
-        .find(hasExactTurn);
+        .find(hasExactRun);
     if (laneRecovery !== undefined) {
         return buildExecutionLaneRecoveryAction(facts, laneRecovery);
     }
-    const activeLeader = facts.activeTurns.find((run) => run.roleName === "leader");
+    const activeLeader = facts.activeRuns.find((run) => run.roleName === "leader");
     if (activeLeader !== undefined) {
         return buildAction(facts, {
             kind: "wait-for-owned-execution",
-            reason: `Leader Turn ${activeLeader.id} is active; the protocol position is being executed.`,
-            refs: [ref("turn", activeLeader.id)],
+            reason: `Leader AgentRun ${activeLeader.id} is active; the protocol position is being executed.`,
+            refs: [ref("run", activeLeader.id)],
             preconditions: [
-                { fact: "Leader Turn is active", satisfied: true, ref: ref("turn", activeLeader.id) }
+                { fact: "Leader AgentRun is active", satisfied: true, ref: ref("run", activeLeader.id) }
             ]
         });
     }
@@ -121,29 +121,58 @@ export function projectNextAction(facts) {
             recommendedCommand: `yui task activate ${task.id}`
         });
     }
+    const checkingIntegration = facts.integrations.find(attempt => attempt.status === "running" && attempt.jobId !== undefined);
+    if (checkingIntegration !== undefined) {
+        const job = facts.integrationJobs?.find(job => job.id === checkingIntegration.jobId);
+        const refs = [ref("integration", checkingIntegration.id), ref("job", checkingIntegration.jobId)];
+        if (job?.status === "queued" || job?.status === "running") {
+            return buildAction(facts, {
+                kind: "wait-for-owned-execution",
+                reason: `Integration ${checkingIntegration.id} check Job ${job.id} is ${job.status}.`,
+                refs,
+                preconditions: [{ fact: "Check Job is still executing", satisfied: true, ref: refs[1] }],
+                alternatives: [{
+                        kind: "continue-integration",
+                        reason: "When the check Job settles, continue this exact Integration to consume its result.",
+                        recommendedCommand: `yui task integration continue ${task.id}/${checkingIntegration.id}`
+                    }]
+            });
+        }
+        return buildAction(facts, {
+            kind: "integrate-work-item",
+            reason: `Integration ${checkingIntegration.id} awaits check-result consumption (${job?.status ?? "read current Job"}); an empty integration queue does not finalize this direct attempt.`,
+            refs,
+            preconditions: [{ fact: "The Integration retains its exact check Job", satisfied: true, ref: refs[0] }],
+            recommendedCommand: `yui task integration continue ${task.id}/${checkingIntegration.id}`
+        });
+    }
     const candidateReady = facts.workItems
-        .find((item) => item.status === "awaiting_acceptance");
+        .find((item) => (item.status === "open" && item.currentCandidateId !== undefined));
     if (candidateReady !== undefined) {
         const candidate = currentWorkItemCandidate(candidateReady);
         const activeReview = latestActiveWorkItemReview(facts.reviewRounds, candidateReady, candidate);
         if (activeReview !== undefined) {
             const reviewRef = ref("review-round", activeReview.id);
             if (activeReview.status === "running") {
-                if (activeReview.reviewerTurnId === undefined
+                if (activeReview.reviewerRunId === undefined
                     && activeReview.executionGroup === undefined) {
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
-                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Turn.`,
+                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer AgentRun.`,
                         refs: [reviewRef],
                         conflicts: [reviewRef],
                         preconditions: [
-                            { fact: "Running ReviewRound has an exact Reviewer Turn", satisfied: false, ref: reviewRef }
+                            { fact: "Running ReviewRound has an exact Reviewer AgentRun", satisfied: false, ref: reviewRef }
                         ]
                     });
                 }
-                const reviewRun = activeReviewRoundRun(activeReview, facts.activeTurns);
+                const reviewRun = activeReviewRoundRun(activeReview, facts.activeRuns);
                 if (reviewRun === undefined) {
-                    if (reviewGroupNeedsDispatch(activeReview, facts.activeTurns)) {
+                    if (activeReview.executionGroup !== undefined && activeReview.reviewerRunId === undefined
+                        && !reviewGroupNeedsDispatch(activeReview, facts.activeRuns)) {
+                        return synthesisSelectionAction(facts, "review", activeReview.id);
+                    }
+                    if (reviewGroupNeedsDispatch(activeReview, facts.activeRuns)) {
                         return buildAction(facts, {
                             kind: "resume-review",
                             reason: `ReviewRound ${activeReview.id} has Review Producer Lanes ready for dispatch or retry.`,
@@ -155,12 +184,12 @@ export function projectNextAction(facts) {
                                 + reviewLaneRoleOptions(activeReview)
                         });
                     }
-                    const runRef = activeReview.reviewerTurnId === undefined
+                    const runRef = activeReview.reviewerRunId === undefined
                         ? reviewRef
-                        : ref("turn", activeReview.reviewerTurnId);
+                        : ref("run", activeReview.reviewerRunId);
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
-                        reason: `ReviewRound ${activeReview.id} has no active Producer or main Reviewer Turn.`,
+                        reason: `ReviewRound ${activeReview.id} has no active Producer or main Reviewer AgentRun.`,
                         refs: [reviewRef, runRef],
                         conflicts: [reviewRef, runRef],
                         preconditions: [
@@ -170,23 +199,23 @@ export function projectNextAction(facts) {
                 }
                 return buildAction(facts, {
                     kind: "wait-for-owned-execution",
-                    reason: `Reviewer Turn ${reviewRun.id} is evaluating Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"}.`,
-                    refs: [reviewRef, ref("turn", reviewRun.id)],
+                    reason: `Reviewer AgentRun ${reviewRun.id} is evaluating Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"}.`,
+                    refs: [reviewRef, ref("run", reviewRun.id)],
                     preconditions: [
                         { fact: "ReviewRound is running", satisfied: true, ref: reviewRef },
-                        { fact: "Reviewer Turn is active", satisfied: true, ref: ref("turn", reviewRun.id) }
+                        { fact: "Reviewer AgentRun is active", satisfied: true, ref: ref("run", reviewRun.id) }
                     ]
                 });
             }
-            if (activeReview.reviewerTurnId !== undefined) {
-                const runRef = ref("turn", activeReview.reviewerTurnId);
+            if (activeReview.reviewerRunId !== undefined) {
+                const runRef = ref("run", activeReview.reviewerRunId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer Turn ${activeReview.reviewerTurnId}.`,
+                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer AgentRun ${activeReview.reviewerRunId}.`,
                     refs: [reviewRef, runRef],
                     conflicts: [reviewRef, runRef],
                     preconditions: [
-                        { fact: "Pending ReviewRound has no Reviewer Turn", satisfied: false, ref: runRef }
+                        { fact: "Pending ReviewRound has no Reviewer AgentRun", satisfied: false, ref: runRef }
                     ]
                 });
             }
@@ -196,7 +225,7 @@ export function projectNextAction(facts) {
                 refs: [reviewRef],
                 preconditions: [
                     { fact: "ReviewRound is pending", satisfied: true, ref: reviewRef },
-                    { fact: "Reviewer Turn exists", satisfied: false }
+                    { fact: "Reviewer AgentRun exists", satisfied: false }
                 ],
                 recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
                     + reviewLaneRoleOptions(activeReview)
@@ -256,35 +285,15 @@ export function projectNextAction(facts) {
             judgmentRequired: `Leader must judge Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"} against the Task objective, acceptance criteria, and delivery risk.`
         });
     }
-    // Turn purpose owns routing. Review Turns remain attached to their exact
+    // AgentRun purpose owns routing. Review AgentRuns remain attached to their exact
     // ReviewRound branches below instead of being mistaken for Worker delivery.
-    const activeDelegatedExecutions = facts.activeTurns.filter((run) => (run.purpose === "execution" && run.roleName !== "leader"));
+    const activeDelegatedExecutions = facts.activeRuns.filter((run) => (run.purpose === "execution" && run.roleName !== "leader"));
     if (activeDelegatedExecutions.length > 0) {
         return buildAction(facts, {
             kind: "wait-for-owned-execution",
-            reason: `${activeDelegatedExecutions.length} delegated execution Turn(s) are active; wait for their completion.`,
-            refs: activeDelegatedExecutions.map((run) => ref("turn", run.id)),
-            preconditions: activeDelegatedExecutions.map((run) => ({ fact: `Execution Turn ${run.id} is active`, satisfied: true, ref: ref("turn", run.id) }))
-        });
-    }
-    const failedWork = facts.workItems.find((item) => item.status === "failed");
-    if (failedWork !== undefined) {
-        const failedReview = latestFailedReviewFor(facts.reviewRounds, failedWork.id);
-        return buildAction(facts, {
-            kind: "implement-current-work-item",
-            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) }
-            ],
-            recommendedCommand: failedWork.assignee === undefined
-                ? `yui task work update ${task.id}/${failedWork.id} running`
-                : `yui task work dispatch ${task.id}/${failedWork.id}`
+            reason: `${activeDelegatedExecutions.length} delegated execution AgentRun(s) are active; wait for their completion.`,
+            refs: activeDelegatedExecutions.map((run) => ref("run", run.id)),
+            preconditions: activeDelegatedExecutions.map((run) => ({ fact: `Execution AgentRun ${run.id} is active`, satisfied: true, ref: ref("run", run.id) }))
         });
     }
     const openWork = selectOpenWorkItem(facts.workItems);
@@ -305,6 +314,11 @@ export function projectNextAction(facts) {
     }
     if (openWork?.kind === "ready") {
         const item = openWork.item;
+        const group = currentWorkItemExecutionGroup(item);
+        if (item.status === "open" && group !== undefined
+            && !facts.activeRuns.some((run) => run.sourceExecutionGroupId === group.id)) {
+            return synthesisSelectionAction(facts, "work", item.id);
+        }
         const refs = [ref("work-item", item.id)];
         return buildAction(facts, {
             kind: "implement-current-work-item",
@@ -342,24 +356,20 @@ export function projectNextAction(facts) {
                     refs: [ref("task", task.id)]
                 }];
         return buildAction(facts, {
-            kind: "complete-task",
-            reason: task.type === "bugfix"
-                ? `Task ${task.id} is a Leader-owned bugfix; implement and verify it on Task main without manufacturing a WorkItem.`
-                : task.type === "feature"
-                    ? `Feature ${task.id} has no independent delivery units; the Leader may implement it on Task main or create WorkItems only if separate ownership is genuinely useful.`
-                    : `Task ${task.id} has no independent delivery units; the Leader decides whether to own it on Task main or create WorkItems only if separate ownership is genuinely useful.`,
+            kind: "advance-task",
+            reason: `Task ${task.id} has no recorded WorkItems. This does not determine its required topology or prove completion; advance the user's persisted requirements and Brief.`,
             refs: [ref("task", task.id)],
             preconditions: [
                 { fact: "Task is active", satisfied: task.status === "active", ref: ref("task", task.id) },
                 { fact: "Task main is clean, committed, and verified", satisfied: false }
             ],
-            recommendedCommand: `yui task complete ${task.id} --summary-file -`,
-            ...(reviewAlternative.length === 0 ? {} : { alternatives: reviewAlternative }),
-            judgmentRequired: task.type === "bugfix"
-                ? "Leader must judge whether the bugfix risk warrants one optional final Review."
-                : task.type === "feature"
-                    ? "Leader must judge whether this feature is small enough to own directly or needs independently owned WorkItems, and whether the final result warrants Review."
-                    : "Leader must choose the smallest useful topology from the Project-defined Task intent, then decide whether the frozen result warrants Review."
+            recommendedCommand: `yui task context ${task.id} --json`,
+            alternatives: [...reviewAlternative, {
+                    kind: "complete-task",
+                    reason: "Complete only after every requested outcome, delegation and Review requirement is satisfied and verified; record counts and a clean commit alone do not prove that.",
+                    recommendedCommand: `yui task complete ${task.id} --summary-file -`
+                }],
+            judgmentRequired: "Honor explicit user/Project requirements first. Otherwise choose direct work or independently owned WorkItems and proportionate Review. This projection does not authorize weakening the Task Contract."
         });
     }
     const unintegrated = governingWorkItemDeliveries(facts.workItems)
@@ -386,24 +396,24 @@ export function projectNextAction(facts) {
     const failedFinal = latestTaskFinalReview(facts.reviewRounds, finalReviewContract);
     if (finalReviewRequired
         && failedFinal?.status === "failed") {
-        const reviewerTurn = failedFinal.reviewerTurnId === undefined
+        const reviewerRun = failedFinal.reviewerRunId === undefined
             ? undefined
-            : facts.reviewOutcomeEvidence?.turns.find(({ id }) => id === failedFinal.reviewerTurnId);
-        const sameRoundCommand = failedFinal.reviewerTurnId === undefined
+            : facts.reviewOutcomeEvidence?.runs.find(({ id }) => id === failedFinal.reviewerRunId);
+        const sameRoundCommand = failedFinal.reviewerRunId === undefined
             ? `yui task review retry ${task.id}/${failedFinal.id}`
-            : reviewerTurn?.status === "failed"
-                ? `yui task turn retry ${task.id}/${reviewerTurn.id}`
+            : reviewerRun?.status === "failed"
+                ? `yui task run retry ${task.id}/${reviewerRun.id}`
                 : undefined;
         return buildAction(facts, {
             kind: "resume-review",
             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)] : [])
+                ...(reviewerRun?.status === "failed" ? [ref("run", reviewerRun.id)] : [])
             ],
             preconditions: [
                 {
-                    fact: "Task-final Review has one exact completed Reviewer Turn",
+                    fact: "Task-final Review has one exact completed Reviewer AgentRun",
                     satisfied: false,
                     ref: ref("review-round", failedFinal.id)
                 }
@@ -413,15 +423,15 @@ export function projectNextAction(facts) {
     }
     if (finalReviewRequired
         && failedFinal?.status === "completed"
-        && !isCompletedTaskReviewEvidenceFromTurns(failedFinal, facts.reviewOutcomeEvidence?.turns ?? [])) {
+        && !isCompletedTaskReviewEvidenceFromRuns(failedFinal, facts.reviewOutcomeEvidence?.runs ?? [])) {
         return buildAction(facts, {
             kind: "repair-protocol-inconsistency",
-            reason: `Task-final Review ${failedFinal.id} is completed without one exact completed main Reviewer Turn.`,
+            reason: `Task-final Review ${failedFinal.id} is completed without one exact completed main Reviewer AgentRun.`,
             refs: [ref("review-round", failedFinal.id)],
             conflicts: [ref("review-round", failedFinal.id)],
             preconditions: [
                 {
-                    fact: "ReviewRound and exact main Reviewer Turn agree",
+                    fact: "ReviewRound and exact main Reviewer AgentRun agree",
                     satisfied: false,
                     ref: ref("review-round", failedFinal.id)
                 }
@@ -433,21 +443,25 @@ export function projectNextAction(facts) {
         && (activeFinal.status === "pending" || activeFinal.status === "running")) {
         const reviewRef = ref("review-round", activeFinal.id);
         if (activeFinal.status === "running") {
-            if (activeFinal.reviewerTurnId === undefined
+            if (activeFinal.reviewerRunId === undefined
                 && activeFinal.executionGroup === undefined) {
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Turn.`,
+                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer AgentRun.`,
                     refs: [reviewRef],
                     conflicts: [reviewRef],
                     preconditions: [
-                        { fact: "Running Task-final ReviewRound has an exact Reviewer Turn", satisfied: false, ref: reviewRef }
+                        { fact: "Running Task-final ReviewRound has an exact Reviewer AgentRun", satisfied: false, ref: reviewRef }
                     ]
                 });
             }
-            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeTurns);
+            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeRuns);
             if (reviewRun === undefined) {
-                if (reviewGroupNeedsDispatch(activeFinal, facts.activeTurns)) {
+                if (activeFinal.executionGroup !== undefined && activeFinal.reviewerRunId === undefined
+                    && !reviewGroupNeedsDispatch(activeFinal, facts.activeRuns)) {
+                    return synthesisSelectionAction(facts, "review", activeFinal.id);
+                }
+                if (reviewGroupNeedsDispatch(activeFinal, facts.activeRuns)) {
                     return buildAction(facts, {
                         kind: "resume-review",
                         reason: `Task-final ReviewRound ${activeFinal.id} has Review Producer Lanes ready for dispatch or retry.`,
@@ -459,12 +473,12 @@ export function projectNextAction(facts) {
                             + reviewLaneRoleOptions(activeFinal)
                     });
                 }
-                const runRef = activeFinal.reviewerTurnId === undefined
+                const runRef = activeFinal.reviewerRunId === undefined
                     ? reviewRef
-                    : ref("turn", activeFinal.reviewerTurnId);
+                    : ref("run", activeFinal.reviewerRunId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Task-final ReviewRound ${activeFinal.id} has no active Producer or main Reviewer Turn.`,
+                    reason: `Task-final ReviewRound ${activeFinal.id} has no active Producer or main Reviewer AgentRun.`,
                     refs: [reviewRef, runRef],
                     conflicts: [reviewRef, runRef],
                     preconditions: [
@@ -474,11 +488,11 @@ export function projectNextAction(facts) {
             }
             return buildAction(facts, {
                 kind: "wait-for-owned-execution",
-                reason: `Reviewer Turn ${reviewRun.id} is executing frozen Task-final Review ${activeFinal.id}; this Review does not globally pause Leader decisions on newer facts.`,
-                refs: [reviewRef, ref("turn", reviewRun.id)],
+                reason: `Reviewer AgentRun ${reviewRun.id} is executing frozen Task-final Review ${activeFinal.id}; this Review does not globally pause Leader decisions on newer facts.`,
+                refs: [reviewRef, ref("run", reviewRun.id)],
                 preconditions: [
                     { fact: "Task-final ReviewRound is running", satisfied: true, ref: reviewRef },
-                    { fact: "Reviewer Turn is active", satisfied: true, ref: ref("turn", reviewRun.id) }
+                    { fact: "Reviewer AgentRun is active", satisfied: true, ref: ref("run", reviewRun.id) }
                 ],
                 alternatives: [
                     {
@@ -496,15 +510,15 @@ export function projectNextAction(facts) {
                 judgmentRequired: "Leader decides whether the current facts justify waiting, continuing development, direct review, or another Reviewer."
             });
         }
-        if (activeFinal.reviewerTurnId !== undefined) {
-            const runRef = ref("turn", activeFinal.reviewerTurnId);
+        if (activeFinal.reviewerRunId !== undefined) {
+            const runRef = ref("run", activeFinal.reviewerRunId);
             return buildAction(facts, {
                 kind: "repair-protocol-inconsistency",
-                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer Turn ${activeFinal.reviewerTurnId}.`,
+                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer AgentRun ${activeFinal.reviewerRunId}.`,
                 refs: [reviewRef, runRef],
                 conflicts: [reviewRef, runRef],
                 preconditions: [
-                    { fact: "Pending Task-final ReviewRound has no Reviewer Turn", satisfied: false, ref: runRef }
+                    { fact: "Pending Task-final ReviewRound has no Reviewer AgentRun", satisfied: false, ref: runRef }
                 ]
             });
         }
@@ -514,7 +528,7 @@ export function projectNextAction(facts) {
             refs: [reviewRef],
             preconditions: [
                 { fact: "Task-final ReviewRound is pending", satisfied: true, ref: reviewRef },
-                { fact: "Reviewer Turn exists", satisfied: false }
+                { fact: "Reviewer AgentRun exists", satisfied: false }
             ],
             recommendedCommand: `yui task review request ${task.id} --role ${activeFinal.reviewerRoleName}`
                 + reviewLaneRoleOptions(activeFinal)
@@ -585,24 +599,36 @@ export function projectNextAction(facts) {
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
 }
-function hasExactTurn(lane) {
-    return lane.turnId !== undefined;
+function synthesisSelectionAction(facts, subject, id) {
+    return buildAction(facts, {
+        kind: "resolve-execution-stage",
+        reason: `Replicated ${subject} ${id} needs Leader judgment over original results and synthesis.`,
+        refs: [ref(subject === "work" ? "work-item" : "review-round", id)],
+        preconditions: [],
+        recommendedCommand: subject === "work"
+            ? `yui task work show ${facts.task.id}/${id}`
+            : `yui task review synthesize ${facts.task.id}/${id} --source-run <task>/<run>`,
+        judgmentRequired: "Inspect original results and any existing main AgentRun. Retry a failed main AgentRun or explicitly select synthesis sources; Core does not enforce a success count or voting rule."
+    });
+}
+function hasExactRun(lane) {
+    return lane.runId !== undefined;
 }
 function buildExecutionLaneRecoveryAction(facts, lane) {
     const refs = [
         ref("execution-group", lane.groupId),
         ref("execution-lane", lane.laneId),
-        ref("turn", lane.turnId)
+        ref("run", lane.runId)
     ];
     return buildAction(facts, {
         kind: "retry-execution-lane",
-        reason: `Execution Lane ${lane.laneId} is durably failed; retry only exact Turn ${lane.turnId} and retain sibling results.`,
+        reason: `Execution Lane ${lane.laneId} is durably failed; retry only exact AgentRun ${lane.runId} and retain sibling results.`,
         refs,
         preconditions: [
             { fact: "Execution Lane is failed and unresolved", satisfied: true, ref: refs[1] },
-            { fact: "Exact failed Turn is retained", satisfied: true, ref: refs[2] }
+            { fact: "Exact failed AgentRun is retained", satisfied: true, ref: refs[2] }
         ],
-        recommendedCommand: `yui task turn retry ${facts.task.id}/${lane.turnId}`
+        recommendedCommand: `yui task run retry ${facts.task.id}/${lane.runId}`
     });
 }
 /**
@@ -654,16 +680,16 @@ function latestActiveWorkItemReview(rounds, item, candidate) {
         && round.candidateId === candidate.id
         && (round.status === "pending" || round.status === "running")));
 }
-function activeReviewRoundRun(round, activeTurns) {
-    if (round.reviewerTurnId !== undefined) {
-        const main = activeTurns.find((run) => (run.id === round.reviewerTurnId && run.roleName === round.reviewerRoleName));
+function activeReviewRoundRun(round, activeRuns) {
+    if (round.reviewerRunId !== undefined) {
+        const main = activeRuns.find((run) => (run.id === round.reviewerRunId && run.roleName === round.reviewerRoleName));
         if (main !== undefined)
             return main;
     }
     for (const lane of round.executionGroup?.lanes ?? []) {
-        if (lane.disposition !== "open" || lane.currentTurnId === undefined)
+        if (lane.disposition !== "open" || lane.currentRunId === undefined)
             continue;
-        const run = activeTurns.find((candidate) => (candidate.id === lane.currentTurnId && candidate.roleName === lane.roleName));
+        const run = activeRuns.find((candidate) => (candidate.id === lane.currentRunId && candidate.roleName === lane.roleName));
         if (run !== undefined)
             return run;
     }
@@ -674,37 +700,37 @@ function reviewLaneRoleOptions(round) {
         .map(({ roleName }) => ` --lane-role ${roleName}`)
         .join("") ?? "";
 }
-function reviewGroupNeedsDispatch(round, turns) {
+function reviewGroupNeedsDispatch(round, runs) {
     return round.executionGroup?.lanes.some((lane) => (lane.disposition === "open"
-        && (lane.currentTurnId === undefined
-            || turns.find(({ id }) => id === lane.currentTurnId)?.status === "failed"))) === true;
+        && (lane.currentRunId === undefined
+            || runs.find(({ id }) => id === lane.currentRunId)?.status === "failed"))) === true;
 }
-function reviewRoundConflict(round, activeTurns) {
+function reviewRoundConflict(round, activeRuns) {
     const reviewRef = ref("review-round", round.id);
     if (round.status === "running") {
-        if (round.reviewerTurnId === undefined && round.executionGroup === undefined) {
+        if (round.reviewerRunId === undefined && round.executionGroup === undefined) {
             return {
                 reason: `ReviewRound ${round.id} is running but has no execution unit.`,
                 conflicts: [reviewRef]
             };
         }
-        if (activeReviewRoundRun(round, activeTurns) === undefined) {
-            if (round.reviewerTurnId === undefined && round.executionGroup !== undefined)
+        if (activeReviewRoundRun(round, activeRuns) === undefined) {
+            if (round.reviewerRunId === undefined && round.executionGroup !== undefined)
                 return null;
-            const runRef = ref("turn", round.reviewerTurnId);
+            const runRef = ref("run", round.reviewerRunId);
             return {
-                reason: `ReviewRound ${round.id} references Reviewer Turn ${round.reviewerTurnId}, but that Turn is not active.`,
+                reason: `ReviewRound ${round.id} references Reviewer AgentRun ${round.reviewerRunId}, but that AgentRun is not active.`,
                 conflicts: [reviewRef, runRef]
             };
         }
     }
     if (round.status === "pending") {
-        const launchedTurnId = round.reviewerTurnId
-            ?? round.executionGroup?.lanes.find((lane) => lane.currentTurnId !== undefined)?.currentTurnId;
-        if (launchedTurnId !== undefined) {
-            const runRef = ref("turn", launchedTurnId);
+        const launchedRunId = round.reviewerRunId
+            ?? round.executionGroup?.lanes.find((lane) => lane.currentRunId !== undefined)?.currentRunId;
+        if (launchedRunId !== undefined) {
+            const runRef = ref("run", launchedRunId);
             return {
-                reason: `Pending ReviewRound ${round.id} already references Reviewer Turn ${launchedTurnId}.`,
+                reason: `Pending ReviewRound ${round.id} already references Reviewer AgentRun ${launchedRunId}.`,
                 conflicts: [reviewRef, runRef]
             };
         }
@@ -718,7 +744,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";
+        return status === "accepted";
     })));
     if (eligible !== undefined)
         return { kind: "ready", item: eligible };
@@ -731,7 +757,7 @@ function selectOpenWorkItem(workItems) {
         visited.add(current.id);
         const blockedBy = current.dependsOn.find((dependencyId) => {
             const status = byId.get(dependencyId)?.status;
-            return status !== "completed";
+            return status !== "accepted";
         });
         if (blockedBy === undefined)
             return { kind: "ready", item: current };
@@ -777,7 +803,7 @@ function hasValidFinalReview(facts) {
         .reverse()
         .find((round) => ((round.scope ?? "work-item") === "task"
         && (contract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, contract))));
-    if (final === undefined || !isCompletedTaskReviewEvidenceFromTurns(final, facts.reviewOutcomeEvidence?.turns ?? []))
+    if (final === undefined || !isCompletedTaskReviewEvidenceFromRuns(final, facts.reviewOutcomeEvidence?.runs ?? []))
         return false;
     return final.taskCandidate !== undefined;
 }
@@ -804,7 +830,7 @@ function detectProtocolInconsistency(facts) {
         };
     }
     for (const round of facts.reviewRounds) {
-        const reviewConflict = reviewRoundConflict(round, facts.activeTurns);
+        const reviewConflict = reviewRoundConflict(round, facts.activeRuns);
         if (reviewConflict !== null)
             return reviewConflict;
     }
@@ -835,15 +861,5 @@ function detectProtocolInconsistency(facts) {
             };
         }
     }
-    for (const item of facts.workItems) {
-        if (item.status !== "awaiting_acceptance")
-            continue;
-        if (item.candidates.length === 0) {
-            return {
-                reason: `Work Item ${item.id} is awaiting acceptance but has no Candidate record.`,
-                conflicts: [ref("work-item", item.id)]
-            };
-        }
-    }
     return null;
 }

package/dist/task/remoteDelivery.js

@@ -98,7 +98,7 @@ function expectedDelivery(facts) {
             ...(event === undefined ? {} : { event })
         };
     }
-    if (task.status === "active" || task.status === "retired") {
+    if (task.status === "active" || task.status === "cancelled") {
         return {
             source: "current-task-main",
             provisional: true,
@@ -135,13 +135,13 @@ function projectBaseCommits(facts, event) {
         if (!result.has(entry.projectId))
             result.set(entry.projectId, entry.baseCommit);
     }
-    const taskTurns = facts.turns
-        .filter((turn) => (turn.workspace?.owner.type === "task"
-        && turn.workspace.owner.taskId === facts.task.id))
+    const taskRuns = facts.runs
+        .filter((run) => (run.workspace?.owner.type === "task"
+        && run.workspace.owner.taskId === facts.task.id))
         .slice()
         .sort(compareCreated);
-    for (const turn of taskTurns) {
-        for (const entry of turn.workspace?.entries ?? []) {
+    for (const run of taskRuns) {
+        for (const entry of run.workspace?.entries ?? []) {
             if (!result.has(entry.projectId))
                 result.set(entry.projectId, entry.baseCommit);
         }