@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/config/model-execution-policy.d.ts

@@ -1,13 +1,17 @@
+import { type RuntimeModelPluginConfig } from "./model-plugin-config.js";
 export declare const REQUEST_EXECUTION_POLICY_IDS: readonly ["supervisor-worker-v1", "execution-agent-v1"];
 export type RequestExecutionPolicyId = (typeof REQUEST_EXECUTION_POLICY_IDS)[number];
 export declare const DEFAULT_REQUEST_EXECUTION_POLICY_ID: RequestExecutionPolicyId;
 export type RuntimeModelExecutionPolicy = Readonly<{
-    policy: RequestExecutionPolicyId;
+    policy?: RequestExecutionPolicyId;
+    plugins?: RuntimeModelPluginConfig;
 }>;
 export type RuntimeModelExecutionPolicies = Readonly<Record<string, RuntimeModelExecutionPolicy>>;
 export type RequestExecutionPolicySelection = Readonly<{
     policy: RequestExecutionPolicyId;
     primaryProfileId?: string;
+    plugins?: RuntimeModelPluginConfig;
     source: "model_profile" | "default";
 }>;
 export declare function isRequestExecutionPolicyId(value: unknown): value is RequestExecutionPolicyId;
+export declare function buildRuntimeModelExecutionPolicy(source: Record<string, unknown>): RuntimeModelExecutionPolicy | undefined;

package/dist/src/runtime/config/model-execution-policy.js

@@ -1,3 +1,5 @@
+import { buildModelPluginConfig, } from "./model-plugin-config.js";
+import { isRecord } from "./utils.js";
 export const REQUEST_EXECUTION_POLICY_IDS = [
     "supervisor-worker-v1",
     "execution-agent-v1",
@@ -6,3 +8,17 @@ export const DEFAULT_REQUEST_EXECUTION_POLICY_ID = "supervisor-worker-v1";
 export function isRequestExecutionPolicyId(value) {
     return REQUEST_EXECUTION_POLICY_IDS.some((policyId) => policyId === value);
 }
+export function buildRuntimeModelExecutionPolicy(source) {
+    const execution = isRecord(source.execution) ? source.execution : undefined;
+    const configuredPolicy = execution?.policy;
+    const policy = isRequestExecutionPolicyId(configuredPolicy)
+        ? configuredPolicy
+        : undefined;
+    const plugins = buildModelPluginConfig(source.plugins);
+    if (!policy && !plugins)
+        return undefined;
+    return {
+        ...(policy ? { policy } : {}),
+        ...(plugins ? { plugins } : {}),
+    };
+}

package/dist/src/runtime/config/model-plugin-config.d.ts

@@ -0,0 +1,8 @@
+/** Runtime-only restrictions for the canonical request model profile. */
+export type RuntimeModelPluginConfig = Readonly<{
+    deny?: readonly string[];
+}>;
+export declare function captureModelPluginConfig(config: RuntimeModelPluginConfig | undefined): RuntimeModelPluginConfig | undefined;
+export declare function buildModelPluginConfig(value: unknown): RuntimeModelPluginConfig | undefined;
+export declare function validateModelPluginConfig(issues: string[], profile: Record<string, unknown>, displayKey: string): void;
+export declare function modelPluginConfigSchema(): Record<string, unknown>;

package/dist/src/runtime/config/model-plugin-config.js

@@ -0,0 +1,40 @@
+import { readNestedConfigStringArray } from "./utils.js";
+import { validateOptionalObject, validateOptionalStringArray, } from "./validation/runtime-config-field-validation.js";
+export function captureModelPluginConfig(config) {
+    const deny = readNestedConfigStringArray(config, "deny");
+    if (!deny)
+        return undefined;
+    return Object.freeze({ deny: Object.freeze(deny.sort()) });
+}
+export function buildModelPluginConfig(value) {
+    const deny = readNestedConfigStringArray(value, "deny");
+    return captureModelPluginConfig(deny ? { deny } : undefined);
+}
+function isSupportedModelPluginField(key) {
+    return key === "deny";
+}
+export function validateModelPluginConfig(issues, profile, displayKey) {
+    const plugins = validateOptionalObject(issues, profile, "plugins", `${displayKey}.plugins`);
+    if (!plugins)
+        return;
+    for (const key of Object.keys(plugins)) {
+        if (isSupportedModelPluginField(key))
+            continue;
+        issues.push(`${displayKey}.plugins.${key} is not a supported configuration field`);
+    }
+    validateOptionalStringArray(issues, plugins, "deny", `${displayKey}.plugins.deny`);
+}
+export function modelPluginConfigSchema() {
+    return {
+        type: "object",
+        description: "Runtime-only restrictions applied to the entire request selected by this model profile. Global plugin restrictions still apply.",
+        properties: {
+            deny: {
+                type: "array",
+                items: { type: "string" },
+                description: "Denied plugin IDs, capability names, plugin.capability selectors, or *. These restrictions do not depend on per-step model overrides.",
+            },
+        },
+        additionalProperties: false,
+    };
+}

package/dist/src/runtime/config/schema.js

@@ -1,3 +1,4 @@
+import { modelPluginConfigSchema } from "./model-plugin-config.js";
 import { DEFAULT_MEMORY_RECALL_CALL_LIMIT } from "../long-term-memory/recall-policy.js";
 import { PATH_CONFIG_FIELDS, STRING_CONFIG_FIELDS, TIMEOUT_CONFIG_FIELDS, } from "./fields.js";
 import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
@@ -269,6 +270,7 @@ function pluginsSchema() {
                 default: ["*"],
             },
             deny: stringArraySchema("Installed plugin or capability ids denied after applying the allow-list."),
+            disabledPluginIds: stringArraySchema("Exact plugin ids disabled independently of tool selectors. Entries are literal ids, not wildcards."),
         },
         additionalProperties: false,
     };
