@zq-silk/yui 0.13.9 → 0.14.0

package/dist/commands/taskCommands.js

@@ -1,16 +1,15 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { createRunAssignment } from "../context/runContextContract.js";
-import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeExecutionStageContextSnapshot, freezeReviewStageContextSnapshot, freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { createTurnInput } from "../context/turnInputContract.js";
+import { buildTurnContextPack, buildTurnContextDelta, contextSnapshotDeltaRefIds, expandTurnContextRef, freezeExecutionStageContextSnapshot, freezeReviewStageContextSnapshot, freezeTurnContextSnapshot } from "../context/turnContextPack.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, taskRecordRetirement } from "../task/taskRecordRetirement.js";
-import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
-import { routeRoleEvent } from "../scheduler/operatorEvent.js";
+import { isRoleTurnStalled, TURN_PROGRESS_EVENT, TURN_RECOVERED_EVENT } from "../scheduler/roleTurnStall.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode, retireTaskRoleSessionsForWorkspace, terminalizeTaskRoleRunSession, updateTaskRoleProviderRuntime, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -18,12 +17,10 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { renderRoleDetails } from "../output/rolePresentation.js";
 import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
-import { retireExactActiveAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
+import { retireExactActiveTurn, terminalizeExactTaskTurn, validateExactTurnReviewRound } from "../lifecycle/exactTurnTerminalization.js";
 import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole } from "../role/role.js";
-import { agentRunDeliveryReceiptId, createAgentRun, failAgentRun, withAgentRunContextSnapshot, yieldAgentRun } from "../run/agentRun.js";
-import { matchYieldReceipt } from "../run/yieldReceipt.js";
-import { createRejectedYieldAttempt, rejectedYieldAttemptEventPayload, rejectedYieldAttemptFromTaskEvent, RUN_YIELD_REJECTED_EVENT } from "../run/rejectedYieldAttempt.js";
-import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryRunningReviewExecutionLane, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
+import { createTurn, withTurnContextSnapshot } from "../turn/turn.js";
+import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, recordReviewWorkspaceDisposition, retryRunningReviewExecutionLane, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
 import { projectReviewerAvailability } from "../review/reviewerAvailability.js";
