@zq-silk/yui 0.13.8 → 0.13.9

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,12 +1,12 @@
 import { createAgentRun } from "../run/agentRun.js";
-import { createRunAssignment } from "../context/runContextContract.js";
+import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
-import { recordLeaderFailure } from "./leaderFailure.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
+import { serializeAgentErrorRaw } from "../runtime/agentError.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
@@ -42,6 +42,13 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ taskId: task.id, status: "skipped", reason: "busy" });
             continue;
         }
+        // A durable wake is already the complete next intent. Do not materialize
+        // another Run while the Provider still owns the previous Turn: doing so
+        // would make its late terminal compete with a newer Run generation.
+        if (providerTurnIsUnsettled(store, task.id, role.name)) {
+            results.push({ taskId: task.id, status: "skipped", reason: "busy" });
+            continue;
+        }
         const reopening = wakeup.reasons.includes("task-reopened");
         let existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
         let effectiveSession = existingSession;
@@ -50,6 +57,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         let run = null;
         let prepared;
         let preStartFencePersisted = false;
+        let mode = "new";
         try {
             const compatibleSession = existingSession !== null
                 && (reopening
@@ -60,16 +68,15 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 && !compatibleSession;
             if (hasNativeSession(existingSession) && !compatibleSession
                 && !reopenIdentityDrift
-                && existingSession.status !== "stopped" && existingSession.status !== "broken") {
+                && existingSession.status === "active") {
                 throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
             }
             const resumableSession = hasNativeSession(existingSession)
-                && existingSession.status !== "stopped"
-                && existingSession.status !== "broken";
+                && existingSession.status === "active";
             // Reuse a healthy Session. A terminal Session is disposable and the next
             // Run starts fresh without consulting historical recovery records.
             const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
-            const mode = reopenIdentityDrift
+            mode = reopenIdentityDrift
                 ? "new"
                 : sessionSet === null
                     ? resumableSession && compatibleSession ? "resume" : "new"
@@ -130,25 +137,17 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 mode,
                 runId: run.id,
                 ...(mode === "resume" ? { nativeSessionId: existingSession.nativeSessionId } : {}),
+                ...(mode !== "resume" || existingSession?.launchId === undefined
+                    ? {}
+                    : { hostActivationId: existingSession.launchId }),
                 beforeHostStart: (preflight) => {
                     persistPreStartFence(store, task, role, run, existingSession, mode, preflight, now);
                     effectiveSession = preflightSession(role, run.effective, existingSession, mode, 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;
-            // Persist the exact preparation fence before waiting on provider
-            // readiness. A pre-input lifecycle Hook may fire during that wait; it
-            // must be able to resolve this Run/Session/launch generation from durable
-            // state rather than an in-memory delivery object. Fresh providers that
-            // discover their native Session later intentionally persist `null`.
+            // Persist the Session identity before submitting the Leader Turn.
+            // Starting/restoring a Session is independent from sending Run input.
             if (!preStartFencePersisted) {
                 const preparedFenceSession = prepared.session === undefined
                     ? existingSession
@@ -164,9 +163,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 });
             }
             const ready = await delivery.waitUntilReady(prepared);
-            deliveryAttempted = deliveryAttempted
-                || ready.prepared.turnAcceptedDuringLaunch === true
-                || ready.prepared.turnDeliveryUnknownDuringLaunch === true;
             const latestTask = store.getTask(task.id);
             if (latestTask === null
                 || latestTask.status !== "active"
@@ -193,10 +189,13 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     : { launchId: ready.prepared.launchId }),
                 now
             });
