@zq-silk/yui 0.13.9 → 0.14.0

package/dist/task/completionReadiness.js

@@ -3,7 +3,7 @@ import { isReviewFindingBlocking } from "../review/reviewFinding.js";
 import { deltaRecheckBlocksAcceptance } from "../review/reviewRound.js";
 import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { reviewFindingLedgerWriteFailedFromEvents } from "../review/reviewFindingLedger.js";
-import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractRebind.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
 import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 const ACTIVE_JOB_STATUSES = new Set([
     "queued",
@@ -16,13 +16,13 @@ const UNRESOLVED_INTEGRATION_STATUSES = new Set([
     "validating"
 ]);
 const TERMINAL_REVIEW_STATUSES = new Set(["completed", "failed"]);
-const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "yielded", "skipped"]);
+const TERMINAL_LANE_STATUSES = new Set(["completed", "failed", "skipped"]);
 export function projectCompletionReadiness(facts, options = {}) {
     const blockers = [];
     const advisories = [];
     const { task } = facts;
     const findingsGate = options.findingsGate ?? true;
-    const taskFinalReviewContract = resolveRecordedTaskFinalReviewContract(task.id, facts.workItems, facts.reviewRounds, facts.taskFinalReviewContractEvents)?.effective;
+    const taskFinalReviewContract = resolveRecordedTaskFinalReviewContract(task.id, facts.workItems, facts.reviewRounds)?.effective;
     const taskFinalReviewRequired = taskFinalReviewContract !== undefined;
     // A pending/running Task-final Review must be resumed or blocked first.
     for (const round of facts.reviewRounds) {
@@ -36,7 +36,7 @@ export function projectCompletionReadiness(facts, options = {}) {
             reason: `Task-final ReviewRound ${round.id} is ${round.status}.`,
             fix: round.status === "pending"
                 ? `yui task review retry ${task.id}/${round.id}`
-                : `wait for Reviewer Run on ${round.id} to finish`
+                : `wait for Reviewer Turn on ${round.id} to finish`
         });
     }
     // Issue 07: only the latest completed Task-final Review can define whether
@@ -47,7 +47,7 @@ export function projectCompletionReadiness(facts, options = {}) {
         .filter((round) => ((round.scope ?? "work-item") === "task"
         && (taskFinalReviewContract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalReviewContract))
         && isSemanticReviewRound(round, {
-            listAgentRuns: () => facts.agentRuns,
+            listTurns: () => facts.turns,
             listReviewFindings: () => facts.reviewFindings,
             listEvents: () => facts.events
         })))

package/dist/task/deliveryGuard.js

