@zq-silk/yui 0.12.3 → 0.13.0

package/dist/commands/taskCommands.js

@@ -7,6 +7,7 @@ import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageErr
 import { createTaskEvent } from "../event/taskEvent.js";
 import { createTaskRecordRetirement, isTaskRecordRetired, taskRecordRetirement } from "../task/taskRecordRetirement.js";
 import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
 import { createRoleSessionSet, retireTaskRoleSessionsForWorkspace, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
@@ -18,17 +19,18 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { renderRoleDetails } from "../output/rolePresentation.js";
 import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
-import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
+import { recoverExactAgentRun, retireExactActiveAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
 import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
+import { createRejectedYieldAttempt, rejectedYieldAttemptEventPayload, rejectedYieldAttemptFromTaskEvent, RUN_YIELD_REJECTED_EVENT } from "../run/rejectedYieldAttempt.js";
 import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryRunningReviewExecutionLane, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
 import { projectReviewerAvailability } from "../review/reviewerAvailability.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
-import { LEADER_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
+import { TASK_CONTROL_FINDING_DISPOSITIONS } from "../review/reviewFinding.js";
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { createMilestone } from "../milestone/milestone.js";
@@ -40,7 +42,6 @@ import { blockingProviderContinuations, projectProviderContinuations, runOwnsBlo
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { assertProjectActive, resolveProject } from "../repository/project.js";
 import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
@@ -63,7 +64,7 @@ import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleAc
 import { assertNoOpenInputRequests, isCurrentGlobalOperator, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runGrantCommand } from "./grantCommands.js";
 import { runWorkflowCommand } from "./workflowCommands.js";
-import { taskActor as resolveTaskActor, taskLeaderActionRunId } from "./taskActor.js";
+import { taskLocalActor as resolveTaskLocalActor, taskLeaderActionRunId } from "./taskActor.js";
 import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
@@ -164,7 +165,7 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
  */
 export function preflightTaskCompletion(taskId, store, options = {}, request = {}) {
     const task = requireTask(store, taskId);
-    const actor = taskActor(options, task.id);
+    const actor = taskActor(store, options, task.id);
     if (task.status === "completed") {
         return { task, actor, completed: true, activeTaskReview: false };
     }
@@ -201,9 +202,6 @@ export function preflightTaskCompletion(taskId, store, options = {}, request = {
         .filter((entry) => entry.run !== null);
     const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
     if (leaderEntry !== undefined) {
-        if (actor !== "leader") {
-            throw usageError(`Task ${task.id} has an active Leader run.`);
-        }
         if (leaderEntry.run.workItemId !== undefined) {
             throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
         }
@@ -379,9 +377,7 @@ function taskProjectCommand(args, store, options) {
     const updated = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
         assertTaskOpen(task);
-        if (task.status === "active" && taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may add a Project to an active Task.");
-        }
+        taskActor(tx, options, task.id);
         const project = resolveProject(tx.listProjects(), parsed.positionals[1]);
         if (project === null)
             throw usageError(`Project not found: ${parsed.positionals[1]}.`);
@@ -444,6 +440,7 @@ function updateTaskCommand(args, store, options) {
         const current = requireTask(tx, parsed.positionals[0]);
         if (current.status === "archived")
             throw usageError(`Task is archived: ${current.id}.`);
+        taskActor(tx, options, current.id);
         const updated = updateTaskMetadata(current, {
             ...(parsed.options.has("--title") ? { title: requiredOption(parsed.options, "--title") } : {}),
             ...(parsed.options.has("--type")
@@ -720,8 +717,7 @@ function completeTaskCommand(args, store, options) {
                 changed: false,
                 runtimeCleanupTargets: [],
                 completionAdvisories: [],
-                finalReview: undefined,
-                publishedTreeAuthorization: undefined
+                finalReview: undefined
             };
         }
         const taskFinalContract = preflight.taskFinalReviewContract;
@@ -731,28 +727,6 @@ function completeTaskCommand(args, store, options) {
         const publishedTreeProof = request.acceptedPublishedTreePublicationId === undefined
             ? undefined
             : assertTaskCompletionPublishedTreeProof(tx, task, request.acceptedPublishedTreePublicationId, options.completionPublishedTreeProof, actualTaskCandidate);
-        const requiresContractHandoff = publishedTreeProof !== undefined
-            && taskFinalContract !== undefined;
-        if (requiresContractHandoff && actor !== "leader") {
-            const existing = matchingPublishedTreeAuthorization(tx, publishedTreeProof);
-            const event = existing ?? recordTaskEventRecord(tx, task.id, TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT, publishedTreeAuthorizationPayload(actor, publishedTreeProof), now);
-            enqueueWork(tx, leaderMailbox(task.id), wakeReason("published-tree-authorized", event.id), now, [eventRef(task.id, event.id)]);
-            return {
-                task,
-                changed: false,
-                runtimeCleanupTargets: [],
-                completionAdvisories: [],
-                finalReview: undefined,
-                publishedTreeAuthorization: {
-                    event,
-                    proof: publishedTreeProof,
-                    created: existing === undefined
-                }
-            };
-        }
-        if (publishedTreeProof !== undefined && actor === "leader") {
-            requirePublishedTreeAuthorization(tx, publishedTreeProof);
-        }
         const roles = tx.listRoles(task.id);
         const activeRuns = roles
             .map((role) => ({ role, run: tx.getActiveAgentRun(task.id, role.name) }))
@@ -763,9 +737,6 @@ function completeTaskCommand(args, store, options) {
         // the post-Review readiness fence below.
         const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
         if (leaderEntry !== undefined) {
-            if (actor !== "leader") {
-                throw usageError(`Task ${task.id} has an active Leader run.`);
-            }
             if (leaderEntry.run.workItemId !== undefined) {
                 throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
             }
@@ -796,7 +767,6 @@ function completeTaskCommand(args, store, options) {
                 runtimeCleanupTargets: [],
                 completionAdvisories: [],
                 finalReview,
-                publishedTreeAuthorization: undefined
             };
         }
         // Issue 06: re-validate the full completion readiness inside the
@@ -860,21 +830,9 @@ function completeTaskCommand(args, store, options) {
             changed: true,
             runtimeCleanupTargets,
             completionAdvisories: readiness.advisories,
-            finalReview: undefined,
-            publishedTreeAuthorization: undefined
+            finalReview: undefined
         };
     });
-    if (result.publishedTreeAuthorization !== undefined) {
-        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        const authorization = result.publishedTreeAuthorization;
-        return output(authorization.created
-            ? `Authorized published-tree completion for ${result.task.id} as ${authorization.event.id}; exact Task Leader completion is required.\n`
-            : `Published-tree completion is already authorized for ${result.task.id} as ${authorization.event.id}; exact Task Leader completion is required.\n`, {
-            task: result.task,
-            authorizationEvent: authorization.event,
-            publishedTreeProof: authorization.proof
-        });
-    }
     if (result.changed) {
         for (const target of result.runtimeCleanupTargets) {
             // Cleanup owns an independent lifecycle lane. Never fall back to the
@@ -952,7 +910,7 @@ function archiveTaskCommand(args, store, options) {
     const now = clock(options);
     const result = store.transaction((tx) => {
         const task = requireTask(tx, request.taskId);
-        const actor = taskActor(options, task.id);
+        const actor = taskActor(tx, options, task.id);
         if (task.status === "archived")
             return { task, changed: false };
         if (task.status !== "completed"
@@ -1016,7 +974,7 @@ function retireTaskCommand(args, store, options) {
     const now = clock(options);
     const result = store.transaction((tx) => {
         const task = requireTask(tx, taskId);
-        const actor = taskActor(options, task.id);
+        const actor = taskActor(tx, options, task.id);
         if (task.status === "retired") {
             const same = task.retirementSummary === summary
                 && task.replacementTaskId === replacementTaskId;
@@ -1144,10 +1102,7 @@ export function parseTaskArchiveArguments(args) {
 export function validateTaskArchiveRequest(args, store, options = {}) {
     const request = parseTaskArchiveArguments(args);
     const task = requireTask(store, request.taskId);
-    const actor = taskActor(options, task.id);
-    if (actor === "leader") {
-        throw usageError("Only the global Operator may archive a Task from a managed Session.");
-    }
+    taskActor(store, options, task.id);
     if (task.status !== "archived"
         && task.status !== "completed"
         && task.status !== "retired") {
@@ -1201,7 +1156,7 @@ function taskMessageCommand(args, store, options) {
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
-            const actor = taskActor(options, task.id);
+            const actor = taskActor(tx, options, task.id);
             const message = actor === "leader"
                 ? appendMessage(tx, task.id, body, "role-result", { type: "role", roleName: LEADER_ROLE }, now)
                 : actor === "operator"
@@ -1296,10 +1251,7 @@ function retireMessage(args, store, options) {
     const result = store.transaction((tx) => {
         const task = requireTask(tx, reference.taskId);
         assertTaskOpen(task);
-        const actor = taskActor(options, task.id);
-        if (actor === "leader") {
-            throw usageError("Only the user or global Operator may retire a Task Message.");
-        }
+        const actor = taskActor(tx, options, task.id);
         const message = tx.listMessages(task.id).find(({ id }) => id === reference.localId);
         if (message === undefined) {
             throw dataError(`Task Message not found: ${task.id}/${reference.localId}.`);
@@ -1405,7 +1357,7 @@ function switchTaskRoleSession(args, store, options) {
             throw usageError(inactiveTaskMessage(task, "switching a Provider Conversation"), usage);
         }
         const role = requireRole(tx, task.id, parsed.positionals[1]);
-        const requestedBy = taskActor(options, task.id);
+        const requestedBy = taskActor(tx, options, task.id);
         const leaderRunId = requestedBy === "leader"
             ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome)
             : undefined;
@@ -1476,6 +1428,7 @@ function addTaskRole(args, store, options) {
     const result = store.transaction((tx) => {
         const task = requireTask(tx, taskId);
         assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         assertRoleRuntimeMutationAllowed(tx, {
             scope: "task",
             taskId: task.id,
@@ -1594,6 +1547,7 @@ function updateTaskRole(args, store, options) {
     const updated = store.transaction((tx) => {
         const task = requireTask(tx, taskId);
         assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         const role = requireRole(tx, task.id, roleName);
         const changesLaunchContext = hasRoleLaunchContextOptions(parsed) || parsed.has("--profile");
         const changesAgentConfig = hasAgentConfigOptions(parsed);
@@ -1640,6 +1594,7 @@ function removeTaskRole(args, store, options) {
     const removed = store.transaction((tx) => {
         const task = requireTask(tx, args[0]);
         assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         const role = requireRole(tx, task.id, args[1]);
         if (role.name === LEADER_ROLE)
             throw usageError("The Task Leader role cannot be removed.");
@@ -1669,6 +1624,7 @@ function bindTaskRole(args, store, options) {
     const result = store.transaction((tx) => {
         const task = requireTask(tx, args[0]);
         assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         const role = requireRole(tx, task.id, args[1]);
         assertRoleRuntimeMutationAllowed(tx, {
             scope: "task",
@@ -1722,6 +1678,8 @@ function unbindTaskRole(args, store, options) {
     const now = clock(options);
     const result = store.transaction((tx) => {
         const task = requireTask(tx, args[0]);
+        assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         const role = requireRole(tx, task.id, args[1]);
         try {
             const unbound = unbindRoleAgent(role, tx.getTaskRoleSessionSet(task.id, role.name), args[2], now);
@@ -1772,6 +1730,7 @@ function transferTaskRoleAuthority(args, store, options, action) {
             if (task.status !== "active") {
                 throw usageError(inactiveTaskMessage(task, `${action} Provider authority`));
             }
+            taskActor(tx, options, task.id);
             const role = requireRole(tx, task.id, args[1]);
             const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
             const session = sessions?.sessions[role.activeAgentId];
@@ -1887,6 +1846,7 @@ function createWork(args, store, options) {
     const item = store.transaction((tx) => {
         const task = requireTask(tx, parsed.positionals[0]);
         assertTaskOpen(task);
+        taskActor(tx, options, task.id);
         for (const dependencyId of parsed.after) {
             const dependency = tx.getWorkItem(task.id, dependencyId);
             if (dependency === null)
@@ -1946,9 +1906,7 @@ function updateWorkScope(args, store, options) {
     const updated = store.transaction((tx) => {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, item.taskId);
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may change a Work Item Project scope.");
-        }
+        taskActor(tx, options, task.id);
         if (tx.getActiveAgentRun(task.id, item.assignee ?? "") !== null) {
             throw usageError(`Stop the active Work Item Run before changing scope: ${item.id}.`);
         }
@@ -1996,9 +1954,7 @@ function updateWork(args, store, options) {
         const task = requireTask(tx, current.taskId);
         assertTaskOpen(task);
         if (current.assignee === undefined) {
-            if (taskActor(options, task.id) !== "leader") {
-                throw usageError(`Only the Task Leader may update unassigned Work Item execution: ${current.id}.`);
-            }
+            taskActor(tx, options, task.id);
             if (status === "running") {
                 assertWorkItemDependenciesCompleted(tx, current);
             }
@@ -2143,6 +2099,7 @@ function dispatchWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(inactiveTaskMessage(task, "dispatch"));
         }
+        taskActor(tx, options, task.id);
         const currentGroup = currentWorkItemExecutionGroup(item);
         const existingGroup = currentGroup?.resolution === undefined
             ? currentGroup
@@ -2190,9 +2147,8 @@ function dispatchWork(args, store, options) {
                 + `The Task Leader must run "yui task work update ${item.id} running", `
                 + "then execute it directly or create native subagents in the Leader Session.");
         }
-        if (expanding && taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may expand a running ExecutionGroup.");
-        }
+        if (expanding)
+            taskActor(tx, options, task.id);
         assertWorkItemDependenciesCompleted(tx, item);
         const workspace = tx.getWorkItemWorkspace(task.id, item.id);
         if (workspace?.owner.type === "work-item"
@@ -2572,9 +2528,7 @@ function resolveWorkExecutionGroup(args, store, options) {
         const task = requireTask(tx, item.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "resolving an ExecutionGroup"));
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may resolve an ExecutionGroup.");
-        }
+        taskActor(tx, options, task.id);
         let group = currentWorkItemExecutionGroup(item);
         if (group === undefined
             || (group.stage === undefined
@@ -2806,9 +2760,7 @@ function acceptWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may accept a Work Item.");
-        }
+        const actor = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -2867,9 +2819,9 @@ function acceptWork(args, store, options) {
             ...(candidate.source.type === "run"
                 ? { runId: candidate.source.runId }
                 : { workItemRevision: String(candidate.workItemRevision) }),
-            acceptedBy: "leader",
+            acceptedBy: actor,
             summary,
-            ...leaderActionEventPayload(tx, item.taskId, options)
+            ...(actor === "leader" ? leaderActionEventPayload(tx, item.taskId, options) : {})
         }, now);
         return completed;
     });
@@ -2929,9 +2881,7 @@ function rejectWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may reject a Work Item.");
-        }
+        const actor = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -2945,7 +2895,7 @@ function rejectWork(args, store, options) {
         recordTaskEvent(tx, item.taskId, "work.rejected", {
             workItemId: item.id,
             candidateId: candidate.id,
-            rejectedBy: "leader",
+            rejectedBy: actor,
             summary
         }, now);
         return failed;
@@ -2966,7 +2916,7 @@ function retireWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        const actor = taskActor(options, task.id);
+        const actor = taskActor(tx, options, task.id);
         if (replacementWorkItemId !== undefined) {
             const replacement = requireWorkItem(tx, replacementWorkItemId, options);
             if (replacement.taskId !== task.id) {
@@ -3088,9 +3038,7 @@ function reviewWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may request a Work Item review.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if (item.status !== "awaiting_acceptance") {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
@@ -3117,7 +3065,7 @@ function reviewWork(args, store, options) {
             }
             throw usageError(`ReviewRound is already active: ${activeRound.id}/${activeRound.status}.`);
         }
-        const queued = queueReviewRound(tx, item, config, "leader", now);
+        const queued = queueReviewRound(tx, item, config, requestedBy, now);
         return { ...queued, resumed: false };
     });
     if (result.run !== null) {
@@ -3131,7 +3079,7 @@ function reviewWork(args, store, options) {
         : output(`Review requested as ${result.round.id}\n`, { reviewRound: result.round });
 }
 /**
- * Leader-controlled recovery for a failed Task-final ReviewRound that never
+ * Task-control recovery for a failed Task-final ReviewRound that never
  * created a Reviewer Run. This is deliberately separate from `task run retry`:
  * that command requires an exact failed Agent Run and remains the only retry
  * path for a failed provider execution. Here the old terminal Round is an
@@ -3281,9 +3229,7 @@ function resolveReviewExecutionGroup(args, store, options) {
         const task = requireTask(tx, round.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "resolving a Review ExecutionGroup"));
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may resolve a Reviewer ExecutionGroup.");
-        }
+        taskActor(tx, options, task.id);
         const group = round.executionGroup;
         if (group === undefined
             || (group.lanes.length < 2 && group.strategy.mode !== "adaptive")) {
@@ -3402,7 +3348,7 @@ function disposeReviewFindingCommand(args, store, options) {
     const parsed = parseTail(args, new Set(["--disposition", "--work-item", "--commit", "--verification", "--note", "--superseded-by"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const disposition = requiredOption(parsed.options, "--disposition");
-    if (!LEADER_FINDING_DISPOSITIONS.includes(disposition)) {
+    if (!TASK_CONTROL_FINDING_DISPOSITIONS.includes(disposition)) {
         throw usageError(`Review finding disposition is invalid: ${disposition}.`);
     }
     const now = clock(options);
@@ -3414,12 +3360,12 @@ function disposeReviewFindingCommand(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "dispositioning a review finding"));
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may disposition a review finding.");
-        }
+        const actor = taskActor(tx, options, task.id);
         const command = {
             disposition,
-            by: taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? "leader",
+            by: actor === "leader"
+                ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? actor
+                : actor,
             ...(parsed.options.get("--note") === undefined ? {} : { note: parsed.options.get("--note") }),
             ...(parsed.options.get("--work-item") === undefined ? {} : { workItemId: parsed.options.get("--work-item") }),
             ...(parsed.options.get("--commit") === undefined ? {} : { commit: parsed.options.get("--commit") }),
@@ -3451,9 +3397,7 @@ function planReviewRepairWave(args, store, options) {
             if (currentTask.status !== "active") {
                 throw usageError(inactiveTaskMessage(currentTask, "creating a review repair wave"));
             }
-            if (taskActor(options, currentTask.id) !== "leader") {
-                throw usageError("Only the Task Leader may create a review repair wave.");
-            }
+            taskActor(tx, options, currentTask.id);
             const openItems = tx.listWorkItems(currentTask.id)
                 .filter((item) => item.status === "pending" || item.status === "running");
             return groups.map((group) => {
@@ -3552,9 +3496,7 @@ function requestTaskReviewRound(args, store, options) {
         const task = requireTask(tx, parsed.positionals[0]);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may request a Task-final Review.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if (task.projectBindings.length === 0) {
             throw usageError(`Task ${task.id} has no bound Projects for a Task-final Review.`);
         }
@@ -3706,8 +3648,8 @@ function requestTaskReviewRound(args, store, options) {
             deltaRecord = validateDeltaRecheckRequest(tx, task.id, provenance.candidate, options.deltaRecheckPreflight);
         }
         let created = deltaRecord === undefined
-            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, now, taskFinalContract)
-            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, "leader", provenance.candidate, deltaRecord, now, taskFinalContract);
+            ? createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, requestedBy, provenance.candidate, now, taskFinalContract)
+            : createTaskDeltaReviewRound(tx.nextReviewRoundId(task.id), task.id, reviewerRoleName, requestedBy, provenance.candidate, deltaRecord, now, taskFinalContract);
         let group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
             target: executionTargetForReviewRound(task, created),
@@ -3783,9 +3725,7 @@ function forceFreshTaskReviewRound(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may force a fresh Task-final ReviewRound.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if ((source.scope ?? "work-item") !== "task") {
             throw usageError(`ReviewRound ${source.id} is not a Task-final ReviewRound.`);
         }
@@ -3859,7 +3799,7 @@ function forceFreshTaskReviewRound(args, store, options) {
             reviewer = createTaskRole(tx, task, source.reviewerRoleName, undefined, now, source.reviewerRoleName);
             tx.saveRole(task.id, reviewer);
         }
-        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.reviewerRoleName, "leader", source.taskCandidate, now, taskFinalContract);
+        let created = createTaskReviewRound(tx.nextReviewRoundId(task.id), task.id, source.reviewerRoleName, requestedBy, source.taskCandidate, now, taskFinalContract);
         const group = createExecutionGroup(`execution-group-${created.id}`, task.id, {
             purpose: "review",
             target: executionTargetForReviewRound(task, created),
@@ -3875,7 +3815,8 @@ function forceFreshTaskReviewRound(args, store, options) {
             reviewerRoleName: created.reviewerRoleName,
             taskCandidate: JSON.stringify(created.taskCandidate),
             reason: "source-round-terminal-without-semantic-review",
-            leaderActionRunId: taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? "leader"
+            requestedBy,
+            ...(requestedBy === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
         return { round: created, source, created: true };
     });
@@ -3995,9 +3936,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         const task = requireTask(tx, reference.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may retry a failed Task-final ReviewRound.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         if ((round.scope ?? "work-item") !== "task") {
             throw usageError(`ReviewRound ${round.id} is not a failed Task-final ReviewRound.`);
         }
@@ -4079,7 +4018,7 @@ function retryFailedTaskReviewRound(args, store, options) {
         // Issue 06: infra retry resets the same semantic Round to pending instead
         // of manufacturing a new Round, so Round count and finding identity stay
         // stable across execution-attempt failures.
-        const resetRound = retryTaskReviewRound(round);
+        const resetRound = retryTaskReviewRound(round, requestedBy);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "review.task-final-retried", {
             reviewRoundId: round.id
@@ -4117,8 +4056,16 @@ function taskRunCommand(args, store, options) {
         : `Unknown command: task run ${command}`);
 }
 function retireRun(args, store, options) {
-    const usage = "Task run retire usage: yui task run retire <task>/<run> --reason <text>.";
-    const parsed = parseTail(args, new Set(["--reason"]), usage);
+    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>] [--launch-id <id>].";
+    const parsed = parseTail(args, new Set([
+        "--reason",
+        "--expected-progress-at",
+        "--progress-at",
+        "--agent-id",
+        "--adapter-id",
+        "--native-session-id",
+        "--launch-id"
+    ]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const reason = requiredOption(parsed.options, "--reason");
     const reference = taskRecordReference(parsed.positionals[0], "agentRun", "Agent Run reference", options);
@@ -4126,10 +4073,7 @@ function retireRun(args, store, options) {
     const result = store.transaction((tx) => {
         const task = requireTask(tx, reference.taskId);
         assertTaskOpen(task);
-        const actor = taskActor(options, task.id);
-        if (actor === "leader") {
-            throw usageError("Only the user or global Operator may retire an Agent Run.");
-        }
+        const actor = taskActor(tx, options, task.id);
         let run = tx.getAgentRun(task.id, reference.localId);
         if (run === null)
             throw dataError(`Agent Run not found: ${task.id}/${reference.localId}.`);
@@ -4138,19 +4082,66 @@ function retireRun(args, store, options) {
             return { task, run, changed: false };
         }
         if (run.status === "active") {
-            const terminal = terminalizeExactTaskRun(tx, {
+            if (actor === "leader"
+                && taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) === run.id) {
+                throw usageError("A Task Leader cannot retire its own current authority Run.", usage);
+            }
+            const expectedProgressAt = requiredOption(parsed.options, parsed.options.has("--expected-progress-at")
+                ? "--expected-progress-at"
+                : "--progress-at");
+            if (parsed.options.has("--expected-progress-at") && parsed.options.has("--progress-at")) {
+                throw usageError("--expected-progress-at and --progress-at are mutually exclusive.", usage);
+            }
+            const agentId = requiredOption(parsed.options, "--agent-id");
+            const adapterId = requiredOption(parsed.options, "--adapter-id");
+            const nativeSessionId = parsed.options.get("--native-session-id");
+            const launchId = parsed.options.get("--launch-id");
+            const sessions = tx.getTaskRoleSessionSet(task.id, run.roleName);
+            const session = sessions?.sessions[run.effective.agentId];
+            if (session?.nativeSessionId !== undefined && nativeSessionId === undefined) {
+                throw usageError("--native-session-id is required for this active Run.", usage);
+            }
+            if (session?.nativeSessionId === undefined && launchId === undefined) {
+                throw usageError("--launch-id is required for an opaque active Run.", usage);
+            }
+            const terminal = retireExactActiveAgentRun(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
-                agentId: run.effective.agentId,
                 runId: run.id,
-                receiptId: agentRunDeliveryReceiptId(run),
-                outcome: { status: "failed", summary: `Agent Run retired: ${reason}` }
+                agentId,
+                adapterId,
+                ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
+                ...(launchId === undefined ? {} : { launchId }),
+                expectedProgressAt,
+                reason: `Agent Run retired: ${reason}`
             }, now);
             if (terminal.disposition !== "applied" || terminal.run === null) {
-                throw usageError(`Agent Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                throw usageError(terminal.disposition === "blocked"
+                    ? `Agent Run retirement is blocked: ${run.id}/${terminal.reason ?? "unsafe"}.`
+                    : `Agent Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
             run = terminal.run;
         }
+        recordTaskEvent(tx, task.id, "run.retired", {
+            runId: run.id,
+            reason,
+            ...(parsed.options.get("--expected-progress-at") === undefined
+                && parsed.options.get("--progress-at") === undefined
+                ? {}
+                : {
+                    expectedProgressAt: parsed.options.get("--expected-progress-at")
+                        ?? parsed.options.get("--progress-at")
+                }),
+            ...(parsed.options.get("--native-session-id") === undefined
+                ? {}
+                : { nativeSessionId: parsed.options.get("--native-session-id") }),
+            ...(parsed.options.get("--launch-id") === undefined
+                ? {}
+                : { launchId: parsed.options.get("--launch-id") }),
+            ...(actor === "leader"
+                ? leaderActionEventPayload(tx, task.id, options)
+                : { retiredBy: actor })
+        }, now);
         tx.saveEvent(task.id, createTaskRecordRetirement({
             eventId: tx.nextEventId(task.id),
             taskId: task.id,
@@ -4289,9 +4280,7 @@ function settleStaleFinalReviewRun(args, store, options) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may settle a stale final review Run.");
-        }
+        const actor = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
@@ -4400,7 +4389,9 @@ function settleStaleFinalReviewRun(args, store, options) {
             runId: run.id,
             reviewRoundId: round.id,
             previousTaskCandidate: JSON.stringify(round.taskCandidate),
-            currentTaskCandidate: JSON.stringify(currentTaskCandidate)
+            currentTaskCandidate: JSON.stringify(currentTaskCandidate),
+            settledBy: actor,
+            ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
         return { run, round: terminal, changed: true };
     });
@@ -4951,7 +4942,7 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
     }
 }
 /**
- * Leader-only retry of an exact failed Task-final review Run. The old failed
+ * Task-control retry of an exact failed Task-final review Run. The old failed
  * Run remains the attempt trail, while the semantic ReviewRound is reset to
  * pending under its existing identity. Every identity and frozen-head fence is
  * checked inside one transaction so a partial fail-old-without-reset state can
@@ -4978,9 +4969,7 @@ function retryFailedReviewRun(previous, store, options, now) {
             throw usageError(`Review Run ${run.id} still owns an unsettled Provider continuation; `
                 + "reconcile it before retrying the Lane.");
         }
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may retry a failed final review Run.");
-        }
+        const requestedBy = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
@@ -5160,7 +5149,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         // Issue 06: infra retry resets the same semantic Round to pending instead
         // of manufacturing a new Round, so Round count and finding identity stay
         // stable across execution-attempt failures.
-        const resetRound = retryTaskReviewRound(roundToReset, run.executionLaneId);
+        const resetRound = retryTaskReviewRound(roundToReset, requestedBy, run.executionLaneId);
         tx.saveReviewRound(task.id, resetRound);
         recordTaskEvent(tx, task.id, "run.review-retried", {
             runId: run.id,
@@ -5205,9 +5194,7 @@ function recoverRun(args, store, options) {
         const task = requireTask(tx, active.taskId);
         if (task.status !== "active")
             throw usageError(inactiveTaskMessage(task, "recovering a run"));
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may control exact Agent Run recovery.");
-        }
+        taskActor(tx, options, task.id);
         const roleName = parsed.options.get("--role") ?? active.roleName;
         if (roleName !== active.roleName) {
             throw usageError(`Recovery Role does not match Run ${active.id}: ${roleName}.`);
@@ -5308,18 +5295,27 @@ function showRun(args, store, options) {
         const retirement = tx.listEvents(run.taskId)
             .map(taskRecordRetirement)
             .find((entry) => entry?.recordKind === "agent-run" && entry.recordId === run.id) ?? null;
-        return { run, recovery: projectRunRecovery(facts), retirement };
+        const allRejectedYieldAttempts = tx.listEvents(run.taskId)
+            .map(rejectedYieldAttemptFromTaskEvent)
+            .filter((attempt) => (attempt !== null && attempt.runId === run.id));
+        return {
+            run,
+            recovery: projectRunRecovery(facts),
+            retirement,
+            rejectedYieldAttemptCount: allRejectedYieldAttempts.length,
+            rejectedYieldAttempts: allRejectedYieldAttempts.slice(-16)
+        };
     });
     if (asJson) {
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }
     return {
         kind: "output",
-        output: renderRunShow(data.run, data.recovery, data.retirement),
+        output: renderRunShow(data.run, data.recovery, data.retirement, data.rejectedYieldAttemptCount, data.rejectedYieldAttempts),
         data
     };
 }
-function renderRunShow(run, recovery, retirement) {
+function renderRunShow(run, recovery, retirement, rejectedYieldAttemptCount, rejectedYieldAttempts) {
     const lines = [
         `Run: ${run.id}`,
         `Task: ${run.taskId}`,
@@ -5339,7 +5335,19 @@ function renderRunShow(run, recovery, retirement) {
             : [`Provider accepted (durable): ${run.deliveredAt}`]),
         ...(run.summary === undefined || run.summary.trim().length === 0
             ? []
-            : [`Summary: ${run.summary}`])
+            : [`Summary: ${run.summary}`]),
+        ...(rejectedYieldAttemptCount === 0
+            ? []
+            : [
+                `Rejected yield attempts: ${rejectedYieldAttempts.length} shown of ${rejectedYieldAttemptCount} (unaccepted diagnostic evidence only)`,
+                ...rejectedYieldAttempts.slice(-5).flatMap((attempt) => [
+                    `  ${attempt.attemptedAt}: ${attempt.rejectionReason} (${attempt.attemptDigest.slice(0, 16)})`,
+                    `    Reviewer output: ${truncateRunShowText(attempt.summary)}`,
+                    `    Checks: ${attempt.checks.length === 0
+                        ? "none"
+                        : attempt.checks.map(({ name, outcome }) => `${name}:${outcome}`).join(", ")}`
+                ])
+            ])
     ];
     if (recovery.canonicalProgressAt !== null) {
         lines.push(`Canonical recovery fence (Yui durable CAS): ${recovery.canonicalProgressAt}`, ...(recovery.canonicalProgressEvidence === undefined
@@ -5370,6 +5378,10 @@ function renderRunShow(run, recovery, retirement) {
     }
     return `${lines.join("\n")}\n`;
 }
+function truncateRunShowText(value) {
+    const normalized = value.replaceAll(/\s+/gu, " ").trim();
+    return normalized.length <= 400 ? normalized : `${normalized.slice(0, 399)}…`;
+}
 /**
  * Issue 04: builds the terminal yield outcome from the command inputs. The
  * same construction feeds both the first commit and the idempotent replay, so
@@ -5462,6 +5474,70 @@ function yieldRunStatus(args, store, options) {
         + `Request: ${run.yieldReceipt.requestId}\n`
         + `Committed: ${run.yieldReceipt.committedAt}\n`, { receipt: run.yieldReceipt });
 }
+function recordRejectedReviewYield(store, input) {
+    if (input.run.purpose !== "review" || input.run.reviewRoundId === undefined) {
+        throw new Error(`Only a Review Run can record rejected yield evidence: ${input.run.id}.`);
+    }
+    const receiptId = agentRunDeliveryReceiptId(input.run);
+    const sessions = store.getTaskRoleSessionSet(input.run.taskId, input.run.roleName);
+    const durableSession = sessions?.sessions[input.run.effective.agentId];
+    const attempt = createRejectedYieldAttempt({
+        taskId: input.run.taskId,
+        runId: input.run.id,
+        roleName: input.run.roleName,
+        reviewRoundId: input.run.reviewRoundId,
+        receiptId,
+        rejectionReason: input.rejectionReason,
+        summary: input.outcome.summary,
+        ...(input.outcome.reviewResult === undefined
+            ? {}
+            : { reviewResult: input.outcome.reviewResult }),
+        ...(input.nativeSessionId === undefined
+            ? {}
+            : { nativeSessionId: input.nativeSessionId }),
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        ...(durableSession?.nativeSessionId === undefined
+            ? {}
+            : { durableNativeSessionId: durableSession.nativeSessionId }),
+        ...(durableSession?.launchId === undefined
+            ? {}
+            : { durableLaunchId: durableSession.launchId }),
+        ...(sessions?.inFlight?.runId === undefined
+            ? {}
+            : { inFlightRunId: sessions.inFlight.runId }),
+        ...(sessions?.inFlight?.receiptId === undefined
+            ? {}
+            : { inFlightReceiptId: sessions.inFlight.receiptId }),
+        ...(input.run.assignment.contextSnapshotRef === undefined
+            ? {}
+            : { contextSnapshot: input.run.assignment.contextSnapshotRef }),
+        activeRun: input.activeRun === null
+            ? null
+            : {
+                id: input.activeRun.id,
+                receiptId: agentRunDeliveryReceiptId(input.activeRun),
+                ...(input.activeRun.assignment.contextSnapshotRef === undefined
+                    ? {}
+                    : { contextSnapshot: input.activeRun.assignment.contextSnapshotRef })
+            },
+        attemptedAt: input.now
+    });
+    const existing = store.listEvents(input.run.taskId).find((event) => (event.type === RUN_YIELD_REJECTED_EVENT
+        && event.payload.runId === input.run.id
+        && event.payload.receiptId === receiptId
+        && event.payload.attemptDigest === attempt.attemptDigest));
+    if (existing !== undefined) {
+        const persisted = rejectedYieldAttemptFromTaskEvent(existing);
+        if (persisted === null) {
+            throw new Error(`Rejected yield attempt is malformed: ${existing.id}.`);
+        }
+        return { attempt: persisted, event: existing, created: false };
+    }
+    const event = createTaskEvent(store.nextEventId(input.run.taskId), input.run.taskId, RUN_YIELD_REJECTED_EVENT, rejectedYieldAttemptEventPayload(attempt), input.now);
+    store.saveEvent(input.run.taskId, event);
+    routeRoleEvent(store, event, input.run.roleName, "run-yield-rejected", input.now);
+    return { attempt, event, created: true };
+}
 function yieldRun(args, store, options) {
     const usage = "Task run yield usage: yui task run yield <task>/<run> (--summary <text>|--summary-file <path|->).";
     const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage);
@@ -5491,8 +5567,6 @@ function yieldRun(args, store, options) {
             throw usageError(inactiveTaskMessage(task, "yielding a run"));
         const role = requireRole(tx, task.id, active.roleName);
         const pointer = activeRunPointer(tx, active);
-        if (pointer?.id !== active.id)
-            throw usageError(`Run is not active for ${task.id}/${role.name}: ${active.id}.`);
         const taskFinalContract = active.purpose === "execution"
             && active.workItemId !== undefined
             ? taskFinalReviewContractForMutation(tx, task.id, options)
@@ -5545,6 +5619,27 @@ function yieldRun(args, store, options) {
                 : { reviewResult: yieldOutcome.reviewResult })
         }, now);
         if (terminalization.disposition !== "applied" || terminalization.run === null) {
+            if (active.purpose === "review" && active.reviewRoundId !== undefined) {
+                const rejected = recordRejectedReviewYield(tx, {
+                    run: active,
+                    activeRun: pointer,
+                    rejectionReason: terminalization.reason ?? "obsolete",
+                    outcome: yieldOutcome,
+                    ...(options.environment?.YUI_NATIVE_SESSION_ID === undefined
+                        ? {}
+                        : { nativeSessionId: options.environment.YUI_NATIVE_SESSION_ID }),
+                    ...(options.environment?.YUI_LAUNCH_ID === undefined
+                        ? {}
+                        : { launchId: options.environment.YUI_LAUNCH_ID }),
+                    now
+                });
+                return {
+                    kind: "rejected",
+                    run: active,
+                    rejected,
+                    notifyLeader: rejected.created
+                };
+            }
             throw usageError(`Run ${active.id} no longer matches its exact execution fence: `
                 + `${terminalization.reason ?? "obsolete"}.`);
         }
@@ -5727,6 +5822,7 @@ function yieldRun(args, store, options) {
             if (receipt !== null) {
                 tx.saveAgentRun(receipt);
                 return {
+                    kind: "yielded",
                     run: receipt,
                     reviewDispatch,
                     notifyLeader: leaderHandoff !== null
@@ -5734,11 +5830,21 @@ function yieldRun(args, store, options) {
             }
         }
         return {
+            kind: "yielded",
             run: terminal,
             reviewDispatch,
             notifyLeader: leaderHandoff !== null
         };
     });
+    if (yielded.kind === "rejected") {
+        if (yielded.notifyLeader) {
+            notifyMailbox(options.runtime, leaderMailbox(yielded.run.taskId), yielded.run.taskId);
+        }
+        throw usageError(`Run ${yielded.run.id} no longer matches its exact execution fence: `
+            + `${yielded.rejected.attempt.rejectionReason}. `
+            + `Rejected Reviewer output was recorded as ${yielded.rejected.event.id} `
+            + "(unaccepted diagnostic evidence only).");
+    }
     if (yielded.notifyLeader) {
         notifyMailbox(options.runtime, leaderMailbox(yielded.run.taskId), yielded.run.taskId);
     }
@@ -6267,6 +6373,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
 export function failPendingReviewRound(taskId, reviewRoundId, summary, store, options = {}) {
     const now = clock(options);
     const failed = store.transaction((tx) => {
+        const task = requireTask(tx, taskId);
+        taskActor(tx, options, task.id);
         const round = tx.getReviewRound(taskId, reviewRoundId);
         if (round === null)
             throw usageError(`ReviewRound not found: ${taskId}/${reviewRoundId}.`);
@@ -6377,52 +6485,6 @@ function recordTaskEventRecord(store, taskId, type, payload, now) {
     store.saveEvent(taskId, event);
     return event;
 }
-function publishedTreeAuthorizationPayload(actor, proof) {
-    return {
-        by: actor,
-        projectId: proof.projectId,
-        publicationId: proof.publicationId,
-        ...(proof.reviewRoundId === undefined
-            ? { reviewAnchor: publishedTreeReviewAnchor(proof) }
-            : { reviewRoundId: proof.reviewRoundId }),
-        localCommit: proof.localCommit,
-        remoteCommit: proof.remoteCommit,
-        tree: proof.tree
-    };
-}
-function matchingPublishedTreeAuthorization(store, proof) {
-    const events = store.listEvents(proof.taskId);
-    for (let index = events.length - 1; index >= 0; index -= 1) {
-        const event = events[index];
-        if (event.type === "task.completed" || event.type === "task.reopened")
-            return undefined;
-        if (event.type === TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT
-            && (event.payload.by === "user" || event.payload.by === "operator")
-            && event.payload.projectId === proof.projectId
-            && event.payload.publicationId === proof.publicationId
-            && (event.payload.reviewAnchor ?? event.payload.reviewRoundId)
-                === publishedTreeReviewAnchor(proof)
-            && event.payload.localCommit === proof.localCommit
-            && event.payload.remoteCommit === proof.remoteCommit
-            && event.payload.tree === proof.tree) {
-            return event;
-        }
-    }
-    return undefined;
-}
-function requirePublishedTreeAuthorization(store, proof) {
-    const authorization = matchingPublishedTreeAuthorization(store, proof);
-    if (authorization === undefined) {
-        throw usageError(`Published-tree completion requires explicit user or global Operator authorization for `
-            + `${proof.taskId}/${proof.publicationId} at ${proof.reviewRoundId === undefined
-                ? "the Leader-owned Task-main head"
-                : `Task-final Review ${proof.reviewRoundId}`}.`);
-    }
-    return authorization;
-}
-function publishedTreeReviewAnchor(proof) {
-    return proof.reviewRoundId ?? "direct";
-}
 /** Keeps a free-text run-fact note bounded so an event payload stays compact. */
 function truncateEventNote(note) {
     const normalized = note.trim();
@@ -6565,8 +6627,8 @@ function assertTaskOpen(task) {
     if (task.status === "retired")
         throw usageError(`Task is retired: ${task.id}.`);
 }
-function taskActor(options, taskId) {
-    return resolveTaskActor(options.environment, taskId);
+function taskActor(store, options, taskId) {
+    return resolveTaskLocalActor(store, options.environment, taskId, options.yuiHome);
 }
 function taskRoleDispatchMode(store, taskId, roleName, sessions, agentId, effective) {
     return roleSessionDispatchModeWithConversationSwitch(sessions, store.listEvents(taskId), store.getWorkMailbox({ kind: "role", taskId, roleName }), roleName, agentId, effective);
@@ -6741,7 +6803,7 @@ function taskBriefCommand(args, store, options) {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
             const existing = tx.getTaskBrief(task.id);
-            const updatedBy = taskActor(options, task.id);
+            const updatedBy = taskActor(tx, options, task.id);
             const brief = existing === null
                 ? createTaskBrief({
                     objective: requiredText(parsed.options.get("--objective"), "--objective"),
@@ -6792,7 +6854,7 @@ function taskDecisionCommand(args, store, options) {
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
-            const actor = taskActor(options, task.id);
+            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", {
@@ -6863,7 +6925,7 @@ function taskDecisionCommand(args, store, options) {
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
-            const actor = taskActor(options, task.id);
+            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]}.`);
@@ -6901,10 +6963,8 @@ function taskMilestoneCommand(args, store, options) {
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
             assertTaskOpen(task);
-            if (taskActor(options, task.id) !== "leader") {
-                throw usageError("Only the Task Leader can add a Milestone.");
-            }
-            const milestone = createMilestone(tx.nextMilestoneId(task.id), task.id, title, summary, now);
+            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,