@zq-silk/yui 0.13.4 → 0.13.5

package/dist/commands/taskCommands.js

@@ -10,19 +10,17 @@ import { isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../sc
 import { routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
-import { createRoleSessionSet, retireTaskRoleSessionsForWorkspace, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, retireTaskRoleSessionsForWorkspace, terminalizeTaskRoleRunSession, updateTaskRoleProviderRuntime, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
 import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
-import { CONVERSATION_SWITCH_REQUESTED_EVENT, CONVERSATION_SWITCH_RESOLVED_EVENT, projectConversationSwitch, providerConversationGeneration, roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { renderRoleDetails } from "../output/rolePresentation.js";
 import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js";
 import { cancelInputRequest } from "../input/inputRequest.js";
-import { recoverExactAgentRun, retireExactActiveAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
+import { retireExactActiveAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
-import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
-import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
+import { 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";
@@ -38,7 +36,7 @@ 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 { blockingProviderContinuations, projectProviderContinuations, runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.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";
@@ -196,19 +194,6 @@ export function preflightTaskCompletion(taskId, store, options = {}, request = {
     if (blockers.length > 0) {
         throw usageError(formatCompletionBlockers(task.id, blockers));
     }
-    const roles = store.listRoles(task.id);
-    const activeRuns = roles
-        .map((role) => ({ role, run: store.getActiveAgentRun(task.id, role.name) }))
-        .filter((entry) => entry.run !== null);
-    const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
-    if (leaderEntry !== undefined) {
-        if (leaderEntry.run.workItemId !== undefined) {
-            throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
-        }
-        if (leaderEntry.run.pushedAt === undefined) {
-            throw usageError(`Task ${task.id} Leader delivery is still pending.`);
-        }
-    }
     return {
         task,
         actor,
@@ -728,33 +713,6 @@ function completeTaskCommand(args, store, options) {
             ? undefined
             : assertTaskCompletionPublishedTreeProof(tx, task, request.acceptedPublishedTreePublicationId, options.completionPublishedTreeProof, actualTaskCandidate);
         const roles = tx.listRoles(task.id);
-        const activeRuns = roles
-            .map((role) => ({ role, run: tx.getActiveAgentRun(task.id, role.name) }))
-            .filter((entry) => entry.run !== null);
-        // The preflight (above, same transaction) already projected the full
-        // readiness via projectCompletionReadiness.  The leader-Run check is
-        // actor-dependent and stays here; every other blocker is re-validated by
-        // the post-Review readiness fence below.
-        const leaderEntry = activeRuns.find(({ role }) => role.name === LEADER_ROLE);
-        if (leaderEntry !== undefined) {
-            if (leaderEntry.run.workItemId !== undefined) {
-                throw usageError(`Task ${task.id} has running work: ${leaderEntry.run.workItemId}.`);
-            }
-            if (leaderEntry.run.pushedAt === undefined) {
-                throw usageError(`Task ${task.id} Leader delivery is still pending.`);
-            }
-            const terminal = terminalizeExactTaskRun(tx, {
-                taskId: task.id,
-                roleName: LEADER_ROLE,
-                agentId: leaderEntry.run.effective.agentId,
-                runId: leaderEntry.run.id,
-                receiptId: agentRunDeliveryReceiptId(leaderEntry.run),
-                outcome: { status: "yielded", summary }
-            }, now);
-            if (terminal.disposition !== "applied") {
-                throw usageError(`Task Leader Run changed during completion: ${leaderEntry.run.id}/${terminal.reason}.`);
-            }
-        }
         // A final (Task-scoped) review is the Task delivery policy: it reviews the
         // complete frozen Task heads, not a single WorkItem Candidate. If the
         // review config requests a final review, create the Task ReviewRound here
@@ -769,6 +727,10 @@ function completeTaskCommand(args, store, options) {
                 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);
         // 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
@@ -818,13 +780,12 @@ function completeTaskCommand(args, store, options) {
         // The durable records remain intact; only the derived mailbox work is
         // discarded at this lifecycle boundary.
         tx.removeWorkMailbox(taskMailbox(task.id));
-        // Role mailboxes are also derived wake state. A Worker result or recovery
+        // 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
         // completed Task and become actionable after a later explicit reopen.
         for (const role of roles) {
             tx.removeWorkMailbox(roleMailbox(task.id, role.name));
         }
-        const runtimeCleanupTargets = queueCompletedTaskRuntimeCleanups(tx, task.id, roles, now);
         return {
             task: completed,
             changed: true,
@@ -930,11 +891,6 @@ function archiveTaskCommand(args, store, options) {
         if (activeArchiveJob !== undefined) {
             throw usageError(`Task ${task.id} has an active DurableJob: ${activeArchiveJob.id}/${activeArchiveJob.status}.`);
         }
-        const continuationBlockers = blockingProviderContinuations(tx.listEvents(task.id));
-        if (continuationBlockers.length > 0) {
-            throw usageError(`Task ${task.id} still owns unsettled Provider continuation(s); `
-                + "reconcile or cancel them before archiving.");
-        }
         if (task.cwd !== undefined || tx.listManagedWorkspaces(task.id).length > 0) {
             throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
         }
@@ -1325,8 +1281,6 @@ function taskRoleCommand(args, store, options) {
         return output(bindTaskRole(rest, store, options));
     if (command === "unbind")
         return output(unbindTaskRole(rest, store, options));
-    if (command === "session")
-        return taskRoleSessionCommand(rest, store, options);
     if (command === "view")
         return viewTaskRole(rest, store);
     if (command === "takeover")
@@ -1337,79 +1291,6 @@ function taskRoleCommand(args, store, options) {
         ? "Task role command is required."
         : `Unknown command: task role ${command}`);
 }
-function taskRoleSessionCommand(args, store, options) {
-    const [command, ...rest] = args;
-    if (command === "switch")
-        return switchTaskRoleSession(rest, store, options);
-    throw usageError(command === undefined
-        ? "Task role session command is required."
-        : `Unknown command: task role session ${command}`);
-}
-function switchTaskRoleSession(args, store, options) {
-    const usage = "Task role session switch usage: yui task role session switch <task> <role> --reason <text>.";
-    const parsed = parseTail(args, new Set(["--reason"]), usage);
-    exactPositionals(parsed.positionals, 2, usage);
-    const reason = truncateEventNote(requiredOption(parsed.options, "--reason"));
-    const now = clock(options);
-    const result = store.transaction((tx) => {
-        const task = requireTask(tx, parsed.positionals[0]);
-        if (task.status !== "active") {
-            throw usageError(inactiveTaskMessage(task, "switching a Provider Conversation"), usage);
-        }
-        const role = requireRole(tx, task.id, parsed.positionals[1]);
-        const requestedBy = taskActor(tx, options, task.id);
-        const leaderRunId = requestedBy === "leader"
-            ? taskLeaderActionRunId(tx, task.id, options.environment, options.yuiHome)
-            : undefined;
-        if (requestedBy === "leader" && leaderRunId === undefined) {
-            throw usageError("Leader Conversation switching requires the exact current-Turn assertion.", usage);
-        }
-        const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
-        const generation = providerConversationGeneration(sessions);
-        if (sessions === null || generation === null) {
-            throw usageError(`Task Role has no current Provider Conversation: ${task.id}/${role.name}.`, usage);
-        }
-        const events = tx.listEvents(task.id);
-        const previous = projectConversationSwitch(events, role.name, sessions);
-        if (previous?.status === "pending"
-            && previous.generation === generation
-            && previous.requestedBy === requestedBy
-            && previous.reason === reason) {
-            return { taskId: task.id, roleName: role.name, request: previous, replayed: true };
-        }
-        if (previous !== null && previous.resolvedAt === undefined) {
-            tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, CONVERSATION_SWITCH_RESOLVED_EVENT, {
-                requestId: previous.requestId,
-                roleName: role.name,
-                generation: previous.generation,
-                status: "obsolete"
-            }, now));
-        }
-        const requestId = tx.nextEventId(task.id);
-        const event = createTaskEvent(requestId, task.id, CONVERSATION_SWITCH_REQUESTED_EVENT, {
-            requestId,
-            roleName: role.name,
-            generation,
-            requestedBy,
-            reason,
-            ...(leaderRunId === undefined ? {} : { leaderRunId })
-        }, now);
-        tx.saveEvent(task.id, event);
-        return {
-            taskId: task.id,
-            roleName: role.name,
-            request: projectConversationSwitch([...events, event], role.name, sessions),
-            replayed: false
-        };
-    });
-    options.runtime?.notifyStateChanged(result.taskId);
-    options.runtime?.notifyMailboxChanged?.({
-        kind: "role",
-        taskId: result.taskId,
-        roleName: result.roleName
-    });
-    return output(`${result.replayed ? "Reused" : "Recorded"} pending Provider Conversation switch ${result.request.requestId} for ${result.taskId}/${result.roleName}. The current Conversation remains authoritative until safe replacement binding.\n`, result);
-}
 function addTaskRole(args, store, options) {
     const usage = "Task role add usage: yui task role add <task> <name> [Role and Agent settings].";
     const [taskId, roleName, ...tail] = args;
@@ -2099,6 +1980,7 @@ function dispatchWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(inactiveTaskMessage(task, "dispatch"));
         }
+        assertTaskExecutionEnabled(task, "dispatching work");
         taskActor(tx, options, task.id);
         const currentGroup = currentWorkItemExecutionGroup(item);
         const existingGroup = currentGroup?.resolution === undefined
@@ -2342,7 +2224,7 @@ function dispatchWork(args, store, options) {
                 workItemWriteProjectIds: item.writeProjectIds
             });
             const sessions = tx.getTaskRoleSessionSet(task.id, plan.role.name);
-            const dispatchMode = taskRoleDispatchMode(tx, task.id, plan.role.name, sessions, effective.agentId, effective);
+            const dispatchMode = roleAgentSessionResumeMode(sessions, effective.agentId, effective);
             const laneWorkspace = laneManagedWorkspace === undefined
                 ? undefined
                 : {
@@ -4041,8 +3923,6 @@ function taskRunCommand(args, store, options) {
         return retryRun(rest, store, options);
     if (command === "settle")
         return settleStaleFinalReviewRun(rest, store, options);
-    if (command === "recover")
-        return output(recoverRun(rest, store, options));
     if (command === "yield")
         return yieldRun(rest, store, options);
     if (command === "yield-status")
@@ -4413,15 +4293,7 @@ function retryRun(args, store, options) {
         const task = requireTask(tx, previous.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (runOwnsBlockingProviderContinuation(tx.listEvents(task.id), {
-            taskId: previous.taskId,
-            roleName: previous.roleName,
-            runId: previous.id,
-            agentId: previous.effective.agentId
-        })) {
-            throw usageError(`Run ${previous.id} still owns an unsettled Provider continuation; `
-                + "reconcile it before retrying the Lane.");
-        }
+        assertTaskExecutionEnabled(task, "retrying a Run");
         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.`);
@@ -4616,7 +4488,7 @@ function retryRun(args, store, options) {
             contextSnapshotRef: contextSnapshotRef(retrySnapshot),
             deltaRefIds: contextSnapshotDeltaRefIds(tx, retrySnapshot)
         });
-        const created = createAgentRun(runId, task.id, role.name, taskRoleDispatchMode(tx, task.id, role.name, sessions, effective.agentId, effective), assignment, now, {
+        const created = createAgentRun(runId, task.id, role.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
             ...(previous.workItemId === undefined ? {} : { workItemId: previous.workItemId }),
             ...(runningGroup === undefined ? {} : {
                 executionGroupId: runningGroup.id,
@@ -4960,15 +4832,6 @@ function retryFailedReviewRun(previous, store, options, now) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        if (runOwnsBlockingProviderContinuation(tx.listEvents(task.id), {
-            taskId: run.taskId,
-            roleName: run.roleName,
-            runId: run.id,
-            agentId: run.effective.agentId
-        })) {
-            throw usageError(`Review Run ${run.id} still owns an unsettled Provider continuation; `
-                + "reconcile it before retrying the Lane.");
-        }
         const requestedBy = taskActor(tx, options, task.id);
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
@@ -5161,127 +5024,7 @@ 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 });
 }
-/**
- * Records one explicit Leader recovery decision against an exact live Run.
- * Diagnose and retry remain same-Run requests: this command never changes a
- * native Conversation generation.
- */
-function recoverRun(args, store, options) {
-    const usage = "Task run recover usage: yui task run recover <task>/<run> --action <diagnose|retry|terminate> (--expected-progress-at <timestamp>|--from-next-action <fingerprint>) --provider-acceptance <accepted|rejected|ambiguous> --reason <text> [--agent-id <id>] [--adapter-id <id>] [--native-session-id <id>] [--launch-id <id>].";
-    const parsed = parseTail(args, new Set([
-        "--action",
-        "--expected-progress-at",
-        "--progress-at",
-        "--from-next-action",
-        "--provider-acceptance",
-        "--reason",
-        "--role",
-        "--agent-id",
-        "--adapter-id",
-        "--native-session-id",
-        "--launch-id"
-    ]), usage);
-    exactPositionals(parsed.positionals, 1, usage);
-    const now = clock(options);
-    const fingerprint = parsed.options.get("--from-next-action");
-    const explicitFence = parsed.options.get("--expected-progress-at")
-        ?? parsed.options.get("--progress-at");
-    if (fingerprint !== undefined && explicitFence !== undefined) {
-        throw usageError("--from-next-action and --expected-progress-at/--progress-at are mutually exclusive.", usage);
-    }
-    const input = store.transaction((tx) => {
-        const active = requireRun(tx, parsed.positionals[0], options);
-        const task = requireTask(tx, active.taskId);
-        if (task.status !== "active")
-            throw usageError(inactiveTaskMessage(task, "recovering a run"));
-        taskActor(tx, options, task.id);
-        const roleName = parsed.options.get("--role") ?? active.roleName;
-        if (roleName !== active.roleName) {
-            throw usageError(`Recovery Role does not match Run ${active.id}: ${roleName}.`);
-        }
-        const role = requireRole(tx, task.id, roleName);
-        const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
-        const session = sessions?.sessions[sessions.activeAgentId];
-        // Issue 08: a fingerprint copied from `task run show` resolves the
-        // canonical fence server-side. The projection is recomputed here, so a
-        // fingerprint from stale observations matches nothing and fails closed.
-        let plan = null;
-        if (fingerprint !== undefined) {
-            const facts = readRunRecoveryFacts(tx, task.id, active.id);
-            if (facts === null)
-                throw usageError(`Agent Run not found: ${task.id}/${active.id}.`, usage);
-            const projection = projectRunRecovery(facts);
-            plan = projection.actions.find((entry) => entry.fingerprint === fingerprint) ?? null;
-            if (plan === null) {
-                throw usageError(runRecoveryStaleDiagnosis(task.id, active.id, projection.canonicalProgressAt ?? null, "recovery action fingerprint is stale or unknown"), usage);
-            }
-        }
-        const action = parseRecoveryAction(parsed.options.get("--action") ?? plan?.action, usage);
-        if (plan !== null && plan.action !== action) {
-            throw usageError(`--action ${action} does not match recovery fingerprint action ${plan.action}.`, usage);
-        }
-        const expectedProgressAt = explicitFence ?? plan?.expectedProgressAt;
-        if (expectedProgressAt === undefined) {
-            throw usageError("--expected-progress-at is required.", usage);
-        }
-        const providerAcceptance = parseProviderAcceptance(parsed.options.get("--provider-acceptance"), usage);
-        const agentId = parsed.options.get("--agent-id")
-            ?? plan?.agentId
-            ?? active.effective.agentId;
-        const adapterId = parsed.options.get("--adapter-id")
-            ?? plan?.adapterId
-            ?? active.effective.adapterId;
-        const nativeSessionId = parsed.options.get("--native-session-id")
-            ?? plan?.nativeSessionId
-            ?? session?.nativeSessionId;
-        const launchId = parsed.options.get("--launch-id")
-            ?? plan?.launchId
-            ?? session?.launchId;
-        return {
-            taskId: task.id,
-            roleName: role.name,
-            runId: active.id,
-            agentId,
-            adapterId,
-            ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-            ...(launchId === undefined ? {} : { launchId }),
-            expectedProgressAt,
-            providerAcceptance,
-            action,
-            reason: requiredOption(parsed.options, "--reason"),
-            now
-        };
-    });
-    const result = recoverExactAgentRun(store, input);
-    if (result.disposition !== "applied") {
-        throw usageError(runRecoveryStaleDiagnosis(input.taskId, input.runId, result.progressAt ?? null, `exact Run recovery ${result.disposition}: ${result.reason ?? "state changed"}`), usage);
-    }
-    // The durable recovery request is committed before asking the Controller to
-    // wake the owning Leader; a failed transaction must not leak a signal.
-    if (result.run !== null && result.run.roleName !== LEADER_ROLE) {
-        notifyMailbox(options.runtime, leaderMailbox(result.run.taskId), result.run.taskId);
-    }
-    const followup = result.requiresExplicitFollowup === true
-        ? " Leader follow-up is required; no provider input or Session action was performed."
-        : "";
-    return `Recorded exact ${result.action} recovery for ${result.run?.id ?? "unknown Run"}.${followup}\n`;
-}
-/**
- * Issue 08: every recovery rejection carries the current canonical fence and
- * points at the single read-only command that projects it. The caller's
- * side-effecting action is never retried automatically.
- */
-function runRecoveryStaleDiagnosis(taskId, runId, canonicalProgressAt, detail) {
-    const fence = canonicalProgressAt === null
-        ? "no durable progress timestamp is available for this Run"
-        : `the canonical durable fence is now ${canonicalProgressAt}`;
-    return `${detail}; ${fence}. Re-read the recovery plan: yui task run show ${taskId}/${runId}.`;
-}
-/**
- * Issue 08: read-only Run detail with the canonical recovery fence, Provider
- * evidence, and every exact recovery action. Never mutates state and never
- * selects an action or Provider acceptance for the Leader.
- */
+/** 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].";
     const asJson = args.includes("--json");
@@ -5289,9 +5032,6 @@ function showRun(args, store, options) {
     exactPositionals(positionals, 1, usage);
     const data = store.transaction((tx) => {
         const run = requireRun(tx, positionals[0], options);
-        const facts = readRunRecoveryFacts(tx, run.taskId, run.id);
-        if (facts === null)
-            throw usageError(`Agent Run not found: ${run.taskId}/${run.id}.`, usage);
         const retirement = tx.listEvents(run.taskId)
             .map(taskRecordRetirement)
             .find((entry) => entry?.recordKind === "agent-run" && entry.recordId === run.id) ?? null;
@@ -5300,7 +5040,6 @@ function showRun(args, store, options) {
             .filter((attempt) => (attempt !== null && attempt.runId === run.id));
         return {
             run,
-            recovery: projectRunRecovery(facts),
             retirement,
             rejectedYieldAttemptCount: allRejectedYieldAttempts.length,
             rejectedYieldAttempts: allRejectedYieldAttempts.slice(-16)
@@ -5311,11 +5050,11 @@ function showRun(args, store, options) {
     }
     return {
         kind: "output",
-        output: renderRunShow(data.run, data.recovery, data.retirement, data.rejectedYieldAttemptCount, data.rejectedYieldAttempts),
+        output: renderRunShow(data.run, data.retirement, data.rejectedYieldAttemptCount, data.rejectedYieldAttempts),
         data
     };
 }
-function renderRunShow(run, recovery, retirement, rejectedYieldAttemptCount, rejectedYieldAttempts) {
+function renderRunShow(run, retirement, rejectedYieldAttemptCount, rejectedYieldAttempts) {
     const lines = [
         `Run: ${run.id}`,
         `Task: ${run.taskId}`,
@@ -5329,6 +5068,7 @@ function renderRunShow(run, recovery, retirement, rejectedYieldAttemptCount, rej
         ]),
         `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
             ? []
@@ -5349,33 +5089,6 @@ function renderRunShow(run, recovery, retirement, rejectedYieldAttemptCount, rej
                 ])
             ])
     ];
-    if (recovery.canonicalProgressAt !== null) {
-        lines.push(`Canonical recovery fence (Yui durable CAS): ${recovery.canonicalProgressAt}`, ...(recovery.canonicalProgressEvidence === undefined
-            ? []
-            : [`Fence evidence: ${recovery.canonicalProgressEvidence}`]));
-    }
-    if (recovery.provider.observedAt !== null) {
-        lines.push(`Provider observation (evidence only, not a fence): `
-            + `${recovery.provider.observationKind} at ${recovery.provider.observedAt}`);
-    }
-    if (recovery.session !== null) {
-        const session = recovery.session;
-        lines.push(`Session: ${session.status}`
-            + `${session.nativeSessionId === undefined ? "" : ` ${session.nativeSessionId}`}`
-            + `${session.launchId === undefined ? "" : ` launch ${session.launchId}`}`);
-    }
-    if (recovery.recoverable) {
-        lines.push(`Provider acceptance options: ${recovery.providerAcceptance.options.join(", ")}`, "Recovery actions (copy one; the fence is already canonical):");
-        for (const plan of recovery.actions) {
-            lines.push(`  [${plan.action}] ${plan.reason}`, `    ${plan.command}`);
-        }
-        if (recovery.judgmentRequired !== undefined) {
-            lines.push(`Judgment: ${recovery.judgmentRequired}`);
-        }
-    }
-    else {
-        lines.push(`Not recoverable: ${recovery.reason ?? "unknown"}`);
-    }
     return `${lines.join("\n")}\n`;
 }
 function truncateRunShowText(value) {
@@ -6027,6 +5740,9 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
             }
         }
         const task = requireTask(tx, taskId);
+        if (task.status !== "active")
+            throw usageError(`Task is not active: ${task.id}.`);
+        assertTaskExecutionEnabled(task, "dispatching a Review");
         if ((round.scope ?? "work-item") === "task") {
             let taskFinalContract;
             try {
@@ -6308,7 +6024,7 @@ export function dispatchPreparedReviewRound(taskId, reviewRoundId, store, option
                 effective,
                 workspace: laneWorkspace
             }, now);
-            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, taskRoleDispatchMode(tx, taskId, laneReviewer.name, sessions, effective.agentId, effective), assignment, now, {
+            createdRuns.push(createAgentRun(runId, taskId, laneReviewer.name, roleAgentSessionResumeMode(sessions, effective.agentId, effective), assignment, now, {
                 ...(item === undefined ? {} : { workItemId: item.id }),
                 purpose: "review",
                 reviewRoundId: round.id,
@@ -6650,12 +6366,14 @@ function assertTaskOpen(task) {
     if (task.status === "retired")
         throw usageError(`Task is retired: ${task.id}.`);
 }
+function assertTaskExecutionEnabled(task, action) {
+    if (task.executionGate.state === "enabled")
+        return;
+    throw usageError(`Task execution is stopped: ${task.id}. Run "yui task execution start ${task.id}" before ${action}.`);
+}
 function taskActor(store, options, taskId) {
     return resolveTaskLocalActor(store, options.environment, taskId, options.yuiHome);
 }
-function taskRoleDispatchMode(store, taskId, roleName, sessions, agentId, effective) {
-    return roleSessionDispatchModeWithConversationSwitch(sessions, store.listEvents(taskId), store.getWorkMailbox({ kind: "role", taskId, roleName }), roleName, agentId, effective);
-}
 function inactiveTaskMessage(task, action) {
     if (task.status === "draft") {
         return `Task ${task.id} is a Draft; activate it before ${action}.`;
@@ -6683,18 +6401,6 @@ function parseWorkStatus(value) {
         return "failed";
     throw usageError(`Invalid work item status: ${value}.`);
 }
-function parseRecoveryAction(value, usage) {
-    if (value === "diagnose"
-        || value === "retry"
-        || value === "terminate")
-        return value;
-    throw usageError("--action must be diagnose, retry, or terminate.", usage);
-}
-function parseProviderAcceptance(value, usage) {
-    if (value === "accepted" || value === "rejected" || value === "ambiguous")
-        return value;
-    throw usageError("--provider-acceptance must be accepted, rejected, or ambiguous.", usage);
-}
 function presentWorkStatus(status) {
     if (status === "pending")
         return "todo";
@@ -7437,14 +7143,42 @@ function messageOf(error) {
 function taskMailbox(taskId) {
     return { kind: "task", taskId };
 }
-function queueCompletedTaskRuntimeCleanups(store, taskId, roles, now) {
+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) {
-        if (store.getActiveAgentRun(taskId, role.name) !== null)
-            continue;
-        const sessions = store.getTaskRoleSessionSet(taskId, role.name);
-        const active = sessions?.sessions[sessions.activeAgentId];
-        if (!ownedRuntimeSessionRequiresCleanup(active))
+        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 !== "stopped" && current.status !== "broken") {
+                sessions = updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now);
+            }
+            store.saveTaskRoleSessionSet(sessions);
+        }
+        if (role.status !== "idle") {
+            store.saveRole(taskId, updateRoleStatus(role, "idle", now));
+        }
+        if (!cleanupRequired)
             continue;
         const target = runtimeLifecycleTarget({
             scope: "task",

package/dist/commands/taskContextCommand.js

@@ -4,11 +4,9 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
-import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-import { projectExecutionLaneRunRecoveries } from "../run/recoveryProjection.js";
 import { projectReviewDecision } from "../review/reviewDecision.js";
 const RECENT_RECORD_LIMIT = 5;
 const RELATED_RECORD_LIMIT = 5;
@@ -76,7 +74,6 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             managedWorkspaces: reader.listManagedWorkspaces(task.id),
             roleSessionSets,
             coordinationMailboxes,
-            roleSessionRecoveries: roles.map((role) => (inspectTaskRoleSessionRecovery(task.id, role.name, reader))),
             workItems,
             agentRuns,
             reviewRounds,
@@ -90,12 +87,11 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             nextAction: projectNextAction({
                 ...nextActionFacts,
                 currentTaskReviewCandidate,
-                executionGroups: execution.executionGroups,
-                runRecoveries: projectExecutionLaneRunRecoveries(reader, task.id, execution.executionGroups)
+                executionGroups: execution.executionGroups
             })
         };
     });
-    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
+    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
@@ -251,7 +247,6 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                 const activeSession = sessions?.sessions[sessions.activeAgentId];
                 const effective = activeRun?.effective ?? activeSession?.effective;
                 const effectiveSource = activeRun === undefined ? "Session" : "Run";
-                const recovery = roleSessionRecoveries.find((entry) => entry.roleName === role.name);
                 const creation = [...events].reverse().find((event) => (event.type === "role.added" && event.payload.role === role.name));
                 return [
                     `  ${role.name} [${role.status}]: ${role.activeAgentId}/${binding.adapterId}`,
@@ -266,13 +261,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                             : "pending next launch"}`,
                     ...(creation?.payload.runtimeSource === undefined
                         ? []
-                        : [`    Runtime source at creation: ${creation.payload.runtimeSource}`]),
-                    ...(recovery === undefined ? [] : [
-                        `    Runtime cleanup: ${recovery.runtimeCleanupPending ? "pending" : "none"}`,
-                        `    Fresh launch: ${recovery.freshLaunchAllowed
-                            ? "allowed"
-                            : `blocked (${recovery.freshLaunchBlockers.join(", ")})`}`
-                    ])
+                        : [`    Runtime source at creation: ${creation.payload.runtimeSource}`])
                 ];
             })),
         "",