@zq-silk/yui 0.13.9 → 0.14.0

package/dist/scheduler/operatorEvent.js

@@ -1,5 +1,6 @@
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { queueLeaderWakeup } from "./wakeupQueue.js";
 export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
 /** The sole Task-event boundary into the global Operator mailbox. */
 export function enqueueOperatorEvent(store, event, reason, now) {
@@ -7,9 +8,7 @@ export function enqueueOperatorEvent(store, event, reason, now) {
         { type: "event", taskId: event.taskId, id: event.id }
     ], {
         source: "task-event",
-        dedupeKey: `operator-event:${event.taskId}:${event.id}`,
-        deliveryMode: "followup",
-        lane: "normal"
+        dedupeKey: `operator-event:${event.taskId}:${event.id}`
     });
 }
 /** Routes one Role fact to its supervisor without exposing Provider details to Operator code. */
@@ -20,10 +19,9 @@ export function routeRoleEvent(store, event, roleName, reason, now) {
     }
     enqueueWork(store, { kind: "role", taskId: event.taskId, roleName: "leader" }, reason, now, [{ type: "event", taskId: event.taskId, id: event.id }], {
         source: "task-event",
-        dedupeKey: `leader-event:${event.taskId}:${event.id}`,
-        deliveryMode: "followup",
-        lane: "normal"
+        dedupeKey: `leader-event:${event.taskId}:${event.id}`
     });
+    queueLeaderWakeup(store, event.taskId, reason, now);
 }
 /** Records the semantic boundary used when a Leader can no longer continue. */
 export function recordLeaderAttentionRequired(store, input) {

package/dist/scheduler/resourceQueueProjection.js

@@ -0,0 +1,71 @@
+import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "../execution/resourceBroker.js";
+/** Exact durable Broker queue used by resource admission. */
+export function projectQueuedResourceLaneIdentities(store, now) {
+    return store.listActiveTaskIds().flatMap((taskId) => {
+        const taskTurns = store.listTurns(taskId);
+        const taskEvents = store.listEvents(taskId);
+        const workItemLanes = store.listWorkItems(taskId).flatMap((item) => {
+            if (item.status !== "running")
+                return [];
+            const group = currentWorkItemExecutionGroup(item);
+            if (group === undefined || group.resolution !== undefined)
+                return [];
+            if (group.stage !== undefined) {
+                const resources = projectExecutionStageResources({
+                    group,
+                    stageGroups: item.executionGroups,
+                    usage: observedExecutionResourceUsage({
+                        group,
+                        stageGroups: item.executionGroups,
+                        turns: taskTurns,
+                        events: taskEvents
+                    }),
+                    now
+                });
+                if (executionStageSpendClosed(resources))
+                    return [];
+            }
+            return group.lanes.flatMap((lane) => {
+                if (lane.status !== "pending"
+                    || lane.effective === undefined
+                    || lane.turnId !== undefined)
+                    return [];
+                return [{
+                        taskId,
+                        workItemId: item.id,
+                        executionGroupId: group.id,
+                        executionLaneId: lane.id,
+                        providerId: lane.effective.adapterId,
+                        agentId: lane.effective.agentId,
+                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
+                        requestedAt: lane.updatedAt
+                    }];
+            });
+        });
+        const reviewLanes = store.listReviewRounds(taskId).flatMap((round) => {
+            if (round.status !== "pending" && round.status !== "running")
+                return [];
+            const group = round.executionGroup;
+            if (group === undefined || group.resolution !== undefined)
+                return [];
+            return group.lanes.flatMap((lane) => {
+                if (lane.status !== "pending"
+                    || lane.effective === undefined
+                    || lane.turnId !== undefined)
+                    return [];
+                return [{
+                        taskId,
+                        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+                        executionGroupId: group.id,
+                        executionLaneId: lane.id,
+                        providerId: lane.effective.adapterId,
+                        agentId: lane.effective.agentId,
+                        ...(lane.effective.model === undefined ? {} : { model: lane.effective.model }),
+                        requestedAt: lane.updatedAt
+                    }];
+            });
+        });
+        return [...workItemLanes, ...reviewLanes];
+    });
+}

package/dist/scheduler/{roleRunLiveness.js → roleTurnLiveness.js}

@@ -1,21 +1,19 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
-import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
+import { currentRoleTurnProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleTurnStall.js";
 /**
- * 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
+ * Lightweight liveness only. Pane/process loss is runtime-health evidence,
+ * not an application-level outcome. The Turn stays active so native
  * child work or another observer can still contribute facts, while the stall
  * path raises bounded attention independently.
  * Process liveness is only a recovery signal. An absent pane/Host never proves
- * that the native Session or AgentRun ended; recover the same generation and
- * native identity when possible, otherwise preserve the active Run.
+ * that the native Session or Turn ended; recover the same generation and
+ * native identity when possible, otherwise preserve the active Turn.
  */
-export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
+export async function reconcileExitedRoleTurns(store, delivery, now, selection, excludedTurnRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
     const failed = [];
     const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
-        const run = store.getActiveAgentRun(task.id, role.name);
+        const run = store.getActiveTurn(task.id, role.name);
         if (run === null)
             return [];
         const session = store.getRoleSession(task.id, role.name, run.effective.agentId);
@@ -29,8 +27,8 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
                     roleName: role.name,
                     agentId: run.effective.agentId,
                     adapterId: run.effective.adapterId,
-                    runId: run.id,
-                    progressAt: run.deliveredAt ?? run.createdAt,
+                    turnId: run.id,
+                    progressAt: run.createdAt,
                     ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
                     ...(session?.nativeSessionId === undefined
                         ? {}
@@ -40,10 +38,9 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
     })));
     if (candidates.length === 0)
         return failed;