@@ -35,14 +32,13 @@ import { createMilestone } from "../milestone/milestone.js";
 import { runPublicationCommand } from "./taskPublicationCommands.js";
 import { enqueueWork, settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { mailboxHasWork as workMailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { runtimeLifecycleTarget } 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 { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { assertProjectActive, resolveProject } from "../repository/project.js";
-import { acquireProjectMaintenanceLocks } from "../repository/projectMaintenanceLock.js";
 import { currentWorkItemCandidate, currentWorkItemExecutionGroup, workItemExecutionGroupById, createWorkItem, planWorkItemExplorationStage, attachWorkItemExecutionGroup, updateWorkItemExecutionGroup, retireWorkItem, retryFailedWorkItem, submitWorkItemCandidate, updateWorkItemWriteProjects, updateWorkItemStatus } from "../workItem/workItem.js";
 import { addExecutionLane, createExecutionGroup, queueExecutionLaneRetry, resolveExecutionGroup, restartExecutionLane, skipPendingExecutionLanes, updateExecutionLane, WORK_ITEM_EXECUTION_MODES } from "../execution/executionGroup.js";
 import { DEFAULT_EXECUTION_STAGE_TOKEN_BUDGET_PER_LANE, executionStageSpendClosed, observedExecutionResourceUsage, planResourceAdmissions, projectExecutionStageResources, resolveResourceBrokerPolicy, routeExecutionStage } from "../execution/resourceBroker.js";
@@ -50,7 +46,7 @@ import { resolveControllerTaskConcurrency, resolveRuntimeHealth } from "../confi
 import { assertIndependentVerificationRoles, candidateConvergenceEvidenceSufficient, candidateConvergenceDirective, validateCandidateConvergenceResolution } from "../execution/candidateConvergence.js";
 import { sameTaskFinalReviewContract, taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
-import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT, createTaskFinalReviewContractRebind, resolveRecordedTaskFinalReviewContract, taskFinalReviewContractRebindPayload } from "../review/taskFinalReviewContractRebind.js";
+import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractResolution.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { hasAgentConfigOptions, parseRoleOptions, patchRoleAgentBinding, roleOptionSpecs, roleProfilePatch } from "./roleConfiguration.js";
 import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
@@ -58,16 +54,15 @@ import { assertRoleRuntimeMutationAllowed } from "./roleRuntimeGuard.js";
 import { runTaskContextCommand } from "./taskContextCommand.js";
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
 import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
-import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastRunLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel } from "./taskRoleRuntimeStatus.js";
-import { assertNoOpenInputRequests, isCurrentGlobalOperator, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
+import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastTurnLabel, 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, taskLeaderActionRunId } from "./taskActor.js";
+import { taskLocalActor as resolveTaskLocalActor, taskLeaderActionTurnId } from "./taskActor.js";
 import { enqueueOperatorEvent } from "../scheduler/operatorEvent.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { renderWakeReason, wakeReason } from "../scheduler/wakeReason.js";
-import { collectTaskActionability, computeActionabilityDigest, deriveLeaderRunDisposition, projectQueuedResourceLaneIdentities } from "../scheduler/actionability.js";
-import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+import { projectQueuedResourceLaneIdentities } from "../scheduler/resourceQueueProjection.js";
 import { buildTaskOverview, parseTaskListOptions, renderTaskOverview } from "./taskOverviewCommand.js";
 const LEADER_ROLE = "leader";
 /** Exact Task-final identity or evidence changed between queueing and dispatch. */
@@ -82,7 +77,7 @@ function taskFinalReviewDispatchDrift(error) {
     return new TaskFinalReviewDispatchDriftError(error instanceof Error ? error.message : String(error), error instanceof CliError ? error : undefined);
 }
 /** `final` is a Task delivery policy, not a per-WorkItem ReviewRound rule. */
-function legacyWorkItemReviewConfig(config) {
+function workItemReviewConfig(config) {
     return config?.trigger === "final" ? null : config;
 }
 function storedTaskFinalReviewContract(store, taskId) {
@@ -90,7 +85,7 @@ function storedTaskFinalReviewContract(store, taskId) {
 }
 function storedTaskFinalReviewContractResolution(store, taskId) {
     try {
-        return resolveRecordedTaskFinalReviewContract(taskId, store.listWorkItems(taskId), store.listReviewRounds(taskId), store.listEvents(taskId));
+        return resolveRecordedTaskFinalReviewContract(taskId, store.listWorkItems(taskId), store.listReviewRounds(taskId));
     }
     catch (error) {
         throw dataError(error instanceof Error
@@ -119,8 +114,8 @@ function taskFinalReviewContractForMutation(store, taskId, options) {
     }
     if (stored === undefined)
         return supplied;
-    // Historical exact contracts now express only a durable Reviewer policy.
-    // The persisted contract remains the audit authority, but ordinary
+    // The exact contract expresses a durable Reviewer policy. The persisted
+    // contract remains the audit authority, but ordinary
     // protocol/storage-compatible CLIs may continue the Task without presenting
     // a release-bound capability on every mutation.
     if (supplied === undefined)
@@ -236,7 +231,7 @@ export function runTaskCommand(args, store, options = {}) {
         case "role": return taskRoleCommand(rest, store, options);
         case "work": return taskWorkCommand(rest, store, options);
         case "review": return taskReviewCommand(rest, store, options);
-        case "run": return taskRunCommand(rest, store, options);
+        case "turn": return taskTurnCommand(rest, store, options);
         case "brief": return taskBriefCommand(rest, store, options);
         case "decision": return taskDecisionCommand(rest, store, options);
         case "milestone": return taskMilestoneCommand(rest, store, options);
@@ -317,7 +312,7 @@ export function normalizedExecutionLanePlan(input) {
     return { expanding, resumingQueued, roles, strategy, capacity, requestedCount, laneIds };
 }
 function activeResourceLaneIdentities(store) {
-    return store.listActiveTaskIds().flatMap((taskId) => (store.listAgentRuns(taskId).flatMap((run) => {
+    return store.listActiveTaskIds().flatMap((taskId) => (store.listTurns(taskId).flatMap((run) => {
         if (run.status !== "active"
             || run.executionGroupId === undefined
             || run.executionLaneId === undefined)
@@ -455,14 +450,6 @@ function updateTaskCommand(args, store, options) {
     notifyMailbox(options.runtime, taskMailbox(result.id), result.id);
     return `Updated task ${result.id}\n`;
 }
-/** Compatibility helper for call sites that cannot yet handle foreground enter. */
-export function runTaskOutputCommand(args, store, options = {}) {
-    const execution = runTaskCommand(args, store, options);
-    if (execution.kind !== "output") {
-        throw runtimeError("Task Role foreground runtime control requires the CLI.");
-    }
-    return execution.output;
-}
 export function submitOperatorMessage(body, taskId, store, options = {}) {
     const now = clock(options);
     const result = store.transaction((tx) => {
@@ -601,7 +588,7 @@ function showTaskCommand(args, store) {
         milestones: milestones.length,
         events: events.length,
         workItems: work.length,
-        agentRuns: store.listAgentRuns(task.id).length,
+        turns: store.listTurns(task.id).length,
         changeSets: changeSets.length,
         integrations: integrations.length,
         publications: publications.length,
@@ -640,7 +627,7 @@ function showTaskCommand(args, store) {
         `Milestones: ${counts.milestones}`,
         `Events: ${counts.events}`,
         `Work items: ${counts.workItems}`,
-        `Agent Runs: ${counts.agentRuns}`,
+        `Turns: ${counts.turns}`,
         `ChangeSets: ${counts.changeSets}`,
         `Integration Attempts: ${counts.integrations}`,
         `Publication references: ${counts.publications} (${verifiedMergedPublications} verified merged)`,
@@ -700,7 +687,6 @@ function completeTaskCommand(args, store, options) {
             return {
                 task,
                 changed: false,
-                runtimeCleanupTargets: [],
                 completionAdvisories: [],
                 finalReview: undefined
             };
@@ -722,15 +708,13 @@ function completeTaskCommand(args, store, options) {
             return {
                 task,
                 changed: false,
-                runtimeCleanupTargets: [],
                 completionAdvisories: [],
                 finalReview,
             };
         }
-        // Completion is a semantic boundary. Current Runs and Sessions are
-        // disposable execution attempts; settle them before deriving readiness so
-        // only durable Task results decide whether the Task can complete.
-        const runtimeCleanupTargets = settleTaskExecutionForCompletion(tx, task.id, roles, summary, now);
+        // Completion is a Task decision only. The current Provider Turn remains
+        // responsible for closing its own Turn, 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
         // same pure projection `task next-action` displays, now with the finding
@@ -781,7 +765,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 Run was being settled must not survive a
+        // signal queued while the final Turn 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));
@@ -789,17 +773,11 @@ function completeTaskCommand(args, store, options) {
         return {
             task: completed,
             changed: true,
-            runtimeCleanupTargets,
             completionAdvisories: readiness.advisories,
             finalReview: undefined
         };
     });
     if (result.changed) {
-        for (const target of result.runtimeCleanupTargets) {
-            // Cleanup owns an independent lifecycle lane. Never fall back to the
-            // Task signal for older runtime ports: a completed Task must not wake.
-            options.runtime?.notifyMailboxChanged?.(target);
-        }
         notifyMailbox(options.runtime, { kind: "operator" }, result.task.id);
     }
     if (result.finalReview !== undefined) {
@@ -826,45 +804,29 @@ function completeTaskCommand(args, store, options) {
 function reopenTaskCommand(args, store, options) {
     exactPositionals(args, 1, "Task reopen usage: yui task reopen <id>.");
     const now = clock(options);
-    // Reopen changes the Task status that archiveLegacyTaskRefs reads before
-    // deleting the legacy ref. Take the same per-Project maintenance fence so a
-    // reopen cannot commit between archive's status read and its ref deletion:
-    // the two operations are mutually exclusive per Project.
-    const existing = store.getTask(args[0]);
-    const projectIds = existing === null
-        ? []
-        : existing.projectBindings.map(({ projectId }) => projectId);
-    const release = options.yuiHome === undefined || projectIds.length === 0
-        ? () => { }
-        : acquireProjectMaintenanceLocks(options.yuiHome, projectIds);
-    try {
-        const result = store.transaction((tx) => {
-            const task = requireTask(tx, args[0]);
-            if (task.status === "active")
-                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}.`);
-            const active = reopenTask(task, now);
-            tx.saveTask(active);
-            const reopenedReason = wakeReason("task-reopened");
-            enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
-            enqueueWork(tx, taskMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
-            recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
-            return { task: active, changed: true };
-        });
-        if (result.changed) {
-            notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
-            notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
-        }
-        return result.changed
-            ? `Reopened task ${result.task.id}\n`
-            : `Task ${result.task.id} is already active\n`;
-    }
-    finally {
-        release();
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, args[0]);
+        if (task.status === "active")
+            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}.`);
+        const active = reopenTask(task, now);
+        tx.saveTask(active);
+        const reopenedReason = wakeReason("task-reopened");
+        enqueueWork(tx, leaderMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
+        enqueueWork(tx, taskMailbox(task.id), reopenedReason, now, [taskRef(task.id)]);
+        recordTaskEvent(tx, task.id, "task.reopened", { status: active.status }, now);
+        return { task: active, changed: true };
+    });
+    if (result.changed) {
+        notifyMailbox(options.runtime, taskMailbox(result.task.id), result.task.id);
+        notifyMailbox(options.runtime, leaderMailbox(result.task.id), result.task.id);
     }
+    return result.changed
+        ? `Reopened task ${result.task.id}\n`
+        : `Task ${result.task.id} is already active\n`;
 }
 function archiveTaskCommand(args, store, options) {
     const request = validateTaskArchiveRequest(args, store, options);
@@ -895,11 +857,20 @@ 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.getActiveAgentRun(task.id, role.name) !== null);
+            .find((role) => tx.getActiveTurn(task.id, role.name) !== null);
         if (activeRole !== undefined) {
-            throw usageError(`Task ${task.id} still has an active Run for Role ${activeRole.name}; `
+            throw usageError(`Task ${task.id} still has an active Turn for Role ${activeRole.name}; `
                 + "stop its runtime before archiving.");
         }
+        const liveSessionRole = tx.listRoles(task.id).find((role) => {
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            const session = sessions?.sessions[sessions.activeAgentId];
+            return session !== undefined && session.status !== "ended";
+        });
+        if (liveSessionRole !== undefined) {
+            throw usageError(`Task ${task.id} still has a live Session for Role ${liveSessionRole.name}; `
+                + "stop that Session before archiving.");
+        }
         const archived = archiveTask(task, now, { by: actor });
         tx.saveTask(archived);
         tx.clearPendingWakeup(task.id);
@@ -960,13 +931,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.listAgentRuns(task.id).filter(({ status: runStatus }) => (runStatus === "active"))) {
-            const terminal = terminalizeExactTaskRun(tx, {
+        for (const run of tx.listTurns(task.id).filter(({ status: runStatus }) => (runStatus === "active"))) {
+            const terminal = terminalizeExactTaskTurn(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
                 agentId: run.effective.agentId,
-                runId: run.id,
-                receiptId: agentRunDeliveryReceiptId(run),
+                turnId: run.id,
                 mailboxDisposition: "discard",
                 outcome: {
                     status: "failed",
@@ -974,7 +944,7 @@ function retireTaskCommand(args, store, options) {
                 }
             }, now);
             if (terminal.disposition !== "applied") {
-                throw usageError(`Task Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                throw usageError(`Task Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
         }
         for (const item of tx.listWorkItems(task.id)) {
@@ -1080,8 +1050,8 @@ function reconcileTaskCommand(args, store, options) {
 function taskMessageCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "send") {
-        const usage = "Task message send usage: yui task message send <id> (<body>|--body-file <path|->) [--wake-policy leader|none] [--delivery-mode followup|steer].";
-        const parsed = parseTail(rest, new Set(["--body-file", "--wake-policy", "--delivery-mode"]), usage);
+        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);
         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);
@@ -1096,13 +1066,6 @@ function taskMessageCommand(args, store, options) {
         else {
             throw usageError(`--wake-policy must be 'leader' or 'none': ${wakePolicyRaw}.`);
         }
-        const deliveryModeRaw = parsed.options.get("--delivery-mode") ?? "followup";
-        if (deliveryModeRaw !== "followup" && deliveryModeRaw !== "steer") {
-            throw usageError(`--delivery-mode must be 'followup' or 'steer': ${deliveryModeRaw}.`);
-        }
-        if (deliveryModeRaw === "steer" && wakePolicy === "none") {
-            throw usageError("--delivery-mode steer cannot be combined with --wake-policy none.");
-        }
         const now = clock(options);
         const result = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
@@ -1119,19 +1082,10 @@ function taskMessageCommand(args, store, options) {
             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)], deliveryModeRaw === "steer"
-                    ? {
-                        source: actor,
-                        dedupeKey: `user-correction:${task.id}:${message.id}`,
-                        deliveryMode: "steer-if-safe",
-                        lane: "user-correction"
-                    }
-                    : {
-                        source: actor,
-                        dedupeKey: `message:${task.id}:${message.id}`,
-                        deliveryMode: "followup",
-                        lane: "normal"
-                    });
+                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 };
         });
@@ -1317,14 +1271,16 @@ function taskRoleSessionCommand(args, store, options) {
         const now = clock(options);
         const request = store.transaction((tx) => {
             const task = requireTask(tx, parsed.positionals[0]);
-            assertTaskOpen(task);
+            if (task.status !== "active" && task.status !== "completed") {
+                throw usageError(`Task Role Session stop requires an active or completed 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.getActiveAgentRun(task.id, role.name) !== null) {
-                throw usageError(`Task Role has an active Run; settle or retire it before stopping the Session: ${task.id}/${role.name}.`, 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);
             }
             const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
             const session = sessions?.sessions[sessions.activeAgentId];
@@ -1454,7 +1410,7 @@ function listTaskRoles(args, store, options) {
         { header: "Health", minWidth: 6, maxWidth: 15 },
         { header: "Open input", minWidth: 5, maxWidth: 10 },
         { header: "Active work", minWidth: 10, maxWidth: 34 },
-        { header: "Last run", minWidth: 10, maxWidth: 28 },
+        { header: "Last turn", minWidth: 10, maxWidth: 28 },
         { header: "Native session", minWidth: 10, maxWidth: 28 },
         { header: "tmux", minWidth: 6, maxWidth: 22 }
     ], statuses.map((status) => [
@@ -1463,7 +1419,7 @@ function listTaskRoles(args, store, options) {
         status.health,
         taskRoleOpenInputLabel(status),
         taskRoleActiveWorkLabel(status),
-        taskRoleLastRunLabel(status),
+        taskRoleLastTurnLabel(status),
         taskRoleNativeSessionLabel(status),
         taskRoleTmuxLabel(status)
     ]), defaultTableWidth())}\n`, { roles: statuses });
@@ -1562,8 +1518,8 @@ function removeTaskRole(args, store, options) {
             taskId: task.id,
             roleName: role.name
         }, "removal");
-        if (tx.getActiveAgentRun(task.id, role.name) !== null) {
-            throw usageError(`Task Role has an active Run and cannot be removed: ${task.id}/${role.name}.`);
+        if (tx.getActiveTurn(task.id, role.name) !== null) {
+            throw usageError(`Task Role has an active Turn 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")) {
@@ -1612,7 +1568,7 @@ function bindTaskRole(args, store, options) {
         const switched = (() => {
             try {
                 return switchActiveRoleAgent(bound, existing, agent.id, {
-                    activeRun: tx.getActiveAgentRun(task.id, role.name) !== null,
+                    activeTurn: tx.getActiveTurn(task.id, role.name) !== null,
                     nativeProcessRunning: currentSession !== undefined
                         && currentSession.status === "active"
                 }, now);
@@ -1705,9 +1661,9 @@ function transferTaskRoleAuthority(args, store, options, action) {
                 throw new Error(`Provider Activation is not live: ${task.id}/${role.name}.`);
             }
             if (action === "takeover") {
-                const activeRun = tx.getActiveAgentRun(task.id, role.name);
-                if (sessions.inFlight === null || activeRun?.id !== sessions.inFlight.runId) {
-                    throw new Error(`Task Role has no active managed Run for takeover: ${task.id}/${role.name}.`);
+                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}.`);
                 }
             }
             if (action === "takeover"
@@ -1866,8 +1822,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.getActiveAgentRun(task.id, item.assignee ?? "") !== null) {
-            throw usageError(`Stop the active Work Item Run before changing scope: ${item.id}.`);
+        if (tx.getActiveTurn(task.id, item.assignee ?? "") !== null) {
+            throw usageError(`Stop the active Work Item Turn before changing scope: ${item.id}.`);
         }
         const requestedProjectIds = (parsed.multiOptions.get("--project") ?? []).map((reference) => {
             const project = resolveProject(task.projectBindings.map(({ projectId }) => requireProject(tx, projectId)), reference);
@@ -1928,7 +1884,7 @@ function updateWork(args, store, options) {
                 ? taskFinalReviewContractForMutation(tx, task.id, options)
                 : undefined;
             const candidatePolicy = taskFinalContract === undefined
-                ? legacyWorkItemReviewConfig(configuredReview)
+                ? workItemReviewConfig(configuredReview)
                 : taskFinalReviewConfig(taskFinalContract);
             const projectDelivery = task.projectBindings.length > 0
                 && current.writeProjectIds.length > 0;
@@ -1987,14 +1943,10 @@ function updateWork(args, store, options) {
             };
         }
         throw usageError(`Assigned Work Item execution cannot use task work update: ${current.id}. `
-            + "Use dispatch and run yield, then let the Task Leader accept or reject the result; "
+            + "Use dispatch, wait for the Turn result, then let the Task Leader accept or reject it; "
             + "use task work retire for an explicit Leader retirement.");
     });
     notifyMailbox(options.runtime, taskMailbox(result.item.taskId), result.item.taskId);
-    if (result.reviewDispatch?.run !== null
-        && result.reviewDispatch?.run !== undefined) {
-        notifyReviewMailbox(options, options.runtime, roleMailbox(result.reviewDispatch.run.taskId, result.reviewDispatch.run.roleName), result.reviewDispatch.run.taskId);
-    }
     if (result.item.status === "awaiting_acceptance" && status === "completed") {
         const failure = result.reviewDispatch?.round.status === "failed"
             ? `Review could not start: ${result.reviewDispatch.round.summary}\n`
@@ -2066,7 +2018,7 @@ function dispatchWork(args, store, options) {
             : undefined;
         if (item.status === "failed" && existingGroup !== undefined) {
             throw usageError(`Work Item ${item.id} retains unresolved ExecutionGroup ${existingGroup.id}; `
-                + "retry the exact failed AgentRun so completed Lane results remain reusable.");
+                + "retry the exact failed Turn so completed Lane results remain reusable.");
         }
         const expanding = item.status === "running" && existingGroup !== undefined;
         const continuingExploration = currentGroup?.stage !== undefined
@@ -2110,31 +2062,37 @@ function dispatchWork(args, store, options) {
         if (expanding)
             taskActor(tx, options, task.id);
         assertWorkItemDependenciesCompleted(tx, item);
-        const workspace = tx.getWorkItemWorkspace(task.id, item.id);
-        if (workspace?.owner.type === "work-item"
+        const leaderOwned = item.assignee === "leader";
+        const workspace = leaderOwned
+            ? tx.getTaskWorkspace(task.id)
+            : tx.getWorkItemWorkspace(task.id, item.id);
+        if (!leaderOwned && workspace?.owner.type === "work-item"
             && workspace.owner.workItemId !== item.id) {
             throw usageError(`Task Role ${item.assignee} still uses the isolated worktree for ${workspace.owner.workItemId}; `
                 + `cleanup ${workspace.owner.workItemId} before dispatching ${item.id}.`);
         }
         if (task.projectBindings.length > 0) {
-            const writable = workspace?.owner.type === "work-item"
-                && workspace.owner.workItemId === item.id
+            const ownsExpectedWorkspace = leaderOwned
+                ? workspace?.owner.type === "task" && workspace.owner.taskId === task.id
+                : workspace?.owner.type === "work-item" && workspace.owner.workItemId === item.id;
+            const writable = workspace !== null && ownsExpectedWorkspace
                 ? workspace.entries
                     .filter(({ access }) => access === "write")
                     .map(({ projectId }) => projectId)
                     .sort()
                 : [];
-            const visible = workspace?.owner.type === "work-item"
-                && workspace.owner.workItemId === item.id
+            const visible = workspace !== null && ownsExpectedWorkspace
                 ? workspace.entries.map(({ projectId }) => projectId).sort()
                 : [];
             if (!isDeepStrictEqual(writable, [...item.writeProjectIds].sort())
                 || !isDeepStrictEqual(visible, task.projectBindings.map(({ projectId }) => projectId).sort())) {
-                throw usageError(`Work Item ${item.id} must be isolated with its approved Project scope before dispatch.`);
+                throw usageError(leaderOwned
+                    ? `Leader-owned Work Item ${item.id} must cover the Task main-worktree Project scope.`
+                    : `Work Item ${item.id} must be isolated with its approved Project scope before dispatch.`);
             }
         }
         const rawInput = trimmed(parsed.options.get("--input")) ?? item.objective;
-        const runWorkspace = workspace ?? tx.getTaskWorkspace(task.id) ?? undefined;
+        const runWorkspace = workspace ?? undefined;
         const lanePlan = normalizedExecutionLanePlan({
             assignee: item.assignee,
             requestedRoles: requestedLaneRoles,
@@ -2142,7 +2100,7 @@ function dispatchWork(args, store, options) {
             existingGroup,
             resolvedRetryGroup,
             status: item.status,
-            nextGroupId: `execution-group-${tx.peekNextAgentRunId(task.id)}`,
+            nextGroupId: `execution-group-${tx.peekNextTurnId(task.id)}`,
             retryLaneId: undefined,
             phase: "dispatch"
         });
@@ -2171,17 +2129,17 @@ function dispatchWork(args, store, options) {
         }
         const roles = laneRoles.map((name) => requireRole(tx, task.id, name));
         const plans = roles.map((role) => {
-            if (tx.getActiveAgentRun(task.id, role.name) !== null) {
-                throw usageError(`${task.id}/${role.name} already has an active run.`);
+            if (tx.getActiveTurn(task.id, role.name) !== null) {
+                throw usageError(`${task.id}/${role.name} already has an active turn.`);
             }
             return {
                 role,
-                runId: tx.nextAgentRunId(task.id)
+                turnId: tx.nextTurnId(task.id)
             };
         });
         let group = existingGroup;
         if (group === undefined) {
-            const groupId = `execution-group-${plans[0].runId}`;
+            const groupId = `execution-group-${plans[0].turnId}`;
             const stage = !startingExploration && !continuingExploration
                 ? undefined
                 : (() => {
@@ -2248,7 +2206,7 @@ function dispatchWork(args, store, options) {
                 : group.lanes.slice(0, plans.length);
         if (lanes.length !== plans.length)
             throw new Error(`ExecutionGroup Lane planning drift: ${group.id}.`);
-        const createdRuns = [];
+        const createdTurns = [];
         const queuedAdmissions = [];
         let runningGroup = group;
         const config = tx.getConfig();
@@ -2268,7 +2226,7 @@ function dispatchWork(args, store, options) {
                 usage: observedExecutionResourceUsage({
                     group,
                     stageGroups: [...item.executionGroups, group],
-                    runs: tx.listAgentRuns(task.id),
+                    turns: tx.listTurns(task.id),
                     events: tx.listEvents(task.id)
                 }),
                 now
@@ -2348,30 +2306,21 @@ function dispatchWork(args, store, options) {
             activeResources.push(request);
             const runningLane = lane.status === "failed"
                 ? restartExecutionLane(runningGroup, lane.id, {
-                    runId: plan.runId,
+                    turnId: plan.turnId,
                     effective,
                     workspace: laneWorkspace,
                     directive: frozenDirective
                 }, now)
                 : updateExecutionLane(runningGroup, lane.id, {
                     status: "running",
-                    runId: plan.runId,
+                    turnId: plan.turnId,
                     effective,
                     workspace: laneWorkspace,
                     directive: frozenDirective
                 }, now);
             runningGroup = runningLane;
-            const assignment = createRunAssignment({
-                runId: plan.runId,
-                roleName: plan.role.name,
-                purpose: "execution",
-                action: item.status === "failed" ? "repair-work-item" : "execute-work-item",
-                subject: {
-                    taskId: task.id,
-                    workItemId: item.id,
-                    executionGroupId: runningGroup.id,
-                    executionLaneId: lane.id
-                },
+            const input = createTurnInput({
+                source: { type: "yui", channel: "workitem-dispatch" },
                 directive: `${frozenDirective}\nFrozen target: ${group.target.fingerprint}.`
                     + (group.stage === undefined
                         ? ""
@@ -2384,7 +2333,7 @@ function dispatchWork(args, store, options) {
                                 : `\n${candidateConvergenceDirective(group.stage)}`)),
                 deltaRefIds: []
             });
-            createdRuns.push(createAgentRun(plan.runId, task.id, plan.role.name, dispatchMode, assignment, now, {
+            createdTurns.push(createTurn(plan.turnId, task.id, plan.role.name, dispatchMode, input, now, {
                 workItemId: item.id,
                 executionGroupId: runningGroup.id,
                 executionLaneId: lane.id,
@@ -2439,37 +2388,37 @@ function dispatchWork(args, store, options) {
                     tx.saveManagedWorkspace(prepared);
             }
         }
-        for (let index = 0; index < createdRuns.length; index += 1) {
-            const unboundRun = createdRuns[index];
-            const snapshot = freezeRunContextSnapshot(tx, {
+        for (let index = 0; index < createdTurns.length; index += 1) {
+            const unboundTurn = createdTurns[index];
+            const snapshot = freezeTurnContextSnapshot(tx, {
                 taskId: task.id,
-                roleName: unboundRun.roleName,
+                roleName: unboundTurn.roleName,
                 purpose: "execution",
                 workItemId: item.id
             }, now, "controller", runningGroup.stage?.contextSnapshotRef);
-            const runWithLineage = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            createdRuns[index] = runWithLineage;
-            const role = requireRole(tx, task.id, unboundRun.roleName);
-            tx.saveAgentRun(runWithLineage);
-            tx.saveActiveAgentRun(runWithLineage);
-            enqueueWork(tx, roleMailbox(task.id, role.name), "run-dispatched", now, [
-                runRef(task.id, runWithLineage.id),
+            const turnWithLineage = withTurnContextSnapshot(unboundTurn, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
+            createdTurns[index] = turnWithLineage;
+            const role = requireRole(tx, task.id, unboundTurn.roleName);
+            tx.saveTurn(turnWithLineage);
+            tx.saveActiveTurn(turnWithLineage);
+            enqueueWork(tx, roleMailbox(task.id, role.name), "turn-dispatched", now, [
+                turnRef(task.id, turnWithLineage.id),
                 workItemRef(task.id, item.id)
             ]);
-            recordTaskEvent(tx, task.id, "run.dispatched", runLaunchEventPayload(runWithLineage), now);
+            recordTaskEvent(tx, task.id, "turn.dispatched", turnLaunchEventPayload(turnWithLineage), now);
         }
-        return { runs: createdRuns, queuedAdmissions, group: runningGroup };
+        return { turns: createdTurns, queuedAdmissions, group: runningGroup };
     });
-    for (const run of dispatch.runs) {
-        notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
+    for (const turn of dispatch.turns) {
+        notifyMailbox(options.runtime, roleMailbox(turn.taskId, turn.roleName), turn.taskId);
     }
     const backpressure = dispatch.queuedAdmissions.length === 0
         ? ""
         : `; ${dispatch.queuedAdmissions.length} Lane(s) retained pending by Resource Broker`;
-    const first = dispatch.runs[0];
+    const first = dispatch.turns[0];
     return first === undefined
         ? `No Lane admitted; ${dispatch.queuedAdmissions.join("; ")}\n`
-        : `Dispatch queued for ${first.taskId}/${first.roleName} (${first.id})${dispatch.runs.length > 1 ? `; ${dispatch.runs.length} Lanes` : ""}${backpressure}\n`;
+        : `Dispatch queued for ${first.taskId}/${first.roleName} (${first.id})${dispatch.turns.length > 1 ? `; ${dispatch.turns.length} Lanes` : ""}${backpressure}\n`;
 }
 function resolveWorkExecutionGroup(args, store, options) {
     const usage = "Task work group resolve usage: yui task work group resolve <task>/<work> --decision <accept|reject|retry|blocked> --summary <text> [--lane <lane-id> ...] [--early-stop <marginal-value-percent>].";
@@ -2509,7 +2458,7 @@ function resolveWorkExecutionGroup(args, store, options) {
         }
         const acceptedLaneIds = decision === "accept"
             ? selectedLaneIds ?? group.lanes
-                .filter((lane) => lane.status === "yielded" || lane.status === "completed")
+                .filter((lane) => lane.status === "completed")
                 .map(({ id }) => id)
             : undefined;
         if (earlyStopMarginalValue !== undefined) {
@@ -2525,7 +2474,7 @@ function resolveWorkExecutionGroup(args, store, options) {
                 usage: observedExecutionResourceUsage({
                     group,
                     stageGroups: item.executionGroups,
-                    runs: tx.listAgentRuns(task.id),
+                    turns: tx.listTurns(task.id),
                     events: tx.listEvents(task.id)
                 }),
                 now
@@ -2594,10 +2543,10 @@ function resolveWorkExecutionGroup(args, store, options) {
         }
         const eligible = resolved.lanes
             .filter((lane) => resolved.resolution?.selectedLaneIds.includes(lane.id) ?? false)
-            .map((lane) => lane.runId === undefined ? null : tx.getAgentRun(task.id, lane.runId))
-            .find((run) => run !== null && run !== undefined && run.status === "yielded");
+            .map((lane) => lane.turnId === undefined ? null : tx.getTurn(task.id, lane.turnId))
+            .find((run) => run !== null && run !== undefined && run.status === "completed");
         if (eligible === undefined) {
-            throw usageError(`ExecutionGroup ${group.id} has no yielded selected Lane Run to capture.`);
+            throw usageError(`ExecutionGroup ${group.id} has no completed selected Lane Turn to capture.`);
         }
         const candidateWorkspace = options.candidateWorkspace;
         if (candidateWorkspace === undefined && options.yuiHome !== undefined) {
@@ -2606,11 +2555,11 @@ function resolveWorkExecutionGroup(args, store, options) {
         const configuredReview = tx.getReviewConfig();
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
         const candidatePolicy = taskFinalContract === undefined
-            ? legacyWorkItemReviewConfig(configuredReview)
+            ? workItemReviewConfig(configuredReview)
             : taskFinalReviewConfig(taskFinalContract);
         const candidate = submitWorkItemCandidate(groupedItem, {
             summary: resolutionSummary,
-            source: { type: "run", runId: eligible.id },
+            source: { type: "turn", turnId: eligible.id },
             executionGroupId: resolved.id,
             executionLaneId: eligible.executionLaneId,
             ...(candidatePolicy === null ? {} : { reviewPolicy: candidatePolicy }),
@@ -2627,7 +2576,7 @@ function resolveWorkExecutionGroup(args, store, options) {
             ? queueReviewRound(tx, candidate, candidatePolicy, "policy", now)
             : null;
         enqueueWork(tx, leaderMailbox(task.id), "candidate-ready", now, [
-            runRef(task.id, eligible.id),
+            turnRef(task.id, eligible.id),
             workItemRef(task.id, item.id)
         ]);
         return {
@@ -2640,9 +2589,6 @@ function resolveWorkExecutionGroup(args, store, options) {
     if (result.waitingForStragglers) {
         return output(`Stopped pending spend for ${result.group.id}; active stragglers are retained until they settle: ${result.group.lanes.filter(({ status }) => status === "running").map(({ id }) => id).join(", ")}\n`, { workItem: result.item, executionGroup: result.group });
     }
-    if (result.reviewDispatch?.run !== null && result.reviewDispatch?.run !== undefined) {
-        notifyReviewMailbox(options, options.runtime, roleMailbox(result.reviewDispatch.run.taskId, result.reviewDispatch.run.roleName), result.reviewDispatch.run.taskId);
-    }
     return output(`Resolved ExecutionGroup ${result.group.id} as ${decision}; Work Item ${result.item.id} is ${result.item.status}.\n`, { workItem: result.item, executionGroup: result.group });
 }
 function aggregateExecutionLaneSummary(leaderSummary, group, selectedLaneIds) {
@@ -2697,7 +2643,7 @@ function executionTargetForReviewRound(task, round, item, candidate) {
         kind: taskScope ? "task-final-review" : "work-item",
         taskId: task.id,
         ...(taskScope ? {} : { workItemId: item.id, candidateId: candidate.id }),
-        // A Task-final ReviewRound is itself the immutable semantic target. Runs
+        // A Task-final ReviewRound is itself the immutable semantic target. Turns
         // retry that same revision; a changed frozen Task creates a new Round.
         revision: taskScope ? 1 : candidate.workItemRevision,
         projects,
@@ -2775,8 +2721,8 @@ function acceptWork(args, store, options) {
         recordTaskEvent(tx, item.taskId, "work.accepted", {
             workItemId: item.id,
             candidateId: candidate.id,
-            ...(candidate.source.type === "run"
-                ? { runId: candidate.source.runId }
+            ...(candidate.source.type === "turn"
+                ? { turnId: candidate.source.turnId }
                 : { workItemRevision: String(candidate.workItemRevision) }),
             acceptedBy: actor,
             summary,
@@ -2898,20 +2844,19 @@ function retireWork(args, store, options) {
                 + `${activeWorkItemJob.id}/${activeWorkItemJob.status}. `
                 + "Cancel or acknowledge it before retiring.");
         }
-        for (const run of tx.listAgentRuns(task.id).filter((candidate) => (candidate.status === "active" && candidate.workItemId === item.id))) {
-            const terminal = terminalizeExactTaskRun(tx, {
+        for (const run of tx.listTurns(task.id).filter((candidate) => (candidate.status === "active" && candidate.workItemId === item.id))) {
+            const terminal = terminalizeExactTaskTurn(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
                 agentId: run.effective.agentId,
-                runId: run.id,
-                receiptId: agentRunDeliveryReceiptId(run),
+                turnId: run.id,
                 outcome: {
                     status: "failed",
                     summary: `Work Item retired: ${summary}`
                 }
             }, now);
             if (terminal.disposition !== "applied") {
-                throw usageError(`Work Item Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                throw usageError(`Work Item Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
         }
         const next = retireWorkItem(item, {
@@ -3017,19 +2962,16 @@ function reviewWork(args, store, options) {
             const resourceQueued = activeRound.executionGroup !== undefined
                 && activeRound.executionGroup.resolution === undefined
                 && activeRound.executionGroup.lanes.some((lane) => (lane.status === "pending"
-                    && lane.runId === undefined));
-            if ((activeRound.status === "pending" && activeRound.reviewerRunId === undefined)
+                    && lane.turnId === undefined));
+            if ((activeRound.status === "pending" && activeRound.reviewerTurnId === undefined)
                 || (activeRound.status === "running" && resourceQueued)) {
-                return { round: activeRound, run: null, resumed: true };
+                return { round: activeRound, resumed: true };
             }
             throw usageError(`ReviewRound is already active: ${activeRound.id}/${activeRound.status}.`);
         }
         const queued = queueReviewRound(tx, item, config, requestedBy, now);
         return { ...queued, resumed: false };
     });
-    if (result.run !== null) {
-        notifyReviewMailbox(options, options.runtime, roleMailbox(result.run.taskId, result.run.roleName), result.run.taskId);
-    }
     if (result.resumed) {
         return output(`Review request ${result.round.id} has pending Lanes; resuming dispatch.\n`, { reviewRound: result.round });
     }
@@ -3039,8 +2981,8 @@ function reviewWork(args, store, options) {
 }
 /**
  * Task-control recovery for a failed Task-final ReviewRound that never
- * created a Reviewer Run. This is deliberately separate from `task run retry`:
- * that command requires an exact failed Agent Run and remains the only retry
+ * created a Reviewer Turn. This is deliberately separate from `task turn retry`:
+ * that command requires an exact failed Turn 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
@@ -3048,8 +2990,6 @@ function reviewWork(args, store, options) {
  */
 function taskReviewCommand(args, store, options) {
     const [command, ...rest] = args;
-    if (command === "rebind")
-        return rebindTaskFinalReviewContract(rest, store, options);
     if (command === "request")
         return requestTaskReviewRound(rest, store, options);
     if (command === "force-fresh")
@@ -3064,115 +3004,6 @@ function taskReviewCommand(args, store, options) {
         ? "Task review command is required."
         : `Unknown command: task review ${command}`);
 }
-export function parseTaskFinalReviewContractRebindRequest(args) {
-    const usage = "Task review rebind usage: yui task review rebind <task> "
-        + "--from-control <digest> --to-control <digest> "
-        + "--from-release <release-id> --to-release <release-id>.";
-    const parsed = parseTail(args, new Set(["--from-control", "--to-control", "--from-release", "--to-release"]), usage);
-    exactPositionals(parsed.positionals, 1, usage);
-    return {
-        taskId: parsed.positionals[0],
-        fromControlPlaneDigest: requiredOption(parsed.options, "--from-control"),
-        toControlPlaneDigest: requiredOption(parsed.options, "--to-control"),
-        fromReleaseId: requiredOption(parsed.options, "--from-release"),
-        toReleaseId: requiredOption(parsed.options, "--to-release")
-    };
-}
-function rebindTaskFinalReviewContract(args, store, options) {
-    const request = parseTaskFinalReviewContractRebindRequest(args);
-    const environment = options.environment ?? {};
-    const usage = "Task review rebind usage: yui task review rebind <task> "
-        + "--from-control <digest> --to-control <digest> "
-        + "--from-release <release-id> --to-release <release-id>.";
-    if (!isCurrentGlobalOperator(store, environment)) {
-        throw usageError("Task-final Review contract rebind requires the authenticated global Operator session.", usage);
-    }
-    const proof = options.taskFinalReviewRebindProof;
-    if (proof === undefined
-        || proof.schemaVersion !== 1
-        || proof.taskId !== request.taskId
-        || proof.fromControlPlaneDigest !== request.fromControlPlaneDigest
-        || proof.toControlPlaneDigest !== request.toControlPlaneDigest
-        || proof.fromRelease.releaseId !== request.fromReleaseId
-        || proof.toRelease.releaseId !== request.toReleaseId) {
-        throw usageError("Task-final Review contract rebind proof is missing or does not match the explicit request.", usage);
-    }
-    const now = clock(options);
-    const result = store.transaction((tx) => {
-        const task = requireTask(tx, request.taskId);
-        if (task.status !== "active") {
-            throw usageError(`Task is not active: ${task.id}.`);
-        }
-        if (task.projectBindings.length === 0) {
-            throw usageError(`Task final-review contract requires a Project-backed Task: ${task.id}.`);
-        }
-        if (!isCurrentGlobalOperator(tx, environment)) {
-            throw usageError("Task-final Review contract rebind Operator identity drifted before commit.");
-        }
-        const resolution = storedTaskFinalReviewContractResolution(tx, task.id);
-        if (resolution === undefined) {
-            throw usageError(`Task final-review contract is missing for ${task.id}.`);
-        }
-        const exactExisting = resolution.rebinds.at(-1);
-        if (resolution.effective.controlPlaneDigest === request.toControlPlaneDigest) {
-            if (exactExisting !== undefined
-                && exactExisting.fromContract.controlPlaneDigest === request.fromControlPlaneDigest
-                && exactExisting.toContract.controlPlaneDigest === request.toControlPlaneDigest
-                && exactExisting.fromRelease.releaseId === request.fromReleaseId
-                && exactExisting.toRelease.releaseId === request.toReleaseId
-                && exactExisting.handoverId === proof.handoverId) {
-                return { rebind: exactExisting, changed: false };
-            }
-            throw usageError(`Task final-review contract already targets ${request.toControlPlaneDigest} without the requested proof tuple.`);
-        }
-        if (resolution.effective.controlPlaneDigest !== request.fromControlPlaneDigest) {
-            throw usageError(`Task final-review contract source control-plane digest drifted for ${task.id}.`);
-        }
-        const activeRound = tx.listReviewRounds(task.id).find((round) => ((round.scope ?? "work-item") === "task"
-            && (round.status === "pending" || round.status === "running")));
-        if (activeRound !== undefined) {
-            throw usageError(`Task final-review contract cannot rebind while ReviewRound ${activeRound.id} is ${activeRound.status}.`);
-        }
-        const activeLeaderRun = tx.getActiveAgentRun(task.id, "leader");
-        if (activeLeaderRun !== null) {
-            throw usageError(`Task final-review contract cannot rebind while Leader Run ${activeLeaderRun.id} is active.`);
-        }
-        const leaderSessions = tx.getTaskRoleSessionSet(task.id, "leader");
-        if (leaderSessions !== null) {
-            if (leaderSessions.inFlight !== null) {
-                throw usageError("Task final-review contract cannot rebind while the Leader runtime has unsettled Run state.");
-            }
-            const liveLeaderSession = Object.values(leaderSessions.sessions).find(({ status }) => status === "active");
-            if (liveLeaderSession !== undefined) {
-                throw usageError(`Task final-review contract cannot rebind while Leader Session ${liveLeaderSession.agentId} is ${liveLeaderSession.status}.`);
-            }
-            if (Object.keys(leaderSessions.sessions).length > 0
-                || leaderSessions.providerBinding !== null) {
-                tx.saveTaskRoleSessionSet(retireTaskRoleSessionsForWorkspace(leaderSessions, now));
-            }
-        }
-        const rebind = createTaskFinalReviewContractRebind({
-            taskId: task.id,
-            reviewerRoleName: resolution.effective.reviewerRoleName,
-            fromContract: resolution.effective,
-            toControlPlaneDigest: proof.toControlPlaneDigest,
-            fromRelease: proof.fromRelease,
-            toRelease: proof.toRelease,
-            handoverId: proof.handoverId,
-            authorizedBy: `operator:${environment.YUI_AGENT_ID ?? "unknown"}`
-        });
-        const event = recordTaskEventRecord(tx, task.id, TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT, taskFinalReviewContractRebindPayload(rebind), now);
-        enqueueWork(tx, leaderMailbox(task.id), wakeReason("review-contract-rebound", event.id), now, [eventRef(task.id, event.id)]);
-        return { rebind, event, changed: true };
-    });
-    if (result.changed) {
-        notifyMailbox(options.runtime, leaderMailbox(request.taskId), request.taskId);
-    }
-    return output(result.changed
-        ? `Rebound Task-final Review contract for ${request.taskId} from `
-            + `${request.fromControlPlaneDigest} to ${request.toControlPlaneDigest}.\n`
-        : `Task-final Review contract rebind is already recorded for ${request.taskId}.\n`, result);
-}
 function resolveReviewExecutionGroup(args, store, options) {
     const usage = "Task review group resolve usage: yui task review group resolve <task>/<review-round> --decision <accept|reject|blocked> --summary <text> [--lane <lane-id> ...].";
     if (args[0] !== "resolve")
@@ -3203,7 +3034,7 @@ function resolveReviewExecutionGroup(args, store, options) {
             ...(decision === "accept"
                 ? {
                     selectedLaneIds: selectedLaneIds ?? group.lanes
-                        .filter((lane) => lane.status === "yielded" || lane.status === "completed")
+                        .filter((lane) => lane.status === "completed")
                         .map(({ id }) => id)
                 }
                 : selectedLaneIds === undefined ? {} : { selectedLaneIds })
@@ -3323,7 +3154,7 @@ function disposeReviewFindingCommand(args, store, options) {
         const command = {
             disposition,
             by: actor === "leader"
-                ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) ?? actor
+                ? taskLeaderActionTurnId(tx, task.id, options.environment, options.yuiHome) ?? actor
                 : actor,
             ...(parsed.options.get("--note") === undefined ? {} : { note: parsed.options.get("--note") }),
             ...(parsed.options.get("--work-item") === undefined ? {} : { workItemId: parsed.options.get("--work-item") }),
@@ -3496,7 +3327,7 @@ function requestTaskReviewRound(args, store, options) {
             if (requestedLaneRoles.length === 0) {
                 if (exact.status === "running"
                     && exact.executionGroup?.resolution === undefined
-                    && exact.executionGroup?.lanes.some((lane) => (lane.status === "pending" && lane.runId === undefined)))
+                    && exact.executionGroup?.lanes.some((lane) => (lane.status === "pending" && lane.turnId === undefined)))
                     return exact;
                 assertTaskReviewRequestLane(tx, task.id, reviewerRoleName, exact);
                 return exact;
@@ -3525,7 +3356,7 @@ function requestTaskReviewRound(args, store, options) {
             for (const laneRoleName of laneRoles) {
                 const existingLane = exact.executionGroup.lanes.find(({ roleName }) => (roleName === laneRoleName));
                 if (existingLane !== undefined) {
-                    if (existingLane.runId === undefined)
+                    if (existingLane.turnId === undefined)
                         continue;
                     if (existingLane.status !== "running")
                         continue;
@@ -3651,7 +3482,7 @@ function requestTaskReviewRound(args, store, options) {
     });
     if ("kind" in round && round.kind === "busy") {
         return output(`Reviewer ${round.reviewerRoleName} is busy (${round.phase}`
-            + `${round.activeRunId === undefined ? "" : `; Run ${round.activeRunId}`}); `
+            + `${round.activeTurnId === undefined ? "" : `; Turn ${round.activeTurnId}`}); `
             + `${round.activeReviewRoundId === undefined
                 ? ""
                 : `active ReviewRound ${round.activeReviewRoundId}; `}`
@@ -3668,7 +3499,7 @@ const TASK_FINAL_FORCE_FRESH_EVENT = "review.task-final-force-fresh-requested";
 /**
  * Creates a distinct full Task-final ReviewRound only when the exact previous
  * terminal Round durably proves that no semantic review was produced. The
- * source Round, Run, findings, workspace, and terminal report remain immutable
+ * source Round, Turn, findings, workspace, and terminal report remain immutable
  * history; the linking Event is both the audit record and the idempotence key.
  */
 function forceFreshTaskReviewRound(args, store, options) {
@@ -3769,7 +3600,7 @@ function forceFreshTaskReviewRound(args, store, options) {
         tx.saveReviewRound(task.id, created);
         recordTaskEvent(tx, task.id, TASK_FINAL_FORCE_FRESH_EVENT, {
             sourceReviewRoundId: source.id,
-            ...(source.reviewerRunId === undefined ? {} : { sourceReviewerRunId: source.reviewerRunId }),
+            ...(source.reviewerTurnId === undefined ? {} : { sourceReviewerTurnId: source.reviewerTurnId }),
             reviewRoundId: created.id,
             reviewerRoleName: created.reviewerRoleName,
             taskCandidate: JSON.stringify(created.taskCandidate),
@@ -3787,7 +3618,7 @@ function forceFreshTaskReviewRound(args, store, options) {
  * Conservatively classifies an immutable Task-final Review as replaceable.
  * A failed Round keeps the existing no-semantic-evidence behavior. A completed
  * Round needs stronger, mutually corroborating evidence: an explicit internal
- * context/workspace failure, its exact yielded Run and receipt, matching Lane
+ * context/workspace failure, its exact completed Turn, matching Lane
  * output, and the mechanically emitted empty completion Event.
  * This is command eligibility only; it never rewrites the source outcome or
  * changes the global semantic classifier used by the finding ledger.
@@ -3809,7 +3640,7 @@ export function classifyForceFreshReviewRecovery(store, round) {
  */
 function validateDeltaRecheckRequest(store, taskId, candidate, preflight) {
     if (preflight === undefined) {
-        throw usageError("Delta-recheck assessment is missing; the CLI preflight did not run. "
+        throw usageError("Delta-recheck assessment is missing; the CLI preflight did not turn. "
             + "Request a full Review or retry with a current CLI.");
     }
     const previous = store.getReviewRound(taskId, preflight.record.previousReviewRoundId);
@@ -3840,42 +3671,42 @@ function assertTaskReviewRequestLane(store, taskId, reviewerRoleName, reusableRo
         roleName: reviewerRoleName
     }));
     const hasMailboxWork = (mailbox) => (mailbox !== null && workMailboxHasWork(mailbox));
-    const activePointer = store.getActiveAgentRun(taskId, reviewerRoleName);
-    const activeRuns = store.listAgentRuns(taskId).filter((entry) => (entry.roleName === reviewerRoleName && entry.status === "active"));
+    const activePointer = store.getActiveTurn(taskId, reviewerRoleName);
+    const activeTurns = store.listTurns(taskId).filter((entry) => (entry.roleName === reviewerRoleName && entry.status === "active"));
     if (reusableRound === undefined || reusableRound.status === "pending") {
-        if (activePointer !== null || activeRuns.length > 0
+        if (activePointer !== null || activeTurns.length > 0
             || hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
             throw usageError(`Reviewer has unrelated active execution: ${reviewerRoleName}.`);
         }
         return;
     }
     if (reusableRound.status === "completed") {
-        if (activePointer !== null || activeRuns.length > 0
+        if (activePointer !== null || activeTurns.length > 0
             || hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
             throw usageError(`Reviewer has unrelated active execution: ${reviewerRoleName}.`);
         }
         return;
     }
-    const reviewerRunId = reusableRound.reviewerRunId;
-    const activeMatches = reviewerRunId !== undefined
-        && activePointer?.id === reviewerRunId
+    const reviewerTurnId = reusableRound.reviewerTurnId;
+    const activeMatches = reviewerTurnId !== undefined
+        && activePointer?.id === reviewerTurnId
         && activePointer.status === "active"
-        && activeRuns.length === 1
-        && activeRuns[0].id === reviewerRunId;
+        && activeTurns.length === 1
+        && activeTurns[0].id === reviewerTurnId;
     if (!activeMatches) {
         throw usageError(`Existing Task-final ReviewRound ${reusableRound.id} is running without its exact Reviewer execution.`);
     }
-    const exactRun = runRef(taskId, reviewerRunId);
+    const exactTurn = turnRef(taskId, reviewerTurnId);
     const reviewerPending = reviewerMailbox === null ? null : nextPendingBatch(reviewerMailbox);
     const processingMatches = reviewerMailbox?.processing !== null
         && reviewerMailbox?.processing !== undefined
         && reviewerPending === null
         && reviewerMailbox.processing.executionRef !== undefined
-        && isDeepStrictEqual(reviewerMailbox.processing.executionRef, exactRun);
+        && isDeepStrictEqual(reviewerMailbox.processing.executionRef, exactTurn);
     const pendingMatches = reviewerPending !== null
         && reviewerMailbox?.processing === null
         && reviewerPending.requestCount === 1
-        && reviewerPending.refs.some((ref) => isDeepStrictEqual(ref, exactRun));
+        && reviewerPending.refs.some((ref) => isDeepStrictEqual(ref, exactTurn));
     if (hasMailboxWork(reviewerMailbox) && !processingMatches && !pendingMatches) {
         throw usageError(`Reviewer mailbox has unrelated active work: ${reviewerRoleName}.`);
     }
@@ -3899,11 +3730,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.reviewerRunId !== undefined) {
+        if (round.reviewerTurnId !== undefined) {
             if (round.status === "completed") {
                 throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
             }
-            throw usageError(`ReviewRound ${round.id} has Reviewer Run ${round.reviewerRunId}; use task run retry instead.`);
+            throw usageError(`ReviewRound ${round.id} has Reviewer Turn ${round.reviewerTurnId}; use task turn retry instead.`);
         }
         if (round.status !== "failed" && round.status !== "pending") {
             throw usageError(`ReviewRound ${round.id} is not retryable from ${round.status}.`);
@@ -3962,10 +3793,10 @@ function retryFailedTaskReviewRound(args, store, options) {
             roleName: reviewer.name
         }));
         const hasMailboxWork = (mailbox) => (mailbox !== null && workMailboxHasWork(mailbox));
-        const activeReviewerRuns = tx.listAgentRuns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
-        const activePointer = tx.getActiveAgentRun(task.id, reviewer.name);
-        if (activePointer !== null || activeReviewerRuns.length > 0) {
-            throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+        const activeReviewerTurns = tx.listTurns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
+        const activePointer = tx.getActiveTurn(task.id, reviewer.name);
+        if (activePointer !== null || activeReviewerTurns.length > 0) {
+            throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
         }
         if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
             throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
@@ -3988,32 +3819,28 @@ 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 taskRunCommand(args, store, options) {
+function taskTurnCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "list")
-        return output(listRuns(rest, store, options));
+        return output(listTurns(rest, store, options));
     if (command === "show")
-        return showRun(rest, store, options);
+        return showTurn(rest, store, options);
     if (command === "context")
-        return runContextCommand(rest, store, options);
+        return turnContextCommand(rest, store, options);
     if (command === "retry")
-        return retryRun(rest, store, options);
+        return retryTurn(rest, store, options);
     if (command === "settle")
-        return settleStaleFinalReviewRun(rest, store, options);
-    if (command === "yield")
-        return yieldRun(rest, store, options);
-    if (command === "yield-status")
-        return yieldRunStatus(rest, store, options);
+        return settleStaleFinalReviewTurn(rest, store, options);
     if (command === "checkpoint")
-        return output(checkpointRun(rest, store, options));
+        return output(checkpointTurn(rest, store, options));
     if (command === "retire")
-        return retireRun(rest, store, options);
+        return retireTurn(rest, store, options);
     throw usageError(command === undefined
-        ? "Task run command is required."
-        : `Unknown command: task run ${command}`);
+        ? "Task turn command is required."
+        : `Unknown command: task turn ${command}`);
 }
-function retireRun(args, store, options) {
-    const usage = "Task run retire usage: yui task run retire <task>/<run> --reason <text> [--expected-progress-at <timestamp>] [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
+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>].";
     const parsed = parseTail(args, new Set([
         "--reason",
         "--expected-progress-at",
@@ -4025,23 +3852,23 @@ function retireRun(args, store, options) {
     ]), usage);
     exactPositionals(parsed.positionals, 1, usage);
     const reason = requiredOption(parsed.options, "--reason");
-    const reference = taskRecordReference(parsed.positionals[0], "agentRun", "Agent Run reference", options);
+    const reference = taskRecordReference(parsed.positionals[0], "turn", "Turn 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.getAgentRun(task.id, reference.localId);
+        let run = tx.getTurn(task.id, reference.localId);
         if (run === null)
-            throw dataError(`Agent Run not found: ${task.id}/${reference.localId}.`);
+            throw dataError(`Turn not found: ${task.id}/${reference.localId}.`);
         const events = tx.listEvents(task.id);
-        if (isTaskRecordRetired(events, "agent-run", run.id)) {
-            return { task, run, changed: false };
+        if (isTaskRecordRetired(events, "turn", run.id)) {
+            return { task, turn: run, changed: false };
         }
         if (run.status === "active") {
             if (actor === "leader"
-                && taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome) === run.id) {
-                throw usageError("A Task Leader cannot retire its own current authority Run.", usage);
+                && taskLeaderActionTurnId(tx, task.id, options.environment, options.yuiHome) === 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"
@@ -4056,31 +3883,31 @@ function retireRun(args, store, options) {
             const sessions = tx.getTaskRoleSessionSet(task.id, run.roleName);
             const session = sessions?.sessions[run.effective.agentId];
             if (session?.nativeSessionId !== undefined && nativeSessionId === undefined) {
-                throw usageError("--native-session-id is required for this active Run.", usage);
+                throw usageError("--native-session-id is required for this active Turn.", usage);
             }
             if (session?.nativeSessionId === undefined && launchId === undefined) {
-                throw usageError("--launch-id is required for an opaque active Run.", usage);
+                throw usageError("--launch-id is required for an opaque active Turn.", usage);
             }
-            const terminal = retireExactActiveAgentRun(tx, {
+            const terminal = retireExactActiveTurn(tx, {
                 taskId: task.id,
                 roleName: run.roleName,
-                runId: run.id,
+                turnId: run.id,
                 agentId,
                 adapterId,
                 ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
                 ...(launchId === undefined ? {} : { launchId }),
                 expectedProgressAt,
-                reason: `Agent Run retired: ${reason}`
+                reason: `Turn retired: ${reason}`
             }, now);
-            if (terminal.disposition !== "applied" || terminal.run === null) {
+            if (terminal.disposition !== "applied" || terminal.turn === null) {
                 throw usageError(terminal.disposition === "blocked"
-                    ? `Agent Run retirement is blocked: ${run.id}/${terminal.reason ?? "unsafe"}.`
-                    : `Agent Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+                    ? `Turn retirement is blocked: ${run.id}/${terminal.reason ?? "unsafe"}.`
+                    : `Turn changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
             }
-            run = terminal.run;
+            run = terminal.turn;
         }
-        recordTaskEvent(tx, task.id, "run.retired", {
-            runId: run.id,
+        recordTaskEvent(tx, task.id, "turn.retired", {
+            turnId: run.id,
             reason,
             ...(parsed.options.get("--expected-progress-at") === undefined
                 && parsed.options.get("--progress-at") === undefined
@@ -4102,69 +3929,69 @@ function retireRun(args, store, options) {
         tx.saveEvent(task.id, createTaskRecordRetirement({
             eventId: tx.nextEventId(task.id),
             taskId: task.id,
-            recordKind: "agent-run",
+            recordKind: "turn",
             recordId: run.id,
             reason,
             retiredBy: actor
         }, now));
-        return { task, run, changed: true };
+        return { task, turn: run, changed: true };
     });
     if (result.changed)
         options.runtime?.notifyStateChanged(result.task.id);
-    return output(`Retired Agent Run ${result.task.id}/${result.run.id}\n`, {
-        agentRun: result.run,
+    return output(`Retired Turn ${result.task.id}/${result.turn.id}\n`, {
+        turn: result.turn,
         retired: true
     });
 }
-function runContextCommand(args, store, options) {
+function turnContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
-        const usage = "Task run context expand usage: yui task run context expand <task>/<run> <ref-id> [--store <store>] [--mode full].";
+        const usage = "Task turn context expand usage: yui task turn context expand <task>/<turn> <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("Run Context expansion mode must be full.", usage);
+            throw usageError("Turn Context expansion mode must be full.", usage);
         }
-        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")));
+        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")));
         return output(`${JSON.stringify(expanded, null, 2)}\n`, { context: expanded });
     }
     if (first === "delta") {
         if (rest.length !== 3 || rest[1] !== "--after") {
-            throw usageError("Task run context delta usage: yui task run context delta <task>/<run> --after <cursor>.");
+            throw usageError("Task turn context delta usage: yui task turn context delta <task>/<turn> --after <cursor>.");
         }
-        const { taskId, runId } = parseRunContextReference(rest[0]);
-        authorizeRunContext(store, taskId, runId, options.environment);
-        const delta = store.transaction((tx) => (buildRunContextDelta(tx, taskId, runId, rest[2])));
+        const { taskId, turnId } = parseTurnContextReference(rest[0]);
+        authorizeTurnContext(store, taskId, turnId, options.environment);
+        const delta = store.transaction((tx) => (buildTurnContextDelta(tx, taskId, turnId, rest[2])));
         return output(`${JSON.stringify(delta, null, 2)}\n`, { contextDelta: delta });
     }
     if (first === undefined || rest.length !== 0) {
-        throw usageError("Task run context usage: yui task run context <task>/<run>.");
+        throw usageError("Task turn context usage: yui task turn context <task>/<turn>.");
     }
-    const { taskId, runId } = parseRunContextReference(first);
-    authorizeRunContext(store, taskId, runId, options.environment);
-    const pack = store.transaction((tx) => buildRunContextPack(tx, taskId, runId));
+    const { taskId, turnId } = parseTurnContextReference(first);
+    authorizeTurnContext(store, taskId, turnId, options.environment);
+    const pack = store.transaction((tx) => buildTurnContextPack(tx, taskId, turnId));
     return output(`${JSON.stringify(pack, null, 2)}\n`, { context: pack });
 }
-function parseRunContextReference(value) {
-    const [taskId, runId, extra] = value.split("/");
-    if (taskId === undefined || taskId.length === 0 || runId === undefined || runId.length === 0
+function parseTurnContextReference(value) {
+    const [taskId, turnId, extra] = value.split("/");
+    if (taskId === undefined || taskId.length === 0 || turnId === undefined || turnId.length === 0
         || extra !== undefined) {
-        throw usageError(`Run context reference is invalid: ${value}.`);
+        throw usageError(`Turn context reference is invalid: ${value}.`);
     }
-    return { taskId, runId };
+    return { taskId, turnId };
 }
-function authorizeRunContext(store, taskId, runId, environment) {
+function authorizeTurnContext(store, taskId, turnId, environment) {
     const managed = environment?.YUI_SESSION_SCOPE !== undefined
         || environment?.YUI_TASK_ID !== undefined
         || environment?.YUI_ROLE !== undefined
-        || environment?.YUI_RUN_ID !== undefined;
+        || environment?.YUI_TURN_ID !== undefined;
     if (!managed)
         return;
-    const run = store.getAgentRun(taskId, runId);
-    const active = run === null ? null : store.getActiveAgentRun(taskId, run.roleName);
+    const run = store.getTurn(taskId, turnId);
+    const active = run === null ? null : store.getActiveTurn(taskId, run.roleName);
     if (environment?.YUI_SESSION_SCOPE !== "task"
         || environment.YUI_TASK_ID !== taskId
         || run === null
@@ -4172,27 +3999,32 @@ function authorizeRunContext(store, taskId, runId, environment) {
         || environment.YUI_AGENT_ID !== run.effective.agentId
         || environment.YUI_ADAPTER_ID !== run.effective.adapterId
         || run.status !== "active"
-        || active?.id !== runId) {
-        throw usageError(`Run Context access is not authorized: ${taskId}/${runId}.`);
+        || active?.id !== turnId) {
+        throw usageError(`Turn Context access is not authorized: ${taskId}/${turnId}.`);
     }
     const callerKey = environment.YUI_JOB_CALLER_KEY;
     const expectedCallerKeyHash = store.getJobCallerKeyHash(taskId, run.roleName, run.effective.agentId);
     if (callerKey === undefined
         || expectedCallerKeyHash === null
         || createHash("sha256").update(callerKey).digest("hex") !== expectedCallerKeyHash) {
-        throw usageError(`Run Context caller key is not authorized: ${taskId}/${runId}.`);
+        throw usageError(`Turn Context caller key is not authorized: ${taskId}/${turnId}.`);
     }
 }
-function listRuns(args, store, options) {
-    exactPositionals(args, 1, "Task run list usage: yui task run list <task>/<work>.");
-    const item = requireWorkItem(store, args[0], options);
-    const runs = store.listAgentRuns(item.taskId).filter((run) => run.workItemId === item.id);
-    if (runs.length === 0)
-        return "No runs found.\n";
-    const events = store.listEvents(item.taskId);
-    return `${renderTable(`Runs: ${item.id}`, [
-        { header: "Run", minWidth: 6, maxWidth: 20 },
+function listTurns(args, store, options) {
+    const usage = "Task turn list usage: yui task turn 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 events = store.listEvents(taskId);
+    return `${renderTable(`Turns: ${item?.id ?? taskId}`, [
+        { header: "Turn", minWidth: 6, maxWidth: 20 },
         { header: "Role", minWidth: 4, maxWidth: 22 },
+        { header: "Subject", minWidth: 7, maxWidth: 24 },
         { header: "Purpose", minWidth: 6, maxWidth: 10 },
         { header: "Mode", minWidth: 4, maxWidth: 8 },
         { header: "Effective", minWidth: 10, maxWidth: 30 },
@@ -4201,38 +4033,39 @@ function listRuns(args, store, options) {
         { header: "Status", minWidth: 6, maxWidth: 12 },
         { header: "History", minWidth: 7, maxWidth: 9 },
         { header: "Summary", minWidth: 8, maxWidth: 58 }
-    ], runs.map((run) => [
+    ], turns.map((run) => [
         run.id,
         run.roleName,
+        run.workItemId ?? (run.reviewRoundId === undefined ? "task" : `review:${run.reviewRoundId}`),
         run.purpose,
         run.mode,
         `${run.effective.agentId}/${run.effective.adapterId} r${run.effective.sourceDesiredRevision}`,
         run.effective.profileAccess,
         run.effective.permission.strategy,
         run.status,
-        isTaskRecordRetired(events, "agent-run", run.id) ? "retired" : "active",
-        run.summary ?? "-"
+        isTaskRecordRetired(events, "turn", run.id) ? "retired" : "active",
+        run.result?.output ?? "-"
     ]), defaultTableWidth())}\n`;
 }
 /**
- * Settles only the known bootstrap split where a failed Task-final Run
+ * Settles only the known bootstrap split where a failed Task-final Turn
  * 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 settleStaleFinalReviewRun(args, store, options) {
-    exactPositionals(args, 1, "Task run settle usage: yui task run settle <task>/<run>.");
+function settleStaleFinalReviewTurn(args, store, options) {
+    exactPositionals(args, 1, "Task turn settle usage: yui task turn settle <task>/<turn>.");
     const now = clock(options);
-    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
+    const previous = store.transaction((tx) => requireTurn(tx, args[0], options));
     const result = store.transaction((tx) => {
-        const run = tx.getAgentRun(previous.taskId, previous.id);
+        const run = tx.getTurn(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "review") {
-            throw usageError(`Run ${previous.id} is not a failed review run.`);
+            throw usageError(`Turn ${previous.id} is not a failed review Turn.`);
         }
         if (run.reviewRoundId === undefined) {
-            throw usageError(`Review Run ${run.id} has no ReviewRound.`);
+            throw usageError(`Review Turn ${run.id} has no ReviewRound.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -4240,30 +4073,30 @@ function settleStaleFinalReviewRun(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 run ${run.id}: ${run.reviewRoundId}.`);
+            throw dataError(`ReviewRound not found for Turn ${run.id}: ${run.reviewRoundId}.`);
         }
         if ((round.scope ?? "work-item") !== "task") {
-            throw usageError(`Review Run ${run.id} is not a Task-final review; request a new WorkItem review `
+            throw usageError(`Review Turn ${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 Run/Round,
+        // This read-only compare-and-swap fence covers the exact Turn/Round,
         // Candidate, stored Review workspace, frozen Project scope, and frozen
         // Project heads before any mailbox or Round write.
-        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
+        const validation = validateExactTurnReviewRound(tx, run, { allowTerminal: true });
         if (validation.disposition !== "applied" || validation.round === null) {
-            throw usageError(`Review Run ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
+            throw usageError(`Review Turn ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
         }
-        const activeReviewerRun = tx.listAgentRuns(task.id).find((entry) => (entry.purpose === "review"
+        const activeReviewerTurn = tx.listTurns(task.id).find((entry) => (entry.purpose === "review"
             && entry.roleName === round.reviewerRoleName
             && entry.status === "active"));
-        const activeRoleRun = tx.getActiveAgentRun(task.id, round.reviewerRoleName);
-        if (activeReviewerRun !== undefined || activeRoleRun !== null) {
-            const active = activeReviewerRun ?? activeRoleRun;
-            throw usageError(`${task.id}/${round.reviewerRoleName} already has active Run ${active.id}.`);
+        const activeRoleTurn = tx.getActiveTurn(task.id, round.reviewerRoleName);
+        if (activeReviewerTurn !== undefined || activeRoleTurn !== null) {
+            const active = activeReviewerTurn ?? activeRoleTurn;
+            throw usageError(`${task.id}/${round.reviewerRoleName} already has active Turn ${active.id}.`);
         }
         const taskRounds = reviewRoundsByIdentity(tx.listReviewRounds(task.id)
             .filter((entry) => (entry.scope ?? "work-item") === "task"));
@@ -4280,13 +4113,13 @@ function settleStaleFinalReviewRun(args, store, options) {
             throw usageError(`Final ReviewRound ${round.id} freezes the current Task candidate; use exact retry.`);
         }
         if (round.status === "failed") {
-            const summary = run.summary?.trim();
+            const summary = run.result?.output.trim();
             if (summary !== undefined
                 && round.summary === summary
                 && round.report === summary
                 && (round.checks?.length ?? 0) === 0
                 && round.evidenceCommit === undefined) {
-                return { run, round, changed: false };
+                return { turn: run, round, changed: false };
             }
             throw usageError(`Final ReviewRound is already terminal: ${round.id}/${round.status}.`);
         }
@@ -4296,11 +4129,11 @@ function settleStaleFinalReviewRun(args, store, options) {
         const reviewerTarget = roleMailbox(task.id, round.reviewerRoleName);
         const reviewerMailbox = tx.getWorkMailbox(reviewerTarget);
         const reviewerPending = reviewerMailbox === null ? null : nextPendingBatch(reviewerMailbox);
-        const exactRunRef = runRef(task.id, run.id);
+        const exactTurnRef = turnRef(task.id, run.id);
         if (reviewerMailbox?.processing !== null && reviewerMailbox?.processing !== undefined) {
             const processing = reviewerMailbox.processing;
             if (processing.executionRef === undefined
-                || !isDeepStrictEqual(processing.executionRef, exactRunRef)
+                || !isDeepStrictEqual(processing.executionRef, exactTurnRef)
                 || reviewerPending !== null) {
                 throw usageError(`Reviewer mailbox has unrelated processing work: ${round.reviewerRoleName}.`);
             }
@@ -4308,7 +4141,7 @@ function settleStaleFinalReviewRun(args, store, options) {
         else if (reviewerPending !== null) {
             const pending = reviewerPending;
             if (pending.requestCount !== 1
-                || !pending.refs.some((ref) => isDeepStrictEqual(ref, exactRunRef))) {
+                || !pending.refs.some((ref) => isDeepStrictEqual(ref, exactTurnRef))) {
                 throw usageError(`Reviewer mailbox has unrelated pending work: ${round.reviewerRoleName}.`);
             }
         }
@@ -4323,10 +4156,10 @@ function settleStaleFinalReviewRun(args, store, options) {
         if (runtimeMailbox !== null && workMailboxHasWork(runtimeMailbox)) {
             throw usageError(`Reviewer runtime lifecycle has pending work: ${round.reviewerRoleName}.`);
         }
-        // A matching pending/processing dispatch belongs to this failed Run and
+        // A matching pending/processing dispatch belongs to this failed Turn and
         // is safe to settle here. It is never merged with unrelated mailbox work.
         if (reviewerMailbox !== null && reviewerMailbox !== undefined) {
-            const settlement = settleExactWorkExecution(tx, reviewerTarget, exactRunRef);
+            const settlement = settleExactWorkExecution(tx, reviewerTarget, exactTurnRef);
             if (settlement === "absent") {
                 throw usageError(`Reviewer mailbox changed before stale final settlement: ${round.reviewerRoleName}.`);
             }
@@ -4334,53 +4167,53 @@ function settleStaleFinalReviewRun(args, store, options) {
         // Preserve any report/check/evidence already attached to the old Round;
         // terminalization only adds the missing failure boundary and end time.
         const summary = round.summary
-            ?? run.summary
-            ?? `Review Run ${run.id} failed before delivery; committed Task heads changed.`;
+            ?? run.result?.output
+            ?? `Review Turn ${run.id} failed before delivery; committed Task heads changed.`;
         const terminal = finishReviewRound(round, "failed", summary, now, {
             report: round.report ?? summary,
             checks: round.checks ?? [],
             ...(round.evidenceCommit === undefined ? {} : { evidenceCommit: round.evidenceCommit })
         });
         tx.saveReviewRound(task.id, terminal);
-        recordTaskEvent(tx, task.id, "run.review-stale-settled", {
-            runId: run.id,
+        recordTaskEvent(tx, task.id, "turn.review-stale-settled", {
+            turnId: 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 { run, round: terminal, changed: true };
+        return { turn: run, round: terminal, changed: true };
     });
     return output(result.changed
-        ? `Settled obsolete final Review ${result.round.id} from failed Run ${result.run.id}\n`
-        : `Obsolete final Review already settled: ${result.round.id}/${result.run.id}\n`, { reviewRound: result.round, reviewRun: result.run });
+        ? `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 });
 }
-function retryRun(args, store, options) {
-    exactPositionals(args, 1, "Task run retry usage: yui task run retry <task>/<run>.");
+function retryTurn(args, store, options) {
+    exactPositionals(args, 1, "Task turn retry usage: yui task turn retry <task>/<turn>.");
     const now = clock(options);
-    const previous = store.transaction((tx) => requireRun(tx, args[0], options));
+    const previous = store.transaction((tx) => requireTurn(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(`Run ${previous.id} is not retryable from ${previous.status}.`);
+            throw usageError(`Turn ${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 Run");
+        assertTaskExecutionEnabled(task, "retrying a Turn");
         const role = requireRole(tx, task.id, previous.roleName);
-        if (tx.getActiveAgentRun(task.id, role.name) !== null) {
-            throw usageError(`${task.id}/${role.name} already has an active run.`);
+        if (tx.getActiveTurn(task.id, role.name) !== null) {
+            throw usageError(`${task.id}/${role.name} already has an active turn.`);
         }
         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 run ${previous.id}: ${previous.workItemId}.`);
+            throw dataError(`Work item not found for Turn ${previous.id}: ${previous.workItemId}.`);
         }
         const retryLaneBefore = previous.executionLaneId === undefined
             ? undefined
@@ -4398,9 +4231,9 @@ function retryRun(args, store, options) {
             && retryLaneBefore !== undefined
             && retryLaneBefore.id === previous.executionLaneId
             && retryLaneBefore.status === "failed"
-            && retryLaneBefore.runId === previous.id);
+            && retryLaneBefore.turnId === previous.id);
         if (!exactCurrentLane) {
-            throw usageError(`Run ${previous.id} no longer owns the current failed Execution Lane.`);
+            throw usageError(`Turn ${previous.id} no longer owns the current failed Execution Lane.`);
         }
         const groupedRunningRetry = retryItem?.status === "running"
             && retriesExecutionLane
@@ -4425,7 +4258,7 @@ function retryRun(args, store, options) {
                 && (retryGroup === undefined
                     || retryGroup.id !== previous.executionGroupId
                     || retryLane === undefined))) {
-            throw dataError(`Run ${previous.id} execution lineage no longer matches its Work Item.`);
+            throw dataError(`Turn ${previous.id} execution lineage no longer matches its Work Item.`);
         }
         const retryManagedWorkspace = retryLane === undefined
             ? runWorkspace
@@ -4443,9 +4276,9 @@ function retryRun(args, store, options) {
                 writableProjectIds: [...(retryItem?.writeProjectIds ?? [])]
             };
         const retryDirective = retryLane?.directive
-            ?? previous.assignment.directive
+            ?? previous.inputs[0].input.directive
             ?? retryItem?.objective
-            ?? `Retry Run ${previous.id}.`;
+            ?? `Retry Turn ${previous.id}.`;
         let queuedReason;
         if (retryGroup !== undefined && retryLane !== undefined && retryItem !== null) {
             const config = tx.getConfig();
@@ -4466,7 +4299,7 @@ function retryRun(args, store, options) {
                     usage: observedExecutionResourceUsage({
                         group: retryGroup,
                         stageGroups,
-                        runs: tx.listAgentRuns(task.id),
+                        turns: tx.listTurns(task.id),
                         events: tx.listEvents(task.id)
                     }),
                     now
@@ -4496,12 +4329,12 @@ function retryRun(args, store, options) {
             if (admission.decision === "queued")
                 queuedReason = admission.reason;
         }
-        const runId = queuedReason === undefined ? tx.nextAgentRunId(task.id) : undefined;
+        const turnId = queuedReason === undefined ? tx.nextTurnId(task.id) : undefined;
         const runningGroup = retryGroup === undefined || retryLane === undefined
             ? undefined
             : queuedReason === undefined
                 ? restartExecutionLane(retryGroup, retryLane.id, {
-                    runId: runId,
+                    turnId: turnId,
                     effective,
                     ...(laneWorkspace === undefined ? {} : { workspace: laneWorkspace }),
                     directive: retryDirective
@@ -4540,32 +4373,24 @@ function retryRun(args, store, options) {
                 reason: queuedReason
             };
         }
-        const retrySnapshot = freezeRunContextSnapshot(tx, {
+        const retrySnapshot = freezeTurnContextSnapshot(tx, {
             taskId: task.id,
             roleName: role.name,
             purpose: "execution",
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId })
         }, now, "controller", retryGroup?.stage?.contextSnapshotRef);
-        const assignment = createRunAssignment({
-            runId: runId,
-            roleName: role.name,
-            purpose: previous.assignment.purpose,
-            action: previous.workItemId === undefined ? previous.assignment.action : "repair-work-item",
-            subject: {
-                taskId: task.id,
-                ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
-                ...(runningGroup === undefined ? {} : {
-                    executionGroupId: runningGroup.id,
-                    executionLaneId: retryLane.id
-                })
+        const input = createTurnInput({
+            source: {
+                type: "yui",
+                channel: previous.workItemId === undefined ? "task-dispatch" : "workitem-dispatch"
             },
-            ...(previous.assignment.directive === undefined
+            ...(previous.inputs[0].input.directive === undefined
                 ? {}
-                : { directive: previous.assignment.directive }),
+                : { directive: previous.inputs[0].input.directive }),
             contextSnapshotRef: contextSnapshotRef(retrySnapshot),
             deltaRefIds: contextSnapshotDeltaRefIds(tx, retrySnapshot)
         });
-        const created = createAgentRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
+        const created = createTurn(turnId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), input, now, {
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
             ...(runningGroup === undefined ? {} : {
                 executionGroupId: runningGroup.id,
@@ -4574,8 +4399,8 @@ function retryRun(args, store, options) {
             ...(retryManagedWorkspace === undefined ? {} : { workspace: retryManagedWorkspace }),
             effective
         });
-        tx.saveAgentRun(created);
-        tx.saveActiveAgentRun(created);
+        tx.saveTurn(created);
+        tx.saveActiveTurn(created);
         if (previous.workItemId !== undefined && retriedItemWithGroup !== null) {
             const item = retriedItemWithGroup;
             const workspace = tx.getWorkItemWorkspace(task.id, item.id);
@@ -4585,18 +4410,18 @@ function retryRun(args, store, options) {
                     + `cannot retry ${item.id}.`);
             }
         }
-        enqueueWork(tx, roleMailbox(task.id, role.name), "run-retried", now, [runRef(task.id, created.id)]);
-        recordTaskEvent(tx, task.id, "run.retried", {
-            ...runLaunchEventPayload(created),
-            previousRunId: previous.id
+        enqueueWork(tx, roleMailbox(task.id, role.name), "turn-retried", now, [turnRef(task.id, created.id)]);
+        recordTaskEvent(tx, task.id, "turn.retried", {
+            ...turnLaunchEventPayload(created),
+            previousTurnId: previous.id
         }, now);
-        return { kind: "run", run: created };
+        return { kind: "turn", turn: created };
     });
     if (retried.kind === "queued") {
         return output(`Retry retained pending for ${retried.taskId}/${retried.laneId}: ${retried.reason}\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`);
+    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`);
 }
 function actualTaskReviewCandidateForMutation(store, task, options) {
     if (options.actualTaskReviewCandidate === undefined) {
@@ -4646,7 +4471,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 Run is created.
+ * head. Drift fails closed before a Reviewer Turn is created.
  */
 function taskReviewProvenance(store, task, options, expected) {
     const candidate = actualTaskReviewCandidateForMutation(store, task, options);
@@ -4707,13 +4532,13 @@ function taskReviewProvenance(store, task, options, expected) {
                         recordProducer(LEADER_ROLE, item.id);
                         continue;
                     }
-                    const sourceRun = store.getAgentRun(task.id, itemCandidate.source.runId);
+                    const sourceRun = store.getTurn(task.id, itemCandidate.source.turnId);
                     if (sourceRun === null
                         || sourceRun.workItemId !== item.id
                         || sourceRun.purpose !== "execution"
-                        || sourceRun.status !== "yielded") {
-                        throw dataError(`Committed producer Candidate Run is unavailable: `
-                            + `${item.id}/${itemCandidate.source.runId}.`);
+                        || sourceRun.status !== "completed") {
+                        throw dataError(`Committed producer Candidate Turn is unavailable: `
+                            + `${item.id}/${itemCandidate.source.turnId}.`);
                     }
                     recordProducer(sourceRun.roleName, item.id);
                 }
@@ -4771,7 +4596,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.activeRunId === undefined ? "" : `; Run ${availability.activeRunId}`}); `
+            + `${availability.activeTurnId === undefined ? "" : `; Turn ${availability.activeTurnId}`}); `
             + `retry after ${availability.retryAfterSeconds}s.`);
     }
     let reviewer = store.getRole(task.id, config.roleName);
@@ -4837,8 +4662,8 @@ function resumablePendingFinalTaskReview(store, task, round, config, taskCandida
         || round.reviewerRoleName !== taskFinalContract.reviewerRoleName) {
         throw usageError(`Pending final ReviewRound Reviewer identity changed: ${round.id}.`);
     }
-    if (round.reviewerRunId !== undefined) {
-        throw usageError(`Pending final ReviewRound already records Reviewer Run ${round.reviewerRunId}: ${round.id}.`);
+    if (round.reviewerTurnId !== undefined) {
+        throw usageError(`Pending final ReviewRound already records Reviewer Turn ${round.reviewerTurnId}: ${round.id}.`);
     }
     if (!isSameTaskReviewCandidate(round.taskCandidate, taskCandidate)) {
         throw usageError(`Final ReviewRound ${round.id} freezes a candidate that is no longer the current Task candidate.`);
@@ -4848,8 +4673,8 @@ function resumablePendingFinalTaskReview(store, task, round, config, taskCandida
     if (reviewer === null || reviewer.name !== round.reviewerRoleName) {
         throw usageError(`Pending final ReviewRound Reviewer identity changed: ${round.id}.`);
     }
-    if (store.getActiveAgentRun(task.id, reviewer.name) !== null) {
-        throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+    if (store.getActiveTurn(task.id, reviewer.name) !== null) {
+        throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
     }
     assertPendingFinalReviewWorkspaceEvidence(store, task, round);
     const provenance = taskReviewProvenance(store, task, options, taskCandidate);
@@ -4890,20 +4715,20 @@ function assertPendingFinalReviewWorkspaceEvidence(store, task, round) {
     }
 }
 /**
- * Task-control retry of an exact failed Task-final review Run. The old failed
- * Run remains the attempt trail, while the semantic ReviewRound is reset to
+ * Task-control retry of an exact failed Task-final review Turn. The old failed
+ * Turn remains the attempt trail, while the semantic ReviewRound is reset to
  * pending under its existing identity. Every identity and frozen-head fence is
  * checked inside one transaction so a partial fail-old-without-reset state can
  * never be committed.
  */
 function retryFailedReviewRun(previous, store, options, now) {
     const result = store.transaction((tx) => {
-        const run = tx.getAgentRun(previous.taskId, previous.id);
+        const run = tx.getTurn(previous.taskId, previous.id);
         if (run === null || run.status !== "failed" || run.purpose !== "review") {
-            throw usageError(`Run ${previous.id} is not a failed review run.`);
+            throw usageError(`Turn ${previous.id} is not a failed review Turn.`);
         }
         if (run.reviewRoundId === undefined) {
-            throw usageError(`Review Run ${run.id} has no ReviewRound.`);
+            throw usageError(`Review Turn ${run.id} has no ReviewRound.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
@@ -4914,7 +4739,7 @@ function retryFailedReviewRun(previous, store, options, now) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);
         }
         if ((round.scope ?? "work-item") !== "task") {
-            throw usageError(`Review Run ${run.id} is not a Task-final review; request a new WorkItem review `
+            throw usageError(`Review Turn ${run.id} is not a Task-final review; request a new WorkItem review `
                 + "for a new Candidate.");
         }
         const retryLane = run.executionLaneId === undefined
@@ -4922,9 +4747,9 @@ 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.runId !== run.id
+            || retryLane.turnId !== run.id
             || retryLane.roleName !== run.roleName)) {
-            throw usageError(`Review Run ${run.id} no longer owns its exact Review Lane attempt.`);
+            throw usageError(`Review Turn ${run.id} no longer owns its exact Review Lane attempt.`);
         }
         const panelGroup = round.executionGroup !== undefined
             && (round.executionGroup.lanes.length > 1
@@ -4933,7 +4758,7 @@ function retryFailedReviewRun(previous, store, options, now) {
             && panelGroup
             && retryLane?.status === "failed";
         if (round.status === "running" && panelGroup && !runningPanelLaneRetry) {
-            throw usageError(`Review Run ${run.id} is not the current failed Lane attempt in running Round ${round.id}.`);
+            throw usageError(`Review Turn ${run.id} is not the current failed Lane attempt in running Round ${round.id}.`);
         }
         const retryReviewerRoleName = retryLane?.roleName ?? round.reviewerRoleName;
         const taskFinalContract = taskFinalReviewContractForMutation(tx, task.id, options);
@@ -4977,12 +4802,12 @@ function retryFailedReviewRun(previous, store, options, now) {
         }));
         const hasMailboxWork = (mailbox) => (mailbox !== null && workMailboxHasWork(mailbox));
         const reviewer = requireRole(tx, task.id, retryReviewerRoleName);
-        const activePointer = tx.getActiveAgentRun(task.id, reviewer.name);
-        const activeReviewerRuns = tx.listAgentRuns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
+        const activePointer = tx.getActiveTurn(task.id, reviewer.name);
+        const activeReviewerTurns = tx.listTurns(task.id).filter((entry) => (entry.roleName === reviewer.name && entry.status === "active"));
         // Issue 06: a completed same-Round retry is a no-write idempotent result.
         if (round.status === "completed") {
-            if (activePointer !== null || activeReviewerRuns.length > 0) {
-                throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+            if (activePointer !== null || activeReviewerTurns.length > 0) {
+                throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
             }
             if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
                 throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
@@ -4990,24 +4815,24 @@ function retryFailedReviewRun(previous, store, options, now) {
             return { round, previousRun: run, created: false };
         }
         // Issue 06: a running same Round is reusable only with its exact active
-        // Run and mailbox execution. A stranded Run (no active pointer) falls
+        // Turn and mailbox execution. A stranded Turn (no active pointer) falls
         // through and resets the Round after the identity fences below.
         if (round.status === "running" && !runningPanelLaneRetry) {
-            const reviewerRunId = round.reviewerRunId;
-            const activeMatches = reviewerRunId !== undefined
+            const reviewerTurnId = round.reviewerTurnId;
+            const activeMatches = reviewerTurnId !== undefined
                 && activePointer !== null
-                && activePointer.id === reviewerRunId
+                && activePointer.id === reviewerTurnId
                 && activePointer.status === "active"
-                && activeReviewerRuns.length === 1
-                && activeReviewerRuns[0].id === reviewerRunId;
-            const processingMatches = reviewerRunId !== undefined
+                && activeReviewerTurns.length === 1
+                && activeReviewerTurns[0].id === reviewerTurnId;
+            const processingMatches = reviewerTurnId !== undefined
                 && reviewerMailbox?.processing?.executionRef !== undefined
-                && isDeepStrictEqual(reviewerMailbox.processing.executionRef, runRef(task.id, reviewerRunId))
+                && isDeepStrictEqual(reviewerMailbox.processing.executionRef, turnRef(task.id, reviewerTurnId))
                 && reviewerPending === null;
-            const pendingMatches = reviewerRunId !== undefined
+            const pendingMatches = reviewerTurnId !== undefined
                 && reviewerMailbox?.processing === null
                 && reviewerPending?.requestCount === 1
-                && reviewerPending.refs.some((ref) => (isDeepStrictEqual(ref, runRef(task.id, reviewerRunId))));
+                && reviewerPending.refs.some((ref) => (isDeepStrictEqual(ref, turnRef(task.id, reviewerTurnId))));
             if (activePointer !== null
                 && (!activeMatches
                     || (!processingMatches && !pendingMatches)
@@ -5019,16 +4844,16 @@ function retryFailedReviewRun(previous, store, options, now) {
         }
         // Issue 06: an already-pending Round is the idempotent retry result.
         if (round.status === "pending") {
-            if (activePointer !== null || activeReviewerRuns.length > 0) {
-                throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+            if (activePointer !== null || activeReviewerTurns.length > 0) {
+                throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
             }
             if (hasMailboxWork(reviewerMailbox) || hasMailboxWork(runtimeMailbox)) {
                 throw usageError(`Reviewer has unrelated mailbox work: ${reviewer.name}.`);
             }
             return { round, previousRun: run, created: false };
         }
-        if (activePointer !== null || activeReviewerRuns.length > 0) {
-            throw usageError(`Reviewer Role already has an active run: ${reviewer.name}.`);
+        if (activePointer !== null || activeReviewerTurns.length > 0) {
+            throw usageError(`Reviewer Role already has an active Turn: ${reviewer.name}.`);
         }
         if (runtimeMailbox?.processing !== null && runtimeMailbox?.processing !== undefined) {
             throw usageError(`Reviewer runtime lifecycle is pending: ${reviewer.name}.`);
@@ -5036,36 +4861,36 @@ function retryFailedReviewRun(previous, store, options, now) {
         if (runtimeMailbox !== null && workMailboxHasWork(runtimeMailbox)) {
             throw usageError(`Reviewer runtime lifecycle has pending work: ${reviewer.name}.`);
         }
-        const validation = validateExactRunReviewRound(tx, run, { allowTerminal: true });
+        const validation = validateExactTurnReviewRound(tx, run, { allowTerminal: true });
         if (validation.disposition !== "applied" || validation.round === null) {
-            throw usageError(`Review Run ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
+            throw usageError(`Review Turn ${run.id} identity does not match its ReviewRound or frozen Task state changed: ${validation.reason ?? "mismatch"}.`);
         }
-        // A stranded pre-delivery Run can leave its exact pending or processing
+        // A stranded pre-delivery Turn can leave its exact pending or processing
         // dispatch behind; settle only that exact reference while holding the
         // same aggregate lock. Any merged or unrelated batch fails closed.
-        const exactOldRunRef = runRef(task.id, run.id);
+        const exactOldTurnRef = turnRef(task.id, run.id);
         if (reviewerMailbox?.processing !== null && reviewerMailbox?.processing !== undefined) {
             if (reviewerMailbox.processing.executionRef === undefined
-                || !isDeepStrictEqual(reviewerMailbox.processing.executionRef, exactOldRunRef)
+                || !isDeepStrictEqual(reviewerMailbox.processing.executionRef, exactOldTurnRef)
                 || reviewerPending !== null) {
                 throw usageError(`Reviewer mailbox is busy: ${reviewer.name}.`);
             }
-            settleExactWorkExecution(tx, reviewerMailboxTarget, exactOldRunRef);
+            settleExactWorkExecution(tx, reviewerMailboxTarget, exactOldTurnRef);
         }
         else if (reviewerPending !== null) {
-            const exact = reviewerPending.refs.some((ref) => (isDeepStrictEqual(ref, exactOldRunRef)));
+            const exact = reviewerPending.refs.some((ref) => (isDeepStrictEqual(ref, exactOldTurnRef)));
             if (!exact)
                 throw usageError(`Reviewer mailbox has unrelated pending work: ${reviewer.name}.`);
             if (reviewerPending.requestCount !== 1) {
                 throw usageError(`Reviewer mailbox has merged pending work: ${reviewer.name}.`);
             }
-            settleExactWorkExecution(tx, reviewerMailboxTarget, exactOldRunRef);
+            settleExactWorkExecution(tx, reviewerMailboxTarget, exactOldTurnRef);
         }
         if (runningPanelLaneRetry) {
             const resetRound = retryRunningReviewExecutionLane(round, retryLane.id, run.id, now);
             tx.saveReviewRound(task.id, resetRound);
-            recordTaskEvent(tx, task.id, "run.review-retried", {
-                runId: run.id,
+            recordTaskEvent(tx, task.id, "turn.review-retried", {
+                turnId: run.id,
                 reviewRoundId: round.id,
                 executionLaneId: retryLane.id
             }, now);
@@ -5076,8 +4901,8 @@ function retryFailedReviewRun(previous, store, options, now) {
         let roundToReset = round;
         if (round.status !== "failed") {
             const summary = round.summary
-                ?? run.summary
-                ?? `Review Run ${run.id} failed before delivery.`;
+                ?? run.result?.output
+                ?? `Review Turn ${run.id} failed before delivery.`;
             roundToReset = finishReviewRound(round, "failed", summary, now, {
                 report: round.report ?? summary,
                 checks: round.checks ?? [],
@@ -5090,8 +4915,8 @@ function retryFailedReviewRun(previous, store, options, now) {
         // stable across execution-attempt failures.
         const resetRound = retryTaskReviewRound(roundToReset, requestedBy, run.executionLaneId);
         tx.saveReviewRound(task.id, resetRound);
-        recordTaskEvent(tx, task.id, "run.review-retried", {
-            runId: run.id,
+        recordTaskEvent(tx, task.id, "turn.review-retried", {
+            turnId: run.id,
             reviewRoundId: round.id
         }, now);
         return { round: resetRound, previousRun: run, created: true };
@@ -5100,39 +4925,31 @@ function retryFailedReviewRun(previous, store, options, now) {
         ? `Review retry requested as ${result.round.id}\n`
         : `Review retry already requested as ${result.round.id} (${result.round.status})\n`, { reviewRound: result.round });
 }
-/** Run details are retained audit evidence; continuation uses durable Task state. */
-function showRun(args, store, options) {
-    const usage = "Task run show usage: yui task run show <task>/<run> [--json].";
+/** 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].";
     const asJson = args.includes("--json");
     const positionals = args.filter((arg) => arg !== "--json");
     exactPositionals(positionals, 1, usage);
     const data = store.transaction((tx) => {
-        const run = requireRun(tx, positionals[0], options);
+        const run = requireTurn(tx, positionals[0], options);
         const retirement = tx.listEvents(run.taskId)
             .map(taskRecordRetirement)
-            .find((entry) => entry?.recordKind === "agent-run" && entry.recordId === run.id) ?? null;
-        const allRejectedYieldAttempts = tx.listEvents(run.taskId)
-            .map(rejectedYieldAttemptFromTaskEvent)
-            .filter((attempt) => (attempt !== null && attempt.runId === run.id));
-        return {
-            run,
-            retirement,
-            rejectedYieldAttemptCount: allRejectedYieldAttempts.length,
-            rejectedYieldAttempts: allRejectedYieldAttempts.slice(-16)
-        };
+            .find((entry) => entry?.recordKind === "turn" && entry.recordId === run.id) ?? null;
+        return { turn: run, retirement };
     });
     if (asJson) {
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }
     return {
         kind: "output",
-        output: renderRunShow(data.run, data.retirement, data.rejectedYieldAttemptCount, data.rejectedYieldAttempts),
+        output: renderTurnShow(data.turn, data.retirement),
         data
     };
 }
-function renderRunShow(run, retirement, rejectedYieldAttemptCount, rejectedYieldAttempts) {
+function renderTurnShow(run, retirement) {
     const lines = [
-        `Run: ${run.id}`,
+        `Turn: ${run.id}`,
         `Task: ${run.taskId}`,
         `Role: ${run.roleName}`,
         `Purpose: ${run.purpose}`,
@@ -5144,589 +4961,48 @@ function renderRunShow(run, retirement, rejectedYieldAttemptCount, rejectedYield
         ]),
         `Effective: ${run.effective.agentId}/${run.effective.adapterId} r${run.effective.sourceDesiredRevision}`,
         `Created: ${run.createdAt}`,
-        ...(run.endedAt === undefined ? [] : [`Ended: ${run.endedAt}`]),
-        ...(run.pushedAt === undefined ? [] : [`Pushed: ${run.pushedAt}`]),
-        ...(run.deliveredAt === undefined
+        ...(run.result === undefined ? [] : [`Ended: ${run.result.completedAt}`]),
+        ...(run.result === undefined || run.result.output.trim().length === 0
             ? []
-            : [`Provider accepted (durable): ${run.deliveredAt}`]),
-        ...(run.summary === undefined || run.summary.trim().length === 0
-            ? []
-            : [`Summary: ${run.summary}`]),
-        ...(rejectedYieldAttemptCount === 0
-            ? []
-            : [
-                `Rejected yield attempts: ${rejectedYieldAttempts.length} shown of ${rejectedYieldAttemptCount} (unaccepted diagnostic evidence only)`,
-                ...rejectedYieldAttempts.slice(-5).flatMap((attempt) => [
-                    `  ${attempt.attemptedAt}: ${attempt.rejectionReason} (${attempt.attemptDigest.slice(0, 16)})`,
-                    `    Reviewer output: ${truncateRunShowText(attempt.summary)}`,
-                    `    Checks: ${attempt.checks.length === 0
-                        ? "none"
-                        : attempt.checks.map(({ name, outcome }) => `${name}:${outcome}`).join(", ")}`
-                ])
-            ])
+            : [`Summary: ${run.result.output}`])
     ];
     return `${lines.join("\n")}\n`;
 }
-function truncateRunShowText(value) {
-    const normalized = value.replaceAll(/\s+/gu, " ").trim();
-    return normalized.length <= 400 ? normalized : `${normalized.slice(0, 399)}…`;
-}
-/**
- * Issue 04: builds the terminal yield outcome from the command inputs. The
- * same construction feeds both the first commit and the idempotent replay, so
- * a resend always hashes to the same digest.
- */
-function buildYieldOutcome(run, inputSummary, options) {
-    let yieldedReport;
-    if (run.purpose === "review"
-        || (run.purpose === "execution" && run.executionGroupId !== undefined)) {
-        yieldedReport = parseReviewYieldReport(inputSummary);
-    }
-    const summary = yieldedReport?.summary ?? inputSummary;
-    if (yieldedReport === undefined)
-        return { summary };
-    return {
-        summary,
-        reviewResult: {
-            report: yieldedReport.report,
-            checks: yieldedReport.checks,
-            ...(yieldedReport.findings === undefined ? {} : { findings: yieldedReport.findings }),
-            ...(yieldedReport.evidence === undefined ? {} : { evidence: yieldedReport.evidence }),
-            ...(run.purpose === "review"
-                && options.reviewWorkspaceResult?.evidenceCommit === undefined
-                ? {}
-                : run.purpose === "review"
-                    ? { evidenceCommit: options.reviewWorkspaceResult.evidenceCommit }
-                    : yieldedReport.evidenceCommit === undefined
-                        ? {}
-                        : { evidenceCommit: yieldedReport.evidenceCommit }),
-            ...(options.executionLaneGitSnapshot === undefined
-                || options.executionLaneGitSnapshot === null
-                ? {}
-                : { gitSnapshot: options.executionLaneGitSnapshot }),
-            ...(yieldedReport.deltaDisposition === undefined
-                ? {}
-                : { deltaDisposition: yieldedReport.deltaDisposition }),
-            ...(yieldedReport.deltaReasoning === undefined
-                ? {}
-                : { deltaReasoning: yieldedReport.deltaReasoning })
-        }
-    };
-}
-/**
- * Issue 04: replays an already-committed yield. Returns the committed receipt
- * for the same outcome, fails closed for a different outcome, or returns
- * `null` to keep the legacy "already terminal" behavior.
- */
-function replayYieldReceipt(run, inputSummary, options) {
-    if (run.yieldReceipt === undefined)
-        return null;
-    const outcome = buildYieldOutcome(run, inputSummary, options);
-    const match = matchYieldReceipt(run.yieldReceipt, {
-        status: "yielded",
-        summary: outcome.summary,
-        ...(outcome.reviewResult === undefined ? {} : { reviewResult: outcome.reviewResult })
-    });
-    if (match === null)
-        return null;
-    if (match.kind === "digest-mismatch") {
-        throw usageError(`Run ${run.id} is already terminal with a different yield outcome. `
-            + `Existing receipt: ${match.existing.receiptId} (request ${match.existing.requestId}).`);
-    }
-    return output(`Run ${run.id} yield already committed.\n`
-        + `Receipt: ${match.receipt.receiptId}\n`
-        + `Request: ${match.receipt.requestId}\n`, { receipt: match.receipt });
-}
-/**
- * Issue 04: `yui task run yield-status <task>/<run>` — returns the committed
- * yield receipt for a terminal Run, or the current status for an active Run.
- */
-function yieldRunStatus(args, store, options) {
-    const usage = "Task run yield-status usage: yui task run yield-status <task>/<run>.";
-    const parsed = parseTail(args, new Set(), usage);
-    exactPositionals(parsed.positionals, 1, usage);
-    const run = requireRun(store, parsed.positionals[0], options);
-    if (run.status === "active") {
-        return output(`Run ${run.id} is active; no yield receipt yet.\n`, {
-            runId: run.id,
-            status: run.status
-        });
-    }
-    if (run.yieldReceipt === undefined) {
-        return output(`Run ${run.id} is ${run.status}; no yield receipt recorded.\n`, {
-            runId: run.id,
-            status: run.status
-        });
-    }
-    return output(`Run ${run.id} yield receipt:\n`
-        + `Receipt: ${run.yieldReceipt.receiptId}\n`
-        + `Request: ${run.yieldReceipt.requestId}\n`
-        + `Committed: ${run.yieldReceipt.committedAt}\n`, { receipt: run.yieldReceipt });
-}
-function recordRejectedReviewYield(store, input) {
-    if (input.run.purpose !== "review" || input.run.reviewRoundId === undefined) {
-        throw new Error(`Only a Review Run can record rejected yield evidence: ${input.run.id}.`);
-    }
-    const receiptId = agentRunDeliveryReceiptId(input.run);
-    const sessions = store.getTaskRoleSessionSet(input.run.taskId, input.run.roleName);
-    const durableSession = sessions?.sessions[input.run.effective.agentId];
-    const attempt = createRejectedYieldAttempt({
-        taskId: input.run.taskId,
-        runId: input.run.id,
-        roleName: input.run.roleName,
-        reviewRoundId: input.run.reviewRoundId,
-        receiptId,
-        rejectionReason: input.rejectionReason,
-        summary: input.outcome.summary,
-        ...(input.outcome.reviewResult === undefined
-            ? {}
-            : { reviewResult: input.outcome.reviewResult }),
-        ...(input.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: input.nativeSessionId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        ...(durableSession?.nativeSessionId === undefined
-            ? {}
-            : { durableNativeSessionId: durableSession.nativeSessionId }),
-        ...(durableSession?.launchId === undefined
-            ? {}
-            : { durableLaunchId: durableSession.launchId }),
-        ...(sessions?.inFlight?.runId === undefined
-            ? {}
-            : { inFlightRunId: sessions.inFlight.runId }),
-        ...(sessions?.inFlight?.receiptId === undefined
-            ? {}
-            : { inFlightReceiptId: sessions.inFlight.receiptId }),
-        ...(input.run.assignment.contextSnapshotRef === undefined
-            ? {}
-            : { contextSnapshot: input.run.assignment.contextSnapshotRef }),
-        activeRun: input.activeRun === null
-            ? null
-            : {
-                id: input.activeRun.id,
-                receiptId: agentRunDeliveryReceiptId(input.activeRun),
-                ...(input.activeRun.assignment.contextSnapshotRef === undefined
-                    ? {}
-                    : { contextSnapshot: input.activeRun.assignment.contextSnapshotRef })
-            },
-        attemptedAt: input.now
-    });
-    const existing = store.listEvents(input.run.taskId).find((event) => (event.type === RUN_YIELD_REJECTED_EVENT
-        && event.payload.runId === input.run.id
-        && event.payload.receiptId === receiptId
-        && event.payload.attemptDigest === attempt.attemptDigest));
-    if (existing !== undefined) {
-        const persisted = rejectedYieldAttemptFromTaskEvent(existing);
-        if (persisted === null) {
-            throw new Error(`Rejected yield attempt is malformed: ${existing.id}.`);
-        }
-        return { attempt: persisted, event: existing, created: false };
-    }
-    const event = createTaskEvent(store.nextEventId(input.run.taskId), input.run.taskId, RUN_YIELD_REJECTED_EVENT, rejectedYieldAttemptEventPayload(attempt), input.now);
-    store.saveEvent(input.run.taskId, event);
-    routeRoleEvent(store, event, input.run.roleName, "run-yield-rejected", input.now);
-    return { attempt, event, created: true };
-}
-function yieldRun(args, store, options) {
-    const usage = "Task run yield usage: yui task run yield <task>/<run> (--summary <text>|--summary-file <path|->).";
-    const parsed = parseTail(args, new Set(["--summary", "--summary-file"]), usage);
-    exactPositionals(parsed.positionals, 1, usage);
-    const inputSummary = readCommandText(parsed.options.get("--summary"), parsed.options.get("--summary-file"), "--summary", usage);
-    const now = clock(options);
-    // Issue 04: an already-terminal Run may be a lost-response resend. Match
-    // the presented outcome against the committed receipt before opening the
-    // transaction; the receipt is immutable once committed.
-    const existing = requireRun(store, parsed.positionals[0], options);
-    if (existing.status !== "active") {
-        const replayed = replayYieldReceipt(existing, inputSummary, options);
-        if (replayed !== null)
-            return replayed;
-        throw usageError(`Run ${existing.id} is already terminal: ${existing.status}.`);
-    }
-    const yielded = store.transaction((tx) => {
-        const active = requireRun(tx, parsed.positionals[0], options);
-        if (active.status !== "active") {
-            throw usageError(`Run ${active.id} is already terminal: ${active.status}.`);
-        }
-        if (active.pushedAt === undefined) {
-            throw usageError(`Run ${active.id} delivery is still pending.`);
-        }
-        const task = requireTask(tx, active.taskId);
-        if (task.status !== "active")
-            throw usageError(inactiveTaskMessage(task, "yielding a run"));
-        const role = requireRole(tx, task.id, active.roleName);
-        const pointer = activeRunPointer(tx, active);
-        const taskFinalContract = active.purpose === "execution"
-            && active.workItemId !== undefined
-            ? taskFinalReviewContractForMutation(tx, task.id, options)
-            : undefined;
-        const wasStalled = isRoleRunStalled(tx.listEvents(task.id), active.id);
-        let yieldedReport;
-        if (active.purpose === "review"
-            || (active.purpose === "execution" && active.executionGroupId !== undefined)) {
-            try {
-                yieldedReport = parseReviewYieldReport(inputSummary);
-            }
-            catch (error) {
-                throw usageError(error instanceof Error ? error.message : String(error));
-            }
-        }
-        const groupedLaneRun = active.executionGroupId !== undefined
-            && active.executionLaneId !== undefined;
-        if (active.purpose !== "review"
-            && groupedLaneRun
-            && options.yuiHome !== undefined
-            && options.executionLaneGitSnapshot === undefined) {
-            throw usageError(`Managed Execution Lane Git snapshot preflight is missing: ${active.id}.`);
-        }
-        if (active.purpose === "review") {
-            if (options.reviewWorkspaceResult === undefined) {
-                throw usageError(`Review Run requires managed workspace preflight: ${active.id}.`);
-            }
-            if (yieldedReport?.evidenceCommit !== undefined
-                && yieldedReport.evidenceCommit !== options.reviewWorkspaceResult.evidenceCommit) {
-                throw usageError(`Reported Review evidence commit does not match the managed workspace: ${active.id}.`);
-            }
-        }
-        const yieldOutcome = buildYieldOutcome(active, inputSummary, options);
-        const summary = yieldOutcome.summary;
-        const terminalization = terminalizeExactTaskRun(tx, {
-            taskId: task.id,
-            roleName: role.name,
-            agentId: active.effective.agentId,
-            runId: active.id,
-            receiptId: agentRunDeliveryReceiptId(active),
-            ...(active.purpose !== "review" || options.environment?.YUI_NATIVE_SESSION_ID === undefined
-                ? {}
-                : { nativeSessionId: options.environment.YUI_NATIVE_SESSION_ID }),
-            ...(active.purpose !== "review" || options.environment?.YUI_LAUNCH_ID === undefined
-                ? {}
-                : { launchId: options.environment.YUI_LAUNCH_ID }),
-            outcome: { status: "yielded", summary },
-            ...(yieldOutcome.reviewResult === undefined
-                ? {}
-                : { reviewResult: yieldOutcome.reviewResult })
-        }, now);
-        if (terminalization.disposition !== "applied" || terminalization.run === null) {
-            if (active.purpose === "review" && active.reviewRoundId !== undefined) {
-                const rejected = recordRejectedReviewYield(tx, {
-                    run: active,
-                    activeRun: pointer,
-                    rejectionReason: terminalization.reason ?? "obsolete",
-                    outcome: yieldOutcome,
-                    ...(options.environment?.YUI_NATIVE_SESSION_ID === undefined
-                        ? {}
-                        : { nativeSessionId: options.environment.YUI_NATIVE_SESSION_ID }),
-                    ...(options.environment?.YUI_LAUNCH_ID === undefined
-                        ? {}
-                        : { launchId: options.environment.YUI_LAUNCH_ID }),
-                    now
-                });
-                return {
-                    kind: "rejected",
-                    run: active,
-                    rejected,
-                    notifyLeader: rejected.created
-                };
-            }
-            throw usageError(`Run ${active.id} no longer matches its exact execution fence: `
-                + `${terminalization.reason ?? "obsolete"}.`);
-        }
-        const terminal = terminalization.run;
-        let reviewGroupPending = false;
-        let reviewGroupReady = false;
-        if (wasStalled) {
-            recordTaskEvent(tx, task.id, RUN_RECOVERED_EVENT, {
-                runId: terminal.id,
-                roleName: role.name,
-                progressAt: now.toISOString(),
-                kind: "yield"
-            }, now);
-        }
-        if (active.purpose === "review") {
-            const round = active.reviewRoundId === undefined
-                ? null
-                : tx.getReviewRound(task.id, active.reviewRoundId);
-            const panel = round?.executionGroup !== undefined
-                && (round.executionGroup.lanes.length > 1
-                    || round.executionGroup.strategy.mode === "adaptive");
-            if (round === null || round.reviewerRunId === undefined) {
-                throw usageError(`ReviewRun did not complete its exact ReviewRound: ${active.id}.`);
-            }
-            if (panel) {
-                reviewGroupPending = round.status !== "completed";
-                reviewGroupReady = reviewGroupPending
-                    && round.executionGroup.lanes.every(({ status }) => (["yielded", "completed", "failed"].includes(status)));
-                if (reviewGroupReady) {
-                    const panelGroup = round.executionGroup;
-                    recordTaskEvent(tx, task.id, "review-group-ready", {
-                        reviewRoundId: round.id,
-                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
-                        ...(round.candidateId === undefined ? {} : { candidateId: round.candidateId }),
-                        executionGroupId: panelGroup.id,
-                        terminalLanes: String(panelGroup.lanes
-                            .filter(({ status }) => ["yielded", "completed", "failed"].includes(status)).length),
-                        laneCount: String(panelGroup.lanes.length)
-                    }, now);
-                }
-            }
-            else {
-                if (round.status !== "completed" || round.reviewerRunId !== active.id) {
-                    throw usageError(`ReviewRun did not complete its exact ReviewRound: ${active.id}.`);
-                }
-                recordTaskEvent(tx, task.id, "review.completed", {
-                    reviewRoundId: round.id,
-                    ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
-                    ...(round.candidateId === undefined ? {} : { candidateId: round.candidateId }),
-                    reviewBaseCommit: round.reviewBaseCommit,
-                    evidenceCommit: round.evidenceCommit ?? "none",
-                    checks: round.checks?.map(({ name, outcome }) => `${name}:${outcome}`)
-                        .join(",") || "none",
-                    ...(round.deltaRecheck === undefined
-                        ? {}
-                        : {
-                            reviewMode: "delta-recheck",
-                            deltaDisposition: round.deltaRecheck.disposition ?? "requires-full-review",
-                            previousReviewRoundId: round.deltaRecheck.previousReviewRoundId,
-                            diffDigest: round.deltaRecheck.diffDigest
-                        })
-                }, now);
-            }
-        }
-        let automaticReview = null;
-        let submittedItem = null;
-        let executionGroupPending = false;
-        let executionGroupReady = false;
-        if (active.purpose === "review") {
-            // Saving the terminal review Run completes its ReviewRound in the same
-            // aggregate transaction. The WorkItem remains the candidate under review.
-        }
-        else if (active.workItemId !== undefined) {
-            const item = tx.getWorkItem(task.id, active.workItemId);
-            if (item === null)
-                throw dataError(`Work item not found for run ${active.id}: ${active.workItemId}.`);
-            const currentGroup = currentWorkItemExecutionGroup(item);
-            const multiLaneGroup = currentGroup !== undefined
-                && (currentGroup.stage !== undefined
-                    || currentGroup.lanes.length > 1
-                    || currentGroup.strategy.mode === "adaptive")
-                && currentGroup.resolution === undefined;
-            if (multiLaneGroup) {
-                executionGroupPending = true;
-                executionGroupReady = currentGroup.lanes.every(({ status }) => (["yielded", "completed", "failed", "skipped"].includes(status)));
-                if (executionGroupReady) {
-                    recordTaskEvent(tx, task.id, "execution-group-ready", {
-                        workItemId: item.id,
-                        executionGroupId: currentGroup.id,
-                        terminalLanes: String(currentGroup.lanes.length),
-                        laneCount: String(currentGroup.lanes.length)
-                    }, now);
-                }
-            }
-            else {
-                const configuredReview = tx.getReviewConfig();
-                const candidatePolicy = taskFinalContract === undefined
-                    ? legacyWorkItemReviewConfig(configuredReview)
-                    : taskFinalReviewConfig(taskFinalContract);
-                const projectDelivery = task.projectBindings.length > 0
-                    && item.writeProjectIds.length > 0;
-                const candidateRequired = role.name !== LEADER_ROLE
-                    || candidatePolicy !== null
-                    || projectDelivery;
-                let candidateSourceItem = item;
-                if (candidateRequired
-                    && currentGroup !== undefined
-                    && currentGroup.resolution === undefined) {
-                    const resolvedSingle = resolveExecutionGroup(currentGroup, {
-                        decision: "accept",
-                        summary,
-                        selectedLaneIds: [active.executionLaneId]
-                    }, now);
-                    candidateSourceItem = updateWorkItemExecutionGroup(item, resolvedSingle, now);
-                    tx.saveWorkItem(task.id, candidateSourceItem);
-                }
-                const yieldedItem = candidateRequired
-                    ? submitWorkItemCandidate(candidateSourceItem, {
-                        summary,
-                        source: { type: "run", runId: terminal.id },
-                        ...(candidatePolicy === null ? {} : { reviewPolicy: candidatePolicy }),
-                        ...(taskFinalContract === undefined
-                            ? {}
-                            : { taskFinalReviewContract: taskFinalContract }),
-                        ...(active.executionGroupId === undefined
-                            ? {}
-                            : {
-                                executionGroupId: active.executionGroupId,
-                                executionLaneId: active.executionLaneId
-                            }),
-                        ...(active.workspace === undefined
-                            || (active.workspace.owner.type === "task"
-                                && active.workspace.entries.length === 0)
-                            ? {}
-                            : { workspace: active.workspace }),
-                        ...(options.candidateGitSnapshot === undefined
-                            ? {}
-                            : { gitSnapshot: options.candidateGitSnapshot })
-                    }, now)
-                    : updateWorkItemStatus(item, "completed", now, summary);
-                tx.saveWorkItem(task.id, yieldedItem);
-                if (candidateRequired)
-                    submittedItem = yieldedItem;
-                if (candidatePolicy?.trigger === "always") {
-                    automaticReview = { item: yieldedItem, config: candidatePolicy };
-                }
-            }
-        }
-        else if (role.name !== LEADER_ROLE) {
-            throw usageError(`Run ${active.id} is not a work run.`);
-        }
-        const reviewDispatch = automaticReview === null
-            ? null
-            : queueReviewRound(tx, automaticReview.item, automaticReview.config, "policy", now);
-        const leaderHandoff = active.purpose === "review"
-            ? (reviewGroupPending
-                ? (reviewGroupReady ? "review-group-ready" : null)
-                : "review-result")
-            : submittedItem === null
-                && executionGroupPending
-                ? (executionGroupReady ? "execution-group-ready" : null)
-                : submittedItem === null
-                    || (reviewDispatch !== null && reviewDispatch.run !== null)
-                    ? null
-                    : reviewDispatch?.round.status === "failed"
-                        ? "review-failed"
-                        : "candidate-ready";
-        if (leaderHandoff !== null) {
-            enqueueWork(tx, leaderMailbox(task.id), leaderHandoff, now, [
-                runRef(task.id, terminal.id),
-                ...(terminal.workItemId === undefined ? [] : [workItemRef(task.id, terminal.workItemId)])
-            ]);
-        }
-        // Issue 05: record the Leader's terminal receipt so the Scheduler can
-        // suppress no-change `task-orphaned` wakes. The disposition and digest are
-        // machine-derived from the post-yield projection; the Leader does not
-        // need to cooperate for the admission check to work.
-        if (role.name === LEADER_ROLE) {
-            const receipt = leaderYieldReceipt(tx, task, terminal, now);
-            if (receipt !== null) {
-                tx.saveAgentRun(receipt);
-                return {
-                    kind: "yielded",
-                    run: receipt,
-                    reviewDispatch,
-                    notifyLeader: leaderHandoff !== null
-                };
-            }
-        }
-        return {
-            kind: "yielded",
-            run: terminal,
-            reviewDispatch,
-            notifyLeader: leaderHandoff !== null
-        };
-    });
-    if (yielded.kind === "rejected") {
-        if (yielded.notifyLeader) {
-            notifyMailbox(options.runtime, leaderMailbox(yielded.run.taskId), yielded.run.taskId);
-        }
-        throw usageError(`Run ${yielded.run.id} no longer matches its exact execution fence: `
-            + `${yielded.rejected.attempt.rejectionReason}. `
-            + `Rejected Reviewer output was recorded as ${yielded.rejected.event.id} `
-            + "(unaccepted diagnostic evidence only).");
-    }
-    if (yielded.notifyLeader) {
-        notifyMailbox(options.runtime, leaderMailbox(yielded.run.taskId), yielded.run.taskId);
-    }
-    if (yielded.reviewDispatch?.run !== null
-        && yielded.reviewDispatch?.run !== undefined) {
-        notifyReviewMailbox(options, options.runtime, roleMailbox(yielded.reviewDispatch.run.taskId, yielded.reviewDispatch.run.roleName), yielded.reviewDispatch.run.taskId);
-    }
-    return output(`Yielded ${yielded.run.id}: ${yielded.run.summary ?? inputSummary}\n`, {
-        run: yielded.run,
-        ...(yielded.reviewDispatch === null
-            ? {}
-            : { reviewRound: yielded.reviewDispatch.round })
-    });
-}
 /**
- * Issue 05: compute the Leader Run terminal receipt (disposition + observed
- * actionability digest) from the post-yield projection. Returns the updated
- * Run, or null when the receipt cannot be computed (the caller keeps the
- * unmodified terminal Run in that case; the Scheduler fails open).
- */
-function leaderYieldReceipt(tx, task, terminal, now) {
-    try {
-        const projection = buildTaskExecutionProjection(tx, task.id, task);
-        if (projection === null)
-            return null;
-        const disposition = deriveLeaderRunDisposition(projection.status, task.status);
-        const digest = computeActionabilityDigest(collectTaskActionability(tx, task.id, now));
-        const waitReason = disposition === "waiting" || disposition === "blocked"
-            ? leaderWaitReason(projection)
-            : undefined;
-        return {
-            ...terminal,
-            disposition,
-            observedActionabilityDigest: digest,
-            ...(waitReason === undefined ? {} : { waitReason }),
-            updatedAt: now.toISOString()
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function leaderWaitReason(projection) {
-    const blocker = projection.blockers[0];
-    if (blocker !== undefined) {
-        return { kind: blocker.kind, ref: blocker.id };
-    }
-    if (projection.status === "waiting-on-agents") {
-        return { kind: "delegated-work" };
-    }
-    if (projection.status === "waiting-user") {
-        return { kind: "input" };
-    }
-    return undefined;
-}
-/**
- * Records a structured progress checkpoint for an active Run. This is a durable
- * run fact, not a Task Message: it advances the Run's durable-progress clock so
- * a healthy but long-running Run keeps proving it is alive without adding
- * collaboration-narrative noise. It never yields, mutates the Run, or wakes the
+ * 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
  * Leader.
  */
-function checkpointRun(args, store, options) {
-    const usage = "Task run checkpoint usage: yui task run checkpoint <run> (--note <text>|--note-file <path|->).";
+function checkpointTurn(args, store, options) {
+    const usage = "Task turn checkpoint usage: yui task turn checkpoint <turn> (--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 = requireRun(tx, parsed.positionals[0], options);
+        const run = requireTurn(tx, parsed.positionals[0], options);
         if (run.status !== "active") {
-            throw usageError(`Run ${run.id} is already terminal: ${run.status}.`);
-        }
-        if (run.deliveredAt === undefined) {
-            throw usageError(`Run ${run.id} delivery is still pending.`);
+            throw usageError(`Turn ${run.id} is already terminal: ${run.status}.`);
         }
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
-            throw usageError(inactiveTaskMessage(task, "checkpointing a run"));
-        const pointer = activeRunPointer(tx, run);
+            throw usageError(inactiveTaskMessage(task, "checkpointing a Turn"));
+        const pointer = activeTurnPointer(tx, run);
         if (pointer?.id !== run.id) {
-            throw usageError(`Run is not active for ${task.id}/${run.roleName}: ${run.id}.`);
+            throw usageError(`Turn is not active for ${task.id}/${run.roleName}: ${run.id}.`);
         }
         const events = tx.listEvents(task.id);
-        const recovered = isRoleRunStalled(events, run.id);
-        const progress = recordTaskEventRecord(tx, task.id, RUN_PROGRESS_EVENT, {
-            runId: run.id,
+        const recovered = isRoleTurnStalled(events, run.id);
+        const progress = recordTaskEventRecord(tx, task.id, TURN_PROGRESS_EVENT, {
+            turnId: run.id,
             note: truncateEventNote(note),
             ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId })
         }, now);
         if (recovered) {
-            recordTaskEventRecord(tx, task.id, RUN_RECOVERED_EVENT, {
-                runId: run.id,
+            recordTaskEventRecord(tx, task.id, TURN_RECOVERED_EVENT, {
+                turnId: run.id,
                 roleName: run.roleName,
                 progressAt: now.toISOString(),
                 kind: "checkpoint"
@@ -5744,13 +5020,13 @@ export function queueReviewRound(store, item, config, requestedBy, now) {
     const pending = createReviewRound(store.nextReviewRoundId(item.taskId), item.taskId, item.id, candidate.id, config.roleName, requestedBy, candidate.gitSnapshot.reviewBaseCommit, now);
     store.saveReviewRound(item.taskId, pending);
     const producerRoleName = item.assignee
-        ?? (candidate.source.type === "run"
-            ? store.getAgentRun(item.taskId, candidate.source.runId)?.roleName
+        ?? (candidate.source.type === "turn"
+            ? store.getTurn(item.taskId, candidate.source.turnId)?.roleName
             : LEADER_ROLE);
     if (producerRoleName === config.roleName) {
         const failed = finishReviewRound(pending, "failed", `Reviewer Role must be separate from the Candidate producer: ${config.roleName}.`, now);
         store.saveReviewRound(item.taskId, failed);
-        return { round: failed, run: null };
+        return { round: failed };
     }
     let reviewer = store.getRole(item.taskId, config.roleName);
     if (reviewer === null) {
@@ -5758,18 +5034,18 @@ export function queueReviewRound(store, item, config, requestedBy, now) {
         if (globalRole === null) {
             const failed = finishReviewRound(pending, "failed", `Global Role not found: ${config.roleName}.`, now);
             store.saveReviewRound(item.taskId, failed);
-            return { round: failed, run: null };
+            return { round: failed };
         }
         const task = requireTask(store, item.taskId);
         reviewer = createTaskRole(store, task, config.roleName, undefined, now, config.roleName);
         store.saveRole(task.id, reviewer);
     }
-    if (store.getActiveAgentRun(item.taskId, reviewer.name) !== null) {
-        const failed = finishReviewRound(pending, "failed", `Reviewer Role already has an active run: ${reviewer.name}.`, now);
+    if (store.getActiveTurn(item.taskId, reviewer.name) !== null) {
+        const failed = finishReviewRound(pending, "failed", `Reviewer Role already has an active Turn: ${reviewer.name}.`, now);
         store.saveReviewRound(item.taskId, failed);
-        return { round: failed, run: null };
+        return { round: failed };
     }
-    return { round: pending, run: null };
+    return { round: pending };
 }
 export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, options = {}) {
     const now = clock(options);
@@ -5834,8 +5110,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.reviewerRunId !== undefined) {
-                throw new TaskFinalReviewDispatchDriftError(`Pending final ReviewRound already records Reviewer Run ${round.reviewerRunId}: `
+            if (round.status === "pending" && round.reviewerTurnId !== undefined) {
+                throw new TaskFinalReviewDispatchDriftError(`Pending final ReviewRound already records Reviewer Turn ${round.reviewerTurnId}: `
                     + `${round.id}.`);
             }
             let currentTaskCandidate;
@@ -5885,8 +5161,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 && (entry.executionGroup?.lanes.some(({ roleName }) => requestedReviewers.has(roleName))
                     ?? requestedReviewers.has(entry.reviewerRoleName))
                 && !(entry.status === "running"
-                    && entry.reviewerRunId !== undefined
-                    && tx.getAgentRun(task.id, entry.reviewerRunId)?.status === "failed")));
+                    && entry.reviewerTurnId !== undefined
+                    && tx.getTurn(task.id, entry.reviewerTurnId)?.status === "failed")));
             if (conflicting !== undefined) {
                 throw new TaskFinalReviewDispatchDriftError(`Another active Task-final ReviewRound already exists: ${conflicting.id}/${conflicting.reviewerRoleName}.`);
             }
@@ -5913,8 +5189,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         }
         const candidateLabel = taskScope
             ? "frozen Task candidate"
-            : candidate.source.type === "run"
-                ? `candidate Run ${candidate.source.runId}`
+            : candidate.source.type === "turn"
+                ? `candidate Turn ${candidate.source.turnId}`
                 : `revision ${candidate.workItemRevision}`;
         const frozenHeads = taskScope
             ? round.taskCandidate.projects
@@ -5932,7 +5208,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 run.`);
+                throw new TaskFinalReviewDispatchDriftError(`Delta-recheck diff is missing for ${round.id}; the CLI preflight did not turn.`);
             }
             try {
                 verifyDeltaRecheckDiff(round.deltaRecheck, diffByProject);
@@ -5976,8 +5252,8 @@ 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.",
-            "Use the exact --summary-file - body to report complete findings, evidence, checks actually run, uncertainty, and recommended next actions in clear Markdown or JSON. Yui preserves the full report; no fixed wording or field list is required. If you include evidenceCommit, it must match the managed Review workspace.",
-            "Report reviewBaseCommit, exact checks/results, material findings, and uncertainty. Review yield completes only this Round and creates no Candidate or ChangeSet.",
+            "End the Provider turn with complete findings, evidence, checks actually run, uncertainty, and recommended next actions in clear Markdown or JSON. Yui preserves the full report automatically; no fixed wording or field list is required. If you include evidenceCommit, it must match the managed Review workspace.",
+            "Report reviewBaseCommit, exact checks/results, material findings, and uncertainty. This Turn 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 executionTarget = executionTargetForReviewRound(task, round, item, candidate);
@@ -5987,19 +5263,19 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             strategy: { mode: "fixed", count: 1 },
             lanes: [{ roleName: reviewer.name, reviewRoundId: round.id }]
         }, now);
-        const dispatchLanes = runningGroup.lanes.filter((lane) => (lane.status === "pending" && lane.runId === undefined));
+        const dispatchLanes = runningGroup.lanes.filter((lane) => (lane.status === "pending" && lane.turnId === undefined));
         const laneRoles = dispatchLanes.map(({ roleName }) => roleName);
         const reviewers = laneRoles.map((roleName) => {
             const laneReviewer = tx.getRole(taskId, roleName);
             if (laneReviewer === null) {
                 throw usageError(`Reviewer Role not found: ${taskId}/${roleName}.`);
             }
-            if (tx.getActiveAgentRun(taskId, roleName) !== null) {
-                throw usageError(`Reviewer Role already has an active run: ${roleName}.`);
+            if (tx.getActiveTurn(taskId, roleName) !== null) {
+                throw usageError(`Reviewer Role already has an active Turn: ${roleName}.`);
             }
             return laneReviewer;
         });
-        const createdRuns = [];
+        const createdTurns = [];
         const config = tx.getConfig();
         const controllerConcurrency = resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
         const capacity = runningGroup.strategy.mode === "fixed"
@@ -6077,30 +5353,23 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 continue;
             }
             activeResources.push(request);
-            const runId = tx.nextAgentRunId(taskId);
-            const assignment = createRunAssignment({
-                runId,
-                roleName: laneReviewer.name,
-                purpose: "review",
-                action: "review-round",
-                subject: {
-                    taskId,
-                    ...(item === undefined ? {} : { workItemId: item.id }),
-                    reviewRoundId: round.id,
-                    executionGroupId: runningGroup.id,
-                    executionLaneId: lane.id
+            const turnId = tx.nextTurnId(taskId);
+            const input = createTurnInput({
+                source: {
+                    type: "yui",
+                    channel: item === undefined ? "task-dispatch" : "workitem-dispatch"
                 },
                 directive: `${rawInput}\nFrozen target: ${runningGroup.target.fingerprint}.`,
                 deltaRefIds: []
             });
             runningGroup = updateExecutionLane(runningGroup, lane.id, {
                 status: "running",
-                runId,
+                turnId,
                 reviewRoundId: round.id,
                 effective,
                 workspace: laneWorkspace
             }, now);
-            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
+            createdTurns.push(createTurn(turnId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), input, now, {
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 purpose: "review",
                 reviewRoundId: round.id,
@@ -6113,8 +5382,8 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
         const roundWithGroup = round.executionGroup === undefined
             ? attachReviewExecutionGroup(round, runningGroup)
             : updateReviewExecutionGroup(round, runningGroup);
-        const persistedRound = round.status === "pending" && createdRuns.length > 0
-            ? startReviewRound(roundWithGroup, createdRuns[0].id)
+        const persistedRound = round.status === "pending" && createdTurns.length > 0
+            ? startReviewRound(roundWithGroup, createdTurns[0].id)
             : roundWithGroup;
         // Save the aggregate before adopting prepared Lane workspaces.  The
         // managed-workspace validator deliberately requires durable Group/Lane
@@ -6132,29 +5401,29 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                     tx.saveManagedWorkspace(prepared);
             }
         }
-        for (let index = 0; index < createdRuns.length; index += 1) {
-            const unboundRun = createdRuns[index];
-            const snapshot = freezeRunContextSnapshot(tx, {
+        for (let index = 0; index < createdTurns.length; index += 1) {
+            const unboundTurn = createdTurns[index];
+            const snapshot = freezeTurnContextSnapshot(tx, {
                 taskId,
-                roleName: unboundRun.roleName,
+                roleName: unboundTurn.roleName,
                 purpose: "review",
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 reviewRoundId: round.id
             }, now, "controller", reviewBaseline === undefined
                 ? undefined
                 : contextSnapshotRef(reviewBaseline));
-            const created = withAgentRunContextSnapshot(unboundRun, contextSnapshotRef(snapshot), contextSnapshotDeltaRefIds(tx, snapshot));
-            createdRuns[index] = created;
-            const laneReviewer = requireRole(tx, taskId, unboundRun.roleName);
-            tx.saveAgentRun(created);
-            tx.saveActiveAgentRun(created);
+            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);
             enqueueWork(tx, roleMailbox(taskId, laneReviewer.name), "review-requested", now, [
-                runRef(taskId, created.id),
+                turnRef(taskId, created.id),
                 ...(item === undefined ? [] : [workItemRef(taskId, item.id)])
             ]);
-            recordTaskEvent(tx, taskId, "run.review-dispatched", runLaunchEventPayload(created), now);
+            recordTaskEvent(tx, taskId, "turn.review-dispatched", turnLaunchEventPayload(created), now);
         }
-        return createdRuns;
+        return createdTurns;
     });
     for (const run of runs) {
         notifyMailbox(options.runtime, roleMailbox(run.taskId, run.roleName), run.taskId);
@@ -6283,7 +5552,7 @@ function appendMessage(store, taskId, body, kind, author, now, context = {}) {
     recordTaskEvent(store, taskId, "message.sent", {
         messageId: message.id,
         kind: message.kind,
-        ...(message.runId === undefined ? {} : { runId: message.runId })
+        ...(message.turnId === undefined ? {} : { turnId: message.turnId })
     }, now);
     return message;
 }
@@ -6291,15 +5560,15 @@ function recordTaskEvent(store, taskId, type, payload, now) {
     return recordTaskEventRecord(store, taskId, type, payload, now);
 }
 function leaderActionEventPayload(store, taskId, options) {
-    const runId = taskLeaderActionRunId(store, taskId, options.environment, options.yuiHome);
-    return runId === undefined ? {} : { leaderRunId: runId };
+    const turnId = taskLeaderActionTurnId(store, taskId, options.environment, options.yuiHome);
+    return turnId === undefined ? {} : { leaderTurnId: turnId };
 }
 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 run-fact note bounded so an event payload stays compact. */
+/** Keeps a free-text Turn-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)}…`;
@@ -6321,9 +5590,9 @@ function roleLaunchEventPayload(role, sessions) {
                 : "pending-next-launch"
     };
 }
-function runLaunchEventPayload(run) {
+function turnLaunchEventPayload(run) {
     return {
-        runId: run.id,
+        turnId: run.id,
         role: run.roleName,
         purpose: run.purpose,
         mode: run.mode,
@@ -6381,18 +5650,18 @@ function requireWorkItem(store, workItemId, options) {
     }
     return item;
 }
-function requireRun(store, runId, options) {
-    const reference = taskRecordReference(runId, "agentRun", "Agent Run reference", options);
-    const run = store.getAgentRun(reference.taskId, reference.localId);
+function requireTurn(store, turnId, options) {
+    const reference = taskRecordReference(turnId, "turn", "Turn reference", options);
+    const run = store.getTurn(reference.taskId, reference.localId);
     if (run === null) {
-        throw usageError(`Agent Run not found: ${reference.taskId}/${reference.localId}.`);
+        throw usageError(`Turn not found: ${reference.taskId}/${reference.localId}.`);
     }
     return run;
 }
-function activeRunPointer(store, run) {
+function activeTurnPointer(store, run) {
     return run.executionGroupId !== undefined && run.executionLaneId !== undefined
-        ? store.getActiveExecutionLaneRun(run.taskId, run.executionGroupId, run.executionLaneId)
-        : store.getActiveAgentRun(run.taskId, run.roleName);
+        ? store.getActiveExecutionLaneTurn(run.taskId, run.executionGroupId, run.executionLaneId)
+        : store.getActiveTurn(run.taskId, run.roleName);
 }
 function requireReviewRound(store, reviewRoundId, options) {
     const reference = taskRecordReference(reviewRoundId, "reviewRound", "ReviewRound reference", options);
@@ -6425,8 +5694,8 @@ function assertWorkItemDependenciesCompleted(store, item) {
         }
     }
 }
-function chronologicalAgentRuns(runs) {
-    return [...runs].sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
+function chronologicalTurns(turns) {
+    return [...turns].sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
         || left.id.localeCompare(right.id)));
 }
 function isTerminalWorkItemStatus(status) {
@@ -6903,7 +6172,7 @@ function taskContinuationCommand(args, store) {
             continuationId: identity.continuationId,
             generation: identity.generation,
             driver: identity.providerNamespace,
-            runId: continuation.runId,
+            turnId: continuation.turnId,
             execution: continuation.execution,
             outcome: continuation.outcome,
             attachment: continuation.attachment,
@@ -6994,13 +6263,13 @@ function taskWakeInspectionCommand(args, store) {
             { header: "Wake", minWidth: 8, maxWidth: 18 },
             { header: "Status", minWidth: 8, maxWidth: 12 },
             { header: "Reasons", minWidth: 10, maxWidth: 40 },
-            { header: "Run", minWidth: 10, maxWidth: 20 },
+            { header: "Turn", minWidth: 10, maxWidth: 20 },
             { header: "Dispatched", minWidth: 10, maxWidth: 28 }
         ], wakes.map((wake) => [
             wake.id,
             wake.status,
             wake.reasons.map(renderWakeReason).join(", "),
-            wake.runId ?? "-",
+            wake.turnId ?? "-",
             presentTime(wake.createdAt, timeZone)
         ]), defaultTableWidth())}\n`, { taskId: task.id, wakes });
     }
@@ -7020,14 +6289,14 @@ function taskWakeInspectionCommand(args, store) {
         };
         const events = store.listEvents(task.id).filter((e) => inWindow(e.createdAt));
         const messages = store.listMessages(task.id).filter((m) => inWindow(m.createdAt));
-        const runs = store.listAgentRuns(task.id).filter((r) => inWindow(r.createdAt));
+        const turns = store.listTurns(task.id).filter((turn) => inWindow(turn.createdAt));
         const lines = [
             `Wake: ${wake.id}`,
             `Task: ${task.id}`,
             `Status: ${wake.status}`,
             `Reasons: ${wake.reasons.map(renderWakeReason).join(", ")}`,
             `Delta window: ${wake.fromCursor} → ${wake.toCursor}`,
-            ...(wake.runId === undefined ? [] : [`Run: ${wake.runId}`]),
+            ...(wake.turnId === undefined ? [] : [`Turn: ${wake.turnId}`]),
             `Dispatched: ${presentTime(wake.createdAt, timeZone)}`,
             ...(wake.consumedAt === undefined
                 ? []
@@ -7036,15 +6305,15 @@ 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)}`),
-            `Runs (${runs.length}):`,
-            ...runs.map((r) => `  ${r.id} [${r.status}/${r.purpose}] ${r.roleName} ${presentTime(r.createdAt, timeZone)}`)
+            `Turns (${turns.length}):`,
+            ...turns.map((turn) => `  ${turn.id} [${turn.status}/${turn.purpose}] ${turn.roleName} ${presentTime(turn.createdAt, timeZone)}`)
         ];
         return output(lines.join("\n").concat("\n"), {
             taskId: task.id,
             wake,
             events,
             messages,
-            runs
+            turns
         });
     }
     throw usageError(command === undefined
@@ -7218,60 +6487,6 @@ function messageOf(error) {
 function taskMailbox(taskId) {
     return { kind: "task", taskId };
 }
-function settleTaskExecutionForCompletion(store, taskId, roles, summary, now) {
-    const activeRuns = store.listAgentRuns(taskId).filter((run) => run.status === "active");
-    for (const run of activeRuns) {
-        store.saveAgentRun(run.roleName === LEADER_ROLE && run.pushedAt !== undefined
-            ? yieldAgentRun(run, summary, now)
-            : failAgentRun(run, `Task completed: ${summary}`, now));
-        if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-            store.clearActiveExecutionLaneRun(taskId, run.executionGroupId, run.executionLaneId);
-        }
-    }
-    // Historical pointer projections are execution state, not Task progress.
-    for (const run of store.listAgentRuns(taskId)) {
-        if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-            store.clearActiveExecutionLaneRun(taskId, run.executionGroupId, run.executionLaneId);
-        }
-    }
-    const targets = [];
-    for (const role of roles) {
-        store.clearActiveAgentRun(taskId, role.name);
-        let sessions = store.getTaskRoleSessionSet(taskId, role.name);
-        const activeSession = sessions?.sessions[sessions.activeAgentId];
-        const cleanupRequired = ownedRuntimeSessionRequiresCleanup(activeSession);
-        if (sessions !== null) {
-            if (sessions.inFlight !== null) {
-                sessions = terminalizeTaskRoleRunSession(sessions, sessions.inFlight, now);
-            }
-            const current = sessions.sessions[sessions.activeAgentId];
-            if (current !== undefined && current.status === "active") {
-                sessions = updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "ended", now, "stopped");
-            }
-            store.saveTaskRoleSessionSet(sessions);
-        }
-        if (!cleanupRequired)
-            continue;
-        const target = runtimeLifecycleTarget({
-            scope: "task",
-            taskId,
-            roleName: role.name
-        });
-        enqueueWork(store, target, RUNTIME_CLEANUP_REQUIRED_REASON, now, [taskRef(taskId)]);
-        targets.push(target);
-    }
-    return targets;
-}
-function ownedRuntimeSessionRequiresCleanup(session) {
-    if (session === undefined || session.status === "ended") {
-        return false;
-    }
-    // Older synthetic session fixtures can represent a ready native session
-    // without a lifecycle generation. Do not manufacture a cleanup obligation
-    // for those records; coordinated launches always carry launchId, while a
-    // running session remains actionable even when an older record lacks it.
-    return session.launchId !== undefined;
-}
 function roleMailbox(taskId, roleName) {
     return { kind: "role", taskId, roleName };
 }
@@ -7281,8 +6496,8 @@ function leaderMailbox(taskId) {
 function taskRef(id) {
     return { type: "task", id };
 }
-function runRef(taskId, id) {
-    return { type: "run", taskId, id };
+function turnRef(taskId, id) {
+    return { type: "turn", taskId, id };
 }
 function workItemRef(taskId, id) {
     return { type: "work-item", taskId, id };