@zq-silk/yui 0.6.16 → 0.7.0

package/dist/scheduler/activeRoleRunDelivery.js

@@ -3,6 +3,7 @@ import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { markYuiRunInput } from "../run/runIdentity.js";
 import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
@@ -11,6 +12,9 @@ import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
+import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
+import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -32,7 +36,10 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             // re-push guard keys on pushedAt (transport), not deliveredAt (provider
             // acceptance): a pushed-but-unaccepted Run must never be pushed twice —
             // no duplicate Enter while acceptance is still pending.
-            if (run === null || run.pushedAt !== undefined)
+            if (run === null
+                || (run.pushedAt !== undefined
+                    && run.providerRetry?.state !== "dispatching"
+                    && run.controlRequest?.state !== "dispatching"))
                 continue;
             const taskWorkspace = store.getTaskWorkspace(task.id);
             if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
@@ -64,7 +71,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 continue;
             }
             const existingSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
-            const receiptId = formatAgentRunReceiptId(task.id, run.id);
+            const receiptId = agentRunDeliveryReceiptId(run);
             const target = { kind: "role", taskId: task.id, roleName: role.name };
             const claim = store.claimWorkMailbox({
                 target,
@@ -229,7 +236,21 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 const outcome = await delivery.sendOnce({
                     delivery: ready,
                     receiptId,
-                    text: run.input
+                    text: run.controlRequest?.state === "dispatching"
+                        ? serializeWorkflowOutcomeRequestEnvelope({
+                            taskId: task.id,
+                            runId: run.id,
+                            roleName: role.name,
+                            request: run.controlRequest
+                        })
+                        : run.providerRetry?.state === "dispatching"
+                            ? serializeProviderRetryEnvelope({
+                                taskId: task.id,
+                                runId: run.id,
+                                roleName: role.name,
+                                retry: run.providerRetry
+                            })
+                            : serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
                 });
                 if (outcome === "busy" || outcome === "unavailable") {
                     results.push({

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,12 +1,10 @@
 import { createAgentRun } from "../run/agentRun.js";
-import { markYuiRunInput } from "../run/runIdentity.js";
-import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { createLeaderRecoveryNotification } from "./operatorNotification.js";
-import { evaluateSessionContextBudget } from "../context/sessionContextBudget.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
@@ -122,52 +120,21 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 && existingSession.status !== "stopped" && existingSession.status !== "broken") {
                 throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
             }
-            // Issue 04: a native Session generation whose observed per-request
-            // input peak crossed the hard context budget is retired before dispatch
-            // so the wake starts a fresh generation instead of waiting for
-            // provider-side auto-compaction. Durable Task records are the checkpoint;
-            // the bounded snapshot below re-establishes working context.
-            let contextBudgetAdvisory;
-            if (hasNativeSession(existingSession)
-                && compatibleSession
-                && existingSession.status !== "stopped"
-                && existingSession.status !== "broken"
-                && typeof store.listEvents === "function"
-                && typeof store.getContextBudget === "function"
-                && typeof store.rolloverTaskRoleSessionForContextBudget === "function") {
-                const budget = evaluateSessionContextBudget(store.listEvents(task.id), {
-                    taskId: task.id,
-                    roleName: role.name,
-                    ...(existingSession.nativeSessionId === undefined
-                        ? {}
-                        : { nativeSessionId: existingSession.nativeSessionId }),
-                    ...(existingSession.launchId === undefined
-                        ? {}
-                        : { launchId: existingSession.launchId })
-                }, store.getContextBudget());
-                if (budget.state === "hard") {
-                    const rollover = store.rolloverTaskRoleSessionForContextBudget({
-                        taskId: task.id,
-                        roleName: role.name,
-                        peakTokens: budget.peakTokens,
-                        hardTokens: budget.budget.hardTokens,
-                        now
-                    });
-                    if (rollover !== null) {
-                        existingSession = null;
-                        effectiveSession = null;
-                        contextBudgetAdvisory = `Previous Session generation ${rollover.retiredNativeSessionId ?? "unknown"} was retired at the hard context budget (peak ${budget.peakTokens} >= ${budget.budget.hardTokens} tokens). This wake starts a fresh generation; durable Task records preserve all state.`;
-                    }
-                }
-                else if (budget.state === "soft") {
-                    contextBudgetAdvisory = `Session context budget advisory: observed per-request input peak ${budget.peakTokens} tokens crossed the soft threshold (${budget.budget.softTokens}). Durable Yui records are the checkpoint; a fresh generation starts automatically at the hard threshold (${budget.budget.hardTokens}).`;
-                }
-            }
             const mode = hasNativeSession(existingSession) && compatibleSession ? "resume" : "new";
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
-            const input = markYuiRunInput(leaderWakeupInput(task.id, runId, wakeEnvelope, contextBudgetAdvisory), runId, taskRoleSessionTitle(task, role.name));
-            run = createAgentRun(runId, task.id, role.name, mode, input, now, {
+            const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
+            const assignment = createRunAssignment({
+                runId,
+                roleName: role.name,
+                purpose: "execution",
+                action: "leader-wake",
+                subject: { taskId: task.id },
+                directive: leaderWakeupInput(task.id, runId, wakeup.reasons),
+                ...(contextSnapshot === undefined ? {} : { contextSnapshotRef: contextSnapshot.ref }),
+                deltaRefIds: contextSnapshot?.deltaRefIds ?? []
+            });
+            run = createAgentRun(runId, task.id, role.name, mode, assignment, now, {
                 ...(role.managedWorkspace === undefined
                     ? {}
                     : { workspace: role.managedWorkspace }),
@@ -300,7 +267,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const outcome = await delivery.sendOnce({
                 delivery: ready,
                 receiptId: formatAgentRunReceiptId(task.id, run.id),
-                text: input
+                text: serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
             });
             if (outcome === "busy" || outcome === "unavailable") {
                 results.push({
@@ -490,18 +457,9 @@ function resolveLeaderWakeEnvelope(store, taskId) {
         return null;
     return store.getTaskWakeEnvelope(taskId);
 }
-function leaderWakeupInput(taskId, runId, wakeEnvelope, contextBudgetAdvisory) {
-    const lines = [
-        "Follow the injected yui-leader Skill for this Yui wakeup.",
-        `Current Leader Run: ${runId}.`,
+function leaderWakeupInput(taskId, runId, reasons) {
+    return [
         `For every Leader decision, milestone, or Work Item lifecycle command that is meaningful progress, carry this exact current-turn assertion on that command: YUI_LEADER_ACTION_RUN_ID=${runId} YUI_LEADER_ACTION_RECEIPT_ID=${formatAgentRunReceiptId(taskId, runId)}. The native Session environment may retain an older YUI_RUN_ID/launch; never copy those values, and never reuse this assertion after the turn changes.`,
-        ...(contextBudgetAdvisory === undefined ? [] : [contextBudgetAdvisory]),
-        ...(wakeEnvelope === null
-            ? [`Read the authoritative context with yui task context ${taskId}.`]
-            : [
-                "Wake envelope (Issue 04):",
-                wakeEnvelope.text
-            ]),
-    ];
-    return lines.join("\n");
+        `Wake reasons: ${reasons.join(", ")}. Load exact context for ${taskId}/${runId}.`
+    ].join("\n");
 }

package/dist/scheduler/roleRunLiveness.js

@@ -1,9 +1,6 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
-import { queueLeaderWakeup } from "./wakeupQueue.js";
-import { wakeReason } from "./wakeReason.js";
 import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
-export const EXITED_ROLE_RUN_SUMMARY = "The role's tmux session exited before the run yielded.";
 /**
  * Lightweight liveness only. Host absence may fail a Run only before any
  * prompt bytes were pushed. After push, acceptance may be unknown even when
@@ -11,6 +8,9 @@ export const EXITED_ROLE_RUN_SUMMARY = "The role's tmux session exited before th
  * evidence, not an application-level outcome. The Run stays active so native
  * child work or another observer can still contribute facts, while the stall
  * path raises bounded attention independently.
+ * Process liveness is only a recovery signal. An absent pane/Host never proves
+ * that the native Session or AgentRun ended; recover the same generation and
+ * native identity when possible, otherwise preserve the active Run.
  */
 export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
     const failed = [];
@@ -52,7 +52,8 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
         && candidates.every(({ task, role }) => liveStatuses.has(`${task.id}\0${role.name}`))
         ? {
             statuses: liveStatuses,
-            resources: resourceEvidence ?? new Map()
+            resources: resourceEvidence ?? new Map(),
+            hostExits: new Map()
         }
         : await inspectRoleStatuses(delivery, candidates, !targetedInventory
             ? candidates.flatMap(({ task, role, run, session }) => (isResourceCandidate(task, run, now)
@@ -90,27 +91,57 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
             throw new Error("Role liveness snapshot is incomplete.");
         if (status === "present")
             continue;
-        const persisted = store.saveExitedRoleRun({
-            task,
-            role,
-            run,
-            session,
-            summary: EXITED_ROLE_RUN_SUMMARY,
-            now
-        });
-        if (persisted === "state-changed")
+        const hostExit = batchSnapshot.hostExits.get(`${task.id}\0${role.name}`);
+        if (hostExit !== undefined) {
+            store.saveRoleHostExitObservation?.({
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(session?.nativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: session.nativeSessionId }),
+                ...(hostExit.deadStatus === undefined ? {} : { deadStatus: hostExit.deadStatus }),
+                observedAt: now
+            });
+        }
+        if (session?.nativeSessionId === undefined) {
+            store.queueTaskProgress(task.id, "host-missing-native-resume-unproven", now);
             continue;
-        delivery.forgetPrepared?.({
-            taskId: task.id,
-            roleName: role.name,
-            runId: run.id
-        });
-        failed.push(formatTaskRecordReference(task.id, run.id, "agentRun"));
-        // Compatibility for narrow in-memory/custom ports that predate the
-        // adapter's atomic failure+wake transition. Production returns
-        // "failed" and already enqueued this wake in the same transaction.
-        if (persisted === undefined && task.status === "active") {
-            queueLeaderWakeup(store, task.id, wakeReason(role.name === "leader" ? "leader-run-failed" : "role-run-failed"), now);
+        }
+        try {
+            delivery.forgetPrepared?.({
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id
+            });
+            const recovered = await delivery.prepareRoleSession({
+                taskId: task.id,
+                roleName: role.name,
+                agentId: run.effective.agentId,
+                adapterId: run.effective.adapterId,
+                effective: run.effective,
+                workspace: run.effective.workspace.root,
+                ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
+                mode: "resume",
+                runId: run.id,
+                nativeSessionId: session.nativeSessionId
+            });
+            store.saveRoleRunPrepared({
+                task,
+                role,
+                run,
+                session: recovered.session ?? session,
+                ...(recovered.launchId === undefined ? {} : { launchId: recovered.launchId }),
+                now
+            });
+            liveStatuses?.set(`${task.id}\0${role.name}`, "present");
+        }
+        catch {
+            // Absence plus an inconclusive local recovery attempt is still not a
+            // native Session death proof. Keep the exact Run active for the next
+            // bounded recovery pass and expose the blocked axis separately.
+            store.queueTaskProgress(task.id, "host-missing-native-resume-pending", now);
         }
     }
     return failed;
@@ -129,7 +160,7 @@ async function inspectRoleStatuses(delivery, candidates, resourceInputs, targete
             }
             statuses.set(key, await delivery.inspectRole(candidate.inspection));
         }
-        return { statuses, resources: new Map() };
+        return { statuses, resources: new Map(), hostExits: new Map() };
     }
     if (delivery.inspectRoles !== undefined) {
         return exactBatchInventory(await delivery.inspectRoles(candidates.map(({ inspection }) => inspection), resourceInputs), candidates);
@@ -141,12 +172,13 @@ async function inspectRoleStatuses(delivery, candidates, resourceInputs, targete
             await delivery.inspectRole(candidate.inspection)
         ]);
     }
-    return { statuses: new Map(entries), resources: new Map() };
+    return { statuses: new Map(entries), resources: new Map(), hostExits: new Map() };
 }
 function exactBatchInventory(batch, candidates) {
     const expected = new Set(candidates.map(({ task, role }) => `${task.id}\0${role.name}`));
     const statuses = new Map();
     const resources = new Map();
+    const hostExits = new Map();
     for (const entry of batch) {
         const key = `${entry.taskId}\0${entry.roleName}`;
         if (!expected.has(key) || statuses.has(key)) {
@@ -155,11 +187,13 @@ function exactBatchInventory(batch, candidates) {
         statuses.set(key, entry.status);
         if (entry.resource !== undefined)
             resources.set(key, entry.resource);
+        if (entry.hostExit !== undefined)
+            hostExits.set(key, entry.hostExit);
     }
     if (statuses.size !== expected.size) {
         throw new Error("Tmux Role batch liveness snapshot is incomplete.");
     }
-    return { statuses, resources };
+    return { statuses, resources, hostExits };
 }
 function isResourceCandidate(task, run, now) {
     if (task.status !== "active" || run.status !== "active" || run.deliveredAt === undefined) {

package/dist/storage/migration/productionRegistry.js

@@ -35,6 +35,10 @@ const AGENT_RUN_TO_VERSION = 6;
  */
 const AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION = 6;
 const AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION = 7;
+const AGENT_RUN_CONTEXT_PROTOCOL_FROM_VERSION = 7;
+const AGENT_RUN_CONTEXT_PROTOCOL_TO_VERSION = 8;
+const AGENT_RUN_RETRY_EPISODE_FROM_VERSION = 8;
+const AGENT_RUN_RETRY_EPISODE_TO_VERSION = 9;
 const MESSAGE_WAKE_POLICY_FROM_VERSION = 2;
 const MESSAGE_WAKE_POLICY_TO_VERSION = 3;
 const REVIEW_ROUND_FROM_VERSION = 2;
@@ -55,6 +59,8 @@ const INTEGRATION_ATTEMPT_GATE_IDENTITY_FROM_VERSION = 3;
 const INTEGRATION_ATTEMPT_GATE_IDENTITY_TO_VERSION = 4;
 const INTEGRATION_QUEUE_FROM_VERSION = 0;
 const INTEGRATION_QUEUE_TO_VERSION = 1;
+const CONTEXT_SNAPSHOT_FROM_VERSION = 0;
+const CONTEXT_SNAPSHOT_TO_VERSION = 1;
 const STORED_TASK_DURABLE_JOBS_FROM_VERSION = 14;
 const STORED_TASK_DURABLE_JOBS_TO_VERSION = 15;
 const STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION = 15;
@@ -130,6 +136,8 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(workItemExecutionGroupHistoryStep())
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_FROM_VERSION, AGENT_RUN_TO_VERSION, "agentRuns"))
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION, AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION, "agentRuns"))
+        .registerOfflineMigration(agentRunContextProtocolStep())
+        .registerOfflineMigration(agentRunRetryEpisodeStep())
         .registerOfflineMigration(messageWakePolicyStep())
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_FROM_VERSION, REVIEW_ROUND_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION, REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION, "reviewRounds"))
@@ -140,6 +148,7 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(integrationAttemptSupersededStep())
         .registerOfflineMigration(recordFamilyStep("integrationAttempt", INTEGRATION_ATTEMPT_GATE_IDENTITY_FROM_VERSION, INTEGRATION_ATTEMPT_GATE_IDENTITY_TO_VERSION, "integrationAttempts"))
         .registerOfflineMigration(integrationQueueIntroductionStep())
+        .registerOfflineMigration(contextSnapshotIntroductionStep())
         .registerCompatible(storedTaskDurableJobsStep())
         .registerCompatible(storedTaskJobCallerKeyHashesStep())
         .registerCompatible(storedTaskWakesAndPublicationReferencesStep())
@@ -725,6 +734,71 @@ function introduceIntegrationQueue(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/** Introduce the immutable Task-scoped ContextSnapshot record family. */
+function contextSnapshotIntroductionStep() {
+    return {
+        axis: "record",
+        recordKind: "contextSnapshot",
+        fromVersion: CONTEXT_SNAPSHOT_FROM_VERSION,
+        toVersion: CONTEXT_SNAPSHOT_TO_VERSION,
+        introduction: true,
+        preconditions: requireContextSnapshotIntroduction,
+        transform: introduceContextSnapshots,
+        declaredEffects: []
+    };
+}
+function requireContextSnapshotIntroduction(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const namedVersion = manifestVersions.contextSnapshot;
+    if (namedVersion !== undefined && namedVersion !== CONTEXT_SNAPSHOT_FROM_VERSION) {
+        throw new Error("Record contextSnapshot introduction requires an absent manifest version or 0.");
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.contextSnapshots !== undefined) {
+            const records = asObject(task.contextSnapshots, `contextSnapshot map ${taskId}`);
+            if (Object.keys(records).length > 0) {
+                throw new Error(`Context Snapshot introduction found existing records: ${taskId}.`);
+            }
+        }
+        const marks = asObject(task.idHighWaterMarks ?? {}, `Task id high-water marks ${taskId}`);
+        const mark = marks.contextSnapshot;
+        if (mark !== undefined && mark !== CONTEXT_SNAPSHOT_FROM_VERSION) {
+            throw new Error(`Context Snapshot introduction found a high-water mark: ${taskId}.`);
+        }
+    }
+}
+function introduceContextSnapshots(snapshot) {
+    requireContextSnapshotIntroduction(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            contextSnapshot: CONTEXT_SNAPSHOT_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const marks = asObject(task.idHighWaterMarks ?? {}, `Task id high-water marks ${taskId}`);
+        nextTasks[taskId] = {
+            ...task,
+            idHighWaterMarks: { ...marks, contextSnapshot: 0 },
+            contextSnapshots: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function legacyLaneKeyParts(key) {
     const match = /^lane:([^:]+):([^:]+)$/u.exec(key);
     if (match === null)
@@ -1411,6 +1485,196 @@ function recordFamilyStep(recordKind, fromVersion, toVersion, taskMapKey) {
         declaredEffects: []
     };
 }
+function agentRunContextProtocolStep() {
+    return {
+        axis: "record",
+        recordKind: "agentRun",
+        fromVersion: AGENT_RUN_CONTEXT_PROTOCOL_FROM_VERSION,
+        toVersion: AGENT_RUN_CONTEXT_PROTOCOL_TO_VERSION,
+        preconditions: (snapshot) => requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_CONTEXT_PROTOCOL_FROM_VERSION, "agentRuns"),
+        transform: migrateAgentRunsToContextProtocol,
+        declaredEffects: []
+    };
+}
+function migrateAgentRunsToContextProtocol(snapshot) {
+    requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_CONTEXT_PROTOCOL_FROM_VERSION, "agentRuns");
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            agentRun: AGENT_RUN_CONTEXT_PROTOCOL_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const records = asObject(task.agentRuns ?? {}, `agentRun map ${taskId}`);
+        const nextRecords = {};
+        for (const [runId, rawRecord] of Object.entries(records)) {
+            const record = asObject(rawRecord, `agentRun ${taskId}/${runId}`);
+            const { input: rawInput, schemaVersion: _schemaVersion, ...rest } = record;
+            const roleName = requiredMigrationText(record.roleName, "Agent Run roleName");
+            const purpose = record.purpose === "review" ? "review" : "execution";
+            const workItemId = optionalMigrationText(record.workItemId, "Agent Run workItemId");
+            const reviewRoundId = optionalMigrationText(record.reviewRoundId, "Agent Run reviewRoundId");
+            const executionGroupId = optionalMigrationText(record.executionGroupId, "Agent Run executionGroupId");
+            const executionLaneId = optionalMigrationText(record.executionLaneId, "Agent Run executionLaneId");
+            const action = purpose === "review"
+                ? "review-round"
+                : roleName === "leader"
+                    ? "leader-wake"
+                    : workItemId === undefined
+                        ? "lead-task"
+                        : "execute-work-item";
+            const subject = {
+                taskId,
+                ...(workItemId === undefined ? {} : { workItemId }),
+                ...(reviewRoundId === undefined ? {} : { reviewRoundId }),
+                ...(executionGroupId === undefined ? {} : { executionGroupId }),
+                ...(executionLaneId === undefined ? {} : { executionLaneId })
+            };
+            const assignment = {
+                schemaVersion: 1,
+                runId,
+                roleName,
+                purpose,
+                action,
+                subject,
+                ...(typeof rawInput === "string" && rawInput.trim().length > 0
+                    ? { directive: rawInput }
+                    : {}),
+                deltaRefIds: []
+            };
+            nextRecords[runId] = {
+                ...rest,
+                schemaVersion: AGENT_RUN_CONTEXT_PROTOCOL_TO_VERSION,
+                assignment,
+                bootstrapEnvelope: {
+                    protocol: "yui-run/v1",
+                    runId,
+                    roleName,
+                    purpose,
+                    action,
+                    subject,
+                    deltaRefIds: []
+                }
+            };
+        }
+        nextTasks[taskId] = { ...task, agentRuns: nextRecords };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+function agentRunRetryEpisodeStep() {
+    return {
+        axis: "record",
+        recordKind: "agentRun",
+        fromVersion: AGENT_RUN_RETRY_EPISODE_FROM_VERSION,
+        toVersion: AGENT_RUN_RETRY_EPISODE_TO_VERSION,
+        preconditions: (snapshot) => requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_RETRY_EPISODE_FROM_VERSION, "agentRuns"),
+        transform: migrateAgentRunsToRetryEpisodes,
+        declaredEffects: []
+    };
+}
+function migrateAgentRunsToRetryEpisodes(snapshot) {
+    requireRecordFamilyVersion(snapshot, "agentRun", AGENT_RUN_RETRY_EPISODE_FROM_VERSION, "agentRuns");
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...manifestVersions, agentRun: AGENT_RUN_RETRY_EPISODE_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const records = asObject(task.agentRuns ?? {}, `agentRun map ${taskId}`);
+        const nextRecords = {};
+        for (const [runId, rawRecord] of Object.entries(records)) {
+            const record = asObject(rawRecord, `agentRun ${taskId}/${runId}`);
+            const legacyRetry = record.providerRetry === undefined
+                ? undefined
+                : asObject(record.providerRetry, `providerRetry ${taskId}/${runId}`);
+            let providerRetry = undefined;
+            let deliveryReceiptId;
+            if (legacyRetry !== undefined) {
+                const attempt = requiredMigrationPositiveInteger(legacyRetry.attempt, `providerRetry attempt ${taskId}/${runId}`);
+                const firstFailureAt = requiredMigrationTimestamp(legacyRetry.firstFailureAt, `providerRetry firstFailureAt ${taskId}/${runId}`);
+                const lastFailureAt = requiredMigrationTimestamp(legacyRetry.lastFailureAt, `providerRetry lastFailureAt ${taskId}/${runId}`);
+                const nextAttemptAt = optionalMigrationTimestamp(legacyRetry.nextAttemptAt, `providerRetry nextAttemptAt ${taskId}/${runId}`);
+                const policyBlocked = legacyRetry.errorClass === "policy-denied";
+                const deadlineMs = Math.max(Date.parse(firstFailureAt) + 600_000, nextAttemptAt === undefined ? 0 : Date.parse(nextAttemptAt) + 1);
+                deliveryReceiptId = nextAttemptAt !== undefined || policyBlocked
+                    ? undefined
+                    : `legacy-retry-receipt-${runId}-${attempt}`;
+                providerRetry = {
+                    schemaVersion: 2,
+                    episodeId: `legacy-retry-${runId}`,
+                    failureEventId: `legacy-provider-failure-${runId}-${attempt}`,
+                    policyVersion: 1,
+                    state: nextAttemptAt !== undefined
+                        ? "scheduled"
+                        : policyBlocked ? "blocked" : "awaiting-progress",
+                    errorClass: legacyRetry.errorClass,
+                    consecutiveFailures: attempt,
+                    dispatchedRetries: Math.min(3, nextAttemptAt === undefined ? attempt : attempt - 1),
+                    maxRetries: 3,
+                    firstFailureAt,
+                    lastFailureAt,
+                    episodeDeadlineAt: new Date(deadlineMs).toISOString(),
+                    ...(nextAttemptAt === undefined ? {} : { nextAttemptAt }),
+                    ...(deliveryReceiptId === undefined
+                        ? {}
+                        : { lastRetryReceiptId: deliveryReceiptId }),
+                    ...(legacyRetry.launchId === undefined ? {} : { launchId: legacyRetry.launchId }),
+                    ...(legacyRetry.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: legacyRetry.nativeSessionId }),
+                    lastErrorSummary: legacyRetry.lastErrorSummary
+                };
+            }
+            nextRecords[runId] = {
+                ...record,
+                schemaVersion: AGENT_RUN_RETRY_EPISODE_TO_VERSION,
+                ...(deliveryReceiptId === undefined ? {} : { deliveryReceiptId }),
+                ...(providerRetry === undefined ? {} : { providerRetry })
+            };
+        }
+        nextTasks[taskId] = { ...task, agentRuns: nextRecords };
+    }
+    return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
+}
+function requiredMigrationPositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
+function requiredMigrationTimestamp(value, label) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be a timestamp.`);
+    }
+    return value;
+}
+function optionalMigrationTimestamp(value, label) {
+    return value === undefined ? undefined : requiredMigrationTimestamp(value, label);
+}
+function requiredMigrationText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}
+function optionalMigrationText(value, label) {
+    return value === undefined ? undefined : requiredMigrationText(value, label);
+}
 /**
  * The snapshot boundary is nested inside WorkItem/ReviewRound ExecutionGroup
  * results.  The parent record versions make that persisted shape explicit;