@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/runtime/composition.d.ts

@@ -1,3 +1,5 @@
+import type { PersonalSkillManagementService } from "./knowledge-skills/personal-contracts.js";
+import type { KnowledgeSkillStore } from "./knowledge-skills/store.js";
 import type WebSocket from "ws";
 import type { RuntimeProjectService } from "./projects/contracts.js";
 import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, RuntimeHost, SessionStore, ToolRegistry } from "./ports.js";
@@ -16,6 +18,8 @@ export type RuntimeEnvironmentServices = Readonly<{
     projects?: RuntimeProjectService;
     attachments: RuntimeAttachmentStore;
     tools: ToolRegistry;
+    knowledgeSkillStore?: KnowledgeSkillStore;
+    personalSkills?: PersonalSkillManagementService;
     models: ModelGatewayClient;
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;
@@ -50,6 +54,7 @@ export type RuntimeDependencies = {
     sessions: SessionStore;
     attachments: RuntimeAttachmentStore;
     tools: ToolRegistry;
+    knowledgeSkillStore?: KnowledgeSkillStore;
     models: ModelGatewayClient;
     events: EventSinkFactory;
     sessionMemoryCompactor: SessionMemoryCompactor;

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

@@ -1,3 +1,5 @@
+import { parseModelReasoningBudgetByMode } from "../../shared/model-reasoning-modes.js";
+import { parseModelReasoningBudget } from "../../shared/model-reasoning.js";
 import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
@@ -316,6 +318,8 @@ export function buildModelGenerationConfig(value) {
     if (!isRecord(value)) {
         return undefined;
     }
+    const reasoningBudget = parseModelReasoningBudget(value.reasoningBudget);
+    const reasoningBudgetByMode = parseModelReasoningBudgetByMode(value.reasoningBudgetByMode);
     const temperature = readOptionalNumber(value, "temperature");
     const topP = readOptionalNumber(value, "topP");
     const reasoningEffort = value.reasoningEffort === "none" ||
@@ -330,6 +334,8 @@ export function buildModelGenerationConfig(value) {
         ...(temperature !== undefined ? { temperature } : {}),
         ...(topP !== undefined ? { topP } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
+        ...(reasoningBudget ? { reasoningBudget } : {}),
+        ...(reasoningBudgetByMode ? { reasoningBudgetByMode } : {}),
     };
     return Object.keys(config).length > 0 ? config : undefined;
 }

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

@@ -1,3 +1,5 @@
+import { validateEffectiveReasoningBudgets } from "./model-reasoning-validation.js";
+import { validateLlamaCppProfileCapabilities } from "./llamacpp-profile-validation.js";
 import { validateProfileContextCapacity, } from "./model-context-capacity.js";
 import { RuntimeConfigValidationError } from "./validation.js";
 function hasConfiguredProfile(profiles, profileId) {
@@ -41,6 +43,8 @@ function validateStepTarget(params) {
 export function validateEffectiveRuntimeModelConfig(params) {
     const issues = [];
     const capacityIssues = [];
+    validateEffectiveReasoningBudgets(issues, params.modelPolicy);
+    validateLlamaCppProfileCapabilities(issues, params.modelPolicy);
     const providers = params.modelPolicy?.providers ?? {};
     const profiles = params.modelPolicy?.profiles ?? {};
     const invocationProfiles = params.modelPolicy?.invocationProfiles ?? {};

package/dist/src/runtime/config/llamacpp-profile-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+/** The current adapter is text-only even when the underlying server has a projector. */
+export declare function validateLlamaCppProfileCapabilities(issues: string[], policy?: ModelGatewayPolicyConfig): void;

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

@@ -0,0 +1,15 @@
+function requestsUnsupportedLlamaImageInput(profile, policy) {
+    if (policy.providers?.[profile.provider ?? ""]?.type !== "llamacpp")
+        return false;
+    return profile.capabilities?.inputModalities?.includes("image") === true;
+}
+/** The current adapter is text-only even when the underlying server has a projector. */
+export function validateLlamaCppProfileCapabilities(issues, policy) {
+    if (!policy)
+        return;
+    for (const [id, profile] of Object.entries(policy.profiles ?? {})) {
+        if (!requestsUnsupportedLlamaImageInput(profile, policy))
+            continue;
+        issues.push(`models.profiles.${id}.capabilities.inputModalities: the llamacpp adapter supports text only`);
+    }
+}

package/dist/src/runtime/config/model-reasoning-schema.d.ts

@@ -0,0 +1,40 @@
+export declare const modelReasoningBudgetSchema: {
+    description: string;
+    oneOf: ({
+        type: string;
+        additionalProperties: boolean;
+        required: string[];
+        properties: {
+            mode: {
+                const: string;
+            };
+            tokens: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+    } | {
+        type: string;
+        additionalProperties: boolean;
+        required: string[];
+        properties: {
+            mode: {
+                const: string;
+            };
+            tokens?: undefined;
+        };
+    })[];
+};
+export declare const modelReasoningBudgetByModeSchema: {
+    type: string;
+    description: string;
+    additionalProperties: boolean;
+    properties: {
+        [k: string]: {
+            type: string;
+            minimum: number;
+            maximum: number;
+        };
+    };
+};

package/dist/src/runtime/config/model-reasoning-schema.js

@@ -0,0 +1,38 @@
+import { MAX_REASONING_BUDGET_TOKENS } from "../../shared/model-reasoning.js";
+export const modelReasoningBudgetSchema = {
+    description: "Reasoning-only budget for a declared budget-capable model. Zero disables thinking. Omit to inherit.",
+    oneOf: [
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["mode", "tokens"],
+            properties: {
+                mode: { const: "tokens" },
+                tokens: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: MAX_REASONING_BUDGET_TOKENS,
+                },
+            },
+        },
+        {
+            type: "object",
+            additionalProperties: false,
+            required: ["mode"],
+            properties: { mode: { const: "server-default" } },
+        },
+    ],
+};
+export const modelReasoningBudgetByModeSchema = {
+    type: "object",
+    description: "Optional llama.cpp token budgets for main-step Low/Reasoning/Deep presets. Omit to inherit; {} clears the inherited map. A provided map replaces the whole parent map. Zero disables thinking; positive mode budgets enable it.",
+    additionalProperties: false,
+    properties: Object.fromEntries(["fast", "reasoning", "deep"].map((mode) => [
+        mode,
+        {
+            type: "integer",
+            minimum: 0,
+            maximum: MAX_REASONING_BUDGET_TOKENS,
+        },
+    ])),
+};

package/dist/src/runtime/config/model-reasoning-validation.d.ts

@@ -0,0 +1,3 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+/** Run after configRef materialization, before accepting any Runtime request. */
+export declare function validateEffectiveReasoningBudgets(issues: string[], policy: ModelGatewayPolicyConfig | undefined): void;

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

@@ -0,0 +1,37 @@
+import { supportsModelReasoningBudget } from "../../shared/model-reasoning.js";
+function validateBoundBudget(issues, policy, profile, budget, path) {
+    if (budget === undefined)
+        return;
+    if (!profile)
+        return; // The model-reference owner diagnoses missing targets.
+    const provider = policy.providers?.[profile.provider ?? ""];
+    if (supportsModelReasoningBudget({
+        provider: provider?.type ?? "",
+        supportsThinking: profile.supportsThinking,
+    }))
+        return;
+    issues.push(`${path} requires a llamacpp profile with supportsThinking: true`);
+}
+function validateGenerationBudgets(issues, policy, profile, generation, path) {
+    for (const key of ["reasoningBudget", "reasoningBudgetByMode"]) {
+        validateBoundBudget(issues, policy, profile, generation?.[key], `${path}.${key}`);
+    }
+}
+/** Run after configRef materialization, before accepting any Runtime request. */
+export function validateEffectiveReasoningBudgets(issues, policy) {
+    if (!policy)
+        return;
+    const profiles = policy.profiles ?? {};
+    for (const [id, profile] of Object.entries(profiles)) {
+        validateGenerationBudgets(issues, policy, profile, profile.generation, `models.profiles.${id}.generation`);
+        for (const [slot, calibration] of Object.entries(profile.calibration ?? {})) {
+            const target = calibration.profileId
+                ? profiles[calibration.profileId]
+                : profile;
+            validateGenerationBudgets(issues, policy, target, calibration.generation, `models.profiles.${id}.calibration.${slot}.generation`);
+        }
+    }
+    for (const [id, invocation] of Object.entries(policy.invocationProfiles ?? {})) {
+        validateGenerationBudgets(issues, policy, profiles[invocation.profileId], invocation.generation, `models.invocationProfiles.${id}.generation`);
+    }
+}

package/dist/src/runtime/config/runner/step-instructions.d.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage, ModelTokenEstimationConfig } from "../../../model-gateway/types.js";
 import type { ModelStep } from "../../../shared/model-steps.js";
 import type { RequestRunnerConfig } from "./contracts.js";
+export type ConfiguredStepInstructionPolicy = "omit";
 export type ConfiguredStepInstructionMetadata = Readonly<{
     blockCount: number;
     characterCount: number;
@@ -13,11 +14,13 @@ export type ConfiguredStepInstructionMetadata = Readonly<{
 export declare function resolveConfiguredStepInstructionMetadata(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
 }): ConfiguredStepInstructionMetadata;
 /** Applies configured guidance exactly once at the shared invocation boundary. */
 export declare function projectConfiguredStepMessages(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
     messages: readonly ChatMessage[];
 }): Readonly<{
     messages: ChatMessage[];
@@ -30,5 +33,6 @@ export declare function projectConfiguredStepMessages(params: {
 export declare function estimateConfiguredStepInstructionReserveTokens(params: {
     runnerConfig: RequestRunnerConfig;
     modelStep: ModelStep;
+    configuredInstructionPolicy?: ConfiguredStepInstructionPolicy;
     tokenEstimation?: ModelTokenEstimationConfig;
 }): number;

package/dist/src/runtime/config/runner/step-instructions.js

@@ -1,5 +1,8 @@
 import { estimateTextTokens } from "../../context/token-estimator.js";
 const EMPTY_STRINGS = Object.freeze([]);
+const EMPTY_CONFIGURED_INSTRUCTIONS = Object.freeze({
+    blockCount: 0, characterCount: 0, refs: EMPTY_STRINGS, contentHashes: EMPTY_STRINGS,
+});
 const CONFIGURED_METHODOLOGY_HEADING = "## Configured operating methodology";
 const CONFIGURED_METHODOLOGY_CONTRACT = "The following Markdown is configured guidance for this model step. Apply the shared principles and the section for your active role. It supplements the runtime contract above; it does not change the available actions, roles, capabilities, or output schema.";
 /**
@@ -49,14 +52,12 @@ export function estimateConfiguredStepInstructionReserveTokens(params) {
         : 0;
 }
 function resolveConfiguredStepContent(params) {
+    if (shouldOmitConfiguredStepInstructions(params.configuredInstructionPolicy)) {
+        return EMPTY_CONFIGURED_INSTRUCTIONS;
+    }
     const blocks = params.runnerConfig.steps[params.modelStep]?.instructionBlocks ?? [];
     if (blocks.length === 0) {
-        return Object.freeze({
-            blockCount: 0,
-            characterCount: 0,
-            refs: EMPTY_STRINGS,
-            contentHashes: EMPTY_STRINGS,
-        });
+        return EMPTY_CONFIGURED_INSTRUCTIONS;
     }
     return Object.freeze({
         appendix: [
@@ -70,3 +71,6 @@ function resolveConfiguredStepContent(params) {
         contentHashes: Object.freeze(blocks.map((block) => block.contentHash)),
     });
 }
+function shouldOmitConfiguredStepInstructions(policy) {
+    return policy === "omit";
+}

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

@@ -1,3 +1,4 @@
+import { modelReasoningBudgetByModeSchema, modelReasoningBudgetSchema } from "./model-reasoning-schema.js";
 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";
@@ -80,6 +81,8 @@ function modelGenerationSchema() {
                 type: "number",
                 description: "Nucleus sampling value forwarded to the model provider.",
             },
+            reasoningBudget: modelReasoningBudgetSchema,
+            reasoningBudgetByMode: modelReasoningBudgetByModeSchema,
             reasoningEffort: {
                 type: "string",
                 enum: ["none", "minimal", "low", "medium", "high", "xhigh"],

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

@@ -1,3 +1,5 @@
+import { parseModelReasoningBudgetByMode } from "../../../shared/model-reasoning-modes.js";
+import { parseModelReasoningBudget } from "../../../shared/model-reasoning.js";
 import { hasOwnValue } from "../utils.js";
 import { validateOptionalNonNegativeInteger, validateOptionalNumber, validateOptionalObject, validateOptionalPositiveNumber, } from "./runtime-config-field-validation.js";
 const SUPPORTED_MODEL_REASONING_EFFORTS = new Set([
@@ -53,6 +55,18 @@ export function validateModelContextConfig(issues, context, displayKey) {
     }
 }
 export function validateModelGenerationConfig(issues, generation, displayKey) {
+    try {
+        parseModelReasoningBudget(generation.reasoningBudget);
+    }
+    catch (error) {
+        issues.push(`${displayKey}.reasoningBudget: ${String(error)}`);
+    }
+    try {
+        parseModelReasoningBudgetByMode(generation.reasoningBudgetByMode);
+    }
+    catch (error) {
+        issues.push(`${displayKey}.reasoningBudgetByMode: ${String(error)}`);
+    }
     if (hasOwnValue(generation, "maxOutputTokens")) {
         issues.push(`${displayKey}.maxOutputTokens is not supported; remove it and let the provider enforce physical output capacity`);
     }

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

@@ -1,4 +1,4 @@
-import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RoleCallFrame, 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. */
@@ -7,6 +7,8 @@ export declare function projectCanonicalCapabilityResultCompactionSources(params
     head: RoleCallLedgerHead;
     callId: string;
 }): readonly SemanticCompactionSource[];
+/** SUPER payloads may belong to a Worker or to the canonical Supervisor root. */
+export declare function isCanonicalSuperCapabilitySourceCall(head: RoleCallLedgerHead, call: RoleCallFrame | undefined): call is RoleCallFrame;
 /** 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

@@ -31,12 +31,24 @@ export function projectCanonicalCapabilityResultCompactionSources(params) {
         throw new Error("context_compaction_source_policy_invalid");
     }
     const call = params.head.state.calls.find(({ callId }) => callId === params.callId);
-    if (!call || call.roleId !== "worker")
+    if (!isCanonicalSuperCapabilitySourceCall(params.head, call))
         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))));
 }
+/** SUPER payloads may belong to a Worker or to the canonical Supervisor root. */
+export function isCanonicalSuperCapabilitySourceCall(head, call) {
+    if (!call)
+        return false;
+    if (call.roleId === "worker")
+        return true;
+    if (call.roleId !== "supervisor")
+        return false;
+    if (call.callId !== head.state.rootCallId)
+        return false;
+    return call.parentCallId === null && call.depth === 0;
+}
 /** The existing visible Worker dedup rule also defines canonical source bytes. */
 export function projectSingleCopyCapabilityResult(result) {
     if (!isReferenceDataRepresentedByAdapterResult(result))

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

@@ -4,4 +4,6 @@ type CompactedResultContent = Pick<RequestToolResult, "adapterResult" | "referen
 export declare function projectCompactedCapabilityResultReceipt<Result extends CompactedResultContent>(result: Result): Readonly<Omit<Omit<Result, "adapterResult"> & {
     summary: string;
 }, "referenceData">>;
+/** The caller must verify that the registered output belongs to the covered source. */
+export declare function projectCompactedRegisteredOutputSummary(summary: string, registeredOutput: string | undefined): string;
 export {};

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

@@ -4,19 +4,20 @@ 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,
+        summary: projectCompactedRegisteredOutputSummary(result.summary, result.adapterResult?.kind === "registered_tool_execution_result_v1"
+            ? result.adapterResult.result.output
+            : undefined),
     };
     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;
+/** The caller must verify that the registered output belongs to the covered source. */
+export function projectCompactedRegisteredOutputSummary(summary, registeredOutput) {
+    return summary === registeredOutput
+        ? "Result evidence is available in the verified compacted source."
+        : summary;
 }
 function isReferenceDataCoveredByCompactedResult(result) {
     if (isReferenceDataRepresentedByAdapterResult(result))

package/dist/src/runtime/context/core-skill-read-context.d.ts

@@ -0,0 +1,16 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RoleSkillRead } from "../orchestration/role-calls/skill-read.js";
+import type { KnowledgeSkillDocument } from "../knowledge-skills/store.js";
+import type { RequestContextPinnedPart } from "./request-context-contracts.js";
+export declare const CORE_SKILL_READ_MESSAGE_KIND = "runtime_core_skill_read_v1";
+/** Each captured document keeps identical bytes and identity across consuming roles. */
+export declare function buildCoreSkillReadContextMessage(requestId: string, read: RoleSkillRead, document?: KnowledgeSkillDocument): ChatMessage;
+/** Child roles inherit read guidance; discovery and failed reads remain with the root. */
+export declare function buildCoreSkillReadContextMessages(head?: RoleCallLedgerHead, audience?: "supervisor" | "delegate"): readonly ChatMessage[];
+/** Only the immediately completed lookup is a continuation; older guidance stays reference data. */
+export declare function projectSupervisorSkillReadContext(head?: RoleCallLedgerHead): Readonly<{
+    referenceMessages: readonly ChatMessage[];
+    continuationParts: readonly RequestContextPinnedPart[];
+}>;
+export declare function coreSkillReadSourceRef(readId: string, skillId?: string): string;

package/dist/src/runtime/context/core-skill-read-context.js

@@ -0,0 +1,76 @@
+export const CORE_SKILL_READ_MESSAGE_KIND = "runtime_core_skill_read_v1";
+/** Each captured document keeps identical bytes and identity across consuming roles. */
+export function buildCoreSkillReadContextMessage(requestId, read, document) {
+    const { result: _result, ...receipt } = read;
+    return Object.freeze({
+        role: "user",
+        content: JSON.stringify({
+            kind: CORE_SKILL_READ_MESSAGE_KIND,
+            authority: "passive_reference",
+            source: "core_skills_store",
+            purpose: document ? "skill_guidance" : "skill_discovery_result",
+            presenceEffect: "no_new_intent_permissions_work_or_completion",
+            requestId,
+            ...(document ? { read: receipt, document } : { read }),
+        }),
+    });
+}
+/** Child roles inherit read guidance; discovery and failed reads remain with the root. */
+export function buildCoreSkillReadContextMessages(head, audience = "supervisor") {
+    return Object.freeze(projectReadEntries(head, audience).flatMap(({ messages }) => messages));
+}
+/** Only the immediately completed lookup is a continuation; older guidance stays reference data. */
+export function projectSupervisorSkillReadContext(head) {
+    const entries = projectReadEntries(head, "supervisor");
+    const root = head?.state.calls.find((call) => call.callId === head.state.rootCallId);
+    const lastRead = head?.state.skillReads?.at(-1);
+    const followsSkillRead = root !== undefined && lastRead !== undefined &&
+        head?.state.activeCallId === root.callId && root.status === "active" &&
+        root.activationCount === lastRead.invocationAttempt + 1;
+    const continuation = followsSkillRead
+        ? entries.find(({ read }) => read === lastRead) : undefined;
+    const continuationParts = [];
+    if (continuation) {
+        const { read, messages } = continuation;
+        continuationParts.push(Object.freeze({
+            sourceRef: `core-skill-continuation:${read.readId}`,
+            category: "role_continuation",
+            retention: "exact",
+            messages: Object.freeze([
+                Object.freeze({ role: "assistant", content: JSON.stringify({
+                        decision: { action: read.operation,
+                            ...(read.operation === "read_skills" ? { skillIds: read.selectors } : {}) },
+                    }) }),
+                ...messages,
+            ]),
+        }));
+    }
+    return Object.freeze({
+        referenceMessages: Object.freeze(entries.filter((entry) => entry !== continuation)
+            .flatMap(({ messages }) => messages)),
+        continuationParts: Object.freeze(continuationParts),
+    });
+}
+function projectReadEntries(head, audience) {
+    if (!head)
+        return [];
+    const reads = head.state.skillReads ?? [];
+    const latest = new Map();
+    for (const read of reads) {
+        if (read.operation !== "read_skills" || read.result.outcome !== "completed")
+            continue;
+        for (const skill of read.result.skills)
+            latest.set(skill.skillId, read);
+    }
+    return reads.map((read) => ({
+        read,
+        messages: read.operation === "read_skills" && read.result.outcome === "completed"
+            ? read.result.skills.filter((skill) => latest.get(skill.skillId) === read)
+                .map((skill) => buildCoreSkillReadContextMessage(head.state.requestId, read, skill))
+            : audience === "supervisor"
+                ? [buildCoreSkillReadContextMessage(head.state.requestId, read)] : [],
+    })).filter(({ messages }) => messages.length > 0);
+}
+export function coreSkillReadSourceRef(readId, skillId) {
+    return `core-skill-read:${readId}${skillId === undefined ? "" : `:${skillId}`}`;
+}

package/dist/src/runtime/context/exact-evidence-match.d.ts

@@ -0,0 +1,3 @@
+export type EvidenceValuePath = readonly (string | number)[];
+/** Match complete values only; field names and substrings carry no identity. */
+export declare function findExactEvidencePath(source: unknown, expected: string | readonly unknown[]): EvidenceValuePath | undefined;

package/dist/src/runtime/context/exact-evidence-match.js

@@ -0,0 +1,34 @@
+/** Match complete values only; field names and substrings carry no identity. */
+export function findExactEvidencePath(source, expected) {
+    const expectedArray = Array.isArray(expected)
+        ? JSON.stringify(expected)
+        : undefined;
+    function visit(value, path) {
+        if (isExactEvidenceValue(value, expected, expectedArray))
+            return Object.freeze([...path]);
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const found = visit(value[index], [...path, index]);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        }
+        if (value !== null && typeof value === "object") {
+            for (const [key, child] of Object.entries(value)) {
+                const found = visit(child, [...path, key]);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    return visit(source, []);
+}
+function isExactEvidenceValue(value, expected, expectedArray) {
+    if (typeof expected === "string")
+        return value === expected;
+    if (!Array.isArray(value) || expectedArray === undefined)
+        return false;
+    return JSON.stringify(value) === expectedArray;
+}

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

@@ -21,6 +21,10 @@ type ExecutionEvidenceProjection = Readonly<{
     objective: string;
     callId: string;
     store?: RequestContextCompactionStore;
+    updates?: readonly Readonly<{
+        text: string;
+    }>[];
+    sourceRevision?: number;
     results: readonly ExecutionEvidenceIdentity[];
 }>;
 /** Resolve only source digests; never transfer the root's continuation authority. */

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

@@ -1,15 +1,11 @@
-import { executionCompactionScopeId } from "./execution-compaction-objective.js";
+import { resolveExecutionEvidenceCheckpoint } from "./execution-compaction-checkpoint-selection.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));
+    const checkpoint = resolveExecutionEvidenceCheckpoint(params);
     if (!checkpoint)
         return undefined;
     const digests = new Map(checkpoint.sourceDigests.map((digest) => [digest.sourceRef, digest]));
@@ -33,23 +29,6 @@ export function resolveExecutionCompactedSources(params) {
         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")

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

@@ -0,0 +1,19 @@
+import { type ModelStep } from "../../shared/model-steps.js";
+import { type SemanticCompactionCheckpoint } from "./semantic-compaction/contracts.js";
+import type { RequestContextCompactionStore } from "./semantic-compaction/store.js";
+type ExecutionCheckpointSelection = Readonly<{
+    requestId: string;
+    prompt: string;
+    objective: string;
+    callId: string;
+    store?: RequestContextCompactionStore;
+    updates?: readonly Readonly<{
+        text: string;
+    }>[];
+    scopeSuffix?: string;
+    allowedConsumers?: readonly ModelStep[];
+    sourceRevision?: number;
+}>;
+/** Select immutable evidence; an earlier objective's continuation is not current intent. */
+export declare function resolveExecutionEvidenceCheckpoint(params: ExecutionCheckpointSelection): SemanticCompactionCheckpoint | undefined;
+export {};