@zq-silk/yui 0.15.9 → 0.15.12

package/dist/runtime/agentHostProtocol.js

@@ -0,0 +1,53 @@
+import { createSessionOwnerIdentity } from "./sessionOwnerIdentity.js";
+/** Independent of CLI/RPC and Home schema. Keep v1 readable while v1 Hosts live. */
+export const AGENT_HOST_EVENT_PROTOCOL = "yui-agent-host-events/v1";
+export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v5";
+export function readAgentHostObservationSource(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Agent Host observation source is invalid.");
+    }
+    const source = value;
+    if (source.protocol !== AGENT_HOST_EVENT_PROTOCOL) {
+        throw new Error("Agent Host event protocol is unsupported.");
+    }
+    if (source.connection !== undefined && (source.connection === null
+        || typeof source.connection !== "object" || Array.isArray(source.connection))) {
+        throw new Error("Agent Host connection evidence is invalid.");
+    }
+    if (source.connection?.processOwner !== undefined
+        && (source.connection.processOwner.schemaVersion !== 2
+            || source.connection.processOwner.kind !== "yui-session-owner")) {
+        throw new Error("Agent Host process custody wire contract is invalid.");
+    }
+    const text = (value) => {
+        if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > 4096) {
+            throw new Error("Agent Host observation identity is invalid.");
+        }
+        return value;
+    };
+    return {
+        protocol: AGENT_HOST_EVENT_PROTOCOL,
+        adapterId: text(source.adapterId),
+        workspace: text(source.workspace),
+        ...(source.startupRunId === undefined ? {} : { startupRunId: text(source.startupRunId) }),
+        ...(source.connection === undefined ? {} : {
+            connection: {
+                ...(source.connection.processOwner === undefined ? {} : {
+                    processOwner: createSessionOwnerIdentity({
+                        ...source.connection.processOwner,
+                        recordedAt: new Date(source.connection.processOwner.recordedAt)
+                    })
+                }),
+                ...(source.connection.account === undefined ? {} : {
+                    account: {
+                        home: text(source.connection.account.home),
+                        codexHome: text(source.connection.account.codexHome),
+                        ...(source.connection.account.nativeAccountHome === undefined ? {} : {
+                            nativeAccountHome: text(source.connection.account.nativeAccountHome)
+                        })
+                    }
+                })
+            }
+        })
+    };
+}

package/dist/runtime/builtinAgentErrorMappers.js

