@zq-silk/yui 0.5.3 → 0.6.1

package/dist/commands/taskCommands.js

@@ -15,7 +15,11 @@ import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRo
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
 import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 import { createAgentRun } from "../run/agentRun.js";
-import { createReviewRound, createTaskReviewRound, attachReviewExecutionGroup, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { matchYieldReceipt } from "../run/yieldReceipt.js";
+import { providerRetryConfig } from "../run/providerRetryConfig.js";
+import { createReviewRound, createTaskReviewRound, attachReviewExecutionGroup, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { blockingOpenFindings, buildTaskFinalReviewFindingContext, completionGateBlocked, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview, reviewFindingLedgerWriteFailed } from "../review/reviewFindingLedger.js";
+import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
 import { markYuiRunInput, retagYuiRunInput } from "../run/runIdentity.js";
 import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
@@ -26,6 +30,7 @@ import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runt
 import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { formatAgentRunReceiptId, resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { resolveProject } from "../repository/project.js";
+import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.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";
@@ -34,10 +39,17 @@ import { hasAgentConfigOptions, parseRoleOptions, patchRoleAgentBinding, roleOpt
 import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
 import { assertRoleRuntimeMutationAllowed } from "./roleRuntimeGuard.js";
 import { runTaskContextCommand } from "./taskContextCommand.js";
+import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
+import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel } from "./taskRoleRuntimeStatus.js";
 import { assertNoOpenInputRequests, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
+import { runGrantCommand } from "./grantCommands.js";
+import { runWorkflowCommand } from "./workflowCommands.js";
 import { taskActor as resolveTaskActor, taskLeaderActionRunId } from "./taskActor.js";
 import { createTaskTerminalNotification } from "../scheduler/operatorNotification.js";
+import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
+import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition } from "../scheduler/actionability.js";
+import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { buildTaskOverview, parseTaskListOptions, renderTaskOverview } from "./taskOverviewCommand.js";
 const LEADER_ROLE = "leader";
 /** Exact Task-final identity or evidence changed between queueing and dispatch. */
@@ -140,6 +152,12 @@ export function preflightTaskCompletion(taskId, store, options = {}) {
     if (incompleteWork !== undefined) {
         throw usageError(`Task ${task.id} has unaccepted work: ${incompleteWork.id}/${incompleteWork.status}.`);
     }
+    const activeJob = store.listDurableJobs(task.id).find((job) => (job.status === "queued"
+        || job.status === "running"
+        || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
+    if (activeJob !== undefined) {
+        throw usageError(`Task ${task.id} has an active DurableJob: ${activeJob.id}/${activeJob.status}.`);
+    }
     if (task.requireIntegration) {
         if (store.listWorkItems(task.id).length === 0) {
             throw usageError(`Task ${task.id} requires at least one WorkItem before completion.`);
@@ -157,6 +175,11 @@ export function preflightTaskCompletion(taskId, store, options = {}) {
     if (unresolvedIntegration !== undefined) {
         throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
     }
+    const unsettledQueueEntry = store.listIntegrationQueueEntries(task.id).find((entry) => (entry.status !== "committed" && entry.status !== "superseded"));
+    if (unsettledQueueEntry !== undefined) {
+        throw usageError(`Task ${task.id} has an unsettled integration queue entry: `
+            + `${unsettledQueueEntry.id}/${unsettledQueueEntry.status}.`);
+    }
     const isolatedWorkspace = store.listManagedWorkspaces(task.id)
         .find(({ owner }) => owner.type === "work-item");
     if (isolatedWorkspace?.owner.type === "work-item") {
@@ -204,6 +227,7 @@ export function runTaskCommand(args, store, options = {}) {
         case "list": return listTaskCommand(rest, store);
         case "show": return showTaskCommand(rest, store);
         case "context": return runTaskContextCommand(rest, store);
+        case "next-action": return runTaskNextActionCommand(rest, store);
         case "activate": return output(activateTaskCommand(rest, store, options));
         case "complete": return completeTaskCommand(rest, store, options);
         case "reopen": return output(reopenTaskCommand(rest, store, options));
@@ -211,8 +235,11 @@ export function runTaskCommand(args, store, options = {}) {
         case "retire": return retireTaskCommand(rest, store, options);
         case "reconcile": return output(reconcileTaskCommand(rest, store, options));
         case "message": return output(taskMessageCommand(rest, store, options));
+        case "wake": return output(taskWakeCommand(rest, store, options));
         case "project": return taskProjectCommand(rest, store, options);
         case "input": return runTaskInputCommand(rest, store, options);
+        case "grant": return runGrantCommand(rest, store, options);
+        case "workflow": return runWorkflowCommand(rest, store, options);
         case "role": return taskRoleCommand(rest, store, options);
         case "work": return taskWorkCommand(rest, store, options);
         case "review": return taskReviewCommand(rest, store, options);
@@ -691,6 +718,22 @@ function completeTaskCommand(args, store, options) {
                 terminalizedLeaderRun
             };
         }
+        // Issue 06: under `review.findingLedger=enforce`, Task completion fails
+        // closed on undispositioned open P1/P2 findings. Run this after final-review
+        // preparation so `fixed-pending-review` findings can still request the one
+        // re-review for a changed frozen head; once no Review is needed, the gate
+        // blocks final completion.
+        if (completionGateBlocked(tx, task.id)) {
+            const blocking = blockingOpenFindings(tx, task.id);
+            if (reviewFindingLedgerWriteFailed(tx, task.id)) {
+                throw usageError(`Task ${task.id} cannot complete: the Review finding ledger was unavailable `
+                    + "while reconciling a semantic Review. Recover the ledger and reconcile the Round "
+                    + "before completing the Task.");
+            }
+            throw usageError(`Task ${task.id} has ${blocking.length} undispositioned open P1/P2 finding(s): `
+                + `${blocking.map(({ id }) => id).join(", ")}. `
+                + "Disposition each finding (yui task review finding dispose) before completing the Task.");
+        }
         const completed = completeTask(task, now, { by: actor, summary });
         tx.saveTask(completed);
         tx.clearPendingWakeup(task.id);
@@ -745,29 +788,45 @@ function completeTaskCommand(args, store, options) {
 function reopenTaskCommand(args, store, options) {
     exactPositionals(args, 1, "Task reopen usage: yui task reopen <id>.");
     const now = clock(options);
-    const result = store.transaction((tx) => {
-        const task = requireTask(tx, args[0]);
-        if (task.status === "active")
-            return { task, changed: false };
-        if (task.status === "archived")
-            throw usageError(`Task is archived: ${task.id}.`);
-        if (task.status !== "completed")
-            throw usageError(`Task is not completed: ${task.id}.`);
-        const active = reopenTask(task, now);
-        tx.saveTask(active);
-        tx.clearOperatorNotification(task.id);
-        enqueueWork(tx, leaderMailbox(task.id), "task-reopened", now, [taskRef(task.id)]);
-        enqueueWork(tx, taskMailbox(task.id), "task-reopened", now, [taskRef(task.id)]);
-        recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
-        return { task: active, changed: true };
-    });
-    if (result.changed) {
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+    // Reopen changes the Task status that archiveLegacyTaskRefs reads before
+    // deleting the legacy ref. Take the same per-Project maintenance fence so a
+    // reopen cannot commit between archive's status read and its ref deletion:
+    // the two operations are mutually exclusive per Project.
+    const existing = store.getTask(args[0]);
+    const projectIds = existing === null
+        ? []
+        : existing.projectBindings.map(({ projectId }) => projectId);
+    const release = options.yuiHome === undefined || projectIds.length === 0
+        ? () => { }
+        : acquireProjectMaintenanceLocks(options.yuiHome, projectIds);
+    try {
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, args[0]);
+            if (task.status === "active")
+                return { task, changed: false };
+            if (task.status === "archived")
+                throw usageError(`Task is archived: ${task.id}.`);
+            if (task.status !== "completed")
+                throw usageError(`Task is not completed: ${task.id}.`);
+            const active = reopenTask(task, now);
+            tx.saveTask(active);
+            tx.clearOperatorNotification(task.id);
+            enqueueWork(tx, leaderMailbox(task.id), "task-reopened", now, [taskRef(task.id)]);
+            enqueueWork(tx, taskMailbox(task.id), "task-reopened", now, [taskRef(task.id)]);
+            recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
+            return { task: active, changed: true };
+        });
+        if (result.changed) {
+            notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+        }
+        return result.changed
+            ? `Reopened task ${result.task.id}\n`
+            : `Task ${result.task.id} is already active\n`;
+    }
+    finally {
+        release();
     }
-    return result.changed
-        ? `Reopened task ${result.task.id}\n`
-        : `Task ${result.task.id} is already active\n`;
 }
 function archiveTaskCommand(args, store, options) {
     const request = validateTaskArchiveRequest(args, store, options);
@@ -781,9 +840,6 @@ function archiveTaskCommand(args, store, options) {
             && task.status !== "retired") {
             throw usageError(`Task ${task.id} must be completed or retired before it can be archived.`);
         }
-        if (task.cwd !== undefined || tx.listManagedWorkspaces(task.id).length > 0) {
-            throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
-        }
         assertNoOpenInputRequests(tx, task.id, "archiving the Task");
         const unresolvedIntegration = tx.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
             || integration.status === "blocked"
@@ -791,6 +847,15 @@ function archiveTaskCommand(args, store, options) {
         if (unresolvedIntegration !== undefined) {
             throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
         }
+        const activeArchiveJob = tx.listDurableJobs(task.id).find((job) => (job.status === "queued"
+            || job.status === "running"
+            || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
+        if (activeArchiveJob !== undefined) {
+            throw usageError(`Task ${task.id} has an active DurableJob: ${activeArchiveJob.id}/${activeArchiveJob.status}.`);
+        }
+        if (task.cwd !== undefined || tx.listManagedWorkspaces(task.id).length > 0) {
+            throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
+        }
         const activeRole = tx.listRoles(task.id)
             .find((role) => tx.getActiveAgentRun(task.id, role.name) !== null);
         if (activeRole !== undefined) {
@@ -851,6 +916,12 @@ function retireTaskCommand(args, store, options) {
         if (unresolvedIntegration !== undefined) {
             throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
         }
+        const activeRetireJob = tx.listDurableJobs(task.id).find((job) => (job.status === "queued"
+            || job.status === "running"
+            || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
+        if (activeRetireJob !== undefined) {
+            throw usageError(`Task ${task.id} has an active DurableJob: ${activeRetireJob.id}/${activeRetireJob.status}.`);
+        }
         assertTaskRetirementProof(tx, task, options.taskRetirementProof);
         for (const run of tx.listAgentRuns(task.id).filter(({ status: runStatus }) => (runStatus === "active"))) {
             const terminal = terminalizeExactTaskRun(tx, {
@@ -982,11 +1053,22 @@ function reconcileTaskCommand(args, store, options) {
 function taskMessageCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "send") {
-        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->).";
-        const parsed = parseTail(rest, new Set(["--body-file"]), usage);
+        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--wake-policy leader|none].";
+        const parsed = parseTail(rest, new Set(["--body-file", "--wake-policy"]), usage);
         if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
             throw usageError(usage);
         const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
+        const wakePolicyRaw = parsed.options.get("--wake-policy");
+        let wakePolicy;
+        if (wakePolicyRaw === undefined) {
+            wakePolicy = undefined;
+        }
+        else if (wakePolicyRaw === "leader" || wakePolicyRaw === "none") {
+            wakePolicy = wakePolicyRaw;
+        }
+        else {
+            throw usageError(`--wake-policy must be 'leader' or 'none': ${wakePolicyRaw}.`);
+        }
         const now = clock(options);
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
@@ -995,9 +1077,14 @@ function taskMessageCommand(args, store, options) {
             const message = actor === "leader"
                 ? appendMessage(tx, task.id, body, "role-result", { type: "role", roleName: LEADER_ROLE }, now)
                 : actor === "operator"
-                    ? appendMessage(tx, task.id, body, "operator", { type: "operator" }, now)
-                    : appendMessage(tx, task.id, body, "user", { type: "user" }, now);
-            if (task.status === "active" && actor !== "leader") {
+                    ? appendMessage(tx, task.id, body, "operator", { type: "operator" }, now, { wakePolicy })
+                    : appendMessage(tx, task.id, body, "user", { type: "user" }, now, { wakePolicy });
+            // Issue 05: only `wakePolicy=leader` (the default for backward
+            // compatibility) enqueues Leader work. `wakePolicy=none` persists the
+            // message as context without waking the Leader.
+            if (task.status === "active"
+                && actor !== "leader"
+                && wakePolicy !== "none") {
                 enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [messageRef(task.id, message.id)]);
             }
             return { task, message, actor };
@@ -1032,6 +1119,30 @@ function taskMessageCommand(args, store, options) {
         ? "Task message command is required."
         : `Unknown command: task message ${command}`);
 }
+/**
+ * Issue 05: force-wake escape hatch. Bypasses the actionability digest and
+ * enqueues exactly one Leader wakeup with an auditable reason. The reason is
+ * truncated to keep the event payload compact.
+ */
+function taskWakeCommand(args, store, options) {
+    const usage = "Task wake usage: yui task wake <id> --force --reason <text>.";
+    const parsed = parseTail(args, new Set(["--reason"]), usage, new Set(["--force"]));
+    exactPositionals(parsed.positionals, 1, usage);
+    if (!parsed.options.has("--force")) {
+        throw usageError("--force is required to wake a Task.", usage);
+    }
+    const reason = requiredOption(parsed.options, "--reason");
+    const now = clock(options);
+    const task = requireTask(store, parsed.positionals[0]);
+    assertTaskOpen(task);
+    const wakeReason = `force-wake:${truncateEventNote(reason)}`;
+    store.transaction((tx) => {
+        queueLeaderWakeup(tx, task.id, wakeReason, now);
+        recordTaskEvent(tx, task.id, "task.wake-forced", { reason: wakeReason }, now);
+    });
+    notifyMailbox(options.runtime, leaderMailbox(task.id), task.id);
+    return `Woke ${task.id} (${wakeReason})\n`;
+}
 function taskRoleCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "add")
@@ -1448,6 +1559,15 @@ function createWork(args, store, options) {
         if (new Set(baseRefs.map(({ projectId }) => projectId)).size !== baseRefs.length) {
             throw usageError("Each Work Item Project may specify at most one base ref.");
         }
+        const guard = runDeliveryGuardPreflight(tx, task.id, {
+            kind: "create-work-item",
+            scope: {
+                title: parsed.positionals[1],
+                objective: parsed.objective ?? parsed.positionals[1],
+                acceptance: parsed.acceptance,
+                writeProjectIds
+            }
+        }, { environment: options.environment, budget: true });
         const created = createWorkItem(tx.nextWorkItemId(task.id), task.id, {
             title: parsed.positionals[1],
             objective: parsed.objective ?? parsed.positionals[1],
@@ -1459,10 +1579,10 @@ function createWork(args, store, options) {
         }, now);
         tx.saveWorkItem(task.id, created);
         enqueueWork(tx, taskMailbox(task.id), "work-created", now, [workItemRef(task.id, created.id)]);
-        return created;
+        return { item: created, guard };
     });
-    notifyMailbox(options.runtime, taskMailbox(item.taskId), item.taskId);
-    return output(`Created work item ${item.id} for ${item.taskId}\n`, { workItem: item });
+    notifyMailbox(options.runtime, taskMailbox(item.item.taskId), item.item.taskId);
+    return output(withGuardWarnings(item.guard, `Created work item ${item.item.id} for ${item.item.taskId}\n`), { workItem: item.item });
 }
 function updateWorkScope(args, store, options) {
     const usage = "Task work scope usage: yui task work scope <task>/<work> [--project <project> ...].";
@@ -1819,6 +1939,24 @@ function dispatchWork(args, store, options) {
                     || prepared.owner.executionLaneId !== lane.id) {
                     throw usageError(`Execution Lane workspace identity does not match dispatch: ${runningGroup.id}/${lane.id}.`);
                 }
+                if (options.laneDispatchProjectPaths !== undefined) {
+                    // The prepared workspaces were created under a held maintenance
+                    // fence that this transaction still holds. Re-prove the Task
+                    // binding set and exact Project paths match the preparation
+                    // snapshot: a migrate in the prepare/adopt gap fails closed here
+                    // rather than stranding a Lane on the external checkout.
+                    const currentIds = task.projectBindings.map(({ projectId }) => projectId).sort();
+                    const proofIds = [...options.laneDispatchProjectPaths.keys()].sort();
+                    if (currentIds.length !== proofIds.length
+                        || currentIds.some((projectId, index) => projectId !== proofIds[index])) {
+                        throw new Error(`Task Project bindings changed during Lane dispatch: ${task.id}.`);
+                    }
+                    for (const [projectId, preparedPath] of options.laneDispatchProjectPaths) {
+                        if (requireProject(tx, projectId).path !== preparedPath) {
+                            throw new Error(`Project path changed during Lane dispatch: ${projectId}.`);
+                        }
+                    }
+                }
                 if (tx.getManagedWorkspace(prepared.owner) === null)
                     tx.saveManagedWorkspace(prepared);
             }
@@ -2018,10 +2156,16 @@ function acceptWork(args, store, options) {
         if (options.workItemIntegrationProof?.workspace.owner.type === "review-round") {
             throw usageError("A ReviewRound-owned workspace cannot be used for WorkItem acceptance.");
         }
-        const evidenceCommits = new Set(tx.listReviewRounds(item.taskId)
-            .flatMap(({ evidenceCommit }) => evidenceCommit === undefined ? [] : [evidenceCommit]));
-        if (options.workItemIntegrationProof?.projects.some(({ headCommit }) => evidenceCommits.has(headCommit))) {
-            throw usageError("A ReviewRound evidence commit cannot be used for WorkItem acceptance.");
+        // Only diagnostic evidence commits (a reviewer's own commit on top of the
+        // frozen base) are barred from WorkItem acceptance.  A clean review
+        // attests the frozen base itself (evidenceCommit === reviewBaseCommit),
+        // which is the candidate's own head.
+        const diagnosticEvidence = new Set(tx.listReviewRounds(item.taskId)
+            .flatMap(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit
+            ? [evidenceCommit]
+            : []));
+        if (options.workItemIntegrationProof?.projects.some(({ headCommit }) => diagnosticEvidence.has(headCommit))) {
+            throw usageError("A ReviewRound diagnostic evidence commit cannot be used for WorkItem acceptance.");
         }
         const candidate = requireWorkItemCandidate(item);
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
@@ -2175,6 +2319,19 @@ function retireWork(args, store, options) {
                 throw usageError("A Work Item cannot replace itself.");
             }
         }
+        // rr4/finding-5: A Work Item with an active DurableJob cannot be retired —
+        // the runner may still be using its workspace. Block on queued, running,
+        // and unacknowledged unknown-needs-attention jobs owned by this Work Item.
+        const activeWorkItemJob = tx.listDurableJobs(task.id).find((job) => (job.owner.kind === "work-item"
+            && job.owner.workItemId === item.id
+            && (job.status === "queued"
+                || job.status === "running"
+                || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined))));
+        if (activeWorkItemJob !== undefined) {
+            throw usageError(`Work Item ${item.id} has an active DurableJob: `
+                + `${activeWorkItemJob.id}/${activeWorkItemJob.status}. `
+                + "Cancel or acknowledge it before retiring.");
+        }
         for (const run of tx.listAgentRuns(task.id).filter((candidate) => (candidate.status === "active" && candidate.workItemId === item.id))) {
             const terminal = terminalizeExactTaskRun(tx, {
                 taskId: task.id,
@@ -2313,6 +2470,8 @@ function taskReviewCommand(args, store, options) {
         return retryFailedTaskReviewRound(rest, store, options);
     if (command === "group")
         return resolveReviewExecutionGroup(rest, store, options);
+    if (command === "finding")
+        return reviewFindingCommand(rest, store, options);
     throw usageError(command === undefined
         ? "Task review command is required."
         : `Unknown command: task review ${command}`);
@@ -2355,29 +2514,32 @@ function resolveReviewExecutionGroup(args, store, options) {
                 : selectedLaneIds === undefined ? {} : { selectedLaneIds })
         }, now);
         const withGroup = updateReviewExecutionGroup(round, resolved);
-        const laneReports = resolved.lanes
-            .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
+        const selectedLanes = resolved.lanes
+            .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false);
+        const laneReports = selectedLanes
             .map((lane) => lane.result?.report ?? lane.result?.summary ?? "")
             .filter((report) => report.length > 0);
-        const checks = resolved.lanes
-            .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
+        const checks = selectedLanes
             .flatMap((lane) => lane.result?.checks ?? [])
             .map(({ name, outcome, details }) => ({
             name,
             outcome,
             ...(details === undefined ? {} : { details })
         }));
-        const findings = resolved.lanes
-            .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
+        const findings = selectedLanes
             .flatMap((lane) => lane.result?.findings ?? []);
-        const evidence = resolved.lanes
-            .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
+        const evidence = selectedLanes
             .flatMap((lane) => lane.result?.evidence ?? []);
-        const evidenceCommits = [...new Set(resolved.lanes
-                .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
+        const evidenceCommits = [...new Set(selectedLanes
                 .map((lane) => lane.result?.evidenceCommit)
                 .filter((commit) => commit !== undefined))];
-        const evidenceCommit = evidenceCommits.length === 1 ? evidenceCommits[0] : undefined;
+        // A Round attests a single tree only when EVERY selected Lane attests it.
+        // A dirty Lane (no evidenceCommit) ran checks on an uncommitted tree, so its
+        // checks cannot be covered by another Lane's base attestation.
+        const allLanesAttest = selectedLanes.every((lane) => lane.result?.evidenceCommit !== undefined);
+        const evidenceCommit = allLanesAttest && evidenceCommits.length === 1
+            ? evidenceCommits[0]
+            : undefined;
         const terminal = finishReviewRound(withGroup, decision === "accept" ? "completed" : "failed", summary, now, {
             report: [
                 laneReports.join("\n\n") || summary,
@@ -2393,6 +2555,11 @@ function resolveReviewExecutionGroup(args, store, options) {
             ...(evidenceCommit === undefined ? {} : { evidenceCommit })
         });
         tx.saveReviewRound(task.id, terminal);
+        // Issue 06: a panel-resolved completed Round feeds the finding ledger;
+        // a rejected Round is an execution-attempt failure and is skipped.
+        if (terminal.status === "completed") {
+            reconcileReviewFindingsAfterReview(tx, task.id, terminal.id, now);
+        }
         enqueueWork(tx, leaderMailbox(task.id), "review-group-resolved", now, [
             workItemRef(task.id, round.workItemId)
         ]);
@@ -2400,6 +2567,166 @@ function resolveReviewExecutionGroup(args, store, options) {
     });
     return output(`Resolved Review ExecutionGroup ${result.executionGroup?.id ?? "unknown"} as ${decision}; ReviewRound ${result.id} is ${result.status}.\n`, { reviewRound: result });
 }
+/**
+ * Issue 06: `yui task review finding` — the cross-Round finding ledger CLI.
+ * Findings are extracted automatically from completed Rounds; these commands
+ * let the Leader inspect the ledger, disposition each finding, and plan the
+ * parallel repair wave.
+ */
+function reviewFindingCommand(args, store, options) {
+    const [command, ...rest] = args;
+    if (command === "list")
+        return listReviewFindings(rest, store, options);
+    if (command === "dispose")
+        return disposeReviewFindingCommand(rest, store, options);
+    if (command === "repair-wave")
+        return planReviewRepairWave(rest, store, options);
+    if (command === "extract")
+        return extractReviewFindingsCommand(rest, store, options);
+    throw usageError(command === undefined
+        ? "Task review finding command is required."
+        : `Unknown command: task review finding ${command}`);
+}
+function listReviewFindings(args, store, options) {
+    const usage = "Task review finding list usage: yui task review finding list <task>.";
+    exactPositionals(args, 1, usage);
+    const task = requireTask(store, args[0]);
+    const findings = store.listReviewFindings(task.id);
+    if (findings.length === 0) {
+        return output(`No review findings recorded for ${task.id}.\n`);
+    }
+    const lines = findings.map((finding) => {
+        const repair = finding.repair === undefined
+            ? ""
+            : `; repair: ${finding.repair.workItemId ?? "?"}${finding.repair.commit === undefined ? "" : `@${finding.repair.commit.slice(0, 12)}`}`;
+        const merge = finding.mergeRequired === true ? " [merge-required]" : "";
+        return `${finding.id} [${finding.severity}/${finding.disposition}] ${finding.title}`
+            + ` (invariant: ${finding.invariant}; first: ${finding.firstReviewRoundId}; last: ${finding.lastReviewRoundId})${repair}${merge}`;
+    });
+    return output(`Review findings for ${task.id}:\n${lines.join("\n")}\n`);
+}
+function disposeReviewFindingCommand(args, store, options) {
+    const usage = "Task review finding dispose usage: yui task review finding dispose <task>/<finding> "
+        + "--disposition <fixed-pending-review|verified-fixed|accepted-risk|not-actionable|superseded> "
+        + "[--work-item <id>] [--commit <sha>] [--verification <text>] [--note <text>] [--superseded-by <stable-key>].";
+    const parsed = parseTail(args, new Set(["--disposition", "--work-item", "--commit", "--verification", "--note", "--superseded-by"]), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const disposition = requiredOption(parsed.options, "--disposition");
+    if (!LEADER_FINDING_DISPOSITIONS.includes(disposition)) {
+        throw usageError(`Review finding disposition is invalid: ${disposition}.`);
+    }
+    const now = clock(options);
+    const reference = resolveTaskRecordReference(parsed.positionals[0], {
+        kind: "reviewFinding",
+        label: "Review finding"
+    });
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, reference.taskId);
+        if (task.status !== "active")
+            throw usageError(inactiveTaskMessage(task, "dispositioning a review finding"));
+        if (taskActor(options, task.id) !== "leader") {
+            throw usageError("Only the Task Leader may disposition a review finding.");
+        }
+        const command = {
+            disposition,
+            by: taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? "leader",
+            ...(parsed.options.get("--note") === undefined ? {} : { note: parsed.options.get("--note") }),
+            ...(parsed.options.get("--work-item") === undefined ? {} : { workItemId: parsed.options.get("--work-item") }),
+            ...(parsed.options.get("--commit") === undefined ? {} : { commit: parsed.options.get("--commit") }),
+            ...(parsed.options.get("--verification") === undefined ? {} : { verification: parsed.options.get("--verification") }),
+            ...(parsed.options.get("--superseded-by") === undefined ? {} : { supersededBy: parsed.options.get("--superseded-by") }),
+            now
+        };
+        return dispositionReviewFinding(tx, task.id, reference.localId, command);
+    });
+    return output(`Dispositioned ${result.id} as ${result.disposition}.\n`);
+}
+function planReviewRepairWave(args, store, options) {
+    const usage = "Task review finding repair-wave usage: yui task review finding repair-wave <task> [--create].";
+    const parsed = parseTail(args, new Set(), usage, new Set(["--create"]));
+    exactPositionals(parsed.positionals, 1, usage);
+    const task = requireTask(store, parsed.positionals[0]);
+    const groups = planRepairGroups(store, task.id);
+    if (groups.length === 0) {
+        return output(`No open P1/P2 findings need repair for ${task.id}.\n`);
+    }
+    if (parsed.options.has("--create")) {
+        const now = clock(options);
+        const created = store.transaction((tx) => {
+            const currentTask = requireTask(tx, task.id);
+            if (currentTask.status !== "active") {
+                throw usageError(inactiveTaskMessage(currentTask, "creating a review repair wave"));
+            }
+            if (taskActor(options, currentTask.id) !== "leader") {
+                throw usageError("Only the Task Leader may create a review repair wave.");
+            }
+            const openItems = tx.listWorkItems(currentTask.id)
+                .filter((item) => item.status === "pending" || item.status === "running");
+            return groups.map((group) => {
+                const findingMarkers = group.findingIds.map((id) => `review-finding:${id}`);
+                const existing = openItems.find((item) => isDeepStrictEqual([...item.acceptance].sort(), [...findingMarkers].sort()));
+                if (existing !== undefined)
+                    return { group, item: existing, changed: false };
+                const item = createWorkItem(tx.nextWorkItemId(currentTask.id), currentTask.id, {
+                    title: `Repair review findings ${group.findingIds.join(", ")}`,
+                    objective: [
+                        "Repair the following Task-final Review findings as one overlapping group:",
+                        ...group.findings.map((finding) => (`- ${finding.id} [${finding.severity}] ${finding.title} `
+                            + `(invariant: ${finding.invariant}; evidence: ${finding.evidence.join(" | ") || "see ReviewRound"})`)),
+                        "Integrate this repair with the rest of the Task before requesting another Task-final Review."
+                    ].join("\n"),
+                    acceptance: findingMarkers,
+                    writeProjectIds: reviewRepairProjectIds(currentTask, group.affectedPaths)
+                }, now);
+                tx.saveWorkItem(currentTask.id, item);
+                enqueueWork(tx, taskMailbox(currentTask.id), "work-created", now, [
+                    workItemRef(currentTask.id, item.id)
+                ]);
+                return { group, item, changed: true };
+            });
+        });
+        const lines = created.map(({ group, item, changed }) => (`wave ${group.groupKey}: ${item.id} ${changed ? "created" : "already open"} `
+            + `(${group.findingIds.join(", ")})`));
+        return output(`Review repair wave for ${task.id} (${groups.length} group(s)):\n${lines.join("\n")}\n`, { groups: created });
+    }
+    const lines = groups.map((group, index) => {
+        const findings = group.findings
+            .map((finding) => `${finding.id} [${finding.severity}] ${finding.title}`)
+            .join("; ");
+        return `wave ${index + 1}: ${findings}`
+            + ` (paths: ${group.affectedPaths.join(", ") || "none"}; invariants: ${group.invariants.join(", ")})`;
+    });
+    return output(`Repair wave for ${task.id} (${groups.length} group(s), run disjoint groups in parallel):\n${lines.join("\n")}\n`);
+}
+function reviewRepairProjectIds(task, affectedPaths) {
+    const bindings = task.projectBindings;
+    const matched = bindings.filter((binding) => affectedPaths.some((path) => pathWithinProject(path, binding.directory)));
+    const projectIds = (matched.length > 0 ? matched : bindings).map(({ projectId }) => projectId);
+    return [...new Set(projectIds)];
+}
+function pathWithinProject(path, directory) {
+    const normalizedPath = path.replace(/^\.\//u, "").replace(/^\/+/u, "");
+    const normalizedDirectory = directory.replace(/^\.\//u, "").replace(/^\/+|\/+$/gu, "");
+    if (normalizedDirectory.length === 0 || normalizedDirectory === ".")
+        return true;
+    return normalizedPath === normalizedDirectory
+        || normalizedPath.startsWith(`${normalizedDirectory}/`);
+}
+function extractReviewFindingsCommand(args, store, options) {
+    const usage = "Task review finding extract usage: yui task review finding extract <task>/<review-round>.";
+    exactPositionals(args, 1, usage);
+    const reference = resolveTaskRecordReference(args[0], {
+        kind: "reviewRound",
+        label: "ReviewRound"
+    });
+    const now = clock(options);
+    const result = store.transaction((tx) => reconcileReviewFindings(tx, reference.taskId, reference.localId, now));
+    if (result.skipped) {
+        return output(`ReviewRound ${result.roundId} produced no findings: ${result.reason ?? "skipped"}\n`);
+    }
+    return output(`Reconciled ${result.created.length + result.updated.length + result.conflicts.length} finding(s) from ${result.roundId}: `
+        + `${result.created.length} created, ${result.updated.length} updated, ${result.conflicts.length} conflict(s).\n`);
+}
 function requestTaskReviewRound(args, store, options) {
     const usage = "Task review request usage: yui task review request <task> --role <global-role> [--strategy fixed:<count>|adaptive:<max>] [--lane-role <role> ...].";
     const parsed = parseMultiValueTail(args, new Set(["--role", "--strategy"]), new Set(["--lane-role"]), usage);
@@ -2633,9 +2960,12 @@ function retryFailedTaskReviewRound(args, store, options) {
             throw usageError(`ReviewRound ${round.id} is not a failed Task-final ReviewRound.`);
         }
         if (round.reviewerRunId !== undefined) {
+            if (round.status === "completed") {
+                throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
+            }
             throw usageError(`ReviewRound ${round.id} has Reviewer Run ${round.reviewerRunId}; use task run retry instead.`);
         }
-        if (round.status !== "failed") {
+        if (round.status !== "failed" && round.status !== "pending") {
             throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
         }
         if (round.taskCandidate === undefined) {
@@ -2667,25 +2997,15 @@ function retryFailedTaskReviewRound(args, store, options) {
         if (roundIndex < 0) {
             throw dataError(`Final ReviewRound is not in Task history: ${round.id}.`);
         }
-        const laterRounds = reviewerRounds.slice(roundIndex + 1);
-        const existingRetry = reviewerRounds.filter((entry) => (entry.id !== round.id
-            && (entry.scope ?? "work-item") === "task"
-            && entry.requestedBy === "leader"
-            && entry.workItemId === round.workItemId
-            && entry.candidateId === round.candidateId
-            && entry.reviewerRoleName === round.reviewerRoleName
-            && entry.reviewBaseCommit === round.reviewBaseCommit
-            && sameTaskFinalReviewContract(entry.taskFinalReviewContract, taskFinalContract)
-            && isSameTaskReviewCandidate(entry.taskCandidate, round.taskCandidate)
-            && entry.status !== "failed")).at(-1);
-        const conflictingLater = laterRounds.find((entry) => entry.id !== existingRetry?.id);
+        // Issue 06: infra retries reuse the same semantic Round ID. Any later
+        // Round supersedes this one; an active Round for the same Reviewer blocks.
+        const conflictingLater = reviewerRounds.slice(roundIndex + 1).at(-1);
         if (conflictingLater !== undefined) {
             throw usageError(`A newer conflicting final ReviewRound already exists after ${round.id}: `
                 + `${conflictingLater.id}/${conflictingLater.status}.`);
         }
-        assertNoConflictingTaskReviewRound(reviewerRounds, existingRetry?.id);
+        assertNoConflictingTaskReviewRound(reviewerRounds, round.id);
         const activeRound = reviewerRounds.find((entry) => (entry.id !== round.id
-            && entry.id !== existingRetry?.id
             && entry.reviewerRoleName === round.reviewerRoleName
             && (entry.status === "pending" || entry.status === "running")));
         if (activeRound !== undefined) {
@@ -2711,62 +3031,27 @@ function retryFailedTaskReviewRound(args, store, options) {
             || mailbox?.pending !== null && mailbox?.pending !== undefined);
         const activeReviewerRuns = tx.listAgentRuns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
         const activePointer = tx.getActiveAgentRun(task.id, reviewer.name);
-        // An exact already-created retry is the idempotent result. The identity
-        // fences are intentionally as strict as the failed-Run retry path: pending
-        // is reusable only while every Reviewer lane is idle; running is reusable
-        // only with its exact active Run/mailbox; completed is a no-write result.
-        if (existingRetry !== undefined) {
-            if (existingRetry.status === "pending") {
-                if (activePointer !== null || activeReviewerRuns.length > 0
-                    || hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
-                    throw usageError(`Reviewer has unrelated active execution: ${reviewer.name}.`);
-                }
-                return { round: existingRetry, created: false };
-            }
-            if (existingRetry.status === "running") {
-                const reviewerRunId = existingRetry.reviewerRunId;
-                const activeMatches = reviewerRunId !== undefined
-                    && activePointer !== null
-                    && activePointer.id === reviewerRunId
-                    && activePointer.status === "active"
-                    && activeReviewerRuns.length === 1
-                    && activeReviewerRuns[0].id === reviewerRunId;
-                const processingMatches = reviewerRunId !== undefined
-                    && reviewerMailbox?.processing?.executionRef !== undefined
-                    && isDeepStrictEqual(reviewerMailbox.processing.executionRef, runRef(task.id, reviewerRunId))
-                    && reviewerMailbox.pending === null;
-                const pendingMatches = reviewerRunId !== undefined
-                    && reviewerMailbox?.pending?.requestCount === 1
-                    && reviewerMailbox.pending.refs.some((ref) => (isDeepStrictEqual(ref, runRef(task.id, reviewerRunId))));
-                if (!activeMatches || (!processingMatches && !pendingMatches) || hasMailboxWork(runtimeMailbox)) {
-                    throw usageError(`Existing retry ${existingRetry.id} is running without its exact active Reviewer execution.`);
-                }
-                return { round: existingRetry, created: false };
-            }
-            if (existingRetry.status === "completed") {
-                if (activePointer !== null || activeReviewerRuns.length > 0
-                    || hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
-                    throw usageError(`Reviewer has unrelated active execution: ${reviewer.name}.`);
-                }
-                return { round: existingRetry, created: false };
-            }
-            throw usageError(`Existing retry ${existingRetry.id} is not reusable from ${existingRetry.status}.`);
-        }
         if (activePointer !== null || activeReviewerRuns.length > 0) {
             throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
         }
         if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
             throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
         }
-        const nextRound = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, round.workItemId, round.candidateId, round.reviewerRoleName, "leader", round.taskCandidate, now, taskFinalContract);
-        tx.saveReviewRound(task.id, nextRound);
+        // Issue 06: an already-pending Round is the idempotent retry result.
+        if (round.status === "pending") {
+            return { round, created: false };
+        }
+        // Issue 06: infra retry resets the same semantic Round to pending instead
+        // of manufacturing a new Round, so Round count and finding identity stay
+        // stable across execution-attempt failures.
+        const resetRound = retryTaskReviewRound(round);
+        tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "review.task-final-retried", {
-            previousReviewRoundId: round.id,
-            nextReviewRoundId: nextRound.id,
+            reviewRoundId: round.id,
             workItemId: round.workItemId,
             candidateId: round.candidateId
         }, now);
-        return { round: nextRound, created: true };
+        return { round: resetRound, created: true };
     });
     return output(result.created
         ? `Task-final Review retry requested as ${result.round.id}\n`
@@ -2784,6 +3069,8 @@ function taskRunCommand(args, store, options) {
         return output(recoverRun(rest, store, options));
     if (command === "yield")
         return yieldRun(rest, store, options);
+    if (command === "yield-status")
+        return yieldRunStatus(rest, store, options);
     if (command === "checkpoint")
         return output(checkpointRun(rest, store, options));
     throw usageError(command === undefined
@@ -3436,11 +3723,9 @@ function latestTaskReviewContractAnchor(store, task, taskFinalContract) {
 }
 /**
  * Leader-only retry of an exact failed Task-final review Run. The old failed
- * Run/Round/workspace/evidence are preserved verbatim: the old Round is
- * terminalized as failed (idempotent if already failed) and a new independent
- * ReviewRound bound to the same frozen Candidate is created (or reused if a
- * prior retry already produced one). Every identity and frozen-head fence is
- * checked inside one transaction so a partial fail-old-without-new state can
+ * Run remains the attempt trail, while the semantic ReviewRound is reset to
+ * pending under its existing identity. Every identity and frozen-head fence is
+ * checked inside one transaction so a partial fail-old-without-reset state can
  * never be committed.
  */
 function retryFailedReviewRun(previous, store, options, now) {
@@ -3470,13 +3755,12 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)) {
             throw usageError(`Task final-review contract does not match ReviewRound ${round.id}.`);
         }
-        if (round.status !== "failed" && round.status !== "running") {
+        if (round.status !== "failed"
+            && round.status !== "running"
+            && round.status !== "pending"
+            && round.status !== "completed") {
             throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
         }
-        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
-        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 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.`);
@@ -3499,27 +3783,9 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (laterRound !== undefined && !isSameTaskReviewCandidate(laterRound.taskCandidate, round.taskCandidate)) {
             throw usageError(`A newer final Task candidate already has ReviewRound ${laterRound.id}.`);
         }
-        const reviewerRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id).filter((entry) => (entry.workItemId === item.id
-            && entry.candidateId === candidate.id
-            && entry.reviewerRoleName === round.reviewerRoleName)));
         const allReviewerRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id).filter((entry) => (entry.reviewerRoleName === round.reviewerRoleName)));
-        const existingRetry = reviewerRounds.filter((entry) => (entry.id !== round.id
-            && entry.status !== "failed"
-            && entry.requestedBy === "leader"
-            && (entry.scope ?? "work-item") === "task"
-            && entry.candidateId === candidate.id
-            && entry.workItemId === item.id
-            && entry.reviewerRoleName === round.reviewerRoleName
-            && entry.reviewBaseCommit === round.reviewBaseCommit
-            && sameTaskFinalReviewContract(entry.taskFinalReviewContract, taskFinalContract)
-            && isSameTaskReviewCandidate(entry.taskCandidate, round.taskCandidate))).at(-1);
-        if (round.status === "running"
-            && tx.getActiveAgentRun(task.id, round.reviewerRoleName) !== null) {
-            throw usageError(`${task.id}/${round.reviewerRoleName} already has an active run.`);
-        }
-        assertNoConflictingTaskReviewRound(tx.listReviewRounds(task.id), [round.id, ...(existingRetry === undefined ? [] : [existingRetry.id])]);
+        assertNoConflictingTaskReviewRound(tx.listReviewRounds(task.id), round.id);
         const activeRound = allReviewerRounds.find((entry) => (entry.id !== round.id
-            && entry.id !== existingRetry?.id
             && (entry.status === "pending" || entry.status === "running")));
         if (activeRound !== undefined) {
             throw usageError(`Reviewer already has an active review round for this candidate: ${activeRound.id}.`);
@@ -3536,39 +3802,21 @@ function retryFailedReviewRun(previous, store, options, now) {
         const reviewer = requireRole(tx, task.id, round.reviewerRoleName);
         const activePointer = tx.getActiveAgentRun(task.id, reviewer.name);
         const activeReviewerRuns = tx.listAgentRuns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
-        if (round.status === "running"
-            && (activePointer !== null || activeReviewerRuns.length > 0)) {
-            throw usageError(`${task.id}/${reviewer.name} already has an active run.`);
-        }
-        // A completed identical retry is terminal evidence and is a no-write
-        // idempotent read only when no unrelated Reviewer state is live. Keep the
-        // same fail-closed fences as pending/running retries.
-        if (existingRetry?.status === "completed") {
-            if (activePointer !== null || activeReviewerRuns.length > 0) {
-                throw usageError(`Reviewer Role already has an active run: ${round.reviewerRoleName}.`);
-            }
-            if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
-                throw usageError(`Reviewer has unrelated mailbox work: ${round.reviewerRoleName}.`);
-            }
-            return { round: existingRetry, previousRun: run };
-        }
-        if (existingRetry?.status === "pending") {
-            // A pending retry is reusable only while every Reviewer lane is idle.
-            // In particular, never return it to the CLI while another Round/Run or
-            // mailbox batch could cause the CLI to dispatch or fail it.
+        // Issue 06: a completed same-Round retry is a no-write idempotent result.
+        if (round.status === "completed") {
             if (activePointer !== null || activeReviewerRuns.length > 0) {
                 throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
             }
-            if (hasMailboxWork(reviewerMailbox)) {
-                throw usageError(`Reviewer mailbox has unrelated work: ${reviewer.name}.`);
-            }
-            if (hasMailboxWork(runtimeMailbox)) {
-                throw usageError(`Reviewer runtime lifecycle is pending: ${reviewer.name}.`);
+            if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
+                throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
             }
-            return { round: existingRetry, previousRun: run };
+            return { round, previousRun: run, created: false };
         }
-        if (existingRetry?.status === "running") {
-            const reviewerRunId = existingRetry.reviewerRunId;
+        // Issue 06: a running same Round is reusable only with its exact active
+        // Run and mailbox execution. A stranded Run (no active pointer) falls
+        // through and resets the Round after the identity fences below.
+        if (round.status === "running") {
+            const reviewerRunId = round.reviewerRunId;
             const activeMatches = reviewerRunId !== undefined
                 && activePointer !== null
                 && activePointer.id === reviewerRunId
@@ -3583,12 +3831,24 @@ function retryFailedReviewRun(previous, store, options, now) {
                 && reviewerMailbox?.processing === null
                 && reviewerMailbox.pending?.requestCount === 1
                 && reviewerMailbox.pending.refs.some((ref) => (isDeepStrictEqual(ref, runRef(task.id, reviewerRunId))));
-            if (!activeMatches
-                || (!processingMatches && !pendingMatches)
-                || hasMailboxWork(runtimeMailbox)) {
-                throw usageError(`Existing retry ${existingRetry.id} is running without its exact active Reviewer execution.`);
+            if (activePointer !== null
+                && (!activeMatches
+                    || (!processingMatches && !pendingMatches)
+                    || hasMailboxWork(runtimeMailbox))) {
+                throw usageError(`Existing running ReviewRound ${round.id} lacks its exact active Reviewer execution.`);
             }
-            return { round: existingRetry, previousRun: run };
+            if (activeMatches)
+                return { round, previousRun: run, created: false };
+        }
+        // Issue 06: an already-pending Round is the idempotent retry result.
+        if (round.status === "pending") {
+            if (activePointer !== null || activeReviewerRuns.length > 0) {
+                throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+            }
+            if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
+                throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
+            }
+            return { round, previousRun: run, created: false };
         }
         if (activePointer !== null || activeReviewerRuns.length > 0) {
             throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
@@ -3599,6 +3859,10 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (runtimeMailbox?.pending !== null && runtimeMailbox?.pending !== undefined) {
             throw usageError(`Reviewer runtime lifecycle has pending work: ${reviewer.name}.`);
         }
+        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
+        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"}.`);
+        }
         // A stranded pre-delivery Run can leave its exact pending or processing
         // dispatch behind; settle only that exact reference while holding the
         // same aggregate lock. Any merged or unrelated batch fails closed.
@@ -3622,27 +3886,31 @@ function retryFailedReviewRun(previous, store, options, now) {
         }
         // Terminalize the old stranded Round only after every identity and mailbox
         // fence has passed. The outer transaction rolls back if Round creation fails.
+        let roundToReset = round;
         if (round.status !== "failed") {
             const summary = round.summary
                 ?? run.summary
                 ?? `Review Run ${run.id} failed before delivery.`;
-            tx.saveReviewRound(task.id, finishReviewRound(round, "failed", summary, now, {
+            roundToReset = finishReviewRound(round, "failed", summary, now, {
                 report: round.report ?? summary,
                 checks: round.checks ?? [],
                 ...(round.evidenceCommit === undefined ? {} : { evidenceCommit: round.evidenceCommit })
-            }));
+            });
+            tx.saveReviewRound(task.id, roundToReset);
         }
-        const nextRound = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, item.id, candidate.id, round.reviewerRoleName, "leader", round.taskCandidate, now, taskFinalContract);
-        tx.saveReviewRound(task.id, nextRound);
+        // Issue 06: infra retry resets the same semantic Round to pending instead
+        // of manufacturing a new Round, so Round count and finding identity stay
+        // stable across execution-attempt failures.
+        const resetRound = retryTaskReviewRound(roundToReset);
+        tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "run.review-retried", {
             runId: run.id,
             reviewRoundId: round.id,
-            nextReviewRoundId: nextRound.id,
             candidateId: candidate.id
         }, now);
-        return { round: nextRound, previousRun: run };
+        return { round: resetRound, previousRun: run, created: true };
     });
-    return output(result.round.status === "pending"
+    return output(result.created
         ? `Review retry requested as ${result.round.id}\n`
         : `Review retry already requested as ${result.round.id} (${result.round.status})\n`, { reviewRound: result.round });
 }
@@ -3722,12 +3990,111 @@ function recoverRun(args, store, options) {
         : "";
     return `Recorded exact ${result.action} recovery for ${result.run?.id ?? "unknown Run"}.${followup}\n`;
 }
+/**
+ * Issue 04: builds the terminal yield outcome from the command inputs. The
+ * same construction feeds both the first commit and the idempotent replay, so
+ * a resend always hashes to the same digest.
+ */
+function buildYieldOutcome(run, inputSummary, options) {
+    let yieldedReport;
+    if (run.purpose === "review"
+        || (run.purpose === "execution" && run.executionGroupId !== undefined)) {
+        yieldedReport = parseReviewYieldReport(inputSummary);
+    }
+    const summary = yieldedReport?.summary ?? inputSummary;
+    if (yieldedReport === undefined)
+        return { summary };
+    return {
+        summary,
+        reviewResult: {
+            report: yieldedReport.report,
+            checks: yieldedReport.checks,
+            ...(yieldedReport.findings === undefined ? {} : { findings: yieldedReport.findings }),
+            ...(yieldedReport.evidence === undefined ? {} : { evidence: yieldedReport.evidence }),
+            ...(run.purpose === "review"
+                && options.reviewWorkspaceResult?.evidenceCommit === undefined
+                ? {}
+                : run.purpose === "review"
+                    ? { evidenceCommit: options.reviewWorkspaceResult.evidenceCommit }
+                    : yieldedReport.evidenceCommit === undefined
+                        ? {}
+                        : { evidenceCommit: yieldedReport.evidenceCommit }),
+            ...(options.executionLaneGitSnapshot === undefined
+                || options.executionLaneGitSnapshot === null
+                ? {}
+                : { gitSnapshot: options.executionLaneGitSnapshot })
+        }
+    };
+}
+/**
+ * Issue 04: replays an already-committed yield. Returns the committed receipt
+ * for the same outcome, fails closed for a different outcome, or returns
+ * `null` to keep the legacy "already terminal" behavior.
+ */
+function replayYieldReceipt(run, inputSummary, options) {
+    const config = providerRetryConfig(options.environment ?? process.env);
+    if (!config.yieldReceiptReplay)
+        return null;
+    if (run.yieldReceipt === undefined)
+        return null;
+    const outcome = buildYieldOutcome(run, inputSummary, options);
+    const match = matchYieldReceipt(run.yieldReceipt, {
+        status: "yielded",
+        summary: outcome.summary,
+        ...(outcome.reviewResult === undefined ? {} : { reviewResult: outcome.reviewResult })
+    });
+    if (match === null)
+        return null;
+    if (match.kind === "digest-mismatch") {
+        throw usageError(`Run ${run.id} is already terminal with a different yield outcome. `
+            + `Existing receipt: ${match.existing.receiptId} (request ${match.existing.requestId}).`);
+    }
+    return output(`Run ${run.id} yield already committed.\n`
+        + `Receipt: ${match.receipt.receiptId}\n`
+        + `Request: ${match.receipt.requestId}\n`, { receipt: match.receipt });
+}
+/**
+ * Issue 04: `yui task run yield-status <task>/<run>` — returns the committed
+ * yield receipt for a terminal Run, or the current status for an active Run.
+ */
+function yieldRunStatus(args, store, options) {
+    const usage = "Task run yield-status usage: yui task run yield-status <task>/<run>.";
+    const parsed = parseTail(args, new Set(), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const run = requireRun(store, parsed.positionals[0], options);
+    if (run.status === "active") {
+        return output(`Run ${run.id} is active; no yield receipt yet.\n`, {
+            runId: run.id,
+            status: run.status
+        });
+    }
+    if (run.yieldReceipt === undefined) {
+        return output(`Run ${run.id} is ${run.status}; no yield receipt recorded.\n`, {
+            runId: run.id,
+            status: run.status
+        });
+    }
+    return output(`Run ${run.id} yield receipt:\n`
+        + `Receipt: ${run.yieldReceipt.receiptId}\n`
+        + `Request: ${run.yieldReceipt.requestId}\n`
+        + `Committed: ${run.yieldReceipt.committedAt}\n`, { receipt: run.yieldReceipt });
+}
 function yieldRun(args, store, options) {
     const usage = "Task run yield usage: yui task run yield <task>/<run> (--summary <text>|--summary-file <path|->).";
     const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const inputSummary = readCommandText(parsed.options.get("--summary"), parsed.options.get("--summary-file"), "--summary", usage);
     const now = clock(options);
+    // Issue 04: an already-terminal Run may be a lost-response resend. Match
+    // the presented outcome against the committed receipt before opening the
+    // transaction; the receipt is immutable once committed.
+    const existing = requireRun(store, parsed.positionals[0], options);
+    if (existing.status !== "active") {
+        const replayed = replayYieldReceipt(existing, inputSummary, options);
+        if (replayed !== null)
+            return replayed;
+        throw usageError(`Run ${existing.id} is already terminal: ${existing.status}.`);
+    }
     const yielded = store.transaction((tx) => {
         const active = requireRun(tx, parsed.positionals[0], options);
         if (active.status !== "active") {
@@ -3775,7 +4142,8 @@ function yieldRun(args, store, options) {
                 throw usageError(`Reported Review evidence commit does not match the managed workspace: ${active.id}.`);
             }
         }
-        const summary = yieldedReport?.summary ?? inputSummary;
+        const yieldOutcome = buildYieldOutcome(active, inputSummary, options);
+        const summary = yieldOutcome.summary;
         const terminalization = terminalizeExactTaskRun(tx, {
             taskId: task.id,
             roleName: role.name,
@@ -3789,28 +4157,9 @@ function yieldRun(args, store, options) {
                 ? {}
                 : { launchId: options.environment.YUI_LAUNCH_ID }),
             outcome: { status: "yielded", summary },
-            ...(yieldedReport === undefined
+            ...(yieldOutcome.reviewResult === undefined
                 ? {}
-                : {
-                    reviewResult: {
-                        report: yieldedReport.report,
-                        checks: yieldedReport.checks,
-                        ...(yieldedReport.findings === undefined ? {} : { findings: yieldedReport.findings }),
-                        ...(yieldedReport.evidence === undefined ? {} : { evidence: yieldedReport.evidence }),
-                        ...(active.purpose === "review"
-                            && options.reviewWorkspaceResult?.evidenceCommit === undefined
-                            ? {}
-                            : active.purpose === "review"
-                                ? { evidenceCommit: options.reviewWorkspaceResult.evidenceCommit }
-                                : yieldedReport.evidenceCommit === undefined
-                                    ? {}
-                                    : { evidenceCommit: yieldedReport.evidenceCommit }),
-                        ...(options.executionLaneGitSnapshot === undefined
-                            || options.executionLaneGitSnapshot === null
-                            ? {}
-                            : { gitSnapshot: options.executionLaneGitSnapshot })
-                    }
-                })
+                : { reviewResult: yieldOutcome.reviewResult })
         }, now);
         if (terminalization.disposition !== "applied" || terminalization.run === null) {
             throw usageError(`Run ${active.id} no longer matches its exact execution fence: `
@@ -3978,6 +4327,21 @@ function yieldRun(args, store, options) {
                 ...(terminal.workItemId === undefined ? [] : [workItemRef(task.id, terminal.workItemId)])
             ]);
         }
+        // Issue 05: record the Leader's terminal receipt so the Scheduler can
+        // suppress no-change `task-orphaned` wakes. The disposition and digest are
+        // machine-derived from the post-yield projection; the Leader does not
+        // need to cooperate for the admission check to work.
+        if (role.name === LEADER_ROLE) {
+            const receipt = leaderYieldReceipt(tx, task, terminal, now);
+            if (receipt !== null) {
+                tx.saveAgentRun(receipt);
+                return {
+                    run: receipt,
+                    reviewDispatch,
+                    notifyLeader: leaderHandoff !== null
+                };
+            }
+        }
         return {
             run: terminal,
             reviewDispatch,
@@ -3998,6 +4362,47 @@ function yieldRun(args, store, options) {
             : { reviewRound: yielded.reviewDispatch.round })
     });
 }
+/**
+ * Issue 05: compute the Leader Run terminal receipt (disposition + observed
+ * actionability digest) from the post-yield projection. Returns the updated
+ * Run, or null when the receipt cannot be computed (the caller keeps the
+ * unmodified terminal Run in that case; the Scheduler fails open).
+ */
+function leaderYieldReceipt(tx, task, terminal, now) {
+    try {
+        const projection = buildTaskExecutionProjection(tx, task.id, task);
+        if (projection === null)
+            return null;
+        const disposition = deriveLeaderRunDisposition(projection.status, task.status);
+        const digest = computeActionabilityDigest(collectTaskActionability(tx, task.id));
+        const waitReason = disposition === "waiting" || disposition === "blocked"
+            ? leaderWaitReason(projection)
+            : undefined;
+        return {
+            ...terminal,
+            disposition,
+            observedActionabilityDigest: digest,
+            ...(waitReason === undefined ? {} : { waitReason }),
+            updatedAt: now.toISOString()
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function leaderWaitReason(projection) {
+    const blocker = projection.blockers[0];
+    if (blocker !== undefined) {
+        return { kind: blocker.kind, ref: blocker.id };
+    }
+    if (projection.status === "waiting-on-agents") {
+        return { kind: "delegated-work" };
+    }
+    if (projection.status === "waiting-user") {
+        return { kind: "input" };
+    }
+    return undefined;
+}
 /**
  * Records a structured progress checkpoint for an active Run. This is a durable
  * run fact, not a Task Message: it advances the Run's durable-progress clock so
@@ -4222,6 +4627,9 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 .map(({ projectId, commit }) => `${projectId}@${commit}`)
                 .join(", ")
             : `candidate@${round.reviewBaseCommit}`;
+        const findingContext = taskScope
+            ? buildTaskFinalReviewFindingContext(tx, taskId, round.taskCandidate).context
+            : "";
         const scopeLabel = taskScope ? "Task-final" : "WorkItem";
         const projectPolicyPointers = task.projectBindings
             .map(({ projectId }) => (`yui project show ${projectId}; yui project knowledge list ${projectId}`))
@@ -4238,6 +4646,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             `Review workspace source: exact workspace attached to this Reviewer Lane`,
             `Candidate summary: ${candidate.summary}`,
             `Acceptance criteria: ${item.acceptance.length === 0 ? "none" : item.acceptance.join("; ")}`,
+            ...(taskScope ? [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"