@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/context/semantic-compaction/run.js

@@ -1,3 +1,4 @@
+import { registerSemanticCompactionSources } from "./generation-source-registration.js";
 import { projectConfiguredStepMessages } from "../../config/runner/step-instructions.js";
 import { assessRequestMessagesBudget, resolveRequestBudgetInputTokens, } from "../request-context-budget.js";
 import { invokeStructuredModelStep } from "../../model/invoke-structured-step.js";
@@ -5,11 +6,12 @@ import { countModelInputTokens } from "../../model/input-token-count.js";
 import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
 import { ModelOutputIncompleteError } from "../../model/provider-completion.js";
 import { traceDebug } from "../../observability/debug-logger.js";
-import { CONTEXT_COMPACTION_MODEL_STEP, SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH, SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH, assertValidSemanticCompactionCheckpoint, assertValidSemanticCompactionCheckpointBinding, createSemanticCompactionSha256Fingerprint, sameSemanticCompactionCheckpointBinding, semanticCompactionDigestTotalLength, } from "./contracts.js";
+import { CONTEXT_COMPACTION_MODEL_STEP, assertValidSemanticCompactionCheckpoint, assertValidSemanticCompactionCheckpointBinding, createSemanticCompactionSha256Fingerprint, sameSemanticCompactionCheckpointBinding, semanticCompactionDigestTotalLength, } from "./contracts.js";
 import { createSemanticCompactionSourceSlice, projectSemanticCompactionUtf8Boundaries, } from "./chunking.js";
-import { createSemanticCompactionFormat } from "./format.js";
-import { parseSemanticCompactionOutput } from "./parser.js";
-import { SEMANTIC_COMPACTION_INSTRUCTIONS } from "./prompt.js";
+import { createSemanticCompactionFormat, SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT, } from "./format.js";
+import { validateSemanticCompactionOutput } from "./output-validation.js";
+import { prepareReplacementCompactionBudget } from "./replacement-budget.js";
+import { buildSemanticCompactionMessages, buildSemanticCompactionSliceMessages, } from "./generation-input.js";
 import { SEMANTIC_COMPACTION_BATCH_VALIDATION, SEMANTIC_COMPACTION_SLICE_VALIDATION, assessSemanticCompactionRepairHeadroom, } from "./repair-headroom.js";
 export function assessSemanticCompactionInput(params) {
     return prepareSemanticCompactionInput(params).assessment;
@@ -35,7 +37,7 @@ export async function generateSemanticCompactionCandidate(params) {
         });
         throw new Error("context_compaction_input_exceeds_budget");
     }
-    params.request.contextCompactionStore?.registerSources(params.sources);
+    registerSemanticCompactionSources(params);
     const startedAt = Date.now();
     traceDebug("runtime.context.compaction", "model.started", {
         requestId: params.request.requestId,
@@ -54,47 +56,14 @@ export async function generateSemanticCompactionCandidate(params) {
             format: prepared.format,
             timeoutReason: "context_compaction_timeout",
             invalidOutputReason: "invalid_context_compaction_output",
-            parse(text) {
-                const parsed = parseSemanticCompactionOutput(text, prepared.expectedSources, prepared.remainingDigestLength);
-                if (!parsed.ok) {
-                    traceDebug("runtime.context.compaction", "model.rejected", {
-                        requestId: params.request.requestId,
-                        modelStep: CONTEXT_COMPACTION_MODEL_STEP,
-                        scopeId: params.scopeId,
-                        sourceRevision: params.sourceRevision,
-                        issueCode: parsed.issueCode,
-                        outputLength: text.length,
-                    });
-                    return Object.freeze({
-                        ok: false,
-                        stage: SEMANTIC_COMPACTION_BATCH_VALIDATION.stage,
-                        issues: Object.freeze([
-                            Object.freeze({
-                                code: parsed.issueCode,
-                                path: SEMANTIC_COMPACTION_BATCH_VALIDATION.path,
-                                message: SEMANTIC_COMPACTION_BATCH_VALIDATION.message,
-                            }),
-                        ]),
-                    });
-                }
-                return Object.freeze({
-                    ok: true,
-                    decision: Object.freeze({
-                        continuation: parsed.continuation,
-                        sourceDigests: parsed.sourceDigests,
-                    }),
-                });
-            },
+            parse: (text, abortSignal) => validateSemanticCompactionOutput(text, params, prepared.checkpointBudget, SEMANTIC_COMPACTION_BATCH_VALIDATION, abortSignal),
         });
         const candidate = Object.freeze({
             kind: "runtime_semantic_compaction_checkpoint_v2",
             scopeId: params.scopeId,
             ...params.binding,
             sourceRevision: params.sourceRevision,
-            sourceDigests: Object.freeze([
-                ...(params.previous?.sourceDigests ?? []),
-                ...generated.sourceDigests,
-            ]),
+            sourceDigests: generated.sourceDigests,
             continuation: generated.continuation,
         });
         assertValidSemanticCompactionCheckpoint(candidate);
@@ -105,6 +74,9 @@ export async function generateSemanticCompactionCandidate(params) {
             sourceRevision: params.sourceRevision,
             coveredSourceCount: candidate.sourceDigests.length,
             replacementCheckpoint: true,
+            digestMode: "rolling_replacement",
+            previousDigestCharacters: semanticCompactionDigestTotalLength(params.previous?.sourceDigests ?? []),
+            replacementDigestCharacters: semanticCompactionDigestTotalLength(candidate.sourceDigests),
             durationMs: Date.now() - startedAt,
         });
         return candidate;
