@zq-silk/yui 2.21.0 → 2.22.0

package/dist/controller/agentRuntimeObserver.js

@@ -15,14 +15,45 @@ export class AgentRuntimeObserver {
     #states = new Map();
     #maxConcurrentSamples;
     #sequence = 0;
+    #samples = 0;
+    #sources = 0;
+    #published = 0;
+    #usagePublications = 0;
+    #failed = 0;
     constructor(store, inbox, drivers = builtinAgentDriverRegistry(), options = {}) {
         this.store = store;
         this.inbox = inbox;
         this.drivers = drivers;
         this.#maxConcurrentSamples = sampleConcurrency(options.maxConcurrentSamples);
     }
-    async sample(now = new Date()) {
-        const active = this.activeSources();
+    async sample(now = new Date(), phases) {
+        this.#samples++;
+        const finishDiscovery = phases?.start("runtime-sample-discovery", "home");
+        let active;
+        try {
+            active = this.activeSources();
+            finishDiscovery?.();
+        }
+        catch (error) {
+            finishDiscovery?.(true);
+            throw error;
+        }
+        this.#sources += active.length;
+        const publish = async (observation) => {
+            try {
+                const result = await (phases === undefined
+                    ? this.inbox.enqueueObservationAsync(observation)
+                    : phases.observe(observation.payload.usage === undefined ? "runtime-sample-publish" : "runtime-usage-publish", undefined, () => this.inbox.enqueueObservationAsync(observation)));
+                this.#published++;
+                if (observation.payload.usage !== undefined)
+                    this.#usagePublications++;
+                return result;
+            }
+            catch (error) {
+                this.#failed++;
+                throw error;
+            }
+        };
         const activeKeys = new Set(active.map(({ key }) => key));
         for (const key of this.#states.keys()) {
             if (!activeKeys.has(key))
@@ -37,7 +68,10 @@ export class AgentRuntimeObserver {
             // usage/activity baseline is durable. Rehydrate it after Controller
             // restart so rereading the bounded transcript tail cannot manufacture a
             // fresh activity edge from tokens that were already observed.
-            const state = existingState ?? { ...persistedState };
+            // Commit process-local state only when every fact from this sample is
+            // durable. A failed later publication must leave the old cursor usable;
+            // retry deduplicates any already-persisted prefix.
+            const state = { ...(existingState ?? persistedState) };
             const restoredUsageEventId = existingState === undefined
                 ? persistedState.usageEventId
                 : undefined;
@@ -63,7 +97,6 @@ export class AgentRuntimeObserver {
                     detail: error instanceof Error ? error.message : String(error)
                 });
             }
-            state.cursor = sample.cursor;
             const at = now.toISOString();
             // Reserve sequence numbers in source-key order before sampling. Provider
             // latency can change completion order without changing observation
@@ -101,7 +134,7 @@ export class AgentRuntimeObserver {
                     const identity = completeHistory
                         ? tokenObservationIdentity("baseline", fence, source.sourceId, baselineKey)
                         : usageObservationIdentity(fence, source.sourceId, latestOccurrence);
-                    this.inbox.enqueueObservation(createRuntimeObservation({
+                    await publish(createRuntimeObservation({
                         schemaVersion: 1,
                         eventId: identity.eventId,
                         semanticKey: identity.semanticKey,
@@ -136,7 +169,7 @@ export class AgentRuntimeObserver {
             }
             const health = JSON.stringify([sample.status, sample.detail ?? null]);
             if (state.health !== health) {
-                this.inbox.enqueueObservation(createRuntimeObservation({
+                await publish(createRuntimeObservation({
                     schemaVersion: 1,
                     eventId: observationId("health", fence, source.sourceId, health),
                     semanticKey: observationId("health", fence, source.sourceId, health),
@@ -180,9 +213,9 @@ export class AgentRuntimeObserver {
                         : Object.freeze({ ...occurrence, observationQuality: "partial" })));
                 }
             }
-            usages.forEach((occurrence, usageIndex) => {
+            for (const [usageIndex, occurrence] of usages.entries()) {
                 const identity = usageObservationIdentity(fence, source.sourceId, occurrence);
-                this.inbox.enqueueObservation(createRuntimeObservation({
+                await publish(createRuntimeObservation({
                     schemaVersion: 1,
                     eventId: identity.eventId,
                     semanticKey: identity.semanticKey,
@@ -210,9 +243,9 @@ export class AgentRuntimeObserver {
                     state.usageOccurrenceId = occurrence.occurrenceId;
                     state.usageOccurrenceCheckpoint = occurrence.resumeCheckpoint;
                 }
-            });
-            if (activityChanged && state.cursor !== undefined) {
-                this.inbox.enqueueObservation(createRuntimeObservation({
+            }
+            if (activityChanged && sample.cursor !== undefined) {
+                await publish(createRuntimeObservation({
                     schemaVersion: 1,
                     eventId: observationId("activity", fence, source.sourceId, sample.activityId),
                     semanticKey: observationId("activity", fence, source.sourceId, sample.activityId),
@@ -232,10 +265,17 @@ export class AgentRuntimeObserver {
             }
             if (sample.activityId !== undefined)
                 state.activityId = sample.activityId;
+            state.cursor = sample.cursor;
             this.#states.set(key, state);
         });
         return Object.freeze([...dirty].sort(numericCompare));
     }
+    /** Counts successful durable admissions (including duplicates), not tokens or
+     * provider content. Phase observations carry discovery/publication duration. */
+    metrics() {
+        return { samples: this.#samples, sources: this.#sources, published: this.#published,
+            usagePublications: this.#usagePublications, failed: this.#failed };
+    }
     activeSources() {
         const result = [];
         const activeTasks = [...new Set(this.store.listActiveTaskIds())]
@@ -354,13 +394,18 @@ export class AgentRuntimeObserver {
 async function forEachConcurrent(values, limit, visit) {
     let nextIndex = 0;
     const workers = Math.min(limit, values.length);
-    await Promise.all(Array.from({ length: workers }, async () => {
+    const results = await Promise.allSettled(Array.from({ length: workers }, async () => {
         while (nextIndex < values.length) {
             const index = nextIndex;
             nextIndex += 1;
             await visit(values[index], index);
         }
     }));
+    // An admission failure must not release the Controller's in-flight sample
+    // guard while another source can still commit state from that sample.
+    const failure = results.find(result => result.status === "rejected");
+    if (failure?.status === "rejected")
+        throw failure.reason;
 }
 function sampleConcurrency(value) {
     const resolved = value ?? DEFAULT_MAX_CONCURRENT_SAMPLES;

package/dist/controller/clientRuntime.js

@@ -2,7 +2,8 @@ import { spawn } from "node:child_process";
 import { jobCleanupBlocker } from "../job/jobCleanupInspection.js";
 import { describeCliFailure } from "../errors/cliFailure.js";
 import { fileURLToPath } from "node:url";
-import { findLiveControllerProcessForHome, inspectLiveControllerProcess } from "../core/controllerProcessIdentity.js";
+import { findLiveControllerProcessForHome } from "../core/controllerProcessIdentity.js";
+import { processGenerationIsLive } from "../core/fileLockOwner.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
 import { parseControllerIdentity } from "../core/controllerIdentity.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
@@ -12,6 +13,7 @@ import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/runtimeCoherence.js";
+import { readLinuxProcessIdentity } from "../runtime/sessionOwnerIdentity.js";
 import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { yuiVersionIdentity } from "../version.js";
@@ -169,13 +171,27 @@ export async function stopFileTaskController(home, options = {}) {
     await waitForForeignHandover(home, options);
     const physical = options.call === undefined
         ? findLiveControllerProcessForHome(readHomeFilesystemId(home)) : undefined;
-    const expectedPid = options.expectedPid ?? physical?.pid;
+    // A protected, Home-validated discovery can retain the generation fence
+    // even if the optional /proc ownership inventory is currently unreadable.
+    // It is not signal authority; physical recovery still revalidates ownership.
+    let captured = physical;
+    if (captured === undefined && options.call === undefined) {
+        try {
+            const discovery = await readControllerDiscovery(home);
+            captured = { pid: discovery.pid, processStartIdentity: discovery.processStartIdentity };
+        }
+        catch (error) {
+            if (!isDefinitelyNotRunning(error))
+                throw error;
+        }
+    }
+    const expectedPid = options.expectedPid ?? captured?.pid;
     const bounded = { ...options, requestTimeoutMs: options.requestTimeoutMs ?? 2000,
         ...(expectedPid === undefined ? {} : { expectedPid }) };
     try {
         const result = await stopControllerGracefully(home, bounded);
-        if (result.stopped && physical !== undefined) {
-            await waitForControllerProcessExit(home, physical, options);
+        if (result.stopped && captured !== undefined) {
+            await waitForControllerProcessExit(captured, options);
         }
         if (result.stopped || options.call !== undefined)
             return result;
@@ -185,15 +201,28 @@ export async function stopFileTaskController(home, options = {}) {
             throw error;
     }
     const stopped = await stopOrphanedFileTaskController(home, options.shutdownTimeoutMs ?? CONTROLLER_SHUTDOWN_TIMEOUT_MS, { force: true, ...(expectedPid === undefined ? {} : { expectedPid }),
-        ...(physical === undefined ? {} : { expectedProcessStartIdentity: physical.processStartIdentity }) });
+        ...(captured === undefined ? {} : { expectedProcessStartIdentity: captured.processStartIdentity }) });
+    // No match is not exit proof: /proc ownership inspection may have become
+    // unreadable after we captured this exact generation. Physical recovery
+    // cannot authorize a successor until that original generation is gone.
+    if (captured !== undefined)
+        await waitForControllerProcessExit(captured, options);
     return stopped === undefined ? { stopped: false, alreadyStopped: true } : { stopped: true, pid: stopped.pid };
 }
-async function waitForControllerProcessExit(home, controller, options) {
+async function waitForControllerProcessExit(controller, options) {
     const timeoutMs = positive(options.shutdownTimeoutMs, CONTROLLER_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
     const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
-    const homeFilesystemId = readHomeFilesystemId(home);
     const deadline = Date.now() + timeoutMs;
-    while (inspectLiveControllerProcess(controller.pid, homeFilesystemId, controller.processStartIdentity) !== undefined) {
+    // This check is tri-state: unreadable OS identity throws rather than
+    // collapsing an unknown/live process into the absence of a Controller match.
+    while (processGenerationIsLive(controller.pid, controller.processStartIdentity)) {
+        if (process.platform === "linux") {
+            const observed = readLinuxProcessIdentity(controller.pid);
+            // Preserve the existing physical-stop boundary: an exact zombie has
+            // exited, even if its parent has not reaped the process table entry.
+            if (observed?.startIdentity === controller.processStartIdentity && observed.state === "Z")
+                return;
+        }
         if (Date.now() >= deadline) {
             throw new ControllerClientError("CONTROLLER_TIMEOUT", `Controller process ${controller.pid} did not exit within ${timeoutMs} ms.`);
         }

package/dist/controller/controller.js

@@ -792,6 +792,7 @@ export class FileTaskController {
     runtimeMetrics() {
         const metrics = this.#lastRuntimeDrain?.metrics ?? ZERO_DRAIN_METRICS;
         return {
+            sampler: this.#runtimeObserver?.metrics?.() ?? null,
             messageHealth: this.#lastMessageHealth,
             diagnostics: this.#diagnosticMetrics?.() ?? null,
             phases: this.#phases.snapshot(),
@@ -920,7 +921,7 @@ export class FileTaskController {
         if (this.#stopped || this.#runtimeObserver === undefined
             || this.#runtimeObserverCurrent !== undefined)
             return;
-        const running = this.#runtimeObserver.sample(this.#now()).then((keys) => {
+        const running = this.#phases.observe("runtime-sample", "home", () => this.#runtimeObserver.sample(this.#now(), this.#phases)).then((keys) => {
             if (this.#stopped)
                 return;
             for (const key of keys)
@@ -1779,6 +1780,7 @@ export async function startFileTaskController(home, store, delivery, dispatcher,
         await runtime.shutdownAndDrain();
     }, {
         domainIdentity: options.domainIdentity,
+        onRequestDiagnostic: options.onRequestDiagnostic,
         status: ({ commandObserver, eventLoopDelay }) => ({
             ...runtime.runtimeMetrics(),
             commands: {

package/dist/controller/diagnosticJournal.js

@@ -13,13 +13,15 @@ const NUMERIC_KEYS = new Set([
     "completed", "failed", "received", "inFlight", "maximumMs", "maximumLagMs",
     "maximumObservedAtMs", "oldestInFlightAgeMs", "startedAtMs", "elapsedMs",
     "ageMs", "depth", "semanticDepth", "progressDepth", "pendingKeys", "queueDepth",
-    "hits", "rebuilds", "invalidations", "passes", "listedEvents", "selectedEvents"
+    "hits", "rebuilds", "invalidations", "passes", "listedEvents", "selectedEvents",
+    "acceptedAtMs", "receivedAtMs", "routedAtMs", "handlerCompletedAtMs", "flushCompletedAtMs",
+    "handlerFailed", "flushFailed", "samples", "sources", "published", "usagePublications"
 ]);
 const CONTAINER_KEYS = new Set([
     "commands", "observations", "routes", "eventLoopDelay", "phases", "reads",
     "persistence", "main", "worker", "database", "roundTrips", "work", "body",
     "lock", "commit", "payloadReads", "inbox", "scheduler", "projectionCache",
-    "active", "recent", "slowest", "latest"
+    "active", "recent", "slowest", "latest", "transport", "sampler"
 ]);
 const ERROR_CODES = new Set([
     "SQLITE_BUSY", "SQLITE_LOCKED", "SQLITE_IOERR", "SQLITE_FULL", "SQLITE_READONLY",
@@ -101,6 +103,12 @@ export class ControllerDiagnosticJournal {
     error(error) {
         this.#enqueue("error", { error: errorEvidence(error) });
     }
+    /** Completion-driven evidence bypasses the periodic recent-array/sample
+     * window, but uses the same allowlist, queue/record/file bounds and async I/O.
+     * Disk failure, queue pressure and force-kill remain explicit evidence gaps. */
+    request(record) {
+        this.#enqueue("request", { request: safeSnapshot(record) });
+    }
     sample(snapshot, lagMs) {
         const now = monotonicMilliseconds();
         if (now - this.#lastSampleAt < 1000) {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -43,7 +43,7 @@ import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
-import { acceptProviderTurn, beginProviderTurn, cancelQuiescentProviderInput, clearProviderGoal, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, settleProviderTurn, settleProviderTurnSubmission, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
+import { acceptProviderTurn, beginProviderTurn, cancelQuiescentProviderInput, clearProviderGoal, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, providerTurnIsActive, settleProviderTurn, settleProviderTurnSubmission, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeUsageEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
@@ -106,11 +106,24 @@ export class FileSchedulerStoreAdapter {
         return errors;
     }
     observeAgentHostObservation(event, now = new Date()) {
+        let preparation;
+        if (isRunTerminalObservation(event.observation)) {
+            preparation = {};
+            try {
+                preparation = this.prepareRuntimeTerminalObservation(resolveAgentHostObservation(this.store, event), now);
+            }
+            catch (error) {
+                if (!(error instanceof AgentHostObservationDeferred || error instanceof RuntimeHookRunFenceError))
+                    throw error;
+                // Re-resolve under the committing fence below; preparation grants no
+                // authority and must not settle a deferred/obsolete Host envelope.
+            }
+        }
         // Match canonical ingress: archive and Host fact settlement share the
         // same write boundary, including the original transport envelope.
-        return this.store.transaction(() => this.foldAgentHostObservation(event, now));
+        return this.store.transaction(() => this.foldAgentHostObservation(event, now, preparation));
     }
-    foldAgentHostObservation(event, now) {
+    foldAgentHostObservation(event, now, preparation) {
         const raw = createRuntimeObservation(event.observation);
         const task = raw.fence.taskId === undefined ? null : this.store.getTask(raw.fence.taskId);
         if (raw.fence.taskId !== undefined && task === null)
@@ -154,7 +167,7 @@ export class FileSchedulerStoreAdapter {
             // Rejection is durable diagnostic evidence, never business acceptance.
             return this.recordObsoleteCanonicalObservation(event.observation, error.message, now);
         }
-        return this.observeRuntimeObservation(input, now);
+        return this.foldRuntimeObservation(input, now, preparation);
     }
     /**
      * Sole provider-independent ingress for structured runtime state. Driver
@@ -163,12 +176,30 @@ export class FileSchedulerStoreAdapter {
      * transitions, and retains the canonical observation for status projection.
      */
     observeRuntimeObservation(raw, now = new Date()) {
+        const preparation = this.prepareRuntimeTerminalObservation(raw, now);
         // Archive and observation settlement share the same write boundary.
         // An ingress read outside this transaction must never authorize clearing
         // a claim after another CLI has committed archive.
-        return this.store.transaction(() => this.foldRuntimeObservation(raw, now));
+        return this.store.transaction(() => this.foldRuntimeObservation(raw, now, preparation));
     }
-    foldRuntimeObservation(raw, now) {
+    prepareRuntimeTerminalObservation(raw, now) {
+        const input = createRuntimeObservation(raw);
+        if (!isRunTerminalObservation(input))
+            return undefined;
+        if (input.fence.taskId === undefined || Date.parse(input.receivedAt) > now.getTime())
+            return {};
+        const adapterId = this.adapterForRuntimeObservation(input);
+        if (adapterId === null)
+            return {};
+        return this.prepareRuntimeTerminal({
+            taskId: input.fence.taskId, roleName: input.fence.roleName,
+            agentId: input.fence.agentId, adapterId, conversationId: input.fence.conversationId,
+            nativeSessionId: input.fence.nativeSessionId, nativeTurnId: input.fence.nativeTurnId,
+            attemptId: input.fence.receiptId, runId: input.fence.runId
+        }, input.kind === "turn.completed" && input.payload.resultTransportDiagnostic === undefined
+            && transportAgentResult(input.payload.output).status === "completed");
+    }
+    foldRuntimeObservation(raw, now, preparation) {
         const input = createRuntimeObservation(raw);
         const taskId = input.fence.taskId;
         if (taskId === undefined)
@@ -263,13 +294,13 @@ export class FileSchedulerStoreAdapter {
                 outcome = this.observeRuntimePromptAccepted(input, adapterId, now);
                 break;
             case "turn.completed":
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "completed", now);
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "completed", now, preparation);
                 break;
             case "turn.failed": {
                 // A Provider Turn is an activation boundary, not a Task outcome.
                 // Keep the AgentRun and Session identity available for Agent-directed
                 // restore + submit, even when a provider marks its AgentRun terminal.
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", now);
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", now, preparation);
                 break;
             }
             case "operation.started":
@@ -286,7 +317,7 @@ export class FileSchedulerStoreAdapter {
                 outcome = this.validateCanonicalRunObservation(input, now);
                 break;
             case "turn.cancelled": {
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", now);
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", now, preparation);
                 break;
             }
             case "conversation.observed":
@@ -617,7 +648,7 @@ export class FileSchedulerStoreAdapter {
             return "applied";
         });
     }
-    foldProviderTurnBoundary(input, adapterId, providerStatus, now) {
+    foldProviderTurnBoundary(input, adapterId, providerStatus, now, preparation) {
         const outcome = providerStatus === "completed"
             ? input.payload.resultTransportDiagnostic === undefined
                 ? transportAgentResult(input.payload.output)
@@ -656,7 +687,7 @@ export class FileSchedulerStoreAdapter {
         const classification = this.classifyRuntimeRunTerminal(completed);
         if (classification !== "apply")
             return classification;
-        const result = this.observeRuntimeRunTerminal(completed, now);
+        const result = this.foldRuntimeRunTerminal(completed, now, preparation ?? {});
         return result.disposition === "obsolete" ? "obsolete" : "applied";
     }
     validateCanonicalSessionObservation(input, now) {
@@ -1774,8 +1805,7 @@ export class FileSchedulerStoreAdapter {
     listDormantRuntimeOwners() {
         return this.listRuntimeSessionCandidates().flatMap((candidate) => {
             if (hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(candidate.owner)))
-                || (candidate.owner.scope === "task"
-                    && this.store.getActiveRun(candidate.owner.taskId, candidate.owner.roleName) !== null)) {
+                || runtimeOwnerHasActiveWork(this.store, candidate.owner)) {
                 return [];
             }
             return [{
@@ -2282,17 +2312,24 @@ export class FileSchedulerStoreAdapter {
     classifyRuntimeRunTerminal(input) {
         return resolveTerminalExecution(this.store, input) === null ? "obsolete" : "apply";
     }
+    prepareRuntimeTerminal(input, completed) {
+        const run = resolveTerminalExecution(this.store, input)?.run;
+        const workspace = run?.status === "active"
+            && run.executionGroupId !== undefined
+            && run.executionLaneId !== undefined
+            && run.workspace !== undefined
+            && completed
+            ? this.#observeRead("git-workspace-snapshot", run.taskId, () => this.snapshotExecutionLaneWorkspace(this.store, run.workspace))
+            : undefined;
+        return { run, workspace };
+    }
     observeRuntimeRunTerminal(input, now = new Date()) {
+        return this.foldRuntimeRunTerminal(input, now, this.prepareRuntimeTerminal(input, input.outcome.status === "completed"));
+    }
+    foldRuntimeRunTerminal(input, now, preparation) {
         // Resource inspection is bounded but external to SQLite. Revalidate the
         // immutable AgentRun workspace after acquiring the write transaction.
-        const preparedRun = resolveTerminalExecution(this.store, input)?.run;
-        const workspace = preparedRun?.status === "active"
-            && preparedRun.executionGroupId !== undefined
-            && preparedRun.executionLaneId !== undefined
-            && preparedRun.workspace !== undefined
-            && input.outcome.status === "completed"
-            ? this.#observeRead("git-workspace-snapshot", preparedRun.taskId, () => this.snapshotExecutionLaneWorkspace(this.store, preparedRun.workspace))
-            : undefined;
+        const { run: preparedRun, workspace } = preparation;
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             if (task === null)
@@ -2304,7 +2341,8 @@ export class FileSchedulerStoreAdapter {
             if (resolved === null)
                 throw new Error("Runtime terminal has no exact execution binding.");
             const { run: observedRun, current: recordedProviderTurn, attemptId } = resolved;
-            if (!isDeepStrictEqual(preparedRun?.workspace, observedRun?.workspace)) {
+            if (preparedRun?.id !== observedRun?.id
+                || !isDeepStrictEqual(preparedRun?.workspace, observedRun?.workspace)) {
                 throw new Error("Runtime terminal workspace changed during result preparation.");
             }
             if (workspace !== undefined && observedRun?.workspace !== undefined
@@ -3132,8 +3170,7 @@ function sameRuntimeOwner(left, right) {
 }
 function dormantRuntimeCandidateIsCurrent(store, candidate, allowActiveRun = false) {
     const { owner } = candidate;
-    if (!allowActiveRun && owner.scope === "task"
-        && store.getActiveRun(owner.taskId, owner.roleName) !== null) {
+    if (!allowActiveRun && runtimeOwnerHasActiveWork(store, owner)) {
         return false;
     }
     const sessions = runtimeOwnerSessionSet(store, owner);
@@ -3143,6 +3180,17 @@ function dormantRuntimeCandidateIsCurrent(store, candidate, allowActiveRun = fal
     return active !== undefined && active.agentId === candidate.agentId && active.adapterId === candidate.adapterId
         && active.nativeSessionId === candidate.nativeSessionId && (allowActiveRun || active.updatedAt === candidate.sessionUpdatedAt);
 }
+function runtimeOwnerHasActiveWork(store, owner) {
+    if (owner.scope === "task")
+        return store.getActiveRun(owner.taskId, owner.roleName) !== null;
+    // Global Turns do not have Task AgentRun records. Use their existing native
+    // delivery binding, including submitting and uncertain acceptance.
+    const sessions = store.getGlobalRoleSessionSet(owner.roleName);
+    const binding = sessions?.providerBinding;
+    return binding != null && (providerTurnIsActive(binding.run)
+        || currentProviderConversation(binding).conversationId
+            !== sessions?.sessions[sessions.activeAgentId]?.nativeSessionId);
+}
 function endRuntimeOwnerSession(store, owner, now) {
     if (owner.scope === "task") {
         const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);

package/dist/controller/messageHealth.js

@@ -91,13 +91,14 @@ function recoveryGuidance(o) {
         if (o.wakeId !== null && roleName === "leader") {
             const wakeTarget = `${arg(taskId)} ${arg(o.wakeId)}`;
             if (o.deliveryEvidence?.outcome === "rejected") {
-                lines.push(`After correcting the rejection cause, and only if this exact wake is still unconsumed, its original claim matches and native acceptance/activity are proven absent: yui task wake retry ${wakeTarget} --reason '<verified correction and quiescence>'. Queued is not accepted. Do not retry accepted/unknown input. This candidate does not establish resolve support for rejected wakes; do not assume another recovery package is installed.`);
+                lines.push(`Choose alternative actions, not a sequence. After correcting the rejection cause, and only if this exact wake is still unconsumed, its original claim matches and native acceptance/activity are proven absent: yui task wake retry ${wakeTarget} --reason '<verified correction and quiescence>'. Queued is not accepted. Do not retry accepted/unknown input.`);
+                lines.push(`Alternatively, after exact shared-native/background/writer quiescence and persisted notification-attempt evidence: yui task wake resolve ${wakeTarget} --reason '<exact quiescence evidence>'. A rejection is not quiescence, including rejection after an unknown outcome. Resolve releases only scheduling without replay, ACK or acceptance; it preserves original claims and delivery evidence. If the operational mailbox is absent, the exact durable wake/attempt must still be proven; another current batch is never released. The rightful handler must inspect original effects and settle still-valid obligations separately.`);
             }
             else if (o.deliveryEvidence?.outcome === "unknown") {
-                lines.push(`Do not replay unknown input. After exact shared-native/background/writer quiescence and persisted evidence, with the original unknown claim still current: yui task wake resolve ${wakeTarget} --reason '<exact quiescence evidence>'. This releases only scheduling without replay, ACK or acceptance. The rightful handler must inspect original effects and settle still-valid obligations separately.`);
+                lines.push(`Do not replay unknown input. After exact shared-native/background/writer quiescence and persisted evidence identifying the original wake/notification attempt: yui task wake resolve ${wakeTarget} --reason '<exact quiescence evidence>'. This releases only scheduling without replay, ACK or acceptance; an absent operational mailbox requires exact durable evidence, never release of another current batch. The rightful handler must inspect original effects and settle still-valid obligations separately.`);
             }
             else {
-                lines.push("Deferred, accepted or unreported delivery does not meet this candidate's rejected-retry/unknown-resolve preconditions. Keep the original wake and inspect the runtime barrier instead of mechanically invoking either action.");
+                lines.push("Deferred, accepted or unreported delivery does not meet this candidate's rejected-retry/unknown-or-rejected-resolve preconditions. Keep the original wake and inspect the runtime barrier instead of mechanically invoking either action.");
             }
         }
     }

package/dist/controller/providerRetryAdmission.js

@@ -4,6 +4,7 @@ import { blockingProviderContinuations } from "../runtime/runtimeContinuationPro
 import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { isDeepStrictEqual } from "node:util";
 import { isHandlingReminder } from "../message/inboxTurn.js";
+import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 export function ownedProviderInput(input) {
     if (input.runId !== undefined && input.taskId !== undefined) {
         return { kind: "run", taskId: input.taskId, runId: input.runId };
@@ -90,8 +91,21 @@ export function admitOwnedProviderInput(store, binding, input) {
     if (input.taskId !== undefined && input.runId !== undefined) {
         const run = store.getRun(input.taskId, input.runId);
         const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+        const session = sessions?.sessions[input.agentId];
+        // Session provenance can describe an older ReviewRound. The exact failed
+        // Run, not that first launch, owns this retry's frozen launch configuration.
+        // Continuity still fences the native Session's physical workspace/authority;
+        // exact equality with the failed Run retains model, permission and candidate.
+        const previous = run?.purpose === "review" && retry.previousRunId !== undefined
+            ? store.getRun(input.taskId, retry.previousRunId) : null;
+        const matchesLaunch = run !== null && session !== undefined && (run.purpose === "review"
+            ? previous?.status === "failed" && previous.purpose === "review"
+                && previous.roleName === run.roleName && previous.reviewRoundId === run.reviewRoundId
+                && isDeepStrictEqual(run.effective, previous.effective)
+                && roleSessionMayContinue(session.effective, run.effective)
+            : isDeepStrictEqual(run.effective, session.effective));
         if (run === null || run.status !== "active"
-            || !isDeepStrictEqual(run.effective, sessions?.sessions[input.agentId]?.effective)) {
+            || !matchesLaunch) {
             throw new Error("Retry execution no longer matches its fixed native Session.");
         }
         if (run.workspace !== undefined && !isDeepStrictEqual(store.getManagedWorkspace(run.workspace.owner), run.workspace)) {

package/dist/controller/providerRetryDelivery.js

@@ -171,9 +171,25 @@ export function createProviderRetryHooks(home, store, ports = {}) {
                     }
                     try {
                         if (owner.scope === "task" && retry.previousRunId !== undefined) {
-                            if (retry.successorRunId !== undefined || retry.successorReviewRoundId !== undefined)
-                                continue;
                             const previous = store.getRun(owner.taskId, retry.previousRunId);
+                            if (retry.successorRunId !== undefined || retry.successorReviewRoundId !== undefined) {
+                                const round = retry.successorReviewRoundId === undefined
+                                    ? null : store.getReviewRound(owner.taskId, retry.successorReviewRoundId);
+                                const successorId = retry.successorRunId ?? (previous?.executionLaneId === undefined
+                                    ? round?.reviewerRunId
+                                    : round?.executionGroup?.lanes.find(lane => lane.id === previous.executionLaneId)?.currentRunId);
+                                const successor = successorId === undefined ? null : store.getRun(owner.taskId, successorId);
+                                // A scheduled Run can fail before Host admission, leaving the
+                                // Provider binding on the original failed Turn. Stop waiting;
+                                // this is not proof of native quiescence or permission to replay.
+                                if (successor?.status === "failed" && successor.id !== previous?.id
+                                    && successor.roleName === owner.roleName
+                                    && (retry.successorReviewRoundId === undefined
+                                        || successor.reviewRoundId === retry.successorReviewRoundId)) {
+                                    stop(set, "successor-failed-before-admission", at);
+                                }
+                                continue;
+                            }
                             if (previous?.status === "active")
                                 continue; // ordinary rejected-delivery terminal fold
                             if (previous?.status !== "failed") {

package/dist/controller/runtime.js

@@ -89,6 +89,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         const running = await createFileTaskControllerRuntime(home, {
             ...options,
             diagnosticMetrics: () => diagnostics.metrics(),
+            onRequestDiagnostic: record => diagnostics.request(record),
             onError: error => { diagnostics.error(error); options.onError?.(error); }
         });
         let expectedAt = monotonicMilliseconds() + 250;
@@ -221,7 +222,7 @@ async function createFileTaskControllerRuntime(home, options) {
                         && typeof session.nativeSessionId === "string" && session.nativeSessionId.trim().length > 0) {
                         return session.nativeSessionId;
                     }
-                    for (const event of runtimeEventInbox.list()) {
+                    for (const event of await runtimeEventInbox.listAsync()) {
                         if (event.type === "runtime-observation" && event.observation.kind === "session.started"
                             && event.observation.fence.taskId === owner.taskId
                             && event.observation.fence.roleName === owner.roleName
@@ -416,7 +417,7 @@ async function createFileTaskControllerRuntime(home, options) {
                 store,
                 environment: options.environment
             });
-        const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, launchCoordinator, planner);
+        const lifecycleDispatcher = createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, options.dispatcher, launchCoordinator, planner, workerMaintenance ? asyncStoreClient : undefined);
         // Process-exit observations are persisted by the Agent Host before socket
         // delivery. Drain them while this Controller is still the only storage
         // writer and before it begins accepting new work after a handover.
@@ -607,6 +608,7 @@ async function createFileTaskControllerRuntime(home, options) {
             now: options.now,
             onError: options.onError,
             diagnosticMetrics: options.diagnosticMetrics,
+            onRequestDiagnostic: options.onRequestDiagnostic,
             lifecycleHost,
             providerRetry: createProviderRetryHooks(home, store, {
                 now: options.now,
@@ -753,7 +755,7 @@ async function createFileTaskControllerRuntime(home, options) {
         throw error;
     }
 }
-export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, fallback, sharedLaunchCoordinator, environmentRefresher) {
+export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionHost, fallback, sharedLaunchCoordinator, environmentRefresher, observationWorker) {
     const launchCoordinator = sharedLaunchCoordinator
         ?? new RuntimeLaunchCoordinator(schedulerStore, sessionHost, {
             assertCurrent: (request) => {
@@ -774,12 +776,20 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             if (event.type !== "runtime-observation" || event.host === undefined) {
                 throw applicationError("INVALID_PARAMS", "Expected an Agent Host observation.");
             }
-            return { outcome: schedulerStore.observeAgentHostObservation(event, new Date()) };
+            // Eager Host delivery and the normal Inbox drainer fold the same durable
+            // fact. Share their existing worker writer: a second synchronous writer
+            // here can wait on BEGIN IMMEDIATE and starve even status socket I/O.
+            // Await the original atomic fold; no eager ACK or cursor advancement.
+            return { outcome: observationWorker === undefined
+                    ? schedulerStore.observeAgentHostObservation(event, new Date())
+                    : await observationWorker.invokeObserver("observeAgentHostObservation", [event, new Date()]) };
         }
         if (method === "runtime.observation-apply") {
             try {
                 return {
-                    outcome: schedulerStore.observeRuntimeObservation(createRuntimeObservation(params), new Date())
+                    outcome: observationWorker === undefined
+                        ? schedulerStore.observeRuntimeObservation(createRuntimeObservation(params), new Date())
+                        : await observationWorker.invokeObserver("observeRuntimeObservation", [createRuntimeObservation(params), new Date()])
                 };
             }
             catch (error) {