@abot-ai/runtime 1.0.0 → 1.1.0

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

@@ -0,0 +1,127 @@
+import { ROLE_CAPABILITY_SELECTION_INVOCATION_LIMIT_MAX } from "./contracts.js";
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+export const ROLE_CAPABILITY_RECONSIDERATION_REASON_MAX_LENGTH = 320;
+export const ROLE_CAPABILITY_RECONSIDERATION_STAGE_MAX_LENGTH = 128;
+export const ROLE_CAPABILITY_RECONSIDERATION_ISSUE_CODE_MAX_LENGTH = 128;
+export const ROLE_CAPABILITY_RECONSIDERATION_ISSUE_PATH_MAX_LENGTH = 512;
+export const ROLE_CAPABILITY_RECONSIDERATION_ISSUE_LIMIT_MAX = 16;
+export const ROLE_CAPABILITY_RECONSIDERATION_REPAIR_LIMIT_MAX = 16;
+export function normalizeRoleCapabilitySelectionReconsiderationCause(input) {
+    if (!isRecord(input) || typeof input.kind !== "string")
+        return undefined;
+    if (input.kind === "refinement_declined") {
+        return normalizeRefinementDeclined(input);
+    }
+    if (input.kind === "refinement_invalid_output") {
+        return normalizeRefinementInvalidOutput(input);
+    }
+    return undefined;
+}
+export function isReconsiderationCauseBoundToInvocationCount(input, invocationCount) {
+    const cause = normalizeRoleCapabilitySelectionReconsiderationCause(input);
+    if (!cause || !Number.isSafeInteger(invocationCount))
+        return false;
+    if (invocationCount < 1)
+        return false;
+    if (cause.kind === "refinement_invalid_output")
+        return true;
+    const indexes = cause.entries.map(({ invocationIndex }) => invocationIndex);
+    const uniqueIndexes = new Set(indexes);
+    return (uniqueIndexes.size === indexes.length &&
+        indexes.every((index) => index < invocationCount));
+}
+function normalizeRefinementDeclined(input) {
+    if (!exactKeys(input, ["kind", "entries"]))
+        return undefined;
+    if (!Array.isArray(input.entries))
+        return undefined;
+    if (input.entries.length < 1 ||
+        input.entries.length > ROLE_CAPABILITY_SELECTION_INVOCATION_LIMIT_MAX) {
+        return undefined;
+    }
+    const entries = input.entries.map(normalizeRefinementDecline);
+    if (entries.some((entry) => entry === undefined))
+        return undefined;
+    return Object.freeze({
+        kind: "refinement_declined",
+        entries: Object.freeze(entries),
+    });
+}
+function normalizeRefinementDecline(input) {
+    if (!isRecord(input) || !exactKeys(input, ["invocationIndex", "reason"])) {
+        return undefined;
+    }
+    if (!Number.isSafeInteger(input.invocationIndex))
+        return undefined;
+    if (input.invocationIndex < 0)
+        return undefined;
+    const reason = normalizeBoundedText(input.reason, ROLE_CAPABILITY_RECONSIDERATION_REASON_MAX_LENGTH);
+    return reason
+        ? Object.freeze({
+            invocationIndex: input.invocationIndex,
+            reason,
+        })
+        : undefined;
+}
+function normalizeRefinementInvalidOutput(input) {
+    if (!exactKeys(input, [
+        "kind",
+        "validationStage",
+        "issues",
+        "repairAttempts",
+        "repeatedInvalidOutput",
+    ])) {
+        return undefined;
+    }
+    const validationStage = normalizeBoundedText(input.validationStage, ROLE_CAPABILITY_RECONSIDERATION_STAGE_MAX_LENGTH);
+    const issues = normalizeValidationIssues(input.issues);
+    const repairAttempts = input.repairAttempts;
+    if (!validationStage || !issues)
+        return undefined;
+    if (!Number.isSafeInteger(repairAttempts))
+        return undefined;
+    if (repairAttempts < 0 ||
+        repairAttempts >
+            ROLE_CAPABILITY_RECONSIDERATION_REPAIR_LIMIT_MAX) {
+        return undefined;
+    }
+    if (typeof input.repeatedInvalidOutput !== "boolean")
+        return undefined;
+    return Object.freeze({
+        kind: "refinement_invalid_output",
+        validationStage,
+        issues,
+        repairAttempts: repairAttempts,
+        repeatedInvalidOutput: input.repeatedInvalidOutput,
+    });
+}
+function normalizeValidationIssues(input) {
+    if (!Array.isArray(input))
+        return undefined;
+    if (input.length > ROLE_CAPABILITY_RECONSIDERATION_ISSUE_LIMIT_MAX) {
+        return undefined;
+    }
+    const issues = input.map((entry) => {
+        if (!isRecord(entry) || !exactKeys(entry, ["code", "path"])) {
+            return undefined;
+        }
+        const code = normalizeBoundedText(entry.code, ROLE_CAPABILITY_RECONSIDERATION_ISSUE_CODE_MAX_LENGTH);
+        const path = normalizeBoundedTextAllowEmpty(entry.path, ROLE_CAPABILITY_RECONSIDERATION_ISSUE_PATH_MAX_LENGTH);
+        return code !== undefined && path !== undefined
+            ? Object.freeze({ code, path })
+            : undefined;
+    });
+    return issues.some((issue) => issue === undefined)
+        ? undefined
+        : Object.freeze(issues);
+}
+function normalizeBoundedText(input, maximumLength) {
+    const normalized = normalizeBoundedTextAllowEmpty(input, maximumLength);
+    return normalized && normalized.length > 0 ? normalized : undefined;
+}
+function normalizeBoundedTextAllowEmpty(input, maximumLength) {
+    if (typeof input !== "string")
+        return undefined;
+    const normalized = input.trim();
+    return normalized.length <= maximumLength ? normalized : undefined;
+}

