@zq-silk/yui 0.11.3 → 0.12.0

package/dist/scheduler/roleRunStall.js

@@ -30,20 +30,6 @@ const ACTIVITY_EVENT_TYPES = new Set([
     "integration.completed",
     "integration.failed"
 ]);
-/**
- * Clear only the Operator projection raised for this exact Leader Run. A
- * later Run (or a recovery notification of another kind) must remain intact;
- * callers use this helper from every supported recovery/terminalization path
- * so attention cleanup cannot drift between CLI and runtime code.
- */
-export function clearMatchingLeaderStallAttention(store, taskId, runId) {
-    const notification = store.getOperatorNotification(taskId);
-    if (notification?.type !== "leader-stalled" || notification.runId !== runId) {
-        return false;
-    }
-    store.clearOperatorNotification(taskId);
-    return true;
-}
 /**
  * One pure projection used by every Role. Resource activity is retained only
  * as exact-generation diagnostic evidence; it never changes the durable

package/dist/scheduler/taskExecutionProjection.js

@@ -5,6 +5,7 @@ import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from
 import { buildTaskObservabilityProjection } from "./taskObservabilityProjection.js";
 import { isRoleRunStalled, latestStallProgressAt } from "./roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
+import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 /**
  * Build one consistent Task-first projection from the existing durable
  * aggregate. This function only reads; it never starts a Controller, queues a
@@ -23,7 +24,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         roleName: "leader"
     }) ?? null;
     const roleSessions = roles.flatMap((role) => {
-        const session = store.getRoleSession?.(taskId, role.name, role.activeAgentId);
+        const session = store.getRoleSession?.(taskId, role.name);
         return session === null || session === undefined
             ? []
             : [{ roleName: role.name, ...session }];
@@ -54,7 +55,6 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         pendingWakeup: store.getPendingWakeup?.(taskId) ?? null,
         leaderMailbox,
         leaderFailure: store.getLeaderFailure?.(taskId) ?? null,
-        operatorNotification: store.getOperatorNotification?.(taskId) ?? null,
         roleSessions,
         now,
         runtimeHealthPolicy: resolveRuntimeHealth(store.getConfig?.().runtimeHealth)
@@ -78,7 +78,7 @@ export function projectTaskExecutionFromFacts(facts) {
 /** Alias kept intentionally small for scheduler callers and external read models. */
 export const deriveTaskExecutionProjection = projectTaskExecution;
 export function projectTaskExecution(facts) {
-    const { task, roles, runs, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, operatorNotification = null, roleSessions = [], executionGroups = [] } = facts;
+    const { task, roles, runs, workItems = [], inputRequests = [], reviewRounds = [], integrations = [], events = [], pendingWakeup = null, leaderMailbox = null, leaderFailure = null, roleSessions = [], executionGroups = [] } = facts;
     const now = facts.now ?? new Date();
     const groupSummaries = executionGroups.map((group) => {
         const stageGroups = workItems.find((item) => (item.executionGroups.some(({ id }) => id === group.id)))?.executionGroups;
@@ -96,6 +96,14 @@ export function projectTaskExecution(facts) {
         ...executionGroups,
         ...workItems.flatMap((item) => item.executionGroups)
     ]);
+    const sessionTokens = roleSessions.map((session) => {
+        const identity = resolveSessionTokenIdentity({ taskId: task.id, ...session });
+        return Object.freeze({
+            roleName: session.roleName,
+            agentId: session.agentId,
+            metrics: projectSessionTokenMetrics(events, identity)
+        });
+    });
     const observability = buildTaskObservabilityProjection({
         workItems,
         executionGroups: observabilityGroups,
@@ -103,6 +111,7 @@ export function projectTaskExecution(facts) {
         runs,
         events,
         contextSnapshots: facts.contextSnapshots,
+        sessionTokens,
         now
     });
     const laneRecovery = actionableExecutionLaneRecoveries(groupSummaries)[0];
@@ -118,6 +127,8 @@ export function projectTaskExecution(facts) {
         purpose: run.purpose,
         delivered: run.deliveredAt !== undefined,
         status: run.status,
+        ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+        ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId }),
         ...(run.executionGroupId === undefined ? {} : { executionGroupId: run.executionGroupId }),
         ...(run.executionLaneId === undefined ? {} : { executionLaneId: run.executionLaneId })
     }));
@@ -138,7 +149,6 @@ export function projectTaskExecution(facts) {
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: 0,
             attention: [],
             blockers: [],
             pendingWakeup
@@ -150,21 +160,22 @@ export function projectTaskExecution(facts) {
         activeRuns,
         events,
         leaderFailure,
-        operatorNotification,
         roleSessions,
         inputRequests
     });
     const openInputs = inputRequests.filter((request) => request.status === "open");
     const blockers = collectBlockers(workItems, reviewRounds, integrations, openInputs, task);
