@zq-silk/yui 0.6.8 → 0.6.10

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,19 +1,28 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { markYuiRunInput } from "../run/runIdentity.js";
+import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
  * route into the Agent terminal, through tmux receipt-backed delivery.
  */
-export async function processActiveRoleRunDeliveries(store, delivery, now, selection) {
+export async function processActiveRoleRunDeliveries(store, delivery, now, selection, inputDeliveryRecoveryCutoff) {
     const results = [];
     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) {
+                const continuation = await processActiveRunContinuation(store, delivery, task, role, run, now, inputDeliveryRecoveryCutoff);
+                if (continuation !== null)
+                    results.push(continuation);
+                continue;
+            }
             // A crash after a Leader wake is durably claimed but before tmux input
             // is recoverable through the same receipt-backed delivery path. The
             // re-push guard keys on pushedAt (transport), not deliveredAt (provider
@@ -308,6 +317,310 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
     }
     return results;
 }
+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 session = store.getRoleSession(task.id, role.name, run.effective.agentId);
+    if (session === null || session.launchId === undefined || !hasText(session.nativeSessionId)) {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "not-ready"
+        };
+    }
+    const originalReceipt = formatAgentRunReceiptId(task.id, run.id);
+    if (mailbox.processing !== null && (mailbox.processing.executionRef?.type !== "run"
+        || mailbox.processing.executionRef.taskId !== task.id
+        || mailbox.processing.executionRef.id !== run.id
+        || mailbox.processing.batchId !== originalReceipt)) {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "mailbox-busy"
+        };
+    }
+    if (mailbox.inputDelivery !== null) {
+        const existing = mailbox.inputDelivery;
+        if ((existing.status === "delivery-unknown"
+            || (existing.status === "dispatching"
+                && inputDeliveryRecoveryCutoff !== undefined
+                && Date.parse(existing.startedAt) < inputDeliveryRecoveryCutoff.getTime()))) {
+            return reconcileStrandedInputDelivery(store, delivery, task, role, run, session, existing, now);
+        }
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "delivery-uncertain"
+        };
+    }
+    const pending = nextPendingBatch(mailbox);
+    const lane = mailbox.pending.userCorrection === pending ? "user-correction" : "normal";
+    const requestedBatchId = pending === null
+        ? originalReceipt
+        : `agent-input:${task.id}/${run.id}/${lane}:${pending.fromSequence}-${pending.toSequence}`;
+    if (requestedBatchId === originalReceipt) {
+        // Initial provider acceptance is still outstanding. It owns this claim;
+        // never reinterpret the original Run prompt as a continuation.
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "delivery-uncertain"
+        };
+    }
+    if (pending === null || session.launchId === undefined)
+        return null;
+    if (session.status === "broken") {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            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") {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "not-ready"
+        };
+    }
+    if (mode === "inject" && (delivery.routeProviderInput === undefined
+        || delivery.canRouteProviderInput?.(run.effective.adapterId) !== true)) {
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: "delivery-unsupported"
+        };
+    }
+    let deliveryAttempted = false;
+    let inputDelivery;
+    try {
+        const prepared = await delivery.prepareRoleSession({
+            taskId: task.id,
+            roleName: role.name,
+            agentId: run.effective.agentId,
+            adapterId: run.effective.adapterId,
+            effective: run.effective,
+            workspace: run.effective.workspace.root,
+            ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
+            mode: "resume",
+            runId: run.id,
+            nativeSessionId: session.nativeSessionId
+        });
+        const ready = await delivery.waitUntilReady(prepared);
+        const readySession = ready.session ?? session;
+        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 claim = store.claimInputDelivery({
+            target,
+            attemptId: requestedBatchId,
+            lane,
+            mode,
+            owner: "controller",
+            now,
+            executionRef: { type: "run", taskId: task.id, id: run.id },
+            providerFence
+        });
+        if (claim.status === "empty")
+            return null;
+        if (claim.delivery.attemptId !== requestedBatchId || claim.status === "delivery") {
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                status: "skipped",
+                reason: "delivery-uncertain"
+            };
+        }
+        inputDelivery = claim.delivery;
+        deliveryAttempted = true;
+        const text = continuationInput(task, role, run, inputDelivery.attemptId, inputDelivery.batch);
+        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);
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                runId: run.id,
+                status: "skipped",
+                reason: outcome === "busy" ? "not-ready" : "runtime-unavailable"
+            };
+        }
+        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.
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: outcome === "sent" ? "delivered" : "already-delivered"
+        };
+    }
+    catch (error) {
+        if (inputDelivery === undefined) {
+            // No durable input intent existed and no provider input method was
+            // called. Session preparation may be retried safely.
+        }
+        else if (!deliveryAttempted)
+            store.releaseInputDelivery(target, inputDelivery.attemptId);
+        else
+            store.markInputDeliveryUnknown(target, inputDelivery.attemptId, error instanceof Error ? error.message : String(error), now);
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            reason: deliveryAttempted ? "delivery-uncertain" : "runtime-unavailable",
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+async function reconcileStrandedInputDelivery(store, delivery, task, role, run, session, input, now) {
+    const target = { kind: "role", taskId: task.id, roleName: role.name };
+    const uncertain = (reason) => {
+        store.markInputDeliveryUnknown(target, input.attemptId, reason, now);
+        return {
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id,
+            status: "skipped",
+            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)}`);
+    }
+}
+function continuationInput(task, role, run, attemptId, batch) {
+    const references = batch.refs.map((ref) => ("taskId" in ref
+        ? `${ref.type}:${ref.taskId}/${ref.id}`
+        : `${ref.type}:${ref.id}`));
+    return markYuiRunInput([
+        `Yui Task Event Batch: ${attemptId}.`,
+        "New durable task events are available for the current Yui Run.",
+        "Read the referenced shared context through the Yui CLI, incorporate it, and decide whether to continue work or wait for more results.",
+        "Do not create a new Yui Run merely because this is a new Provider Turn.",
+        `Reasons: ${batch.reasons.join(", ")}.`,
+        ...(batch.sources.length === 0 ? [] : [`Sources: ${batch.sources.join(", ")}.`]),
+        ...(references.length === 0 ? [] : [`References: ${references.join(", ")}.`])
+    ].join("\n"), run.id, taskRoleSessionTitle(task, role.name));
+}
 function roleRunDeliveryFailure(run, mailboxBatchId, session, launchId) {
     return {
         taskId: run.taskId,

package/dist/scheduler/leaderWakeupProcessor.js

@@ -410,7 +410,8 @@ function leaderWakeupInput(taskId, runId, reasons, projectBindings) {
             : `Project Policy references: ${projectBindings.map((binding) => `${binding.directory} (${binding.projectId})`).join(", ")}. Read each with yui project show <project>, then yui project knowledge list <project> and yui project knowledge show <project> <knowledge>.`,
         "Use narrower Task message, WorkItem, decision, milestone, and input commands only when a specific record needs closer inspection.",
         `When the requested outcome is finished and there are no active Worker Runs or unresolved inputs, complete the Task with yui task complete ${taskId} --summary-file - and a quoted heredoc containing the final outcome and evidence.`,
-        `Before ending this turn, if the Task was not completed and no InputRequest terminalized this Run, release the active fence with yui task run yield ${runId} --summary-file - and a quoted heredoc containing the current result or waiting state. In particular, yield before waiting for Worker results; do not end the native turn while this Run remains active. The yield command must be the final tool action: after it succeeds, stop immediately and do not inspect, poll, accept, or perform further work in the same native turn.`
+        "Provider-native subagents remain inside this Leader AgentRun. Yui observes their structured lifecycle and keeps the Run active across intermediate provider Turn boundaries while children remain active; let the provider deliver completion notifications and continue synthesis without polling or yielding merely for that native wait.",
+        `A Provider Turn ending does not end this Yui Run. Leave the Run active when later native-subagent results, managed Role results, reviewer results, or user corrections still belong to the same objective; Yui will aggregate those durable events and resume this Session with another Turn. Use yui task run yield ${runId} --summary-file - only for a deliberate Yui-level handoff that should close this Run rather than for ordinary waiting. If used, the yield command must be the final tool action: after it succeeds, stop immediately.`
     ];
     return lines.join("\n");
 }

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,12 +1,13 @@
 import { createInputRequestOperatorPresentation, createLeaderRecoveryOperatorPresentation, createLeaderStallOperatorPresentation, createTaskTerminalOperatorPresentation } from "../interaction/operatorPresentation.js";
+import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 export async function processOperatorInputNotifications(store, delivery, selection, now = new Date()) {
     if (selection !== undefined && !selection.full && !selection.operator)
         return [];
     const targetMailbox = { kind: "operator" };
     const mailbox = store.getWorkMailbox(targetMailbox);
-    if (mailbox === null || (mailbox.pending === null && mailbox.processing === null))
+    if (mailbox === null || !mailboxHasWork(mailbox))
         return [];
-    const pending = mailbox.pending;
+    const pending = nextPendingBatch(mailbox);
     const claim = store.claimWorkMailbox({
         target: targetMailbox,
         batchId: pending === null

package/dist/scheduler/roleRunLiveness.js

@@ -4,8 +4,12 @@ import { queueLeaderWakeup } from "./wakeupQueue.js";
 import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
 export const EXITED_ROLE_RUN_SUMMARY = "The role's tmux session exited before the run yielded.";
 /**
- * Lightweight liveness only: an active AgentRun whose tmux role is absent is
- * failed, then the Leader is durably queued. No TTL, cooldown, or schedules.
+ * Lightweight liveness only. Host absence may fail a Run only before any
+ * prompt bytes were pushed. After push, acceptance may be unknown even when
+ * deliveredAt is absent; pane/process loss is therefore runtime-health
+ * evidence, not an application-level outcome. The Run stays active so native
+ * child work or another observer can still contribute facts, while the stall
+ * path raises bounded attention independently.
  */
 export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
     const failed = [];
@@ -35,11 +39,8 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
     })));
     if (candidates.length === 0)
         return failed;
-    const candidateTaskIds = [...new Set(candidates.map(({ task }) => task.id))]
-        .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
-    const completing = new Set(store.listPendingRuntimeTurnCompletions(candidateTaskIds).map((completion) => (`${completion.taskId}\0${completion.roleName}\0${completion.runId}`)));
-    const eligible = candidates.filter(({ task, role, run }) => (!excludedRunRefs.has(formatTaskRecordReference(task.id, run.id, "agentRun"))
-        && !completing.has(`${task.id}\0${role.name}\0${run.id}`)));
+    const eligible = candidates.filter(({ task, run }) => (!excludedRunRefs.has(formatTaskRecordReference(task.id, run.id, "agentRun"))
+        && run.pushedAt === undefined));
     // Full reconciliation builds one complete provider inventory for every
     // active Run, including delivery-uncertain and completion-pending Runs.
     // The stall phase reuses that snapshot so one full pass never probes the

package/dist/scheduler/roleRunStall.js

@@ -1,4 +1,5 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
+import { nextPendingBatch } from "../coordination/workMailbox.js";
 /**
  * Default window of no durable progress before a live-but-idle Run becomes a
  * traceable needs-attention signal. It is deliberately long: a healthy Run that
@@ -845,7 +846,7 @@ function classifyLeaderStall(store, taskId, observed, now, windowMs) {
     const downstreamPresent = downstream.some((entry) => entry.live === "present");
     const leader = [...observed.values()].find((entry) => (entry.candidate.task.id === taskId && entry.candidate.role.name === "leader"));
     const mailbox = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" });
-    const pending = mailbox?.pending;
+    const pending = mailbox === null || mailbox === undefined ? null : nextPendingBatch(mailbox);
     const processing = mailbox?.processing;
     const processingCurrent = processing?.executionRef?.type === "run"
         && processing.executionRef.taskId === taskId
@@ -952,7 +953,8 @@ function leaderStallEvidence(store, taskId, observed, now, windowMs) {
     const active = downstream.filter((entry) => entry.candidate.run !== null).length;
     const healthy = downstream.filter((entry) => entry.live === "present" && !entry.stalled).length;
     const stalled = downstream.filter((entry) => entry.live === "present" && entry.stalled).length;
-    const pending = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" })?.pending;
+    const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" });
+    const pending = leaderMailbox === null ? null : nextPendingBatch(leaderMailbox);
     const pendingAge = pending === undefined || pending === null
         ? "none"
         : Number.isFinite(Date.parse(pending.lastQueuedAt))

package/dist/scheduler/taskExecutionProjection.js

@@ -1,4 +1,5 @@
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { mailboxBatches } from "../coordination/workMailbox.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
 /**
@@ -537,8 +538,7 @@ function isRecoveryPending(wakeup, mailbox, failure, notification) {
         return false;
     const reasons = [
         ...(wakeup?.reasons ?? []),
-        ...(mailbox?.pending?.reasons ?? []),
-        ...(mailbox?.processing?.batch.reasons ?? [])
+        ...(mailbox === null ? [] : mailboxBatches(mailbox).flatMap((batch) => batch.reasons))
     ];
     return reasons.some((reason) => /(?:recover|stalled|failed|uncertain|orphan)/iu.test(reason));
 }