package/dist/src/runtime/orchestration/role-calls/reducer-primitives.d.ts

@@ -1,14 +1,13 @@
 import { type CapabilityAdapterResult } from "../capability-adapters/result.js";
 import { type ExecutionPolicyAuthoritySnapshot, type RoleCallCommitEffect, type RoleCallFrame, type RoleCallState, type RoleCallTransitionRejectionCode, type RoleCallTransitionResult, type RoleCallValidationIssue, type RoleCapabilityDeclaredEffect, type RoleCapabilityExecutionOutcome, type RoleCapabilityObservedEffect, type RoleCapabilityResultReference } from "./contracts.js";
+export { exactKeys, isRecord } from "../../validation/strict-record.js";
 export declare function commit(candidate: RoleCallState, effect: RoleCallCommitEffect): RoleCallTransitionResult;
 export declare function reject(state: RoleCallState, code: RoleCallTransitionRejectionCode, issues?: readonly RoleCallValidationIssue[]): RoleCallTransitionResult;
 export declare function findCall(state: RoleCallState, callId: string): RoleCallFrame | undefined;
-export declare function exactKeys(value: Record<string, unknown>, requiredKeys: readonly string[], optionalKeys?: readonly string[]): boolean;
 export declare function isExactJsonObjectString(value: unknown): value is string;
 export declare function isUniqueStringArray(value: unknown): value is readonly string[];
 export declare function sameStringArray(left: readonly string[], right: readonly string[]): boolean;
 export declare function areOwnedDependencyResults(state: RoleCallState, caller: RoleCallFrame, resultRefs: readonly string[], dependentCallIndex?: number): boolean;
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function parseOptionalCapabilityAdapterResult(input: unknown): CapabilityAdapterResult | undefined | null;
 export declare function isExactResultValidForCall(_call: RoleCallFrame, input: unknown): boolean;
 export declare function parseCapabilityResultReferences(input: unknown): readonly RoleCapabilityResultReference[] | undefined | null;

package/dist/src/runtime/orchestration/role-calls/reducer-primitives.js