@@ -310,8 +312,9 @@ export function createRuntimeConfigJsonSchema() {
             },
             webUi: {
                 type: "object",
-                description: "Local Web UI startup behavior.",
+                description: "Local Web UI behavior.",
                 properties: {
+                    pageSize: { type: "integer", minimum: 1, default: 20, description: "Sessions and messages per Web UI history page, including SPARK." },
                     openOnRuntimeServiceStart: {
                         type: "boolean",
                         default: false,
@@ -456,6 +459,7 @@ export function createRuntimeConfigJsonSchema() {
                                 },
                                 generation: modelGenerationSchema(),
                                 context: modelContextSchema(),
+                                plugins: modelPluginConfigSchema(),
                                 execution: {
                                     type: "object",
                                     description: "Runtime-only request execution policy for this model profile. Omission selects supervisor-worker-v1; execution-agent-v1 is an explicit per-profile opt-in. This metadata is not forwarded to the model gateway.",

package/dist/src/runtime/config/validation/model-profile-validation.js

@@ -1,3 +1,4 @@
+import { validateModelPluginConfig } from "../model-plugin-config.js";
 import { isRequestExecutionPolicyId, REQUEST_EXECUTION_POLICY_IDS, } from "../model-execution-policy.js";
 import { hasOwnValue, isRecord } from "../utils.js";
 import { validateModelContextConfig, validateModelGenerationConfig, } from "./model-invocation-config-validation.js";
@@ -79,6 +80,7 @@ export function validateModelProfileConfig(issues, profile, displayKey, options
     if (context) {
         validateModelContextConfig(issues, context, `${displayKey}.context`);
     }
+    validateModelPluginConfig(issues, profile, displayKey);
     const execution = validateOptionalObject(issues, profile, "execution", `${displayKey}.execution`);
     if (execution) {
         validateModelExecutionPolicy(issues, execution, `${displayKey}.execution`);

package/dist/src/runtime/config/validation/runtime-config-validation-contract.d.ts

@@ -1,9 +1,11 @@
+import type { ModelContextCapacityIssue } from "../model-context-capacity.js";
 export type RuntimeConfigValidationOptions = Readonly<{
     /** Inspection-only mode. Canonical runtime loading always omits this flag. */
     allowIncompleteSetup?: boolean;
 }>;
 export declare class RuntimeConfigValidationError extends Error {
+    readonly capacityIssues: readonly ModelContextCapacityIssue[];
     readonly configPath: string;
     readonly issues: string[];
-    constructor(configPath: string, issues: string[]);
+    constructor(configPath: string, issues: string[], capacityIssues?: readonly ModelContextCapacityIssue[]);
 }

package/dist/src/runtime/config/validation/runtime-config-validation-contract.js

@@ -1,11 +1,13 @@
 export class RuntimeConfigValidationError extends Error {
+    capacityIssues;
     configPath;
     issues;
-    constructor(configPath, issues) {
+    constructor(configPath, issues, capacityIssues = []) {
         super([
             `Invalid runtime config at ${configPath}:`,
             ...issues.map((issue) => `- ${issue}`),
         ].join("\n"));
+        this.capacityIssues = capacityIssues;
         this.name = "RuntimeConfigValidationError";
         this.configPath = configPath;
         this.issues = issues;

package/dist/src/runtime/config/validation/runtime-root-section-validation.js

@@ -15,11 +15,18 @@ export function validatePluginConfig(issues, plugins) {
     validateOptionalBoolean(issues, plugins, "enabled", "plugins.enabled");
     validateOptionalStringArray(issues, plugins, "allow", "plugins.allow");
     validateOptionalStringArray(issues, plugins, "deny", "plugins.deny");
+    validateOptionalStringArray(issues, plugins, "disabledPluginIds", "plugins.disabledPluginIds");
+    const supportedPluginFields = [
+        "enabled",
+        "allow",
+        "deny",
+        "disabledPluginIds",
+    ];
     for (const key of Object.keys(plugins)) {
-        const isUnsupportedPluginField = key !== "enabled" && key !== "allow" && key !== "deny";
-        if (isUnsupportedPluginField) {
-            issues.push(`plugins.${key} is not a supported configuration field`);
-        }
+        const isSupportedPluginField = supportedPluginFields.includes(key);
+        if (isSupportedPluginField)
+            continue;
+        issues.push(`plugins.${key} is not a supported configuration field`);
     }
 }
 function hasInvalidRuntimeTimeout(value) {

package/dist/src/runtime/config/validation/web-ui-config-validation.js

@@ -1,10 +1,11 @@
-import { validateOptionalBoolean, validateOptionalObject, } from "./runtime-config-field-validation.js";
+import { validateOptionalBoolean, validateOptionalPositiveInteger, validateOptionalObject, } from "./runtime-config-field-validation.js";
 import { RuntimeConfigValidationError } from "./runtime-config-validation-contract.js";
 function isUnsupportedWebUiField(key) {
-    return key !== "openOnRuntimeServiceStart";
+    return !["openOnRuntimeServiceStart", "pageSize"].includes(key);
 }
 function validateWebUiConfig(issues, webUi) {
     validateOptionalBoolean(issues, webUi, "openOnRuntimeServiceStart", "webUi.openOnRuntimeServiceStart");
+    validateOptionalPositiveInteger(issues, webUi, "pageSize", "webUi.pageSize");
     for (const key of Object.keys(webUi)) {
         if (isUnsupportedWebUiField(key)) {
             issues.push(`webUi.${key} is not a supported configuration field`);

package/dist/src/runtime/config/web-ui.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeConfigFile } from "./types.js";
+export declare const DEFAULT_WEB_UI_PAGE_SIZE = 20;
+export declare function buildWebUiConfig(config: RuntimeConfigFile): {
+    pageSize: number;
+};

package/dist/src/runtime/config/web-ui.js

@@ -0,0 +1,5 @@
+export const DEFAULT_WEB_UI_PAGE_SIZE = 20;
+export function buildWebUiConfig(config) {
+    const webUi = config.webUi;
+    return { pageSize: webUi?.pageSize ?? DEFAULT_WEB_UI_PAGE_SIZE };
+}

package/dist/src/runtime/config.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { buildWebUiConfig } from "./config/web-ui.js";
 import { DEFAULT_RUNTIME_ID, DEFAULT_MODEL_GATEWAY_URL, } from "../shared/constants.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
 import { buildFeatureFlags, buildLoggingConfig, buildRuntimeModelConfiguration, buildPluginConfig, compactTimeouts, } from "./config/builders.js";
@@ -155,6 +156,7 @@ export function loadRuntimeConfig(options = {}) {
             compiledDir,
             traceFile,
         },
+        webUi: buildWebUiConfig(fileConfig),
         logging: loggingConfig,
         ...(timeouts ? { timeouts } : {}),
         ...(pluginConfig ? { plugins: pluginConfig } : {}),

package/dist/src/runtime/context/canonical-capability-result.d.ts

@@ -0,0 +1,4 @@
+import { type RoleCallLedgerHead, type RoleCapabilityExecution } from "../orchestration/role-calls/index.js";
+import type { RequestToolResult } from "./request-tool-results.js";
+/** Exact validated ledger evidence, before consumer filtering or supersession. */
+export declare function projectCanonicalRequestToolResult(head: RoleCallLedgerHead, execution: RoleCapabilityExecution): RequestToolResult;

package/dist/src/runtime/context/canonical-capability-result.js

@@ -0,0 +1,80 @@
+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 { normalizeCapabilityAdapterResult } from "../orchestration/capability-adapters/result.js";
+import { projectAcceptedCapabilityAction } from "./accepted-capability-action.js";
+/** Exact validated ledger evidence, before consumer filtering or supersession. */
+export function projectCanonicalRequestToolResult(head, execution) {
+    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");
+    }
+    return 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(head, execution),
+            }
+            : {}),
+        adapterResult: exactResult.value,
+    });
+}
+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));
+}

package/dist/src/runtime/context/capability-brief-readmission.js

@@ -4,9 +4,6 @@ import { resolveCapabilityBriefMessageHeadroom } from "./capability-brief-budget
 export function createCapabilityBriefReadmissionController(params) {
     const { controller } = params;
     return Object.freeze({
-        get compactionScope() {
-            return controller.compactionScope;
-        },
         project(messages) {
             const projected = controller.project(messages);
             const briefIndex = projected.findIndex(isCapabilityBriefMessage);
@@ -40,8 +37,8 @@ export function createCapabilityBriefReadmissionController(params) {
                 ...projected.slice(briefIndex + 1),
             ];
         },
-        prepare(messages) {
-            return controller.prepare(messages);
+        getStages() {
+            return controller.getStages();
         },
     });
 }

package/dist/src/runtime/context/capability-result-compaction-source.d.ts

@@ -0,0 +1,12 @@
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestToolResult } from "./request-tool-results.js";
+import { type SemanticCompactionSource } from "./semantic-compaction/contracts.js";
+/** Capture full immutable bytes once, independently of the evidence consumer. */
+export declare function createCapabilityResultCompactionSource(result: RequestToolResult): SemanticCompactionSource;
+export declare function projectCanonicalCapabilityResultCompactionSources(params: {
+    head: RoleCallLedgerHead;
+    callId: string;
+}): readonly SemanticCompactionSource[];
+/** The existing visible Worker dedup rule also defines canonical source bytes. */
+export declare function projectSingleCopyCapabilityResult(result: RequestToolResult): RequestToolResult;
+export declare function isReferenceDataRepresentedByAdapterResult(result: Pick<RequestToolResult, "referenceData" | "adapterResult">): boolean;

package/dist/src/runtime/context/capability-result-compaction-source.js

@@ -0,0 +1,61 @@
+import { projectCanonicalRequestToolResult } from "./canonical-capability-result.js";
+import { hasSuperContextContract } from "./super-context-policy.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+/** Capture full immutable bytes once, independently of the evidence consumer. */
+export function createCapabilityResultCompactionSource(result) {
+    if (!result.adapterResult)
+        throw new Error("context_compaction_source_adapter_required");
+    const exact = projectSingleCopyCapabilityResult(result);
+    const content = JSON.stringify({
+        executionId: exact.executionId,
+        callId: exact.callId,
+        invocationAttempt: exact.invocationAttempt,
+        capabilityId: exact.capabilityId,
+        declaredEffect: exact.declaredEffect,
+        outcome: exact.outcome,
+        observedEffect: exact.observedEffect,
+        summary: exact.summary,
+        ...(exact.referenceData ? { referenceData: exact.referenceData } : {}),
+        ...(exact.references ? { references: exact.references } : {}),
+        ...(exact.acceptedAction ? { acceptedAction: exact.acceptedAction } : {}),
+        adapterResult: exact.adapterResult,
+    });
+    return Object.freeze({
+        sourceRef: result.executionId,
+        sourceFingerprint: createSemanticCompactionSha256Fingerprint(content),
+        content,
+    });
+}
+export function projectCanonicalCapabilityResultCompactionSources(params) {
+    if (!hasSuperContextContract(params.head.policy.authority, "delegated.worker")) {
+        throw new Error("context_compaction_source_policy_invalid");
+    }
+    const call = params.head.state.calls.find(({ callId }) => callId === params.callId);
+    if (!call || call.roleId !== "worker")
+        throw new Error("context_compaction_source_call_invalid");
+    return Object.freeze(params.head.state.capabilityExecutions
+        .filter((execution) => execution.callId === call.callId && execution.status === "settled")
+        .map((execution) => createCapabilityResultCompactionSource(projectCanonicalRequestToolResult(params.head, execution))));
+}
+/** The existing visible Worker dedup rule also defines canonical source bytes. */
+export function projectSingleCopyCapabilityResult(result) {
+    if (!isReferenceDataRepresentedByAdapterResult(result))
+        return result;
+    const { referenceData: _referenceData, ...singleCopyResult } = result;
+    return Object.freeze(singleCopyResult);
+}
+export 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")
+        return false;
+    const payload = adapterResult.payload;
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload))
+        return false;
+    return payload.referenceData === referenceData;
+}

package/dist/src/runtime/context/compacted-capability-result-receipt.d.ts

@@ -0,0 +1,7 @@
+import type { RequestToolResult } from "./request-tool-results.js";
+type CompactedResultContent = Pick<RequestToolResult, "adapterResult" | "referenceData" | "summary">;
+/** Call only after exact source verification; independent supplements remain raw. */
+export declare function projectCompactedCapabilityResultReceipt<Result extends CompactedResultContent>(result: Result): Readonly<Omit<Omit<Result, "adapterResult"> & {
+    summary: string;
+}, "referenceData">>;
+export {};

package/dist/src/runtime/context/compacted-capability-result-receipt.js

@@ -0,0 +1,29 @@
+import { isReferenceDataRepresentedByAdapterResult } from "./capability-result-compaction-source.js";
+/** Call only after exact source verification; independent supplements remain raw. */
+export function projectCompactedCapabilityResultReceipt(result) {
+    const { adapterResult: _adapterResult, ...metadata } = result;
+    const receipt = {
+        ...metadata,
+        summary: isSummaryCoveredByCompactedResult(result)
+            ? "Result evidence is available in the verified compacted source."
+            : result.summary,
+    };
+    if (!isReferenceDataCoveredByCompactedResult(result))
+        return Object.freeze(receipt);
+    const { referenceData: _referenceData, ...coveredReceipt } = receipt;
+    return Object.freeze(coveredReceipt);
+}
+function isSummaryCoveredByCompactedResult(result) {
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return result.summary === result.adapterResult.result.output;
+}
+function isReferenceDataCoveredByCompactedResult(result) {
+    if (isReferenceDataRepresentedByAdapterResult(result))
+        return true;
+    if (!result.referenceData)
+        return false;
+    if (result.adapterResult?.kind !== "registered_tool_execution_result_v1")
+        return false;
+    return (result.referenceData === result.adapterResult.result.data?.mutationGrounding);
+}

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

@@ -0,0 +1,6 @@
+/** Keeps the bounded identity of rejected evidence, never its content. */
+export declare class CompactionSourceInvariantError extends Error {
+    readonly code: string;
+    readonly sourceRef: string | undefined;
+    constructor(code: string, sourceRef?: string);
+}

package/dist/src/runtime/context/compaction-source-invariant.js

@@ -0,0 +1,12 @@
+/** Keeps the bounded identity of rejected evidence, never its content. */
+export class CompactionSourceInvariantError extends Error {
+    code;
+    sourceRef;
+    constructor(code, sourceRef) {
+        super(code);
+        this.code = code;
+        this.name = "CompactionSourceInvariantError";
+        this.sourceRef =
+            sourceRef && sourceRef.length <= 256 ? sourceRef : undefined;
+    }
+}

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

@@ -0,0 +1,29 @@
+import { type SemanticCompactionDigest } from "./semantic-compaction/contracts.js";
+import type { RequestContextCompactionStore } from "./semantic-compaction/store.js";
+type ExecutionEvidenceIdentity = Readonly<{
+    executionId: string;
+    callId: string;
+    invocationAttempt: number;
+    capabilityId: string;
+    adapterResult: unknown;
+}>;
+export type ExecutionCompactedSource = SemanticCompactionDigest & Readonly<{
+    executionId: string;
+}>;
+export type ExecutionCompactedSources = Readonly<{
+    scopeId: string;
+    sourceRevision: number;
+    sources: readonly ExecutionCompactedSource[];
+}>;
+type ExecutionEvidenceProjection = Readonly<{
+    requestId: string;
+    prompt: string;
+    objective: string;
+    callId: string;
+    store?: RequestContextCompactionStore;
+    results: readonly ExecutionEvidenceIdentity[];
+}>;
+/** Resolve only source digests; never transfer the root's continuation authority. */
+export declare function resolveExecutionCompactedSources(params: ExecutionEvidenceProjection): ExecutionCompactedSources | undefined;
+export declare function matchesCompactedExecutionResult(content: string, result: ExecutionEvidenceIdentity): boolean;
+export {};

package/dist/src/runtime/context/execution-compacted-evidence.js

@@ -0,0 +1,87 @@
+import { executionCompactionScopeId } from "./execution-compaction-objective.js";
+import { isDeepStrictEqual } from "node:util";
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { createSemanticCompactionSha256Fingerprint, } from "./semantic-compaction/contracts.js";
+/** Resolve only source digests; never transfer the root's continuation authority. */
+export function resolveExecutionCompactedSources(params) {
+    const store = params.store;
+    if (!store)
+        return undefined;
+    const checkpoint = store
+        .findByCallIds([params.callId])
+        .find((candidate) => canReuseExecutionCheckpoint(candidate, params));
+    if (!checkpoint)
+        return undefined;
+    const digests = new Map(checkpoint.sourceDigests.map((digest) => [digest.sourceRef, digest]));
+    const sources = [];
+    for (const result of params.results) {
+        const digest = digests.get(`tool-result:${result.executionId}`);
+        if (!digest)
+            continue;
+        if (result.callId !== checkpoint.callId)
+            continue;
+        const source = store.materializeSource(digest.sourceRef, digest.sourceFingerprint);
+        if (!source || !matchesCompactedExecutionResult(source.content, result))
+            continue;
+        sources.push(Object.freeze({ ...digest, executionId: result.executionId }));
+    }
+    if (sources.length === 0)
+        return undefined;
+    return Object.freeze({
+        scopeId: checkpoint.scopeId,
+        sourceRevision: checkpoint.sourceRevision,
+        sources: Object.freeze(sources),
+    });
+}
+function canReuseExecutionCheckpoint(checkpoint, params) {
+    if (checkpoint.requestId !== params.requestId)
+        return false;
+    if (checkpoint.callId !== params.callId)
+        return false;
+    if (checkpoint.roleId !== "supervisor")
+        return false;
+    if (checkpoint.scopeId !== executionCompactionScopeId(params))
+        return false;
+    if (checkpoint.currentRequestFingerprint !==
+        createSemanticCompactionSha256Fingerprint(params.prompt))
+        return false;
+    if (checkpoint.objectiveFingerprint !==
+        createSemanticCompactionSha256Fingerprint(params.objective))
+        return false;
+    return checkpoint.allowedConsumers.includes(MODEL_STEPS.EXECUTION_DECISION);
+}
+export function matchesCompactedExecutionResult(content, result) {
+    const message = readCompactionRecord(content);
+    if (message?.role !== "tool")
+        return false;
+    if (message.toolCallId !== result.executionId)
+        return false;
+    if (message.attachments !== undefined)
+        return false;
+    const envelope = readCompactionRecord(message.content);
+    if (envelope?.kind !== "runtime_execution_capability_result_v1")
+        return false;
+    if (envelope.invocationAttempt !== result.invocationAttempt)
+        return false;
+    const covered = compactionRecord(envelope.result);
+    if (covered?.executionId !== result.executionId)
+        return false;
+    if (covered.capabilityId !== result.capabilityId)
+        return false;
+    return isDeepStrictEqual(covered.adapterResult, result.adapterResult);
+}
+function readCompactionRecord(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return compactionRecord(JSON.parse(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function compactionRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}

package/dist/src/runtime/context/execution-compaction-objective.d.ts

@@ -0,0 +1,11 @@
+/** One accepted request objective shared by EA and its evidence consumers. */
+export declare function projectExecutionCompactionObjective(prompt: string, updates: readonly Readonly<{
+    text: string;
+}>[]): string;
+/** A changed objective gets a fresh lane; prior checkpoints retain their binding. */
+export declare function executionCompactionScopeId(params: Readonly<{
+    callId: string;
+    prompt: string;
+    objective: string;
+    scopeSuffix?: string;
+}>): string;

package/dist/src/runtime/context/execution-compaction-objective.js

@@ -0,0 +1,12 @@
+import { createSemanticCompactionSha256Fingerprint } from "./semantic-compaction/contracts.js";
+/** One accepted request objective shared by EA and its evidence consumers. */
+export function projectExecutionCompactionObjective(prompt, updates) {
+    return [prompt, ...updates.map(({ text }) => text)].join("\n");
+}
+/** A changed objective gets a fresh lane; prior checkpoints retain their binding. */
+export function executionCompactionScopeId(params) {
+    const scope = `role:supervisor:${params.callId}:${params.scopeSuffix ?? "continuation"}`;
+    if (params.objective === params.prompt)
+        return scope;
+    return `${scope}:objective:${createSemanticCompactionSha256Fingerprint(params.objective)}`;
+}