@deepstrike/wasm 0.2.68 → 0.2.70

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCano
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
 export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionEventKind, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
+export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
@@ -35,6 +37,8 @@ export type { RankableMemory, RankedMemory, RankOptions } from "./memory/ranking
 export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
 export type { MemoryStore, Memory, MemorySearchOptions, SessionStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryRecallLifecycle, MemoryQuery, MemoryScope, MemoryProvenance, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./memory/index.js";
 export type { KnowledgeSource } from "./knowledge/index.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
+export type { ActivationBinding, ArtifactKind, ArtifactManifest, ArtifactRef, ArtifactSet, ArtifactVersion, ContextEntryRef, ContextEntrySource, ContextExecutionInput, ContextPlan, ContextPlanAction, ContextPreparationRequest, ContextSelection, ContextState, EvaluationContextBinding, EvaluationFact, EvaluationGate, EvaluationMetric, EvaluationRun, EvolutionBundle, EvolutionProposal, EvolutionReport, EvolutionVerdict, PromotionDecision, PromotionOutcome, EvolutionStore, } from "./runtime/evolution.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export type { AttemptBody, AttemptBodyContext, AttemptBodyEvent, AttemptBodyTerminal, AttemptJudge, AttemptLoopEvent, AttemptLoopOptions, AttemptOutcome, AttemptOutcomeKind, AttemptProgressEvent, AttemptRequest, CarryPolicy, JudgeContext, JudgeResult, PreparedAttempt, StopPolicy, VerdictFn, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
@@ -49,6 +53,9 @@ export type { CanonicalStopReason } from "./providers/stop-reason.js";
 export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
 export type { ContentDisposition, ContentPlacement, InputModality } from "./providers/content-policy.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
+export type { ProviderMessage, ToolCall, ToolExecutionResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
 export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";
+export type { ContextPrepareJson, ContextVerifyJson, ContextPrepared, ContextProviderPreparationRequest } from "./runtime/context.js";
+export type { PreparedProviderRequest } from "./types.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, Jour
 // ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
+export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
@@ -21,6 +22,7 @@ export { InMemoryMemoryStore } from "./memory/in-memory-store.js";
 export { memoryRetentionScore } from "./memory/retention.js";
 export { rankMemories } from "./memory/ranking.js";
 export { extractSessionMemories, parseExtractedMemories } from "./memory/extraction.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
 export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJudge, continueSession, freshWithFeedback, freshWithDigest, } from "./harness/index.js";
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
@@ -29,3 +31,4 @@ export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord, tryNor
 export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
 export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,5 @@
-import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderDescriptor, ProviderReplay } from "../types.js";
+import type { PreparedProviderRequest, ProviderRunState } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay } from "../types.js";
 export declare class AnthropicProvider implements LLMProvider {
     private readonly apiKey;
     private readonly model;
@@ -15,9 +16,11 @@ export declare class AnthropicProvider implements LLMProvider {
             baseURL: string;
         };
     };
-    peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
-    seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    peekProviderReplay(message: Pick<ProviderMessage, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<ProviderMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    private streamBody;
     private rememberNativeBlocks;
 }

package/dist/providers/anthropic.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from "./base.js";
 /** Anthropic accepts at most this many cache_control breakpoints per request. */
 const MAX_CACHE_BREAKPOINTS = 4;
