@zq-silk/yui 0.11.3 → 0.12.0

package/dist/runtime/builtinTranscriptUsage.js

@@ -12,13 +12,13 @@ export function codexTranscriptUsage(transcript) {
     });
 }
 export function codexTranscriptUsageReport(transcript) {
-    // Codex token_count events are cumulative session snapshots. Per-request
-    // input is the delta between consecutive snapshots; the first snapshot is
-    // treated as one full request.
+    // Codex token_count events are cumulative Session snapshots. Per-request
+    // input is the non-negative delta between consecutive snapshots; the first
+    // snapshot only establishes the generation baseline.
     let latestInput = 0;
     let latestCached = 0;
     let latestOutput = 0;
-    let previous = 0;
+    let previous;
     let peak = 0;
     let requests = 0;
     let seen = false;
@@ -39,9 +39,11 @@ export function codexTranscriptUsageReport(transcript) {
         requests += 1;
         seen = true;
         const total = inputTokens + cachedInputTokens;
-        const delta = Math.max(0, total - previous);
-        if (delta > peak)
-            peak = delta;
+        if (previous !== undefined) {
+            const delta = Math.max(0, total - previous);
+            if (delta > peak)
+                peak = delta;
+        }
         previous = total;
         latestInput = inputTokens;
         latestCached = cachedInputTokens;

package/dist/runtime/index.js

@@ -1,5 +1,6 @@
 export { createPromptEnvelope } from "./promptEnvelope.js";
 export { codexTranscriptUsage, codexTranscriptUsageReport, claudeTranscriptUsage, claudeTranscriptUsageReport } from "./builtinTranscriptUsage.js";
+export { projectSessionTokenMetrics, resolveSessionTokenIdentity, unobservedSessionTokenMetrics } from "./sessionTokenMetrics.js";
 export { createRuntimeBinding } from "./runtimeBinding.js";
 export { normalizeRuntimeOwner } from "./runtimeOwner.js";
 export { createSessionLaunchRequest } from "./sessionLaunchRequest.js";

package/dist/runtime/runtimeObservation.js

@@ -1,6 +1,19 @@
 import { createHash } from "node:crypto";
 import { requireDriverId } from "./agentDriver.js";
 export const RUNTIME_OBSERVATION_TASK_EVENT = "runtime.observation";
+/**
+ * Numeric usage and value-less partial request boundaries are both durable
+ * token-projection evidence. The latter deliberately carries no activityId so
+ * it cannot be mistaken for lifecycle progress.
+ */
+export function isRuntimeTokenEvidence(observation) {
+    return observation.kind === "activity.observed"
+        && (observation.payload.usage !== undefined
+            || (observation.payload.sourceId !== undefined
+                && observation.payload.activityId === undefined
+                && (observation.payload.observationQuality === "partial"
+                    || observation.payload.observationQuality === "unavailable")));
+}
 const KINDS = [
     "host.observed",
     "session.started",

package/dist/runtime/runtimeProjection.js

@@ -158,16 +158,23 @@ export function projectRuntimeObservation(current, raw) {
         }
         case "activity.observed": {
             const usage = event.payload.usage;
-            if (usage !== undefined && !usageAdvanced(current.usage, usage)) {
-                return next(current, { usage: Object.freeze({ ...usage }) });
-            }
-            return withActivity(next(current, {
+            const lifecycleActivity = event.payload.activityId !== undefined
+                && usage === undefined;
+            const projected = next(current, {
                 ...(usage === undefined ? {} : { usage: Object.freeze({ ...usage }) }),
-                session: current.turn === "waiting" ? "active" : current.session,
-                turn: current.turn === "waiting" ? "accepted" : current.turn,
-                waitingReason: undefined,
-                waitId: undefined
-            }), event.payload.activity, at);
+                ...(lifecycleActivity ? {
+                    session: current.turn === "waiting" ? "active" : current.session,
+                    turn: current.turn === "waiting" ? "accepted" : current.turn,
+                    waitingReason: undefined,
+                    waitId: undefined
+                } : {})
+            });
+            // Token counters are read-only measurements. Only a separate explicit
+            // activity observation may advance runtime health or waiting state;
+            // usage activityId values identify requests only for token projection.
+            if (!lifecycleActivity)
+                return projected;
+            return withActivity(projected, event.payload.activity, at);
         }
         case "observer.health":
             return next(current, {
@@ -488,22 +495,6 @@ function next(current, patch) {
         runActivity
     });
 }
-function usageAdvanced(previous, current) {
-    if (current.semantics === "remaining-context")
-        return false;
-    if (current.semantics === "request-context")
-        return usageTotal(current) > 0;
-    // A first cumulative snapshot may contain history from a resumed native
-    // Session. It establishes a baseline but cannot prove current progress.
-    if (previous === undefined || previous.semantics !== "cumulative-session")
-        return false;
-    return usageTotal(current) > usageTotal(previous);
-}
-function usageTotal(usage) {
-    // cachedInputTokens and reasoningTokens are breakdowns of the normalized
-    // input/output totals, not additional usage.
-    return usage.inputTokens + usage.outputTokens;
-}
 function dominantOperation(operations) {
     const kinds = Object.values(operations).map(({ kind }) => kind);
     if (kinds.includes("subagent"))

package/dist/runtime/sessionTokenMetrics.js

@@ -0,0 +1,181 @@
+import { builtinDriverIdForAdapter } from "./builtinAgentDrivers.js";
+import { isRuntimeTokenEvidence, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+const UNOBSERVED = Object.freeze({ status: "unobserved" });
+export function resolveSessionTokenIdentity(input) {
+    if (input?.taskId === undefined
+        || input.roleName === undefined
+        || input.agentId === undefined
+        || input.adapterId === undefined
+        || input.launchId === undefined
+        || input.nativeSessionId === undefined)
+        return null;
+    let driverId;
+    try {
+        driverId = builtinDriverIdForAdapter(input.adapterId);
+    }
+    catch {
+        return null;
+    }
+    return Object.freeze({
+        taskId: input.taskId,
+        roleName: input.roleName,
+        agentId: input.agentId,
+        driverId,
+        launchId: input.launchId,
+        nativeSessionId: input.nativeSessionId,
+        sessionGenerationId: input.launchId
+    });
+}
+/**
+ * Read-only projection over canonical runtime observations. Token values never
+ * decide lifecycle, health, scheduling, resource admission, or workflow state.
+ */
+export function projectSessionTokenMetrics(events, identity) {
+    if (identity === null)
+        return unobservedSessionTokenMetrics();
+    const observations = events
+        .map(runtimeObservationFromTaskEvent)
+        .filter((observation) => (observation !== null
+        && isRuntimeTokenEvidence(observation)
+        && matchesSessionGeneration(observation, identity)))
+        .sort(compareObservations);
+    const incompleteBoundaries = observations.filter(({ payload }) => (payload.usage === undefined));
+    const request = observations.filter(({ payload }) => (payload.usage?.semantics === "request-context"));
+    const cumulative = observations.filter(({ payload }) => (payload.usage?.semantics === "cumulative-session"));
+    // A generation cannot switch counter semantics without an explicit fact
+    // explaining how the two streams overlap. Remaining-context is capacity,
+    // not consumption, and is intentionally absent from both metrics.
+    if (request.length > 0 && cumulative.length > 0) {
+        return unobservedSessionTokenMetrics(identity);
+    }
+    if (request.length > 0) {
+        return projectRequestSnapshots(identity, request, incompleteBoundaries.length > 0);
+    }
+    if (cumulative.length > 0) {
+        return projectCumulativeSnapshots(identity, cumulative, incompleteBoundaries.length > 0);
+    }
+    return unobservedSessionTokenMetrics(identity);
+}
+export function unobservedSessionTokenMetrics(identity = null) {
+    return Object.freeze({
+        identity: identity === null ? null : Object.freeze({ ...identity }),
+        cumulativeTotal: UNOBSERVED,
+        maximumRequestInput: UNOBSERVED
+    });
+}
+function projectRequestSnapshots(identity, observations, hasIncompleteBoundary) {
+    if (hasIncompleteBoundary || observations.some(({ payload }) => (payload.observationQuality === "partial"
+        || payload.observationQuality === "unavailable")))
+        return unobservedSessionTokenMetrics(identity);
+    const requests = new Map();
+    for (const observation of observations) {
+        const usage = observation.payload.usage;
+        const requestId = observation.payload.activityId ?? observation.semanticKey;
+        // Structured providers may publish multiple snapshots for one stable
+        // request identity. The latest snapshot supersedes the earlier delivery;
+        // replays with the same identity never become a second request.
+        requests.set(requestId, usage);
+    }
+    const values = [...requests.values()];
+    const inputTokens = safeSum(values.map((usage) => usage.inputTokens));
+    const outputTokens = safeSum(values.map((usage) => usage.outputTokens));
+    if (inputTokens === null || outputTokens === null) {
+        return unobservedSessionTokenMetrics(identity);
+    }
+    const totalTokens = safeAdd(inputTokens, outputTokens);
+    if (totalTokens === null)
+        return unobservedSessionTokenMetrics(identity);
+    const cachedInputTokens = values.every((usage) => usage.cachedInputTokens !== undefined)
+        ? safeSum(values.map((usage) => usage.cachedInputTokens))
+        : null;
+    const reasoningTokens = values.every((usage) => usage.reasoningTokens !== undefined)
+        ? safeSum(values.map((usage) => usage.reasoningTokens))
+        : null;
+    return Object.freeze({
+        identity: Object.freeze({ ...identity }),
+        cumulativeTotal: Object.freeze({
+            status: "observed",
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            ...(cachedInputTokens === null ? {} : { cachedInputTokens }),
+            ...(reasoningTokens === null ? {} : { reasoningTokens })
+        }),
+        maximumRequestInput: Object.freeze({
+            status: "observed",
+            inputTokens: Math.max(...values.map((usage) => usage.inputTokens))
+        })
+    });
+}
+function projectCumulativeSnapshots(identity, observations, hasIncompleteBoundary) {
+    const values = observations.map(({ payload }) => payload.usage);
+    const requestBoundaryIncomplete = hasIncompleteBoundary || observations.some(({ payload }) => (payload.observationQuality === "partial"
+        || payload.observationQuality === "unavailable"));
+    let counterRollback = false;
+    let maximumRequestInput = null;
+    for (let index = 1; index < values.length; index += 1) {
+        const previous = values[index - 1];
+        const current = values[index];
+        if (current.inputTokens < previous.inputTokens
+            || current.outputTokens < previous.outputTokens)
+            counterRollback = true;
+        const requestInput = Math.max(0, current.inputTokens - previous.inputTokens);
+        maximumRequestInput = maximumRequestInput === null
+            ? requestInput
+            : Math.max(maximumRequestInput, requestInput);
+    }
+    const latest = values.at(-1);
+    const totalTokens = safeAdd(latest.inputTokens, latest.outputTokens);
+    const cumulativeTotal = counterRollback || totalTokens === null
+        ? UNOBSERVED
+        : Object.freeze({
+            status: "observed",
+            totalTokens,
+            inputTokens: latest.inputTokens,
+            outputTokens: latest.outputTokens,
+            ...(latest.cachedInputTokens === undefined
+                ? {}
+                : { cachedInputTokens: latest.cachedInputTokens }),
+            ...(latest.reasoningTokens === undefined
+                ? {}
+                : { reasoningTokens: latest.reasoningTokens })
+        });
+    return Object.freeze({
+        identity: Object.freeze({ ...identity }),
+        cumulativeTotal,
+        maximumRequestInput: counterRollback
+            || requestBoundaryIncomplete
+            || maximumRequestInput === null
+            ? UNOBSERVED
+            : Object.freeze({ status: "observed", inputTokens: maximumRequestInput })
+    });
+}
+function matchesSessionGeneration(observation, identity) {
+    const fence = observation.fence;
+    return fence.taskId === identity.taskId
+        && fence.roleName === identity.roleName
+        && fence.agentId === identity.agentId
+        && fence.driverId === identity.driverId
+        && fence.launchId === identity.launchId
+        && fence.nativeSessionId === identity.nativeSessionId
+        && fence.sessionGenerationId === identity.sessionGenerationId;
+}
+function compareObservations(left, right) {
+    return left.receivedAt.localeCompare(right.receivedAt)
+        || (left.sequence ?? -1) - (right.sequence ?? -1)
+        || (left.ordinal ?? -1) - (right.ordinal ?? -1)
+        || left.eventId.localeCompare(right.eventId);
+}
+function safeSum(values) {
+    let total = 0;
+    for (const value of values) {
+        total = safeAdd(total, value) ?? Number.NaN;
+        if (!Number.isSafeInteger(total))
+            return null;
+    }
+    return total;
+}
+function safeAdd(left, right) {
+    const total = left + right;
+    return Number.isSafeInteger(total) && total >= 0 ? total : null;
+}

package/dist/runtime/structuredProviderHost.js

@@ -391,7 +391,13 @@ class ClaudeStructuredProviderSession {
                 waiter.reject(new ProviderDeliveryUnknownError("Claude replayed input for a different native Session.", waiter.attemptId));
                 return;
             }
-            const nativeTurnId = `claude-input:${waiter.attemptId}`;
+            const nativeTurnId = optionalId(message.uuid);
+            if (nativeTurnId === undefined) {
+                clearTimeout(waiter.timer);
+                this.#waiter = undefined;
+                waiter.reject(new ProviderDeliveryUnknownError("Claude replayed input without a native message identity.", waiter.attemptId));
+                return;
+            }
             this.#activeTurnId = nativeTurnId;
             clearTimeout(waiter.timer);
             this.#waiter = undefined;

package/dist/scheduler/activeRoleRunDelivery.js

@@ -4,7 +4,7 @@ import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { prefixYuiTitleInput } from "../run/runIdentity.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
@@ -881,7 +881,7 @@ 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 (!effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)) {
+    if (!effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)) {
         throw new Error(`Role resume effective snapshot drifted: ${role.taskId}/${role.name}.`);
     }
     return session.nativeSessionId;
@@ -948,13 +948,13 @@ function validateRoleSession(role, effective, existing, mode, session) {
         throw new Error(`Ready Role session identity changed: ${role.taskId}/${role.name}.`);
     }
     const compatible = mode === "resume"
-        ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)
+        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)
         : effectiveLaunchSnapshotsCompatible(session.effective, effective);
     if (!compatible) {
         throw new Error(`Ready Role session effective snapshot changed: ${role.taskId}/${role.name}.`);
     }
     if (existing?.nativeSessionId !== undefined
-        && effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, effective, role.managedWorkspace)
+        && effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, effective)
         && session.nativeSessionId !== existing.nativeSessionId) {
         throw new Error(`Ready Role session changed the fixed native session id: ${role.taskId}/${role.name}.`);
     }

