@zq-silk/yui 0.7.1 → 0.8.2

package/dist/scheduler/leaderWakeupProcessor.js

@@ -67,6 +67,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         let effectiveSession = existingSession;
         let claimed = false;
         let deliveryAttempted = false;
+        let providerSubmissionBegun = false;
         let run = null;
         let prepared;
         let preStartFencePersisted = false;
@@ -183,13 +184,14 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     preStartFencePersisted = true;
                 }
             });
-            // A managed host may already have submitted the exact Run prompt as
-            // part of process launch. Once preparation returns that transport
+            // 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.inputSubmittedAtLaunch === true;
+            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
@@ -211,7 +213,8 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             }
             const ready = await delivery.waitUntilReady(prepared);
             deliveryAttempted = deliveryAttempted
-                || ready.prepared.inputSubmittedAtLaunch === true;
+                || ready.prepared.turnAcceptedDuringLaunch === true
+                || ready.prepared.turnDeliveryUnknownDuringLaunch === true;
             const latestTask = store.getTask(task.id);
             if (latestTask === null || latestTask.status !== "active") {
                 delivery.forgetPrepared?.({
@@ -236,12 +239,54 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     : { launchId: ready.prepared.launchId }),
                 now
             });
-            if (ready.prepared.inputSubmittedAtLaunch === true) {
-                // A fresh Codex command may carry the exact first prompt in its launch
-                // argv. That is transport evidence only: the matching Provider Hook
-                // still owns Run acceptance. Persist the push fence without writing a
-                // second terminal prompt, then leave the reservation for the async
-                // SessionStart/UserPromptSubmit fold.
+            if (ready.prepared.turnRejectedDuringLaunch === true) {
+                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: "skipped",
+                    reason: "not-ready"
+                });
+                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,
+                    runId: run.id,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId })
+                });
+                results.push({
+                    taskId: task.id,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "delivery-uncertain"
+                });
+                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.
                 store.saveRoleRunDelivery({
                     task,
                     role,
@@ -263,13 +308,41 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 results.push({ taskId: task.id, runId: run.id, status: "dispatched" });
                 continue;
             }
+            const receiptId = formatAgentRunReceiptId(task.id, run.id);
+            if (effectiveSession === null || effectiveSession.launchId === undefined
+                || !hasNativeSession(effectiveSession)
+                || store.beginRoleRunProviderTurn?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    agentId: run.effective.agentId,
+                    launchId: effectiveSession.launchId,
+                    nativeSessionId: effectiveSession.nativeSessionId,
+                    attemptId: receiptId,
+                    now
+                }) !== true) {
+                throw new Error("Provider Turn intent could not be durably fenced before delivery.");
+            }
+            providerSubmissionBegun = true;
             deliveryAttempted = true;
             const outcome = await delivery.sendOnce({
                 delivery: ready,
-                receiptId: formatAgentRunReceiptId(task.id, run.id),
+                receiptId,
                 text: serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
             });
             if (outcome === "busy" || outcome === "unavailable") {
+                store.resolveRoleRunProviderSubmission?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    attemptId: receiptId,
+                    status: "rejected",
+                    reason: outcome === "busy"
+                        ? "Agent Host was busy before Provider mutation."
+                        : "Agent Host was unavailable before Provider mutation.",
+                    now
+                });
+                providerSubmissionBegun = false;
                 results.push({
                     taskId: task.id,
                     runId: run.id,
@@ -278,6 +351,49 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 });
                 continue;
             }
+            if (outcome === "rejected") {
+                store.resolveRoleRunProviderSubmission?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    attemptId: receiptId,
+                    status: "rejected",
+                    reason: "Provider returned an exact negative acknowledgement.",
+                    now
+                });
+                providerSubmissionBegun = false;
+                results.push({ taskId: task.id, runId: run.id, status: "skipped", reason: "not-ready" });
+                continue;
+            }
+            if (outcome === "delivery-unknown") {
+                store.resolveRoleRunProviderSubmission?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    attemptId: receiptId,
+                    status: "delivery-unknown",
+                    reason: "Provider Turn delivery is ambiguous; automatic retry is fenced.",
+                    now
+                });
+                providerSubmissionBegun = false;
+                store.saveRoleRunDelivery({
+                    task,
+                    role,
+                    run,
+                    session: effectiveSession,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId }),
+                    now
+                });
+                results.push({
+                    taskId: task.id,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "delivery-uncertain"
+                });
+                continue;
+            }
             store.saveRoleRunDelivery({
                 task,
                 role,
@@ -293,6 +409,17 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
             const message = `Leader dispatch failed: ${detail}`;
+            if (providerSubmissionBegun && run !== null) {
+                store.resolveRoleRunProviderSubmission?.({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    attemptId: formatAgentRunReceiptId(task.id, run.id),
+                    status: "delivery-unknown",
+                    reason: detail,
+                    now
+                });
+            }
             if (claimed && run !== null) {
                 // Scheduler single-flight backpressure: the Role runtime lifecycle
                 // lane was busy when the launch was reserved. The claimed Run stays
@@ -314,11 +441,9 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     });
                     continue;
                 }
