@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/request/root-invalid-output.js

@@ -1,14 +1,25 @@
+import { finalizeSuperRootFailure } from "./super-root-failure-finalization.js";
 import { projectInvalidOutputProgress } from "./root-invalid-output-progress.js";
 import { resolveModelOutputFailure, } from "../model/invalid-output-failure.js";
 import { ModelOutputIncompleteError } from "../model/provider-completion.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
 import { runModelAuthoredDegradedFinalization } from "../steps/degraded-finalization/model-authored.js";
+import { projectOutputLimitCause } from "../steps/degraded-finalization/output-limit-cause.js";
 import { resolveRequestSteeringInbox } from "./request-steering.js";
 import { commitSupervisorResponse } from "./root-response-commit.js";
 import { resolveRoleCallTransactions } from "../orchestration/role-calls/index.js";
 /** Finalizes known model-output failures at the still-current root boundary. */
 export async function finalizeInvalidRootOutput(params) {
+    if (params.request.superFailureFinalization) {
+        const recognized = isRootModelOutputStage(params.failureStage)
+            ? resolveRootModelOutputFailure(params.request, params.error)
+            : undefined;
+        const failure = recognized && isRootModelOutputStep(params.request, recognized.modelStep)
+            ? recognized
+            : undefined;
+        return finalizeSuperRootFailure({ ...params, failure });
+    }
     if (!isRootModelOutputStage(params.failureStage))
         return undefined;
     const failure = resolveRootModelOutputFailure(params.request, params.error);
@@ -35,7 +46,11 @@ export async function finalizeInvalidRootOutput(params) {
         steeringVersion,
     });
     const input = {
-        problem: { stage: failure.validationStage, code: failure.code },
+        problem: {
+            stage: failure.validationStage,
+            code: failure.code,
+            ...projectOutputLimitCause(params.error),
+        },
         progress: projectInvalidOutputProgress(head),
     };
     let response;

package/dist/src/runtime/request/session-admission.d.ts

