@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -1,10 +1,14 @@
-import { isRoleCapabilityId, ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../orchestration/role-calls/index.js";
+import { projectCurrentRequestToolResults } from "./request-tool-results-supersession.js";
+export { projectCurrentRequestToolResults } from "./request-tool-results-supersession.js";
+import { bindSuperWorkerCompactionSources } from "./super-worker-compaction-sidecar.js";
+import { projectSingleCopyCapabilityResult } from "./capability-result-compaction-source.js";
+import { projectCanonicalRequestToolResult } from "./canonical-capability-result.js";
+import { projectSuperCompactedRequestToolResults } from "./super-request-tool-results-checkpoint.js";
 import { projectWorkerCapabilityPlannerItemBinding } from "../orchestration/worker-capabilities/assignment-provenance.js";
 import { traceDebug } from "../observability/debug-logger.js";
-import { normalizeCapabilityAdapterResult, } from "../orchestration/capability-adapters/result.js";
 import { bindRequestToolResultsMessage } from "./request-tool-results-message-binding.js";
 import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/index.js";
-import { projectAcceptedCapabilityAction, } from "./accepted-capability-action.js";
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./semantic-compaction/evidence-scope.js";
 export const REQUEST_TOOL_RESULTS_MESSAGE_KIND = "runtime_request_tool_results_v1";
 const REQUEST_TOOL_RESULTS_LOG_SCOPE = "runtime.request_tool_results";
 /**
@@ -32,46 +36,7 @@ export function projectRequestToolResults(params) {
                 runningExecutionCount += 1;
                 continue;
             }
-            const exactResult = normalizeCapabilityAdapterResult(execution.exactResult);
-            if (execution.status !== "settled" ||
-                typeof execution.executionId !== "string" ||
-                execution.executionId.length === 0 ||
-                typeof execution.callId !== "string" ||
-                execution.callId.length === 0 ||
-                !Number.isSafeInteger(execution.invocationAttempt) ||
-                execution.invocationAttempt < 1 ||
-                !isRoleCapabilityId(execution.capabilityId) ||
-                !isDeclaredEffect(execution.declaredEffect) ||
-                !isOutcome(execution.outcome) ||
-                !isObservedEffect(execution.observedEffect) ||
-                !isBoundedSummary(execution.summary) ||
-                !isOptionalBoundedReferenceData(execution.referenceData) ||
-                !isValidReferences(execution.references) ||
-                !exactResult.ok) {
-                throw new Error("request_tool_results_execution_invalid");
-            }
-            const sourceResult = 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]) }
-                    : {}),
-                ...(execution.actionFingerprint
-                    ? {
-                        acceptedAction: projectAcceptedCapabilityAction(params.head, execution),
-                    }
-                    : {}),
-                adapterResult: exactResult.value,
-            });
+            const sourceResult = projectCanonicalRequestToolResult(params.head, execution);
             sourceProjected.push(sourceResult);
             if (plannerItemScoped && execution.callId !== params.callId)
                 continue;
@@ -84,7 +49,7 @@ export function projectRequestToolResults(params) {
             }
         }
         const currentResults = projectCurrentRequestToolResults(projected);
-        const view = Object.freeze({
+        const view = bindSuperWorkerCompactionSources({
             sourceRevision: params.head.revision,
             results: Object.freeze(currentResults),
             ...(plannerItemScoped
@@ -95,7 +60,7 @@ export function projectRequestToolResults(params) {
                     }),
                 }
                 : {}),
-        });
+        }, params.head, params.callId);
         traceProjection("projected", params, currentResults, runningExecutionCount, undefined, sourceProjected);
         return view;
     }
@@ -114,7 +79,9 @@ export function buildRequestToolResultsMessage(view) {
         results,
     }));
 }
-export function buildCompactedRequestToolResultsMessage(view, checkpoint) {
+export function buildCompactedRequestToolResultsMessage(view, checkpoint, integrity) {
+    if (integrity)
+        return projectSuperCompactedRequestToolResults(view, checkpoint, integrity, buildRequestToolResultsMessage(view));
     const modelVisibleResults = projectModelVisibleRequestToolResults(view.results);
     const availableExecutionIds = new Set(modelVisibleResults.map(({ executionId }) => executionId));
     if (checkpoint.sourceDigests.some(({ sourceRef }) => !availableExecutionIds.has(sourceRef))) {
@@ -147,6 +114,7 @@ export function buildCompactedRequestToolResultsMessage(view, checkpoint) {
         ...(view.scope ? { coverage: view.scope } : {}),
         semanticCheckpoint: {
             kind: checkpoint.kind,
+            evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
             scopeId: checkpoint.scopeId,
             roleId: checkpoint.roleId,
             callId: checkpoint.callId,
@@ -170,29 +138,7 @@ export function buildCompactedRequestToolResultsMessage(view, checkpoint) {
  * the identical string; otherwise the explicit referenceData field remains.
  */
 function projectModelVisibleRequestToolResults(results) {
-    return Object.freeze(results.map((result) => {
-        if (!isReferenceDataRepresentedByAdapterResult(result))
-            return result;
-        const { referenceData: _referenceData, ...singleCopyResult } = result;
-        return Object.freeze(singleCopyResult);
-    }));
-}
-function isReferenceDataRepresentedByAdapterResult(result) {
-    const referenceData = result.referenceData;
-    const adapterResult = result.adapterResult;
-    if (!referenceData || !adapterResult)
-        return false;
-    if (adapterResult.kind === "registered_tool_execution_result_v1") {
-        return adapterResult.result.output === referenceData;
-    }
-    if (adapterResult.kind === "generic_capability_result_v1" &&
-        isCapabilityJsonObject(adapterResult.payload)) {
-        return adapterResult.payload.referenceData === referenceData;
-    }
-    return false;
-}
-function isCapabilityJsonObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
+    return Object.freeze(results.map(projectSingleCopyCapabilityResult));
 }
 function traceProjection(event, params, results, runningExecutionCount, issueCode, sourceResults = results) {
     traceDebug(REQUEST_TOOL_RESULTS_LOG_SCOPE, event, {
@@ -219,118 +165,6 @@ function traceProjection(event, params, results, runningExecutionCount, issueCod
         ...(issueCode ? { issueCode } : {}),
     });
 }
-/**
- * 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 function projectCurrentRequestToolResults(results) {
-    const latestMutationByTarget = new Map();
-    const latestEquivalentObservation = new Map();
-    const projected = new Array(results.length);
-    for (let index = results.length - 1; index >= 0; index -= 1) {
-        const result = results[index];
-        const targets = result.references?.map(({ target }) => target) ?? [];
-        const isSuccessfulObservation = result.outcome === "succeeded" &&
-            result.observedEffect === "observation" &&
-            targets.length > 0;
-        const isSuccessfulMutation = result.outcome === "succeeded" &&
-            result.observedEffect === "mutation" &&
-            targets.length > 0;
-        const supersedingMutationExecutionIds = isSuccessfulObservation
-            ? targets
-                .map((target) => latestMutationByTarget.get(target))
-                .filter((executionId) => Boolean(executionId))
-            : [];
-        const observationKey = isSuccessfulObservation
-            ? equivalentObservationKey(result, targets)
-            : undefined;
-        const equivalentObservationExecutionId = observationKey
-            ? latestEquivalentObservation.get(observationKey)
-            : undefined;
-        const isSupersededByMutation = isSuccessfulObservation &&
-            supersedingMutationExecutionIds.length === targets.length;
-        const isSupersededObservation = isSupersededByMutation || Boolean(equivalentObservationExecutionId);
-        const supersedingExecutionIds = isSupersededByMutation
-            ? supersedingMutationExecutionIds
-            : equivalentObservationExecutionId
-                ? [equivalentObservationExecutionId]
-                : [];
-        if (isSupersededObservation) {
-            const { referenceData: _referenceData, adapterResult: _adapterResult, ...receipt } = result;
-            projected[index] = Object.freeze({
-                ...receipt,
-                summary: "Earlier successful observation superseded by later settled evidence for the same target.",
-                summaryProjection: "superseded_target_evidence",
-                supersededByExecutionIds: Object.freeze([
-                    ...new Set(supersedingExecutionIds),
-                ]),
-            });
-        }
-        else {
-            projected[index] = result;
-        }
-        if (isSuccessfulMutation) {
-            for (const target of targets) {
-                if (!latestMutationByTarget.has(target)) {
-                    latestMutationByTarget.set(target, result.executionId);
-                }
-            }
-        }
-        if (isSuccessfulObservation &&
-            observationKey &&
-            !latestEquivalentObservation.has(observationKey)) {
-            latestEquivalentObservation.set(observationKey, result.executionId);
-        }
-    }
-    return projected;
-}
-function equivalentObservationKey(result, targets) {
-    const acceptedAction = result.acceptedAction;
-    return JSON.stringify([
-        result.capabilityId,
-        [...targets].sort(),
-        ...(acceptedAction
-            ? [acceptedAction.controls, acceptedAction.workingDirectory]
-            : [result.summary]),
-    ]);
-}
-function isDeclaredEffect(value) {
-    return value === "observation" || value === "mutation" || value === "mixed";
-}
-function isOutcome(value) {
-    return value === "succeeded" || value === "failed";
-}
-function isObservedEffect(value) {
-    return (value === "none" ||
-        value === "observation" ||
-        value === "mutation" ||
-        value === "indeterminate");
-}
-function isBoundedSummary(value) {
-    return (typeof value === "string" &&
-        value.trim().length > 0 &&
-        value.length <= ROLE_CALL_RESULT_MAX_LENGTH);
-}
-function isOptionalBoundedReferenceData(value) {
-    return (value === undefined ||
-        (typeof value === "string" &&
-            value.trim().length > 0 &&
-            value.length <= ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH));
-}
-function isValidReferences(value) {
-    return (value === undefined ||
-        (Array.isArray(value) &&
-            value.length <= ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX &&
-            value.every((reference) => reference.kind === "tool_target" &&
-                typeof reference.target === "string" &&
-                reference.target.trim().length > 0 &&
-                reference.target.length <=
-                    ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH) &&
-            new Set(value.map(({ target }) => target)).size === value.length));
-}
 function projectionIssueCode(error) {
     return error instanceof Error &&
         error.message.startsWith("request_tool_results_")

package/dist/src/runtime/context/runtime-filesystem-scope.d.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+export declare const RUNTIME_FILESYSTEM_SCOPE_KIND: "runtime_filesystem_scope_v1";
+export type RuntimeFilesystemScope = Readonly<{
+    agentWorkRoot: string;
+    hostPathSyntax: "posix" | "win32";
+}>;
+type RuntimePathCapability = Readonly<{
+    runtimePathControlIds?: readonly string[];
+}>;
+/** Uses the same frozen root supplied to the request-bound tool registry. */
+export declare function captureRuntimeFilesystemScope(requestWorkingDirectory?: string): RuntimeFilesystemScope | undefined;
+export declare function canEstablishRuntimeWorkingDirectory(workingDirectory: string | undefined, invocationAvailable: boolean): boolean;
+export declare function needsRuntimeFilesystemScope(capabilities: readonly RuntimePathCapability[], canSelectWorkingDirectory?: boolean): boolean;
+/** Passive root meaning only; selected targets remain in their existing lane. */
+export declare function buildRuntimeFilesystemScopeMessage(input: Readonly<{
+    scope?: RuntimeFilesystemScope;
+    workingDirectory?: string;
+    capabilities?: readonly RuntimePathCapability[];
+    canSelectWorkingDirectory?: boolean;
+}>): ChatMessage | undefined;
+export {};

package/dist/src/runtime/context/runtime-filesystem-scope.js

@@ -0,0 +1,51 @@
+import { isAbsolute } from "node:path";
+export const RUNTIME_FILESYSTEM_SCOPE_KIND = "runtime_filesystem_scope_v1";
+/** Uses the same frozen root supplied to the request-bound tool registry. */
+export function captureRuntimeFilesystemScope(requestWorkingDirectory) {
+    if (requestWorkingDirectory === undefined)
+        return undefined;
+    if (!isAbsolute(requestWorkingDirectory)) {
+        throw new Error("runtime_filesystem_scope_root_invalid");
+    }
+    return Object.freeze({
+        agentWorkRoot: requestWorkingDirectory,
+        hostPathSyntax: process.platform === "win32" ? "win32" : "posix",
+    });
+}
+export function canEstablishRuntimeWorkingDirectory(workingDirectory, invocationAvailable) {
+    if (workingDirectory !== undefined)
+        return false;
+    return invocationAvailable;
+}
+export function needsRuntimeFilesystemScope(capabilities, canSelectWorkingDirectory = false) {
+    if (canSelectWorkingDirectory)
+        return true;
+    return capabilities.some((descriptor) => (descriptor.runtimePathControlIds?.length ?? 0) > 0);
+}
+/** Passive root meaning only; selected targets remain in their existing lane. */
+export function buildRuntimeFilesystemScopeMessage(input) {
+    if (!input.scope)
+        return undefined;
+    if (!needsRuntimeFilesystemScope(input.capabilities ?? [], input.canSelectWorkingDirectory))
+        return undefined;
+    return Object.freeze({
+        role: "system",
+        content: JSON.stringify({
+            kind: RUNTIME_FILESYSTEM_SCOPE_KIND,
+            authority: "canonical_runtime_state",
+            provenance: "request_bound_agent_work_directory",
+            purpose: "interpret_runtime_filesystem_paths",
+            hostPathSyntax: input.scope.hostPathSyntax,
+            agentWorkRoot: input.scope.agentWorkRoot,
+            workingDirectory: input.workingDirectory ?? null,
+            applicability: {
+                canSelectWorkingDirectory: input.canSelectWorkingDirectory === true,
+                relativePathBase: "agentWorkRoot_plus_canonical_workingDirectory",
+                absolutePathSyntax: "runtime_host",
+                allowedLocations: "defined_and_validated_by_each_operation",
+            },
+            presenceEffect: "Reference only. Does not add user intent, authorization, a Desktop location, OS-target mapping, or completion evidence. SYSTEM target paths belong to the selected OS independently of this runtime filesystem root.",
+            omissions: "Only agent-work is represented; no workspace root or file inventory.",
+        }),
+    });
+}

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

@@ -0,0 +1,3 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { SemanticCompactionCheckpoint } from "./contracts.js";
+export declare function buildCheckpointMessage(checkpoint: SemanticCompactionCheckpoint): ChatMessage;

package/dist/src/runtime/context/semantic-compaction/checkpoint-message.js

@@ -0,0 +1,22 @@
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./evidence-scope.js";
+export function buildCheckpointMessage(checkpoint) {
+    return Object.freeze({
+        role: "user",
+        content: JSON.stringify({
+            kind: checkpoint.kind,
+            evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
+            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,
+        }),
+    });
+}

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

@@ -1,7 +1,5 @@
 import { type ModelStep } from "../../../shared/model-steps.js";
 export declare const CONTEXT_COMPACTION_MODEL_STEP: "context.compact";
-export declare const SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH = 2000;
-export declare const SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH = 8000;
 export declare const SEMANTIC_COMPACTION_TEXT_MAX_LENGTH = 2000;
 export declare const SEMANTIC_COMPACTION_LIST_MAX_COUNT = 24;
 export declare const SEMANTIC_COMPACTION_ID_MAX_LENGTH = 256;
@@ -55,6 +53,5 @@ export declare function isSemanticCompactionSha256Fingerprint(value: unknown): v
 export declare function assertValidSemanticCompactionCheckpointBinding(binding: SemanticCompactionCheckpointBinding): void;
 export declare function sameSemanticCompactionCheckpointBinding(left: SemanticCompactionCheckpointBinding, right: SemanticCompactionCheckpointBinding): boolean;
 export declare function semanticCompactionDigestTotalLength(sourceDigests: readonly SemanticCompactionDigest[]): number;
-export declare function semanticCompactionContinuationTotalLength(continuation: SemanticCompactionContinuation): number;
 export declare function assertValidSemanticCompactionCheckpoint(checkpoint: SemanticCompactionCheckpoint): void;
 export declare function isSemanticCompactionCheckpointApplicable(checkpoint: SemanticCompactionCheckpoint, applicability: SemanticCompactionApplicability): boolean;

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

@@ -1,8 +1,6 @@
 import { createHash } from "node:crypto";
 import { MODEL_STEPS, } from "../../../shared/model-steps.js";
 export const CONTEXT_COMPACTION_MODEL_STEP = MODEL_STEPS.CONTEXT_COMPACTION;
-export const SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH = 2_000;
-export const SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH = 8_000;
 export const SEMANTIC_COMPACTION_TEXT_MAX_LENGTH = 2_000;
 export const SEMANTIC_COMPACTION_LIST_MAX_COUNT = 24;
 export const SEMANTIC_COMPACTION_ID_MAX_LENGTH = 256;
@@ -46,18 +44,6 @@ export function sameSemanticCompactionCheckpointBinding(left, right) {
 export function semanticCompactionDigestTotalLength(sourceDigests) {
     return sourceDigests.reduce((total, sourceDigest) => total + sourceDigest.digest.length, 0);
 }
-export function semanticCompactionContinuationTotalLength(continuation) {
-    return (continuation.currentState.length +
-        continuation.nextStep.length +
-        continuation.completed.reduce((total, entry) => total + entry.length, 0) +
-        continuation.findings.reduce((total, entry) => total + entry.length, 0) +
-        continuation.evidenceRefs.reduce((total, entry) => total + entry.length, 0) +
-        continuation.artifacts.reduce((total, entry) => total + entry.length, 0) +
-        continuation.decisions.reduce((total, entry) => total + entry.length, 0) +
-        continuation.failedApproaches.reduce((total, entry) => total + entry.length, 0) +
-        continuation.openWork.reduce((total, entry) => total + entry.length, 0) +
-        continuation.blockers.reduce((total, entry) => total + entry.length, 0));
-}
 export function assertValidSemanticCompactionCheckpoint(checkpoint) {
     assertValidSemanticCompactionCheckpointBinding(checkpoint);
     if (checkpoint.kind !== "runtime_semantic_compaction_checkpoint_v2" ||
@@ -73,16 +59,12 @@ export function assertValidSemanticCompactionCheckpoint(checkpoint) {
         if (!isBoundedId(sourceDigest.sourceRef) ||
             sourceRefs.has(sourceDigest.sourceRef) ||
             !isSemanticCompactionSha256Fingerprint(sourceDigest.sourceFingerprint) ||
-            !isBoundedText(sourceDigest.digest, SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH)) {
+            !isSemanticCompactionDigestText(sourceDigest.digest)) {
             throw new Error("context_compaction_checkpoint_source_invalid");
         }
         sourceRefs.add(sourceDigest.sourceRef);
     }
-    if (semanticCompactionDigestTotalLength(checkpoint.sourceDigests) >
-        SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH ||
-        !isValidContinuation(checkpoint.continuation) ||
-        semanticCompactionContinuationTotalLength(checkpoint.continuation) >
-            SEMANTIC_COMPACTION_DIGEST_TOTAL_MAX_LENGTH) {
+    if (!isValidContinuation(checkpoint.continuation)) {
         throw new Error("context_compaction_checkpoint_content_invalid");
     }
 }
@@ -132,3 +114,10 @@ function isBoundedText(value, maxLength) {
 function isBoundedId(value, maxLength = SEMANTIC_COMPACTION_ID_MAX_LENGTH) {
     return isBoundedText(value, maxLength);
 }
+function isSemanticCompactionDigestText(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim().length === 0)
+        return false;
+    return value === value.trim();
+}

package/dist/src/runtime/context/semantic-compaction/dependency-results.js

@@ -1,5 +1,8 @@
+import { hasSuperContextContract } from "../super-context-policy.js";
+import { assertSuperCompactionCheckpointIntegrity } from "./super-source-integrity.js";
 import { projectRoleCallDependencyResults, } from "../../orchestration/role-calls/index.js";
 import { SEMANTIC_COMPACTION_CONTEXT_LANE, assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint, } from "./contracts.js";
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./evidence-scope.js";
 /**
  * Carries request-local semantic checkpoints only through canonical result
  * dependencies. The ledger remains the authority for applicability; the
@@ -23,6 +26,13 @@ export function projectSemanticCompactionDependencyResults(params) {
             .store.findByCallIds(lineageCallIds)
             .filter((checkpoint) => {
             assertValidSemanticCompactionCheckpoint(checkpoint);
+            if (hasSuperContextContract(params.head.policy.authority, "supervisor")) {
+                assertSuperCompactionCheckpointIntegrity({
+                    ...params,
+                    store: params.store,
+                    checkpoint,
+                });
+            }
             const checkpointCall = callsById.get(checkpoint.callId);
             if (!checkpointCall?.objective ||
                 checkpoint.requestId !== params.requestId ||
@@ -35,7 +45,11 @@ export function projectSemanticCompactionDependencyResults(params) {
                 throw new Error("context_compaction_dependency_checkpoint_not_applicable");
             }
             return checkpoint.allowedConsumers.includes(params.consumer);
-        });
+        })
+            .map((checkpoint) => Object.freeze({
+            ...checkpoint,
+            evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
+        }));
         return checkpoints.length === 0
             ? result
             : Object.freeze({

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

@@ -0,0 +1,7 @@
+/** Derived presentation metadata; persisted checkpoint bytes remain unchanged. */
+export declare const SEMANTIC_COMPACTION_EVIDENCE_SCOPE: Readonly<{
+    kind: "runtime_semantic_compaction_evidence_scope_v1";
+    authority: "passive_reference_only";
+    coverage: "listed_source_evidence_only";
+    omissionMeaning: "not_supplied_not_proven_absent";
+}>;

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

@@ -0,0 +1,7 @@
+/** Derived presentation metadata; persisted checkpoint bytes remain unchanged. */
+export const SEMANTIC_COMPACTION_EVIDENCE_SCOPE = Object.freeze({
+    kind: "runtime_semantic_compaction_evidence_scope_v1",
+    authority: "passive_reference_only",
+    coverage: "listed_source_evidence_only",
+    omissionMeaning: "not_supplied_not_proven_absent",
+});

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

@@ -1,3 +1,4 @@
 import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
 import { type SemanticCompactionSourceIdentity } from "./contracts.js";
-export declare function createSemanticCompactionFormat(expectedSources: readonly SemanticCompactionSourceIdentity[], digestMaxLength?: number): ModelGatewayJsonSchemaFormat;
+export declare const SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT: number;
+export declare function createSemanticCompactionFormat(expectedSources: readonly SemanticCompactionSourceIdentity[], checkpointTokenAllowance: number): ModelGatewayJsonSchemaFormat;

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

@@ -1,13 +1,20 @@
-import { SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH, SEMANTIC_COMPACTION_LIST_MAX_COUNT, SEMANTIC_COMPACTION_TEXT_MAX_LENGTH, } from "./contracts.js";
-export function createSemanticCompactionFormat(expectedSources, digestMaxLength = SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH) {
+import { SEMANTIC_COMPACTION_LIST_MAX_COUNT, SEMANTIC_COMPACTION_TEXT_MAX_LENGTH, } from "./contracts.js";
+import { bindSemanticCompactionSourceSlots } from "./source-slots.js";
+// OpenAI Structured Outputs permits 5000 object properties in one schema.
+// Reserve the two root properties and ten continuation properties.
+export const SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT = 5_000 - 12;
+export function createSemanticCompactionFormat(expectedSources, checkpointTokenAllowance) {
+    if (expectedSources.length > SEMANTIC_COMPACTION_BATCH_SOURCE_MAX_COUNT) {
+        throw new Error("context_compaction_source_count_exceeds_schema_limit");
+    }
     const sourceRefs = expectedSources.map(({ sourceRef }) => sourceRef);
-    if (sourceRefs.length === 0 ||
-        new Set(sourceRefs).size !== sourceRefs.length ||
-        !Number.isSafeInteger(digestMaxLength) ||
-        digestMaxLength < 1 ||
-        digestMaxLength > SEMANTIC_COMPACTION_DIGEST_MAX_LENGTH) {
+    const hasUniqueSourceRefs = sourceRefs.length > 0 && new Set(sourceRefs).size === sourceRefs.length;
+    if (!hasUniqueSourceRefs) {
         throw new Error("context_compaction_source_refs_invalid");
     }
+    const hasPositiveCheckpointTokenAllowance = Number.isSafeInteger(checkpointTokenAllowance) && checkpointTokenAllowance > 0;
+    if (!hasPositiveCheckpointTokenAllowance)
+        throw new Error("context_compaction_token_allowance_invalid");
     const textListSchema = Object.freeze({
         type: "array",
         maxItems: SEMANTIC_COMPACTION_LIST_MAX_COUNT,
@@ -17,15 +24,12 @@ export function createSemanticCompactionFormat(expectedSources, digestMaxLength
             maxLength: SEMANTIC_COMPACTION_TEXT_MAX_LENGTH,
         }),
     });
+    const sourceKeys = bindSemanticCompactionSourceSlots(expectedSources).map(({ sourceKey }) => sourceKey);
     return Object.freeze({
         type: "json_schema",
         name: "context_compaction",
         strict: true,
         postValidatedSchemaConstraints: Object.freeze([
-            Object.freeze({
-                keyword: "maxLength",
-                path: "/properties/sourceDigests/items/maxLength",
-            }),
             ...[
                 "completed",
                 "findings",
@@ -50,6 +54,7 @@ export function createSemanticCompactionFormat(expectedSources, digestMaxLength
         ]),
         schema: Object.freeze({
             type: "object",
+            description: `The complete checkpoint (sourceDigests, continuation, and runtime source-reference envelope) must fit ${checkpointTokenAllowance} input tokens for its consuming model. This is one shared allowance for the complete checkpoint.`,
             properties: Object.freeze({
                 continuation: Object.freeze({
                     type: "object",
@@ -88,14 +93,17 @@ export function createSemanticCompactionFormat(expectedSources, digestMaxLength
                     additionalProperties: false,
                 }),
                 sourceDigests: Object.freeze({
-                    type: "array",
-                    minItems: sourceRefs.length,
-                    maxItems: sourceRefs.length,
-                    items: Object.freeze({
-                        type: "string",
-                        minLength: 1,
-                        maxLength: digestMaxLength,
-                    }),
+                    type: "object",
+                    description: "Allocate the shared checkpoint token budget according to the evidence needed from each source. Sources have no equal quotas or separate character limits. Preserve complete facts within the shared allowance.",
+                    properties: Object.freeze(Object.fromEntries(sourceKeys.map((key) => [
+                        key,
+                        Object.freeze({
+                            type: "string",
+                            minLength: 1,
+                        }),
+                    ]))),
+                    required: Object.freeze(sourceKeys),
+                    additionalProperties: false,
                 }),
             }),
             required: Object.freeze(["continuation", "sourceDigests"]),

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

@@ -0,0 +1,18 @@
+import type { ModelStep } from "../../../shared/model-steps.js";
+import type { SemanticCompactionCheckpoint, SemanticCompactionCheckpointBinding, SemanticCompactionSource } from "./contracts.js";
+import type { BoundRequestModelInvocationContext, RequestExecutionSeed } from "../../request/contracts.js";
+import type { SuperCompactionFailureOwner } from "../super-compaction-failure-owner.js";
+export type SemanticCompactionGenerationParams = Readonly<{
+    request: SemanticCompactionRequest;
+    scopeId: string;
+    binding: SemanticCompactionCheckpointBinding;
+    sourceRevision: number;
+    preservationObjective: string;
+    previous?: SemanticCompactionCheckpoint;
+    /** Model step that will consume the checkpoint. */
+    consumer?: ModelStep;
+    sources: readonly SemanticCompactionSource[];
+    registrationMode?: "atomic";
+    failureOwner?: SuperCompactionFailureOwner;
+}>;
+export type SemanticCompactionRequest = BoundRequestModelInvocationContext & Pick<RequestExecutionSeed, "prompt" | "contextCompactionStore">;

package/dist/src/runtime/context/semantic-compaction/generation-contracts.js

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

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

@@ -0,0 +1,11 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { SemanticCompactionContinuation, SemanticCompactionDigest } from "./contracts.js";
+import type { SemanticCompactionSourceSlice } from "./chunking.js";
+import type { SemanticCompactionGenerationParams } from "./generation-contracts.js";
+export type SemanticCompactionFoldState = Readonly<{
+    continuation: SemanticCompactionContinuation;
+    sourceDigests: readonly SemanticCompactionDigest[];
+    coveredThroughByte: number;
+}>;
+export declare function buildSemanticCompactionMessages(params: SemanticCompactionGenerationParams): ChatMessage[];
+export declare function buildSemanticCompactionSliceMessages(params: SemanticCompactionGenerationParams, slice: SemanticCompactionSourceSlice, state: SemanticCompactionFoldState | undefined): ChatMessage[];