@zq-silk/yui 0.13.7 → 0.13.9

package/dist/scheduler/activeRoleRunDelivery.js

@@ -2,6 +2,8 @@ import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
+import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from "../context/runContextContract.js";
+import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
@@ -9,6 +11,7 @@ import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
+import { serializeAgentErrorRaw } from "../runtime/agentError.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -20,7 +23,6 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
         for (const role of selectedSchedulerRoles(store, task.id, selection)) {
             const run = store.getActiveAgentRun(task.id, role.name);
             if (run !== null && run.pushedAt !== undefined
-                && run.providerRetry?.state !== "dispatching"
                 && run.controlRequest?.state !== "dispatching") {
                 const continuation = await processActiveRunContinuation(store, delivery, task, role, run, now, inputDeliveryRecoveryCutoff);
                 if (continuation !== null)
@@ -34,7 +36,6 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             // no duplicate Enter while acceptance is still pending.
             if (run === null
                 || (run.pushedAt !== undefined
-                    && run.providerRetry?.state !== "dispatching"
                     && run.controlRequest?.state !== "dispatching"))
                 continue;
             const taskWorkspace = store.getTaskWorkspace(task.id);
@@ -48,6 +49,19 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 });
                 continue;
             }
+            // Recovery can expose an unpushed Run while an older Provider Turn is
+            // still settling. Preserve the Run and its mailbox claim without even
+            // touching the Host; terminal observation will wake the next pass.
+            if (providerTurnIsUnsettled(store, task.id, role.name)) {
+                results.push({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "not-ready"
+                });
+                continue;
+            }
             const existingSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
             const receiptId = agentRunDeliveryReceiptId(run);
             const target = { kind: "role", taskId: task.id, roleName: role.name };
@@ -82,16 +96,15 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 continue;
             }
             let prepared;
-            let preparedSession = existingSession;
             let preStartFencePersisted = false;
             let deliveryAttempted = false;
+            const launchMode = run.controlRequest?.state === "dispatching"
+                ? "resume"
+                : run.mode;
             try {
                 // Workflow-outcome control is always another Turn on the already-bound
-                // Conversation. Provider retry alone may carry an exact missing-
-                // Conversation decision and therefore retains its explicit new mode.
-                const launchMode = run.controlRequest?.state === "dispatching"
-                    ? "resume"
-                    : run.mode;
+                // Session. A fresh Session is selected only by the Run created after
+                // the prior Session was explicitly ended.
                 const nativeSessionId = launchMode === "resume"
                     ? requireResumeSession(role, run.effective, existingSession)
                     : undefined;
@@ -108,30 +121,20 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     mode: launchMode,
                     runId: run.id,
                     ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
+                    ...(launchMode !== "resume" || existingSession?.launchId === undefined
+                        ? {}
+                        : { hostActivationId: existingSession.launchId }),
                     beforeHostStart: (preflight) => {
                         persistPreStartFence(store, task, role, run, existingSession, preflight, now);
-                        preparedSession = preflightSession(role, run.effective, existingSession, launchMode, preflight);
+                        preflightSession(role, run.effective, existingSession, launchMode, preflight);
                         preStartFencePersisted = true;
                     }
                 });
