@zq-silk/yui 0.11.3 → 0.12.1

package/dist/review/reviewOutcomeClassifier.js

@@ -62,7 +62,7 @@ export function classifyReviewRoundOutcome(round, evidence) {
             reason: corroborationFailure
         };
 }
-/** True only when a Round may consume semantic Review budget or feed findings. */
+/** True only when a Round contains semantic Reviewer evidence. */
 export function isSemanticReviewRound(round, evidence) {
     return classifyReviewRoundOutcome(round, evidence)?.kind === "semantic";
 }

package/dist/review/reviewRound.js

@@ -120,7 +120,7 @@ export function finishReviewRound(round, status, summary, now, result = {}) {
         return terminal;
     }
     // Fail closed: a completed delta Round without an explicit, valid
-    // disposition escalates to a full Review.  Uncertainty never accepts.
+    // disposition remains non-accepting for Leader routing. Uncertainty never accepts.
     const disposition = result.deltaDisposition ?? "requires-full-review";
     const reasoning = result.deltaReasoning ?? result.report ?? summary;
     return validateReviewRound({

package/dist/review/reviewerAvailability.js

@@ -0,0 +1,69 @@
+import { nextPendingBatch, mailboxHasWork } from "../coordination/workMailbox.js";
+import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+/** One authoritative read-only projection for a Task Reviewer Role slot. */
+export function projectReviewerAvailability(store, taskId, reviewerRoleName) {
+    const active = store.getActiveAgentRun(taskId, reviewerRoleName)
+        ?? store.listAgentRuns(taskId).find((run) => (run.roleName === reviewerRoleName && run.status === "active"));
+    if (active !== null && active !== undefined) {
+        return {
+            kind: "busy",
+            reviewerRoleName,
+            phase: "active-run",
+            activeRunId: active.id,
+            ...(active.reviewRoundId === undefined
+                ? {}
+                : { activeReviewRoundId: active.reviewRoundId }),
+            startedAt: active.createdAt,
+            retryable: true,
+            retryAfterSeconds: 5
+        };
+    }
+    const activeRound = store.listReviewRounds(taskId).find((round) => ((round.scope ?? "work-item") === "task"
+        && (round.status === "pending" || round.status === "running")
+        && (round.reviewerRoleName === reviewerRoleName
+            || round.executionGroup?.lanes.some(({ roleName }) => roleName === reviewerRoleName) === true)));
+    if (activeRound !== undefined) {
+        return {
+            kind: "busy",
+            reviewerRoleName,
+            phase: "review-slot",
+            activeReviewRoundId: activeRound.id,
+            startedAt: activeRound.createdAt,
+            retryable: true,
+            retryAfterSeconds: 5
+        };
+    }
+    const reviewerMailbox = store.getWorkMailbox({
+        kind: "role",
+        taskId,
+        roleName: reviewerRoleName
+    });
+    if (reviewerMailbox !== null && mailboxHasWork(reviewerMailbox)) {
+        return mailboxBusy(reviewerRoleName, "mailbox", reviewerMailbox);
+    }
+    const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
+        scope: "task",
+        taskId,
+        roleName: reviewerRoleName
+    }));
+    if (runtimeMailbox !== null && mailboxHasWork(runtimeMailbox)) {
+        return mailboxBusy(reviewerRoleName, "runtime-lifecycle", runtimeMailbox);
+    }
+    return {
+        kind: "available",
+        reviewerRoleName,
+        retryable: true
+    };
+}
+function mailboxBusy(reviewerRoleName, phase, mailbox) {
+    const pending = nextPendingBatch(mailbox);
+    const startedAt = mailbox.processing?.startedAt ?? pending?.firstQueuedAt;
+    return {
+        kind: "busy",
+        reviewerRoleName,
+        phase,
+        ...(startedAt === undefined ? {} : { startedAt }),
+        retryable: true,
+        retryAfterSeconds: 5
+    };
+}

