@zq-silk/yui 0.2.0 → 0.4.2

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,20 +1,31 @@
+import { selectedSchedulerRoles, selectedSchedulerTasks } from "./ports.js";
+import { isSchedulerTaskWorkspaceReady } from "./ports.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { effectiveLaunchSnapshotsCompatible } from "../executor/effectiveLaunch.js";
+import { RuntimeLaunchError } from "../runtime/ports.js";
+import { isPreInputReadinessSupported } from "../lifecycle/canonicalLifecycleEvent.js";
+import { preInputReadinessCapability } from "../lifecycle/providerLifecycleMapping.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) {
+export async function processActiveRoleRunDeliveries(store, delivery, now, selection) {
     const results = [];
-    for (const task of store.listTasks()) {
+    for (const task of selectedSchedulerTasks(store, selection)) {
         if (task.status !== "active")
             continue;
-        for (const role of store.listRoles(task.id)) {
+        for (const role of selectedSchedulerRoles(store, task.id, selection)) {
             const run = store.getActiveAgentRun(task.id, role.name);
             // A crash after a Leader wake is durably claimed but before tmux input
-            // is recoverable through the same receipt-backed delivery path.
-            if (run === null || run.deliveredAt !== undefined)
+            // is recoverable through the same receipt-backed delivery path. The
+            // re-push guard keys on pushedAt (transport), not deliveredAt (provider
+            // acceptance): a pushed-but-unaccepted Run must never be pushed twice —
+            // no duplicate Enter while acceptance is still pending.
+            if (run === null || run.pushedAt !== undefined)
                 continue;
-            if (task.repositoryId !== undefined && task.cwd === undefined) {
+            const taskWorkspace = store.getTaskWorkspace(task.id);
+            if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
                 results.push({
                     taskId: task.id,
                     roleName: role.name,
@@ -24,66 +35,355 @@ export async function processActiveRoleRunDeliveries(store, delivery, now) {
                 });
                 continue;
             }
-            const existingSession = store.getRoleSession(task.id, role.name);
-            const receiptId = `agent-run:${run.id}`;
+            const existingSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
+            const receiptId = formatAgentRunReceiptId(task.id, run.id);
+            const target = { kind: "role", taskId: task.id, roleName: role.name };
+            const claim = store.claimWorkMailbox({
+                target,
+                batchId: receiptId,
+                owner: "controller",
+                now,
+                executionRef: { type: "run", taskId: task.id, id: run.id }
+            });
+            if (claim.status === "empty") {
+                results.push({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "mailbox-empty"
+                });
+                continue;
+            }
+            const processing = claim.processing;
+            if (processing.executionRef?.type !== "run"
+                || processing.executionRef.taskId !== task.id
+                || processing.executionRef.id !== run.id) {
+                results.push({
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    status: "skipped",
+                    reason: "mailbox-busy"
+                });
+                continue;
+            }
+            let prepared;
+            let preparedSession = existingSession;
+            let preStartFencePersisted = false;
+            let deliveryAttempted = false;
             try {
                 const nativeSessionId = run.mode === "resume"
-                    ? requireResumeSession(role, existingSession)
+                    ? requireResumeSession(role, run.effective, existingSession)
                     : undefined;
-                const prepared = await delivery.prepareRoleSession({
+                prepared = await delivery.prepareRoleSession({
                     taskId: task.id,
                     roleName: role.name,
-                    agentId: role.activeAgentId,
-                    adapterId: role.adapterId,
+                    agentId: run.effective.agentId,
+                    adapterId: run.effective.adapterId,
+                    effective: run.effective,
+                    workspace: run.effective.workspace.root,
+                    ...(run.workspace === undefined
+                        ? {}
+                        : { managedWorkspace: run.workspace }),
                     mode: run.mode,
-                    ...(nativeSessionId === undefined ? {} : { nativeSessionId })
+                    runId: run.id,
+                    ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
+                    beforeHostStart: (preflight) => {
+                        persistPreStartFence(store, task, role, run, existingSession, preflight, now);
+                        preparedSession = preflightSession(role, run.effective, existingSession, run.mode, preflight);
+                        preStartFencePersisted = true;
+                    }
+                });
+                // A fresh Codex host may already carry the exact Run prompt in its
+                // launch argv. 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;
+                // 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`.
+                if (!preStartFencePersisted) {
+                    const preparedFenceSession = prepared.session === undefined
+                        ? existingSession
+                        : validateReadySession(role, run.effective, existingSession, run.mode, { prepared, session: prepared.session });
+                    preparedSession = preparedFenceSession;
+                    store.saveRoleRunPrepared({
+                        task,
+                        role,
+                        run,
+                        session: preparedFenceSession,
+                        ...(prepared.launchId === undefined ? {} : { launchId: prepared.launchId }),
+                        now
+                    });
+                }
+                const ready = await delivery.waitUntilReady(prepared);
+                deliveryAttempted = deliveryAttempted
+                    || ready.prepared.inputSubmittedAtLaunch === true;
+                const session = validateReadySession(role, run.effective, existingSession, run.mode, ready);
+                preparedSession = session;
+                store.saveRoleRunPrepared({
+                    task,
+                    role,
+                    run,
+                    session,
+                    ...(ready.prepared.launchId === undefined
+                        ? {}
+                        : { launchId: ready.prepared.launchId }),
+                    now
                 });
-                const existingReceipt = await delivery.findExistingReceipt?.({
-                    delivery: prepared,
-                    receiptId
-                }) ?? null;
-                const ready = existingReceipt ?? await delivery.waitUntilReady(prepared);
-                const session = validateReadySession(role, existingSession, run.mode, ready);
-                let status = "already-delivered";
-                if (existingReceipt === null) {
-                    status = await delivery.sendOnce({
-                        delivery: ready,
-                        receiptId,
-                        text: run.input
-                    }) === "sent" ? "delivered" : "already-delivered";
+                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.
+                    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: "delivered"
+                    });
+                    continue;
+                }
+                // Pre-input readiness gate. For an adapter whose capability proves a
+                // native event fires before the first prompt (e.g. Claude SessionStart),
+                // a freshly-started host must not be pushed until that provider-ready
+                // fact has been folded. Unsupported adapters (e.g. Codex) have no
+                // pre-input event, so their push proceeds and acceptance is confirmed
+                // only by the later exact provider-accepted fold. The gate reads the
+                // adapter capability and the durable ready projection — never a sleep,
+                // screen scrape, or pane/PID inference — and fails closed for a
+                // supported adapter whose readiness cannot be confirmed.
+                if (ready.prepared.sessionStarted
+                    && isPreInputReadinessSupported(preInputReadinessCapability(run.effective.adapterId))
+                    && !providerReadyForPush(store, {
+                        taskId: task.id,
+                        roleName: role.name,
+                        agentId: run.effective.agentId,
+                        ...(ready.prepared.launchId === undefined ? {} : { launchId: ready.prepared.launchId }),
+                        ...(session?.nativeSessionId === undefined
+                            ? {}
+                            : { nativeSessionId: session.nativeSessionId })
+                    })) {
+                    results.push({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        status: "skipped",
+                        reason: "not-ready"
+                    });
+                    continue;
                 }
-                store.saveRoleRunDelivery({ task, role, run, session, now });
+                deliveryAttempted = true;
+                const outcome = await delivery.sendOnce({
+                    delivery: ready,
+                    receiptId,
+                    text: run.input
+                });
+                if (outcome === "busy" || outcome === "unavailable") {
+                    results.push({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        status: "skipped",
+                        reason: outcome === "busy" ? "not-ready" : "runtime-unavailable",
+                        terminalFailure: roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId)
+                    });
+                    continue;
+                }
+                const status = outcome === "sent" ? "delivered" : "already-delivered";
+                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 });
             }
             catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (error instanceof RuntimeLaunchError) {
+                    const terminalFailure = roleRunDeliveryFailure(run, processing.batchId, existingSession, error.launchId);
+                    if (error.retryable) {
+                        results.push({
+                            taskId: task.id,
+                            roleName: role.name,
+                            runId: run.id,
+                            status: "skipped",
+                            reason: "runtime-unavailable",
+                            error: message,
+                            terminalFailure
+                        });
+                        continue;
+                    }
+                    const persisted = store.saveRoleRunDeliveryFailure({
+                        ...terminalFailure,
+                        now
+                    });
+                    if (persisted === "failed") {
+                        delivery.forgetPrepared?.({
+                            taskId: task.id,
+                            roleName: role.name,
+                            runId: run.id,
+                            launchId: error.launchId
+                        });
+                    }
+                    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"
+                    });
+                    continue;
+                }
+                if (!deliveryAttempted) {
+                    delivery.forgetPrepared?.({
+                        taskId: task.id,
+                        roleName: role.name,
+                        runId: run.id,
+                        ...(prepared?.launchId === undefined
+                            ? {}
+                            : { launchId: prepared.launchId })
+                    });
+                    const persisted = store.saveExitedRoleRun({
+                        task,
+                        role,
+                        run,
+                        session: existingSession,
+                        summary: `Role Run could not start: ${message}`,
+                        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"
+                    });
+                    continue;
+                }
                 results.push({
                     taskId: task.id,
                     roleName: role.name,
                     runId: run.id,
                     status: "failed",
-                    error: error instanceof Error ? error.message : String(error)
+                    reason: "delivery-uncertain",
+                    error: message,
+                    terminalFailure: roleRunDeliveryFailure(run, processing.batchId, preparedSession, prepared?.launchId)
                 });
             }
         }
     }
     return results;
 }
