@deepstrike/wasm 0.2.69 → 0.2.70

package/dist/runtime/evolution.d.ts

@@ -0,0 +1,189 @@
+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 EvolutionReport {
+    readonly schema: "evolution-report/v1";
+    readonly verdict: EvolutionVerdict;
+    readonly violations: readonly {
+        readonly code: string;
+        readonly detail: string;
+    }[];
+}
+export type EvolutionValidateJson = (request: string) => string;
+export interface EvolutionStore {
+    loadBundle(): Promise<EvolutionBundle> | EvolutionBundle;
+}
+export declare function createEvolutionRuntimeAdapter(validateJson: EvolutionValidateJson): {
+    validate: (bundle: EvolutionBundle) => EvolutionReport;
+};
+export declare function createNativeEvolutionRuntimeAdapter(): Promise<{
+    validate: (bundle: EvolutionBundle) => EvolutionReport;
+}>;
+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,25 @@
+import { getKernel } from "./kernel.js";
+export function createEvolutionRuntimeAdapter(validateJson) {
+    return { validate: (bundle) => JSON.parse(validateJson(JSON.stringify(bundle))) };
+}
+export async function createNativeEvolutionRuntimeAdapter() {
+    const kernel = await getKernel();
+    return createEvolutionRuntimeAdapter(kernel.evolutionValidateJson);
+}
+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/kernel-step.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolCall, ToolResult, ToolSchema } from "../types.js";
+import type { ProviderMessage, RenderedContext, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
 import type { RollbackReason } from "./session-log.js";
 interface TaskUpdate {
     plan?: string[];
@@ -15,7 +15,7 @@ interface SkillMetadata {
     effort?: number;
     estimatedTokens?: number;
     /** P1-B tool gating: tool ids this skill needs; when active the kernel narrows the toolset to
-     *  `stable-core ∪ allowedTools`. Absent ⇒ no narrowing (back-compat). */
+     *  `stable-core ∪ allowedTools`. Absent ⇒ no narrowing. */
     allowedTools?: string[];
 }
 export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
@@ -41,7 +41,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;
 }
@@ -50,6 +50,7 @@ export type KernelRunnerAction = {
     effectId: string;
     context: RenderedContext;
     tools: ToolSchema[];
+    contextEffect: Record<string, unknown>;
 } | {
     kind: "execute_tool";
     effectId: string;
@@ -89,7 +90,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    archived: Message[];
+    archived: ProviderMessage[];
     handleId?: string;
     payload?: {
         content: string;
@@ -218,12 +219,12 @@ 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>;
 export declare function capabilityMarker(kind: string, id: string, description: string): Record<string, unknown>;
-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;
 export {};

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

@@ -1,6 +1,6 @@
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
+import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
-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 the incompatible envelope is skipped so

package/dist/runtime/provider-replay.js

@@ -29,7 +29,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 || !isReplayCompatibleWithProvider(stored, descriptor))
             continue;
         provider.seedProviderReplay({ content: event.content, toolCalls }, stored);

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

@@ -6,20 +6,20 @@
  * 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 camelCase and snake_case tool-call wire shapes. Token usage remains session
- * evidence; the returned public Message mirror carries no token projection.
+ * evidence; the returned public ProviderMessage mirror carries no token projection.
  *
  * @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,10 +10,10 @@
  * 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 camelCase and snake_case tool-call wire shapes. Token usage remains session
- * evidence; the returned public Message mirror carries no token projection.
+ * evidence; the returned public ProviderMessage mirror carries no token projection.
  *
  * @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

@@ -23,7 +23,7 @@
  * 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`.
@@ -53,7 +53,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;
@@ -61,7 +61,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/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, MemorySummarizer } from "../types.js";
+import type { LLMProvider, ProviderMessage, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, MemorySummarizer } from "../types.js";
 import type { ToolSuspendEvent } from "./execution-plane.js";
 import type { MemoryStore, MemoryQuery, MemoryRecord, MemoryScope } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
@@ -65,8 +65,8 @@ export interface KernelReliabilityOptions {
     maxInputBytes?: number;
 }
 export interface ArchiveStore {
-    write(sessionId: string, startSeq: number, messages: Message[]): Promise<string | undefined>;
-    read?(archiveRef: string): Promise<Message[]>;
+    write(sessionId: string, startSeq: number, messages: ProviderMessage[]): Promise<string | undefined>;
+    read?(archiveRef: string): Promise<ProviderMessage[]>;
 }
 /** P0-C tool-gating telemetry: per-LLM-turn metrics, emitted via `RuntimeOptions.onTurnMetrics`.
  *  Pure observation — no behavior change. `toolsExposed` vs `toolsCalled` quantifies over-exposure;
@@ -99,7 +99,9 @@ export interface ToolResultHookDecision {
 }
 export interface RuntimeOptions {
     provider: LLMProvider;
-    /** Required for ABI-v3 operation recovery unless the SessionLog embeds one. */
+    /** Host-owned artifact set identity captured in operation genesis. */
+    artifactSetDigest?: string;
+    /** Required for ABI operation recovery unless the SessionLog embeds one. */
     kernelJournal?: KernelJournal;
     /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`.
      *  Returns undefined ⇒ fall back to `provider`. Without this hook the hint is a no-op. */
@@ -342,7 +344,7 @@ export declare class RuntimeRunner {
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary) 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>;
@@ -414,5 +416,5 @@ export declare class RuntimeRunner {
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, archiveStore?: ArchiveStore): Promise<Message[]>;
+}>, maxBytes?: number, archiveStore?: ArchiveStore): Promise<ProviderMessage[]>;
 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 { extractSessionMemories } from "../memory/extraction.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
 import { governancePolicyToKernelEvent, governanceFilterSchema } from "../governance.js";
