@zq-silk/yui 0.8.9 → 0.9.0

package/dist/repository/taskWorkspacePreparer.js

@@ -1168,19 +1168,22 @@ export class FileTaskWorkspacePreparer {
             if (round.status !== "pending") {
                 throw new Error(`ReviewRound workspace can only prepare while pending: ${round.id}.`);
             }
-            const item = requireWorkItem(this.store, task.id, round.workItemId);
-            const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-            if (candidate === undefined) {
+            const taskScope = (round.scope ?? "work-item") === "task";
+            const item = taskScope || round.workItemId === undefined
+                ? undefined
+                : requireWorkItem(this.store, task.id, round.workItemId);
+            const candidate = taskScope
+                ? undefined
+                : item?.candidates.find(({ id }) => id === round.candidateId);
+            if (!taskScope && candidate === undefined) {
                 throw new Error(`ReviewRound Candidate not found: ${round.candidateId}.`);
             }
-            const taskScope = (round.scope ?? "work-item") === "task";
             // A WorkItem ReviewRound is an immutable snapshot of Develop. A Task
-            // ReviewRound intentionally uses the latest committed Integration heads
-            // instead, while retaining the WorkItem/Candidate anchor for storage and
-            // lifecycle compatibility.
-            const develop = candidate.workspace;
-            if (!taskScope && (develop === undefined || candidate.gitSnapshot === undefined)) {
-                throw new Error(`Candidate has no frozen managed Git snapshot: ${candidate.id}.`);
+            // ReviewRound instead freezes every bound Project at the unified Task
+            // heads and deliberately has no WorkItem/Candidate anchor.
+            const develop = candidate?.workspace;
+            if (!taskScope && (develop === undefined || candidate?.gitSnapshot === undefined)) {
+                throw new Error(`Candidate has no frozen managed Git snapshot: ${candidate?.id ?? "unknown"}.`);
             }
             if (!taskScope && candidate.gitSnapshot.reviewBaseCommit !== round.reviewBaseCommit) {
                 throw new Error(`ReviewRound base no longer matches its Candidate: ${round.id}.`);
@@ -1199,7 +1202,7 @@ export class FileTaskWorkspacePreparer {
                         throw new Error(`Task Review candidate Project is missing: ${binding.projectId}.`);
                     }
                     const project = requireProject(this.store, binding.projectId);
-                    const identity = worktreeIdentity(taskSegment, round.id);
+                    const identity = worktreeIdentity(taskSegment, this.#reviewWorktreeName(round));
                     return {
                         projectId: binding.projectId,
                         directory: binding.directory,
@@ -1222,7 +1225,12 @@ export class FileTaskWorkspacePreparer {
             }
             const expectedEntries = new Map(frozenEntries.map((entry) => [entry.projectId, entry]));
             const existing = this.store.getReviewRoundWorkspace(task.id, round.id);
-            const reviewRoot = this.#reviewRoundWorkspaceRoot(task.id, round.id);
+            const reviewRoot = this.#reviewRoundWorkspaceRoot(task.id, round);
+            if (taskScope && existing === null) {
+                const reassigned = await this.#reassignTaskReviewWorkspace(task, round, reviewer, reviewRoot, frozenEntries);
+                if (reassigned !== null)
+                    return reassigned;
+            }
             const retained = new Map();
             const missing = new Set();
             const adopted = existing?.root === reviewRoot;
@@ -1251,7 +1259,7 @@ export class FileTaskWorkspacePreparer {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace metadata changed for ${round.id}/${entry.projectId}.`);
                     }
                     const project = requireProject(this.store, entry.projectId);
-                    const identity = worktreeIdentity(taskSegment, round.id);
+                    const identity = worktreeIdentity(taskSegment, this.#reviewWorktreeName(round));
                     const expectedPath = join(this.#projectContainer(project.name), identity.directory);
                     if (entry.path !== expectedPath || entry.branch !== identity.branch) {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound workspace managed identity mismatch for ${round.id}/${entry.projectId}.`);
@@ -1339,7 +1347,7 @@ export class FileTaskWorkspacePreparer {
                         repositoryPath: project.path,
                         container: this.#projectContainer(project.name),
                         taskSegment,
-                        roleName: round.id,
+                        roleName: this.#reviewWorktreeName(round),
                         baseRef: source.baseCommit
                     });
                     const entry = {
@@ -1404,10 +1412,14 @@ export class FileTaskWorkspacePreparer {
                 this.#registerWorkspace(stored);
                 return this.store.transaction((tx) => {
                     const currentRound = tx.getReviewRound(task.id, round.id);
-                    const currentItem = tx.getWorkItem(task.id, item.id);
+                    const currentItem = item === undefined ? null : tx.getWorkItem(task.id, item.id);
+                    const candidateChanged = taskScope
+                        ? currentRound === null
+                            || !isDeepStrictEqual(currentRound.taskCandidate, round.taskCandidate)
+                        : currentItem === null
+                            || !isDeepStrictEqual(currentItem.candidates.find(({ id }) => id === candidate.id), candidate);
                     if (currentRound === null || currentRound.status !== "pending"
-                        || currentItem === null
-                        || !isDeepStrictEqual(currentItem.candidates.find(({ id }) => id === candidate.id), candidate)) {
+                        || candidateChanged) {
                         throw new ReviewRoundWorkspaceEvidenceError(`ReviewRound changed while preparing its workspace: ${round.id}.`);
                     }
                     if (tx.getActiveAgentRun(task.id, reviewer.name) !== null) {
@@ -1441,7 +1453,7 @@ export class FileTaskWorkspacePreparer {
                 });
             }
             catch (error) {
-                await this.#discardUnadoptedEntries(task, taskSegment, prepared, round.id, existing === null, new Set([...retained.values()].map(({ entry }) => entry.path)));
+                await this.#discardUnadoptedEntries(task, taskSegment, prepared, this.#reviewWorktreeName(round), existing === null, new Set([...retained.values()].map(({ entry }) => entry.path)));
                 throw error;
             }
         }
@@ -1449,6 +1461,135 @@ export class FileTaskWorkspacePreparer {
             release();
         }
     }
+    /**
+     * Keep one physical workspace per Task Reviewer Role. A new semantic Round
+     * receives a new immutable ManagedWorkspace owner and frozen base record,
+     * while a clean, unmodified terminal workspace is reset in place so the
+     * provider-native Reviewer Session can continue at the same cwd.
+     */
+    async #reassignTaskReviewWorkspace(task, round, reviewer, reviewRoot, frozenEntries) {
+        const previous = this.store.listReviewRounds(task.id)
+            .filter((candidate) => (candidate.id !== round.id
+            && (candidate.scope ?? "work-item") === "task"
+            && candidate.reviewerRoleName === round.reviewerRoleName
+            && (candidate.status === "completed" || candidate.status === "failed")
+            && candidate.workspaceDisposition?.kind !== "removed"
+            && candidate.workspaceDisposition?.kind !== "reassigned"))
+            .sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
+            || left.id.localeCompare(right.id, undefined, { numeric: true })))
+            .at(-1);
+        if (previous === undefined)
+            return null;
+        const previousWorkspace = this.store.getReviewRoundWorkspace(task.id, previous.id);
+        if (previousWorkspace === null)
+            return null;
+        if (previous.workspace === undefined
+            || !isDeepStrictEqual(previous.workspace, previousWorkspace)
+            || previousWorkspace.root !== reviewRoot) {
+            throw new ReviewRoundWorkspaceEvidenceError(`Previous Task-final Review workspace cannot be continued: ${previous.id}.`);
+        }
+        if (this.store.getActiveAgentRun(task.id, reviewer.name) !== null) {
+            throw new ReviewRoundWorkspaceEvidenceError(`Reviewer Role has an active Run: ${task.id}/${reviewer.name}.`);
+        }
+        const expected = new Map(frozenEntries.map((entry) => [entry.projectId, entry]));
+        if (previousWorkspace.entries.length !== expected.size) {
+            throw new ReviewRoundWorkspaceEvidenceError(`Task-final Review Project scope changed for Reviewer ${reviewer.name}.`);
+        }
+        const nextEntries = [];
+        const reset = [];
+        for (const prior of previousWorkspace.entries) {
+            const next = expected.get(prior.projectId);
+            if (next === undefined
+                || prior.path !== next.path
+                || prior.branch !== next.branch
+                || prior.directory !== next.directory
+                || prior.access !== "write") {
+                throw new ReviewRoundWorkspaceEvidenceError(`Task-final Review workspace identity changed for ${reviewer.name}/${prior.projectId}.`);
+            }
+            const physical = await this.git.inspect(prior.path, "HEAD");
+            if (!await this.git.isClean(prior.path)
+                || !sameCommit(physical.baseCommit, prior.baseCommit)) {
+                throw new ReviewRoundWorkspaceEvidenceError(`Previous Task-final Review workspace contains retained diagnostics: `
+                    + `${previous.id}/${prior.projectId}; preserve or clean it before continuing the Reviewer Session.`);
+            }
+            nextEntries.push({
+                ...next,
+                path: prior.path,
+                branch: prior.branch,
+                baseRef: next.baseCommit,
+                baseCommit: next.baseCommit
+            });
+            if (!sameCommit(physical.baseCommit, next.baseCommit)) {
+                reset.push({
+                    path: prior.path,
+                    previousHead: physical.baseCommit,
+                    nextHead: next.baseCommit
+                });
+            }
+        }
+        const stored = createManagedWorkspace({
+            owner: { type: "review-round", taskId: task.id, reviewRoundId: round.id },
+            root: reviewRoot,
+            entries: nextEntries
+        }, this.now());
+        try {
+            for (const entry of reset) {
+                await this.git.resetWorktree({
+                    targetPath: entry.path,
+                    expectedHead: entry.previousHead,
+                    restoreHead: entry.nextHead
+                });
+            }
+            await ensureWorkspaceView(reviewRoot, nextEntries);
+            const reassigned = this.store.transaction((tx) => {
+                const currentPrevious = tx.getReviewRound(task.id, previous.id);
+                const currentRound = tx.getReviewRound(task.id, round.id);
+                const currentPreviousWorkspace = tx.getReviewRoundWorkspace(task.id, previous.id);
+                if (currentPrevious === null
+                    || currentPrevious.status !== previous.status
+                    || currentPrevious.workspaceDisposition?.kind === "removed"
+                    || currentPrevious.workspaceDisposition?.kind === "reassigned"
+                    || currentPreviousWorkspace === null
+                    || !sameManagedWorkspace(currentPreviousWorkspace, previousWorkspace)
+                    || currentRound === null
+                    || currentRound.status !== "pending"
+                    || currentRound.workspace !== undefined
+                    || !isDeepStrictEqual(currentRound.taskCandidate, round.taskCandidate)
+                    || tx.getReviewRoundWorkspace(task.id, round.id) !== null
+                    || tx.getActiveAgentRun(task.id, reviewer.name) !== null) {
+                    throw new ReviewRoundWorkspaceEvidenceError(`Task-final Review workspace changed before reassignment: ${previous.id}/${round.id}.`);
+                }
+                const latestReviewer = tx.getRole(task.id, reviewer.name);
+                if (latestReviewer === null || latestReviewer.workspace !== reviewRoot) {
+                    throw new ReviewRoundWorkspaceEvidenceError(`Reviewer Role workspace changed before reassignment: ${reviewer.name}.`);
+                }
+                tx.removeManagedWorkspace(previousWorkspace.owner);
+                tx.saveReviewRound(task.id, recordReviewWorkspaceDisposition(currentPrevious, "reassigned", this.now()));
+                tx.saveManagedWorkspace(stored);
+                tx.saveReviewRound(task.id, attachReviewRoundWorkspace(currentRound, stored));
+                return stored;
+            });
+            this.#registerWorkspace(reassigned);
+            return reassigned;
+        }
+        catch (error) {
+            for (const entry of [...reset].reverse()) {
+                try {
+                    await this.git.resetWorktree({
+                        targetPath: entry.path,
+                        expectedHead: entry.nextHead,
+                        restoreHead: entry.previousHead
+                    });
+                }
+                catch {
+                    // Keep the original failure; the durable owner still names the
+                    // previous Round and exposes any compensation problem for cleanup.
+                }
+            }
+            await ensureWorkspaceView(reviewRoot, previousWorkspace.entries);
+            throw error;
+        }
+    }
     async inspectReviewRoundWorkspace(taskId, reviewRoundId) {
         const task = requireTask(this.store, taskId);
         const round = this.store.getReviewRound(taskId, reviewRoundId);
@@ -1461,7 +1602,7 @@ export class FileTaskWorkspacePreparer {
         if (round.workspace !== undefined && !isDeepStrictEqual(round.workspace, workspace)) {
             throw new Error(`ReviewRound workspace record diverged: ${round.id}.`);
         }
-        return this.#inspectEntries(this.#taskSegment(task), round.id, workspace.entries);
+        return this.#inspectEntries(this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries);
     }
     async snapshotReviewRoundResult(taskId, reviewRoundId) {
         const round = this.store.getReviewRound(taskId, reviewRoundId);
@@ -1548,7 +1689,8 @@ export class FileTaskWorkspacePreparer {
         if (round.status !== "completed" && round.status !== "failed") {
             throw new Error(`ReviewRound must be terminal before cleanup: ${round.id}.`);
         }
-        if (round.workspaceDisposition?.kind === "removed")
+        if (round.workspaceDisposition?.kind === "removed"
+            || round.workspaceDisposition?.kind === "reassigned")
             return "missing";
         const workspace = this.store.getReviewRoundWorkspace(task.id, round.id);
         if (workspace === null || round.workspace === undefined) {
@@ -1562,7 +1704,7 @@ export class FileTaskWorkspacePreparer {
         for (const lane of round.executionGroup?.lanes ?? []) {
             assertWorkspaceSessionsRetirable(this.store, task.id, lane.roleName, this.now());
         }
-        if (await this.#inspectEntries(this.#taskSegment(task), managedWorktreeName(workspace.owner), workspace.entries) === "dirty")
+        if (await this.#inspectEntries(this.#taskSegment(task), this.#reviewWorktreeName(round), workspace.entries) === "dirty")
             return "dirty";
         let removed = false;
         for (const entry of workspace.entries) {
@@ -1571,7 +1713,7 @@ export class FileTaskWorkspacePreparer {
                 repositoryPath: project.path,
                 container: this.#projectContainer(project.name),
                 taskSegment: this.#taskSegment(task),
-                roleName: managedWorktreeName(workspace.owner),
+                roleName: this.#reviewWorktreeName(round),
                 deleteBranch: true
             });
             if (result === "dirty") {
@@ -2064,8 +2206,13 @@ export class FileTaskWorkspacePreparer {
     #workItemWorkspaceRoot(taskId, workItemId) {
         return join(resolveTaskRoot(this.home, this.store.getConfig().defaultWorkspace), safePathSegment(taskId), "work-items", safePathSegment(workItemId));
     }
-    #reviewRoundWorkspaceRoot(taskId, reviewRoundId) {
-        return join(resolveTaskRoot(this.home, this.store.getConfig().defaultWorkspace), safePathSegment(taskId), "reviews", safePathSegment(reviewRoundId));
+    #reviewRoundWorkspaceRoot(taskId, round) {
+        return join(resolveTaskRoot(this.home, this.store.getConfig().defaultWorkspace), safePathSegment(taskId), "reviews", safePathSegment(this.#reviewWorktreeName(round)));
+    }
+    #reviewWorktreeName(round) {
+        return (round.scope ?? "work-item") === "task"
+            ? `reviewer-${round.reviewerRoleName}`
+            : round.id;
     }
     #executionLaneWorkspaceRoot(taskId, groupId, laneId) {
         return join(resolveTaskRoot(this.home, this.store.getConfig().defaultWorkspace), safePathSegment(taskId), "execution-lanes", safePathSegment(groupId), safePathSegment(laneId));
@@ -2409,7 +2556,7 @@ function executionLaneLineage(store, task, executionGroupId, executionLaneId, hi
         const round = store.getReviewRound(task.id, hint.reviewRoundId);
         if (round === null)
             throw new Error(`ReviewRound not found: ${hint.reviewRoundId}.`);
-        return { purpose: "review", workItemId: round.workItemId, reviewRoundId: round.id };
+        return { purpose: "review", reviewRoundId: round.id };
     }
     // Prefer the active Run's exact WorkItem for this Lane; fall back to the
     // first queued WorkItem only when no active Run owns the Lane.
@@ -2430,7 +2577,7 @@ function executionLaneLineage(store, task, executionGroupId, executionLaneId, hi
     for (const round of store.listReviewRounds(task.id)) {
         if (round.executionGroup?.id === executionGroupId
             && round.executionGroup.lanes.some(({ id }) => id === executionLaneId)) {
-            return { purpose: "review", workItemId: round.workItemId, reviewRoundId: round.id };
+            return { purpose: "review", reviewRoundId: round.id };
         }
     }
     throw new Error(`Execution Lane lineage not found: ${task.id}/${executionGroupId}/${executionLaneId}.`);

package/dist/review/reviewRound.js

@@ -5,7 +5,7 @@ import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { assertExecutionGroupTransition, resetReviewExecutionLane, validateExecutionGroup } from "../execution/executionGroup.js";
 export function createReviewRound(id, taskId, workItemId, candidateId, reviewerRoleName, requestedBy, reviewBaseCommit, now, executionGroup) {
     return validateReviewRound({
-        schemaVersion: 4,
+        schemaVersion: 5,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
         workItemId: requireIdentity(workItemId, "Work Item id"),
@@ -18,14 +18,12 @@ export function createReviewRound(id, taskId, workItemId, candidateId, reviewerR
         createdAt: now.toISOString()
     });
 }
-export function createTaskReviewRound(id, taskId, workItemId, candidateId, reviewerRoleName, requestedBy, taskCandidate, now, taskFinalReviewContract, executionGroup) {
+export function createTaskReviewRound(id, taskId, reviewerRoleName, requestedBy, taskCandidate, now, taskFinalReviewContract, executionGroup) {
     const candidate = validateTaskReviewCandidate(taskCandidate);
     return validateReviewRound({
-        schemaVersion: 4,
+        schemaVersion: 5,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
-        workItemId: requireIdentity(workItemId, "Work Item id"),
-        candidateId: requireIdentity(candidateId, "Candidate id"),
         reviewerRoleName: requireIdentity(reviewerRoleName, "Reviewer Role"),
         reviewBaseCommit: candidate.projects[0].commit,
         scope: "task",
@@ -46,14 +44,12 @@ export function createTaskReviewRound(id, taskId, workItemId, candidateId, revie
  * diff so the Reviewer can prove equivalence instead of reloading every
  * first-round evidence.
  */
-export function createTaskDeltaReviewRound(id, taskId, workItemId, candidateId, reviewerRoleName, requestedBy, taskCandidate, deltaRecheck, now, taskFinalReviewContract, executionGroup) {
+export function createTaskDeltaReviewRound(id, taskId, reviewerRoleName, requestedBy, taskCandidate, deltaRecheck, now, taskFinalReviewContract, executionGroup) {
     const candidate = validateTaskReviewCandidate(taskCandidate);
     return validateReviewRound({
-        schemaVersion: 4,
+        schemaVersion: 5,
         id: requireIdentity(id, "ReviewRound id"),
         taskId: requireIdentity(taskId, "Task id"),
-        workItemId: requireIdentity(workItemId, "Work Item id"),
-        candidateId: requireIdentity(candidateId, "Candidate id"),
         reviewerRoleName: requireIdentity(reviewerRoleName, "Reviewer Role"),
         reviewBaseCommit: candidate.projects[0].commit,
         scope: "task",
@@ -157,8 +153,7 @@ export function retryTaskReviewRound(round) {
         schemaVersion: round.schemaVersion,
         id: round.id,
         taskId: round.taskId,
-        workItemId: round.workItemId,
-        candidateId: round.candidateId,
+        ...(round.legacyAnchor === undefined ? {} : { legacyAnchor: round.legacyAnchor }),
         reviewerRoleName: round.reviewerRoleName,
         reviewBaseCommit: round.reviewBaseCommit,
         scope: "task",
@@ -293,7 +288,9 @@ export function recordReviewWorkspaceDisposition(round, disposition, now) {
     if (round.workspace === undefined) {
         throw new Error(`ReviewRound has no managed workspace: ${round.id}.`);
     }
-    if (disposition !== "preserved" && disposition !== "removed") {
+    if (disposition !== "preserved"
+        && disposition !== "reassigned"
+        && disposition !== "removed") {
         throw new Error(`Review workspace disposition is invalid: ${String(disposition)}.`);
     }
     if (round.workspaceDisposition?.kind === disposition)
@@ -341,13 +338,9 @@ export function updateReviewExecutionGroup(round, executionGroup) {
     return validateReviewRound({ ...round, executionGroup });
 }
 export function validateReviewRound(round) {
-    if (round.schemaVersion !== 4)
-        throw new Error("ReviewRound must use schemaVersion 4.");
+    if (round.schemaVersion !== 5)
+        throw new Error("ReviewRound must use schemaVersion 5.");
     validateTaskRecordReference({ taskId: round.taskId, localId: round.id }, "reviewRound");
-    validateTaskRecordReference({ taskId: round.taskId, localId: round.workItemId }, "workItem");
-    if (!/^candidate-[1-9]\d*$/.test(round.candidateId)) {
-        throw new Error(`Candidate local id is invalid: ${round.candidateId}.`);
-    }
     requireIdentity(round.reviewerRoleName, "Reviewer Role");
     requireCommit(round.reviewBaseCommit, "Review base commit");
     const scope = round.scope ?? "work-item";
@@ -355,6 +348,18 @@ export function validateReviewRound(round) {
         throw new Error(`ReviewRound scope is invalid: ${String(round.scope)}.`);
     }
     if (scope === "task") {
+        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}.`);
         }
@@ -372,9 +377,19 @@ export function validateReviewRound(round) {
             }
         }
     }
-    else if (round.taskCandidate !== undefined
-        || round.taskFinalReviewContract !== undefined) {
-        throw new Error(`WorkItem ReviewRound cannot carry a Task candidate or contract: ${round.id}.`);
+    else {
+        if (round.workItemId === undefined || round.candidateId === undefined) {
+            throw new Error(`WorkItem ReviewRound requires a Candidate anchor: ${round.id}.`);
+        }
+        validateTaskRecordReference({ taskId: round.taskId, localId: round.workItemId }, "workItem");
+        if (!/^candidate-[1-9]\d*$/.test(round.candidateId)) {
+            throw new Error(`Candidate local id is invalid: ${round.candidateId}.`);
+        }
+        if (round.taskCandidate !== undefined
+            || round.taskFinalReviewContract !== undefined
+            || round.legacyAnchor !== undefined) {
+            throw new Error(`WorkItem ReviewRound cannot carry Task-final metadata: ${round.id}.`);
+        }
     }
     if (round.executionGroup !== undefined)
         validateReviewExecutionGroup(round.executionGroup, round);
@@ -428,6 +443,7 @@ export function validateReviewRound(round) {
             throw new Error("Only a terminal ReviewRound workspace can have a disposition.");
         }
         if (round.workspaceDisposition.kind !== "preserved"
+            && round.workspaceDisposition.kind !== "reassigned"
             && round.workspaceDisposition.kind !== "removed") {
             throw new Error("Review workspace disposition is invalid.");
         }
@@ -511,11 +527,12 @@ function validateReviewExecutionGroup(group, round) {
         ? "task-final-review"
         : "work-item";
     if (group.target.kind !== expectedKind
-        || group.target.taskId !== round.taskId
-        || group.target.candidateId !== round.candidateId) {
+        || group.target.taskId !== round.taskId) {
         throw new Error(`ReviewRound ExecutionGroup target is invalid: ${round.id}.`);
     }
-    if (expectedKind === "work-item" && group.target.workItemId !== round.workItemId) {
+    if (expectedKind === "work-item"
+        && (group.target.workItemId !== round.workItemId
+            || group.target.candidateId !== round.candidateId)) {
         throw new Error(`ReviewRound ExecutionGroup WorkItem target is invalid: ${round.id}.`);
     }
     return group;

package/dist/storage/migration/productionRegistry.js

@@ -20,6 +20,8 @@ const PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION = 3;
 const PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION = 4;
 const TASK_FROM_VERSION = 3;
 const TASK_TO_VERSION = 4;
+const TASK_INTENT_FROM_VERSION = 4;
+const TASK_INTENT_TO_VERSION = 5;
 const WORK_ITEM_FROM_VERSION = 6;
 const WORK_ITEM_TO_VERSION = 7;
 const WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION = 7;
@@ -45,6 +47,8 @@ const REVIEW_ROUND_FROM_VERSION = 2;
 const REVIEW_ROUND_TO_VERSION = 3;
 const REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION = 3;
 const REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION = 4;
+const REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION = 4;
+const REVIEW_ROUND_TASK_ANCHOR_TO_VERSION = 5;
 const ACTIVE_RUN_POINTER_FROM_VERSION = 1;
 const ACTIVE_RUN_POINTER_TO_VERSION = 2;
 const ACTIVE_RUN_POINTER_NAMESPACE_FROM_VERSION = 2;
@@ -136,6 +140,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(configV2Step())
         .registerCompatible(projectKnowledgeProposalsStep())
         .registerOfflineMigration(taskWorkspaceIdentityStep())
+        .registerOfflineMigration(taskIntentStep())
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_FROM_VERSION, WORK_ITEM_TO_VERSION, "workItems"))
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION, WORK_ITEM_GIT_SNAPSHOT_TO_VERSION, "workItems"))
         .registerOfflineMigration(workItemExecutionGroupHistoryStep())
@@ -146,6 +151,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(messageWakePolicyStep())
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_FROM_VERSION, REVIEW_ROUND_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION, REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION, "reviewRounds"))
+        .registerOfflineMigration(reviewRoundTaskAnchorStep())
         .registerOfflineMigration(recordFamilyStep("activeRunPointer", ACTIVE_RUN_POINTER_FROM_VERSION, ACTIVE_RUN_POINTER_TO_VERSION, "activeRuns"))
         .registerOfflineMigration(managedWorkspaceFamilyStep())
         .registerOfflineMigration(activeRunPointerNamespaceStep())
@@ -1546,6 +1552,65 @@ function recordFamilyStep(recordKind, fromVersion, toVersion, taskMapKey) {
         declaredEffects: []
     };
 }
+function reviewRoundTaskAnchorStep() {
+    return {
+        axis: "record",
+        recordKind: "reviewRound",
+        fromVersion: REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION,
+        toVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION,
+        preconditions: (snapshot) => requireRecordFamilyVersion(snapshot, "reviewRound", REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION, "reviewRounds"),
+        transform: migrateReviewRoundTaskAnchors,
+        declaredEffects: []
+    };
+}
+function migrateReviewRoundTaskAnchors(snapshot) {
+    requireRecordFamilyVersion(snapshot, "reviewRound", REVIEW_ROUND_TASK_ANCHOR_FROM_VERSION, "reviewRounds");
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            reviewRound: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        const rawRounds = aggregate.reviewRounds;
+        if (rawRounds === undefined) {
+            nextTasks[taskId] = { ...aggregate };
+            continue;
+        }
+        const rounds = asObject(rawRounds, `reviewRound map ${taskId}`);
+        const nextRounds = {};
+        for (const [roundId, rawRound] of Object.entries(rounds)) {
+            const round = asObject(rawRound, `reviewRound ${taskId}/${roundId}`);
+            if (round.scope !== "task") {
+                nextRounds[roundId] = {
+                    ...round,
+                    schemaVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION
+                };
+                continue;
+            }
+            const workItemId = requiredMigrationText(round.workItemId, `reviewRound ${taskId}/${roundId} WorkItem id`);
+            const candidateId = requiredMigrationText(round.candidateId, `reviewRound ${taskId}/${roundId} Candidate id`);
+            const { workItemId: _workItemId, candidateId: _candidateId, schemaVersion: _schemaVersion, ...retained } = round;
+            nextRounds[roundId] = {
+                ...retained,
+                schemaVersion: REVIEW_ROUND_TASK_ANCHOR_TO_VERSION,
+                legacyAnchor: { workItemId, candidateId }
+            };
+        }
+        nextTasks[taskId] = { ...aggregate, reviewRounds: nextRounds };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function agentRunContextProtocolStep() {
     return {
         axis: "record",
@@ -2747,6 +2812,79 @@ function migrateTaskV3ToV4(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/**
+ * Task v5 replaces the stored delivery topology switch with an optional,
+ * Project-defined intent. Historical topology is retained as audit context,
+ * but no current workflow decision reads it.
+ */
+function taskIntentStep() {
+    return {
+        axis: "record",
+        recordKind: "task",
+        fromVersion: TASK_INTENT_FROM_VERSION,
+        toVersion: TASK_INTENT_TO_VERSION,
+        preconditions: requireTaskV4Family,
+        transform: migrateTaskV4ToV5,
+        declaredEffects: []
+    };
+}
+function requireTaskV4Family(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.task !== TASK_INTENT_FROM_VERSION) {
+        throw new Error(`Record task migration requires manifest version ${TASK_INTENT_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (aggregate.task === undefined)
+            continue;
+        const record = asObject(aggregate.task, `Task ${taskId}`);
+        if (record.schemaVersion !== TASK_INTENT_FROM_VERSION) {
+            throw new Error(`Task ${taskId} must use schemaVersion ${TASK_INTENT_FROM_VERSION}.`);
+        }
+    }
+}
+function migrateTaskV4ToV5(snapshot) {
+    requireTaskV4Family(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...manifestVersions, task: TASK_INTENT_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const aggregate = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (aggregate.task === undefined) {
+            nextTasks[taskId] = { ...aggregate };
+            continue;
+        }
+        const task = asObject(aggregate.task, `Task ${taskId}`);
+        const { requireIntegration, schemaVersion: _schemaVersion, ...retained } = task;
+        const projectBindings = Array.isArray(task.projectBindings)
+            ? task.projectBindings
+            : [];
+        const legacyDeliveryPath = projectBindings.length === 0
+            ? undefined
+            : requireIntegration === true ? "integrated" : "direct";
+        nextTasks[taskId] = {
+            ...aggregate,
+            task: {
+                ...retained,
+                schemaVersion: TASK_INTENT_TO_VERSION,
+                ...(legacyDeliveryPath === undefined ? {} : { legacyDeliveryPath })
+            }
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 /**
  * A version bump is deliverable only when the shared planner resolves the full
  * adjacent path. This also covers target-only record families as explicit 0->1

package/dist/storage/sqliteStore.js

@@ -722,7 +722,7 @@ export class SqliteTaskStore {
                 id: task.id,
                 status: task.status,
                 projectBindings: task.projectBindings,
-                requireIntegration: task.requireIntegration
+                type: task.type
             },
             workItems: this.#sortById(this.#listPayload("work_items", "task_id = ?", [taskId]), (item) => item.id),
             changeSets: this.#sortById(this.#listPayload("change_sets", "task_id = ?", [taskId]), (changeSet) => changeSet.id),