@zq-silk/yui 0.15.7 → 0.15.9

package/dist/commands/taskCommands.js

@@ -1,27 +1,33 @@
+import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { randomUUID } from "node:crypto";
+import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { createTurnInput } from "../context/turnInputContract.js";
-import { buildTurnContextPack, buildTurnContextDelta, contextSnapshotDeltaRefIds, expandTurnContextRef, freezeWorkItemExecutionAssignmentContextSnapshot, freezeReviewStageContextSnapshot, freezeTurnContextSnapshot } from "../context/turnContextPack.js";
+import { createRunInput } from "../context/runInputContract.js";
+import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeWorkItemExecutionAssignmentContextSnapshot, freezeReviewStageContextSnapshot, freezeRunContextSnapshot } from "../context/runContextPack.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { createTaskRecordRetirement, isTaskRecordRetired, operationalTaskRecords, taskRecordRetirement } from "../task/taskRecordRetirement.js";
-import { referencedWakeTurnIds } from "../context/wakeNotification.js";
-import { isRoleTurnStalled, TURN_PROGRESS_EVENT, TURN_RECOVERED_EVENT } from "../scheduler/roleTurnStall.js";
+import { referencedWakeRunIds } from "../context/wakeNotification.js";
+import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
-import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime, taskRoleControlTarget } from "../executor/agentExecutor.js";
+import { transferProviderAuthority, currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
+import { agentExecutionComponentLabel } from "../agent/executionComponents.js";
+import { agentRunConfigurationLabel, renderAgentRunConfiguration } from "../output/agentRunConfigurationPresentation.js";
 import { formatTimestamp } from "../output/timePresentation.js";
-import { renderRoleDetails } from "../output/rolePresentation.js";
-import { createTaskMessage, taskMessageAuthorLabel, updateDraftTaskMessage } from "../message/message.js";
+import { renderRoleDetails, renderRoleLaunchComparison } from "../output/rolePresentation.js";
+import { createTaskMessage, expandTaskMessageResult, taskMessageAuthorLabel, updateDraftTaskMessage, withSubmissionReceipt, TASK_SUBMISSION_INTENTS } from "../message/message.js";
 import { assertDraftTaskExecutionFree, validateDraftWorkItemEdit } from "../task/draftPlan.js";
+import { TASK_PLANNING_ENTERED_EVENT, decideSubmissionRouting, describeSubmissionFeedback, draftActivationState, draftHasEnteredPlanning, normalizeSubmissionIntent, sameSubmissionTarget } from "../task/taskSubmission.js";
+import { recordTaskActivationRequestInTransaction, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
-import { retireExactActiveTurn, terminalizeExactTaskTurn, validateExactTurnReviewRound } from "../lifecycle/exactTurnTerminalization.js";
+import { retireExactActiveRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole } from "../role/role.js";
-import { createTurn, withTurnContextSnapshot } from "../turn/turn.js";
+import { createRun, runPurposeAdmitsTaskState, runExecutionObservation, withRunContextSnapshot } from "../agentRun/agentRun.js";
 import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, finishReviewRound, recordReviewWorkspaceDisposition, retryReviewRound, retryRunningReviewExecutionLane, retryTaskReviewRound, startReplicatedReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { isCompletedTaskReviewEvidence } from "../review/reviewAcceptance.js";
@@ -30,38 +36,45 @@ import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
 import { createDecision, supersedeDecision } from "../decision/decision.js";
 import { createMilestone } from "../milestone/milestone.js";
 import { runPublicationCommand } from "./taskPublicationCommands.js";
+import { runTaskActivationCommand, nonLeaderActivationIdentity } from "./taskActivationCommands.js";
 import { assertTaskRemoteDeliveryProof, projectTaskRemoteDeliveryFromStore, renderTaskRemoteDelivery, runTaskRemoteDeliveryCommand } from "./taskRemoteDeliveryCommand.js";
-import { enqueueRoleTurnDispatch, enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
-import { mailboxHasWork as workMailboxHasWork } from "../coordination/workMailbox.js";
-import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { enqueueRoleRunDispatch, enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
+import { completeProcessing } from "../coordination/workMailbox.js";
+import { runtimeLifecycleTarget, RUNTIME_SESSION_REPLACE_REQUIRED_REASON } from "../runtime/lifecycleReservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, updateTaskMetadata } from "../task/task.js";
+import { addTaskProjectBinding, archiveTask, completeTask, createTask, retireTask, reopenTask, taskOwnsManagedWorkspace, updateTaskMetadata } from "../task/task.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
+import { StorageConflictError } from "../storage/taskStore.js";
 import { requireResolvedAgentProfileRuntime } from "../profile/agentProfileRuntime.js";
 import { assertProjectActive, resolveProject } from "../repository/project.js";
-import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, editDraftWorkItemDefinition, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
+import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, editWorkItemDefinition, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, prepareWorkItemDispatch, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
 import { assertWorkItemDependenciesCompleted as assertWorkItemDependencyGate, WorkItemDependencyGateError } from "../workItem/dependencyGate.js";
-import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
-import { reconcileWorkItemMainTurns, successfulWorkItemSynthesisProducers } from "../execution/workItemMainTurn.js";
-import { reconcileReviewMainTurns } from "../execution/reviewMainTurn.js";
+import { createExecutionGroup, createReviewExecutionAssignment, createWorkItemExecutionAssignment, createWorkItemExecutionGroup, updateExecutionLane as updateUnifiedExecutionLane, updateWorkItemExecutionLane, workItemExecutionGroupSettled } from "../execution/workItemExecution.js";
+import { dispatchWorkItemSynthesis, selectedWorkItemSynthesisProducers } from "../execution/workItemMainRun.js";
+import { dispatchReviewSynthesis, selectedReviewSynthesisProducers } from "../execution/reviewMainRun.js";
+import { synthesisSourceRunIds } from "../context/runContextPack.js";
 import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
 import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { hasAgentConfigOptions, hasNoRoleMutation, parseRoleOptions, patchRoleAgentBinding, roleOptionSpecs, roleProfilePatch } from "./roleConfiguration.js";
 import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
-import { assertLiveRoleSessionAcknowledged, assertRoleRuntimeMutationAllowed, LIVE_SESSION_ACKNOWLEDGEMENT_OPTION } from "./roleRuntimeGuard.js";
+import { assertRoleRuntimeMutationAllowed } from "./roleRuntimeGuard.js";
 import { runTaskContextCommand } from "./taskContextCommand.js";
+import { listContextMessages } from "../context/taskContext.js";
+import { createProjectResources } from "../resources/projectResourceService.js";
+import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
 import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
-import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastTurnLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel } from "./taskRoleRuntimeStatus.js";
+import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastRunLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel } from "./taskRoleRuntimeStatus.js";
 import { assertNoOpenInputRequests, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runGrantCommand } from "./grantCommands.js";
 import { runWorkflowCommand } from "./workflowCommands.js";
-import { taskLocalActor as resolveTaskLocalActor, taskLeaderActionTurnId } from "./taskActor.js";
-import { currentManagedRuntime } from "../runtime/managedCaller.js";
+import { taskLocalActor as resolveTaskLocalActor, assertTaskDeliveryAuthority } from "./taskActor.js";
+import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
+import { resolveMessageRecipient, messageContinuationBlocker } from "../message/messageContinuation.js";
 import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
@@ -181,8 +194,11 @@ export function previewTaskRoleAgentConfigurationMutation(args, store) {
         }
         const parsed = parseRoleOptions(tail, new Map([
             ...roleOptionSpecs({ update: true, includeAgent: true }),
-            ["--profile", "value"]
+            ["--profile", "value"],
+            ["--environment", "value"],
+            ["--managed-environment", "flag"]
         ]), usage);
+        validateTaskRoleEnvironmentOptions(parsed, usage);
         if (parsed.has("--agent") && (parsed.one("--agent")?.trim().length ?? 0) === 0) {
             throw usageError("--agent is required.", usage);
         }
@@ -201,7 +217,7 @@ export function previewTaskRoleAgentConfigurationMutation(args, store) {
 }
 export function parseTaskCompletionRequest(args, summaryOverride) {
     const usage = "Task complete usage: yui task complete <id> (--summary <text>|--summary-file <path|->) [--refresh-remote] [--accept-published-tree <publication-id>].";
-    const parsed = parseTail(args, new Set(["--summary", "--summary-file", "--accept-published-tree"]), usage, new Set(["--refresh-remote"]));
+    const parsed = parseMultiValueTail(args, new Set(["--summary", "--summary-file", "--accept-published-tree"]), new Set(["--artifact-ref"]), usage, new Set(["--refresh-remote"]));
     exactPositionals(parsed.positionals, 1, usage);
     const inlineSummary = parsed.options.get("--summary");
     const summaryFile = parsed.options.get("--summary-file");
@@ -213,6 +229,7 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
     return {
         taskId: parsed.positionals[0],
         summary,
+        artifactRefs: parsed.multiOptions.get("--artifact-ref") ?? [],
         ...(acceptedPublishedTreePublicationId === undefined
             ? {}
             : { acceptedPublishedTreePublicationId })
@@ -233,6 +250,7 @@ export function parseTaskCompletionRequest(args, summaryOverride) {
 export function preflightTaskCompletion(taskId, store, options = {}, request = {}) {
     const task = requireTask(store, taskId);
     const actor = taskActor(store, options, task.id);
+    assertTaskDeliveryAuthority(store, options.environment, task.id);
     if (task.status === "completed") {
         return { task, actor, completed: true, activeTaskReview: false };
     }
@@ -279,19 +297,29 @@ function formatCompletionBlockers(taskId, blockers) {
 }
 export function runTaskCommand(args, store, options = {}) {
     const [command, ...rest] = args;
+    const delivery = command === "complete"
+        || (command === "work" && ["dispatch", "synthesize", "review", "accept"].includes(rest[0] ?? ""))
+        || (command === "review" && !["list", "show"].includes(rest[0] ?? ""))
+        || ((command === "run" || command === "run") && rest[0] === "retry");
+    if (delivery && options.environment?.YUI_SESSION_SCOPE === "task"
+        && options.environment.YUI_TASK_ID !== undefined) {
+        assertTaskDeliveryAuthority(store, options.environment, options.environment.YUI_TASK_ID);
+    }
     switch (command) {
         case "create": return createTaskCommand(rest, store, options);
         case "update": return output(updateTaskCommand(rest, store, options));
         case "list": return listTaskCommand(rest, store);
         case "show": return showTaskCommand(rest, store, options.actualTaskReviewCandidate ?? null);
-        case "context": return runTaskContextCommand(rest, store, options.actualTaskReviewCandidate ?? null);
+        case "context": return runTaskContextCommand(rest, store, options.environment);
         case "next-action": return runTaskNextActionCommand(rest, store, options.actualTaskReviewCandidate ?? null);
         case "remote-delivery": return runTaskRemoteDeliveryCommand(rest, store, options.actualTaskReviewCandidate ?? null);
         case "activate": return output(activateTaskCommand(rest, store, options));
+        case "activation": return runTaskActivationCommand(rest, store, options);
         case "complete": return completeTaskCommand(rest, store, options);
         case "reopen": return output(reopenTaskCommand(rest, store, options));
         case "archive": return output(archiveTaskCommand(rest, store, options));
         case "retire": return retireTaskCommand(rest, store, options);
+        case "cancel": return cancelTaskCommand(rest, store, options);
         case "reconcile": return output(reconcileTaskCommand(rest, store, options));
         case "message": {
             const execution = taskMessageCommand(rest, store, options);
@@ -306,7 +334,8 @@ export function runTaskCommand(args, store, options = {}) {
         case "role": return taskRoleCommand(rest, store, options);
         case "work": return taskWorkCommand(rest, store, options);
         case "review": return taskReviewCommand(rest, store, options);
-        case "turn": return taskTurnCommand(rest, store, options);
+        case "run":
+        case "run": return taskRunCommand(rest, store, options);
         case "brief": return taskBriefCommand(rest, store, options);
         case "decision": return taskDecisionCommand(rest, store, options);
         case "milestone": return taskMilestoneCommand(rest, store, options);
@@ -356,21 +385,21 @@ function workItemCandidateProducerRoles(store, item, candidate) {
         roles.add(LEADER_ROLE);
         return roles;
     }
-    const sourceTurn = store.getTurn(item.taskId, candidate.source.turnId);
-    if (sourceTurn === null
-        || sourceTurn.workItemId !== item.id
-        || sourceTurn.purpose !== "execution"
-        || sourceTurn.status !== "completed") {
-        throw dataError(`WorkItem Candidate producer Turn is unavailable: ${item.id}/${candidate.source.turnId}.`);
+    const sourceRun = store.getRun(item.taskId, candidate.source.runId);
+    if (sourceRun === null
+        || sourceRun.workItemId !== item.id
+        || sourceRun.purpose !== "execution"
+        || sourceRun.status !== "completed") {
+        throw dataError(`WorkItem Candidate producer AgentRun is unavailable: ${item.id}/${candidate.source.runId}.`);
     }
-    roles.add(sourceTurn.roleName);
-    if (sourceTurn.sourceExecutionGroupId !== undefined) {
-        const group = workItemExecutionGroupById(item, sourceTurn.sourceExecutionGroupId);
+    roles.add(sourceRun.roleName);
+    if (sourceRun.sourceExecutionGroupId !== undefined) {
+        const group = workItemExecutionGroupById(item, sourceRun.sourceExecutionGroupId);
         if (group === undefined) {
             throw dataError(`WorkItem Candidate ExecutionGroup is unavailable: `
-                + `${item.id}/${sourceTurn.sourceExecutionGroupId}.`);
+                + `${item.id}/${sourceRun.sourceExecutionGroupId}.`);
         }
-        for (const producer of successfulWorkItemSynthesisProducers(store, item, group)) {
+        for (const producer of selectedWorkItemSynthesisProducers(store, item, group, synthesisSourceRunIds(store, sourceRun))) {
             roles.add(producer.roleName);
         }
     }
@@ -506,6 +535,8 @@ export function updateTaskMetadataCommand(store, taskId, patch, options = {}) {
         tx.saveTask(updated);
         recordTaskEvent(tx, updated.id, "task.updated", {
             status: updated.status,
+            previous: editedFieldValues(current, Object.keys(patch)),
+            current: editedFieldValues(updated, Object.keys(patch)),
             ...(updated.type === undefined ? {} : { taskType: updated.type })
         }, now);
         enqueueWork(tx, taskMailbox(updated.id), "task-updated", now, [taskRef(updated.id)]);
@@ -514,26 +545,273 @@ export function updateTaskMetadataCommand(store, taskId, patch, options = {}) {
     notifyMailbox(options.runtime, taskMailbox(result.id), result.id);
     return result;
 }
-export function submitOperatorMessage(body, taskId, store, options = {}) {
+function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey, target) {
+    const kind = actor;
+    const author = actor === "operator"
+        ? { type: "operator" }
+        : { type: "user" };
+    // §2.3 keyed idempotency: a retry is detected by reading an existing keyed
+    // Message, and its original disposition is reproduced from the receipt that
+    // Message carries — never recomputed from current state. A matching key with
+    // matching input and target replays; any mismatch conflicts.
+    if (submissionKey !== undefined) {
+        const prior = tx.listMessages(task.id).find((message) => message.submissionKey === submissionKey);
+        if (prior !== undefined) {
+            return replayKeyedSubmission(task, prior, kind, body, intent, target);
+        }
+    }
+    // Save first, recording intent and key, so the "saved" facet holds regardless of
+    // how routing then resolves (§2.5). Intent is stored, never re-read from the body.
+    const message = appendMessage(tx, task.id, body, kind, author, now, {
+        intent,
+        ...(submissionKey === undefined ? {} : { submissionKey })
+    });
+    // Re-read phase and activation inside this same transaction: this is the point
+    // the race is decided at (§2.3).
+    const enteredPlanning = draftHasEnteredPlanning(tx, task);
+    const activation = draftActivationState(task.activationRequest);
+    const routing = decideSubmissionRouting({
+        intent,
+        status: task.status,
+        enteredPlanning,
+        activation,
+        executionEnabled: task.executionGate.state === "enabled",
+        // develop adopts no extra resource by guessing: the workspace is still built
+        // from the Task's own Project bindings when it activates (§2.3).
+        developEnvironmentPlan: { kind: "empty" }
+    });
+    let queuedForLeader = false;
+    let activationRef;
+    let activationFailure;
+    switch (routing.kind) {
+        case "record":
+        case "planned-needs-manual-activation":
+        case "activation-blocked-execution-stopped":
+            // Save only. No Leader wake, no planning, no activation.
+            break;
+        case "await-activation":
+            // The submission is a post-activation input or a report against an existing
+            // request; it acts on nothing itself but surfaces the exact reference.
+            activationRef = task.activationRequest === undefined
+                ? undefined
+                : taskActivationOperationRef(task.id, task.activationRequest.operation.requestId);
+            if (routing.state === "failed") {
+                activationFailure = task.activationRequest?.outcome;
+            }
+            break;
+        case "enter-planning":
+            // The one place the shared service itself writes the planning-entered fact,
+            // in the same transaction as the message (§2.2 derivation source (a)).
+            recordTaskEvent(tx, task.id, TASK_PLANNING_ENTERED_EVENT, {
+                messageId: message.id,
+                intent
+            }, now);
+            enqueueWork(tx, leaderMailbox(task.id), submissionEnqueueReason(actor), now, [messageRef(task.id, message.id)], { source: actor, dedupeKey: `message:${task.id}:${message.id}` });
+            queuedForLeader = true;
+            break;
+        case "continue-planning":
+        case "active-context":
+            enqueueWork(tx, leaderMailbox(task.id), submissionEnqueueReason(actor), now, [messageRef(task.id, message.id)], { source: actor, dedupeKey: `message:${task.id}:${message.id}` });
+            queuedForLeader = true;
+            break;
+        case "activate": {
+            // Record the activation in-transaction, then queue only activation
+            // processing. The requestId is derived from the message so a retried
+            // submission cannot mint a second request.
+            const identity = nonLeaderActivationIdentity(tx, actor);
+            recordTaskActivationRequestInTransaction(tx, {
+                taskId: task.id,
+                requestId: `submit-${message.id}`,
+                actorId: identity.actorId,
+                authorityRef: identity.authorityRef,
+                environmentPlan: routing.environmentPlan,
+                origin: "submit-develop"
+            }, now);
+            activationRef = taskActivationOperationRef(task.id, `submit-${message.id}`);
+            enqueueWork(tx, taskMailbox(task.id), "activation-requested", now, [taskRef(task.id)]);
+            break;
+        }
+        default: {
+            const exhaustive = routing;
+            throw new Error(`Unhandled submission routing: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+    const feedback = describeSubmissionFeedback({
+        taskId: task.id,
+        messageId: message.id,
+        status: task.status,
+        enteredPlanning,
+        activationState: activation,
+        routing,
+        ...(activationRef === undefined ? {} : { activationRef }),
+        ...(activationFailure === undefined ? {} : { activationFailure })
+    });
+    // §2.3 receipt: a keyed submission records the disposition it actually received
+    // (routing + feedback) and the target its key bound to, in this same
+    // transaction, so a later retry reproduces exactly this outcome rather than
+    // re-deriving one from a phase or activation that has since changed.
+    if (submissionKey !== undefined && target !== undefined) {
+        const receipted = withSubmissionReceipt(message, { target, routing, feedback });
+        tx.updateMessage(task.id, receipted);
+        return { task, message: receipted, routing, feedback, queuedForLeader };
+    }
+    return { task, message, routing, feedback, queuedForLeader };
+}
+/**
+ * Reproduce a keyed submission's original outcome from the receipt it recorded
+ * (task-32 §2.3), never by recomputing from the Task's current state. The prior
+ * Message's frozen {@link SubmissionReceipt} names the routing it received and the
+ * §2.5 feedback it returned, so a gate enabled or an activation cancelled after
+ * the fact can no longer fabricate a different disposition. The replay writes
+ * nothing — any Leader wake or activation request the original made already
+ * exists — and preserves the original Task/Message/routing/request references
+ * exactly.
+ *
+ * Same key with a different normalized input (kind, body or intent) or a
+ * different target is a conflict, never a silent overwrite or a cross-target
+ * replay. A prior keyed Message that carries no receipt (an old client, before
+ * receipts existed) also conflicts rather than being replayed from a rebuilt
+ * disposition.
+ */
+function replayKeyedSubmission(task, prior, kind, body, intent, target) {
+    const receipt = prior.submissionReceipt;
+    if (prior.kind !== kind
+        || prior.body !== body
+        || normalizeSubmissionIntent(prior.intent) !== intent
+        || receipt === undefined
+        || (target !== undefined && !sameSubmissionTarget(receipt.target, target))) {
+        throw new StorageConflictError(`Submission key ${prior.submissionKey} was already used for a different submission on ${task.id}/${prior.id}.`);
+    }
+    // Reproduce the recorded disposition verbatim; a retry acts on nothing itself.
+    return {
+        task,
+        message: prior,
+        routing: receipt.routing,
+        feedback: receipt.feedback,
+        queuedForLeader: false
+    };
+}
+/** The mailbox reason a submission wake carries, preserving the existing
+ *  operator-input / user-message vocabulary the Controller already understands. */
+function submissionEnqueueReason(actor) {
+    return actor === "operator" ? "operator-input" : "user-message";
+}
+/**
+ * Render the §2.5 feedback as CLI text, one facet per line, so the user always
+ * sees the save, the phase, planning, activation, delivery and next step as
+ * separate statements — never a single "started". Web and capability callers
+ * return {@link SubmissionFeedback} structurally instead of this text.
+ */
+function renderSubmissionFeedback(feedback) {
+    const lines = [
+        `Saved message ${feedback.saved.messageId} to ${feedback.saved.taskId}.`,
+        `Phase: ${SUBMISSION_PHASE_LABEL[feedback.phase]}.`
+    ];
+    if (feedback.planning !== "none") {
+        lines.push(`Planning: ${feedback.planning === "entered"
+            ? "started; the Leader is queued to plan"
+            : "continued; the Leader is queued"}.`);
+    }
+    if (feedback.activation !== "none") {
+        lines.push(`Activation: ${SUBMISSION_ACTIVATION_LABEL[feedback.activation]}.`);
+    }
+    if (feedback.delivery === "queued" && feedback.planning === "none") {
+        lines.push("Delivery: queued to the Leader.");
+    }
+    const nextStep = feedback.nextStep;
+    if (nextStep !== undefined)
+        lines.push(`Next: ${renderSubmissionNextStep(nextStep)}`);
+    return `${lines.join("\n")}\n`;
+}
+const SUBMISSION_PHASE_LABEL = {
+    active: "active",
+    "draft-planning": "Draft, in planning",
+    "draft-unplanned": "Draft, not yet in planning"
+};
+const SUBMISSION_ACTIVATION_LABEL = {
+    none: "none",
+    requested: "requested; activation is queued",
+    pending: "already pending; this input waits for it",
+    failed: "the previous request failed",
+    "manual-required": "already planned; activate explicitly to develop",
+    "execution-stopped": "not requested; execution is stopped"
+};
+function renderSubmissionNextStep(step) {
+    switch (step.kind) {
+        case "activate-manually":
+            return `activate it explicitly with "yui task activate ${step.taskId}".`;
+        case "start-execution":
+            return `start execution with "yui task execution start ${step.taskId}", then submit develop again.`;
+        case "await-pending-activation":
+            return `wait for the pending activation ${step.activationRef}.`;
+        case "resolve-failed-activation":
+            return `retry with a new activation request or cancel ${step.activationRef} (failure: ${step.failure}).`;
+        default: {
+            const exhaustive = step;
+            throw new Error(`Unhandled submission next step: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+/** Parse and validate the CLI `--intent` option. Absent leaves it undefined so
+ *  the shared service applies the discuss default (task-32 §2.5). */
+function parseSubmissionIntentOption(raw, usage) {
+    if (raw === undefined)
+        return undefined;
+    if (TASK_SUBMISSION_INTENTS.includes(raw)) {
+        return raw;
+    }
+    throw usageError(`--intent must be one of ${TASK_SUBMISSION_INTENTS.join(", ")}: ${raw}.`, usage);
+}
+export function submitOperatorMessage(body, taskId, store, options = {}, intent, submissionKey) {
     const now = clock(options);
+    const effectiveIntent = normalizeSubmissionIntent(intent);
     const result = store.transaction((tx) => {
         if (taskId !== undefined) {
+            // Addressed submit: the key is scoped to this Task and dedups within it, so
+            // no other Task is read (§2.3). Its target is this Task.
             const task = requireTask(tx, taskId);
             assertTaskOpen(task);
-            const message = appendMessage(tx, task.id, body, "operator", { type: "operator" }, now);
-            if (task.status === "active") {
-                enqueueWork(tx, leaderMailbox(task.id), "operator-input", now, [messageRef(task.id, message.id)]);
+            const routed = routeUserSubmission(tx, task, "operator", body, effectiveIntent, now, submissionKey, { kind: "task", taskId: task.id });
+            return { ...routed, created: false };
+        }
+        // Task-less submit: the key is scoped to "create a new Task". A retry must
+        // locate the Draft the original create produced — not any same-key Message on
+        // an addressed Task — and a key already bound to a specific Task cannot be
+        // reused to create (§2.3 "同 key 不同目标冲突").
+        if (submissionKey !== undefined) {
+            const lookup = findSubmissionKeyCreate(tx, submissionKey);
+            if (lookup.kind === "create") {
+                const task = requireTask(tx, lookup.taskId);
+                const routed = routeUserSubmission(tx, task, "operator", body, effectiveIntent, now, submissionKey, { kind: "create" });
+                return { ...routed, created: false };
+            }
+            if (lookup.kind === "other-target") {
+                throw new StorageConflictError(`Submission key ${submissionKey} is already bound to a specific Task; a task-less create cannot reuse it.`);
             }
-            return { task, message, created: false };
         }
-        const created = createTaskAggregate(tx, titleFrom(body), {}, now);
-        const message = appendMessage(tx, created.task.id, body, "operator", { type: "operator" }, now);
-        return { ...created, message, created: true };
+        const createdAgg = createTaskAggregate(tx, titleFrom(body), {}, now);
+        const routed = routeUserSubmission(tx, createdAgg.task, "operator", body, effectiveIntent, now, submissionKey, { kind: "create" });
+        return { ...routed, task: createdAgg.task, created: true };
     });
-    notifyMailbox(options.runtime, result.task.status === "active" ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
-    return result.created
-        ? `Created Draft task ${result.task.id}: ${result.task.title}\nSubmitted message ${result.message.id}\n`
-        : `Submitted message ${result.message.id} to ${result.task.id}\n`;
+    notifyMailbox(options.runtime, result.queuedForLeader ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
+    const header = result.created
+        ? `Created Draft task ${result.task.id}: ${result.task.title}\n`
+        : "";
+    return `${header}${renderSubmissionFeedback(result.feedback)}`;
+}
+function findSubmissionKeyCreate(store, submissionKey) {
+    let otherTarget = false;
+    for (const task of store.listTasks()) {
+        for (const message of store.listMessages(task.id)) {
+            if (message.submissionKey !== submissionKey)
+                continue;
+            if (message.submissionReceipt?.target.kind === "create") {
+                return { kind: "create", taskId: task.id };
+            }
+            otherTarget = true;
+        }
+    }
+    return otherTarget ? { kind: "other-target" } : { kind: "unused" };
 }
 function createTaskCommand(args, store, options) {
     const parsed = parseTaskCreation(args, store);
@@ -657,7 +935,7 @@ function showTaskCommand(args, store, currentTaskCandidate) {
         events: events.length,
         workItems: work.length,
         currentWorkItems: currentWorkItemCount,
-        turns: store.listTurns(task.id).length,
+        runs: store.listRuns(task.id).length,
         changeSets: changeSets.length,
         integrations: integrations.length,
         publications: publications.length,
@@ -698,7 +976,7 @@ function showTaskCommand(args, store, currentTaskCandidate) {
         `Events: ${counts.events}`,
         `Work items: ${counts.workItems}`,
         `Current work items: ${currentWorkItemCount}`,
-        `Turns: ${counts.turns}`,
+        `AgentRuns: ${counts.runs}`,
         `ChangeSets: ${counts.changeSets}`,
         `Integration Attempts: ${counts.integrations}`,
         `Publication references: ${counts.publications} (${verifiedMergedPublications} verified merged)`,
@@ -721,7 +999,7 @@ function activateTaskCommand(args, store, options) {
         const task = requireTask(tx, args[0]);
         if (task.status === "archived")
             throw usageError(`Task is archived: ${task.id}.`);
-        if (task.status === "retired")
+        if (task.status === "cancelled")
             throw usageError(`Task is retired: ${task.id}.`);
         if (task.status === "completed") {
             throw usageError(`Task ${task.id} is completed; use task reopen before activating it.`);
@@ -734,13 +1012,26 @@ function activateTaskCommand(args, store, options) {
                 || activation.task.id !== task.id
                 || activation.task.status !== "active"
                 || !isDeepStrictEqual(activation.task.workspaceIdentity, task.workspaceIdentity)
-                || activation.path !== task.cwd
-                || workspace === null
-                || workspace.owner.type !== "task"
-                || workspace.owner.taskId !== task.id
-                || workspace.root !== task.cwd) {
+                || activation.path !== task.cwd) {
                 throw usageError(`Task workspace activation proof does not match ${task.id}.`);
             }
+            // An empty environment plan over no bound Project is a legal Task shape,
+            // so the proof of adoption is the *absence* of a workspace rather than a
+            // ManagedWorkspace record. Demanding one here would have forced every
+            // such activation to create a worktree purely to satisfy this check.
+            if (taskOwnsManagedWorkspace(task)) {
+                if (workspace === null
+                    || workspace.owner.type !== "task"
+                    || workspace.owner.taskId !== task.id
+                    || workspace.root !== task.cwd) {
+                    throw usageError(`Task workspace activation proof does not match ${task.id}.`);
+                }
+            }
+            else if (workspace !== null
+                || task.workspaceIdentity !== undefined
+                || activation.path !== undefined) {
+                throw usageError(`Workspace-free Task activation proof claims a workspace: ${task.id}.`);
+            }
             return { task, changed: activation.changed };
         }
         throw usageError(`Task ${task.id} activation requires atomic workspace adoption through the CLI preflight.`);
@@ -790,7 +1081,7 @@ function completeTaskCommand(args, store, options) {
             };
         }
         // Completion is a Task decision only. The current Provider Turn remains
-        // responsible for closing its own Turn, and the reusable Session keeps
+        // responsible for closing its own AgentRun, and the reusable Session keeps
         // its independent lifecycle.
         // Issue 06: re-validate the full completion readiness inside the
         // transaction (the CAS fence) after final-review preparation.  This is the
@@ -803,7 +1094,21 @@ function completeTaskCommand(args, store, options) {
         if (!readiness.ready) {
             throw usageError(formatCompletionBlockers(task.id, readiness.blockers));
         }
-        const completed = completeTask(task, now, { by: actor, summary });
+        for (const ref of request.artifactRefs) {
+            if (isGitArtifactRefString(ref)) {
+                fixedArtifactRefs(task.id, [ref]);
+            }
+            else if (ref.startsWith("turn:")) {
+                const run = tx.getRun(task.id, ref.slice("turn:".length));
+                if (run === null || run.result === undefined) {
+                    throw usageError(`Task completion result ref is not readable: ${ref}.`);
+                }
+            }
+            else if (!/^https?:\/\/[^\s]+$/u.test(ref)) {
+                throw usageError("Completion --artifact-ref must be a commit-pinned git:<commit>:<relativePath> reference, turn:<local-turn-id>, or an explicit HTTP(S) reference URL.");
+            }
+        }
+        const completed = completeTask(task, now, { by: actor, summary, artifactRefs: request.artifactRefs });
         tx.saveTask(completed);
         tx.clearPendingWakeup(task.id);
         tx.clearLeaderFailure(task.id);
@@ -834,6 +1139,10 @@ function completeTaskCommand(args, store, options) {
         const terminalEvent = recordTaskEvent(tx, task.id, "task.completed", {
             by: actor,
             summary,
+            ...(completed.completionArtifactRefs === undefined ? {} : {
+                artifactRefs: JSON.stringify(completed.completionArtifactRefs)
+            }),
+            dispatchHistory: JSON.stringify(taskDispatchMailboxes(tx, task.id)),
             ...(completedProjectHeads === undefined
                 ? {}
                 : { projectHeads: completedProjectHeads }),
@@ -850,7 +1159,7 @@ function completeTaskCommand(args, store, options) {
         // discarded at this lifecycle boundary.
         tx.removeWorkMailbox(taskMailbox(task.id));
         // Role mailboxes are also derived wake state. A Worker result or runtime
-        // signal queued while the final Turn was being settled must not survive a
+        // signal queued while the final AgentRun was being settled must not survive a
         // completed Task and become actionable after a later explicit reopen.
         for (const role of roles) {
             tx.removeWorkMailbox(roleMailbox(task.id, role.name));
@@ -895,19 +1204,39 @@ function reopenTaskCommand(args, store, options) {
             return { task, changed: false };
         if (task.status === "archived")
             throw usageError(`Task is archived: ${task.id}.`);
-        if (task.status !== "completed")
-            throw usageError(`Task is not completed: ${task.id}.`);
+        if (task.status !== "completed" && task.status !== "cancelled") {
+            throw usageError(`Task is not completed or cancelled: ${task.id}.`);
+        }
+        const actor = taskActor(tx, options, task.id);
+        if (task.status === "cancelled" && actor === "leader") {
+            throw usageError("Restoring a cancelled Task requires user or Operator authority.");
+        }
+        const dispatchHistory = JSON.stringify(taskDispatchMailboxes(tx, task.id));
+        // Reopening changes Task intent, not the disposition of existing inputs.
+        // In particular, external messages and unknown deliveries remain owned by
+        // their existing mailbox fences.
         const active = reopenTask(task, now);
         tx.saveTask(active);
         const reopenedReason = wakeReason("task-reopened");
-        enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
+        if (actor !== "leader") {
+            enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
+        }
         enqueueWork(tx, taskMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
-        recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
-        return { task: active, changed: true };
+        recordTaskEvent(tx, task.id, "task.reopened", {
+            status: active.status, by: actor, historicalInputs: "preserved", dispatchHistory,
+            ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {}),
+            previous: editedFieldValues(task, [
+                "status", "completedAt", "completedBy", "completionSummary", "completionArtifactRefs",
+                "retiredAt", "retiredBy", "retirementSummary", "replacementTaskId", "retirementIsolation"
+            ])
+        }, now);
+        return { task: active, changed: true, wakeLeader: actor !== "leader" };
     });
     if (result.changed) {
         notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+        if (result.wakeLeader) {
+            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
+        }
     }
     return result.changed
         ? `Reopened task ${result.task.id}\n`
@@ -922,13 +1251,17 @@ function archiveTaskCommand(args, store, options) {
         if (task.status === "archived")
             return { task, changed: false };
         if (task.status !== "completed"
-            && task.status !== "retired") {
+            && task.status !== "cancelled") {
             throw usageError(`Task ${task.id} must be completed or retired before it can be archived.`);
         }
         const remoteDelivery = request.disposition === "integrated"
             ? assertTaskRemoteDeliveryProof(tx, task, options.archiveRemoteDeliveryProof, { forceUnverified: request.forceUnverified })
             : undefined;
         assertNoOpenInputRequests(tx, task.id, "archiving the Task");
+        const unsettledWork = tx.listWorkItems(task.id).find((item) => item.status === "open");
+        if (unsettledWork !== undefined) {
+            throw usageError(`Work Item ${unsettledWork.id} must be accepted or explicitly retired before archive.`);
+        }
         const unresolvedIntegration = tx.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
             || integration.status === "blocked"
             || integration.status === "validating"));
@@ -945,9 +1278,9 @@ function archiveTaskCommand(args, store, options) {
             throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
         }
         const activeRole = tx.listRoles(task.id)
-            .find((role) => tx.getActiveTurn(task.id, role.name) !== null);
+            .find((role) => tx.getActiveRun(task.id, role.name) !== null);
         if (activeRole !== undefined) {
-            throw usageError(`Task ${task.id} still has an active Turn for Role ${activeRole.name}; `
+            throw usageError(`Task ${task.id} still has an active AgentRun for Role ${activeRole.name}; `
                 + "stop its runtime before archiving.");
         }
         const liveSessionRole = tx.listRoles(task.id).find((role) => {
@@ -1003,6 +1336,41 @@ function archiveTaskCommand(args, store, options) {
         ? `Archived task ${result.task.id}\n`
         : `Task ${result.task.id} is already archived\n`;
 }
+function cancelTaskCommand(args, store, options) {
+    const usage = "Task cancel usage: yui task cancel <task> (--summary <text>|--summary-file <path|->).";
+    const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const summary = readCommandText(parsed.options.get("--summary"), parsed.options.get("--summary-file"), "--summary", usage);
+    const now = clock(options);
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, parsed.positionals[0]);
+        const actor = taskActor(tx, options, task.id);
+        const cancelled = retireTask(task, { by: actor, summary }, now);
+        if (cancelled === task)
+            return task;
+        const dispatchHistory = JSON.stringify(taskDispatchMailboxes(tx, task.id));
+        tx.saveTask(cancelled);
+        tx.clearPendingWakeup(task.id);
+        tx.clearLeaderFailure(task.id);
+        for (const mailbox of tx.listWorkMailboxes()) {
+            if ((mailbox.target.kind === "task" || mailbox.target.kind === "role")
+                && mailbox.target.taskId === task.id)
+                tx.removeWorkMailbox(mailbox.target);
+        }
+        const event = recordTaskEvent(tx, task.id, "task.cancelled", { by: actor, summary, dispatchHistory }, now);
+        enqueueOperatorEvent(tx, event, "task-terminal", now);
+        // Cancellation is intent, not fabricated proof that old processes stopped.
+        // AgentRuns, inputs, WorkItems and their results remain independently readable.
+        return cancelled;
+    });
+    options.runtime?.notifyStateChanged(result.id);
+    notifyMailbox(options.runtime, { kind: "operator" }, result.id);
+    return output(`Cancelled task ${result.id}\n`, { task: result });
+}
+/** Historical evidence only; these snapshots are never dispatch input. */
+function taskDispatchMailboxes(store, taskId) {
+    return store.listWorkMailboxes().filter(({ target }) => (target.kind === "task" || target.kind === "role") && target.taskId === taskId);
+}
 function retireTaskCommand(args, store, options) {
     const usage = "Task retire usage: yui task retire <task> (--summary <text>|--summary-file <path|->) [--replacement <task>].";
     const parsed = parseTail(args, new Set(["--summary", "--summary-file", "--replacement"]), usage);
@@ -1014,7 +1382,7 @@ function retireTaskCommand(args, store, options) {
     const result = store.transaction((tx) => {
         const task = requireTask(tx, taskId);
         const actor = taskActor(tx, options, task.id);
-        if (task.status === "retired") {
+        if (task.status === "cancelled") {
             const same = task.retirementSummary === summary
                 && task.replacementTaskId === replacementTaskId;
             if (!same)
@@ -1043,12 +1411,12 @@ function retireTaskCommand(args, store, options) {
             throw usageError(`Task ${task.id} has an active DurableJob: ${activeRetireJob.id}/${activeRetireJob.status}.`);
         }
         assertTaskRetirementProof(tx, task, options.taskRetirementProof);
-        for (const run of tx.listTurns(task.id).filter(({ status: runStatus }) => (runStatus === "active"))) {
-            const terminal = terminalizeExactTaskTurn(tx, {
+        for (const run of tx.listRuns(task.id).filter(({ status: runStatus }) => (runStatus === "active"))) {
+            const terminal = terminalizeExactTaskRun(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
                 agentId: run.effective.agentId,
-                turnId: run.id,
+                runId: run.id,
                 mailboxDisposition: "discard",
                 outcome: {
                     status: "failed",
@@ -1057,11 +1425,11 @@ function retireTaskCommand(args, store, options) {
                 }
             }, now);
             if (terminal.disposition !== "applied") {
-                throw usageError(`Task Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                throw usageError(`Task AgentRun changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
         }
         for (const item of tx.listWorkItems(task.id)) {
-            if (item.status === "completed" || item.status === "retired")
+            if (item.status === "accepted" || item.status === "retired")
                 continue;
             tx.saveWorkItem(task.id, updateWorkItemStatus(item, "retired", now, `Task retired: ${summary}`));
         }
@@ -1082,12 +1450,14 @@ function retireTaskCommand(args, store, options) {
         const retired = retireTask(task, {
             by: actor,
             summary,
+            isolated: true,
             ...(replacementTaskId === undefined ? {} : { replacementTaskId })
         }, now);
         tx.saveTask(retired);
         const terminalEvent = recordTaskEvent(tx, task.id, "task.retired", {
             by: actor,
             summary,
+            isolationEstablished: "true",
             ...(replacementTaskId === undefined ? {} : { replacementTaskId })
         }, now);
         enqueueOperatorEvent(tx, terminalEvent, "task-terminal", now);
@@ -1153,10 +1523,13 @@ function formatProjectCommits(projects) {
 export function validateTaskArchiveRequest(args, store, options = {}) {
     const request = parseTaskArchiveArguments(args);
     const task = requireTask(store, request.taskId);
-    taskActor(store, options, task.id);
+    const archiveActor = taskActor(store, options, task.id);
+    if (archiveActor === "leader") {
+        throw usageError("Task archive requires independent user or Operator authorization.");
+    }
     if (task.status !== "archived"
         && task.status !== "completed"
-        && task.status !== "retired") {
+        && task.status !== "cancelled") {
         throw usageError(`Task ${task.id} must be completed or retired before it can be archived.`);
     }
     if (task.status !== "archived") {
@@ -1179,9 +1552,55 @@ function reconcileTaskCommand(args, store, options) {
 }
 function taskMessageCommand(args, store, options) {
     const [command, ...rest] = args;
+    if (command === "handoff") {
+        const usage = "Task message handoff usage: yui task message handoff <task/message> --to <role>.";
+        const parsed = parseTail(rest, new Set(["--to"]), usage);
+        exactPositionals(parsed.positionals, 1, usage);
+        const ref = taskRecordReference(parsed.positionals[0], "message", "Message reference", options);
+        const now = clock(options);
+        const message = store.transaction((tx) => {
+            assertTaskDeliveryAuthority(tx, options.environment, ref.taskId);
+            const current = tx.listMessages(ref.taskId).find((entry) => entry.id === ref.localId);
+            if (current?.recipient?.ownerRunId === undefined || current.continuation?.runId !== undefined) {
+                throw usageError("Only an unassigned pending Message can be explicitly handed off.");
+            }
+            const recipient = resolveMessageRecipient(tx, ref.taskId, requiredOption(parsed.options, "--to"), {
+                ...(current.recipient.workItemId === undefined ? {} : { workItemId: current.recipient.workItemId }),
+                ...(current.recipient.reviewRoundId === undefined ? {} : { reviewRoundId: current.recipient.reviewRoundId })
+            });
+            const updated = { ...current, recipient, continuation: {},
+                handovers: [...(current.handovers ?? []), { from: current.recipient, at: now.toISOString() }] };
+            const blocker = messageContinuationBlocker(tx, updated);
+            if (blocker !== undefined)
+                throw usageError(`Message handoff cannot proceed: ${blocker}.`);
+            tx.updateMessage(ref.taskId, updated);
+            recordTaskEvent(tx, ref.taskId, "message.handed-off", {
+                messageId: current.id, fromRole: current.recipient.roleName, toRole: recipient.roleName,
+                ownerRunId: recipient.ownerRunId
+            }, now);
+            enqueueWork(tx, taskMailbox(ref.taskId), "message-continuation", now, [messageRef(ref.taskId, current.id)]);
+            return updated;
+        });
+        notifyMailbox(options.runtime, taskMailbox(ref.taskId), ref.taskId);
+        return output(`Handed off Message ${ref.localId} to ${message.recipient.roleName}.\n`, message);
+    }
+    if (command === "show") {
+        const usage = "Task message show usage: yui task message show <task/message>.";
+        exactPositionals(rest, 1, usage);
+        const ref = taskRecordReference(rest[0], "message", "Message reference", options);
+        const message = listContextMessages(store, ref.taskId, options.environment)
+            .find((entry) => entry.id === ref.localId);
+        if (message === undefined)
+            throw dataError("Message is unavailable in the caller's scope.");
+        const continuationRun = message.continuation?.runId === undefined
+            ? null : store.getRun(ref.taskId, message.continuation.runId);
+        const expanded = { ...expandTaskMessageResult(message, (task, run) => store.getRun(task, run)),
+            ...(continuationRun === null ? {} : { execution: runExecutionObservation(continuationRun, store.getTaskRoleSessionSet(ref.taskId, continuationRun.roleName)?.providerBinding, store.listEvents(ref.taskId)) }) };
+        return { kind: "output", output: `${JSON.stringify(expanded, null, 2)}\n`, data: expanded };
+    }
     if (command === "send") {
-        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--wake-policy leader|none].";
-        const parsed = parseTail(rest, new Set(["--body-file", "--wake-policy"]), usage);
+        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--intent record|discuss|develop] [--request-id <key>] [--wake-policy leader|none] [--to <role> --work-item <id>|--review-round <id>].";
+        const parsed = parseTail(rest, new Set(["--body-file", "--intent", "--request-id", "--wake-policy", "--to", "--work-item", "--review-round"]), usage);
         if (parsed.positionals.length < 1 || parsed.positionals.length > 2)
             throw usageError(usage);
         const body = readCommandText(parsed.positionals[1], parsed.options.get("--body-file"), "--body", usage);
@@ -1196,42 +1615,34 @@ function taskMessageCommand(args, store, options) {
         else {
             throw usageError(`--wake-policy must be 'leader' or 'none': ${wakePolicyRaw}.`);
         }
-        const now = clock(options);
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
-            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"
-                    ? appendMessage(tx, task.id, body, "operator", { type: "operator" }, now, { wakePolicy })
-                    : appendMessage(tx, task.id, body, "user", { type: "user" }, now, { wakePolicy });
-            // Issue 05: only `wakePolicy=leader` (the default for backward
-            // compatibility) enqueues Leader work. `wakePolicy=none` persists the
-            // message as context without waking the Leader.
-            if (task.status === "active"
-                && actor !== "leader"
-                && wakePolicy !== "none") {
-                enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [messageRef(task.id, message.id)], {
-                    source: actor,
-                    dedupeKey: `message:${task.id}:${message.id}`
-                });
-            }
-            return { task, message, actor };
-        });
-        if (result.actor !== "leader") {
-            notifyMailbox(options.runtime, result.task.status === "active"
-                ? leaderMailbox(result.task.id)
-                : taskMailbox(result.task.id), result.task.id);
-        }
-        return `Sent message ${result.message.id} to ${result.task.id}\n`;
+        const intent = parseSubmissionIntentOption(parsed.options.get("--intent"), usage);
+        const submissionKey = parsed.options.get("--request-id");
+        if (submissionKey !== undefined && submissionKey.trim().length === 0) {
+            throw usageError("--request-id is required.", usage);
+        }
+        const recipientRole = parsed.options.get("--to");
+        const workItemId = parsed.options.get("--work-item");
+        const reviewRoundId = parsed.options.get("--review-round");
+        if (recipientRole === undefined && (workItemId !== undefined || reviewRoundId !== undefined))
+            throw usageError("--to is required for scoped Message delivery.");
+        const result = sendTaskMessageCommand(store, parsed.positionals[0], body, wakePolicy, options, recipientRole === undefined ? undefined : { roleName: recipientRole, workItemId, reviewRoundId }, intent, submissionKey);
+        // A user/operator submission returns the unified §2.5 feedback; render each
+        // facet on its own line and expose the structure to non-text callers.
+        if (result.feedback !== undefined) {
+            return output(renderSubmissionFeedback(result.feedback), { taskId: result.task.id, message: result.message, submission: result.feedback });
+        }
+        const reason = result.message.continuation?.notDeliveredReason;
+        const delivery = reason !== undefined ? { state: "not-delivered", reason }
+            : recipientRole !== undefined || result.queuedForLeader
+                ? { state: "queued" } : { state: "saved" };
+        return output(`Saved message ${result.message.id} to ${result.task.id} (${delivery.state}${reason === undefined ? "" : `: ${reason}`}).\n`, { taskId: result.task.id, message: result.message, delivery });
     }
     if (command === "list") {
         const messageListUsage = "Task message list usage: yui task message list <id> [--after <timestamp>] [--limit <n>].";
         const parsed = parseTail(rest, new Set(["--after", "--limit"]), messageListUsage);
         exactPositionals(parsed.positionals, 1, messageListUsage);
         const task = requireTask(store, parsed.positionals[0]);
-        let messages = store.listMessages(task.id);
+        let messages = listContextMessages(store, task.id, options.environment);
         const after = optionalNonEmptyOption(parsed.options, "--after");
         if (after !== undefined) {
             const afterMs = Date.parse(after);
@@ -1279,6 +1690,127 @@ function taskMessageCommand(args, store, options) {
         ? "Task message command is required."
         : `Unknown command: task message ${command}`);
 }
+/** CLI and authenticated user Surface share the same message and mailbox
+ * transaction. Talking to Leader does not impersonate Leader authority. */
+/**
+ * The one transaction that turns an inbound Task Message into durable facts and,
+ * when the Task's own lifecycle calls for it, Leader work.
+ *
+ * CLI `task message send` and the Web Task surface both call this, so neither
+ * owns a private notion of what "sending a message" means. The Draft case is the
+ * reason that matters here: a Draft's Leader conversation is its planning Turn,
+ * so a Draft must wake its Leader exactly like an active Task does. Gating the
+ * wake on `active` would leave the Draft entry point saving text that no Leader
+ * ever reads — the message would be persisted and silently go nowhere, which is
+ * indistinguishable to the user from a Provider that never answered.
+ *
+ * The wake carries intent only. Whether the resulting Turn is planning or
+ * execution is decided by the Controller from the Task's own status, so this
+ * function never names a purpose and no second planning path exists.
+ */
+export function sendTaskMessageCommand(store, taskId, body, wakePolicy, options = {}, recipient, intent, submissionKey) {
+    if (!body.trim())
+        throw usageError("Message body is required.");
+    if (recipient !== undefined && wakePolicy !== undefined) {
+        throw usageError("--wake-policy applies only to unaddressed Leader Messages; an owner-directed Message uses its exact continuation boundary.");
+    }
+    if (recipient !== undefined && intent !== undefined) {
+        throw usageError("A submission intent applies only to unaddressed Leader Messages; an owner-directed Message uses its exact continuation boundary.");
+    }
+    if (recipient !== undefined && submissionKey !== undefined) {
+        throw usageError("A submission key applies only to unaddressed Leader Messages; an owner-directed Message uses its exact continuation boundary.");
+    }
+    const now = clock(options);
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, taskId);
+        if (recipient === undefined)
+            assertTaskOpen(task);
+        const caller = currentManagedRuntime(tx, options.environment, task.id);
+        const roleCaller = caller !== undefined && caller.roleName !== "leader" ? caller : undefined;
+        if (roleCaller !== undefined) {
+            const run = roleCaller.currentRunId === undefined ? null : tx.getRun(task.id, roleCaller.currentRunId);
+            if (run === null || recipient?.roleName !== "leader"
+                || recipient.workItemId !== run.workItemId || recipient.reviewRoundId !== run.reviewRoundId) {
+                throw usageError("A Worker or Reviewer may send only to Leader within its current Assignment.");
+            }
+        }
+        const actor = roleCaller === undefined ? taskActor(tx, options, task.id) : "role";
+        // A user/operator Message with no explicit recipient is the single path that
+        // carries submission intent (record | discuss | develop). It routes through
+        // the one shared submission service so intent means exactly the same thing
+        // here as on every other surface. Internal role/leader result messages and
+        // owner-directed continuations keep their exact existing boundary and never
+        // gain develop authority (task-32 §2.5).
+        if (recipient === undefined && (actor === "user" || actor === "operator")) {
+            const effectiveIntent = normalizeSubmissionIntent(intent, wakePolicy);
+            const routed = routeUserSubmission(tx, task, actor, body, effectiveIntent, now, submissionKey, { kind: "task", taskId: task.id });
+            return {
+                task: routed.task, message: routed.message, actor,
+                queuedForLeader: routed.queuedForLeader, feedback: routed.feedback
+            };
+        }
+        if (intent !== undefined) {
+            throw usageError("Submission intent applies only to an unaddressed user or Operator Message.");
+        }
+        if (recipient !== undefined && actor === "leader")
+            assertTaskDeliveryAuthority(tx, options.environment, task.id);
+        const target = recipient === undefined ? undefined
+            : recipient.roleName === "leader" && roleCaller !== undefined ? {
+                roleName: "leader", ...(recipient.workItemId === undefined ? {} : { workItemId: recipient.workItemId }),
+                ...(recipient.reviewRoundId === undefined ? {} : { reviewRoundId: recipient.reviewRoundId })
+            } : resolveMessageRecipient(tx, task.id, recipient.roleName, {
+                ...(recipient.workItemId === undefined ? {} : { workItemId: recipient.workItemId }),
+                ...(recipient.reviewRoundId === undefined ? {} : { reviewRoundId: recipient.reviewRoundId })
+            });
+        const context = {
+            ...(target === undefined ? {} : { recipient: target }),
+            ...(recipient?.workItemId === undefined ? {} : { workItemId: recipient.workItemId })
+        };
+        const message = actor === "leader"
+            ? appendMessage(tx, task.id, body, "role-result", { type: "role", roleName: LEADER_ROLE }, now, context)
+            : actor === "role"
+                ? appendMessage(tx, task.id, body, "role-result", { type: "role", roleName: roleCaller.roleName }, now, context)
+                : actor === "operator"
+                    ? appendMessage(tx, task.id, body, "operator", { type: "operator" }, now, context)
+                    : appendMessage(tx, task.id, body, "user", { type: "user" }, now, context);
+        // Reached only by addressed Messages and by an unaddressed Leader result now:
+        // unaddressed user/operator submissions are handled above by the shared
+        // service. A Worker/Reviewer message addressed to its Leader still wakes the
+        // Leader exactly as before; an owner-directed continuation posts to the Task
+        // mailbox for its exact owner Run.
+        const queuedForLeader = target?.ownerRunId === undefined
+            && leaderWakingTaskStatus(task.status) && actor !== "leader";
+        if (target?.ownerRunId !== undefined) {
+            const reason = messageContinuationBlocker(tx, message);
+            if (reason !== undefined) {
+                message.continuation = { notDeliveredReason: reason };
+                tx.updateMessage(task.id, message);
+            }
+            enqueueWork(tx, taskMailbox(task.id), "message-continuation", now, [messageRef(task.id, message.id)], { dedupeKey: `message:${task.id}:${message.id}` });
+        }
+        else if (queuedForLeader) {
+            enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [messageRef(task.id, message.id)], { source: actor, dedupeKey: `message:${task.id}:${message.id}` });
+        }
+        return { task, message, actor, queuedForLeader, feedback: undefined };
+    });
+    if (recipient !== undefined) {
+        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
+    }
+    else if (result.actor !== "leader") {
+        notifyMailbox(options.runtime, result.queuedForLeader
+            ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
+    }
+    return result;
+}
+/**
+ * Whether an inbound Message on a Task in this status is delivered to its
+ * Leader. Draft qualifies because planning is a Leader conversation that
+ * deliberately precedes any delivery environment or Activation (S01); a
+ * terminal Task has no Leader lane and keeps the message as context only.
+ */
+export function leaderWakingTaskStatus(status) {
+    return status === "active" || status === "draft";
+}
 function updateMessage(args, store, options) {
     const usage = "Task message update usage: yui task message update <task>/<message> (<body>|--body-file <path|->) [--wake-policy leader|none].";
     const parsed = parseTail(args, new Set(["--body-file", "--wake-policy"]), usage);
@@ -1322,9 +1854,14 @@ function updateMessage(args, store, options) {
             updatedBy: actor,
             ...(wakePolicy === undefined ? {} : { wakePolicy })
         }, now);
-        return { task, message: updated };
+        const queuedForLeader = updated.wakePolicy !== "none";
+        if (queuedForLeader) {
+            enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [messageRef(task.id, updated.id)], { source: actor });
+        }
+        return { task, message: updated, queuedForLeader };
     });
-    options.runtime?.notifyStateChanged(result.task.id);
+    notifyMailbox(options.runtime, result.queuedForLeader
+        ? leaderMailbox(result.task.id) : taskMailbox(result.task.id), result.task.id);
     return output(`Updated Task Message ${result.task.id}/${result.message.id}\n`, {
         message: result.message
     });
@@ -1353,7 +1890,7 @@ function retireMessage(args, store, options) {
         // Remove an isolated pending wake for this exact directive. A merged batch
         // is retained because its other signals remain actionable; context and
         // actionability projections still filter the retired message below.
-        if (task.status === "active") {
+        if (leaderWakingTaskStatus(task.status)) {
             try {
                 settleExactWorkExecution(tx, leaderMailbox(task.id), messageRef(task.id, message.id));
             }
@@ -1408,9 +1945,9 @@ function taskRoleCommand(args, store, options) {
     if (command === "status")
         return taskRoleStatus(rest, store, options);
     if (command === "show")
-        return output(showTaskRole(rest, store));
+        return showTaskRole(rest, store);
     if (command === "update")
-        return output(updateTaskRole(rest, store, options));
+        return updateTaskRole(rest, store, options);
     if (command === "remove")
         return output(removeTaskRole(rest, store, options));
     if (command === "bind")
@@ -1435,20 +1972,76 @@ function taskRoleSessionCommand(args, store, options) {
         exactPositionals(rest, 2, "Task Role Session inspect usage: yui task role session inspect <task> <role>.");
         const task = requireTask(store, rest[0]);
         const role = requireRole(store, task.id, rest[1]);
-        taskActor(store, options, task.id);
+        const reader = resolveManagedTaskReader(store, options.environment);
+        if (reader === undefined)
+            taskActor(store, options, task.id);
+        else if (reader.taskId !== task.id || (reader.roleName !== "leader" && reader.roleName !== role.name)) {
+            throw usageError("Session inspection is outside the caller's Task/Role.");
+        }
         const sessions = store.getTaskRoleSessionSet(task.id, role.name);
         const active = sessions?.sessions[sessions.activeAgentId] ?? null;
         const binding = sessions?.providerBinding ?? null;
+        // The live reading, when the CLI took one. Rendered under the persisted
+        // facts rather than merged into them: the Session's own record is what Yui
+        // launched, and this is what the Agent says about it now. An empty render
+        // means there was nothing an Agent reported, and the one-line label above
+        // still states which of the "no value" cases applies.
+        const runConfiguration = active === null ? undefined : options.liveRunConfiguration;
+        const runConfigurationDetail = renderAgentRunConfiguration(runConfiguration);
         return output(active === null
-            ? `No Session exists for ${task.id}/${role.name}.\n`
+            ? `No attached Session exists for ${task.id}/${role.name}.\n`
+                + (binding === null ? "" : `Retained native execution: ${currentProviderConversation(binding).conversationId}; input=${binding.run?.status ?? "none"}. Use session new to replace from durable context.\n`)
             : [
                 `Session ${task.id}/${role.name}`,
-                `Agent: ${active.agentId}/${active.adapterId}`,
+                // The component, not just the connection plan: several products are
+                // reached over `acp`, and the plan alone cannot say which one ran.
+                `Agent: ${active.agentId}/${agentExecutionComponentLabel(active.effective.component)}`
+                    + ` (${active.adapterId} plan)`,
                 `Native id: ${active.nativeSessionId}`,
-                `Host activation: ${active.runtimeGenerationId ?? "none"}`,
                 `Session: ${active.status}${active.endReason === undefined ? "" : `/${active.endReason}`}`,
-                `Turn: ${binding?.turn?.status ?? "none"}`
-            ].join("\n") + "\n", { task, role, session: active, providerBinding: binding });
+                `AgentRun: ${binding?.run?.status ?? "none"}`,
+                `Run configuration: ${agentRunConfigurationLabel(runConfiguration)}`
+            ].join("\n") + "\n"
+                + `\n${renderRoleLaunchComparison(role, active.effective)}\n`
+                + (runConfigurationDetail === "" ? "" : `\n${runConfigurationDetail}\n`), {
+            task,
+            role,
+            session: active,
+            providerBinding: binding,
+            ...(runConfiguration === undefined ? {} : { runConfiguration })
+        });
+    }
+    if (command === "new") {
+        const usage = "Task Role Session new usage: yui task role session new <task> <role> --reason <text>.";
+        const parsed = parseTail(rest, new Set(["--reason"]), usage);
+        exactPositionals(parsed.positionals, 2, usage);
+        const reason = requiredOption(parsed.options, "--reason");
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            if (task.status === "archived")
+                throw usageError("An archived Task cannot select a new Session.", usage);
+            const actor = taskActor(tx, options, task.id);
+            const role = requireRole(tx, task.id, parsed.positionals[1]);
+            const current = tx.getTaskRoleSessionSet(task.id, role.name);
+            const previous = current?.sessions[current.activeAgentId];
+            const target = runtimeLifecycleTarget({ scope: "task", taskId: task.id, roleName: role.name });
+            const mailbox = tx.getWorkMailbox(target);
+            if ([...(mailbox?.pending?.reasons ?? []), ...(mailbox?.processing?.batch.reasons ?? [])]
+                .includes(RUNTIME_SESSION_REPLACE_REQUIRED_REASON))
+                return { taskId: task.id, roleName: role.name, target, alreadyRequested: true };
+            recordTaskEvent(tx, task.id, "runtime.session-replacement-requested", {
+                roleName: role.name, agentId: current?.activeAgentId ?? role.activeAgentId,
+                ...(previous === undefined ? {} : { nativeSessionId: previous.nativeSessionId }),
+                reason, requestedBy: actor
+            }, now);
+            enqueueWork(tx, target, RUNTIME_SESSION_REPLACE_REQUIRED_REASON, now, [{ type: "task", id: task.id }]);
+            return { taskId: task.id, roleName: role.name, target, alreadyRequested: false };
+        });
+        notifyMailbox(options.runtime, result.target, result.taskId);
+        return output(`Requested Session replacement for ${result.taskId}/${result.roleName}. `
+            + "Yui will stop the old execution, retain its history and workspaces, and select a fresh Session. "
+            + "If replacing your own Session, end this turn; the successor reads durable Task context.\n", result);
     }
     if (command === "stop") {
         const usage = "Task Role Session stop usage: yui task role session stop <task> <role> --reason <text>.";
@@ -1458,36 +2051,26 @@ function taskRoleSessionCommand(args, store, options) {
         const now = clock(options);
         const request = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
-            if (task.status !== "active" && task.status !== "completed") {
-                throw usageError(`Task Role Session stop requires an active or completed Task: ${task.id}.`, usage);
+            if (!["draft", "active", "completed", "cancelled"].includes(task.status)) {
+                throw usageError(`Task Role Session stop is unavailable for an archived Task: ${task.id}.`, usage);
             }
             const actor = taskActor(tx, options, task.id);
             const role = requireRole(tx, task.id, parsed.positionals[1]);
             if (actor === "leader" && role.name === LEADER_ROLE) {
-                throw usageError("A Leader cannot stop the Session executing its own current command.", usage);
-            }
-            if (tx.getActiveTurn(task.id, role.name) !== null) {
-                throw usageError(`Task Role has an active Turn; settle or retire it before stopping the Session: ${task.id}/${role.name}.`, usage);
+                throw usageError("Use task role session new to request your own replacement and end this turn; synchronous self-stop cannot return.", usage);
             }
             const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
-            const session = sessions?.sessions[sessions.activeAgentId];
-            if (session === undefined || session.status === "ended") {
+            const session = taskRoleControlTarget(sessions);
+            if (session === undefined || session.adapterId === undefined) {
                 throw usageError(`Task Role has no active Session: ${task.id}/${role.name}.`, usage);
             }
-            const lifecycle = tx.getWorkMailbox(runtimeLifecycleTarget({
-                scope: "task",
-                taskId: task.id,
-                roleName: role.name
-            }));
-            if (lifecycle !== null && workMailboxHasWork(lifecycle)) {
-                throw usageError(`Task Role Session lifecycle is busy: ${task.id}/${role.name}.`, usage);
-            }
+            // A repeated stop is a recovery request, not contention with its own
+            // earlier cleanup obligation.
             recordTaskEvent(tx, task.id, "runtime.session-stop-requested", {
                 roleName: role.name,
                 agentId: session.agentId,
                 adapterId: session.adapterId,
                 nativeSessionId: session.nativeSessionId,
-                runtimeGenerationId: session.runtimeGenerationId ?? "",
                 reason,
                 requestedBy: actor
             }, now);
@@ -1497,7 +2080,6 @@ function taskRoleSessionCommand(args, store, options) {
                 agentId: session.agentId,
                 adapterId: session.adapterId,
                 nativeSessionId: session.nativeSessionId,
-                ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 sessionUpdatedAt: session.updatedAt
             };
         });
@@ -1615,7 +2197,7 @@ function listTaskRoles(args, store, options) {
         status.health,
         taskRoleOpenInputLabel(status),
         taskRoleActiveWorkLabel(status),
-        taskRoleLastTurnLabel(status),
+        taskRoleLastRunLabel(status),
         taskRoleNativeSessionLabel(status),
         taskRoleTmuxLabel(status)
     ]), defaultTableWidth())}\n`, { roles: statuses });
@@ -1633,9 +2215,15 @@ function showTaskRole(args, store) {
     exactPositionals(args, 2, "Task role show usage: yui task role show <task> <role>.");
     const task = requireTask(store, args[0]);
     const role = requireRole(store, task.id, args[1]);
-    return renderRoleDetails(`Task Role: ${role.name}`, role, {
+    const sessions = store.getTaskRoleSessionSet(task.id, role.name);
+    return output(renderRoleDetails(`Task Role: ${role.name}`, role, {
         kind: "task",
-        sessions: store.getTaskRoleSessionSet(task.id, role.name)
+        sessions
+    }), {
+        role,
+        sessions,
+        runs: store.listRuns(task.id).filter((run) => run.roleName === role.name)
+            .map((run) => ({ id: run.id, status: run.status, effective: run.effective }))
     });
 }
 function updateTaskRole(args, store, options) {
@@ -1646,8 +2234,11 @@ function updateTaskRole(args, store, options) {
     }
     const parsed = parseRoleOptions(tail, new Map([
         ...roleOptionSpecs({ update: true, includeAgent: true }),
-        ["--profile", "value"]
+        ["--profile", "value"],
+        ["--environment", "value"],
+        ["--managed-environment", "flag"]
     ]), usage);
+    validateTaskRoleEnvironmentOptions(parsed, usage);
     if (parsed.has("--agent") && (parsed.one("--agent")?.trim().length ?? 0) === 0) {
         throw usageError("--agent is required.", usage);
     }
@@ -1660,7 +2251,9 @@ function updateTaskRole(args, store, options) {
         assertTaskOpen(task);
         taskActor(tx, options, task.id);
         const role = requireRole(tx, task.id, roleName);
-        const changesLaunchContext = hasRoleLaunchContextOptions(parsed) || parsed.has("--profile");
+        const changesEnvironment = parsed.has("--environment") || parsed.has("--managed-environment");
+        const changesLaunchContext = hasRoleLaunchContextOptions(parsed) || parsed.has("--profile")
+            || changesEnvironment;
         const changesAgentConfig = hasAgentConfigOptions(parsed);
         if (changesLaunchContext || changesAgentConfig) {
             assertRoleRuntimeMutationAllowed(tx, {
@@ -1668,13 +2261,6 @@ function updateTaskRole(args, store, options) {
                 taskId: task.id,
                 roleName: role.name
             }, "desired launch configuration update");
-            assertLiveRoleSessionAcknowledged({
-                sessions: tx.getTaskRoleSessionSet(task.id, role.name),
-                roleName: role.name,
-                desiredRevision: role.launchRevision,
-                acknowledged: parsed.has(LIVE_SESSION_ACKNOWLEDGEMENT_OPTION),
-                stopCommand: `yui task role session stop ${task.id} ${role.name} --reason "<decision>"`
-            });
         }
         const profileId = parsed.one("--profile");
         const agentProfile = profileId === undefined
@@ -1692,7 +2278,7 @@ function updateTaskRole(args, store, options) {
                     [bindingUpdate.agentId]: bindingUpdate.binding
                 }
             }, now);
-        const next = updateRole(withBinding, {
+        let next = updateRole(withBinding, {
             ...roleProfilePatch(parsed)
         }, now);
         if (bindingUpdate !== undefined) {
@@ -1701,16 +2287,32 @@ function updateTaskRole(args, store, options) {
         if (changesLaunchContext) {
             validateConfiguredRoleSkills(options.yuiHome, next.skills ?? []);
         }
-        tx.saveRole(task.id, next);
-        enqueueWork(tx, taskMailbox(task.id), "role-updated", now, [taskRef(task.id)]);
-        recordTaskEvent(tx, task.id, "role.updated", roleLaunchEventPayload(next, tx.getTaskRoleSessionSet(task.id, next.name)), now);
+        if (changesEnvironment) {
+            next = updateRole(next, {
+                executionEnvironment: parsed.has("--managed-environment")
+                    ? null
+                    : createProjectResources(tx, () => now).resolveExecutionEnvironment(task.id, parsed.one("--environment"))
+            }, now);
+        }
+        saveTaskRoleUpdate(tx, role, next, now, {
+            source: "task.role.update", actor: taskActor(tx, options, task.id)
+        });
         return next;
     });
     notifyMailbox(options.runtime, taskMailbox(updated.taskId), updated.taskId);
-    return renderRoleDetails(`Updated Task Role: ${updated.name}`, updated, {
+    const sessions = store.getTaskRoleSessionSet(updated.taskId, updated.name);
+    return output(renderRoleDetails(`Updated Task Role: ${updated.name}`, updated, {
         kind: "task",
-        sessions: store.getTaskRoleSessionSet(updated.taskId, updated.name)
-    });
+        sessions
+    }), { role: updated, sessions });
+}
+function validateTaskRoleEnvironmentOptions(parsed, usage) {
+    if (parsed.has("--environment") && parsed.has("--managed-environment")) {
+        throw usageError("--environment and --managed-environment are mutually exclusive.", usage);
+    }
+    if (parsed.has("--environment") && (parsed.one("--environment")?.trim().length ?? 0) === 0) {
+        throw usageError("--environment requires an adopted preparation id.", usage);
+    }
 }
 function removeTaskRole(args, store, options) {
     exactPositionals(args, 2, "Task role remove usage: yui task role remove <task> <role>.");
@@ -1727,8 +2329,8 @@ function removeTaskRole(args, store, options) {
             taskId: task.id,
             roleName: role.name
         }, "removal");
-        if (tx.getActiveTurn(task.id, role.name) !== null) {
-            throw usageError(`Task Role has an active Turn and cannot be removed: ${task.id}/${role.name}.`);
+        if (tx.getActiveRun(task.id, role.name) !== null) {
+            throw usageError(`Task Role has an active AgentRun and cannot be removed: ${task.id}/${role.name}.`);
         }
         const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
         if (Object.values(sessions?.sessions ?? {}).some(({ status }) => status === "active")) {
@@ -1757,7 +2359,7 @@ function bindTaskRole(args, store, options) {
         }, "desired Agent binding update");
         const agent = requireAgent(tx, args[2]);
         const binding = role.agentBindings[agent.id]
-            ?? createRoleAgentBinding({ id: agent.id, adapterId: agent.adapterId });
+            ?? createRoleAgentBinding(agent);
         const bound = updateRole(role, {
             agentBindings: { ...role.agentBindings, [agent.id]: binding }
         }, now);
@@ -1777,7 +2379,7 @@ function bindTaskRole(args, store, options) {
         const switched = (() => {
             try {
                 return switchActiveRoleAgent(bound, existing, agent.id, {
-                    activeTurn: tx.getActiveTurn(task.id, role.name) !== null,
+                    activeRun: tx.getActiveRun(task.id, role.name) !== null,
                     nativeProcessRunning: currentSession !== undefined
                         && currentSession.status === "active"
                 }, now);
@@ -1790,6 +2392,10 @@ function bindTaskRole(args, store, options) {
         recordTaskEvent(tx, task.id, "role.agent-bound", {
             role: switched.role.name,
             agentId: agent.id,
+            // Re-selecting an Agent must not revive its old management entrance.
+            // This revokes authority, not the Session's independent execution fact.
+            ...(role.name === LEADER_ROLE && currentSession?.nativeSessionId !== undefined
+                ? { revokedNativeSessionId: currentSession.nativeSessionId } : {}),
             ...roleLaunchEventPayload(switched.role, switched.sessions)
         }, now);
         return { role: switched.role, mode: switched.mode };
@@ -1859,20 +2465,13 @@ function transferTaskRoleAuthority(args, store, options, action) {
             const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
             const session = sessions?.sessions[role.activeAgentId];
             const binding = sessions?.providerBinding;
-            if (sessions === null || sessions === undefined || session === undefined
-                || binding === null || binding === undefined
-                || session.runtimeGenerationId === undefined
-                || session.status === "ended") {
+            if (sessions === null || sessions === undefined || session === undefined || binding === null || binding === undefined || session.status === "ended") {
                 throw new Error(`Task Role has no live managed Provider: ${task.id}/${role.name}.`);
             }
-            const activation = currentProviderActivation(binding);
-            if (activation === null) {
-                throw new Error(`Provider Activation is not live: ${task.id}/${role.name}.`);
-            }
             if (action === "takeover") {
-                const activeTurn = tx.getActiveTurn(task.id, role.name);
-                if (activeTurn === null) {
-                    throw new Error(`Task Role has no active managed Turn for takeover: ${task.id}/${role.name}.`);
+                const activeRun = tx.getActiveRun(task.id, role.name);
+                if (activeRun === null) {
+                    throw new Error(`Task Role has no active managed AgentRun for takeover: ${task.id}/${role.name}.`);
                 }
             }
             if (action === "takeover"
@@ -1893,7 +2492,7 @@ function transferTaskRoleAuthority(args, store, options, action) {
                     expectedEpoch: binding.authority.epoch,
                     expectedOwner: binding.authority.owner,
                     owner: desiredOwner,
-                    holderId: action === "takeover" ? `human:${randomUUID()}` : activation.activationId,
+                    holderId: action === "takeover" ? `human:${randomUUID()}` : "controller",
                     changedAt: now.toISOString()
                 });
             const authority = updatedBinding.authority;
@@ -1914,7 +2513,6 @@ function transferTaskRoleAuthority(args, store, options, action) {
                 action,
                 taskId: task.id,
                 roleName: role.name,
-                runtimeGenerationId: session.runtimeGenerationId,
                 nativeSessionId: session.nativeSessionId,
                 authority: {
                     epoch: authority.epoch,
@@ -1947,6 +2545,8 @@ function taskWorkCommand(args, store, options) {
         return output(updateWorkScope(rest, store, options));
     if (command === "dispatch")
         return output(dispatchWork(rest, store, options));
+    if (command === "synthesize")
+        return synthesizeRuns(rest, "workItem", store, options);
     if (command === "review") {
         return rest[0] === "retry"
             ? retryFailedTaskReviewRound(rest.slice(1), store, options)
@@ -1986,14 +2586,10 @@ function editWork(args, store, options) {
     const result = store.transaction((tx) => {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, item.taskId);
-        if (task.status !== "draft") {
-            throw usageError(`Work Item definition edit is Draft-only: ${task.id}/${task.status}.`);
-        }
-        assertDraftTaskExecutionFree(tx, task);
+        assertTaskOpen(task);
+        if (task.status === "draft")
+            assertDraftTaskExecutionFree(tx, task);
         const actor = taskActor(tx, options, task.id);
-        if (actor !== "user" && actor !== "operator") {
-            throw usageError("Only the user or Operator may edit a Draft Work Item.");
-        }
         if (item.status === "retired") {
             throw usageError(`Work Item is retired: ${item.id}.`);
         }
@@ -2014,7 +2610,7 @@ function editWork(args, store, options) {
             : parsed.options.has("--clear-role") ? null : undefined;
         if (typeof assignee === "string")
             requireRole(tx, task.id, assignee);
-        const updated = editDraftWorkItemDefinition(item, {
+        const updated = editWorkItemDefinition(item, {
             ...(parsed.options.has("--title")
                 ? { title: requiredOption(parsed.options, "--title") }
                 : {}),
@@ -2031,7 +2627,21 @@ function editWork(args, store, options) {
             ...(baseRefs === undefined ? {} : { baseRefs }),
             ...(assignee === undefined ? {} : { assignee })
         }, now);
-        validateDraftWorkItemEdit(tx, task, updated);
+        if (task.status === "draft")
+            validateDraftWorkItemEdit(tx, task, updated);
+        else {
+            // Requirements can evolve while a frozen Assignment continues. Resource
+            // scope and ownership changes still require an explicit idle boundary.
+            if ((projects !== undefined || baseRefs !== undefined || assignee !== undefined)
+                && tx.listRuns(task.id).some((run) => run.workItemId === item.id && run.status === "active")) {
+                throw usageError(`Stop the active Work Item AgentRun before changing ownership or workspace scope: ${item.id}.`);
+            }
+            for (const dependencyId of updated.dependsOn) {
+                if (tx.getWorkItem(task.id, dependencyId) === null) {
+                    throw usageError(`Work Item dependency not found: ${dependencyId}.`);
+                }
+            }
+        }
         tx.saveWorkItem(task.id, updated);
         const changedFields = [
             parsed.options.has("--title") ? "title" : undefined,
@@ -2051,8 +2661,13 @@ function editWork(args, store, options) {
             workItemId: updated.id,
             revision: String(updated.revision),
             fields: changedFields.join(","),
+            previous: editedFieldValues(item, changedFields),
+            current: editedFieldValues(updated, changedFields),
             editedBy: actor
         }, now);
+        if (actor !== "leader") {
+            enqueueWork(tx, leaderMailbox(task.id), actor === "operator" ? "operator-input" : "user-message", now, [workItemRef(task.id, updated.id)], { source: actor });
+        }
         return { task, item: updated };
     });
     options.runtime?.notifyStateChanged(result.task.id);
@@ -2129,8 +2744,8 @@ function updateWorkScope(args, store, options) {
         const item = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, item.taskId);
         taskActor(tx, options, task.id);
-        if (tx.getActiveTurn(task.id, item.assignee ?? "") !== null) {
-            throw usageError(`Stop the active Work Item Turn before changing scope: ${item.id}.`);
+        if (tx.getActiveRun(task.id, item.assignee ?? "") !== null) {
+            throw usageError(`Stop the active Work Item AgentRun before changing scope: ${item.id}.`);
         }
         const requestedProjectIds = (parsed.multiOptions.get("--project") ?? []).map((reference) => {
             const project = resolveProject(task.projectBindings.map(({ projectId }) => requireProject(tx, projectId)), reference);
@@ -2160,12 +2775,16 @@ function updateWorkScope(args, store, options) {
     return `${updated.changed ? "Updated" : "Unchanged"} Work Item Project scope ${updated.item.id}: ${updated.item.writeProjectIds.join(", ") || "read-only"}\n`;
 }
 function updateWork(args, store, options) {
-    const usage = "Task work update usage: yui task work update <task>/<work> <todo|running|done|failed> [--summary <text>].";
-    const parsed = parseTail(args, new Set(["--summary"]), usage);
+    const usage = "Task work update usage: yui task work update <task>/<work> <todo|running|done|failed> [--summary <text>] [--artifact-ref git:<commit>:<relative-path> ...].";
+    const parsed = parseMultiValueTail(args, new Set(["--summary"]), new Set(["--artifact-ref"]), usage);
     exactPositionals(parsed.positionals, 2, usage);
     const requested = parsed.positionals[1];
     const status = parseWorkStatus(requested);
     const summary = trimmed(parsed.options.get("--summary"));
+    const artifactIds = parsed.multiOptions.get("--artifact-ref") ?? [];
+    if (artifactIds.length > 0 && status !== "completed") {
+        throw usageError("--artifact-ref is only valid when submitting a done Candidate.");
+    }
     if (["completed", "failed"].includes(status)
         && summary === undefined) {
         throw usageError(`--summary is required when work becomes ${requested}.`);
@@ -2175,19 +2794,16 @@ function updateWork(args, store, options) {
         const current = requireWorkItem(tx, parsed.positionals[0], options);
         const task = requireTask(tx, current.taskId);
         assertTaskOpen(task);
+        const artifactRefs = artifactIds.length === 0 ? undefined : fixedArtifactRefs(task.id, artifactIds);
         if (current.assignee === undefined) {
             taskActor(tx, options, task.id);
             if (status === "running") {
                 assertWorkItemDependenciesCompletedForCommand(tx, current);
             }
-            if (status === "completed" && current.status === "awaiting_acceptance") {
-                throw usageError(`Work Item ${current.id} is awaiting acceptance; use task work accept `
-                    + "after the required ReviewRound and Integration evidence.");
-            }
             const configuredReview = status === "completed" && !isTerminalWorkItemStatus(current.status)
                 ? tx.getReviewConfig()
                 : null;
-            const taskFinalContract = status === "completed" && current.status === "running"
+            const taskFinalContract = status === "completed" && current.status === "open"
                 ? taskFinalReviewContractForMutation(tx, task.id, options)
                 : undefined;
             const candidatePolicy = taskFinalContract === undefined
@@ -2197,9 +2813,7 @@ function updateWork(args, store, options) {
                 && current.writeProjectIds.length > 0;
             const metadataOnlyTaskFinalDelivery = taskFinalContract !== undefined
                 && current.assignee === undefined;
-            const candidateRequired = status === "completed"
-                && current.status === "running"
-                && (projectDelivery || candidatePolicy !== null);
+            const candidateRequired = status === "completed" && current.status === "open";
             const developWorkspace = tx.getWorkItemWorkspace(task.id, current.id);
             if (status === "completed"
                 && projectDelivery
@@ -2211,6 +2825,7 @@ function updateWork(args, store, options) {
                 ? submitWorkItemCandidate(current, {
                     summary: summary,
                     source: { type: "direct" },
+                    ...(artifactRefs === undefined ? {} : { artifactRefs }),
                     ...(candidatePolicy === null ? {} : { reviewPolicy: candidatePolicy }),
                     ...(taskFinalContract === undefined
                         ? {}
@@ -2225,9 +2840,7 @@ function updateWork(args, store, options) {
                         ? {}
                         : { taskMainSnapshot: options.directTaskMainSnapshot })
                 }, now)
-                : current.status === "failed" && status === "running"
-                    ? retryFailedWorkItem(current, now)
-                    : updateWorkItemStatus(current, status, now, isTerminalWorkItemStatus(status) ? summary : undefined);
+                : updateWorkItemStatus(current, "open", now);
             tx.saveWorkItem(task.id, updated);
             if (summary !== undefined) {
                 recordTaskEvent(tx, task.id, "work.updated", {
@@ -2250,29 +2863,29 @@ function updateWork(args, store, options) {
             };
         }
         taskActor(tx, options, task.id);
-        if (status !== "completed" || current.status !== "running") {
-            throw usageError(`Assigned Work Item ${current.id} can only submit a completed direct Turn from running; `
-                + "use dispatch, task turn retry, or task work retire for other transitions.");
+        if (status !== "completed" || current.status !== "open") {
+            throw usageError(`Assigned Work Item ${current.id} can only submit a completed direct AgentRun from running; `
+                + "use dispatch, task run retry, or task work retire for other transitions.");
         }
-        if (tx.getActiveTurn(task.id, current.assignee) !== null) {
-            throw usageError(`Work Item main Turn is still active: ${current.id}/${current.assignee}.`);
+        if (tx.getActiveRun(task.id, current.assignee) !== null) {
+            throw usageError(`Work Item main AgentRun is still active: ${current.id}/${current.assignee}.`);
         }
         const sourceGroup = currentWorkItemExecutionGroup(current);
-        const mainTurn = tx.listTurns(task.id).filter((turn) => (turn.purpose === "execution"
-            && turn.workItemId === current.id
-            && turn.roleName === current.assignee
-            && turn.executionGroupId === undefined
-            && turn.executionLaneId === undefined
-            && turn.sourceExecutionGroupId === sourceGroup?.id
-            && turn.status === "completed"
-            && turn.result !== undefined)).at(-1);
-        if (mainTurn === undefined) {
+        const mainRun = tx.listRuns(task.id).filter((run) => (run.purpose === "execution"
+            && run.workItemId === current.id
+            && run.roleName === current.assignee
+            && run.executionGroupId === undefined
+            && run.executionLaneId === undefined
+            && run.sourceExecutionGroupId === sourceGroup?.id
+            && run.status === "completed"
+            && run.result !== undefined)).at(-1);
+        if (mainRun === undefined) {
             throw usageError(sourceGroup === undefined
-                ? `Work Item ${current.id} has no completed direct main Turn.`
-                : `Work Item ${current.id} has no completed main Turn for ExecutionGroup ${sourceGroup.id}.`);
+                ? `Work Item ${current.id} has no completed direct main AgentRun.`
+                : `Work Item ${current.id} has no completed main AgentRun for ExecutionGroup ${sourceGroup.id}.`);
         }
-        if (mainTurn.result === undefined) {
-            throw dataError(`Completed WorkItem main Turn has no result: ${mainTurn.id}.`);
+        if (mainRun.result === undefined) {
+            throw dataError(`Completed WorkItem main AgentRun has no result: ${mainRun.id}.`);
         }
         const configuredReview = tx.getReviewConfig();
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
@@ -2288,8 +2901,9 @@ function updateWork(args, store, options) {
             throw usageError(`Project-backed Work Item ${current.id} must be isolated before Candidate submission.`);
         }
         const updated = submitWorkItemCandidate(current, {
-            summary: `Result from Turn ${mainTurn.id}.`,
-            source: { type: "turn", turnId: mainTurn.id },
+            summary: `Result from AgentRun ${mainRun.id}.`,
+            source: { type: "run", runId: mainRun.id },
+            ...(artifactRefs === undefined ? {} : { artifactRefs }),
             ...(candidatePolicy === null ? {} : { reviewPolicy: candidatePolicy }),
             ...(taskFinalContract === undefined
                 ? {}
@@ -2307,12 +2921,12 @@ function updateWork(args, store, options) {
             workItemId: updated.id,
             status: updated.status,
             summary: summary,
-            turnId: mainTurn.id,
+            runId: mainRun.id,
             ...leaderActionEventPayload(tx, task.id, options)
         }, now);
         enqueueWork(tx, taskMailbox(task.id), "work-updated", now, [
             workItemRef(task.id, updated.id),
-            turnRef(task.id, mainTurn.id)
+            runRef(task.id, mainRun.id)
         ]);
         const reviewDispatch = candidatePolicy?.trigger === "always"
             ? queueReviewRound(tx, updated, candidatePolicy, "policy", now)
@@ -2324,7 +2938,7 @@ function updateWork(args, store, options) {
         };
     });
     notifyMailbox(options.runtime, taskMailbox(result.item.taskId), result.item.taskId);
-    if (result.item.status === "awaiting_acceptance" && status === "completed") {
+    if ((result.item.status === "open" && result.item.candidates.length > 0) && status === "completed") {
         const failure = result.reviewDispatch?.round.status === "failed"
             ? `Review could not start: ${result.reviewDispatch.round.failure?.message ?? result.reviewDispatch.round.id}\n`
             : "";
@@ -2359,13 +2973,13 @@ function dispatchWork(args, store, options) {
             throw usageError(`Work Item has no Task Role assignee: ${item.id}. `
                 + `The Task Leader must run "yui task work update ${item.id} running" and execute it directly.`);
         }
-        const lanePlan = planReplicatedWorkItemLanes(item.assignee, requestedLaneRoles, `execution-group-${tx.peekNextTurnId(task.id)}`);
+        const lanePlan = planReplicatedWorkItemLanes(item.assignee, requestedLaneRoles, `execution-group-${tx.peekNextRunId(task.id)}`);
         const currentGroup = currentWorkItemExecutionGroup(item);
-        if (item.status !== "pending" && item.status !== "failed") {
+        if (item.status !== "open") {
             throw usageError(`Work item ${item.id} cannot be dispatched from ${item.status}.`);
         }
         if (currentGroup !== undefined && !workItemExecutionGroupSettled(currentGroup)) {
-            throw usageError(`Work Item ${item.id} retains open ExecutionGroup ${currentGroup.id}; retry or settle its exact Lane Turns.`);
+            throw usageError(`Work Item ${item.id} retains open ExecutionGroup ${currentGroup.id}; retry or settle its exact Lane AgentRuns.`);
         }
         assertWorkItemDependenciesCompletedForCommand(tx, item);
         const leaderOwned = item.assignee === "leader";
@@ -2389,18 +3003,16 @@ function dispatchWork(args, store, options) {
         }
         const roles = lanePlan.roles.map((name) => requireRole(tx, task.id, name));
         for (const role of roles) {
-            if (tx.getActiveTurn(task.id, role.name) !== null) {
-                throw usageError(`${task.id}/${role.name} already has an active turn.`);
+            if (tx.getActiveRun(task.id, role.name) !== null) {
+                throw usageError(`${task.id}/${role.name} already has an active run.`);
             }
         }
         const rawInput = trimmed(parsed.options.get("--input")) ?? item.objective;
-        let workItemForDispatch = item.status === "failed"
-            ? retryFailedWorkItem(item, now)
-            : item;
+        let workItemForDispatch = prepareWorkItemDispatch(item, now);
         if (lanePlan.roles.length === 0) {
             const role = requireRole(tx, task.id, item.assignee);
-            if (tx.getActiveTurn(task.id, role.name) !== null) {
-                throw usageError(`${task.id}/${role.name} already has an active turn.`);
+            if (tx.getActiveRun(task.id, role.name) !== null) {
+                throw usageError(`${task.id}/${role.name} already has an active run.`);
             }
             const effective = resolveEffectiveLaunch({
                 role,
@@ -2408,8 +3020,8 @@ function dispatchWork(args, store, options) {
                 workspace,
                 workItemWriteProjectIds: item.writeProjectIds
             });
-            const turnId = tx.nextTurnId(task.id);
-            const turn = createTurn(turnId, task.id, role.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(task.id, role.name), effective.agentId, effective), createTurnInput({
+            const runId = tx.nextRunId(task.id);
+            const run = createRun(runId, task.id, role.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(task.id, role.name), effective.agentId, effective), createRunInput({
                 source: { type: "yui", channel: "workitem-dispatch" },
                 directive: rawInput,
                 deltaRefIds: []
@@ -2418,30 +3030,30 @@ function dispatchWork(args, store, options) {
                 workspace,
                 effective
             });
-            const snapshot = freezeTurnContextSnapshot(tx, {
+            const snapshot = freezeRunContextSnapshot(tx, {
                 taskId: task.id,
-                roleName: turn.roleName,
+                roleName: run.roleName,
                 purpose: "execution",
                 workItemId: item.id
             }, now, "controller");
-            const withContext = withTurnContextSnapshot(turn, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            if (workItemForDispatch.status !== "running") {
-                workItemForDispatch = updateWorkItemStatus(workItemForDispatch, "running", now);
+            const withContext = withRunContextSnapshot(run, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            if (workItemForDispatch.status !== "open") {
+                workItemForDispatch = updateWorkItemStatus(workItemForDispatch, "open", now);
             }
             tx.saveWorkItem(task.id, workItemForDispatch);
-            tx.saveTurn(withContext);
-            tx.saveActiveTurn(withContext);
-            enqueueRoleTurnDispatch(tx, {
+            tx.saveRun(withContext);
+            tx.saveActiveRun(withContext);
+            enqueueRoleRunDispatch(tx, {
                 taskId: task.id,
                 roleName: role.name,
-                turnId: withContext.id,
+                runId: withContext.id,
                 reason: "turn-dispatched",
                 occurredAt: now
             });
-            recordTaskEvent(tx, task.id, "turn.dispatched", turnLaunchEventPayload(withContext), now);
-            return { kind: "direct", turns: [withContext] };
+            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(withContext), now);
+            return { kind: "direct", runs: [withContext] };
         }
-        const groupId = `execution-group-${tx.peekNextTurnId(task.id)}`;
+        const groupId = `execution-group-${tx.peekNextRunId(task.id)}`;
         if (workItemForDispatch !== item) {
             // Freeze the Assignment against the retried WorkItem revision. The
             // aggregate transaction rolls this back if a later precondition fails.
@@ -2470,7 +3082,7 @@ function dispatchWork(args, store, options) {
                 laneId,
                 managedWorkspace: laneWorkspace,
                 effective,
-                turnId: tx.nextTurnId(task.id),
+                runId: tx.nextRunId(task.id),
                 dispatchMode: roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(task.id, role.name), effective.agentId, effective)
             };
         });
@@ -2503,15 +3115,15 @@ function dispatchWork(args, store, options) {
                 root: plan.managedWorkspace.root,
                 writableProjectIds: [...item.writeProjectIds]
             },
-            currentTurnId: plan.turnId
+            currentRunId: plan.runId
         })), now);
         workItemForDispatch = attachWorkItemExecutionGroup(workItemForDispatch, group, now);
-        if (workItemForDispatch.status !== "running") {
-            workItemForDispatch = updateWorkItemStatus(workItemForDispatch, "running", now);
+        if (workItemForDispatch.status !== "open") {
+            workItemForDispatch = updateWorkItemStatus(workItemForDispatch, "open", now);
         }
         tx.saveWorkItem(task.id, workItemForDispatch);
-        const turns = plans.map((plan, index) => {
-            const turn = createTurn(plan.turnId, task.id, plan.role.name, plan.dispatchMode, createTurnInput({
+        const runs = plans.map((plan, index) => {
+            const run = createRun(plan.runId, task.id, plan.role.name, plan.dispatchMode, createRunInput({
                 source: { type: "yui", channel: "workitem-dispatch" },
                 directive: assignment.input,
                 deltaRefIds: []
@@ -2522,37 +3134,37 @@ function dispatchWork(args, store, options) {
                 workspace: plan.managedWorkspace,
                 effective: plan.effective
             });
-            const snapshot = freezeTurnContextSnapshot(tx, {
+            const snapshot = freezeRunContextSnapshot(tx, {
                 taskId: task.id,
-                roleName: turn.roleName,
+                roleName: run.roleName,
                 purpose: "execution",
                 workItemId: item.id
             }, now, "controller", assignment.contextSnapshotRef);
-            const withContext = withTurnContextSnapshot(turn, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            const withContext = withRunContextSnapshot(run, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
             const prepared = options.executionLaneWorkspaces?.get(group.lanes[index].id);
             if (prepared !== undefined && tx.getManagedWorkspace(prepared.owner) === null) {
                 tx.saveManagedWorkspace(prepared);
             }
-            tx.saveTurn(withContext);
-            tx.saveActiveTurn(withContext);
-            enqueueRoleTurnDispatch(tx, {
+            tx.saveRun(withContext);
+            tx.saveActiveRun(withContext);
+            enqueueRoleRunDispatch(tx, {
                 taskId: task.id,
                 roleName: plan.role.name,
-                turnId: withContext.id,
+                runId: withContext.id,
                 reason: "turn-dispatched",
                 occurredAt: now
             });
-            recordTaskEvent(tx, task.id, "turn.dispatched", turnLaunchEventPayload(withContext), now);
+            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(withContext), now);
             return withContext;
         });
-        return { kind: "replicated", turns };
+        return { kind: "replicated", runs };
     });
-    for (const turn of dispatch.turns) {
-        notifyMailbox(options.runtime, roleMailbox(turn.taskId, turn.roleName), turn.taskId);
+    for (const run of dispatch.runs) {
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
     }
     return dispatch.kind === "direct"
-        ? `Direct WorkItem Turn queued as ${dispatch.turns[0].id}\n`
-        : `Dispatch queued for ${dispatch.turns.length} replicated Lanes\n`;
+        ? `Direct WorkItem AgentRun queued as ${dispatch.runs[0].id}\n`
+        : `Dispatch queued for ${dispatch.runs.length} replicated Lanes\n`;
 }
 function replicatedProducerAssignmentInput(input, requiresCodeRef) {
     return [
@@ -2568,7 +3180,7 @@ function replicatedProducerAssignmentInput(input, requiresCodeRef) {
 }
 function acceptWork(args, store, options) {
     const usage = "Task work accept usage: yui task work accept <task>/<work> --summary <text>.";
-    const parsed = parseTail(args, new Set(["--summary"]), usage);
+    const parsed = parseTail(args, new Set(["--summary", "--candidate"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const summary = requiredOption(parsed.options, "--summary");
     const now = clock(options);
@@ -2579,17 +3191,23 @@ function acceptWork(args, store, options) {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
         const actor = taskActor(tx, options, task.id);
-        if (item.status !== "awaiting_acceptance") {
+        if ((item.status !== "open" || item.candidates.length === 0)) {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
         if (options.workItemIntegrationProof?.workspace.owner.type === "review-round") {
             throw usageError("A ReviewRound-owned workspace cannot be used for WorkItem acceptance.");
         }
-        const candidate = requireWorkItemCandidate(item);
+        const candidateId = parsed.options.get("--candidate");
+        const candidate = candidateId === undefined ? requireWorkItemCandidate(item)
+            : item.candidates.find(({ id }) => id === candidateId);
+        if (candidate === undefined)
+            throw usageError(`Work Item Candidate not found: ${candidateId}.`);
+        // A Candidate's artifact references are commit-pinned (git:<commit>:<path>):
+        // the commit self-certifies the frozen bytes, so they cannot drift and are
+        // re-validated for shape whenever the Candidate is loaded. Their bytes are
+        // resolved lazily on the async read/context path, never re-derived from a DB
+        // mirror here.
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
-        if (!sameTaskFinalReviewContract(candidate.taskFinalReviewContract, taskFinalContract)) {
-            throw usageError(`Task final-review contract does not match Candidate ${candidate.id}.`);
-        }
         const latestReview = reviewRoundsByIdentity(tx.listReviewRounds(item.taskId)
             .filter((round) => round.workItemId === item.id
             && round.candidateId === candidate.id)).at(-1);
@@ -2617,17 +3235,25 @@ function acceptWork(args, store, options) {
             && isolatedWorkspace.owner.workItemId === item.id
             && isolatedWorkspace.entries.some(({ access }) => access === "write")) {
             assertWorkItemIntegrationProof(tx, item.id, item.assignee, isolatedWorkspace, options.workItemIntegrationProof);
+            for (const proof of options.workItemIntegrationProof.projects) {
+                const candidateCommit = candidate.gitSnapshot?.projects
+                    .find(({ projectId }) => projectId === proof.projectId)?.commit;
+                if (candidateCommit === undefined || candidateCommit !== proof.headCommit) {
+                    throw usageError(`Selected Candidate ${candidate.id} does not match the integrated result for ${proof.projectId}.`);
+                }
+            }
         }
-        const completed = updateWorkItemStatus(item, "completed", now, summary);
+        const completed = updateWorkItemStatus(item, "accepted", now, summary, candidate.id);
         tx.saveWorkItem(item.taskId, completed);
         recordTaskEvent(tx, item.taskId, "work.accepted", {
             workItemId: item.id,
             candidateId: candidate.id,
-            ...(candidate.source.type === "turn"
-                ? { turnId: candidate.source.turnId }
+            ...(candidate.source.type === "run"
+                ? { runId: candidate.source.runId }
                 : { workItemRevision: String(candidate.workItemRevision) }),
             acceptedBy: actor,
             summary,
+            ...(latestReview === undefined ? {} : { reviewRoundId: latestReview.id }),
             ...(actor === "leader" ? leaderActionEventPayload(tx, item.taskId, options) : {})
         }, now);
         return completed;
@@ -2673,7 +3299,7 @@ function rejectWork(args, store, options) {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
         const actor = taskActor(tx, options, task.id);
-        if (item.status !== "awaiting_acceptance") {
+        if (item.status === "retired" || item.candidates.length === 0) {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
         const candidate = requireWorkItemCandidate(item);
@@ -2681,7 +3307,7 @@ function rejectWork(args, store, options) {
         if (activeReview !== undefined) {
             throw usageError(`ReviewRound is still active: ${activeReview.id}/${activeReview.status}.`);
         }
-        const failed = updateWorkItemStatus(item, "failed", now, summary);
+        const { currentCandidateId: _declinedCandidate, ...failed } = updateWorkItemStatus(item, "open", now);
         tx.saveWorkItem(item.taskId, failed);
         recordTaskEvent(tx, item.taskId, "work.rejected", {
             workItemId: item.id,
@@ -2735,12 +3361,12 @@ function retireWork(args, store, options) {
                     + `${activeWorkItemJob.id}/${activeWorkItemJob.status}. `
                     + "Cancel or acknowledge it before retiring.");
             }
-            for (const run of tx.listTurns(task.id).filter((candidate) => (candidate.status === "active" && candidate.workItemId === item.id))) {
-                const terminal = terminalizeExactTaskTurn(tx, {
+            for (const run of tx.listRuns(task.id).filter((candidate) => (candidate.status === "active" && candidate.workItemId === item.id))) {
+                const terminal = terminalizeExactTaskRun(tx, {
                     taskId: task.id,
                     roleName: run.roleName,
                     agentId: run.effective.agentId,
-                    turnId: run.id,
+                    runId: run.id,
                     outcome: {
                         status: "failed",
                         diagnostic: `Work Item retired: ${summary}`,
@@ -2748,7 +3374,7 @@ function retireWork(args, store, options) {
                     }
                 }, now);
                 if (terminal.disposition !== "applied") {
-                    throw usageError(`Work Item Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                    throw usageError(`Work Item AgentRun changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
                 }
             }
         }
@@ -2785,9 +3411,9 @@ function listWork(args, store) {
     exactPositionals(args, 1, "Task work list usage: yui task work list <task>.");
     const task = requireTask(store, args[0]);
     const items = store.listWorkItems(task.id);
-    const turns = store.listTurns(task.id);
+    const runs = store.listRuns(task.id);
     const sessionSets = store.listRoleSessionSets(task.id);
-    const executions = items.map((item) => projectWorkItemExecution(item, turns, sessionSets));
+    const executions = items.map((item) => projectWorkItemExecution(item, runs, sessionSets, store));
     const rendered = items.length === 0
         ? "No work items found.\n"
         : `${renderTable(`Task work: ${task.id}`, [
@@ -2814,7 +3440,7 @@ function listWork(args, store) {
 function showWork(args, store, options) {
     exactPositionals(args, 1, "Task work show usage: yui task work show <work>.");
     const item = requireWorkItem(store, args[0], options);
-    const execution = projectWorkItemExecution(item, store.listTurns(item.taskId), store.listRoleSessionSets(item.taskId));
+    const execution = projectWorkItemExecution(item, store.listRuns(item.taskId), store.listRoleSessionSets(item.taskId), store);
     const replacement = item.disposition?.replacementWorkItemId;
     const rendered = [
         `Work Item: ${item.id}`,
@@ -2835,7 +3461,7 @@ function showWork(args, store, options) {
 }
 function compactWorkItemExecution(projection) {
     if (projection.shape === "direct")
-        return `main=${projection.mainTurn.status}`;
+        return `main=${projection.mainRun.status}`;
     const counts = projection.laneCounts;
     return `lanes ${counts.running}/${counts.succeeded}/${counts.needsAttention}/${counts.failed}/${counts.unknown}; ${projection.synthesis.status}`;
 }
@@ -2848,16 +3474,16 @@ function renderWorkItemExecutionProjection(projection) {
             : [
                 `Lanes: running=${projection.laneCounts.running}, succeeded=${projection.laneCounts.succeeded}, needs-attention=${projection.laneCounts.needsAttention}, failed=${projection.laneCounts.failed}, unknown=${projection.laneCounts.unknown}`,
                 ...projection.lanes.map((lane) => (`  ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}): ${lane.status}; `
-                    + `turn=${lane.currentTurnId ?? "unknown"}; session=${lane.session}; `
-                    + `retry=${lane.retryTurnId ?? "none"}; settle=${lane.settleTurnId ?? "none"}`))
+                    + `run=${lane.currentRunId ?? "unknown"}; session=${lane.session}; `
+                    + `retry=${lane.retryRunId ?? "none"}; settle=${lane.settleRunId ?? "none"}`))
             ]),
-        `Synthesis: ${projection.synthesis.status}; successful=${projection.synthesis.successfulLaneCount}/${projection.synthesis.requiredSuccessfulLaneCount}`,
-        `Main Turn: ${projection.mainTurn.turnId ?? "unobserved"} [${projection.mainTurn.status}]; role=${projection.mainTurn.roleName ?? "unobserved"}; session=${projection.mainTurn.session}; retry=${projection.mainTurn.retryTurnId ?? "none"}`,
-        `Candidate Source: ${projection.candidate.candidateId ?? "none"} [${projection.candidate.status}]; source=${projection.candidate.sourceType ?? "unobserved"}; main=${projection.candidate.mainTurnId ?? "unobserved"}`,
+        `Synthesis: ${projection.synthesis.status}; successful=${projection.synthesis.successfulLaneCount}; sources selected by Leader`,
+        `Main AgentRun: ${projection.mainRun.runId ?? "unobserved"} [${projection.mainRun.status}]; role=${projection.mainRun.roleName ?? "unobserved"}; session=${projection.mainRun.session}; retry=${projection.mainRun.retryRunId ?? "none"}`,
+        `Candidate Source: ${projection.candidate.candidateId ?? "none"} [${projection.candidate.status}]; source=${projection.candidate.sourceType ?? "unobserved"}; main=${projection.candidate.mainRunId ?? "unobserved"}`,
         ...(projection.candidate.sourceExecutionGroupId === undefined
             ? []
             : [
-                `Candidate Provenance: main ${projection.candidate.mainTurnId ?? "unobserved"} -> group ${projection.candidate.sourceExecutionGroupId} -> ${projection.candidate.successfulLaneTurns.map(({ laneId, successfulTurnId }) => `${laneId} -> ${successfulTurnId}`).join(", ") || "unobserved"}`
+                `Candidate Provenance: main ${projection.candidate.mainRunId ?? "unobserved"} -> group ${projection.candidate.sourceExecutionGroupId} -> ${projection.candidate.successfulLaneRuns.map(({ laneId, successfulRunId }) => `${laneId} -> ${successfulRunId}`).join(", ") || "unobserved"}`
             ]),
         `Next Action: ${projection.nextAction.kind}; owner=${projection.nextAction.owners.join(", ") || "none"}; target=${projection.nextAction.targetIds.join(", ") || "none"}`
     ];
@@ -2882,7 +3508,7 @@ function reviewWork(args, store, options) {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
         const requestedBy = taskActor(tx, options, task.id);
-        if (item.status !== "awaiting_acceptance") {
+        if ((item.status !== "open" || item.candidates.length === 0)) {
             throw usageError(`Work Item is not awaiting acceptance: ${item.id}/${item.status}.`);
         }
         const candidate = requireWorkItemCandidate(item);
@@ -2900,9 +3526,9 @@ function reviewWork(args, store, options) {
             && (round.status === "pending" || round.status === "running")))).at(-1);
         if (activeRound !== undefined) {
             const producerDispatchPending = activeRound.executionGroup?.lanes.some((lane) => (lane.disposition === "open"
-                && (lane.currentTurnId === undefined
-                    || tx.getTurn(task.id, lane.currentTurnId)?.status === "failed"))) === true;
-            if ((activeRound.status === "pending" && activeRound.reviewerTurnId === undefined)
+                && (lane.currentRunId === undefined
+                    || tx.getRun(task.id, lane.currentRunId)?.status === "failed"))) === true;
+            if ((activeRound.status === "pending" && activeRound.reviewerRunId === undefined)
                 || (activeRound.status === "running" && producerDispatchPending)) {
                 const persistedRoles = activeRound.executionGroup?.lanes
                     .map(({ roleName }) => roleName) ?? [];
@@ -2935,7 +3561,7 @@ function reviewWork(args, store, options) {
     if (result.kind === "busy") {
         const busy = result.availability;
         return output(`Reviewer ${busy.reviewerRoleName} is busy (${busy.phase}`
-            + `${busy.activeTurnId === undefined ? "" : `; Turn ${busy.activeTurnId}`}); `
+            + `${busy.activeRunId === undefined ? "" : `; AgentRun ${busy.activeRunId}`}); `
             + `${busy.activeReviewRoundId === undefined
                 ? ""
                 : `active ReviewRound ${busy.activeReviewRoundId}; `}`
@@ -2950,17 +3576,49 @@ function reviewWork(args, store, options) {
 }
 /**
  * Task-control recovery for a failed Task-final ReviewRound that never
- * created a Reviewer Turn. This is deliberately separate from `task turn retry`:
- * that command requires an exact failed Turn and remains the only retry
+ * created a Reviewer AgentRun. This is deliberately separate from `task run retry`:
+ * that command requires an exact failed AgentRun and remains the only retry
  * path for a failed provider execution. Here the old terminal Round is an
  * immutable anchor and one fresh Round is created only after the same frozen
  * committed Integration/ChangeSet provenance and Reviewer independence fences
  * pass again.
  */
+function synthesizeRuns(args, kind, store, options) {
+    const subject = kind === "workItem" ? "work" : "review";
+    const usage = `Usage: yui task ${subject} synthesize <task>/<${subject}> --source-run <task>/<run> ...`;
+    const parsed = parseMultiValueTail(args, new Set(), new Set(["--source-run"]), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const reference = taskRecordReference(parsed.positionals[0], kind, "Synthesis target", options);
+    const sources = parsed.multiOptions.get("--source-run") ?? [];
+    const sourceRunIds = sources.map((value) => {
+        const source = taskRecordReference(value, "run", "Source AgentRun", options);
+        if (source.taskId !== reference.taskId)
+            throw usageError("Synthesis sources must belong to the same Task.");
+        return source.localId;
+    });
+    const now = clock(options);
+    const run = store.transaction((tx) => {
+        const actor = taskActor(tx, options, reference.taskId);
+        const created = kind === "workItem"
+            ? dispatchWorkItemSynthesis(tx, reference.taskId, reference.localId, sourceRunIds, now)
+            : dispatchReviewSynthesis(tx, reference.taskId, reference.localId, sourceRunIds, now);
+        recordTaskEvent(tx, reference.taskId, "run.synthesis-requested", {
+            runId: created.id,
+            requestedBy: actor,
+            sourceRunIds: sourceRunIds.join(","),
+            ...(actor === "leader" ? leaderActionEventPayload(tx, reference.taskId, options) : {})
+        }, now);
+        return created;
+    });
+    notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+    return output(`Dispatched synthesis AgentRun ${run.taskId}/${run.id}\n`, { run });
+}
 function taskReviewCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "request")
         return requestTaskReviewRound(rest, store, options);
+    if (command === "synthesize")
+        return synthesizeRuns(rest, "reviewRound", store, options);
     if (command === "retry")
         return retryFailedTaskReviewRound(rest, store, options);
     throw usageError(command === undefined
@@ -2968,7 +3626,7 @@ function taskReviewCommand(args, store, options) {
         : `Unknown command: task review ${command}`);
 }
 function requestTaskReviewRound(args, store, options) {
-    const usage = "Task review request usage: yui task review request <task> --role <global-role> "
+    const usage = "Task review request usage: yui task review request <task> --role <reviewer-role> "
         + "[--lane-role <producer-role> ...] [--delta-recheck].";
     const parsed = parseMultiValueTail(args, new Set(["--role"]), new Set(["--lane-role"]), usage, new Set(["--delta-recheck"]));
     exactPositionals(parsed.positionals, 1, usage);
@@ -2993,8 +3651,8 @@ function requestTaskReviewRound(args, store, options) {
                 throw usageError("Delta-recheck is not supported with a Task-final review contract.");
             }
         }
-        if (tx.getGlobalRole(reviewerRoleName) === null) {
-            throw usageError(`Global Role not found: ${reviewerRoleName}.`);
+        if (tx.getRole(task.id, reviewerRoleName) === null && tx.getGlobalRole(reviewerRoleName) === null) {
+            throw usageError(`Reviewer Role not found in this Task or global templates: ${reviewerRoleName}.`);
         }
         const provenance = taskReviewProvenance(tx, task, options);
         const producerCollision = taskReviewProducerCollision(provenance, reviewerRoleName);
@@ -3095,7 +3753,7 @@ function requestTaskReviewRound(args, store, options) {
     });
     if ("kind" in round && round.kind === "busy") {
         return output(`Reviewer ${round.reviewerRoleName} is busy (${round.phase}`
-            + `${round.activeTurnId === undefined ? "" : `; Turn ${round.activeTurnId}`}); `
+            + `${round.activeRunId === undefined ? "" : `; AgentRun ${round.activeRunId}`}); `
             + `${round.activeReviewRoundId === undefined
                 ? ""
                 : `active ReviewRound ${round.activeReviewRoundId}; `}`
@@ -3134,26 +3792,26 @@ function validateDeltaRecheckRequest(store, taskId, candidate, preflight) {
     return preflight.record;
 }
 function assertTaskReviewRequestLane(store, taskId, reviewerRoleName, reusableRound) {
-    const activePointer = store.getActiveTurn(taskId, reviewerRoleName);
+    const activePointer = store.getActiveRun(taskId, reviewerRoleName);
     if (reusableRound === undefined || reusableRound.status === "completed") {
         assertReviewerAvailable(store, taskId, reviewerRoleName);
         return;
     }
     if (reusableRound.status === "pending") {
         if (activePointer !== null) {
-            throw usageError(`Reviewer Role already has an active Turn: ${reviewerRoleName}.`);
+            throw usageError(`Reviewer Role already has an active AgentRun: ${reviewerRoleName}.`);
         }
         assertReviewerAvailable(store, taskId, reviewerRoleName, reusableRound);
         return;
     }
-    const reviewerTurnId = reusableRound.reviewerTurnId;
-    if (reviewerTurnId === undefined
+    const reviewerRunId = reusableRound.reviewerRunId;
+    if (reviewerRunId === undefined
         && reusableRound.executionGroup?.lanes.some(({ disposition }) => disposition === "open")) {
         assertReviewerAvailable(store, taskId, reviewerRoleName, reusableRound);
         return;
     }
-    const activeMatches = reviewerTurnId !== undefined
-        && activePointer?.id === reviewerTurnId
+    const activeMatches = reviewerRunId !== undefined
+        && activePointer?.id === reviewerRunId
         && activePointer.status === "active";
     if (!activeMatches) {
         throw usageError(`Existing Task-final ReviewRound ${reusableRound.id} is running without its exact Reviewer execution.`);
@@ -3168,7 +3826,7 @@ function assertReviewerAvailable(store, taskId, reviewerRoleName, reusableRound)
         return;
     }
     throw usageError(`Reviewer ${reviewerRoleName} is busy (${availability.phase}`
-        + `${availability.activeTurnId === undefined ? "" : `; Turn ${availability.activeTurnId}`}`
+        + `${availability.activeRunId === undefined ? "" : `; AgentRun ${availability.activeRunId}`}`
         + `${availability.activeReviewRoundId === undefined
             ? ""
             : `; ReviewRound ${availability.activeReviewRoundId}`}).`);
@@ -3178,10 +3836,10 @@ function reviewerBusyBelongsToRound(busy, round) {
         return false;
     if (busy.phase === "review-slot")
         return true;
-    if (busy.phase !== "active-turn" || busy.activeTurnId === undefined)
+    if (busy.phase !== "active-turn" || busy.activeRunId === undefined)
         return false;
-    return round.reviewerTurnId === busy.activeTurnId
-        || round.executionGroup?.lanes.some(({ currentTurnId }) => (currentTurnId === busy.activeTurnId)) === true;
+    return round.reviewerRunId === busy.activeRunId
+        || round.executionGroup?.lanes.some(({ currentRunId }) => (currentRunId === busy.activeRunId)) === true;
 }
 function retryFailedTaskReviewRound(args, store, options) {
     exactPositionals(args, 1, "Task review retry usage: yui task review retry <task>/<review-round>.");
@@ -3199,11 +3857,11 @@ function retryFailedTaskReviewRound(args, store, options) {
         if ((round.scope ?? "work-item") !== "task") {
             throw usageError(`ReviewRound ${round.id} is not a failed Task-final ReviewRound.`);
         }
-        if (round.reviewerTurnId !== undefined) {
+        if (round.reviewerRunId !== undefined) {
             if (round.status === "completed") {
                 throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
             }
-            throw usageError(`ReviewRound ${round.id} has Reviewer Turn ${round.reviewerTurnId}; use task turn retry instead.`);
+            throw usageError(`ReviewRound ${round.id} has Reviewer AgentRun ${round.reviewerRunId}; use task run retry instead.`);
         }
         if (round.status !== "failed" && round.status !== "pending") {
             throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
@@ -3243,9 +3901,9 @@ function retryFailedTaskReviewRound(args, store, options) {
             reviewer = createTaskRole(tx, task, round.reviewerRoleName, undefined, now, round.reviewerRoleName);
             tx.saveRole(task.id, reviewer);
         }
-        const activePointer = tx.getActiveTurn(task.id, reviewer.name);
+        const activePointer = tx.getActiveRun(task.id, reviewer.name);
         if (activePointer !== null) {
-            throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
+            throw usageError(`Reviewer Role already has an active AgentRun: ${reviewer.name}.`);
         }
         assertReviewerAvailable(tx, task.id, reviewer.name, round);
         // Issue 06: an already-pending Round is the idempotent retry result.
@@ -3266,50 +3924,50 @@ function retryFailedTaskReviewRound(args, store, options) {
         ? `Task-final Review retry requested as ${result.round.id}\n`
         : `Task-final Review retry already requested as ${result.round.id} (${result.round.status})\n`, { reviewRound: result.round });
 }
-function taskTurnCommand(args, store, options) {
+function taskRunCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "list")
-        return output(listTurns(rest, store, options));
+        return output(listRuns(rest, store, options));
     if (command === "show")
-        return showTurn(rest, store, options);
+        return showRun(rest, store, options);
     if (command === "context")
-        return turnContextCommand(rest, store, options);
+        return runContextCommand(rest, store, options);
     if (command === "retry")
-        return retryTurn(rest, store, options);
+        return retryRun(rest, store, options);
     if (command === "settle")
-        return settleTurn(rest, store, options);
+        return settleRun(rest, store, options);
     if (command === "checkpoint")
-        return output(checkpointTurn(rest, store, options));
+        return output(checkpointRun(rest, store, options));
     if (command === "retire")
-        return retireTurn(rest, store, options);
+        return retireRun(rest, store, options);
     throw usageError(command === undefined
         ? "Task turn command is required."
-        : `Unknown command: task turn ${command}`);
+        : `Unknown command: task run ${command}`);
 }
-function settleTurn(args, store, options) {
-    exactPositionals(args, 1, "Task turn settle usage: yui task turn settle <task>/<turn>.");
-    const previous = store.transaction((tx) => requireTurn(tx, args[0], options));
+function settleRun(args, store, options) {
+    exactPositionals(args, 1, "Task turn settle usage: yui task run settle <task>/<run>.");
+    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     if (previous.purpose === "review") {
         if (previous.executionGroupId !== undefined
             && previous.executionLaneId !== undefined) {
-            return settleFailedReviewExecutionLaneTurn(previous, store, options);
+            return settleFailedReviewExecutionLaneRun(previous, store, options);
         }
-        return settleStaleFinalReviewTurn(args, store, options);
+        return settleStaleFinalReviewRun(args, store, options);
     }
-    return settleFailedExecutionLaneTurn(previous, store, options);
+    return settleFailedExecutionLaneRun(previous, store, options);
 }
-function settleFailedReviewExecutionLaneTurn(previous, store, options) {
+function settleFailedReviewExecutionLaneRun(previous, store, options) {
     const now = clock(options);
     const result = store.transaction((tx) => {
-        const run = tx.getTurn(previous.taskId, previous.id);
+        const run = tx.getRun(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "review") {
-            throw usageError(`Turn ${previous.id} is not a failed review Turn.`);
+            throw usageError(`AgentRun ${previous.id} is not a failed review AgentRun.`);
         }
         if (run.reviewRoundId === undefined
             || run.executionGroupId === undefined
             || run.executionLaneId === undefined
             || run.sourceExecutionGroupId !== undefined) {
-            throw usageError(`Turn ${run.id} is not a failed Review Producer Lane Turn.`);
+            throw usageError(`AgentRun ${run.id} is not a failed Review Producer Lane AgentRun.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -3317,80 +3975,79 @@ function settleFailedReviewExecutionLaneTurn(previous, store, options) {
         const actor = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
-            throw dataError(`ReviewRound not found for Turn ${run.id}: ${run.reviewRoundId}.`);
+            throw dataError(`ReviewRound not found for AgentRun ${run.id}: ${run.reviewRoundId}.`);
         }
         const group = round.executionGroup;
         if (group === undefined || group.id !== run.executionGroupId) {
-            throw usageError(`Turn ${run.id} no longer belongs to the Review ExecutionGroup.`);
+            throw usageError(`AgentRun ${run.id} no longer belongs to the Review ExecutionGroup.`);
         }
         const lane = group.lanes.find(({ id }) => id === run.executionLaneId);
-        if (lane === undefined || lane.currentTurnId !== run.id || lane.roleName !== run.roleName) {
-            throw usageError(`Turn ${run.id} no longer owns its Review Producer Lane.`);
+        if (lane === undefined || lane.currentRunId !== run.id || lane.roleName !== run.roleName) {
+            throw usageError(`AgentRun ${run.id} no longer owns its Review Producer Lane.`);
         }
         if (lane.disposition === "failed") {
             return {
-                turn: run,
+                run: run,
                 reviewRound: round,
                 changed: false,
-                mainTurns: []
+                mainRuns: []
             };
         }
         if (round.status !== "running" || lane.disposition !== "open") {
-            throw usageError(`Turn ${run.id} cannot settle ${round.id}/${group.id}/${lane.id} from `
+            throw usageError(`AgentRun ${run.id} cannot settle ${round.id}/${group.id}/${lane.id} from `
                 + `${round.status}/${lane.disposition}.`);
         }
-        const validation = validateExactTurnReviewRound(tx, run, { allowTerminal: true });
+        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
         if (validation.disposition !== "applied") {
-            throw usageError(`Review Turn ${run.id} no longer matches its frozen Review Lane: `
+            throw usageError(`Review AgentRun ${run.id} no longer matches its frozen Review Lane: `
                 + `${validation.reason ?? "mismatch"}.`);
         }
-        if (tx.getActiveExecutionLaneTurn(task.id, group.id, lane.id) !== null) {
-            throw usageError(`Review Producer Lane still has an active Turn: ${group.id}/${lane.id}.`);
+        if (tx.getActiveExecutionLaneRun(task.id, group.id, lane.id) !== null) {
+            throw usageError(`Review Producer Lane still has an active AgentRun: ${group.id}/${lane.id}.`);
         }
         const settledGroup = updateUnifiedExecutionLane(group, lane.id, {
-            currentTurnId: run.id,
+            currentRunId: run.id,
             disposition: "failed"
         }, now);
         tx.saveReviewRound(task.id, updateReviewExecutionGroup(round, settledGroup));
-        recordTaskEvent(tx, task.id, "turn.review-settled", {
-            turnId: run.id,
+        recordTaskEvent(tx, task.id, "run.review-settled", {
+            runId: run.id,
             reviewRoundId: round.id,
             executionGroupId: group.id,
             executionLaneId: lane.id,
             settledBy: actor,
             ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
-        const reconciliation = reconcileReviewMainTurns(tx, task.id, now);
         return {
-            turn: run,
+            run: run,
             reviewRound: tx.getReviewRound(task.id, round.id),
             changed: true,
-            mainTurns: reconciliation.createdTurns
+            mainRuns: []
         };
     });
-    for (const turn of result.mainTurns) {
-        notifyMailbox(options.runtime, roleMailbox(turn.taskId, turn.roleName), turn.taskId);
+    for (const run of result.mainRuns) {
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
     }
     return output(result.changed
-        ? `Settled failed Review Producer Lane from Turn ${result.turn.id}\n`
-        : `Failed Review Producer Lane already settled from Turn ${result.turn.id}\n`, {
-        turn: result.turn,
+        ? `Settled failed Review Producer Lane from AgentRun ${result.run.id}\n`
+        : `Failed Review Producer Lane already settled from AgentRun ${result.run.id}\n`, {
+        run: result.run,
         reviewRound: result.reviewRound,
-        ...(result.mainTurns.length === 0 ? {} : { mainTurns: result.mainTurns })
+        ...(result.mainRuns.length === 0 ? {} : { mainRuns: result.mainRuns })
     });
 }
-function settleFailedExecutionLaneTurn(previous, store, options) {
+function settleFailedExecutionLaneRun(previous, store, options) {
     const now = clock(options);
     const result = store.transaction((tx) => {
-        const run = tx.getTurn(previous.taskId, previous.id);
+        const run = tx.getRun(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "execution") {
-            throw usageError(`Turn ${previous.id} is not a failed execution Turn.`);
+            throw usageError(`AgentRun ${previous.id} is not a failed execution AgentRun.`);
         }
         if (run.workItemId === undefined
             || run.executionGroupId === undefined
             || run.executionLaneId === undefined
             || run.sourceExecutionGroupId !== undefined) {
-            throw usageError(`Turn ${run.id} is not a failed WorkItem Execution Lane Turn.`);
+            throw usageError(`AgentRun ${run.id} is not a failed WorkItem Execution Lane AgentRun.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -3398,94 +4055,88 @@ function settleFailedExecutionLaneTurn(previous, store, options) {
         const actor = taskActor(tx, options, task.id);
         const item = tx.getWorkItem(task.id, run.workItemId);
         if (item === null)
-            throw dataError(`Work item not found for Turn ${run.id}: ${run.workItemId}.`);
+            throw dataError(`Work item not found for AgentRun ${run.id}: ${run.workItemId}.`);
         const group = currentWorkItemExecutionGroup(item);
         if (group === undefined || group.id !== run.executionGroupId) {
-            throw usageError(`Turn ${run.id} no longer belongs to the current ExecutionGroup.`);
+            throw usageError(`AgentRun ${run.id} no longer belongs to the current ExecutionGroup.`);
         }
         const lane = group.lanes.find(({ id }) => id === run.executionLaneId);
-        if (lane === undefined || lane.currentTurnId !== run.id) {
-            throw usageError(`Turn ${run.id} no longer owns its Execution Lane.`);
+        if (lane === undefined || lane.currentRunId !== run.id) {
+            throw usageError(`AgentRun ${run.id} no longer owns its Execution Lane.`);
         }
         if (lane.disposition === "failed") {
             return {
-                turn: run,
+                run: run,
                 workItem: item,
                 changed: false,
-                mainTurns: []
+                mainRuns: []
             };
         }
-        if (item.status !== "running" || lane.disposition !== "open") {
-            throw usageError(`Turn ${run.id} cannot settle ${item.id}/${group.id}/${lane.id} from `
+        if (item.status !== "open" || lane.disposition !== "open") {
+            throw usageError(`AgentRun ${run.id} cannot settle ${item.id}/${group.id}/${lane.id} from `
                 + `${item.status}/${lane.disposition}.`);
         }
-        if (tx.getActiveExecutionLaneTurn(task.id, group.id, lane.id) !== null) {
-            throw usageError(`Execution Lane still has an active Turn: ${group.id}/${lane.id}.`);
+        if (tx.getActiveExecutionLaneRun(task.id, group.id, lane.id) !== null) {
+            throw usageError(`Execution Lane still has an active AgentRun: ${group.id}/${lane.id}.`);
         }
         const settledGroup = updateWorkItemExecutionLane(group, lane.id, {
-            currentTurnId: run.id,
+            currentRunId: run.id,
             disposition: "failed"
         }, now);
         const settledItem = updateWorkItemExecutionGroup(item, settledGroup, now);
         tx.saveWorkItem(task.id, settledItem);
-        recordTaskEvent(tx, task.id, "turn.execution-settled", {
-            turnId: run.id,
+        recordTaskEvent(tx, task.id, "run.execution-settled", {
+            runId: run.id,
             workItemId: item.id,
             executionGroupId: group.id,
             executionLaneId: lane.id,
             settledBy: actor,
             ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
-        const reconciliation = reconcileWorkItemMainTurns(tx, task.id, now);
         return {
-            turn: run,
+            run: run,
             workItem: tx.getWorkItem(task.id, item.id) ?? settledItem,
             changed: true,
-            mainTurns: reconciliation.createdTurns
+            mainRuns: []
         };
     });
-    for (const turn of result.mainTurns) {
-        notifyMailbox(options.runtime, roleMailbox(turn.taskId, turn.roleName), turn.taskId);
+    for (const run of result.mainRuns) {
+        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
     }
     return output(result.changed
-        ? `Settled failed Execution Lane from Turn ${result.turn.id}\n`
-        : `Failed Execution Lane already settled from Turn ${result.turn.id}\n`, {
-        turn: result.turn,
+        ? `Settled failed Execution Lane from AgentRun ${result.run.id}\n`
+        : `Failed Execution Lane already settled from AgentRun ${result.run.id}\n`, {
+        run: result.run,
         workItem: result.workItem,
-        ...(result.mainTurns.length === 0 ? {} : { mainTurns: result.mainTurns })
+        ...(result.mainRuns.length === 0 ? {} : { mainRuns: result.mainRuns })
     });
 }
-function retireTurn(args, store, options) {
-    const usage = "Task turn retire usage: yui task turn retire <task>/<turn> --reason <text> [--expected-progress-at <timestamp>] [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
+function retireRun(args, store, options) {
+    const usage = "Task turn retire usage: yui task run retire <task>/<run> --reason <text> [--expected-progress-at <timestamp>] [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>].";
     const parsed = parseTail(args, new Set([
         "--reason",
         "--expected-progress-at",
         "--progress-at",
         "--agent-id",
         "--adapter-id",
-        "--native-session-id",
-        "--launch-id"
+        "--native-session-id"
     ]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const reason = requiredOption(parsed.options, "--reason");
-    const reference = taskRecordReference(parsed.positionals[0], "turn", "Turn reference", options);
+    const reference = taskRecordReference(parsed.positionals[0], "run", "AgentRun reference", options);
     const now = clock(options);
     const result = store.transaction((tx) => {
         const task = requireTask(tx, reference.taskId);
         assertTaskOpen(task);
         const actor = taskActor(tx, options, task.id);
-        let run = tx.getTurn(task.id, reference.localId);
+        let run = tx.getRun(task.id, reference.localId);
         if (run === null)
-            throw dataError(`Turn not found: ${task.id}/${reference.localId}.`);
+            throw dataError(`AgentRun not found: ${task.id}/${reference.localId}.`);
         const events = tx.listEvents(task.id);
-        if (isTaskRecordRetired(events, "turn", run.id)) {
-            return { task, turn: run, changed: false };
+        if (isTaskRecordRetired(events, "run", run.id)) {
+            return { task, run: run, changed: false };
         }
         if (run.status === "active") {
-            if (actor === "leader"
-                && taskLeaderActionTurnId(tx, task.id, options.environment) === run.id) {
-                throw usageError("A Task Leader cannot retire its own current authority Turn.", usage);
-            }
             const expectedProgressAt = requiredOption(parsed.options, parsed.options.has("--expected-progress-at")
                 ? "--expected-progress-at"
                 : "--progress-at");
@@ -3495,35 +4146,30 @@ function retireTurn(args, store, options) {
             const agentId = requiredOption(parsed.options, "--agent-id");
             const adapterId = requiredOption(parsed.options, "--adapter-id");
             const nativeSessionId = parsed.options.get("--native-session-id");
-            const runtimeGenerationId = 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 Turn.", usage);
+                throw usageError("--native-session-id is required for this active AgentRun.", usage);
             }
-            if (session?.nativeSessionId === undefined && runtimeGenerationId === undefined) {
-                throw usageError("--launch-id is required for an opaque active Turn.", usage);
-            }
-            const terminal = retireExactActiveTurn(tx, {
+            const terminal = retireExactActiveRun(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
-                turnId: run.id,
+                runId: run.id,
                 agentId,
                 adapterId,
                 ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-                ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId }),
                 expectedProgressAt,
-                reason: `Turn retired: ${reason}`
+                reason: `AgentRun retired: ${reason}`
             }, now);
-            if (terminal.disposition !== "applied" || terminal.turn === null) {
+            if (terminal.disposition !== "applied" || terminal.run === null) {
                 throw usageError(terminal.disposition === "blocked"
-                    ? `Turn retirement is blocked: ${run.id}/${terminal.reason ?? "unsafe"}.`
-                    : `Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                    ? `AgentRun retirement is blocked: ${run.id}/${terminal.reason ?? "unsafe"}.`
+                    : `AgentRun changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
-            run = terminal.turn;
+            run = terminal.run;
         }
-        recordTaskEvent(tx, task.id, "turn.retired", {
-            turnId: run.id,
+        recordTaskEvent(tx, task.id, "run.retired", {
+            runId: run.id,
             reason,
             ...(parsed.options.get("--expected-progress-at") === undefined
                 && parsed.options.get("--progress-at") === undefined
@@ -3535,9 +4181,6 @@ function retireTurn(args, store, options) {
             ...(parsed.options.get("--native-session-id") === undefined
                 ? {}
                 : { nativeSessionId: parsed.options.get("--native-session-id") }),
-            ...(parsed.options.get("--launch-id") === undefined
-                ? {}
-                : { runtimeGenerationId: parsed.options.get("--launch-id") }),
             ...(actor === "leader"
                 ? leaderActionEventPayload(tx, task.id, options)
                 : { retiredBy: actor })
@@ -3545,98 +4188,98 @@ function retireTurn(args, store, options) {
         tx.saveEvent(task.id, createTaskRecordRetirement({
             eventId: tx.nextEventId(task.id),
             taskId: task.id,
-            recordKind: "turn",
+            recordKind: "run",
             recordId: run.id,
             reason,
             retiredBy: actor
         }, now));
-        return { task, turn: run, changed: true };
+        return { task, run: run, changed: true };
     });
     if (result.changed)
         options.runtime?.notifyStateChanged(result.task.id);
-    return output(`Retired Turn ${result.task.id}/${result.turn.id}\n`, {
-        turn: result.turn,
+    return output(`Retired AgentRun ${result.task.id}/${result.run.id}\n`, {
+        run: result.run,
         retired: true
     });
 }
-function turnContextCommand(args, store, options) {
+function runContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
-        const usage = "Task turn context expand usage: yui task turn context expand <task>/<turn> <ref-id> [--store <store>] [--mode full].";
+        const usage = "Task turn context expand usage: yui task run context expand <task>/<run> <ref-id> [--store <store>] [--mode full].";
         const parsed = parseTail(rest, new Set(["--store", "--mode"]), usage);
         exactPositionals(parsed.positionals, 2, usage);
         const mode = parsed.options.get("--mode");
         if (mode !== undefined && mode !== "full") {
-            throw usageError("Turn Context expansion mode must be full.", usage);
+            throw usageError("AgentRun Context expansion mode must be full.", usage);
         }
-        const { taskId, turnId } = parseTurnContextReference(parsed.positionals[0]);
-        authorizeTurnContext(store, taskId, turnId, options.environment);
-        const expanded = store.transaction((tx) => expandTurnContextRef(tx, taskId, turnId, parsed.positionals[1], optionalNonEmptyOption(parsed.options, "--store")));
+        const { taskId, runId } = parseRunContextReference(parsed.positionals[0]);
+        authorizeRunContext(store, taskId, runId, options.environment);
+        const expanded = store.transaction((tx) => expandRunContextRef(tx, taskId, runId, parsed.positionals[1], optionalNonEmptyOption(parsed.options, "--store")));
         return output(`${JSON.stringify(expanded, null, 2)}\n`, { context: expanded });
     }
     if (first === "delta") {
         if (rest.length !== 3 || rest[1] !== "--after") {
-            throw usageError("Task turn context delta usage: yui task turn context delta <task>/<turn> --after <cursor>.");
+            throw usageError("Task turn context delta usage: yui task run context delta <task>/<run> --after <cursor>.");
         }
-        const { taskId, turnId } = parseTurnContextReference(rest[0]);
-        authorizeTurnContext(store, taskId, turnId, options.environment);
-        const delta = store.transaction((tx) => (buildTurnContextDelta(tx, taskId, turnId, rest[2])));
+        const { taskId, runId } = parseRunContextReference(rest[0]);
+        authorizeRunContext(store, taskId, runId, options.environment);
+        const delta = store.transaction((tx) => (buildRunContextDelta(tx, taskId, runId, rest[2])));
         return output(`${JSON.stringify(delta, null, 2)}\n`, { contextDelta: delta });
     }
     if (first === undefined || rest.length !== 0) {
-        throw usageError("Task turn context usage: yui task turn context <task>/<turn>.");
+        throw usageError("Task turn context usage: yui task run context <task>/<run>.");
     }
-    const { taskId, turnId } = parseTurnContextReference(first);
-    authorizeTurnContext(store, taskId, turnId, options.environment);
-    const pack = store.transaction((tx) => buildTurnContextPack(tx, taskId, turnId));
+    const { taskId, runId } = parseRunContextReference(first);
+    authorizeRunContext(store, taskId, runId, options.environment);
+    const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
     return output(`${JSON.stringify(pack, null, 2)}\n`, { context: pack });
 }
-function parseTurnContextReference(value) {
-    const [taskId, turnId, extra] = value.split("/");
-    if (taskId === undefined || taskId.length === 0 || turnId === undefined || turnId.length === 0
+function parseRunContextReference(value) {
+    const [taskId, runId, extra] = value.split("/");
+    if (taskId === undefined || taskId.length === 0 || runId === undefined || runId.length === 0
         || extra !== undefined) {
-        throw usageError(`Turn context reference is invalid: ${value}.`);
+        throw usageError(`AgentRun context reference is invalid: ${value}.`);
     }
-    return { taskId, turnId };
+    return { taskId, runId };
 }
 /**
- * A Turn Context Pack is information the Role's own runtime reads in order to
+ * A AgentRun Context Pack is information the Role's own runtime reads in order to
  * work. Authorization is therefore scope-shaped, not schedule-shaped: the
- * caller must be the current runtime of the Task Role that owns the Turn,
+ * caller must be the current runtime of the Task Role that owns the AgentRun,
  * proven by its per-Session caller key against durable state.
  *
- * It deliberately does not require the Turn to still be the active one. An
- * Agent whose Turn has advanced must still be able to read the context it was
+ * It deliberately does not require the AgentRun to still be the active one. An
+ * Agent whose AgentRun has advanced must still be able to read the context it was
  * given; losing read access to its own Role's history is what forces an
  * otherwise healthy Agent to stop and escalate to a human.
  */
-function authorizeTurnContext(store, taskId, turnId, environment) {
+function authorizeRunContext(store, taskId, runId, environment) {
     const managed = environment?.YUI_SESSION_SCOPE !== undefined
         || environment?.YUI_TASK_ID !== undefined
         || environment?.YUI_ROLE !== undefined;
     if (!managed)
         return;
-    const run = store.getTurn(taskId, turnId);
+    const run = store.getRun(taskId, runId);
     if (run === null) {
-        throw usageError(`Turn Context access is not authorized: ${taskId}/${turnId}.`);
+        throw usageError(`AgentRun Context access is not authorized: ${taskId}/${runId}.`);
     }
     if (currentManagedRuntime(store, environment, taskId, run.roleName) === undefined) {
-        throw usageError(`Turn Context access requires the current runtime of ${taskId}/${run.roleName}.`);
+        throw usageError(`AgentRun Context access requires the current runtime of ${taskId}/${run.roleName}.`);
     }
 }
-function listTurns(args, store, options) {
-    const usage = "Task turn list usage: yui task turn list <task|task/work>.";
+function listRuns(args, store, options) {
+    const usage = "Task turn list usage: yui task run list <task|task/work>.";
     exactPositionals(args, 1, usage);
     const reference = args[0];
     const task = store.getTask(reference);
     const item = task === null ? requireWorkItem(store, reference, options) : null;
     const taskId = task?.id ?? item.taskId;
-    const turns = store.listTurns(taskId).filter((turn) => (item === null || turn.workItemId === item.id));
-    if (turns.length === 0)
-        return "No Turns found.\n";
+    const runs = store.listRuns(taskId).filter((run) => (item === null || run.workItemId === item.id));
+    if (runs.length === 0)
+        return "No AgentRuns found.\n";
     const events = store.listEvents(taskId);
-    return `${renderTable(`Turns: ${item?.id ?? taskId}`, [
-        { header: "Turn", minWidth: 6, maxWidth: 20 },
+    return `${renderTable(`AgentRuns: ${item?.id ?? taskId}`, [
+        { header: "AgentRun", minWidth: 6, maxWidth: 20 },
         { header: "Role", minWidth: 4, maxWidth: 22 },
         { header: "Subject", minWidth: 7, maxWidth: 24 },
         { header: "Purpose", minWidth: 6, maxWidth: 10 },
@@ -3647,7 +4290,7 @@ function listTurns(args, store, options) {
         { header: "Status", minWidth: 6, maxWidth: 12 },
         { header: "History", minWidth: 7, maxWidth: 9 },
         { header: "Summary", minWidth: 8, maxWidth: 58 }
-    ], turns.map((run) => [
+    ], runs.map((run) => [
         run.id,
         run.roleName,
         run.workItemId ?? (run.reviewRoundId === undefined ? "task" : `review:${run.reviewRoundId}`),
@@ -3657,29 +4300,29 @@ function listTurns(args, store, options) {
         run.effective.profileAccess,
         run.effective.permission.strategy,
         run.status,
-        isTaskRecordRetired(events, "turn", run.id) ? "retired" : "active",
+        isTaskRecordRetired(events, "run", run.id) ? "retired" : "active",
         run.result?.output ?? run.result?.diagnostic ?? "-"
     ]), defaultTableWidth())}\n`;
 }
 /**
- * Settles only the known bootstrap split where a failed Task-final Turn
+ * Settles only the known bootstrap split where a failed Task-final AgentRun
  * still owns a running ReviewRound, but the committed Task heads have moved
  * on. This is deliberately narrower than retry: it cannot manufacture a
  * review or fail an arbitrary Round, and every identity/mailbox fence is
  * checked before the old Round changes. The next normal Task completion then
  * creates one fresh Round over the newer frozen Task heads.
  */
-function settleStaleFinalReviewTurn(args, store, options) {
-    exactPositionals(args, 1, "Task turn settle usage: yui task turn settle <task>/<turn>.");
+function settleStaleFinalReviewRun(args, store, options) {
+    exactPositionals(args, 1, "Task turn settle usage: yui task run settle <task>/<run>.");
     const now = clock(options);
-    const previous = store.transaction((tx) => requireTurn(tx, args[0], options));
+    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     const result = store.transaction((tx) => {
-        const run = tx.getTurn(previous.taskId, previous.id);
+        const run = tx.getRun(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "review") {
-            throw usageError(`Turn ${previous.id} is not a failed review Turn.`);
+            throw usageError(`AgentRun ${previous.id} is not a failed review AgentRun.`);
         }
         if (run.reviewRoundId === undefined) {
-            throw usageError(`Review Turn ${run.id} has no ReviewRound.`);
+            throw usageError(`Review AgentRun ${run.id} has no ReviewRound.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -3687,26 +4330,26 @@ function settleStaleFinalReviewTurn(args, store, options) {
         const actor = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
-            throw dataError(`ReviewRound not found for Turn ${run.id}: ${run.reviewRoundId}.`);
+            throw dataError(`ReviewRound not found for AgentRun ${run.id}: ${run.reviewRoundId}.`);
         }
         if ((round.scope ?? "work-item") !== "task") {
-            throw usageError(`Review Turn ${run.id} is not a Task-final review; request a new WorkItem review `
+            throw usageError(`Review AgentRun ${run.id} is not a Task-final review; request a new WorkItem review `
                 + "for a new Candidate.");
         }
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
         if (!sameTaskFinalReviewContract(round.taskFinalReviewContract, taskFinalContract)) {
             throw usageError(`Task final-review contract does not match ReviewRound ${round.id}.`);
         }
-        // This read-only compare-and-swap fence covers the exact Turn/Round,
+        // This read-only compare-and-swap fence covers the exact AgentRun/Round,
         // Candidate, stored Review workspace, frozen Project scope, and frozen
         // Project heads before any mailbox or Round write.
-        const validation = validateExactTurnReviewRound(tx, run, { allowTerminal: true });
+        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
         if (validation.disposition !== "applied" || validation.round === null) {
-            throw usageError(`Review Turn ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
+            throw usageError(`Review AgentRun ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
         }
-        const activeRoleTurn = tx.getActiveTurn(task.id, round.reviewerRoleName);
-        if (activeRoleTurn !== null) {
-            throw usageError(`${task.id}/${round.reviewerRoleName} already has active Turn ${activeRoleTurn.id}.`);
+        const activeRoleRun = tx.getActiveRun(task.id, round.reviewerRoleName);
+        if (activeRoleRun !== null) {
+            throw usageError(`${task.id}/${round.reviewerRoleName} already has active AgentRun ${activeRoleRun.id}.`);
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id)
             .filter((entry) => (entry.scope ?? "work-item") === "task"));
@@ -3724,7 +4367,7 @@ function settleStaleFinalReviewTurn(args, store, options) {
         }
         if (round.status === "failed") {
             if (round.failure?.kind === "execution") {
-                return { turn: run, round, changed: false };
+                return { run: run, round, changed: false };
             }
             throw usageError(`Final ReviewRound is already terminal: ${round.id}/${round.status}.`);
         }
@@ -3732,53 +4375,54 @@ function settleStaleFinalReviewTurn(args, store, options) {
             throw usageError(`Final ReviewRound is not stranded running: ${round.id}/${round.status}.`);
         }
         assertReviewerAvailable(tx, task.id, round.reviewerRoleName, round);
-        const summary = `Review Turn ${run.id} failed before delivery; committed Task heads changed.`;
+        const summary = `Review AgentRun ${run.id} failed before delivery; committed Task heads changed.`;
         const terminal = finishReviewRound(round, "failed", now, { kind: "execution", message: summary });
         tx.saveReviewRound(task.id, terminal);
-        recordTaskEvent(tx, task.id, "turn.review-stale-settled", {
-            turnId: run.id,
+        recordTaskEvent(tx, task.id, "run.review-stale-settled", {
+            runId: run.id,
             reviewRoundId: round.id,
             previousTaskCandidate: JSON.stringify(round.taskCandidate),
             currentTaskCandidate: JSON.stringify(currentTaskCandidate),
             settledBy: actor,
             ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : {})
         }, now);
-        return { turn: run, round: terminal, changed: true };
+        return { run: run, round: terminal, changed: true };
     });
     return output(result.changed
-        ? `Settled obsolete final Review ${result.round.id} from failed Turn ${result.turn.id}\n`
-        : `Obsolete final Review already settled: ${result.round.id}/${result.turn.id}\n`, { reviewRound: result.round, reviewTurn: result.turn });
+        ? `Settled obsolete final Review ${result.round.id} from failed AgentRun ${result.run.id}\n`
+        : `Obsolete final Review already settled: ${result.round.id}/${result.run.id}\n`, { reviewRound: result.round, reviewRun: result.run });
 }
-function retryTurn(args, store, options) {
-    exactPositionals(args, 1, "Task turn retry usage: yui task turn retry <task>/<turn>.");
+function retryRun(args, store, options) {
+    exactPositionals(args, 1, "Task turn retry usage: yui task run retry <task>/<run>.");
     const now = clock(options);
-    const previous = store.transaction((tx) => requireTurn(tx, args[0], options));
+    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
     if (previous.purpose === "review") {
         return retryFailedReviewRun(previous, store, options, now);
     }
     const retried = store.transaction((tx) => {
         if (previous.status !== "failed") {
-            throw usageError(`Turn ${previous.id} is not retryable from ${previous.status}.`);
+            throw usageError(`AgentRun ${previous.id} is not retryable from ${previous.status}.`);
         }
         const task = requireTask(tx, previous.taskId);
-        if (task.status !== "active")
-            throw usageError(`Task is not active: ${task.id}.`);
-        assertTaskExecutionEnabled(task, "retrying a Turn");
+        assertTaskExecutionEnabled(task, "retrying a AgentRun");
+        if (!runPurposeAdmitsTaskState(previous.purpose, task)) {
+            throw usageError(`Task does not admit ${previous.purpose} retry: ${task.id}/${task.status}.`);
+        }
         const role = requireRole(tx, task.id, previous.roleName);
-        if (tx.getActiveTurn(task.id, role.name) !== null) {
-            throw usageError(`${task.id}/${role.name} already has an active turn.`);
+        if (tx.getActiveRun(task.id, role.name) !== null) {
+            throw usageError(`${task.id}/${role.name} already has an active run.`);
         }
         const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
         const retryItem = previous.workItemId === undefined
             ? null
             : tx.getWorkItem(task.id, previous.workItemId);
         if (previous.workItemId !== undefined && retryItem === null) {
-            throw dataError(`Work item not found for Turn ${previous.id}: ${previous.workItemId}.`);
+            throw dataError(`Work item not found for AgentRun ${previous.id}: ${previous.workItemId}.`);
         }
         const retriesSynthesisMain = previous.sourceExecutionGroupId !== undefined;
         if (retriesSynthesisMain
             && (previous.executionGroupId !== undefined || previous.executionLaneId !== undefined)) {
-            throw dataError(`Turn ${previous.id} has conflicting execution lineage.`);
+            throw dataError(`AgentRun ${previous.id} has conflicting execution lineage.`);
         }
         const retryLaneBefore = previous.executionLaneId === undefined
             ? undefined
@@ -3796,57 +4440,54 @@ function retryTurn(args, store, options) {
             && retryLaneBefore !== undefined
             && retryLaneBefore.id === previous.executionLaneId
             && retryLaneBefore.disposition === "open"
-            && retryLaneBefore.currentTurnId === previous.id);
+            && retryLaneBefore.currentRunId === previous.id);
         if (!exactCurrentLane) {
-            throw usageError(`Turn ${previous.id} no longer owns the current failed Execution Lane.`);
+            throw usageError(`AgentRun ${previous.id} no longer owns the current failed Execution Lane.`);
         }
         const sourceGroup = !retriesSynthesisMain || retryItem === null
             ? undefined
             : workItemExecutionGroupById(retryItem, previous.sourceExecutionGroupId);
-        const sourceMainTurns = retriesSynthesisMain
-            ? chronologicalTurns(tx.listTurns(task.id).filter((turn) => (turn.purpose === "execution"
-                && turn.workItemId === previous.workItemId
-                && turn.sourceExecutionGroupId === previous.sourceExecutionGroupId)))
+        const sourceMainRuns = retriesSynthesisMain
+            ? chronologicalRuns(tx.listRuns(task.id).filter((run) => (run.purpose === "execution"
+                && run.workItemId === previous.workItemId
+                && run.sourceExecutionGroupId === previous.sourceExecutionGroupId)))
             : [];
         const exactSourceMain = !retriesSynthesisMain || (retryItem !== null
-            && retryItem.status === "running"
+            && retryItem.status === "open"
             && retryItem.assignee === previous.roleName
             && sourceGroup !== undefined
             && currentRetryGroup?.id === sourceGroup.id
-            && workItemExecutionGroupSettled(sourceGroup)
-            && successfulWorkItemSynthesisProducers(tx, retryItem, sourceGroup).length
-                >= MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
-            && sourceMainTurns.at(-1)?.id === previous.id);
+            && selectedWorkItemSynthesisProducers(tx, retryItem, sourceGroup, synthesisSourceRunIds(tx, previous)).length > 0
+            && sourceMainRuns.at(-1)?.id === previous.id);
         if (!exactSourceMain) {
-            throw usageError(`Turn ${previous.id} no longer owns the current WorkItem main synthesis.`);
+            throw usageError(`AgentRun ${previous.id} no longer owns the current WorkItem main synthesis.`);
         }
-        const directMainTurns = retryItem === null
+        const directMainRuns = retryItem === null
             ? []
-            : chronologicalTurns(tx.listTurns(task.id).filter((turn) => (turn.purpose === "execution"
-                && turn.workItemId === retryItem.id
-                && turn.executionGroupId === undefined
-                && turn.executionLaneId === undefined
-                && turn.sourceExecutionGroupId === undefined)));
+            : chronologicalRuns(tx.listRuns(task.id).filter((run) => (run.purpose === "execution"
+                && run.workItemId === retryItem.id
+                && run.executionGroupId === undefined
+                && run.executionLaneId === undefined
+                && run.sourceExecutionGroupId === undefined)));
         const retriesDirectMain = retryItem !== null
             && !retriesExecutionLane
             && !retriesSynthesisMain;
-        const exactDirectMain = !retriesDirectMain || ((retryItem.status === "running" || retryItem.status === "failed")
+        const exactDirectMain = !retriesDirectMain || (retryItem.status === "open"
             && retryItem.assignee === previous.roleName
-            && directMainTurns.at(-1)?.id === previous.id);
+            && directMainRuns.at(-1)?.id === previous.id);
         if (!exactDirectMain) {
-            throw usageError(`Turn ${previous.id} no longer owns the current direct WorkItem execution.`);
+            throw usageError(`AgentRun ${previous.id} no longer owns the current direct WorkItem execution.`);
         }
-        const groupedRunningRetry = retryItem?.status === "running"
+        const groupedRunningRetry = retryItem?.status === "open"
             && retriesExecutionLane
             && exactCurrentLane;
-        const synthesisRunningRetry = retryItem?.status === "running"
+        const synthesisRunningRetry = retryItem?.status === "open"
             && retriesSynthesisMain
             && exactSourceMain;
-        const directRunningRetry = retryItem?.status === "running"
+        const directRunningRetry = retryItem?.status === "open"
             && retriesDirectMain
             && exactDirectMain;
         if (retryItem !== null
-            && retryItem.status !== "failed"
             && !groupedRunningRetry
             && !synthesisRunningRetry
             && !directRunningRetry) {
@@ -3873,7 +4514,7 @@ function retryTurn(args, store, options) {
                 && (retryGroup === undefined
                     || retryGroup.id !== previous.executionGroupId
                     || retryLane === undefined))) {
-            throw dataError(`Turn ${previous.id} execution lineage no longer matches its Work Item.`);
+            throw dataError(`AgentRun ${previous.id} execution lineage no longer matches its Work Item.`);
         }
         const retryManagedWorkspace = retryLane === undefined ? runWorkspace : previous.workspace;
         if (retryLane !== undefined) {
@@ -3893,7 +4534,7 @@ function retryTurn(args, store, options) {
                 || !isDeepStrictEqual(writableProjectIds, [...retryLane.workspace.writableProjectIds].sort())
                 || storedLaneWorkspace === null
                 || !isDeepStrictEqual(storedLaneWorkspace, previous.workspace)) {
-                throw dataError(`Turn ${previous.id} Lane workspace is missing or has drifted.`);
+                throw dataError(`AgentRun ${previous.id} Lane workspace is missing or has drifted.`);
             }
         }
         if (retriesSynthesisMain) {
@@ -3910,7 +4551,7 @@ function retryTurn(args, store, options) {
                 || currentMainWorkspace === null
                 || !isDeepStrictEqual(storedMainWorkspace, previous.workspace)
                 || !isDeepStrictEqual(currentMainWorkspace, previous.workspace)) {
-                throw dataError(`Turn ${previous.id} WorkItem main workspace is missing or has drifted.`);
+                throw dataError(`AgentRun ${previous.id} WorkItem main workspace is missing or has drifted.`);
             }
         }
         if (retriesDirectMain) {
@@ -3927,20 +4568,20 @@ function retryTurn(args, store, options) {
                 || currentDirectWorkspace === null
                 || !isDeepStrictEqual(storedDirectWorkspace, previous.workspace)
                 || !isDeepStrictEqual(currentDirectWorkspace, previous.workspace)) {
-                throw dataError(`Turn ${previous.id} direct WorkItem workspace is missing or has drifted.`);
+                throw dataError(`AgentRun ${previous.id} direct WorkItem workspace is missing or has drifted.`);
             }
         }
         const effective = retryLane?.effective ?? resolveEffectiveLaunch({
             role,
-            purpose: "execution",
+            purpose: previous.purpose,
             ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
             ...(retryItem === null ? {} : { workItemWriteProjectIds: retryItem.writeProjectIds })
         });
-        const turnId = tx.nextTurnId(task.id);
+        const runId = tx.nextRunId(task.id);
         const runningGroup = retryGroup === undefined || retryLane === undefined
             ? undefined
             : updateWorkItemExecutionLane(retryGroup, retryLane.id, {
-                currentTurnId: turnId
+                currentRunId: runId
             }, now);
         // Restart the bound lane and reopen the failed WorkItem as two ordered
         // single-step record revisions, matching the dispatch path. Folding both
@@ -3949,11 +4590,7 @@ function retryTurn(args, store, options) {
         const laneRestartedItem = retryItem === null || runningGroup === undefined
             ? retryItem
             : updateWorkItemExecutionGroup(retryItem, runningGroup, now);
-        const retriedItemWithGroup = laneRestartedItem === null
-            ? null
-            : laneRestartedItem.status === "failed"
-                ? retryFailedWorkItem(laneRestartedItem, now)
-                : laneRestartedItem;
+        const retriedItemWithGroup = laneRestartedItem;
         if (retriedItemWithGroup !== null) {
             if (laneRestartedItem !== null && laneRestartedItem !== retryItem) {
                 tx.saveWorkItem(task.id, laneRestartedItem);
@@ -3965,13 +4602,13 @@ function retryTurn(args, store, options) {
         const input = retriesSynthesisMain
             ? previous.inputs[0].input
             : (() => {
-                const retrySnapshot = freezeTurnContextSnapshot(tx, {
+                const retrySnapshot = freezeRunContextSnapshot(tx, {
                     taskId: task.id,
                     roleName: role.name,
-                    purpose: "execution",
+                    purpose: previous.purpose,
                     ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId })
                 }, now, "controller", retryGroup?.assignment.contextSnapshotRef);
-                return createTurnInput({
+                return createRunInput({
                     source: {
                         type: "yui",
                         channel: previous.workItemId === undefined ? "task-dispatch" : "workitem-dispatch"
@@ -3983,7 +4620,8 @@ function retryTurn(args, store, options) {
                     deltaRefIds: contextSnapshotDeltaRefIds(tx, retrySnapshot)
                 });
             })();
-        const created = createTurn(turnId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), input, now, {
+        const created = createRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), input, now, {
+            purpose: previous.purpose,
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
             ...(runningGroup === undefined ? {} : {
                 executionGroupId: runningGroup.id,
@@ -3995,8 +4633,8 @@ function retryTurn(args, store, options) {
             ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
             effective
         });
-        tx.saveTurn(created);
-        tx.saveActiveTurn(created);
+        tx.saveRun(created);
+        tx.saveActiveRun(created);
         if (previous.workItemId !== undefined && retriedItemWithGroup !== null) {
             const item = retriedItemWithGroup;
             const workspace = tx.getWorkItemWorkspace(task.id, item.id);
@@ -4006,21 +4644,21 @@ function retryTurn(args, store, options) {
                     + `cannot retry ${item.id}.`);
             }
         }
-        enqueueRoleTurnDispatch(tx, {
+        enqueueRoleRunDispatch(tx, {
             taskId: task.id,
             roleName: role.name,
-            turnId: created.id,
+            runId: created.id,
             reason: "turn-retried",
             occurredAt: now
         });
-        recordTaskEvent(tx, task.id, "turn.retried", {
-            ...turnLaunchEventPayload(created),
-            previousTurnId: previous.id
+        recordTaskEvent(tx, task.id, "run.retried", {
+            ...runLaunchEventPayload(created),
+            previousRunId: previous.id
         }, now);
-        return { kind: "turn", turn: created };
+        return { kind: "run", run: created };
     });
-    notifyMailbox(options.runtime, roleMailbox(retried.turn.taskId, retried.turn.roleName), retried.turn.taskId);
-    return output(`Retry queued as ${retried.turn.id} for ${retried.turn.taskId}/${retried.turn.roleName}\n`);
+    notifyMailbox(options.runtime, roleMailbox(retried.run.taskId, retried.run.roleName), retried.run.taskId);
+    return output(`Retry queued as ${retried.run.id} for ${retried.run.taskId}/${retried.run.roleName}\n`);
 }
 function actualTaskReviewCandidateForMutation(store, task, options) {
     if (options.actualTaskReviewCandidate === undefined) {
@@ -4063,7 +4701,7 @@ function taskReviewProducerCollision(provenance, reviewerRoleName) {
  *
  * When `expected` is supplied this is also the final dispatch compare-and-swap
  * fence: every bound Project must still point at the exact frozen physical
- * head. Drift fails closed before a Reviewer Turn is created.
+ * head. Drift fails closed before a Reviewer AgentRun is created.
  */
 function taskReviewProvenance(store, task, options, expected) {
     const candidate = actualTaskReviewCandidateForMutation(store, task, options);
@@ -4118,13 +4756,13 @@ function taskReviewProvenance(store, task, options, expected) {
                 recordProducer(LEADER_ROLE, item.id);
                 continue;
             }
-            const sourceRun = store.getTurn(task.id, sourceCandidate.source.turnId);
+            const sourceRun = store.getRun(task.id, sourceCandidate.source.runId);
             if (sourceRun === null
                 || sourceRun.workItemId !== item.id
                 || sourceRun.purpose !== "execution"
                 || sourceRun.status !== "completed") {
-                throw dataError(`Committed producer Candidate Turn is unavailable: `
-                    + `${item.id}/${sourceCandidate.source.turnId}.`);
+                throw dataError(`Committed producer Candidate AgentRun is unavailable: `
+                    + `${item.id}/${sourceCandidate.source.runId}.`);
             }
             recordProducer(sourceRun.roleName, item.id);
             if (sourceRun.sourceExecutionGroupId !== undefined) {
@@ -4133,7 +4771,7 @@ function taskReviewProvenance(store, task, options, expected) {
                     throw dataError(`Committed producer ExecutionGroup is unavailable: `
                         + `${item.id}/${sourceRun.sourceExecutionGroupId}.`);
                 }
-                for (const producer of successfulWorkItemSynthesisProducers(store, item, executionGroup)) {
+                for (const producer of selectedWorkItemSynthesisProducers(store, item, executionGroup, synthesisSourceRunIds(store, sourceRun))) {
                     recordProducer(producer.roleName, item.id);
                 }
             }
@@ -4182,7 +4820,7 @@ function queueTaskReviewRound(store, task, config, taskCandidate, options, now,
     const availability = projectReviewerAvailability(store, task.id, config.roleName);
     if (availability.kind === "busy") {
         throw usageError(`Reviewer ${config.roleName} is busy (${availability.phase}`
-            + `${availability.activeTurnId === undefined ? "" : `; Turn ${availability.activeTurnId}`}); `
+            + `${availability.activeRunId === undefined ? "" : `; AgentRun ${availability.activeRunId}`}); `
             + `retry after ${availability.retryAfterSeconds}s.`);
     }
     let reviewer = store.getRole(task.id, config.roleName);
@@ -4251,16 +4889,16 @@ function resumablePendingFinalTaskReview(store, task, round, config, taskCandida
         || round.reviewerRoleName !== taskFinalContract.reviewerRoleName) {
         throw usageError(`Pending final ReviewRound Reviewer identity changed: ${round.id}.`);
     }
-    if (round.reviewerTurnId !== undefined) {
-        throw usageError(`Pending final ReviewRound already records Reviewer Turn ${round.reviewerTurnId}: ${round.id}.`);
+    if (round.reviewerRunId !== undefined) {
+        throw usageError(`Pending final ReviewRound already records Reviewer AgentRun ${round.reviewerRunId}: ${round.id}.`);
     }
     assertNoConflictingTaskReviewRound(store.listReviewRounds(task.id), round.id, round.reviewerRoleName);
     const reviewer = store.getRole(task.id, round.reviewerRoleName);
     if (reviewer === null || reviewer.name !== round.reviewerRoleName) {
         throw usageError(`Pending final ReviewRound Reviewer identity changed: ${round.id}.`);
     }
-    if (store.getActiveTurn(task.id, reviewer.name) !== null) {
-        throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
+    if (store.getActiveRun(task.id, reviewer.name) !== null) {
+        throw usageError(`Reviewer Role already has an active AgentRun: ${reviewer.name}.`);
     }
     assertPendingFinalReviewWorkspaceEvidence(store, task, round);
     return round;
@@ -4296,7 +4934,7 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
     }
 }
 /**
- * Task-control retry of an exact failed review Turn. The old failed Turn
+ * Task-control retry of an exact failed review AgentRun. The old failed AgentRun
  * remains the attempt trail, while the 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
@@ -4304,12 +4942,12 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
  */
 function retryFailedReviewRun(previous, store, options, now) {
     const result = store.transaction((tx) => {
-        const run = tx.getTurn(previous.taskId, previous.id);
+        const run = tx.getRun(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "review") {
-            throw usageError(`Turn ${previous.id} is not a failed review Turn.`);
+            throw usageError(`AgentRun ${previous.id} is not a failed review AgentRun.`);
         }
         if (run.reviewRoundId === undefined) {
-            throw usageError(`Review Turn ${run.id} has no ReviewRound.`);
+            throw usageError(`Review AgentRun ${run.id} has no ReviewRound.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -4325,16 +4963,16 @@ function retryFailedReviewRun(previous, store, options, now) {
             : round.executionGroup?.lanes.find(({ id }) => id === run.executionLaneId);
         if (run.executionGroupId !== undefined && (round.executionGroup?.id !== run.executionGroupId
             || retryLane === undefined
-            || retryLane.currentTurnId !== run.id
+            || retryLane.currentRunId !== run.id
             || retryLane.roleName !== run.roleName)) {
-            throw usageError(`Review Turn ${run.id} no longer owns its exact Review Lane attempt.`);
+            throw usageError(`Review AgentRun ${run.id} no longer owns its exact Review Lane attempt.`);
         }
         const panelGroup = round.executionGroup !== undefined;
         const runningPanelLaneRetry = round.status === "running"
             && panelGroup
             && retryLane?.disposition === "open";
         if (round.status === "running" && panelGroup && !runningPanelLaneRetry) {
-            throw usageError(`Review Turn ${run.id} is not the current failed Lane attempt in running Round ${round.id}.`);
+            throw usageError(`Review AgentRun ${run.id} is not the current failed Lane attempt in running Round ${round.id}.`);
         }
         const retryReviewerRoleName = retryLane?.roleName ?? round.reviewerRoleName;
         if (round.status !== "failed"
@@ -4370,10 +5008,10 @@ function retryFailedReviewRun(previous, store, options, now) {
                 throw dataError(`WorkItem ReviewRound has no Candidate anchor: ${round.id}.`);
             }
             if (run.workItemId !== round.workItemId) {
-                throw usageError(`Review Turn ${run.id} does not match WorkItem ${round.workItemId}.`);
+                throw usageError(`Review AgentRun ${run.id} does not match WorkItem ${round.workItemId}.`);
             }
             const item = tx.getWorkItem(task.id, round.workItemId);
-            if (item === null || item.status !== "awaiting_acceptance") {
+            if (item === null || (item.status !== "open" || item.candidates.length === 0)) {
                 throw usageError(`WorkItem ReviewRound ${round.id} no longer has an awaiting Candidate.`);
             }
             const candidate = currentWorkItemCandidate(item);
@@ -4412,20 +5050,20 @@ function retryFailedReviewRun(previous, store, options, now) {
             throw usageError(`Reviewer already has an active review round for this candidate: ${activeRound.id}.`);
         }
         const reviewer = requireRole(tx, task.id, retryReviewerRoleName);
-        const activePointer = tx.getActiveTurn(task.id, reviewer.name);
+        const activePointer = tx.getActiveRun(task.id, reviewer.name);
         // Issue 06: a completed same-Round retry is a no-write idempotent result.
         if (round.status === "completed") {
             assertReviewerAvailable(tx, task.id, reviewer.name);
             return { round, previousRun: run, created: false };
         }
         // Issue 06: a running same Round is reusable only with its exact active
-        // Turn. A stranded Turn (no active pointer) falls through and resets the
+        // AgentRun. A stranded AgentRun (no active pointer) falls through and resets the
         // Round after the identity fences below.
         if (round.status === "running" && !runningPanelLaneRetry) {
-            const reviewerTurnId = round.reviewerTurnId;
-            const activeMatches = reviewerTurnId !== undefined
+            const reviewerRunId = round.reviewerRunId;
+            const activeMatches = reviewerRunId !== undefined
                 && activePointer !== null
-                && activePointer.id === reviewerTurnId
+                && activePointer.id === reviewerRunId
                 && activePointer.status === "active";
             if (activePointer !== null && !activeMatches) {
                 throw usageError(`Existing running ReviewRound ${round.id} lacks its exact active Reviewer execution.`);
@@ -4438,24 +5076,65 @@ function retryFailedReviewRun(previous, store, options, now) {
         // Issue 06: an already-pending Round is the idempotent retry result.
         if (round.status === "pending") {
             if (activePointer !== null) {
-                throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
+                throw usageError(`Reviewer Role already has an active AgentRun: ${reviewer.name}.`);
             }
             assertReviewerAvailable(tx, task.id, reviewer.name, round);
             return { round, previousRun: run, created: false };
         }
         if (activePointer !== null) {
-            throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
+            throw usageError(`Reviewer Role already has an active AgentRun: ${reviewer.name}.`);
         }
         assertReviewerAvailable(tx, task.id, reviewer.name, round);
-        const validation = validateExactTurnReviewRound(tx, run, { allowTerminal: true });
+        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
         if (validation.disposition !== "applied" || validation.round === null) {
-            throw usageError(`Review Turn ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
+            throw usageError(`Review AgentRun ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
+        }
+        if (run.sourceExecutionGroupId !== undefined) {
+            assertTaskExecutionEnabled(task, "retrying Review synthesis");
+            const group = round.executionGroup;
+            if (round.status !== "failed" || round.reviewerRunId !== run.id
+                || group?.id !== run.sourceExecutionGroupId
+                || run.workspace === undefined) {
+                throw usageError(`Review AgentRun ${run.id} no longer owns the current main synthesis.`);
+            }
+            selectedReviewSynthesisProducers(tx, round, group, synthesisSourceRunIds(tx, run));
+            const effective = resolveEffectiveLaunch({
+                role: reviewer,
+                purpose: "review",
+                workspace: run.workspace,
+                reviewRoundId: round.id,
+                reviewBaseCommit: round.reviewBaseCommit
+            });
+            const created = createRun(tx.nextRunId(task.id), task.id, reviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(task.id, reviewer.name), effective.agentId, effective), run.inputs[0].input, now, {
+                purpose: "review",
+                ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+                reviewRoundId: round.id,
+                sourceExecutionGroupId: group.id,
+                workspace: run.workspace,
+                effective
+            });
+            const restarted = startReviewRound(retryReviewRound(round, requestedBy, now), created.id);
+            tx.saveReviewRound(task.id, restarted);
+            tx.saveRun(created);
+            tx.saveActiveRun(created);
+            enqueueRoleRunDispatch(tx, {
+                taskId: task.id,
+                roleName: reviewer.name,
+                runId: created.id,
+                reason: "turn-retried",
+                occurredAt: now
+            });
+            recordTaskEvent(tx, task.id, "run.review-retried", {
+                ...runLaunchEventPayload(created),
+                previousRunId: run.id
+            }, now);
+            return { round: restarted, previousRun: run, created: true, run: created };
         }
         if (runningPanelLaneRetry) {
             const resetRound = retryRunningReviewExecutionLane(round, retryLane.id, run.id);
             tx.saveReviewRound(task.id, resetRound);
-            recordTaskEvent(tx, task.id, "turn.review-retried", {
-                turnId: run.id,
+            recordTaskEvent(tx, task.id, "run.review-retried", {
+                runId: run.id,
                 reviewRoundId: round.id,
                 executionLaneId: retryLane.id
             }, now);
@@ -4465,7 +5144,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         // fence has passed. The outer transaction rolls back if Round creation fails.
         let roundToReset = round;
         if (round.status !== "failed") {
-            const summary = `Review Turn ${run.id} failed before delivery.`;
+            const summary = `Review AgentRun ${run.id} failed before delivery.`;
             roundToReset = finishReviewRound(round, "failed", now, { kind: "execution", message: summary });
             tx.saveReviewRound(task.id, roundToReset);
         }
@@ -4474,41 +5153,44 @@ function retryFailedReviewRun(previous, store, options, now) {
         // stable across execution-attempt failures.
         const resetRound = retryReviewRound(roundToReset, requestedBy, now);
         tx.saveReviewRound(task.id, resetRound);
-        recordTaskEvent(tx, task.id, "turn.review-retried", {
-            turnId: run.id,
+        recordTaskEvent(tx, task.id, "run.review-retried", {
+            runId: run.id,
             reviewRoundId: round.id
         }, now);
         return { round: resetRound, previousRun: run, created: true };
     });
+    if ("run" in result && result.run !== undefined) {
+        notifyMailbox(options.runtime, roleMailbox(result.run.taskId, result.run.roleName), result.run.taskId);
+    }
     return output(result.created
         ? `Review retry requested as ${result.round.id}\n`
-        : `Review retry already requested as ${result.round.id} (${result.round.status})\n`, { reviewRound: result.round });
+        : `Review retry already requested as ${result.round.id} (${result.round.status})\n`, { reviewRound: result.round, ...("run" in result ? { run: result.run } : {}) });
 }
-/** Turn details are retained audit evidence; continuation uses durable Task state. */
-function showTurn(args, store, options) {
-    const usage = "Task turn show usage: yui task turn show <task>/<turn> [--json].";
+/** AgentRun details are retained audit evidence; continuation uses durable Task state. */
+function showRun(args, store, options) {
+    const usage = "Task turn show usage: yui task run show <task>/<run> [--json].";
     const asJson = args.includes("--json");
     const positionals = args.filter((arg) => arg !== "--json");
     exactPositionals(positionals, 1, usage);
     const data = store.transaction((tx) => {
-        const run = requireTurn(tx, positionals[0], options);
+        const run = requireRun(tx, positionals[0], options);
         const retirement = tx.listEvents(run.taskId)
             .map(taskRecordRetirement)
-            .find((entry) => entry?.recordKind === "turn" && entry.recordId === run.id) ?? null;
-        return { turn: run, retirement };
+            .find((entry) => entry?.recordKind === "run" && entry.recordId === run.id) ?? null;
+        return { run: run, retirement, execution: runExecutionObservation(run, tx.getTaskRoleSessionSet(run.taskId, run.roleName)?.providerBinding, tx.listEvents(run.taskId)) };
     });
     if (asJson) {
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }
     return {
         kind: "output",
-        output: renderTurnShow(data.turn, data.retirement),
+        output: `Delivery observation: ${data.execution.delivery}\n` + renderRunShow(data.run, data.retirement),
         data
     };
 }
-function renderTurnShow(run, retirement) {
+function renderRunShow(run, retirement) {
     const lines = [
-        `Turn: ${run.id}`,
+        `AgentRun: ${run.id}`,
         `Task: ${run.taskId}`,
         `Role: ${run.roleName}`,
         `Purpose: ${run.purpose}`,
@@ -4531,40 +5213,40 @@ function renderTurnShow(run, retirement) {
     return `${lines.join("\n")}\n`;
 }
 /**
- * Records a structured progress checkpoint for an active Turn. This is a durable
- * Turn fact, not a Task Message: it advances the Turn's durable-progress clock so
- * a healthy but long-running Turn keeps proving it is alive without adding
- * collaboration-narrative noise. It never completes, mutates the Turn, or wakes the
+ * Records a structured progress checkpoint for an active AgentRun. This is a durable
+ * AgentRun fact, not a Task Message: it advances the AgentRun's durable-progress clock so
+ * a healthy but long-running AgentRun keeps proving it is alive without adding
+ * collaboration-narrative noise. It never completes, mutates the AgentRun, or wakes the
  * Leader.
  */
-function checkpointTurn(args, store, options) {
-    const usage = "Task turn checkpoint usage: yui task turn checkpoint <turn> (--note <text>|--note-file <path|->).";
+function checkpointRun(args, store, options) {
+    const usage = "Task turn checkpoint usage: yui task run checkpoint <run> (--note <text>|--note-file <path|->).";
     const parsed = parseTail(args, new Set(["--note", "--note-file"]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const note = readCommandText(parsed.options.get("--note"), parsed.options.get("--note-file"), "--note", usage);
     const now = clock(options);
     const event = store.transaction((tx) => {
-        const run = requireTurn(tx, parsed.positionals[0], options);
+        const run = requireRun(tx, parsed.positionals[0], options);
         if (run.status !== "active") {
-            throw usageError(`Turn ${run.id} is already terminal: ${run.status}.`);
+            throw usageError(`AgentRun ${run.id} is already terminal: ${run.status}.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
-            throw usageError(inactiveTaskMessage(task, "checkpointing a Turn"));
-        const pointer = activeTurnPointer(tx, run);
+            throw usageError(inactiveTaskMessage(task, "checkpointing a AgentRun"));
+        const pointer = activeRunPointer(tx, run);
         if (pointer?.id !== run.id) {
-            throw usageError(`Turn is not active for ${task.id}/${run.roleName}: ${run.id}.`);
+            throw usageError(`AgentRun is not active for ${task.id}/${run.roleName}: ${run.id}.`);
         }
         const events = tx.listEvents(task.id);
-        const recovered = isRoleTurnStalled(events, run.id);
-        const progress = recordTaskEventRecord(tx, task.id, TURN_PROGRESS_EVENT, {
-            turnId: run.id,
+        const recovered = isRoleRunStalled(events, run.id);
+        const progress = recordTaskEventRecord(tx, task.id, RUN_PROGRESS_EVENT, {
+            runId: run.id,
             note: truncateEventNote(note),
             ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId })
         }, now);
         if (recovered) {
-            recordTaskEventRecord(tx, task.id, TURN_RECOVERED_EVENT, {
-                turnId: run.id,
+            recordTaskEventRecord(tx, task.id, RUN_RECOVERED_EVENT, {
+                runId: run.id,
                 roleName: run.roleName,
                 progressAt: now.toISOString(),
                 kind: "checkpoint"
@@ -4612,12 +5294,12 @@ export function queueReviewRound(store, item, config, requestedBy, now, requeste
             reviewer = createTaskRole(store, task, roleName, undefined, now, roleName);
             store.saveRole(task.id, reviewer);
         }
-        if (store.getActiveTurn(item.taskId, reviewer.name) !== null) {
+        if (store.getActiveRun(item.taskId, reviewer.name) !== null) {
             const pending = createPending();
             store.saveReviewRound(item.taskId, pending);
             const failed = finishReviewRound(pending, "failed", now, {
                 kind: "dispatch",
-                message: `Reviewer Role already has an active Turn: ${reviewer.name}.`
+                message: `Reviewer Role already has an active AgentRun: ${reviewer.name}.`
             });
             store.saveReviewRound(item.taskId, failed);
             return { round: failed };
@@ -4757,8 +5439,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 && round.reviewerRoleName !== taskFinalContract.reviewerRoleName) {
                 throw new TaskFinalReviewDispatchDriftError(`Task final-review Reviewer identity does not match ReviewRound ${round.id}.`);
             }
-            if (round.status === "pending" && round.reviewerTurnId !== undefined) {
-                throw new TaskFinalReviewDispatchDriftError(`Pending final ReviewRound already records Reviewer Turn ${round.reviewerTurnId}: `
+            if (round.status === "pending" && round.reviewerRunId !== undefined) {
+                throw new TaskFinalReviewDispatchDriftError(`Pending final ReviewRound already records Reviewer AgentRun ${round.reviewerRunId}: `
                     + `${round.id}.`);
             }
             let currentTaskCandidate;
@@ -4810,8 +5492,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 && (requestedReviewers.has(entry.reviewerRoleName)
                     || entry.executionGroup?.lanes.some(({ roleName }) => (requestedReviewers.has(roleName))) === true)
                 && !(entry.status === "running"
-                    && entry.reviewerTurnId !== undefined
-                    && tx.getTurn(task.id, entry.reviewerTurnId)?.status === "failed")));
+                    && entry.reviewerRunId !== undefined
+                    && tx.getRun(task.id, entry.reviewerRunId)?.status === "failed")));
             if (conflicting !== undefined) {
                 throw new TaskFinalReviewDispatchDriftError(`Another active Task-final ReviewRound already exists: ${conflicting.id}/${conflicting.reviewerRoleName}.`);
             }
@@ -4838,8 +5520,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         }
         const candidateLabel = taskScope
             ? "frozen Task candidate"
-            : candidate.source.type === "turn"
-                ? `candidate Turn ${candidate.source.turnId}`
+            : candidate.source.type === "run"
+                ? `candidate AgentRun ${candidate.source.runId}`
                 : `revision ${candidate.workItemRevision}`;
         const frozenHeads = taskScope
             ? round.taskCandidate.projects
@@ -4854,7 +5536,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             }
             const diffByProject = options.deltaRecheckDiff;
             if (diffByProject === undefined) {
-                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck diff is missing for ${round.id}; the CLI preflight did not turn.`);
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck diff is missing for ${round.id}; the CLI preflight did not run.`);
             }
             try {
                 verifyDeltaRecheckDiff(round.deltaRecheck, diffByProject);
@@ -4898,17 +5580,17 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             "You may freely edit source/tests, run local build or test commands, and optionally commit diagnostic evidence only inside this stable Reviewer workspace at the exact ReviewRound snapshot.",
             "Do not push, integrate, mutate Task state, touch the Candidate or Worker workspace, another Task/workspace, a stable checkout, or the real Yui control-plane home.",
             "End the Provider turn with one complete original result in clear Markdown or JSON. Recommended sections are conclusion, material findings, checks actually run, uncertainty, and next actions. Yui preserves the text verbatim and does not parse or validate those sections.",
-            "Report reviewBaseCommit, exact checks/results, material findings, and uncertainty. This Turn result completes only the Round and creates no Candidate or ChangeSet.",
+            "Report reviewBaseCommit, exact checks/results, material findings, and uncertainty. This AgentRun result completes only the Round and creates no Candidate or ChangeSet.",
             "The Leader alone interprets and routes evidence: original Worker when open, a small Repair WorkItem when needed, or Leader/Integration for merge and local fixes; never merge review evidence yourself."
         ].join("\n");
-        const createdTurns = [];
+        const createdRuns = [];
         if (round.executionGroup === undefined) {
             if (round.status !== "pending")
-                return createdTurns;
-            if (tx.getActiveTurn(taskId, reviewer.name) !== null) {
-                throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
+                return createdRuns;
+            if (tx.getActiveRun(taskId, reviewer.name) !== null) {
+                throw usageError(`Reviewer Role already has an active AgentRun: ${reviewer.name}.`);
             }
-            const turnId = tx.nextTurnId(taskId);
+            const runId = tx.nextRunId(taskId);
             const effective = resolveEffectiveLaunch({
                 role: reviewer,
                 purpose: "review",
@@ -4916,14 +5598,14 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 reviewRoundId: round.id,
                 reviewBaseCommit: round.reviewBaseCommit
             });
-            const snapshot = freezeTurnContextSnapshot(tx, {
+            const snapshot = freezeRunContextSnapshot(tx, {
                 taskId,
                 roleName: reviewer.name,
                 purpose: "review",
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 reviewRoundId: round.id
             }, now, "controller");
-            const created = createTurn(turnId, taskId, reviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(taskId, reviewer.name), effective.agentId, effective), createTurnInput({
+            const created = createRun(runId, taskId, reviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(taskId, reviewer.name), effective.agentId, effective), createRunInput({
                 source: {
                     type: "yui",
                     channel: item === undefined ? "task-dispatch" : "workitem-dispatch"
@@ -4938,27 +5620,27 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 workspace: round.workspace,
                 effective
             });
-            tx.saveTurn(created);
+            tx.saveRun(created);
             tx.saveReviewRound(taskId, startReviewRound(round, created.id));
-            tx.saveActiveTurn(created);
-            enqueueRoleTurnDispatch(tx, {
+            tx.saveActiveRun(created);
+            enqueueRoleRunDispatch(tx, {
                 taskId,
                 roleName: reviewer.name,
-                turnId: created.id,
+                runId: created.id,
                 reason: "review-requested",
                 occurredAt: now
             });
-            recordTaskEvent(tx, taskId, "turn.review-dispatched", turnLaunchEventPayload(created), now);
-            createdTurns.push(created);
-            return createdTurns;
+            recordTaskEvent(tx, taskId, "run.review-dispatched", runLaunchEventPayload(created), now);
+            createdRuns.push(created);
+            return createdRuns;
         }
         let runningGroup = round.executionGroup;
         const dispatchLanes = runningGroup.lanes.filter((lane) => {
             if (lane.disposition !== "open")
                 return false;
-            if (lane.currentTurnId === undefined)
+            if (lane.currentRunId === undefined)
                 return true;
-            return tx.getTurn(taskId, lane.currentTurnId)?.status === "failed";
+            return tx.getRun(taskId, lane.currentRunId)?.status === "failed";
         });
         const preparedLaneWorkspaces = requireIsolatedReviewLaneWorkspaces(tx, round, dispatchLanes, options.executionLaneWorkspaces);
         for (const lane of dispatchLanes) {
@@ -4966,8 +5648,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             if (laneReviewer === null) {
                 throw usageError(`Review Producer Role not found: ${taskId}/${lane.roleName}.`);
             }
-            if (tx.getActiveTurn(taskId, lane.roleName) !== null) {
-                throw usageError(`Review Producer Role already has an active Turn: ${lane.roleName}.`);
+            if (tx.getActiveRun(taskId, lane.roleName) !== null) {
+                throw usageError(`Review Producer Role already has an active AgentRun: ${lane.roleName}.`);
             }
             const laneManagedWorkspace = preparedLaneWorkspaces.get(lane.id);
             const effective = lane.effective ?? resolveEffectiveLaunch({
@@ -4977,8 +5659,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 reviewRoundId: round.id,
                 reviewBaseCommit: round.reviewBaseCommit
             });
-            const turnId = tx.nextTurnId(taskId);
-            const input = createTurnInput({
+            const runId = tx.nextRunId(taskId);
+            const input = createRunInput({
                 source: {
                     type: "yui",
                     channel: item === undefined ? "task-dispatch" : "workitem-dispatch"
@@ -5000,7 +5682,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 deltaRefIds: []
             });
             runningGroup = updateUnifiedExecutionLane(runningGroup, lane.id, {
-                currentTurnId: turnId,
+                currentRunId: runId,
                 effective,
                 workspace: {
                     root: laneManagedWorkspace.root,
@@ -5009,7 +5691,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                         .map(({ projectId }) => projectId)
                 }
             }, now);
-            createdTurns.push(createTurn(turnId, taskId, laneReviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(taskId, laneReviewer.name), effective.agentId, effective), input, now, {
+            createdRuns.push(createRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(tx.getTaskRoleSessionSet(taskId, laneReviewer.name), effective.agentId, effective), input, now, {
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 purpose: "review",
                 reviewRoundId: round.id,
@@ -5031,32 +5713,30 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                     tx.saveManagedWorkspace(prepared);
             }
         }
-        for (let index = 0; index < createdTurns.length; index += 1) {
-            const unboundTurn = createdTurns[index];
-            const snapshot = freezeTurnContextSnapshot(tx, {
+        for (let index = 0; index < createdRuns.length; index += 1) {
+            const unboundRun = createdRuns[index];
+            const snapshot = freezeRunContextSnapshot(tx, {
                 taskId,
-                roleName: unboundTurn.roleName,
+                roleName: unboundRun.roleName,
                 purpose: "review",
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 reviewRoundId: round.id
             }, now, "controller", runningGroup.assignment.contextSnapshotRef);
-            const created = withTurnContextSnapshot(unboundTurn, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            createdTurns[index] = created;
-            const laneReviewer = requireRole(tx, taskId, unboundTurn.roleName);
-            tx.saveTurn(created);
-            tx.saveActiveTurn(created);
-            enqueueRoleTurnDispatch(tx, {
+            const created = withRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            createdRuns[index] = created;
+            const laneReviewer = requireRole(tx, taskId, unboundRun.roleName);
+            tx.saveRun(created);
+            tx.saveActiveRun(created);
+            enqueueRoleRunDispatch(tx, {
                 taskId,
                 roleName: laneReviewer.name,
-                turnId: created.id,
+                runId: created.id,
                 reason: "review-requested",
                 occurredAt: now
             });
-            recordTaskEvent(tx, taskId, "turn.review-dispatched", turnLaunchEventPayload(created), now);
+            recordTaskEvent(tx, taskId, "run.review-dispatched", runLaunchEventPayload(created), now);
         }
-        const reconciliation = reconcileReviewMainTurns(tx, taskId, now);
-        createdTurns.push(...reconciliation.createdTurns);
-        return createdTurns;
+        return createdRuns;
     });
     for (const run of runs) {
         notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
@@ -5106,6 +5786,28 @@ function requireWorkItemCandidate(item) {
     }
     return candidate;
 }
+/**
+ * Parse `--artifact-ref git:<commit>:<relativePath>` selectors into canonical
+ * commit-pinned references for the given Task. This is a PURE shape check with
+ * no Git or DB I/O: the commit self-certifies the frozen bytes, so a valid
+ * pinned reference is complete evidence. The bytes are proven to exist lazily
+ * when they are resolved on the async read/context path.
+ */
+function fixedArtifactRefs(taskId, refs) {
+    if (new Set(refs).size !== refs.length)
+        throw usageError("Artifact references must be unique.");
+    return refs.map((ref) => {
+        if (!isGitArtifactRefString(ref)) {
+            throw usageError("Artifact reference must be a commit-pinned git:<commit>:<relativePath> reference.");
+        }
+        try {
+            return parseGitArtifactRef(ref, taskId);
+        }
+        catch (error) {
+            throw usageError(`Artifact reference is invalid: ${messageOf(error)}`);
+        }
+    });
+}
 /** ReviewRound ids are the durable Task-local creation order; wall time is not causal. */
 function reviewRoundsByIdentity(rounds) {
     return [...rounds].sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })));
@@ -5118,7 +5820,9 @@ function activeReviewRoundForCandidate(store, item, candidate) {
         .at(-1);
 }
 function createTaskRole(store, task, roleName, explicitAgentId, now, sourceGlobalRoleName) {
-    const workspace = task.cwd ?? store.getConfig().defaultWorkspace ?? process.cwd();
+    const workspace = task.status === "draft"
+        ? join(`${store.rootDirectory()}.task-runtimes`, "planning", task.id)
+        : task.cwd ?? store.getConfig().defaultWorkspace ?? process.cwd();
     if (explicitAgentId === undefined) {
         const sourceRoleName = sourceGlobalRoleName
             ?? (roleName === LEADER_ROLE ? LEADER_ROLE : "worker");
@@ -5136,7 +5840,7 @@ function createTaskRole(store, task, roleName, explicitAgentId, now, sourceGloba
         throw dataError(`No Agent is configured for Task role: ${roleName}.`);
     }
     const agent = requireAgent(store, agentId);
-    const binding = createRoleAgentBinding({ id: agent.id, adapterId: agent.adapterId });
+    const binding = createRoleAgentBinding(agent);
     return createRole(task.id, roleName, [binding], agent.id, workspace, now);
 }
 function requireAgentProfile(store, id) {
@@ -5146,7 +5850,9 @@ function requireAgentProfile(store, id) {
     return profile;
 }
 function createTaskRoleFromAgentBinding(store, task, roleName, binding, now) {
-    const workspace = task.cwd ?? store.getConfig().defaultWorkspace ?? process.cwd();
+    const workspace = task.status === "draft"
+        ? join(`${store.rootDirectory()}.task-runtimes`, "planning", task.id)
+        : task.cwd ?? store.getConfig().defaultWorkspace ?? process.cwd();
     return createRole(task.id, roleName, [binding], binding.agentId, workspace, now);
 }
 function resolvedAgentProfileRuntime(profile, store) {
@@ -5174,7 +5880,7 @@ function resolveTaskRoleAgentBindingAdd(parsed, profile, store) {
         if (explicitAgentId === undefined)
             return undefined;
         const agent = requireAgent(store, explicitAgentId);
-        binding = createRoleAgentBinding({ id: agent.id, adapterId: agent.adapterId });
+        binding = createRoleAgentBinding(agent);
     }
     if (hasAgentConfigOptions(parsed)) {
         binding = patchRoleAgentBinding(binding, parsed);
@@ -5185,11 +5891,6 @@ function resolveTaskRoleAgentBindingUpdate(parsed, role, profile, store) {
     const changesAgentConfig = hasAgentConfigOptions(parsed);
     const explicitAgentId = parsed.one("--agent")?.trim();
     const targetAgentId = explicitAgentId || role.activeAgentId;
-    if (profile?.runtime.source === "global-worker"
-        && explicitAgentId === undefined
-        && !changesAgentConfig) {
-        return undefined;
-    }
     let binding;
     if (profile !== undefined) {
         const profileRuntime = resolvedAgentProfileRuntime(profile, store);
@@ -5208,7 +5909,7 @@ function resolveTaskRoleAgentBindingUpdate(parsed, role, profile, store) {
             return undefined;
         const agent = requireAgent(store, targetAgentId);
         binding = role.agentBindings[targetAgentId]
-            ?? createRoleAgentBinding({ id: agent.id, adapterId: agent.adapterId });
+            ?? createRoleAgentBinding(agent);
     }
     if (changesAgentConfig) {
         binding = patchRoleAgentBinding(binding, parsed);
@@ -5245,7 +5946,7 @@ function appendMessage(store, taskId, body, kind, author, now, context = {}) {
     recordTaskEvent(store, taskId, "message.sent", {
         messageId: message.id,
         kind: message.kind,
-        ...(message.turnId === undefined ? {} : { turnId: message.turnId })
+        ...(message.runId === undefined ? {} : { runId: message.runId })
     }, now);
     return message;
 }
@@ -5253,43 +5954,29 @@ function recordTaskEvent(store, taskId, type, payload, now) {
     return recordTaskEventRecord(store, taskId, type, payload, now);
 }
 function leaderActionEventPayload(store, taskId, options) {
-    const turnId = taskLeaderActionTurnId(store, taskId, options.environment);
-    return turnId === undefined ? {} : { leaderTurnId: turnId };
+    const caller = currentManagedRuntime(store, options.environment, taskId, "leader");
+    // A long-lived Session may be handling direct input while another request
+    // awaits admission. The Role's active pointer cannot prove command origin.
+    return caller === undefined ? {} : { leaderNativeSessionId: caller.nativeSessionId };
 }
 function recordTaskEventRecord(store, taskId, type, payload, now) {
     const event = createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now);
     store.saveEvent(taskId, event);
     return event;
 }
-/** Keeps a free-text Turn-fact note bounded so an event payload stays compact. */
+/** Keeps a free-text AgentRun-fact note bounded so an event payload stays compact. */
 function truncateEventNote(note) {
     const normalized = note.trim();
     return normalized.length <= 280 ? normalized : `${normalized.slice(0, 279)}…`;
 }
-function roleLaunchEventPayload(role, sessions) {
-    const effective = sessions?.sessions[sessions.activeAgentId]?.effective;
+function runLaunchEventPayload(run) {
     return {
-        desiredRevision: String(role.launchRevision),
-        defaultAccess: role.defaultAccess,
-        effectiveRevision: effective === undefined
-            ? "none"
-            : String(effective.sourceDesiredRevision),
-        profileAccess: effective?.profileAccess ?? "none",
-        effectivePermission: effective?.permission.strategy ?? "none",
-        desiredDrift: effective === undefined
-            ? "not-started"
-            : effective.sourceDesiredRevision === role.launchRevision
-                ? "none"
-                : "pending-next-launch"
-    };
-}
-function turnLaunchEventPayload(run) {
-    return {
-        turnId: run.id,
+        runId: run.id,
         role: run.roleName,
         purpose: run.purpose,
         mode: run.mode,
         agent: `${run.effective.agentId}/${run.effective.adapterId}`,
+        component: run.effective.component,
         effectiveRevision: String(run.effective.sourceDesiredRevision),
         profileAccess: run.effective.profileAccess,
         effectivePermission: run.effective.permission.strategy,
@@ -5346,18 +6033,18 @@ function requireWorkItem(store, workItemId, options) {
     }
     return item;
 }
-function requireTurn(store, turnId, options) {
-    const reference = taskRecordReference(turnId, "turn", "Turn reference", options);
-    const run = store.getTurn(reference.taskId, reference.localId);
+function requireRun(store, runId, options) {
+    const reference = taskRecordReference(runId, "run", "AgentRun reference", options);
+    const run = store.getRun(reference.taskId, reference.localId);
     if (run === null) {
-        throw usageError(`Turn not found: ${reference.taskId}/${reference.localId}.`);
+        throw usageError(`AgentRun not found: ${reference.taskId}/${reference.localId}.`);
     }
     return run;
 }
-function activeTurnPointer(store, run) {
+function activeRunPointer(store, run) {
     return run.executionGroupId !== undefined && run.executionLaneId !== undefined
-        ? store.getActiveExecutionLaneTurn(run.taskId, run.executionGroupId, run.executionLaneId)
-        : store.getActiveTurn(run.taskId, run.roleName);
+        ? store.getActiveExecutionLaneRun(run.taskId, run.executionGroupId, run.executionLaneId)
+        : store.getActiveRun(run.taskId, run.roleName);
 }
 function requireReviewRound(store, reviewRoundId, options) {
     const reference = taskRecordReference(reviewRoundId, "reviewRound", "ReviewRound reference", options);
@@ -5392,12 +6079,12 @@ export function assertWorkItemDependenciesCompletedForCommand(store, item) {
         throw error;
     }
 }
-function chronologicalTurns(turns) {
-    return [...turns].sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
+function chronologicalRuns(runs) {
+    return [...runs].sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
         || left.id.localeCompare(right.id)));
 }
 function isTerminalWorkItemStatus(status) {
-    return ["completed", "failed", "retired"].includes(status);
+    return ["accepted", "retired"].includes(status);
 }
 function assertTaskOpen(task) {
     if (task.status === "completed") {
@@ -5405,7 +6092,7 @@ function assertTaskOpen(task) {
     }
     if (task.status === "archived")
         throw usageError(`Task is archived: ${task.id}.`);
-    if (task.status === "retired")
+    if (task.status === "cancelled")
         throw usageError(`Task is retired: ${task.id}.`);
 }
 function assertTaskExecutionEnabled(task, action) {
@@ -5423,7 +6110,7 @@ function inactiveTaskMessage(task, action) {
     if (task.status === "completed") {
         return `Task ${task.id} is completed; reopen it before ${action}.`;
     }
-    if (task.status === "retired")
+    if (task.status === "cancelled")
         return `Task ${task.id} is retired; it cannot resume ${action}.`;
     return `Task is archived: ${task.id}.`;
 }
@@ -5444,10 +6131,6 @@ function parseWorkStatus(value) {
     throw usageError(`Invalid work item status: ${value}.`);
 }
 function presentWorkStatus(status) {
-    if (status === "pending")
-        return "todo";
-    if (status === "completed")
-        return "done";
     return status;
 }
 function parseWorkCreateArgs(args, usage) {
@@ -5622,7 +6305,10 @@ function taskBriefCommand(args, store, options) {
                     ...(hasSummary ? { leaderSummary: parsed.options.get("--leader-summary") } : {})
                 }, updatedBy, now);
             tx.saveTaskBrief(task.id, brief);
-            recordTaskEvent(tx, task.id, "brief.updated", { updatedBy }, now);
+            recordTaskEvent(tx, task.id, "brief.updated", {
+                updatedBy,
+                previous: JSON.stringify(existing), current: JSON.stringify(brief)
+            }, now);
             enqueueWork(tx, taskMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
             if (task.status === "active" && updatedBy !== "leader") {
                 enqueueWork(tx, leaderMailbox(task.id), "brief-updated", now, [taskRef(task.id)]);
@@ -5633,12 +6319,18 @@ function taskBriefCommand(args, store, options) {
         if (result.task.status === "active") {
             notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
         }
-        return output(`Updated brief for ${result.task.id}\n`);
+        return output(`Updated brief for ${result.task.id}\n`, { taskId: result.task.id, brief: result.brief });
     }
     throw usageError(command === undefined
         ? "Task brief command is required."
         : `Unknown command: task brief ${command}`);
 }
+/** Persist only edited fields, not another copy of aggregate execution history.
+ * Null records an absent optional field so clearing it remains observable. */
+function editedFieldValues(record, fields) {
+    const values = record;
+    return JSON.stringify(Object.fromEntries(fields.map((field) => [field, values[field] ?? null])));
+}
 function taskDecisionCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "record") {
@@ -5889,14 +6581,11 @@ function taskContinuationCommand(args, store) {
         const report = [...continuation.reports].reverse()[0];
         const reportEvent = report === undefined
             ? undefined
-            : reportEvents.find((entry) => (entry.continuationId === identity.continuationId
-                && entry.continuationGeneration === identity.generation
-                && entry.reportId === report.reportId));
+            : reportEvents.find((entry) => (entry.continuationId === identity.continuationId && entry.reportId === report.reportId));
         return Object.freeze({
             continuationId: identity.continuationId,
-            generation: identity.generation,
             driver: identity.providerNamespace,
-            turnId: continuation.turnId,
+            runId: continuation.runId,
             execution: continuation.execution,
             outcome: continuation.outcome,
             attachment: continuation.attachment,
@@ -5942,12 +6631,9 @@ function continuationReportEvents(events) {
         const observation = runtimeObservationFromTaskEvent(event);
         if (observation !== null && observation.kind === "continuation.reported") {
             const continuationId = observation.fence.continuationId;
-            const continuationGeneration = observation.fence.continuationGeneration;
             const reportId = observation.payload?.reportId;
-            if (continuationId !== undefined
-                && continuationGeneration !== undefined
-                && reportId !== undefined) {
-                result.push({ event, continuationId, continuationGeneration, reportId });
+            if (continuationId !== undefined && reportId !== undefined) {
+                result.push({ event, continuationId, reportId });
             }
         }
     }
@@ -5961,6 +6647,48 @@ function continuationReportEvents(events) {
  */
 function taskWakeDispatch(args, store, options) {
     const [subcommand] = args;
+    if (subcommand === "resolve") {
+        const usage = "Task wake resolve usage: yui task wake resolve <task> <wake> --reason <quiescence-evidence>.";
+        const parsed = parseTail(args.slice(1), new Set(["--reason"]), usage);
+        exactPositionals(parsed.positionals, 2, usage);
+        const reason = requiredOption(parsed.options, "--reason");
+        const now = clock(options);
+        const result = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            taskActor(tx, options, task.id);
+            const wakeId = parsed.positionals[1];
+            const wake = tx.getTaskWake(task.id, wakeId);
+            if (wake === null)
+                throw usageError("Wake is unavailable.");
+            const target = leaderMailbox(task.id);
+            const mailbox = tx.getWorkMailbox(target);
+            const claim = mailbox?.processing;
+            if (claim === undefined || claim === null || claim.owner !== `leader-notification:${wake.id}`) {
+                throw usageError("This wake has no unresolved notification claim.");
+            }
+            const previous = tx.listEvents(task.id).filter((event) => event.type === "notification.delivery" && event.payload.attemptId === claim.batchId).at(-1);
+            const sessions = tx.getTaskRoleSessionSet(task.id, "leader");
+            const provider = sessions?.providerBinding;
+            if (previous?.payload.outcome !== "unknown")
+                throw usageError("Only an unknown notification can be resolved.");
+            if (tx.getActiveRun(task.id, "leader") !== null
+                || provider?.authority.owner === "human" || provider?.authority.owner === "unknown"
+                || (provider?.run !== undefined && provider.run !== null
+                    && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status))) {
+                throw usageError("Shared native execution is not proven quiescent; resolve that exact runtime boundary first.");
+            }
+            // Preserve the original unknown outcome and the unconsumed fixed wake.
+            // This releases only the scheduling claim; it never replays, claims
+            // acceptance, or asserts that Message requirements were implemented.
+            recordTaskEvent(tx, task.id, "notification.resolved", {
+                wakeId: wake.id, attemptId: claim.batchId, reason, outcome: "released-without-replay"
+            }, now);
+            tx.saveWorkMailbox(completeProcessing(mailbox, claim.batchId));
+            return { taskId: task.id, wakeId: wake.id, outcome: "released-without-replay" };
+        });
+        notifyMailbox(options.runtime, leaderMailbox(result.taskId), result.taskId);
+        return output(`Released ${result.wakeId} without replay; original acceptance remains unknown.\n`, result);
+    }
     if (subcommand === "list" || subcommand === "show") {
         return taskWakeInspectionCommand(args, store);
     }
@@ -5987,13 +6715,13 @@ function taskWakeInspectionCommand(args, store) {
             { header: "Wake", minWidth: 8, maxWidth: 18 },
             { header: "Status", minWidth: 8, maxWidth: 12 },
             { header: "Reasons", minWidth: 10, maxWidth: 40 },
-            { header: "Turn", minWidth: 10, maxWidth: 20 },
+            { header: "AgentRun", minWidth: 10, maxWidth: 20 },
             { header: "Dispatched", minWidth: 10, maxWidth: 28 }
         ], wakes.map((wake) => [
             wake.id,
             wake.status,
             wake.reasons.map(renderWakeReason).join(", "),
-            wake.turnId ?? "-",
+            wake.runId ?? "-",
             presentTime(wake.createdAt, timeZone)
         ]), defaultTableWidth())}\n`, { taskId: task.id, wakes });
     }
@@ -6012,18 +6740,30 @@ function taskWakeInspectionCommand(args, store) {
             return ms > fromMs && ms <= toMs;
         };
         const allEvents = store.listEvents(task.id);
-        const events = allEvents.filter((e) => inWindow(e.createdAt));
-        const messages = store.listMessages(task.id).filter((m) => inWindow(m.createdAt));
-        const allTurns = store.listTurns(task.id);
-        const referencedTurnIds = new Set(referencedWakeTurnIds(allTurns, allEvents, events));
-        const turns = operationalTaskRecords(allTurns, allEvents, "turn").filter((turn) => (inWindow(turn.createdAt) || referencedTurnIds.has(turn.id)));
+        const deliveryEvents = allEvents.filter((event) => (event.type === "notification.delivery" || event.type === "notification.resolved")
+            && (event.payload.wakeId === wake.id
+                || event.payload.attemptId?.startsWith(`notification:${task.id}/${wake.id}/`)));
+        const referenced = (type, id) => wake.refs?.some(ref => ref.type === type && ref.id === id
+            && (!("taskId" in ref) || ref.taskId === task.id)) === true;
+        const events = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id));
+        const messages = store.listMessages(task.id).filter((m) => inWindow(m.createdAt) || referenced("message", m.id));
+        const allRuns = store.listRuns(task.id);
+        const referencedRunIds = new Set(referencedWakeRunIds(allRuns, allEvents, events));
+        for (const run of allRuns)
+            if (referenced("run", run.id))
+                referencedRunIds.add(run.id);
+        for (const message of messages)
+            if (message.resultRef?.type === "agent-run-result")
+                referencedRunIds.add(message.resultRef.runId);
+        const runs = operationalTaskRecords(allRuns, allEvents, "run").filter((run) => (inWindow(run.createdAt) || referencedRunIds.has(run.id)));
         const lines = [
             `Wake: ${wake.id}`,
             `Task: ${task.id}`,
             `Status: ${wake.status}`,
+            `Notification: ${deliveryEvents.at(-1)?.payload.outcome ?? "unobserved"}`,
             `Reasons: ${wake.reasons.map(renderWakeReason).join(", ")}`,
             `Delta window: ${wake.fromCursor} → ${wake.toCursor}`,
-            ...(wake.turnId === undefined ? [] : [`Turn: ${wake.turnId}`]),
+            ...(wake.runId === undefined ? [] : [`AgentRun: ${wake.runId}`]),
             `Dispatched: ${presentTime(wake.createdAt, timeZone)}`,
             ...(wake.consumedAt === undefined
                 ? []
@@ -6032,19 +6772,20 @@ function taskWakeInspectionCommand(args, store) {
             ...events.map((e) => `  ${e.id} ${e.type} ${presentTime(e.createdAt, timeZone)}`),
             `Messages (${messages.length}):`,
             ...messages.map((m) => `  ${m.id} [${taskMessageAuthorLabel(m.author)}] ${presentTime(m.createdAt, timeZone)}`),
-            `Turns (${turns.length}):`,
-            ...turns.map((turn) => (`  ${turn.id} [${turn.status}/${turn.purpose}] ${turn.roleName} `
-                + `${presentTime(turn.createdAt, timeZone)}`
-                + `${referencedTurnIds.has(turn.id)
-                    ? ` → yui task turn show ${task.id}/${turn.id}`
+            `AgentRuns (${runs.length}):`,
+            ...runs.map((run) => (`  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} `
+                + `${presentTime(run.createdAt, timeZone)}`
+                + `${referencedRunIds.has(run.id)
+                    ? ` → yui task run show ${task.id}/${run.id}`
                     : ""}`))
         ];
         return output(lines.join("\n").concat("\n"), {
             taskId: task.id,
+            deliveryEvents,
             wake,
             events,
             messages,
-            turns
+            runs
         });
     }
     throw usageError(command === undefined
@@ -6175,8 +6916,8 @@ function leaderMailbox(taskId) {
 function taskRef(id) {
     return { type: "task", id };
 }
-function turnRef(taskId, id) {
-    return { type: "turn", taskId, id };
+function runRef(taskId, id) {
+    return { type: "run", taskId, id };
 }
 function workItemRef(taskId, id) {
     return { type: "work-item", taskId, id };