@@ -1,5 +1,7 @@
 import { normalizeCapabilityAdapterResult, } from "../capability-adapters/result.js";
 import { ROLE_CAPABILITY_INVOCATION_CONTROLS_JSON_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, } from "./contracts.js";
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+export { exactKeys, isRecord } from "../../validation/strict-record.js";
 export function commit(candidate, effect) {
     return {
         ok: true,
@@ -20,15 +22,6 @@ export function reject(state, code, issues) {
 export function findCall(state, callId) {
     return state.calls.find((call) => call.callId === callId);
 }
-export function exactKeys(value, requiredKeys, optionalKeys = []) {
-    const required = new Set(requiredKeys);
-    const allowed = new Set([...requiredKeys, ...optionalKeys]);
-    const actual = Object.keys(value);
-    return (requiredKeys.every((key) => actual.includes(key)) &&
-        actual.every((key) => allowed.has(key)) &&
-        actual.length >= required.size &&
-        actual.length <= allowed.size);
-}
 export function isExactJsonObjectString(value) {
     if (typeof value !== "string" ||
         value.length < 2 ||
@@ -70,9 +63,6 @@ export function areOwnedDependencyResults(state, caller, resultRefs, dependentCa
             producer.roleId === result.roleId);
     });
 }
-export function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 export function parseOptionalCapabilityAdapterResult(input) {
     if (input === undefined)
         return undefined;

package/dist/src/runtime/orchestration/role-calls/reducer.js

@@ -2,10 +2,14 @@ import { ROLE_CALL_LEDGER_CONTRACT_VERSION, SUPERVISOR_WORKER_V1_AUTHORITY_SNAPS
 import { validateRoleCallPolicy, validateRoleCallState, } from "./candidate-validation.js";
 import { decodeRoleCallCommand } from "./command-decoder.js";
 import { dispatchRoleCallCommand } from "./command-dispatch.js";
+import { findRoleActivationReservationIssue } from "./activation-budget.js";
+import { createInitialRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision.js";
+import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision-issuance.js";
+import { createInitialRoleOperationSupervisionState } from "./operation-supervision.js";
 import { reject, seal } from "./reducer-primitives.js";
 export { hasRoleCallCapabilityAuthority } from "./candidate-validation.js";
 export function createInitialRoleCallState(requestId) {
-    return seal({
+    const state = seal({
         contractVersion: ROLE_CALL_LEDGER_CONTRACT_VERSION,
         requestId,
         phase: "empty",
@@ -18,8 +22,14 @@ export function createInitialRoleCallState(requestId) {
         results: [],
         plans: [],
         capabilityExecutions: [],
+        operationSupervision: createInitialRoleOperationSupervisionState(),
+        capabilitySelectionSupervision: createInitialRoleCapabilitySelectionSupervisionState(),
         rootResponse: null,
     });
+    if (!issueInitialRoleCapabilitySelectionSupervisionState(state)) {
+        throw new Error("role_call_capability_selection_supervision_initial_issuance_invalid");
+    }
+    return state;
 }
 export function applyRoleCallCommand(state, commandInput, policy) {
     const policyIssues = validateRoleCallPolicy(policy);
@@ -34,7 +44,14 @@ export function applyRoleCallCommand(state, commandInput, policy) {
     if (!command.ok) {
         return reject(state, command.code);
     }
-    return dispatchRoleCallCommand(state, command.value, policy);
+    const transition = dispatchRoleCallCommand(state, command.value, policy);
+    if (!transition.ok)
+        return transition;
+    const reservationIssue = findRoleActivationReservationIssue(state, policy, command.value);
+    if (reservationIssue) {
+        return reject(state, "role_activation_limit_exceeded", [reservationIssue]);
+    }
+    return transition;
 }
 export function validateRoleCallCandidate(params) {
     const policyIssues = validateRoleCallPolicy(params.policy);

package/dist/src/runtime/orchestration/role-calls/transactions.js

@@ -41,8 +41,11 @@ export function createRoleCallTransactions(apply) {
                 effect.childCallId === input.childCallId);
         },
         async beginCapabilityExecution(input) {
-            return requireEffect(await apply({
+            return requireCapabilityExecutionAttemptEffect(await apply({
                 expectedHead: input.expectedHead,
+                ...(input.admission
+                    ? { capabilityExecutionAdmission: input.admission }
+                    : {}),
                 command: {
                     authority: "active_role",
                     type: "begin_capability_execution",
@@ -52,8 +55,11 @@ export function createRoleCallTransactions(apply) {
                     declaredEffect: input.declaredEffect,
                     intent: input.intent,
                     controlsJson: input.controlsJson,
+                    ...(input.actionFingerprint
+                        ? { actionFingerprint: input.actionFingerprint }
+                        : {}),
                 },
-            }), "capability_execution_begun", "commit_effect_invalid", (effect) => effect.callId === input.callId);
+            }), input);
         },
         async settleCapabilityExecution(input) {
             return requireEffect(await apply({
@@ -63,8 +69,11 @@ export function createRoleCallTransactions(apply) {
                 effect.executionId === input.executionId);
         },
         async beginCapabilityBatch(input) {
-            return requireEffect(await apply({
+            return requireCapabilityBatchAttemptEffect(await apply({
                 expectedHead: input.expectedHead,
+                ...(input.admission
+                    ? { capabilityExecutionAdmission: input.admission }
+                    : {}),
                 command: {
                     authority: "active_role",
                     type: "begin_capability_batch",
@@ -72,8 +81,7 @@ export function createRoleCallTransactions(apply) {
                     invocationAttempt: input.invocationAttempt,
                     entries: input.entries,
                 },
-            }), "capability_batch_begun", "commit_effect_invalid", (effect) => effect.callId === input.callId &&
-                effect.executionIds.length === input.entries.length);
+            }), input);
         },
         async settleCapabilityBatch(input) {
             return requireEffect(await apply({
@@ -122,12 +130,58 @@ export function createRoleCallTransactions(apply) {
                     invocationAttempt: input.invocationAttempt,
                     steeringVersion: input.steeringVersion,
                     selection: input.selection,
+                    cause: input.cause,
                 },
             }), "capability_selection_reconsidered", "capability_selection_reconsideration_transition_invalid", (effect) => effect.callId === input.callId &&
                 effect.invocationAttempt === input.invocationAttempt);
         },
     });
 }
+function requireCapabilityExecutionAttemptEffect(commit, input) {
+    if (!commit.ok) {
+        return Object.freeze({
+            ok: false,
+            issueCode: commit.code,
+            commit,
+        });
+    }
+    const effect = commit.effect;
+    const isExpectedExecution = effect.type === "capability_execution_begun" &&
+        effect.callId === input.callId;
+    const isExpectedIntervention = effect.type === "operation_supervision_intervened" &&
+        effect.callId === input.callId &&
+        effect.invocationAttempt === input.invocationAttempt &&
+        effect.capabilityId === input.capabilityId &&
+        effect.actionFingerprint === input.actionFingerprint;
+    if (!isExpectedExecution && !isExpectedIntervention) {
+        return invalidEffect(commit, "commit_effect_invalid");
+    }
+    const typedCommit = commit;
+    return Object.freeze({ ok: true, commit: typedCommit });
+}
+function requireCapabilityBatchAttemptEffect(commit, input) {
+    if (!commit.ok) {
+        return Object.freeze({
+            ok: false,
+            issueCode: commit.code,
+            commit,
+        });
+    }
+    const effect = commit.effect;
+    const isExpectedBatch = effect.type === "capability_batch_begun" &&
+        effect.callId === input.callId &&
+        effect.executionIds.length === input.entries.length;
+    const isExpectedIntervention = effect.type === "operation_supervision_intervened" &&
+        effect.callId === input.callId &&
+        effect.invocationAttempt === input.invocationAttempt &&
+        input.entries.some((entry) => entry.capabilityId === effect.capabilityId &&
+            entry.actionFingerprint === effect.actionFingerprint);
+    if (!isExpectedBatch && !isExpectedIntervention) {
+        return invalidEffect(commit, "commit_effect_invalid");
+    }
+    const typedCommit = commit;
+    return Object.freeze({ ok: true, commit: typedCommit });
+}
 export function resolveRoleCallTransactions(ledger) {
     if (ledger.transactions) {
         return ledger.transactions;
@@ -158,6 +212,9 @@ function createSettleCapabilityExecutionCommand(input) {
         callId: input.callId,
         executionId: input.executionId,
         outcome: input.outcome,
+        ...(input.outcomeFingerprint
+            ? { outcomeFingerprint: input.outcomeFingerprint }
+            : {}),
         observedEffect: input.observedEffect,
         summary: input.summary,
         exactResult: input.exactResult,

package/dist/src/runtime/orchestration/role-executors/activation/capability-continuation.d.ts

@@ -0,0 +1,15 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../../role-calls/index.js";
+import type { RoleExecutionContinuation, RoleExecutionContinuationReference } from "../contracts.js";
+import type { RoleExecutorDiagnosticContext } from "../shared/diagnostic-context.js";
+export type RoleCapabilityContinuationResolution = Readonly<{
+    call: RoleCallFrame;
+    continuationReference?: RoleExecutionContinuationReference;
+}>;
+export declare function continueRoleThroughCapability(params: Readonly<{
+    ledger: RoleCallLedger;
+    before: RoleCallLedgerHead;
+    currentCall: RoleCallFrame;
+    diagnostic: RoleExecutorDiagnosticContext;
+    continuation: RoleExecutionContinuation["continuation"];
+    turnCount: number;
+}>): RoleCapabilityContinuationResolution;

package/dist/src/runtime/orchestration/role-executors/activation/capability-continuation.js

@@ -0,0 +1,73 @@
+import { traceRoleExecutorContinued, traceRoleExecutorContinuationRejected, } from "../diagnostics.js";
+import { continuationError, readLedgerOrReject, } from "../shared/runtime-invariants.js";
+import { validateCapabilityContinuation, validateOperationSupervisionInterventionContinuation, } from "./state-validation.js";
+export function continueRoleThroughCapability(params) {
+    const after = readLedgerOrReject({
+        ledger: params.ledger,
+        diagnostic: params.diagnostic,
+        turnCount: params.turnCount,
+    });
+    if (params.continuation.kind === "operation_supervision_intervention") {
+        return continueAfterOperationSupervisionIntervention({ ...params, continuation: params.continuation }, after);
+    }
+    return continueAfterCapabilityExecution({ ...params, continuation: params.continuation }, after);
+}
+function continueAfterCapabilityExecution(params, after) {
+    const executionIds = params.continuation.kind === "capability_batch_execution"
+        ? params.continuation.executionIds
+        : [params.continuation.executionId];
+    const continuation = validateCapabilityContinuation({
+        before: params.before,
+        after,
+        currentCall: params.currentCall,
+        executionIds,
+    });
+    const diagnosticIds = params.continuation.kind === "capability_batch_execution"
+        ? { executionIds }
+        : { executionId: executionIds[0] };
+    if (!continuation.ok) {
+        traceRoleExecutorContinuationRejected(params.diagnostic, {
+            continuationKind: params.continuation.kind,
+            issueCode: continuation.issueCode,
+            ...diagnosticIds,
+            fromActivation: params.currentCall.activationCount,
+            turnCount: params.turnCount,
+        });
+        throw continuationError(params.currentCall.roleId, continuation.issueCode);
+    }
+    traceRoleExecutorContinued(params.diagnostic, {
+        continuationKind: params.continuation.kind,
+        ...diagnosticIds,
+        fromActivation: params.currentCall.activationCount,
+        toActivation: continuation.call.activationCount,
+        turnCount: params.turnCount,
+    });
+    return Object.freeze({
+        call: continuation.call,
+        continuationReference: params.continuation,
+    });
+}
+function continueAfterOperationSupervisionIntervention(params, after) {
+    const continuation = validateOperationSupervisionInterventionContinuation({
+        before: params.before,
+        after,
+        currentCall: params.currentCall,
+        commit: params.continuation.commit,
+    });
+    if (!continuation.ok) {
+        traceRoleExecutorContinuationRejected(params.diagnostic, {
+            continuationKind: params.continuation.kind,
+            issueCode: continuation.issueCode,
+            fromActivation: params.currentCall.activationCount,
+            turnCount: params.turnCount,
+        });
+        throw continuationError(params.currentCall.roleId, continuation.issueCode);
+    }
+    traceRoleExecutorContinued(params.diagnostic, {
+        continuationKind: params.continuation.kind,
+        fromActivation: params.currentCall.activationCount,
+        toActivation: continuation.call.activationCount,
+        turnCount: params.turnCount,
+    });
+    return Object.freeze({ call: continuation.call });
+}

package/dist/src/runtime/orchestration/role-executors/activation/loop.d.ts

@@ -16,6 +16,5 @@ export declare class RoleActivationLoop<TContext, TValue> {
     private runActivation;
     private completeTerminal;
     private continueThroughChild;
-    private continueThroughCapability;
 }
 export {};

package/dist/src/runtime/orchestration/role-executors/activation/loop.js

@@ -1,10 +1,11 @@
 import { isRuntimeDelegateRoleId } from "../../roles.js";
-import { traceRoleExecutorCompleted, traceRoleExecutorContinued, traceRoleExecutorContinuationRejected, traceRoleExecutorFailed, traceRoleExecutorInitialStateRejected, traceRoleExecutorResolved, traceRoleExecutorResultRejected, traceRoleExecutorStarted, traceRoleExecutorStateRejected, traceRoleExecutorUnavailable, } from "../diagnostics.js";
+import { traceRoleExecutorCompleted, traceRoleExecutorFailed, traceRoleExecutorInitialStateRejected, traceRoleExecutorResolved, traceRoleExecutorResultRejected, traceRoleExecutorStarted, traceRoleExecutorStateRejected, traceRoleExecutorUnavailable, } from "../diagnostics.js";
 import { requireResumedCallerCall } from "../child-invocation/state-validation.js";
 import { createAttemptDiagnostic, createDiagnostic, } from "../shared/diagnostic-context.js";
-import { continuationError, readLedgerOrReject, stateError, } from "../shared/runtime-invariants.js";
+import { readLedgerOrReject, stateError, } from "../shared/runtime-invariants.js";
+import { continueRoleThroughCapability } from "./capability-continuation.js";
 import { normalizeRoleExecutorActivationResult } from "./result-normalization.js";
-import { resolveCurrentCall, validateCapabilityContinuation, } from "./state-validation.js";
+import { resolveCurrentCall } from "./state-validation.js";
 export class RoleActivationLoop {
     params;
     expectedCall;
@@ -14,24 +15,14 @@ export class RoleActivationLoop {
         this.expectedCall = params.input.call;
     }
     async run() {
-        const { executor, initialHead, call } = this.resolveInitialActivation();
+        const { executor, call } = this.resolveInitialActivation();
         this.expectedCall = call;
-        const maximumTurns = initialHead.policy.limits.maxCalls +
-            initialHead.policy.limits.maxCapabilityExecutions +
-            1;
-        for (let turnCount = 1; turnCount <= maximumTurns; turnCount += 1) {
+        for (let turnCount = 1;; turnCount += 1) {
             const activation = this.requireCurrentActivation(turnCount);
             const terminal = await this.runActivation(executor, activation, turnCount);
             if (terminal)
                 return terminal;
         }
-        const exhaustedDiagnostic = createDiagnostic({
-            requestId: this.params.input.requestId,
-            call: this.expectedCall,
-            registeredRoleIds: this.params.registeredRoleIds,
-        });
-        traceRoleExecutorStateRejected(exhaustedDiagnostic, "continuation_limit_exceeded", maximumTurns);
-        throw stateError("continuation_limit_exceeded");
     }
     resolveInitialActivation() {
         const { input, registeredRoleIds, executorByRoleId } = this.params;
@@ -78,7 +69,6 @@ export class RoleActivationLoop {
         traceRoleExecutorResolved(initialDiagnostic);
         return Object.freeze({
             executor,
-            initialHead,
             call: initialAuthority.call,
         });
     }
@@ -148,7 +138,16 @@ export class RoleActivationLoop {
                 await this.continueThroughChild(activation, result.value, turnCount);
                 return undefined;
             }
-            this.continueThroughCapability(activation, result.value, turnCount);
+            const continued = continueRoleThroughCapability({
+                ledger: input.ledger,
+                before: activation.before,
+                currentCall: activation.call,
+                diagnostic: activation.diagnostic,
+                continuation: result.value.continuation,
+                turnCount,
+            });
+            this.expectedCall = continued.call;
+            this.continuationReference = continued.continuationReference;
             return undefined;
         }
         catch (error) {
@@ -202,43 +201,6 @@ export class RoleActivationLoop {
         this.expectedCall = requireResumedCallerCall(child.returnCommit, activation.call);
         this.continuationReference = continuationReference;
     }
-    continueThroughCapability(activation, result, turnCount) {
-        const after = readLedgerOrReject({
-            ledger: this.params.input.ledger,
-            diagnostic: activation.diagnostic,
-            turnCount,
-        });
-        const executionIds = result.continuation.kind === "capability_batch_execution"
-            ? result.continuation.executionIds
-            : [result.continuation.executionId];
-        const continuation = validateCapabilityContinuation({
-            before: activation.before,
-            after,
-            currentCall: activation.call,
-            executionIds,
-        });
-        if (!continuation.ok) {
-            traceRoleExecutorContinuationRejected(activation.diagnostic, {
-                issueCode: continuation.issueCode,
-                ...(result.continuation.kind === "capability_batch_execution"
-                    ? { executionIds }
-                    : { executionId: executionIds[0] }),
-                fromActivation: activation.call.activationCount,
-                turnCount,
-            });
-            throw continuationError(activation.call.roleId, continuation.issueCode);
-        }
-        traceRoleExecutorContinued(activation.diagnostic, {
-            ...(result.continuation.kind === "capability_batch_execution"
-                ? { executionIds }
-                : { executionId: executionIds[0] }),
-            fromActivation: activation.call.activationCount,
-            toActivation: continuation.call.activationCount,
-            turnCount,
-        });
-        this.expectedCall = continuation.call;
-        this.continuationReference = result.continuation;
-    }
 }
 function isTerminalStateFresh(after, before) {
     return after === before;

package/dist/src/runtime/orchestration/role-executors/activation/result-normalization.js

@@ -62,6 +62,20 @@ export function normalizeRoleExecutorActivationResult(input, maxSummaryLength, m
         !isPlainRecord(input.continuation)) {
         return { ok: false, issueCode: "continuation_shape_invalid" };
     }
+    if (hasExactKeys(input.continuation, ["kind", "commit"]) &&
+        input.continuation.kind === "operation_supervision_intervention" &&
+        isPlainRecord(input.continuation.commit)) {
+        return {
+            ok: true,
+            value: Object.freeze({
+                kind: "continue",
+                continuation: Object.freeze({
+                    kind: "operation_supervision_intervention",
+                    commit: input.continuation.commit,
+                }),
+            }),
+        };
+    }
     if (hasExactKeys(input.continuation, ["kind", "executionId"]) &&
         input.continuation.kind === "capability_execution" &&
         isCapabilityExecutionId(input.continuation.executionId)) {

package/dist/src/runtime/orchestration/role-executors/activation/state-validation.d.ts

@@ -1,4 +1,4 @@
-import type { RoleCallFrame, RoleCallLedgerHead } from "../../role-calls/index.js";
+import type { RoleCallFrame, RoleCallLedgerHead, RoleCallOperationSupervisionInterventionCommit } from "../../role-calls/index.js";
 export declare function resolveCurrentCall(params: Readonly<{
     head: RoleCallLedgerHead;
     requestId: string;
@@ -22,3 +22,15 @@ export declare function validateCapabilityContinuation(params: Readonly<{
     ok: false;
     issueCode: string;
 }>;
+export declare function validateOperationSupervisionInterventionContinuation(params: Readonly<{
+    before: RoleCallLedgerHead;
+    after: RoleCallLedgerHead;
+    currentCall: RoleCallFrame;
+    commit: RoleCallOperationSupervisionInterventionCommit;
+}>): Readonly<{
+    ok: true;
+    call: RoleCallFrame;
+}> | Readonly<{
+    ok: false;
+    issueCode: string;
+}>;