@zq-silk/yui 0.8.1 → 0.8.2

package/dist/scheduler/activeRoleRunDelivery.js

@@ -25,7 +25,9 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
     for (const task of selectedActiveSchedulerTasks(store, selection)) {
         for (const role of selectedSchedulerRoles(store, task.id, selection)) {
             const run = store.getActiveAgentRun(task.id, role.name);
-            if (run !== null && run.pushedAt !== undefined) {
+            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)
                     results.push(continuation);
@@ -107,6 +109,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             let preparedSession = existingSession;
             let preStartFencePersisted = false;
             let deliveryAttempted = false;
+            let providerSubmissionBegun = false;
             try {
                 const nativeSessionId = run.mode === "resume"
                     ? requireResumeSession(role, run.effective, existingSession)
@@ -130,13 +133,14 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         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;
                 // 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
@@ -158,7 +162,8 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 }
                 const ready = await delivery.waitUntilReady(prepared);
                 deliveryAttempted = deliveryAttempted
-                    || ready.prepared.inputSubmittedAtLaunch === true;
+                    || ready.prepared.turnAcceptedDuringLaunch === true
+                    || ready.prepared.turnDeliveryUnknownDuringLaunch === true;
                 const session = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, run.mode, ready.prepared, ready.session);
                 preparedSession = session;
                 store.saveRoleRunPrepared({
@@ -171,11 +176,56 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         : { launchId: ready.prepared.launchId }),
                     now
                 });
-                if (ready.prepared.inputSubmittedAtLaunch === true) {
-                    // The exact Run prompt was already carried by the newly-created
-                    // Provider command. Persist transport success without writing any
-                    // terminal bytes; only the later matching Provider Hook may mark
-                    // the Run delivered/accepted.
+                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,
+                        roleName: role.name,
+                        runId: run.id,
+                        status: "skipped",
+                        reason: "not-ready"
+                    });
+                    continue;
+                }
+                if (ready.prepared.turnDeliveryUnknownDuringLaunch === true) {
+                    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: "skipped",
+                        reason: "delivery-uncertain"
+                    });
+                    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.
                     store.saveRoleRunDelivery({
                         task,
                         role,
@@ -232,6 +282,21 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                     continue;
                 }
+                if (session === null || session.launchId === undefined
+                    || !hasText(session.nativeSessionId)
+                    || store.beginRoleRunProviderTurn?.({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        agentId: run.effective.agentId,
+                        launchId: session.launchId,
+                        nativeSessionId: session.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,
@@ -253,6 +318,18 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                             : 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,
                         roleName: role.name,
@@ -263,6 +340,56 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                     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,
+                        roleName: role.name,
+                        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,
+                        ...(ready.prepared.launchId === undefined
+                            ? {}
+                            : { launchId: ready.prepared.launchId }),
+                        now
+                    });
+                    results.push({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        status: "skipped",
+                        reason: "delivery-uncertain"
+                    });
+                    continue;
+                }
                 const status = outcome === "sent" ? "delivered" : "already-delivered";
                 store.saveRoleRunDelivery({
                     task,
@@ -278,6 +405,17 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
+                if (providerSubmissionBegun) {
+                    store.resolveRoleRunProviderSubmission?.({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        attemptId: receiptId,
+                        status: "delivery-unknown",
+                        reason: message,
+                        now
+                    });
+                }
                 // Scheduler single-flight backpressure: the Role runtime lifecycle
                 // lane was busy when the launch was reserved. The Run stays
                 // active-unpushed and its mailbox claim is retained; the next pass
@@ -428,6 +566,23 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             reason: "not-ready"
         };
     }
+    const writer = store.getProviderAuthorityFence?.({
+        taskId: task.id,
+        roleName: role.name,
+        runId: run.id,
+        agentId: run.effective.agentId,
+        launchId: session.launchId,
+        nativeSessionId: session.nativeSessionId
+    }) ?? null;
+    if (writer !== null && writer.owner !== "controller") {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "writer-attached"
+        };
+    }
     const originalReceipt = formatAgentRunReceiptId(task.id, run.id);
     if (mailbox.processing !== null && (mailbox.processing.executionRef?.type !== "run"
         || mailbox.processing.executionRef.taskId !== task.id
@@ -447,7 +602,7 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             || (existing.status === "dispatching"
                 && inputDeliveryRecoveryCutoff !== undefined
                 && Date.parse(existing.startedAt) < inputDeliveryRecoveryCutoff.getTime()))) {
-            return reconcileStrandedInputDelivery(store, delivery, task, role, run, session, existing, now);
+            return reconcileStrandedInputDelivery(store, task, role, run, existing, now);
         }
         return {
             taskId: task.id,
@@ -484,23 +639,10 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             reason: "runtime-unavailable"
         };
     }