-                // A finite managed provider from the preceding Run may still be
-                // exiting after its durable yield. Keep this newly-claimed Run as the
-                // sole owner of the Role mailbox; active-Run delivery will retry it
-                // after the old host disappears. This is runtime backpressure, not a
-                // Leader failure and not grounds for allocating another Run.
+                // 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.
                 if (error instanceof RuntimeLaunchError && error.retryable) {
                     results.push({
                         taskId: task.id,

package/dist/scheduler/roleRunStall.js

@@ -51,6 +51,8 @@ export function clearMatchingLeaderStallAttention(store, taskId, runId) {
  */
 export function projectRoleRunHealth(input) {
     const windowMs = input.windowMs ?? DEFAULT_STALL_WINDOW_MS;
+    const diagnosticAfterMs = input.diagnosticAfterMs
+        ?? DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
     if (!Number.isFinite(windowMs) || windowMs <= 0) {
         throw new Error("Role run stall window must be a positive number of milliseconds.");
     }
@@ -65,7 +67,7 @@ export function projectRoleRunHealth(input) {
     const candidate = Number.isFinite(candidateAge)
         && (input.deliveredAt === undefined
             ? candidateAge >= windowMs
-            : candidateAge >= DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS);
+            : candidateAge >= diagnosticAfterMs);
     const providerAcceptance = input.providerAcceptance
         ?? (input.deliveredAt === undefined ? "ambiguous" : "accepted");
     const hostLiveness = input.hostLiveness;
@@ -84,7 +86,7 @@ export function projectRoleRunHealth(input) {
                         : "matching";
     const resourceActivity = hostLiveness === "present"
         && nativeSession === "matching"
-        && resourceEvidenceIsFresh(input.resource, input.now, windowMs)
+        && resourceEvidenceIsFresh(input.resource, input.now, windowMs, diagnosticAfterMs)
         // Residency/RSS and an unchanged cumulative counter are not progress.
         && input.resource?.active === true
         && input.resource?.changed === true;
@@ -494,7 +496,7 @@ export function isRoleRunStalled(events, runId) {
  * structured waiting/working facts. No branch sends terminal bytes, retries,
  * replaces a Session, or changes Run status.
  */
-export async function reconcileStalledRoleRuns(store, delivery, now, selection, windowMs = DEFAULT_STALL_WINDOW_MS, liveStatuses, resourceEvidence) {
+export async function reconcileStalledRoleRuns(store, delivery, now, selection, windowMs = DEFAULT_STALL_WINDOW_MS, liveStatuses, resourceEvidence, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
     // Dirty mailbox passes are intentionally not a second scheduler. Full
     // reconcile owns the all-active-Run scan; dirty passes may still route the
     // existing mailbox work without manufacturing another episode.
@@ -519,7 +521,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
                 session: store.getRoleSession(task.id, role.name, run.effective.agentId)
             }];
     })));
-    const stallCandidates = candidates.filter(({ run }) => isStallCandidate(run, now, windowMs));
+    const stallCandidates = candidates.filter(({ run }) => isStallCandidate(run, now, windowMs, diagnosticAfterMs));
     if (stallCandidates.length === 0)
         return [];
     const stallCandidateKeys = new Set(stallCandidates.map(({ task, role }) => (`${task.id}\0${role.name}`)));
@@ -689,7 +691,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             && sessionUsable
             && expectedResourceIdentity !== undefined
             && resourceEvidenceMatchesCurrentRun(resourceSnapshot, expectedResourceIdentity, progressAt)
-            && resourceEvidenceIsFresh(resourceSnapshot, now, windowMs);
+            && resourceEvidenceIsFresh(resourceSnapshot, now, windowMs, diagnosticAfterMs);
         const resource = resourceIsCurrent ? resourceSnapshot : undefined;
         const health = projectRoleRunHealth({
             progressAt,
@@ -699,6 +701,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
                 : { deliveredAt: candidate.run.deliveredAt }),
             now,
             windowMs,
+            diagnosticAfterMs,
             hostLiveness: live,
             nativeSession: candidate.session,
             providerAcceptance: candidate.run.deliveredAt === undefined
@@ -825,7 +828,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     }
     return raised;
 }
-function isStallCandidate(run, now, windowMs) {
+function isStallCandidate(run, now, windowMs, diagnosticAfterMs) {
     const startAt = run.deliveredAt ?? run.createdAt;
     const ageMs = now.getTime() - Date.parse(startAt);
     if (!Number.isFinite(ageMs))
@@ -834,7 +837,7 @@ function isStallCandidate(run, now, windowMs) {
     // window, but they never enter workflow-stall candidate filtering.
     return run.deliveredAt === undefined
         ? ageMs >= windowMs
-        : ageMs >= DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
+        : ageMs >= diagnosticAfterMs;
 }
 function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     if (store.hasOpenInputRequest(taskId))
@@ -1020,7 +1023,7 @@ function resourceEvidenceMatchesCurrentRun(resource, expected, progressAt) {
 function hasResourceIdentityText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
-function resourceEvidenceIsFresh(evidence, now, windowMs) {
+function resourceEvidenceIsFresh(evidence, now, windowMs, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
     if (evidence === undefined)
         return false;
     const observedAt = Date.parse(evidence.observedAt);
@@ -1028,5 +1031,5 @@ function resourceEvidenceIsFresh(evidence, now, windowMs) {
         return false;
     // A sample from an earlier scheduler window is not a current health signal.
     return observedAt <= now.getTime()
-        && now.getTime() - observedAt < Math.max(windowMs, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS);
+        && now.getTime() - observedAt < Math.max(windowMs, diagnosticAfterMs);
 }