@deepstrike/sdk 0.2.68 → 0.2.70

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>;
 }

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

@@ -1,4 +1,4 @@
-import type { EntropySample, Message, RenderedContext, TaskUpdate, ToolCall, ToolResult, ToolSchema } from "../types.js";
+import type { EntropySample, ProviderMessage, RenderedContext, TaskUpdate, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
 import type { SkillMetadata } from "../skills/loader.js";
 import type { RollbackReason } from "./session-log.js";
 export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
@@ -15,7 +15,7 @@ export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
-    finalMessage?: Message;
+    finalMessage?: ProviderMessage;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -36,6 +36,7 @@ export type KernelRunnerAction = {
     effectId: string;
     context: RenderedContext;
     tools: ToolSchema[];
+    contextEffect: Record<string, unknown>;
 } | {
     kind: "execute_tool";
     effectId: string;
@@ -75,7 +76,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    archived?: Message[];
+    archived?: ProviderMessage[];
     handleId?: string;
     payload?: {
         content: string;
@@ -212,8 +213,8 @@ export declare function archivePresentationFromObservations(observations: readon
 };
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
-export declare function messageToKernelMessage(message: Message): Record<string, unknown>;
-export declare function toolResultToKernel(result: ToolResult): Record<string, unknown>;
+export declare function messageToKernelMessage(message: ProviderMessage): Record<string, unknown>;
+export declare function toolResultToKernel(result: ToolExecutionResult): Record<string, unknown>;
 export declare function taskUpdateToKernel(update: TaskUpdate): Record<string, unknown>;
 export declare function capabilityTool(schema: ToolSchema): Record<string, unknown>;
 export declare function capabilitySkill(skill: SkillMetadata): Record<string, unknown>;
@@ -222,5 +223,5 @@ export declare function capabilityCommandMount(capability: Record<string, unknow
 export declare function capabilityCommandUnmount(capabilityKind: string, id: string): Record<string, unknown>;
 /** Camel-case an `entropy_sample` kernel observation into the SDK's `EntropySample`. */
 export declare function entropySampleFromObservation(obs: KernelObservation): EntropySample;
-export declare function kernelMessageToSdk(raw: Record<string, unknown>): Message;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): ProviderMessage;
 export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;

package/dist/runtime/provider-replay.d.ts

@@ -1,10 +1,10 @@
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export declare class ProviderReplayProtocolMismatchError extends Error {
     readonly code: "provider_replay_protocol_mismatch";
     constructor(provider: string, storedProtocol: string, resolvedProtocol: string);
 }
-export declare function assistantReplayKey(message: Pick<Message, "content" | "toolCalls">): string;
+export declare function assistantReplayKey(message: Pick<ProviderMessage, "content" | "toolCalls">): string;
 /**
  * A stored replay may only be seeded into a provider speaking the same wire
  * protocol. On a cross-protocol fallback (provider A -> provider B) the

package/dist/runtime/provider-replay.js

@@ -67,7 +67,7 @@ export function seedProviderReplayFromEvents(provider, events) {
         if (event.kind !== "llm_completed")
             continue;
         const toolCalls = event.tool_calls ?? [];
-        const stored = event.provider_replay;
+        const stored = event.wire_evidence?.replay_state;
         if (!stored)
             continue;
         if (!isReplayCompatibleWithProvider(stored, descriptor)) {

package/dist/runtime/replay-fixture.d.ts

@@ -6,21 +6,21 @@
  * pulls the assistant turns in order, so the fixture is just "a prior session log + the messages
  * the LLM produced". No new on-disk format.
  */
-import type { Message } from "../types.js";
+import type { ProviderMessage } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 /**
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
- * one Message per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case; token_count is wire evidence)
+ *   - in-memory: `{ toolCalls }` (camelCase)
+ *   - serialised session-log: `{ tool_calls, token_count, wire_evidence }` (snake_case; token_count is wire evidence)
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.
  */
 export declare function extractRecordedMessages(events: Array<{
     event: SessionEvent;
-} | SessionEvent>): Message[];
+} | SessionEvent>): ProviderMessage[];

package/dist/runtime/replay-fixture.js

@@ -10,11 +10,11 @@
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
- * one Message per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
- *   - in-memory: `{ toolCalls, providerReplay }` (camelCase)
- *   - serialised session-log: `{ tool_calls, token_count, provider_replay }` (snake_case; token_count is wire evidence)
+ *   - in-memory: `{ toolCalls }` (camelCase)
+ *   - serialised session-log: `{ tool_calls, token_count, wire_evidence }` (snake_case; token_count is wire evidence)
  *
  * @param events Session events, in original order. Accepts both `{ event, seq }` (the shape
  *               `SessionLog.read()` returns) and a bare `SessionEvent[]`.

package/dist/runtime/replay-provider.d.ts

@@ -17,14 +17,14 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public Message mirror.
+ *     the session measurement plane, never to the public ProviderMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *
  * Tokenizer: by default a `chars/4` estimator (±20% for English; worse for code/JSON). For tighter
  * numbers plug `opts.tokenizer = tiktokenEncoder` or similar.
  */
-import type { LLMProvider, Message, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 export interface ReplayProviderOpts {
     /**
      * Maps a rendered-context text payload to a token count. Defaults to `chars / 4`.
@@ -54,7 +54,7 @@ export declare class ReplayProvider implements LLMProvider {
      * @param messages Ordered list of assistant messages to replay (one per LLM call).
      * @param opts Optional tokenizer / descriptor / wrap-around behavior.
      */
-    constructor(messages: ReadonlyArray<Message>, opts?: ReplayProviderOpts);
+    constructor(messages: ReadonlyArray<ProviderMessage>, opts?: ReplayProviderOpts);
     descriptor(): ProviderDescriptor;
     /** Number of messages consumed so far. */
     consumed(): number;
@@ -62,7 +62,7 @@ export declare class ReplayProvider implements LLMProvider {
     remaining(): number;
     /** Reset the cursor — useful for re-running the same fixture in a fresh session. */
     reset(): void;
-    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<Message>;
+    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ProviderMessage>;
     stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, _state?: ProviderRunState, _signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private pull;
     private estimateInputTokens;

package/dist/runtime/replay-provider.js

@@ -17,7 +17,7 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public Message mirror.
+ *     the session measurement plane, never to the public ProviderMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *

package/dist/runtime/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { LLMProvider, ProviderMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
 import type { MemoryStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
@@ -95,6 +95,8 @@ export interface KernelReliabilityOptions {
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** Host-owned artifact set identity captured in operation genesis. */
+    artifactSetDigest?: string;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
      *  `tokenBudget` flows here for its child run, so an expensive node self-terminates at the cap.
      *  Undefined ⇒ the kernel default. */
@@ -109,7 +111,7 @@ export interface RuntimeOptions {
      *  Undefined ⇒ worktree nodes fall back to the inherited plane (no isolation). */
     worktreeManager?: import("./worktree-plane.js").WorktreeManager;
     sessionLog: SessionLog;
-    /** ABI v3 transaction capability. Default session logs expose one; custom logs pass it explicitly. */
+    /** ABI transaction capability. Default session logs expose one; custom logs pass it explicitly. */
     kernelJournal?: KernelJournal;
     executionPlane: ExecutionPlane;
     /** Receives failures from run-owned best-effort tasks after their semantic owner has committed. */
@@ -486,7 +488,7 @@ export declare class RuntimeRunner {
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
      *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
-    pushKnowledge(message: Message, tokens?: number, opts?: {
+    pushKnowledge(message: ProviderMessage, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
     }): Promise<void>;
@@ -601,14 +603,14 @@ export declare class RuntimeRunner {
  *  message exists. A tail assistant tool_call with nothing after it is a genuinely PENDING tool the
  *  run stopped in front of (the wake/recovery case), which must stay unpaired so wake executes it.
  *  Pure. */
-export declare function pairOrphanToolCalls(messages: Message[]): Message[];
+export declare function pairOrphanToolCalls(messages: ProviderMessage[]): ProviderMessage[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number): Message[];
+}>, maxBytes?: number): ProviderMessage[];
 export declare function replayMessagesAsync(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<Message[]>): Promise<Message[]>;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ProviderMessage[]>): Promise<ProviderMessage[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;

package/dist/runtime/runner.js

@@ -1,3 +1,5 @@
+import { prepareProviderRequest } from "../providers/prepared-request.js";
+import { createNativeContextPreparationAdapter } from "./context.js";
 import { createHash } from "node:crypto";
 import { extractSessionMemories } from "../memory/extraction.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
@@ -389,6 +391,7 @@ export class RuntimeRunner {
             maxTurns: this.opts.maxTurns,
             maxTotalTokens: this.opts.maxTotalTokens,
             maxWallMs: this.opts.timeoutMs,
+            artifactSetDigest: this.opts.artifactSetDigest,
             memoryBindingId: `node-memory-${this.opts.agentId ?? "root"}`,
             persistPayload: async (callId, content, previewBytes) => {
                 const digest = `sha256:${createHash("sha256").update(content).digest("hex")}`;
@@ -1077,7 +1080,7 @@ export class RuntimeRunner {
                 else if (completionAction) {
                     throw new Error(`workflow completion returned unexpected effect: ${completionAction.kind}`);
                 }
-                // ABI v3: child-authored DAG additions ride on ChildCompleted.parent_requests. Admission is
+                // ABI: child-authored DAG additions ride on ChildCompleted.parent_requests. Admission is
                 // independent of the completion fact; only an admitted request emits this observation.
                 if (result.submittedNodes?.length) {
                     const submitted = obs.find(o => o.kind === "workflow_nodes_submitted");
@@ -1636,13 +1639,16 @@ export class RuntimeRunner {
                         // P4 §2: the raw postflight provider usage frame, kept whole so the attempt's
                         // measurement carries full fields (only the settlement crosses the kernel boundary, B4).
                         let turnProviderUsage;
-                        const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
+                        const preparedRequest = prepareProviderRequest(this.opts.provider, context, tools, ext, providerState);
+                        const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext, {
+                            scope: preparedRequest.scope, request: preparedRequest.request, state: preparedRequest.state,
+                        });
                         const recorded = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
                         let promptMeasurement = recorded;
                         if (!promptMeasurement && !context.budgetOverflow) {
                             try {
-                                const count = this.opts.provider.countTokens
-                                    ? await withTimeout(this.opts.provider.countTokens(context, tools, Object.keys(ext).length ? ext : undefined), 5_000)
+                                const count = preparedRequest.countTokens
+                                    ? await withTimeout(preparedRequest.countTokens(), 5_000)
                                     : undefined;
                                 promptMeasurement = recordPromptMeasurement(providerPlan, count ?? {
                                     inputTokens: estimateProviderPromptTokens(context, tools),
@@ -1702,9 +1708,21 @@ export class RuntimeRunner {
                             this.providerRetryPending = action.kind === "call_provider";
                             continue;
                         }
+                        if (!promptMeasurement)
+                            throw new Error("context preparation requires prompt measurement");
+                        const contextAdapter = createNativeContextPreparationAdapter();
+                        const preparation = contextAdapter.prepare({
+                            effect: action.contextEffect,
+                            request_fingerprint: providerPlan.fingerprint,
+                            provider_route: { ...this.providerRoute, request_fingerprint_scope: preparedRequest.scope },
+                            prompt_measurement: promptMeasurement,
+                        });
+                        await this.opts.sessionLog.append(sessionId, {
+                            kind: "context_prepared", turn: runtime.turn(), effect_id: providerEffectId, preparation,
+                        });
                         const abortSignal = this.abortController?.signal;
                         try {
-                            for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
+                            for await (const evt of preparedRequest.stream(abortSignal)) {
                                 // #2-B-ii: a preempting `interrupt()` fires `abortController` — stop consuming the live
                                 // stream immediately (providers that forward `signal` also abort the socket; the rest at
                                 // least stop here at the next event). The loop-top `interrupted` check then ends the run.
@@ -1959,7 +1977,6 @@ export class RuntimeRunner {
                             content: finalText,
                             tokenCount: turnOutputTokens || turnTokens || undefined,
                             toolCalls: finalToolCalls,
-                            providerReplay,
                             effectId: providerEffectId,
                             invocationId,
                             wireEvidence,

package/dist/runtime/session-log.d.ts

@@ -1,5 +1,6 @@
+import type { ContextPrepared } from "./context.js";
 import type { KernelPrimitive } from "./kernel-event-log.js";
-import type { ContentPart, ProviderReplay, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
+import type { ContentPart, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
 import type { RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
 import type { ProviderAttemptRecord } from "./execution-evidence.js";
 import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
@@ -38,10 +39,14 @@ export type SessionEvent = {
     content: string;
     token_count?: number;
     tool_calls: ToolCall[];
-    provider_replay?: ProviderReplay;
     effect_id?: string;
     invocation_id?: string;
     wire_evidence?: ProviderWireEvidence;
+} | {
+    kind: "context_prepared";
+    turn: number;
+    effect_id: string;
+    preparation: ContextPrepared;
 } | {
     kind: "prompt_measured";
     turn: number;
@@ -274,7 +279,7 @@ export type SessionEvent = {
     classify_branch?: string;
     tournament_winner?: string;
     loop_continue?: boolean;
-    output?: import("../types.js").Message;
+    output?: import("../types.js").ProviderMessage;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;
@@ -342,7 +347,7 @@ export type SessionEventKind = SessionEvent["kind"];
  * `tests/fixtures/sdk-conformance/canonical/session-event-vocabulary.json` and the python/wasm
  * vocabularies turns cross-SDK conformance red. Declared in `SessionEvent` union order.
  */
-export declare const SESSION_EVENT_KINDS: readonly ["run_started", "llm_completed", "prompt_measured", "provider_attempt", "tool_requested", "tool_completed", "tool_argument_repaired", "tool_denied", "permission_requested", "permission_resolved", "compressed", "page_out", "semantic_archive_pending", "semantic_archive_completed", "semantic_archive_failed", "page_in", "rollbacked", "capability_changed", "context_renewed", "suspended", "resumed", "tool_gated", "signal_delivery_disposed", "budget_exceeded", "budget_usage_reported", "operation_cancelled", "milestone_advanced", "milestone_blocked", "checkpoint_taken", "entropy_sample", "entropy_alert", "agent_process_changed", "memory_written", "memory_queried", "memory_validation_failed", "memory_write_failed", "memory_query_failed", "memory_retrieval_result", "workflow_node_completed", "workflow_nodes_submitted", "workflow_batch_spawned", "workflow_completed", "kernel_observation", "run_terminal", "summary_upgraded", "group_member_joined", "group_budget_charged", "round_started", "round_paced"];
+export declare const SESSION_EVENT_KINDS: readonly ["run_started", "llm_completed", "prompt_measured", "context_prepared", "provider_attempt", "tool_requested", "tool_completed", "tool_argument_repaired", "tool_denied", "permission_requested", "permission_resolved", "compressed", "page_out", "semantic_archive_pending", "semantic_archive_completed", "semantic_archive_failed", "page_in", "rollbacked", "capability_changed", "context_renewed", "suspended", "resumed", "tool_gated", "signal_delivery_disposed", "budget_exceeded", "budget_usage_reported", "operation_cancelled", "milestone_advanced", "milestone_blocked", "checkpoint_taken", "entropy_sample", "entropy_alert", "agent_process_changed", "memory_written", "memory_queried", "memory_validation_failed", "memory_write_failed", "memory_query_failed", "memory_retrieval_result", "workflow_node_completed", "workflow_nodes_submitted", "workflow_batch_spawned", "workflow_completed", "kernel_observation", "run_terminal", "summary_upgraded", "group_member_joined", "group_budget_charged", "round_started", "round_paced"];
 /**
  * The business-projection log (spec §9.2): run started/terminal, stream events, observations,
  * provider/tool presentation, audit metadata.

package/dist/runtime/session-log.js

@@ -16,6 +16,7 @@ export const SESSION_EVENT_KINDS = [
     "run_started",
     "llm_completed",
     "prompt_measured",
+    "context_prepared",
     "provider_attempt",
     "tool_requested",
     "tool_completed",
@@ -214,8 +215,8 @@ function decodePersistedSessionRecord(value) {
     if (!record.event || typeof record.event !== "object" || Array.isArray(record.event))
         throw new Error("session record event must be an object");
     const event = record.event;
-    if (event.kind === "llm_completed" && event.provider_replay !== undefined) {
-        assertCanonicalProviderReplay(event.provider_replay);
+    if (event.kind === "llm_completed" && "provider_replay" in event) {
+        throw new Error("llm_completed has removed provider_replay field; use wire_evidence.replay_state");
     }
     if (event.kind === "llm_completed" && event.wire_evidence !== undefined) {
         assertCanonicalWireEvidence(event.wire_evidence);

package/dist/runtime/session-repair.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ProviderReplay, ProviderWireEvidence, ToolCall } from "../types.js";
+import type { ProviderMessage, ProviderWireEvidence, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 import type { WorkflowNodeStatus } from "../types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
@@ -6,7 +6,7 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
  * Normalize a persisted llm_completed event for recovery.
  *
  * Content is sanitized while any existing token_count remains raw evidence, but the stored
- * `provider_replay` envelope is passed through verbatim — this layer is
+ * `wire_evidence.replay_state` is passed through verbatim — this layer is
  * provider-neutral and must never synthesize protocol-specific replay shapes
  * (e.g. Anthropic `native_blocks`). Canonical replay seeding for a given protocol
  * is the responsibility of that provider's `seedProviderReplay`.
@@ -34,7 +34,6 @@ export declare function buildLlmCompletedEvent(input: {
     content: string;
     tokenCount?: number;
     toolCalls: ToolCall[];
-    providerReplay?: ProviderReplay;
     effectId?: string;
     invocationId?: string;
     wireEvidence?: ProviderWireEvidence;
@@ -58,7 +57,7 @@ export declare function buildWorkflowNodeCompletedEvent(input: {
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: Message;
+    output?: ProviderMessage;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;

package/dist/runtime/session-repair.js

@@ -4,7 +4,7 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
  * Normalize a persisted llm_completed event for recovery.
  *
  * Content is sanitized while any existing token_count remains raw evidence, but the stored
- * `provider_replay` envelope is passed through verbatim — this layer is
+ * `wire_evidence.replay_state` is passed through verbatim — this layer is
  * provider-neutral and must never synthesize protocol-specific replay shapes
  * (e.g. Anthropic `native_blocks`). Canonical replay seeding for a given protocol
  * is the responsibility of that provider's `seedProviderReplay`.
@@ -16,14 +16,12 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
 export function normalizeLlmCompleted(event, maxBytes) {
     const content = sanitizeReplayText(event.content ?? "", maxBytes);
     const toolCalls = event.tool_calls ?? [];
-    const providerReplay = event.provider_replay;
     return {
         kind: "llm_completed",
         turn: event.turn,
         content,
         tool_calls: toolCalls,
         ...(event.token_count !== undefined ? { token_count: event.token_count } : {}),
-        ...(providerReplay ? { provider_replay: providerReplay } : {}),
         ...(event.effect_id !== undefined ? { effect_id: event.effect_id } : {}),
         ...(event.invocation_id !== undefined ? { invocation_id: event.invocation_id } : {}),
         ...(event.wire_evidence !== undefined ? { wire_evidence: event.wire_evidence } : {}),
@@ -45,7 +43,6 @@ export function buildLlmCompletedEvent(input) {
         content: sanitizeReplayText(input.content),
         tool_calls: input.toolCalls ?? [],
         token_count: input.tokenCount,
-        provider_replay: input.providerReplay,
         ...(input.effectId !== undefined ? { effect_id: input.effectId } : {}),
         ...(input.invocationId !== undefined ? { invocation_id: input.invocationId } : {}),
         ...(input.wireEvidence !== undefined ? { wire_evidence: input.wireEvidence } : {}),

package/dist/runtime/verifiable-report.d.ts

@@ -0,0 +1,64 @@
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export declare const VERIFIABLE_REPORT_SCHEMA: "verifiable-report/v2";
+export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v2";
+export type VerifiableCommand = "inspect" | "verify" | "replay" | "fork";
+export type CheckVerdict = "pass" | "degraded" | "fail" | "unavailable";
+export type ReplayVerdict = "pass" | "fail" | "unavailable";
+export type VerifiableReport = {
+    readonly schema: typeof VERIFIABLE_REPORT_SCHEMA;
+    readonly command: VerifiableCommand;
+    readonly operation_id: string;
+    readonly [key: string]: unknown;
+};
+export interface VerifiableEvidence {
+    readonly journal: ReadonlyArray<Uint8Array>;
+    readonly sessionLogs?: ReadonlyArray<ReadonlyArray<Uint8Array>>;
+    readonly checkpoints?: ReadonlyArray<Uint8Array>;
+}
+export interface VerifyOptions {
+    readonly strict?: boolean;
+    readonly requireComplete?: boolean;
+}
+export interface ReplayOptions {
+    readonly strict?: boolean;
+    readonly atStep?: number;
+}
+export interface ForkPlan extends VerifiableForkManifest {
+    readonly at_step: string;
+}
+export interface VerifiableRuntimeAdapter {
+    inspect(operationId: string, evidence: VerifiableEvidence, strict: boolean): VerifiableReport;
+    verify(operationId: string, evidence: VerifiableEvidence, options: VerifyOptions): VerifiableReport;
+    replay(operationId: string, evidence: VerifiableEvidence, options: ReplayOptions): VerifiableReport;
+    prepareFork(operationId: string, evidence: VerifiableEvidence, atStep: number, strict: boolean): ForkPlan;
+}
+export type VerifiableOperationJson = (request: string) => string;
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export declare function createVerifiableRuntimeAdapter(operationJson: VerifiableOperationJson): VerifiableRuntimeAdapter;
+/** Create the adapter from the installed native Node binding. */
+export declare function createNativeVerifiableRuntimeAdapter(): VerifiableRuntimeAdapter;
+/**
+ * Storage-neutral framework handle. The adapter is the single semantic bridge to Rust core;
+ * filesystem, database, and browser stores implement evidence loading outside this class.
+ */
+export declare class VerifiableOperation {
+    readonly operationId: string;
+    readonly evidence: VerifiableEvidence;
+    private readonly adapter;
+    constructor(operationId: string, evidence: VerifiableEvidence, adapter: VerifiableRuntimeAdapter);
+    inspect(strict?: boolean): VerifiableReport;
+    verify(options?: VerifyOptions): VerifiableReport;
+    replay(options?: ReplayOptions): VerifiableReport;
+    prepareFork(atStep: number, strict?: boolean): ForkPlan;
+}
+export interface VerifiableForkManifest {
+    schema: typeof VERIFIABLE_FORK_SCHEMA;
+    operation_id: string;
+    at_step: string;
+    parent_record_digest: string;
+    parent_input_id: string;
+    source_records: number;
+}
+export declare function assertVerifiableReportSchema(value: {
+    schema?: unknown;
+}): void;

package/dist/runtime/verifiable-report.js

@@ -0,0 +1,66 @@
+import { getKernel } from "../kernel.js";
+/** Framework-facing API plus the Rust verifiable-runtime report ABI. */
+export const VERIFIABLE_REPORT_SCHEMA = "verifiable-report/v2";
+export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v2";
+/** Create the SDK adapter backed by the Rust core JSON bridge. */
+export function createVerifiableRuntimeAdapter(operationJson) {
+    const call = (operationId, evidence, command, options = {}) => {
+        const result = JSON.parse(operationJson(JSON.stringify({
+            operation_id: operationId,
+            command,
+            evidence: {
+                journal: evidence.journal.map((bytes) => Array.from(bytes)),
+                session_logs: (evidence.sessionLogs ?? []).map((stream) => stream.map((bytes) => Array.from(bytes))),
+                checkpoints: (evidence.checkpoints ?? []).map((bytes) => Array.from(bytes)),
+            },
+            strict: options.strict ?? false,
+            require_complete: "requireComplete" in options ? options.requireComplete ?? false : false,
+            at_step: "atStep" in options ? options.atStep : undefined,
+        })));
+        if (command === "fork")
+            return result;
+        assertVerifiableReportSchema(result);
+        return result;
+    };
+    return {
+        inspect: (operationId, evidence, strict) => call(operationId, evidence, "inspect", { strict }),
+        verify: (operationId, evidence, options) => call(operationId, evidence, "verify", options),
+        replay: (operationId, evidence, options) => call(operationId, evidence, "replay", options),
+        prepareFork: (operationId, evidence, atStep, strict) => call(operationId, evidence, "fork", { atStep, strict }),
+    };
+}
+/** Create the adapter from the installed native Node binding. */
+export function createNativeVerifiableRuntimeAdapter() {
+    return createVerifiableRuntimeAdapter(getKernel().verifiableOperationJson);
+}
+/**
+ * Storage-neutral framework handle. The adapter is the single semantic bridge to Rust core;
+ * filesystem, database, and browser stores implement evidence loading outside this class.
+ */
+export class VerifiableOperation {
+    operationId;
+    evidence;
+    adapter;
+    constructor(operationId, evidence, adapter) {
+        this.operationId = operationId;
+        this.evidence = evidence;
+        this.adapter = adapter;
+    }
+    inspect(strict = false) {
+        return this.adapter.inspect(this.operationId, this.evidence, strict);
+    }
+    verify(options = {}) {
+        return this.adapter.verify(this.operationId, this.evidence, options);
+    }
+    replay(options = {}) {
+        return this.adapter.replay(this.operationId, this.evidence, options);
+    }
+    prepareFork(atStep, strict = false) {
+        return this.adapter.prepareFork(this.operationId, this.evidence, atStep, strict);
+    }
+}
+export function assertVerifiableReportSchema(value) {
+    if (value.schema !== VERIFIABLE_REPORT_SCHEMA) {
+        throw new Error(`unsupported verifiable report schema: ${String(value.schema)}`);
+    }
+}

package/dist/skills/loader.d.ts

@@ -9,7 +9,7 @@ export interface SkillMetadata {
     capabilityGrants?: Array<Record<string, unknown>>;
     /** P1-B tool gating: tool ids this skill needs. When the skill is active, the kernel narrows the
      *  exposed toolset to `stable-core ∪ allowedTools`. Parsed from `allowed_tools:` frontmatter
-     *  (comma-separated or `[a, b]`). Absent ⇒ the skill does not narrow (back-compat). */
+     *  (comma-separated or `[a, b]`). Absent ⇒ the skill does not narrow. */
     allowedTools?: string[];
 }
 /** Read one skill file and return its body (frontmatter stripped). */

package/dist/tools/index.d.ts

@@ -1,4 +1,4 @@
-import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
+import type { ToolChunk, ToolSchema, ToolExecutionResult } from "../types.js";
 import type { OperationContext } from "../runtime/reliability.js";
 /** M3/G4: the runtime context a tool may read when executing. Carries the working directory the tool
  *  should operate in — set to a sub-agent's git worktree for `isolation: "worktree"` nodes. A narrow,
@@ -35,6 +35,6 @@ export declare function executeTools(calls: {
     id: string;
     name: string;
     arguments: string;
-}[], registry: Map<string, RegisteredTool>): Promise<ToolResult[]>;
+}[], registry: Map<string, RegisteredTool>): Promise<ToolExecutionResult[]>;
 export declare function maybeWarnFailureShapedChunk(toolName: string, deltaText: string): void;
 export declare const readFile: RegisteredTool;

package/dist/types/agent.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ToolSchema } from "../types.js";
+import type { ProviderMessage, ToolSchema } from "../types.js";
 export type KernelAgentRole = "explore" | "plan" | "implement" | "verify" | "custom";
 export type AgentIsolation = "shared" | "read_only" | "worktree" | "remote";
 export type ContextInheritance = "none" | "system_only" | "full";
@@ -86,7 +86,7 @@ export interface AgentProcessChangedObservation {
 }
 export interface LoopResult {
     termination: TerminationReason | string;
-    finalMessage?: Message;
+    finalMessage?: ProviderMessage;
     turnsUsed: number;
     totalTokensUsed: number;
     /** loop-control loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
@@ -228,7 +228,7 @@ export interface KernelWorkflowNodeOutcome {
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
     output?: {
-        role: Message["role"];
+        role: ProviderMessage["role"];
         content: string;
         tool_calls?: Array<{
             id: string;
@@ -241,7 +241,7 @@ export interface WorkflowNodeOutcome {
     nodeId: string;
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
-    output?: Message;
+    output?: ProviderMessage;
 }
 /** A control-plane request rejected before any workflow effect started. */
 export interface ControlRequestRejection {
@@ -308,7 +308,7 @@ export interface WorkflowBudget {
     tokens_used?: number;
     tokens_max?: number;
     tokens_remaining?: number;
-    /** Canonical ABI v3 publishes immutable caps rather than a host-authored remaining snapshot. */
+    /** Canonical ABI publishes immutable caps rather than a host-authored remaining snapshot. */
     max_total_tokens?: string | number;
     max_turns?: number;
     max_concurrency?: number;