-                // A managed Host may have submitted the exact Run Turn after its
-                // two-phase launch handshake. Once preparation returns that transport
-                // fact, any
-                // later readiness or aggregate-write failure is delivery uncertainty,
-                // not a launch failure: preserve the Run and its reservation for the
-                // matching provider Hook instead of terminalizing it.
-                deliveryAttempted = prepared.turnAcceptedDuringLaunch === true
-                    || prepared.turnDeliveryUnknownDuringLaunch === true;
-                // Preparation may already have an exact native Session identity while
-                // the provider is still starting. Persist that Session + the Run fence
-                // before awaiting readiness so a pre-input provider Hook can validate
-                // the complete generation (including receipt) instead of racing an
-                // in-memory boundary. A delivery adapter that cannot expose a
-                // pre-readiness Session falls back to the existing durable Session;
-                // fresh runtime-discovered providers intentionally persist `null`.
+                // Persist the Session identity before submitting any Turn. Host start
+                // and Session restore are complete lifecycle operations; neither owns
+                // nor implies the Run's first Provider write.
                 if (!preStartFencePersisted) {
-                    const preparedFenceSession = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, run.mode, prepared, prepared.session);
-                    preparedSession = preparedFenceSession;
+                    const preparedFenceSession = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, launchMode, prepared.session);
                     store.saveRoleRunPrepared({
                         task,
                         role,
@@ -142,11 +145,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                 }
                 const ready = await delivery.waitUntilReady(prepared);
-                deliveryAttempted = deliveryAttempted
-                    || ready.prepared.turnAcceptedDuringLaunch === true
-                    || ready.prepared.turnDeliveryUnknownDuringLaunch === true;
-                const session = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, run.mode, ready.prepared, ready.session);
-                preparedSession = session;
+                const session = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, launchMode, ready.session);
                 store.saveRoleRunPrepared({
                     task,
                     role,
@@ -157,9 +156,13 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         : { launchId: ready.prepared.launchId }),
                     now
                 });
-                if (ready.prepared.turnBusyDuringLaunch === true) {
-                    // An ordinary user Turn is temporary backpressure for this Role,
-                    // not a failed Yui Run or a reason to consume its mailbox batch.
+                deliveryAttempted = true;
+                const outcome = await delivery.sendOnce({
+                    delivery: ready,
+                    receiptId,
+                    text: initialRunTurnInput(run)
+                });
+                if (outcome === "busy" || outcome === "unavailable") {
                     delivery.forgetPrepared?.({
                         taskId: task.id,
                         roleName: role.name,
@@ -173,49 +176,26 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         roleName: role.name,
                         runId: run.id,
                         status: "skipped",
-                        reason: "not-ready"
+                        reason: outcome === "busy" ? "not-ready" : "runtime-unavailable"
                     });
                     continue;
                 }
-                if (ready.prepared.turnRejectedDuringLaunch === true) {
-                    const persisted = store.saveRoleRunDeliveryFailure({
-                        ...roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId),
-                        summary: `Provider conclusively rejected the exact initial Run input: ${run.id}.`,
-                        cleanupRequired: false,
-                        now
-                    });
-                    if (persisted === "failed") {
-                        delivery.forgetPrepared?.({
-                            taskId: task.id,
-                            roleName: role.name,
-                            runId: run.id,
-                            ...(ready.prepared.launchId === undefined
-                                ? {}
-                                : { launchId: ready.prepared.launchId })
-                        });
-                    }
-                    results.push({
+                if (outcome === "rejected") {
+                    const terminal = store.saveRoleRunDeliveryFailure({
                         taskId: task.id,
                         roleName: role.name,
+                        agentId: run.effective.agentId,
+                        adapterId: run.effective.adapterId,
                         runId: run.id,
-                        status: persisted === "failed" ? "failed" : "skipped",
-                        reason: "provider-rejected",
-                        terminalized: persisted === "failed",
-                        ...(persisted === "failed"
+                        mailboxBatchId: processing.batchId,
+                        ...(session?.nativeSessionId === undefined
                             ? {}
-                            : { error: "Run state changed while recording exact Provider rejection." })
-                    });
-                    continue;
-                }
-                if (ready.prepared.turnDeliveryUnknownDuringLaunch === true) {
-                    store.saveRoleRunDelivery({
-                        task,
-                        role,
-                        run,
-                        session,
+                            : { nativeSessionId: session.nativeSessionId }),
                         ...(ready.prepared.launchId === undefined
                             ? {}
                             : { launchId: ready.prepared.launchId }),
+                        summary: "Provider rejected the Turn before acceptance; Agent recovery is required.",
+                        cleanupRequired: false,
                         now
                     });
                     delivery.forgetPrepared?.({
@@ -230,15 +210,13 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         taskId: task.id,
                         roleName: role.name,
                         runId: run.id,
-                        status: "skipped",
-                        reason: "delivery-uncertain"
+                        status: terminal === "failed" ? "failed" : "skipped",
+                        reason: "provider-rejected",
+                        ...(terminal === "failed" ? { terminalized: true } : {})
                     });
                     continue;
                 }
-                if (ready.prepared.turnAcceptedDuringLaunch === true) {
-                    // The newly-created Agent Host already submitted the exact Run Turn
-                    // through Provider-native control. Persist launch transport success;
-                    // only the matching structured acknowledgement marks it accepted.
+                if (outcome === "delivery-unknown") {
                     store.saveRoleRunDelivery({
                         task,
                         role,
@@ -261,11 +239,36 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         taskId: task.id,
                         roleName: role.name,
                         runId: run.id,
-                        status: "delivered"
+                        status: "skipped",
+                        reason: "delivery-uncertain"
                     });
                     continue;
                 }
-                throw new Error("Managed Provider launch completed without an initial Turn outcome.");
+                store.saveRoleRunDelivery({
+                    task,
+                    role,
+                    run,
+                    session,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId }),
+                    now
+                });
+                delivery.forgetPrepared?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId })
+                });
+                results.push({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    status: outcome === "sent" ? "delivered" : "already-delivered"
+                });
+                continue;
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -290,8 +293,40 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                     continue;
                 }
