@zq-silk/yui 0.13.4 → 0.13.6

package/dist/execution/executionHealth.js

@@ -64,11 +64,6 @@ export function summarizeExecutionGroupHealth(input) {
 }
 /** Unresolved Lane recovery in deterministic operational priority order. */
 export function actionableExecutionLaneRecoveries(groups) {
-    const priority = {
-        "terminate-exact-run": 0,
-        "retry-new-agent-run": 1,
-        diagnose: 2
-    };
     return groups
         .filter(({ resolution }) => resolution === undefined)
         .flatMap((group) => group.laneSummaries.flatMap((lane) => {
@@ -76,9 +71,7 @@ export function actionableExecutionLaneRecoveries(groups) {
             && group.resources !== undefined
             && executionStageSpendClosed(group.resources))
             return [];
-        if (lane.recovery !== "diagnose"
-            && lane.recovery !== "terminate-exact-run"
-            && lane.recovery !== "retry-new-agent-run")
+        if (lane.recovery !== "retry-new-agent-run")
             return [];
         return [{
                 groupId: group.groupId,
@@ -87,8 +80,7 @@ export function actionableExecutionLaneRecoveries(groups) {
                 ...(lane.runtimeHealth === undefined ? {} : { runtimeHealth: lane.runtimeHealth }),
                 recovery: lane.recovery
             }];
-    }))
-        .sort((left, right) => priority[left.recovery] - priority[right.recovery]);
+    }));
 }
 function projectExecutionLaneHealth(lane, input, policy) {
     const run = lane.runId === undefined
@@ -149,7 +141,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
     if (run === undefined) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
-            recovery: "diagnose",
+            recovery: "inspect",
             resultReusable: false,
             reason: "the running Lane has no exact AgentRun record",
             evidence: ["execution-lineage-missing"]
@@ -167,7 +159,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
     if (run.status !== "active") {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
-            recovery: "diagnose",
+            recovery: "inspect",
             resultReusable: false,
             reason: "the Lane is running but its exact AgentRun is terminal without a Lane result",
             evidence: ["execution-lineage-inconsistent"]
@@ -189,7 +181,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
         && observation.payload.failure?.runTerminal === true)) && !unsettledChildWork) {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "terminate-exact-run",
+            recovery: "inspect",
             resultReusable: false,
             reason: "the Provider reported an exact run-terminal failure",
             evidence: ["provider-run-terminal"]
@@ -206,7 +198,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
     if (runtimeTerminalEvidence.length > 0 && !unsettledChildWork) {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "terminate-exact-run",
+            recovery: "inspect",
             resultReusable: false,
             reason: "the exact runtime host or Session is terminal and no unsettled child work remains",
             evidence: runtimeTerminalEvidence
@@ -220,7 +212,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
         && !unsettledChildWork) {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "terminate-exact-run",
+            recovery: "inspect",
             resultReusable: false,
             reason: "the exact Session and abnormal process exit independently confirm death",
             evidence: ["native-session-terminal", `process-exit:${exit.classification}`]
@@ -229,7 +221,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
     if (isRoleRunStalled(input.events, run.id)) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
-            recovery: "diagnose",
+            recovery: "inspect",
             resultReusable: false,
             reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, run.id) ?? run.updatedAt}; no death proof exists`,
             evidence: ["run-stalled"]

package/dist/executor/agentAdapter.js

@@ -150,10 +150,6 @@ class CodexAdapter extends BaseAdapter {
     }
     compileManagedControl(input, _mode, _nativeSessionId) {
         const config = this.canonicalizeConfig(input.config);
-        if (config.profile !== undefined) {
-            throw new Error("Managed Codex does not accept a Codex config profile because it cannot be scoped to one "
-                + "shared-daemon thread. Use a Yui Agent Profile for skills, model, and effort.");
-        }
         const launch = this.compileNew(input);
         // A managed Codex thread is an ordinary user thread. Its Yui guidance is
         // part of the durable Task message, not a developer_instructions override
@@ -170,10 +166,9 @@ class CodexAdapter extends BaseAdapter {
         }
         return {
             ...launch,
-            argv: [...argv, "app-server", "proxy"],
-            transport: "codex-app-server-proxy",
-            codexThread: codexThreadOptions(input, config),
-            codexDaemonStartArgs: [...input.agent.baseArgs, "app-server", "daemon", "start"]
+            argv: [...argv, "app-server"],
+            transport: "codex-app-server",
+            codexThread: codexThreadOptions(input, config)
         };
     }
 }

package/dist/executor/agentExecutor.js

@@ -120,12 +120,8 @@ export function recordRoleAgentSession(set, input, now) {
     validateRoleSessionSet(updated);
     return updated;
 }
-/**
- * Atomically archives the quiescent old native Session and binds the Provider
- * Conversation selected by an already-authorized switch. Authorization is
- * deliberately owned by the Controller caller, not inferred here.
- */
-export function replaceTaskRoleAgentSessionForConversationSwitch(set, input, now) {
+/** Atomically archives a disposable old native Session and binds its replacement. */
+export function replaceTaskRoleAgentSession(set, input, now) {
     validateRoleSessionSet(set);
     const existing = set.sessions[input.agentId];
     if (existing === undefined || existing.nativeSessionId === input.nativeSessionId) {
@@ -302,12 +298,15 @@ export function bindTaskRoleRun(set, fence, preparedAt, mode) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    // A fresh Conversation is a two-phase replacement: keep the old binding as
-    // current evidence until the new Provider session is observed and atomically
-    // superseded. Homes with no prior Conversation still start from null.
-    const providerBinding = set.providerBinding !== null
-        ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
-        : null;
+    // A fresh Session follows physical cleanup and does not inherit execution
+    // fences from the disposable old Conversation. Runtime events retain its
+    // audit evidence; the new Provider binds a fresh control identity when it is
+    // observed. Resume keeps the existing exact Conversation fence.
+    const providerBinding = mode === "new"
+        ? null
+        : set.providerBinding !== null
+            ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
+            : null;
     const updated = {
         ...set,
         inFlight: { ...normalized, preparedAt: timestamp },
@@ -666,8 +665,8 @@ export function validateRoleAgentSession(session, expectedAgentId = session.agen
     if (session.effective.agentId !== agentId || session.effective.adapterId !== session.adapterId) {
         throw new Error(`Role Agent session effective identity is inconsistent: ${agentId}.`);
     }
-    // A restored opaque host may have no provider-native identity; its launch
-    // fence is still durable and exact recovery remains possible.
+    // A restored opaque host may have no provider-native identity; retain its
+    // launch fence so it can be inspected or stopped without inventing identity.
     if (session.nativeSessionId === undefined) {
         if (session.launchId === undefined) {
             throw new Error("Role Agent session requires a native Session or launch id.");

package/dist/executor/fileRoleLaunchPlanner.js

@@ -27,7 +27,6 @@ import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment }
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
-import { freshConversationLaunchAllowed } from "../runtime/conversationSwitch.js";
 import { currentProviderActivation } from "../runtime/providerRuntimeIdentity.js";
 import { assertCodexLaunchOverridesAvailable, inspectCodexLaunchConfig } from "./codexConfigConflict.js";
 /** Builds managed native Agent launches from the authoritative Task records. */
@@ -97,7 +96,10 @@ export class FileRoleLaunchPlanner {
     refreshTaskRuntimeDescriptor(input) {
         const task = this.store.getTask(input.taskId);
         const role = this.store.getRole(input.taskId, input.roleName);
-        if (task === null || task.status !== "active" || role === null) {
+        if (task === null
+            || task.status !== "active"
+            || task.executionGate.state !== "enabled"
+            || role === null) {
             throw new Error(`Task runtime is not current: ${input.taskId}/${input.roleName}.`);
         }
         const run = this.store.getActiveAgentRun(input.taskId, input.roleName);
@@ -137,8 +139,9 @@ export class FileRoleLaunchPlanner {
         const task = this.store.getTask(input.taskId);
         if (task === null)
             throw new Error(`Task not found: ${input.taskId}.`);
-        if (task.status !== "active")
-            throw new Error(`Task is not active: ${input.taskId}.`);
+        if (task.status !== "active" || task.executionGate.state !== "enabled") {
+            throw new Error(`Task execution is not enabled: ${input.taskId}.`);
+        }
         const role = this.store.getRole(input.taskId, input.roleName);
         if (role === null)
             throw new Error(`Role not found: ${input.taskId}/${input.roleName}.`);
@@ -228,18 +231,8 @@ export class FileRoleLaunchPlanner {
             throw new Error(`Task Role resume effective snapshot drifted: ${task.id}/${role.name}.`);
         }
         if (input.mode === "new" && sessionSet !== null
-            && !freshConversationLaunchAllowed({
-                sessions: sessionSet,
-                events: this.store.listEvents(task.id),
-                mailbox: this.store.getWorkMailbox({
-                    kind: "role",
-                    taskId: task.id,
-                    roleName: role.name
-                }),
-                roleName: role.name,
-                ...(input.runId === undefined ? {} : { candidateRunId: input.runId })
-            })) {
-            throw new Error(`Fresh Provider Conversation is not authorized: ${task.id}/${role.name}.`);
+            && activeLiveRoleAgentSession(sessionSet) !== null) {
+            throw new Error(`Task Role still has a live Session: ${task.id}/${role.name}.`);
         }
         return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
             purpose: activeRun?.purpose ?? "execution"
@@ -427,7 +420,7 @@ export class FileRoleLaunchPlanner {
             if (owner.scope !== "task" || input.runId === undefined) {
                 args = addCodexSessionNotify(args, launchMode, this.#cliPath);
             }
-            // Managed Codex Runs are ordinary shared-daemon threads. Their Session
+            // Managed Codex Runs use Yui-owned App Server processes. Their Session
             // Manifest points at the Yui Skills; no Yui Hook config is installed.
             if (owner.scope === "task" && input.runId !== undefined) {
                 if (managedRun === null || managedRun.status !== "active") {
@@ -523,9 +516,6 @@ export class FileRoleLaunchPlanner {
                     ...(managedCompiled.codexThread === undefined
                         ? {}
                         : { codexThread: managedCompiled.codexThread }),
-                    ...(managedCompiled.codexDaemonStartArgs === undefined
-                        ? {}
-                        : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
                     ...(providerOwnedTurn === undefined ? {} : { ownedTurn: providerOwnedTurn }),
                     authority: providerAuthority
                 }
@@ -543,9 +533,6 @@ export class FileRoleLaunchPlanner {
                         ...(managedCompiled.codexThread === undefined
                             ? {}
                             : { codexThread: managedCompiled.codexThread }),
-                        ...(managedCompiled.codexDaemonStartArgs === undefined
-                            ? {}
-                            : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
                         authority: providerAuthority,
                         initialTurn
                     }
@@ -560,9 +547,6 @@ export class FileRoleLaunchPlanner {
                         ...(managedCompiled.codexThread === undefined
                             ? {}
                             : { codexThread: managedCompiled.codexThread }),
-                        ...(managedCompiled.codexDaemonStartArgs === undefined
-                            ? {}
-                            : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
                         authority: providerAuthority,
                         initialTurn
                     };

package/dist/lifecycle/exactRunTerminalization.js

@@ -1,10 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
 import { completeProcessing } from "../coordination/workMailbox.js";
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { settleExactWorkExecution } from "../coordination/workMailboxQueue.js";
 import { terminalizeTaskRoleRunSession } from "../executor/agentExecutor.js";
 import { updateRoleStatus } from "../role/role.js";
-import { createTaskEvent } from "../event/taskEvent.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
 import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { agentRunDeliveryReceiptId, failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
@@ -12,10 +10,9 @@ import { createYieldReceipt } from "../run/yieldReceipt.js";
 import { recordExecutionLaneResult, resolveExecutionGroup } from "../execution/executionGroup.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
-import { runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
-import { latestRunDurableProgressAt, RUN_RECOVERY_APPLIED_EVENT, RUN_RECOVERY_REQUESTED_EVENT } from "../scheduler/roleRunStall.js";
+import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { markTaskWakeConsumed } from "../scheduler/taskWake.js";
-import { workItemExecutionGroupById, workItemOwnsUnresolvedExecutionLane, updateWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
+import { workItemExecutionGroupById, updateWorkItemExecutionGroup } from "../workItem/workItem.js";
 /**
  * Validate every immutable identity and frozen Project head needed before a
  * review Run can settle any mailbox or Round state.  This is deliberately
@@ -249,23 +246,22 @@ export function retireExactActiveAgentRun(store, input, now) {
     if (progress.progressAt !== input.expectedProgressAt) {
         return { ...stateChanged("progress-fence-mismatch"), progressAt: progress.progressAt };
     }
-    if (!matchesRecoverySessionFence(store, {
-        ...input,
-        action: "terminate",
-        providerAcceptance: current.deliveredAt === undefined ? "rejected" : "accepted",
-        now
-    }))
+    const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+    const terminalInput = {
+        taskId: input.taskId,
+        roleName: input.roleName,
+        agentId: input.agentId,
+        runId: input.runId,
+        receiptId: agentRunDeliveryReceiptId(current),
+        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        settleFailedExecutionGroup: true,
+        outcome: { status: "failed", summary: input.reason }
+    };
+    if (!matchesSessionFence(sessions, terminalInput)
+        || !matchesLaunchFence(store, sessions, terminalInput)) {
         return stateChanged("session-or-launch-fence-mismatch");
-    const blocker = exactRecoveryExecutionBlocker(store, current);
-    if (blocker !== null) {
-        return {
-            disposition: "blocked",
-            run: current,
-            progressAt: progress.progressAt,
-            reason: blocker
-        };
     }
-    const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
     const session = sessions?.sessions[input.agentId];
     const providerBinding = sessions?.providerBinding;
     const providerTurn = providerBinding?.turn;
@@ -282,28 +278,10 @@ export function retireExactActiveAgentRun(store, input, now) {
             reason: "runtime-not-terminal"
         };
     }
-    const terminal = terminalizeExactTaskRun(store, {
-        taskId: input.taskId,
-        roleName: input.roleName,
-        agentId: input.agentId,
-        runId: input.runId,
-        receiptId: agentRunDeliveryReceiptId(current),
-        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        settleFailedExecutionGroup: true,
-        outcome: { status: "failed", summary: input.reason }
-    }, now);
+    const terminal = terminalizeExactTaskRun(store, terminalInput, now);
     if (terminal.disposition !== "applied" || terminal.run === null) {
         return stateChanged(terminal.reason ?? "terminalization-fence-mismatch");
     }
-    if (terminal.run.purpose === "execution" && terminal.run.workItemId !== undefined) {
-        const item = store.getWorkItem(input.taskId, terminal.run.workItemId);
-        if (item !== null
-            && !["completed", "failed", "retired"].includes(item.status)
-            && !workItemOwnsUnresolvedExecutionLane(item, terminal.run.executionGroupId, terminal.run.executionLaneId)) {
-            store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", now, input.reason));
-        }
-    }
     return {
         disposition: "applied",
         run: terminal.run,
@@ -342,12 +320,13 @@ export function terminalizeExactTaskRun(store, input, now) {
     if (!matchesLaunchFence(store, sessions, input)) {
         return obsolete(run, "launch-fence-mismatch");
     }
-    if (runOwnsBlockingProviderContinuation(store.listEvents(input.taskId), {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        runId: run.id,
-        agentId: run.effective.agentId
-    })) {
+    if (input.settleFailedExecutionGroup !== true
+        && runOwnsBlockingProviderContinuation(store.listEvents(input.taskId), {
+            taskId: run.taskId,
+            roleName: run.roleName,
+            runId: run.id,
+            agentId: run.effective.agentId
+        })) {
         return obsolete(run, "provider-continuation-writer-owned");
     }
     // Validate the exact ReviewRound, Candidate, stored workspace, and frozen
@@ -482,283 +461,6 @@ export function terminalizeExactTaskRun(store, input, now) {
     settleLaunchReservation(store, sessions, input);
     return { disposition: "applied", run: terminal };
 }
-/**
- * Leader-controlled recovery boundary for one active AgentRun. This primitive
- * validates every durable fence in one transaction and records only a
- * structured request for same-Run diagnosis/retry. It never writes terminal
- * bytes, retries a provider input, kills a host, or silently rebinds a native
- * generation. Explicit termination is the sole action that changes Run state.
- */
-export function recoverExactAgentRun(store, input) {
-    return store.transaction((tx) => recoverExactAgentRunInTransaction(tx, input));
-}
-/** Alias named after the existing exact terminalization primitive. */
-export const recoverExactTaskRun = recoverExactAgentRun;
-function recoverExactAgentRunInTransaction(store, input) {
-    const current = store.getAgentRun(input.taskId, input.runId);
-    const stateChanged = (reason) => ({
-        disposition: "state-changed",
-        action: input.action,
-        run: current,
-        ...(current === null ? {} : { progressAt: latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId)?.progressAt }),
-        reason
-    });
-    const task = store.getTask(input.taskId);
-    if (task === null)
-        return stateChanged("task-missing");
-    if (task.status !== "active")
-        return stateChanged("task-terminal");
-    if (current === null)
-        return stateChanged("run-missing");
-    if (current.status !== "active")
-        return stateChanged("run-terminal");
-    if (current.taskId !== input.taskId || current.roleName !== input.roleName) {
-        return stateChanged("run-owner-mismatch");
-    }
-    if (current.effective.agentId !== input.agentId
-        || current.effective.adapterId !== input.adapterId) {
-        return stateChanged("run-launch-identity-mismatch");
-    }
-    const role = store.getRole(input.taskId, input.roleName);
-    if (role === null)
-        return stateChanged("role-missing");
-    const active = current.executionGroupId !== undefined && current.executionLaneId !== undefined
-        ? store.getActiveExecutionLaneRun(input.taskId, current.executionGroupId, current.executionLaneId)
-        : store.getActiveAgentRun(input.taskId, input.roleName);
-    if (active?.id !== current.id) {
-        return stateChanged("active-run-mismatch");
-    }
-    const progress = latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId);
-    if (progress === null)
-        return stateChanged("progress-unavailable");
-    if (progress.progressAt !== input.expectedProgressAt) {
-        return {
-            ...stateChanged("progress-fence-mismatch"),
-            progressAt: progress.progressAt
-        };
-    }
-    // Acceptance is a durable delivery boundary, not a Leader assertion. An
-    // accepted request must match the Run's persisted receipt; an already
-    // delivered Run cannot be reclassified as provider-rejected.
-    if ((input.providerAcceptance === "accepted" && current.deliveredAt === undefined)
-        || (input.providerAcceptance === "rejected" && current.deliveredAt !== undefined)) {
-        return {
-            disposition: "blocked",
-            action: input.action,
-            run: current,
-            progressAt: progress.progressAt,
-            reason: "provider-acceptance-mismatch"
-        };
-    }
-    if (!matchesRecoverySessionFence(store, input)) {
-        return stateChanged("session-or-launch-fence-mismatch");
-    }
-    const recoveryBlocker = exactRecoveryExecutionBlocker(store, current);
-    if (recoveryBlocker !== null) {
-        return {
-            disposition: "blocked",
-            action: input.action,
-            run: current,
-            progressAt: progress.progressAt,
-            reason: recoveryBlocker
-        };
-    }
-    if (input.action === "terminate") {
-        const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-        const session = sessions?.sessions[input.agentId];
-        const providerTurn = sessions?.providerBinding?.turn;
-        const exactTerminalEvidence = session?.status === "stopped"
-            || session?.status === "broken"
-            || providerTurn?.status === "failed"
-            || providerTurn?.status === "cancelled"
-            || providerTurn?.status === "rejected";
-        if (!exactTerminalEvidence) {
-            return {
-                disposition: "blocked",
-                action: input.action,
-                run: current,
-                progressAt: progress.progressAt,
-                reason: "runtime-not-terminal"
-            };
-        }
-    }
-    if (input.providerAcceptance === "ambiguous"
-        && input.action !== "diagnose") {
-        return {
-            disposition: "blocked",
-            action: input.action,
-            run: current,
-            progressAt: progress.progressAt,
-            reason: "provider-acceptance-ambiguous"
-        };
-    }
-    if (!hasRecoveryReason(input.reason)) {
-        return {
-            disposition: "blocked",
-            action: input.action,
-            run: current,
-            progressAt: progress.progressAt,
-            reason: "recovery-reason-required"
-        };
-    }
-    const eventPayload = {
-        runId: current.id,
-        roleName: current.roleName,
-        action: input.action,
-        providerAcceptance: input.providerAcceptance,
-        progressAt: progress.progressAt,
-        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        reason: input.reason
-    };
-    const events = store.listEvents(input.taskId);
-    const alreadyRequested = events.some((event) => (event.type === RUN_RECOVERY_REQUESTED_EVENT
-        && event.payload.runId === current.id
-        && event.payload.action === input.action
-        && event.payload.progressAt === progress.progressAt
-        && event.payload.nativeSessionId === input.nativeSessionId
-        && event.payload.launchId === input.launchId));
-    if (input.action !== "terminate") {
-        if (!alreadyRequested) {
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, RUN_RECOVERY_REQUESTED_EVENT, eventPayload, input.now));
-            // A non-Leader request is surfaced through the existing Leader mailbox;
-            // it is not a Task Message and is coalesced by the mailbox reason.
-            if (input.roleName !== "leader") {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, "run-recovery-requested", input.now, [{ type: "run", taskId: input.taskId, id: current.id }]);
-            }
-        }
-        return {
-            disposition: "applied",
-            action: input.action,
-            run: current,
-            progressAt: progress.progressAt,
-            requiresExplicitFollowup: true
-        };
-    }
-    const terminalization = terminalizeExactTaskRun(store, {
-        taskId: input.taskId,
-        roleName: input.roleName,
-        agentId: input.agentId,
-        runId: input.runId,
-        receiptId: agentRunDeliveryReceiptId(current),
-        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        outcome: { status: "failed", summary: input.reason }
-    }, input.now);
-    if (terminalization.disposition !== "applied" || terminalization.run === null) {
-        return stateChanged(terminalization.reason ?? "terminalization-fence-mismatch");
-    }
-    const terminal = terminalization.run;
-    if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
-        const item = store.getWorkItem(input.taskId, terminal.workItemId);
-        if (item !== null
-            && !["completed", "failed", "retired"].includes(item.status)
-            && !workItemOwnsUnresolvedExecutionLane(item, terminal.executionGroupId, terminal.executionLaneId)) {
-            store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", input.now, input.reason));
-        }
-    }
-    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, RUN_RECOVERY_APPLIED_EVENT, { ...eventPayload, status: "terminated" }, input.now));
-    if (input.roleName !== "leader") {
-        enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, "run-recovery-terminated", input.now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
-    }
-    return {
-        disposition: "applied",
-        action: input.action,
-        run: terminal,
-        progressAt: progress.progressAt
-    };
-}
-function exactRecoveryExecutionBlocker(store, run) {
-    const sessions = store.getTaskRoleSessionSet(run.taskId, run.roleName);
-    const binding = sessions?.providerBinding;
-    const mailbox = store.getWorkMailbox({
-        kind: "role",
-        taskId: run.taskId,
-        roleName: run.roleName
-    });
-    if (mailbox?.inputDelivery != null)
-        return "provider-input-delivery-unsettled";
-    if (runOwnsBlockingProviderContinuation(store.listEvents(run.taskId), {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        runId: run.id,
-        agentId: run.effective.agentId
-    }))
-        return "provider-continuation-writer-owned";
-    if (runHasActiveRuntimeOperations(store.listEvents(run.taskId), {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        runId: run.id,
-        agentId: run.effective.agentId
-    }))
-        return "provider-operation-active";
-    if (run.deliveredAt !== undefined
-        && (binding === null || binding?.turn === null))
-        return "provider-turn-state-missing";
-    if (binding === null || binding === undefined)
-        return null;
-    if (["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn?.status ?? ""))
-        return "provider-turn-unsettled";
-    if (binding.authority.owner === "human" || binding.authority.owner === "unknown") {
-        return "provider-writer-authority-unavailable";
-    }
-    return null;
-}
-function matchesRecoverySessionFence(store, input) {
-    const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-    // Recovery must never proceed without a durable Session fence.  A missing
-    // nativeSessionId is supported for an opaque host, but its exact launchId
-    // is then the only identity that can fence the action.
-    if (sessions === null)
-        return false;
-    if (sessions.activeAgentId !== input.agentId)
-        return false;
-    const session = sessions.sessions[input.agentId];
-    if (session === undefined)
-        return false;
-    if (session.agentId !== input.agentId || session.adapterId !== input.adapterId)
-        return false;
-    // Preserve a dead Session's exact identity as the CAS fence; only same-Session
-    // retry is invalid once the native process is stopped or broken.
-    if ((session.status === "stopped" || session.status === "broken")
-        && input.action === "retry")
-        return false;
-    const sessionNativeSessionId = session.nativeSessionId;
-    if (sessionNativeSessionId === undefined) {
-        if (input.nativeSessionId !== undefined)
-            return false;
-    }
-    else if (input.nativeSessionId !== sessionNativeSessionId) {
-        return false;
-    }
-    let launchMatches = false;
-    if (input.launchId !== undefined && session.launchId === input.launchId) {
-        launchMatches = true;
-    }
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-        scope: "task",
-        taskId: input.taskId,
-        roleName: input.roleName
-    }));
-    if (!launchMatches
-        && input.launchId !== undefined
-        && isRuntimeLaunchReservation(mailbox?.processing, input.launchId)) {
-        launchMatches = true;
-    }
-    // An opaque Session has no native identity to compare, so an exact launch
-    // identity is mandatory.  Native Sessions may retain the older no-launch
-    // shape; their exact native identity remains a valid fence.
-    if (sessionNativeSessionId === undefined)
-        return launchMatches;
-    if (input.nativeSessionId === undefined)
-        return launchMatches;
-    return session.launchId === undefined
-        ? input.launchId === undefined || launchMatches
-        : launchMatches;
-}
-function hasRecoveryReason(value) {
-    return typeof value === "string" && value.includes("\0") === false && value.trim().length > 0;
-}
 function matchesSessionFence(sessions, input) {
     if (sessions === null)
         return input.nativeSessionId === undefined;