package/dist/scheduler/activeTaskProgress.js

@@ -35,8 +35,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             runs: activeRuns,
             pendingWakeup: store.getPendingWakeup(task.id),
             leaderMailbox,
-            leaderFailure: store.getLeaderFailure(task.id),
-            operatorNotification: store.getOperatorNotification(task.id)
+            leaderFailure: store.getLeaderFailure(task.id)
         });
         const queuedAlongsideActiveSibling = hasDispatchableQueuedResourceLane(store, task.id)
             && !activeRuns.some(({ roleName }) => roleName === "leader")
@@ -45,7 +44,6 @@ export function repairOrphanedActiveTasks(store, now, selection) {
         if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
             || store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
-            || store.getOperatorNotification(task.id) !== null
             || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {
             continue;
@@ -121,8 +119,11 @@ function findLastLeaderRun(store, taskId) {
     };
 }
 function hasUnclaimedLeaderWork(store, taskId, leaderMailbox) {
+    if (store.getPendingWakeup(taskId) !== null)
+        return true;
     if (leaderMailbox === null)
-        return store.getPendingWakeup(taskId) !== null;
-    return leaderMailbox?.processing === null
-        && leaderMailbox.pending !== null;
+        return false;
+    return leaderMailbox.processing === null
+        && (leaderMailbox.pending.normal !== null
+            || leaderMailbox.pending.userCorrection !== null);
 }

package/dist/scheduler/leaderWakeupProcessor.js

@@ -3,10 +3,9 @@ import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/r
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { prefixYuiTitleInput } from "../run/runIdentity.js";
 import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
-import { createLeaderRecoveryNotification } from "./operatorNotification.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
@@ -114,7 +113,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const compatibleSession = existingSession !== null
                 && (reopening
                     ? effectiveLaunchSnapshotsCompatible(existingSession.effective, role.effective)
-                    : effectiveLaunchSnapshotsCompatibleForTaskMain(existingSession.effective, role.effective, role.managedWorkspace));
+                    : effectiveLaunchSnapshotsCompatibleForTaskSession(existingSession.effective, role.effective));
             const reopenIdentityDrift = reopening
                 && hasNativeSession(existingSession)
                 && !compatibleSession;
