@zq-silk/yui 0.15.11 → 0.16.0

package/dist/commands/taskCommands.js

@@ -1,87 +1,87 @@
-import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { createHash, randomUUID } from "node:crypto";
-import { archiveDeliveryWarnings, archiveRetainedResources, renderArchiveDiagnostics, taskArchiveDiagnostics } from "../task/archiveDiagnostics.js";
 import { isDeepStrictEqual } from "node:util";
-import { createRunInput } from "../context/runInputContract.js";
-import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeWorkItemExecutionAssignmentContextSnapshot, freezeReviewStageContextSnapshot, freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
+import { createRun, runExecutionObservation, runPurposeAdmitsTaskState, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
+import { buildRunContextDelta, buildRunContextPack, contextSnapshotDeltaRefIds, expandRunContextRef, freezeReviewStageContextSnapshot, freezeRunContextSnapshot, freezeWorkItemExecutionAssignmentContextSnapshot, synthesisSourceRunIds } from "../context/runContextPack.js";
+import { createRunInput } from "../context/runInputContract.js";
+import { parseTaskCatalogOptions, readTaskCatalog, renderTaskCatalog } from "../context/taskCatalog.js";
+import { listContextMessages } from "../context/taskContext.js";
+import { referencedWakeRunIds } from "../context/wakeRunReferences.js";
+import { completeProcessing, releaseProcessing } from "../coordination/workMailbox.js";
+import { enqueueRoleRunDispatch, enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
-import { createTaskEvent } from "../event/taskEvent.js";
-import { createTaskRecordRetirement, isTaskRecordRetired, operationalTaskRecords, taskRecordRetirement } from "../task/taskRecordRetirement.js";
-import { referencedWakeRunIds } from "../context/wakeNotification.js";
-import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
-import { readCommandText } from "./textInput.js";
-import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime, taskRoleControlTarget } from "../executor/agentExecutor.js";
-import { transferProviderAuthority, currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
+import { dispatchReviewSynthesis, selectedReviewSynthesisProducers } from "../execution/reviewMainRun.js";
+import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
+import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
+import { dispatchWorkItemSynthesis, selectedWorkItemSynthesisProducers } from "../execution/workItemMainRun.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, taskRoleControlTarget, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
-import { agentRunConfigurationLabel, renderAgentRunConfiguration } from "../output/agentRunConfigurationPresentation.js";
-import { formatTimestamp } from "../output/timePresentation.js";
-import { renderRoleDetails, renderRoleLaunchComparison } from "../output/rolePresentation.js";
-import { createTaskMessage, expandTaskMessageResult, recordTaskMessageControlOutcome, taskMessageAuthorLabel, taskMessageInputControlState, updateDraftTaskMessage, withSubmissionReceipt, TASK_SUBMISSION_INTENTS } from "../message/message.js";
-import { assertDraftTaskExecutionFree, validateDraftWorkItemEdit } from "../task/draftPlan.js";
-import { TASK_PLANNING_ENTERED_EVENT, decideSubmissionRouting, describeSubmissionFeedback, draftActivationState, draftHasEnteredPlanning, normalizeSubmissionIntent, sameSubmissionTarget } from "../task/taskSubmission.js";
-import { recordTaskActivationRequestInTransaction, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { retireExactActiveRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
-import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole } from "../role/role.js";
-import { createRun, runPurposeAdmitsTaskState, runExecutionObservation, withRunContextSnapshot } from "../agentRun/agentRun.js";
-import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, finishReviewRound, recordReviewWorkspaceDisposition, retryReviewRound, retryRunningReviewExecutionLane, retryTaskReviewRound, startReplicatedReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { resolveTaskInputControl } from "../message/inputControlResolution.js";
+import { createTaskMessage, expandTaskMessageResult, recordTaskMessageControlOutcome, TASK_SUBMISSION_INTENTS, taskMessageAuthorLabel, taskMessageInputControlState, updateDraftTaskMessage, withSubmissionReceipt } from "../message/message.js";
+import { messageContinuationBlocker, resolveMessageRecipient } from "../message/messageContinuation.js";
+import { findTaskInterrupt, reserveTaskInterrupt, taskInterruptReceipt, taskInterruptWasRejected } from "../message/taskInterrupt.js";
+import { agentRunConfigurationLabel, renderAgentRunConfiguration } from "../output/agentRunConfigurationPresentation.js";
+import { renderRoleDetails, renderRoleLaunchComparison } from "../output/rolePresentation.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { requireResolvedAgentProfileRuntime } from "../profile/agentProfileRuntime.js";
+import { assertProjectActive, resolveProject } from "../repository/project.js";
+import { createProjectResources } from "../resources/projectResourceService.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { isCompletedTaskReviewEvidence } from "../review/reviewAcceptance.js";
 import { projectReviewerAvailability } from "../review/reviewerAvailability.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 { runTaskActivationCommand, nonLeaderActivationIdentity } from "./taskActivationCommands.js";
-import { assertTaskRemoteDeliveryProof, projectTaskRemoteDeliveryFromStore, renderTaskRemoteDelivery, runTaskRemoteDeliveryCommand } from "./taskRemoteDeliveryCommand.js";
-import { enqueueRoleRunDispatch, enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
-import { completeProcessing } from "../coordination/workMailbox.js";
-import { runtimeLifecycleTarget, RUNTIME_SESSION_REPLACE_REQUIRED_REASON } from "../runtime/lifecycleReservation.js";
+import { attachReviewExecutionGroup, createReviewRound, createTaskDeltaReviewRound, createTaskReviewRound, finishReviewRound, recordReviewWorkspaceDisposition, retryReviewRound, retryRunningReviewExecutionLane, retryTaskReviewRound, startReplicatedReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
+import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole } from "../role/role.js";
+import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
+import { RUNTIME_SESSION_REPLACE_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
+import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { currentProviderConversation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, taskOwnsManagedWorkspace, updateTaskMetadata } from "../task/task.js";
-import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { projectCompletionReadiness } from "../task/completionReadiness.js";
-import { StorageConflictError } from "../storage/taskStore.js";
+import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.js";
+import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
+import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
+import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { planningRuntimeCwd } from "../storage/homeLayout.js";
-import { requireResolvedAgentProfileRuntime } from "../profile/agentProfileRuntime.js";
-import { assertProjectActive, resolveProject } from "../repository/project.js";
-import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, editWorkItemDefinition, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, prepareWorkItemDispatch, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
+import { StorageConflictError } from "../storage/taskStore.js";
+import { archiveDeliveryWarnings, archiveRetainedResources, renderArchiveDiagnostics, taskArchiveDiagnostics } from "../task/archiveDiagnostics.js";
+import { archiveSettlementChecks } from "../task/archivePreflight.js";
+import { projectCompletionReadiness } from "../task/completionReadiness.js";
+import { assertDraftTaskExecutionFree, validateDraftWorkItemEdit } from "../task/draftPlan.js";
+import { assertTaskRemoteDeliveryProof, projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
+import { addTaskProjectBinding, archiveTask, completeTask, createTask, reopenTask, retireTask, taskOwnsManagedWorkspace, updateTaskMetadata } from "../task/task.js";
+import { recordTaskActivationRequestInTransaction, taskActivationOperationRef } from "../task/taskActivationService.js";
+import { assertTaskDeliveryAuthority, assertTaskInputControlAuthority } from "../task/taskAuthority.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { createTaskRecordRetirement, isTaskRecordRetired, operationalTaskRecords, taskRecordRetirement } from "../task/taskRecordRetirement.js";
+import { decideSubmissionRouting, describeSubmissionFeedback, draftActivationState, draftHasEnteredPlanning, normalizeSubmissionIntent, sameSubmissionTarget, TASK_PLANNING_ENTERED_EVENT } from "../task/taskSubmission.js";
 import { assertWorkItemDependenciesCompleted as assertWorkItemDependencyGate, WorkItemDependencyGateError } from "../workItem/dependencyGate.js";
-import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
-import { dispatchWorkItemSynthesis, selectedWorkItemSynthesisProducers } from "../execution/workItemMainRun.js";
-import { dispatchReviewSynthesis, selectedReviewSynthesisProducers } from "../execution/reviewMainRun.js";
-import { synthesisSourceRunIds } from "../context/runContextPack.js";
-import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
-import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
-import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
+import { attachWorkItemExecutionGroup, createWorkItem, currentWorkItemCandidate, currentWorkItemExecutionGroup, editWorkItemDefinition, prepareWorkItemDispatch, retireWorkItem, submitWorkItemCandidate, updateWorkItemExecutionGroup, updateWorkItemStatus, updateWorkItemWriteProjects, workItemExecutionGroupById } from "../workItem/workItem.js";
+import { CleanupInspectionError } from "../workspace/cleanupInspection.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
+import { runGrantCommand } from "./grantCommands.js";
 import { hasAgentConfigOptions, hasNoRoleMutation, parseRoleOptions, patchRoleAgentBinding, roleOptionSpecs, roleProfilePatch } from "./roleConfiguration.js";
-import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
 import { assertRoleRuntimeMutationAllowed } from "./roleRuntimeGuard.js";
+import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
+import { nonLeaderActivationIdentity, runTaskActivationCommand } from "./taskActivationCommands.js";
+import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, optionalNonEmptyOption, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, recordTaskEventRecord, requiredOption, requiredText, requireTask, roleMailbox, taskActor, taskMailbox, taskRef, trimmed } from "./taskCommandSupport.js";
+import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
 import { runTaskContextCommand } from "./taskContextCommand.js";
-import { listContextMessages } from "../context/taskContext.js";
-import { createProjectResources } from "../resources/projectResourceService.js";
-import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
+import { taskBriefCommand, taskDecisionCommand, taskEventCommand, taskMilestoneCommand } from "./taskFactCommands.js";
+import { openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
-import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
-import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastRunLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel, withTaskRoleHostObservation, taskRoleHostDiagnostic } from "./taskRoleRuntimeStatus.js";
-import { assertNoOpenInputRequests, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
-import { runGrantCommand } from "./grantCommands.js";
+import { runPublicationCommand } from "./taskPublicationCommands.js";
+import { renderTaskRemoteDelivery, runTaskRemoteDeliveryCommand } from "./taskRemoteDeliveryCommand.js";
+import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleHostDiagnostic, taskRoleLastRunLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel, withTaskRoleHostObservation } from "./taskRoleRuntimeStatus.js";
+import { readCommandText } from "./textInput.js";
 import { runWorkflowCommand } from "./workflowCommands.js";
-import { taskLocalActor as resolveTaskLocalActor, assertTaskDeliveryAuthority, assertTaskInputControlAuthority } from "./taskActor.js";
-import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
-import { resolveMessageRecipient, messageContinuationBlocker } from "../message/messageContinuation.js";
-import { findTaskInterrupt, reserveTaskInterrupt, taskInterruptReceipt, taskInterruptWasRejected } from "../message/taskInterrupt.js";
-import { resolveTaskInputControl } from "../message/inputControlResolution.js";
-import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
-import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
-import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
-import { buildTaskOverview, parseTaskListOptions, renderTaskOverview } from "./taskOverviewCommand.js";
 const LEADER_ROLE = "leader";
 /** Exact Task-final identity or evidence changed between queueing and dispatch. */
 export class TaskFinalReviewDispatchDriftError extends CliError {
@@ -250,7 +250,7 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
  * terminalization precondition before attempting completion.  All blockers
  * are reported in one error instead of one per attempt.
  */
-export function preflightTaskCompletion(taskId, store, options = {}, request = {}) {
+export function preflightTaskCompletion(taskId, store, options = {}, _request = {}) {
     const task = requireTask(store, taskId);
     const actor = taskActor(store, options, task.id);
     assertTaskDeliveryAuthority(store, options.environment, task.id);
@@ -265,7 +265,7 @@ export function preflightTaskCompletion(taskId, store, options = {}, request = {
     // Integration write. Historical control-plane identity is audit evidence,
     // not a capability that every compatible CLI must reproduce.
     const taskFinalReviewContract = taskFinalReviewContractForMutation(store, task.id, options);
-    const activeTaskReview = store.listReviewRounds(task.id).some((round) => ((round.scope ?? "work-item") === "task"
+    const activeTaskReview = store.listReviewRounds(task.id).some((round) => (round.scope === "task"
         && (round.status === "pending" || round.status === "running")));
     // Issue 06: one shared readiness projection enumerates every blocker.
     const readinessFacts = store.readCompletionReadinessFacts(task.id);
@@ -303,7 +303,7 @@ export function runTaskCommand(args, store, options = {}) {
     const delivery = command === "complete"
         || (command === "work" && ["dispatch", "synthesize", "review", "accept"].includes(rest[0] ?? ""))
         || (command === "review" && !["list", "show"].includes(rest[0] ?? ""))
-        || ((command === "run" || command === "run") && rest[0] === "retry");
+        || (command === "run" && rest[0] === "retry");
     if (delivery && options.environment?.YUI_SESSION_SCOPE === "task"
         && options.environment.YUI_TASK_ID !== undefined) {
         assertTaskDeliveryAuthority(store, options.environment, options.environment.YUI_TASK_ID);
@@ -311,7 +311,7 @@ export function runTaskCommand(args, store, options = {}) {
     switch (command) {
         case "create": return createTaskCommand(rest, store, options);
         case "update": return output(updateTaskCommand(rest, store, options));
-        case "list": return listTaskCommand(rest, store);
+        case "list": return listTaskCommand(rest, store, options.environment);
         case "show": return showTaskCommand(rest, store, options.actualTaskReviewCandidate ?? null);
         case "context": return runTaskContextCommand(rest, store, options.environment);
         case "next-action": return runTaskNextActionCommand(rest, store, options.actualTaskReviewCandidate ?? null);
@@ -337,12 +337,11 @@ export function runTaskCommand(args, store, options = {}) {
         case "role": return taskRoleCommand(rest, store, options);
         case "work": return taskWorkCommand(rest, store, options);
         case "review": return taskReviewCommand(rest, store, options);
-        case "run":
         case "run": return taskRunCommand(rest, store, options);
         case "brief": return taskBriefCommand(rest, store, options);
         case "decision": return taskDecisionCommand(rest, store, options);
         case "milestone": return taskMilestoneCommand(rest, store, options);
-        case "event": return taskEventCommand(rest, store);
+        case "event": return taskEventCommand(rest, store, options);
         case "continuation": return taskContinuationCommand(rest, store);
         default:
             throw usageError(command === undefined
@@ -466,9 +465,9 @@ function taskProjectCommand(args, store, options) {
         }
         return next;
     });
-    notifyMailbox(options.runtime, taskMailbox(updated.id), updated.id);
+    notifyMailbox(options.runtime, taskMailbox(updated.id));
     if (updated.status === "active") {
-        notifyMailbox(options.runtime, leaderMailbox(updated.id), updated.id);
+        notifyMailbox(options.runtime, leaderMailbox(updated.id));
     }
     return output(`Added Project to ${updated.id}\n`, { task: updated });
 }
@@ -523,7 +522,7 @@ function updateTaskCommand(args, store, options) {
     }, options);
     return `Updated task ${result.id}\n`;
 }
-/** Shared domain transaction for structured capabilities and the legacy CLI.
+/** Shared domain transaction for structured capabilities and the CLI.
  * Parsing text flags must not become an alternate business write path. */
 export function updateTaskMetadataCommand(store, taskId, patch, options = {}) {
     if (Object.keys(patch).length === 0)
@@ -545,7 +544,7 @@ export function updateTaskMetadataCommand(store, taskId, patch, options = {}) {
         enqueueWork(tx, taskMailbox(updated.id), "task-updated", now, [taskRef(updated.id)]);
         return updated;
     });
-    notifyMailbox(options.runtime, taskMailbox(result.id), result.id);
+    notifyMailbox(options.runtime, taskMailbox(result.id));
     return result;
 }
 function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey, target, inputControl) {
@@ -628,8 +627,7 @@ function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey,
                 requestId: `submit-${message.id}`,
                 actorId: identity.actorId,
                 authorityRef: identity.authorityRef,
-                environmentPlan: routing.environmentPlan,
-                origin: "submit-develop"
+                environmentPlan: routing.environmentPlan
             }, now);
             activationRef = taskActivationOperationRef(task.id, `submit-${message.id}`);
             enqueueWork(tx, taskMailbox(task.id), "activation-requested", now, [taskRef(task.id)]);
@@ -681,7 +679,7 @@ function replayKeyedSubmission(task, prior, kind, body, intent, target) {
     const receipt = prior.submissionReceipt;
     if (prior.kind !== kind
         || prior.body !== body
-        || normalizeSubmissionIntent(prior.intent) !== intent
+        || prior.intent !== intent
         || receipt === undefined
         || (target !== undefined && !sameSubmissionTarget(receipt.target, target))) {
         throw new StorageConflictError(`Submission key ${prior.submissionKey} was already used for a different submission on ${task.id}/${prior.id}.`);
@@ -743,7 +741,7 @@ const SUBMISSION_ACTIVATION_LABEL = {
 function renderSubmissionNextStep(step) {
     switch (step.kind) {
         case "activate-manually":
-            return `activate it explicitly with "yui task activate ${step.taskId}".`;
+            return `request activation with "yui task activation request ${step.taskId} --request-id <id> --environment <plan>".`;
         case "start-execution":
             return `start execution with "yui task execution start ${step.taskId}", then submit develop again.`;
         case "await-pending-activation":
@@ -797,7 +795,7 @@ export function submitOperatorMessage(body, taskId, store, options = {}, intent,
         const routed = routeUserSubmission(tx, createdAgg.task, "operator", body, effectiveIntent, now, submissionKey, { kind: "create" });
         return { ...routed, task: createdAgg.task, created: true };
     });
-    notifyMailbox(options.runtime, result.queuedForLeader ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
+    notifyMailbox(options.runtime, result.queuedForLeader ? leaderMailbox(result.task.id) : taskMailbox(result.task.id));
     const header = result.created
         ? `Created Draft task ${result.task.id}: ${result.task.title}\n`
         : "";
@@ -824,7 +822,7 @@ function createTaskCommand(args, store, options) {
         projectBindings: parsed.projectBindings,
         ...(parsed.type === undefined ? {} : { type: parsed.type })
     }, now, parsed.defaultProjectIds));
-    notifyMailbox(options.runtime, taskMailbox(created.task.id), created.task.id);
+    notifyMailbox(options.runtime, taskMailbox(created.task.id));
     return output(`Created Draft task ${created.task.id}: ${created.task.title}\n`
         + `Assigned role: ${created.leader.name}\n`
         + `Type: ${created.task.type ?? "unspecified"}\n`
@@ -904,14 +902,9 @@ function createTaskAggregate(store, title, metadata, now, defaultProjectIds = []
     enqueueWork(store, taskMailbox(task.id), "task-created", now, [taskRef(task.id)]);
     return { task, leader };
 }
-function listTaskCommand(args, store) {
-    const options = parseTaskListOptions(args);
-    const snapshot = store.transaction((reader) => ({
-        result: buildTaskOverview(reader, options),
-        timeZone: reader.getConfig().timeZone
-    }));
-    const rendered = renderTaskOverview(snapshot.result, options, snapshot.timeZone, defaultTableWidth());
-    return output(rendered, snapshot.result);
+function listTaskCommand(args, store, environment = {}) {
+    const result = readTaskCatalog(store, parseTaskCatalogOptions(args), environment);
+    return output(renderTaskCatalog(result), result);
 }
 function showTaskCommand(args, store, currentTaskCandidate) {
     const [taskId] = args;
@@ -1044,8 +1037,8 @@ function activateTaskCommand(args, store, options) {
         throw usageError(`Task ${task.id} activation requires atomic workspace adoption through the CLI preflight.`);
     });
     if (result.changed) {
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
+        notifyMailbox(options.runtime, leaderMailbox(result.task.id));
     }
     return result.changed
         ? `Activated task ${result.task.id}\n`
@@ -1179,7 +1172,7 @@ function completeTaskCommand(args, store, options) {
         };
     });
     if (result.changed) {
-        notifyMailbox(options.runtime, { kind: "operator" }, result.task.id);
+        notifyMailbox(options.runtime, { kind: "operator" });
     }
     if (result.finalReview !== undefined) {
         const status = result.finalReview.status === "pending"
@@ -1240,9 +1233,9 @@ function reopenTaskCommand(args, store, options) {
         return { task: active, changed: true, wakeLeader: actor !== "leader" };
     });
     if (result.changed) {
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
         if (result.wakeLeader) {
-            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id));
         }
     }
     return result.changed
@@ -1267,24 +1260,9 @@ function archiveTaskCommand(args, store, options) {
                 ? assertTaskRemoteDeliveryProof(tx, task, options.archiveRemoteDeliveryProof)
                 : undefined;
         if (!request.force) {
-            assertNoOpenInputRequests(tx, task.id, "archiving the Task");
-            const unsettledWork = tx.listWorkItems(task.id).find((item) => item.status === "open");
-            if (unsettledWork !== undefined) {
-                throw usageError(`Work Item ${unsettledWork.id} must be accepted or explicitly retired before archive.`);
-            }
-            const unresolvedIntegration = tx.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
-                || integration.status === "blocked"
-                || integration.status === "conflicted"
-                || integration.status === "validating"));
-            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}.`);
-            }
+            const checks = archiveSettlementChecks(tx, task);
+            if (checks.length > 0)
+                throw new CleanupInspectionError(checks);
             if (task.cwd !== undefined || tx.listManagedWorkspaces(task.id).length > 0) {
                 throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
             }
@@ -1348,7 +1326,7 @@ function archiveTaskCommand(args, store, options) {
         return { task: archived, changed: true };
     });
     if (result.changed && !request.force)
-        options.runtime?.notifyStateChanged(result.task.id);
+        options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.task.id });
     const diagnostics = taskArchiveDiagnostics(store, result.task);
     return output((result.changed
         ? `Archived task ${result.task.id}\n`
@@ -1381,8 +1359,8 @@ function cancelTaskCommand(args, store, options) {
         // AgentRuns, inputs, WorkItems and their results remain independently readable.
         return cancelled;
     });
-    options.runtime?.notifyStateChanged(result.id);
-    notifyMailbox(options.runtime, { kind: "operator" }, result.id);
+    options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.id });
+    notifyMailbox(options.runtime, { kind: "operator" });
     return output(`Cancelled task ${result.id}\n`, { task: result });
 }
 /** Historical evidence only; these snapshots are never dispatch input. */
@@ -1483,8 +1461,8 @@ function retireTaskCommand(args, store, options) {
         return { task: retired, changed: true };
     });
     if (result.changed) {
-        options.runtime?.notifyStateChanged(result.task.id);
-        notifyMailbox(options.runtime, { kind: "operator" }, result.task.id);
+        options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.task.id });
+        notifyMailbox(options.runtime, { kind: "operator" });
     }
     return output(result.changed
         ? `Retired task ${result.task.id}\n`
@@ -1512,9 +1490,9 @@ function assertTaskRetirementProof(store, task, proof) {
         throw usageError(`Task workspaces changed after retirement preflight: ${task.id}.`);
     }
 }
-export function parseTaskArchiveArguments(args) {
+export function parseTaskArchiveArguments(args, command = "archive") {
     const usage = "Task archive usage: "
-        + "yui task archive <id> (--integrated|--abandon) [--force].";
+        + `yui task ${command} <id> (--integrated|--abandon) [--force].`;
     const taskId = args[0]?.trim();
     const flags = args.slice(1);
     if (taskId === undefined
@@ -1552,14 +1530,9 @@ export function validateTaskArchiveRequest(args, store, options = {}) {
         throw usageError(`Task ${task.id} must be completed or retired before it can be archived.`);
     }
     if (task.status !== "archived" && !request.force) {
-        assertNoOpenInputRequests(store, task.id, "archiving the Task");
-        const unresolvedIntegration = store.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
-            || integration.status === "blocked"
-            || integration.status === "conflicted"
-            || integration.status === "validating"));
-        if (unresolvedIntegration !== undefined) {
-            throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
-        }
+        const checks = archiveSettlementChecks(store, task);
+        if (checks.length > 0)
+            throw new CleanupInspectionError(checks);
     }
     return request;
 }
@@ -1601,7 +1574,7 @@ function taskMessageCommand(args, store, options) {
             enqueueWork(tx, taskMailbox(ref.taskId), "message-continuation", now, [messageRef(ref.taskId, current.id)]);
             return updated;
         });
-        notifyMailbox(options.runtime, taskMailbox(ref.taskId), ref.taskId);
+        notifyMailbox(options.runtime, taskMailbox(ref.taskId));
         return output(`Handed off Message ${ref.localId} to ${message.recipient.roleName}.\n`, message);
     }
     if (command === "show") {
@@ -1619,22 +1592,11 @@ function taskMessageCommand(args, store, options) {
         return { kind: "output", output: `${JSON.stringify(expanded, null, 2)}\n`, data: expanded };
     }
     if (command === "send") {
-        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--intent record|discuss|develop] [--request-id <key>] [--wake-policy leader|none] [--to <role> --work-item <id>|--review-round <id>].";
-        const parsed = parseTail(rest, new Set(["--body-file", "--intent", "--request-id", "--wake-policy", "--to", "--work-item", "--review-round"]), usage);
+        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--intent record|discuss|develop] [--request-id <key>] [--to <role> --work-item <id>|--review-round <id>].";
+        const parsed = parseTail(rest, new Set(["--body-file", "--intent", "--request-id", "--to", "--work-item", "--review-round"]), 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 intent = parseSubmissionIntentOption(parsed.options.get("--intent"), usage);
         const submissionKey = parsed.options.get("--request-id");
         if (submissionKey !== undefined && submissionKey.trim().length === 0) {
@@ -1645,7 +1607,7 @@ function taskMessageCommand(args, store, options) {
         const reviewRoundId = parsed.options.get("--review-round");
         if (recipientRole === undefined && (workItemId !== undefined || reviewRoundId !== undefined))
             throw usageError("--to is required for scoped Message delivery.");
-        const result = sendTaskMessageCommand(store, parsed.positionals[0], body, wakePolicy, options, recipientRole === undefined ? undefined : { roleName: recipientRole, workItemId, reviewRoundId }, intent, submissionKey);
+        const result = sendTaskMessageCommand(store, parsed.positionals[0], body, options, recipientRole === undefined ? undefined : { roleName: recipientRole, workItemId, reviewRoundId }, intent, submissionKey);
         // A user/operator submission returns the unified §2.5 feedback; render each
         // facet on its own line and expose the structure to non-text callers.
         if (result.feedback !== undefined) {
@@ -1724,6 +1686,13 @@ function taskMessageCommand(args, store, options) {
  * reusing the requestId with different content is a conflict, never a second
  * input (decision-3 §5/§6).
  */
+export function applyTaskInputControl(taskId, input, store, options) {
+    if (input.action === "queue")
+        return queueTaskInput(taskId, input, store, options);
+    if (input.action === "steer")
+        return steerTaskInput(taskId, input, store, options);
+    return interruptTaskInput(taskId, input, store, options);
+}
 function queueTaskMessage(args, store, options) {
     const usage = "Task message queue usage: yui task message queue <id> (<body>|--body-file <path|->) --request-id <id> [--to <role> --work-item <id>|--review-round <id>].";
     const parsed = parseTail(args, new Set(["--body-file", "--request-id", "--to", "--work-item", "--review-round"]), usage);
@@ -1734,10 +1703,16 @@ function queueTaskMessage(args, store, options) {
     const recipientRole = parsed.options.get("--to");
     const workItemId = parsed.options.get("--work-item");
     const reviewRoundId = parsed.options.get("--review-round");
+    return applyTaskInputControl(parsed.positionals[0], {
+        action: "queue", body, requestId, to: recipientRole, workItem: workItemId, reviewRound: reviewRoundId
+    }, store, options);
+}
+function queueTaskInput(taskId, input, store, options) {
+    const { body, requestId, to: recipientRole, workItem: workItemId, reviewRound: reviewRoundId } = input;
     if (recipientRole === undefined && (workItemId !== undefined || reviewRoundId !== undefined)) {
         throw usageError("--to is required for scoped Message delivery.");
     }
-    const result = sendTaskMessageCommand(store, parsed.positionals[0], body, undefined, options, recipientRole === undefined ? undefined : { roleName: recipientRole, workItemId, reviewRoundId }, undefined, undefined, { action: "queue", requestId });
+    const result = sendTaskMessageCommand(store, taskId, body, options, recipientRole === undefined ? undefined : { roleName: recipientRole, workItemId, reviewRoundId }, undefined, undefined, { action: "queue", requestId });
     const reason = result.message.continuation?.notDeliveredReason;
     const delivery = result.idempotentReplay ? { state: "idempotent-replay" }
         : reason !== undefined ? { state: "not-delivered", reason }
@@ -1768,6 +1743,13 @@ function steerTaskMessage(args, store, options) {
     if (recipientRole === undefined) {
         throw usageError("steer requires --to <role>; it targets that Role's exact current Turn.");
     }
+    return applyTaskInputControl(parsed.positionals[0], {
+        action: "steer", body, requestId, expectedTarget, to: recipientRole,
+        workItem: workItemId, reviewRound: reviewRoundId
+    }, store, options);
+}
+function steerTaskInput(taskId, input, store, options) {
+    const { body, requestId, expectedTarget, to: recipientRole, workItem: workItemId, reviewRound: reviewRoundId } = input;
     // decision-3 §9: a Task Leader's current native turn (including a Draft's
     // planning turn) is a real turn but NOT an implicit AgentRun, so steering it
     // never establishes a Worker-style Assignment. It is persisted as an ordinary
@@ -1779,8 +1761,8 @@ function steerTaskMessage(args, store, options) {
         throw usageError("Steering the Leader targets its current turn directly; it takes no --work-item/--review-round Assignment.");
     }
     const result = leaderTarget
-        ? sendTaskMessageCommand(store, parsed.positionals[0], body, "none", options, undefined, undefined, undefined, { action: "steer", requestId, expectedTarget })
-        : sendTaskMessageCommand(store, parsed.positionals[0], body, undefined, options, { roleName: recipientRole, workItemId, reviewRoundId }, undefined, undefined, { action: "steer", requestId, expectedTarget });
+        ? sendTaskMessageCommand(store, taskId, body, options, undefined, undefined, undefined, { action: "steer", requestId, expectedTarget })
+        : sendTaskMessageCommand(store, taskId, body, options, { roleName: recipientRole, workItemId, reviewRoundId }, undefined, undefined, { action: "steer", requestId, expectedTarget });
     const roleName = result.message.recipient?.roleName ?? recipientRole;
     if (result.idempotentReplay) {
         // A replay is a later reader (another CLI invocation): surface the durable
@@ -1875,12 +1857,9 @@ function steerInputDelivery(taskId, messageId, roleName, body) {
  * execution is decided by the Controller from the Task's own status, so this
  * function never names a purpose and no second planning path exists.
  */
-export function sendTaskMessageCommand(store, taskId, body, wakePolicy, options = {}, recipient, intent, submissionKey, inputControl) {
+export function sendTaskMessageCommand(store, taskId, body, options = {}, recipient, intent, submissionKey, inputControl) {
     if (!body.trim())
         throw usageError("Message body is required.");
-    if (recipient !== undefined && wakePolicy !== undefined) {
-        throw usageError("--wake-policy applies only to unaddressed Leader Messages; an owner-directed Message uses its exact continuation boundary.");
-    }
     if (recipient !== undefined && intent !== undefined) {
         throw usageError("A submission intent applies only to unaddressed Leader Messages; an owner-directed Message uses its exact continuation boundary.");
     }
@@ -1935,7 +1914,7 @@ export function sendTaskMessageCommand(store, taskId, body, wakePolicy, options
         // owner-directed continuations keep their exact existing boundary and never
         // gain develop authority (task-32 §2.5).
         if (recipient === undefined && (actor === "user" || actor === "operator")) {
-            const effectiveIntent = normalizeSubmissionIntent(intent, wakePolicy);
+            const effectiveIntent = inputControl?.action === "steer" ? "record" : normalizeSubmissionIntent(intent);
             const routed = routeUserSubmission(tx, task, actor, body, effectiveIntent, now, submissionKey, { kind: "task", taskId: task.id }, inputControl);
             return {
                 task: routed.task, message: routed.message, actor,
@@ -1990,11 +1969,11 @@ export function sendTaskMessageCommand(store, taskId, body, wakePolicy, options
     if (result.idempotentReplay)
         return result;
     if (recipient !== undefined) {
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
+        notifyMailbox(options.runtime, taskMailbox(result.task.id));
     }
     else if (result.actor !== "leader") {
         notifyMailbox(options.runtime, result.queuedForLeader
-            ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
+            ? leaderMailbox(result.task.id) : taskMailbox(result.task.id));
     }
     return result;
 }
@@ -2015,19 +1994,11 @@ export function leaderWakingTaskStatus(status) {
     return status === "active" || status === "draft";
 }
 function updateMessage(args, store, options) {
-    const usage = "Task message update usage: yui task message update <task>/<message> (<body>|--body-file <path|->) [--wake-policy leader|none].";
-    const parsed = parseTail(args, new Set(["--body-file", "--wake-policy"]), usage);
+    const usage = "Task message update usage: yui task message update <task>/<message> (<body>|--body-file <path|->).";
+    const parsed = parseTail(args, new Set(["--body-file"]), 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");
-    const wakePolicy = wakePolicyRaw === undefined
-        ? undefined
-        : wakePolicyRaw === "leader" || wakePolicyRaw === "none"
-            ? wakePolicyRaw
-            : (() => {
-                throw usageError(`--wake-policy must be 'leader' or 'none': ${wakePolicyRaw}.`);
-            })();
     const reference = taskRecordReference(parsed.positionals[0], "message", "Message reference", options);
     const now = clock(options);
     const result = store.transaction((tx) => {
@@ -2048,24 +2019,42 @@ function updateMessage(args, store, options) {
             throw usageError(`Task Message is retired: ${task.id}/${message.id}.`);
         }
         const updated = updateDraftTaskMessage(message, {
-            body,
-            ...(wakePolicy === undefined ? {} : { wakePolicy })
+            body
         });
+        if (updated === message)
+            return { task, message, queuedForLeader: false, changed: false };
         tx.updateMessage(task.id, updated);
         recordTaskEvent(tx, task.id, "message.updated", {
             messageId: updated.id,
-            updatedBy: actor,
-            ...(wakePolicy === undefined ? {} : { wakePolicy })
+            updatedBy: actor
         }, now);
-        const queuedForLeader = updated.wakePolicy !== "none";
+        // An edit can continue a discussion, but it is not a new develop request.
+        // Use the submission router's current activation/planning facts so pending
+        // or failed activation cannot be turned into a planning wake by an edit.
+        const routing = decideSubmissionRouting({
+            intent: updated.intent,
+            status: task.status,
+            enteredPlanning: draftHasEnteredPlanning(tx, task),
+            activation: draftActivationState(task.activationRequest),
+            executionEnabled: task.executionGate.state === "enabled",
+            developEnvironmentPlan: { kind: "empty" }
+        });
+        const queuedForLeader = routing.kind === "enter-planning" || routing.kind === "continue-planning";
+        if (routing.kind === "enter-planning") {
+            recordTaskEvent(tx, task.id, TASK_PLANNING_ENTERED_EVENT, {
+                messageId: updated.id, intent: updated.intent
+            }, now);
+        }
         if (queuedForLeader) {
             enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [messageRef(task.id, updated.id)], { source: actor });
         }
-        return { task, message: updated, queuedForLeader };
+        return { task, message: updated, queuedForLeader, changed: true };
     });
-    notifyMailbox(options.runtime, result.queuedForLeader
-        ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
-    return output(`Updated Task Message ${result.task.id}/${result.message.id}\n`, {
+    if (result.changed) {
+        notifyMailbox(options.runtime, result.queuedForLeader
+            ? leaderMailbox(result.task.id) : taskMailbox(result.task.id));
+    }
+    return output(`${result.changed ? "Updated" : "Unchanged"} Task Message ${result.task.id}/${result.message.id}\n`, {
         message: result.message
     });
 }
@@ -2112,32 +2101,58 @@ function retireMessage(args, store, options) {
         return { task, message, changed: true };
     });
     if (result.changed)
-        options.runtime?.notifyStateChanged(result.task.id);
+        options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.task.id });
     return `Retired Task Message ${result.task.id}/${result.message.id}\n`;
 }
-/**
- * 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 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);
-    if (!parsed.options.has("--force")) {
-        throw usageError("--force is required to wake a Task.", usage);
-    }
+/** Explicitly retry one proven-rejected notification, preserving its inputs. */
+function taskWakeRetryCommand(args, store, options) {
+    const usage = "Task wake retry usage: yui task wake retry <task> <wake> --reason <correction>.";
+    const parsed = parseTail(args, new Set(["--reason"]), usage);
+    exactPositionals(parsed.positionals, 2, usage);
     const reason = requiredOption(parsed.options, "--reason");
     const now = clock(options);
-    const task = requireTask(store, parsed.positionals[0]);
-    assertTaskOpen(task);
-    const wakeReasonTag = wakeReason("force-wake", truncateEventNote(reason));
-    store.transaction((tx) => {
-        queueLeaderWakeup(tx, task.id, wakeReasonTag, now);
-        recordTaskEvent(tx, task.id, "task.wake-forced", { reason: wakeReasonTag }, now);
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        assertTaskOpen(task);
+        taskActor(tx, options, task.id);
+        const wakeId = parsed.positionals[1];
+        const wake = tx.getTaskWake(task.id, wakeId);
+        if (wake === null)
+            throw dataError(`Wake not found: ${wakeId}.`);
+        if (wake.status === "consumed")
+            throw usageError("An accepted notification cannot be retried.");
+        const mailbox = tx.getWorkMailbox(leaderMailbox(task.id));
+        const claim = mailbox?.processing;
+        if (claim == null || claim.owner !== `leader-notification:${wakeId}`) {
+            throw usageError("This wake has no rejected notification claim.");
+        }
+        const events = tx.listEvents(task.id);
+        const previous = events.filter(event => event.type === "notification.delivery" && event.payload.attemptId === claim.batchId).at(-1);
+        if (previous?.payload.outcome !== "rejected") {
+            throw usageError("Only a rejected notification can be retried; unknown acceptance must not be replayed.");
+        }
+        const provider = tx.getTaskRoleSessionSet(task.id, "leader")?.providerBinding;
+        const accepted = events.some(event => {
+            const observation = runtimeObservationFromTaskEvent(event);
+            return observation?.fence.roleName === "leader" && observation.fence.receiptId === claim.batchId
+                && ((observation.kind === "turn.accepted" && observation.authority !== "transport")
+                    || ["turn.completed", "turn.failed", "turn.cancelled"].includes(observation.kind));
+        });
+        if (accepted || tx.getActiveRun(task.id, "leader") !== null
+            || provider?.authority.owner === "human" || provider?.authority.owner === "unknown"
+            || (provider?.run != null && (["submitting", "accepted", "delivery-unknown"].includes(provider.run.status)
+                || provider.run.attemptId === claim.batchId && provider.run.status !== "rejected"))) {
+            throw usageError("Native execution is not proven unaccepted and quiescent; this notification cannot be replayed.");
+        }
+        tx.saveWorkMailbox(releaseProcessing(mailbox, claim.batchId));
+        queueLeaderWakeup(tx, task.id, wakeReason("notification-retry", wakeId), now);
+        recordTaskEvent(tx, task.id, "notification.retry-requested", {
+            wakeId, attemptId: claim.batchId, reason
+        }, now);
+        return { taskId: task.id, wakeId, outcome: "queued" };
     });
-    notifyMailbox(options.runtime, leaderMailbox(task.id), task.id);
-    return `Woke ${task.id} (${wakeReasonTag})\n`;
+    notifyMailbox(options.runtime, leaderMailbox(result.taskId));
+    return output(`Queued rejected ${result.wakeId} for retry; original input was preserved.\n`, result);
 }
 function taskRoleCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -2194,9 +2209,15 @@ function interruptTaskRole(args, store, options) {
     const expectedTarget = requiredOption(parsed.options, "--expected-target");
     const thenMessageRef = optionalNonEmptyOption(parsed.options, "--then-message");
     const requestId = optionalNonEmptyOption(parsed.options, "--request-id");
+    return applyTaskInputControl(parsed.positionals[0], {
+        action: "interrupt", expectedTarget, role: parsed.positionals[1], thenMessage: thenMessageRef, requestId
+    }, store, options);
+}
+function interruptTaskInput(taskId, input, store, options) {
+    const { expectedTarget, thenMessage: thenMessageRef, requestId } = input;
     const now = clock(options);
-    const task = requireTask(store, parsed.positionals[0]);
-    const role = requireRole(store, task.id, parsed.positionals[1]);
+    const task = requireTask(store, taskId);
+    const role = requireRole(store, task.id, input.role);
     const fingerprint = createHash("sha256").update(JSON.stringify({
         roleName: role.name, expectedTarget, thenMessageRef: thenMessageRef ?? null
     })).digest("hex");
@@ -2373,7 +2394,7 @@ function registerInterruptThen(store, taskId, roleName, thenMessageRef, target,
     // AgentRun's terminal — no extra wake is needed. A no-Run Leader turn owns no
     // AgentRun and is never surfaced by that push path; it is delivered only by
     // being woken to read its own Context. The interrupt itself (and, when the
-    // handoff reuses a Leader self-steer, wakePolicy "none") enqueues no wake, so
+    // handoff reuses a Leader self-steer with record intent) enqueues no wake, so
     // without this the claim would be structurally unreleasable: listPendingWakeups
     // never selects the Task and the busy-gated leader mailbox is never consulted.
     // Enqueue that wake now, keyed to the claimed Message so an idempotent repeat of
@@ -2387,6 +2408,38 @@ function registerInterruptThen(store, taskId, roleName, thenMessageRef, target,
 }
 function taskRoleSessionCommand(args, store, options) {
     const [command, ...rest] = args;
+    if (command === "retry") {
+        const [taskId, roleName, action = "show", ...extra] = rest;
+        if (extra.length > 0 || !["show", "cancel", "disable", "enable"].includes(action)) {
+            throw usageError("Usage: yui task role session retry <task> <role> [show|cancel|disable|enable]");
+        }
+        return store.transaction(tx => {
+            const task = requireTask(tx, taskId);
+            const role = requireRole(tx, task.id, roleName);
+            if (action !== "show")
+                taskActor(tx, options, task.id);
+            else {
+                const reader = resolveManagedTaskReader(tx, options.environment);
+                if (reader === undefined)
+                    taskActor(tx, options, task.id);
+                else if (reader.taskId !== task.id || reader.roleName !== "leader" && reader.roleName !== role.name) {
+                    throw usageError("Provider retry read is outside the caller's Task/Role.");
+                }
+            }
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            let binding = sessions?.providerBinding ?? null;
+            if (action !== "show") {
+                if (task.status === "archived" || sessions === null || binding === null)
+                    throw usageError("No writable Provider Session.");
+                binding = controlProviderRetry(binding, action, clock(options).getTime());
+                tx.saveTaskRoleSessionSet({ ...sessions, providerBinding: binding });
+                recordTaskEvent(tx, task.id, "provider.retry-control", { roleName: role.name, action }, clock(options));
+            }
+            return output(`${renderProviderRetry(binding)}\n`, {
+                roleName: role.name, retry: providerRetryProjection(binding), disabled: binding?.retryDisabled ?? false
+            });
+        });
+    }
     if (command === "inspect") {
         exactPositionals(rest, 2, "Task Role Session inspect usage: yui task role session inspect <task> <role>.");
         const task = requireTask(store, rest[0]);
@@ -2420,6 +2473,7 @@ function taskRoleSessionCommand(args, store, options) {
                 `Native id: ${active.nativeSessionId}`,
                 `Session: ${active.status}${active.endReason === undefined ? "" : `/${active.endReason}`}`,
                 `AgentRun: ${binding?.run?.status ?? "none"}`,
+                renderProviderRetry(binding),
                 ...(host === undefined ? [] : [`Host reporting: ${taskRoleHostDiagnostic(host)}`]),
                 `Run configuration: ${agentRunConfigurationLabel(runConfiguration)}`
             ].join("\n") + "\n"
@@ -2429,6 +2483,7 @@ function taskRoleSessionCommand(args, store, options) {
             role,
             session: active,
             providerBinding: binding,
+            retry: providerRetryProjection(binding),
             ...(host === undefined ? {} : { host }),
             ...(runConfiguration === undefined ? {} : { runConfiguration })
         });
@@ -2460,7 +2515,7 @@ function taskRoleSessionCommand(args, store, options) {
             enqueueWork(tx, target, RUNTIME_SESSION_REPLACE_REQUIRED_REASON, now, [{ type: "task", id: task.id }]);
             return { taskId: task.id, roleName: role.name, target, alreadyRequested: false };
         });
-        notifyMailbox(options.runtime, result.target, result.taskId);
+        notifyMailbox(options.runtime, result.target);
         return output(`Requested Session replacement for ${result.taskId}/${result.roleName}. `
             + "Yui will stop the old execution, retain its history and workspaces, and select a fresh Session. "
             + "If replacing your own Session, end this turn; the successor reads durable Task context.\n", result);
@@ -2579,7 +2634,7 @@ function addTaskRole(args, store, options) {
         }, now);
         return { role: created, binding };
     });
-    notifyMailbox(options.runtime, taskMailbox(result.role.taskId), result.role.taskId);
+    notifyMailbox(options.runtime, taskMailbox(result.role.taskId));
     const profileId = parsed.one("--profile");
     const runtimeSource = profileId !== undefined
         ? `Agent Profile ${profileId}`
@@ -2719,7 +2774,7 @@ function updateTaskRole(args, store, options) {
         });
         return next;
     });
-    notifyMailbox(options.runtime, taskMailbox(updated.taskId), updated.taskId);
+    notifyMailbox(options.runtime, taskMailbox(updated.taskId));
     const sessions = store.getTaskRoleSessionSet(updated.taskId, updated.name);
     return output(renderRoleDetails(`Updated Task Role: ${updated.name}`, updated, {
         kind: "task",
@@ -2761,7 +2816,7 @@ function removeTaskRole(args, store, options) {
         enqueueWork(tx, taskMailbox(task.id), "role-removed", now, [taskRef(task.id)]);
         return role;
     });
-    notifyMailbox(options.runtime, taskMailbox(removed.taskId), removed.taskId);
+    notifyMailbox(options.runtime, taskMailbox(removed.taskId));
     return `Removed role ${removed.name} from ${removed.taskId}\n`;
 }
 function bindTaskRole(args, store, options) {
@@ -2820,7 +2875,7 @@ function bindTaskRole(args, store, options) {
         }, now);
         return { role: switched.role, mode: switched.mode };
     });
-    notifyMailbox(options.runtime, taskMailbox(result.role.taskId), result.role.taskId);
+    notifyMailbox(options.runtime, taskMailbox(result.role.taskId));
     return `Bound ${result.role.taskId}/${result.role.name} to ${result.role.activeAgentId} (${result.mode})\n`;
 }
 function unbindTaskRole(args, store, options) {
@@ -3090,7 +3145,7 @@ function editWork(args, store, options) {
         }
         return { task, item: updated };
     });
-    options.runtime?.notifyStateChanged(result.task.id);
+    options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.task.id });
     return output(`Edited Work Item ${result.task.id}/${result.item.id}\n`, {
         workItem: result.item
     });
@@ -3130,15 +3185,6 @@ 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],
@@ -3150,10 +3196,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 { item: created, guard };
+        return created;
     });
-    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 });
+    notifyMailbox(options.runtime, taskMailbox(item.taskId));
+    return output(`Created work item ${item.id} for ${item.taskId}\n`, { workItem: item });
 }
 function updateWorkScope(args, store, options) {
     const usage = "Task work scope usage: yui task work scope <task>/<work> [--project <project> ...].";
@@ -3190,7 +3236,7 @@ function updateWorkScope(args, store, options) {
         return { item: next, changed: true };
     });
     if (updated.changed) {
-        notifyMailbox(options.runtime, taskMailbox(updated.item.taskId), updated.item.taskId);
+        notifyMailbox(options.runtime, taskMailbox(updated.item.taskId));
     }
     return `${updated.changed ? "Updated" : "Unchanged"} Work Item Project scope ${updated.item.id}: ${updated.item.writeProjectIds.join(", ") || "read-only"}\n`;
 }
@@ -3357,7 +3403,7 @@ function updateWork(args, store, options) {
             reviewTrigger: candidatePolicy?.trigger ?? null
         };
     });
-    notifyMailbox(options.runtime, taskMailbox(result.item.taskId), result.item.taskId);
+    notifyMailbox(options.runtime, taskMailbox(result.item.taskId));
     if ((result.item.status === "open" && result.item.candidates.length > 0) && status === "completed") {
         const failure = result.reviewDispatch?.round.status === "failed"
             ? `Review could not start: ${result.reviewDispatch.round.failure?.message ?? result.reviewDispatch.round.id}\n`
@@ -3588,7 +3634,7 @@ function dispatchWork(args, store, options) {
         return { kind: "replicated", runs };
     });
     for (const run of dispatch.runs) {
-        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName));
     }
     return dispatch.kind === "direct"
         ? `Direct WorkItem AgentRun queued as ${dispatch.runs[0].id}\n`
@@ -3832,7 +3878,7 @@ function retireWork(args, store, options) {
         }
         return next;
     });
-    options.runtime?.notifyStateChanged(retired.taskId);
+    options.runtime?.notifyMailboxChanged({ kind: "task", taskId: retired.taskId });
     return output(`Retired Work Item ${retired.id}\n`, { workItem: retired });
 }
 function listWork(args, store) {
@@ -4038,7 +4084,7 @@ function synthesizeRuns(args, kind, store, options) {
         }, now);
         return created;
     });
-    notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+    notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName));
     return output(`Dispatched synthesis AgentRun ${run.taskId}/${run.id}\n`, { run });
 }
 function taskReviewCommand(args, store, options) {
@@ -4088,7 +4134,7 @@ function requestTaskReviewRound(args, store, options) {
             throw usageError(producerCollision);
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id))
-            .filter((entry) => (entry.scope ?? "work-item") === "task");
+            .filter((entry) => entry.scope === "task");
         const exact = taskRounds.filter((entry) => (entry.reviewerRoleName === reviewerRoleName
             && (deltaRecheckRequested
                 ? entry.deltaRecheck !== undefined
@@ -4282,7 +4328,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
         const requestedBy = taskActor(tx, options, task.id);
-        if ((round.scope ?? "work-item") !== "task") {
+        if (round.scope !== "task") {
             throw usageError(`ReviewRound ${round.id} is not a failed Task-final ReviewRound.`);
         }
         if (round.reviewerRunId !== undefined) {
@@ -4369,11 +4415,11 @@ function taskRunCommand(args, store, options) {
     if (command === "retire")
         return retireRun(rest, store, options);
     throw usageError(command === undefined
-        ? "Task turn command is required."
+        ? "Task run command is required."
         : `Unknown command: task run ${command}`);
 }
 function settleRun(args, store, options) {
-    exactPositionals(args, 1, "Task turn settle usage: yui task run settle <task>/<run>.");
+    exactPositionals(args, 1, "Task run settle usage: yui task run settle <task>/<run>.");
     const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     if (previous.purpose === "review") {
         if (previous.executionGroupId !== undefined
@@ -4454,7 +4500,7 @@ function settleFailedReviewExecutionLaneRun(previous, store, options) {
         };
     });
     for (const run of result.mainRuns) {
-        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName));
     }
     return output(result.changed
         ? `Settled failed Review Producer Lane from AgentRun ${result.run.id}\n`
@@ -4529,7 +4575,7 @@ function settleFailedExecutionLaneRun(previous, store, options) {
         };
     });
     for (const run of result.mainRuns) {
-        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName));
     }
     return output(result.changed
         ? `Settled failed Execution Lane from AgentRun ${result.run.id}\n`
@@ -4540,7 +4586,7 @@ function settleFailedExecutionLaneRun(previous, store, options) {
     });
 }
 function retireRun(args, store, options) {
-    const usage = "Task turn retire usage: yui task run retire <task>/<run> --reason <text> [--expected-progress-at <timestamp>] [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>].";
+    const usage = "Task run retire usage: yui task run retire <task>/<run> --reason <text> [--expected-progress-at <timestamp>] [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>].";
     const parsed = parseTail(args, new Set([
         "--reason",
         "--expected-progress-at",
@@ -4624,7 +4670,7 @@ function retireRun(args, store, options) {
         return { task, run: run, changed: true };
     });
     if (result.changed)
-        options.runtime?.notifyStateChanged(result.task.id);
+        options.runtime?.notifyMailboxChanged({ kind: "task", taskId: result.task.id });
     return output(`Retired AgentRun ${result.task.id}/${result.run.id}\n`, {
         run: result.run,
         retired: true
@@ -4633,7 +4679,7 @@ function retireRun(args, store, options) {
 function runContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
-        const usage = "Task turn context expand usage: yui task run context expand <task>/<run> <ref-id> [--store <store>] [--mode full].";
+        const usage = "Task run context expand usage: yui task run context expand <task>/<run> <ref-id> [--store <store>] [--mode full].";
         const parsed = parseTail(rest, new Set(["--store", "--mode"]), usage);
         exactPositionals(parsed.positionals, 2, usage);
         const mode = parsed.options.get("--mode");
@@ -4647,7 +4693,7 @@ function runContextCommand(args, store, options) {
     }
     if (first === "delta") {
         if (rest.length !== 3 || rest[1] !== "--after") {
-            throw usageError("Task turn context delta usage: yui task run context delta <task>/<run> --after <cursor>.");
+            throw usageError("Task run context delta usage: yui task run context delta <task>/<run> --after <cursor>.");
         }
         const { taskId, runId } = parseRunContextReference(rest[0]);
         authorizeRunContext(store, taskId, runId, options.environment);
@@ -4655,7 +4701,7 @@ function runContextCommand(args, store, options) {
         return output(`${JSON.stringify(delta, null, 2)}\n`, { contextDelta: delta });
     }
     if (first === undefined || rest.length !== 0) {
-        throw usageError("Task turn context usage: yui task run context <task>/<run>.");
+        throw usageError("Task run context usage: yui task run context <task>/<run>.");
     }
     const { taskId, runId } = parseRunContextReference(first);
     authorizeRunContext(store, taskId, runId, options.environment);
@@ -4696,7 +4742,7 @@ function authorizeRunContext(store, taskId, runId, environment) {
     }
 }
 function listRuns(args, store, options) {
-    const usage = "Task turn list usage: yui task run list <task|task/work>.";
+    const usage = "Task run list usage: yui task run list <task|task/work>.";
     exactPositionals(args, 1, usage);
     const reference = args[0];
     const task = store.getTask(reference);
@@ -4741,7 +4787,7 @@ function listRuns(args, store, options) {
  * creates one fresh Round over the newer frozen Task heads.
  */
 function settleStaleFinalReviewRun(args, store, options) {
-    exactPositionals(args, 1, "Task turn settle usage: yui task run settle <task>/<run>.");
+    exactPositionals(args, 1, "Task run settle usage: yui task run settle <task>/<run>.");
     const now = clock(options);
     const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     const result = store.transaction((tx) => {
@@ -4760,7 +4806,7 @@ function settleStaleFinalReviewRun(args, store, options) {
         if (round === null) {
             throw dataError(`ReviewRound not found for AgentRun ${run.id}: ${run.reviewRoundId}.`);
         }
-        if ((round.scope ?? "work-item") !== "task") {
+        if (round.scope !== "task") {
             throw usageError(`Review AgentRun ${run.id} is not a Task-final review; request a new WorkItem review `
                 + "for a new Candidate.");
         }
@@ -4780,7 +4826,7 @@ function settleStaleFinalReviewRun(args, store, options) {
             throw usageError(`${task.id}/${round.reviewerRoleName} already has active AgentRun ${activeRoleRun.id}.`);
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id)
-            .filter((entry) => (entry.scope ?? "work-item") === "task"));
+            .filter((entry) => entry.scope === "task"));
         const roundIndex = taskRounds.findIndex(({ id }) => id === round.id);
         if (roundIndex < 0) {
             throw dataError(`Final ReviewRound is not in Task history: ${round.id}.`);
@@ -4821,7 +4867,46 @@ function settleStaleFinalReviewRun(args, store, options) {
         : `Obsolete final Review already settled: ${result.round.id}/${result.run.id}\n`, { reviewRound: result.round, reviewRun: result.run });
 }
 function retryRun(args, store, options) {
-    exactPositionals(args, 1, "Task turn retry usage: yui task run retry <task>/<run>.");
+    return store.transaction(tx => {
+        const previous = requireRun(tx, args[0], options);
+        const existing = tx.listEvents(previous.taskId).find(event => event.type === "run.retried"
+            && event.payload.previousRunId === previous.id);
+        if (existing !== undefined) {
+            return output(`Retry already recorded as ${existing.payload.runId}; retry that exact successor if needed.\n`);
+        }
+        const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
+        const retry = sessions?.providerBinding?.retry;
+        if (options.providerRetryChainId !== undefined
+            && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
+                || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
+                || clock(options).getTime() >= Date.parse(retry.deadline))) {
+            throw usageError("Provider recovery intent is no longer eligible.");
+        }
+        const result = retryRunOperation(args, tx, options);
+        if (retry !== undefined && retry.status !== "recovered" && retry.previousRunId === previous.id && sessions?.providerBinding != null) {
+            const successor = tx.getActiveRun(previous.taskId, previous.roleName);
+            tx.saveTaskRoleSessionSet({
+                ...sessions, providerBinding: {
+                    ...sessions.providerBinding, retry: {
+                        ...retry, status: "waiting", successorAutomatic: options.providerRetryChainId !== undefined,
+                        ...(options.providerRetryChainId === undefined ? {
+                            intentAt: clock(options).toISOString(),
+                            // An explicit manual attempt does not inherit automatic jitter,
+                            // but cannot shorten a trusted server minimum.
+                            nextEligibleAt: new Date(Math.max(clock(options).getTime(), retry.error.retryAfterMs === undefined ? 0
+                                : Date.parse(sessions.providerBinding.run.updatedAt) + retry.error.retryAfterMs + 1)).toISOString()
+                        } : {}),
+                        ...(successor === null ? {} : { successorRunId: successor.id }),
+                        ...(previous.reviewRoundId === undefined ? {} : { successorReviewRoundId: previous.reviewRoundId })
+                    }
+                }
+            });
+        }
+        return result;
+    });
+}
+function retryRunOperation(args, store, options) {
+    exactPositionals(args, 1, "Task run retry usage: yui task run retry <task>/<run>.");
     const now = clock(options);
     const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     if (previous.purpose === "review") {
@@ -5085,10 +5170,10 @@ function retryRun(args, store, options) {
         }, now);
         return { kind: "run", run: created };
     });
-    notifyMailbox(options.runtime, roleMailbox(retried.run.taskId, retried.run.roleName), retried.run.taskId);
+    notifyMailbox(options.runtime, roleMailbox(retried.run.taskId, retried.run.roleName));
     return output(`Retry queued as ${retried.run.id} for ${retried.run.taskId}/${retried.run.roleName}\n`);
 }
-function actualTaskReviewCandidateForMutation(store, task, options) {
+function actualTaskReviewCandidateForMutation(_store, task, options) {
     if (options.actualTaskReviewCandidate === undefined) {
         throw usageError(`Actual Task Project heads were not verified for delivery: ${task.id}.`);
     }
@@ -5224,7 +5309,7 @@ function isSameTaskReviewCandidate(left, right) {
 function assertNoConflictingTaskReviewRound(rounds, reusableRoundIds = [], reviewerRoleName) {
     const reusable = new Set(typeof reusableRoundIds === "string" ? [reusableRoundIds] : reusableRoundIds);
     const conflicting = rounds.find((entry) => (!reusable.has(entry.id)
-        && (entry.scope ?? "work-item") === "task"
+        && entry.scope === "task"
         && (entry.status === "pending" || entry.status === "running")
         && (reviewerRoleName === undefined || entry.reviewerRoleName === reviewerRoleName)));
     if (conflicting !== undefined) {
@@ -5279,7 +5364,7 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
     if (taskFinalContract === undefined || task.projectBindings.length === 0)
         return null;
     const taskRounds = reviewRoundsByIdentity(store.listReviewRounds(task.id))
-        .filter((round) => ((round.scope ?? "work-item") === "task"
+        .filter((round) => (round.scope === "task"
         && sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)));
     const establishedRound = taskRounds.at(-1);
     const config = taskFinalReviewConfig(taskFinalContract);
@@ -5306,7 +5391,7 @@ function prepareFinalTaskReview(store, task, now, taskFinalContract, options) {
     }
     return queueTaskReviewRound(store, task, config, taskCandidate, options, now, establishedRound?.requestedBy ?? "policy", taskFinalContract);
 }
-function resumablePendingFinalTaskReview(store, task, round, config, taskCandidate, taskFinalContract, options) {
+function resumablePendingFinalTaskReview(store, task, round, config, _taskCandidate, taskFinalContract, _options) {
     if (taskFinalContract === undefined || round.taskFinalReviewContract === undefined) {
         throw usageError(`Final Task Review is still active: ${round.id}/${round.status}.`);
     }
@@ -5380,12 +5465,12 @@ function retryFailedReviewRun(previous, store, options, now) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        const requestedBy = taskActor(tx, options, task.id);
+        const requestedBy = options.providerRetryChainId === undefined ? taskActor(tx, options, task.id) : "policy";
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
         }
-        const taskScope = (round.scope ?? "work-item") === "task";
+        const taskScope = round.scope === "task";
         const retryLane = run.executionLaneId === undefined
             ? undefined
             : round.executionGroup?.lanes.find(({ id }) => id === run.executionLaneId);
@@ -5420,7 +5505,7 @@ function retryFailedReviewRun(previous, store, options, now) {
                 throw usageError(`Task-final ReviewRound ${round.id} no longer matches the frozen Task heads.`);
             }
             const taskRounds = reviewRoundsByIdentity(allRounds
-                .filter((entry) => (entry.scope ?? "work-item") === "task"));
+                .filter((entry) => entry.scope === "task"));
             const roundIndex = taskRounds.findIndex(({ id }) => id === round.id);
             if (roundIndex < 0) {
                 throw dataError(`Final ReviewRound is not in Task history: ${round.id}.`);
@@ -5588,7 +5673,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         return { round: resetRound, previousRun: run, created: true };
     });
     if ("run" in result && result.run !== undefined) {
-        notifyMailbox(options.runtime, roleMailbox(result.run.taskId, result.run.roleName), result.run.taskId);
+        notifyMailbox(options.runtime, roleMailbox(result.run.taskId, result.run.roleName));
     }
     return output(result.created
         ? `Review retry requested as ${result.round.id}\n`
@@ -5596,7 +5681,7 @@ function retryFailedReviewRun(previous, store, options, now) {
 }
 /** AgentRun details are retained audit evidence; continuation uses durable Task state. */
 function showRun(args, store, options) {
-    const usage = "Task turn show usage: yui task run show <task>/<run> [--json].";
+    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);
@@ -5648,7 +5733,7 @@ function renderRunShow(run, retirement) {
  * Leader.
  */
 function checkpointRun(args, store, options) {
-    const usage = "Task turn checkpoint usage: yui task run checkpoint <run> (--note <text>|--note-file <path|->).";
+    const usage = "Task run checkpoint usage: yui task run checkpoint <run> (--note <text>|--note-file <path|->).";
     const parsed = parseTail(args, new Set(["--note", "--note-file"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const note = readCommandText(parsed.options.get("--note"), parsed.options.get("--note-file"), "--note", usage);
@@ -5814,12 +5899,12 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             throw usageError(`ReviewRound is not dispatchable: ${round.id}/${round.status}.`);
         }
         if (round.workspace === undefined) {
-            if ((round.scope ?? "work-item") === "task") {
+            if (round.scope === "task") {
                 throw new TaskFinalReviewDispatchDriftError(`ReviewRound workspace is not ready: ${round.id}.`);
             }
             throw usageError(`ReviewRound workspace is not ready: ${round.id}.`);
         }
-        const taskScope = (round.scope ?? "work-item") === "task";
+        const taskScope = round.scope === "task";
         let item;
         let candidate;
         if (taskScope) {
@@ -5852,7 +5937,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
         assertTaskExecutionEnabled(task, "dispatching a Review");
-        if ((round.scope ?? "work-item") === "task") {
+        if (round.scope === "task") {
             let taskFinalContract;
             try {
                 taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
@@ -5893,7 +5978,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         }
         const reviewer = tx.getRole(taskId, round.reviewerRoleName);
         if (reviewer === null) {
-            if ((round.scope ?? "work-item") === "task") {
+            if (round.scope === "task") {
                 throw new TaskFinalReviewDispatchDriftError(`Reviewer Role not found: ${taskId}/${round.reviewerRoleName}.`);
             }
             throw roleNotFound(round.reviewerRoleName);
@@ -5904,7 +5989,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             || storedWorkspace.owner.type !== "review-round"
             || storedWorkspace.owner.reviewRoundId !== round.id) {
             const message = `ReviewRound workspace ownership changed: ${round.id}.`;
-            if ((round.scope ?? "work-item") === "task") {
+            if (round.scope === "task") {
                 throw new TaskFinalReviewDispatchDriftError(message);
             }
             throw usageError(message);
@@ -5915,7 +6000,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 ...(round.executionGroup?.lanes.map(({ roleName }) => roleName) ?? [])
             ]);
             const conflicting = tx.listReviewRounds(task.id).find((entry) => (entry.id !== round.id
-                && (entry.scope ?? "work-item") === "task"
+                && entry.scope === "task"
                 && (entry.status === "pending" || entry.status === "running")
                 && (requestedReviewers.has(entry.reviewerRoleName)
                     || entry.executionGroup?.lanes.some(({ roleName }) => (requestedReviewers.has(roleName))) === true)
@@ -6167,7 +6252,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         return createdRuns;
     });
     for (const run of runs) {
-        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName));
     }
     return runs[0] ?? null;
 }
@@ -6194,7 +6279,7 @@ export function failPendingReviewRound(taskId, reviewRoundId, summary, store, op
         ]);
         return terminal;
     });
-    notifyMailbox(options.runtime, leaderMailbox(taskId), taskId);
+    notifyMailbox(options.runtime, leaderMailbox(taskId));
     return failed;
 }
 export function preserveReviewRoundWorkspace(taskId, reviewRoundId, store, options = {}) {
@@ -6378,20 +6463,6 @@ function appendMessage(store, taskId, body, kind, author, now, context = {}) {
     }, now);
     return message;
 }
-function recordTaskEvent(store, taskId, type, payload, now) {
-    return recordTaskEventRecord(store, taskId, type, payload, now);
-}
-function leaderActionEventPayload(store, taskId, options) {
-    const caller = currentManagedRuntime(store, options.environment, taskId, "leader");
-    // A long-lived Session may be handling direct input while another request
-    // awaits admission. The Role's active pointer cannot prove command origin.
-    return caller === undefined ? {} : { leaderNativeSessionId: caller.nativeSessionId };
-}
-function recordTaskEventRecord(store, taskId, type, payload, now) {
-    const event = createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now);
-    store.saveEvent(taskId, event);
-    return event;
-}
 /** Keeps a free-text AgentRun-fact note bounded so an event payload stays compact. */
 function truncateEventNote(note) {
     const normalized = note.trim();
@@ -6426,13 +6497,6 @@ function runLaunchEventPayload(run) {
             })
     };
 }
-function requireTask(store, taskId) {
-    const id = requiredText(taskId, "Task id");
-    const task = store.getTask(id);
-    if (task === null)
-        throw taskNotFound(id);
-    return task;
-}
 function requireRole(store, taskId, roleName) {
     const name = requiredText(roleName, "Role name");
     const role = store.getRole(taskId, name);
@@ -6474,14 +6538,6 @@ function activeRunPointer(store, run) {
         ? store.getActiveExecutionLaneRun(run.taskId, run.executionGroupId, run.executionLaneId)
         : store.getActiveRun(run.taskId, run.roleName);
 }
-function requireReviewRound(store, reviewRoundId, options) {
-    const reference = taskRecordReference(reviewRoundId, "reviewRound", "ReviewRound reference", options);
-    const round = store.getReviewRound(reference.taskId, reference.localId);
-    if (round === null) {
-        throw usageError(`ReviewRound not found: ${reference.taskId}/${reference.localId}.`);
-    }
-    return round;
-}
 function taskRecordReference(value, kind, label, options) {
     try {
         return resolveTaskRecordReference(requiredText(value, label), {
@@ -6514,23 +6570,11 @@ function chronologicalRuns(runs) {
 function isTerminalWorkItemStatus(status) {
     return ["accepted", "retired"].includes(status);
 }
-function assertTaskOpen(task) {
-    if (task.status === "completed") {
-        throw usageError(`Task ${task.id} is completed; reopen it before continuing.`);
-    }
-    if (task.status === "archived")
-        throw usageError(`Task is archived: ${task.id}.`);
-    if (task.status === "cancelled")
-        throw usageError(`Task is retired: ${task.id}.`);
-}
 function assertTaskExecutionEnabled(task, action) {
     if (task.executionGate.state === "enabled")
         return;
     throw usageError(`Task execution is stopped: ${task.id}. Run "yui task execution start ${task.id}" before ${action}.`);
 }
-function taskActor(store, options, taskId) {
-    return resolveTaskLocalActor(store, options.environment, taskId);
-}
 function inactiveTaskMessage(task, action) {
     if (task.status === "draft") {
         return `Task ${task.id} is a Draft; activate it before ${action}.`;
@@ -6672,317 +6716,12 @@ function parseIsoTimestamp(value, label) {
     }
     return timestamp.toISOString();
 }
-function taskBriefCommand(args, store, options) {
-    const [command, ...rest] = args;
-    if (command === "show") {
-        exactPositionals(rest, 1, "Task brief show usage: yui task brief show <task>.");
-        const task = requireTask(store, rest[0]);
-        const brief = store.getTaskBrief(task.id);
-        if (brief === null) {
-            return output(`Task ${task.id} has no brief.\n`, { taskId: task.id, brief: null });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output([
-            `Task: ${task.id}`,
-            `Objective: ${brief.objective}`,
-            `Boundaries:`,
-            ...(brief.boundaries.length === 0 ? ["  (none)"] : brief.boundaries.map((b) => `  - ${b}`)),
-            `Technical approach: ${brief.technicalApproach || "(not defined)"}`,
-            `Current focus: ${brief.currentFocus}`,
-            `Leader summary: ${brief.leaderSummary}`,
-            `Updated by: ${brief.updatedBy}`,
-            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`
-        ].join("\n").concat("\n"), { taskId: task.id, brief });
-    }
-    if (command === "update") {
-        const usage = "Task brief update usage: yui task brief update <task> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>].";
-        const parsed = parseMultiValueTail(rest, new Set(["--objective", "--approach", "--focus", "--leader-summary"]), new Set(["--boundary"]), usage);
-        exactPositionals(parsed.positionals, 1, usage);
-        const hasObjective = parsed.options.has("--objective");
-        const hasApproach = parsed.options.has("--approach");
-        const hasFocus = parsed.options.has("--focus");
-        const hasSummary = parsed.options.has("--leader-summary");
-        const boundaries = parsed.multiOptions.get("--boundary") ?? [];
-        if (!hasObjective && !hasApproach && !hasFocus && !hasSummary && boundaries.length === 0) {
-            throw usageError("At least one brief field is required.", usage);
-        }
-        const now = clock(options);
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
-            const existing = tx.getTaskBrief(task.id);
-            const updatedBy = taskActor(tx, options, task.id);
-            const brief = existing === null
-                ? createTaskBrief({
-                    objective: requiredText(parsed.options.get("--objective"), "--objective"),
-                    boundaries,
-                    ...(hasApproach
-                        ? { technicalApproach: requiredText(parsed.options.get("--approach"), "--approach") }
-                        : {}),
-                    currentFocus: requiredText(parsed.options.get("--focus"), "--focus"),
-                    leaderSummary: requiredText(parsed.options.get("--leader-summary"), "--leader-summary"),
-                    updatedBy
-                }, now)
-                : updateTaskBrief(existing, {
-                    ...(hasObjective ? { objective: parsed.options.get("--objective") } : {}),
-                    ...(boundaries.length > 0 ? { boundaries } : {}),
-                    ...(hasApproach
-                        ? { technicalApproach: parsed.options.get("--approach") }
-                        : {}),
-                    ...(hasFocus ? { currentFocus: parsed.options.get("--focus") } : {}),
-                    ...(hasSummary ? { leaderSummary: parsed.options.get("--leader-summary") } : {})
-                }, updatedBy, now);
-            tx.saveTaskBrief(task.id, brief);
-            recordTaskEvent(tx, task.id, "brief.updated", {
-                updatedBy,
-                previous: JSON.stringify(existing), current: JSON.stringify(brief)
-            }, now);
-            enqueueWork(tx, taskMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
-            if (task.status === "active" && updatedBy !== "leader") {
-                enqueueWork(tx, leaderMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
-            }
-            return { task, brief };
-        });
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        if (result.task.status === "active") {
-            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        }
-        return output(`Updated brief for ${result.task.id}\n`, { taskId: result.task.id, brief: result.brief });
-    }
-    throw usageError(command === undefined
-        ? "Task brief command is required."
-        : `Unknown command: task brief ${command}`);
-}
 /** Persist only edited fields, not another copy of aggregate execution history.
  * Null records an absent optional field so clearing it remains observable. */
 function editedFieldValues(record, fields) {
     const values = record;
     return JSON.stringify(Object.fromEntries(fields.map((field) => [field, values[field] ?? null])));
 }
-function taskDecisionCommand(args, store, options) {
-    const [command, ...rest] = args;
-    if (command === "record") {
-        const usage = "Task decision record usage: yui task decision record <task> --title <text> --rationale <text>.";
-        const parsed = parseTail(rest, new Set(["--title", "--rationale"]), usage);
-        exactPositionals(parsed.positionals, 1, usage);
-        const title = requiredOption(parsed.options, "--title");
-        const rationale = requiredOption(parsed.options, "--rationale");
-        const now = clock(options);
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
-            const actor = taskActor(tx, options, task.id);
-            const decision = createDecision(tx.nextDecisionId(task.id), task.id, title, rationale, now);
-            tx.saveDecision(task.id, decision);
-            recordTaskEvent(tx, task.id, "decision.recorded", {
-                decisionId: decision.id,
-                title,
-                ...leaderActionEventPayload(tx, task.id, options)
-            }, now);
-            enqueueWork(tx, taskMailbox(task.id), "decision-recorded", now, [taskRef(task.id)]);
-            if (task.status === "active" && actor !== "leader") {
-                enqueueWork(tx, leaderMailbox(task.id), "decision-recorded", now, [taskRef(task.id)]);
-            }
-            return { task, decision };
-        });
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        if (result.task.status === "active")
-            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        return output(`Recorded decision ${result.decision.id} for ${result.task.id}\n`);
-    }
-    if (command === "list") {
-        const usage = "Task decision list usage: yui task decision list <task> [--status active|superseded].";
-        const parsed = parseTail(rest, new Set(["--status"]), usage);
-        exactPositionals(parsed.positionals, 1, usage);
-        const task = requireTask(store, parsed.positionals[0]);
-        let decisions = store.listDecisions(task.id);
-        const status = parsed.options.get("--status");
-        if (status !== undefined) {
-            if (status !== "active" && status !== "superseded") {
-                throw usageError("--status must be active or superseded.", usage);
-            }
-            decisions = decisions.filter((d) => d.status === status);
-        }
-        if (decisions.length === 0) {
-            return output(`No decisions found for ${task.id}.\n`, { taskId: task.id, decisions: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Decisions: ${task.id}`, [
-            { header: "Decision", minWidth: 8, maxWidth: 18 },
-            { header: "Status", minWidth: 6, maxWidth: 12 },
-            { header: "Title", minWidth: 8, maxWidth: 64 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], decisions.map((d) => [d.id, d.status, d.title, presentTime(d.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, decisions });
-    }
-    if (command === "show") {
-        exactPositionals(rest, 2, "Task decision show usage: yui task decision show <task> <decision>.");
-        const task = requireTask(store, rest[0]);
-        const decision = store.getDecision(task.id, rest[1]);
-        if (decision === null)
-            throw dataError(`Decision not found: ${rest[1]}.`);
-        const timeZone = store.getConfig().timeZone;
-        return output([
-            `Decision: ${decision.id}`,
-            `Task: ${task.id}`,
-            `Title: ${decision.title}`,
-            `Rationale: ${decision.rationale}`,
-            `Status: ${decision.status}`,
-            ...(decision.supersededReason === undefined ? [] : [`Superseded reason: ${decision.supersededReason}`]),
-            ...(decision.supersededAt === undefined ? [] : [`Superseded at: ${presentTime(decision.supersededAt, timeZone)}`]),
-            `Created: ${presentTime(decision.createdAt, timeZone)}`,
-            `Updated: ${presentTime(decision.updatedAt, timeZone)}`
-        ].join("\n").concat("\n"), { taskId: task.id, decision });
-    }
-    if (command === "supersede") {
-        const usage = "Task decision supersede usage: yui task decision supersede <task> <decision> --reason <text>.";
-        const parsed = parseTail(rest, new Set(["--reason"]), usage);
-        exactPositionals(parsed.positionals, 2, usage);
-        const reason = requiredOption(parsed.options, "--reason");
-        const now = clock(options);
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
-            const actor = taskActor(tx, options, task.id);
-            const existing = tx.getDecision(task.id, parsed.positionals[1]);
-            if (existing === null)
-                throw dataError(`Decision not found: ${parsed.positionals[1]}.`);
-            const decision = supersedeDecision(existing, reason, now);
-            tx.saveDecision(task.id, decision);
-            recordTaskEvent(tx, task.id, "decision.superseded", {
-                decisionId: decision.id,
-                reason,
-                ...leaderActionEventPayload(tx, task.id, options)
-            }, now);
-            enqueueWork(tx, taskMailbox(task.id), "decision-superseded", now, [taskRef(task.id)]);
-            if (task.status === "active" && actor !== "leader") {
-                enqueueWork(tx, leaderMailbox(task.id), "decision-superseded", now, [taskRef(task.id)]);
-            }
-            return { task, decision };
-        });
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        if (result.task.status === "active")
-            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        return output(`Superseded decision ${result.decision.id} for ${result.task.id}\n`);
-    }
-    throw usageError(command === undefined
-        ? "Task decision command is required."
-        : `Unknown command: task decision ${command}`);
-}
-function taskMilestoneCommand(args, store, options) {
-    const [command, ...rest] = args;
-    if (command === "add") {
-        const usage = "Task milestone add usage: yui task milestone add <task> --title <text> --summary <text>.";
-        const parsed = parseTail(rest, new Set(["--title", "--summary"]), usage);
-        exactPositionals(parsed.positionals, 1, usage);
-        const title = requiredOption(parsed.options, "--title");
-        const summary = requiredOption(parsed.options, "--summary");
-        const now = clock(options);
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
-            const actor = taskActor(tx, options, task.id);
-            const milestone = createMilestone(tx.nextMilestoneId(task.id), task.id, title, summary, actor, now);
-            tx.saveMilestone(task.id, milestone);
-            recordTaskEvent(tx, task.id, "milestone.added", {
-                milestoneId: milestone.id,
-                title,
-                ...leaderActionEventPayload(tx, task.id, options)
-            }, now);
-            enqueueWork(tx, taskMailbox(task.id), "milestone-added", now, [taskRef(task.id)]);
-            return { task, milestone };
-        });
-        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        return output(`Added milestone ${result.milestone.id} for ${result.task.id}\n`);
-    }
-    if (command === "list") {
-        exactPositionals(rest, 1, "Task milestone list usage: yui task milestone list <task>.");
-        const task = requireTask(store, rest[0]);
-        const milestones = store.listMilestones(task.id);
-        if (milestones.length === 0) {
-            return output(`No milestones found for ${task.id}.\n`, { taskId: task.id, milestones: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Milestones: ${task.id}`, [
-            { header: "Milestone", minWidth: 9, maxWidth: 18 },
-            { header: "Title", minWidth: 8, maxWidth: 64 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], milestones.map((m) => [m.id, m.title, presentTime(m.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, milestones });
-    }
-    if (command === "show") {
-        exactPositionals(rest, 2, "Task milestone show usage: yui task milestone show <task> <milestone>.");
-        const task = requireTask(store, rest[0]);
-        const milestone = store.getMilestone(task.id, rest[1]);
-        if (milestone === null)
-            throw dataError(`Milestone not found: ${rest[1]}.`);
-        const timeZone = store.getConfig().timeZone;
-        return output([
-            `Milestone: ${milestone.id}`,
-            `Task: ${task.id}`,
-            `Title: ${milestone.title}`,
-            `Summary: ${milestone.summary}`,
-            `Created by: ${milestone.createdBy}`,
-            `Created: ${presentTime(milestone.createdAt, timeZone)}`
-        ].join("\n").concat("\n"), { taskId: task.id, milestone });
-    }
-    throw usageError(command === undefined
-        ? "Task milestone command is required."
-        : `Unknown command: task milestone ${command}`);
-}
-function taskEventCommand(args, store) {
-    const [command, ...rest] = args;
-    if (command === "list") {
-        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: [] });
-        }
-        const timeZone = store.getConfig().timeZone;
-        return output(`${renderTable(`Events: ${task.id}`, [
-            { header: "Event", minWidth: 8, maxWidth: 18 },
-            { header: "Type", minWidth: 8, maxWidth: 28 },
-            { header: "Created", minWidth: 10, maxWidth: 28 }
-        ], events.map((e) => [e.id, e.type, presentTime(e.createdAt, timeZone)]), defaultTableWidth())}\n`, { taskId: task.id, events });
-    }
-    if (command === "show") {
-        exactPositionals(rest, 2, "Task event show usage: yui task event show <task> <event>.");
-        const task = requireTask(store, rest[0]);
-        const events = store.listEvents(task.id);
-        const event = events.find((e) => e.id === rest[1]) ?? null;
-        if (event === null)
-            throw dataError(`Event not found: ${rest[1]}.`);
-        const timeZone = store.getConfig().timeZone;
-        return output([
-            `Event: ${event.id}`,
-            `Task: ${task.id}`,
-            `Type: ${event.type}`,
-            `Created: ${presentTime(event.createdAt, timeZone)}`,
-            `Payload:`,
-            ...(Object.keys(event.payload).length === 0
-                ? ["  (none)"]
-                : Object.entries(event.payload).map(([k, v]) => `  ${k}: ${v}`))
-        ].join("\n").concat("\n"), { taskId: task.id, event });
-    }
-    throw usageError(command === undefined
-        ? "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
@@ -7075,6 +6814,8 @@ function continuationReportEvents(events) {
  */
 function taskWakeDispatch(args, store, options) {
     const [subcommand] = args;
+    if (subcommand === "retry")
+        return taskWakeRetryCommand(args.slice(1), store, options);
     if (subcommand === "resolve") {
         const usage = "Task wake resolve usage: yui task wake resolve <task> <wake> --reason <quiescence-evidence>.";
         const parsed = parseTail(args.slice(1), new Set(["--reason"]), usage);
@@ -7114,13 +6855,15 @@ function taskWakeDispatch(args, store, options) {
             tx.saveWorkMailbox(completeProcessing(mailbox, claim.batchId));
             return { taskId: task.id, wakeId: wake.id, outcome: "released-without-replay" };
         });
-        notifyMailbox(options.runtime, leaderMailbox(result.taskId), result.taskId);
+        notifyMailbox(options.runtime, leaderMailbox(result.taskId));
         return output(`Released ${result.wakeId} without replay; original acceptance remains unknown.\n`, result);
     }
     if (subcommand === "list" || subcommand === "show") {
         return taskWakeInspectionCommand(args, store);
     }
-    return output(taskWakeForceCommand(args, store, options));
+    throw usageError(subcommand === undefined
+        ? "Task wake command is required."
+        : `Unknown command: task wake ${subcommand}`);
 }
 /**
  * Issue 04 (long-term): the durable wake ledger. `wake list` shows the
@@ -7143,13 +6886,11 @@ function taskWakeInspectionCommand(args, store) {
             { header: "Wake", minWidth: 8, maxWidth: 18 },
             { header: "Status", minWidth: 8, maxWidth: 12 },
             { header: "Reasons", minWidth: 10, maxWidth: 40 },
-            { header: "AgentRun", 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 });
     }
@@ -7171,6 +6912,8 @@ function taskWakeInspectionCommand(args, store) {
         const deliveryEvents = allEvents.filter((event) => (event.type === "notification.delivery" || event.type === "notification.resolved")
             && (event.payload.wakeId === wake.id
                 || event.payload.attemptId?.startsWith(`notification:${task.id}/${wake.id}/`)));
+        const lastDelivery = deliveryEvents.at(-1);
+        const currentClaim = store.getWorkMailbox(leaderMailbox(task.id))?.processing;
         const referenced = (type, id) => wake.refs?.some(ref => ref.type === type && ref.id === id
             && (!("taskId" in ref) || ref.taskId === task.id)) === true;
         const events = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id));
@@ -7188,10 +6931,18 @@ function taskWakeInspectionCommand(args, store) {
             `Wake: ${wake.id}`,
             `Task: ${task.id}`,
             `Status: ${wake.status}`,
-            `Notification: ${deliveryEvents.at(-1)?.payload.outcome ?? "unobserved"}`,
+            `Notification: ${lastDelivery?.payload.outcome ?? "unobserved"}`,
+            ...(lastDelivery?.payload.detail === undefined ? [] : [`Failure: ${lastDelivery.payload.detail}`]),
+            ...(lastDelivery?.payload.errorEventId === undefined ? [] : [
+                `Failure record: ${task.id}/${lastDelivery.payload.errorEventId}`,
+                `Inspect capabilities: ${failureCapabilitiesCommand(task.id, "leader", lastDelivery.payload.errorEventId)}`
+            ]),
+            ...(lastDelivery?.payload.outcome !== "rejected"
+                || currentClaim?.batchId !== lastDelivery.payload.attemptId ? [] : [
+                `Recovery: correct the cause, then yui task wake retry ${task.id} ${wake.id} --reason <correction>.`
+            ]),
             `Reasons: ${wake.reasons.map(renderWakeReason).join(", ")}`,
             `Delta window: ${wake.fromCursor} → ${wake.toCursor}`,
-            ...(wake.runId === undefined ? [] : [`AgentRun: ${wake.runId}`]),
             `Dispatched: ${presentTime(wake.createdAt, timeZone)}`,
             ...(wake.consumedAt === undefined
                 ? []
@@ -7220,130 +6971,13 @@ function taskWakeInspectionCommand(args, store) {
         ? "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();
-    const multiOptions = new Map();
-    for (let index = 0; index < args.length; index += 1) {
-        const value = args[index];
-        if (!value.startsWith("--")) {
-            positionals.push(value);
-            continue;
-        }
-        if (!valueOptions.has(value) && !repeatOptions.has(value) && !flagOptions.has(value)) {
-            throw usageError(`Unsupported option: ${value}.`, usage);
-        }
-        if (flagOptions.has(value)) {
-            if (options.has(value))
-                throw usageError(`Option may only be specified once: ${value}.`, usage);
-            options.set(value, "");
-            continue;
-        }
-        if (repeatOptions.has(value)) {
-            const optionValue = args[index + 1];
-            if (optionValue === undefined || optionValue.startsWith("--")) {
-                throw usageError(`${value} is required.`, usage);
-            }
-            const existing = multiOptions.get(value) ?? [];
-            multiOptions.set(value, [...existing, optionValue]);
-            index += 1;
-            continue;
-        }
-        if (options.has(value))
-            throw usageError(`Option may only be specified once: ${value}.`, usage);
-        const optionValue = args[index + 1];
-        if (optionValue === undefined || optionValue.startsWith("--")) {
-            throw usageError(`${value} is required.`, usage);
-        }
-        options.set(value, optionValue);
-        index += 1;
-    }
-    return { positionals, options, multiOptions };
-}
-function parseTail(args, valueOptions, usage, flagOptions = new Set()) {
-    const positionals = [];
-    const options = new Map();
-    for (let index = 0; index < args.length; index += 1) {
-        const value = args[index];
-        if (!value.startsWith("--")) {
-            positionals.push(value);
-            continue;
-        }
-        if (!valueOptions.has(value) && !flagOptions.has(value)) {
-            throw usageError(`Unsupported option: ${value}.`, usage);
-        }
-        if (options.has(value))
-            throw usageError(`Option may only be specified once: ${value}.`, usage);
-        if (flagOptions.has(value)) {
-            options.set(value, "");
-            continue;
-        }
-        const optionValue = args[index + 1];
-        if (optionValue === undefined || optionValue.startsWith("--")) {
-            throw usageError(`${value} is required.`, usage);
-        }
-        options.set(value, optionValue);
-        index += 1;
-    }
-    return { positionals, options };
-}
-function requiredOption(options, name) {
-    return requiredText(options.get(name), name);
-}
-function optionalNonEmptyOption(options, name) {
-    if (!options.has(name))
-        return undefined;
-    return requiredText(options.get(name), name);
-}
-function exactPositionals(values, count, usage) {
-    if (values.length !== count || values.some((value) => value.trim().length === 0)) {
-        throw usageError(usage);
-    }
-}
-function assertNoArguments(args, usage) {
-    if (args.length > 0)
-        throw usageError(usage);
-}
-function requiredText(value, label) {
-    const normalized = value?.trim();
-    if (normalized === undefined || normalized.length === 0)
-        throw usageError(`${label} is required.`);
-    return normalized;
-}
-function trimmed(value) {
-    const normalized = value?.trim();
-    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
-}
 function titleFrom(body) {
     const oneLine = requiredText(body, "Message body").replace(/\s+/g, " ");
     return oneLine.length <= 80 ? oneLine : `${oneLine.slice(0, 77)}...`;
 }
-function presentTime(value, timeZone) {
-    return formatTimestamp(value, timeZone);
-}
-function output(value, data) {
-    return data === undefined
-        ? { kind: "output", output: value }
-        : { kind: "output", output: value, data };
-}
-function clock(options) {
-    return options.now?.() ?? new Date();
-}
 function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function taskMailbox(taskId) {
-    return { kind: "task", taskId };
-}
-function roleMailbox(taskId, roleName) {
-    return { kind: "role", taskId, roleName };
-}
-function leaderMailbox(taskId) {
-    return roleMailbox(taskId, LEADER_ROLE);
-}
-function taskRef(id) {
-    return { type: "task", id };
-}
 function runRef(taskId, id) {
     return { type: "run", taskId, id };
 }
@@ -7356,14 +6990,3 @@ function messageRef(taskId, id) {
 function eventRef(taskId, id) {
     return { type: "event", taskId, id };
 }
-function notifyMailbox(runtime, target, compatibilityTaskId) {
-    if (runtime?.notifyMailboxChanged !== undefined) {
-        runtime.notifyMailboxChanged(target);
-    }
-    else {
-        runtime?.notifyStateChanged(compatibilityTaskId);
-    }
-}
-function notifyReviewMailbox(_options, runtime, target, compatibilityTaskId) {
-    notifyMailbox(runtime, target, compatibilityTaskId);
-}