@@ -173,32 +173,32 @@ function overlap(left, right) {
     return left.split("\n").some((line) => line.length > 0 && rightLines.has(line));
 }
 /**
- * Default number of consecutive yielded Leader turns that must produce no
+ * Default number of consecutive completed Leader turns that must produce no
  * durable delivery change before the budget is exhausted.
  */
 export const DEFAULT_SEMANTIC_BUDGET_TURNS = 3;
 /**
  * Evaluate the semantic-progress budget from existing records only. The
- * budget is exhausted when the last `turns` Leader Runs all yielded and no
+ * budget is exhausted when the last `turns` Leader Turns all completed and no
  * WorkItem/ChangeSet/Integration/Review record changed at or after the first
- * of those Runs. Active execution (any Run) never exhausts the budget: a
+ * of those Turns. Active execution (any Turn) never exhausts the budget: a
  * slow but progressing Worker or Leader is never interrupted.
  */
 export function evaluateSemanticBudget(facts, turns = DEFAULT_SEMANTIC_BUDGET_TURNS) {
-    if (facts.activeRuns.length > 0) {
+    if (facts.activeTurns.length > 0) {
         return {
             exhausted: false,
-            reason: "Active execution is in flight; the budget never interrupts a progressing Run.",
-            evidence: facts.activeRuns.map((run) => run.id)
+            reason: "Active execution is in flight; the budget never interrupts a progressing Turn.",
+            evidence: facts.activeTurns.map((run) => run.id)
         };
     }
-    const recentLeaderRuns = facts.leaderRuns
-        .filter((run) => run.status === "yielded")
+    const recentLeaderRuns = facts.leaderTurns
+        .filter((run) => run.status === "completed")
         .slice(-turns);
     if (recentLeaderRuns.length < turns) {
         return {
             exhausted: false,
-            reason: `Fewer than ${turns} consecutive yielded Leader turns.`,
+            reason: `Fewer than ${turns} consecutive completed Leader turns.`,
             evidence: recentLeaderRuns.map((run) => run.id)
         };
     }
@@ -213,7 +213,7 @@ export function evaluateSemanticBudget(facts, turns = DEFAULT_SEMANTIC_BUDGET_TU
     }
     return {
         exhausted: true,
-        reason: `${turns} consecutive Leader turns produced no durable delivery change; record a diagnosis/yield and wait for new facts instead of creating more records.`,
+        reason: `${turns} consecutive Leader turns produced no durable delivery change; record a diagnosis and wait for new facts instead of creating more records.`,
         evidence: recentLeaderRuns.map((run) => run.id)
     };
 }

package/dist/task/nextAction.js

@@ -7,7 +7,7 @@ import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.
 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/taskFinalReviewContractRebind.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
 import { currentWorkItemCandidate, currentWorkItemExecutionGroup, governingWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
@@ -57,18 +57,18 @@ export function projectNextAction(facts) {
         });
     }
     const laneRecovery = actionableExecutionLaneRecoveries(facts.executionGroups ?? [])
-        .find(hasExactRun);
+        .find(hasExactTurn);
     if (laneRecovery !== undefined) {
         return buildExecutionLaneRecoveryAction(facts, laneRecovery);
     }
-    const activeLeader = facts.activeRuns.find((run) => run.roleName === "leader");
+    const activeLeader = facts.activeTurns.find((run) => run.roleName === "leader");
     if (activeLeader !== undefined) {
         return buildAction(facts, {
             kind: "wait-for-owned-execution",
-            reason: `Leader Run ${activeLeader.id} is active; the protocol position is being executed.`,
-            refs: [ref("agent-run", activeLeader.id)],
+            reason: `Leader Turn ${activeLeader.id} is active; the protocol position is being executed.`,
+            refs: [ref("turn", activeLeader.id)],
             preconditions: [
-                { fact: "Leader Run is active", satisfied: true, ref: ref("agent-run", activeLeader.id) }
+                { fact: "Leader Turn is active", satisfied: true, ref: ref("turn", activeLeader.id) }
             ]
         });
     }
