@deepstrike/sdk 0.2.69 → 0.2.70

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/protocol-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
+import type { ProviderMessage, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import type { GenerationProtocol, ProtocolRuntimeCapabilities } from "./protocol-capabilities.js";
 export { GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
@@ -19,7 +19,7 @@ export interface ProtocolAdapter<TRequest, TCompleteResponse, TStreamChunk, TStr
     readonly protocolCapabilities: ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): TRequest;
     decodeComplete(raw: TCompleteResponse, input: AdapterDecodeInput): {
-        message: Message;
+        message: ProviderMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): TStreamState;

package/dist/providers/replay-validator.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
+import type { ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
 export type { ReplayabilityAssessment };
 export declare class ProviderReplayValidationError extends Error {
     constructor(message: string);
@@ -20,7 +20,7 @@ export interface OpenAIChatReplayValidationOptions {
      * rather than fail outright.
      */
     degradeMissingReasoning?: boolean;
-    replayForAssistant?: (message: Pick<Message, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
+    replayForAssistant?: (message: Pick<ProviderMessage, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
 }
 export declare function validateOpenAIChatReplay(context: RenderedContext, options?: OpenAIChatReplayValidationOptions): void;
 /**
@@ -29,4 +29,4 @@ export declare function validateOpenAIChatReplay(context: RenderedContext, optio
  * embedder decide per-candidate whether to keep thinking on, disable it, or
  * skip the candidate — before sending.
  */
-export declare function assessReasoningReplay(turns: Message[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;
+export declare function assessReasoningReplay(turns: ProviderMessage[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;

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

@@ -7,6 +7,11 @@ export interface ProviderRequestEndpoint {
 }
 /** One provider-visible request, deliberately excluding credentials and transport-only retries. */
 export interface ProviderRequestPlan {
+    execution?: {
+        scope: "encoded_body" | "adapter_input";
+        request: unknown;
+        state: unknown;
+    };
     providerId: string;
     modelId: string;
     endpoint: ProviderRequestEndpoint;
@@ -79,7 +84,7 @@ 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;
 /**
  * P4 §1.3: the resolved route one provider execution is pinned to. Content-addressed
  * (`routeId` = stable hash of every field except `capabilitiesRef`); the capability table's
@@ -87,6 +92,7 @@ export declare function createProviderRequestPlanForProvider(provider: {
  * never a copy.
  */
 export interface ResolvedProviderRoute {
+    request_fingerprint_scope?: "encoded_body" | "adapter_input";
     routeId: string;
     provider: string;
     protocol: GenerationProtocol;
@@ -127,3 +133,4 @@ export declare function measurementForPlan(plan: Pick<ProviderRequestPlan, "fing
 export declare function normalizeProviderUsage(usage: ProviderUsage): NormalizedProviderUsage;
 /** Cost is derived only from an explicit, time-valid host snapshot; otherwise it stays unknown. */
 export declare function priceProviderUsage(usage: NormalizedProviderUsage, snapshot: PricingSnapshot, observedAt?: string | Date): CostObservation;
+export declare function materialOptions(options: Record<string, unknown>): Record<string, unknown>;

package/dist/providers/request-plan.js

@@ -13,6 +13,7 @@ export function createProviderRequestPlan(input) {
         context: clone(input.context),
         tools: clone(input.tools),
         options,
+        ...(input.execution ? { execution: clone(input.execution) } : {}),
     };
     const stablePrefix = {
         providerId: plan.providerId,
@@ -29,7 +30,7 @@ export function createProviderRequestPlan(input) {
     };
 }
 /** Build the plan from a resolved provider when the runner only has the public provider object. */
-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({
@@ -42,7 +43,7 @@ export function createProviderRequestPlanForProvider(provider, context, tools, o
         },
         context,
         tools,
-        options,
+        options, execution,
     });
 }
 const KNOWN_GENERATION_PROTOCOLS = new Set([
@@ -184,7 +185,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/archive.d.ts

@@ -1,15 +1,15 @@
-import type { Message } from "../types.js";
+import type { ProviderMessage } from "../types.js";
 export interface ArchiveStore {
-    write(sessionId: string, seq: number, messages: Message[]): Promise<string>;
-    read(archiveRef: string): Promise<Message[]>;
+    write(sessionId: string, seq: number, messages: ProviderMessage[]): Promise<string>;
+    read(archiveRef: string): Promise<ProviderMessage[]>;
 }
 export declare class NullArchiveStore implements ArchiveStore {
-    write(_sessionId: string, _seq: number, _messages: Message[]): Promise<string>;
-    read(_archiveRef: string): Promise<Message[]>;
+    write(_sessionId: string, _seq: number, _messages: ProviderMessage[]): Promise<string>;
+    read(_archiveRef: string): Promise<ProviderMessage[]>;
 }
 export declare class FileArchiveStore implements ArchiveStore {
     private readonly root;
     constructor(root: string);
-    write(sessionId: string, seq: number, messages: Message[]): Promise<string>;
-    read(archiveRef: string): Promise<Message[]>;
+    write(sessionId: string, seq: number, messages: ProviderMessage[]): Promise<string>;
+    read(archiveRef: string): Promise<ProviderMessage[]>;
 }

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

@@ -1,5 +1,5 @@
 import type { CanonicalKernelInstance, CanonicalRestoreCost } from "../kernel.js";
-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 Node action surface. */
+/** Adapt the core-owned KernelProjection JSON into the Node 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;
@@ -119,7 +120,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

@@ -40,7 +40,7 @@ export function canonicalUnsupportedEffectResolution(effectId, effectKind) {
         },
     };
 }
-/** The only ABI-v3 planned-step → Node host-action projection. */
+/** The only ABI planned-step → Node host-action projection. */
 function canonicalDoneFromTerminal(terminal) {
     const usage = asObject(terminal.usage);
     let termination = String(terminal.kind ?? "failed");
@@ -80,7 +80,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 Node action surface. */
+/** Adapt the core-owned KernelProjection JSON into the Node action surface. */
 export function canonicalActionFromProjectionJson(raw) {
     const projection = asObject(JSON.parse(raw));
     const state = String(projection.state ?? "idle");
@@ -120,6 +120,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 {
@@ -682,6 +683,9 @@ export class CanonicalRunnerRuntime {
         this.host = new CanonicalKernelHost(kernel, journal, operationId);
         this.memoryBindingId = options.memoryBindingId ?? "node-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 } : {}),
@@ -856,12 +860,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 = Buffer.byteLength(output, "utf8");
                     if (bytes > this.payloadInlineThreshold && this.options.persistPayload) {
                         const persisted = await this.options.persistPayload(callId, output, this.payloadPreviewBytes);
@@ -884,15 +892,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":
@@ -1086,7 +1095,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(`Node host fact has no canonical ABI input: ${String(event.kind)}`);
         }
@@ -1156,7 +1165,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(): {
+    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 function createNativeContextPreparationAdapter() {
+    const kernel = getKernel();
+    return createContextPreparationAdapter(kernel.contextPrepareJson, kernel.contextVerifyJson);
+}

package/dist/runtime/eval.d.ts

@@ -9,7 +9,7 @@
  * The judge is a single LLM call: build the eval prompt → stream → parse verdict. No retry loop,
  * no skill extraction, no loop state. Use `AttemptLoop` if you want the retry/refine flow.
  */
-import type { LLMProvider, Message } from "../types.js";
+import type { LLMProvider, ProviderMessage } from "../types.js";
 export interface Criterion {
     /** The criterion text the judge evaluates against. */
     text: string;
@@ -52,7 +52,7 @@ export interface JudgeArgs {
  * Exposed in case a caller wants to render the prompt without calling the LLM (e.g., dry-run cost
  * estimation, fixture generation). For the common case, use `judge()`.
  */
-export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): Message[];
+export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): ProviderMessage[];
 /** Parse a Verdict from raw judge-LLM text. Throws on schema mismatch. */
 export declare function parseVerdict(text: string): Verdict;
 /** The JSON Schema the kernel expects judge output to conform to. */

package/dist/runtime/evolution.d.ts

@@ -0,0 +1,195 @@
+/** Canonical artifact kinds accepted by the 0.2.70 Evolution Runtime. */
+export type ArtifactKind = "runtime" | "skill" | "prompt" | "policy" | "toolset" | "bundle";
+export interface ArtifactRef {
+    readonly kind: ArtifactKind;
+    readonly digest: string;
+}
+export interface ArtifactManifest {
+    readonly kind: ArtifactKind;
+    readonly payload_digest: string;
+    readonly parents: readonly string[];
+    readonly toolchain_digest: string;
+    readonly scope: string;
+}
+export interface ArtifactVersion {
+    readonly digest: string;
+    readonly manifest: ArtifactManifest;
+}
+export interface ArtifactSet {
+    readonly digest: string;
+    readonly artifacts: readonly ArtifactRef[];
+}
+export interface EvolutionProposal {
+    readonly digest: string;
+    readonly base_artifact_set: string;
+    readonly candidate_artifact_set: string;
+    readonly objective: string;
+    readonly change_manifest: string;
+    readonly proposer: string;
+    readonly constraints: readonly string[];
+}
+export interface EvaluationContextBinding {
+    readonly digest: string;
+    readonly operation_id: string;
+    readonly execution_input: string;
+    readonly context_state: string;
+    readonly context_policy: string;
+    readonly context_plan: string;
+    readonly rendered_snapshot: string;
+    readonly prompt_measurement: string;
+    readonly provider_route: string;
+    readonly cache_prefix?: string;
+}
+export type ContextEntrySource = "system" | "knowledge" | "history" | "state" | "signal";
+export type ContextPlanAction = "include" | "excerpt" | "collapse" | "page_out" | "omit";
+export interface ContextEntryRef {
+    readonly entry_id: string;
+    readonly content_digest: string;
+    readonly source: ContextEntrySource;
+    readonly ordinal: number;
+}
+export interface ContextState {
+    readonly schema: "context/v1";
+    readonly generation: number;
+    readonly system: readonly ContextEntryRef[];
+    readonly knowledge: readonly ContextEntryRef[];
+    readonly history: readonly ContextEntryRef[];
+    readonly state: readonly ContextEntryRef[];
+    readonly task_state: string;
+    readonly signals: readonly string[];
+    readonly digest: string;
+}
+export interface ContextSelection {
+    readonly entry_id: string;
+    readonly action: ContextPlanAction;
+    readonly reason: string;
+}
+export interface ContextPlan {
+    readonly schema: "context/v1";
+    readonly plan_id: string;
+    readonly operation_id: string;
+    readonly step_id: string;
+    readonly state_digest: string;
+    readonly state_generation: number;
+    readonly runtime_inputs: string;
+    readonly policy_digest: string;
+    readonly provider_profile_digest: string;
+    readonly measurement_fingerprints: readonly string[];
+    readonly selections: readonly ContextSelection[];
+    readonly input_budget_tokens: number;
+    readonly projected_tokens: number;
+    readonly pressure_ppm: number;
+    readonly cache_prefix: {
+        readonly digest: string;
+        readonly entries: number;
+    } | null;
+}
+export interface ContextExecutionInput {
+    readonly schema: "context/v1";
+    readonly input_digest: string;
+    readonly operation_id: string;
+    readonly step_id: string;
+    readonly input_sequence: number;
+    readonly state_digest: string;
+    readonly policy_digest: string;
+    readonly plan_digest: string;
+    readonly rendered_snapshot: string;
+    readonly prompt_measurement: string;
+    readonly provider_route: string;
+    readonly cache_prefix: {
+        readonly digest: string;
+        readonly entries: number;
+    } | null;
+}
+export interface ContextPreparationRequest {
+    readonly operation_id: string;
+    readonly step_id: string;
+    readonly input_sequence: number;
+    readonly policy_digest: string;
+    readonly prompt_measurement: string;
+    readonly provider_route: string;
+}
+export interface EvaluationRun {
+    readonly digest: string;
+    readonly proposal: string;
+    readonly baseline_artifact_set: string;
+    readonly candidate_artifact_set: string;
+    readonly evaluator: string;
+    readonly dataset: string;
+    readonly operation_ids: readonly string[];
+    readonly contexts: readonly EvaluationContextBinding[];
+    readonly evidence_refs: readonly string[];
+}
+export interface EvaluationMetric {
+    readonly name: string;
+    readonly baseline: string;
+    readonly candidate: string;
+    readonly improved: boolean;
+}
+export interface EvaluationGate {
+    readonly name: string;
+    readonly required: boolean;
+    readonly passed: boolean;
+}
+export interface EvaluationFact {
+    readonly digest: string;
+    readonly evaluation: string;
+    readonly metrics: readonly EvaluationMetric[];
+    readonly gates: readonly EvaluationGate[];
+    readonly replay_passed: boolean;
+}
+export type PromotionOutcome = "promote" | "reject" | "hold";
+export interface PromotionDecision {
+    readonly digest: string;
+    readonly proposal: string;
+    readonly evaluation_facts: readonly string[];
+    readonly policy: string;
+    readonly outcome: PromotionOutcome;
+    readonly selected_artifact_set: string;
+}
+export interface ActivationBinding {
+    readonly digest: string;
+    readonly operation_id: string;
+    readonly artifact_set: string;
+    readonly promotion_decision: string;
+}
+export interface EvolutionBundle {
+    readonly artifacts: readonly ArtifactVersion[];
+    readonly artifact_sets: readonly ArtifactSet[];
+    readonly proposals: readonly EvolutionProposal[];
+    readonly evaluations: readonly EvaluationRun[];
+    readonly facts: readonly EvaluationFact[];
+    readonly decisions: readonly PromotionDecision[];
+    readonly activations: readonly ActivationBinding[];
+}
+export type EvolutionVerdict = "pass" | "fail" | "unavailable";
+export interface EvolutionViolation {
+    readonly code: string;
+    readonly detail: string;
+}
+export interface EvolutionReport {
+    readonly schema: "evolution-report/v1";
+    readonly verdict: EvolutionVerdict;
+    readonly violations: readonly EvolutionViolation[];
+}
+export type EvolutionValidateJson = (request: string) => string;
+/** Host-owned persistence boundary. Implementations may use a CAS, database, or object store. */
+export interface EvolutionStore {
+    loadBundle(): Promise<EvolutionBundle> | EvolutionBundle;
+}
+/** Create the SDK adapter backed by the Rust core E1–E8 validator. */
+export declare function createEvolutionRuntimeAdapter(validateJson: EvolutionValidateJson): {
+    validate(bundle: EvolutionBundle): EvolutionReport;
+};
+/** Create the adapter from the native Rust binding. */
+export declare function createNativeEvolutionRuntimeAdapter(): {
+    validate(bundle: EvolutionBundle): EvolutionReport;
+};
+/** Storage-neutral evolution handle. Artifact and ledger persistence remain host-owned. */
+export declare class EvolutionRuntime {
+    private readonly adapter;
+    constructor(adapter: ReturnType<typeof createEvolutionRuntimeAdapter>);
+    validate(bundle: EvolutionBundle): EvolutionReport;
+    validateStore(store: EvolutionStore): Promise<EvolutionReport>;
+    activate(bundle: EvolutionBundle, operationId: string): ActivationBinding;
+}

package/dist/runtime/evolution.js

@@ -0,0 +1,34 @@
+import { getKernel } from "../kernel.js";
+/** Create the SDK adapter backed by the Rust core E1–E8 validator. */
+export function createEvolutionRuntimeAdapter(validateJson) {
+    return {
+        validate(bundle) {
+            return JSON.parse(validateJson(JSON.stringify(bundle)));
+        },
+    };
+}
+/** Create the adapter from the native Rust binding. */
+export function createNativeEvolutionRuntimeAdapter() {
+    return createEvolutionRuntimeAdapter(getKernel().evolutionValidateJson);
+}
+/** Storage-neutral evolution handle. Artifact and ledger persistence remain host-owned. */
+export class EvolutionRuntime {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    validate(bundle) { return this.adapter.validate(bundle); }
+    async validateStore(store) {
+        return this.validate(await store.loadBundle());
+    }
+    activate(bundle, operationId) {
+        const report = this.validate(bundle);
+        if (report.verdict !== "pass") {
+            throw new Error(`evolution bundle is not activatable: ${report.violations.map(v => v.code).join(", ")}`);
+        }
+        const activation = bundle.activations.find(value => value.operation_id === operationId);
+        if (!activation)
+            throw new Error(`no verified activation binding for operation ${operationId}`);
+        return activation;
+    }
+}

package/dist/runtime/execution-plane.d.ts

@@ -26,7 +26,7 @@ export interface ExecutionPlane {
     /**
      * Execute a batch of calls. Yields StreamEvents during execution.
      * Guarantees exactly one `tool_result` event per call in `calls`.
-     * The runner collects those events to build ToolResult[] for the kernel.
+     * The runner collects those events to build ToolExecutionResult[] for the kernel.
      */
     executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
 }