@zq-silk/yui 0.8.9 → 0.10.0

package/dist/commands/taskCommands.js

@@ -36,13 +36,13 @@ import { mailboxHasWork as workMailboxHasWork, nextPendingBatch } from "../coord
 import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { blockingProviderContinuations, projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, taskDeliveryPath, updateTaskMetadata } from "../task/task.js";
+import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
-import { currentWorkItemCandidate, governingWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
+import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
 import { addExecutionLane, createExecutionGroup, resolveExecutionGroup, restartExecutionLane, updateExecutionLane } from "../execution/executionGroup.js";
 import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { classifyReviewRoundOutcome, isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
@@ -102,7 +102,7 @@ function storedTaskFinalReviewContractResolution(store, taskId) {
  * acceptance, and completion mutation must present the same verified
  * capability; shared review-config drift is intentionally irrelevant.
  */
-function taskFinalReviewContractForMutation(store, taskId, options, authorization = {}) {
+function taskFinalReviewContractForMutation(store, taskId, options) {
     const supplied = options.taskFinalReviewContract;
     if (supplied !== undefined) {
         validateTaskFinalReviewContract(supplied);
@@ -117,11 +117,12 @@ function taskFinalReviewContractForMutation(store, taskId, options, authorizatio
     }
     if (stored === undefined)
         return supplied;
-    if (supplied === undefined) {
-        if (authorization.allowStoredWithoutSupplied === true)
-            return stored;
-        throw usageError(`Task final-review contract is missing for ${taskId}.`);
-    }
+    // Historical exact contracts now express only a durable Reviewer policy.
+    // The persisted contract remains the audit authority, but ordinary
+    // protocol/storage-compatible CLIs may continue the Task without presenting
+    // a release-bound capability on every mutation.
+    if (supplied === undefined)
+        return stored;
     if (!sameTaskFinalReviewContract(stored, supplied)) {
         throw usageError(`Task final-review contract control-plane digest mismatch for ${taskId}.`);
     }
@@ -168,18 +169,10 @@ export function preflightTaskCompletion(taskId, store, options = {}, request = {
         throw usageError(`Task is archived: ${task.id}.`);
     if (task.status !== "active")
         throw usageError(`Task is not active: ${task.id}.`);
-    // Resolve and authenticate the durable Task-local gate before any remote
-    // fetch or Integration write.  All checks below mirror the transactional
-    // completion path, which remains the final CAS fence after reconciliation.
-    // A human/global Operator cannot present the exact managed Leader contract.
-    // For the explicit published-tree path only, let that caller authenticate
-    // the stored contract far enough to persist an exact authorization fact.
-    // The same command must return before any contract-governed completion
-    // mutation; the exact Leader later consumes the authorization with the real
-    // contract capability.
-    const authorizingPublishedTree = request.acceptedPublishedTreePublicationId !== undefined
-        && actor !== "leader";
-    const taskFinalReviewContract = taskFinalReviewContractForMutation(store, task.id, options, { allowStoredWithoutSupplied: authorizingPublishedTree });
+    // Resolve the durable Task-local Reviewer policy before any remote fetch or
+    // Integration write. Historical control-plane identity is audit evidence,
+    // not a capability that every compatible CLI must reproduce.
+    const taskFinalReviewContract = taskFinalReviewContractForMutation(store, task.id, options);
     const activeTaskReview = store.listReviewRounds(task.id).some((round) => ((round.scope ?? "work-item") === "task"
         && (round.status === "pending" || round.status === "running")));
     // Issue 06: one shared readiness projection enumerates every blocker.
@@ -367,13 +360,12 @@ function taskProjectCommand(args, store, options) {
 }
 function updateTaskCommand(args, store, options) {
     const optionNames = new Set([
-        "--title", "--description", "--priority", "--tags", "--due-at", "--delivery"
+        "--title", "--type", "--description", "--priority", "--tags", "--due-at"
     ]);
     const flagOptions = new Set([
-        "--clear-description", "--clear-priority", "--clear-tags", "--clear-due-at",
-        "--require-integration"
+        "--clear-type", "--clear-description", "--clear-priority", "--clear-tags", "--clear-due-at"
     ]);
-    const usage = "Task update usage: yui task update <id> [--title <text>] [--description <text>|--clear-description] [--priority <low|medium|high|urgent>|--clear-priority] [--tags <comma-separated>|--clear-tags] [--due-at <RFC3339>|--clear-due-at] [--delivery <direct|integrated>] [--require-integration].";
+    const usage = "Task update usage: yui task update <id> [--title <text>] [--type <project-defined-type>|--clear-type] [--description <text>|--clear-description] [--priority <low|medium|high|urgent>|--clear-priority] [--tags <comma-separated>|--clear-tags] [--due-at <RFC3339>|--clear-due-at].";
     const parsed = parseTail(args, optionNames, usage, flagOptions);
     exactPositionals(parsed.positionals, 1, usage);
     if (parsed.options.size === 0)
@@ -397,44 +389,16 @@ function updateTaskCommand(args, store, options) {
     const tags = parsed.options.has("--tags")
         ? parseTaskTags(requiredOption(parsed.options, "--tags"))
         : undefined;
-    const requestedDelivery = parsed.options.has("--delivery")
-        ? parseTaskDelivery(requiredOption(parsed.options, "--delivery"))
-        : undefined;
-    if (requestedDelivery === "direct" && parsed.options.has("--require-integration")) {
-        throw usageError("--delivery direct conflicts with --require-integration.", usage);
-    }
-    const enableIntegration = requestedDelivery === "integrated"
-        || parsed.options.has("--require-integration");
     const now = clock(options);
     const result = store.transaction((tx) => {
         const current = requireTask(tx, parsed.positionals[0]);
         if (current.status === "archived")
             throw usageError(`Task is archived: ${current.id}.`);
-        if ((requestedDelivery !== undefined || parsed.options.has("--require-integration"))
-            && current.projectBindings.length === 0) {
-            throw usageError(`Task ${current.id} has no Project; delivery selection is not applicable.`);
-        }
-        if (requestedDelivery === "direct" && current.requireIntegration === true) {
-            throw usageError(`Task ${current.id} already uses integrated delivery and cannot be downgraded to direct.`);
-        }
-        if (enableIntegration && current.status === "completed") {
-            throw usageError(`Task ${current.id} is completed; use task reopen before enabling integration evidence.`);
-        }
-        if (enableIntegration && current.requireIntegration !== true) {
-            assertTaskDeliveryPromotionEligible(tx, current, options.directTaskMainSnapshot);
-        }
-        if (parsed.options.size === 1
-            && enableIntegration
-            && current.requireIntegration === true) {
-            return { task: current, integrationState: "already-enabled" };
-        }
-        if (parsed.options.size === 1
-            && requestedDelivery === "direct"
-            && taskDeliveryPath(current) === "direct") {
-            return { task: current, integrationState: "already-direct" };
-        }
         const updated = updateTaskMetadata(current, {
             ...(parsed.options.has("--title") ? { title: requiredOption(parsed.options, "--title") } : {}),
+            ...(parsed.options.has("--type")
+                ? { type: requiredOption(parsed.options, "--type") }
+                : parsed.options.has("--clear-type") ? { type: null } : {}),
             ...(parsed.options.has("--description")
                 ? { description: requiredOption(parsed.options, "--description") }
                 : parsed.options.has("--clear-description") ? { description: null } : {}),
@@ -446,94 +410,18 @@ function updateTaskCommand(args, store, options) {
                 : { tags }),
             ...(dueAt === undefined
                 ? parsed.options.has("--clear-due-at") ? { dueAt: null } : {}
-                : { dueAt }),
-            ...(enableIntegration ? { requireIntegration: true } : {})
+                : { dueAt })
         }, now);
         tx.saveTask(updated);
         recordTaskEvent(tx, updated.id, "task.updated", {
             status: updated.status,
-            ...(requestedDelivery === undefined && !parsed.options.has("--require-integration")
-                ? {}
-                : {
-                    completionEvidence: enableIntegration
-                        ? "integration-required"
-                        : "direct",
-                    deliveryPath: taskDeliveryPath(updated)
-                })
+            ...(updated.type === undefined ? {} : { taskType: updated.type })
         }, now);
         enqueueWork(tx, taskMailbox(updated.id), "task-updated", now, [taskRef(updated.id)]);
-        return {
-            task: updated,
-            integrationState: enableIntegration
-                ? "enabled"
-                : requestedDelivery === "direct"
-                    ? "direct"
-                    : "unchanged"
-        };
+        return updated;
     });
-    if (result.integrationState !== "already-enabled"
-        && result.integrationState !== "already-direct") {
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-    }
-    return result.integrationState === "enabled"
-        ? `Updated task ${result.task.id}\nDelivery: integrated (WorkItem, ChangeSet, and committed Integration required)\n`
-        : result.integrationState === "already-enabled"
-            ? `Task ${result.task.id} already uses integrated delivery\n`
-            : result.integrationState === "already-direct"
-                ? `Task ${result.task.id} already uses direct delivery\n`
-                : result.integrationState === "direct"
-                    ? `Updated task ${result.task.id}\nDelivery: direct\n`
-                    : `Updated task ${result.task.id}\n`;
-}
-function assertTaskDeliveryPromotionEligible(store, task, snapshot) {
-    const evidence = [
-        ...store.listWorkItems(task.id).map(({ id }) => `WorkItem ${id}`),
-        ...store.listChangeSets(task.id).map(({ id }) => `ChangeSet ${id}`),
-        ...store.listIntegrationAttempts(task.id).map(({ id }) => `IntegrationAttempt ${id}`),
-        ...store.listReviewRounds(task.id).map(({ id }) => `ReviewRound ${id}`)
-    ];
-    if (evidence.length > 0) {
-        throw usageError(`Task ${task.id} cannot promote to integrated delivery after delivery evidence exists: `
-            + `${evidence.join(", ")}. Create an integrated replacement Task or keep the current direct contract.`);
-    }
-    if (task.status !== "draft" && task.status !== "active") {
-        throw usageError(`Task ${task.id} must be Draft or Active to promote delivery; current status is ${task.status}.`);
-    }
-    const workspace = store.getTaskWorkspace(task.id);
-    if (task.status === "draft" && workspace === null)
-        return;
-    if (snapshot === undefined) {
-        throw usageError(`Task ${task.id} delivery promotion requires a CLI-verified clean Task-main snapshot.`);
-    }
-    if (workspace === null
-        || workspace.owner.type !== "task"
-        || workspace.owner.taskId !== task.id) {
-        throw usageError(`Task has no authoritative main workspace: ${task.id}.`);
-    }
-    const snapshotIds = snapshot.schemaVersion === 1 && Array.isArray(snapshot.projects)
-        ? snapshot.projects.map(({ projectId }) => projectId)
-        : [];
-    if (snapshotIds.length !== task.projectBindings.length
-        || new Set(snapshotIds).size !== snapshotIds.length) {
-        throw usageError(`Task-main promotion snapshot does not match bound Projects: ${task.id}.`);
-    }
-    for (const binding of task.projectBindings) {
-        const project = snapshot.projects.find(({ projectId }) => projectId === binding.projectId);
-        const entry = workspace.entries.find(({ projectId }) => projectId === binding.projectId);
-        if (project === undefined
-            || entry === undefined
-            || entry.access !== "write"
-            || project.directory !== entry.directory
-            || project.branch !== entry.branch
-            || project.baseCommit !== entry.baseCommit) {
-            throw usageError(`Task-main promotion snapshot changed before mutation: ${task.id}/${binding.projectId}.`);
-        }
-        if (project.headCommit !== project.baseCommit) {
-            throw usageError(`Task ${task.id} main already advanced for Project ${binding.projectId}; `
-                + "cannot promote without losing ChangeSet provenance. Create an integrated replacement "
-                + "Task or keep the current direct contract.");
-        }
-    }
+    notifyMailbox(options.runtime, taskMailbox(result.id), result.id);
+    return `Updated task ${result.id}\n`;
 }
 /** Compatibility helper for call sites that cannot yet handle foreground enter. */
 export function runTaskOutputCommand(args, store, options = {}) {
@@ -569,25 +457,22 @@ function createTaskCommand(args, store, options) {
     const now = clock(options);
     const created = store.transaction((tx) => createTaskAggregate(tx, parsed.title, {
         projectBindings: parsed.projectBindings,
-        ...(parsed.requireIntegration ? { requireIntegration: true } : {})
+        ...(parsed.type === undefined ? {} : { type: parsed.type })
     }, now, parsed.defaultProjectIds));
     notifyMailbox(options.runtime, taskMailbox(created.task.id), created.task.id);
     return output(`Created Draft task ${created.task.id}: ${created.task.title}\n`
         + `Assigned role: ${created.leader.name}\n`
-        + `Delivery: ${taskDeliveryPath(created.task)}\n`
-        + (created.task.requireIntegration
-            ? "Completion: WorkItem, ChangeSet, and committed Integration required\n"
-            : created.task.projectBindings.length > 0
-                ? "Completion: clean committed Task main required; no WorkItem, ChangeSet, IntegrationAttempt, or managed ReviewRound required\n"
-                : "Completion: no Project delivery evidence required\n"), {
+        + `Type: ${created.task.type ?? "unspecified"}\n`
+        + (created.task.projectBindings.length > 0
+            ? "Execution: Leader decides whether independent WorkItems are warranted\n"
+            : "Execution: no Project delivery evidence required\n"), {
         task: created.task,
-        leader: created.leader,
-        deliveryPath: taskDeliveryPath(created.task)
+        leader: created.leader
     });
 }
 function parseTaskCreation(args, store) {
-    const usage = "Task create usage: yui task create <title> [--project <project> ...] [--base <project>=<ref> ...] [--delivery <direct|integrated>] [--require-integration].";
-    const parsed = parseMultiValueTail(args, new Set(["--delivery"]), new Set(["--project", "--base"]), usage, new Set(["--require-integration"]));
+    const usage = "Task create usage: yui task create <title> [--type <project-defined-type>] [--project <project> ...] [--base <project>=<ref> ...].";
+    const parsed = parseMultiValueTail(args, new Set(["--type"]), new Set(["--project", "--base"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const projectReferences = parsed.multiOptions.get("--project") ?? [];
     const baseOptions = parsed.multiOptions.get("--base") ?? [];
@@ -603,16 +488,6 @@ function parseTaskCreation(args, store) {
     if (new Set(projects.map(({ id }) => id)).size !== projects.length) {
         throw usageError("A Task cannot bind the same Project more than once.");
     }
-    const requestedDelivery = parsed.options.has("--delivery")
-        ? parseTaskDelivery(requiredOption(parsed.options, "--delivery"))
-        : undefined;
-    if ((requestedDelivery !== undefined || parsed.options.has("--require-integration"))
-        && projects.length === 0) {
-        throw usageError("Delivery selection requires at least one --project.", usage);
-    }
-    if (requestedDelivery === "direct" && parsed.options.has("--require-integration")) {
-        throw usageError("--delivery direct conflicts with --require-integration.", usage);
-    }
     const bases = new Map();
     for (const option of baseOptions) {
         const separator = option.indexOf("=");
@@ -637,14 +512,15 @@ function parseTaskCreation(args, store) {
         .map(({ id }) => id);
     return {
         title: parsed.positionals[0],
+        ...(parsed.options.has("--type")
+            ? { type: requiredOption(parsed.options, "--type") }
+            : {}),
         projectBindings: projects.map((project) => ({
             projectId: project.id,
             directory: project.name,
             baseRef: bases.get(project.id) ?? project.developmentBranch
         })),
-        defaultProjectIds,
-        requireIntegration: requestedDelivery === "integrated"
-            || parsed.options.has("--require-integration")
+        defaultProjectIds
     };
 }
 function createTaskAggregate(store, title, metadata, now, defaultProjectIds = []) {
@@ -654,7 +530,7 @@ function createTaskAggregate(store, title, metadata, now, defaultProjectIds = []
     store.saveRole(task.id, leader);
     recordTaskEvent(store, task.id, "task.created", {
         status: task.status,
-        deliveryPath: taskDeliveryPath(task),
+        ...(task.type === undefined ? {} : { taskType: task.type }),
         ...(defaultProjectIds.length === 0
             ? {}
             : { defaultProjectIds: defaultProjectIds.join(",") })
@@ -703,16 +579,14 @@ function showTaskCommand(args, store) {
         `Task: ${task.id}`,
         `Title: ${task.title}`,
         `Status: ${task.status}`,
-        `Delivery: ${taskDeliveryPath(task)}`,
+        `Type: ${task.type ?? "unspecified"}`,
         ...(task.description === undefined ? [] : [`Description: ${task.description}`]),
         ...(task.priority === undefined ? [] : [`Priority: ${task.priority}`]),
         ...(task.tags === undefined ? [] : [`Tags: ${task.tags.join(", ")}`]),
         ...(task.dueAt === undefined ? [] : [`Due: ${presentTime(task.dueAt, timeZone)}`]),
-        `Completion evidence: ${task.requireIntegration === true
-            ? "WorkItem, ChangeSet, and committed Integration required"
-            : task.projectBindings.length > 0
-                ? "clean committed Task main required"
-                : "no Project evidence required"}`,
+        `Execution topology: ${task.projectBindings.length > 0
+            ? "Leader-owned; WorkItems are optional independent delivery units"
+            : "no Project delivery evidence required"}`,
         ...(task.completedAt === undefined ? [] : [`Completed: ${presentTime(task.completedAt, timeZone)}`]),
         ...(task.completedBy === undefined ? [] : [`Completed by: ${task.completedBy}`]),
         ...(task.completionSummary === undefined ? [] : [`Completion summary: ${task.completionSummary}`]),
@@ -741,12 +615,7 @@ function showTaskCommand(args, store) {
         `Created: ${presentTime(task.createdAt, timeZone)}`,
         `Updated: ${presentTime(task.updatedAt, timeZone)}`
     ].join("\n").concat("\n");
-    return output(rendered, {
-        task,
-        deliveryPath: taskDeliveryPath(task),
-        counts,
-        hasBrief: brief !== null
-    });
+    return output(rendered, { task, counts, hasBrief: brief !== null });
 }
 function activateTaskCommand(args, store, options) {
     exactPositionals(args, 1, "Task activate usage: yui task activate <task>.");
@@ -860,7 +729,7 @@ function completeTaskCommand(args, store, options) {
             terminalizedLeaderRun = true;
         }
         // A final (Task-scoped) review is the Task delivery policy: it reviews the
-        // complete integrated Task heads, not a single WorkItem Candidate. If the
+        // complete frozen Task heads, not a single WorkItem Candidate. If the
         // review config requests a final review, create the Task ReviewRound here
         // and return it for dispatch instead of completing the Task.
         const pendingFinalReviewIds = new Set(tx.listReviewRounds(task.id)
@@ -915,7 +784,6 @@ function completeTaskCommand(args, store, options) {
         recordTaskEvent(tx, task.id, "task.completed", {
             by: actor,
             summary,
-            deliveryPath: taskDeliveryPath(task),
             ...(actualTaskCandidate === undefined
                 ? {}
                 : {
@@ -2518,14 +2386,16 @@ function executionTargetForWorkItem(taskId, workItemId, revision, item, workspac
 }
 function executionTargetForReviewRound(task, round, item, candidate) {
     const taskScope = (round.scope ?? "work-item") === "task";
+    if (!taskScope && (item === undefined || candidate === undefined)) {
+        throw dataError(`WorkItem ReviewRound target is missing its Candidate: ${round.id}.`);
+    }
     const projects = taskScope
         ? round.taskCandidate?.projects ?? []
         : candidate.gitSnapshot?.projects ?? [];
     const fingerprint = JSON.stringify({
         taskId: task.id,
         reviewRoundId: round.id,
-        workItemId: item.id,
-        candidateId: candidate.id,
+        ...(taskScope ? {} : { workItemId: item.id, candidateId: candidate.id }),
         scope: taskScope ? "task" : "work-item",
         projects,
         contractDigest: round.taskFinalReviewContract?.digest
@@ -2534,9 +2404,10 @@ function executionTargetForReviewRound(task, round, item, candidate) {
         schemaVersion: 1,
         kind: taskScope ? "task-final-review" : "work-item",
         taskId: task.id,
-        workItemId: item.id,
-        candidateId: candidate.id,
-        revision: candidate.workItemRevision,
+        ...(taskScope ? {} : { workItemId: item.id, candidateId: candidate.id }),
+        // A Task-final ReviewRound is itself the immutable semantic target. Runs
+        // retry that same revision; a changed frozen Task creates a new Round.
+        revision: taskScope ? 1 : candidate.workItemRevision,
         projects,
         ...(round.taskFinalReviewContract === undefined
             ? {}
@@ -3096,7 +2967,7 @@ function resolveReviewExecutionGroup(args, store, options) {
             reconcileReviewFindingsAfterReview(tx, task.id, terminal.id, now);
         }
         enqueueWork(tx, leaderMailbox(task.id), "review-group-resolved", now, [
-            workItemRef(task.id, round.workItemId)
+            ...(round.workItemId === undefined ? [] : [workItemRef(task.id, round.workItemId)])
         ]);
         return terminal;
     });
@@ -3323,7 +3194,6 @@ function requestTaskReviewRound(args, store, options) {
         if (producerCollision !== null) {
             throw usageError(producerCollision);
         }
-        const anchor = latestTaskReviewAnchor(tx, task);
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id))
             .filter((entry) => (entry.scope ?? "work-item") === "task");
         const exact = taskRounds.filter((entry) => (entry.reviewerRoleName === reviewerRoleName
@@ -3441,11 +3311,11 @@ function requestTaskReviewRound(args, store, options) {
             deltaRecord = validateDeltaRecheckRequest(tx, task.id, reviewerRoleName, provenance.candidate, options.deltaRecheckPreflight);
         }
         let created = deltaRecord === undefined
-            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, anchor.item.id, anchor.candidate.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract)
-            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, anchor.item.id, anchor.candidate.id, reviewerRoleName, "leader", provenance.candidate, deltaRecord, now, taskFinalContract);
+            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract)
+            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, deltaRecord, now, taskFinalContract);
         let group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
-            target: executionTargetForReviewRound(task, created, anchor.item, anchor.candidate),
+            target: executionTargetForReviewRound(task, created),
             strategy,
             lanes: laneRoles.map((roleName) => ({ roleName, reviewRoundId: created.id }))
         }, now);
@@ -3471,8 +3341,6 @@ function requestTaskReviewRound(args, store, options) {
         }
         recordTaskEvent(tx, task.id, "review.task-final-requested", {
             reviewRoundId: created.id,
-            workItemId: created.workItemId,
-            candidateId: created.candidateId,
             reviewerRoleName: created.reviewerRoleName,
             requestedBy: created.requestedBy,
             taskCandidate: JSON.stringify(created.taskCandidate),
@@ -3532,14 +3400,10 @@ function forceFreshTaskReviewRound(args, store, options) {
             if (replacement === null
                 || replacement.id === source.id
                 || (replacement.scope ?? "work-item") !== "task"
-                || replacement.workItemId !== source.workItemId
-                || replacement.candidateId !== source.candidateId
                 || replacement.reviewerRoleName !== source.reviewerRoleName
                 || replacement.deltaRecheck !== undefined
                 || !sameTaskFinalReviewContract(replacement.taskFinalReviewContract, source.taskFinalReviewContract)
                 || !isSameTaskReviewCandidate(replacement.taskCandidate, source.taskCandidate)
-                || replacementEvent.payload.workItemId !== replacement.workItemId
-                || replacementEvent.payload.candidateId !== replacement.candidateId
                 || replacementEvent.payload.reviewerRoleName !== replacement.reviewerRoleName
                 || replacementEvent.payload.taskCandidate !== JSON.stringify(replacement.taskCandidate)) {
                 throw dataError(`Force-fresh audit for ${source.id} does not match its replacement Round.`);
@@ -3564,12 +3428,6 @@ function forceFreshTaskReviewRound(args, store, options) {
                 || source.executionGroup.lanes[0].roleName !== source.reviewerRoleName)) {
             throw usageError(`ReviewRound ${source.id} is not a single-Reviewer full Review; force-fresh is refused.`);
         }
-        const item = tx.getWorkItem(task.id, source.workItemId);
-        const candidate = item?.candidates.find(({ id }) => id === source.candidateId);
-        if (item === null || item === undefined || candidate === undefined) {
-            throw dataError(`Final Review anchor Candidate is no longer available: `
-                + `${source.workItemId}/${source.candidateId}.`);
-        }
         const provenance = taskReviewProvenance(tx, task, options);
         if (!isSameTaskReviewCandidate(source.taskCandidate, provenance.candidate)) {
             throw usageError(`Final ReviewRound ${source.id} freezes a candidate that is no longer the current Task candidate.`);
@@ -3598,10 +3456,10 @@ function forceFreshTaskReviewRound(args, store, options) {
             reviewer = createTaskRole(tx, task, source.reviewerRoleName, undefined, now, source.reviewerRoleName);
             tx.saveRole(task.id, reviewer);
         }
-        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.workItemId, source.candidateId, source.reviewerRoleName, "leader", source.taskCandidate, now, taskFinalContract);
+        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.reviewerRoleName, "leader", source.taskCandidate, now, taskFinalContract);
         const group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
-            target: executionTargetForReviewRound(task, created, item, candidate),
+            target: executionTargetForReviewRound(task, created),
             strategy: { mode: "fixed", count: 1 },
             lanes: [{ roleName: reviewer.name, reviewRoundId: created.id }]
         }, now);
@@ -3611,8 +3469,6 @@ function forceFreshTaskReviewRound(args, store, options) {
             sourceReviewRoundId: source.id,
             ...(source.reviewerRunId === undefined ? {} : { sourceReviewerRunId: source.reviewerRunId }),
             reviewRoundId: created.id,
-            workItemId: created.workItemId,
-            candidateId: created.candidateId,
             reviewerRoleName: created.reviewerRoleName,
             taskCandidate: JSON.stringify(created.taskCandidate),
             reason: "source-round-terminal-without-semantic-review",
@@ -3763,15 +3619,9 @@ function retryFailedTaskReviewRound(args, store, options) {
         if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)) {
             throw usageError(`Task final-review contract does not match ReviewRound ${round.id}.`);
         }
-        // Re-read the exact current integrated heads and all ChangeSet-linked
-        // WorkItem producer roles before touching any record. A moved head,
-        // missing anchor, malformed provenance, or reviewer collision fails closed
-        // with the old failed Round byte-for-byte unchanged.
-        const item = tx.getWorkItem(task.id, round.workItemId);
-        if (item === null || item.candidates.every(({ id }) => id !== round.candidateId)) {
-            throw dataError(`Final Review anchor Candidate is no longer available: `
-                + `${round.workItemId}/${round.candidateId}.`);
-        }
+        // Re-read the exact current Task heads and producer roles before touching
+        // any record. A moved head or reviewer collision fails closed with the old
+        // failed Round byte-for-byte unchanged.
         const provenance = taskReviewProvenance(tx, task, options);
         if (!isSameTaskReviewCandidate(round.taskCandidate, provenance.candidate)) {
             throw usageError(`Final ReviewRound ${round.id} freezes a candidate that is no longer the current Task candidate.`);
@@ -3834,9 +3684,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         const resetRound = retryTaskReviewRound(round);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "review.task-final-retried", {
-            reviewRoundId: round.id,
-            workItemId: round.workItemId,
-            candidateId: round.candidateId
+            reviewRoundId: round.id
         }, now);
         return { round: resetRound, created: true };
     });
@@ -4026,7 +3874,7 @@ function listRuns(args, store, options) {
  * on. This is deliberately narrower than retry: it cannot manufacture a
  * review or fail an arbitrary Round, and every identity/mailbox fence is
  * checked before the old Round changes. The next normal Task completion then
- * creates one fresh Round over the newer integrated heads.
+ * creates one fresh Round over the newer frozen Task heads.
  */
 function settleStaleFinalReviewRun(args, store, options) {
     exactPositionals(args, 1, "Task run settle usage: yui task run settle <task>/<run>.");
@@ -4065,14 +3913,6 @@ function settleStaleFinalReviewRun(args, store, options) {
         if (validation.disposition !== "applied" || validation.round === null) {
             throw usageError(`Review Run ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
         }
-        const item = tx.getWorkItem(task.id, round.workItemId);
-        if (item === null) {
-            throw dataError(`Work item not found for run ${run.id}: ${round.workItemId}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-        if (candidate === undefined) {
-            throw dataError(`ReviewRound Candidate not found: ${round.candidateId}.`);
-        }
         const activeReviewerRun = tx.listAgentRuns(task.id).find((entry) => (entry.purpose === "review" && entry.status === "active"));
         const activeRoleRun = tx.getActiveAgentRun(task.id, round.reviewerRoleName);
         if (activeReviewerRun !== undefined || activeRoleRun !== null) {
@@ -4159,7 +3999,6 @@ function settleStaleFinalReviewRun(args, store, options) {
         recordTaskEvent(tx, task.id, "run.review-stale-settled", {
             runId: run.id,
             reviewRoundId: round.id,
-            candidateId: candidate.id,
             previousTaskCandidate: JSON.stringify(round.taskCandidate),
             currentTaskCandidate: JSON.stringify(currentTaskCandidate)
         }, now);
@@ -4364,7 +4203,7 @@ function taskReviewProducerCollision(provenance, reviewerRoleName) {
         .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
     return workItemIds.length === 0
         ? null
-        : `Reviewer Role must be separate from every integrated Candidate producer: `
+        : `Reviewer Role must be separate from every WorkItem Candidate producer: `
             + `${reviewerRoleName} (${workItemIds.join(", ")}).`;
 }
 /**
@@ -4381,7 +4220,7 @@ function taskReviewProducerCollision(provenance, reviewerRoleName) {
 function taskReviewProvenance(store, task, options, expected) {
     const candidate = actualTaskReviewCandidateForMutation(store, task, options);
     if (expected !== undefined && !isSameTaskReviewCandidate(candidate, expected)) {
-        throw usageError(`Task-final ReviewRound frozen integrated heads changed for its Project set.`);
+        throw usageError(`Task-final ReviewRound frozen Task heads changed for its Project set.`);
     }
     const producerRoles = new Set();
     const producerWorkItemIds = new Map();
@@ -4484,32 +4323,18 @@ function assertNoConflictingTaskReviewRound(rounds, reusableRoundIds = []) {
         throw usageError(`Another active Task-final ReviewRound already exists: ${conflicting.id}/${conflicting.reviewerRoleName}.`);
     }
 }
-function latestTaskReviewAnchor(store, task) {
-    const item = [...store.listWorkItems(task.id)]
-        .filter(({ candidates }) => candidates.length > 0)
-        .sort((left, right) => (left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id)))
-        .at(-1);
-    if (item === undefined) {
-        throw usageError(`Task ${task.id} has no WorkItem Candidate to anchor its final Review.`);
-    }
-    const candidate = item.candidates.at(-1);
-    if (candidate === undefined) {
-        throw usageError(`Task ${task.id} has no WorkItem Candidate to anchor its final Review.`);
-    }
-    return { item, candidate };
-}
 /**
  * Queues a Task-scoped final ReviewRound. The reviewer Role must be separate
  * from the Candidate producer. Returns the round (pending or failed) so the
  * caller can surface it to the CLI for workspace preparation and dispatch.
  */
-function queueTaskReviewRound(store, task, item, candidateId, config, taskCandidate, options, now, requestedBy = "policy", taskFinalContract) {
+function queueTaskReviewRound(store, task, config, taskCandidate, options, now, requestedBy = "policy", taskFinalContract) {
     assertNoConflictingTaskReviewRound(store.listReviewRounds(task.id));
     const provenance = taskReviewProvenance(store, task, options, taskCandidate);
     if (!isSameTaskReviewCandidate(provenance.candidate, taskCandidate)) {
-        throw usageError(`Task-final ReviewRound integrated heads changed before queueing.`);
+        throw usageError(`Task-final ReviewRound frozen Task heads changed before queueing.`);
     }
-    const pending = createTaskReviewRound(store.nextReviewRoundId(task.id), task.id, item.id, candidateId, config.roleName, requestedBy, taskCandidate, now, taskFinalContract);
+    const pending = createTaskReviewRound(store.nextReviewRoundId(task.id), task.id, config.roleName, requestedBy, taskCandidate, now, taskFinalContract);
     store.saveReviewRound(task.id, pending);
     const producerCollision = taskReviewProducerCollision(provenance, config.roleName);
     if (producerCollision !== null) {
@@ -4543,36 +4368,17 @@ function queueTaskReviewRound(store, task, item, candidateId, config, taskCandid
  * (or a failed round is surfaced as a blocker).
  */
 function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
-    // Any Task-final ReviewRound is durable completion evidence/obligation.
-    // Once one exists, later changes to the mutable global review config cannot
-    // weaken the requirement or change its reviewer. Before the first such
-    // Round, the current global `final` config establishes the initial Round
-    // only for integrated delivery.
+    // A Leader-requested ReviewRound is evidence, not policy. Only an explicit
+    // immutable Task contract creates a durable completion obligation; optional
+    // historical Rounds never cause completion to manufacture another Round for
+    // a later head.
+    if (taskFinalContract === undefined || task.projectBindings.length === 0)
+        return null;
     const taskRounds = reviewRoundsByIdentity(store.listReviewRounds(task.id))
         .filter((round) => ((round.scope ?? "work-item") === "task"
-        && (taskFinalContract === undefined || sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract))));
+        && sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)));
     const establishedRound = taskRounds.at(-1);
-    let config;
-    if (taskFinalContract !== undefined) {
-        config = taskFinalReviewConfig(taskFinalContract);
-    }
-    else if (establishedRound === undefined) {
-        const globalConfig = store.getReviewConfig();
-        // Direct delivery is an explicit low-overhead contract. Mutable global
-        // policy must not create a managed Round during direct completion; risk
-        // that warrants one promotes the Task to integrated delivery. Any already-
-        // established Task Round or immutable contract remains authoritative
-        // through the branches above.
-        config = taskDeliveryPath(task) === "integrated"
-            && globalConfig?.trigger === "final"
-            ? globalConfig
-            : null;
-    }
-    else {
-        config = { roleName: establishedRound.reviewerRoleName, trigger: "final" };
-    }
-    if (config === null || task.projectBindings.length === 0)
-        return null;
+    const config = taskFinalReviewConfig(taskFinalContract);
     const taskCandidate = taskReviewProvenance(store, task, options).candidate;
     const latest = establishedRound;
     if (latest?.status === "running") {
@@ -4593,10 +4399,7 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
             && latest.deltaRecheck !== undefined
             && latest.deltaRecheck.disposition === "requires-full-review") {
             // Fall through to queue a full Review for the same candidate.
-            const anchor = taskFinalContract === undefined
-                ? latestTaskReviewAnchor(store, task)
-                : latestTaskReviewContractAnchor(store, task, taskFinalContract);
-            const escalated = queueTaskReviewRound(store, task, anchor.item, anchor.candidate.id, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
+            const escalated = queueTaskReviewRound(store, task, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
             // Record the escalation lineage on the delta Round so the full Review
             // is traceable from the non-accepting delta disposition.
             if (latest.deltaRecheck.escalatedToReviewRoundId === undefined) {
@@ -4617,10 +4420,7 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
                 : latest;
         }
     }
-    const anchor = taskFinalContract === undefined
-        ? latestTaskReviewAnchor(store, task)
-        : latestTaskReviewContractAnchor(store, task, taskFinalContract);
-    return queueTaskReviewRound(store, task, anchor.item, anchor.candidate.id, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
+    return queueTaskReviewRound(store, task, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
 }
 function resumablePendingFinalTaskReview(store, task, round, config, taskCandidate, taskFinalContract, options) {
     if (taskFinalContract === undefined || round.taskFinalReviewContract === undefined) {
@@ -4685,22 +4485,6 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
         }
     }
 }
-function latestTaskReviewContractAnchor(store, task, taskFinalContract) {
-    const anchor = store.listWorkItems(task.id)
-        .flatMap((item) => {
-        const candidate = governingWorkItemCandidate(item);
-        return candidate !== undefined && sameTaskFinalReviewContract(candidate.taskFinalReviewContract, taskFinalContract)
-            ? [{ item, candidate }]
-            : [];
-    })
-        .sort((left, right) => (left.item.updatedAt.localeCompare(right.item.updatedAt)
-        || left.item.id.localeCompare(right.item.id)))
-        .at(-1);
-    if (anchor === undefined) {
-        throw usageError(`Task ${task.id} has no WorkItem Candidate to anchor its final Review.`);
-    }
-    return anchor;
-}
 /**
  * Leader-only retry of an exact failed Task-final review Run. The old failed
  * Run remains the attempt trail, while the semantic ReviewRound is reset to
@@ -4743,15 +4527,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         }
         const currentTaskCandidate = actualTaskReviewCandidateForMutation(tx, task, options);
         if (!isSameTaskReviewCandidate(currentTaskCandidate, round.taskCandidate)) {
-            throw usageError(`Task-final ReviewRound ${round.id} no longer matches the latest committed Integration heads.`);
-        }
-        const item = tx.getWorkItem(task.id, round.workItemId);
-        if (item === null) {
-            throw dataError(`Work item not found for run ${run.id}: ${round.workItemId}.`);
-        }
-        const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-        if (candidate === undefined) {
-            throw dataError(`ReviewRound Candidate not found: ${round.candidateId}.`);
+            throw usageError(`Task-final ReviewRound ${round.id} no longer matches the frozen Task heads.`);
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id)
             .filter((entry) => (entry.scope ?? "work-item") === "task"));
@@ -4885,8 +4661,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "run.review-retried", {
             runId: run.id,
-            reviewRoundId: round.id,
-            candidateId: candidate.id
+            reviewRoundId: round.id
         }, now);
         return { round: resetRound, previousRun: run, created: true };
     });
@@ -5300,8 +5075,8 @@ function yieldRun(args, store, options) {
                     const panelGroup = round.executionGroup;
                     recordTaskEvent(tx, task.id, "review-group-ready", {
                         reviewRoundId: round.id,
-                        workItemId: round.workItemId,
-                        candidateId: round.candidateId,
+                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+                        ...(round.candidateId === undefined ? {} : { candidateId: round.candidateId }),
                         executionGroupId: panelGroup.id,
                         terminalLanes: String(panelGroup.lanes
                             .filter(({ status }) => ["yielded", "completed", "failed"].includes(status)).length),
@@ -5315,8 +5090,8 @@ function yieldRun(args, store, options) {
                 }
                 recordTaskEvent(tx, task.id, "review.completed", {
                     reviewRoundId: round.id,
-                    workItemId: round.workItemId,
-                    candidateId: round.candidateId,
+                    ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+                    ...(round.candidateId === undefined ? {} : { candidateId: round.candidateId }),
                     reviewBaseCommit: round.reviewBaseCommit,
                     evidenceCommit: round.evidenceCommit ?? "none",
                     checks: round.checks?.map(({ name, outcome }) => `${name}:${outcome}`)
@@ -5614,18 +5389,12 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             }
             throw usageError(`ReviewRound workspace is not ready: ${round.id}.`);
         }
-        const item = tx.getWorkItem(taskId, round.workItemId);
-        if (item === null)
-            throw dataError(`ReviewRound Work Item not found: ${round.workItemId}.`);
-        const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-        if (candidate === undefined) {
-            throw dataError(`ReviewRound Candidate not found: ${round.candidateId}.`);
-        }
         const taskScope = (round.scope ?? "work-item") === "task";
+        let item;
+        let candidate;
         if (taskScope) {
-            // A Task-scoped final ReviewRound freezes the integrated Task heads in
-            // its taskCandidate. The WorkItem Candidate snapshot is irrelevant: the
-            // authoritative review base is the first Project's committed head.
+            // A Task-scoped final ReviewRound is anchored directly to its frozen
+            // Task candidate. It deliberately has no synthetic WorkItem Candidate.
             if (round.taskCandidate === undefined) {
                 throw new TaskFinalReviewDispatchDriftError(`Task ReviewRound ${round.id} has no frozen Task candidate.`);
             }
@@ -5633,8 +5402,21 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 throw new TaskFinalReviewDispatchDriftError(`Task ReviewRound base does not match its frozen Task candidate: ${round.id}.`);
             }
         }
-        else if (candidate.gitSnapshot?.reviewBaseCommit !== round.reviewBaseCommit) {
-            throw usageError(`ReviewRound Candidate snapshot changed: ${round.id}.`);
+        else {
+            if (round.workItemId === undefined || round.candidateId === undefined) {
+                throw dataError(`WorkItem ReviewRound has no Candidate anchor: ${round.id}.`);
+            }
+            item = tx.getWorkItem(taskId, round.workItemId) ?? undefined;
+            if (item === undefined) {
+                throw dataError(`ReviewRound Work Item not found: ${round.workItemId}.`);
+            }
+            candidate = item.candidates.find(({ id }) => id === round.candidateId);
+            if (candidate === undefined) {
+                throw dataError(`ReviewRound Candidate not found: ${round.candidateId}.`);
+            }
+            if (candidate.gitSnapshot?.reviewBaseCommit !== round.reviewBaseCommit) {
+                throw usageError(`ReviewRound Candidate snapshot changed: ${round.id}.`);
+            }
         }
         const task = requireTask(tx, taskId);
         if ((round.scope ?? "work-item") === "task") {
@@ -5671,7 +5453,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                         && frozenCommits.get(project.projectId) !== project.commit;
                 });
                 throw new TaskFinalReviewDispatchDriftError(committedIntegrationMoved
-                    ? "Task-final ReviewRound frozen integrated heads changed for its Project set."
+                    ? "Task-final ReviewRound frozen Task heads changed for its Project set."
                     : `Final ReviewRound ${round.id} freezes a candidate that is no longer `
                         + "the current Task candidate.");
             }
@@ -5732,9 +5514,11 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 throw new TaskFinalReviewDispatchDriftError(`Task ReviewRound frozen Project heads changed: ${round.id}.`);
             }
         }
-        const candidateLabel = candidate.source.type === "run"
-            ? `candidate Run ${candidate.source.runId}`
-            : `revision ${candidate.workItemRevision}`;
+        const candidateLabel = taskScope
+            ? "frozen Task candidate"
+            : candidate.source.type === "run"
+                ? `candidate Run ${candidate.source.runId}`
+                : `revision ${candidate.workItemRevision}`;
         const frozenHeads = taskScope
             ? round.taskCandidate.projects
                 .map(({ projectId, commit }) => `${projectId}@${commit}`)
@@ -5772,22 +5556,26 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             .map(({ projectId }) => (`yui project show ${projectId}; yui project knowledge list ${projectId}`))
             .join(" | ");
         const rawInput = [
-            `Review ${scopeLabel} WorkItem ${item.id} ${candidateLabel}.`,
+            taskScope
+                ? `Review the ${scopeLabel} ${candidateLabel}.`
+                : `Review ${scopeLabel} WorkItem ${item.id} ${candidateLabel}.`,
             `ReviewRound: ${round.id}`,
             `Review scope: ${taskScope ? "task" : "work-item"}`,
             `Review base commit: ${round.reviewBaseCommit}`,
             ...(taskScope
-                ? [`Frozen integrated Task heads: ${frozenHeads}`]
+                ? [`Frozen Task heads: ${frozenHeads}`]
                 : [`Candidate snapshot base: ${round.reviewBaseCommit}`]),
             `Project Policy pointers: ${projectPolicyPointers || "none"}`,
             `Review workspace source: exact workspace attached to this Reviewer Lane`,
-            `Candidate summary: ${candidate.summary}`,
-            `Acceptance criteria: ${item.acceptance.length === 0 ? "none" : item.acceptance.join("; ")}`,
+            `Candidate summary: ${taskScope ? task.title : candidate.summary}`,
+            `Acceptance criteria: ${taskScope
+                ? "Task objective, maintained decisions, and Project Policy"
+                : item.acceptance.length === 0 ? "none" : item.acceptance.join("; ")}`,
             ...(taskScope ? [deltaContext !== "" ? deltaContext : findingContext] : []),
             "Start from the user's core outcome and the WorkItem intent. The candidate summary is a pointer, not proof: inspect the complete relevant change, callers, and proportionate checks.",
             "Keep Yui Core lifecycle safety, generic Reviewer behavior, Project Policy/Knowledge, and the Task Contract separate. Follow Project Policy pointers from the dispatch context for project-specific checks.",
             ...(round.scope === "task" && round.deltaRecheck === undefined
-                ? ["This is the one final Task Review: inspect every bound Project at the frozen integrated heads, and report only reachable, material, actionable P1/P2 findings or bounded verification gaps."]
+                ? ["This is the one final Task Review: inspect every bound Project at the frozen Task heads, and report only reachable, material, actionable P1/P2 findings or bounded verification gaps."]
                 : []),
             "You may freely edit source/tests, run local build or test commands, and optionally commit diagnostic evidence only inside this ReviewRound-owned workspace.",
             "Do not push, integrate, mutate Task state, touch the Candidate or Worker workspace, another Task/workspace, a stable checkout, or the real Yui control-plane home.",
@@ -5848,7 +5636,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 action: "review-round",
                 subject: {
                     taskId,
-                    workItemId: item.id,
+                    ...(item === undefined ? {} : { workItemId: item.id }),
                     reviewRoundId: round.id,
                     executionGroupId: runningGroup.id,
                     executionLaneId: lane.id
@@ -5864,7 +5652,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 workspace: laneWorkspace
             }, now);
             createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
-                workItemId: item.id,
+                ...(item === undefined ? {} : { workItemId: item.id }),
                 purpose: "review",
                 reviewRoundId: round.id,
                 executionGroupId: runningGroup.id,
@@ -5901,7 +5689,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 taskId,
                 roleName: unboundRun.roleName,
                 purpose: "review",
-                workItemId: item.id,
+                ...(item === undefined ? {} : { workItemId: item.id }),
                 reviewRoundId: round.id
             }, now);
             const created = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
@@ -5912,7 +5700,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             tx.saveRole(taskId, updateRoleStatus(laneReviewer, "running", now));
             enqueueWork(tx, roleMailbox(taskId, laneReviewer.name), "review-requested", now, [
                 runRef(taskId, created.id),
-                workItemRef(taskId, item.id)
+                ...(item === undefined ? [] : [workItemRef(taskId, item.id)])
             ]);
             recordTaskEvent(tx, taskId, "run.review-dispatched", runLaunchEventPayload(created), now);
         }
@@ -5934,7 +5722,7 @@ export function failPendingReviewRound(taskId, reviewRoundId, summary, store, op
         const terminal = finishReviewRound(round, "failed", summary, now);
         tx.saveReviewRound(taskId, terminal);
         enqueueWork(tx, leaderMailbox(taskId), "review-failed", now, [
-            workItemRef(taskId, round.workItemId)
+            ...(round.workItemId === undefined ? [] : [workItemRef(taskId, round.workItemId)])
         ]);
         return terminal;
     });
@@ -6068,7 +5856,7 @@ function requirePublishedTreeAuthorization(store, proof) {
     if (authorization === undefined) {
         throw usageError(`Published-tree completion requires explicit user or global Operator authorization for `
             + `${proof.taskId}/${proof.publicationId} at ${proof.reviewRoundId === undefined
-                ? "the direct Task-main head"
+                ? "the Leader-owned Task-main head"
                 : `Task-final Review ${proof.reviewRoundId}`}.`);
     }
     return authorization;
@@ -6337,11 +6125,6 @@ function parseTaskPriority(value) {
         return value;
     throw usageError(`Invalid Task priority: ${value}.`);
 }
-function parseTaskDelivery(value) {
-    if (value === "direct" || value === "integrated")
-        return value;
-    throw usageError(`Task delivery is invalid: ${value}. Use direct or integrated.`);
-}
 function parseTaskTags(value) {
     const tags = [...new Set(value.split(",").map((tag) => tag.trim()).filter(Boolean))];
     if (tags.length === 0)