@@ -504,7 +503,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     session: effectiveSession,
                     claimed: { run, wakeup },
                     failure: recordLeaderFailure(task.id, effectiveSession?.nativeSessionId ?? "(unregistered)", message, now, store.getLeaderFailure(task.id)),
-                    notification: createLeaderRecoveryNotification(task.id, message, now, store.getOperatorNotification(task.id)),
                     now
                 });
                 if (failureResult === "state-changed") {
@@ -535,7 +533,7 @@ function validateReadySession(role, effective, existing, mode, session) {
         throw new Error(`Ready session belongs to another Agent: ${session.agentId}.`);
     }
     const compatible = mode === "resume"
-        ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)
+        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)
         : effectiveLaunchSnapshotsCompatible(session.effective, effective);
     if (!compatible) {
         throw new Error("Ready Leader session effective snapshot changed.");

package/dist/scheduler/operatorEvent.js

@@ -0,0 +1,34 @@
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { createTaskEvent } from "../event/taskEvent.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) {
+    enqueueWork(store, { kind: "operator" }, reason, now, [
+        { type: "event", taskId: event.taskId, id: event.id }
+    ], {
+        source: "task-event",
+        dedupeKey: `operator-event:${event.taskId}:${event.id}`,
+        deliveryMode: "followup",
+        lane: "normal"
+    });
+}
+/** Routes one Role fact to its supervisor without exposing Provider details to Operator code. */
+export function routeRoleEvent(store, event, roleName, reason, now) {
+    if (roleName === "leader") {
+        enqueueOperatorEvent(store, event, reason, now);
+        return;
+    }
+    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"
+    });
+}
+/** Records the semantic boundary used when a Leader can no longer continue. */
+export function recordLeaderAttentionRequired(store, input) {
+    const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, LEADER_ATTENTION_REQUIRED_EVENT, { ...(input.payload ?? {}), reason: input.reason }, input.now);
+    store.saveEvent(input.taskId, event);
+    enqueueOperatorEvent(store, event, "leader-attention-required", input.now);
+    return event;
+}

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,4 +1,4 @@
-import { createInputRequestOperatorPresentation, createLeaderRecoveryOperatorPresentation, createLeaderStallOperatorPresentation, createTaskTerminalOperatorPresentation } from "../interaction/operatorPresentation.js";
+import { createOperatorBatchPresentation } 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)
@@ -19,18 +19,18 @@ export async function processOperatorInputNotifications(store, delivery, selecti
     if (claim.status === "empty")
         return [];
     const processing = claim.processing;
-    const requests = processing.batch.refs
-        .flatMap((ref) => ref.type === "input"
-        ? [store.getInputRequest(ref.taskId, ref.id)]
-        : [])
-        .filter((request) => request !== null && request.status === "open")
-        .map((request) => ({ kind: "input", request }));
-    const notifications = processing.batch.refs
-        .filter((ref) => ref.type === "task")
-        .map((ref) => store.getOperatorNotification(ref.id))
-        .filter((notification) => notification !== null)
-        .map((notification) => ({ kind: "notification", notification }));
-    const attentions = deduplicateAttention([...requests, ...notifications]);
+    const attentions = deduplicateAttention(processing.batch.refs.flatMap((ref) => {
+        if (ref.type === "input") {
+            const request = store.getInputRequest(ref.taskId, ref.id);
+            return request !== null && request.status === "open"
+                ? [{ kind: "input", request }]
+                : [];
+        }
+        if (ref.type !== "event" || store.listEvents === undefined)
+            return [];
+        const event = store.listEvents(ref.taskId).find(({ id }) => id === ref.id);
+        return event === undefined ? [] : [{ kind: "event", event }];
+    }));
     if (attentions.length === 0) {
         store.completeWorkMailbox(targetMailbox, processing.batchId);
         return [];
@@ -41,58 +41,35 @@ export async function processOperatorInputNotifications(store, delivery, selecti
         store.releaseWorkMailbox(targetMailbox, processing.batchId);
         return attentions.map((attention) => skipped(attention, reason));
     }
-    const results = [];
-    for (const [index, attention] of attentions.entries()) {
-        try {
-            const presentation = createAttentionPresentation(attention, store);
-            const outcome = await delivery.notifyOperatorInputOnce({
-                ...target,
-                receiptId: presentation.receiptId,
-                text: presentation.text
-            });
-            if (outcome === "unavailable") {
-                store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                results.push(skipped(attention, "operator-unavailable"));
-                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-unavailable"))));
-                break;
-            }
-            else if (outcome === "not-ready") {
-                store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                results.push(skipped(attention, "operator-not-ready"));
-                results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
-                break;
-            }
-            else {
-                results.push({
-                    ...attentionIdentity(attention),
-                    status: outcome
-                });
-                if (outcome === "sent") {
-                    if (index === attentions.length - 1) {
-                        store.completeWorkMailbox(targetMailbox, processing.batchId);
-                    }
-                    else {
-                        store.releaseWorkMailbox(targetMailbox, processing.batchId);
-                    }
-                    results.push(...attentions.slice(index + 1).map((pending) => (skipped(pending, "operator-not-ready"))));
-                    break;
-                }
-            }
-        }
-        catch (error) {
+    try {
+        const presentation = createOperatorBatchPresentation(processing.batchId, attentions.map(toPresentationItem));
+        const outcome = await delivery.notifyOperatorInputOnce({
+            ...target,
+            receiptId: presentation.receiptId,
+            text: presentation.text
+        });
+        if (outcome === "unavailable" || outcome === "not-ready") {
             store.releaseWorkMailbox(targetMailbox, processing.batchId);
-            results.push({
-                ...attentionIdentity(attention),
-                status: "failed",
-                error: error instanceof Error ? error.message : String(error)
-            });
-            break;
+            const reason = outcome === "unavailable" ? "operator-unavailable" : "operator-not-ready";
+            return attentions.map((attention) => skipped(attention, reason));
         }
-    }
-    if (results.length > 0 && results.every((result) => result.status === "already-sent")) {
+        if (outcome === "sent")
+            store.markOperatorTurnStarted(now);
         store.completeWorkMailbox(targetMailbox, processing.batchId);
+        return attentions.map((attention) => ({
+            ...attentionIdentity(attention),
+            status: outcome
+        }));
+    }
+    catch (error) {
+        store.releaseWorkMailbox(targetMailbox, processing.batchId);
+        const detail = error instanceof Error ? error.message : String(error);
+        return attentions.map((attention) => ({
+            ...attentionIdentity(attention),
+            status: "failed",
+            error: detail
+        }));
     }
-    return results;
 }
 function skipped(attention, reason) {
     return {
@@ -102,45 +79,28 @@ function skipped(attention, reason) {
     };
 }
 function attentionIdentity(attention) {
-    if (attention.kind === "input") {
-        return { inputRequestId: attention.request.id, taskId: attention.request.taskId };
-    }
-    if (attention.notification.type === "leader-recovery-failed") {
-        return {
-            recoveryTaskId: attention.notification.taskId,
-            taskId: attention.notification.taskId
-        };
-    }
-    if (attention.notification.type === "leader-stalled") {
-        return {
-            stallTaskId: attention.notification.taskId,
-            taskId: attention.notification.taskId
+    return attention.kind === "input"
+        ? {
+            sourceKind: "input",
+            sourceId: attention.request.id,
+            taskId: attention.request.taskId
+        }
+        : {
+            sourceKind: "event",
+            sourceId: attention.event.id,
+            taskId: attention.event.taskId
         };
-    }
-    return {
-        terminalTaskId: attention.notification.taskId,
-        taskId: attention.notification.taskId
-    };
 }
-function createAttentionPresentation(attention, store) {
-    if (attention.kind === "input") {
-        return createInputRequestOperatorPresentation(attention.request, store.getPresentationContext());
-    }
-    if (attention.notification.type === "leader-recovery-failed") {
-        return createLeaderRecoveryOperatorPresentation(attention.notification);
-    }
-    return attention.notification.type === "leader-stalled"
-        ? createLeaderStallOperatorPresentation(attention.notification)
-        : createTaskTerminalOperatorPresentation(attention.notification);
+function toPresentationItem(attention) {
+    return attention.kind === "input"
+        ? { kind: "input-request", request: attention.request }
+        : { kind: "task-event", event: attention.event };
 }
 function deduplicateAttention(attentions) {
     const seen = new Set();
     return attentions.filter((attention) => {
-        const key = attention.kind === "input"
-            ? `input:${attention.request.taskId}:${attention.request.id}`
-            : attention.notification.type === "leader-stalled"
-                ? `stall:${attention.notification.taskId}:${attention.notification.runId}:${attention.notification.progressAt}`
-                : `recovery:${attention.notification.taskId}:${attention.notification.createdAt}`;
+        const identity = attentionIdentity(attention);
+        const key = `${identity.sourceKind}:${identity.taskId}:${identity.sourceId}`;
         if (seen.has(key))
             return false;
         seen.add(key);