@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/orchestration/final-response/invoke.d.ts

@@ -4,6 +4,7 @@ import type { RootAuthoredResponse } from "../../long-term-memory/contracts.js";
 import type { ModelStepContextCompactionController } from "../../model/model-step-port.js";
 import type { BoundRequestModelInvocationContext } from "../../request/contracts.js";
 import { type RootFinalResponseValidator } from "./authoring-contract.js";
+import type { ConversationMemoryAuthoringContext } from "../../long-term-memory/conversation-authoring/context.js";
 export declare function invokeRootAuthoredResponse(params: {
     request: BoundRequestModelInvocationContext;
     modelStep: ModelStep;
@@ -14,4 +15,5 @@ export declare function invokeRootAuthoredResponse(params: {
     contextCompaction?: ModelStepContextCompactionController;
     maxResponseChars?: number;
     validateFinalResponse?: RootFinalResponseValidator;
+    memoryAuthoringContext?: ConversationMemoryAuthoringContext;
 }): Promise<RootAuthoredResponse>;

package/dist/src/runtime/orchestration/final-response/invoke.js

@@ -14,6 +14,7 @@ export function invokeRootAuthoredResponse(params) {
             ? { contextCompaction: params.contextCompaction }
             : {}),
         parse: (text) => parseRootAuthoredResponse(text, {
+            ...(params.memoryAuthoringContext ? { memoryAuthoringContext: params.memoryAuthoringContext } : {}),
             ...(params.maxResponseChars !== undefined
                 ? { maxResponseChars: params.maxResponseChars }
                 : {}),

package/dist/src/runtime/orchestration/lifecycle/execution-budgets.d.ts

@@ -0,0 +1,8 @@
+/** Active execution time only; an approval wait does not spend these budgets. */
+export type RequestExecutionBudgets = Readonly<{
+    requestTimeoutMs: number;
+    inactivityTimeoutMs: number;
+    requestRemainingMs: number;
+    inactivityRemainingMs: number;
+}>;
+export declare function assertExecutionBudgets(value: RequestExecutionBudgets): void;

package/dist/src/runtime/orchestration/lifecycle/execution-budgets.js

@@ -0,0 +1,13 @@
+export function assertExecutionBudgets(value) {
+    for (const number of Object.values(value)) {
+        if (!Number.isFinite(number) || number < 0) {
+            throw new Error("invalid_request_execution_budgets");
+        }
+    }
+    if (value.requestRemainingMs > value.requestTimeoutMs) {
+        throw new Error("invalid_request_execution_budgets");
+    }
+    if (value.inactivityRemainingMs > value.inactivityTimeoutMs) {
+        throw new Error("invalid_request_execution_budgets");
+    }
+}

package/dist/src/runtime/orchestration/lifecycle/request-lifecycle.d.ts

@@ -1,3 +1,4 @@
+import { type RequestExecutionBudgets } from "./execution-budgets.js";
 export type RequestLifecycleAbortReason = "request_timeout" | "request_inactivity_timeout";
 export type MeaningfulProgressKind = "accepted_tool_execution" | "valid_decision" | "valid_final_output";
 export type RequestLifecycleState = {
@@ -19,18 +20,38 @@ export declare class RequestLifecycle {
     private readonly inactivityTimeoutMs;
     private requestTimeoutHandle;
     private inactivityTimeoutHandle;
+    private requestTimeoutRemainingMs;
+    private inactivityTimeoutRemainingMs;
+    private requestTimeoutDeadlineMs;
+    private inactivityTimeoutDeadlineMs;
+    private pendingApprovalWaits;
+    private disposed;
     private abortReason;
     private state;
+    private readonly removeExternalAbort;
     constructor(params: {
         requestId: string;
         requestTimeoutMs?: number;
         inactivityTimeoutMs?: number;
+        abortSignal?: AbortSignal;
+        budgets?: RequestExecutionBudgets;
     });
     get signal(): AbortSignal;
     get timedOutReason(): RequestLifecycleAbortReason | null;
+    snapshotBudgets(): RequestExecutionBudgets;
+    /** Human decision time does not consume either request execution budget. */
+    beginToolApprovalWait(): () => void;
     markProgress(kind: MeaningfulProgressKind): void;
     updateState(state: RequestLifecycleState): void;
     dispose(): void;
+    private hasPendingToolApprovals;
+    private canScheduleTimeouts;
+    private suspendTimeouts;
+    private clearTimeouts;
+    private scheduleRequestTimeout;
+    private scheduleInactivityTimeout;
+    private canScheduleRequestTimeout;
+    private canScheduleInactivityTimeout;
     private resetInactivityTimer;
     private abort;
 }

package/dist/src/runtime/orchestration/lifecycle/request-lifecycle.js

@@ -1,4 +1,7 @@
 import { traceDebug } from "../../observability/debug-logger.js";
+import { createRequestCancellationError } from "../../request/cancellation.js";
+import { isRequestInterruption } from "../../request/interruption.js";
+import { assertExecutionBudgets, } from "./execution-budgets.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 0;
 const DEFAULT_REQUEST_INACTIVITY_TIMEOUT_MS = 0;
 function readPositiveInt(name, fallback) {
@@ -19,20 +22,45 @@ export class RequestLifecycle {
     inactivityTimeoutMs;
     requestTimeoutHandle;
     inactivityTimeoutHandle;
+    requestTimeoutRemainingMs;
+    inactivityTimeoutRemainingMs;
+    requestTimeoutDeadlineMs;
+    inactivityTimeoutDeadlineMs;
+    pendingApprovalWaits = 0;
+    disposed = false;
     abortReason = null;
     state = {};
+    removeExternalAbort;
     constructor(params) {
         this.requestId = params.requestId;
         this.startedAtMs = Date.now();
-        this.requestTimeoutMs = params.requestTimeoutMs ?? getRequestTimeoutMs();
+        if (params.budgets)
+            assertExecutionBudgets(params.budgets);
+        this.requestTimeoutMs =
+            params.budgets?.requestTimeoutMs ??
+                params.requestTimeoutMs ??
+                getRequestTimeoutMs();
         this.inactivityTimeoutMs =
-            params.inactivityTimeoutMs ?? getRequestInactivityTimeoutMs();
-        if (this.requestTimeoutMs > 0) {
-            this.requestTimeoutHandle = setTimeout(() => {
-                this.abort("request_timeout");
-            }, this.requestTimeoutMs);
-        }
-        this.resetInactivityTimer();
+            params.budgets?.inactivityTimeoutMs ??
+                params.inactivityTimeoutMs ??
+                getRequestInactivityTimeoutMs();
+        this.requestTimeoutRemainingMs =
+            params.budgets?.requestRemainingMs ?? this.requestTimeoutMs;
+        this.inactivityTimeoutRemainingMs =
+            params.budgets?.inactivityRemainingMs ?? this.inactivityTimeoutMs;
+        this.scheduleRequestTimeout();
+        this.scheduleInactivityTimeout();
+        const external = params.abortSignal;
+        const abort = () => {
+            const reason = isRequestInterruption(external?.reason)
+                ? external.reason
+                : createRequestCancellationError();
+            this.abortController.abort(reason);
+        };
+        external?.addEventListener("abort", abort, { once: true });
+        this.removeExternalAbort = () => external?.removeEventListener("abort", abort);
+        if (external?.aborted)
+            abort();
     }
     get signal() {
         return this.abortController.signal;
@@ -40,6 +68,34 @@ export class RequestLifecycle {
     get timedOutReason() {
         return this.abortReason;
     }
+    snapshotBudgets() {
+        const now = Date.now();
+        return {
+            requestTimeoutMs: this.requestTimeoutMs,
+            inactivityTimeoutMs: this.inactivityTimeoutMs,
+            requestRemainingMs: this.requestTimeoutDeadlineMs === undefined
+                ? this.requestTimeoutRemainingMs
+                : Math.max(0, this.requestTimeoutDeadlineMs - now),
+            inactivityRemainingMs: this.inactivityTimeoutDeadlineMs === undefined
+                ? this.inactivityTimeoutRemainingMs
+                : Math.max(0, this.inactivityTimeoutDeadlineMs - now),
+        };
+    }
+    /** Human decision time does not consume either request execution budget. */
+    beginToolApprovalWait() {
+        if (!this.hasPendingToolApprovals())
+            this.suspendTimeouts();
+        this.pendingApprovalWaits += 1;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.pendingApprovalWaits -= 1;
+            this.scheduleRequestTimeout();
+            this.scheduleInactivityTimeout();
+        };
+    }
     markProgress(kind) {
         if (this.abortReason !== null || this.signal.aborted) {
             return;
@@ -57,6 +113,31 @@ export class RequestLifecycle {
         };
     }
     dispose() {
+        this.disposed = true;
+        this.removeExternalAbort();
+        this.clearTimeouts();
+    }
+    hasPendingToolApprovals() {
+        return this.pendingApprovalWaits > 0;
+    }
+    canScheduleTimeouts() {
+        if (this.disposed)
+            return false;
+        if (this.signal.aborted)
+            return false;
+        return !this.hasPendingToolApprovals();
+    }
+    suspendTimeouts() {
+        const now = Date.now();
+        if (this.requestTimeoutDeadlineMs !== undefined) {
+            this.requestTimeoutRemainingMs = Math.max(0, this.requestTimeoutDeadlineMs - now);
+        }
+        if (this.inactivityTimeoutDeadlineMs !== undefined) {
+            this.inactivityTimeoutRemainingMs = Math.max(0, this.inactivityTimeoutDeadlineMs - now);
+        }
+        this.clearTimeouts();
+    }
+    clearTimeouts() {
         if (this.requestTimeoutHandle !== undefined) {
             clearTimeout(this.requestTimeoutHandle);
             this.requestTimeoutHandle = undefined;
@@ -65,18 +146,44 @@ export class RequestLifecycle {
             clearTimeout(this.inactivityTimeoutHandle);
             this.inactivityTimeoutHandle = undefined;
         }
+        this.requestTimeoutDeadlineMs = undefined;
+        this.inactivityTimeoutDeadlineMs = undefined;
+    }
+    scheduleRequestTimeout() {
+        if (!this.canScheduleRequestTimeout())
+            return;
+        this.requestTimeoutDeadlineMs = Date.now() + this.requestTimeoutRemainingMs;
+        this.requestTimeoutHandle = setTimeout(() => {
+            this.abort("request_timeout");
+        }, this.requestTimeoutRemainingMs);
+    }
+    scheduleInactivityTimeout() {
+        if (!this.canScheduleInactivityTimeout())
+            return;
+        this.inactivityTimeoutDeadlineMs =
+            Date.now() + this.inactivityTimeoutRemainingMs;
+        this.inactivityTimeoutHandle = setTimeout(() => {
+            this.abort("request_inactivity_timeout");
+        }, this.inactivityTimeoutRemainingMs);
+    }
+    canScheduleRequestTimeout() {
+        if (this.requestTimeoutMs <= 0)
+            return false;
+        return this.canScheduleTimeouts();
+    }
+    canScheduleInactivityTimeout() {
+        if (this.inactivityTimeoutMs <= 0)
+            return false;
+        return this.canScheduleTimeouts();
     }
     resetInactivityTimer() {
         if (this.inactivityTimeoutHandle !== undefined) {
             clearTimeout(this.inactivityTimeoutHandle);
             this.inactivityTimeoutHandle = undefined;
         }
-        if (this.inactivityTimeoutMs <= 0 || this.abortReason !== null) {
-            return;
-        }
-        this.inactivityTimeoutHandle = setTimeout(() => {
-            this.abort("request_inactivity_timeout");
-        }, this.inactivityTimeoutMs);
+        this.inactivityTimeoutDeadlineMs = undefined;
+        this.inactivityTimeoutRemainingMs = this.inactivityTimeoutMs;
+        this.scheduleInactivityTimeout();
     }
     abort(reason) {
         if (this.abortReason !== null) {

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

@@ -15,6 +15,7 @@ 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";
+import { isRoleCallResultText } from "./role-result-text.js";
 export function validateRoleCallPolicy(policy) {
     if (!isExecutionPolicyAuthoritySnapshot(policy?.authority)) {
         return [issue("invalid_execution_policy_authority", "policy.authority")];
@@ -164,7 +165,7 @@ export function validateRoleCallState(state, policy) {
             producer.status !== "completed" ||
             producer.roleId !== result.roleId ||
             (result.outcome !== "completed" && result.outcome !== "failed") ||
-            !isBoundedText(result.summary, policy.limits.maxResultChars) ||
+            !isRoleCallResultText(result.summary) ||
             !isRoleCallResultReceiptValidForStoredResult({
                 receipt: result.receipt,
                 producer,

package/dist/src/runtime/orchestration/role-calls/checkpoint-contract.d.ts

@@ -0,0 +1,8 @@
+import type { RoleCallPolicy, RoleCallState } from "./contracts.js";
+/** Trusted runtime persistence only; never accepted as model or client input. */
+export type RoleCallLedgerCheckpoint = Readonly<{
+    kind: "role_call_checkpoint_v1";
+    revision: number;
+    state: RoleCallState;
+    policy: RoleCallPolicy;
+}>;

package/dist/src/runtime/orchestration/role-calls/checkpoint-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.d.ts

@@ -0,0 +1,4 @@
+import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
+import type { RoleCallPolicy, RoleCallState } from "./contracts.js";
+/** Hydrate only an admitted, parked capability; no model or reducer command replay. */
+export declare function restoreCheckpointState(checkpoint: RoleCallLedgerCheckpoint, requestId: string, policy: RoleCallPolicy): RoleCallState;

package/dist/src/runtime/orchestration/role-calls/checkpoint-state.js

@@ -0,0 +1,79 @@
+import { isDeepStrictEqual } from "node:util";
+import { seal } from "./reducer-primitives.js";
+import { validateRoleCallCandidate } from "./reducer.js";
+import { issueInitialRoleCapabilitySelectionSupervisionState } from "./capability-selection-supervision-issuance.js";
+import { restoreRoleOperationSupervisionIssuance } from "./operation-supervision-issuance.js";
+/** Hydrate only an admitted, parked capability; no model or reducer command replay. */
+export function restoreCheckpointState(checkpoint, requestId, policy) {
+    if (!isCheckpointEnvelope(checkpoint))
+        throw new Error("role_call_checkpoint_invalid");
+    if (!hasCheckpointRequestIdentity(checkpoint, requestId))
+        throw new Error("role_call_checkpoint_request_mismatch");
+    if (!hasCheckpointPolicy(checkpoint, policy))
+        throw new Error("role_call_checkpoint_policy_mismatch");
+    const state = seal(structuredClone(checkpoint.state));
+    if (!isParkedCapabilityState(state))
+        throw new Error("role_call_checkpoint_not_parked");
+    if (!issueInitialRoleCapabilitySelectionSupervisionState(state))
+        throw new Error("role_call_checkpoint_selection_issuance_invalid");
+    restoreRoleOperationSupervisionIssuance(state);
+    if (!isCheckpointCandidateValid(state, policy))
+        throw new Error("role_call_checkpoint_state_invalid");
+    if (!hasConsistentCheckpointRevision(checkpoint.revision, state))
+        throw new Error("role_call_checkpoint_revision_inconsistent");
+    return state;
+}
+function isCheckpointEnvelope(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (value.kind !== "role_call_checkpoint_v1")
+        return false;
+    if (!Number.isSafeInteger(value.revision))
+        return false;
+    return value.revision > 0;
+}
+function isParkedCapabilityState(state) {
+    if (state.phase !== "running")
+        return false;
+    if (!Array.isArray(state.calls))
+        return false;
+    if (!Array.isArray(state.capabilityExecutions))
+        return false;
+    if (!state.capabilitySelectionSupervision)
+        return false;
+    if (!state.operationSupervision)
+        return false;
+    if (!Array.isArray(state.operationSupervision.interventions))
+        return false;
+    const call = state.calls.find((entry) => entry.callId === state.activeCallId);
+    if (call?.status !== "waiting_for_capability")
+        return false;
+    return state.capabilityExecutions.some((execution) => execution.callId === call.callId && execution.status === "running");
+}
+function hasCheckpointRequestIdentity(checkpoint, requestId) {
+    return checkpoint.state?.requestId === requestId;
+}
+function hasCheckpointPolicy(checkpoint, policy) {
+    return isDeepStrictEqual(checkpoint.policy, policy);
+}
+function isCheckpointCandidateValid(state, policy) {
+    try {
+        return validateRoleCallCandidate({ state, policy }).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function hasConsistentCheckpointRevision(revision, state) {
+    const begins = new Set(state.capabilityExecutions.map(executionActivationIdentity));
+    const settlements = new Set(state.capabilityExecutions
+        .filter((entry) => entry.status === "settled")
+        .map(executionActivationIdentity));
+    const minimumCommits = state.calls.length + state.results.length + begins.size + settlements.size;
+    if (revision < minimumCommits)
+        return false;
+    return state.results.every((result) => result.receipt === undefined || result.receipt.sourceRevision < revision);
+}
+function executionActivationIdentity(execution) {
+    return JSON.stringify([execution.callId, execution.invocationAttempt]);
+}

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

@@ -0,0 +1,8 @@
+import type { RoleCallLedger, RoleCallPolicyInput } from "./contracts.js";
+import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
+export type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
+export declare function captureRoleCallLedgerCheckpoint(ledger: RoleCallLedger): RoleCallLedgerCheckpoint;
+export declare function restoreRoleCallLedgerCheckpoint(checkpoint: RoleCallLedgerCheckpoint, expected: Readonly<{
+    requestId: string;
+    policy: RoleCallPolicyInput;
+}>): RoleCallLedger;

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

@@ -0,0 +1,15 @@
+import { createRoleCallLedger, isCurrentRoleCallLedgerHead } from "./ledger.js";
+export function captureRoleCallLedgerCheckpoint(ledger) {
+    const head = ledger.current();
+    if (!isCurrentRoleCallLedgerHead(ledger, head))
+        throw new Error("role_call_checkpoint_ledger_unowned");
+    return Object.freeze({
+        kind: "role_call_checkpoint_v1",
+        revision: head.revision,
+        state: head.state,
+        policy: head.policy,
+    });
+}
+export function restoreRoleCallLedgerCheckpoint(checkpoint, expected) {
+    return createRoleCallLedger({ ...expected, checkpoint });
+}

package/dist/src/runtime/orchestration/role-calls/child-return.js

@@ -1,7 +1,8 @@
-import { ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "./contracts.js";
+import { ROLE_CALL_OBJECTIVE_MAX_LENGTH, } from "./contracts.js";
 import { isRuntimeDelegateRoleId, } from "../roles.js";
 import { isRoleCallResultReceiptValidForStoredResult, } from "./result-receipt.js";
 import { projectRoleCallWorkResultLineage, } from "./work-result-lineage.js";
+import { isRoleCallResultText } from "./role-result-text.js";
 export function requireRoleCallChildReturnCommit(commit) {
     if (!commit.ok || commit.effect.type !== "child_returned") {
         throw new Error("role_child_return_commit_invalid");
@@ -60,7 +61,7 @@ function projectCompletedChild(state, refs, policy) {
         result?.producerCallId !== child.callId ||
         result.roleId !== child.roleId ||
         (result.outcome !== "completed" && result.outcome !== "failed") ||
-        !isBoundedText(result.summary, ROLE_CALL_RESULT_MAX_LENGTH) ||
+        !isRoleCallResultText(result.summary) ||
         !isRoleCallResultReceiptValidForStoredResult({
             receipt: result.receipt,
             producer: child,

package/dist/src/runtime/orchestration/role-calls/command-dispatch/child-transitions.js

@@ -4,6 +4,7 @@ import { bindRoleCallPlanChild, plannerPlanHasOpenItems, settleRoleCallPlanChild
 import { areOwnedDependencyResults, commit, findCall, isBoundedText, reject, } from "../reducer-primitives.js";
 import { isRoleCallWorkingDirectoryRoleId } from "../working-directory.js";
 import { resolveCanonicalResultReceiptForReturn } from "../return-result-receipt.js";
+import { isRoleCallResultText } from "../role-result-text.js";
 import { nextCallId, replaceCall } from "./call-frame-state.js";
 export function openChild(state, command, policy) {
     const { callerCallId, objective, workerCapabilityScope, workingDirectory, dependencyResultRefs = [], plannerPlan, } = command;
@@ -102,7 +103,7 @@ export function returnChild(state, command, policy, admittedHeadRevision) {
         return reject(state, "child_return_mismatch");
     }
     const { caller, child } = matchedReturn;
-    if (!hasValidChildReturnPayload(child, outcome, summary, policy)) {
+    if (!hasValidChildReturnPayload(child, outcome, summary)) {
         return reject(state, "invalid_command");
     }
     const resultRef = nextResultRef(state);
@@ -205,12 +206,12 @@ function findMatchingActiveChildReturn(state, callerCallId, childCallId) {
         return undefined;
     return { caller, child };
 }
-function hasValidChildReturnPayload(child, outcome, summary, policy) {
+function hasValidChildReturnPayload(child, outcome, summary) {
     if (child.roleId === RUNTIME_ROOT_ROLE_ID)
         return false;
     if (outcome !== "completed" && outcome !== "failed")
         return false;
-    return isBoundedText(summary, policy.limits.maxResultChars);
+    return isRoleCallResultText(summary);
 }
 function hasIncompleteCompletedPlannerPlan(state, child, outcome) {
     if (child.roleId !== "planner")

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

@@ -10,6 +10,7 @@ import type { AdoptedModelWorkPlan, UpdateModelWorkPlanCommand, ModelWorkPlanCom
 export declare const ROLE_CALL_LEDGER_CONTRACT_VERSION = 18;
 export declare const ROLE_CALL_LEDGER_HEAD_KIND: "runtime_role_call_ledger_v18";
 export declare const ROLE_CALL_OBJECTIVE_MAX_LENGTH = 8192;
+/** Bounds structured receipts, capability summaries and diagnostics, not role-result prose. */
 export declare const ROLE_CALL_RESULT_MAX_LENGTH = 8192;
 export declare const ROLE_CALL_RESPONSE_MAX_LENGTH = 65536;
 export declare const ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH = 256;
@@ -48,6 +49,7 @@ export type RoleCallPolicy = Readonly<{
         maxCalls: number;
         maxCapabilityExecutions: number;
         maxObjectiveChars: number;
+        /** Capability-summary and diagnostic envelope bound; role-result prose is uncapped. */
         maxResultChars: number;
         maxResponseChars: number;
     }>;

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

@@ -1,6 +1,7 @@
 export const ROLE_CALL_LEDGER_CONTRACT_VERSION = 18;
 export const ROLE_CALL_LEDGER_HEAD_KIND = "runtime_role_call_ledger_v18";
 export const ROLE_CALL_OBJECTIVE_MAX_LENGTH = 8_192;
+/** Bounds structured receipts, capability summaries and diagnostics, not role-result prose. */
 export const ROLE_CALL_RESULT_MAX_LENGTH = 8_192;
 export const ROLE_CALL_RESPONSE_MAX_LENGTH = 65_536;
 export const ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH = 256;

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

@@ -7,6 +7,7 @@ export * from "./capability-selection-reconsideration.js";
 export * from "./capability-selection-supervision.js";
 export * from "./reconsideration-cause.js";
 export * from "./result-receipt.js";
+export * from "./role-result-text.js";
 export * from "./return-result-receipt.js";
 export * from "./work-result-lineage.js";
 export * from "./work-result-receipt.js";

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

@@ -7,6 +7,7 @@ export * from "./capability-selection-reconsideration.js";
 export * from "./capability-selection-supervision.js";
 export * from "./reconsideration-cause.js";
 export * from "./result-receipt.js";
+export * from "./role-result-text.js";
 export * from "./return-result-receipt.js";
 export * from "./work-result-lineage.js";
 export * from "./work-result-receipt.js";

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

@@ -1,7 +1,9 @@
+import type { RoleCallLedgerCheckpoint } from "./checkpoint-contract.js";
 import { type RoleCallLedger, type RoleCallLedgerHead, type RoleCallPolicyInput } from "./contracts.js";
 export declare function createRoleCallLedger(params: {
     requestId: string;
     policy: RoleCallPolicyInput;
+    checkpoint?: RoleCallLedgerCheckpoint;
 }): RoleCallLedger;
 /** Confirms exact current-head ownership without trusting structural ledgers. */
 export declare function isCurrentRoleCallLedgerHead(ledger: RoleCallLedger, head: RoleCallLedgerHead): boolean;

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

@@ -1,3 +1,4 @@
+import { restoreCheckpointState } from "./checkpoint-state.js";
 import { consumeUnexpectedThenable } from "../synchronous-boundary.js";
 import { createCanonicalStateHeadFactory } from "../state-head.js";
 import { ROLE_CALL_LEDGER_HEAD_KIND, } from "./contracts.js";
@@ -12,16 +13,18 @@ import { createRoleCallTransactions } from "./transactions.js";
 import { ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH } from "./working-directory.js";
 const issuedRoleCallLedgerHeads = new WeakMap();
 export function createRoleCallLedger(params) {
-    const initialState = createInitialRoleCallState(params.requestId);
+    const policy = sealRoleCallPolicy(params.policy);
+    const initialState = params.checkpoint
+        ? restoreCheckpointState(params.checkpoint, params.requestId, policy)
+        : createInitialRoleCallState(params.requestId);
     const capabilitySelectionSupervisionIssuanceAuthority = resolveRoleCapabilitySelectionSupervisionIssuanceAuthority(initialState);
     if (!capabilitySelectionSupervisionIssuanceAuthority) {
         throw new Error("role_call_capability_selection_supervision_issuance_authority_missing");
     }
     const createRoleCallStateHead = createRoleCallStateHeadFactory(capabilitySelectionSupervisionIssuanceAuthority);
-    const channel = createRoleCallStateHead({
-        state: initialState,
-        policy: sealRoleCallPolicy(params.policy),
-    });
+    const channel = createRoleCallStateHead({ state: initialState, policy }, params.checkpoint
+        ? { initialRevision: params.checkpoint.revision }
+        : undefined);
     const commitObservers = new Set();
     const commits = Object.freeze({
         subscribe(observer) {

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

@@ -5,6 +5,8 @@ export declare function issueCanonicalRoleOperationSupervisionTransition(input:
     after: RoleCallState;
     effect: RoleCallCommitEffect;
 }): boolean;
+/** Reissue only a private persisted copy, validated before publication. */
+export declare function restoreRoleOperationSupervisionIssuance(state: RoleCallState): void;
 export declare function isIssuedRoleOperationSupervisionInterventionForRequest(input: {
     requestId: string;
     intervention: RoleOperationSupervisionInterventionRecord;

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

@@ -18,6 +18,11 @@ export function issueCanonicalRoleOperationSupervisionTransition(input) {
     }
     return input.after.operationSupervision === input.before.operationSupervision;
 }
+/** Reissue only a private persisted copy, validated before publication. */
+export function restoreRoleOperationSupervisionIssuance(state) {
+    for (const intervention of state.operationSupervision.interventions)
+        issuedInterventionRequestIds.set(intervention, state.requestId);
+}
 export function isIssuedRoleOperationSupervisionInterventionForRequest(input) {
     return (issuedInterventionRequestIds.get(input.intervention) === input.requestId);
 }

package/dist/src/runtime/orchestration/role-calls/role-result-text.d.ts

@@ -0,0 +1,2 @@
+/** Role-result text is admitted to model context by the shared token budget. */
+export declare function isRoleCallResultText(value: unknown): value is string;

package/dist/src/runtime/orchestration/role-calls/role-result-text.js

@@ -0,0 +1,4 @@
+/** Role-result text is admitted to model context by the shared token budget. */
+export function isRoleCallResultText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

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

@@ -1,20 +1,20 @@
-import type { RoleExecutionResult, RoleExecutor, RoleExecutorRegistry } from "../contracts.js";
-type RoleExecutionInput<TContext, TValue> = Parameters<RoleExecutorRegistry<TContext, TValue>["execute"]>[0];
+import { type RoleApprovalWait } from "../approval-continuation.js";
+import type { RoleExecutionResult, RoleExecutor, RoleExecutorRegistry, RoleExecutionInput, RoleChildInvocationInput, RoleChildInvocationResult } from "../contracts.js";
 export declare class RoleActivationLoop<TContext, TValue> {
     private readonly params;
     private expectedCall;
     private continuationReference;
     constructor(params: Readonly<{
-        input: RoleExecutionInput<TContext, TValue>;
+        input: RoleExecutionInput<TContext>;
         registeredRoleIds: RoleExecutorRegistry<TContext, TValue>["roleIds"];
         executorByRoleId: ReadonlyMap<RoleExecutor<TContext, TValue>["roleId"], RoleExecutor<TContext, TValue>>;
-        invokeChild: RoleExecutorRegistry<TContext, TValue>["invokeChild"];
+        invokeChild(input: RoleChildInvocationInput<TContext>): Promise<RoleChildInvocationResult<TValue> | RoleApprovalWait>;
     }>);
-    run(): Promise<RoleExecutionResult<TValue>>;
+    run(): Promise<RoleExecutionResult<TValue> | RoleApprovalWait>;
+    private continueEnteredChild;
     private resolveInitialActivation;
     private requireCurrentActivation;
     private runActivation;
     private completeTerminal;
     private continueThroughChild;
 }
-export {};