@zq-silk/yui 0.6.13 → 0.6.14

package/dist/commands/taskCommands.js

@@ -15,22 +15,27 @@ import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRo
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
 import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 import { createAgentRun } from "../run/agentRun.js";
+import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.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 { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
+import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } 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";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { createMilestone } from "../milestone/milestone.js";
+import { runPublicationCommand } from "./taskPublicationCommands.js";
 import { enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { mailboxHasWork as workMailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
+import { blockingProviderContinuations, projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { activateTask, addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { formatAgentRunReceiptId, resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { projectCompletionReadiness } from "../task/completionReadiness.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";
@@ -43,13 +48,14 @@ 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 { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastRunLabel, 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 { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
 import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition } from "../scheduler/actionability.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { buildTaskOverview, parseTaskListOptions, renderTaskOverview } from "./taskOverviewCommand.js";
@@ -114,8 +120,8 @@ function taskFinalReviewContractForMutation(store, taskId, options) {
     return stored;
 }
 export function parseTaskCompletionRequest(args, summaryOverride) {
-    const usage = "Task complete usage: yui task complete <id> (--summary <text>|--summary-file <path|->).";
-    const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage);
+    const usage = "Task complete usage: yui task complete <id> (--summary <text>|--summary-file <path|->) [--refresh-remote].";
+    const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage, new Set(["--refresh-remote"]));
     exactPositionals(parsed.positionals, 1, usage);
     const inlineSummary = parsed.options.get("--summary");
     const summaryFile = parsed.options.get("--summary-file");
@@ -131,6 +137,11 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
  * path invokes this same preflight and then repeats its checks while holding
  * the store write fence, so remote reconciliation can never get ahead of the
  * local lifecycle/readiness gate.
+ *
+ * Issue 06: the blocker enumeration is the pure `projectCompletionReadiness`
+ * projection, shared with `task next-action` so the Leader sees every
+ * terminalization precondition before attempting completion.  All blockers
+ * are reported in one error instead of one per attempt.
  */
 export function preflightTaskCompletion(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
@@ -148,64 +159,27 @@ export function preflightTaskCompletion(taskId, store, options = {}) {
     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")));
-    assertNoOpenInputRequests(store, task.id, "completing the Task");
-    const incompleteWork = store.listWorkItems(task.id).find((item) => (item.status !== "completed"
-        && item.status !== "retired"));
-    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.`);
-        }
-        if (store.listChangeSets(task.id).length === 0) {
-            throw usageError(`Task ${task.id} requires at least one ChangeSet before completion.`);
-        }
-        if (!store.listIntegrationAttempts(task.id).some(({ status }) => status === "committed")) {
-            throw usageError(`Task ${task.id} requires a committed Integration Attempt before completion.`);
-        }
-    }
-    const unresolvedIntegration = store.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
-        || integration.status === "blocked"
-        || integration.status === "validating"));
-    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 continuationBlockers = blockingProviderContinuations(store.listEvents(task.id));
-    if (continuationBlockers.length > 0) {
-        throw usageError(`Task ${task.id} has ${continuationBlockers.length} Provider continuation(s) `
-            + "that may still write the Workspace or have an identity conflict.");
-    }
-    const isolatedWorkspace = store.listManagedWorkspaces(task.id)
-        .find(({ owner }) => owner.type === "work-item");
-    if (isolatedWorkspace?.owner.type === "work-item") {
-        throw usageError(`Task ${task.id} has an isolated WorkItem workspace: `
-            + `${isolatedWorkspace.owner.workItemId}. Capture, integrate or abandon it, then clean it up.`);
+    // Issue 06: one shared readiness projection enumerates every blocker.
+    const readinessFacts = store.readCompletionReadinessFacts(task.id);
+    if (readinessFacts === null)
+        throw taskNotFound(task.id);
+    // The finding ledger gate is intentionally deferred: the transactional
+    // completion path runs it after `prepareFinalTaskReview`, which may create
+    // the Task-final Review that resolves `fixed-pending-review` findings.
+    const readiness = projectCompletionReadiness(readinessFacts, { findingsGate: false });
+    // An active Task-final Review is not a preflight failure: the transactional
+    // path resumes a pending Round (or reports the running one) via
+    // `prepareFinalTaskReview`, and the CLI skips remote reconciliation while
+    // `activeTaskReview` is true.  The blocker stays in the shared projection
+    // so other surfaces (next-action, future readers) see the full rule set.
+    const blockers = readiness.blockers.filter((blocker) => blocker.code !== "active-task-review");
+    if (blockers.length > 0) {
+        throw usageError(formatCompletionBlockers(task.id, blockers));
     }
     const roles = store.listRoles(task.id);
     const activeRuns = roles
         .map((role) => ({ role, run: store.getActiveAgentRun(task.id, role.name) }))
         .filter((entry) => entry.run !== null);
-    const workerRun = activeRuns.find(({ role }) => role.name !== LEADER_ROLE);
-    if (workerRun !== undefined) {
-        throw usageError(`Task ${task.id} has an active run for Role ${workerRun.role.name}.`);
-    }
-    const unsettledWork = store.listWorkItems(task.id)
-        .find((item) => item.status === "pending" || item.status === "running");
-    if (unsettledWork !== undefined) {
-        throw usageError(`Task ${task.id} has unsettled work: ${unsettledWork.id}.`);
-    }
     const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
     if (leaderEntry !== undefined) {
         if (actor !== "leader") {
@@ -226,6 +200,15 @@ export function preflightTaskCompletion(taskId, store, options = {}) {
         ...(taskFinalReviewContract === undefined ? {} : { taskFinalReviewContract })
     };
 }
+/**
+ * Issue 06: format every completion blocker into one fail-closed error so the
+ * Leader sees the full remaining work instead of one blocker per attempt.
+ */
+function formatCompletionBlockers(taskId, blockers) {
+    const lines = blockers.map((blocker) => `  ${blocker.code} (${blocker.ref.kind} ${blocker.ref.id}): ${blocker.reason}`
+        + ` — fix: ${blocker.fix}`);
+    return `Task ${taskId} cannot complete: ${blockers.length} blocker(s) remain.\n${lines.join("\n")}`;
+}
 export function runTaskCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     switch (command) {
@@ -242,11 +225,12 @@ 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 "wake": return taskWakeDispatch(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 "publication": return runPublicationCommand(rest, store, options);
         case "role": return taskRoleCommand(rest, store, options);
         case "work": return taskWorkCommand(rest, store, options);
         case "review": return taskReviewCommand(rest, store, options);
@@ -255,6 +239,7 @@ export function runTaskCommand(args, store, options = {}) {
         case "decision": return taskDecisionCommand(rest, store, options);
         case "milestone": return taskMilestoneCommand(rest, store, options);
         case "event": return taskEventCommand(rest, store);
+        case "continuation": return taskContinuationCommand(rest, store);
         case "enter": return enterTaskRoleAlias(rest, store, options);
         default:
             throw usageError(command === undefined
@@ -571,6 +556,8 @@ function showTaskCommand(args, store) {
     const work = store.listWorkItems(task.id);
     const changeSets = store.listChangeSets(task.id);
     const integrations = store.listIntegrationAttempts(task.id);
+    const publications = store.listPublicationReferences(task.id);
+    const verifiedMergedPublications = publications.filter((reference) => (reference.state === "merged" && reference.verification === "verified")).length;
     const counts = {
         messages: messages.length,
         decisions: decisions.length,
@@ -580,6 +567,7 @@ function showTaskCommand(args, store) {
         agentRuns: store.listAgentRuns(task.id).length,
         changeSets: changeSets.length,
         integrations: integrations.length,
+        publications: publications.length,
         openInputs
     };
     const timeZone = store.getConfig().timeZone;
@@ -615,6 +603,7 @@ function showTaskCommand(args, store) {
         `Agent Runs: ${counts.agentRuns}`,
         `ChangeSets: ${counts.changeSets}`,
         `Integration Attempts: ${counts.integrations}`,
+        `Publication references: ${counts.publications} (${verifiedMergedPublications} verified merged)`,
         `Open inputs: ${counts.openInputs}`,
         `Created: ${presentTime(task.createdAt, timeZone)}`,
         `Updated: ${presentTime(task.updatedAt, timeZone)}`
@@ -673,20 +662,10 @@ function completeTaskCommand(args, store, options) {
         const activeRuns = roles
             .map((role) => ({ role, run: tx.getActiveAgentRun(task.id, role.name) }))
             .filter((entry) => entry.run !== null);
-        const workerRun = activeRuns.find(({ role }) => role.name !== LEADER_ROLE);
-        if (workerRun !== undefined) {
-            throw usageError(`Task ${task.id} has an active run for Role ${workerRun.role.name}.`);
-        }
-        const unsettledWork = tx.listWorkItems(task.id)
-            .find((item) => item.status === "pending" || item.status === "running");
-        if (unsettledWork !== undefined) {
-            throw usageError(`Task ${task.id} has unsettled work: ${unsettledWork.id}.`);
-        }
-        const continuationBlockers = blockingProviderContinuations(tx.listEvents(task.id));
-        if (continuationBlockers.length > 0) {
-            throw usageError(`Task ${task.id} has ${continuationBlockers.length} Provider continuation(s) `
-                + "that may still write the Workspace or have an identity conflict.");
-        }
+        // The preflight (above, same transaction) already projected the full
+        // readiness via projectCompletionReadiness.  The leader-Run check is
+        // actor-dependent and stays here; every other blocker is re-validated by
+        // the post-Review readiness fence below.
         let terminalizedLeaderRun = false;
         const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
         if (leaderEntry !== undefined) {
@@ -730,21 +709,18 @@ 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.");
+        // Issue 06: re-validate the full completion readiness inside the
+        // transaction (the CAS fence) after final-review preparation.  This is the
+        // same pure projection `task next-action` displays, now with the finding
+        // ledger gate enabled: `fixed-pending-review` findings that the prepared
+        // Review would resolve are no longer blocked, but once no Review is needed
+        // every remaining blocker fails closed with the fresh list.
+        const readinessFacts = tx.readCompletionReadinessFacts(task.id);
+        if (readinessFacts === null)
+            throw taskNotFound(task.id);
+        const readiness = projectCompletionReadiness(readinessFacts);
+        if (!readiness.ready) {
+            throw usageError(formatCompletionBlockers(task.id, readiness.blockers));
         }
         const completed = completeTask(task, now, { by: actor, summary });
         tx.saveTask(completed);
@@ -823,8 +799,9 @@ function reopenTaskCommand(args, store, options) {
             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)]);
+            const reopenedReason = wakeReason("task-reopened");
+            enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
+            enqueueWork(tx, taskMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
             recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
             return { task: active, changed: true };
         });
@@ -1133,9 +1110,25 @@ function taskMessageCommand(args, store, options) {
         return `Sent message ${result.message.id} to ${result.task.id}\n`;
     }
     if (command === "list") {
-        exactPositionals(rest, 1, "Task message list usage: yui task message list <id>.");
-        const task = requireTask(store, rest[0]);
-        const messages = store.listMessages(task.id);
+        const messageListUsage = "Task message list usage: yui task message list <id> [--after <timestamp>] [--limit <n>].";
+        const parsed = parseTail(rest, new Set(["--after", "--limit"]), messageListUsage);
+        exactPositionals(parsed.positionals, 1, messageListUsage);
+        const task = requireTask(store, parsed.positionals[0]);
+        let messages = store.listMessages(task.id);
+        const after = optionalNonEmptyOption(parsed.options, "--after");
+        if (after !== undefined) {
+            const afterMs = Date.parse(after);
+            if (!Number.isFinite(afterMs))
+                throw usageError("--after must be a valid timestamp.", messageListUsage);
+            messages = messages.filter((m) => Date.parse(m.createdAt) > afterMs);
+        }
+        const limit = optionalNonEmptyOption(parsed.options, "--limit");
+        if (limit !== undefined) {
+            const n = Number(limit);
+            if (!Number.isSafeInteger(n) || n <= 0)
+                throw usageError("--limit must be a positive integer.", messageListUsage);
+            messages = messages.slice(-n);
+        }
         if (messages.length === 0)
             return "No messages found.\n";
         const timeZone = store.getConfig().timeZone;
@@ -1160,7 +1153,7 @@ function taskMessageCommand(args, store, options) {
  * enqueues exactly one Leader wakeup with an auditable reason. The reason is
  * truncated to keep the event payload compact.
  */
-function taskWakeCommand(args, store, options) {
+function taskWakeForceCommand(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);
@@ -1171,13 +1164,13 @@ function taskWakeCommand(args, store, options) {
     const now = clock(options);
     const task = requireTask(store, parsed.positionals[0]);
     assertTaskOpen(task);
-    const wakeReason = `force-wake:${truncateEventNote(reason)}`;
+    const wakeReasonTag = wakeReason("force-wake", truncateEventNote(reason));
     store.transaction((tx) => {
-        queueLeaderWakeup(tx, task.id, wakeReason, now);
-        recordTaskEvent(tx, task.id, "task.wake-forced", { reason: wakeReason }, now);
+        queueLeaderWakeup(tx, task.id, wakeReasonTag, now);
+        recordTaskEvent(tx, task.id, "task.wake-forced", { reason: wakeReasonTag }, now);
     });
     notifyMailbox(options.runtime, leaderMailbox(task.id), task.id);
-    return `Woke ${task.id} (${wakeReason})\n`;
+    return `Woke ${task.id} (${wakeReasonTag})\n`;
 }
 function taskRoleCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -1313,6 +1306,7 @@ function listTaskRoles(args, store, options) {
         { header: "Health", minWidth: 6, maxWidth: 15 },
         { header: "Open input", minWidth: 5, maxWidth: 10 },
         { header: "Active work", minWidth: 10, maxWidth: 34 },
+        { header: "Last run", minWidth: 10, maxWidth: 28 },
         { header: "Native session", minWidth: 10, maxWidth: 28 },
         { header: "tmux", minWidth: 6, maxWidth: 22 }
     ], statuses.map((status) => [
@@ -1321,6 +1315,7 @@ function listTaskRoles(args, store, options) {
         status.health,
         taskRoleOpenInputLabel(status),
         taskRoleActiveWorkLabel(status),
+        taskRoleLastRunLabel(status),
         taskRoleNativeSessionLabel(status),
         taskRoleTmuxLabel(status)
     ]), defaultTableWidth())}\n`, { roles: statuses });
@@ -2806,12 +2801,14 @@ function extractReviewFindingsCommand(args, store, options) {
         + `${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);
+    const usage = "Task review request usage: yui task review request <task> --role <global-role> "
+        + "[--strategy fixed:<count>|adaptive:<max>] [--lane-role <role> ...] [--delta-recheck].";
+    const parsed = parseMultiValueTail(args, new Set(["--role", "--strategy"]), new Set(["--lane-role"]), usage, new Set(["--delta-recheck"]));
     exactPositionals(parsed.positionals, 1, usage);
     const reviewerRoleName = requiredOption(parsed.options, "--role");
     const requestedStrategy = parseExecutionStrategy(parsed.options.get("--strategy"), usage);
     const requestedLaneRoles = parsed.multiOptions.get("--lane-role") ?? [];
+    const deltaRecheckRequested = parsed.options.has("--delta-recheck");
     const now = clock(options);
     const round = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
@@ -2824,6 +2821,17 @@ function requestTaskReviewRound(args, store, options) {
             throw usageError(`Task ${task.id} has no bound Projects for a Task-final Review.`);
         }
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
+        if (deltaRecheckRequested) {
+            const reviewConfig = tx.getReviewConfig();
+            if (reviewConfig === null || reviewConfig.deltaRecheck !== "enabled") {
+                throw usageError("Delta-recheck is not enabled for this Project's review policy. "
+                    + "Set `yui config set review --role <role> --trigger final --delta-recheck enabled` "
+                    + "or request a full Review.");
+            }
+            if (taskFinalContract !== undefined) {
+                throw usageError("Delta-recheck is not supported with a Task-final review contract.");
+            }
+        }
         if (tx.getGlobalRole(reviewerRoleName) === null) {
             throw usageError(`Global Role not found: ${reviewerRoleName}.`);
         }
@@ -2838,7 +2846,8 @@ function requestTaskReviewRound(args, store, options) {
         const exact = taskRounds.filter((entry) => (entry.reviewerRoleName === reviewerRoleName
             && (taskFinalContract === undefined || sameTaskFinalReviewContract(entry.taskFinalReviewContract, taskFinalContract))
             && isSameTaskReviewCandidate(entry.taskCandidate, provenance.candidate))).at(-1);
-        if (exact !== undefined) {
+        if (exact !== undefined
+            && (deltaRecheckRequested || !deltaRecheckBlocksAcceptance(exact))) {
             if (exact.status === "failed") {
                 throw usageError(`Explicit Task-final ReviewRound ${exact.id} is failed for this exact candidate; resolve it before requesting again.`);
             }
@@ -2941,7 +2950,16 @@ function requestTaskReviewRound(args, store, options) {
             }
             assertTaskReviewRequestLane(tx, task.id, laneRole.name);
         }
-        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, anchor.item.id, anchor.candidate.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract);
+        let deltaRecord;
+        if (deltaRecheckRequested) {
+            if (requestedLaneRoles.length > 0 || requestedStrategy !== undefined) {
+                throw usageError("Delta-recheck supports only the default single Reviewer Lane.");
+            }
+            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);
         let group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
             target: executionTargetForReviewRound(task, created, anchor.item, anchor.candidate),
@@ -2953,20 +2971,80 @@ function requestTaskReviewRound(args, store, options) {
             executionGroup: group
         };
         tx.saveReviewRound(task.id, created);
+        // Issue 07: when a full Review is created after a non-accepting delta
+        // disposition, record the escalation lineage on the delta Round.
+        if (exact !== undefined
+            && deltaRecheckBlocksAcceptance(exact)
+            && created.deltaRecheck === undefined
+            && exact.deltaRecheck !== undefined
+            && exact.deltaRecheck.escalatedToReviewRoundId === undefined) {
+            tx.saveReviewRound(task.id, {
+                ...exact,
+                deltaRecheck: {
+                    ...exact.deltaRecheck,
+                    escalatedToReviewRoundId: created.id
+                }
+            });
+        }
         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)
+            taskCandidate: JSON.stringify(created.taskCandidate),
+            ...(created.deltaRecheck === undefined
+                ? {}
+                : {
+                    deltaRecheck: "true",
+                    previousReviewRoundId: created.deltaRecheck.previousReviewRoundId,
+                    diffDigest: created.deltaRecheck.diffDigest
+                })
         }, now);
         return created;
     });
     return output(round.status === "pending"
-        ? `Task-final Review requested as ${round.id}\n`
+        ? round.deltaRecheck === undefined
+            ? `Task-final Review requested as ${round.id}\n`
+            : `Task-final delta-recheck requested as ${round.id} (rechecks ${round.deltaRecheck.previousReviewRoundId})\n`
         : `Task-final Review is already ${round.status}: ${round.id}\n`, { reviewRound: round });
 }
+/**
+ * Issue 07: re-validates the CLI-computed delta preflight inside the store
+ * transaction.  The previous Round must be a completed acceptance (a full
+ * Review or an equivalent-and-accepted delta) so a delta never extends a
+ * non-accepting disposition.
+ */
+function validateDeltaRecheckRequest(store, taskId, reviewerRoleName, candidate, preflight) {
+    if (preflight === undefined) {
+        throw usageError("Delta-recheck assessment is missing; the CLI preflight did not run. "
+            + "Request a full Review or retry with a current CLI.");
+    }
+    const previous = store.getReviewRound(taskId, preflight.record.previousReviewRoundId);
+    if (previous === null
+        || (previous.scope ?? "work-item") !== "task"
+        || previous.status !== "completed") {
+        throw usageError(`Delta-recheck previous ReviewRound is not a completed Task-final Review: `
+            + `${preflight.record.previousReviewRoundId}.`);
+    }
+    if (previous.reviewerRoleName !== reviewerRoleName) {
+        throw usageError(`Delta-recheck Reviewer Role must match the previous acceptance: `
+            + `${previous.reviewerRoleName}.`);
+    }
+    if (previous.reviewBaseCommit !== preflight.record.previousBaseCommit) {
+        throw usageError("Delta-recheck previous base commit does not match the recorded acceptance.");
+    }
+    // A delta may only extend an acceptance, never a finding or an escalation.
+    if (previous.deltaRecheck !== undefined
+        && previous.deltaRecheck.disposition !== "equivalent-and-accepted") {
+        throw usageError(`Delta-recheck cannot extend ${previous.id}: its disposition is `
+            + `${previous.deltaRecheck.disposition}. Resolve it with a full Review first.`);
+    }
+    if (candidate.projects[0].commit === preflight.record.previousBaseCommit) {
+        throw usageError("Delta-recheck candidate head is unchanged; the previous acceptance already covers it.");
+    }
+    return preflight.record;
+}
 function assertTaskReviewRequestLane(store, taskId, reviewerRoleName, reusableRound) {
     const reviewerMailbox = store.getWorkMailbox(roleMailbox(taskId, reviewerRoleName));
     const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
@@ -3137,6 +3215,8 @@ function taskRunCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "list")
         return output(listRuns(rest, store, options));
+    if (command === "show")
+        return showRun(rest, store, options);
     if (command === "retry")
         return retryRun(rest, store, options);
     if (command === "settle")
@@ -3717,7 +3797,33 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
         // review evidence. Do not create duplicate rounds on repeated completion
         // attempts. A failed round remains a blocker until the Leader changes the
         // candidate or otherwise resolves the failed evidence explicitly.
-        return latest.status === "completed" ? null : latest;
+        // Issue 07: a completed delta-recheck that did not accept the head is not
+        // final evidence.  A `requires-full-review` disposition escalates to a new
+        // full Review; a `finding` disposition stays a blocker for the Leader.
+        if (latest.status === "completed"
+            && 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);
+            // 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) {
+                store.saveReviewRound(task.id, {
+                    ...latest,
+                    deltaRecheck: {
+                        ...latest.deltaRecheck,
+                        escalatedToReviewRoundId: escalated.id
+                    }
+                });
+            }
+            return escalated;
+        }
+        else {
+            return latest.status === "completed" ? null : latest;
+        }
     }
     const anchor = taskFinalContract === undefined
         ? latestTaskReviewAnchor(store, task)
@@ -3997,11 +4103,12 @@ function retryFailedReviewRun(previous, store, options, now) {
  * another input or changes a native generation from this command.
  */
 function recoverRun(args, store, options) {
-    const usage = "Task run recover usage: yui task run recover <task>/<run> --action <diagnose|retry|replace-session|terminate> --expected-progress-at <timestamp> --provider-acceptance <accepted|rejected|ambiguous> --reason <text> [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
+    const usage = "Task run recover usage: yui task run recover <task>/<run> --action <diagnose|retry|replace-session|terminate> (--expected-progress-at <timestamp>|--from-next-action <fingerprint>) --provider-acceptance <accepted|rejected|ambiguous> --reason <text> [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
     const parsed = parseTail(args, new Set([
         "--action",
         "--expected-progress-at",
         "--progress-at",
+        "--from-next-action",
         "--provider-acceptance",
         "--reason",
         "--role",
@@ -4012,6 +4119,12 @@ function recoverRun(args, store, options) {
     ]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const now = clock(options);
+    const fingerprint = parsed.options.get("--from-next-action");
+    const explicitFence = parsed.options.get("--expected-progress-at")
+        ?? parsed.options.get("--progress-at");
+    if (fingerprint !== undefined && explicitFence !== undefined) {
+        throw usageError("--from-next-action and --expected-progress-at/--progress-at are mutually exclusive.", usage);
+    }
     const input = store.transaction((tx) => {
         const active = requireRun(tx, parsed.positionals[0], options);
         const task = requireTask(tx, active.taskId);
@@ -4027,17 +4140,41 @@ function recoverRun(args, store, options) {
         const role = requireRole(tx, task.id, roleName);
         const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
         const session = sessions?.sessions[sessions.activeAgentId];
-        const action = parseRecoveryAction(parsed.options.get("--action"), usage);
-        const expectedProgressAt = parsed.options.get("--expected-progress-at")
-            ?? parsed.options.get("--progress-at");
-        if (expectedProgressAt === undefined)
+        // Issue 08: a fingerprint copied from `task run show` resolves the
+        // canonical fence server-side. The projection is recomputed here, so a
+        // fingerprint from stale observations matches nothing and fails closed.
+        let plan = null;
+        if (fingerprint !== undefined) {
+            const facts = readRunRecoveryFacts(tx, task.id, active.id);
+            if (facts === null)
+                throw usageError(`Agent Run not found: ${task.id}/${active.id}.`, usage);
+            const projection = projectRunRecovery(facts);
+            plan = projection.actions.find((entry) => entry.fingerprint === fingerprint) ?? null;
+            if (plan === null) {
+                throw usageError(runRecoveryStaleDiagnosis(task.id, active.id, projection.canonicalProgressAt ?? null, "recovery action fingerprint is stale or unknown"), usage);
+            }
+        }
+        const action = parseRecoveryAction(parsed.options.get("--action") ?? plan?.action, usage);
+        if (plan !== null && plan.action !== action) {
+            throw usageError(`--action ${action} does not match recovery fingerprint action ${plan.action}.`, usage);
+        }
+        const expectedProgressAt = explicitFence ?? plan?.expectedProgressAt;
+        if (expectedProgressAt === undefined) {
             throw usageError("--expected-progress-at is required.", usage);
+        }
         const providerAcceptance = parseProviderAcceptance(parsed.options.get("--provider-acceptance"), usage);
-        const agentId = parsed.options.get("--agent-id") ?? active.effective.agentId;
-        const adapterId = parsed.options.get("--adapter-id") ?? active.effective.adapterId;
+        const agentId = parsed.options.get("--agent-id")
+            ?? plan?.agentId
+            ?? active.effective.agentId;
+        const adapterId = parsed.options.get("--adapter-id")
+            ?? plan?.adapterId
+            ?? active.effective.adapterId;
         const nativeSessionId = parsed.options.get("--native-session-id")
+            ?? plan?.nativeSessionId
             ?? session?.nativeSessionId;
-        const launchId = parsed.options.get("--launch-id") ?? session?.launchId;
+        const launchId = parsed.options.get("--launch-id")
+            ?? plan?.launchId
+            ?? session?.launchId;
         return {
             taskId: task.id,
             roleName: role.name,
@@ -4055,7 +4192,7 @@ function recoverRun(args, store, options) {
     });
     const result = recoverExactAgentRun(store, input);
     if (result.disposition !== "applied") {
-        throw usageError(`Exact Run recovery ${result.disposition}: ${result.reason ?? "state changed"}.`, usage);
+        throw usageError(runRecoveryStaleDiagnosis(input.taskId, input.runId, result.progressAt ?? null, `exact Run recovery ${result.disposition}: ${result.reason ?? "state changed"}`), usage);
     }
     // The durable recovery request is committed before asking the Controller to
     // wake the owning Leader; a failed transaction must not leak a signal.
@@ -4067,6 +4204,86 @@ function recoverRun(args, store, options) {
         : "";
     return `Recorded exact ${result.action} recovery for ${result.run?.id ?? "unknown Run"}.${followup}\n`;
 }
+/**
+ * Issue 08: every recovery rejection carries the current canonical fence and
+ * points at the single read-only command that projects it. The caller's
+ * side-effecting action is never retried automatically.
+ */
+function runRecoveryStaleDiagnosis(taskId, runId, canonicalProgressAt, detail) {
+    const fence = canonicalProgressAt === null
+        ? "no durable progress timestamp is available for this Run"
+        : `the canonical durable fence is now ${canonicalProgressAt}`;
+    return `${detail}; ${fence}. Re-read the recovery plan: yui task run show ${taskId}/${runId}.`;
+}
+/**
+ * Issue 08: read-only Run detail with the canonical recovery fence, Provider
+ * evidence, and every exact recovery action. Never mutates state and never
+ * selects an action or Provider acceptance for the Leader.
+ */
+function showRun(args, store, options) {
+    const usage = "Task run show usage: yui task run show <task>/<run> [--json].";
+    const asJson = args.includes("--json");
+    const positionals = args.filter((arg) => arg !== "--json");
+    exactPositionals(positionals, 1, usage);
+    const data = store.transaction((tx) => {
+        const run = requireRun(tx, positionals[0], options);
+        const facts = readRunRecoveryFacts(tx, run.taskId, run.id);
+        if (facts === null)
+            throw usageError(`Agent Run not found: ${run.taskId}/${run.id}.`, usage);
+        return { run, recovery: projectRunRecovery(facts) };
+    });
+    if (asJson) {
+        return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
+    }
+    return { kind: "output", output: renderRunShow(data.run, data.recovery), data };
+}
+function renderRunShow(run, recovery) {
+    const lines = [
+        `Run: ${run.id}`,
+        `Task: ${run.taskId}`,
+        `Role: ${run.roleName}`,
+        `Purpose: ${run.purpose}`,
+        `Mode: ${run.mode}`,
+        `Status: ${run.status}`,
+        `Effective: ${run.effective.agentId}/${run.effective.adapterId} r${run.effective.sourceDesiredRevision}`,
+        `Created: ${run.createdAt}`,
+        ...(run.pushedAt === undefined ? [] : [`Pushed: ${run.pushedAt}`]),
+        ...(run.deliveredAt === undefined
+            ? []
+            : [`Provider accepted (durable): ${run.deliveredAt}`]),
+        ...(run.summary === undefined || run.summary.trim().length === 0
+            ? []
+            : [`Summary: ${run.summary}`])
+    ];
+    if (recovery.canonicalProgressAt !== null) {
+        lines.push(`Canonical recovery fence (Yui durable CAS): ${recovery.canonicalProgressAt}`, ...(recovery.canonicalProgressEvidence === undefined
+            ? []
+            : [`Fence evidence: ${recovery.canonicalProgressEvidence}`]));
+    }
+    if (recovery.provider.observedAt !== null) {
+        lines.push(`Provider observation (evidence only, not a fence): `
+            + `${recovery.provider.observationKind} at ${recovery.provider.observedAt}`);
+    }
+    if (recovery.session !== null) {
+        const session = recovery.session;
+        lines.push(`Session: ${session.status}`
+            + `${session.nativeSessionId === undefined ? "" : ` ${session.nativeSessionId}`}`
+            + `${session.launchId === undefined ? "" : ` launch ${session.launchId}`}`);
+    }
+    if (recovery.recoverable) {
+        lines.push(`Provider acceptance options: ${recovery.providerAcceptance.options.join(", ")}`, "Recovery actions (copy one; the fence is already canonical):");
+        for (const plan of recovery.actions) {
+            lines.push(`  [${plan.action}] ${plan.reason}`, `    ${plan.command}`);
+        }
+        if (recovery.judgmentRequired !== undefined) {
+            lines.push(`Judgment: ${recovery.judgmentRequired}`);
+        }
+    }
+    else {
+        lines.push(`Not recoverable: ${recovery.reason ?? "unknown"}`);
+    }
+    return `${lines.join("\n")}\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
@@ -4099,7 +4316,13 @@ function buildYieldOutcome(run, inputSummary, options) {
             ...(options.executionLaneGitSnapshot === undefined
                 || options.executionLaneGitSnapshot === null
                 ? {}
-                : { gitSnapshot: options.executionLaneGitSnapshot })
+                : { gitSnapshot: options.executionLaneGitSnapshot }),
+            ...(yieldedReport.deltaDisposition === undefined
+                ? {}
+                : { deltaDisposition: yieldedReport.deltaDisposition }),
+            ...(yieldedReport.deltaReasoning === undefined
+                ? {}
+                : { deltaReasoning: yieldedReport.deltaReasoning })
         }
     };
 }
@@ -4108,9 +4331,8 @@ function buildYieldOutcome(run, inputSummary, options) {
  * 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)
+function replayYieldReceipt(run, inputSummary, options, retryConfig) {
+    if (!retryConfig.yieldReceiptReplay)
         return null;
     if (run.yieldReceipt === undefined)
         return null;
@@ -4167,7 +4389,7 @@ function yieldRun(args, store, options) {
     // 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);
+        const replayed = replayYieldReceipt(existing, inputSummary, options, providerRetryConfig(store.getConfig()));
         if (replayed !== null)
             return replayed;
         throw usageError(`Run ${existing.id} is already terminal: ${existing.status}.`);
@@ -4292,7 +4514,15 @@ function yieldRun(args, store, options) {
                     reviewBaseCommit: round.reviewBaseCommit,
                     evidenceCommit: round.evidenceCommit ?? "none",
                     checks: round.checks?.map(({ name, outcome }) => `${name}:${outcome}`)
-                        .join(",") || "none"
+                        .join(",") || "none",
+                    ...(round.deltaRecheck === undefined
+                        ? {}
+                        : {
+                            reviewMode: "delta-recheck",
+                            deltaDisposition: round.deltaRecheck.disposition ?? "requires-full-review",
+                            previousReviewRoundId: round.deltaRecheck.previousReviewRoundId,
+                            diffDigest: round.deltaRecheck.diffDigest
+                        })
                 }, now);
             }
         }
@@ -4707,6 +4937,30 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         const findingContext = taskScope
             ? buildTaskFinalReviewFindingContext(tx, taskId, round.taskCandidate).context
             : "";
+        let deltaContext = "";
+        if (taskScope && round.deltaRecheck !== undefined) {
+            const previousRound = tx.getReviewRound(taskId, round.deltaRecheck.previousReviewRoundId);
+            if (previousRound === null || previousRound.status !== "completed") {
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck previous ReviewRound is unavailable: ${round.deltaRecheck.previousReviewRoundId}.`);
+            }
+            const diffByProject = options.deltaRecheckDiff;
+            if (diffByProject === undefined) {
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck diff is missing for ${round.id}; the CLI preflight did not run.`);
+            }
+            try {
+                verifyDeltaRecheckDiff(round.deltaRecheck, diffByProject);
+            }
+            catch (error) {
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck diff verification failed for ${round.id}: `
+                    + `${error instanceof Error ? error.message : String(error)}`);
+            }
+            deltaContext = buildDeltaRecheckDispatchContext({
+                round,
+                previousRound,
+                diffByProject,
+                ledgerContext: findingContext
+            });
+        }
         const scopeLabel = taskScope ? "Task-final" : "WorkItem";
         const projectPolicyPointers = task.projectBindings
             .map(({ projectId }) => (`yui project show ${projectId}; yui project knowledge list ${projectId}`))
@@ -4723,10 +4977,10 @@ 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] : []),
+            ...(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.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."]
                 : []),
             "You may freely edit source/tests, run local build or test commands, and optionally commit diagnostic evidence only inside this ReviewRound-owned workspace.",
@@ -5482,9 +5736,25 @@ function taskMilestoneCommand(args, store, options) {
 function taskEventCommand(args, store) {
     const [command, ...rest] = args;
     if (command === "list") {
-        exactPositionals(rest, 1, "Task event list usage: yui task event list <task>.");
-        const task = requireTask(store, rest[0]);
-        const events = store.listEvents(task.id);
+        const eventListUsage = "Task event list usage: yui task event list <task> [--after <timestamp>] [--limit <n>].";
+        const parsed = parseTail(rest, new Set(["--after", "--limit"]), eventListUsage);
+        exactPositionals(parsed.positionals, 1, eventListUsage);
+        const task = requireTask(store, parsed.positionals[0]);
+        let events = store.listEvents(task.id);
+        const after = optionalNonEmptyOption(parsed.options, "--after");
+        if (after !== undefined) {
+            const afterMs = Date.parse(after);
+            if (!Number.isFinite(afterMs))
+                throw usageError("--after must be a valid timestamp.", eventListUsage);
+            events = events.filter((e) => Date.parse(e.createdAt) > afterMs);
+        }
+        const limit = optionalNonEmptyOption(parsed.options, "--limit");
+        if (limit !== undefined) {
+            const n = Number(limit);
+            if (!Number.isSafeInteger(n) || n <= 0)
+                throw usageError("--limit must be a positive integer.", eventListUsage);
+            events = events.slice(-n);
+        }
         if (events.length === 0) {
             return output(`No events found for ${task.id}.\n`, { taskId: task.id, events: [] });
         }
@@ -5518,6 +5788,187 @@ function taskEventCommand(args, store) {
         ? "Task event command is required."
         : `Unknown command: task event ${command}`);
 }
+/**
+ * Issue 13: native child durability visibility. A native Provider subagent is
+ * best-effort until Yui persists its result content; once a continuation
+ * report carries a result digest receipt the child is durable-result and its
+ * full content stays readable through the referenced Task event.
+ */
+function taskContinuationCommand(args, store) {
+    const [command, ...rest] = args;
+    if (command !== "list") {
+        throw usageError(command === undefined
+            ? "Task continuation command is required."
+            : `Unknown command: task continuation ${command}`);
+    }
+    const usage = "Task continuation list usage: yui task continuation list <task> [--json].";
+    const asJson = rest.includes("--json");
+    const positionals = rest.filter((arg) => arg !== "--json");
+    exactPositionals(positionals, 1, usage);
+    const task = requireTask(store, positionals[0]);
+    const events = store.listEvents(task.id);
+    const continuations = projectProviderContinuations(events);
+    const reportEvents = continuationReportEvents(events);
+    const rows = continuations.map((continuation) => {
+        const identity = continuation.identity;
+        const report = [...continuation.reports].reverse()[0];
+        const reportEvent = report === undefined
+            ? undefined
+            : reportEvents.find((entry) => (entry.continuationId === identity.continuationId
+                && entry.continuationGeneration === identity.generation
+                && entry.reportId === report.reportId));
+        return Object.freeze({
+            continuationId: identity.continuationId,
+            generation: identity.generation,
+            driver: identity.providerNamespace,
+            runId: continuation.runId,
+            execution: continuation.execution,
+            outcome: continuation.outcome,
+            attachment: continuation.attachment,
+            durability: continuation.durability,
+            ...(report?.resultDigest === undefined
+                ? {}
+                : { resultDigest: report.resultDigest }),
+            ...(report?.resultSize === undefined
+                ? {}
+                : { resultSize: report.resultSize }),
+            ...(reportEvent === undefined ? {} : { resultEvent: reportEvent.event.id }),
+            ...(continuation.settledAt === undefined ? {} : { settledAt: continuation.settledAt })
+        });
+    });
+    if (asJson) {
+        return output(`${JSON.stringify({ taskId: task.id, continuations: rows }, null, 2)}\n`, { taskId: task.id, continuations: rows });
+    }
+    if (rows.length === 0) {
+        return output(`No native child continuations found for ${task.id}.\n`, { taskId: task.id, continuations: rows });
+    }
+    const timeZone = store.getConfig().timeZone;
+    return output(`${renderTable(`Native child continuations: ${task.id}`, [
+        { header: "Child", minWidth: 8, maxWidth: 24 },
+        { header: "Driver", minWidth: 8, maxWidth: 24 },
+        { header: "Execution", minWidth: 8, maxWidth: 12 },
+        { header: "Outcome", minWidth: 8, maxWidth: 12 },
+        { header: "Durability", minWidth: 10, maxWidth: 16 },
+        { header: "Result", minWidth: 8, maxWidth: 24 },
+        { header: "Settled", minWidth: 10, maxWidth: 28 }
+    ], rows.map((row) => [
+        row.continuationId,
+        row.driver,
+        row.execution,
+        row.outcome,
+        row.durability,
+        row.resultEvent ?? (row.resultDigest === undefined ? "-" : `digest:${row.resultDigest.slice(0, 12)}`),
+        ...(row.settledAt === undefined ? ["-"] : [presentTime(row.settledAt, timeZone)])
+    ]), defaultTableWidth())}\n`, { taskId: task.id, continuations: rows });
+}
+function continuationReportEvents(events) {
+    const result = [];
+    for (const event of events) {
+        const observation = runtimeObservationFromTaskEvent(event);
+        if (observation !== null && observation.kind === "continuation.reported") {
+            const continuationId = observation.fence.continuationId;
+            const continuationGeneration = observation.fence.continuationGeneration;
+            const reportId = observation.payload?.reportId;
+            if (continuationId !== undefined
+                && continuationGeneration !== undefined
+                && reportId !== undefined) {
+                result.push({ event, continuationId, continuationGeneration, reportId });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Issue 04 (long-term): the durable wake ledger. `wake list` shows the
+ * dispatch history; `wake show` returns the structured delta content for one
+ * wake — the on-demand read the Agent uses instead of a context dump in the
+ * wake envelope.
+ */
+function taskWakeDispatch(args, store, options) {
+    const [subcommand] = args;
+    if (subcommand === "list" || subcommand === "show") {
+        return taskWakeInspectionCommand(args, store);
+    }
+    return output(taskWakeForceCommand(args, store, options));
+}
+/**
+ * Issue 04 (long-term): the durable wake ledger. `wake list` shows the
+ * dispatch history; `wake show` returns the structured delta content for one
+ * wake — the on-demand read the Agent uses instead of a context dump in the
+ * wake envelope.
+ */
+function taskWakeInspectionCommand(args, store) {
+    const [command, ...rest] = args;
+    if (command === "list") {
+        const usage = "Task wake list usage: yui task wake list <task>.";
+        exactPositionals(rest, 1, usage);
+        const task = requireTask(store, rest[0]);
+        const wakes = store.listTaskWakes(task.id);
+        if (wakes.length === 0) {
+            return output(`No wakes recorded for ${task.id}.\n`, { taskId: task.id, wakes: [] });
+        }
+        const timeZone = store.getConfig().timeZone;
+        return output(`${renderTable(`Wakes: ${task.id}`, [
+            { header: "Wake", minWidth: 8, maxWidth: 18 },
+            { header: "Status", minWidth: 8, maxWidth: 12 },
+            { header: "Reasons", minWidth: 10, maxWidth: 40 },
+            { header: "Run", minWidth: 10, maxWidth: 20 },
+            { header: "Dispatched", minWidth: 10, maxWidth: 28 }
+        ], wakes.map((wake) => [
+            wake.id,
+            wake.status,
+            wake.reasons.map(renderWakeReason).join(", "),
+            wake.runId ?? "-",
+            presentTime(wake.createdAt, timeZone)
+        ]), defaultTableWidth())}\n`, { taskId: task.id, wakes });
+    }
+    if (command === "show") {
+        const usage = "Task wake show usage: yui task wake show <task> <wake>.";
+        exactPositionals(rest, 2, usage);
+        const task = requireTask(store, rest[0]);
+        const wake = store.getTaskWake(task.id, rest[1]);
+        if (wake === null)
+            throw dataError(`Wake not found: ${rest[1]}.`);
+        const timeZone = store.getConfig().timeZone;
+        const fromMs = Date.parse(wake.fromCursor);
+        const toMs = Date.parse(wake.toCursor);
+        const inWindow = (createdAt) => {
+            const ms = Date.parse(createdAt);
+            return ms > fromMs && ms <= toMs;
+        };
+        const events = store.listEvents(task.id).filter((e) => inWindow(e.createdAt));
+        const messages = store.listMessages(task.id).filter((m) => inWindow(m.createdAt));
+        const runs = store.listAgentRuns(task.id).filter((r) => inWindow(r.createdAt));
+        const lines = [
+            `Wake: ${wake.id}`,
+            `Task: ${task.id}`,
+            `Status: ${wake.status}`,
+            `Reasons: ${wake.reasons.map(renderWakeReason).join(", ")}`,
+            `Delta window: ${wake.fromCursor} → ${wake.toCursor}`,
+            ...(wake.runId === undefined ? [] : [`Run: ${wake.runId}`]),
+            `Dispatched: ${presentTime(wake.createdAt, timeZone)}`,
+            ...(wake.consumedAt === undefined
+                ? []
+                : [`Consumed: ${presentTime(wake.consumedAt, timeZone)}`]),
+            `Events (${events.length}):`,
+            ...events.map((e) => `  ${e.id} ${e.type} ${presentTime(e.createdAt, timeZone)}`),
+            `Messages (${messages.length}):`,
+            ...messages.map((m) => `  ${m.id} [${taskMessageAuthorLabel(m.author)}] ${presentTime(m.createdAt, timeZone)}`),
+            `Runs (${runs.length}):`,
+            ...runs.map((r) => `  ${r.id} [${r.status}/${r.purpose}] ${r.roleName} ${presentTime(r.createdAt, timeZone)}`)
+        ];
+        return output(lines.join("\n").concat("\n"), {
+            taskId: task.id,
+            wake,
+            events,
+            messages,
+            runs
+        });
+    }
+    throw usageError(command === undefined
+        ? "Task wake command is required."
+        : `Unknown command: task wake ${command}`);
+}
 function parseMultiValueTail(args, valueOptions, repeatOptions, usage, flagOptions = new Set()) {
     const positionals = [];
     const options = new Map();