@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/context/execution-compaction-checkpoint-selection.js

@@ -0,0 +1,104 @@
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { executionCompactionScopeId, projectExecutionCompactionObjective, } from "./execution-compaction-objective.js";
+import { assertValidSemanticCompactionCheckpoint, createSemanticCompactionSha256Fingerprint as fingerprint, SEMANTIC_COMPACTION_CONTEXT_LANE, } from "./semantic-compaction/contracts.js";
+/** Select immutable evidence; an earlier objective's continuation is not current intent. */
+export function resolveExecutionEvidenceCheckpoint(params) {
+    const store = params.store;
+    if (!store)
+        return undefined;
+    const objectives = acceptedExecutionObjectives(params);
+    const candidates = store
+        .findByCallIds([params.callId])
+        .filter((checkpoint) => {
+        const accepted = objectives.get(checkpoint.scopeId);
+        return (accepted !== undefined &&
+            hasExecutionCheckpointBinding(checkpoint, accepted, params));
+    });
+    candidates.sort((left, right) => objectives.get(right.scopeId).prefix -
+        objectives.get(left.scopeId).prefix ||
+        right.sourceRevision - left.sourceRevision ||
+        right.sourceDigests.length - left.sourceDigests.length ||
+        left.scopeId.localeCompare(right.scopeId));
+    for (const checkpoint of candidates) {
+        const inherited = params.updates !== undefined &&
+            checkpoint.objectiveFingerprint !== fingerprint(params.objective);
+        if (hasMaterializedExecutionSources(checkpoint, store, inherited))
+            return checkpoint;
+    }
+    return undefined;
+}
+function acceptedExecutionObjectives(params) {
+    const objectives = new Map();
+    if (params.updates === undefined) {
+        objectives.set(executionCompactionScopeId(params), {
+            prefix: 0,
+            objectiveFingerprint: fingerprint(params.objective),
+        });
+        return objectives;
+    }
+    if (projectExecutionCompactionObjective(params.prompt, params.updates) !==
+        params.objective)
+        return objectives;
+    for (let prefix = 0; prefix <= params.updates.length; prefix += 1) {
+        const objective = projectExecutionCompactionObjective(params.prompt, params.updates.slice(0, prefix));
+        objectives.set(executionCompactionScopeId({ ...params, objective }), {
+            prefix,
+            objectiveFingerprint: fingerprint(objective),
+        });
+    }
+    return objectives;
+}
+function hasExecutionCheckpointBinding(checkpoint, accepted, params) {
+    if (!isValidExecutionCheckpoint(checkpoint))
+        return false;
+    if (checkpoint.requestId !== params.requestId)
+        return false;
+    if (checkpoint.callId !== params.callId)
+        return false;
+    if (checkpoint.roleId !== "supervisor")
+        return false;
+    if (checkpoint.contextLane !== SEMANTIC_COMPACTION_CONTEXT_LANE)
+        return false;
+    if (checkpoint.currentRequestFingerprint !== fingerprint(params.prompt))
+        return false;
+    if (checkpoint.objectiveFingerprint !== accepted.objectiveFingerprint)
+        return false;
+    if (params.sourceRevision !== undefined &&
+        checkpoint.sourceRevision > params.sourceRevision)
+        return false;
+    return hasExecutionConsumers(checkpoint.allowedConsumers, params.allowedConsumers);
+}
+function isValidExecutionCheckpoint(checkpoint) {
+    try {
+        assertValidSemanticCompactionCheckpoint(checkpoint);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasExecutionConsumers(actual, expected) {
+    if (actual.some((consumer) => consumer !== MODEL_STEPS.EXECUTION_DECISION &&
+        consumer !== MODEL_STEPS.EXECUTION_RESPONSE))
+        return false;
+    if (!expected)
+        return actual.includes(MODEL_STEPS.EXECUTION_DECISION);
+    return (actual.length === expected.length &&
+        actual.every((consumer, index) => consumer === expected[index]));
+}
+function hasMaterializedExecutionSources(checkpoint, store, inherited) {
+    return checkpoint.sourceDigests.every((digest) => {
+        const source = store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+        if (!source) {
+            if (inherited)
+                throw new Error("context_compaction_inheritance_source_missing");
+            return false;
+        }
+        const exact = source.sourceRef === digest.sourceRef &&
+            source.sourceFingerprint === digest.sourceFingerprint &&
+            fingerprint(source.content) === digest.sourceFingerprint;
+        if (!exact && inherited)
+            throw new Error("context_compaction_inheritance_source_identity_invalid");
+        return exact;
+    });
+}

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

@@ -0,0 +1,12 @@
+import { type SemanticCompactionCheckpoint, type SemanticCompactionCheckpointBinding } from "./semantic-compaction/contracts.js";
+import type { RequestContextCompactionStore } from "./semantic-compaction/store.js";
+type CompactionInheritance = Readonly<{
+    checkpoint?: SemanticCompactionCheckpoint;
+    store: RequestContextCompactionStore;
+    binding: SemanticCompactionCheckpointBinding;
+    scopeId: string;
+    sourceRevision: number;
+}>;
+/** The EA owner proves accepted steering lineage; the shared controller enforces isolation. */
+export declare function readInheritedCompactionCheckpoint({ checkpoint, store, binding, scopeId, sourceRevision, }: CompactionInheritance): SemanticCompactionCheckpoint | undefined;
+export {};

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

@@ -0,0 +1,28 @@
+import { assertValidSemanticCompactionCheckpoint, sameSemanticCompactionCheckpointBinding, } from "./semantic-compaction/contracts.js";
+/** The EA owner proves accepted steering lineage; the shared controller enforces isolation. */
+export function readInheritedCompactionCheckpoint({ checkpoint, store, binding, scopeId, sourceRevision, }) {
+    if (!checkpoint)
+        return undefined;
+    assertValidSemanticCompactionCheckpoint(checkpoint);
+    if (!hasExecutionOnlyBinding(binding))
+        throw new Error("context_compaction_inheritance_consumer_invalid");
+    if (checkpoint.scopeId === scopeId)
+        throw new Error("context_compaction_inheritance_scope_invalid");
+    if (store.get(checkpoint.scopeId) !== checkpoint)
+        throw new Error("context_compaction_inheritance_checkpoint_missing");
+    if (checkpoint.sourceRevision > sourceRevision)
+        throw new Error("context_compaction_inheritance_revision_invalid");
+    if (!sameEvidenceBinding(checkpoint, binding))
+        throw new Error("context_compaction_inheritance_binding_invalid");
+    return checkpoint;
+}
+function hasExecutionOnlyBinding(binding) {
+    if (binding.roleId !== "supervisor")
+        return false;
+    if (binding.allowedConsumers.length === 0)
+        return false;
+    return binding.allowedConsumers.every((consumer) => consumer === "execution.decision" || consumer === "execution.response");
+}
+function sameEvidenceBinding(checkpoint, binding) {
+    return sameSemanticCompactionCheckpointBinding(checkpoint, { ...binding, objectiveFingerprint: checkpoint.objectiveFingerprint });
+}

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

@@ -0,0 +1,12 @@
+import { type CheckpointProjectionOptions } from "./semantic-compaction/checkpoint-message.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { SuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+import { type SemanticCompactionCheckpoint, type SemanticCompactionSource } from "./semantic-compaction/contracts.js";
+type ScannedSource = Readonly<{
+    index: number;
+    source: SemanticCompactionSource;
+}>;
+export declare function projectCheckpointMessages(messages: readonly ChatMessage[], scopeId: string, checkpoint: SemanticCompactionCheckpoint, resultSourceOverrides: ReadonlyMap<string, SemanticCompactionSource>, superOwned?: boolean, recordVerifiedProjection?: (message: ChatMessage) => void, options?: CheckpointProjectionOptions): ChatMessage[];
+export declare function scanCompactionSources(messages: readonly ChatMessage[], scopeId: string, resultSourceOverrides: ReadonlyMap<string, SemanticCompactionSource>, sidecar?: SuperWorkerCompactionSidecar): readonly ScannedSource[];
+export declare function createResultSourceOverrideMap(sources: readonly SemanticCompactionSource[]): ReadonlyMap<string, SemanticCompactionSource>;
+export {};

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

@@ -0,0 +1,322 @@
+import { buildCheckpointMessage } from "./semantic-compaction/checkpoint-message.js";
+import { SEMANTIC_COMPACTION_EVIDENCE_SCOPE } from "./semantic-compaction/evidence-scope.js";
+import { readOperationSupervisionEvidenceBinding } from "./operation-supervision-evidence-binding.js";
+import { CORE_SKILL_READ_MESSAGE_KIND, coreSkillReadSourceRef } from "./core-skill-read-context.js";
+import { OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND } from "./operation-supervision-evidence.js";
+import { projectRequestToolResultsCheckpointMessage } from "./request-tool-results-checkpoint.js";
+import { CompactionSourceInvariantError } from "./compaction-source-invariant.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+const PAYLOAD_CONTEXT_PREFIX = "Canonical runtime context:\n";
+export function projectCheckpointMessages(messages, scopeId, checkpoint, resultSourceOverrides, superOwned = false, recordVerifiedProjection, options = {}) {
+    const scanned = scanCompactionSources(messages, scopeId, resultSourceOverrides);
+    const covered = new Map(checkpoint.sourceDigests.map((source) => [source.sourceRef, source]));
+    const removable = new Set();
+    let insertionIndex = messages.length;
+    const checkpointEmbedded = messages.some(isCheckpointCarrierMessage);
+    for (const { index, source } of scanned) {
+        const exact = covered.get(source.sourceRef);
+        if (exact?.sourceFingerprint === source.sourceFingerprint) {
+            if (!isCheckpointCarrierMessage(messages[index])) {
+                removable.add(index);
+                insertionIndex = Math.min(insertionIndex, index);
+            }
+        }
+    }
+    messages.forEach((message, index) => {
+        if (isCheckpointMessage(message, scopeId) ||
+            (options.replacesScopeId !== undefined &&
+                isCheckpointMessage(message, options.replacesScopeId))) {
+            removable.add(index);
+            insertionIndex = Math.min(insertionIndex, index);
+        }
+    });
+    const checkpointMessage = buildCheckpointMessage(checkpoint, options);
+    if (checkpoint.sourceDigests.length > 0 && !checkpointEmbedded)
+        recordVerifiedProjection?.(checkpointMessage);
+    const projected = [];
+    let inserted = false;
+    messages.forEach((message, index) => {
+        const requestToolResults = projectRequestToolResultsCheckpointMessage(message, checkpoint, resultSourceOverrides, options);
+        const payloadContext = projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides, superOwned, options);
+        if (!checkpointEmbedded && !inserted && index === insertionIndex) {
+            projected.push(checkpointMessage);
+            inserted = true;
+        }
+        if (!removable.has(index)) {
+            const carrier = requestToolResults ?? payloadContext;
+            if (checkpoint.sourceDigests.length > 0 && carrier)
+                recordVerifiedProjection?.(carrier);
+            projected.push(requestToolResults ?? payloadContext ?? message);
+        }
+    });
+    if (!checkpointEmbedded && !inserted)
+        projected.push(checkpointMessage);
+    return projected;
+}
+export function scanCompactionSources(messages, scopeId, resultSourceOverrides, sidecar) {
+    const sources = [];
+    messages.forEach((message, index) => {
+        if (isCheckpointMessage(message, scopeId) ||
+            readOperationSupervisionEvidenceBinding(message))
+            return;
+        for (const source of resolveMessageSources(message, resultSourceOverrides, sidecar)) {
+            sources.push(Object.freeze({ index, source }));
+        }
+    });
+    return Object.freeze(sources);
+}
+function resolveMessageSources(message, resultSourceOverrides, sidecar) {
+    if (message.role === "tool") {
+        return Object.freeze([
+            resultSourceOverrides.get(`tool-result:${message.toolCallId}`) ??
+                createMessageSource(`tool-result:${message.toolCallId}`, message),
+        ]);
+    }
+    if (message.role === "assistant" && message.toolCalls) {
+        return Object.freeze([
+            createMessageSource(`tool-action:${createSemanticCompactionSha256Fingerprint(message.toolCalls.map(({ callId }) => callId).join("\n")).slice("sha256:".length)}`, message),
+        ]);
+    }
+    if (!message.content)
+        return Object.freeze([]);
+    const payloadContext = parsePayloadContextRecord(message.content);
+    if (payloadContext) {
+        return Object.freeze(readRecordArray(payloadContext.settledCapabilityResults).flatMap((result) => {
+            const source = resolveScannableResultSource(result, "payload-result", resultSourceOverrides, sidecar);
+            return source ? [source] : [];
+        }));
+    }
+    const record = parseJsonRecord(message.content);
+    if (record?.kind === CORE_SKILL_READ_MESSAGE_KIND) {
+        const read = record.read;
+        const document = record.document;
+        const readId = readNonEmptyString(read?.readId);
+        return readId ? Object.freeze([createMessageSource(coreSkillReadSourceRef(readId, readNonEmptyString(document?.skillId)), message)]) : Object.freeze([]);
+    }
+    if (record?.kind === OPERATION_SUPERVISION_EVIDENCE_MESSAGE_KIND) {
+        return Object.freeze([
+            createMessageSource(hashedMessageSourceRef("operation-supervision-evidence", message.content), message),
+        ]);
+    }
+    if (record?.kind === "runtime_request_tool_results_v1") {
+        return Object.freeze(readRecordArray(record.results).flatMap((result) => {
+            const source = resolveScannableResultSource(result, undefined, resultSourceOverrides, sidecar);
+            return source ? [source] : [];
+        }));
+    }
+    if (record?.kind === "runtime_child_result") {
+        const resultRef = readNonEmptyString(record.resultRef);
+        return resultRef
+            ? Object.freeze([
+                createMessageSource(`child-result:${resultRef}`, message),
+            ])
+            : Object.freeze([]);
+    }
+    if (record?.kind === "runtime_execution_agent_auditor_evidence_v1") {
+        return Object.freeze([
+            createMessageSource(hashedMessageSourceRef("role-evidence", message.content), message),
+        ]);
+    }
+    const header = parseJsonRecord(message.content.split("\n", 1)[0] ?? "");
+    if (header?.kind === "runtime_reviewer_evidence_v1") {
+        const evidenceRef = readNonEmptyString(header.evidenceRef);
+        return Object.freeze([
+            createMessageSource(evidenceRef
+                ? `reviewer-evidence:${evidenceRef}`
+                : hashedMessageSourceRef("reviewer-evidence", message.content), message),
+        ]);
+    }
+    return Object.freeze([]);
+}
+function createMessageSource(sourceRef, message) {
+    const content = JSON.stringify(message);
+    return Object.freeze({
+        sourceRef,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+function hashedMessageSourceRef(prefix, content) {
+    return `${prefix}:${createSemanticCompactionSha256Fingerprint(content).slice("sha256:".length)}`;
+}
+function isCheckpointMessage(message, scopeId) {
+    if (!message.content)
+        return false;
+    const record = parseJsonRecord(message.content);
+    return (record?.kind === "runtime_semantic_compaction_checkpoint_v2" &&
+        record.scopeId === scopeId);
+}
+function isCheckpointCarrierMessage(message) {
+    return (parseJsonRecord(message.content)?.kind ===
+        "runtime_request_tool_results_v1" ||
+        parsePayloadContextRecord(message.content) !== undefined);
+}
+function projectPayloadContextCheckpointMessage(message, checkpoint, resultSourceOverrides, superOwned, options) {
+    const context = parsePayloadContextRecord(message.content);
+    if (!context)
+        return undefined;
+    if (message.role !== "user" || message.attachments?.length) {
+        throw new Error("context_compaction_payload_context_invalid");
+    }
+    const previousProjection = parseRecord(context.semanticCheckpoint);
+    const previousScopeId = readNonEmptyString(previousProjection?.scopeId);
+    if (previousScopeId &&
+        previousScopeId !== checkpoint.scopeId &&
+        previousScopeId !== options.replacesScopeId) {
+        throw new Error("context_compaction_checkpoint_scope_conflict");
+    }
+    const covered = new Map(checkpoint.sourceDigests.map((source) => [source.sourceRef, source]));
+    const coveredResults = new Map();
+    for (const receipt of readRecordArray(previousProjection?.coveredResults)) {
+        const executionId = readNonEmptyString(receipt.executionId);
+        const fingerprint = readNonEmptyString(receipt.sourceFingerprint);
+        const source = executionId
+            ? resolveResultSource(receipt, "payload-result", resultSourceOverrides)
+            : undefined;
+        const exact = source ? covered.get(source.sourceRef) : undefined;
+        if (!executionId ||
+            !fingerprint ||
+            exact?.sourceFingerprint !== fingerprint) {
+            throw new Error("context_compaction_checkpoint_receipt_invalid");
+        }
+        coveredResults.set(executionId, receipt);
+    }
+    const remainingResults = [];
+    for (const result of readRecordArray(context.settledCapabilityResults)) {
+        const executionId = readNonEmptyString(result.executionId);
+        const source = resolveResultSource(result, "payload-result", resultSourceOverrides);
+        const exact = source ? covered.get(source.sourceRef) : undefined;
+        if (!executionId || !source || !exact) {
+            remainingResults.push(result);
+            continue;
+        }
+        if (source.sourceFingerprint !== exact.sourceFingerprint) {
+            if (superOwned) {
+                throw new CompactionSourceInvariantError("context_compaction_source_identity_conflict", source.sourceRef);
+            }
+            throw new Error("context_compaction_source_identity_conflict");
+        }
+        const { referenceData: _referenceData, adapterResult: _adapterResult, ...receipt } = result;
+        coveredResults.set(executionId, Object.freeze({
+            ...receipt,
+            sourceFingerprint: exact.sourceFingerprint,
+        }));
+    }
+    return Object.freeze({
+        role: "user",
+        content: `${PAYLOAD_CONTEXT_PREFIX}${JSON.stringify({
+            ...context,
+            semanticCheckpoint: {
+                kind: checkpoint.kind,
+                evidenceScope: SEMANTIC_COMPACTION_EVIDENCE_SCOPE,
+                scopeId: checkpoint.scopeId,
+                roleId: checkpoint.roleId,
+                callId: checkpoint.callId,
+                checkpointSourceRevision: checkpoint.sourceRevision,
+                ...(options.includeContinuation === false
+                    ? { authority: "passive_source_evidence" }
+                    : {}),
+                presenceEffect: options.includeContinuation === false
+                    ? "passive_source_evidence_not_current_intent_or_completion"
+                    : "passive_role_continuation_not_user_intent_or_completion",
+                coveredSources: checkpoint.sourceDigests.map(({ sourceRef, sourceFingerprint, digest }) => ({
+                    sourceRef,
+                    sourceFingerprint,
+                    digest,
+                })),
+                ...(options.includeContinuation === false
+                    ? {}
+                    : { continuation: checkpoint.continuation }),
+                coveredResults: [...coveredResults.values()],
+            },
+            settledCapabilityResults: remainingResults,
+        })}`,
+    });
+}
+function parseJsonRecord(value) {
+    try {
+        const decoded = JSON.parse(value);
+        return decoded && typeof decoded === "object" && !Array.isArray(decoded)
+            ? decoded
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createResultSourceOverrideMap(sources) {
+    const overrides = new Map();
+    for (const source of sources) {
+        if (!source.sourceRef.trim() ||
+            !source.content ||
+            createSemanticCompactionSha256Fingerprint(source.content) !==
+                source.sourceFingerprint ||
+            overrides.has(source.sourceRef)) {
+            throw new Error("context_compaction_source_override_invalid");
+        }
+        overrides.set(source.sourceRef, source);
+    }
+    return overrides;
+}
+function resolveResultSource(result, sourceRefPrefix, overrides) {
+    const executionId = readNonEmptyString(result.executionId);
+    if (!executionId)
+        return undefined;
+    const sourceRef = sourceRefPrefix
+        ? `${sourceRefPrefix}:${executionId}`
+        : executionId;
+    const override = overrides.get(executionId) ?? overrides.get(sourceRef);
+    if (override)
+        return override;
+    const content = JSON.stringify(result);
+    return Object.freeze({
+        sourceRef,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+/**
+ * A summary-only receipt is a passive index entry, not a second representation
+ * of the exact evidence body. Only exact evidence (or a canonical override)
+ * can become a semantic-compaction source.
+ */
+function resolveScannableResultSource(result, sourceRefPrefix, overrides, sidecar) {
+    const executionId = readNonEmptyString(result.executionId);
+    if (!executionId)
+        return undefined;
+    if (sidecar && !sidecar.eligibleExecutionIds.includes(executionId))
+        return undefined;
+    const sourceRef = sourceRefPrefix
+        ? `${sourceRefPrefix}:${executionId}`
+        : executionId;
+    if (!overrides.has(executionId) &&
+        !overrides.has(sourceRef) &&
+        !readNonEmptyString(result.referenceData) &&
+        !parseRecord(result.adapterResult)) {
+        return undefined;
+    }
+    return resolveResultSource(result, sourceRefPrefix, overrides);
+}
+function parseRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parsePayloadContextRecord(value) {
+    return value.startsWith(PAYLOAD_CONTEXT_PREFIX)
+        ? parseJsonRecord(value.slice(PAYLOAD_CONTEXT_PREFIX.length))
+        : 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;
+}

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

@@ -3,7 +3,7 @@ import type { SuperWorkerCompactionSidecar } from "./super-worker-compaction-sid
 import type { ChatMessage } from "../../model-gateway/types.js";
 import type { ModelStep } from "../../shared/model-steps.js";
 import type { ModelStepContextCompactionController } from "../model/model-step-port.js";
-import { type SemanticCompactionSource, type SemanticCompactionRequest } from "./semantic-compaction/index.js";
+import { type SemanticCompactionCheckpoint, type SemanticCompactionSource, type SemanticCompactionRequest } from "./semantic-compaction/index.js";
 type ModelStepCompactionOptions = Readonly<{
     call: Readonly<{
         roleId: string;
@@ -16,6 +16,7 @@ type ModelStepCompactionOptions = Readonly<{
     scopeId?: string;
     scopeSuffix?: string;
     resultSourceOverrides?: readonly SemanticCompactionSource[];
+    inheritedCheckpoint?: SemanticCompactionCheckpoint;
     superWorkerCompaction?: SuperWorkerCompactionSidecar;
     requireSuperWorkerSources?: boolean;
     consumer?: ModelStep;