@@ -160,7 +161,7 @@ export class AnthropicProvider {
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
-    async *stream(context, tools, extensions, _state, signal) {
+    prepareRequest(context, tools, extensions, state) {
         const strategy = resolveCacheBreakpointStrategy(extensions);
         const emitOnSystemBlocks = strategy === "default" || strategy === "system-only";
         const cc = { type: "ephemeral" };
@@ -198,6 +199,16 @@ export class AnthropicProvider {
         if (extensions?.enable_thinking) {
             body.thinking = { type: "enabled", budget_tokens: 8000 };
         }
+        const frozenBody = requestSnapshot(body);
+        return {
+            scope: "encoded_body", request: requestSnapshot(frozenBody), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamBody(frozenBody, slotBp, signal),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
+    }
+    async *streamBody(body, slotBp, signal) {
         const resp = await fetch("https://api.anthropic.com/v1/messages", {
             method: "POST",
             headers: {

package/dist/providers/base.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext } from "../types.js";
+import type { ProviderMessage, RenderedContext } from "../types.js";
 import { assistantReplayKey } from "../runtime/provider-replay.js";
 export declare class UnsupportedModalityError extends Error {
     readonly modality: string;
@@ -9,16 +9,16 @@ export declare class UnsupportedModalityError extends Error {
  *  (OpenAI), keeping the history a stable cacheable prefix. Anthropic appends it
  *  after the cache breakpoint. Absent on un-rebuilt bindings — then the state is
  *  already inside `turns`. */
-export declare function turnsWithStateAppended(context: RenderedContext): Message[];
+export declare function turnsWithStateAppended(context: RenderedContext): ProviderMessage[];
 /** Build OpenAI-compatible chat messages from a RenderedContext. */
 export declare function toOpenAIMessages(context: RenderedContext): Array<Record<string, unknown>>;
-export declare function toAnthropicMessages(context: RenderedContext, nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
-/** Collect a non-streaming assistant Message from stream events. */
+export declare function toAnthropicMessages(context: RenderedContext, nativeReplay?: (message: ProviderMessage) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+/** Collect a non-streaming assistant ProviderMessage from stream events. */
 export declare function collectStreamMessage(stream: AsyncIterable<{
     type: string;
     delta?: string;
     id?: string;
     name?: string;
     arguments?: Record<string, unknown>;
-}>): Promise<Message>;
+}>): Promise<ProviderMessage>;
 export { assistantReplayKey };

package/dist/providers/base.js

@@ -135,7 +135,7 @@ export function toAnthropicMessages(context, nativeReplay) {
     }
     return result;
 }
-/** Collect a non-streaming assistant Message from stream events. */
+/** Collect a non-streaming assistant ProviderMessage from stream events. */
 export async function collectStreamMessage(stream) {
     let content = "";
     const toolCalls = [];

package/dist/providers/openai.d.ts

@@ -1,4 +1,5 @@
-import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderDescriptor } from "../types.js";
+import type { PreparedProviderRequest, ProviderRunState } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, ProviderMessage, ProviderDescriptor } from "../types.js";
 type OpenAIProviderDialect = "openai" | "qwen" | "deepseek" | "minimax";
 export interface OpenAIProviderOptions {
     apiKey: string;
@@ -41,9 +42,10 @@ export declare class OpenAIProvider implements LLMProvider {
             parameters: any;
         };
     }[];
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
-    protected streamInner(context: RenderedContext, tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean, signal?: AbortSignal): AsyncIterable<StreamEvent>;
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    private streamBody;
+    prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;
+    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
 export declare function qwen(options: BackendProviderOptions): LLMProvider;
 export declare function deepseek(options: BackendProviderOptions): LLMProvider;

package/dist/providers/openai.js

@@ -1,3 +1,4 @@
+import { requestSnapshot } from "./prepared-request.js";
 import { collectStreamMessage, toOpenAIMessages } from "./base.js";
 const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
 const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
@@ -42,14 +43,7 @@ export class OpenAIProvider {
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
-    async *streamInner(context, tools, extraBody, exposeReasoning = false, signal) {
-        const body = {
-            model: this.model,
-            messages: toOpenAIMessages(context),
-            stream: true,
-            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-            ...extraBody,
-        };
+    async *streamBody(body, exposeReasoning = false, signal) {
         const resp = await fetch(`${this.baseUrl}/chat/completions`, {
             method: "POST",
             headers: { "Authorization": `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
@@ -116,28 +110,38 @@ export class OpenAIProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
     }
-    async *stream(context, tools, extensions, _state, signal) {
+    prepareRequest(context, tools, extensions, state) {
+        let requestTools = tools;
+        let extraBody;
+        let exposeReasoning = false;
         if (this.dialect === "qwen") {
             const enableThinking = Boolean(extensions?.enableThinking);
             const thinkingBudget = extensions?.thinkingBudget;
             const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
-            yield* this.streamInner(context, tools, {
-                ...passthrough,
-                ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
-            }, enableThinking, signal);
-            return;
+            extraBody = { ...passthrough, ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}) };
+            exposeReasoning = enableThinking;
         }
-        if (this.dialect === "deepseek" || this.dialect === "minimax") {
-            const exposeReasoning = Boolean(extensions?.exposeReasoning);
-            const isReasoner = this.dialect === "deepseek"
-                ? DEEPSEEK_REASONERS.has(this.model)
-                : MINIMAX_REASONERS.has(this.model);
-            const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
-            yield* this.streamInner(context, isReasoner ? [] : tools, passthrough, exposeReasoning, signal);
-            return;
+        else {
+            const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
+            extraBody = passthrough;
+            if (this.dialect === "deepseek" || this.dialect === "minimax") {
+                exposeReasoning = Boolean(extensions?.exposeReasoning);
+                const isReasoner = this.dialect === "deepseek" ? DEEPSEEK_REASONERS.has(this.model) : MINIMAX_REASONERS.has(this.model);
+                if (isReasoner)
+                    requestTools = [];
+            }
         }
-        const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(context, tools, passthrough, false, signal);
+        const body = requestSnapshot({
+            model: this.model, messages: toOpenAIMessages(context), stream: true,
+            ...(requestTools.length ? { tools: this.buildTools(requestTools) } : {}), ...extraBody,
+        });
+        return {
+            scope: "encoded_body", request: requestSnapshot(body), state: requestSnapshot(state ?? null),
+            stream: signal => this.streamBody(body, exposeReasoning, signal),
+        };
+    }
+    async *stream(context, tools, extensions, state, signal) {
+        yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
     }
 }
 export function qwen(options) {

package/dist/providers/prepared-request.d.ts

@@ -0,0 +1,4 @@
+import type { LLMProvider, PreparedProviderRequest, ProviderRunState, RenderedContext, ToolSchema } from "../types.js";
+/** JSON value snapshots sever aliases to mutable provider replay and continuation state. */
+export declare function requestSnapshot<T>(value: T): T;
+export declare function prepareProviderRequest(provider: LLMProvider, context: RenderedContext, tools: ToolSchema[], options?: Record<string, unknown>, state?: ProviderRunState): PreparedProviderRequest;

package/dist/providers/prepared-request.js

@@ -0,0 +1,78 @@
+import { materialOptions } from "./request-plan.js";
+/** JSON value snapshots sever aliases to mutable provider replay and continuation state. */
+export function requestSnapshot(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+/** A fallback can freeze only JSON state without silently discarding execution semantics. */
+function assertJsonRunState(state) {
+    if (state === undefined)
+        return;
+    const seen = new WeakSet();
+    const reject = (path) => {
+        throw new TypeError(`Custom provider state at ${path} is not losslessly JSON representable; implement prepareRequest() for opaque state`);
+    };
+    const visit = (value, path) => {
+        if (value === null || typeof value === "string" || typeof value === "boolean")
+            return;
+        if (typeof value === "number") {
+            if (!Number.isFinite(value) || Object.is(value, -0))
+                reject(path);
+            return;
+        }
+        if (typeof value !== "object")
+            reject(path);
+        const object = value;
+        if (seen.has(object))
+            reject(path);
+        seen.add(object);
+        const array = Array.isArray(object);
+        if (!array && Object.getPrototypeOf(object) !== Object.prototype && Object.getPrototypeOf(object) !== null)
+            reject(path);
+        if (Object.getOwnPropertySymbols(object).length)
+            reject(path);
+        const descriptors = Object.getOwnPropertyDescriptors(object);
+        if (array) {
+            const values = object;
+            for (let index = 0; index < values.length; index++) {
+                if (!Object.hasOwn(descriptors, String(index)))
+                    reject(`${path}[${index}]`);
+            }
+        }
+        for (const [key, descriptor] of Object.entries(descriptors)) {
+            if (array && key === "length")
+                continue;
+            if (array && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= object.length))
+                reject(`${path}.${key}`);
+            if (!descriptor.enumerable || !("value" in descriptor))
+                reject(`${path}.${key}`);
+            visit(descriptor.value, `${path}.${key}`);
+        }
+    };
+    visit(state, "state");
+}
+export function prepareProviderRequest(provider, context, tools, options, state) {
+    if (provider.prepareRequest)
+        return provider.prepareRequest(context, tools, options, state);
+    assertJsonRunState(state);
+    const input = requestSnapshot({ context, tools, options, state });
+    const replay = context.turns.map(message => provider.peekProviderReplay?.(message) ?? null);
+    const frozenState = input.state;
+    return {
+        scope: "adapter_input",
+        request: requestSnapshot({ context: input.context, tools: input.tools, options: materialOptions(input.options ?? {}), replay }),
+        state: requestSnapshot(frozenState ?? null),
+        ...(provider.countTokens ? { countTokens: () => {
+                const counted = requestSnapshot(input);
+                return provider.countTokens(counted.context, counted.tools, counted.options, counted.state);
+            } } : {}),
+        async *stream(signal) {
+            // Keep the run-state object's identity while restoring the frozen preflight input.
+            if (state && frozenState && typeof state === "object" && typeof frozenState === "object") {
+                for (const key of Object.keys(state))
+                    delete state[key];
+                Object.assign(state, requestSnapshot(frozenState));
+            }
+            yield* provider.stream(input.context, input.tools, input.options, state ?? frozenState, signal);
+        },
+    };
+}

package/dist/providers/request-plan.d.ts

@@ -5,6 +5,11 @@ export interface ProviderRequestEndpoint {
     baseURL: string;
 }
 export interface ProviderRequestPlan {
+    execution?: {
+        scope: "encoded_body" | "adapter_input";
+        request: unknown;
+        state: unknown;
+    };
     providerId: string;
     modelId: string;
     endpoint: ProviderRequestEndpoint;
@@ -38,6 +43,7 @@ export interface ProviderUsage {
 }
 /** P4 §1.3 mirror of the node ResolvedProviderRoute (content-addressed route evidence). */
 export interface ResolvedProviderRoute {
+    request_fingerprint_scope?: "encoded_body" | "adapter_input";
     routeId: string;
     provider: string;
     protocol: ProviderProtocol;
@@ -90,11 +96,12 @@ export declare function createProviderRequestPlanForProvider(provider: {
             baseURL?: string;
         };
     };
-}, context: RenderedContext, tools: ToolSchema[], options?: Record<string, unknown>): ProviderRequestPlan;
+}, context: RenderedContext, tools: ToolSchema[], options?: Record<string, unknown>, execution?: ProviderRequestPlan["execution"]): ProviderRequestPlan;
 export declare function recordPromptMeasurement(plan: Pick<ProviderRequestPlan, "fingerprint">, measurement: Omit<RecordedPromptMeasurement, "requestFingerprint">): RecordedPromptMeasurement;
 export declare function measurementForPlan(plan: Pick<ProviderRequestPlan, "fingerprint">, record: RecordedPromptMeasurement | undefined): RecordedPromptMeasurement | undefined;
 export declare function normalizeProviderUsage(usage: ProviderUsage): NormalizedProviderUsage;
 export declare function priceProviderUsage(usage: NormalizedProviderUsage, snapshot: PricingSnapshot, observedAt?: string | Date): CostObservation;
+export declare function materialOptions(options: Record<string, unknown>): Record<string, unknown>;
 /**
  * P4-S1: assemble the run's route once at runner construction (P4 §0.2 — the provider is
  * fixed for the run today; a future failover resolver re-evaluates per attempt with the same

package/dist/providers/request-plan.js

@@ -9,10 +9,11 @@ export function createProviderRequestPlan(input) {
     const value = {
         providerId: input.providerId, modelId: input.modelId, endpoint: sanitizeEndpoint(input.endpoint),
         context: clone(input.context), tools: clone(input.tools), options: materialOptions(input.options ?? {}),
+        ...(input.execution ? { execution: clone(input.execution) } : {}),
     };
     return { ...value, fingerprint: sha256Hex(stableJson(value)) };
 }
-export function createProviderRequestPlanForProvider(provider, context, tools, options) {
+export function createProviderRequestPlanForProvider(provider, context, tools, options, execution) {
     const descriptor = provider.descriptor?.() ?? { provider: "unknown", protocol: "unknown", model: "unknown" };
     const identity = provider.requestPlanIdentity?.();
     return createProviderRequestPlan({
@@ -23,7 +24,7 @@ export function createProviderRequestPlanForProvider(provider, context, tools, o
             protocol: identity?.endpoint?.protocol ?? descriptor.protocol,
             baseURL: identity?.endpoint?.baseURL ?? "",
         },
-        context, tools, options,
+        context, tools, options, execution,
     });
 }
 export function recordPromptMeasurement(plan, measurement) {
@@ -90,7 +91,7 @@ export function priceProviderUsage(usage, snapshot, observedAt = new Date()) {
         + (usage.reasoningTokens ?? 0) * (rates.reasoning ?? 0)) / 1_000_000;
     return { source: "snapshot", currency: snapshot.currency, amount, pricingVersion: snapshot.version };
 }
-function materialOptions(options) {
+export function materialOptions(options) {
     return sanitizeMaterialValue(options);
 }
 function sanitizeEndpoint(endpoint) {

package/dist/runtime/canonical-kernel-step.d.ts

@@ -1,5 +1,5 @@
 import type { CanonicalKernel as CanonicalKernelInstance, CanonicalRestoreCost } from "@deepstrike/wasm-kernel";
-import type { Message } from "../types.js";
+import type { ProviderMessage } from "../types.js";
 import { type InstalledCheckpoint, type KernelJournal } from "./kernel-journal.js";
 import { type KernelObservation, type KernelRunnerAction } from "./kernel-step.js";
 export declare const MAX_CHAIN_POSITION = 1000000000000;
@@ -37,7 +37,7 @@ export interface CanonicalTransition {
     replayed: boolean;
 }
 export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
-/** Adapt the additive core CurrentProjection JSON into the existing WASM action surface. */
+/** Adapt the core-owned KernelProjection JSON into the WASM action surface. */
 export declare function canonicalActionFromProjectionJson(raw: string): KernelRunnerAction | null;
 export declare class CanonicalKernelRejectedError extends Error {
     readonly fault: Record<string, unknown>;
@@ -85,6 +85,7 @@ export interface CanonicalRunnerRuntimeOptions {
     maxTurns?: number;
     maxTotalTokens?: number;
     maxWallMs?: number;
+    artifactSetDigest?: string;
     memoryBindingId?: string;
     persistPayload?: (callId: string, content: string, previewBytes: number) => Promise<{
         payloadRef: string;
@@ -120,7 +121,7 @@ export declare class CanonicalRunnerRuntime {
     isTerminal(): boolean;
     recoveryContentBytes(): number;
     preservedRefs(): string[];
-    drainNewMessages(): Message[];
+    drainNewMessages(): ProviderMessage[];
     drainHostObservations(): KernelObservationLike[];
     terminal(): Record<string, unknown> | undefined;
     localSubagentsSpawned(): number;

package/dist/runtime/canonical-kernel-step.js

@@ -66,7 +66,7 @@ function canonicalDoneFromTerminal(terminal) {
         termination = asObject(terminal.failure).code === "provider_recovery_exhausted" ? "context_overflow" : "error";
     return { kind: "done", effectId: "", result: { termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal) } };
 }
-/** Adapt the additive core CurrentProjection JSON into the existing WASM action surface. */
+/** Adapt the core-owned KernelProjection JSON into the WASM action surface. */
 export function canonicalActionFromProjectionJson(raw) {
     const projection = asObject(JSON.parse(raw));
     const state = String(projection.state ?? "idle");
@@ -106,6 +106,7 @@ export function canonicalActionFromProjectionJson(raw) {
             kind: "call_provider",
             effectId,
             context: renderedContextToSdk(context),
+            contextEffect: payload,
             tools: (Array.isArray(payload.tools) ? payload.tools : []).map(raw => {
                 const tool = asObject(raw);
                 return {
@@ -664,6 +665,9 @@ export class CanonicalRunnerRuntime {
         this.host = new CanonicalKernelHost(kernel, journal, operationId);
         this.memoryBindingId = options.memoryBindingId ?? "wasm-memory";
         this.config = {
+            ...(options.artifactSetDigest
+                ? { artifact_set_binding: { artifact_set_digest: options.artifactSetDigest } }
+                : {}),
             execution_policy: {
                 max_context_tokens: options.maxContextTokens,
                 ...(options.maxTurns !== undefined ? { max_turns: options.maxTurns } : {}),
@@ -842,12 +846,16 @@ export class CanonicalRunnerRuntime {
             }
             case "tool_results": {
                 const results = [];
+                const measurements = [];
                 for (const value of Array.isArray(event.results) ? event.results : []) {
                     const result = asObject(value);
                     const callId = String(result.call_id ?? "");
                     const output = String(result.output ?? "");
                     const isError = Boolean(result.is_error);
                     const disposition = result.is_fatal ? "fatal" : "recoverable";
+                    if (result.token_count !== null && result.token_count !== undefined) {
+                        measurements.push({ call_id: callId, tokens: Number(result.token_count) });
+                    }
                     const bytes = utf8ByteLength(output);
                     if (bytes > this.payloadInlineThreshold && this.options.persistPayload) {
                         const persisted = await this.options.persistPayload(callId, output, this.payloadPreviewBytes);
@@ -870,15 +878,16 @@ export class CanonicalRunnerRuntime {
                                 output,
                                 ...(isError ? { is_error: true } : {}),
                                 disposition,
-                                ...(result.token_count !== null && result.token_count !== undefined
-                                    ? { tokens: Number(result.token_count) }
-                                    : {}),
                             },
                         });
                     }
                     this.newMessages.push({ role: "tool", content: output, toolCalls: [] });
                 }
-                input = this.succeededEffect(event, { kind: "tools", results });
+                input = this.succeededEffect(event, {
+                    kind: "tools",
+                    results,
+                    ...(measurements.length > 0 ? { measurements } : {}),
+                });
                 break;
             }
             case "approval_result":
@@ -1072,7 +1081,7 @@ export class CanonicalRunnerRuntime {
                 input = { kind: "host_control", command: this.canonicalCapabilityCommand(asObject(event.command)) };
                 break;
             case "add_history_message":
-                throw new Error("running ABI v3 operations accept history only through effects or external events");
+                throw new Error("running ABI operations accept history only through effects or external events");
             default:
                 throw new Error(`WASM host fact has no canonical ABI input: ${String(event.kind)}`);
         }
@@ -1142,7 +1151,7 @@ export class CanonicalRunnerRuntime {
         }
     }
     currentAction() {
-        return canonicalActionFromProjectionJson(this.host.kernel.currentProjectionJson());
+        return canonicalActionFromProjectionJson(this.host.kernel.projectionJson());
     }
     pendingEffects() {
         return JSON.parse(this.host.kernel.pendingEffectsJson());

package/dist/runtime/context.d.ts

@@ -0,0 +1,28 @@
+import type { RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
+import type { ContextExecutionInput, ContextPlan, ContextState, EvaluationContextBinding } from "./evolution.js";
+/** Host evidence completing the kernel's immutable context candidate. */
+export interface ContextProviderPreparationRequest {
+    readonly effect: Record<string, unknown>;
+    readonly request_fingerprint: string;
+    readonly provider_route: ResolvedProviderRoute;
+    readonly prompt_measurement: RecordedPromptMeasurement;
+}
+export interface ContextPrepared {
+    readonly state: ContextState;
+    readonly provider_route: ResolvedProviderRoute;
+    readonly prompt_measurement: RecordedPromptMeasurement;
+    readonly execution_input: ContextExecutionInput;
+    readonly plan: ContextPlan;
+    readonly binding: EvaluationContextBinding;
+}
+export type ContextPrepareJson = (request: string) => string;
+export type ContextVerifyJson = (request: string) => string;
+/** All validation and content addressing are delegated to the Rust authority. */
+export declare function createContextPreparationAdapter(prepareJson: ContextPrepareJson, verifyJson: ContextVerifyJson): {
+    verify(effect: Record<string, unknown>, preparation: ContextPrepared): boolean;
+    prepare(request: ContextProviderPreparationRequest): ContextPrepared;
+};
+export declare function createNativeContextPreparationAdapter(): Promise<{
+    verify(effect: Record<string, unknown>, preparation: ContextPrepared): boolean;
+    prepare(request: ContextProviderPreparationRequest): ContextPrepared;
+}>;

package/dist/runtime/context.js

@@ -0,0 +1,16 @@
+import { getKernel } from "./kernel.js";
+/** All validation and content addressing are delegated to the Rust authority. */
+export function createContextPreparationAdapter(prepareJson, verifyJson) {
+    return {
+        verify(effect, preparation) {
+            return JSON.parse(verifyJson(JSON.stringify({ effect, preparation })));
+        },
+        prepare(request) {
+            return JSON.parse(prepareJson(JSON.stringify(request)));
+        },
+    };
+}
+export async function createNativeContextPreparationAdapter() {
+    const kernel = await getKernel();
+    return createContextPreparationAdapter(kernel.contextPrepareJson, kernel.contextVerifyJson);
+}

package/dist/runtime/eval.d.ts

@@ -7,7 +7,7 @@
  *
  * See node/src/runtime/eval.ts for the full design rationale.
  */
-import type { LLMProvider, Message } from "../types.js";
+import type { LLMProvider, ProviderMessage } from "../types.js";
 export interface Criterion {
     text: string;
     required?: boolean;
@@ -35,7 +35,7 @@ export interface JudgeArgs {
     signal?: AbortSignal;
 }
 /** Build the kernel's eval prompt for (goal, criteria, result). Async — the WASM kernel loads lazily. */
-export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): Promise<Message[]>;
+export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): Promise<ProviderMessage[]>;
 /** Parse a Verdict from raw judge-LLM text. */
 export declare function parseVerdict(text: string): Promise<Verdict>;
 /** The JSON Schema the kernel expects judge output to conform to. */