@zq-silk/yui 0.12.2 → 0.12.4

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,11 +19,12 @@ 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";
@@ -63,7 +65,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 +166,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 };
     }
@@ -379,7 +381,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") {
+        if (task.status === "active" && taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may add a Project to an active Task.");
         }
         const project = resolveProject(tx.listProjects(), parsed.positionals[1]);
@@ -444,6 +446,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")
@@ -952,7 +955,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 +1019,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,7 +1147,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);
+    const actor = taskActor(store, options, task.id);
     if (actor === "leader") {
         throw usageError("Only the global Operator may archive a Task from a managed Session.");
     }
@@ -1201,7 +1204,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 +1299,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 +1405,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 +1476,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 +1595,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 +1642,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 +1672,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 +1726,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 +1778,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 +1894,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,7 +1954,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may change a Work Item Project scope.");
         }
         if (tx.getActiveAgentRun(task.id, item.assignee ?? "") !== null) {
@@ -1996,7 +2004,7 @@ function updateWork(args, store, options) {
         const task = requireTask(tx, current.taskId);
         assertTaskOpen(task);
         if (current.assignee === undefined) {
-            if (taskActor(options, task.id) !== "leader") {
+            if (taskActor(tx, options, task.id) !== "leader") {
                 throw usageError(`Only the Task Leader may update unassigned Work Item execution: ${current.id}.`);
             }
             if (status === "running") {
@@ -2143,6 +2151,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,7 +2199,7 @@ 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") {
+        if (expanding && taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may expand a running ExecutionGroup.");
         }
         assertWorkItemDependenciesCompleted(tx, item);
@@ -2572,7 +2581,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may resolve an ExecutionGroup.");
         }
         let group = currentWorkItemExecutionGroup(item);
@@ -2806,7 +2815,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may accept a Work Item.");
         }
         if (item.status !== "awaiting_acceptance") {
@@ -2929,7 +2938,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may reject a Work Item.");
         }
         if (item.status !== "awaiting_acceptance") {
@@ -2966,7 +2975,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,7 +3097,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may request a Work Item review.");
         }
         if (item.status !== "awaiting_acceptance") {
@@ -3281,7 +3290,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may resolve a Reviewer ExecutionGroup.");
         }
         const group = round.executionGroup;
@@ -3414,7 +3423,7 @@ 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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may disposition a review finding.");
         }
         const command = {
@@ -3451,7 +3460,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") {
+            if (taskActor(tx, options, currentTask.id) !== "leader") {
                 throw usageError("Only the Task Leader may create a review repair wave.");
             }
             const openItems = tx.listWorkItems(currentTask.id)
@@ -3552,7 +3561,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may request a Task-final Review.");
         }
         if (task.projectBindings.length === 0) {
@@ -3783,7 +3792,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may force a fresh Task-final ReviewRound.");
         }
         if ((source.scope ?? "work-item") !== "task") {
@@ -3995,7 +4004,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may retry a failed Task-final ReviewRound.");
         }
         if ((round.scope ?? "work-item") !== "task") {
@@ -4117,8 +4126,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 +4143,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 +4152,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,7 +4350,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may settle a stale final review Run.");
         }
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
@@ -4978,7 +5039,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may retry a failed final review Run.");
         }
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
@@ -5205,7 +5266,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") {
+        if (taskActor(tx, options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may control exact Agent Run recovery.");
         }
         const roleName = parsed.options.get("--role") ?? active.roleName;
@@ -5308,18 +5369,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 +5409,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 +5452,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 +5548,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 +5641,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 +5693,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 +5896,7 @@ function yieldRun(args, store, options) {
             if (receipt !== null) {
                 tx.saveAgentRun(receipt);
                 return {
+                    kind: "yielded",
                     run: receipt,
                     reviewDispatch,
                     notifyLeader: leaderHandoff !== null
@@ -5734,11 +5904,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 +6447,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}.`);
@@ -6565,8 +6747,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 +6923,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 +6974,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 +7045,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,7 +7083,7 @@ 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") {
+            if (taskActor(tx, 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);