-                if (error instanceof RuntimeLaunchFailure) {
-                    if (!deliveryAttempted) {
+                store.recordAgentError?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    source: error instanceof RuntimeLaunchError || error instanceof RuntimeLaunchFailure
+                        ? "host"
+                        : "yui",
+                    phase: deliveryAttempted
+                        ? "turn-submit"
+                        : launchMode === "new" ? "session-start" : "session-restore",
+                    message,
+                    raw: serializeAgentErrorRaw(error),
+                    inputDisposition: deliveryAttempted ? "unknown" : "not-accepted"
+                }, now);
+                if (!deliveryAttempted) {
+                    const failedSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
+                    const terminal = store.saveRoleRunDeliveryFailure({
+                        taskId: task.id,
+                        roleName: role.name,
+                        agentId: run.effective.agentId,
+                        adapterId: run.effective.adapterId,
+                        runId: run.id,
+                        mailboxBatchId: processing.batchId,
+                        ...(failedSession?.nativeSessionId === undefined
+                            ? {}
+                            : { nativeSessionId: failedSession.nativeSessionId }),
+                        ...(prepared?.launchId === undefined && failedSession?.launchId === undefined
+                            ? {}
+                            : { launchId: prepared?.launchId ?? failedSession.launchId }),
+                        summary: `Agent Session preparation failed before Turn acceptance: ${message}`,
+                        cleanupRequired: false,
+                        now
+                    });
+                    if (terminal === "failed") {
                         delivery.forgetPrepared?.({
                             taskId: task.id,
                             roleName: role.name,
@@ -300,68 +335,48 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                                 ? {}
                                 : { launchId: prepared.launchId })
                         });
-                        const persisted = store.saveExitedRoleRun({
-                            task,
-                            role,
-                            run,
-                            session: existingSession,
-                            summary: error.message,
-                            leaderRecovery: role.name === "leader" && error.diagnostic.kind === "config"
-                                ? "blocked"
-                                : "automatic",
-                            now
-                        });
                         results.push({
                             taskId: task.id,
                             roleName: role.name,
                             runId: run.id,
                             status: "failed",
                             reason: "launch-failed",
-                            error: persisted === "state-changed"
-                                ? "Run state changed during launch failure."
-                                : message,
-                            terminalized: persisted === "failed"
+                            error: message,
+                            terminalized: true
                         });
                         continue;
                     }
                 }