@@ -168,6 +170,7 @@ export class RuntimeRunner {
             maxTurns: this.opts.maxTurns,
             maxTotalTokens: this.opts.maxTotalTokens,
             maxWallMs: this.opts.timeoutMs,
+            artifactSetDigest: this.opts.artifactSetDigest,
             memoryBindingId: `wasm-memory-${this.opts.agentId ?? "root"}`,
             persistPayload: async (_callId, content, previewBytes) => {
                 const digest = canonicalSha256(content);
@@ -703,12 +706,15 @@ export class RuntimeRunner {
                     let turnCacheCreationTokens = 0;
                     let turnCacheReadBySlot;
                     let turnStopReason;
-                    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,
+                    });
                     let promptMeasurement = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
                     if (!promptMeasurement && !context.budgetOverflow) {
                         try {
-                            const counted = this.opts.provider.countTokens
-                                ? await withTimeout(this.opts.provider.countTokens(context, tools, Object.keys(ext).length ? ext : undefined), 5_000)
+                            const counted = preparedRequest.countTokens
+                                ? await withTimeout(preparedRequest.countTokens(), 5_000)
                                 : undefined;
                             promptMeasurement = recordPromptMeasurement(providerPlan, counted ?? {
                                 inputTokens: estimateProviderPromptTokens(context, tools),
@@ -758,9 +764,21 @@ export class RuntimeRunner {
                         this.providerRetryPending = action.kind === "call_provider";
                         continue;
                     }
+                    if (!promptMeasurement)
+                        throw new Error("context preparation requires prompt measurement");
+                    const contextAdapter = await 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.
                             if (abortSignal?.aborted)
                                 break;
@@ -919,7 +937,6 @@ export class RuntimeRunner {
                         turn: runtime.turn(),
                         content: finalText,
                         toolCalls: finalToolCalls,
-                        providerReplay,
                         effectId: providerEffectId,
                         invocationId,
                         wireEvidence,

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

@@ -1,4 +1,5 @@
-import type { ProviderReplay, ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
+import type { ContextPrepared } from "./context.js";
+import type { ProviderWireEvidence, ToolCall, ToolErrorKind } from "../types.js";
 import type { MemoryRecall, MemoryScope } from "../memory/index.js";
 import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { KernelJournal } from "./kernel-journal.js";
@@ -56,10 +57,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;
@@ -292,7 +297,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;
@@ -360,7 +365,7 @@ export type SessionEventKind = SessionEvent["kind"];
  * `tests/fixtures/sdk-conformance/canonical/session-event-vocabulary.json` pins both, and any
  * same-commit desync turns 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, and audit metadata. Canonical durable records live exclusively in

package/dist/runtime/session-log.js

@@ -10,6 +10,7 @@ export const SESSION_EVENT_KINDS = [
     "run_started",
     "llm_completed",
     "prompt_measured",
+    "context_prepared",
     "provider_attempt",
     "tool_requested",
     "tool_completed",

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

@@ -1,10 +1,10 @@
-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";
 /**
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
- * and any existing token_count remains raw evidence, but the stored `provider_replay` envelope is
+ * and any existing token_count remains raw evidence, but `wire_evidence.replay_state` is
  * passed through verbatim — this layer is provider-neutral and never
  * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.
@@ -26,7 +26,6 @@ export declare function buildLlmCompletedEvent(input: {
     content: string;
     tokenCount?: number;
     toolCalls: ToolCall[];
-    providerReplay?: ProviderReplay;
     effectId?: string;
     invocationId?: string;
     wireEvidence?: ProviderWireEvidence;
@@ -49,7 +48,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

@@ -2,7 +2,7 @@ import { sanitizeReplayText } from "./replay-sanitize.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
 /**
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
- * and any existing token_count remains raw evidence, but the stored `provider_replay` envelope is
+ * and any existing token_count remains raw evidence, but `wire_evidence.replay_state` is
  * passed through verbatim — this layer is provider-neutral and never
  * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.
@@ -10,14 +10,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 } : {}),
         // P4 §3: the evidence-plane fields ride along verbatim — recovery never reads them
         // (SessionLog is evidence, not authority), so normalize must neither synthesize nor drop them.
         ...(event.effect_id !== undefined ? { effect_id: event.effect_id } : {}),
@@ -39,7 +37,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/sub-agent-orchestrator.js

@@ -166,7 +166,7 @@ export const defaultSubAgentOrchestrator = new SubAgentOrchestrator();
 /** Canonical single-node root workflow for harness / coordinator use. */
 export async function spawnStandalone(parentOpts, parentSessionId, spec, orchestrator = defaultSubAgentOrchestrator, contextInput) {
     if (spec.tokenBudget !== undefined || spec.maxTurns !== undefined || spec.maxWallMs !== undefined) {
-        throw new Error("spawnStandalone cannot represent per-node resource caps under canonical ABI v3");
+        throw new Error("spawnStandalone cannot represent per-node resource caps under canonical ABI");
     }
     const { RuntimeRunner } = await import("./runner.js");
     let captured;

package/dist/runtime/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";
@@ -81,7 +81,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`.
@@ -211,7 +211,7 @@ export interface KernelWorkflowNodeOutcome {
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
     output?: {
-        role: Message["role"];
+        role: ProviderMessage["role"];
         content: string;
         tool_calls?: Array<{
             id: string;
@@ -224,7 +224,7 @@ export interface WorkflowNodeOutcome {
     nodeId: string;
     status: WorkflowNodeStatus;
     termination?: TerminationReason;
-    output?: Message;
+    output?: ProviderMessage;
 }
 export interface ControlRequestRejection {
     operation: string;

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

@@ -1,6 +1,6 @@
 /** Framework-facing API plus the Rust verifiable-runtime report ABI. */
-export declare const VERIFIABLE_REPORT_SCHEMA: "verifiable-report/v1";
-export declare const VERIFIABLE_FORK_SCHEMA: "verifiable-fork/v1";
+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";

package/dist/runtime/verifiable-report.js

@@ -1,7 +1,7 @@
 import { getKernel } from "./kernel.js";
 /** Framework-facing API plus the Rust verifiable-runtime report ABI. */
-export const VERIFIABLE_REPORT_SCHEMA = "verifiable-report/v1";
-export const VERIFIABLE_FORK_SCHEMA = "verifiable-fork/v1";
+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 = {}) => {