@abot-ai/runtime 1.4.0 → 1.6.0

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[];

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

@@ -0,0 +1,133 @@
+import { isDeepStrictEqual } from "node:util";
+import { readBoundRequestToolResultsView } from "./request-tool-results-message-binding.js";
+import { resolveCompactedOperationSupervisionEvidence, } from "./operation-supervision-compacted-evidence.js";
+import { assertOperationSupervisionEvidenceContext, readOperationSupervisionEvidenceBinding, rebindOperationSupervisionEvidenceMessage, } from "./operation-supervision-evidence-binding.js";
+/** Resolve exact references against the final messages, before token admission. */
+export function projectOperationSupervisionEvidenceClosure(messages, context, compaction) {
+    const origins = new Set();
+    return messages.map((message) => {
+        const binding = readOperationSupervisionEvidenceBinding(message);
+        if (!binding)
+            return message;
+        assertOperationSupervisionEvidenceContext(binding, context);
+        const capsule = record(JSON.parse(message.content));
+        const originals = JSON.parse(binding.exactEntriesJson);
+        const entries = originals.map((entry) => {
+            assertExact(!origins.has(entry.originExecutionId));
+            origins.add(entry.originExecutionId);
+            const evidence = entry.evidence;
+            if (evidence.kind === "existing_exact_capability_result_lane") {
+                throw new Error("operation_supervision_evidence_exact_binding_invalid");
+            }
+            if (evidence.kind === "embedded_cross_call_exact_result")
+                return entry;
+            if (!hasExactLane(messages, entry.originExecutionId, evidence)) {
+                const compacted = resolveCompactedOperationSupervisionEvidence(entry.originExecutionId, evidence, context, compaction);
+                return compacted ? { ...entry, evidence: compacted } : entry;
+            }
+            return {
+                ...entry,
+                evidence: {
+                    kind: "existing_exact_capability_result_lane",
+                    executionId: entry.originExecutionId,
+                },
+            };
+        });
+        return rebindOperationSupervisionEvidenceMessage(message, JSON.stringify({ ...capsule, entries }));
+    });
+}
+function hasExactLane(messages, executionId, expected) {
+    let nativeAction = false;
+    let nativeResult = false;
+    let projectedResult = false;
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            for (const call of message.toolCalls ?? []) {
+                if (call.callId !== executionId)
+                    continue;
+                const action = record(parse(call.arguments));
+                const invocation = record(action?.invocation);
+                assertExact(isExactNativeAction(action, invocation, executionId, expected));
+                assertExact(!nativeAction);
+                nativeAction = true;
+            }
+        }
+        if (message.role === "tool" && message.toolCallId === executionId) {
+            const payload = record(parse(message.content));
+            const result = record(payload?.result);
+            assertExact(isExactNativeResult(payload, result, executionId, expected));
+            assertExact(!nativeResult);
+            nativeResult = true;
+        }
+        if (message.role !== "user" || !readBoundRequestToolResultsView(message))
+            continue;
+        const payload = record(parse(message.content));
+        if (payload?.kind !== "runtime_request_tool_results_v1")
+            continue;
+        for (const value of Array.isArray(payload.results) ? payload.results : []) {
+            const result = record(value);
+            if (result?.executionId !== executionId)
+                continue;
+            // A summary-only receipt cannot satisfy an exact lane.
+            if (result.acceptedAction !== undefined) {
+                assertExact(isDeepStrictEqual(result.acceptedAction, expected.acceptedAction));
+            }
+            if (result.adapterResult === undefined)
+                continue;
+            assertExact(isExactProjectedResult(result, expected));
+            assertExact(!projectedResult);
+            projectedResult = true;
+        }
+    }
+    assertExact(nativeAction === nativeResult);
+    assertExact(!(nativeResult && projectedResult));
+    return (nativeAction && nativeResult) || projectedResult;
+}
+function isExactNativeAction(action, invocation, executionId, expected) {
+    const original = expected.acceptedAction;
+    return (action?.kind === "runtime_execution_agent_action_v1" &&
+        action.invocationAttempt === expected.receipt.invocationAttempt &&
+        invocation?.executionId === executionId &&
+        invocation.capabilityId === original.capabilityId &&
+        invocation.declaredEffect === original.declaredEffect &&
+        isDeepStrictEqual(invocation.controls, original.controls));
+}
+function isExactNativeResult(payload, result, executionId, expected) {
+    return (payload?.kind === "runtime_execution_capability_result_v1" &&
+        payload.invocationAttempt === expected.receipt.invocationAttempt &&
+        result?.executionId === executionId &&
+        result.capabilityId === expected.acceptedAction.capabilityId &&
+        isDeepStrictEqual(result.adapterResult, expected.adapterResult));
+}
+function isExactProjectedResult(result, expected) {
+    const receipt = expected.receipt;
+    const matchesReceipt = result.callId === receipt.callId &&
+        result.invocationAttempt === receipt.invocationAttempt &&
+        result.capabilityId === receipt.capabilityId &&
+        result.outcome === receipt.outcome &&
+        result.declaredEffect === receipt.declaredEffect &&
+        result.observedEffect === receipt.observedEffect &&
+        result.summary === receipt.summary &&
+        result.referenceData === receipt.referenceData &&
+        isDeepStrictEqual(result.references, receipt.references);
+    return (matchesReceipt &&
+        isDeepStrictEqual(result.acceptedAction, expected.acceptedAction) &&
+        isDeepStrictEqual(result.adapterResult, expected.adapterResult));
+}
+function assertExact(valid) {
+    if (!valid)
+        throw new Error("operation_supervision_evidence_exact_lane_invalid");
+}
+function parse(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

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

@@ -23,7 +23,7 @@ export type OperationSupervisionEvidenceEntry = Readonly<{
         kind: "existing_exact_capability_result_lane";
         executionId: string;
     }> | Readonly<{
-        kind: "embedded_cross_call_exact_result";
+        kind: "embedded_cross_call_exact_result" | "embedded_exact_result";
         acceptedAction: OperationSupervisionEvidenceAcceptedAction;
         receipt: OperationSupervisionEvidenceReceipt;
         adapterResult: CapabilityAdapterResult;
@@ -35,3 +35,4 @@ export type OperationSupervisionEvidenceEntry = Readonly<{
  * ownership or request-wide result projection.
  */
 export declare function buildImmediateOperationSupervisionEvidenceMessage(head: RoleCallLedgerHead, call: RoleCallFrame): ChatMessage | undefined;
+export declare function projectOperationSupervisionLinkedEvidence(head: RoleCallLedgerHead, call: RoleCallFrame, notice: RoleOperationSupervisionNotice, embedSameCall?: boolean): OperationSupervisionEvidenceEntry;

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

@@ -1,3 +1,6 @@
+import { projectSingleCopyCapabilityResult } from "./capability-result-compaction-source.js";
+import { projectCanonicalRequestToolResult } from "./canonical-capability-result.js";
+import { bindOperationSupervisionEvidenceMessage } from "./operation-supervision-evidence-binding.js";
 import { projectImmediateRoleOperationSupervisionNotices, } from "../orchestration/role-calls/index.js";
 import { normalizeCapabilityAdapterResult, } from "../orchestration/capability-adapters/result.js";
 import { projectAcceptedCapabilityAction, } from "./accepted-capability-action.js";
@@ -11,27 +14,33 @@ export function buildImmediateOperationSupervisionEvidenceMessage(head, call) {
     const notices = projectImmediateRoleOperationSupervisionNotices(head, call);
     if (notices.length === 0)
         return undefined;
-    const entries = notices.map((notice) => projectLinkedEvidenceEntry(head, call, notice));
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify({
-            kind: OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND,
-            authority: "canonical_role_call_ledger",
-            purpose: "supply_exact_immediate_operation_supervision_evidence",
-            applicability: "bound_activation_decision_or_its_immediate_presentation_handoff",
-            presenceEffect: "passive_evidence_not_user_intent_action_authority_or_new_execution",
-            sourceRevision: head.revision,
-            binding: {
-                callId: call.callId,
-                invocationAttempt: call.activationCount,
-                consumers: ["activation_decision", "immediate_presentation_handoff"],
+    const exactEntries = notices.map((notice) => projectOperationSupervisionLinkedEvidence(head, call, notice, true));
+    const entries = exactEntries.map((entry) => entry.evidence.kind === "embedded_exact_result"
+        ? {
+            ...entry,
+            evidence: {
+                kind: "existing_exact_capability_result_lane",
+                executionId: entry.originExecutionId,
             },
-            coverage: "complete_for_immediate_operation_supervision_notices",
-            entries,
-        }),
-    });
+        }
+        : entry);
+    return bindOperationSupervisionEvidenceMessage(head, call, JSON.stringify({
+        kind: OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND,
+        authority: "canonical_role_call_ledger",
+        purpose: "supply_exact_immediate_operation_supervision_evidence",
+        applicability: "bound_activation_decision_or_its_immediate_presentation_handoff",
+        presenceEffect: "passive_evidence_not_user_intent_action_authority_or_new_execution",
+        sourceRevision: head.revision,
+        binding: {
+            callId: call.callId,
+            invocationAttempt: call.activationCount,
+            consumers: ["activation_decision", "immediate_presentation_handoff"],
+        },
+        coverage: "complete_for_immediate_operation_supervision_notices",
+        entries,
+    }), exactEntries);
 }
-function projectLinkedEvidenceEntry(head, call, notice) {
+export function projectOperationSupervisionLinkedEvidence(head, call, notice, embedSameCall = false) {
     const execution = head.state.capabilityExecutions.find(({ executionId }) => executionId === notice.originExecutionId);
     if (!isLinkedSettledExecution(execution, notice)) {
         throw new Error("operation_supervision_evidence_origin_invalid");
@@ -44,7 +53,7 @@ function projectLinkedEvidenceEntry(head, call, notice) {
         originExecutionId: notice.originExecutionId,
         notice,
     };
-    if (execution.callId === call.callId) {
+    if (execution.callId === call.callId && !embedSameCall) {
         return Object.freeze({
             ...entry,
             evidence: Object.freeze({
@@ -53,27 +62,19 @@ function projectLinkedEvidenceEntry(head, call, notice) {
             }),
         });
     }
+    const canonical = projectCanonicalRequestToolResult(head, execution);
+    const projected = execution.callId === call.callId
+        ? projectSingleCopyCapabilityResult(canonical)
+        : canonical;
+    const { acceptedAction: _action, adapterResult: _result, ...receipt } = projected;
     return Object.freeze({
         ...entry,
         evidence: Object.freeze({
-            kind: "embedded_cross_call_exact_result",
+            kind: execution.callId === call.callId
+                ? "embedded_exact_result"
+                : "embedded_cross_call_exact_result",
             acceptedAction: projectAcceptedCapabilityAction(head, execution),
-            receipt: Object.freeze({
-                executionId: execution.executionId,
-                callId: execution.callId,
-                invocationAttempt: execution.invocationAttempt,
-                capabilityId: execution.capabilityId,
-                declaredEffect: execution.declaredEffect,
-                outcome: execution.outcome,
-                observedEffect: execution.observedEffect,
-                summary: execution.summary,
-                ...(execution.referenceData
-                    ? { referenceData: execution.referenceData }
-                    : {}),
-                ...(execution.references
-                    ? { references: Object.freeze([...execution.references]) }
-                    : {}),
-            }),
+            receipt: Object.freeze(receipt),
             adapterResult: exactResult.value,
         }),
     });

package/dist/src/runtime/context/request-context-contracts.d.ts

@@ -7,6 +7,8 @@ export type RequestHistoryMessage = Readonly<{
     createdAt: string;
     requestId?: string;
     grounding?: SessionMessageGrounding;
+    /** Trusted persisted assistant-origin turn; never supplied as current user intent. */
+    assistantInitiativeId?: string;
 }>;
 export type RequestContextBudget = Readonly<{
     contextWindowTokens: number;

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

@@ -197,6 +197,10 @@ function collectConversationTurns(historyMessages) {
             turns.push(createConversationTurn(message));
             continue;
         }
+        if (message.assistantInitiativeId) {
+            turns.push({ source: [message], messages: [{ role: "assistant", content: message.content }] });
+            continue;
+        }
         const pendingTurn = findPendingConversationTurn(turns, message);
         if (!pendingTurn) {
             continue;
@@ -221,7 +225,7 @@ function createConversationTurn(user, assistant) {
     };
 }
 function findPendingConversationTurn(turns, assistant) {
-    const pendingTurns = turns.filter((turn) => turn.source.length === 1);
+    const pendingTurns = turns.filter((turn) => turn.source.length === 1 && turn.source[0]?.role === "user");
     if (assistant.requestId) {
         const exactMatch = findLastConversationTurn(pendingTurns, (turn) => turn.source[0]?.requestId === assistant.requestId);
         if (exactMatch) {

package/dist/src/runtime/context/request-tool-results-checkpoint.d.ts

@@ -0,0 +1,3 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type SemanticCompactionCheckpoint, type SemanticCompactionSource } from "./semantic-compaction/contracts.js";
+export declare function projectRequestToolResultsCheckpointMessage(message: ChatMessage, checkpoint: SemanticCompactionCheckpoint, resultSourceOverrides: ReadonlyMap<string, SemanticCompactionSource>): ChatMessage | undefined;

package/dist/src/runtime/context/request-tool-results-checkpoint.js

@@ -0,0 +1,126 @@
+import { CompactionSourceInvariantError } from "./compaction-source-invariant.js";
+import { readSuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+import { bindRequestToolResultsMessage, readBoundRequestToolResultsView, } from "./request-tool-results-message-binding.js";
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./semantic-compaction/evidence-scope.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+export 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 view = readBoundRequestToolResultsView(message);
+    const superSources = view
+        ? readSuperWorkerCompactionSidecar(view)
+        : undefined;
+    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) {
+            if (superSources)
+                throw new CompactionSourceInvariantError("context_compaction_checkpoint_receipt_invalid", executionId);
+            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) {
+            if (superSources)
+                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;
+        coveredResults.set(executionId, Object.freeze({
+            ...receipt,
+            sourceFingerprint: exact.sourceFingerprint,
+        }));
+    }
+    const projected = Object.freeze({
+        role: "user",
+        content: JSON.stringify({
+            ...record,
+            semanticCheckpoint: {
+                kind: checkpoint.kind,
+                evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
+                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,
+        }),
+    });
+    return view
+        ? bindRequestToolResultsMessage(view, projected.content)
+        : projected;
+}
+function parseRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseJsonRecord(content) {
+    try {
+        return parseRecord(JSON.parse(content));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRecordArray(value) {
+    return Array.isArray(value)
+        ? value.flatMap((entry) => {
+            const record = parseRecord(entry);
+            return record ? [record] : [];
+        })
+        : [];
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function resolveResultSource(result, _prefix, overrides) {
+    const executionId = readNonEmptyString(result.executionId);
+    if (!executionId)
+        return undefined;
+    const override = overrides.get(executionId);
+    if (override)
+        return override;
+    const content = JSON.stringify(result);
+    return {
+        sourceRef: executionId,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    };
+}

package/dist/src/runtime/context/request-tool-results-message-binding.d.ts

@@ -4,3 +4,4 @@ import type { RequestToolResultsView } from "./request-tool-results.js";
 export declare function bindRequestToolResultsMessage(view: RequestToolResultsView, content: string): ChatMessage;
 /** Accepts only a message minted for this exact canonical result view. */
 export declare function isRequestToolResultsMessageBoundToView(message: ChatMessage, view: RequestToolResultsView): boolean;
+export declare function readBoundRequestToolResultsView(message: ChatMessage): RequestToolResultsView | undefined;

package/dist/src/runtime/context/request-tool-results-message-binding.js

@@ -28,3 +28,13 @@ export function isRequestToolResultsMessageBoundToView(message, view) {
         descriptor.configurable === false &&
         descriptor.writable === false);
 }
+export function readBoundRequestToolResultsView(message) {
+    const descriptor = Object.getOwnPropertyDescriptor(message, REQUEST_TOOL_RESULTS_MESSAGE_AUTHORITY);
+    if (!descriptor)
+        return undefined;
+    const view = descriptor.value?.view;
+    if (!view || !isRequestToolResultsMessageBoundToView(message, view)) {
+        throw new Error("context_compaction_source_message_binding_invalid");
+    }
+    return view;
+}

package/dist/src/runtime/context/request-tool-results-supersession.d.ts

@@ -0,0 +1,9 @@
+import type { RequestToolResult } from "./request-tool-results.js";
+/**
+ * Keeps every canonical execution record while replacing stale successful
+ * observations with a small, explicit supersession marker. A mutation makes
+ * earlier observations of the same target stale. An exact later observation
+ * makes an identical earlier observation redundant. Different observations of
+ * one target remain visible because they may cover complementary regions.
+ */
+export declare function projectCurrentRequestToolResults(results: readonly RequestToolResult[]): RequestToolResult[];