-    const eligible = candidates.filter(({ task, run }) => (!excludedRunRefs.has(formatTaskRecordReference(task.id, run.id, "agentRun"))
-        && run.pushedAt === undefined));
+    const eligible = candidates.filter(({ task, run }) => (!excludedTurnRefs.has(formatTaskRecordReference(task.id, run.id, "turn"))));
     // Full reconciliation builds one complete provider inventory for every
-    // active Run, including delivery-uncertain and completion-pending Runs.
+    // active Turn, including delivery-uncertain and completion-pending Turns.
     // The stall phase reuses that snapshot so one full pass never probes the
     // same pane twice. When targetedInventory is true, a dirty pass instead
     // uses exact probes below; stall reconciliation intentionally does not run
@@ -60,10 +57,10 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
                 ? [{
                         taskId: task.id,
                         roleName: role.name,
-                        runId: run.id,
+                        turnId: run.id,
                         agentId: run.effective.agentId,
                         adapterId: run.effective.adapterId,
-                        progressAt: currentRoleRunProgressAt(store, task.id, role.name, run).progressAt,
+                        progressAt: currentRoleTurnProgressAt(store, task.id, role.name, run).progressAt,
                         ...(session?.nativeSessionId === undefined
                             ? {}
                             : { nativeSessionId: session.nativeSessionId }),
@@ -79,7 +76,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
         for (const [key, resource] of batchSnapshot.resources) {
             const candidate = candidates.find(({ task, role }) => (`${task.id}\0${role.name}` === key));
             if (candidate !== undefined) {
-                // Keep only the exact Run key. A task/role or bare-Run fallback can
+                // Keep only the exact Turn key. A task/role or bare-Turn fallback can
                 // bridge an asynchronous sample from a prior generation.
                 resourceEvidence.set(`${key}\0${candidate.run.id}`, resource);
             }
@@ -96,7 +93,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
             store.saveRoleHostExitObservation?.({
                 taskId: task.id,
                 roleName: role.name,
-                runId: run.id,
+                turnId: run.id,
                 ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
                 ...(session?.nativeSessionId === undefined
                     ? {}
@@ -113,7 +110,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
             delivery.forgetPrepared?.({
                 taskId: task.id,
                 roleName: role.name,
-                runId: run.id
+                turnId: run.id
             });
             const recovered = await delivery.prepareRoleSession({
                 taskId: task.id,
@@ -124,16 +121,16 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
                 workspace: run.effective.workspace.root,
                 ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
                 mode: "resume",
-                runId: run.id,
+                turnId: run.id,
                 nativeSessionId: session.nativeSessionId,
                 ...(session.launchId === undefined
                     ? {}
                     : { hostActivationId: session.launchId })
             });
-            store.saveRoleRunPrepared({
+            store.saveRoleTurnPrepared({
                 task,
                 role,
-                run,
+                turn: run,
                 session: recovered.session ?? session,
                 ...(recovered.launchId === undefined ? {} : { launchId: recovered.launchId }),
                 now
@@ -142,7 +139,7 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
         }
         catch {
             // Absence plus an inconclusive local recovery attempt is still not a
-            // native Session death proof. Keep the exact Run active for the next
+            // native Session death proof. Keep the exact Turn active for the next
             // bounded recovery pass and expose the blocked axis separately.
             store.queueTaskProgress(task.id, "host-missing-native-resume-pending", now);
         }
@@ -201,11 +198,10 @@ function exactBatchInventory(batch, candidates) {
 function isResourceCandidate(task, run, now) {
     if (task.status !== "active"
         || task.executionGate.state !== "enabled"
-        || run.status !== "active"
-        || run.deliveredAt === undefined) {
+        || run.status !== "active") {
         return false;
     }
-    const deliveredAt = Date.parse(run.deliveredAt);
-    return Number.isFinite(deliveredAt)
-        && now.getTime() - deliveredAt >= DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
+    const createdAt = Date.parse(run.createdAt);
+    return Number.isFinite(createdAt)
+        && now.getTime() - createdAt >= DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
 }