-            if (ready.prepared.turnBusyDuringLaunch === true) {
-                // A direct Desktop/user Turn is ordinary thread activity. Keep the
-                // claimed Run and wake batch intact; active-Run delivery retries after
-                // that Turn reaches its native terminal boundary.
+            deliveryAttempted = true;
+            const outcome = await delivery.sendOnce({
+                delivery: ready,
+                receiptId: formatAgentRunReceiptId(task.id, run.id),
+                text: serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
+            });
+            if (outcome === "busy" || outcome === "unavailable") {
                 delivery.forgetPrepared?.({
                     taskId: task.id,
                     roleName: role.name,
@@ -209,12 +208,12 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     taskId: task.id,
                     runId: run.id,
                     status: "skipped",
-                    reason: "busy"
+                    reason: outcome === "busy" ? "busy" : "not-ready"
                 });
                 continue;
             }
-            if (ready.prepared.turnRejectedDuringLaunch === true) {
-                const persisted = store.saveRoleRunDeliveryFailure({
+            if (outcome === "rejected") {
+                const terminal = store.saveRoleRunDeliveryFailure({
                     taskId: task.id,
                     roleName: role.name,
                     agentId: run.effective.agentId,
@@ -227,43 +226,10 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     ...(ready.prepared.launchId === undefined
                         ? {}
                         : { launchId: ready.prepared.launchId }),
-                    summary: `Provider conclusively rejected the exact initial Leader Run input: ${run.id}.`,
+                    summary: "Provider rejected the Leader Turn before acceptance; Operator recovery is required.",
                     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({
-                    taskId: task.id,
-                    runId: run.id,
-                    status: persisted === "failed" ? "failed" : "skipped",
-                    reason: "provider-rejected",
-                    terminalized: persisted === "failed",
-                    ...(persisted === "failed"
-                        ? {}
-                        : { error: "Run state changed while recording exact Provider rejection." })
-                });
-                continue;
-            }
-            if (ready.prepared.turnDeliveryUnknownDuringLaunch === true) {
-                store.saveRoleRunDelivery({
-                    task,
-                    role,
-                    run,
-                    session: effectiveSession,
-                    ...(ready.prepared.launchId === undefined
-                        ? {}
-                        : { launchId: ready.prepared.launchId }),
-                    now
-                });
                 delivery.forgetPrepared?.({
                     taskId: task.id,
                     roleName: role.name,
@@ -275,15 +241,13 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 results.push({
                     taskId: task.id,
                     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 Agent Host submitted the exact first Turn through structured
-                // Provider control. Persist the transport fence without a second write;
-                // the matching structured acknowledgement owns Run acceptance.
+            if (outcome === "delivery-unknown") {
                 store.saveRoleRunDelivery({
                     task,
                     role,
@@ -302,10 +266,34 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                         ? {}
                         : { launchId: ready.prepared.launchId })
                 });
-                results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
+                results.push({
+                    taskId: task.id,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "delivery-uncertain"
+                });
                 continue;
             }
-            throw new Error("Managed Provider launch completed without an initial Turn outcome.");
+            store.saveRoleRunDelivery({
+                task,
+                role,
+                run,
+                session: effectiveSession,
+                ...(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, runId: run.id, status: "dispatched" });
+            continue;
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
@@ -331,6 +319,57 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     });
                     continue;
                 }
+                store.recordAgentError?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    source: error instanceof RuntimeLaunchError ? "host" : "yui",
+                    phase: deliveryAttempted
+                        ? "turn-submit"
+                        : mode === "new" ? "session-start" : "session-restore",
+                    message: detail,
+                    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: formatAgentRunReceiptId(task.id, run.id),
+                        ...(failedSession?.nativeSessionId === undefined
+                            ? {}
+                            : { nativeSessionId: failedSession.nativeSessionId }),
+                        ...(prepared?.launchId === undefined && failedSession?.launchId === undefined
+                            ? {}
+                            : { launchId: prepared?.launchId ?? failedSession.launchId }),
+                        summary: `Leader Session preparation failed before Turn acceptance: ${message}`,
+                        cleanupRequired: false,
+                        now
+                    });
+                    if (terminal === "failed") {
+                        delivery.forgetPrepared?.({
+                            taskId: task.id,
+                            roleName: role.name,
+                            runId: run.id,
+                            ...(prepared?.launchId === undefined
+                                ? {}
+                                : { launchId: prepared.launchId })
+                        });
+                        results.push({
+                            taskId: task.id,
+                            runId: run.id,
+                            status: "failed",
+                            reason: "unavailable",
+                            error: message,
+                            terminalized: true
+                        });
+                        continue;
+                    }
+                }
                 // A managed Provider lifecycle operation may still be settling. Keep
                 // this newly-claimed Run as the sole mailbox owner; active-Run delivery
                 // retries after the lifecycle lane clears.
@@ -367,20 +406,13 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                         ? {}
                         : { launchId: prepared.launchId })
                 });
-                const failureResult = store.saveLeaderDispatchFailure({
-                    task,
-                    role,
-                    session: effectiveSession,
-                    claimed: { run, wakeup },
-                    failure: recordLeaderFailure(task.id, effectiveSession?.nativeSessionId ?? "(unregistered)", message, now, store.getLeaderFailure(task.id)),
-                    now
+                results.push({
+                    taskId: task.id,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "not-ready",
+                    error: message
                 });
-                if (failureResult === "state-changed") {
-                    results.push({ taskId: task.id, status: "skipped", reason: "state-changed" });
-                }
-                else {
-                    results.push({ taskId: task.id, runId: run.id, status: "failed", error: message });
-                }
                 continue;
             }
             results.push({
@@ -394,6 +426,14 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
     }
     return results;
 }
+function providerTurnIsUnsettled(store, taskId, roleName) {
+    if (store.getRoleSession(taskId, roleName)?.status !== "active")
+        return false;
+    const status = store.getTaskRoleSessionSet?.(taskId, roleName)
+        ?.providerBinding?.turn?.status;
+    return status !== undefined
+        && ["submitting", "accepted", "running", "delivery-unknown"].includes(status);
+}
 function validateReadySession(role, effective, existing, mode, session) {
     if (mode === "new" && session === null)
         return null;
@@ -416,7 +456,7 @@ function validateReadySession(role, effective, existing, mode, session) {
     }
     return {
         ...session,
-        status: "running",
+        status: "active",
         ...(mode === "resume" && existing !== null
             ? { effective: existing.effective }
             : {})
@@ -449,7 +489,7 @@ 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 validateReadySession(role, effective, existing, mode, session);

package/dist/scheduler/roleRunLiveness.js

@@ -125,7 +125,10 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
                 ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
                 mode: "resume",
                 runId: run.id,
-                nativeSessionId: session.nativeSessionId
+                nativeSessionId: session.nativeSessionId,
+                ...(session.launchId === undefined
+                    ? {}
+                    : { hostActivationId: session.launchId })
             });
             store.saveRoleRunPrepared({
                 task,

package/dist/scheduler/roleRunStall.js

@@ -56,16 +56,12 @@ export function projectRoleRunHealth(input) {
     const session = input.nativeSession;
     const nativeSession = session === null || session === undefined
         ? "missing"
-        : session.status === "stopped"
-            ? "stopped"
-            : session.status === "broken"
-                ? "broken"
-                : session.status !== "ready" && session.status !== "running"
-                    ? "unknown"
-                    : !hasResourceIdentityText(session.nativeSessionId)
-                        && !hasResourceIdentityText(session.launchId)
-                        ? "unknown"
-                        : "matching";
+        : session.status === "ended"
+            ? session.endReason === "failed" ? "broken" : "stopped"
+            : !hasResourceIdentityText(session.nativeSessionId)
+                && !hasResourceIdentityText(session.launchId)
+                ? "unknown"
+                : "matching";
     const resourceActivity = hostLiveness === "present"
         && nativeSession === "matching"
         && resourceEvidenceIsFresh(input.resource, input.now, windowMs, diagnosticAfterMs)
@@ -689,7 +685,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             || (candidate.session.agentId === runAgentId
                 && candidate.session.adapterId === runAdapterId);
         const sessionUsable = candidate.session === null
-            || (candidate.session.status !== "stopped" && candidate.session.status !== "broken");
+            || candidate.session.status === "active";
         const expectedResourceIdentity = candidate.session === null
             ? undefined
             : {

package/dist/scheduler/wakeReason.js

@@ -17,8 +17,12 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "task-orphaned",
     "input-timeout",
     "role-run-stalled",
+    "agent-error",
+    "agent-session-recovery",
     "review-failed",
     "task-reopened",
+    "agent-error",
+    "agent-session-recovery",
     "leader-run-failed",
     "role-run-failed",
     "job-finished",