@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/orchestration/role-calls/candidate-validation.js

@@ -1,7 +1,15 @@
 import { isRuntimeDelegateRoleId, RUNTIME_ROOT_ROLE_ID, RUNTIME_ROLE_IDS, } from "../roles.js";
 import { createRoleCapabilitySelectionFingerprint, normalizeRoleCapabilitySelectionProjection, } from "./capability-selection-reconsideration.js";
+import { createRoleCapabilitySelectionSupervisionFingerprint, isRoleCapabilitySelectionSupervisionState, } from "./capability-selection-supervision.js";
+import { isIssuedRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision-issuance.js";
+import { isRoleOperationFingerprint, isRoleOperationOutcomeFingerprintForOutcome, isSameRoleOperationIdentity, replayRoleOperationSupervisionEvidence, } from "./operation-supervision.js";
+import { isIssuedRoleOperationSupervisionInterventionForRequest } from "./operation-supervision-issuance.js";
+import { isRoleOperationSupervisionSettlementHistoryValid, isRoleOperationSupervisionState, } from "./operation-supervision-state-validation.js";
+import { isReconsiderationCauseBoundToInvocationCount } from "./reconsideration-cause.js";
 import { isRoleCapabilityId, ROLE_CAPABILITY_EXECUTION_LIMIT_MAX, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CALL_LEDGER_CONTRACT_VERSION, } from "./contracts.js";
 import { validateRoleCallPlans } from "./plan.js";
+import { isRoleCallResultReceiptValidForStoredResult } from "./result-receipt.js";
+import { findRoleActivationBudgetIssue } from "./activation-budget.js";
 import { isRoleCallWorkerCapabilityScope } from "./worker-capability-scope.js";
 import { isRoleCallWorkingDirectoryRoleId, normalizeEstablishedRoleCallWorkingDirectory, normalizeRoleCallWorkingDirectory, } from "./working-directory.js";
 import { areOwnedDependencyResults, exactKeys, findCall, isBoundedText, isCanonicalTerminalText, isExactJsonObjectString, isExactResultValidForCall, isOptionalBoundedText, isRecord, isRoleCapabilityDeclaredEffect, isSettledObservedEffectCompatible, isUniqueStringArray, isValidCapabilityResultReferences, issue, } from "./reducer-primitives.js";
@@ -36,6 +44,8 @@ export function validateRoleCallState(state, policy) {
         !Array.isArray(state?.results) ||
         !Array.isArray(state?.plans) ||
         !Array.isArray(state?.capabilityExecutions) ||
+        !isRoleOperationSupervisionState(state?.operationSupervision) ||
+        !isRoleCapabilitySelectionSupervisionState(state?.capabilitySelectionSupervision) ||
         !Number.isInteger(state?.callSequence) ||
         !Number.isInteger(state?.resultSequence) ||
         !Number.isInteger(state?.capabilityExecutionSequence) ||
@@ -65,6 +75,10 @@ export function validateRoleCallState(state, policy) {
             state.results.length > 0 ||
             state.plans.length > 0 ||
             state.capabilityExecutions.length > 0 ||
+            state.operationSupervision.entries.length > 0 ||
+            state.operationSupervision.interventions.length > 0 ||
+            state.capabilitySelectionSupervision.epoch !== null ||
+            state.capabilitySelectionSupervision.records.length > 0 ||
             state.rootResponse !== null) {
             issues.push(issue("invalid_empty_role_call_state", "state.phase"));
         }
@@ -85,6 +99,8 @@ export function validateRoleCallState(state, policy) {
     if (state.phase === "completed" &&
         (state.activeCallId !== null ||
             root?.status !== "completed" ||
+            state.capabilitySelectionSupervision.epoch !== null ||
+            state.capabilitySelectionSupervision.records.length > 0 ||
             !isCanonicalTerminalText(state.rootResponse, policy.limits.maxResponseChars, policy.authority.terminalTextMode))) {
         issues.push(issue("invalid_completed_role_call_state", "state.phase"));
     }
@@ -142,14 +158,74 @@ export function validateRoleCallState(state, policy) {
             producer.status !== "completed" ||
             producer.roleId !== result.roleId ||
             (result.outcome !== "completed" && result.outcome !== "failed") ||
-            !isBoundedText(result.summary, policy.limits.maxResultChars)) {
+            !isBoundedText(result.summary, policy.limits.maxResultChars) ||
+            !isRoleCallResultReceiptValidForStoredResult({
+                receipt: result.receipt,
+                producer,
+                result,
+                policy, state,
+            })) {
             issues.push(issue("invalid_role_call_result_owner", `state.results.${result.resultRef}`));
         }
     }
     issues.push(...validateRoleCallPlans(state, policy));
     validateCapabilityExecutions(state, policy, issues);
+    if (!isValidRoleOperationSupervision(state, policy)) {
+        issues.push(issue("invalid_role_operation_supervision", "state.operationSupervision"));
+    }
+    if (!isValidRoleCapabilitySelectionSupervision(state, policy)) {
+        issues.push(issue("invalid_role_capability_selection_supervision", "state.capabilitySelectionSupervision"));
+    }
+    const activationBudgetIssue = findRoleActivationBudgetIssue(state, policy);
+    if (activationBudgetIssue)
+        issues.push(activationBudgetIssue);
     return issues;
 }
+function isValidRoleCapabilitySelectionSupervision(state, policy) {
+    const supervision = state.capabilitySelectionSupervision;
+    if (!isRoleCapabilitySelectionSupervisionState(supervision))
+        return false;
+    if (supervision.epoch === null)
+        return supervision.records.length === 0;
+    if (!isIssuedRoleCapabilitySelectionSupervisionState({ state }))
+        return false;
+    if (state.phase !== "running" || supervision.records.length < 1) {
+        return false;
+    }
+    const call = findCall(state, supervision.epoch.callId);
+    const lastRecord = supervision.records.at(-1);
+    const reconsideration = call?.lastCapabilitySelectionReconsideration;
+    let expectedSupervisionFingerprint;
+    if (reconsideration) {
+        try {
+            expectedSupervisionFingerprint =
+                createRoleCapabilitySelectionSupervisionFingerprint({
+                    steeringVersion: reconsideration.steeringVersion,
+                    selection: reconsideration.selection,
+                });
+        }
+        catch {
+            return false;
+        }
+    }
+    if (!hasCapabilityAuthority(policy.authority, state, call) ||
+        state.activeCallId !== call.callId ||
+        call.status !== "active" ||
+        !lastRecord ||
+        !reconsideration ||
+        supervision.epoch.steeringVersion !== reconsideration.steeringVersion ||
+        lastRecord.invocationAttempt !== reconsideration.invocationAttempt ||
+        lastRecord.receiptFingerprint !== reconsideration.fingerprint ||
+        lastRecord.supervisionFingerprint !== expectedSupervisionFingerprint ||
+        call.activationCount !== lastRecord.invocationAttempt + 1) {
+        return false;
+    }
+    return supervision.records.every((record, index, records) => {
+        const previous = records[index - 1];
+        return (record.invocationAttempt < call.activationCount &&
+            (!previous || record.invocationAttempt === previous.invocationAttempt + 1));
+    });
+}
 function isValidCapabilitySelectionReconsideration(call, policy, state) {
     const reconsideration = call.lastCapabilitySelectionReconsideration;
     if (reconsideration === undefined)
@@ -161,6 +237,7 @@ function isValidCapabilitySelectionReconsideration(call, policy, state) {
             "steeringVersion",
             "fingerprint",
             "selection",
+            "cause",
         ]) ||
         !Number.isSafeInteger(reconsideration.invocationAttempt) ||
         reconsideration.invocationAttempt < 1 ||
@@ -173,6 +250,7 @@ function isValidCapabilitySelectionReconsideration(call, policy, state) {
     }
     const selection = normalizeRoleCapabilitySelectionProjection(reconsideration.selection);
     return (selection !== undefined &&
+        isReconsiderationCauseBoundToInvocationCount(reconsideration.cause, selection.invocations.length) &&
         createRoleCapabilitySelectionFingerprint({
             steeringVersion: reconsideration.steeringVersion,
             selection,
@@ -202,6 +280,7 @@ function validateCapabilityExecutions(state, policy, issues) {
             !isRoleCapabilityDeclaredEffect(execution.declaredEffect) ||
             !isBoundedText(execution.intent, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH) ||
             !isExactJsonObjectString(execution.controlsJson) ||
+            !isValidExecutionActionFingerprint(execution) ||
             (execution.status !== "running" && execution.status !== "settled")) {
             issues.push(issue("invalid_role_capability_execution", `state.capabilityExecutions.${execution.executionId}`));
             continue;
@@ -212,6 +291,7 @@ function validateCapabilityExecutions(state, policy, issues) {
                 call.status !== "waiting_for_capability" ||
                 call.activationCount !== execution.invocationAttempt ||
                 execution.outcome !== null ||
+                execution.outcomeFingerprint !== null ||
                 execution.observedEffect !== null ||
                 execution.summary !== null ||
                 execution.referenceData !== undefined ||
@@ -226,6 +306,8 @@ function validateCapabilityExecutions(state, policy, issues) {
                 !isValidCapabilityResultReferences(execution.references) ||
                 !isExactResultValidForCall(call, execution.exactResult) ||
                 (execution.outcome !== "succeeded" && execution.outcome !== "failed") ||
+                (execution.outcomeFingerprint !== null &&
+                    !isRoleOperationOutcomeFingerprintForOutcome(execution.outcomeFingerprint, execution.outcome)) ||
                 !isSettledObservedEffectCompatible({
                     declaredEffect: execution.declaredEffect,
                     outcome: execution.outcome,
@@ -256,6 +338,85 @@ function validateCapabilityExecutions(state, policy, issues) {
         }
     }
 }
+function isValidExecutionActionFingerprint(execution) {
+    return (execution.actionFingerprint === undefined ||
+        isRoleOperationFingerprint(execution.actionFingerprint));
+}
+function isValidRoleOperationSupervision(state, policy) {
+    const interventions = state.operationSupervision.interventions;
+    const allInterventionsWereIssuedForRequest = interventions.every((intervention) => isIssuedRoleOperationSupervisionInterventionForRequest({
+        requestId: state.requestId,
+        intervention,
+    }));
+    if (!allInterventionsWereIssuedForRequest)
+        return false;
+    const settlements = projectOperationSupervisionSettlements(state.capabilityExecutions);
+    if (!isRoleOperationSupervisionSettlementHistoryValid(settlements)) {
+        return false;
+    }
+    const replayed = replayRoleOperationSupervisionEvidence({
+        settlements,
+        interventions,
+    });
+    if (!replayed ||
+        state.operationSupervision.entries.length !== replayed.entries.length) {
+        return false;
+    }
+    return (state.operationSupervision.entries.every((current, index) => {
+        const replayedEntry = replayed.entries[index];
+        return (replayedEntry !== undefined &&
+            isSameRoleOperationSupervisionEntry(current, replayedEntry));
+    }) &&
+        interventions.every((intervention) => isValidOperationSupervisionIntervention(state, policy, intervention)));
+}
+function projectOperationSupervisionSettlements(executions) {
+    const settlements = [];
+    for (const execution of executions) {
+        if (execution.status !== "settled" ||
+            execution.outcome === null ||
+            execution.observedEffect === null) {
+            continue;
+        }
+        settlements.push({
+            capabilityId: execution.capabilityId,
+            ...(execution.actionFingerprint
+                ? { actionFingerprint: execution.actionFingerprint }
+                : {}),
+            outcome: execution.outcome,
+            ...(execution.outcomeFingerprint
+                ? { outcomeFingerprint: execution.outcomeFingerprint }
+                : {}),
+            observedEffect: execution.observedEffect,
+            originExecutionId: execution.executionId,
+        });
+    }
+    return settlements;
+}
+function isSameRoleOperationSupervisionEntry(left, right) {
+    if (left.stage !== right.stage ||
+        !isSameRoleOperationIdentity(left, right) ||
+        left.priorOutcome !== right.priorOutcome ||
+        left.outcomeFingerprint !== right.outcomeFingerprint ||
+        left.originExecutionId !== right.originExecutionId ||
+        left.matchingOutcomeCount !== right.matchingOutcomeCount) {
+        return false;
+    }
+    if (left.stage !== "intervened" || right.stage !== "intervened") {
+        return true;
+    }
+    return (left.interventionCount === right.interventionCount &&
+        left.interventionCallId === right.interventionCallId &&
+        left.interventionInvocationAttempt === right.interventionInvocationAttempt);
+}
+function isValidOperationSupervisionIntervention(state, policy, intervention) {
+    const call = findCall(state, intervention.interventionCallId);
+    const executionWasRecordedForIntervention = state.capabilityExecutions.some((execution) => execution.callId === intervention.interventionCallId &&
+        execution.invocationAttempt ===
+            intervention.interventionInvocationAttempt);
+    return (hasCapabilityAuthority(policy.authority, state, call) &&
+        intervention.interventionInvocationAttempt < call.activationCount &&
+        !executionWasRecordedForIntervention);
+}
 export function hasCapabilityAuthority(authority, state, call) {
     return hasRoleCallCapabilityAuthority(authority, state.rootCallId, call);
 }

package/dist/src/runtime/orchestration/role-calls/capability-selection-reconsideration.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
 import { isRoleCapabilityId, ROLE_CAPABILITY_INVOCATION_CONTROLS_JSON_MAX_LENGTH, ROLE_CAPABILITY_INVOCATION_INTENT_MAX_LENGTH, ROLE_CAPABILITY_SELECTION_INVOCATION_LIMIT_MAX, } from "./contracts.js";
 import { parseRoleCallWorkerCapabilityScope } from "./worker-capability-scope.js";
 import { normalizeEstablishedRoleCallWorkingDirectory } from "./working-directory.js";
@@ -144,15 +145,7 @@ function canonicalizeJsonValue(input) {
         .sort()
         .map((key) => [key, canonicalizeJsonValue(input[key])]));
 }
-function exactKeys(input, expectedKeys) {
-    const expected = new Set(expectedKeys);
-    const actual = Object.keys(input);
-    return (actual.length === expected.size && actual.every((key) => expected.has(key)));
-}
 function sameStringArray(left, right) {
     return (left.length === right.length &&
         left.every((value, index) => value === right[index]));
 }
-function isRecord(input) {
-    return input !== null && typeof input === "object" && !Array.isArray(input);
-}

package/dist/src/runtime/orchestration/role-calls/capability-selection-supervision-issuance.d.ts

@@ -0,0 +1,17 @@
+import type { RoleCallCommitEffect, RoleCallState } from "./contracts.js";
+declare const roleCapabilitySelectionSupervisionIssuanceAuthorityBrand: unique symbol;
+export type RoleCapabilitySelectionSupervisionIssuanceAuthority = Readonly<{
+    [roleCapabilitySelectionSupervisionIssuanceAuthorityBrand]: true;
+}>;
+export declare function issueInitialRoleCapabilitySelectionSupervisionState(state: RoleCallState): boolean;
+export declare function resolveRoleCapabilitySelectionSupervisionIssuanceAuthority(state: RoleCallState): RoleCapabilitySelectionSupervisionIssuanceAuthority | undefined;
+export declare function issueCanonicalRoleCapabilitySelectionSupervisionTransition(input: Readonly<{
+    before: RoleCallState;
+    after: RoleCallState;
+    effect: RoleCallCommitEffect;
+}>): boolean;
+export declare function isIssuedRoleCapabilitySelectionSupervisionState(input: Readonly<{
+    state: RoleCallState;
+    authority?: RoleCapabilitySelectionSupervisionIssuanceAuthority;
+}>): boolean;
+export {};

package/dist/src/runtime/orchestration/role-calls/capability-selection-supervision-issuance.js

@@ -0,0 +1,155 @@
+const issuedStateMetadata = new WeakMap();
+const issuedRecordMetadata = new WeakMap();
+export function issueInitialRoleCapabilitySelectionSupervisionState(state) {
+    if (!isInitialSupervisionState(state) || issuedStateMetadata.has(state)) {
+        return false;
+    }
+    const authority = Object.freeze({});
+    issuedStateMetadata.set(state, Object.freeze({ authority, lastRecord: null }));
+    return true;
+}
+export function resolveRoleCapabilitySelectionSupervisionIssuanceAuthority(state) {
+    return issuedStateMetadata.get(state)?.authority;
+}
+export function issueCanonicalRoleCapabilitySelectionSupervisionTransition(input) {
+    const beforeMetadata = issuedStateMetadata.get(input.before);
+    if (!beforeMetadata ||
+        !isIssuedRoleCapabilitySelectionSupervisionState({
+            state: input.before,
+            authority: beforeMetadata.authority,
+        })) {
+        return false;
+    }
+    if (input.effect.type === "capability_selection_reconsidered") {
+        const record = findCanonicalAppendedRecord({
+            before: input.before,
+            after: input.after,
+            effect: input.effect,
+        });
+        const epoch = input.after.capabilitySelectionSupervision.epoch;
+        if (!record || !epoch || issuedRecordMetadata.has(record))
+            return false;
+        const sameEpoch = input.before.capabilitySelectionSupervision.epoch?.callId ===
+            epoch.callId &&
+            input.before.capabilitySelectionSupervision.epoch.steeringVersion ===
+                epoch.steeringVersion;
+        const beforeEpoch = input.before.capabilitySelectionSupervision.epoch;
+        if (!sameEpoch &&
+            beforeEpoch &&
+            (beforeEpoch.callId !== epoch.callId ||
+                epoch.steeringVersion <= beforeEpoch.steeringVersion)) {
+            return false;
+        }
+        const previousRecord = sameEpoch
+            ? (input.before.capabilitySelectionSupervision.records.at(-1) ?? null)
+            : null;
+        if (!canIssueState(input.after, beforeMetadata.authority, record)) {
+            return false;
+        }
+        issuedRecordMetadata.set(record, Object.freeze({
+            authority: beforeMetadata.authority,
+            requestId: input.before.requestId,
+            callId: epoch.callId,
+            steeringVersion: epoch.steeringVersion,
+            recordIndex: input.after.capabilitySelectionSupervision.records.length - 1,
+            previousRecord,
+        }));
+        return issueState(input.after, beforeMetadata.authority, record);
+    }
+    if (isCapabilitySelectionSupervisionResetEffect(input.effect)) {
+        if (!isInitialSupervisionState(input.after))
+            return false;
+        return issueState(input.after, beforeMetadata.authority, null);
+    }
+    if (input.after.capabilitySelectionSupervision !==
+        input.before.capabilitySelectionSupervision) {
+        return false;
+    }
+    return issueState(input.after, beforeMetadata.authority, beforeMetadata.lastRecord);
+}
+export function isIssuedRoleCapabilitySelectionSupervisionState(input) {
+    const stateMetadata = issuedStateMetadata.get(input.state);
+    if (!stateMetadata ||
+        (input.authority !== undefined &&
+            stateMetadata.authority !== input.authority)) {
+        return false;
+    }
+    const supervision = input.state.capabilitySelectionSupervision;
+    if (supervision.epoch === null || supervision.records.length === 0) {
+        return (supervision.epoch === null &&
+            supervision.records.length === 0 &&
+            stateMetadata.lastRecord === null);
+    }
+    let previousRecord = null;
+    for (const [recordIndex, record] of supervision.records.entries()) {
+        const recordMetadata = issuedRecordMetadata.get(record);
+        if (!recordMetadata ||
+            recordMetadata.authority !== stateMetadata.authority ||
+            recordMetadata.requestId !== input.state.requestId ||
+            recordMetadata.callId !== supervision.epoch.callId ||
+            recordMetadata.steeringVersion !== supervision.epoch.steeringVersion ||
+            recordMetadata.recordIndex !== recordIndex ||
+            recordMetadata.previousRecord !== previousRecord) {
+            return false;
+        }
+        previousRecord = record;
+    }
+    return stateMetadata.lastRecord === previousRecord;
+}
+function issueState(state, authority, lastRecord) {
+    if (!canIssueState(state, authority, lastRecord))
+        return false;
+    issuedStateMetadata.set(state, Object.freeze({ authority, lastRecord }));
+    return true;
+}
+function canIssueState(state, authority, lastRecord) {
+    const existing = issuedStateMetadata.get(state);
+    return (!existing ||
+        (existing.authority === authority && existing.lastRecord === lastRecord));
+}
+function findCanonicalAppendedRecord(input) {
+    const before = input.before.capabilitySelectionSupervision;
+    const after = input.after.capabilitySelectionSupervision;
+    const reconsideration = input.after.calls.find((call) => call.callId === input.effect.callId)?.lastCapabilitySelectionReconsideration;
+    const record = after.records.at(-1);
+    if (after === before ||
+        !after.epoch ||
+        !reconsideration ||
+        !record ||
+        after.epoch.callId !== input.effect.callId ||
+        after.epoch.steeringVersion !== reconsideration.steeringVersion ||
+        record.invocationAttempt !== input.effect.invocationAttempt ||
+        record.receiptFingerprint !== input.effect.fingerprint ||
+        record.supervisionFingerprint !== input.effect.supervisionFingerprint ||
+        record.stage !== input.effect.supervisionStage ||
+        record.trigger !== input.effect.supervisionTrigger ||
+        record.identityCount !== input.effect.matchingSelectionCount ||
+        record.totalCount !== input.effect.totalReconsiderationCount) {
+        return undefined;
+    }
+    const sameEpoch = before.epoch?.callId === after.epoch.callId &&
+        before.epoch.steeringVersion === after.epoch.steeringVersion;
+    if (!sameEpoch) {
+        return after.records.length === 1 ? record : undefined;
+    }
+    if (after.epoch !== before.epoch ||
+        after.records.length !== before.records.length + 1 ||
+        !before.records.every((previousRecord, index) => after.records[index] === previousRecord)) {
+        return undefined;
+    }
+    return record;
+}
+function isCapabilitySelectionSupervisionResetEffect(effect) {
+    return (effect.type === "root_response_committed" ||
+        effect.type === "child_opened" ||
+        effect.type === "child_returned" ||
+        effect.type === "capability_execution_begun" ||
+        effect.type === "capability_batch_begun" ||
+        effect.type === "operation_supervision_intervened" ||
+        effect.type === "capability_scope_updated" ||
+        effect.type === "working_directory_established");
+}
+function isInitialSupervisionState(state) {
+    return (state.capabilitySelectionSupervision.epoch === null &&
+        state.capabilitySelectionSupervision.records.length === 0);
+}

package/dist/src/runtime/orchestration/role-calls/capability-selection-supervision.d.ts

@@ -0,0 +1,78 @@
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_FINGERPRINT_PATTERN: RegExp;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_REPEAT_WARNING_COUNT: 2;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_REPEAT_INTERVENTION_COUNT: 3;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_REPEAT_LIMIT: 4;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_TOTAL_WARNING_COUNT: 6;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_TOTAL_INTERVENTION_COUNT: 7;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_TOTAL_LIMIT: 8;
+export declare const ROLE_CAPABILITY_SELECTION_SUPERVISION_RECORD_LIMIT: number;
+export type RoleCapabilitySelectionSupervisionFingerprint = string;
+export type RoleCapabilitySelectionSupervisionStage = "tracking" | "warning" | "intervened";
+export type RoleCapabilitySelectionSupervisionTrigger = "repeat_identity" | "total_budget" | "repeat_and_total";
+export type RoleCapabilitySelectionSupervisionSelection = Readonly<{
+    action: "invoke_capability" | "invoke_capabilities";
+    invocations: readonly Readonly<{
+        capabilityId: string;
+        selectionControlsJson: string;
+        intent?: string;
+    }>[];
+    workingDirectory?: string | null;
+    activeCapabilityCatalogGroupIds?: readonly string[];
+}>;
+export type RoleCapabilitySelectionSupervisionEpoch = Readonly<{
+    callId: string;
+    steeringVersion: number;
+}>;
+export type RoleCapabilitySelectionSupervisionRecord = Readonly<{
+    invocationAttempt: number;
+    receiptFingerprint: string;
+    supervisionFingerprint: RoleCapabilitySelectionSupervisionFingerprint;
+    identityCount: number;
+    totalCount: number;
+    stage: RoleCapabilitySelectionSupervisionStage;
+    trigger: RoleCapabilitySelectionSupervisionTrigger;
+}>;
+export type RoleCapabilitySelectionSupervisionState = Readonly<{
+    epoch: RoleCapabilitySelectionSupervisionEpoch | null;
+    records: readonly RoleCapabilitySelectionSupervisionRecord[];
+}>;
+type RoleCapabilitySelectionSupervisionAssessmentBase = Readonly<{
+    supervisionFingerprint: RoleCapabilitySelectionSupervisionFingerprint;
+    identityCount: number;
+    totalCount: number;
+    trigger: RoleCapabilitySelectionSupervisionTrigger;
+}>;
+export type RoleCapabilitySelectionSupervisionAssessment = (RoleCapabilitySelectionSupervisionAssessmentBase & Readonly<{
+    disposition: RoleCapabilitySelectionSupervisionStage;
+    state: RoleCapabilitySelectionSupervisionState;
+    record: RoleCapabilitySelectionSupervisionRecord;
+}>) | (RoleCapabilitySelectionSupervisionAssessmentBase & Readonly<{
+    disposition: "reject";
+    issueCode: "capability_selection_supervision_limit_exceeded";
+    attemptedRecord: Readonly<{
+        invocationAttempt: number;
+        receiptFingerprint: string;
+        supervisionFingerprint: RoleCapabilitySelectionSupervisionFingerprint;
+    }>;
+}>);
+export declare function createInitialRoleCapabilitySelectionSupervisionState(): RoleCapabilitySelectionSupervisionState;
+export declare function createRoleCapabilitySelectionSupervisionFingerprint(input: {
+    steeringVersion: number;
+    selection: RoleCapabilitySelectionSupervisionSelection;
+}): RoleCapabilitySelectionSupervisionFingerprint;
+export declare function assessRoleCapabilitySelectionSupervisionReconsideration(input: {
+    state: RoleCapabilitySelectionSupervisionState;
+    callId: string;
+    invocationAttempt: number;
+    steeringVersion: number;
+    receiptFingerprint: string;
+    selection: RoleCapabilitySelectionSupervisionSelection;
+}): RoleCapabilitySelectionSupervisionAssessment;
+export declare function resetRoleCapabilitySelectionSupervisionState(): RoleCapabilitySelectionSupervisionState;
+export declare function replayRoleCapabilitySelectionSupervisionRecords(input: {
+    epoch: RoleCapabilitySelectionSupervisionEpoch | null;
+    records: readonly RoleCapabilitySelectionSupervisionRecord[];
+}): RoleCapabilitySelectionSupervisionState | undefined;
+export declare function isRoleCapabilitySelectionSupervisionState(input: unknown): input is RoleCapabilitySelectionSupervisionState;
+export declare function isRoleCapabilitySelectionSupervisionFingerprint(input: unknown): input is RoleCapabilitySelectionSupervisionFingerprint;
+export {};