@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/request/request-steering.js

@@ -1,4 +1,4 @@
-import { traceDebug } from "../observability/debug-logger.js";
+import { createRequestControlDiagnosticId, traceRequestControl, } from "../observability/request-control-diagnostics.js";
 export const REQUEST_STEERING_FEATURE = "request_steering_v1";
 export const REQUEST_STEERING_MESSAGE_KIND = "runtime_active_request_updates_v1";
 const LOG_SCOPE = "runtime.request_steering";
@@ -30,6 +30,10 @@ export function projectRequestSteeringSnapshot(inbox, version) {
     });
 }
 export function createRequestSteeringInbox(params) {
+    const diagnosticIdentity = {
+        inboxId: params.diagnostics?.inboxId ?? createRequestControlDiagnosticId("inbox"),
+        inboxOrigin: params.diagnostics?.origin ?? "request",
+    };
     const updates = [];
     const bySteerId = new Map();
     let closed = false;
@@ -37,6 +41,10 @@ export function createRequestSteeringInbox(params) {
     let persistenceBound = false;
     let persistUpdate;
     let persistenceTail = Promise.resolve();
+    traceRequestControl(LOG_SCOPE, "inbox.opened", {
+        ...diagnosticIdentity,
+        requestId: params.requestId,
+    });
     function schedulePersistence(update) {
         if (!persistUpdate)
             return;
@@ -44,7 +52,8 @@ export function createRequestSteeringInbox(params) {
         persistenceTail = persistenceTail.then(async () => {
             try {
                 await persist(update);
-                traceDebug(LOG_SCOPE, "update.persisted", {
+                traceRequestControl(LOG_SCOPE, "update.persisted", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId: update.steerId,
                     sequence: update.sequence,
@@ -52,7 +61,8 @@ export function createRequestSteeringInbox(params) {
                 });
             }
             catch (error) {
-                traceDebug(LOG_SCOPE, "update.persistence_failed", {
+                traceRequestControl(LOG_SCOPE, "update.persistence_failed", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId: update.steerId,
                     sequence: update.sequence,
@@ -66,8 +76,10 @@ export function createRequestSteeringInbox(params) {
             const steerId = input.steerId.trim();
             const text = input.text.trim();
             if (!steerId || !text) {
-                traceDebug(LOG_SCOPE, "update.rejected", {
+                traceRequestControl(LOG_SCOPE, "update.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
+                    steerId,
                     reason: "invalid_steer_request",
                     steerIdLength: steerId.length,
                     textLength: text.length,
@@ -80,7 +92,8 @@ export function createRequestSteeringInbox(params) {
             const existing = bySteerId.get(steerId);
             if (existing) {
                 if (existing.text !== text) {
-                    traceDebug(LOG_SCOPE, "update.rejected", {
+                    traceRequestControl(LOG_SCOPE, "update.rejected", {
+                        ...diagnosticIdentity,
                         requestId: params.requestId,
                         steerId,
                         reason: "steer_id_conflict",
@@ -90,7 +103,8 @@ export function createRequestSteeringInbox(params) {
                         reason: "steer_id_conflict",
                     });
                 }
-                traceDebug(LOG_SCOPE, "update.duplicate", {
+                traceRequestControl(LOG_SCOPE, "update.duplicate", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId,
                     sequence: existing.sequence,
@@ -102,7 +116,8 @@ export function createRequestSteeringInbox(params) {
                 });
             }
             if (closed || sealed) {
-                traceDebug(LOG_SCOPE, "update.rejected", {
+                traceRequestControl(LOG_SCOPE, "update.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     steerId,
                     reason: "request_not_active",
@@ -122,7 +137,8 @@ export function createRequestSteeringInbox(params) {
             updates.push(update);
             bySteerId.set(steerId, update);
             schedulePersistence(update);
-            traceDebug(LOG_SCOPE, "update.accepted", {
+            traceRequestControl(LOG_SCOPE, "update.accepted", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 steerId,
                 sequence: update.sequence,
@@ -144,7 +160,8 @@ export function createRequestSteeringInbox(params) {
             for (const update of updates) {
                 schedulePersistence(update);
             }
-            traceDebug(LOG_SCOPE, "persistence.bound", {
+            traceRequestControl(LOG_SCOPE, "persistence.bound", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 queuedUpdateCount: updates.length,
             });
@@ -156,8 +173,14 @@ export function createRequestSteeringInbox(params) {
             }
             closed = true;
             sealed = true;
+            traceRequestControl(LOG_SCOPE, "inbox.closing", {
+                ...diagnosticIdentity,
+                requestId: params.requestId,
+                updateCount: updates.length,
+            });
             await persistenceTail;
-            traceDebug(LOG_SCOPE, "inbox.closed", {
+            traceRequestControl(LOG_SCOPE, "inbox.closed", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 updateCount: updates.length,
             });
@@ -167,7 +190,8 @@ export function createRequestSteeringInbox(params) {
         },
         seal(version) {
             if (closed || sealed || updates.length !== version) {
-                traceDebug(LOG_SCOPE, "finalization.rejected", {
+                traceRequestControl(LOG_SCOPE, "finalization.rejected", {
+                    ...diagnosticIdentity,
                     requestId: params.requestId,
                     expectedVersion: version,
                     currentVersion: updates.length,
@@ -177,7 +201,8 @@ export function createRequestSteeringInbox(params) {
                 return false;
             }
             sealed = true;
-            traceDebug(LOG_SCOPE, "finalization.sealed", {
+            traceRequestControl(LOG_SCOPE, "finalization.sealed", {
+                ...diagnosticIdentity,
                 requestId: params.requestId,
                 version,
             });

package/dist/src/runtime/request/result.d.ts

@@ -6,8 +6,11 @@ export type RequestObservation = {
     observationContent: string;
 };
 export type RequestOutputTextMode = "exact";
+export type RequestCompletionDisposition = "responded" | "blocked";
 export type RequestRunnerResult = {
     output: string;
+    /** Explicit root blockage; omission preserves ordinary response semantics. */
+    disposition?: RequestCompletionDisposition;
     /** Omission preserves the legacy normalized finalization contract. */
     outputTextMode?: RequestOutputTextMode;
     finalObservation?: RequestObservation;

package/dist/src/runtime/request/role-executor-composition.js

@@ -9,18 +9,19 @@ import { EXECUTION_AGENT_AUDITOR_EXECUTOR } from "../steps/auditor-decision/inde
 import { DEFAULT_REQUEST_EXECUTION_POLICY_ID, } from "../config/model-execution-policy.js";
 import { SUPERVISOR_ROOT_CONTRACT } from "./supervisor-root-execution.js";
 import { EXECUTION_AGENT_ROOT_CONTRACT } from "./execution-agent-root-execution.js";
+import { containSuperContextFailures } from "./super-context-failure-executor.js";
 const REQUEST_ROLE_EXECUTOR_CATALOG = sealRequestRoleExecutorCatalog([
     {
         contractId: "delegated.planner",
-        executor: GENERIC_PLANNER_EXECUTOR,
+        executor: containSuperContextFailures(GENERIC_PLANNER_EXECUTOR, "delegated.planner"),
     },
     {
         contractId: "delegated.worker",
-        executor: GENERIC_WORKER_EXECUTOR,
+        executor: containSuperContextFailures(GENERIC_WORKER_EXECUTOR, "delegated.worker"),
     },
     {
         contractId: "delegated.reviewer",
-        executor: GENERIC_REVIEWER_EXECUTOR,
+        executor: containSuperContextFailures(GENERIC_REVIEWER_EXECUTOR, "delegated.reviewer"),
     },
     {
         contractId: "direct.planner_advisory",

package/dist/src/runtime/request/root-contract.d.ts

@@ -39,6 +39,7 @@ type RootContractAction = MemoryRecallDecision | Readonly<{
     action: "invoke_capability";
     capabilityId: string;
     intent: string;
+    authoringObjective?: string;
     controls: WorkerCapabilityControls;
     workingDirectory?: string;
     acknowledgement?: string;
@@ -48,6 +49,7 @@ type RootContractAction = MemoryRecallDecision | Readonly<{
     invocations: readonly Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         controls: WorkerCapabilityControls;
     }>[];
     workingDirectory?: string;

package/dist/src/runtime/request/root-execution-kernel.js

@@ -11,7 +11,7 @@ import { isModelStepSteeringSuperseded } from "../model/model-step-steering.js";
 import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
 import { createRoleCapabilityBinding, isWorkerCapabilityOperationSupervisionLimitError, projectWorkerCapabilityCatalogGroups, } from "../orchestration/worker-capabilities/index.js";
-import { runDegradedFinalization } from "../steps/degraded-finalization/run.js";
+import { runPolicyDegradedFinalization, projectPolicyDegradedResult, } from "./policy-degraded-finalization.js";
 import { resolveRequestSteeringInbox, } from "./request-steering.js";
 import { traceSupervisorRootAcknowledgementPublished, traceSupervisorRootActivationFailed, traceSupervisorRootActivationStarted, traceSupervisorRootInvocationSuperseded, traceSupervisorRootResponseSuperseded, } from "./supervisor-root-execution-diagnostics.js";
 import { projectSupervisorFinalObservation, } from "./root-observation-handoff.js";
@@ -414,6 +414,9 @@ class RootExecutionSession {
                 ? await binding.execute({
                     capabilityId: decision.capabilityId,
                     intent: decision.intent,
+                    ...(decision.authoringObjective
+                        ? { authoringObjective: decision.authoringObjective }
+                        : {}),
                     controls: decision.controls,
                 })
                 : await binding.executeBatch({ invocations: decision.invocations });
@@ -445,8 +448,9 @@ class RootExecutionSession {
             return CONTINUE_ROOT_EXECUTION;
         }
         params.attempt.failureStage = "compose_response";
-        const response = await runDegradedFinalization({
+        const response = await runPolicyDegradedFinalization({
             request: this.request,
+            maxResponseChars: params.head.policy.limits.maxResponseChars,
             input: Object.freeze({
                 problem: params.problem,
                 progress: null,
@@ -470,12 +474,7 @@ class RootExecutionSession {
         });
         return Object.freeze({
             kind: "complete",
-            result: Object.freeze({
-                output,
-                ...(this.policy.authority.terminalTextMode === "exact"
-                    ? { outputTextMode: "exact" }
-                    : {}),
-            }),
+            result: Object.freeze(projectPolicyDegradedResult(this.request, output)),
         });
     }
     async completeResponse(activation, decision, attempt) {
@@ -488,7 +487,8 @@ class RootExecutionSession {
             : undefined;
         attempt.publishDeferredTitle = () => this.publishDeferredTitle(activation, attempt);
         attempt.failureStage = "compose_response";
-        const authoredResponse = decision.action === "blocked"
+        const isBlockedCompletion = decision.action === "blocked";
+        const authoredResponse = isBlockedCompletion
             ? createPlainRootAuthoredResponse(decision.response)
             : await this.policy.rootContract.authorResponse(this.request, {
                 responseRecommendation: decision.responseRecommendation,
@@ -533,6 +533,7 @@ class RootExecutionSession {
                 ...(this.policy.authority.terminalTextMode === "exact"
                     ? { outputTextMode: "exact" }
                     : {}),
+                ...(isBlockedCompletion ? { disposition: "blocked" } : {}),
                 ...(finalObservation ? { finalObservation } : {}),
                 ...(authoredResponse.memoryCandidates.length > 0
                     ? { memoryCandidates: authoredResponse.memoryCandidates }

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;