@@ -4,13 +4,19 @@ export declare class SessionRequestAdmission {
     private readonly hasSavedWait?;
     private readonly active;
     private readonly reserved;
+    private readonly automationReserved;
     private readonly waiters;
     private readonly idleWaiters;
     private closed;
     constructor(isDeleted: (sessionId: string) => boolean, hasSavedWait?: ((sessionId: string) => Promise<boolean>) | undefined);
     tryReserveAvailable(sessionId: string): Promise<(() => void) | null>;
     tryReserve(sessionId: string): (() => void) | null;
+    /** Automation Runs share idle accounting without impersonating a session. */
+    tryReserveAutomation(automationId: string): (() => void) | null;
     run<T>(sessionId: string, execute: () => Promise<T>, resume?: boolean): Promise<T>;
+    private isSessionReserved;
+    private shouldCheckSavedApproval;
+    private waitForSessionReservation;
     close(): void;
     whenIdle(): Promise<void>;
     private requireOpenAdmission;

package/dist/src/runtime/request/session-admission.js

@@ -4,6 +4,7 @@ export class SessionRequestAdmission {
     hasSavedWait;
     active = new Map();
     reserved = new Set();
+    automationReserved = new Set();
     waiters = new Map();
     idleWaiters = new Set();
     closed = false;
@@ -38,22 +39,39 @@ export class SessionRequestAdmission {
             this.notifyIdle();
         };
     }
+    /** Automation Runs share idle accounting without impersonating a session. */
+    tryReserveAutomation(automationId) {
+        if (this.closed)
+            return null;
+        if (this.automationReserved.has(automationId))
+            return null;
+        this.automationReserved.add(automationId);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.automationReserved.delete(automationId);
+            this.notifyIdle();
+        };
+    }
     async run(sessionId, execute, resume = false) {
-        this.requireOpenAdmission();
-        while (this.reserved.has(sessionId)) {
-            // Even a cancelled request must wait before changing session history.
-            await new Promise((resolve) => {
-                const waiting = this.waiters.get(sessionId) ?? new Set();
-                waiting.add(resolve);
-                this.waiters.set(sessionId, waiting);
-            });
+        for (;;) {
             this.requireOpenAdmission();
+            if (this.isSessionReserved(sessionId)) {
+                await this.waitForSessionReservation(sessionId);
+                continue;
+            }
+            if (this.shouldCheckSavedApproval(resume) && await this.hasSavedWait(sessionId))
+                throw new Error("session_awaiting_approval");
+            this.requireOpenAdmission();
+            // The saved-wait read yielded; a clear or scheduler may have reserved meanwhile.
+            if (this.isSessionReserved(sessionId))
+                continue;
+            if (this.isDeleted(sessionId))
+                throw new Error("session_deleted");
+            break;
         }
-        if (!resume && this.hasSavedWait && (await this.hasSavedWait(sessionId)))
-            throw new Error("session_awaiting_approval");
-        this.requireOpenAdmission();
-        if (this.isDeleted(sessionId))
-            throw new Error("session_deleted");
         this.active.set(sessionId, (this.active.get(sessionId) ?? 0) + 1);
         try {
             return await execute();
@@ -67,6 +85,19 @@ export class SessionRequestAdmission {
             this.notifyIdle();
         }
     }
+    isSessionReserved(sessionId) { return this.reserved.has(sessionId); }
+    shouldCheckSavedApproval(resume) {
+        if (resume)
+            return false;
+        return this.hasSavedWait !== undefined;
+    }
+    waitForSessionReservation(sessionId) {
+        return new Promise((resolve) => {
+            const waiting = this.waiters.get(sessionId) ?? new Set();
+            waiting.add(resolve);
+            this.waiters.set(sessionId, waiting);
+        });
+    }
     close() {
         this.closed = true;
         for (const waiting of this.waiters.values()) {
@@ -87,7 +118,9 @@ export class SessionRequestAdmission {
     isIdle() {
         if (this.active.size > 0)
             return false;
-        return this.reserved.size === 0;
+        if (this.reserved.size > 0)
+            return false;
+        return this.automationReserved.size === 0;
     }
     notifyIdle() {
         if (!this.isIdle())

package/dist/src/runtime/request/super-checkpoint-quarantine.d.ts

@@ -0,0 +1,8 @@
+import type { SuperCompactionIntegrityInput } from "../context/semantic-compaction/super-source-integrity.js";
+import { type SuperContextFailureReturnInput } from "./super-context-failure-integrity.js";
+/** Revalidate stored data independently; the caught projection is never proof. */
+export declare function quarantineProvenUnusableSuperCheckpoint(params: SuperContextFailureReturnInput): void;
+/** Callers establish current or captured canonical invocation ownership first. */
+export declare function quarantineProvenOwnedSuperCheckpoint(integrity: SuperCompactionIntegrityInput & {
+    scopeId: string;
+}): string | undefined;

package/dist/src/runtime/request/super-checkpoint-quarantine.js

@@ -0,0 +1,76 @@
+import { assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, assertSuperCompactionCheckpointBinding, } from "../context/semantic-compaction/super-source-integrity.js";
+import { isCheckpointQuarantineReason } from "../context/semantic-compaction/scope-quarantine.js";
+import { hasCurrentSuperFailureAuthority, } from "./super-context-failure-integrity.js";
+import { traceDebug } from "../observability/debug-logger.js";
+/** Revalidate stored data independently; the caught projection is never proof. */
+export function quarantineProvenUnusableSuperCheckpoint(params) {
+    if (!hasCurrentSuperFailureAuthority(params))
+        return;
+    const failure = params.error;
+    const store = params.request.contextCompactionStore;
+    if (!store)
+        return;
+    const quarantined = quarantineProvenOwnedSuperCheckpoint({
+        requestId: params.request.requestId,
+        prompt: params.request.prompt,
+        head: params.expectedHead,
+        store,
+        scopeId: failure.binding.scopeId,
+    });
+    if (quarantined)
+        traceDebug("runtime.context.compaction", "checkpoint.quarantined", {
+            ...failure.binding,
+            code: failure.code,
+            validationCode: quarantined,
+        });
+}
+/** Callers establish current or captured canonical invocation ownership first. */
+export function quarantineProvenOwnedSuperCheckpoint(integrity) {
+    const { store } = integrity;
+    if (!store.snapshot || !store.quarantineScope)
+        return undefined;
+    const checkpoint = store
+        .snapshot()
+        .checkpoints.find((candidate) => candidate.scopeId === integrity.scopeId);
+    if (!checkpoint)
+        return undefined;
+    try {
+        assertSuperCompactionSourceIntegrity(integrity);
+        assertSuperCompactionCheckpointBinding({ ...integrity, checkpoint });
+        if (!Array.isArray(checkpoint.sourceDigests))
+            return;
+        for (const digest of checkpoint.sourceDigests) {
+            if (!store.materializeSource(digest.sourceRef, digest.sourceFingerprint))
+                return;
+        }
+    }
+    catch {
+        return;
+    }
+    try {
+        assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint });
+    }
+    catch (validation) {
+        if (!(validation instanceof Error))
+            return;
+        if (!isCheckpointQuarantineReason(validation.message))
+            return;
+        store.quarantineScope({
+            scopeId: checkpoint.scopeId,
+            binding: checkpointBinding(checkpoint),
+            failureCode: validation.message,
+        });
+        return validation.message;
+    }
+}
+function checkpointBinding(checkpoint) {
+    return {
+        requestId: checkpoint.requestId,
+        currentRequestFingerprint: checkpoint.currentRequestFingerprint,
+        roleId: checkpoint.roleId,
+        callId: checkpoint.callId,
+        objectiveFingerprint: checkpoint.objectiveFingerprint,
+        contextLane: checkpoint.contextLane,
+        allowedConsumers: checkpoint.allowedConsumers,
+    };
+}

package/dist/src/runtime/request/super-context-failure-executor.d.ts

@@ -0,0 +1,4 @@
+import type { RoleExecutor } from "../orchestration/role-executors/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+/** The existing activation/return transaction remains the only role-state writer. */
+export declare function containSuperContextFailures<TValue>(executor: RoleExecutor<RequestExecutionScope, TValue>, contractId: string): RoleExecutor<RequestExecutionScope, TValue>;

package/dist/src/runtime/request/super-context-failure-executor.js

@@ -0,0 +1,68 @@
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { hasSafeSuperContextFailureReturn } from "./super-context-failure-integrity.js";
+import { quarantineProvenUnusableSuperCheckpoint } from "./super-checkpoint-quarantine.js";
+import { requireLiveSuperContextScope } from "./super-context-scope.js";
+/** The existing activation/return transaction remains the only role-state writer. */
+export function containSuperContextFailures(executor, contractId) {
+    return Object.freeze({
+        roleId: executor.roleId,
+        async execute(input) {
+            const request = input.context;
+            if (!hasSuperContextContract(request.executionPolicy.authority, contractId))
+                return executor.execute(input);
+            const expectedHead = input.ledger.current();
+            request.abortSignal.throwIfAborted();
+            try {
+                requireLiveSuperContextScope({
+                    request,
+                    head: expectedHead,
+                    call: input.call,
+                    contractId,
+                });
+                return await executor.execute(input);
+            }
+            catch (error) {
+                request.abortSignal.throwIfAborted();
+                const integrity = {
+                    error,
+                    request,
+                    ledger: input.ledger,
+                    expectedHead,
+                    call: input.call,
+                    contractId,
+                };
+                quarantineProvenUnusableSuperCheckpoint(integrity);
+                if (!hasSafeSuperContextFailureReturn(integrity))
+                    throw error;
+                const failure = error;
+                traceDebug("runtime.context.compaction", "owned_failure.returning", {
+                    ...failure.binding,
+                    code: failure.code,
+                    route: "return_failed_child",
+                });
+                return Object.freeze({
+                    kind: "terminal",
+                    outcome: "failed",
+                    summary: failureSummary(failure, expectedHead.policy.limits.maxResultChars),
+                });
+            }
+        },
+    });
+}
+function failureSummary(failure, maxLength) {
+    const capsule = JSON.stringify({
+        kind: "runtime_role_context_failure_v1",
+        authority: "runtime_failure",
+        presenceEffect: "passive_failure_not_work_or_review_evidence",
+        ...failure.binding,
+        reason: failure.code,
+    });
+    if (capsule.length <= maxLength)
+        return capsule;
+    if (maxLength >= 22)
+        return "Context step failed.";
+    if (maxLength >= 7)
+        return "Failed.";
+    return "!";
+}

package/dist/src/runtime/request/super-context-failure-integrity.d.ts

@@ -0,0 +1,16 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+export type SuperContextFailureReturnInput = Readonly<{
+    error: unknown;
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    expectedHead: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    contractId: string;
+}>;
+export type SuperContextStateInput = Omit<SuperContextFailureReturnInput, "error">;
+/** Error identity is not integrity proof: independently validate every authority. */
+export declare function hasSafeSuperContextFailureReturn(params: SuperContextFailureReturnInput): boolean;
+/** Output failures also require independently healthy canonical state. */
+export declare function hasSafeSuperContextState(params: SuperContextStateInput): boolean;
+export declare function hasCurrentSuperFailureAuthority(params: SuperContextFailureReturnInput): boolean;

package/dist/src/runtime/request/super-context-failure-integrity.js

@@ -0,0 +1,130 @@
+import { validateRoleCallCandidate } from "../orchestration/role-calls/reducer.js";
+import { isCurrentRoleCallLedgerHead } from "../orchestration/role-calls/ledger.js";
+import { SuperContextFailure } from "../context/super-context-failure.js";
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, } from "../context/semantic-compaction/super-source-integrity.js";
+/** Error identity is not integrity proof: independently validate every authority. */
+export function hasSafeSuperContextFailureReturn(params) {
+    if (!isOwnedSuperContextFailureInvocation(params))
+        return false;
+    return hasSafeSuperContextState(params);
+}
+/** Output failures also require independently healthy canonical state. */
+export function hasSafeSuperContextState(params) {
+    if (!hasCurrentSuperContextStateAuthority(params))
+        return false;
+    const head = params.expectedHead;
+    try {
+        const store = params.request.contextCompactionStore;
+        if (!store?.snapshot)
+            return false;
+        const integrity = {
+            requestId: params.request.requestId,
+            prompt: params.request.prompt,
+            head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(integrity);
+        for (const checkpoint of store.snapshot().checkpoints) {
+            assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function hasCurrentSuperFailureAuthority(params) {
+    if (!isOwnedSuperContextFailureInvocation(params))
+        return false;
+    return hasCurrentSuperContextStateAuthority(params);
+}
+function hasCurrentSuperContextStateAuthority(params) {
+    if (!hasSuperContextContract(params.request.executionPolicy.authority, params.contractId))
+        return false;
+    if (!hasSuperContextContract(params.expectedHead.policy.authority, params.contractId))
+        return false;
+    if (params.request.requestId !== params.expectedHead.state.requestId)
+        return false;
+    const expectedContract = params.call.roleId === "supervisor"
+        ? "supervisor"
+        : `delegated.${params.call.roleId}`;
+    if (params.contractId !== expectedContract)
+        return false;
+    if (!isCurrentRoleCallLedgerHead(params.ledger, params.expectedHead))
+        return false;
+    const head = params.expectedHead;
+    if (head.state.phase !== "running")
+        return false;
+    if (head.state.activeCallId !== params.call.callId)
+        return false;
+    if (params.call.status !== "active")
+        return false;
+    if (head.state.calls.find((call) => call.callId === params.call.callId) !==
+        params.call)
+        return false;
+    if (params.request.abortSignal.aborted)
+        return false;
+    try {
+        if (validateRoleCallCandidate({ state: head.state, policy: head.policy })
+            .length > 0)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isOwnedSuperContextFailureInvocation(params) {
+    const failure = params.error;
+    if (!(failure instanceof SuperContextFailure))
+        return false;
+    if (failure.code === "context_compaction_snapshot_source_incompatible")
+        return false;
+    if (!hasSuperContextContract(params.request.executionPolicy.authority, params.contractId))
+        return false;
+    if (!hasSuperContextContract(params.expectedHead.policy.authority, params.contractId))
+        return false;
+    const binding = failure.binding;
+    if (binding.requestId !== params.request.requestId)
+        return false;
+    if (binding.requestId !== params.expectedHead.state.requestId)
+        return false;
+    if (binding.callId !== params.call.callId)
+        return false;
+    if (binding.parentCallId !== params.call.parentCallId)
+        return false;
+    if (binding.contractId !== params.contractId)
+        return false;
+    if (binding.invocationAttempt !== params.call.activationCount)
+        return false;
+    if (binding.sourceRevision !== params.expectedHead.revision)
+        return false;
+    if (!isFailureStepOwnedByContract(binding.modelStep, params.contractId))
+        return false;
+    const scope = params.call.roleId === "worker"
+        ? `worker:${params.call.callId}:request-tool-results`
+        : `role:${params.call.roleId}:${params.call.callId}:continuation`;
+    return binding.scopeId === scope;
+}
+function isFailureStepOwnedByContract(step, contract) {
+    if (step === "context.compact")
+        return true;
+    switch (contract) {
+        case "supervisor":
+            return step === "supervisor.decision" || step === "supervisor.response";
+        case "delegated.planner":
+            return step === "planner.decision";
+        case "delegated.worker":
+            return [
+                "worker.decision",
+                "worker.result",
+                "capability.controls",
+                "tool_payload.raw",
+            ].includes(step);
+        case "delegated.reviewer":
+            return step === "reviewer.decision";
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/request/super-context-scope.d.ts

@@ -0,0 +1,9 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+/** Repeated parent-driven invocation cannot revive a quarantined owned scope. */
+export declare function requireLiveSuperContextScope(params: {
+    request: RequestExecutionScope;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    contractId: string;
+}): void;

package/dist/src/runtime/request/super-context-scope.js

@@ -0,0 +1,65 @@
+import { withSuperCompactionFailure } from "../context/super-compaction-failure-owner.js";
+import { createOwnedSuperContextFailure } from "../context/super-context-failure.js";
+import { InvalidatedCompactionScopeError, freezeCompactionInvalidation, } from "../context/semantic-compaction/scope-quarantine.js";
+import { assertSuperCompactionCheckpointBinding, assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, } from "../context/semantic-compaction/super-source-integrity.js";
+/** Repeated parent-driven invocation cannot revive a quarantined owned scope. */
+export function requireLiveSuperContextScope(params) {
+    const store = params.request.contextCompactionStore;
+    // Payload failures settle through the existing capability path. Re-check the
+    // canonical inventory at the fresh activation before any further inference.
+    if (store?.snapshot) {
+        const integrity = {
+            requestId: params.request.requestId,
+            prompt: params.request.prompt,
+            head: params.head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(integrity);
+        for (const checkpoint of store.snapshot().checkpoints) {
+            const owner = checkpoint.callId === params.call.callId
+                ? {
+                    head: params.head,
+                    binding: {
+                        requestId: params.request.requestId,
+                        callId: params.call.callId,
+                        parentCallId: params.call.parentCallId,
+                        contractId: params.contractId,
+                        invocationAttempt: params.call.activationCount,
+                        sourceRevision: params.head.revision,
+                        modelStep: "context.compact",
+                        phase: "scope_preflight",
+                        scopeId: checkpoint.scopeId,
+                    },
+                }
+                : undefined;
+            withSuperCompactionFailure(owner, () => assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint }));
+        }
+    }
+    const records = store?.snapshot?.().invalidatedScopes ?? [];
+    const record = records.find((candidate) => candidate.binding.callId === params.call.callId);
+    if (!record)
+        return;
+    const validated = freezeCompactionInvalidation(record);
+    assertSuperCompactionCheckpointBinding({
+        requestId: params.request.requestId,
+        prompt: params.request.prompt,
+        head: params.head,
+        checkpoint: { ...validated.binding, scopeId: validated.scopeId },
+    });
+    throw createOwnedSuperContextFailure({
+        code: "context_compaction_scope_invalidated",
+        head: params.head,
+        binding: {
+            requestId: params.request.requestId,
+            callId: params.call.callId,
+            parentCallId: params.call.parentCallId,
+            contractId: params.contractId,
+            invocationAttempt: params.call.activationCount,
+            sourceRevision: params.head.revision,
+            modelStep: "context.compact",
+            phase: "scope_reuse",
+            scopeId: validated.scopeId,
+        },
+        cause: new InvalidatedCompactionScopeError(validated),
+    });
+}

package/dist/src/runtime/request/super-failure-explanation.d.ts

@@ -0,0 +1,22 @@
+import type { RequestExecutionBudgets } from "../orchestration/lifecycle/execution-budgets.js";
+import type { DegradedFinalizationInput } from "../steps/degraded-finalization/contract.js";
+import { type SuperFailureExplanation } from "../steps/degraded-finalization/super.js";
+import type { RequestExecutionSeed } from "./contracts.js";
+import type { CompiledRequestExecutionPolicy } from "./execution-scope.js";
+export type SuperFailureFinalization = Readonly<{
+    agentMode: RequestExecutionSeed["agentMode"];
+    remember(error: unknown, stage: string): void;
+    primaryError(): unknown;
+    explain(params: {
+        error: unknown;
+        input: DegradedFinalizationInput;
+        maxResponseChars: number;
+        steeringVersion?: number;
+    }): Promise<SuperFailureExplanation>;
+}>;
+/** Activation-local authoring cache only; lifecycle/persistence stay with their owners. */
+export declare function createSuperFailureFinalization(params: {
+    request: RequestExecutionSeed;
+    executionPolicy: CompiledRequestExecutionPolicy;
+    readBudgets?: () => RequestExecutionBudgets;
+}): SuperFailureFinalization | undefined;

package/dist/src/runtime/request/super-failure-explanation.js

@@ -0,0 +1,77 @@
+import { hasSuperContextContract } from "../context/super-context-policy.js";
+import { projectOutputLimitCause } from "../steps/degraded-finalization/output-limit-cause.js";
+import { boundedSuperFailureCode, createSuperFailureFallback, runSuperDegradedFinalization, } from "../steps/degraded-finalization/super.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+/** Activation-local authoring cache only; lifecycle/persistence stay with their owners. */
+export function createSuperFailureFinalization(params) {
+    if (!hasSuperContextContract(params.executionPolicy.authority, params.executionPolicy.rootContract.contractId))
+        return undefined;
+    const request = projectTrustedFailureRequest(params.request);
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    let primary;
+    let attempt;
+    const remember = (error, stage) => {
+        primary ??= Object.freeze({
+            error,
+            stage: boundedFailureStage(stage),
+            code: boundedSuperFailureCode(error),
+        });
+    };
+    return Object.freeze({
+        agentMode: request.agentMode,
+        remember,
+        primaryError: () => primary?.error,
+        async explain(input) {
+            remember(input.error, input.input.problem.stage);
+            const steeringVersion = input.steeringVersion ?? steering.snapshot().version;
+            const problem = {
+                stage: primary.stage,
+                code: primary.code,
+                ...projectOutputLimitCause(primary.error),
+            };
+            if (!attempt) {
+                // Install the promise before invoking model services or callbacks.
+                attempt = Promise.resolve().then(() => runSuperDegradedFinalization({
+                    request,
+                    input: { ...input.input, problem },
+                    maxResponseChars: input.maxResponseChars,
+                    steeringVersion,
+                    ...(params.readBudgets ? { readBudgets: params.readBudgets } : {}),
+                }));
+            }
+            const explanation = await attempt;
+            if (explanation.steeringVersion !== steeringVersion)
+                return createSuperFailureFallback({ problem, progress: null }, steeringVersion);
+            return explanation;
+        },
+    });
+}
+function projectTrustedFailureRequest(seed) {
+    return Object.freeze({
+        requestId: seed.requestId,
+        sessionId: seed.sessionId,
+        prompt: seed.prompt,
+        historyMessages: [],
+        shouldGenerateSessionTitle: false,
+        runnerConfig: seed.runnerConfig,
+        agentMode: seed.agentMode,
+        modelGatewayClient: seed.modelGatewayClient,
+        toolPermissionMode: seed.toolPermissionMode,
+        abortSignal: seed.abortSignal,
+        ...(seed.modelPreference ? { modelPreference: seed.modelPreference } : {}),
+        ...(seed.modelPolicy ? { modelPolicy: seed.modelPolicy } : {}),
+        ...(seed.modelInvocationScope
+            ? { modelInvocationScope: seed.modelInvocationScope }
+            : {}),
+        ...(seed.requestSteering ? { requestSteering: seed.requestSteering } : {}),
+        onAcknowledgement: () => undefined,
+        onSessionTitle: async () => undefined,
+        onAnswerToken: () => undefined,
+        onThinkingDelta: seed.onThinkingDelta,
+        onThinkingTrace: seed.onThinkingTrace,
+        onEvent: seed.onEvent,
+    });
+}
+function boundedFailureStage(stage) {
+    return /^[a-z][a-z0-9_.-]{0,119}$/iu.test(stage) ? stage : "request_failure";
+}

package/dist/src/runtime/request/super-failure-message.d.ts

@@ -0,0 +1,10 @@
+import type { SessionTerminalMessage } from "../../sessions/request-lifecycle/contracts.js";
+import type { SuperFailureFinalization } from "./super-failure-explanation.js";
+import type { RequestSteeringInbox } from "./request-steering.js";
+/** Presentation uses trusted request services only, never a failed role ledger. */
+export declare function composeSuperFailureMessage(params: {
+    requestId: string;
+    error: unknown;
+    finalization?: SuperFailureFinalization | undefined;
+    steering: RequestSteeringInbox;
+}): Promise<SessionTerminalMessage>;