@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/context/model-step-compaction.d.ts

@@ -1,3 +1,6 @@
+import { type SuperCompactionFailureOwner } from "./super-compaction-failure-owner.js";
+import type { SuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
 import type { ModelStepContextCompactionController } from "../model/model-step-port.js";
 import { type SemanticCompactionSource, type SemanticCompactionRequest } from "./semantic-compaction/index.js";
@@ -6,12 +9,18 @@ type ModelStepCompactionOptions = Readonly<{
         roleId: string;
         callId: string;
         objective: string | null;
+        activationCount?: number;
     }>;
     sourceRevision: number;
     allowedConsumers: readonly ModelStep[];
     scopeId?: string;
     scopeSuffix?: string;
     resultSourceOverrides?: readonly SemanticCompactionSource[];
+    superWorkerCompaction?: SuperWorkerCompactionSidecar;
+    requireSuperWorkerSources?: boolean;
+    consumer?: ModelStep;
+    superFailureOwner?: SuperCompactionFailureOwner;
+    hasVerifiedCompactedEvidence?(messages: readonly ChatMessage[]): boolean;
 }>;
 export declare function createModelStepCompactionController(request: SemanticCompactionRequest, options: ModelStepCompactionOptions): ModelStepContextCompactionController;
 export {};

package/dist/src/runtime/context/model-step-compaction.js

@@ -1,3 +1,13 @@
+import { buildCheckpointMessage } from "./semantic-compaction/checkpoint-message.js";
+import { createVerifiedCompactionProjection } from "./verified-compaction-projection.js";
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./semantic-compaction/evidence-scope.js";
+import { readOperationSupervisionEvidenceBinding } from "./operation-supervision-evidence-binding.js";
+import { projectOperationSupervisionEvidenceClosure } from "./operation-supervision-evidence-projection.js";
+import { superWorkerCompactionFailureOwner } from "./super-worker-compaction-failure.js";
+import { withSuperCompactionFailure, } from "./super-compaction-failure-owner.js";
+import { resolveSuperWorkerCompactionProjection } from "./super-worker-compaction-projection.js";
+import { CompactionSourceInvariantError } from "./compaction-source-invariant.js";
+import { projectRequestToolResultsCheckpointMessage } from "./request-tool-results-checkpoint.js";
 import { OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND } from "./operation-supervision-evidence.js";
 import { SEMANTIC_COMPACTION_CONTEXT_LANE, assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint, generateSemanticCompactionCandidateBatched, sameSemanticCompactionCheckpointBinding, } from "./semantic-compaction/index.js";
 const PAYLOAD_CONTEXT_PREFIX = "Canonical runtime context:\n";