package/dist/run/recoveryProjection.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
+import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
+import { runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
 export const RUN_RECOVERY_ACTIONS = [
     "diagnose",
     "retry",
-    "replace-session",
     "terminate"
 ];
 /**
@@ -17,13 +18,32 @@ export function readRunRecoveryFacts(store, taskId, runId) {
         return null;
     const task = store.getTask(taskId);
     const sessionSet = store.getTaskRoleSessionSet(taskId, run.roleName);
+    const events = store.listEvents(taskId);
+    const roleMailbox = store.getWorkMailbox?.({
+        kind: "role",
+        taskId,
+        roleName: run.roleName
+    }) ?? null;
     const progress = latestRunDurableProgressAt(store, taskId, run.roleName, runId);
     return {
         run,
         task: task === null ? null : { id: task.id, status: task.status },
         sessionSet,
+        inputDeliveryUnsettled: roleMailbox?.inputDelivery != null,
+        blockingProviderContinuation: runOwnsBlockingProviderContinuation(events, {
+            taskId,
+            roleName: run.roleName,
+            runId: run.id,
+            agentId: run.effective.agentId
+        }),
+        activeRuntimeOperation: runHasActiveRuntimeOperations(events, {
+            taskId,
+            roleName: run.roleName,
+            runId: run.id,
+            agentId: run.effective.agentId
+        }),
         progress,
-        latestProviderObservation: latestRunProviderObservation(store.listEvents(taskId), runId)
+        latestProviderObservation: latestRunProviderObservation(events, runId)
     };
 }
 /**
@@ -72,9 +92,12 @@ export function projectRunRecovery(facts) {
         ? ["accepted", "ambiguous"]
         : ["rejected", "ambiguous"];
     const blocked = recoveryBlocker(facts, session, canonicalProgressAt);
-    const supportedActions = session?.status === "stopped" || session?.status === "broken"
-        ? RUN_RECOVERY_ACTIONS.filter((action) => action !== "retry")
-        : RUN_RECOVERY_ACTIONS;
+    const sessionTerminal = session?.status === "stopped" || session?.status === "broken";
+    const providerTerminal = sessionSet?.providerBinding?.turn?.status === "failed"
+        || sessionSet?.providerBinding?.turn?.status === "cancelled"
+        || sessionSet?.providerBinding?.turn?.status === "rejected";
+    const supportedActions = RUN_RECOVERY_ACTIONS.filter((action) => ((action !== "retry" || !sessionTerminal)
+        && (action !== "terminate" || sessionTerminal || providerTerminal)));
     const actions = blocked === null
         ? supportedActions.map((action) => buildActionPlan(facts, action, session, canonicalProgressAt))
         : [];
@@ -139,6 +162,23 @@ function recoveryBlocker(facts, session, canonicalProgressAt) {
         return "progress-unavailable";
     if (session === null)
         return "session-missing";
+    if (facts.inputDeliveryUnsettled)
+        return "provider-input-delivery-unsettled";
+    if (facts.blockingProviderContinuation)
+        return "provider-continuation-writer-owned";
+    if (facts.activeRuntimeOperation)
+        return "provider-operation-active";
+    const binding = facts.sessionSet?.providerBinding;
+    if (run.deliveredAt !== undefined
+        && (binding === null || binding?.turn === null))
+        return "provider-turn-state-missing";
+    if (binding !== null && binding !== undefined) {
+        if (["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn?.status ?? ""))
+            return "provider-turn-unsettled";
+        if (binding.authority.owner === "human" || binding.authority.owner === "unknown") {
+            return "provider-writer-authority-unavailable";
+        }
+    }
     return null;
 }
 function buildActionPlan(facts, action, session, canonicalProgressAt) {
@@ -208,6 +248,5 @@ function actionAcceptance(facts, action) {
 const ACTION_REASONS = {
     diagnose: "Collect bounded diagnostics before any state-changing recovery.",
     retry: "Request another provider turn on the same native Session when the failure is transient.",
-    "replace-session": "Request a fresh native Session when the current one is unusable.",
     terminate: "Fail the Run explicitly when recovery is not viable."
 };

package/dist/runtime/agentDriverObservation.js

@@ -33,18 +33,24 @@ export function mapAgentDriverUsage(input, usage) {
     });
 }
 function observation(input, mapped) {
-    const eventId = hookEventId(input, mapped);
+    const requestOccurrenceId = mapped.kind === "activity.observed"
+        && mapped.payload.usage?.semantics === "request-context"
+        ? requireRequestOccurrenceId(mapped.payload.activityId)
+        : undefined;
+    const eventId = hookEventId(input, mapped, requestOccurrenceId);
     const fence = { ...input.fence, ...mapped.fence };
     return createRuntimeObservation({
         schemaVersion: 2,
         eventId,
-        semanticKey: runtimeObservationSemanticKey({
-            eventId,
-            kind: mapped.kind,
-            fence,
-            ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
-            payload: mapped.payload
-        }),
+        semanticKey: requestOccurrenceId === undefined
+            ? runtimeObservationSemanticKey({
+                eventId,
+                kind: mapped.kind,
+                fence,
+                ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
+                payload: mapped.payload
+            })
+            : `provider-request:${eventId}`,
         kind: mapped.kind,
         authority: "provider-structured",
         receivedAt: input.receivedAt,
@@ -60,13 +66,21 @@ function requireMatchingDriver(input) {
         throw new Error("Agent Driver Hook fence does not match the selected Driver.");
     }
 }
-function hookEventId(input, mapped) {
+function hookEventId(input, mapped, requestOccurrenceId) {
     const digest = createHash("sha256").update(JSON.stringify([
         input.driver.id,
         input.hookEventName,
         input.fence,
         mapped.kind,
-        mapped.payload
+        ...(requestOccurrenceId === undefined
+            ? [mapped.payload]
+            : [{ requestOccurrenceId }])
     ])).digest("hex");
     return `runtime-observation-${digest}`;
 }
+function requireRequestOccurrenceId(value) {
+    if (value === undefined || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error("Request-context usage requires a stable activity id.");
+    }
+    return value.trim();
+}

package/dist/runtime/agentHost.js

@@ -1,18 +1,20 @@
 import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, chmodSync, closeSync, fsyncSync, mkdirSync, openSync, rmSync } from "node:fs";
-import { readdir, readFile, rename, unlink } from "node:fs/promises";
+import { chmodSync, mkdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createConnection, createServer } from "node:net";
 import { createInterface } from "node:readline";
-import { callController, ControllerClientError } from "../core/controllerClient.js";
+import { callController, controllerCallMayHaveApplied, ControllerClientError } from "../core/controllerClient.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
+import { callFileTaskController } from "../controller/clientRuntime.js";
+import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { publishStructuredProviderAccepted, publishStructuredProviderActivationTerminal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
 import { validateAgentHostLaunchPayload } from "./launchBroker.js";
 import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
-import { readRuntimeStopReceipt, removeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
+import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
+import { readRuntimeStopReceipt, removeRuntimeStopReceipt, writeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
 import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
 export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v2";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
@@ -26,6 +28,7 @@ export async function runAgentHost(input) {
     let session;
     let sessionPayload;
     let activeTurnPayload;
+    const switchDetachedSessions = new WeakSet();
     let activationId;
     let conversationRecoverability = "unknown";
     let authority;
@@ -116,19 +119,21 @@ export async function runAgentHost(input) {
             const stopReceipt = readRuntimeStopReceipt(input.home, currentPayload.launchId);
             const observedAt = new Date().toISOString();
             const failures = [];
-            try {
-                await publishStructuredProviderActivationTerminal({
-                    home: input.home,
-                    environment: currentPayload.environment,
-                    conversationId: providerSession.conversationId,
-                    nativeSessionId: providerSession.nativeSessionId,
-                    activationId: currentActivationId,
-                    status: stopReceipt !== null || hostStopRequested ? "ended" : "failed",
-                    observedAt
-                });
-            }
-            catch (error) {
-                failures.push(`activation terminal: ${errorText(error)}`);
+            if (!switchDetachedSessions.has(providerSession)) {
+                try {
+                    await publishStructuredProviderActivationTerminal({
+                        home: input.home,
+                        environment: currentPayload.environment,
+                        conversationId: providerSession.conversationId,
+                        nativeSessionId: providerSession.nativeSessionId,
+                        activationId: currentActivationId,
+                        status: stopReceipt !== null || hostStopRequested ? "ended" : "failed",
+                        observedAt
+                    });
+                }
+                catch (error) {
+                    failures.push(`activation terminal: ${errorText(error)}`);
+                }
             }
             let exitPersisted = false;
             try {
@@ -163,7 +168,7 @@ export async function runAgentHost(input) {
             if (stopReceipt !== null && exitPersisted) {
                 removeRuntimeStopReceipt(input.home, currentPayload.launchId);
             }
-            if (hostStopRequested)
+            if (hostStopRequested || !ownsCurrentSession)
                 return;
             updateSnapshot(hostSnapshot(failures.length === 0 ? "exited" : "failed", {
                 launchId: currentPayload.launchId,
@@ -196,9 +201,12 @@ export async function runAgentHost(input) {
             throw new Error("Agent Host still owns an unsettled Provider Turn.");
         }
         const requestedAuthority = validateProviderAuthorityFence(providerControl.authority);
-        if (authority === undefined)
+        const replacesCurrentConversation = session !== undefined && providerControl.kind === "new";
+        if (!replacesCurrentConversation && authority === undefined)
             authority = requestedAuthority;
-        else if (!sameProviderAuthorityFence(authority, requestedAuthority)) {
+        else if (!replacesCurrentConversation
+            && authority !== undefined
+            && !sameProviderAuthorityFence(authority, requestedAuthority)) {
             throw new Error("Agent Host launch carries a stale Provider authority fence.");
         }
         updateSnapshot(hostSnapshot("starting", {
@@ -217,6 +225,43 @@ export async function runAgentHost(input) {
         let providerAcceptedAttemptId;
         let durableInitialTurn;
         try {
+            if (replacesCurrentConversation) {
+                const previousSession = session;
+                const previousPayload = sessionPayload;
+                const previousActivationId = activationId ?? previousPayload?.launchId;
+                if (previousPayload === undefined || previousActivationId === undefined
+                    || authority?.owner !== "controller") {
+                    throw new Error("Agent Host cannot detach an inexact Provider Activation.");
+                }
+                await detachDurableProviderForConversationSwitch(input.home, {
+                    taskId: requiredEnvironment(next.environment.YUI_TASK_ID, "Task id"),
+                    roleName: requiredEnvironment(next.environment.YUI_ROLE, "Role name"),
+                    runId: requiredEnvironment(next.environment.YUI_RUN_ID, "Run id"),
+                    agentId: requiredEnvironment(next.environment.YUI_AGENT_ID, "Agent id"),
+                    launchId: next.launchId,
+                    previousConversationId: previousSession.conversationId,
+                    previousNativeSessionId: previousSession.nativeSessionId,
+                    previousActivationId,
+                    nextAuthorityEpoch: requestedAuthority.epoch,
+                    nextAuthorityHolderId: requestedAuthority.holderId,
+                    observedAt: new Date().toISOString()
+                });
+                switchDetachedSessions.add(previousSession);
+                // The persistent Provider child belongs to the Activation that first
+                // created it, not to the most recent resume Run payload. The exit
+                // observer carries that Activation launch id, so the stop receipt must
+                // use the same identity or the expected switch detach is misclassified
+                // as an abnormal child exit and generic cleanup can kill the Host.
+                writeRuntimeStopReceipt(input.home, previousActivationId, new Date());
+                authority = undefined;
+                await terminateProviderSessionForConversationSwitch(previousSession);
+                if (session === previousSession)
+                    session = undefined;
+                sessionPayload = undefined;
+                activationId = undefined;
+                conversationRecoverability = "unknown";
+                authority = requestedAuthority;
+            }
             if (session !== undefined) {
                 if (session.adapterId !== providerControl.adapterId
                     || providerControl.mode !== "resume"
@@ -493,30 +538,12 @@ export async function runAgentHost(input) {
                 }
             };
             const durableTurn = hostTurnControlParams(currentPayload, currentSession.nativeSessionId, currentAuthority, attemptId);
-            try {
-                await beginDurableProviderTurn(input.home, durableTurn);
-            }
-            catch (error) {
-                await callController(input.home, "runtime.provider-turn-submission-resolve", {
-                    ...durableTurn,
-                    status: "rejected",
-                    reason: `Human Turn intent acknowledgement failed before Provider write: ${errorText(error)}`,
-                    observedAt: new Date().toISOString()
-                }).catch(() => { });
-                throw error;
-            }
+            await beginDurableProviderTurn(input.home, durableTurn);
             try {
                 await submitTurn(turnControl);
             }
             catch (error) {
-                await callController(input.home, "runtime.provider-turn-submission-resolve", {
-                    ...durableTurn,
-                    status: error instanceof ProviderDeliveryUnknownError
-                        ? "delivery-unknown"
-                        : "rejected",
-                    reason: errorText(error),
-                    observedAt: new Date().toISOString()
-                }).catch(() => { });
+                await resolveProviderTurnSubmission(input.home, durableTurn, error);
                 throw error;
             }
             process.stdout.write("Provider accepted the human Turn; waiting for its terminal boundary.\n");
@@ -670,50 +697,19 @@ async function redeem(home, launchId, ticket) {
     return validateAgentHostLaunchPayload(result);
 }
 async function persistAndSubmitExit(home, observation) {
-    const directory = resolve(join(home, "runtime", "agent-host-outbox"));
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    const path = join(directory, `${observation.hostInstanceId}.jsonl`);
-    const descriptor = openSync(path, "a", 0o600);
     try {
-        appendFileSync(descriptor, `${JSON.stringify(observation)}\n`, "utf8");
-        fsyncSync(descriptor);
-    }
-    finally {
-        closeSync(descriptor);
-    }
-    chmodSync(path, 0o600);
-    await callController(home, "runtime.process-exit-observe", observation);
-    rmSync(path, { force: true });
-}
-async function replayExitOutbox(home) {
-    const directory = resolve(join(home, "runtime", "agent-host-outbox"));
-    let entries;
-    try {
-        entries = await readdir(directory);
+        await persistRuntimeProcessExitObservation(home, observation, (value) => callController(home, "runtime.process-exit-observe", value).then(() => undefined));
     }
     catch (error) {
-        if (error.code === "ENOENT")
+        // The durable outbox is the acknowledgement during a planned Controller
+        // gap. The replacement Controller drains it before accepting new work.
+        if (isForeignHandoverLockHeld(home))
             return;
         throw error;
     }
-    for (const name of entries.filter((value) => value.includes(".jsonl")).sort()) {
-        const path = join(directory, name);
-        const claimed = `${path}.claim-${process.pid}-${randomUUID()}`;
-        try {
-            await rename(path, claimed);
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                continue;
-            throw error;
-        }
-        const lines = (await readFile(claimed, "utf8")).split("\n").filter(Boolean);
-        for (const line of lines) {
-            const observation = validateRuntimeProcessExitObservation(JSON.parse(line));
-            await callController(home, "runtime.process-exit-observe", observation);
-        }
-        await unlink(claimed);
-    }
+}
+async function replayExitOutbox(home) {
+    await replayRuntimeProcessExitOutbox(home, (observation) => callController(home, "runtime.process-exit-observe", observation).then(() => undefined));
 }
 /** Internal socket boundary exported for transport-level verification. */
 export async function openAgentHostControl(home, payload, snapshot, dispatch) {
@@ -906,26 +902,104 @@ function hostTurnControlParams(payload, nativeSessionId, authority, attemptId) {
 }
 async function beginDurableProviderTurn(home, durableTurn) {
     try {
-        await callController(home, "runtime.provider-turn-begin", durableTurn);
+        await callControllerIdempotently(home, "runtime.provider-turn-begin", durableTurn);
+    }
+    catch (error) {
+        if (!(error instanceof ControllerAcknowledgementUnknownError))
+            throw error;
+        await resolveProviderTurnSubmission(home, durableTurn, new Error(`Provider Turn intent acknowledgement failed before Provider write: ${errorText(error)}`));
+        throw error;
+    }
+}
+async function detachDurableProviderForConversationSwitch(home, request) {
+    await callControllerIdempotently(home, "runtime.conversation-switch-detach", request);
+}
+async function callControllerIdempotently(home, method, request) {
+    try {
+        await callAgentController(home, method, request);
     }
     catch (error) {
-        if (!(error instanceof ControllerClientError) || error.code !== "INTERNAL_ERROR") {
+        if (!(error instanceof ControllerClientError)
+            || (error.code !== "INTERNAL_ERROR" && !controllerCallMayHaveApplied(error))) {
             throw error;
         }
-        // The exact attempt is idempotent, so one lost acknowledgement can be
-        // retried without creating a second Provider write.
-        await callController(home, "runtime.provider-turn-begin", durableTurn);
+        const firstCallMayHaveApplied = controllerCallMayHaveApplied(error);
+        // These methods carry exact attempt, launch, and authority fences. A
+        // bounded replay confirms a commit whose acknowledgement may have been lost.
+        try {
+            await callAgentController(home, method, request);
+        }
+        catch (replayError) {
+            if (firstCallMayHaveApplied || controllerCallMayHaveApplied(replayError)) {
+                throw new ControllerAcknowledgementUnknownError(`${method} may have been committed, but its acknowledgement could not be confirmed: ${errorText(replayError)}`);
+            }
+            throw replayError;
+        }
+    }
+}
+class ControllerAcknowledgementUnknownError extends Error {
+    name = "ControllerAcknowledgementUnknownError";
+}
+async function terminateProviderSessionForConversationSwitch(providerSession) {
+    providerSession.terminate("SIGTERM");
+    const forceKill = setTimeout(() => providerSession.terminate("SIGKILL"), 3_000);
+    forceKill.unref();
+    let hardTimeout;
+    const timeout = new Promise((_resolve, reject) => {
+        hardTimeout = setTimeout(() => reject(new Error("Old Provider Activation did not exit after its switch authority was revoked.")), 8_000);
+        hardTimeout.unref();
+    });
+    try {
+        await Promise.race([providerSession.waitForExit(), timeout]);
+    }
+    finally {
+        clearTimeout(forceKill);
+        if (hardTimeout !== undefined)
+            clearTimeout(hardTimeout);
     }
 }
 async function resolveProviderTurnSubmission(home, durableTurn, error) {
-    await callController(home, "runtime.provider-turn-submission-resolve", {
+    const attemptId = durableTurn.attemptId;
+    if (typeof attemptId !== "string") {
+        throw new Error("Provider Turn resolution has no attempt id.");
+    }
+    const request = {
         ...durableTurn,
         status: error instanceof ProviderDeliveryUnknownError
             ? "delivery-unknown"
             : "rejected",
         reason: errorText(error),
         observedAt: new Date().toISOString()
-    }).catch(() => { });
+    };
+    try {
+        await callControllerIdempotently(home, "runtime.provider-turn-submission-resolve", request);
+    }
+    catch (resolutionError) {
+        throw new ProviderDeliveryUnknownError(`Provider submission outcome could not be durably resolved: ${errorText(resolutionError)}. Original outcome: ${errorText(error)}`, attemptId);
+    }
+}
+/**
+ * Existing in-flight launches keep using the old Controller while it drains.
+ * If the socket is already gone under an explicit handover fence, wait for
+ * the replacement and retry the domain-idempotent Agent Host operation.
+ */
+async function callAgentController(home, method, params) {
+    try {
+        await callController(home, method, params);
+        return;
+    }
+    catch (error) {
+        if (!isControllerUnavailable(error) || !isForeignHandoverLockHeld(home)) {
+            throw error;
+        }
+    }
+    await callFileTaskController(home, method, params);
+}
+function isControllerUnavailable(error) {
+    return error instanceof ControllerClientError
+        && (error.code === "CONTROLLER_NOT_RUNNING"
+            || error.code === "CONTROLLER_UNAVAILABLE"
+            || error.code === "CONTROLLER_DRAINING");
 }
 function requiredEnvironment(value, label) {
     if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {

package/dist/runtime/builtinAgentDrivers.js

@@ -51,8 +51,8 @@ const STRUCTURED_CLI_CAPABILITIES = Object.freeze({
         preInputReadiness: "unavailable",
         promptAcceptance: "exact",
         turnLifecycle: "exact",
-        // Model activity is inferred from usage deltas; these are the operation
-        // boundaries the current Hook surfaces actually expose.
+        // Transcript sources may emit an explicit activity identity separately
+        // from usage snapshots. Numeric token values never decide runtime health.
         operations: Object.freeze(["tool", "subagent"]),
         waiting: Object.freeze(["permission"]),
         usage: "streaming-cumulative",
@@ -70,7 +70,8 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
             observation: Object.freeze({
                 ...STRUCTURED_CLI_CAPABILITIES.observation,
                 sessionBootstrap: "preallocated",
-                preInputReadiness: "exact"
+                preInputReadiness: "exact",
+                usage: "event-snapshot"
             })
         }),
         runtime: Object.freeze({