-function requireResumeSession(role, session) {
+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}.`);
     }
+    if (!effectiveLaunchSnapshotsCompatible(session.effective, effective)) {
+        throw new Error(`Role resume effective snapshot drifted: ${role.taskId}/${role.name}.`);
+    }
     return session.nativeSessionId;
 }
-function validateReadySession(role, existing, mode, ready) {
-    const session = ready.session;
+function persistPreStartFence(store, task, role, run, existingSession, preflight, now) {
+    if (preflight.owner.scope !== "task"
+        || preflight.owner.taskId !== task.id
+        || preflight.owner.roleName !== role.name
+        || preflight.runId !== run.id
+        || preflight.launchId.trim().length === 0) {
+        throw new Error(`Pre-start launch fence changed the active Role Run: ${task.id}/${role.name}.`);
+    }
+    const session = preflightSession(role, run.effective, existingSession, run.mode, preflight);
+    store.saveRoleRunPrepared({
+        task,
+        role,
+        run,
+        session,
+        launchId: preflight.launchId,
+        now
+    });
+}
+function preflightSession(role, effective, existing, mode, preflight) {
+    const session = preflight.nativeSessionId === undefined
+        ? null
+        : {
+            agentId: preflight.agentId,
+            adapterId: preflight.adapterId,
+            nativeSessionId: preflight.nativeSessionId,
+            launchId: preflight.launchId,
+            status: "ready",
+            effective: preflight.effective
+        };
+    return validateRoleSession(role, effective, existing, mode, session);
+}
+function validateReadySession(role, effective, existing, mode, ready) {
+    return validateRoleSession(role, effective, existing, mode, ready.session);
+}
+function validateRoleSession(role, effective, existing, mode, session) {
     if (mode === "new" && session === null)
         return null;
     if (session === null || !hasText(session.nativeSessionId)) {
         throw new Error(`Ready Role session has no native session id: ${role.taskId}/${role.name}.`);
     }
-    if (session.agentId !== role.activeAgentId || session.adapterId !== role.adapterId) {
+    if (session.agentId !== effective.agentId || session.adapterId !== effective.adapterId) {
         throw new Error(`Ready Role session identity changed: ${role.taskId}/${role.name}.`);
     }
+    if (!effectiveLaunchSnapshotsCompatible(session.effective, effective)) {
+        throw new Error(`Ready Role session effective snapshot changed: ${role.taskId}/${role.name}.`);
+    }
+    if (existing?.nativeSessionId !== undefined
+        && effectiveLaunchSnapshotsCompatible(existing.effective, effective)
+        && session.nativeSessionId !== existing.nativeSessionId) {
+        throw new Error(`Ready Role session changed the fixed native session id: ${role.taskId}/${role.name}.`);
+    }
     if (mode === "resume" && session.nativeSessionId !== existing?.nativeSessionId) {
         throw new Error(`Role resume changed the fixed native session id: ${role.taskId}/${role.name}.`);
     }
@@ -92,3 +392,13 @@ function validateReadySession(role, existing, mode, ready) {
 function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
+/**
+ * Fail-closed readiness check for a supported-readiness adapter's first push.
+ * When the store cannot answer (no implementation), the push is held rather than
+ * proceeding blind — a supported adapter must have a proven provider-ready fold.
+ */
+function providerReadyForPush(store, input) {
+    if (store.isRoleGenerationProviderReady === undefined)
+        return false;
+    return store.isRoleGenerationProviderReady(input);
+}

package/dist/scheduler/activeTaskProgress.js

@@ -0,0 +1,63 @@
+import { selectedSchedulerTasks, isSchedulerTaskWorkspaceReady } from "./ports.js";
+import { queueLeaderWakeup } from "./wakeupQueue.js";
+import { projectTaskExecution } from "./taskExecutionProjection.js";
+/**
+ * Repairs an active Task that has no durable owner capable of advancing it.
+ * This is a low-frequency safety net; normal transitions enqueue their own
+ * Role mailbox signal in the same transaction.
+ */
+export function repairOrphanedActiveTasks(store, now, selection) {
+    const repaired = [];
+    for (const task of selectedSchedulerTasks(store, selection)) {
+        if (task.status !== "active")
+            continue;
+        const roles = store.listRoles(task.id);
+        const activeRuns = roles.flatMap((role) => {
+            const run = store.getActiveAgentRun(task.id, role.name);
+            return run === null ? [] : [run];
+        });
+        const hasInFlightTurn = roles.some((role) => store.hasInFlightTurn(task.id, role.name));
+        const leaderTarget = { kind: "role", taskId: task.id, roleName: "leader" };
+        const leaderMailbox = store.getWorkMailbox(leaderTarget);
+        const projection = projectTaskExecution({
+            task,
+            roles,
+            runs: activeRuns,
+            pendingWakeup: store.getPendingWakeup(task.id),
+            leaderMailbox,
+            leaderFailure: store.getLeaderFailure(task.id),
+            operatorNotification: store.getOperatorNotification(task.id)
+        });
+        if (hasInFlightTurn
+            || store.hasOpenInputRequest(task.id)
+            || store.getLeaderFailure(task.id) !== null
+            || store.getOperatorNotification(task.id) !== null
+            || projection.status !== "needs-leader-action"
+            || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {
+            continue;
+        }
+        const taskWorkspace = store.getTaskWorkspace(task.id);
+        if (!isSchedulerTaskWorkspaceReady(task, taskWorkspace)) {
+            store.queueTaskProgress(task.id, "task-orphaned", now);
+        }
+        if (leaderMailbox?.processing !== null && leaderMailbox?.processing !== undefined) {
+            const recovered = store.releaseLeaderWakeupAndEnqueue === undefined
+                ? store.releaseWorkMailbox(leaderTarget, leaderMailbox.processing.batchId)
+                    && (queueLeaderWakeup(store, task.id, "task-orphaned", now), true)
+                : store.releaseLeaderWakeupAndEnqueue(task.id, leaderMailbox.processing.batchId, "task-orphaned", now);
+            if (recovered) {
+                repaired.push(task.id);
+            }
+            continue;
+        }
+        queueLeaderWakeup(store, task.id, "task-orphaned", now);
+        repaired.push(task.id);
+    }
+    return repaired;
+}
+function hasUnclaimedLeaderWork(store, taskId, leaderMailbox) {
+    if (leaderMailbox === null)
+        return store.getPendingWakeup(taskId) !== null;
+    return leaderMailbox?.processing === null
+        && leaderMailbox.pending !== null;
+}

package/dist/scheduler/leaderFailure.js

@@ -1,7 +1,8 @@
+export const CURRENT_LEADER_FAILURE_SCHEMA_VERSION = 1;
 export function recordLeaderFailure(taskId, nativeSessionId, message, now, existing) {
     const timestamp = now.toISOString();
     return {
-        schemaVersion: 1,
+        schemaVersion: CURRENT_LEADER_FAILURE_SCHEMA_VERSION,
         taskId: requiredText(taskId, "Task id"),
         nativeSessionId: requiredText(nativeSessionId, "Native session id"),
         message: requiredText(message, "Leader failure message"),