-                if (error instanceof RuntimeLaunchError) {
-                    const terminalFailure = roleRunDeliveryFailure(run, processing.batchId, existingSession, error.launchId);
-                    if (error.retryable) {
-                        const writerAttached = error.reason === "writable-client";
-                        results.push({
+                if (error instanceof RuntimeLaunchFailure) {
+                    if (!deliveryAttempted) {
+                        delivery.forgetPrepared?.({
                             taskId: task.id,
                             roleName: role.name,
                             runId: run.id,
-                            status: "skipped",
-                            reason: writerAttached ? "writer-attached" : "runtime-unavailable",
-                            error: message,
-                            ...(writerAttached ? {} : { terminalFailure })
+                            ...(prepared?.launchId === undefined
+                                ? {}
+                                : { launchId: prepared.launchId })
                         });
-                        continue;
-                    }
-                    const persisted = store.saveRoleRunDeliveryFailure({
-                        ...terminalFailure,
-                        now
-                    });
-                    if (persisted === "failed") {
-                        delivery.forgetPrepared?.({
+                        results.push({
                             taskId: task.id,
                             roleName: role.name,
                             runId: run.id,
-                            launchId: error.launchId
+                            status: "skipped",
+                            reason: "launch-failed",
+                            error: message
                         });
+                        continue;
                     }
+                }
+                if (error instanceof RuntimeLaunchError) {
+                    const writerAttached = error.reason === "writable-client";
                     results.push({
                         taskId: task.id,
                         roleName: role.name,
                         runId: run.id,
-                        status: "failed",
-                        reason: "generation-lost",
-                        error: persisted === "state-changed"
-                            ? "Run state changed during exact launch generation failure."
-                            : message,
-                        terminalized: persisted === "failed"
+                        status: "skipped",
+                        reason: writerAttached ? "writer-attached" : "runtime-unavailable",
+                        error: message
                     });
                     continue;
                 }
@@ -374,23 +389,13 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                             ? {}
                             : { launchId: prepared.launchId })
                     });
-                    const persisted = store.saveExitedRoleRun({
-                        task,
-                        role,
-                        run,
-                        session: existingSession,
-                        summary: `Role Run could not start: ${message}`,
-                        leaderRecovery: "automatic",
-                        now
-                    });
                     results.push({
                         taskId: task.id,
                         roleName: role.name,
                         runId: run.id,
-                        status: "failed",
-                        reason: "launch-failed",
-                        error: persisted === "state-changed" ? "Run state changed during launch failure." : message,
-                        terminalized: persisted === "failed"
+                        status: "skipped",
+                        reason: "runtime-unavailable",
+                        error: message
                     });
                     continue;
                 }
@@ -400,19 +405,37 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     runId: run.id,
                     status: "failed",
                     reason: "delivery-uncertain",
-                    error: message,
-                    terminalFailure: roleRunDeliveryFailure(run, processing.batchId, preparedSession, prepared?.launchId)
+                    error: message
                 });
             }
         }
     }
     return results;
 }