@@ -1,5 +1,8 @@
 /** Provider-specific Claude Code failure recognition. */
 export function mapClaudeAgentError(input) {
+    return withTransientEvidence(mapClaudeDisplayError(input), input);
+}
+function mapClaudeDisplayError(input) {
     const text = `${input.message}\n${input.raw}`;
     if (/^No conversation found with session ID: [A-Za-z0-9-]+\.?$/imu.test(input.message)) {
         return sessionUnavailable("provider.session-not-found");
@@ -23,6 +26,9 @@ export function mapClaudeAgentError(input) {
 }
 /** Provider-specific Codex failure recognition. */
 export function mapCodexAgentError(input) {
+    return withTransientEvidence(mapCodexDisplayError(input), input);
+}
+function mapCodexDisplayError(input) {
     const text = `${input.message}\n${input.raw}`;
     if (/^server_error$/iu.test(input.message)) {
         return recoverable("availability", "provider.server-error");
@@ -200,3 +206,88 @@ function sessionUnavailable(code) {
         sessionDisposition: "unrecoverable"
     });
 }
+/** Replay qualification is stricter than the readable, best-effort category.
+ * Never promote a number occurring in provider prose to submission safety. */
+function structuredTransientError(input) {
+    if (/insufficient[_ -]quota|quota.{0,25}(exhaust|exceed)|billing[_ -]hard[_ -]limit|usageLimitExceeded|credits?.{0,20}(exhaust|insufficient)/iu.test(`${input.message}\n${input.raw}`))
+        return { category: "access", code: "provider.quota-exhausted", retryable: false };
+    const nodes = [];
+    const visit = (value, depth) => {
+        if (depth > 8 || value === null || typeof value !== "object" || Array.isArray(value))
+            return;
+        const node = value;
+        nodes.push(node);
+        for (const key of ["cause", "error", "data", "codexErrorInfo", "responseTooManyFailedAttempts",
+            "httpConnectionFailed", "responseStreamConnectionFailed", "responseStreamDisconnected", "error_details"]) {
+            visit(node[key], depth + 1);
+        }
+    };
+    try {
+        visit(JSON.parse(input.raw), 0);
+    }
+    catch { /* Display classification may still use prose. */ }
+    const codes = nodes.flatMap(n => [n.code, n.type, n.error, n.codexErrorInfo]).filter(v => typeof v === "string");
+    if (codes.some(c => ["authentication_error", "permission_error", "invalid_api_key", "invalid_model",
+        "model_not_found", "usage_limit_exceeded", "insufficient_quota"].includes(c))) {
+        return { category: "access", code: "provider.access-denied", retryable: false };
+    }
+    const statuses = nodes.flatMap(n => [n.httpStatusCode, n.statusCode, n.status]).filter(v => typeof v === "number");
+    if (statuses.some(s => s === 401 || s === 403 || s === 400 || s === 404)) {
+        return { category: "invalid-request", code: "provider.http-4xx", retryable: false };
+    }
+    const nativeCode = input.message.trim();
+    let result;
+    if (statuses.includes(429) || codes.includes("rate_limit_error") || nativeCode === "rate_limit_error") {
+        result = recoverable("rate-limit", "provider.rate-limit");
+    }
+    else if (statuses.some(s => [500, 502, 503, 504].includes(s))
+        || codes.some(c => ["server_error", "overloaded_error"].includes(c))
+        || ["server_error", "overloaded_error"].includes(nativeCode)) {
+        result = recoverable("availability", "provider.server-error");
+    }
+    else if (codes.some(c => ["ECONNRESET", "ECONNREFUSED", "EAI_AGAIN", "ETIMEDOUT", "EPIPE"].includes(c))) {
+        result = recoverable("transport", "transport.temporary-failure");
+    }
+    if (result === undefined)
+        return undefined;
+    const waits = [];
+    for (const node of nodes) {
+        for (const value of [node.retry_after_ms, node.retryAfterMs]) {
+            if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+                waits.push(value);
+        }
+        const headers = node.headers;
+        if (headers === null || typeof headers !== "object" || Array.isArray(headers))
+            continue;
+        const entries = Object.entries(headers);
+        const value = entries.find(([k]) => k.toLowerCase() === "retry-after")?.[1];
+        if (typeof value !== "string")
+            continue;
+        if (/^\d+(?:\.\d+)?$/u.test(value.trim()))
+            waits.push(Math.ceil(Number(value) * 1_000));
+        else {
+            const date = Date.parse(value);
+            if (Number.isFinite(date))
+                waits.push(Math.max(0, date - Date.now()));
+        }
+    }
+    const retryAfterMs = Math.max(...waits.filter(Number.isSafeInteger));
+    return { ...result, retryable: true,
+        ...(Number.isFinite(retryAfterMs) ? { retryAfterMs } : {}) };
+}
+/** Add positive evidence without renaming established diagnostics or letting
+ * a transient nested cause override a known fatal Session/request failure. */
+function withTransientEvidence(base, input) {
+    const evidence = structuredTransientError(input);
+    if (evidence === undefined)
+        return base;
+    const possiblyTransient = ["rate-limit", "availability", "transport", "unknown"].includes(base.category);
+    if (evidence.retryable === false)
+        return possiblyTransient ? evidence : { ...base, retryable: false };
+    if (!possiblyTransient || base.sessionDisposition === "unrecoverable")
+        return base;
+    return {
+        ...(base.category === "unknown" ? evidence : base), retryable: true,
+        ...(evidence.retryAfterMs === undefined ? {} : { retryAfterMs: evidence.retryAfterMs })
+    };
+}

package/dist/runtime/codexAppServerRuntime.js

@@ -1,4 +1,5 @@
 import { YUI_VERSION } from "../version.js";
+import { serializeAgentErrorRaw } from "./agentError.js";
 /**
  * Preserve the native non-interactive Codex identity used by our historical
  * execution adapter. A proxy's environment cannot set the daemon's originator;
@@ -94,6 +95,10 @@ export class CodexAppServerRuntime {
             conversationId: input.conversationId,
             text: input.text,
             expectedNoActiveTurn: input.expectedNoActiveTurn,
+            ...(input.requireQuiescent ? { requireQuiescent: true } : {}),
+            ...(input.expectedFailedNativeTurnId === undefined ? {} : {
+                expectedFailedNativeTurnId: input.expectedFailedNativeTurnId
+            }),
             clientUserMessageId: input.attemptId
         });
     }
@@ -101,11 +106,13 @@ export class CodexAppServerRuntime {
         const requestedThreadId = text(input.conversationId, "Codex thread id");
         let threadId = requestedThreadId;
         try {
+            const expectedFailedTurn = input.expectedFailedNativeTurnId === undefined ? undefined
+                : text(input.expectedFailedNativeTurnId, "Expected failed Codex Turn id");
             // Submission needs current availability, not historical Turns. Some
             // App Server transports expose status without supporting history reads.
             const snapshot = await this.readConversation(requestedThreadId, { includeTurns: false });
             threadId = snapshot.threadId;
-            if (input.expectedNoActiveTurn
+            if ((input.expectedNoActiveTurn || expectedFailedTurn !== undefined || input.requireQuiescent)
                 && (snapshot.status === "active" || snapshot.activeTurnId !== undefined)) {
                 return {
                     status: "busy",
@@ -115,9 +122,30 @@ export class CodexAppServerRuntime {
                         : `active-turn:${snapshot.activeTurnId}`
                 };
             }
-            if (snapshot.status !== "idle" && snapshot.status !== "active") {
+            if (snapshot.status !== "idle" && snapshot.status !== "active"
+                && !(snapshot.status === "systemError" && expectedFailedTurn !== undefined)) {
                 throw new Error(`Codex Session availability is ${snapshot.status}; no input was submitted.`);
             }
+            if (expectedFailedTurn !== undefined) {
+                // systemError alone proves neither terminal execution nor permission
+                // to replay. Only the exact latest failed Turn permits this recovery.
+                const page = await this.transport.request("thread/turns/list", {
+                    threadId, limit: 1, sortDirection: "desc", itemsView: "notLoaded"
+                });
+                const latest = object(arrayMember(page, "data")[0]);
+                if (latest?.id !== expectedFailedTurn || latest.status !== "failed") {
+                    throw new Error("Codex retry has no exact failed latest Turn proof; no input was submitted.");
+                }
+            }
+            if (expectedFailedTurn !== undefined || input.requireQuiescent) {
+                const backgrounds = await this.transport.request("thread/backgroundTerminals/list", {
+                    threadId, limit: 1
+                });
+                if (!Array.isArray(backgrounds.data) || backgrounds.data.length !== 0
+                    || backgrounds.nextCursor !== null) {
+                    throw new Error("Codex retry background execution is not proven empty; no input was submitted.");
+                }
+            }
         }
         catch (error) {
             throw new CodexPreSubmissionError("Codex Session inspection failed before input submission.", { cause: error });
@@ -304,7 +332,10 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
                 turnId,
                 ...(status === undefined ? {} : { status }),
                 ...(output === undefined ? {} : { output }),
-                ...(error === undefined ? {} : { error })
+                ...(error === undefined ? {} : { error }),
+                ...(turn.error === undefined || turn.error === null ? {} : {
+                    rawError: serializeAgentErrorRaw(turn.error)
+                })
             }];
     });
     return {

package/dist/runtime/executionEnvironment.js

@@ -1,5 +1,4 @@
 import { isDeepStrictEqual } from "node:util";
-import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { createProjectResources } from "../resources/projectResourceService.js";
 /** Revalidate the adopted owner; a saved path alone never authorizes execution. */
 export function assertExecutionEnvironmentCurrent(store, taskId, snapshot) {
@@ -10,21 +9,3 @@ export function assertExecutionEnvironmentCurrent(store, taskId, snapshot) {
         throw new Error("Execution environment changed; select an adopted environment and start a new Session.");
     }
 }
-/** Last local check before native process creation or another Provider input. */
-export function assertAgentExecutionEnvironment(home, payload) {
-    const snapshot = payload.executionEnvironment;
-    if (snapshot === undefined)
-        return;
-    if (payload.environment.YUI_SESSION_SCOPE !== "task"
-        || payload.environment.YUI_TASK_ID !== snapshot.taskId
-        || payload.cwd !== snapshot.directory.path) {
-        throw new Error("Agent launch does not match its adopted execution environment.");
-    }
-    const store = openCurrentTaskStore(home);
-    try {
-        assertExecutionEnvironmentCurrent(store, snapshot.taskId, snapshot);
-    }
-    finally {
-        store.close();
-    }
-}

package/dist/runtime/launchBroker.js

@@ -60,6 +60,12 @@ function validatePayload(payload) {
         throw new Error("Agent Host launch payload version is invalid.");
     text(payload.command, "command");
     text(payload.cwd, "cwd");
+    if (payload.startupRunId !== undefined) {
+        text(payload.startupRunId, "startup Run id");
+        if (payload.environment?.YUI_SESSION_SCOPE !== "task") {
+            throw new Error("Only a Task launch may carry a startup Run identity.");
+        }
+    }
     if (!Array.isArray(payload.args))
         throw new Error("Agent Host launch args must be an array.");
     payload.args.forEach((value) => text(value, "argument"));

package/dist/runtime/providerControl.js

@@ -14,7 +14,11 @@ export class FencedProviderControl {
             conversationId: input.fence.conversationId,
             attemptId: identity(input.attemptId, "Provider input attempt id"),
             text: text(input.text, "Provider Turn input"),
-            expectedNoActiveTurn: input.expectedNoActiveTurn ?? true
+            expectedNoActiveTurn: input.expectedNoActiveTurn ?? true,
+            ...(input.requireQuiescent ? { requireQuiescent: true } : {}),
+            ...(input.expectedFailedNativeTurnId === undefined ? {} : {
+                expectedFailedNativeTurnId: identity(input.expectedFailedNativeTurnId, "Expected failed Provider Turn id")
+            })
         });
     }
     async interruptTurn(input) {

package/dist/runtime/providerRetry.js

@@ -0,0 +1,198 @@
+export const PROVIDER_RETRY_LIMIT = 5;
+export const PROVIDER_RETRY_BUDGET_MS = 600_000;
+export function providerRetryPending(binding) {
+    return binding?.retry?.status === "waiting" || binding?.retry?.status === "in-flight";
+}
+/** Called only in the transaction recording the exact failed/rejected input. */
+export function recordProviderFailure(binding, input) {
+    let turn = binding.run;
+    const previous = binding.retry;
+    if (turn === null || !["failed", "rejected", "delivery-unknown"].includes(turn.status))
+        return binding;
+    turn = { ...turn, failure: { error: input.error, ref: input.failureRef } };
+    binding = { ...binding, run: turn };
+    if (turn.status === "delivery-unknown")
+        return binding;
+    if (previous?.currentAttemptId === turn.attemptId
+        && ["cancelled", "exhausted", "needs-attention"].includes(previous.status))
+        return binding;
+    if (previous?.failedAttemptId === turn.attemptId && previous.status !== "in-flight")
+        return binding;
+    if (input.error.retryable !== true || input.error.inputDisposition === "unknown"
+        || input.error.sessionDisposition !== "recoverable"
+        || binding.authority.owner !== "controller" || binding.retryDisabled === true
+        || turn.status === "failed" && (turn.nativeTurnId === undefined || input.error.inputDisposition !== "accepted")) {
+        return providerRetryPending(binding)
+            ? cancelProviderRetry(binding, "failure-not-safely-retryable", input.at) : binding;
+    }
+    const continuing = previous?.status === "in-flight" && previous.currentAttemptId === turn.attemptId;
+    const originalInput = continuing ? previous.input : turn.input;
+    if (originalInput === undefined)
+        return binding; // no owned input: never replay arbitrary native chat
+    const current = {
+        policyVersion: 1,
+        chainId: continuing ? previous.chainId : turn.attemptId,
+        status: "waiting",
+        input: originalInput,
+        nativeSessionId: binding.conversations.find(c => c.epoch === binding.currentConversationEpoch).conversationId,
+        authorityEpoch: binding.authority.epoch,
+        attempts: continuing ? previous.attempts - (input.noProviderWrite && previous.successorAutomatic !== false ? 1 : 0) : 0,
+        transportSequence: continuing ? previous.transportSequence : 0,
+        startedAt: continuing ? previous.startedAt : iso(input.at),
+        intentAt: continuing ? previous.intentAt : turn.submittedAt,
+        deadline: continuing ? previous.deadline : iso(input.at + PROVIDER_RETRY_BUDGET_MS),
+        nextEligibleAt: iso(input.at),
+        updatedAt: iso(input.at),
+        failedAttemptId: turn.attemptId,
+        failureAttemptId: turn.nativeTurnId !== undefined || !continuing ? turn.attemptId : previous.failureAttemptId,
+        ...((turn.nativeTurnId ?? (continuing ? previous.failedNativeTurnId : undefined)) === undefined ? {}
+            : { failedNativeTurnId: turn.nativeTurnId ?? previous.failedNativeTurnId }),
+        ...(turn.runId === undefined ? {} : { previousRunId: turn.runId }),
+        failureRef: input.failureRef,
+        error: input.error
+    };
+    const random = unitRandom(input.random ?? Math.random);
+    const window = Math.min(60_000, 5_000 * 2 ** current.attempts);
+    const backoff = Math.ceil(window * (0.5 + random / 2));
+    const serverWait = input.error.retryAfterMs;
+    const delay = serverWait === undefined ? backoff
+        : Math.max(backoff, serverWait + 1 + Math.ceil(random * 1_000));
+    const eligible = input.at + delay;
+    const exhausted = current.attempts >= PROVIDER_RETRY_LIMIT || eligible >= Date.parse(current.deadline);
+    return {
+        ...binding,
+        ...(!continuing && previous !== undefined
+            ? { retryHistory: [...(binding.retryHistory ?? []), previous] } : {}),
+        retry: {
+            // A terminal chain has no next submission. Keep its bounded deadline
+            // representable even for huge hints; the unshortened hint stays in error.
+            ...current, nextEligibleAt: iso(exhausted ? Math.min(eligible, Date.parse(current.deadline)) : eligible),
+            ...(turn.retrySupported !== true ? { status: "needs-attention", reason: "host-safe-retry-unsupported" }
+                : exhausted ? { status: "exhausted", reason: current.attempts >= PROVIDER_RETRY_LIMIT
+                        ? "automatic-attempt-limit" : "retry-after-exceeds-deadline" } : {})
+        }
+    };
+}
+/** Atomically called at the shared native write admission, never by a timer alone. */
+export function admitProviderRetry(binding, input) {
+    const retry = binding.retry;
+    if (retry?.status === "in-flight" && retry.currentAttemptId === input.attemptId)
+        return binding;
+    if (retry?.status !== "waiting"
+        || input.at < Date.parse(retry.nextEligibleAt)
+        || retry.successorAutomatic !== false && (binding.retryDisabled === true
+            || input.at >= Date.parse(retry.deadline) || retry.attempts >= PROVIDER_RETRY_LIMIT)
+        || binding.authority.owner !== "controller" || binding.authority.epoch !== retry.authorityEpoch
+        || binding.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId !== retry.nativeSessionId
+        || binding.run?.attemptId !== retry.failedAttemptId
+        || !["failed", "rejected", "deferred"].includes(binding.run.status)) {
+        throw new Error("Provider retry is not eligible under the current input, Session, authority or budget.");
+    }
+    return { ...binding, retry: {
+            ...retry, status: "in-flight", attempts: retry.attempts + (retry.successorAutomatic === false ? 0 : 1),
+            transportSequence: retry.transportSequence + 1,
+            currentAttemptId: input.attemptId, updatedAt: iso(input.at)
+        } };
+}
+/** Busy/preflight refusal is not a model attempt. Keep its exact receipt visible. */
+export function deferProviderRetry(binding, at, reason) {
+    const retry = binding.retry;
+    if (retry?.status !== "in-flight" || retry.currentAttemptId !== binding.run?.attemptId)
+        return binding;
+    const { currentAttemptId: _attempt, successorRunId, ...remaining } = retry;
+    return { ...binding, retry: {
+            ...remaining, attempts: retry.attempts - (retry.successorAutomatic === false ? 0 : 1),
+            failedAttemptId: binding.run.attemptId,
+            ...(reason === undefined && successorRunId !== undefined ? { successorRunId } : {}),
+            ...(reason !== undefined && binding.run?.runId !== undefined ? { previousRunId: binding.run.runId } : {}),
+            status: reason === undefined ? "waiting" : "needs-attention",
+            nextEligibleAt: iso(Math.min(at + 1_000, Date.parse(retry.deadline))),
+            updatedAt: iso(at), ...(reason === undefined ? {} : { reason })
+        } };
+}
+export function cancelProviderRetry(binding, reason, at) {
+    return !providerRetryPending(binding) ? binding : {
+        ...binding, retry: { ...binding.retry, status: "cancelled", reason, updatedAt: iso(at) }
+    };
+}
+export function completeProviderRetry(binding, turn) {
+    const retry = binding.retry;
+    return retry === undefined || !["in-flight", "cancelled", "needs-attention"].includes(retry.status)
+        || retry.currentAttemptId !== turn.attemptId
+        || turn.status !== "completed" ? binding : {
+        ...binding, retry: { ...retry, status: "recovered", updatedAt: turn.updatedAt }
+    };
+}
+export function providerRetryAttemptId(retry) {
+    return `provider-retry:${retry.chainId}/${retry.transportSequence + 1}`;
+}
+export function providerRetryPrompt(retry, original) {
+    if (retry.failedNativeTurnId === undefined)
+        return original;
+    return [
+        "Yui infrastructure recovery, not new user authorization.",
+        `Continue the existing input after failed attempt ${retry.failureAttemptId}`,
+        `(native Turn ${retry.failedNativeTurnId}; failure ${retry.failureRef}).`,
+        "Read current authorized context and the original input. Inspect existing work and receipts first;",
+        "continue only unfinished work. Preserve local changes and do not repeat confirmed side effects.",
+        original
+    ].join("\n");
+}
+/** The same presentation is consumed by CLI, Context and Web. */
+export function providerRetryProjection(binding) {
+    const retry = binding?.retry;
+    if (retry === undefined)
+        return null;
+    return {
+        chainId: retry.chainId,
+        status: retry.status === "in-flight" && binding?.run?.status === "delivery-unknown"
+            ? "delivery-unknown" : retry.status,
+        attempts: retry.status === "recovered" ? 0 : retry.attempts,
+        limit: PROVIDER_RETRY_LIMIT, nextEligibleAt: retry.nextEligibleAt, deadline: retry.deadline,
+        category: retry.error.category, preservesWork: true, nativeSessionId: retry.nativeSessionId,
+        ...(retry.reason === undefined ? {} : { reason: retry.reason }),
+        failureRef: retry.failureRef,
+        ...(retry.previousRunId === undefined ? {} : { previousRunId: retry.previousRunId }),
+        ...(retry.successorRunId === undefined ? {} : { successorRunId: retry.successorRunId })
+    };
+}
+export function controlProviderRetry(binding, action, at) {
+    if (action === "enable")
+        return { ...binding, retryDisabled: false };
+    return { ...cancelProviderRetry(binding, `user-${action}`, at),
+        ...(action === "disable" ? { retryDisabled: true } : {}) };
+}
+export function renderProviderRetry(binding) {
+    const view = providerRetryProjection(binding);
+    return view === null ? `Provider retry: ${binding?.retryDisabled ? "disabled" : "none"}`
+        : `Provider retry: ${view.category}/${view.status}; ${view.attempts}/${view.limit}; next=${view.nextEligibleAt}; `
+            + `deadline=${view.deadline}; existing work preserved${view.reason === undefined ? "" : `; ${view.reason}`}`;
+}
+export function validateProviderRetry(retry) {
+    if (retry.policyVersion !== 1 || !["waiting", "in-flight", "recovered", "cancelled", "exhausted", "needs-attention"].includes(retry.status)
+        || !Number.isSafeInteger(retry.attempts) || retry.attempts < 0 || retry.attempts > PROVIDER_RETRY_LIMIT
+        || !Number.isSafeInteger(retry.transportSequence) || retry.transportSequence < retry.attempts
+        || !Number.isSafeInteger(retry.authorityEpoch) || retry.authorityEpoch < 1
+        || [retry.chainId, retry.nativeSessionId, retry.failedAttemptId, retry.failureRef].some(v => typeof v !== "string" || v.length === 0)
+        || [retry.startedAt, retry.intentAt, retry.deadline, retry.nextEligibleAt, retry.updatedAt].some(v => !Number.isFinite(Date.parse(v)))
+        || Date.parse(retry.deadline) - Date.parse(retry.startedAt) !== PROVIDER_RETRY_BUDGET_MS
+        || retry.status === "in-flight" && !retry.currentAttemptId)
+        throw new Error("Invalid Provider retry record.");
+    validateProviderInput(retry.input);
+}
+export function validateProviderInput(input) {
+    const fields = input.kind === "run" ? [input.taskId, input.runId]
+        : input.kind === "wake" ? [input.taskId, input.wakeId]
+            : input.kind === "message" ? [input.roleName, input.messageId]
+                : input.kind === "text" ? [input.text] : [];
+    if (fields.length === 0 || fields.some(v => typeof v !== "string" || !v.trim())) {
+        throw new Error("Invalid owned Provider input.");
+    }
+}
+function iso(at) { return new Date(at).toISOString(); }
+function unitRandom(random) {
+    const value = random();
+    if (!Number.isFinite(value) || value < 0 || value > 1)
+        throw new Error("Retry RNG must return a unit fraction.");
+    return value;
+}

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,3 +1,5 @@
+import { cancelProviderRetry, completeProviderRetry, validateProviderInput, validateProviderRetry } from "./providerRetry.js";
+import { isStandardAgentError } from "./agentError.js";
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Conversation startedAt");
     return validateProviderRuntimeBinding({
@@ -84,7 +86,7 @@ export function transferProviderAuthority(raw, input) {
     });
 }
 export function beginProviderTurn(raw, input) {
-    const binding = validateProviderRuntimeBinding(raw);
+    let binding = validateProviderRuntimeBinding(raw);
     const attemptId = identity(input.attemptId, "Provider input attempt id");
     const runId = input.runId === undefined ? undefined : identity(input.runId, "AgentRun id");
     const currentRun = binding.run;
@@ -104,6 +106,9 @@ export function beginProviderTurn(raw, input) {
         throw new Error("Provider Conversation already has an unsettled AgentRun.");
     }
     const submittedAt = timestamp(input.submittedAt, "Provider Turn submittedAt");
+    if (binding.retry?.currentAttemptId !== attemptId) {
+        binding = cancelProviderRetry(binding, "superseded-by-explicit-input", Date.parse(submittedAt));
+    }
     return validateProviderRuntimeBinding({
         ...binding,
         run: {
@@ -111,6 +116,8 @@ export function beginProviderTurn(raw, input) {
             attemptId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
+            ...(input.input === undefined ? {} : { input: input.input }),
+            ...(input.retrySupported === undefined ? {} : { retrySupported: input.retrySupported }),
             submittedAt,
             updatedAt: submittedAt
         }
@@ -221,7 +228,7 @@ export function settleProviderTurn(raw, input) {
         throw new Error("Provider Turn settlement does not match the current AgentRun.");
     }
     const settledAt = orderedRunTimestamp(run, input.settledAt, "Provider Turn settledAt");
-    return validateProviderRuntimeBinding({
+    const settled = validateProviderRuntimeBinding({
         ...binding,
         run: {
             ...run,
@@ -233,6 +240,7 @@ export function settleProviderTurn(raw, input) {
                 : { terminalReason: identity(input.reason, "Provider Turn terminal reason") })
         }
     });
+    return completeProviderRetry(settled, settled.run);
 }
 /** Explicitly abandon an engineering input only after its execution resources
  * are quiescent. This does not invent native acceptance, a Turn id or success. */
@@ -367,6 +375,24 @@ export function validateProviderRuntimeBinding(value) {
         throw new Error("Provider Runtime Binding requires Goal state.");
     if (value.goal !== null)
         validateProviderGoal(value.goal);
+    if (value.retry !== undefined)
+        validateProviderRetry(value.retry);
+    if (value.retryHistory !== undefined) {
+        if (!Array.isArray(value.retryHistory))
+            throw new Error("Provider retry audit must be an array.");
+        for (const retry of value.retryHistory) {
+            validateProviderRetry(retry);
+            if (retry.status === "waiting" || retry.status === "in-flight")
+                throw new Error("Provider retry audit cannot schedule work.");
+        }
+    }
+    if (value.retryDisabled !== undefined && typeof value.retryDisabled !== "boolean")
+        throw new Error("Provider retry switch must be boolean.");
+    if (value.run?.input !== undefined)
+        validateProviderInput(value.run.input);
+    if (value.run?.failure !== undefined
+        && (!isStandardAgentError(value.run.failure.error) || !value.run.failure.ref))
+        throw new Error("Invalid Provider input failure.");
     return value;
 }
 function validateProviderGoal(goal) {

package/dist/runtime/sessionReconciliation.js

@@ -8,8 +8,8 @@
  * live Session can always be re-attributed and reported.
  *
  * Pure: all I/O is injected. Unknown owners are reported, never cleaned.
- * An entry is archive-blocking when its durable state is terminal but the
- * physical Provider root is still live, and the Task is terminal/archived.
+ * An entry blocks ordinary archive / workspace cleanup when a terminal Task
+ * still owns a live or unverified physical root, regardless of Session status.
  */
 export function reconcileSessionOwners(input) {
     const entries = input.records.map((record) => reconcileOne(record, input));
@@ -54,8 +54,8 @@ function reconcileOne(record, input) {
     const terminalTask = taskStatus === "completed"
         || taskStatus === "cancelled"
         || taskStatus === "archived";
-    const archiveBlocked = mismatch === "durable-terminal-physical-live"
-        && terminalTask;
+    const archiveBlocked = terminalTask && (physical === undefined
+        || physical.alive || physical.identityConflict);
     return {
         owner: {
             scope: owner.scope,

package/dist/runtime/sessionTokenMetrics.js

@@ -26,11 +26,21 @@ export function resolveSessionTokenIdentity(input) {
 export function projectSessionTokenMetrics(events, identity) {
     if (identity === null)
         return unobservedSessionTokenMetrics();
-    const observations = events
-        .map(runtimeObservationFromTaskEvent)
-        .filter((observation) => (observation !== null
-        && isRuntimeTokenEvidence(observation)
-        && matchesSessionIdentity(observation, identity)))
+    return projectSessionTokenObservations(events.flatMap((event) => {
+        const observation = runtimeObservationFromTaskEvent(event);
+        return observation === null ? [] : [observation];
+    }), identity);
+}
+/** Shared reducer for authorized, already decoded canonical observations. */
+export function projectSessionTokenObservations(input, identity) {
+    const observations = input
+        .filter((observation) => (isRuntimeTokenEvidence(observation)
+        && matchesSessionIdentity(observation, identity)
+        && (observation.authority === "provider-structured" || observation.authority === "driver-inferred")
+        // Child counters have no declared inclusion relationship with the
+        // Session's parent counter. They must never be added as extra requests.
+        && observation.fence.continuationId === undefined
+        && observation.fence.parentContinuationId === undefined))
         .sort(compareObservations);
     const incompleteBoundaries = observations.filter(({ payload }) => (payload.usage === undefined));
     const request = observations.filter(({ payload }) => (payload.usage?.semantics === "request-context"));

package/dist/runtime/structuredProviderHost.js

@@ -462,7 +462,7 @@ class CodexStructuredProviderSession {
                         ? {}
                         : {
                             error: recovered.error ?? "Provider Turn failed.",
-                            rawError: serializeAgentErrorRaw(recovered)
+                            ...(recovered.rawError === undefined ? {} : { rawError: recovered.rawError })
                         })
                 };
                 session.#clientOwnedTurnId = undefined;
@@ -594,7 +594,11 @@ class CodexStructuredProviderSession {
                 conversationId: this.conversationId,
                 attemptId: turn.attemptId,
                 text: turn.boundedText,
-                expectedNoActiveTurn: true
+                expectedNoActiveTurn: true,
+                ...(turn.requireQuiescent ? { requireQuiescent: true } : {}),
+                ...(turn.expectedFailedNativeTurnId === undefined ? {} : {
+                    expectedFailedNativeTurnId: turn.expectedFailedNativeTurnId
+                })
             });
             if (acceptance.status === "unknown") {
                 throw new ProviderDeliveryUnknownError(acceptance.reason, turn.attemptId);