-    const activeTurn = store.getActiveProviderTurnFence?.({
-        taskId: task.id,
-        roleName: role.name,
-        runId: run.id,
-        agentId: run.effective.agentId,
-        launchId: session.launchId,
-        nativeSessionId: session.nativeSessionId
-    }) ?? null;
-    const mode = lane === "user-correction"
-        ? activeTurn !== null && delivery.canRouteProviderInput?.(run.effective.adapterId) === true
-            ? "steer-if-safe"
-            : "followup"
-        : pending.deliveryModes.includes("followup") ? "followup" : "inject";
-    // Normal facts never enter an active Turn. A user correction may steer only
-    // through the exact Turn fence above; without it, retain the high-priority
-    // lane until the current Turn ends and deliver it as the next followup.
-    if (mode === "followup" && session.status === "running") {
+    // Managed input has one write path: a new structured Turn at a settled
+    // boundary. Corrections retain their priority while the current Turn runs.
+    const mode = "followup";
+    if (session.status === "running") {
         return {
             taskId: task.id,
             roleName: role.name,
@@ -509,14 +651,13 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             reason: "not-ready"
         };
     }
-    if (mode === "inject" && (delivery.routeProviderInput === undefined
-        || delivery.canRouteProviderInput?.(run.effective.adapterId) !== true)) {
+    if (writer === null) {
         return {
             taskId: task.id,
             roleName: role.name,
             runId: run.id,
             status: "skipped",
-            reason: "delivery-unsupported"
+            reason: "not-ready"
         };
     }
     let deliveryAttempted = false;
@@ -539,12 +680,10 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         if (readySession.launchId === undefined || !hasText(readySession.nativeSessionId)) {
             throw new Error("Continuation delivery has no Provider Activation fence.");
         }
-        const providerFence = mode === "steer-if-safe"
-            ? activeTurn
-            : {
-                conversationId: readySession.nativeSessionId,
-                activationId: readySession.launchId
-            };
+        const providerFence = {
+            conversationId: writer.conversationId,
+            activationId: writer.activationId
+        };
         const claim = store.claimInputDelivery({
             target,
             attemptId: requestedBatchId,
@@ -569,44 +708,13 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         inputDelivery = claim.delivery;
         deliveryAttempted = true;
         const text = continuationInput(task, role, run, inputDelivery.attemptId, inputDelivery.batch, boundedContinuationSummaries(store, task.id, inputDelivery.batch.refs));
-        if (mode !== "followup") {
-            const routed = await delivery.routeProviderInput({
-                delivery: ready,
-                attemptId: inputDelivery.attemptId,
-                mode,
-                text,
-                fence: providerFence
-            });
-            if (routed === "accepted") {
-                store.completeInputDelivery(target, inputDelivery.attemptId, now);
-                return { taskId: task.id, roleName: role.name, runId: run.id, status: "delivered" };
-            }
-            if (routed === "unknown") {
-                store.markInputDeliveryUnknown(target, inputDelivery.attemptId, "Provider input acceptance could not be reconciled.", now);
-                return {
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    status: "skipped",
-                    reason: "delivery-uncertain"
-                };
-            }
-            store.releaseInputDelivery(target, inputDelivery.attemptId);
-            return {
-                taskId: task.id,
-                roleName: role.name,
-                runId: run.id,
-                status: "skipped",
-                reason: routed === "unavailable" ? "runtime-unavailable" : "not-ready"
-            };
-        }
         const outcome = await delivery.sendOnce({
             delivery: ready,
             receiptId: inputDelivery.attemptId,
             text
         });
         if (outcome === "busy" || outcome === "unavailable") {
-            store.releaseInputDelivery(target, inputDelivery.attemptId);
+            store.releaseInputDelivery(target, inputDelivery.attemptId, now);
             return {
                 taskId: task.id,
                 roleName: role.name,
@@ -615,10 +723,30 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
                 reason: outcome === "busy" ? "not-ready" : "runtime-unavailable"
             };
         }
+        if (outcome === "rejected") {
+            store.resolveInputDeliveryNotAccepted(target, inputDelivery.attemptId, now);
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                status: "skipped",
+                reason: "not-ready"
+            };
+        }
+        if (outcome === "delivery-unknown") {
+            store.markInputDeliveryUnknown(target, inputDelivery.attemptId, "Provider Turn delivery is ambiguous; automatic retry is fenced.", now);
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                status: "skipped",
+                reason: "delivery-uncertain"
+            };
+        }
         store.markInputDeliveryPushed(target, inputDelivery.attemptId, now);
         // Keep the exact claim until the matching provider turn.accepted Hook
-        // folds it. sendOnce is receipt-idempotent, so Controller recovery cannot
-        // inject a second Enter for the same batch.
+        // folds it. An interrupted acknowledgement becomes delivery-unknown and
+        // cannot be resubmitted automatically.
         return {
             taskId: task.id,
             roleName: role.name,
@@ -632,7 +760,7 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
             // called. Session preparation may be retried safely.
         }
         else if (!deliveryAttempted)
-            store.releaseInputDelivery(target, inputDelivery.attemptId);
+            store.releaseInputDelivery(target, inputDelivery.attemptId, now);
         else
             store.markInputDeliveryUnknown(target, inputDelivery.attemptId, error instanceof Error ? error.message : String(error), now);
         return {
@@ -645,7 +773,7 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
 }
-async function reconcileStrandedInputDelivery(store, delivery, task, role, run, session, input, now) {
+async function reconcileStrandedInputDelivery(store, task, role, run, input, now) {
     const target = { kind: "role", taskId: task.id, roleName: role.name };
     const uncertain = (reason) => {
         store.markInputDeliveryUnknown(target, input.attemptId, reason, now);
@@ -657,51 +785,7 @@ async function reconcileStrandedInputDelivery(store, delivery, task, role, run,
             reason: "delivery-uncertain"
         };
     };
-    if (input.providerFence === undefined
-        || delivery.reconcileProviderInput === undefined
-        || delivery.canRouteProviderInput?.(run.effective.adapterId) !== true) {
-        return uncertain("Controller restarted without exact Provider input readback.");
-    }
-    try {
-        // Exact readback is addressed entirely from the durable fence. It must not
-        // resume a Session, create an Activation, or call any model-starting port.
-        const reconciled = await delivery.reconcileProviderInput({
-            taskId: task.id,
-            roleName: role.name,
-            agentId: run.effective.agentId,
-            adapterId: run.effective.adapterId,
-            launchId: session.launchId,
-            nativeSessionId: session.nativeSessionId,
-            attemptId: input.attemptId,
-            mode: input.mode,
-            fence: input.providerFence
-        });
-        if (reconciled === "accepted") {
-            store.completeInputDelivery(target, input.attemptId, now);
-            return {
-                taskId: task.id,
-                roleName: role.name,
-                runId: run.id,
-                status: "already-delivered"
-            };
-        }
-        if (reconciled === "not-accepted") {
-            store.resolveInputDeliveryNotAccepted(target, input.attemptId);
-            return {
-                taskId: task.id,
-                roleName: role.name,
-                runId: run.id,
-                status: "skipped",
-                reason: "not-ready"
-            };
-        }
-        return uncertain(reconciled === "unavailable"
-            ? "Provider input readback is unavailable after Controller restart."
-            : "Provider input acceptance remains unknown after metadata readback.");
-    }
-    catch (error) {
-        return uncertain(`Provider input readback failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    return uncertain("Controller restarted with unsettled Provider delivery; automatic resubmission is fenced.");
 }
 function continuationInput(task, role, run, attemptId, batch, resultSummaries) {
     const references = batch.refs.map((ref) => ("taskId" in ref
@@ -834,13 +918,15 @@ function preflightSession(role, effective, existing, mode, preflight) {
 }
 /**
  * A Controller restart can recover an exact launch-submitted Run while its
- * finite provider process is still alive. The host intentionally does not
+ * 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.inputSubmittedAtLaunch === true
+        && (prepared.turnAcceptedDuringLaunch === true
+            || prepared.turnDeliveryUnknownDuringLaunch === true
+            || prepared.turnRejectedDuringLaunch === true)
         && prepared.sessionStarted === false
         && existing?.launchId !== undefined
         && existing.launchId === prepared.launchId) {