+function providerTurnIsUnsettled(store, taskId, roleName) {
+    if (store.getRoleSession(taskId, roleName)?.status !== "active")
+        return false;
+    const turn = store.getTaskRoleSessionSet?.(taskId, roleName)?.providerBinding?.turn;
+    return turn !== null
+        && turn !== undefined
+        && ["submitting", "accepted", "running", "delivery-unknown"].includes(turn.status);
+}
 async function processActiveRunContinuation(store, delivery, task, role, run, now, inputDeliveryRecoveryCutoff) {
     const target = { kind: "role", taskId: task.id, roleName: role.name };
     const mailbox = store.getWorkMailbox(target);
     if (mailbox === null || !mailboxHasWork(mailbox))
         return null;
+    const blockedBy = latestContinuationPreparationFailure(store, task.id, run);
+    if (blockedBy !== null) {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "runtime-unavailable",
+            error: blockedBy.payload.message
+        };
+    }
     const session = store.getRoleSession(task.id, role.name, run.effective.agentId);
     if (session === null || session.launchId === undefined || !hasText(session.nativeSessionId)) {
         return {
@@ -487,7 +510,7 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
     }
     if (pending === null || session.launchId === undefined)
         return null;
-    if (session.status === "broken") {
+    if (session.status === "ended") {
         return {
             taskId: task.id,
             roleName: role.name,
@@ -497,17 +520,9 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
     // Managed input has one write path: a new structured Turn at a settled
-    // boundary. Corrections retain their priority while the current Turn runs.
+    // boundary. AgentHost owns Provider serialization; a busy send releases the
+    // claim and leaves the durable correction pending for the next pass.
     const mode = "followup";
-    if (session.status === "running") {
-        return {
-            taskId: task.id,
-            roleName: role.name,
-            runId: run.id,
-            status: "skipped",
-            reason: "not-ready"
-        };
-    }
     if (writer === null) {
         return {
             taskId: task.id,
@@ -530,11 +545,16 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
             mode: "resume",
             runId: run.id,
-            nativeSessionId: session.nativeSessionId
+            nativeSessionId: session.nativeSessionId,
+            hostActivationId: session.launchId
         });
         const ready = await delivery.waitUntilReady(prepared);
-        const readySession = ready.session ?? session;
-        if (readySession.launchId === undefined || !hasText(readySession.nativeSessionId)) {
+        const readyLaunchId = ready.prepared.launchId
+            ?? ready.session?.launchId
+            ?? session.launchId;
+        const readyNativeSessionId = ready.session?.nativeSessionId
+            ?? session.nativeSessionId;
+        if (readyLaunchId === undefined || !hasText(readyNativeSessionId)) {
             throw new Error("Continuation delivery has no Provider Activation fence.");
         }
         const providerFence = {
@@ -553,6 +573,15 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         });
         if (claim.status === "empty")
             return null;
+        if (claim.status === "busy") {
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                status: "skipped",
+                reason: "not-ready"
+            };
+        }
         if (claim.delivery.attemptId !== requestedBatchId || claim.status === "delivery") {
             return {
                 taskId: task.id,
@@ -612,6 +641,18 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
     catch (error) {
+        store.recordAgentError?.({
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            source: error instanceof RuntimeLaunchError || error instanceof RuntimeLaunchFailure
+                ? "host"
+                : "yui",
+            phase: deliveryAttempted ? "turn-submit" : "session-restore",
+            message: error instanceof Error ? error.message : String(error),
+            raw: serializeAgentErrorRaw(error),
+            inputDisposition: deliveryAttempted ? "unknown" : "not-accepted"
+        }, now);
         if (inputDelivery === undefined) {
             // No durable input intent existed and no provider input method was
             // called. Session preparation may be retried safely.
@@ -630,6 +671,24 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
 }
+/**
+ * A persisted, conclusively unaccepted continuation failure is the recovery
+ * fence for this exact Run. Periodic scheduler passes must not reinterpret it
+ * as permission to start another Host or submit the same pending input. A new
+ * Run has a new identity and therefore makes the Agent's explicit retry
+ * observable without adding a second writable recovery state.
+ */
+function latestContinuationPreparationFailure(store, taskId, run) {
+    if (run.deliveredAt === undefined)
+        return null;
+    const deliveredAt = Date.parse(run.deliveredAt);
+    const events = store.listEvents?.(taskId) ?? [];
+    return [...events].reverse().find((event) => (event.type === "runtime.agent-error"
+        && event.payload.runId === run.id
+        && ["session-restore", "turn-submit"].includes(event.payload.phase ?? "")
+        && event.payload.inputDisposition === "not-accepted"
+        && Date.parse(event.createdAt) >= deliveredAt)) ?? null;
+}
 async function reconcileStrandedInputDelivery(store, task, role, run, input, now) {
     const target = { kind: "role", taskId: task.id, roleName: role.name };
     const uncertain = (reason) => {
@@ -719,20 +778,6 @@ function boundedExcerpt(text) {
         return joined;
     return `${joined.slice(0, MAX_RESULT_SUMMARY_CHARS)}… [truncated]`;
 }
-function roleRunDeliveryFailure(run, mailboxBatchId, session, launchId) {
-    return {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        agentId: run.effective.agentId,
-        adapterId: run.effective.adapterId,
-        runId: run.id,
-        mailboxBatchId,
-        ...(session?.nativeSessionId === undefined
-            ? {}
-            : { nativeSessionId: session.nativeSessionId }),
-        ...(launchId === undefined ? {} : { launchId })
-    };
-}
 function requireResumeSession(role, effective, session) {
     if (session === null || !hasText(session.nativeSessionId)) {
         throw new Error(`Role resume has no fixed native session: ${role.taskId}/${role.name}.`);
@@ -769,32 +814,29 @@ function preflightSession(role, effective, existing, mode, preflight) {
             nativeSessionId: preflight.nativeSessionId,
             launchId: preflight.launchId,
             ...(preflight.sessionTitle === undefined ? {} : { title: preflight.sessionTitle }),
-            status: "ready",
+            status: "active",
             effective: preflight.effective
         };
     return validateRoleSession(role, effective, existing, mode, session);
 }
-/**
- * A Controller restart can recover an exact launch-submitted Run while its
- * persistent Provider process is still alive. The Host intentionally does not
- * re-plan or re-submit that Run and therefore may return no native identity;
- * retain only the durable Session fenced to the same launch generation.
- */
-function validateLaunchSubmittedRecoverySession(role, effective, existing, mode, prepared, session) {
-    if (session === null
-        && (prepared.turnAcceptedDuringLaunch === true
-            || prepared.turnDeliveryUnknownDuringLaunch === true
-            || prepared.turnBusyDuringLaunch === true
-            || prepared.turnRejectedDuringLaunch === true)
-        && prepared.sessionStarted === false
-        && existing?.launchId !== undefined
-        && existing.launchId === prepared.launchId) {
-        return validateRoleSession(role, effective, existing, mode, existing);
-    }
+function validateLaunchSubmittedRecoverySession(role, effective, existing, mode, session) {
     return session === undefined
         ? existing
         : validateRoleSession(role, effective, existing, mode, session);
 }
+function initialRunTurnInput(run) {
+    if (run.controlRequest?.state === "dispatching") {
+        return serializeWorkflowOutcomeRequestEnvelope({
+            taskId: run.taskId,
+            runId: run.id,
+            roleName: run.roleName,
+            request: run.controlRequest
+        });
+    }
+    return run.pushedAt === undefined
+        ? serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
+        : serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope);
+}
 function validateRoleSession(role, effective, existing, mode, session) {
     if (mode === "new" && session === null)
         return null;
@@ -815,7 +857,7 @@ function validateRoleSession(role, effective, existing, mode, session) {
     }
     return {
         ...session,
-        status: "running",
+        status: "active",
         ...(mode === "resume" && existing !== null
             ? { effective: existing.effective }
             : {})

package/dist/scheduler/activeTaskProgress.js

@@ -25,8 +25,6 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             const run = store.getActiveAgentRun(task.id, role.name);
             return run === null ? [] : [run];
         });
-        const hasInFlightTurn = roles.some((role) => store.hasInFlightTurn(task.id, role.name));
-        const hasLeaderInFlightTurn = store.hasInFlightTurn(task.id, "leader");
         const leaderTarget = { kind: "role", taskId: task.id, roleName: "leader" };
         const leaderMailbox = store.getWorkMailbox(leaderTarget);
         const projection = projectTaskExecution({
@@ -41,8 +39,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             && !activeRuns.some(({ roleName }) => roleName === "leader")
             && activeRuns.some(({ roleName }) => roleName !== "leader")
             && projection.status === "waiting-on-agents";
-        if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
-            || store.hasOpenInputRequest(task.id)
+        if (store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
             || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {