@zq-silk/yui 0.6.2 → 0.6.3

package/dist/controller/runtimeEventProcessor.js

@@ -1,13 +1,16 @@
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 const DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN = 64;
 /** Folds immutable Hook facts in one bounded transaction before acknowledging them. */
 export class FileRuntimeEventProcessor {
     inbox;
     observer;
     options;
+    drivers;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
         this.options = options;
+        this.drivers = options.drivers ?? builtinAgentDriverRegistry();
     }
     drain(now) {
         const acknowledgedEventIds = [];
@@ -58,11 +61,11 @@ export class FileRuntimeEventProcessor {
                 }
             }
         }
-        const progressEventsSelected = selected.filter(({ event }) => (event.type === "native-turn-progress")).length;
+        const progressEventsSelected = selected.filter(({ event }) => (isRuntimeActivityEvent(event))).length;
         const representedEventCount = selected.reduce((count, candidate) => (count + candidate.representedEventIds.length), 0);
         const acknowledged = new Set(acknowledgedEventIds);
         const remaining = events.filter(({ id }) => !acknowledged.has(id));
-        const remainingProgressEventCount = remaining.filter(({ type }) => (type === "native-turn-progress")).length;
+        const remainingProgressEventCount = remaining.filter(isRuntimeActivityEvent).length;
         return {
             acknowledgedEventIds,
             deferred,
@@ -86,33 +89,34 @@ export class FileRuntimeEventProcessor {
         if (event.type === "native-turn-completed") {
             outcome = this.applyCodex(event, now);
         }
-        else if (event.type === "claude-stop-failure") {
-            this.applyClaudeStopFailure(event, now);
+        else if (event.type === "runtime-observation") {
+            outcome = this.applyRuntimeObservation(event, now);
         }
-        else if (event.type === "native-session-lifecycle") {
-            outcome = this.applySessionLifecycle(event, now);
-        }
-        else if (event.type === "native-turn-progress") {
-            outcome = this.applyProviderTurnProgress(event, now);
-        }
-        else if (event.type === "durable-job-terminal") {
+        else {
             // f7/rr5: The supervisor already transitioned the job and
             // enqueued the Leader wakeup. This event is the durable terminal
             // channel: acknowledge it so the Controller's event pipeline
             // converges without re-processing. No state change to apply.
             this.applyDurableJobTerminal(event);
         }
-        else {
-            outcome = this.applyPromptAccepted(event, now);
-        }
         return {
             candidate,
             outcome,
-            notifyTaskRuntime: outcome === "applied" && (event.type === "native-session-lifecycle"
-                || event.type === "native-prompt-accepted"
+            notifyTaskRuntime: outcome === "applied" && ((event.type === "runtime-observation" && event.scope === "task"
+                && ["session.started", "session.ready", "turn.accepted", "turn.completed"]
+                    .includes(event.observation.kind))
                 || (event.type === "native-turn-completed" && event.scope === "task"))
         };
     }
+    applyRuntimeObservation(event, now) {
+        const taskId = event.observation.fence.taskId;
+        if (taskId !== undefined) {
+            const task = this.observer.getTask(taskId);
+            if (task === null || task.status !== "active")
+                return "obsolete";
+        }
+        return this.observer.observeRuntimeObservation?.(event.observation, now) ?? "obsolete";
+    }
     finalizeOne(folded, acknowledged, deferred, failed) {
         const { candidate, outcome } = folded;
         try {
@@ -123,16 +127,34 @@ export class FileRuntimeEventProcessor {
             }
             if (folded.notifyTaskRuntime) {
                 const event = candidate.event;
-                if (event.scope === "task" && event.taskId !== undefined && event.type !== "durable-job-terminal") {
-                    this.options.onTaskRuntimeApplied?.({
-                        taskId: event.taskId,
-                        roleName: event.roleName,
-                        agentId: event.agentId,
-                        adapterId: event.adapterId,
-                        ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
-                        nativeSessionId: event.nativeSessionId,
-                        ...(event.runId === undefined ? {} : { runId: event.runId })
-                    });
+                if (event.scope === "task"
+                    && event.taskId !== undefined
+                    && event.type !== "durable-job-terminal") {
+                    if (event.type === "runtime-observation") {
+                        const fence = event.observation.fence;
+                        if (fence.taskId !== undefined && fence.nativeSessionId !== undefined) {
+                            this.options.onTaskRuntimeApplied?.({
+                                taskId: fence.taskId,
+                                roleName: fence.roleName,
+                                agentId: fence.agentId,
+                                adapterId: this.drivers.require(fence.driverId).adapterId,
+                                launchId: fence.launchId,
+                                nativeSessionId: fence.nativeSessionId,
+                                ...(fence.runId === undefined ? {} : { runId: fence.runId })
+                            });
+                        }
+                    }
+                    else if (event.type === "native-turn-completed") {
+                        this.options.onTaskRuntimeApplied?.({
+                            taskId: event.taskId,
+                            roleName: event.roleName,
+                            agentId: event.agentId,
+                            adapterId: event.adapterId,
+                            ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+                            nativeSessionId: event.nativeSessionId,
+                            ...(event.runId === undefined ? {} : { runId: event.runId })
+                        });
+                    }
                 }
             }
             this.acknowledge(candidate.representedEventIds, acknowledged);
@@ -141,44 +163,6 @@ export class FileRuntimeEventProcessor {
             failed.push({ eventId: candidate.event.id, error });
         }
     }
-    applySessionLifecycle(event, now) {
-        const task = this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderSessionLifecycle === undefined)
-            return "obsolete";
-        const outcome = this.observer.observeProviderSessionLifecycle({
-            eventId: event.id,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            ...(event.runId === undefined ? {} : { runId: event.runId }),
-            ...(event.sessionSource === undefined ? {} : { sessionSource: event.sessionSource })
-        }, now);
-        return outcome === "deferred" ? "deferred" : outcome;
-    }
-    applyPromptAccepted(event, now) {
-        const task = this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderPromptAccepted === undefined)
-            return "obsolete";
-        const outcome = this.observer.observeProviderPromptAccepted({
-            eventId: event.id,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            receiptId: event.receiptId
-        }, now);
-        return outcome === "deferred" ? "deferred" : outcome;
-    }
     /**
      * f7/rr5: Acknowledge a durable-job-terminal event. The supervisor
      * already committed the terminal transition and the Leader wakeup;
@@ -190,27 +174,6 @@ export class FileRuntimeEventProcessor {
         // transaction as the terminal transition.
         void event;
     }
-    applyProviderTurnProgress(event, now) {
-        const task = this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderTurnProgress === undefined)
-            return "obsolete";
-        const outcome = this.observer.observeProviderTurnProgress({
-            eventId: event.id,
-            receivedAt: event.receivedAt,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            progressId: event.progressId,
-            ...(event.sequence === undefined ? {} : { sequence: event.sequence })
-        }, now);
-        return outcome === "deferred" ? "deferred" : "applied";
-    }
     applyCodex(event, now) {
         if (event.scope === "task") {
             const task = this.observer.getTask(event.taskId);
@@ -263,43 +226,26 @@ export class FileRuntimeEventProcessor {
         }
         return "obsolete";
     }
-    applyClaudeStopFailure(event, now) {
-        const task = this.observer.getTask(event.taskId);
-        if (task === null)
-            return;
-        const input = {
-            eventId: event.id,
-            type: event.type,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            error: event.error,
-            ...(event.errorDetails === undefined ? {} : { errorDetails: event.errorDetails }),
-            ...(event.lastAssistantMessage === undefined
-                ? {}
-                : { lastAssistantMessage: event.lastAssistantMessage })
-        };
-        if (task.status !== "active"
-            || this.observer.classifyClaudeStopFailureEvent?.(input) === "obsolete") {
-            this.recordObsolete(event, task.status === "archived"
-                ? "task-archived"
-                : task.status !== "active"
-                    ? "task-retired"
-                    : "identity-mismatch-or-terminal", now);
-            return;
-        }
-        if (this.observer.observeClaudeStopFailureEvent === undefined) {
-            throw new Error("Claude StopFailure observer is unavailable.");
-        }
-        this.observer.observeClaudeStopFailureEvent(input, now);
-    }
     recordObsolete(event, reason, now) {
         if (event.scope !== "task" || event.taskId === undefined)
             return;
+        if (event.type === "runtime-observation") {
+            const fence = event.observation.fence;
+            if (fence.nativeSessionId === undefined)
+                return;
+            this.observer.observeObsoleteRuntimeEvent?.({
+                eventId: event.id,
+                eventType: event.type,
+                taskId: event.taskId,
+                roleName: fence.roleName,
+                agentId: fence.agentId,
+                ...(fence.runId === undefined ? {} : { runId: fence.runId }),
+                launchId: fence.launchId,
+                nativeSessionId: fence.nativeSessionId,
+                reason
+            }, now);
+            return;
+        }
         // durable-job-terminal events have no provider identity; they are never
         // recorded as obsolete.
         if (!("roleName" in event) || !("nativeSessionId" in event))
@@ -333,51 +279,38 @@ export function coalesceRuntimeProgress(events, instrumentation = {}) {
     const flush = () => {
         if (segment.length === 0)
             return;
-        const frontiers = new Map();
+        const indicesByStream = new Map();
         for (let index = 0; index < segment.length; index += 1) {
             instrumentation.onProgressVisit?.();
             const event = segment[index];
             const key = progressStreamKey(event);
-            const frontier = frontiers.get(key);
-            if (frontier === undefined || event.receivedAt > frontier.latestReceivedAt) {
-                frontiers.set(key, {
-                    latestReceivedAt: event.receivedAt,
-                    ...(event.sequence === undefined
-                        ? {}
-                        : {
-                            greatestSequence: event.sequence,
-                            firstGreatestSequenceIndex: index
-                        }),
-                    firstLatestIndex: index
-                });
-            }
-            else if (event.receivedAt === frontier.latestReceivedAt
-                && event.sequence !== undefined
-                && (frontier.greatestSequence === undefined
-                    || event.sequence > frontier.greatestSequence)) {
-                frontiers.set(key, {
-                    ...frontier,
-                    greatestSequence: event.sequence,
-                    firstGreatestSequenceIndex: index
-                });
-            }
+            const indices = indicesByStream.get(key) ?? [];
+            indices.push(index);
+            indicesByStream.set(key, indices);
         }
         const representedByIndex = new Map();
-        for (let index = 0; index < segment.length; index += 1) {
-            instrumentation.onProgressVisit?.();
-            const event = segment[index];
-            const frontier = frontiers.get(progressStreamKey(event));
-            const strictlyDominated = event.receivedAt < frontier.latestReceivedAt
-                || (event.receivedAt === frontier.latestReceivedAt
-                    && event.sequence !== undefined
-                    && frontier.greatestSequence !== undefined
-                    && event.sequence < frontier.greatestSequence);
-            const representativeIndex = strictlyDominated
-                ? frontier.firstGreatestSequenceIndex ?? frontier.firstLatestIndex
-                : index;
-            const represented = representedByIndex.get(representativeIndex) ?? [];
-            represented.push(event.id);
-            representedByIndex.set(representativeIndex, represented);
+        for (const indices of indicesByStream.values()) {
+            const hasUsage = segment[indices[0]].observation.payload.usage !== undefined;
+            const retainedPositions = hasUsage ? [0] : [];
+            if (hasUsage) {
+                for (let position = 1; position < indices.length; position += 1) {
+                    const previous = segment[indices[position - 1]].observation.payload.usage;
+                    const current = segment[indices[position]].observation.payload.usage;
+                    if (runtimeUsageTotal(current) < runtimeUsageTotal(previous)) {
+                        retainedPositions.push(position);
+                    }
+                }
+            }
+            const lastPosition = indices.length - 1;
+            if (retainedPositions.at(-1) !== lastPosition)
+                retainedPositions.push(lastPosition);
+            let previousRetainedPosition = -1;
+            for (const retainedPosition of retainedPositions) {
+                const retainedIndex = indices[retainedPosition];
+                representedByIndex.set(retainedIndex, indices.slice(previousRetainedPosition + 1, retainedPosition + 1)
+                    .map((index) => segment[index].id));
+                previousRetainedPosition = retainedPosition;
+            }
         }
         for (let index = 0; index < segment.length; index += 1) {
             const representedEventIds = representedByIndex.get(index);
@@ -388,7 +321,7 @@ export function coalesceRuntimeProgress(events, instrumentation = {}) {
         segment = [];
     };
     for (const event of events) {
-        if (event.type !== "native-turn-progress") {
+        if (!isRuntimeActivityEvent(event)) {
             flush();
             result.push({ event, representedEventIds: [event.id] });
             continue;
@@ -399,22 +332,32 @@ export function coalesceRuntimeProgress(events, instrumentation = {}) {
     return result;
 }
 function selectDrainBatch(events, maximum) {
-    // A batch is always an arrival-order prefix. Admission and drain coalescing
-    // keep a progress flood bounded without allowing a later semantic fact to
+    // A batch is always an arrival-order prefix. Drain-time coalescing bounds
+    // worker folds without allowing a later semantic fact to
     // overtake an earlier progress fence from another Run.
     return events.slice(0, maximum);
 }
 function progressStreamKey(event) {
+    const { fence, payload } = event.observation;
     return JSON.stringify([
-        event.taskId,
-        event.roleName,
-        event.agentId,
-        event.adapterId,
-        event.launchId,
-        event.nativeSessionId,
-        event.runId
+        fence.taskId ?? null,
+        fence.roleName,
+        fence.agentId,
+        fence.driverId,
+        fence.launchId,
+        fence.nativeSessionId ?? null,
+        fence.runId ?? null,
+        payload.activity,
+        payload.usage === undefined ? "signal" : "usage"
     ]);
 }
+function runtimeUsageTotal(usage) {
+    return usage.inputTokens + usage.outputTokens;
+}
+function isRuntimeActivityEvent(event) {
+    return event.type === "runtime-observation"
+        && event.observation.kind === "activity.observed";
+}
 function emptyDrainFailure(error) {
     return {
         acknowledgedEventIds: [],
@@ -456,13 +399,10 @@ export function createAsyncRuntimeObserver(invoke) {
     const withNow = (method, input, now) => now === undefined ? call(method, [input]) : call(method, [input, now]);
     return {
         getTask: (taskId) => call("getTask", [taskId]),
+        observeRuntimeObservation: (input, now) => withNow("observeRuntimeObservation", input, now),
         observeRuntimeTurnCompleted: (input, now) => withNow("observeRuntimeTurnCompleted", input, now),
         observeGlobalRuntimeTurnCompleted: (input, now) => withNow("observeGlobalRuntimeTurnCompleted", input, now),
-        observeClaudeStopFailureEvent: (input, now) => withNow("observeClaudeStopFailureEvent", input, now),
-        observeObsoleteRuntimeEvent: (input, now) => withNow("observeObsoleteRuntimeEvent", input, now),
-        observeProviderSessionLifecycle: (input, now) => withNow("observeProviderSessionLifecycle", input, now),
-        observeProviderPromptAccepted: (input, now) => withNow("observeProviderPromptAccepted", input, now),
-        observeProviderTurnProgress: (input, now) => withNow("observeProviderTurnProgress", input, now)
+        observeObsoleteRuntimeEvent: (input, now) => withNow("observeObsoleteRuntimeEvent", input, now)
     };
 }
 /**
@@ -475,10 +415,12 @@ export class AsyncRuntimeEventProcessor {
     inbox;
     observer;
     options;
+    drivers;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
         this.options = options;
+        this.drivers = options.drivers ?? builtinAgentDriverRegistry();
     }
     async drainAsync(now) {
         const acknowledgedEventIds = [];
@@ -491,46 +433,31 @@ export class AsyncRuntimeEventProcessor {
         catch (error) {
             return emptyDrainFailure(error);
         }
-        for (const event of events) {
+        const coalesced = coalesceRuntimeProgress(events);
+        const maximum = positiveInteger(this.options.maxEventsPerDrain, DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN);
+        const selected = selectDrainBatch(coalesced, maximum);
+        for (const candidate of selected) {
+            const event = candidate.event;
             try {
+                let outcome = "applied";
                 if (event.type === "native-turn-completed") {
-                    const outcome = await this.applyCodex(event, now);
-                    if (outcome === "deferred") {
-                        deferred.push(event);
-                        continue;
-                    }
+                    outcome = await this.applyCodex(event, now);
                 }
-                else if (event.type === "claude-stop-failure") {
-                    await this.applyClaudeStopFailure(event, now);
-                }
-                else if (event.type === "native-session-lifecycle") {
-                    const outcome = await this.applySessionLifecycle(event, now);
-                    if (outcome === "deferred") {
-                        deferred.push(event);
-                        continue;
-                    }
-                }
-                else if (event.type === "native-turn-progress") {
-                    const outcome = await this.applyProviderTurnProgress(event, now);
-                    if (outcome === "deferred") {
-                        deferred.push(event);
-                        continue;
-                    }
+                else if (event.type === "runtime-observation") {
+                    outcome = await this.applyRuntimeObservation(event, now);
                 }
-                else if (event.type === "durable-job-terminal") {
+                else {
                     // f7/rr5: The supervisor already transitioned the job and
                     // enqueued the Leader wakeup. This event is the durable terminal
                     // channel: acknowledge it so the pipeline converges without
                     // re-processing. No state change to apply.
                 }
-                else {
-                    const outcome = await this.applyPromptAccepted(event, now);
-                    if (outcome === "deferred") {
-                        deferred.push(event);
-                        continue;
-                    }
+                if (outcome === "deferred") {
+                    deferred.push(event);
+                    this.acknowledge(candidate.representedEventIds.filter((id) => id !== event.id), acknowledgedEventIds);
+                    continue;
                 }
-                this.acknowledge(event.id, acknowledgedEventIds);
+                this.acknowledge(candidate.representedEventIds, acknowledgedEventIds);
             }
             catch (error) {
                 failed.push({ eventId: event.id, error });
@@ -538,8 +465,9 @@ export class AsyncRuntimeEventProcessor {
         }
         const acknowledged = new Set(acknowledgedEventIds);
         const remaining = events.filter(({ id }) => !acknowledged.has(id));
-        const progressEventsSelected = events.filter(({ type }) => (type === "native-turn-progress")).length;
-        const remainingProgressEventCount = remaining.filter(({ type }) => (type === "native-turn-progress")).length;
+        const progressEventsSelected = selected.filter(({ event }) => (isRuntimeActivityEvent(event))).length;
+        const representedEventCount = selected.reduce((count, candidate) => (count + candidate.representedEventIds.length), 0);
+        const remainingProgressEventCount = remaining.filter(isRuntimeActivityEvent).length;
         return {
             acknowledgedEventIds,
             deferred,
@@ -547,96 +475,42 @@ export class AsyncRuntimeEventProcessor {
             remainingEventCount: remaining.length,
             metrics: {
                 listedEventCount: events.length,
-                selectedEventCount: events.length,
-                semanticEventsSelected: events.length - progressEventsSelected,
+                selectedEventCount: selected.length,
+                semanticEventsSelected: selected.length - progressEventsSelected,
                 progressEventsSelected,
-                progressEventsCoalesced: 0,
+                progressEventsCoalesced: representedEventCount - selected.length,
                 stateTransactions: 0,
                 remainingSemanticEventCount: remaining.length - remainingProgressEventCount,
                 remainingProgressEventCount
             }
         };
     }
-    async applySessionLifecycle(event, now) {
-        const task = await this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderSessionLifecycle === undefined)
-            return "obsolete";
-        const outcome = await this.observer.observeProviderSessionLifecycle({
-            eventId: event.id,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            ...(event.runId === undefined ? {} : { runId: event.runId }),
-            ...(event.sessionSource === undefined ? {} : { sessionSource: event.sessionSource })
-        }, now);
-        if (outcome === "applied") {
-            this.options.onTaskRuntimeApplied?.({
-                taskId: event.taskId,
-                roleName: event.roleName,
-                agentId: event.agentId,
-                adapterId: event.adapterId,
-                launchId: event.launchId,
-                nativeSessionId: event.nativeSessionId,
-                ...(event.runId === undefined ? {} : { runId: event.runId })
-            });
+    async applyRuntimeObservation(event, now) {
+        const taskId = event.observation.fence.taskId;
+        if (taskId !== undefined) {
+            const task = await this.observer.getTask(taskId);
+            if (task === null || task.status !== "active")
+                return "obsolete";
         }
-        return outcome === "deferred" ? "deferred" : outcome;
-    }
-    async applyPromptAccepted(event, now) {
-        const task = await this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderPromptAccepted === undefined)
-            return "obsolete";
-        const outcome = await this.observer.observeProviderPromptAccepted({
-            eventId: event.id,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            receiptId: event.receiptId
-        }, now);
-        if (outcome === "applied") {
+        const outcome = (await this.observer.observeRuntimeObservation?.(event.observation, now))
+            ?? "obsolete";
+        const fence = event.observation.fence;
+        if (outcome === "applied"
+            && fence.taskId !== undefined
+            && fence.nativeSessionId !== undefined
+            && ["session.started", "session.ready", "turn.accepted", "turn.completed"]
+                .includes(event.observation.kind)) {
             this.options.onTaskRuntimeApplied?.({
-                taskId: event.taskId,
-                roleName: event.roleName,
-                agentId: event.agentId,
-                adapterId: event.adapterId,
-                launchId: event.launchId,
-                nativeSessionId: event.nativeSessionId,
-                runId: event.runId
+                taskId: fence.taskId,
+                roleName: fence.roleName,
+                agentId: fence.agentId,
+                adapterId: this.drivers.require(fence.driverId).adapterId,
+                launchId: fence.launchId,
+                nativeSessionId: fence.nativeSessionId,
+                ...(fence.runId === undefined ? {} : { runId: fence.runId })
             });
         }
-        return outcome === "deferred" ? "deferred" : outcome;
-    }
-    async applyProviderTurnProgress(event, now) {
-        const task = await this.observer.getTask(event.taskId);
-        if (task === null || task.status !== "active")
-            return "obsolete";
-        if (this.observer.observeProviderTurnProgress === undefined)
-            return "obsolete";
-        const outcome = await this.observer.observeProviderTurnProgress({
-            eventId: event.id,
-            receivedAt: event.receivedAt,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            progressId: event.progressId,
-            ...(event.sequence === undefined ? {} : { sequence: event.sequence })
-        }, now);
-        return outcome === "deferred" ? "deferred" : "applied";
+        return outcome;
     }
     async applyCodex(event, now) {
         if (event.scope === "task") {
@@ -699,43 +573,26 @@ export class AsyncRuntimeEventProcessor {
         }
         return "obsolete";
     }
-    async applyClaudeStopFailure(event, now) {
-        const task = await this.observer.getTask(event.taskId);
-        if (task === null)
-            return;
-        const input = {
-            eventId: event.id,
-            type: event.type,
-            taskId: event.taskId,
-            roleName: event.roleName,
-            agentId: event.agentId,
-            adapterId: event.adapterId,
-            launchId: event.launchId,
-            nativeSessionId: event.nativeSessionId,
-            runId: event.runId,
-            error: event.error,
-            ...(event.errorDetails === undefined ? {} : { errorDetails: event.errorDetails }),
-            ...(event.lastAssistantMessage === undefined
-                ? {}
-                : { lastAssistantMessage: event.lastAssistantMessage })
-        };
-        if (task.status !== "active"
-            || (await this.observer.classifyClaudeStopFailureEvent?.(input)) === "obsolete") {
-            await this.recordObsolete(event, task.status === "archived"
-                ? "task-archived"
-                : task.status !== "active"
-                    ? "task-retired"
-                    : "identity-mismatch-or-terminal", now);
-            return;
-        }
-        if (this.observer.observeClaudeStopFailureEvent === undefined) {
-            throw new Error("Claude StopFailure observer is unavailable.");
-        }
-        await this.observer.observeClaudeStopFailureEvent(input, now);
-    }
     async recordObsolete(event, reason, now) {
         if (event.scope !== "task" || event.taskId === undefined || event.type === "durable-job-terminal")
             return;
+        if (event.type === "runtime-observation") {
+            const fence = event.observation.fence;
+            if (fence.nativeSessionId === undefined)
+                return;
+            await this.observer.observeObsoleteRuntimeEvent?.({
+                eventId: event.id,
+                eventType: event.type,
+                taskId: event.taskId,
+                roleName: fence.roleName,
+                agentId: fence.agentId,
+                ...(fence.runId === undefined ? {} : { runId: fence.runId }),
+                launchId: fence.launchId,
+                nativeSessionId: fence.nativeSessionId,
+                reason
+            }, now);
+            return;
+        }
         await this.observer.observeObsoleteRuntimeEvent?.({
             eventId: event.id,
             eventType: event.type,
@@ -748,8 +605,14 @@ export class AsyncRuntimeEventProcessor {
             reason
         }, now);
     }
-    acknowledge(id, acknowledged) {
-        this.inbox.acknowledge(id);
-        acknowledged.push(id);
+    acknowledge(ids, acknowledged) {
+        if (this.inbox.acknowledgeMany !== undefined) {
+            acknowledged.push(...this.inbox.acknowledgeMany(ids));
+            return;
+        }
+        for (const id of ids) {
+            if (this.inbox.acknowledge(id))
+                acknowledged.push(id);
+        }
     }
 }