@zq-silk/yui 0.14.0 → 0.14.2

package/dist/review/reviewRound.js

@@ -2,10 +2,10 @@ import { requireIdentity, requireText, requireTimestamp } from "../domain/valida
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { validateTaskFinalReviewContract } from "./taskFinalReviewContract.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
-import { assertExecutionGroupTransition, resetReviewExecutionLane, validateExecutionGroup } from "../execution/executionGroup.js";
+import { assertExecutionGroupTransition, retryFailedExecutionLanes, validateExecutionGroup, validateReviewExecutionAssignment } from "../execution/workItemExecution.js";
 export function createReviewRound(id, taskId, workItemId, candidateId, reviewerRoleName, requestedBy, reviewBaseCommit, now, executionGroup) {
     return validateReviewRound({
-        schemaVersion: 6,
+        schemaVersion: 8,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
         workItemId: requireIdentity(workItemId, "Work Item id"),
@@ -21,7 +21,7 @@ export function createReviewRound(id, taskId, workItemId, candidateId, reviewerR
 export function createTaskReviewRound(id, taskId, reviewerRoleName, requestedBy, taskCandidate, now, taskFinalReviewContract, executionGroup) {
     const candidate = validateTaskReviewCandidate(taskCandidate);
     return validateReviewRound({
-        schemaVersion: 6,
+        schemaVersion: 8,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
         reviewerRoleName: requireIdentity(reviewerRoleName, "Reviewer Role"),
@@ -47,7 +47,7 @@ export function createTaskReviewRound(id, taskId, reviewerRoleName, requestedBy,
 export function createTaskDeltaReviewRound(id, taskId, reviewerRoleName, requestedBy, taskCandidate, deltaRecheck, now, taskFinalReviewContract, executionGroup) {
     const candidate = validateTaskReviewCandidate(taskCandidate);
     return validateReviewRound({
-        schemaVersion: 6,
+        schemaVersion: 8,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
         reviewerRoleName: requireIdentity(reviewerRoleName, "Reviewer Role"),
@@ -80,7 +80,10 @@ export function attachReviewRoundWorkspace(round, workspace) {
 }
 export function startReviewRound(round, reviewerTurnId) {
     validateReviewRound(round);
-    if (round.status !== "pending") {
+    if (round.status !== "pending"
+        && !(round.status === "running"
+            && round.executionGroup !== undefined
+            && round.reviewerTurnId === undefined)) {
         throw new Error(`ReviewRound cannot start from ${round.status}: ${round.id}.`);
     }
     if (round.workspace === undefined) {
@@ -92,74 +95,67 @@ export function startReviewRound(round, reviewerTurnId) {
         status: "running"
     });
 }
-export function finishReviewRound(round, status, summary, now, result = {}) {
+export function startReplicatedReviewRound(round) {
+    validateReviewRound(round);
+    if (round.status !== "pending" || round.executionGroup === undefined) {
+        throw new Error(`ReviewRound cannot start replicated execution: ${round.id}.`);
+    }
+    if (round.workspace === undefined) {
+        throw new Error(`ReviewRound workspace is not ready: ${round.id}.`);
+    }
+    return validateReviewRound({ ...round, status: "running" });
+}
+export function finishReviewRound(round, status, now, failure) {
     validateReviewRound(round);
     if (round.status !== "pending" && round.status !== "running") {
         throw new Error(`ReviewRound is already terminal: ${round.id}.`);
     }
-    const terminal = validateReviewRound({
-        ...round,
-        status,
-        summary: requireText(summary, "Review summary"),
-        report: requireText(result.report ?? summary, "Review report"),
-        checks: validateChecks(result.checks ?? []),
-        ...(result.evidenceCommit === undefined
-            ? {}
-            : { evidenceCommit: requireCommit(result.evidenceCommit, "Review evidence commit") }),
-        endedAt: now.toISOString()
-    });
-    if (round.deltaRecheck === undefined) {
-        if (result.deltaDisposition !== undefined || result.deltaReasoning !== undefined) {
-            throw new Error(`Only a delta-recheck ReviewRound can carry a delta disposition: ${round.id}.`);
-        }
-        return terminal;
+    if (status === "completed" && failure !== undefined) {
+        throw new Error("A completed ReviewRound cannot carry failure metadata.");
     }
-    if (status !== "completed") {
-        // A failed delta Round is an infra attempt; it records no disposition and
-        // the candidate stays unaccepted.
-        return terminal;
+    if (status === "failed" && failure === undefined) {
+        throw new Error("A failed ReviewRound requires Core-owned failure metadata.");
     }
-    // Fail closed: a completed delta Round without an explicit, valid
-    // disposition remains non-accepting for Leader routing. Uncertainty never accepts.
-    const disposition = result.deltaDisposition ?? "requires-full-review";
-    const reasoning = result.deltaReasoning ?? result.report ?? summary;
     return validateReviewRound({
-        ...terminal,
-        deltaRecheck: validateDeltaRecheckRecord({
-            ...round.deltaRecheck,
-            disposition,
-            reasoning: requireText(reasoning, "Delta recheck reasoning")
-        })
+        ...round,
+        status,
+        ...(failure === undefined ? {} : { failure: validateReviewRoundFailure(failure) }),
+        endedAt: now.toISOString()
     });
 }
 /**
- * Issue 06: retry a failed Task-final execution attempt under the same semantic
- * 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.
+ * Retry a failed review execution attempt under the same semantic 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.
  */
-export function retryTaskReviewRound(round, requestedBy, executionLaneId) {
+export function retryReviewRound(round, requestedBy, now) {
     validateReviewRound(round);
-    if ((round.scope ?? "work-item") !== "task") {
-        throw new Error(`Only a Task-final ReviewRound can be retried in place: ${round.id}.`);
-    }
     if (round.status !== "failed") {
         throw new Error(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
     }
-    const retryExecutionGroup = round.executionGroup === undefined
-        ? undefined
-        : retryReviewExecutionGroup(round, executionLaneId);
+    const taskScope = (round.scope ?? "work-item") === "task";
     return validateReviewRound({
         schemaVersion: round.schemaVersion,
         id: round.id,
         taskId: round.taskId,
+        ...(round.scope === undefined ? {} : { scope: round.scope }),
+        ...(taskScope
+            ? {}
+            : {
+                workItemId: round.workItemId,
+                candidateId: round.candidateId
+            }),
         reviewerRoleName: round.reviewerRoleName,
         reviewBaseCommit: round.reviewBaseCommit,
-        scope: "task",
-        ...(round.taskCandidate === undefined ? {} : { taskCandidate: round.taskCandidate }),
-        ...(round.taskFinalReviewContract === undefined
-            ? {}
-            : { taskFinalReviewContract: round.taskFinalReviewContract }),
+        ...(taskScope
+            ? {
+                taskCandidate: round.taskCandidate,
+                ...(round.taskFinalReviewContract === undefined
+                    ? {}
+                    : { taskFinalReviewContract: round.taskFinalReviewContract })
+            }
+            : {}),
         ...(round.deltaRecheck === undefined
             ? {}
             // A retried delta Round is still the same semantic recheck: the
@@ -176,129 +172,37 @@ export function retryTaskReviewRound(round, requestedBy, executionLaneId) {
                     deletedLines: round.deltaRecheck.deletedLines
                 })
             }),
-        // Keep the historical attempt Group and Lane addressable from Turn
-        // history while resetting the Lane for another dispatch attempt.
-        ...(retryExecutionGroup === undefined ? {} : { executionGroup: retryExecutionGroup }),
+        // A replicated retry preserves settled successful Producers and reopens
+        // only failed Lanes. If every Producer succeeded, only the main Reviewer
+        // Turn is retried.
+        ...(round.executionGroup === undefined
+            ? {}
+            : { executionGroup: retryFailedExecutionLanes(round.executionGroup, now) }),
         requestedBy: validateReviewRequestSource(requestedBy),
         status: "pending",
         ...(round.workspace === undefined ? {} : { workspace: round.workspace }),
         createdAt: round.createdAt
     });
 }
-/** Keep a running panel Round active while retrying only its exact failed Lane. */
-export function retryRunningReviewExecutionLane(round, executionLaneId, turnId, now) {
+/** Task-final compatibility wrapper for callers that require that scope. */
+export function retryTaskReviewRound(round, requestedBy, now) {
+    if ((round.scope ?? "work-item") !== "task") {
+        throw new Error(`Only a Task-final ReviewRound can be retried in place: ${round.id}.`);
+    }
+    return retryReviewRound(round, requestedBy, now);
+}
+/** A failed producer attempt leaves its logical Lane open for another Turn. */
+export function retryRunningReviewExecutionLane(round, executionLaneId, turnId) {
     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.turnId !== turnId) {
+    if (lane === undefined || lane.disposition !== "open" || lane.currentTurnId !== turnId) {
         throw new Error(`Review retry does not target the current failed Lane attempt: `
             + `${round.executionGroup.id}/${executionLaneId}/${turnId}.`);
     }
-    return updateReviewExecutionGroup(round, retryReviewExecutionGroup(round, executionLaneId, now));
-}
-function retryReviewExecutionGroup(round, executionLaneId, retryAt) {
-    const previous = round.executionGroup;
-    if (executionLaneId !== undefined) {
-        const exactLane = previous.lanes.find(({ id }) => id === executionLaneId);
-        if (exactLane === undefined || exactLane.status !== "failed") {
-            throw new Error(`Review retry Lane is not failed: ${previous.id}/${executionLaneId}.`);
-        }
-    }
-    const now = retryAt ?? new Date(Date.parse(round.endedAt ?? round.createdAt));
-    const lanes = previous.lanes.map((lane) => (lane.status === "failed"
-        && (executionLaneId === undefined || lane.id === executionLaneId)
-        ? resetReviewExecutionLane(previous, lane.id, now)
-        : lane));
-    return validateExecutionGroup({
-        ...previous,
-        lanes,
-        updatedAt: now.toISOString()
-    });
-}
-/** Accepts the Reviewer's complete report and extracts only optional known evidence. */
-export function parseReviewResultReport(value) {
-    const report = requireText(value, "Review report");
-    let parsed;
-    try {
-        parsed = JSON.parse(report);
-    }
-    catch {
-        return { summary: report, report, checks: [] };
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        return { summary: report, report, checks: [] };
-    }
-    const record = parsed;
-    const summary = typeof record.summary === "string" && record.summary.trim().length > 0
-        ? requireText(record.summary, "Review summary")
-        : report;
-    const checks = extractChecks(record.checks);
-    const findings = extractFindings(record.findings);
-    const evidence = extractEvidence(record.evidence);
-    const deltaDisposition = extractDeltaDisposition(record.deltaDisposition);
-    return {
-        summary,
-        report,
-        checks,
-        ...(findings.length === 0 ? {} : { findings }),
-        ...(evidence.length === 0 ? {} : { evidence }),
-        ...(deltaDisposition === undefined ? {} : { deltaDisposition }),
-        ...(typeof record.deltaReasoning !== "string"
-            || record.deltaReasoning.trim().length === 0
-            ? {}
-            : { deltaReasoning: requireText(record.deltaReasoning, "Delta recheck reasoning") }),
-        ...(typeof record.evidenceCommit !== "string"
-            ? {}
-            : {
-                evidenceCommit: requireCommit(record.evidenceCommit, "Review evidence commit")
-            })
-    };
-}
-function extractDeltaDisposition(value) {
-    if (value !== "equivalent-and-accepted"
-        && value !== "finding"
-        && value !== "requires-full-review") {
-        return undefined;
-    }
-    return value;
-}
-function extractFindings(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((entry) => {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            return [];
-        }
-        const finding = entry;
-        if (typeof finding.id !== "string"
-            || (finding.severity !== "low" && finding.severity !== "medium"
-                && finding.severity !== "high" && finding.severity !== "critical"
-                && finding.severity !== "p1" && finding.severity !== "p2")
-            || (finding.status !== "open" && finding.status !== "resolved")
-            || typeof finding.summary !== "string") {
-            return [];
-        }
-        return [{
-                id: requireIdentity(finding.id, "Review finding id"),
-                // Reviewers may use the product-level P1/P2 vocabulary. Execution
-                // groups keep one canonical severity scale so resolution gates remain
-                // stable across Worker and Reviewer reports.
-                severity: finding.severity === "p1"
-                    ? "critical"
-                    : finding.severity === "p2"
-                        ? "high"
-                        : finding.severity,
-                status: finding.status,
-                summary: requireText(finding.summary, "Review finding summary")
-            }];
-    });
-}
-function extractEvidence(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.flatMap((entry) => (typeof entry === "string" && entry.trim().length > 0 ? [entry.trim()] : []));
+    return round;
 }
 export function recordReviewWorkspaceDisposition(round, disposition, now) {
     validateReviewRound(round);
@@ -348,9 +252,8 @@ export function updateReviewExecutionGroup(round, executionGroup) {
         }
         return validateReviewRound({ ...round, executionGroup });
     }
-    if (round.executionGroup.id !== executionGroup.id
-        || JSON.stringify(round.executionGroup.target) !== JSON.stringify(executionGroup.target)) {
-        throw new Error(`ReviewRound ExecutionGroup target is immutable: ${round.id}.`);
+    if (round.executionGroup.id !== executionGroup.id) {
+        throw new Error(`ReviewRound ExecutionGroup identity is immutable: ${round.id}.`);
     }
     if (JSON.stringify(round.executionGroup) === JSON.stringify(executionGroup))
         return round;
@@ -358,8 +261,30 @@ export function updateReviewExecutionGroup(round, executionGroup) {
     return validateReviewRound({ ...round, executionGroup });
 }
 export function validateReviewRound(round) {
-    if (round.schemaVersion !== 6)
-        throw new Error("ReviewRound must use schemaVersion 6.");
+    rejectUnknownFields(round, [
+        "schemaVersion",
+        "id",
+        "taskId",
+        "workItemId",
+        "candidateId",
+        "reviewerRoleName",
+        "reviewerTurnId",
+        "reviewBaseCommit",
+        "scope",
+        "taskCandidate",
+        "taskFinalReviewContract",
+        "deltaRecheck",
+        "executionGroup",
+        "workspace",
+        "requestedBy",
+        "status",
+        "failure",
+        "workspaceDisposition",
+        "createdAt",
+        "endedAt"
+    ], "ReviewRound");
+    if (round.schemaVersion !== 8)
+        throw new Error("ReviewRound must use schemaVersion 8.");
     validateTaskRecordReference({ taskId: round.taskId, localId: round.id }, "reviewRound");
     requireIdentity(round.reviewerRoleName, "Reviewer Role");
     requireCommit(round.reviewBaseCommit, "Review base commit");
@@ -424,29 +349,30 @@ export function validateReviewRound(round) {
     requireTimestamp(round.createdAt, "ReviewRound createdAt");
     const terminal = round.status === "completed" || round.status === "failed";
     if (terminal) {
-        requireText(round.summary ?? "", "Review summary");
-        requireText(round.report ?? "", "Review report");
-        validateChecks(round.checks ?? []);
-        if (round.evidenceCommit !== undefined) {
-            // The exact commit on which the review's checks ran.  Equals the base
-            // when the reviewer ran checks on the frozen candidate tree; differs
-            // when the reviewer committed diagnostics on top of it.  A dirty
-            // review with uncommitted changes records no evidenceCommit, since no
-            // single commit captures the checked tree.
-            requireCommit(round.evidenceCommit, "Review evidence commit");
+        if (round.status === "completed" && round.reviewerTurnId === undefined) {
+            throw new Error("A completed ReviewRound requires its exact main Reviewer Turn.");
+        }
+        if (round.status === "completed" && round.failure !== undefined) {
+            throw new Error("A completed ReviewRound cannot carry failure metadata.");
         }
+        if (round.status === "failed" && round.failure === undefined) {
+            throw new Error("A failed ReviewRound requires failure metadata.");
+        }
+        if (round.failure !== undefined)
+            validateReviewRoundFailure(round.failure);
         requireTimestamp(round.endedAt ?? "", "ReviewRound endedAt");
     }
-    else if (round.summary !== undefined
-        || round.report !== undefined
-        || round.checks !== undefined
-        || round.evidenceCommit !== undefined
+    else if (round.failure !== undefined
         || round.endedAt !== undefined) {
         throw new Error("An active ReviewRound cannot have terminal metadata.");
     }
+    if (round.status === "running" && round.workspace === undefined) {
+        throw new Error("A running ReviewRound requires its main Reviewer workspace.");
+    }
     if (round.status === "running"
-        && (round.reviewerTurnId === undefined || round.workspace === undefined)) {
-        throw new Error("A running ReviewRound requires a Reviewer Turn and workspace.");
+        && round.reviewerTurnId === undefined
+        && round.executionGroup === undefined) {
+        throw new Error("A running ReviewRound requires a direct Reviewer Turn or replicated Group.");
     }
     if (round.workspaceDisposition !== undefined) {
         if (!terminal || round.workspace === undefined) {
@@ -459,23 +385,19 @@ export function validateReviewRound(round) {
         }
         requireTimestamp(round.workspaceDisposition.recordedAt, "Review workspace disposition time");
     }
-    if (round.deltaRecheck?.disposition !== undefined) {
-        if (!terminal) {
-            throw new Error("An active delta-recheck ReviewRound cannot have a disposition.");
-        }
-        if (round.deltaRecheck.reasoning === undefined
-            || round.deltaRecheck.reasoning.trim().length === 0) {
-            throw new Error("A terminal delta-recheck ReviewRound requires reasoning.");
-        }
-        if (round.deltaRecheck.escalatedToReviewRoundId !== undefined
-            && round.deltaRecheck.disposition !== "requires-full-review") {
-            throw new Error("Only a requires-full-review delta-recheck can record an escalation.");
-        }
-    }
     return round;
 }
 /** Validates a delta-recheck record's immutable identity and terminal fields. */
 export function validateDeltaRecheckRecord(record) {
+    rejectUnknownFields(record, [
+        "schemaVersion",
+        "previousReviewRoundId",
+        "previousBaseCommit",
+        "diffDigest",
+        "changedFiles",
+        "addedLines",
+        "deletedLines"
+    ], "Delta recheck record");
     if (record.schemaVersion !== 1) {
         throw new Error("Delta recheck record must use schemaVersion 1.");
     }
@@ -492,59 +414,43 @@ export function validateDeltaRecheckRecord(record) {
         || !Number.isInteger(record.deletedLines) || record.deletedLines < 0) {
         throw new Error("Delta recheck line counts are invalid.");
     }
-    if (record.disposition !== undefined
-        && record.disposition !== "equivalent-and-accepted"
-        && record.disposition !== "finding"
-        && record.disposition !== "requires-full-review") {
-        throw new Error(`Delta recheck disposition is invalid: ${String(record.disposition)}.`);
-    }
-    if (record.reasoning !== undefined) {
-        requireText(record.reasoning, "Delta recheck reasoning");
-    }
-    if (record.escalatedToReviewRoundId !== undefined) {
-        requireIdentity(record.escalatedToReviewRoundId, "Delta recheck escalation ReviewRound id");
-    }
     return record;
 }
 /** True when this Round is an Issue 07 delta-recheck. */
 export function isDeltaRecheckRound(round) {
     return round.deltaRecheck !== undefined;
 }
-/** True only when a delta Round explicitly accepted the new head. */
-export function deltaRecheckAccepted(round) {
-    return round.deltaRecheck?.disposition === "equivalent-and-accepted";
-}
-/** True when a delta Round escalated to a full Review. */
-export function deltaRecheckEscalated(round) {
-    return round.deltaRecheck?.disposition === "requires-full-review";
-}
-/**
- * True when a completed delta Round does NOT accept the new head.  A `finding`
- * or `requires-full-review` disposition must keep the completion gate closed.
- */
-export function deltaRecheckBlocksAcceptance(round) {
-    return round.deltaRecheck !== undefined
-        && round.status === "completed"
-        && round.deltaRecheck.disposition !== undefined
-        && round.deltaRecheck.disposition !== "equivalent-and-accepted";
+function validateReviewRoundFailure(failure) {
+    rejectUnknownFields(failure, [
+        "kind",
+        "message"
+    ], "ReviewRound failure");
+    if (failure.kind !== "dispatch"
+        && failure.kind !== "execution"
+        && failure.kind !== "quorum") {
+        throw new Error("ReviewRound failure kind is invalid.");
+    }
+    requireText(failure.message, "ReviewRound failure message");
+    return failure;
 }
 function validateReviewExecutionGroup(group, round) {
     validateExecutionGroup(group);
-    if (group.taskId !== round.taskId || group.purpose !== "review") {
+    const assignment = validateReviewExecutionAssignment(group.assignment);
+    if (group.taskId !== round.taskId
+        || assignment.taskId !== round.taskId
+        || assignment.reviewRoundId !== round.id
+        || assignment.reviewBaseCommit !== round.reviewBaseCommit
+        || assignment.scope !== (round.scope ?? "work-item")) {
         throw new Error(`ReviewRound ExecutionGroup provenance is invalid: ${round.id}.`);
     }
-    const expectedKind = (round.scope ?? "work-item") === "task"
-        ? "task-final-review"
-        : "work-item";
-    if (group.target.kind !== expectedKind
-        || group.target.taskId !== round.taskId) {
-        throw new Error(`ReviewRound ExecutionGroup target is invalid: ${round.id}.`);
-    }
-    if (expectedKind === "work-item"
-        && (group.target.workItemId !== round.workItemId
-            || group.target.candidateId !== round.candidateId)) {
+    if ((round.scope ?? "work-item") === "work-item"
+        && (assignment.workItemId !== round.workItemId
+            || assignment.candidateId !== round.candidateId)) {
         throw new Error(`ReviewRound ExecutionGroup WorkItem target is invalid: ${round.id}.`);
     }
+    if (group.lanes.some(({ roleName }) => roleName === round.reviewerRoleName)) {
+        throw new Error(`The main Reviewer cannot also be a Producer Lane: ${round.id}.`);
+    }
     return group;
 }
 export function validateTaskReviewCandidate(candidate) {
@@ -563,26 +469,6 @@ export function validateTaskReviewCandidate(candidate) {
     }
     return { schemaVersion: 1, projects };
 }
-function extractChecks(value) {
-    if (!Array.isArray(value))
-        return [];
-    const extracted = value.flatMap((entry) => {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
-            return [];
-        const check = entry;
-        if (typeof check.name !== "string"
-            || (check.outcome !== "passed"
-                && check.outcome !== "failed"
-                && check.outcome !== "skipped"))
-            return [];
-        return [{
-                name: check.name,
-                outcome: check.outcome,
-                ...(typeof check.details === "string" ? { details: check.details } : {})
-            }];
-    });
-    return validateChecks(extracted);
-}
 function validateReviewWorkspace(round, workspace) {
     validateManagedWorkspace(workspace);
     if (workspace.owner.taskId !== round.taskId) {
@@ -600,24 +486,6 @@ function validateReviewWorkspace(round, workspace) {
         throw new Error(`ReviewRound workspace does not contain its review base: ${round.id}.`);
     }
 }
-function validateChecks(checks) {
-    if (!Array.isArray(checks))
-        throw new Error("Review checks are invalid.");
-    return checks.map((check) => {
-        const name = requireText(check.name, "Review check name");
-        if (check.outcome !== "passed" && check.outcome !== "failed"
-            && check.outcome !== "skipped") {
-            throw new Error(`Review check outcome is invalid: ${String(check.outcome)}.`);
-        }
-        return {
-            name,
-            outcome: check.outcome,
-            ...(check.details === undefined
-                ? {}
-                : { details: requireText(check.details, "Review check details") })
-        };
-    });
-}
 function requireCommit(value, label) {
     const commit = requireText(value, label).toLowerCase();
     if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/u.test(commit)) {
@@ -634,3 +502,9 @@ function validateReviewRequestSource(source) {
     }
     return source;
 }
+function rejectUnknownFields(value, fields, label) {
+    const allowed = new Set(fields);
+    const unknown = Object.keys(value).find((field) => !allowed.has(field));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unknown field: ${unknown}.`);
+}

package/dist/review/reviewerAvailability.js

@@ -2,9 +2,8 @@ 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.getActiveTurn(taskId, reviewerRoleName)
-        ?? store.listTurns(taskId).find((run) => (run.roleName === reviewerRoleName && run.status === "active"));
-    if (active !== null && active !== undefined) {
+    const active = store.getActiveTurn(taskId, reviewerRoleName);
+    if (active !== null) {
         return {
             kind: "busy",
             reviewerRoleName,
@@ -18,8 +17,15 @@ export function projectReviewerAvailability(store, taskId, reviewerRoleName) {
             retryAfterSeconds: 5
         };
     }
-    const activeRound = store.listReviewRounds(taskId).find((round) => ((round.scope ?? "work-item") === "task"
-        && (round.status === "pending" || round.status === "running")
+    const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
+        scope: "task",
+        taskId,
+        roleName: reviewerRoleName
+    }));
+    if (runtimeMailbox !== null && mailboxHasWork(runtimeMailbox)) {
+        return runtimeLifecycleBusy(reviewerRoleName, runtimeMailbox);
+    }
+    const activeRound = store.listReviewRounds(taskId).find((round) => ((round.status === "pending" || round.status === "running")
         && (round.reviewerRoleName === reviewerRoleName
             || round.executionGroup?.lanes.some(({ roleName }) => roleName === reviewerRoleName) === true)));
     if (activeRound !== undefined) {
@@ -33,35 +39,19 @@ export function projectReviewerAvailability(store, taskId, reviewerRoleName) {
             retryAfterSeconds: 5
         };
     }
-    const reviewerMailbox = store.getWorkMailbox({
-        kind: "role",
-        taskId,
-        roleName: reviewerRoleName
-    });
-    if (reviewerMailbox !== null && mailboxHasWork(reviewerMailbox)) {
-        return mailboxBusy(reviewerRoleName, "mailbox", reviewerMailbox);
-    }
-    const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-        scope: "task",
-        taskId,
-        roleName: reviewerRoleName
-    }));
-    if (runtimeMailbox !== null && mailboxHasWork(runtimeMailbox)) {
-        return mailboxBusy(reviewerRoleName, "runtime-lifecycle", runtimeMailbox);
-    }
     return {
         kind: "available",
         reviewerRoleName,
         retryable: true
     };
 }
-function mailboxBusy(reviewerRoleName, phase, mailbox) {
+function runtimeLifecycleBusy(reviewerRoleName, mailbox) {
     const pending = nextPendingBatch(mailbox);
     const startedAt = mailbox.processing?.startedAt ?? pending?.firstQueuedAt;
     return {
         kind: "busy",
         reviewerRoleName,
-        phase,
+        phase: "runtime-lifecycle",
         ...(startedAt === undefined ? {} : { startedAt }),
         retryable: true,
         retryAfterSeconds: 5

package/dist/role/role.js

@@ -98,6 +98,9 @@ export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, no
         : {
             ...sessions,
             activeAgentId: normalizedTarget,
+            ...(sessions.owner.scope === "task" && fromAgentId !== normalizedTarget
+                ? { providerBinding: null }
+                : {}),
             updatedAt: timestamp
         };
     return {

package/dist/runtime/agentDriverObservation.js

@@ -40,7 +40,7 @@ function observation(input, mapped) {
     const eventId = hookEventId(input, mapped, requestOccurrenceId);
     const fence = { ...input.fence, ...mapped.fence };
     return createRuntimeObservation({
-        schemaVersion: 2,
+        schemaVersion: 4,
         eventId,
         semanticKey: requestOccurrenceId === undefined
             ? runtimeObservationSemanticKey({