@zq-silk/yui 0.5.2 → 0.6.0

package/dist/cli/agentConfigurationPicker.js

@@ -261,7 +261,7 @@ function renderResolutionNotice(resolved, io) {
         io.write(notice);
 }
 async function choose(title, choices, io, defaultValue, label) {
-    io.write(`${renderTable(title, [{ header: "#", minWidth: 1, maxWidth: 4 }, ...COLUMNS], choices.map((choice, index) => [
+    io.write(`\n\n${renderTable(title, [{ header: "#", minWidth: 1, maxWidth: 4 }, ...COLUMNS], choices.map((choice, index) => [
         String(index + 1),
         choice.label,
         choice.detail

package/dist/cli/commandCatalog.js

@@ -229,8 +229,8 @@ const taskChildren = [
     {
         name: "rebuild",
         summary: "Rebuild a legacy Task workspace under its canonical identity.",
-        usage: "yui task rebuild <task>",
-        options: []
+        usage: "yui task rebuild <task> [--latest]",
+        options: ["--latest"]
     },
     {
         name: "history",

package/dist/commands/taskWorkspaceCommands.js

@@ -20,11 +20,17 @@ export async function runTaskWorkspaceCommand(args, store, preparer, options = {
         + "yui task history list|archive [task], yui task replace <task>.");
 }
 async function rebuildTaskCommand(args, preparer) {
-    const usage = "Task rebuild usage: yui task rebuild <task>.";
+    const usage = "Task rebuild usage: yui task rebuild <task> [--latest].";
     const taskId = args[0];
-    if (taskId === undefined || args.length !== 1)
+    const options = new Set(args.slice(1));
+    if (taskId === undefined
+        || options.size !== args.length - 1
+        || [...options].some((option) => option !== "--latest")) {
         throw usageError(usage);
-    const result = await preparer.rebuildTaskWorkspace(taskId);
+    }
+    const result = await preparer.rebuildTaskWorkspace(taskId, {
+        latestRemote: options.has("--latest")
+    });
     const archived = result.archived.length === 0
         ? "no legacy refs"
         : `${result.archived.length} legacy ref(s) archived`;
@@ -35,7 +41,8 @@ async function rebuildTaskCommand(args, preparer) {
         data: {
             taskId: result.task.id,
             archived: result.archived,
-            resumed: result.resumed
+            resumed: result.resumed,
+            latestRemote: options.has("--latest")
         }
     };
 }

package/dist/controller/controller.js

@@ -768,9 +768,9 @@ export class FileTaskController {
                             }
                         }
                     }
-                    const firstRuntimeDrain = this.#drainRuntimeEvents();
+                    const firstRuntimeDrain = await this.#drainRuntimeEvents();
                     result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#resourceSuppressionKeys);
-                    const secondRuntimeDrain = this.#drainRuntimeEvents();
+                    const secondRuntimeDrain = await this.#drainRuntimeEvents();
                     this.#clearPassRetry();
                     this.#scheduleRuntimeCleanupRetries(runtimeCleanupOutcomes);
                     this.#scheduleDeliveryRetries(result);
@@ -830,9 +830,15 @@ export class FileTaskController {
             this.#lastOperatorSignalIdentity = identity;
         }
     }
-    #drainRuntimeEvents() {
-        const result = this.#runtimeEventProcessor?.drain(this.#now());
-        if (result !== undefined && result.failed.length > 0) {
+    async #drainRuntimeEvents() {
+        const processor = this.#runtimeEventProcessor;
+        if (processor === undefined)
+            return undefined;
+        // The worker backend exposes drainAsync; the file backend stays sync.
+        const result = "drainAsync" in processor
+            ? await processor.drainAsync(this.#now())
+            : processor.drain(this.#now());
+        if (result.failed.length > 0) {
             throw new RuntimeEventApplyError(result.failed.map((failure) => failure.error), "One or more native Turn events could not be applied.");
         }
         return result;

package/dist/controller/ephemeralResourceReaper.js

@@ -80,8 +80,9 @@ export async function reapExpiredEphemeralResources(options = {}) {
     return result;
 }
 export function createEphemeralResourceReaper(options) {
+    const scan = options.scan ?? (() => scanControllerResourceInventory(options));
     return () => reapExpiredEphemeralResources({
-        scan: () => scanControllerResourceInventory(options),
+        scan,
         clean: (resource) => cleanControllerResource(resource, {
             environment: options.environment
         }),

package/dist/controller/resourceInventoryRpc.js

@@ -0,0 +1,85 @@
+/**
+ * Bounded RPC client for the resource inventory Worker Thread
+ * (task-21, work-item-6).
+ *
+ * The `/proc` scanning in `resourceInventoryLinux` is blocking IO (hundreds of
+ * `readFileSync` calls per pass, `spawnSync`, tmux inspection). When the worker
+ * backend is active (`YUI_STORE_BACKEND=sqlite` + `YUI_STORE_WORKER=1`, the same
+ * flag as the persistence worker, §6), the Controller runtime and the ephemeral
+ * reaper scan through this client instead: the scan runs in the inventory
+ * worker (its own thread), the main event loop stays free, and the result is
+ * posted back at the same cadence (design §3.3).
+ *
+ * The backpressure, cancellation, and fault-boundary machinery is the shared
+ * `core/boundedRpc` client; this module adds the inventory dialect:
+ *
+ *   main -> worker: init | scan | cancel | shutdown
+ *   worker -> main: ready | result | error
+ *
+ * Only structured-cloneable scan options cross the port (the file-backed
+ * `inspectStorage` / `openCompatibleStore` / `now` seams stay on the direct
+ * path, which the file backend still uses). The inventory worker never touches
+ * the persistence worker's database connection (§3.3): it is a separate worker
+ * with a separate concern.
+ */
+import { BoundedRpcClient, deserializeError, nextRequestId } from "../core/boundedRpc.js";
+// -- Protocol adapter ---------------------------------------------------------
+const inventoryProtocol = {
+    initRequest: () => ({ kind: "init" }),
+    cancelRequest: (requestId) => ({ kind: "cancel", requestId }),
+    shutdownRequest: () => ({ kind: "shutdown" }),
+    isReady: (response) => response.kind === "ready",
+    responseRequestId: (response) => {
+        if (response.kind === "ready") {
+            throw new Error("ready response has no requestId.");
+        }
+        return response.requestId;
+    },
+    settle: (response, settlement) => {
+        if (response.kind === "result") {
+            settlement.resolve(response.inventory);
+            return;
+        }
+        if (response.kind === "error") {
+            settlement.reject(deserializeError(response.error));
+        }
+    }
+};
+// -- Client ------------------------------------------------------------------
+/**
+ * The main-thread client for the inventory worker. `scan` runs the full
+ * `scanControllerResourceInventory` in the worker and resolves with the same
+ * inventory shape the direct call returns; the scheduler and the ephemeral
+ * reaper consume it through the same ports as today (§3.3, behavior unchanged).
+ */
+export class ResourceInventoryClient {
+    #rpc;
+    constructor(options = {}) {
+        this.#rpc = new BoundedRpcClient(inventoryProtocol, {
+            maxInFlight: options.maxInFlight ?? 4,
+            maxQueue: options.maxQueue ?? 16,
+            workerScript: options.workerScript ?? new URL("./resourceInventoryWorker.js", import.meta.url)
+        });
+    }
+    /** Run one resource inventory scan in the worker. */
+    scan(options, rpcOptions) {
+        const requestId = nextRequestId();
+        return this.#rpc.send(requestId, { kind: "scan", requestId, options }, rpcOptions);
+    }
+    /** Close the worker. */
+    close() {
+        return this.#rpc.close();
+    }
+    /** Currently in-flight scans (metrics/tests). */
+    get inFlight() {
+        return this.#rpc.inFlight;
+    }
+    /** Currently queued scans waiting for a slot (metrics/tests). */
+    get queueDepth() {
+        return this.#rpc.queueDepth;
+    }
+    /** Test-only fault injection: terminate the worker (the client restarts it). */
+    crashForTest() {
+        return this.#rpc.crashForTest();
+    }
+}

package/dist/controller/resourceInventoryWorker.js

@@ -0,0 +1,50 @@
+/**
+ * Resource inventory Worker Thread (task-21, work-item-6).
+ *
+ * Runs the blocking `/proc` scanning of `resourceInventoryLinux` off the main
+ * thread. The main thread asks for a scan over a `MessageChannel` port; the
+ * worker runs the exact same `scanControllerResourceInventory` the file backend
+ * calls directly and posts the inventory back. Because worker threads share the
+ * process, the scanner's self-exclusion (`process.pid`, its start identity)
+ * keeps excluding the Controller process exactly as on the main thread.
+ *
+ * The port handshake, dispatch, cancellation observation, and error
+ * serialization are the shared `core/boundedRpc` worker host; this module only
+ * supplies the inventory dialect. The worker is read-only: it never touches the
+ * persistence worker's database connection (§3.3) — it opens the same file
+ * store reads the direct scan uses, in its own thread.
+ *
+ * Protocol (see resourceInventoryRpc.ts):
+ *   main -> worker: init | scan | cancel | shutdown
+ *   worker -> main: ready | result | error
+ */
+import { runRpcWorker } from "../core/boundedRpc.js";
+import { scanControllerResourceInventory } from "./resourceInventoryLinux.js";
+runRpcWorker({
+    kindOf: (request) => (request.kind === "scan" ? "request" : request.kind),
+    requestIdOf: (request) => (request.kind === "scan" || request.kind === "cancel" ? request.requestId : undefined),
+    init: async () => {
+        // No resources to initialize: each scan opens what it needs and closes it.
+    },
+    handle: async (request) => {
+        if (request.kind !== "scan") {
+            throw new Error(`Unexpected inventory request: ${request.kind}`);
+        }
+        return scanControllerResourceInventory(request.options);
+    },
+    cancel: () => {
+        // The /proc scan has no cancellation points. The main thread rejects the
+        // aborted call immediately and suppresses the late result; the worker
+        // thread finishes the scan on its own time without blocking the main loop.
+    },
+    shutdown: async () => {
+        // Nothing to close: scans own no long-lived resources.
+    },
+    ready: () => ({ kind: "ready" }),
+    result: (requestId, value) => ({
+        kind: "result",
+        requestId,
+        inventory: value
+    }),
+    error: (requestId, error) => ({ kind: "error", requestId, error })
+});

package/dist/controller/runtime.js

@@ -11,6 +11,8 @@ import { effectiveLaunchSnapshotsCompatible, resolveEffectiveLaunch } from "../e
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { SqliteTaskStore } from "../storage/sqliteStore.js";
+import { AsyncTaskStoreClient, resolveStoreWorkerEnabled } from "../storage/storeRpc.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
@@ -18,15 +20,41 @@ import { FileTaskRuntimeIsolation, TmuxPromptPushAdapter, TmuxSessionHost } from
 import { startFileTaskController } from "./controller.js";
 import { FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
-import { FileRuntimeEventProcessor } from "./runtimeEventProcessor.js";
+import { AsyncRuntimeEventProcessor, FileRuntimeEventProcessor, createAsyncRuntimeObserver } from "./runtimeEventProcessor.js";
 import { RuntimeLaunchCoordinator } from "./runtimeLaunchCoordinator.js";
 import { ephemeralDomainFromEnvironment, recordEphemeralTmuxTarget } from "./domainIdentity.js";
 import { createEphemeralResourceReaper } from "./ephemeralResourceReaper.js";
 import { scanControllerResourceInventory } from "./resourceInventoryLinux.js";
+import { ResourceInventoryClient } from "./resourceInventoryRpc.js";
 import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
 /** Production composition root for the lean FileTaskStore + tmux Controller. */
 export async function startFileTaskControllerRuntime(home, options = {}) {
-    const store = options.store ?? openCompatibleFileTaskStore(home);
+    // The persistence worker (task-21, work-item-5) is opt-in: YUI_STORE_BACKEND
+    // must be sqlite AND YUI_STORE_WORKER=1. The file store remains the default
+    // for CLI tools and tests; rollback is a config flip (§6).
+    const useWorker = resolveStoreWorkerEnabled(options.environment ?? process.env);
+    const store = options.store
+        ?? (useWorker
+            // Transitional: the scheduler/planner still use a sync store. The worker
+            // owns the event-processing hot path; the scheduler migration is the next
+            // step (see work-item-5 remaining call sites). Both connections point at
+            // the same WAL db and serialize via BEGIN IMMEDIATE + busy_timeout.
+            ? new SqliteTaskStore(home)
+            : openCompatibleFileTaskStore(home));
+    // When the worker backend is active, the db-touching observer folds run in
+    // the worker (off the main event loop). The client is closed on shutdown.
+    const asyncStoreClient = useWorker
+        ? new AsyncTaskStoreClient(home, {
+            environment: options.environment,
+            observerModule: new URL("./fileSchedulerStoreAdapter.js", import.meta.url)
+        })
+        : undefined;
+    // When the worker backend is active, the blocking /proc inventory scan runs
+    // in the inventory worker (off the main event loop); the scheduler and the
+    // ephemeral reaper consume the same inventory shape through this client (§3.3).
+    const inventoryClient = useWorker
+        ? new ResourceInventoryClient()
+        : undefined;
     const schedulerStore = options.schedulerStore ?? new FileSchedulerStoreAdapter(store);
     const domainIdentity = options.domainIdentity
         ?? ephemeralDomainFromEnvironment(options.environment ?? process.env);
@@ -95,19 +123,32 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         onCleanupRequired: signalRuntimeCleanup,
         runtimeIsolation
     });
+    // One inventory scan per scheduler pass. When the worker backend is active
+    // the blocking /proc scan runs in the inventory worker; otherwise it runs on
+    // the main thread (file backend, unchanged).
+    const scanInventory = (panes) => inventoryClient !== undefined
+        ? inventoryClient.scan({
+            currentHome: home,
+            scope: "current",
+            panes,
+            ...(options.environment === undefined
+                ? {}
+                : { environment: options.environment })
+        })
+        : scanControllerResourceInventory({
+            currentHome: home,
+            scope: "current",
+            panes,
+            ...(options.environment === undefined
+                ? {}
+                : { environment: options.environment })
+        });
     const delivery = options.delivery ?? new ExecutorRegistry(planner, tmux, agentProcessReadinessProbe, {
         sessionHost,
         promptPush,
         launchCoordinator,
         roleResourceInventory: async (panes, inputs) => {
-            const inventory = await scanControllerResourceInventory({
-                currentHome: home,
-                scope: "current",
-                panes,
-                ...(options.environment === undefined
-                    ? {}
-                    : { environment: options.environment })
-            });
+            const inventory = await scanInventory(panes);
             return inventory.resources.flatMap((resource) => {
                 if (resource.kind !== "agent-session")
                     return [];
@@ -182,7 +223,20 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
                 // recovery bounded to that domain; cross-home cleanup remains an
                 // explicit `controller cleanup --all` inventory operation.
                 scope: "current",
-                environment: options.environment
+                environment: options.environment,
+                // When the worker backend is active, the reaper's scan runs in the
+                // inventory worker too (same cadence, same inventory shape).
+                ...(inventoryClient === undefined
+                    ? {}
+                    : {
+                        scan: () => inventoryClient.scan({
+                            currentHome: home,
+                            scope: "current",
+                            ...(options.environment === undefined
+                                ? {}
+                                : { environment: options.environment })
+                        })
+                    })
             }));
     const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, signalRuntimeCleanup, launchCoordinator, planner);
     const running = await startFileTaskController(home, schedulerStore, delivery, lifecycleDispatcher, {
@@ -202,11 +256,17 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         },
         workspacePreparer,
         runtimeEventProcessor: options.runtimeEventProcessor
-            ?? new FileRuntimeEventProcessor(new FileRuntimeEventInbox(home), schedulerStore, {
-                onTaskRuntimeApplied: (input) => {
-                    planner.refreshTaskRuntimeDescriptor(input);
-                }
-            }),
+            ?? (useWorker && asyncStoreClient !== undefined
+                ? new AsyncRuntimeEventProcessor(new FileRuntimeEventInbox(home), createAsyncRuntimeObserver((method, args) => asyncStoreClient.invokeObserver(method, args)), {
+                    onTaskRuntimeApplied: (input) => {
+                        planner.refreshTaskRuntimeDescriptor(input);
+                    }
+                })
+                : new FileRuntimeEventProcessor(new FileRuntimeEventInbox(home), schedulerStore, {
+                    onTaskRuntimeApplied: (input) => {
+                        planner.refreshTaskRuntimeDescriptor(input);
+                    }
+                })),
         domainIdentity,
         ...(options.configuration !== undefined
             ? { configuration: options.configuration }
@@ -222,6 +282,12 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
     runningRuntime = running.runtime;
     return {
         ...running,
+        close: async () => {
+            await running.close();
+            // Release the worker's database connections when the worker backend is active.
+            await asyncStoreClient?.close();
+            await inventoryClient?.close();
+        },
         store,
         schedulerStore,
         planner,

package/dist/controller/runtimeEventProcessor.js

@@ -246,3 +246,271 @@ function isObsoleteRuntimeTurnObservation(value) {
         && 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 { acknowledgedEventIds, deferred, failed: [{ error }] };
+        }
+        for (const event of events) {
+            try {
+                if (event.type === "native-turn-completed") {
+                    const outcome = await this.applyCodex(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                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 {
+                    const outcome = await this.applyPromptAccepted(event, now);
+                    if (outcome === "deferred") {
+                        deferred.push(event);
+                        continue;
+                    }
+                }
+                this.acknowledge(event.id, acknowledgedEventIds);
+            }
+            catch (error) {
+                failed.push({ eventId: event.id, error });
+            }
+        }
+        return { acknowledgedEventIds, deferred, failed };
+    }
+    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
+            });
+        }
+        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") {
+            this.options.onTaskRuntimeApplied?.({
+                taskId: event.taskId,
+                roleName: event.roleName
+            });
+        }
+        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";
+    }
+    async applyCodex(event, now) {
+        if (event.scope === "task") {
+            const task = await 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") {
+                await this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
+                return "obsolete";
+            }
+            const disposition = (await this.observer.classifyRuntimeTurnCompleted?.(input)) ?? "apply";
+            if (disposition === "deferred")
+                return disposition;
+            if (disposition === "obsolete") {
+                await this.recordObsolete(event, "identity-mismatch-or-terminal", now);
+                return disposition;
+            }
+            const observed = await this.observer.observeRuntimeTurnCompleted(input, now);
+            if (isObsoleteRuntimeTurnObservation(observed)) {
+                await this.recordObsolete(event, "runtime-cleanup-or-stopped-session", now);
+                return "obsolete";
+            }
+            this.options.onTaskRuntimeApplied?.({
+                taskId: event.taskId,
+                roleName: event.roleName
+            });
+            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 ((await this.observer.classifyGlobalRuntimeTurnCompleted?.(input)) !== "obsolete") {
+            await this.observer.observeGlobalRuntimeTurnCompleted(input, now);
+            return "applied";
+        }
+        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)
+            return;
+        await 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(id, acknowledged) {
+        this.inbox.acknowledge(id);
+        acknowledged.push(id);
+    }
+}