@zq-silk/yui 0.5.3 → 0.6.1

package/dist/controller/runtimeEventProcessor.js

@@ -1,4 +1,5 @@
-/** Folds immutable Hook facts one at a time before acknowledging them. */
+const DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN = 64;
+/** Folds immutable Hook facts in one bounded transaction before acknowledging them. */
 export class FileRuntimeEventProcessor {
     inbox;
     observer;
@@ -17,36 +18,513 @@ export class FileRuntimeEventProcessor {
             events = this.inbox.list();
         }
         catch (error) {
-            return { acknowledgedEventIds, deferred, failed: [{ error }] };
+            return emptyDrainFailure(error);
+        }
+        const coalesced = coalesceRuntimeProgress(events);
+        const maximum = positiveInteger(this.options.maxEventsPerDrain, DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN);
+        const selected = selectDrainBatch(coalesced, maximum);
+        let stateTransactions = 0;
+        if (selected.length > 0 && this.observer.withRuntimeEventTransaction !== undefined) {
+            try {
+                stateTransactions += 1;
+                const folded = this.observer.withRuntimeEventTransaction(() => (selected.map((candidate) => this.foldOne(candidate, now))));
+                for (const result of folded) {
+                    this.finalizeOne(result, acknowledgedEventIds, deferred, failed);
+                }
+            }
+            catch {
+                // A failed aggregate transaction commits nothing. Retry each candidate
+                // independently so one bad event cannot strand unrelated facts.
+                for (const candidate of selected) {
+                    try {
+                        stateTransactions += 1;
+                        const folded = this.observer.withRuntimeEventTransaction(() => (this.foldOne(candidate, now)));
+                        this.finalizeOne(folded, acknowledgedEventIds, deferred, failed);
+                    }
+                    catch (candidateError) {
+                        failed.push({ eventId: candidate.event.id, error: candidateError });
+                    }
+                }
+            }
+        }
+        else {
+            for (const candidate of selected) {
+                try {
+                    const folded = this.foldOne(candidate, now);
+                    this.finalizeOne(folded, acknowledgedEventIds, deferred, failed);
+                }
+                catch (error) {
+                    failed.push({ eventId: candidate.event.id, error });
+                }
+            }
+        }
+        const progressEventsSelected = selected.filter(({ event }) => (event.type === "native-turn-progress")).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;
+        return {
+            acknowledgedEventIds,
+            deferred,
+            failed,
+            remainingEventCount: Math.max(0, events.length - acknowledgedEventIds.length),
+            metrics: {
+                listedEventCount: events.length,
+                selectedEventCount: selected.length,
+                semanticEventsSelected: selected.length - progressEventsSelected,
+                progressEventsSelected,
+                progressEventsCoalesced: representedEventCount - selected.length,
+                stateTransactions,
+                remainingSemanticEventCount: remaining.length - remainingProgressEventCount,
+                remainingProgressEventCount
+            }
+        };
+    }
+    foldOne(candidate, now) {
+        const event = candidate.event;
+        let outcome = "applied";
+        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 === "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") {
+            // 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"
+                || (event.type === "native-turn-completed" && event.scope === "task"))
+        };
+    }
+    finalizeOne(folded, acknowledged, deferred, failed) {
+        const { candidate, outcome } = folded;
+        try {
+            if (outcome === "deferred") {
+                deferred.push(candidate.event);
+                this.acknowledge(candidate.representedEventIds.filter((id) => id !== candidate.event.id), acknowledged);
+                return;
+            }
+            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 })
+                    });
+                }
+            }
+            this.acknowledge(candidate.representedEventIds, acknowledged);
+        }
+        catch (error) {
+            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;
+     * this event only needs to be acknowledged so it leaves the inbox.
+     */
+    applyDurableJobTerminal(event) {
+        // The event is a notification of a committed state change. No observer
+        // call is needed — the Leader wakeup was enqueued in the same
+        // 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);
+            const input = {
+                eventId: event.id,
+                taskId: event.taskId,
+                roleName: event.roleName,
+                agentId: event.agentId,
+                adapterId: event.adapterId,
+                ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+                nativeSessionId: event.nativeSessionId,
+                turnId: event.turnId,
+                ...(event.runId === undefined ? {} : { runId: event.runId }),
+                summary: event.summary
+            };
+            if (task === null)
+                return "obsolete";
+            if (task.status !== "active") {
+                this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
+                return "obsolete";
+            }
+            const disposition = this.observer.classifyRuntimeTurnCompleted?.(input) ?? "apply";
+            if (disposition === "deferred")
+                return disposition;
+            if (disposition === "obsolete") {
+                this.recordObsolete(event, "identity-mismatch-or-terminal", now);
+                return disposition;
+            }
+            const observed = this.observer.observeRuntimeTurnCompleted(input, now);
+            if (isObsoleteRuntimeTurnObservation(observed)) {
+                this.recordObsolete(event, "runtime-cleanup-or-stopped-session", now);
+                return "obsolete";
+            }
+            return "applied";
+        }
+        const input = {
+            eventId: event.id,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            adapterId: event.adapterId,
+            ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+            nativeSessionId: event.nativeSessionId,
+            turnId: event.turnId,
+            ...(event.title === undefined ? {} : { title: event.title }),
+            summary: event.summary
+        };
+        if (this.observer.classifyGlobalRuntimeTurnCompleted?.(input) !== "obsolete") {
+            this.observer.observeGlobalRuntimeTurnCompleted(input, now);
+            return "applied";
+        }
+        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;
+        // durable-job-terminal events have no provider identity; they are never
+        // recorded as obsolete.
+        if (!("roleName" in event) || !("nativeSessionId" in event))
+            return;
+        this.observer.observeObsoleteRuntimeEvent?.({
+            eventId: event.id,
+            eventType: event.type,
+            taskId: event.taskId,
+            roleName: event.roleName,
+            agentId: event.agentId,
+            ...(event.runId === undefined ? {} : { runId: event.runId }),
+            ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+            nativeSessionId: event.nativeSessionId,
+            reason
+        }, now);
+    }
+    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);
+        }
+    }
+}
+export function coalesceRuntimeProgress(events, instrumentation = {}) {
+    const result = [];
+    let segment = [];
+    const flush = () => {
+        if (segment.length === 0)
+            return;
+        const frontiers = 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 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 (let index = 0; index < segment.length; index += 1) {
+            const representedEventIds = representedByIndex.get(index);
+            if (representedEventIds === undefined)
+                continue;
+            result.push({ event: segment[index], representedEventIds });
+        }
+        segment = [];
+    };
+    for (const event of events) {
+        if (event.type !== "native-turn-progress") {
+            flush();
+            result.push({ event, representedEventIds: [event.id] });
+            continue;
+        }
+        segment.push(event);
+    }
+    flush();
+    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
+    // overtake an earlier progress fence from another Run.
+    return events.slice(0, maximum);
+}
+function progressStreamKey(event) {
+    return JSON.stringify([
+        event.taskId,
+        event.roleName,
+        event.agentId,
+        event.adapterId,
+        event.launchId,
+        event.nativeSessionId,
+        event.runId
+    ]);
+}
+function emptyDrainFailure(error) {
+    return {
+        acknowledgedEventIds: [],
+        deferred: [],
+        failed: [{ error }],
+        remainingEventCount: 0,
+        metrics: {
+            listedEventCount: 0,
+            selectedEventCount: 0,
+            semanticEventsSelected: 0,
+            progressEventsSelected: 0,
+            progressEventsCoalesced: 0,
+            stateTransactions: 0,
+            remainingSemanticEventCount: 0,
+            remainingProgressEventCount: 0
+        }
+    };
+}
+function positiveInteger(value, fallback) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new TypeError("Runtime event drain limit must be a positive integer.");
+    }
+    return resolved;
+}
+function isObsoleteRuntimeTurnObservation(value) {
+    return typeof value === "object"
+        && value !== null
+        && value.disposition === "obsolete";
+}
+/**
+ * Build an {@link AsyncRuntimeTurnEventObserver} that forwards every fold to the
+ * worker-hosted adapter via {@link AsyncObserverInvoker}. The adapter's fold
+ * logic (read-then-write transactions) runs in the worker, off the main event
+ * loop; the main thread only awaits the result.
+ */
+export function createAsyncRuntimeObserver(invoke) {
+    const call = (method, args) => invoke(method, args);
+    const withNow = (method, input, now) => now === undefined ? call(method, [input]) : call(method, [input, now]);
+    return {
+        getTask: (taskId) => call("getTask", [taskId]),
+        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)
+    };
+}
+/**
+ * The async counterpart to {@link FileRuntimeEventProcessor}: folds immutable
+ * Hook facts one at a time (awaiting the worker-hosted observer) before
+ * acknowledging them. The inbox itself is file-based and stays on the main
+ * thread; only the db-touching folds are proxied to the worker.
+ */
+export class AsyncRuntimeEventProcessor {
+    inbox;
+    observer;
+    options;
+    constructor(inbox, observer, options = {}) {
+        this.inbox = inbox;
+        this.observer = observer;
+        this.options = options;
+    }
+    async drainAsync(now) {
+        const acknowledgedEventIds = [];
+        const deferred = [];
+        const failed = [];
+        let events;
+        try {
+            events = this.inbox.list();
+        }
+        catch (error) {
+            return emptyDrainFailure(error);
         }
         for (const event of events) {
             try {
                 if (event.type === "native-turn-completed") {
-                    const outcome = this.applyCodex(event, now);
+                    const outcome = await this.applyCodex(event, now);
                     if (outcome === "deferred") {
                         deferred.push(event);
                         continue;
                     }
                 }
                 else if (event.type === "claude-stop-failure") {
-                    this.applyClaudeStopFailure(event, now);
+                    await this.applyClaudeStopFailure(event, now);
                 }
                 else if (event.type === "native-session-lifecycle") {
-                    const outcome = this.applySessionLifecycle(event, now);
+                    const outcome = await this.applySessionLifecycle(event, now);
                     if (outcome === "deferred") {
                         deferred.push(event);
                         continue;
                     }
                 }
                 else if (event.type === "native-turn-progress") {
-                    const outcome = this.applyProviderTurnProgress(event, now);
+                    const outcome = await this.applyProviderTurnProgress(event, now);
                     if (outcome === "deferred") {
                         deferred.push(event);
                         continue;
                     }
                 }
+                else if (event.type === "durable-job-terminal") {
+                    // 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 = this.applyPromptAccepted(event, now);
+                    const outcome = await this.applyPromptAccepted(event, now);
                     if (outcome === "deferred") {
                         deferred.push(event);
                         continue;
@@ -58,15 +536,34 @@ export class FileRuntimeEventProcessor {
                 failed.push({ eventId: event.id, error });
             }
         }
-        return { acknowledgedEventIds, deferred, failed };
+        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;
+        return {
+            acknowledgedEventIds,
+            deferred,
+            failed,
+            remainingEventCount: remaining.length,
+            metrics: {
+                listedEventCount: events.length,
+                selectedEventCount: events.length,
+                semanticEventsSelected: events.length - progressEventsSelected,
+                progressEventsSelected,
+                progressEventsCoalesced: 0,
+                stateTransactions: 0,
+                remainingSemanticEventCount: remaining.length - remainingProgressEventCount,
+                remainingProgressEventCount
+            }
+        };
     }
-    applySessionLifecycle(event, now) {
-        const task = this.observer.getTask(event.taskId);
+    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 = this.observer.observeProviderSessionLifecycle({
+        const outcome = await this.observer.observeProviderSessionLifecycle({
             eventId: event.id,
             taskId: event.taskId,
             roleName: event.roleName,
@@ -80,18 +577,23 @@ export class FileRuntimeEventProcessor {
         if (outcome === "applied") {
             this.options.onTaskRuntimeApplied?.({
                 taskId: event.taskId,
-                roleName: event.roleName
+                roleName: event.roleName,
+                agentId: event.agentId,
+                adapterId: event.adapterId,
+                launchId: event.launchId,
+                nativeSessionId: event.nativeSessionId,
+                ...(event.runId === undefined ? {} : { runId: event.runId })
             });
         }
         return outcome === "deferred" ? "deferred" : outcome;
     }
-    applyPromptAccepted(event, now) {
-        const task = this.observer.getTask(event.taskId);
+    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 = this.observer.observeProviderPromptAccepted({
+        const outcome = await this.observer.observeProviderPromptAccepted({
             eventId: event.id,
             taskId: event.taskId,
             roleName: event.roleName,
@@ -105,18 +607,23 @@ export class FileRuntimeEventProcessor {
         if (outcome === "applied") {
             this.options.onTaskRuntimeApplied?.({
                 taskId: event.taskId,
-                roleName: event.roleName
+                roleName: event.roleName,
+                agentId: event.agentId,
+                adapterId: event.adapterId,
+                launchId: event.launchId,
+                nativeSessionId: event.nativeSessionId,
+                runId: event.runId
             });
         }
         return outcome === "deferred" ? "deferred" : outcome;
     }
-    applyProviderTurnProgress(event, now) {
-        const task = this.observer.getTask(event.taskId);
+    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 = this.observer.observeProviderTurnProgress({
+        const outcome = await this.observer.observeProviderTurnProgress({
             eventId: event.id,
             receivedAt: event.receivedAt,
             taskId: event.taskId,
@@ -131,9 +638,9 @@ export class FileRuntimeEventProcessor {
         }, now);
         return outcome === "deferred" ? "deferred" : "applied";
     }
-    applyCodex(event, now) {
+    async applyCodex(event, now) {
         if (event.scope === "task") {
-            const task = this.observer.getTask(event.taskId);
+            const task = await this.observer.getTask(event.taskId);
             const input = {
                 eventId: event.id,
                 taskId: event.taskId,
@@ -149,24 +656,29 @@ export class FileRuntimeEventProcessor {
             if (task === null)
                 return "obsolete";
             if (task.status !== "active") {
-                this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
+                await this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
                 return "obsolete";
             }
-            const disposition = this.observer.classifyRuntimeTurnCompleted?.(input) ?? "apply";
+            const disposition = (await this.observer.classifyRuntimeTurnCompleted?.(input)) ?? "apply";
             if (disposition === "deferred")
                 return disposition;
             if (disposition === "obsolete") {
-                this.recordObsolete(event, "identity-mismatch-or-terminal", now);
+                await this.recordObsolete(event, "identity-mismatch-or-terminal", now);
                 return disposition;
             }
-            const observed = this.observer.observeRuntimeTurnCompleted(input, now);
+            const observed = await this.observer.observeRuntimeTurnCompleted(input, now);
             if (isObsoleteRuntimeTurnObservation(observed)) {
-                this.recordObsolete(event, "runtime-cleanup-or-stopped-session", now);
+                await this.recordObsolete(event, "runtime-cleanup-or-stopped-session", now);
                 return "obsolete";
             }
             this.options.onTaskRuntimeApplied?.({
                 taskId: event.taskId,
-                roleName: event.roleName
+                roleName: event.roleName,
+                agentId: event.agentId,
+                adapterId: event.adapterId,
+                ...(event.launchId === undefined ? {} : { launchId: event.launchId }),
+                nativeSessionId: event.nativeSessionId,
+                ...(event.runId === undefined ? {} : { runId: event.runId })
             });
             return "applied";
         }
@@ -181,14 +693,14 @@ export class FileRuntimeEventProcessor {
             ...(event.title === undefined ? {} : { title: event.title }),
             summary: event.summary
         };
-        if (this.observer.classifyGlobalRuntimeTurnCompleted?.(input) !== "obsolete") {
-            this.observer.observeGlobalRuntimeTurnCompleted(input, now);
+        if ((await this.observer.classifyGlobalRuntimeTurnCompleted?.(input)) !== "obsolete") {
+            await this.observer.observeGlobalRuntimeTurnCompleted(input, now);
             return "applied";
         }
         return "obsolete";
     }
-    applyClaudeStopFailure(event, now) {
-        const task = this.observer.getTask(event.taskId);
+    async applyClaudeStopFailure(event, now) {
+        const task = await this.observer.getTask(event.taskId);
         if (task === null)
             return;
         const input = {
@@ -208,8 +720,8 @@ export class FileRuntimeEventProcessor {
                 : { lastAssistantMessage: event.lastAssistantMessage })
         };
         if (task.status !== "active"
-            || this.observer.classifyClaudeStopFailureEvent?.(input) === "obsolete") {
-            this.recordObsolete(event, task.status === "archived"
+            || (await this.observer.classifyClaudeStopFailureEvent?.(input)) === "obsolete") {
+            await this.recordObsolete(event, task.status === "archived"
                 ? "task-archived"
                 : task.status !== "active"
                     ? "task-retired"
@@ -219,12 +731,12 @@ export class FileRuntimeEventProcessor {
         if (this.observer.observeClaudeStopFailureEvent === undefined) {
             throw new Error("Claude StopFailure observer is unavailable.");
         }
-        this.observer.observeClaudeStopFailureEvent(input, now);
+        await this.observer.observeClaudeStopFailureEvent(input, now);
     }
-    recordObsolete(event, reason, now) {
-        if (event.scope !== "task" || event.taskId === undefined)
+    async recordObsolete(event, reason, now) {
+        if (event.scope !== "task" || event.taskId === undefined || event.type === "durable-job-terminal")
             return;
-        this.observer.observeObsoleteRuntimeEvent?.({
+        await this.observer.observeObsoleteRuntimeEvent?.({
             eventId: event.id,
             eventType: event.type,
             taskId: event.taskId,
@@ -241,8 +753,3 @@ export class FileRuntimeEventProcessor {
         acknowledged.push(id);
     }
 }
-function isObsoleteRuntimeTurnObservation(value) {
-    return typeof value === "object"
-        && value !== null
-        && value.disposition === "obsolete";
-}