@@ -107,18 +107,18 @@ export function projectNextAction(facts) {
                 if (reviewGroupAwaitingResolution(activeReview)) {
                     return buildResolveReviewGroupAction(facts, activeReview);
                 }
-                if (activeReview.reviewerRunId === undefined) {
+                if (activeReview.reviewerTurnId === undefined) {
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
-                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Run.`,
+                        reason: `ReviewRound ${activeReview.id} is running but has no Reviewer Turn.`,
                         refs: [reviewRef],
                         conflicts: [reviewRef],
                         preconditions: [
-                            { fact: "Running ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                            { fact: "Running ReviewRound has an exact Reviewer Turn", satisfied: false, ref: reviewRef }
                         ]
                     });
                 }
-                const reviewRun = activeReviewRoundRun(activeReview, facts.activeRuns);
+                const reviewRun = activeReviewRoundRun(activeReview, facts.activeTurns);
                 if (reviewRun === undefined) {
                     if (reviewGroupHasResourceQueue(activeReview)) {
                         return buildAction(facts, {
@@ -132,36 +132,36 @@ export function projectNextAction(facts) {
                             recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
                         });
                     }
-                    const runRef = ref("agent-run", activeReview.reviewerRunId);
+                    const runRef = ref("turn", activeReview.reviewerTurnId);
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
-                        reason: `ReviewRound ${activeReview.id} references Reviewer Run ${activeReview.reviewerRunId}, but that Run is not active.`,
+                        reason: `ReviewRound ${activeReview.id} references Reviewer Turn ${activeReview.reviewerTurnId}, but that Turn is not active.`,
                         refs: [reviewRef, runRef],
                         conflicts: [reviewRef, runRef],
                         preconditions: [
-                            { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                            { fact: "Reviewer Turn 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)],
+                    reason: `Reviewer Turn ${reviewRun.id} is evaluating Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"}.`,
+                    refs: [reviewRef, ref("turn", reviewRun.id)],
                     preconditions: [
                         { fact: "ReviewRound is running", satisfied: true, ref: reviewRef },
-                        { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                        { fact: "Reviewer Turn is active", satisfied: true, ref: ref("turn", reviewRun.id) }
                     ]
                 });
             }
-            if (activeReview.reviewerRunId !== undefined) {
-                const runRef = ref("agent-run", activeReview.reviewerRunId);
+            if (activeReview.reviewerTurnId !== undefined) {
+                const runRef = ref("turn", activeReview.reviewerTurnId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer Run ${activeReview.reviewerRunId}.`,
+                    reason: `Pending ReviewRound ${activeReview.id} already references Reviewer Turn ${activeReview.reviewerTurnId}.`,
                     refs: [reviewRef, runRef],
                     conflicts: [reviewRef, runRef],
                     preconditions: [
-                        { fact: "Pending ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                        { fact: "Pending ReviewRound has no Reviewer Turn", satisfied: false, ref: runRef }
                     ]
                 });
             }
@@ -171,7 +171,7 @@ export function projectNextAction(facts) {
                 refs: [reviewRef],
                 preconditions: [
                     { fact: "ReviewRound is pending", satisfied: true, ref: reviewRef },
-                    { fact: "Reviewer Run exists", satisfied: false }
+                    { fact: "Reviewer Turn exists", satisfied: false }
                 ],
                 recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
             });
@@ -211,15 +211,15 @@ export function projectNextAction(facts) {
             judgmentRequired: `Leader must judge Candidate ${candidateReady.id}/${candidate?.id ?? "unknown"} against the Task objective, acceptance criteria, and delivery risk.`
         });
     }
-    // AgentRun purpose owns routing. Review Runs remain attached to their exact
+    // Turn purpose owns routing. Review Turns remain attached to their exact
     // ReviewRound branches below instead of being mistaken for Worker delivery.
-    const activeDelegatedExecutions = facts.activeRuns.filter((run) => (run.purpose === "execution" && run.roleName !== "leader"));
+    const activeDelegatedExecutions = facts.activeTurns.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 Run(s) are active; wait for their delivery.`,
-            refs: activeDelegatedExecutions.map((run) => ref("agent-run", run.id)),
-            preconditions: activeDelegatedExecutions.map((run) => ({ fact: `Execution Run ${run.id} is active`, satisfied: true, ref: ref("agent-run", run.id) }))
+            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");
@@ -446,18 +446,18 @@ export function projectNextAction(facts) {
             if (reviewGroupAwaitingResolution(activeFinal)) {
                 return buildResolveReviewGroupAction(facts, activeFinal);
             }
-            if (activeFinal.reviewerRunId === undefined) {
+            if (activeFinal.reviewerTurnId === undefined) {
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Run.`,
+                    reason: `Task-final ReviewRound ${activeFinal.id} is running but has no Reviewer Turn.`,
                     refs: [reviewRef],
                     conflicts: [reviewRef],
                     preconditions: [
-                        { fact: "Running Task-final ReviewRound has an exact Reviewer Run", satisfied: false, ref: reviewRef }
+                        { fact: "Running Task-final ReviewRound has an exact Reviewer Turn", satisfied: false, ref: reviewRef }
                     ]
                 });
             }
-            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeRuns);
+            const reviewRun = activeReviewRoundRun(activeFinal, facts.activeTurns);
             if (reviewRun === undefined) {
                 if (reviewGroupHasResourceQueue(activeFinal)) {
                     return buildAction(facts, {
@@ -471,24 +471,24 @@ export function projectNextAction(facts) {
                         recommendedCommand: `yui task review request ${task.id} --role ${activeFinal.reviewerRoleName}`
                     });
                 }
-                const runRef = ref("agent-run", activeFinal.reviewerRunId);
+                const runRef = ref("turn", activeFinal.reviewerTurnId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
-                    reason: `Task-final ReviewRound ${activeFinal.id} references Reviewer Run ${activeFinal.reviewerRunId}, but that Run is not active.`,
+                    reason: `Task-final ReviewRound ${activeFinal.id} references Reviewer Turn ${activeFinal.reviewerTurnId}, but that Turn is not active.`,
                     refs: [reviewRef, runRef],
                     conflicts: [reviewRef, runRef],
                     preconditions: [
-                        { fact: "Reviewer Run is active", satisfied: false, ref: runRef }
+                        { fact: "Reviewer Turn is active", satisfied: false, ref: runRef }
                     ]
                 });
             }
             return buildAction(facts, {
                 kind: "wait-for-owned-execution",
-                reason: `Reviewer Run ${reviewRun.id} is executing frozen Task-final Review ${activeFinal.id}; this Review does not globally pause Leader decisions on newer facts.`,
-                refs: [reviewRef, ref("agent-run", reviewRun.id)],
+                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)],
                 preconditions: [
                     { fact: "Task-final ReviewRound is running", satisfied: true, ref: reviewRef },
-                    { fact: "Reviewer Run is active", satisfied: true, ref: ref("agent-run", reviewRun.id) }
+                    { fact: "Reviewer Turn is active", satisfied: true, ref: ref("turn", reviewRun.id) }
                 ],
                 alternatives: [
                     {
@@ -506,15 +506,15 @@ export function projectNextAction(facts) {
                 judgmentRequired: "Leader decides whether the current facts justify waiting, continuing development, direct review, or another Reviewer."
             });
         }
-        if (activeFinal.reviewerRunId !== undefined) {
-            const runRef = ref("agent-run", activeFinal.reviewerRunId);
+        if (activeFinal.reviewerTurnId !== undefined) {
+            const runRef = ref("turn", activeFinal.reviewerTurnId);
             return buildAction(facts, {
                 kind: "repair-protocol-inconsistency",
-                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer Run ${activeFinal.reviewerRunId}.`,
+                reason: `Pending Task-final ReviewRound ${activeFinal.id} already references Reviewer Turn ${activeFinal.reviewerTurnId}.`,
                 refs: [reviewRef, runRef],
                 conflicts: [reviewRef, runRef],
                 preconditions: [
-                    { fact: "Pending Task-final ReviewRound has no Reviewer Run", satisfied: false, ref: runRef }
+                    { fact: "Pending Task-final ReviewRound has no Reviewer Turn", satisfied: false, ref: runRef }
                 ]
             });
         }
@@ -524,7 +524,7 @@ export function projectNextAction(facts) {
             refs: [reviewRef],
             preconditions: [
                 { fact: "Task-final ReviewRound is pending", satisfied: true, ref: reviewRef },
-                { fact: "Reviewer Run exists", satisfied: false }
+                { fact: "Reviewer Turn exists", satisfied: false }
             ],
             recommendedCommand: `yui task review retry ${task.id}/${activeFinal.id}`
         });
@@ -599,24 +599,24 @@ export function projectNextAction(facts) {
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
 }
-function hasExactRun(lane) {
-    return lane.runId !== undefined;
+function hasExactTurn(lane) {
+    return lane.turnId !== undefined;
 }
 function buildExecutionLaneRecoveryAction(facts, lane) {
     const refs = [
         ref("execution-group", lane.groupId),
         ref("execution-lane", lane.laneId),
-        ref("agent-run", lane.runId)
+        ref("turn", lane.turnId)
     ];
     return buildAction(facts, {
         kind: "retry-execution-lane",
-        reason: `Execution Lane ${lane.laneId} is durably failed; retry only exact Run ${lane.runId} and retain sibling results.`,
+        reason: `Execution Lane ${lane.laneId} is durably failed; retry only exact Turn ${lane.turnId} and retain sibling results.`,
         refs,
         preconditions: [
             { fact: "Execution Lane is failed and unresolved", satisfied: true, ref: refs[1] },
-            { fact: "Exact failed AgentRun is retained", satisfied: true, ref: refs[2] }
+            { fact: "Exact failed Turn is retained", satisfied: true, ref: refs[2] }
         ],
-        recommendedCommand: `yui task run retry ${facts.task.id}/${lane.runId}`
+        recommendedCommand: `yui task turn retry ${facts.task.id}/${lane.turnId}`
     });
 }
 function exhaustedExplorationReason(item, executionGroups) {
@@ -655,8 +655,7 @@ export function durableStateFingerprint(facts) {
         ...facts.changeSets.map((changeSet) => `change-set:${changeSet.id}:${changeSet.headCommit}`),
         ...facts.integrations.map((attempt) => `integration:${attempt.id}:${attempt.status}:${attempt.updatedAt}`),
         ...facts.integrationQueueEntries.map((entry) => `integration-queue:${entry.id}:${entry.status}:${entry.updatedAt}`),
-        ...facts.reviewRounds.map((round) => `review:${round.id}:${round.status}:${round.endedAt ?? ""}`),
-        ...facts.taskFinalReviewContractEvents.map((event) => `task-final-review-event:${event.id}:${event.createdAt}`)
+        ...facts.reviewRounds.map((round) => `review:${round.id}:${round.status}:${round.endedAt ?? ""}`)
     ];
     return createHash("sha256").update(parts.join("\n")).digest("hex");
 }
@@ -692,7 +691,7 @@ function buildExecutionStageAction(facts, item) {
     const resources = projected?.resources;
     if (resources === undefined)
         return null;
-    const usableLaneIds = group.lanes.filter(({ status }) => (status === "yielded" || status === "completed")).map(({ id }) => id);
+    const usableLaneIds = group.lanes.filter(({ status }) => status === "completed").map(({ id }) => id);
     const stageResultsValid = candidateConvergenceStageResultsValid(group);
     const disagreement = candidateConvergenceDisagreement(group);
     const routing = routeExecutionStage({
@@ -824,11 +823,11 @@ function buildExecutionStageAction(facts, item) {
     if (resources.activeLaneIds.length > 0) {
         return buildAction(facts, {
             kind: "repair-protocol-inconsistency",
-            reason: `ExecutionGroup ${group.id} retains active Lanes but no delegated AgentRun is active.`,
+            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 AgentRun", satisfied: false, ref: refs[1] }
+                { fact: "Every active Lane has an active exact Turn", satisfied: false, ref: refs[1] }
             ]
         });
     }
@@ -843,25 +842,25 @@ function latestActiveWorkItemReview(rounds, item, candidate) {
         && round.candidateId === candidate.id
         && (round.status === "pending" || round.status === "running")));
 }
-function activeReviewRoundRun(round, activeRuns) {
+function activeReviewRoundRun(round, activeTurns) {
     if (round.executionGroup !== undefined) {
         for (const lane of round.executionGroup.lanes) {
             if (lane.status !== "running"
                 || lane.reviewRoundId !== round.id
-                || lane.runId === undefined) {
+                || lane.turnId === undefined) {
                 continue;
             }
-            const run = activeRuns.find((candidate) => (candidate.id === lane.runId && candidate.roleName === lane.roleName));
+            const run = activeTurns.find((candidate) => (candidate.id === lane.turnId && candidate.roleName === lane.roleName));
             if (run !== undefined)
                 return run;
         }
         return undefined;
     }
-    if (round.reviewerRunId === undefined)
+    if (round.reviewerTurnId === undefined)
         return undefined;
-    return activeRuns.find((run) => (run.id === round.reviewerRunId && run.roleName === round.reviewerRoleName));
+    return activeTurns.find((run) => (run.id === round.reviewerTurnId && run.roleName === round.reviewerRoleName));
 }
-const TERMINAL_REVIEW_LANE_STATUSES = new Set(["yielded", "completed", "failed"]);
+const TERMINAL_REVIEW_LANE_STATUSES = new Set(["completed", "failed"]);
 function isPanelReviewRound(round) {
     return round.executionGroup !== undefined
         && (round.executionGroup.lanes.length > 1
@@ -878,7 +877,7 @@ function reviewGroupHasResourceQueue(round) {
     return round.executionGroup !== undefined
         && round.executionGroup.resolution === undefined
         && round.executionGroup.lanes.some((lane) => (lane.status === "pending"
-            && lane.runId === undefined));
+            && lane.turnId === undefined));
 }
 function buildResolveReviewGroupAction(facts, round) {
     const group = round.executionGroup;
@@ -921,35 +920,35 @@ function buildResolveReviewGroupAction(facts, round) {
         judgmentRequired: `Leader must judge Review panel ${group.id} against the Task objective, acceptance criteria, and delivery risk.`
     });
 }
-function reviewRoundConflict(round, activeRuns) {
+function reviewRoundConflict(round, activeTurns) {
     const reviewRef = ref("review-round", round.id);
     if (round.status === "running") {
         if (reviewGroupAwaitingResolution(round)) {
             return null;
         }
-        if (round.reviewerRunId === undefined) {
+        if (round.reviewerTurnId === undefined) {
             return {
-                reason: `ReviewRound ${round.id} is running but has no Reviewer Run.`,
+                reason: `ReviewRound ${round.id} is running but has no Reviewer Turn.`,
                 conflicts: [reviewRef]
             };
         }
-        if (activeReviewRoundRun(round, activeRuns) === undefined) {
+        if (activeReviewRoundRun(round, activeTurns) === undefined) {
             if (reviewGroupHasResourceQueue(round))
                 return null;
-            const runRef = ref("agent-run", round.reviewerRunId);
+            const runRef = ref("turn", round.reviewerTurnId);
             return {
-                reason: `ReviewRound ${round.id} references Reviewer Run ${round.reviewerRunId}, but that Run is not active.`,
+                reason: `ReviewRound ${round.id} references Reviewer Turn ${round.reviewerTurnId}, but that Turn 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);
+        const launchedTurnId = round.reviewerTurnId
+            ?? round.executionGroup?.lanes.find((lane) => lane.turnId !== undefined)?.turnId;
+        if (launchedTurnId !== undefined) {
+            const runRef = ref("turn", launchedTurnId);
             return {
-                reason: `Pending ReviewRound ${round.id} already references Reviewer Run ${launchedRunId}.`,
+                reason: `Pending ReviewRound ${round.id} already references Reviewer Turn ${launchedTurnId}.`,
                 conflicts: [reviewRef, runRef]
             };
         }
@@ -992,7 +991,7 @@ function taskFinalReviewContract(facts) {
     return taskFinalReviewContractResolution(facts)?.effective;
 }
 function taskFinalReviewContractResolution(facts) {
-    return resolveRecordedTaskFinalReviewContract(facts.task.id, facts.workItems, facts.reviewRounds, facts.taskFinalReviewContractEvents);
+    return resolveRecordedTaskFinalReviewContract(facts.task.id, facts.workItems, facts.reviewRounds);
 }
 function taskFinalReviewRequired(facts) {
     return taskFinalReviewContract(facts) !== undefined;
@@ -1073,7 +1072,7 @@ export function nextActionReviewOutcomeEvidence(facts) {
     if (evidence === undefined)
         return undefined;
     return {
-        listAgentRuns: () => evidence.agentRuns,
+        listTurns: () => evidence.turns,
         listReviewFindings: () => evidence.reviewFindings,
         listEvents: () => evidence.events
     };
@@ -1095,16 +1094,14 @@ function detectProtocolInconsistency(facts) {
             .filter((round) => ((round.scope ?? "work-item") === "task"
             && round.taskFinalReviewContract !== undefined))
             .map((round) => ref("review-round", round.id));
-        const eventRefs = facts.taskFinalReviewContractEvents
-            .map((event) => ref("task-event", event.id));
         return {
-            reason: "Task-final Review contract history is inconsistent: "
+            reason: "Task-final Review contract is inconsistent: "
                 + (error instanceof Error ? error.message : String(error)),
-            conflicts: [...candidateRefs, ...reviewRefs, ...eventRefs]
+            conflicts: [...candidateRefs, ...reviewRefs]
         };
     }
     for (const round of facts.reviewRounds) {
-        const reviewConflict = reviewRoundConflict(round, facts.activeRuns);
+        const reviewConflict = reviewRoundConflict(round, facts.activeTurns);
         if (reviewConflict !== null)
             return reviewConflict;
     }

package/dist/task/task.js

@@ -242,10 +242,8 @@ export function validateTask(task) {
     normalizeProjectBindings(task.projectBindings);
     if (task.cwd !== undefined)
         requireText(task.cwd, "Task workspace");
-    if (task.legacyDeliveryPath !== undefined
-        && task.legacyDeliveryPath !== "direct"
-        && task.legacyDeliveryPath !== "integrated") {
-        throw new Error("Task legacy delivery path is invalid.");
+    if (Object.hasOwn(task, "legacyDeliveryPath")) {
+        throw new Error("Task contains the removed delivery-path field.");
     }
     const completionFields = [task.completedAt, task.completedBy, task.completionSummary];
     const hasAnyCompletion = completionFields.some((value) => value !== undefined);

package/dist/task/taskRecordReference.js

@@ -2,7 +2,7 @@ import { requireIdentity } from "../domain/validation.js";
 export const TASK_RECORD_ID_PREFIXES = {
     workItem: "work-item",
     contextSnapshot: "context-snapshot",
-    agentRun: "agent-run",
+    turn: "turn",
     reviewRound: "review-round",
     reviewFinding: "review-finding",
     changeSet: "change-set",
@@ -23,8 +23,8 @@ export function formatTaskRecordReference(taskId, localId, kind) {
     const reference = validateTaskRecordReference({ taskId, localId }, kind);
     return `${reference.taskId}/${reference.localId}`;
 }
-export function formatAgentRunReceiptId(taskId, runId) {
-    return `agent-run:${formatTaskRecordReference(taskId, runId, "agentRun")}`;
+export function formatTurnReceiptId(taskId, turnId) {
+    return `turn:${formatTaskRecordReference(taskId, turnId, "turn")}`;
 }
 export function formatInputRequestReceiptId(taskId, requestId) {
     return `input-request:${formatTaskRecordReference(taskId, requestId, "inputRequest")}`;

package/dist/task/taskRecordRetirement.js

@@ -3,7 +3,7 @@ export const TASK_RECORD_RETIRED_EVENT = "task.record-retired";
 export const RETIRABLE_TASK_RECORD_KINDS = [
     "work-item",
     "message",
-    "agent-run"
+    "turn"
 ];
 /**
  * Appends a tombstone fact without rewriting the original record. Operational