-    const activeExecutors = activeRuns.filter((run) => isExecutionCarrier(run));
-    const activeWorkers = activeExecutors.filter((run) => run.roleName !== "leader");
-    const healthyExecutionCarriers = activeWorkers.filter((run) => (run.deliveredAt !== undefined
+    const activeExecutionRuns = activeRuns.filter((run) => run.purpose === "execution");
+    const activeReviewRuns = activeRuns.filter((run) => run.purpose === "review");
+    const activeDelegatedExecutions = activeExecutionRuns.filter((run) => (run.roleName !== "leader"));
+    const healthyActiveRuns = activeRuns.filter((run) => (run.deliveredAt !== undefined
         && !attention.some((item) => item.runId === run.id)));
     const activeLeader = activeRuns.find((run) => run.roleName === "leader");
-    const pendingDelivery = activeRuns.some((run) => run.deliveredAt === undefined);
+    const pendingDeliveryRuns = activeRuns.filter((run) => run.deliveredAt === undefined);
     const hasPendingLeaderWork = pendingWakeup !== null
-        || leaderMailbox?.pending !== null && leaderMailbox?.pending !== undefined;
-    const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure, operatorNotification);
+        || leaderMailbox !== null && (leaderMailbox.pending.normal !== null
+            || leaderMailbox.pending.userCorrection !== null);
+    const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
     const failedWork = workItems.some((item) => item.status === "failed");
     const candidateReady = workItems.some((item) => item.status === "awaiting_acceptance");
     const blockedIntegration = integrations.some((attempt) => attempt.status === "blocked");
@@ -177,20 +188,19 @@ export function projectTaskExecution(facts) {
         if (first === undefined)
             throw new Error("Task execution attention disappeared.");
         const progressingWithAttention = first.kind === "checkpoint-overdue"
-            && healthyExecutionCarriers.length > 0;
+            && healthyActiveRuns.length > 0;
         return render({
             task,
             status: progressingWithAttention ? "progressing-with-attention" : "attention",
             owner: first.owner,
             action: "inspect-attention",
             summary: progressingWithAttention
-                ? `${healthyExecutionCarriers.length} healthy execution carrier(s) remain while ${first.summary}`
+                ? `${healthyActiveRuns.length} healthy active Run(s) remain while ${first.summary}`
                 : first.summary,
             reason: progressingWithAttention ? "progressing-with-attention" : first.kind,
             monitoring,
             failClosed: hasLeaderMismatch || attention.some((item) => item.failClosed === true),
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
@@ -210,7 +220,6 @@ export function projectTaskExecution(facts) {
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
@@ -231,7 +240,6 @@ export function projectTaskExecution(facts) {
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
@@ -251,7 +259,6 @@ export function projectTaskExecution(facts) {
             monitoring,
             failClosed: hasLeaderMismatch,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
@@ -269,83 +276,124 @@ export function projectTaskExecution(facts) {
             monitoring,
             failClosed: leaderFailure !== null,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (pendingDelivery) {
+    const leaderDeliveryPending = pendingDeliveryRuns.some((run) => run.roleName === "leader");
+    if (leaderDeliveryPending) {
         return render({
             task,
             status: "recovering",
             owner: "leader",
             action: "recover-leader",
-            summary: "An active Run is awaiting provider acceptance; delivery remains fail-closed.",
+            summary: "The active Leader Run is awaiting provider acceptance; delivery remains fail-closed.",
             reason: "delivery-pending",
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (activeWorkers.length > 0 && activeLeader === undefined) {
+    if (activeLeader !== undefined) {
+        const concurrentExecutionCount = activeDelegatedExecutions.length;
+        const concurrentReviewCount = activeReviewRuns.length;
+        const concurrentSummary = [
+            concurrentExecutionCount === 0
+                ? null
+                : `${concurrentExecutionCount} delegated execution Run(s)`,
+            concurrentReviewCount === 0
+                ? null
+                : `${concurrentReviewCount} Review Run(s)`
+        ].filter((value) => value !== null).join(" and ");
         return render({
             task,
-            status: "waiting-on-agents",
-            owner: roleOwner(activeWorkers[0].roleName),
-            action: "wait-for-agents",
-            summary: `${activeWorkers.length} delegated execution Run(s) are active; Leader is waiting for their result.`,
-            reason: "delegated-work-active",
+            status: "working",
+            owner: "leader",
+            action: "advance-task",
+            summary: concurrentSummary.length === 0
+                ? "Leader Run is actively advancing the Task."
+                : `Leader Run is actively advancing the Task alongside ${concurrentSummary}.`,
+            reason: concurrentSummary.length === 0 ? "leader-run-active" : "leader-and-agents-active",
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (activeLeader !== undefined) {
+    if (hasPendingLeaderWork) {
         return render({
             task,
-            status: activeWorkers.length > 0 ? "waiting-on-agents" : "working",
+            status: "needs-leader-action",
             owner: "leader",
-            action: activeWorkers.length > 0 ? "wait-for-agents" : "advance-task",
-            summary: activeWorkers.length > 0
-                ? `Leader Run is active while ${activeWorkers.length} delegated Run(s) continue.`
-                : "Leader Run is actively advancing the Task.",
-            reason: activeWorkers.length > 0 ? "leader-and-delegates-active" : "leader-run-active",
+            action: "advance-task",
+            summary: "A durable Leader wake is pending; concurrent AgentRuns remain visible but do not suppress it.",
+            reason: "leader-wake-pending",
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (activeExecutors.length > 0) {
+    if (pendingDeliveryRuns.length > 0) {
+        return render({
+            task,
+            status: "recovering",
+            owner: "leader",
+            action: "recover-execution",
+            summary: `${pendingDeliveryRuns.length} active delegated AgentRun(s) are awaiting provider acceptance; delivery remains fail-closed.`,
+            reason: "delivery-pending",
+            monitoring,
+            failClosed: false,
+            activeRuns: activeRunViews,
+            attention,
+            blockers,
+            pendingWakeup
+        });
+    }
+    if (activeDelegatedExecutions.length > 0) {
+        const reviewSuffix = activeReviewRuns.length === 0
+            ? ""
+            : `; ${activeReviewRuns.length} Review Run(s) are also active`;
         return render({
             task,
             status: "waiting-on-agents",
-            owner: roleOwner(activeExecutors[0].roleName),
+            owner: roleOwner(activeDelegatedExecutions[0].roleName),
             action: "wait-for-agents",
-            summary: `${activeExecutors.length} delegated execution Run(s) are active.`,
+            summary: `${activeDelegatedExecutions.length} delegated execution Run(s) are active${reviewSuffix}.`,
             reason: "delegated-work-active",
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
         });
     }
-    if (candidateReady || unresolvedIntegration || hasPendingLeaderWork) {
+    if (activeReviewRuns.length > 0) {
+        return render({
+            task,
+            status: "waiting-on-agents",
+            owner: "reviewer",
+            action: "wait-for-agents",
+            summary: `${activeReviewRuns.length} Review Run(s) are evaluating frozen candidates; newer facts can still wake the Leader.`,
+            reason: "review-active",
+            monitoring,
+            failClosed: false,
+            activeRuns: activeRunViews,
+            attention,
+            blockers,
+            pendingWakeup
+        });
+    }
+    if (candidateReady || unresolvedIntegration) {
         return render({
             task,
             status: "needs-leader-action",
@@ -353,16 +401,13 @@ export function projectTaskExecution(facts) {
             action: "advance-task",
             summary: candidateReady
                 ? "A WorkItem Candidate is awaiting Leader action."
-                : unresolvedIntegration
-                    ? "An Integration or validation record needs Leader action."
-                    : "A durable Leader wake is pending.",
+                : "An Integration or validation record needs Leader action.",
             reason: candidateReady
                 ? "candidate-ready"
-                : unresolvedIntegration ? "integration-pending" : "leader-wake-pending",
+                : "integration-pending",
             monitoring,
             failClosed: false,
             activeRuns: activeRunViews,
-            activeExecutorCount: activeExecutors.length,
             attention,
             blockers,
             pendingWakeup
@@ -378,7 +423,6 @@ export function projectTaskExecution(facts) {
         monitoring,
         failClosed: false,
         activeRuns: activeRunViews,
-        activeExecutorCount: activeExecutors.length,
         attention,
         blockers,
         pendingWakeup
@@ -395,7 +439,6 @@ function projection(input) {
         reason: input.reason,
         monitoring: input.monitoring,
         failClosed: input.failClosed,
-        activeExecutorCount: input.activeExecutorCount,
         activeRuns: input.activeRuns,
         executionGroups: input.executionGroups ?? [],
         observability: input.observability,
@@ -456,27 +499,14 @@ function collectExecutionGroups(workItems, reviewRounds) {
 }
 function collectAttention(input) {
     const result = [];
-    const { task, activeRuns, events, leaderFailure, operatorNotification } = input;
-    if (leaderFailure !== null || operatorNotification?.type === "leader-recovery-failed") {
+    const { task, activeRuns, events, leaderFailure } = input;
+    if (leaderFailure !== null) {
         result.push({
             kind: "leader-recovery",
             id: `leader-recovery:${task.id}`,
             owner: "operator",
-            summary: leaderFailure?.message
-                ?? (operatorNotification?.type === "leader-recovery-failed"
-                    ? operatorNotification.message
-                    : "Leader recovery failed."),
-            ...(leaderFailure === null ? {} : { failClosed: true })
-        });
-    }
-    if (operatorNotification?.type === "leader-stalled") {
-        result.push({
-            kind: "leader-stalled",
-            id: `leader-stall:${operatorNotification.runId}:${operatorNotification.progressAt}`,
-            owner: "operator",
-            summary: operatorNotification.message,
-            runId: operatorNotification.runId,
-            roleName: "leader"
+            summary: leaderFailure.message,
+            failClosed: true
         });
     }
     for (const run of activeRuns) {
@@ -620,15 +650,6 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
     }
     return blockers;
 }
-function isExecutionCarrier(run) {
-    return run.purpose === "review"
-        || run.roleName === "leader"
-        // A scheduler-only projection may not have the WorkItem fold available
-        // (for example during a recovery read). An active non-Leader Role is still
-        // an execution carrier; omitting it would falsely wake the Leader.
-        || run.workItemId !== undefined
-        || run.roleName !== "leader";
-}
 function roleOwner(roleName) {
     const normalized = roleName.toLowerCase();
     if (normalized === "leader")
@@ -639,8 +660,8 @@ function roleOwner(roleName) {
         return "tester";
     return "worker";
 }
-function isRecoveryPending(wakeup, mailbox, failure, notification) {
-    if (failure !== null || notification?.type === "leader-recovery-failed")
+function isRecoveryPending(wakeup, mailbox, failure) {
+    if (failure !== null)
         return false;
     const reasons = [
         ...(wakeup?.reasons ?? []),

package/dist/scheduler/taskObservabilityProjection.js

@@ -1,6 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
 import { observedExecutionResourceUsage } from "../execution/resourceBroker.js";
-import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 /**
  * Build the read-only DAG, execution, cost, and context view consumed by CLI
  * and Web. It deliberately derives every value from existing Task records and
@@ -34,7 +33,7 @@ export function buildTaskObservabilityProjection(input) {
             });
         });
         const itemCost = projectCost(groups, input.runs, input.events, now);
-        const itemContext = projectContext(groups, input.runs, input.events, input.contextSnapshots);
+        const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
         const evidence = groups.flatMap((group) => group.lanes.flatMap((lane) => (lane.result?.evidence ?? [])));
         const openFindingCount = groups.reduce((count, group) => count + group.lanes.reduce((laneCount, lane) => laneCount + (lane.result?.findings ?? [])
             .filter(({ status }) => status === "open").length, 0), 0);
@@ -53,8 +52,14 @@ export function buildTaskObservabilityProjection(input) {
         });
     });
     const cost = projectCost(input.executionGroups, input.runs, input.events, now);
-    const context = projectContext(input.executionGroups, input.runs, input.events, input.contextSnapshots);
-    return Object.freeze({ dag, workItems, cost, context });
+    const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
+    return Object.freeze({
+        dag,
+        workItems,
+        cost,
+        context,
+        sessionTokens: Object.freeze([...(input.sessionTokens ?? [])])
+    });
 }
 function projectDag(workItems) {
     const byId = new Map(workItems.map((item) => [item.id, item]));
@@ -187,7 +192,7 @@ function projectCost(groups, runs, events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectContext(groups, runs, events, snapshots) {
+function projectContext(groups, runs, snapshots) {
     const refs = new Map();
     for (const group of groups) {
         const ref = group.stage?.contextSnapshotRef;
@@ -216,17 +221,11 @@ function projectContext(groups, runs, events, snapshots) {
         });
     });
     const sizes = metrics.flatMap(({ byteSize }) => byteSize === null ? [] : [byteSize]);
-    const observedInputPeakTokens = events.flatMap((event) => {
-        const observation = runtimeObservationFromTaskEvent(event);
-        const inputTokens = observation?.payload.usage?.inputTokens;
-        return inputTokens === undefined ? [] : [inputTokens];
-    }).reduce((peak, value) => Math.max(peak, value), 0);
     return Object.freeze({
         snapshotCount: metrics.length,
         snapshots: Object.freeze(metrics),
         totalBytes: sizes.length === metrics.length ? sizes.reduce((sum, size) => sum + size, 0) : null,
         largestBytes: sizes.length === 0 ? null : Math.max(...sizes),
-        observedInputPeakTokens,
         compressionEvents: null,
         compressionRatio: null,
         compressionStatus: "unavailable"