@@ -25,51 +35,72 @@ export function createModelStepCompactionController(request, options) {
     if (!store) {
         throw new Error("context_compaction_store_required");
     }
-    const resultSourceOverrides = createResultSourceOverrideMap(options.resultSourceOverrides ?? []);
-    const readPrevious = () => {
+    const verifiedProjection = createVerifiedCompactionProjection();
+    let projectedCheckpoint;
+    const reconcileEvidence = (messages, checkpoint) => projectOperationSupervisionEvidenceClosure(messages, {
+        requestId: request.requestId,
+        call: options.call,
+        sourceRevision: options.sourceRevision,
+        consumer: options.consumer,
+    }, checkpoint ? { checkpoint, store } : undefined);
+    const sourceProjection = (messages) => {
+        const sidecar = resolveSuperWorkerCompactionProjection(messages, {
+            requestId: request.requestId,
+            callId: options.call.callId,
+            sourceRevision: options.sourceRevision,
+        }, options.superWorkerCompaction, options.requireSuperWorkerSources);
+        const failureOwner = superWorkerCompactionFailureOwner(sidecar, options.consumer, "model_context_projection", scopeId) ?? options.superFailureOwner;
+        withSuperCompactionFailure(failureOwner, () => reconcileEvidence(messages));
+        return {
+            sidecar,
+            failureOwner,
+            overrides: createResultSourceOverrideMap(sidecar?.sources ?? options.resultSourceOverrides ?? []),
+        };
+    };
+    const readPrevious = (messages) => {
         const previous = store.get(scopeId);
         if (!previous)
             return undefined;
         assertValidSemanticCompactionCheckpoint(previous);
+        if ((options.requireSuperWorkerSources ||
+            options.superFailureOwner ||
+            messages.some(readOperationSupervisionEvidenceBinding)) &&
+            previous.sourceRevision > options.sourceRevision) {
+            throw new Error("context_compaction_checkpoint_revision_invalid");
+        }
         if (!sameSemanticCompactionCheckpointBinding(previous, binding)) {
             throw new Error("context_compaction_checkpoint_not_applicable");
         }
         return previous;
     };
-    return Object.freeze({
+    const activeStage = Object.freeze({
         compactionScope: "active_request",
-        project(messages) {
-            const previous = readPrevious();
-            return previous
-                ? projectCheckpointMessages(messages, scopeId, previous, resultSourceOverrides)
-                : [...messages];
-        },
+        scopeId,
         async prepare(messages) {
-            const previous = readPrevious();
-            const scanned = scanCompactionSources(messages, scopeId, resultSourceOverrides);
+            const { sidecar, failureOwner, overrides: resultSourceOverrides, } = sourceProjection(messages);
+            const previous = withSuperCompactionFailure(failureOwner, () => readPrevious(messages));
+            const scanned = scanCompactionSources(messages, scopeId, resultSourceOverrides, sidecar);
             const covered = new Map(previous?.sourceDigests.map((source) => [source.sourceRef, source]) ??
                 []);
-            const newSources = scanned
+            const newSources = withSuperCompactionFailure(failureOwner, () => scanned
                 .map(({ source }) => source)
                 .filter((source) => {
                 const existing = covered.get(source.sourceRef);
                 if (!existing)
                     return true;
                 if (existing.sourceFingerprint !== source.sourceFingerprint) {
+                    if (failureOwner) {
+                        throw new CompactionSourceInvariantError("context_compaction_source_identity_conflict", source.sourceRef);
+                    }
                     throw new Error("context_compaction_source_identity_conflict");
                 }
                 return false;
-            });
-            if (newSources.length === 0) {
-                if (!previous) {
-                    throw new Error("context_compaction_sources_empty");
-                }
+            }));
+            const hasNewCompactionSources = newSources.length > 0;
+            if (!hasNewCompactionSources) {
                 return Object.freeze({
-                    messages: projectCheckpointMessages(messages, scopeId, previous, resultSourceOverrides),
-                    commit() { },
-                    scopeId,
-                    sourceRevision: previous.sourceRevision,
-                    coveredSourceCount: previous.sourceDigests.length,
+                    kind: "unavailable",
+                    reason: previous ? "no_new_sources" : "no_eligible_sources",
                 });
             }
             const candidate = await generateSemanticCompactionCandidateBatched({
@@ -78,22 +109,55 @@ export function createModelStepCompactionController(request, options) {
                 binding,
                 sourceRevision: options.sourceRevision,
                 preservationObjective: options.call.objective,
+                consumer: options.consumer,
                 ...(previous ? { previous } : {}),
                 sources: newSources,
+                ...(sidecar || failureOwner
+                    ? { registrationMode: "atomic" }
+                    : {}),
+                ...(failureOwner ? { failureOwner } : {}),
             });
+            const preparedMessages = withSuperCompactionFailure(failureOwner, () => reconcileEvidence(projectCheckpointMessages(messages, scopeId, candidate, resultSourceOverrides, failureOwner !== undefined), candidate));
             return Object.freeze({
-                messages: projectCheckpointMessages(messages, scopeId, candidate, resultSourceOverrides),
-                commit() {
-                    store.commit(candidate);
-                },
-                scopeId,
-                sourceRevision: candidate.sourceRevision,
-                coveredSourceCount: candidate.sourceDigests.length,
+                kind: "prepared",
+                preparation: Object.freeze({
+                    messages: preparedMessages,
+                    hasExhaustedCompactionSources: scanCompactionSources(preparedMessages, scopeId, resultSourceOverrides, sidecar).length === 0,
+                    commit() {
+                        withSuperCompactionFailure(failureOwner, () => store.commit(candidate));
+                    },
+                    scopeId,
+                    sourceRevision: candidate.sourceRevision,
+                    coveredSourceCount: candidate.sourceDigests.length,
+                }),
             });
         },
     });
+    return Object.freeze({
+        project(messages) {
+            verifiedProjection.clear();
+            const { failureOwner, overrides: resultSourceOverrides } = sourceProjection(messages);
+            const previous = withSuperCompactionFailure(failureOwner, () => readPrevious(messages));
+            projectedCheckpoint = previous;
+            return withSuperCompactionFailure(failureOwner, () => reconcileEvidence(previous
+                ? projectCheckpointMessages(messages, scopeId, previous, resultSourceOverrides, failureOwner !== undefined, verifiedProjection.record)
+                : [...messages], previous));
+        },
+        hasExhaustedVerifiedCompactionSources(messages) {
+            const ownProjection = projectedCheckpoint !== undefined &&
+                store.get(scopeId) === projectedCheckpoint &&
+                verifiedProjection.contains(messages);
+            if (!ownProjection && !options.hasVerifiedCompactedEvidence?.(messages))
+                return false;
+            const { sidecar, overrides } = sourceProjection(messages);
+            return (scanCompactionSources(messages, scopeId, overrides, sidecar).length === 0);
+        },
+        getStages() {
+            return Object.freeze([activeStage]);
+        },
+    });
 }
-function projectCheckpointMessages(messages, scopeId, checkpoint, resultSourceOverrides) {
+function projectCheckpointMessages(messages, scopeId, checkpoint, resultSourceOverrides, superOwned = false, recordVerifiedProjection) {
     const scanned = scanCompactionSources(messages, scopeId, resultSourceOverrides);
     const covered = new Map(checkpoint.sourceDigests.map((source) => [source.sourceRef, source]));
     const removable = new Set();
@@ -115,16 +179,21 @@ function projectCheckpointMessages(messages, scopeId, checkpoint, resultSourceOv
         }
     });
     const checkpointMessage = buildCheckpointMessage(checkpoint);
+    if (checkpoint.sourceDigests.length > 0 && !checkpointEmbedded)
+        recordVerifiedProjection?.(checkpointMessage);
     const projected = [];
     let inserted = false;
     messages.forEach((message, index) => {
         const requestToolResults = projectRequestToolResultsCheckpointMessage(message, checkpoint, resultSourceOverrides);
-        const payloadContext = projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides);
+        const payloadContext = projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides, superOwned);
         if (!checkpointEmbedded && !inserted && index === insertionIndex) {
             projected.push(checkpointMessage);
             inserted = true;
         }
         if (!removable.has(index)) {
+            const carrier = requestToolResults ?? payloadContext;
+            if (checkpoint.sourceDigests.length > 0 && carrier)
+                recordVerifiedProjection?.(carrier);
             projected.push(requestToolResults ?? payloadContext ?? message);
         }
     });
@@ -132,38 +201,19 @@ function projectCheckpointMessages(messages, scopeId, checkpoint, resultSourceOv
         projected.push(checkpointMessage);
     return projected;
 }
-function buildCheckpointMessage(checkpoint) {
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify({
-            kind: checkpoint.kind,
-            authority: "runtime_role_continuation",
-            presenceEffect: "passive_continuity_not_user_intent_routing_or_completion",
-            scopeId: checkpoint.scopeId,
-            roleId: checkpoint.roleId,
-            callId: checkpoint.callId,
-            sourceRevision: checkpoint.sourceRevision,
-            coveredSources: checkpoint.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
-                sourceRef,
-                sourceFingerprint,
-                digest,
-            })),
-            continuation: checkpoint.continuation,
-        }),
-    });
-}
-function scanCompactionSources(messages, scopeId, resultSourceOverrides) {
+function scanCompactionSources(messages, scopeId, resultSourceOverrides, sidecar) {
     const sources = [];
     messages.forEach((message, index) => {
-        if (isCheckpointMessage(message, scopeId))
+        if (isCheckpointMessage(message, scopeId) ||
+            readOperationSupervisionEvidenceBinding(message))
             return;
-        for (const source of resolveMessageSources(message, resultSourceOverrides)) {
+        for (const source of resolveMessageSources(message, resultSourceOverrides, sidecar)) {
             sources.push(Object.freeze({ index, source }));
         }
     });
     return Object.freeze(sources);
 }
-function resolveMessageSources(message, resultSourceOverrides) {
+function resolveMessageSources(message, resultSourceOverrides, sidecar) {
     if (message.role === "tool") {
         return Object.freeze([
             createMessageSource(`tool-result:${message.toolCallId}`, message),
@@ -179,7 +229,7 @@ function resolveMessageSources(message, resultSourceOverrides) {
     const payloadContext = parsePayloadContextRecord(message.content);
     if (payloadContext) {
         return Object.freeze(readRecordArray(payloadContext.settledCapabilityResults).flatMap((result) => {
-            const source = resolveScannableResultSource(result, "payload-result", resultSourceOverrides);
+            const source = resolveScannableResultSource(result, "payload-result", resultSourceOverrides, sidecar);
             return source ? [source] : [];
         }));
     }
@@ -191,7 +241,7 @@ function resolveMessageSources(message, resultSourceOverrides) {
     }
     if (record?.kind === "runtime_request_tool_results_v1") {
         return Object.freeze(readRecordArray(record.results).flatMap((result) => {
-            const source = resolveScannableResultSource(result, undefined, resultSourceOverrides);
+            const source = resolveScannableResultSource(result, undefined, resultSourceOverrides, sidecar);
             return source ? [source] : [];
         }));
     }
@@ -242,76 +292,7 @@ function isCheckpointCarrierMessage(message) {
         "runtime_request_tool_results_v1" ||
         parsePayloadContextRecord(message.content) !== undefined);
 }
-function projectRequestToolResultsCheckpointMessage(message, checkpoint, resultSourceOverrides) {
-    const record = parseJsonRecord(message.content);
-    if (record?.kind !== "runtime_request_tool_results_v1")
-        return undefined;
-    if (message.role !== "user" || message.attachments?.length) {
-        throw new Error("context_compaction_request_tool_results_invalid");
-    }
-    const previousProjection = parseRecord(record.semanticCheckpoint);
-    const previousScopeId = readNonEmptyString(previousProjection?.scopeId);
-    if (previousScopeId && previousScopeId !== checkpoint.scopeId) {
-        throw new Error("context_compaction_checkpoint_scope_conflict");
-    }
-    const covered = new Map(checkpoint.sourceDigests.map((source) => [source.sourceRef, source]));
-    const coveredResults = new Map();
-    for (const receipt of readRecordArray(previousProjection?.coveredResults)) {
-        const executionId = readNonEmptyString(receipt.executionId);
-        const fingerprint = readNonEmptyString(receipt.sourceFingerprint);
-        const source = executionId
-            ? resolveResultSource(receipt, undefined, resultSourceOverrides)
-            : undefined;
-        const exact = source ? covered.get(source.sourceRef) : undefined;
-        if (!executionId ||
-            !fingerprint ||
-            exact?.sourceFingerprint !== fingerprint) {
-            throw new Error("context_compaction_checkpoint_receipt_invalid");
-        }
-        coveredResults.set(executionId, receipt);
-    }
-    const remainingResults = [];
-    for (const result of readRecordArray(record.results)) {
-        const executionId = readNonEmptyString(result.executionId);
-        const source = resolveResultSource(result, undefined, resultSourceOverrides);
-        const exact = source ? covered.get(source.sourceRef) : undefined;
-        if (!executionId || !source || !exact) {
-            remainingResults.push(result);
-            continue;
-        }
-        if (source.sourceFingerprint !== exact.sourceFingerprint) {
-            throw new Error("context_compaction_source_identity_conflict");
-        }
-        const { referenceData: _referenceData, adapterResult: _adapterResult, ...receipt } = result;
-        coveredResults.set(executionId, Object.freeze({
-            ...receipt,
-            sourceFingerprint: exact.sourceFingerprint,
-        }));
-    }
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify({
-            ...record,
-            semanticCheckpoint: {
-                kind: checkpoint.kind,
-                scopeId: checkpoint.scopeId,
-                roleId: checkpoint.roleId,
-                callId: checkpoint.callId,
-                checkpointSourceRevision: checkpoint.sourceRevision,
-                presenceEffect: "passive_role_continuation_not_user_intent_or_completion",
-                coveredSources: checkpoint.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
-                    sourceRef,
-                    sourceFingerprint,
-                    digest,
-                })),
-                continuation: checkpoint.continuation,
-                coveredResults: [...coveredResults.values()],
-            },
-            results: remainingResults,
-        }),
-    });
-}
-function projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides) {
+function projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides, superOwned) {
     const context = parsePayloadContextRecord(message.content);
     if (!context)
         return undefined;
@@ -349,6 +330,9 @@ function projectPayloadContextCheckpointMessage(message, checkpoint, resultSourc
             continue;
         }
         if (source.sourceFingerprint !== exact.sourceFingerprint) {
+            if (superOwned) {
+                throw new CompactionSourceInvariantError("context_compaction_source_identity_conflict", source.sourceRef);
+            }
             throw new Error("context_compaction_source_identity_conflict");
         }
         const { referenceData: _referenceData, adapterResult: _adapterResult, ...receipt } = result;
@@ -363,6 +347,7 @@ function projectPayloadContextCheckpointMessage(message, checkpoint, resultSourc
             ...context,
             semanticCheckpoint: {
                 kind: checkpoint.kind,
+                evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
                 scopeId: checkpoint.scopeId,
                 roleId: checkpoint.roleId,
                 callId: checkpoint.callId,
@@ -426,10 +411,12 @@ function resolveResultSource(result, sourceRefPrefix, overrides) {
  * of the exact evidence body. Only exact evidence (or a canonical override)
  * can become a semantic-compaction source.
  */
-function resolveScannableResultSource(result, sourceRefPrefix, overrides) {
+function resolveScannableResultSource(result, sourceRefPrefix, overrides, sidecar) {
     const executionId = readNonEmptyString(result.executionId);
     if (!executionId)
         return undefined;
+    if (sidecar && !sidecar.eligibleExecutionIds.includes(executionId))
+        return undefined;
     if (!overrides.has(executionId) &&
         !readNonEmptyString(result.referenceData) &&
         !parseRecord(result.adapterResult)) {

package/dist/src/runtime/context/operation-supervision-compacted-evidence.d.ts

@@ -0,0 +1,37 @@
+import type { OperationSupervisionEvidenceEntry } from "./operation-supervision-evidence.js";
+import type { OperationSupervisionEvidenceContext } from "./operation-supervision-evidence-binding.js";
+import type { SemanticCompactionCheckpoint } from "./semantic-compaction/contracts.js";
+import type { RequestContextCompactionStore } from "./semantic-compaction/store.js";
+export type OperationSupervisionCompaction = Readonly<{
+    checkpoint: SemanticCompactionCheckpoint;
+    store: RequestContextCompactionStore;
+}>;
+type EmbeddedEvidence = Exclude<OperationSupervisionEvidenceEntry["evidence"], {
+    kind: "existing_exact_capability_result_lane";
+}>;
+/** Keep the canonical repeat notice without resurrecting its compacted result. */
+export declare function resolveCompactedOperationSupervisionEvidence(executionId: string, evidence: EmbeddedEvidence, context: OperationSupervisionEvidenceContext, compaction: OperationSupervisionCompaction | undefined): Readonly<{
+    kind: "compacted_capability_result_reference";
+    executionId: string;
+    scopeId: string;
+    sourceRef: string;
+    sourceFingerprint: string;
+    acceptedAction: Readonly<{
+        executionId: string;
+        capabilityId: string;
+        controls: import("../orchestration/capability-adapters/result.js").CapabilityJsonObject;
+        declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecution["declaredEffect"];
+        workingDirectory: string | null;
+    }>;
+    receipt: Readonly<{
+        executionId: string;
+        callId: string;
+        invocationAttempt: number;
+        capabilityId: string;
+        declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityDeclaredEffect;
+        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
+        observedEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityObservedEffect;
+        summary: string;
+    }>;
+}> | undefined;
+export {};

package/dist/src/runtime/context/operation-supervision-compacted-evidence.js

@@ -0,0 +1,69 @@
+import { createCapabilityResultCompactionSource } from "./capability-result-compaction-source.js";
+import { matchesCompactedExecutionResult } from "./execution-compacted-evidence.js";
+import { traceDebug } from "../observability/debug-logger.js";
+/** Keep the canonical repeat notice without resurrecting its compacted result. */
+export function resolveCompactedOperationSupervisionEvidence(executionId, evidence, context, compaction) {
+    if (!compaction)
+        return undefined;
+    const { checkpoint, store } = compaction;
+    const receipt = evidence.receipt;
+    const isSameOwnerCheckpoint = checkpoint.requestId === context.requestId &&
+        checkpoint.callId === context.call.callId &&
+        checkpoint.roleId === context.call.roleId &&
+        checkpoint.sourceRevision <= context.sourceRevision &&
+        receipt.callId === context.call.callId &&
+        receipt.executionId === executionId;
+    if (!isSameOwnerCheckpoint)
+        return undefined;
+    const permitsConsumer = context.consumer !== undefined &&
+        checkpoint.allowedConsumers.includes(context.consumer);
+    if (!permitsConsumer)
+        return undefined;
+    const nativeSourceRef = `tool-result:${executionId}`;
+    const digest = checkpoint.sourceDigests.find((source) => source.sourceRef === nativeSourceRef || source.sourceRef === executionId);
+    if (!digest)
+        return undefined;
+    const source = store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+    if (!source)
+        return undefined;
+    if (!matchesRegisteredSupervisionResult(source, executionId, evidence))
+        return undefined;
+    traceDebug("runtime.context.compaction", "supervision.evidence_reused", {
+        requestId: context.requestId,
+        modelStep: context.consumer,
+        scopeId: checkpoint.scopeId,
+        sourceRevision: checkpoint.sourceRevision,
+        executionId,
+        sourceRef: digest.sourceRef,
+    });
+    return Object.freeze({
+        kind: "compacted_capability_result_reference",
+        executionId,
+        scopeId: checkpoint.scopeId,
+        sourceRef: digest.sourceRef,
+        sourceFingerprint: digest.sourceFingerprint,
+        acceptedAction: evidence.acceptedAction,
+        receipt: Object.freeze({
+            executionId: receipt.executionId,
+            callId: receipt.callId,
+            invocationAttempt: receipt.invocationAttempt,
+            capabilityId: receipt.capabilityId,
+            declaredEffect: receipt.declaredEffect,
+            outcome: receipt.outcome,
+            observedEffect: receipt.observedEffect,
+            summary: receipt.summary,
+        }),
+    });
+}
+function matchesRegisteredSupervisionResult(source, executionId, evidence) {
+    const exactResult = {
+        ...evidence.receipt,
+        acceptedAction: evidence.acceptedAction,
+        adapterResult: evidence.adapterResult,
+    };
+    const isNativeResultSource = source.sourceRef === `tool-result:${executionId}`;
+    if (isNativeResultSource)
+        return matchesCompactedExecutionResult(source.content, exactResult);
+    const canonical = createCapabilityResultCompactionSource(exactResult);
+    return canonical.sourceFingerprint === source.sourceFingerprint;
+}

package/dist/src/runtime/context/operation-supervision-evidence-binding.d.ts

@@ -0,0 +1,29 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { RoleCallFrame, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { OperationSupervisionEvidenceEntry } from "./operation-supervision-evidence.js";
+export type OperationSupervisionEvidenceContext = Readonly<{
+    requestId: string;
+    call: Readonly<{
+        roleId: string;
+        callId: string;
+        activationCount?: number;
+    }>;
+    sourceRevision: number;
+    consumer?: ModelStep;
+}>;
+type EvidenceBinding = Readonly<{
+    requestId: string;
+    roleId: string;
+    callId: string;
+    activationCount: number;
+    sourceRevision: number;
+    exactEntriesJson: string;
+}>;
+/** Only canonical builders mint current evidence; JSON is never authority. */
+export declare function bindOperationSupervisionEvidenceMessage(head: RoleCallLedgerHead, call: RoleCallFrame, content: string, exactEntries: readonly OperationSupervisionEvidenceEntry[]): ChatMessage;
+export declare function readOperationSupervisionEvidenceBinding(message: ChatMessage): EvidenceBinding | undefined;
+export declare function assertOperationSupervisionEvidenceContext(binding: EvidenceBinding, context: OperationSupervisionEvidenceContext): void;
+/** A projection carries the same authority only through this internal owner. */
+export declare function rebindOperationSupervisionEvidenceMessage(message: ChatMessage, content: string): ChatMessage;
+export {};

package/dist/src/runtime/context/operation-supervision-evidence-binding.js

@@ -0,0 +1,66 @@
+const CURRENT_SUPERVISION_AUTHORITY = Symbol("currentOperationSupervisionAuthority");
+/** Only canonical builders mint current evidence; JSON is never authority. */
+export function bindOperationSupervisionEvidenceMessage(head, call, content, exactEntries) {
+    if (!head.state.calls.some((candidate) => candidate === call)) {
+        throw new Error("operation_supervision_evidence_call_invalid");
+    }
+    return bindMessage(content, Object.freeze({
+        requestId: head.state.requestId,
+        roleId: call.roleId,
+        callId: call.callId,
+        activationCount: call.activationCount,
+        sourceRevision: head.revision,
+        exactEntriesJson: JSON.stringify(exactEntries),
+    }));
+}
+export function readOperationSupervisionEvidenceBinding(message) {
+    const descriptor = Object.getOwnPropertyDescriptor(message, CURRENT_SUPERVISION_AUTHORITY);
+    if (!descriptor)
+        return undefined;
+    const authority = descriptor.value;
+    if (!authority ||
+        !Object.isFrozen(authority) ||
+        authority.message !== message ||
+        descriptor.enumerable !== false ||
+        descriptor.configurable !== false ||
+        descriptor.writable !== false) {
+        throw new Error("operation_supervision_evidence_message_binding_invalid");
+    }
+    return authority.binding;
+}
+export function assertOperationSupervisionEvidenceContext(binding, context) {
+    const matchesIdentity = binding.requestId === context.requestId &&
+        binding.callId === context.call.callId &&
+        binding.roleId === context.call.roleId &&
+        binding.activationCount === context.call.activationCount &&
+        binding.sourceRevision === context.sourceRevision;
+    const permittedConsumer = context.consumer === "execution.decision" ||
+        context.consumer === "execution.response" ||
+        context.consumer === "worker.decision" ||
+        context.consumer === "worker.result";
+    const matchesRole = binding.roleId === "worker"
+        ? context.consumer === "worker.decision" ||
+            context.consumer === "worker.result"
+        : context.consumer === "execution.decision" ||
+            context.consumer === "execution.response";
+    if (!matchesIdentity || !permittedConsumer || !matchesRole) {
+        throw new Error("operation_supervision_evidence_context_binding_invalid");
+    }
+}
+/** A projection carries the same authority only through this internal owner. */
+export function rebindOperationSupervisionEvidenceMessage(message, content) {
+    const binding = readOperationSupervisionEvidenceBinding(message);
+    if (!binding)
+        throw new Error("operation_supervision_evidence_message_binding_invalid");
+    return content === message.content ? message : bindMessage(content, binding);
+}
+function bindMessage(content, binding) {
+    const message = { role: "user", content };
+    Object.defineProperty(message, CURRENT_SUPERVISION_AUTHORITY, {
+        value: Object.freeze({ message, binding }),
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return Object.freeze(message);
+}

package/dist/src/runtime/context/operation-supervision-evidence-projection.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type OperationSupervisionCompaction } from "./operation-supervision-compacted-evidence.js";
+import { type OperationSupervisionEvidenceContext } from "./operation-supervision-evidence-binding.js";
+/** Resolve exact references against the final messages, before token admission. */
+export declare function projectOperationSupervisionEvidenceClosure(messages: readonly ChatMessage[], context: OperationSupervisionEvidenceContext, compaction?: OperationSupervisionCompaction): ChatMessage[];