@zq-silk/yui 0.13.9 → 0.14.0

package/dist/resources/autoResourceGc.js

@@ -98,14 +98,14 @@ function collectTaskStatuses(store) {
     return statuses;
 }
 /**
- * Workspace paths claimed by active durable Jobs. An active AgentRun still
+ * Workspace paths claimed by active durable Jobs. An active Turn still
  * holds its workspace even after the managed workspace record is gone, so
- * those paths stay protected until the Run finishes.
+ * those paths stay protected until the Turn finishes.
  */
 function collectActiveWorkspaceOwnerPaths(store) {
     const paths = [];
     for (const task of store.listTasks()) {
-        for (const run of store.listAgentRuns(task.id)) {
+        for (const run of store.listTurns(task.id)) {
             if (run.status !== "active")
                 continue;
             const workspace = run.workspace;

package/dist/resources/liveReferences.js

@@ -145,7 +145,7 @@ export async function scanLiveReferences(input) {
             }
         }
     }
-    // 6. Active durable workspace owners (e.g. an active AgentRun launch).
+    // 6. Active durable workspace owners (e.g. an active Turn launch).
     const activeOwners = input.ports?.activeWorkspaceOwners !== undefined
         ? input.ports.activeWorkspaceOwners()
         : [];

package/dist/resources/resourceGc.js

@@ -125,7 +125,7 @@ function classifyDiscoveredResources(discovered, registry, scan, input, home) {
 }
 /**
  * Collect active workspace owner path fragments from durable state.
- * These protect resources that an active Session, Job, or AgentRun still
+ * These protect resources that an active Session, Job, or Turn still
  * references even when the Task itself is terminal.
  */
 function collectActiveWorkspaceOwners(input) {

package/dist/resources/sqliteResourceRegistry.js

@@ -8,7 +8,7 @@
  *
  * The registry is GC's own state: it is not part of the aggregate and never
  * participates in aggregate versioning.  The `resource_registry` table is
- * created by schema migration 8.
+ * created by the current SQLite baseline.
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";

package/dist/review/reviewDecision.js

@@ -3,7 +3,7 @@ import { isAcceptedTaskReviewBaseline } from "./reviewAcceptance.js";
 import { projectReviewerAvailability } from "./reviewerAvailability.js";
 /** Read-only facts for Leader judgment; this projection never blocks an action. */
 export function projectReviewDecision(input) {
-    const { store, task, roles, runs, rounds, reviewConfig, currentCandidate } = input;
+    const { store, task, roles, turns, rounds, reviewConfig, currentCandidate } = input;
     const taskRounds = rounds.filter((round) => (round.scope ?? "work-item") === "task");
     const accepted = [...taskRounds]
         .filter((round) => isAcceptedTaskReviewBaseline(store, round))
@@ -20,15 +20,15 @@ export function projectReviewDecision(input) {
     const activeReviews = taskRounds
         .filter((round) => (round.status === "pending" || round.status === "running"))
         .map((round) => {
-        const activeRun = runs.find((run) => (run.status === "active" && run.reviewRoundId === round.id));
-        const workspaceRoot = round.workspace?.root ?? activeRun?.workspace?.root;
+        const activeTurn = turns.find((turn) => (turn.status === "active" && turn.reviewRoundId === round.id));
+        const workspaceRoot = round.workspace?.root ?? activeTurn?.workspace?.root;
         return {
             reviewRoundId: round.id,
             reviewerRoleName: round.reviewerRoleName,
             mode: round.deltaRecheck === undefined ? "full" : "delta-recheck",
             status: round.status,
-            ...(activeRun === undefined ? {} : { activeRunId: activeRun.id }),
-            startedAt: activeRun?.createdAt ?? round.createdAt,
+            ...(activeTurn === undefined ? {} : { activeTurnId: activeTurn.id }),
+            startedAt: activeTurn?.createdAt ?? round.createdAt,
             frozenCandidate: round.taskCandidate ?? null,
             candidateRelation: candidateRelation(round.taskCandidate ?? null, currentCandidate),
             ...(workspaceRoot === undefined ? {} : { workspaceRoot })
@@ -62,9 +62,9 @@ export function projectReviewDecision(input) {
             reviewerRoleName,
             status: "busy",
             phase: availability.phase,
-            ...(availability.activeRunId === undefined
+            ...(availability.activeTurnId === undefined
                 ? {}
-                : { activeRunId: availability.activeRunId }),
+                : { activeTurnId: availability.activeTurnId }),
             ...(availability.activeReviewRoundId === undefined
                 ? {}
                 : { activeReviewRoundId: availability.activeReviewRoundId }),

package/dist/review/reviewFindingLedger.js

@@ -505,7 +505,7 @@ export function buildTaskFinalReviewFindingContext(store, taskId, candidate) {
         ledgerContext = renderFindingLedgerContext(summarizeFindingLedger(store, taskId));
     }
     catch {
-        ledgerContext = "Finding ledger: unavailable (SQLite backend required; run `yui update` to migrate this Home).";
+        ledgerContext = "Finding ledger: unavailable (a current SQLite Home is required).";
     }
     const lines = [
         "Review convergence context:",

package/dist/review/reviewOutcomeClassifier.js

@@ -1,27 +1,25 @@
-import { matchYieldReceipt } from "../run/yieldReceipt.js";
 import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 const INFRA_SIGNATURES = [
     { kind: "session-not-stopped", pattern: /session must be stopped before workspace migration/iu },
-    { kind: "run-start", pattern: /role run could not start|could not start (?:the )?(?:reviewer|role) run/iu },
+    { kind: "turn-start", pattern: /role turn could not start|could not start (?:the )?(?:reviewer|role) turn/iu },
     { kind: "storage-lock", pattern: /\.state\.lock|state lock|lock timeout|storage lock/iu },
     { kind: "tmux-exit", pattern: /tmux[^\n]{0,80}(?:exited|exit|died|vanished)|pane (?:exited|died)/iu },
-    { kind: "yield-timeout", pattern: /yield timeout|controller yield timeout|yield timed out/iu },
-    { kind: "run-identity", pattern: /wrong run id|unknown run id|run id (?:is )?(?:invalid|unknown|mismatch)/iu },
+    { kind: "turn-identity", pattern: /wrong turn id|unknown turn id|turn id (?:is )?(?:invalid|unknown|mismatch)/iu },
     { kind: "policy", pattern: /cyber_?policy|policy denial|permission denied by policy/iu },
     { kind: "baseline-contamination", pattern: /cross[-\s]?baseline|baseline pollution|contaminated baseline|wrong base sha/iu },
-    { kind: "context-load", pattern: /(?:run )?(?:context|context pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)/iu },
+    { kind: "context-load", pattern: /(?:turn )?(?:context|context pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)/iu },
     { kind: "workspace-binding", pattern: /workspace is not the durable owner|workspace-binding failure/iu }
 ];
 /** Classify one terminal Round without rewriting it. */
 export function classifyReviewRoundOutcome(round, evidence) {
     if (round.status !== "completed" && round.status !== "failed")
         return null;
-    if (evidence !== undefined && round.reviewerRunId !== undefined
-        && isTaskRecordRetired(evidence.listEvents(round.taskId), "agent-run", round.reviewerRunId)) {
+    if (evidence !== undefined && round.reviewerTurnId !== undefined
+        && isTaskRecordRetired(evidence.listEvents(round.taskId), "turn", round.reviewerTurnId)) {
         return {
             kind: "non-semantic",
-            infraKind: "run-identity",
-            reason: `Reviewer Run ${round.reviewerRunId} was retired from operational evidence.`
+            infraKind: "turn-identity",
+            reason: `Reviewer Turn ${round.reviewerTurnId} was retired from operational evidence.`
         };
     }
     const infraKind = classifyInfraKind(`${round.summary ?? ""}\n${round.report ?? ""}`);
@@ -46,7 +44,7 @@ export function classifyReviewRoundOutcome(round, evidence) {
         return {
             kind: "ambiguous",
             infraKind,
-            reason: "Completed Round claims an infrastructure failure but corroborating Run/Event evidence was not supplied."
+            reason: "Completed Round claims an infrastructure failure but corroborating Turn/Event evidence was not supplied."
         };
     }
     const corroborationFailure = completedInfrastructureCorroborationFailure(round, evidence);
@@ -54,7 +52,7 @@ export function classifyReviewRoundOutcome(round, evidence) {
         ? {
             kind: "non-semantic",
             infraKind,
-            reason: "Completed Round and yielded Run agree on an explicit pre-review infrastructure failure."
+            reason: "Completed Round and Turn agree on an explicit pre-review infrastructure failure."
         }
         : {
             kind: "ambiguous",
@@ -90,17 +88,17 @@ function failedRoundSemanticEvidence(round, evidence) {
         || (lane.result?.evidence ?? []).length > 0
         || lane.result?.evidenceCommit !== undefined
         || lane.result?.gitSnapshot !== undefined
-        || lane.status === "yielded"
         || lane.status === "completed"));
     if (semanticLane !== undefined)
         return `Reviewer Lane ${semanticLane.id} delivered semantic evidence.`;
     if (evidence !== undefined) {
         const events = evidence.listEvents(round.taskId);
-        const reviewRun = operationalTaskRecords(evidence.listAgentRuns(round.taskId), events, "agent-run").find((run) => (run.purpose === "review"
+        const reviewRun = operationalTaskRecords(evidence.listTurns(round.taskId), events, "turn").find((run) => (run.purpose === "review"
             && run.reviewRoundId === round.id
-            && (run.status === "yielded" || runtimeFailureSummaryHasReviewerOutput(run.summary ?? ""))));
+            && (run.status === "completed"
+                || runtimeFailureSummaryHasReviewerOutput(run.result?.output ?? ""))));
         if (reviewRun !== undefined)
-            return `Reviewer Run ${reviewRun.id} records Reviewer output.`;
+            return `Reviewer Turn ${reviewRun.id} records Reviewer output.`;
         const finding = evidence.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
         if (finding !== undefined)
             return `Review finding ${finding.id} references the Round.`;
@@ -140,7 +138,7 @@ function completedInfrastructureCorroborationFailure(round, store) {
             || lane.result?.gitSnapshot !== undefined) {
             return `Reviewer Lane ${lane.id} delivered semantic evidence.`;
         }
-        if (lane.status === "yielded" || lane.status === "completed") {
+        if (lane.status === "completed") {
             if (lane.result === undefined
                 || lane.result.summary !== round.summary
                 || lane.result.report !== round.report
@@ -153,36 +151,23 @@ function completedInfrastructureCorroborationFailure(round, store) {
         }
     }
     const allEvents = store.listEvents(round.taskId);
-    const runs = operationalTaskRecords(store.listAgentRuns(round.taskId), allEvents, "agent-run").filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
+    const runs = operationalTaskRecords(store.listTurns(round.taskId), allEvents, "turn").filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
     const active = runs.find(({ status }) => status === "active");
     if (active !== undefined)
-        return `Reviewer Run ${active.id} is still active.`;
-    const output = runs.find((run) => (run.status === "failed" && runtimeFailureSummaryHasReviewerOutput(run.summary ?? "")));
+        return `Reviewer Turn ${active.id} is still active.`;
+    const output = runs.find((run) => (run.status === "failed" && runtimeFailureSummaryHasReviewerOutput(run.result?.output ?? "")));
     if (output !== undefined)
-        return `Reviewer Run ${output.id} records Reviewer output.`;
-    const yielded = runs.filter(({ status }) => status === "yielded");
-    if (round.reviewerRunId === undefined
-        || yielded.length !== 1
-        || yielded[0].id !== round.reviewerRunId) {
-        return "Completed Round lacks one exact yielded Reviewer Run.";
-    }
-    const run = yielded[0];
+        return `Reviewer Turn ${output.id} records Reviewer output.`;
+    const completed = runs.filter(({ status }) => status === "completed");
+    if (round.reviewerTurnId === undefined
+        || completed.length !== 1
+        || completed[0].id !== round.reviewerTurnId) {
+        return "Completed Round lacks one exact completed Reviewer Turn.";
+    }
+    const run = completed[0];
     if (run.roleName !== round.reviewerRoleName
-        || run.summary !== round.summary
-        || run.yieldReceipt === undefined) {
-        return `Reviewer Run ${run.id} does not match the non-semantic Round receipt.`;
-    }
-    const receiptMatch = matchYieldReceipt(run.yieldReceipt, {
-        status: "yielded",
-        summary: round.summary ?? "",
-        reviewResult: {
-            report: round.report ?? "",
-            checks: round.checks ?? [],
-            evidenceCommit: round.reviewBaseCommit
-        }
-    });
-    if (receiptMatch?.kind !== "replayed") {
-        return `Reviewer Run ${run.id} yield receipt does not cover the Round outcome.`;
+        || run.result?.output !== round.summary) {
+        return `Reviewer Turn ${run.id} does not match the non-semantic Round result.`;
     }
     const finding = store.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
     if (finding !== undefined)
@@ -204,12 +189,12 @@ function explicitCompletedReviewInfrastructureFailure(summary, round) {
     if (exactCompletedReviewInfrastructureFailureReport(summary))
         return true;
     const report = summary.trim();
-    if (report === `Role Run workspace is not the durable owner: ${round.taskId}/${round.reviewerRoleName}.`
-        || (round.reviewerRunId !== undefined
-            && report === `Review Run workspace is not the durable owner: ${round.reviewerRunId}.`)) {
+    if (report === `Role Turn workspace is not the durable owner: ${round.taskId}/${round.reviewerRoleName}.`
+        || (round.reviewerTurnId !== undefined
+            && report === `Review Turn workspace is not the durable owner: ${round.reviewerTurnId}.`)) {
         return true;
     }
-    return /^(?:Run )?(?:Context|Context Pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)(?:: (?:failure|mismatch|unavailable|unauthorized|stale|mismatched|malformed))?\.?$/iu
+    return /^(?:Turn )?(?:Context|Context Pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)(?:: (?:failure|mismatch|unavailable|unauthorized|stale|mismatched|malformed))?\.?$/iu
         .test(report);
 }
 function exactCompletedReviewInfrastructureFailureReport(summary) {
@@ -217,9 +202,9 @@ function exactCompletedReviewInfrastructureFailureReport(summary) {
     const envelope = [
         /^# Review result: (?:context-load|workspace-binding) failure$/u,
         /^$/u,
-        /^The assigned Run context could not be safely matched to this native session, so no candidate review was performed\.$/u,
+        /^The assigned Turn context could not be safely matched to this native session, so no candidate review was performed\.$/u,
         /^$/u,
-        /^- Run: `[^`\r\n]+`$/u,
+        /^- Turn: `[^`\r\n]+`$/u,
         /^- ReviewRound: `[^`\r\n]+`$/u,
         /^- Review base commit: `[0-9a-f]{40}`$/u,
         /^- Frozen target: `[^`\r\n]+`$/u,
@@ -236,14 +221,14 @@ function exactCompletedReviewInfrastructureFailureReport(summary) {
         /^$/u,
         /^## Checks actually run$/u,
         /^$/u,
-        /^- Exact Context API load: passed for Task\/Run\/Role\/purpose\/subject\/snapshot\/adapter\.$/u,
+        /^- Exact Context API load: passed for Task\/Turn\/Role\/purpose\/subject\/snapshot\/adapter\.$/u,
         /^- Workspace binding verification: failed\.$/u,
         /^- Candidate build\/tests\/package checks: not run\.$/u,
         /^- Real-provider E2E: not run and not authorized\.$/u,
         /^$/u,
         /^## Required next action$/u,
         /^$/u,
-        /^Attach the native Reviewer session to the exact workspace recorded by the Context Pack, or issue a fresh internally consistent Review Run\/Context Pack\. Then perform the complete bounded Task-final review at the frozen head\.$/u
+        /^Attach the native Reviewer session to the exact workspace recorded by the Context Pack, or issue a fresh internally consistent Review Turn\/Context Pack\. Then perform the complete bounded Task-final review at the frozen head\.$/u
     ];
     return lines.length === envelope.length
         && envelope.every((pattern, index) => pattern.test(lines[index]));

package/dist/review/reviewRound.js

@@ -78,7 +78,7 @@ export function attachReviewRoundWorkspace(round, workspace) {
     }
     return validateReviewRound({ ...round, workspace });
 }
-export function startReviewRound(round, reviewerRunId) {
+export function startReviewRound(round, reviewerTurnId) {
     validateReviewRound(round);
     if (round.status !== "pending") {
         throw new Error(`ReviewRound cannot start from ${round.status}: ${round.id}.`);
@@ -88,7 +88,7 @@ export function startReviewRound(round, reviewerRunId) {
     }
     return validateReviewRound({
         ...round,
-        reviewerRunId: requireIdentity(reviewerRunId, "Reviewer Run id"),
+        reviewerTurnId: requireIdentity(reviewerTurnId, "Reviewer Turn id"),
         status: "running"
     });
 }
@@ -134,7 +134,7 @@ export function finishReviewRound(round, status, summary, now, result = {}) {
 }
 /**
  * Issue 06: retry a failed Task-final execution attempt under the same semantic
- * Round identity. AgentRun history remains the attempt trail; the Round itself
+ * Round identity. Turn history remains the attempt trail; the Round itself
  * returns to pending so infrastructure retries do not manufacture a new
  * semantic ReviewRound or duplicate findings.
  */
@@ -153,7 +153,6 @@ export function retryTaskReviewRound(round, requestedBy, executionLaneId) {
         schemaVersion: round.schemaVersion,
         id: round.id,
         taskId: round.taskId,
-        ...(round.legacyAnchor === undefined ? {} : { legacyAnchor: round.legacyAnchor }),
         reviewerRoleName: round.reviewerRoleName,
         reviewBaseCommit: round.reviewBaseCommit,
         scope: "task",
@@ -177,7 +176,7 @@ export function retryTaskReviewRound(round, requestedBy, executionLaneId) {
                     deletedLines: round.deltaRecheck.deletedLines
                 })
             }),
-        // Keep the historical attempt Group and Lane addressable from AgentRun
+        // Keep the historical attempt Group and Lane addressable from Turn
         // history while resetting the Lane for another dispatch attempt.
         ...(retryExecutionGroup === undefined ? {} : { executionGroup: retryExecutionGroup }),
         requestedBy: validateReviewRequestSource(requestedBy),
@@ -187,15 +186,15 @@ export function retryTaskReviewRound(round, requestedBy, executionLaneId) {
     });
 }
 /** Keep a running panel Round active while retrying only its exact failed Lane. */
-export function retryRunningReviewExecutionLane(round, executionLaneId, runId, now) {
+export function retryRunningReviewExecutionLane(round, executionLaneId, turnId, now) {
     validateReviewRound(round);
     if (round.status !== "running" || round.executionGroup === undefined) {
         throw new Error(`ReviewRound ${round.id} has no running ExecutionGroup.`);
     }
     const lane = round.executionGroup.lanes.find(({ id }) => id === executionLaneId);
-    if (lane === undefined || lane.status !== "failed" || lane.runId !== runId) {
+    if (lane === undefined || lane.status !== "failed" || lane.turnId !== turnId) {
         throw new Error(`Review retry does not target the current failed Lane attempt: `
-            + `${round.executionGroup.id}/${executionLaneId}/${runId}.`);
+            + `${round.executionGroup.id}/${executionLaneId}/${turnId}.`);
     }
     return updateReviewExecutionGroup(round, retryReviewExecutionGroup(round, executionLaneId, now));
 }
@@ -219,7 +218,7 @@ function retryReviewExecutionGroup(round, executionLaneId, retryAt) {
     });
 }
 /** Accepts the Reviewer's complete report and extracts only optional known evidence. */
-export function parseReviewYieldReport(value) {
+export function parseReviewResultReport(value) {
     const report = requireText(value, "Review report");
     let parsed;
     try {
@@ -372,15 +371,6 @@ export function validateReviewRound(round) {
         if (round.workItemId !== undefined || round.candidateId !== undefined) {
             throw new Error(`Task ReviewRound cannot use a WorkItem Candidate anchor: ${round.id}.`);
         }
-        if (round.legacyAnchor !== undefined) {
-            validateTaskRecordReference({
-                taskId: round.taskId,
-                localId: round.legacyAnchor.workItemId
-            }, "workItem");
-            if (!/^candidate-[1-9]\d*$/.test(round.legacyAnchor.candidateId)) {
-                throw new Error(`Legacy Candidate local id is invalid: ${round.legacyAnchor.candidateId}.`);
-            }
-        }
         if (round.taskCandidate === undefined) {
             throw new Error(`Task ReviewRound requires a frozen Task candidate: ${round.id}.`);
         }
@@ -407,8 +397,7 @@ export function validateReviewRound(round) {
             throw new Error(`Candidate local id is invalid: ${round.candidateId}.`);
         }
         if (round.taskCandidate !== undefined
-            || round.taskFinalReviewContract !== undefined
-            || round.legacyAnchor !== undefined) {
+            || round.taskFinalReviewContract !== undefined) {
             throw new Error(`WorkItem ReviewRound cannot carry Task-final metadata: ${round.id}.`);
         }
     }
@@ -424,11 +413,11 @@ export function validateReviewRound(round) {
         }
         validateDeltaRecheckRecord(round.deltaRecheck);
     }
-    if (round.reviewerRunId !== undefined) {
+    if (round.reviewerTurnId !== undefined) {
         validateTaskRecordReference({
             taskId: round.taskId,
-            localId: round.reviewerRunId
-        }, "agentRun");
+            localId: round.reviewerTurnId
+        }, "turn");
     }
     if (round.workspace !== undefined)
         validateReviewWorkspace(round, round.workspace);
@@ -456,8 +445,8 @@ export function validateReviewRound(round) {
         throw new Error("An active ReviewRound cannot have terminal metadata.");
     }
     if (round.status === "running"
-        && (round.reviewerRunId === undefined || round.workspace === undefined)) {
-        throw new Error("A running ReviewRound requires a Reviewer Run and workspace.");
+        && (round.reviewerTurnId === undefined || round.workspace === undefined)) {
+        throw new Error("A running ReviewRound requires a Reviewer Turn and workspace.");
     }
     if (round.workspaceDisposition !== undefined) {
         if (!terminal || round.workspace === undefined) {

package/dist/review/reviewerAvailability.js

@@ -2,14 +2,14 @@ import { nextPendingBatch, mailboxHasWork } from "../coordination/workMailbox.js
 import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 /** One authoritative read-only projection for a Task Reviewer Role slot. */
 export function projectReviewerAvailability(store, taskId, reviewerRoleName) {
-    const active = store.getActiveAgentRun(taskId, reviewerRoleName)
-        ?? store.listAgentRuns(taskId).find((run) => (run.roleName === reviewerRoleName && run.status === "active"));
+    const active = store.getActiveTurn(taskId, reviewerRoleName)
+        ?? store.listTurns(taskId).find((run) => (run.roleName === reviewerRoleName && run.status === "active"));
     if (active !== null && active !== undefined) {
         return {
             kind: "busy",
             reviewerRoleName,
-            phase: "active-run",
-            activeRunId: active.id,
+            phase: "active-turn",
+            activeTurnId: active.id,
             ...(active.reviewRoundId === undefined
                 ? {}
                 : { activeReviewRoundId: active.reviewRoundId }),

package/dist/review/taskFinalReviewContractResolution.js

@@ -0,0 +1,41 @@
+import { requireIdentity } from "../domain/validation.js";
+import { sameTaskFinalReviewContract, validateTaskFinalReviewContract } from "./taskFinalReviewContract.js";
+/**
+ * Resolve the one Task-final Review contract recorded by current Candidate and
+ * ReviewRound evidence. The contract is immutable once established; all later
+ * observations must match it exactly.
+ */
+export function resolveRecordedTaskFinalReviewContract(taskId, workItems, reviewRounds) {
+    const normalizedTaskId = requireIdentity(taskId, "Task final-review contract Task id");
+    const observations = [
+        ...workItems.flatMap((item) => item.candidates.flatMap((candidate) => (candidate.taskFinalReviewContract === undefined
+            ? []
+            : [{
+                    contract: candidate.taskFinalReviewContract,
+                    source: `Candidate ${item.id}/${candidate.id}`
+                }]))),
+        ...reviewRounds.flatMap((round) => ((round.scope ?? "work-item") !== "task"
+            || round.taskFinalReviewContract === undefined
+            ? []
+            : [{
+                    contract: round.taskFinalReviewContract,
+                    source: `ReviewRound ${round.id}`
+                }]))
+    ];
+    if (observations.length === 0)
+        return undefined;
+    const effective = validateTaskFinalReviewContract(observations[0].contract);
+    if (effective.taskId !== normalizedTaskId) {
+        throw new Error(`${observations[0].source} carries a final-review contract for another Task.`);
+    }
+    for (const observation of observations.slice(1)) {
+        const contract = validateTaskFinalReviewContract(observation.contract);
+        if (contract.taskId !== normalizedTaskId) {
+            throw new Error(`${observation.source} carries a final-review contract for another Task.`);
+        }
+        if (!sameTaskFinalReviewContract(contract, effective)) {
+            throw new Error(`${observation.source} conflicts with the Task final-review contract.`);
+        }
+    }
+    return Object.freeze({ effective });
+}

package/dist/role/role.js

@@ -93,7 +93,7 @@ export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, no
         : updateGlobalRole(role, { activeAgentId: normalizedTarget }, now);
     // A running process keeps its immutable effective identity. The desired
     // switch becomes visible only when the next launch is planned.
-    const updatedSessions = runtime.activeRun || runtime.nativeProcessRunning
+    const updatedSessions = runtime.activeTurn || runtime.nativeProcessRunning
         ? sessions
         : {
             ...sessions,
@@ -126,8 +126,11 @@ export function unbindRoleAgent(role, sessions, agentId, now) {
         const taskSessions = sessions.owner.scope === "task"
             ? sessions
             : null;
-        if (taskSessions?.inFlight?.agentId === normalizedAgentId) {
-            throw new Error(`Cannot unbind Role Agent with an active Run: ${normalizedAgentId}.`);
+        if (taskSessions?.providerBinding?.turn !== null
+            && taskSessions?.providerBinding?.turn !== undefined
+            && taskSessions.activeAgentId === normalizedAgentId
+            && ["submitting", "accepted", "running"].includes(taskSessions.providerBinding.turn.status)) {
+            throw new Error(`Cannot unbind Role Agent with an active Turn: ${normalizedAgentId}.`);
         }
         const targetSession = sessions.sessions[normalizedAgentId];
         if (targetSession !== undefined && targetSession.status === "active") {

package/dist/runtime/agentDriver.js

@@ -92,6 +92,9 @@ export function validateAgentDriverCapabilities(input) {
     if (!["exact", "partial", "unavailable"].includes(observation.turnLifecycle)) {
         throw new Error("Agent Driver turn lifecycle capability is invalid.");
     }
+    if (!["exact", "partial", "unavailable"].includes(observation.goalLifecycle)) {
+        throw new Error("Agent Driver Goal lifecycle capability is invalid.");
+    }
     if (!USAGE_MODES.includes(observation.usage)) {
         throw new Error("Agent Driver usage capability is invalid.");
     }
@@ -163,6 +166,7 @@ export function validateAgentDriverCapabilities(input) {
             preInputReadiness: observation.preInputReadiness,
             promptAcceptance: observation.promptAcceptance,
             turnLifecycle: observation.turnLifecycle,
+            goalLifecycle: observation.goalLifecycle,
             operations: Object.freeze(uniqueMembers(observation.operations, OPERATIONS, "Agent Driver operation")),
             waiting: Object.freeze(uniqueMembers(observation.waiting, WAIT_REASONS, "Agent Driver wait reason")),
             usage: observation.usage,