@@ -127,19 +99,16 @@ export async function generateSemanticCompactionCandidate(params) {
  * returned checkpoint still contains exactly one digest for the full source.
  */
 export async function generateSemanticCompactionCandidateBatched(params) {
-    params.request.contextCompactionStore?.registerSources(params.sources);
+    registerSemanticCompactionSources(params);
     let candidate = params.previous;
     let nextSourceIndex = 0;
     while (nextSourceIndex < params.sources.length) {
         let selectedParams;
-        for (let endSourceIndex = params.sources.length; endSourceIndex > nextSourceIndex; endSourceIndex -= 1) {
+        for (let endSourceIndex = Math.min(params.sources.length, nextSourceIndex + SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT); endSourceIndex > nextSourceIndex; endSourceIndex -= 1) {
             const batch = Object.freeze(params.sources.slice(nextSourceIndex, endSourceIndex));
             const batchParams = Object.freeze({
                 ...params,
                 ...(candidate ? { previous: candidate } : { previous: undefined }),
-                futureSourceCount: (params.futureSourceCount ?? 0) +
-                    params.sources.length -
-                    endSourceIndex,
                 sources: batch,
             });
             if ((await assessSemanticCompactionInputForAdmission(batchParams)).fits) {
@@ -156,10 +125,6 @@ export async function generateSemanticCompactionCandidateBatched(params) {
         const slicedParams = Object.freeze({
             ...params,
             ...(candidate ? { previous: candidate } : { previous: undefined }),
-            futureSourceCount: (params.futureSourceCount ?? 0) +
-                params.sources.length -
-                nextSourceIndex -
-                1,
             sources: Object.freeze([source]),
         });
         candidate = await generateSemanticCompactionSlicedSource(slicedParams, source);
@@ -230,7 +195,7 @@ async function generateSemanticCompactionSlicedSource(params, source) {
         }
         state = Object.freeze({
             continuation: generated.continuation,
-            digest: generated.sourceDigests[0],
+            sourceDigests: generated.sourceDigests,
             coveredThroughByte: selected.slice.range.endByteExclusive,
         });
         startBoundaryIndex = selected.endBoundaryIndex;
@@ -245,10 +210,7 @@ async function generateSemanticCompactionSlicedSource(params, source) {
         scopeId: params.scopeId,
         ...params.binding,
         sourceRevision: params.sourceRevision,
-        sourceDigests: Object.freeze([
-            ...(params.previous?.sourceDigests ?? []),
-            state.digest,
-        ]),
+        sourceDigests: state.sourceDigests,
         continuation: state.continuation,
     });
     assertValidSemanticCompactionCheckpoint(candidate);
@@ -265,61 +227,15 @@ function resolveOutputIncompleteRetryEndBoundary(params) {
         : undefined;
 }
 function prepareSemanticCompactionSliceInput(params, slice, state) {
-    const expectedSources = Object.freeze([
-        Object.freeze({
-            sourceRef: slice.sourceRef,
-            sourceFingerprint: slice.sourceFingerprint,
-        }),
-    ]);
-    const remainingDigestLength = resolveRemainingDigestLength(params, 1);
-    const format = createSemanticCompactionFormat(expectedSources, Math.min(SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH, remainingDigestLength));
-    const messages = [
-        Object.freeze({
-            role: "system",
-            content: [
-                SEMANTIC_COMPACTION_INSTRUCTIONS,
-                "The supplied source is one exact contiguous UTF-8 range of a larger canonical source.",
-                "Return a cumulative replacement continuation and cumulative digest covering every prior range plus this range; do not treat ranges as separate sources.",
-            ].join("\n"),
-        }),
-        Object.freeze({
-            role: "user",
-            content: JSON.stringify({
-                kind: "runtime_semantic_compaction_slice_input_v1",
-                currentRequest: params.request.prompt,
-                active: {
-                    roleId: params.binding.roleId,
-                    callId: params.binding.callId,
-                    preservationObjective: params.preservationObjective,
-                    allowedConsumers: params.binding.allowedConsumers,
-                },
-                ...(params.previous
-                    ? {
-                        previousCheckpoint: {
-                            continuation: params.previous.continuation,
-                            sourceDigests: params.previous.sourceDigests,
-                        },
-                    }
-                    : {}),
-                ...(state
-                    ? {
-                        partialSourceFold: {
-                            coveredThroughByte: state.coveredThroughByte,
-                            continuation: state.continuation,
-                            digest: state.digest.digest,
-                        },
-                    }
-                    : {}),
-                sourceSlice: slice,
-            }),
-        }),
-    ];
+    const checkpointBudget = prepareReplacementCompactionBudget(params, [slice]);
+    const { expectedSources, checkpointTokenAllowance } = checkpointBudget;
+    const format = createSemanticCompactionFormat(expectedSources, checkpointTokenAllowance);
+    const messages = buildSemanticCompactionSliceMessages(params, slice, state);
     const assessment = assessSemanticCompactionMessages(params.request, messages, format);
     return Object.freeze({
-        expectedSources,
         messages,
         format,
-        remainingDigestLength,
+        checkpointBudget,
         assessment,
     });
 }
@@ -347,43 +263,9 @@ async function invokeSemanticCompactionSlice(params, prepared) {
         format: prepared.format,
         timeoutReason: "context_compaction_timeout",
         invalidOutputReason: "invalid_context_compaction_output",
-        parse(text) {
-            const parsed = parseSemanticCompactionOutput(text, prepared.expectedSources, prepared.remainingDigestLength);
-            return parsed.ok
-                ? Object.freeze({
-                    ok: true,
-                    decision: Object.freeze({
-                        continuation: parsed.continuation,
-                        sourceDigests: parsed.sourceDigests,
-                    }),
-                })
-                : Object.freeze({
-                    ok: false,
-                    stage: SEMANTIC_COMPACTION_SLICE_VALIDATION.stage,
-                    issues: Object.freeze([
-                        Object.freeze({
-                            code: parsed.issueCode,
-                            path: SEMANTIC_COMPACTION_SLICE_VALIDATION.path,
-                            message: SEMANTIC_COMPACTION_SLICE_VALIDATION.message,
-                        }),
-                    ]),
-                });
-        },
+        parse: (text, abortSignal) => validateSemanticCompactionOutput(text, params, prepared.checkpointBudget, SEMANTIC_COMPACTION_SLICE_VALIDATION, abortSignal),
     });
 }
-function resolveRemainingDigestLength(params, currentSourceCount) {
-    const futureSourceCount = params.futureSourceCount ?? 0;
-    if (!Number.isSafeInteger(futureSourceCount) || futureSourceCount < 0) {
-        throw new Error("context_compaction_future_source_count_invalid");
-    }
-    const remaining = SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH -
-        semanticCompactionDigestTotalLength(params.previous?.sourceDigests ?? []) -
-        futureSourceCount;
-    if (remaining < currentSourceCount) {
-        throw new Error("context_compaction_digest_allowance_exhausted");
-    }
-    return remaining;
-}
 function prepareSemanticCompactionInput(params) {
     assertValidSemanticCompactionCheckpointBinding(params.binding);
     if (params.binding.requestId !== params.request.requestId ||
@@ -413,56 +295,15 @@ function prepareSemanticCompactionInput(params) {
             throw new Error("context_compaction_checkpoint_not_applicable");
         }
     }
-    const expectedSources = Object.freeze(params.sources.map(({ sourceRef, sourceFingerprint }) => Object.freeze({ sourceRef, sourceFingerprint })));
-    const messages = [
-        Object.freeze({
-            role: "system",
-            content: SEMANTIC_COMPACTION_INSTRUCTIONS,
-        }),
-        Object.freeze({
-            role: "user",
-            content: JSON.stringify({
-                kind: "runtime_semantic_compaction_input_v2",
-                currentRequest: params.request.prompt,
-                active: {
-                    roleId: params.binding.roleId,
-                    callId: params.binding.callId,
-                    preservationObjective: params.preservationObjective,
-                    allowedConsumers: params.binding.allowedConsumers,
-                },
-                ...(params.previous
-                    ? {
-                        previousContinuation: params.previous.continuation,
-                        previousSourceDigests: params.previous.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
-                            sourceRef,
-                            sourceFingerprint,
-                            digest,
-                        })),
-                    }
-                    : {}),
-                newSources: params.sources,
-            }),
-        }),
-    ];
-    const previousDigestLength = semanticCompactionDigestTotalLength(params.previous?.sourceDigests ?? []);
-    const futureSourceCount = params.futureSourceCount ?? 0;
-    if (!Number.isSafeInteger(futureSourceCount) || futureSourceCount < 0) {
-        throw new Error("context_compaction_future_source_count_invalid");
-    }
-    const remainingDigestLength = SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH -
-        previousDigestLength -
-        futureSourceCount;
-    if (remainingDigestLength < expectedSources.length) {
-        throw new Error("context_compaction_digest_allowance_exhausted");
-    }
-    const digestMaxLength = Math.min(SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH, Math.floor(remainingDigestLength / expectedSources.length));
-    const format = createSemanticCompactionFormat(expectedSources, digestMaxLength);
+    const checkpointBudget = prepareReplacementCompactionBudget(params);
+    const { expectedSources, checkpointTokenAllowance } = checkpointBudget;
+    const messages = buildSemanticCompactionMessages(params);
+    const format = createSemanticCompactionFormat(expectedSources, checkpointTokenAllowance);
     const assessment = assessSemanticCompactionMessages(params.request, messages, format);
     return Object.freeze({
-        expectedSources,
         messages,
         format,
-        remainingDigestLength,
+        checkpointBudget,
         assessment,
     });
 }

package/dist/src/runtime/context/semantic-compaction/scope-quarantine.d.ts

@@ -0,0 +1,17 @@
+import { type SemanticCompactionCheckpointBinding } from "./contracts.js";
+export declare const QUARANTINE_VALIDATION_CODES: readonly ["context_compaction_checkpoint_revision_invalid", "context_compaction_checkpoint_content_invalid", "context_compaction_checkpoint_source_invalid", "context_compaction_checkpoint_invalid"];
+export type CheckpointQuarantineReason = (typeof QUARANTINE_VALIDATION_CODES)[number];
+export type InvalidatedCompactionScope = Readonly<{
+    scopeId: string;
+    binding: SemanticCompactionCheckpointBinding;
+    failureCode: CheckpointQuarantineReason;
+}>;
+/** The owning validator must prove intact sources and a bad committed derivative. */
+export declare function freezeCompactionInvalidation(record: InvalidatedCompactionScope): InvalidatedCompactionScope;
+export declare function isCheckpointQuarantineReason(value: unknown): value is CheckpointQuarantineReason;
+/** Lower-level record; the consuming invocation supplies typed role provenance. */
+export declare class InvalidatedCompactionScopeError extends Error {
+    readonly record: InvalidatedCompactionScope;
+    readonly code = "context_compaction_scope_invalidated";
+    constructor(record: InvalidatedCompactionScope);
+}

package/dist/src/runtime/context/semantic-compaction/scope-quarantine.js

@@ -0,0 +1,37 @@
+import { assertValidSemanticCompactionCheckpointBinding, } from "./contracts.js";
+export const QUARANTINE_VALIDATION_CODES = [
+    "context_compaction_checkpoint_revision_invalid",
+    "context_compaction_checkpoint_content_invalid",
+    "context_compaction_checkpoint_source_invalid",
+    "context_compaction_checkpoint_invalid",
+];
+/** The owning validator must prove intact sources and a bad committed derivative. */
+export function freezeCompactionInvalidation(record) {
+    if (!record || typeof record.scopeId !== "string")
+        throw new Error("context_compaction_invalidation_invalid");
+    if (!record.scopeId.trim() || record.scopeId.length > 512)
+        throw new Error("context_compaction_invalidation_invalid");
+    if (!isCheckpointQuarantineReason(record.failureCode))
+        throw new Error("context_compaction_invalidation_reason_invalid");
+    assertValidSemanticCompactionCheckpointBinding(record.binding);
+    return Object.freeze({
+        scopeId: record.scopeId,
+        failureCode: record.failureCode,
+        binding: Object.freeze({
+            ...record.binding,
+            allowedConsumers: Object.freeze([...record.binding.allowedConsumers]),
+        }),
+    });
+}
+export function isCheckpointQuarantineReason(value) {
+    return QUARANTINE_VALIDATION_CODES.some((code) => code === value);
+}
+/** Lower-level record; the consuming invocation supplies typed role provenance. */
+export class InvalidatedCompactionScopeError extends Error {
+    record;
+    code = "context_compaction_scope_invalidated";
+    constructor(record) {
+        super("context_compaction_scope_invalidated");
+        this.record = record;
+    }
+}

package/dist/src/runtime/context/semantic-compaction/snapshot.d.ts

@@ -0,0 +1,13 @@
+import type { SemanticCompactionCheckpoint, SemanticCompactionSource } from "./contracts.js";
+import { type RequestContextCompactionStore } from "./store.js";
+import type { InvalidatedCompactionScope } from "./scope-quarantine.js";
+export type RequestContextCompactionSnapshot = Readonly<{
+    kind: "request_context_compaction_v1";
+    checkpoints: readonly SemanticCompactionCheckpoint[];
+    sources: readonly SemanticCompactionSource[];
+    invalidatedScopes?: readonly InvalidatedCompactionScope[];
+}>;
+export declare function captureRequestContextCompaction(store: RequestContextCompactionStore): RequestContextCompactionSnapshot;
+export declare function restoreRequestContextCompaction(snapshot: RequestContextCompactionSnapshot, options?: Readonly<{
+    restoreSuperQuarantine: true;
+}>): RequestContextCompactionStore;

package/dist/src/runtime/context/semantic-compaction/snapshot.js

@@ -0,0 +1,28 @@
+import { createRequestContextCompactionStore, } from "./store.js";
+export function captureRequestContextCompaction(store) {
+    if (!store.snapshot)
+        throw new Error("context_compaction_snapshot_unavailable");
+    return store.snapshot();
+}
+export function restoreRequestContextCompaction(snapshot, options) {
+    if (snapshot?.kind !== "request_context_compaction_v1")
+        throw new Error("context_compaction_snapshot_invalid");
+    const records = options?.restoreSuperQuarantine
+        ? snapshot.invalidatedScopes
+        : undefined;
+    if (records !== undefined && !Array.isArray(records))
+        throw new Error("context_compaction_invalidation_invalid");
+    if (records?.some((record) => snapshot.checkpoints.some((checkpoint) => checkpoint.scopeId === record.scopeId))) {
+        throw new Error("context_compaction_invalidation_active_checkpoint");
+    }
+    const store = createRequestContextCompactionStore(records ? { invalidatedScopes: records } : undefined);
+    store.registerSources(snapshot.sources);
+    for (const checkpoint of snapshot.checkpoints) {
+        for (const source of checkpoint.sourceDigests) {
+            if (!store.materializeSource(source.sourceRef, source.sourceFingerprint))
+                throw new Error("context_compaction_snapshot_source_missing");
+        }
+        store.commit(checkpoint);
+    }
+    return store;
+}

package/dist/src/runtime/context/semantic-compaction/source-registration.d.ts

@@ -0,0 +1,3 @@
+import { type SemanticCompactionSource } from "./contracts.js";
+/** Validate the complete SUPER batch before the source inventory can change. */
+export declare function prepareAtomicCompactionSources(existing: ReadonlyMap<string, SemanticCompactionSource>, candidates: readonly SemanticCompactionSource[]): readonly SemanticCompactionSource[];

package/dist/src/runtime/context/semantic-compaction/source-registration.js

@@ -0,0 +1,34 @@
+import { createSemanticCompactionSha256Fingerprint, } from "./contracts.js";
+import { CompactionSourceInvariantError } from "../compaction-source-invariant.js";
+/** Validate the complete SUPER batch before the source inventory can change. */
+export function prepareAtomicCompactionSources(existing, candidates) {
+    const pending = new Map();
+    for (const source of candidates) {
+        if (!hasValidCompactionSourceContent(source)) {
+            throw new CompactionSourceInvariantError("context_compaction_source_invalid", typeof source?.sourceRef === "string" ? source.sourceRef : undefined);
+        }
+        const previous = pending.get(source.sourceRef) ?? existing.get(source.sourceRef);
+        if (hasConflictingCompactionSource(previous, source)) {
+            throw new CompactionSourceInvariantError("context_compaction_source_identity_conflict", source.sourceRef);
+        }
+        pending.set(source.sourceRef, Object.freeze({ ...source }));
+    }
+    return Object.freeze([...pending.values()]);
+}
+function hasValidCompactionSourceContent(source) {
+    if (typeof source?.sourceRef !== "string")
+        return false;
+    if (!source.sourceRef.trim())
+        return false;
+    if (typeof source.content !== "string")
+        return false;
+    return (createSemanticCompactionSha256Fingerprint(source.content) ===
+        source.sourceFingerprint);
+}
+function hasConflictingCompactionSource(previous, candidate) {
+    if (!previous)
+        return false;
+    if (previous.sourceFingerprint !== candidate.sourceFingerprint)
+        return true;
+    return previous.content !== candidate.content;
+}

package/dist/src/runtime/context/semantic-compaction/source-slots.d.ts

@@ -0,0 +1,5 @@
+import type { SemanticCompactionSourceIdentity } from "./contracts.js";
+/** Invocation-local keys never replace canonical source identity or ordering. */
+export declare function bindSemanticCompactionSourceSlots<Source extends SemanticCompactionSourceIdentity>(sources: readonly Source[], offset?: number): readonly (Source & {
+    readonly sourceKey: string;
+})[];

package/dist/src/runtime/context/semantic-compaction/source-slots.js

@@ -0,0 +1,4 @@
+/** Invocation-local keys never replace canonical source identity or ordering. */
+export function bindSemanticCompactionSourceSlots(sources, offset = 0) {
+    return Object.freeze(sources.map((source, index) => Object.freeze({ ...source, sourceKey: `source_${offset + index}` })));
+}

package/dist/src/runtime/context/semantic-compaction/store.d.ts

@@ -1,9 +1,16 @@
 import { SemanticCompactionCheckpoint, type SemanticCompactionSource } from "./contracts.js";
+import type { RequestContextCompactionSnapshot } from "./snapshot.js";
+import { type InvalidatedCompactionScope } from "./scope-quarantine.js";
 export type RequestContextCompactionStore = Readonly<{
+    snapshot?(): RequestContextCompactionSnapshot;
     get(scopeId: string): SemanticCompactionCheckpoint | undefined;
     findByCallIds(callIds: readonly string[]): readonly SemanticCompactionCheckpoint[];
     registerSources(sources: readonly SemanticCompactionSource[]): void;
+    registerSourcesAtomically?(sources: readonly SemanticCompactionSource[]): void;
+    quarantineScope?(record: InvalidatedCompactionScope): void;
     materializeSource(sourceRef: string, sourceFingerprint: string): SemanticCompactionSource | undefined;
     commit(checkpoint: SemanticCompactionCheckpoint): void;
 }>;
-export declare function createRequestContextCompactionStore(): RequestContextCompactionStore;
+export declare function createRequestContextCompactionStore(options?: Readonly<{
+    invalidatedScopes?: readonly InvalidatedCompactionScope[];
+}>): RequestContextCompactionStore;

package/dist/src/runtime/context/semantic-compaction/store.js

@@ -1,9 +1,30 @@
 import { assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint, sameSemanticCompactionCheckpointBinding, } from "./contracts.js";
-export function createRequestContextCompactionStore() {
+import { prepareAtomicCompactionSources } from "./source-registration.js";
+import { freezeCompactionInvalidation, InvalidatedCompactionScopeError, } from "./scope-quarantine.js";
+export function createRequestContextCompactionStore(options) {
     const checkpoints = new Map();
     const sources = new Map();
+    const invalidated = new Map();
+    for (const record of options?.invalidatedScopes ?? []) {
+        if (invalidated.has(record.scopeId))
+            throw new Error("context_compaction_invalidation_duplicate");
+        invalidated.set(record.scopeId, freezeCompactionInvalidation(record));
+    }
     return Object.freeze({
+        snapshot() {
+            return Object.freeze({
+                kind: "request_context_compaction_v1",
+                checkpoints: Object.freeze([...checkpoints.values()].filter((checkpoint) => !invalidated.has(checkpoint.scopeId))),
+                sources: Object.freeze([...sources.values()]),
+                ...(invalidated.size
+                    ? { invalidatedScopes: Object.freeze([...invalidated.values()]) }
+                    : {}),
+            });
+        },
         get(scopeId) {
+            const record = invalidated.get(scopeId);
+            if (record)
+                throw new InvalidatedCompactionScopeError(record);
             return checkpoints.get(scopeId);
         },
         findByCallIds(callIds) {
@@ -15,6 +36,8 @@ export function createRequestContextCompactionStore() {
             const selected = [];
             for (const callId of callIds) {
                 for (const checkpoint of checkpoints.values()) {
+                    if (invalidated.has(checkpoint.scopeId))
+                        continue;
                     if (checkpoint.callId === callId)
                         selected.push(checkpoint);
                 }
@@ -37,6 +60,26 @@ export function createRequestContextCompactionStore() {
                 sources.set(source.sourceRef, Object.freeze({ ...source }));
             }
         },
+        registerSourcesAtomically(nextSources) {
+            const prepared = prepareAtomicCompactionSources(sources, nextSources);
+            for (const source of prepared)
+                sources.set(source.sourceRef, source);
+        },
+        quarantineScope(record) {
+            const frozen = freezeCompactionInvalidation(record);
+            const previous = invalidated.get(frozen.scopeId);
+            if (previous) {
+                if (JSON.stringify(previous) !== JSON.stringify(frozen))
+                    throw new Error("context_compaction_invalidation_conflict");
+                return;
+            }
+            const checkpoint = checkpoints.get(frozen.scopeId);
+            if (!checkpoint)
+                throw new Error("context_compaction_invalidation_checkpoint_missing");
+            if (!sameSemanticCompactionCheckpointBinding(checkpoint, frozen.binding))
+                throw new Error("context_compaction_invalidation_binding_invalid");
+            invalidated.set(frozen.scopeId, frozen);
+        },
         materializeSource(sourceRef, sourceFingerprint) {
             const source = sources.get(sourceRef);
             return source?.sourceFingerprint === sourceFingerprint
@@ -44,22 +87,31 @@ export function createRequestContextCompactionStore() {
                 : undefined;
         },
         commit(checkpoint) {
+            const invalidation = invalidated.get(checkpoint.scopeId);
+            if (invalidation)
+                throw new InvalidatedCompactionScopeError(invalidation);
             assertValidSemanticCompactionCheckpoint(checkpoint);
             const previous = checkpoints.get(checkpoint.scopeId);
             if (previous &&
-                (!sameSemanticCompactionCheckpointBinding(previous, checkpoint) ||
-                    checkpoint.sourceRevision < previous.sourceRevision ||
-                    previous.sourceDigests.some((previousDigest, index) => checkpoint.sourceDigests[index]?.sourceRef !==
-                        previousDigest.sourceRef ||
-                        checkpoint.sourceDigests[index]?.sourceFingerprint !==
-                            previousDigest.sourceFingerprint ||
-                        checkpoint.sourceDigests[index]?.digest !== previousDigest.digest))) {
+                !preservesCompactionSourceCoverage(previous, checkpoint)) {
                 throw new Error("context_compaction_checkpoint_regression");
             }
             checkpoints.set(checkpoint.scopeId, freezeCheckpoint(checkpoint));
         },
     });
 }
+function preservesCompactionSourceCoverage(previous, next) {
+    if (!sameSemanticCompactionCheckpointBinding(previous, next))
+        return false;
+    if (next.sourceRevision < previous.sourceRevision)
+        return false;
+    return previous.sourceDigests.every((source, index) => {
+        const replacement = next.sourceDigests[index];
+        if (replacement?.sourceRef !== source.sourceRef)
+            return false;
+        return replacement.sourceFingerprint === source.sourceFingerprint;
+    });
+}
 function freezeCheckpoint(checkpoint) {
     return Object.freeze({
         ...checkpoint,

package/dist/src/runtime/context/semantic-compaction/super-child-result-source.d.ts

@@ -0,0 +1,8 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { SemanticCompactionSource } from "./contracts.js";
+/** Validates a historical return against immutable child/result facts, not the current revision. */
+export declare function assertHistoricalChildResultSource(params: {
+    source: SemanticCompactionSource;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}): void;

package/dist/src/runtime/context/semantic-compaction/super-child-result-source.js

@@ -0,0 +1,50 @@
+import { projectStoredCompletedRoleChild } from "../../orchestration/role-calls/child-return.js";
+import { buildSupervisorChildContinuationParts } from "../../steps/supervisor-decision/resume.js";
+import { buildPlannerCompletedChildMessages } from "../../steps/planner-decision/resume.js";
+import { readStoredSourceMessage } from "./super-source-message.js";
+/** Validates a historical return against immutable child/result facts, not the current revision. */
+export function assertHistoricalChildResultSource(params) {
+    const { source, head, call } = params;
+    const message = readStoredSourceMessage(source);
+    const record = JSON.parse(message.content);
+    if (record.kind !== "runtime_child_result")
+        throw new Error("context_compaction_child_source_invalid");
+    if (source.sourceRef !== `child-result:${record.resultRef}`)
+        throw new Error("context_compaction_child_source_invalid");
+    if (record.callerCallId !== call.callId)
+        throw new Error("context_compaction_child_caller_invalid");
+    if (!call.childCallIds.includes(record.childCallId))
+        throw new Error("context_compaction_child_lineage_invalid");
+    const child = projectStoredCompletedRoleChild(head.state, { callerCallId: call.callId, childCallId: record.childCallId }, head.policy);
+    const resume = {
+        callerCallId: call.callId,
+        invocationAttempt: call.activationCount,
+        returnedChildCallId: child.childCallId,
+        returnedResultRef: child.resultRef,
+        completedChildren: [child],
+    };
+    const input = {
+        resume,
+        currentCallId: call.callId,
+        currentInvocationAttempt: call.activationCount,
+    };
+    if (call.roleId === "supervisor") {
+        const parts = buildSupervisorChildContinuationParts(input);
+        const messages = parts.flatMap((part) => [
+            ...part.messages,
+            ...(part.compactMessages ?? []),
+        ]);
+        if (!messages.some((candidate) => JSON.stringify(candidate) === source.content))
+            throw new Error("context_compaction_child_evidence_changed");
+        return;
+    }
+    if (call.roleId !== "planner")
+        throw new Error("context_compaction_source_family_not_owned");
+    const messages = [
+        ...buildPlannerCompletedChildMessages(child, call.callId, false),
+        // This flag selects an existing historical projection shape; it adds no plan authority.
+        ...buildPlannerCompletedChildMessages(child, call.callId, true),
+    ];
+    if (!messages.some((candidate) => JSON.stringify(candidate) === source.content))
+        throw new Error("context_compaction_child_evidence_changed");
+}