@deepstrike/wasm 0.2.61 → 0.2.63

package/LICENSE

@@ -0,0 +1,106 @@
+DeepStrike License (Dual License)
+Version 1.0 — 2026-09-01
+
+Copyright (c) 2025-2026 DeepStrike Contributors
+Project: https://github.com/kongusen/deepstrike
+
+======================================================================
+中文摘要（便于理解，不具有法律效力；以下英文条款为准）
+======================================================================
+
+本软件采用双授权模式：
+
+1. 个人，以及上一财年总营收低于 1,000,000 美元的组织（含其关联方），
+   可按 MIT 条款免费使用本软件（见第 2 节），包括使用、复制、修改、
+   合并、发布、分发、再授权及销售的权利。
+2. 上一财年总营收达到或超过 1,000,000 美元的组织（含其关联方），
+   在使用本软件之前（包括内部使用、基于本软件开发的项目、以及对外
+   分发此类产品或服务）须向作者获取商业授权（见第 3 节）。
+   获取方式：发送邮件至 wanghaishan0210@gmail.com，或通过
+   https://github.com/kongusen/deepstrike 提交 Issue / Discussion
+   联系作者。出于评估目的的试用不超过 30 天除外。
+3. 当组织的年营收增长至达到或超过该阈值时，自该时点起第 2 节的免费
+   授权终止，须获取商业授权后方可继续使用。
+4. v0.2.62 及之前已经以 MIT 协议发布的版本继续适用 MIT 协议，不受
+   本协议影响。本协议仅适用于随其一同分发的版本。
+
+======================================================================
+TERMS AND CONDITIONS
+======================================================================
+
+1. DEFINITIONS
+
+"Software" means the DeepStrike software and associated documentation
+files distributed by the Licensor, including all copies and substantial
+portions thereof.
+
+"Licensor" means the copyright holders of the Software (the DeepStrike
+Contributors), represented by the project maintainer at
+https://github.com/kongusen/deepstrike.
+
+"You" (or "Licensee") means the individual or legal entity exercising
+permissions granted by this License, including, where that entity is an
+organization, all entities that control, are controlled by, or are under
+common control with that entity ("Affiliates"). "Control" means ownership
+of more than fifty percent (50%) of the equity or voting interests, or
+the power to direct management and policies.
+
+"Annual Revenue" means the total gross revenue of You and Your Affiliates
+for the most recently completed fiscal year, expressed in US dollars or
+converted into US dollars at prevailing exchange rates.
+
+2. FREE LICENSE FOR INDIVIDUALS AND SMALL ORGANIZATIONS
+
+If You are an individual, or a legal entity whose Annual Revenue is less
+than one million US dollars (USD 1,000,000), the Licensor hereby grants
+You, free of charge, permission to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+(a) The above copyright notice and this License shall be included in all
+    copies or substantial portions of the Software.
+
+(b) If Your Annual Revenue reaches or exceeds USD 1,000,000, the grant in
+    this Section 2 terminates for You, and Section 3 applies from that
+    point on.
+
+3. COMMERCIAL LICENSE REQUIRED (ANNUAL REVENUE >= USD 1,000,000)
+
+If Your Annual Revenue equals or exceeds one million US dollars
+(USD 1,000,000), You must obtain a commercial license from the Licensor
+before using the Software. This applies to every form of use, including
+internal use, use within products or services developed based on the
+Software, and distribution or provision of such products or services to
+third parties.
+
+Exception: You may use the Software without a commercial license solely
+for evaluation purposes, for a period of up to thirty (30) days.
+
+To obtain a commercial license, contact the Licensor at
+wanghaishan0210@gmail.com, or via the project repository at
+https://github.com/kongusen/deepstrike (open an issue or discussion).
+Commercial terms, including fees, are set by individual agreement with
+the Licensor.
+
+Any use of the Software requiring a commercial license under this
+Section 3 without one is unlicensed use and constitutes copyright
+infringement.
+
+4. PRIOR VERSIONS
+
+Versions of the Software released before this License took effect (up to
+and including version 0.2.62) were released under the MIT License and
+remain available under the terms of the MIT License. This License applies
+only to versions of the Software distributed together with it.
+
+5. NO WARRANTY
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, SESSION_EVENT_KINDS, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
 export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
 export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, JournalStorageDriver, KernelJournal, } from "./runtime/kernel-journal.js";
+export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
-export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
+export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionEventKind, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
@@ -40,12 +41,14 @@ export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, ProviderUsage, RecordedPromptMeasurement } from "./providers/request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, ProviderUsage, RecordedPromptMeasurement, ResolvedProviderRoute } from "./providers/request-plan.js";
+export type { ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, ModelInvocation, InvocationOutcome, UsageSettlement, UsageAccountingPolicy, } from "./runtime/execution-evidence.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord, tryNormalizeProviderUsage } from "./runtime/execution-evidence.js";
 export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
 export type { CanonicalStopReason } from "./providers/stop-reason.js";
 export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
 export type { ContentDisposition, ContentPlacement, InputModality } from "./providers/content-policy.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";
 export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";

package/dist/index.js

@@ -1,6 +1,8 @@
-export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
+export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, SESSION_EVENT_KINDS, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
 // ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
 export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
+// ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
+export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
@@ -23,6 +25,7 @@ export { AttemptLoop, RuntimeAttemptBody, VerdictFnJudge, LlmEvalJudge, HybridJu
 export { ScheduledPrompt } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord, tryNormalizeProviderUsage } from "./runtime/execution-evidence.js";
 export { decodeCanonicalStopReason, normalizeProviderStopReason } from "./providers/stop-reason.js";
 export { ContentPolicyError, contentDispositionFor, requireContentDisposition } from "./providers/content-policy.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput } from "./runtime/durable-content.js";

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

@@ -36,6 +36,16 @@ export interface ProviderUsage {
     cacheCreationInputTokens?: number;
     reasoningTokens?: number;
 }
+/** P4 §1.3 mirror of the node ResolvedProviderRoute (content-addressed route evidence). */
+export interface ResolvedProviderRoute {
+    routeId: string;
+    provider: string;
+    protocol: string;
+    model: string;
+    endpoint: ProviderRequestEndpoint;
+    adapterVersion: string;
+    capabilitiesRef: string;
+}
 export interface NormalizedProviderUsage extends ProviderUsage {
     uncachedInputTokens: number;
 }

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

@@ -37,8 +37,8 @@ export interface CanonicalTransition {
     replayed: boolean;
 }
 export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
-/** The only ABI-v3 planned-step → Node host-action projection. */
-export declare function canonicalActionFromPlannedStep(plannedStep: CanonicalPlannedStep): KernelRunnerAction | null;
+/** Adapt the additive core CurrentProjection JSON into the existing WASM action surface. */
+export declare function canonicalActionFromProjectionJson(raw: string): KernelRunnerAction | null;
 export declare class CanonicalKernelRejectedError extends Error {
     readonly fault: Record<string, unknown>;
     constructor(faultJson: string);

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

@@ -27,240 +27,186 @@ export function canonicalUnsupportedEffectResolution(effectId, effectKind) {
         },
     };
 }
-/** The only ABI-v3 planned-step → Node host-action projection. */
-export function canonicalActionFromPlannedStep(plannedStep) {
-    if (plannedStep.disposition.kind === "terminal") {
-        const terminal = plannedStep.disposition.terminal;
-        const usage = asObject(terminal.usage);
-        let termination = String(terminal.kind ?? "failed");
-        let turnsUsed = Number(usage.turns ?? 0);
-        if (terminal.kind === "agent") {
-            const result = asObject(terminal.result);
-            termination = String(result.termination ?? "completed");
-            turnsUsed = Number(result.turns_used ?? turnsUsed);
-            const finalMessage = asObject(result.final_message);
-            const pace = asObject(result.pace_decision);
-            if (Object.keys(finalMessage).length > 0) {
-                return {
-                    kind: "done",
-                    effectId: "",
-                    result: {
-                        termination,
-                        turnsUsed,
-                        totalTokensUsed: totalUsageTokens(terminal),
-                        finalMessage: {
-                            role: String(finalMessage.role ?? "assistant"),
-                            content: String(finalMessage.content ?? ""),
-                            toolCalls: (Array.isArray(finalMessage.tool_calls) ? finalMessage.tool_calls : [])
-                                .map(value => {
-                                const call = asObject(value);
-                                return {
-                                    id: String(call.call_id ?? ""),
-                                    name: String(call.name ?? ""),
-                                    arguments: JSON.stringify(call.arguments ?? {}),
-                                };
-                            }),
-                        },
-                        ...(Object.keys(pace).length > 0
-                            ? {
-                                paceDecision: {
-                                    action: String(pace.action ?? "stop"),
-                                    ...(pace.delay_ms !== undefined ? { delayMs: Number(pace.delay_ms) } : {}),
-                                    reason: String(pace.reason ?? ""),
-                                    ...(pace.coerced_from ? { coercedFrom: String(pace.coerced_from) } : {}),
-                                },
-                            }
-                            : {}),
-                    },
-                };
-            }
-        }
-        else if (terminal.kind === "workflow") {
-            const outcome = asObject(terminal.outcome);
-            termination = String(outcome.status ?? "completed");
-        }
-        else if (terminal.kind === "cancelled") {
-            termination = String(terminal.reason ?? "cancelled");
-        }
-        else if (terminal.kind === "failed") {
-            const failure = asObject(terminal.failure);
-            termination = failure.code === "provider_recovery_exhausted"
-                ? "context_overflow"
-                : "error";
-        }
+function canonicalDoneFromTerminal(terminal) {
+    const usage = asObject(terminal.usage);
+    let termination = String(terminal.kind ?? "failed");
+    let turnsUsed = Number(usage.turns ?? 0);
+    if (terminal.kind === "agent") {
+        const result = asObject(terminal.result);
+        termination = String(result.termination ?? "completed");
+        turnsUsed = Number(result.turns_used ?? turnsUsed);
+        const finalMessage = asObject(result.final_message);
+        const pace = asObject(result.pace_decision);
         return {
-            kind: "done",
-            effectId: "",
+            kind: "done", effectId: "",
             result: {
-                termination,
-                turnsUsed,
-                totalTokensUsed: totalUsageTokens(terminal),
+                termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal),
+                ...(Object.keys(finalMessage).length > 0 ? { finalMessage: {
+                        role: String(finalMessage.role ?? "assistant"),
+                        content: String(finalMessage.content ?? ""),
+                        toolCalls: (Array.isArray(finalMessage.tool_calls) ? finalMessage.tool_calls : []).map(value => {
+                            const call = asObject(value);
+                            return { id: String(call.call_id ?? ""), name: String(call.name ?? ""), arguments: JSON.stringify(call.arguments ?? {}) };
+                        }),
+                    } } : {}),
+                ...(Object.keys(pace).length > 0 ? { paceDecision: {
+                        action: String(pace.action ?? "stop"),
+                        ...(pace.delay_ms !== undefined ? { delayMs: Number(pace.delay_ms) } : {}),
+                        reason: String(pace.reason ?? ""),
+                        ...(pace.coerced_from ? { coercedFrom: String(pace.coerced_from) } : {}),
+                    } } : {}),
             },
         };
     }
-    const published = plannedStep.disposition.effects ?? [];
-    if (published.length === 0)
+    if (terminal.kind === "workflow")
+        termination = String(asObject(terminal.outcome).status ?? "completed");
+    if (terminal.kind === "cancelled")
+        termination = String(terminal.reason ?? "cancelled");
+    if (terminal.kind === "failed")
+        termination = asObject(terminal.failure).code === "provider_recovery_exhausted" ? "context_overflow" : "error";
+    return { kind: "done", effectId: "", result: { termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal) } };
+}
+/** Adapt the additive core CurrentProjection JSON into the existing WASM action surface. */
+export function canonicalActionFromProjectionJson(raw) {
+    const projection = asObject(JSON.parse(raw));
+    const state = String(projection.state ?? "idle");
+    if (state === "idle")
         return null;
-    if (published.length !== 1) {
-        throw new Error(`WASM runner expects one canonical effect at a time, received ${published.length}`);
+    if (state === "terminal") {
+        return canonicalDoneFromTerminal(asObject(projection.action));
     }
-    const envelope = asObject(published[0]);
-    const effectId = String(envelope.effect_id ?? "");
-    const effect = asObject(envelope.effect);
-    if (!effectId)
-        throw new Error("canonical effect is missing effect_id");
-    switch (effect.kind) {
-        case "call_provider":
-            return {
-                kind: "call_provider",
-                effectId,
-                context: renderedContextToSdk(asObject(effect.context)),
-                tools: (Array.isArray(effect.tools) ? effect.tools : []).map(raw => {
-                    const tool = asObject(raw);
-                    return {
-                        name: String(tool.name ?? ""),
-                        description: String(tool.description ?? ""),
-                        parameters: JSON.stringify(tool.parameters ?? {}),
-                    };
-                }),
-            };
-        case "execute_tools":
-            return {
-                kind: "execute_tool",
-                effectId,
-                calls: (Array.isArray(effect.calls) ? effect.calls : []).map(raw => {
-                    const call = asObject(raw);
-                    return {
-                        id: String(call.call_id ?? ""),
-                        name: String(call.name ?? ""),
-                        arguments: JSON.stringify(call.arguments ?? {}),
-                    };
-                }),
-            };
-        case "request_approval":
-            return {
-                kind: "request_approval",
-                effectId,
-                requests: (Array.isArray(effect.requests) ? effect.requests : []).map(raw => {
-                    const request = asObject(raw);
-                    return {
-                        callId: String(request.call_id ?? ""),
-                        tool: String(request.tool_name ?? ""),
-                        arguments: JSON.stringify(request.arguments ?? {}),
-                        reason: String(request.reason ?? ""),
-                    };
-                }),
-            };
-        case "spawn_tasks":
-            return {
-                kind: "spawn_workflow",
-                effectId,
-                nodes: (Array.isArray(effect.tasks) ? effect.tasks : []).map(raw => {
-                    const task = asObject(raw);
-                    const spec = asObject(task.spec);
-                    return {
-                        agent_id: String(task.task_id ?? ""),
-                        task_id: String(task.task_id ?? ""),
-                        attempt_id: String(task.attempt_id ?? ""),
-                        launch_token: String(task.launch_token ?? ""),
-                        node_id: String(task.node_id ?? ""),
-                        goal: String(spec.goal ?? ""),
-                        role: String(spec.role ?? "custom"),
-                        isolation: String(spec.isolation ?? "shared"),
-                        context_inheritance: String(spec.context_inheritance ?? "none"),
-                        ...(spec.metadata && typeof spec.metadata === "object"
-                            ? asObject(spec.metadata)
-                            : {}),
-                    };
-                }),
-                ...(effect.budget ? { budget: asObject(effect.budget) } : {}),
-            };
-        case "preempt_tasks": {
-            const attempts = (Array.isArray(effect.attempts) ? effect.attempts : []).map(raw => {
-                const attempt = asObject(raw);
+    const action = asObject(projection.action);
+    const payload = asObject(action.payload);
+    const effectId = String(action.effect_id ?? "");
+    if (action.kind === "query_memory") {
+        return {
+            kind: "query_memory",
+            effectId,
+            query: asObject(payload.query),
+            requestedK: Number(payload.requested_k ?? 0),
+        };
+    }
+    if (action.kind === "execute_tools") {
+        return {
+            kind: "execute_tool",
+            effectId,
+            calls: (Array.isArray(payload.calls) ? payload.calls : []).map(raw => {
+                const call = asObject(raw);
                 return {
-                    task_id: String(attempt.task_id ?? ""),
-                    attempt_id: String(attempt.attempt_id ?? ""),
+                    id: String(call.call_id ?? ""),
+                    name: String(call.name ?? ""),
+                    arguments: JSON.stringify(call.arguments ?? {}),
                 };
-            });
-            return {
-                kind: "preempt_sub_agents",
-                effectId,
-                attempts,
-                agentIds: attempts.map(attempt => attempt.task_id),
-                reason: String(effect.reason ?? ""),
-            };
-        }
-        case "persist_memory":
-            return {
-                kind: "persist_memory",
-                effectId,
-                memory: asObject(effect.memory),
-            };
-        case "query_memory":
-            return {
-                kind: "query_memory",
-                effectId,
-                query: asObject(effect.query),
-                requestedK: Number(effect.requested_k ?? 0),
-            };
-        case "archive_page_out": {
-            const payload = asObject(effect.payload);
-            let archived = [];
-            try {
-                const decoded = JSON.parse(String(payload.content ?? ""));
-                if (Array.isArray(decoded)) {
-                    archived = decoded.map(value => kernelMessageToSdk(asObject(value)));
-                }
-            }
-            catch {
-                // Persistence still uses the opaque body and digest. Only optional presentation-side
-                // summarization is skipped if the archived message batch cannot be decoded.
-            }
-            const compressed = (plannedStep.observations ?? [])
-                .find(observation => observation.kind === "compressed");
-            const pressureAction = compressed ? String(compressed.action ?? "") : "";
-            return {
-                kind: "archive_page_out",
-                effectId,
-                handleId: String(effect.handle_id ?? ""),
-                payload,
-                archived,
-                ...(pressureAction ? { action: pressureAction } : {}),
-                ...(compressed?.summary ? { summary: String(compressed.summary) } : {}),
-                ...(pressureAction
-                    ? {
-                        tier: ["context_collapse", "auto_compact"].includes(pressureAction)
-                            ? "semantic"
-                            : "durable",
-                    }
-                    : {}),
-            };
+            }),
+        };
+    }
+    if (action.kind === "call_provider") {
+        const context = asObject(payload.context);
+        return {
+            kind: "call_provider",
+            effectId,
+            context: renderedContextToSdk(context),
+            tools: (Array.isArray(payload.tools) ? payload.tools : []).map(raw => {
+                const tool = asObject(raw);
+                return {
+                    name: String(tool.name ?? ""),
+                    description: String(tool.description ?? ""),
+                    parameters: JSON.stringify(tool.parameters ?? {}),
+                };
+            }),
+        };
+    }
+    if (action.kind === "request_approval") {
+        return {
+            kind: "request_approval",
+            effectId,
+            requests: (Array.isArray(payload.requests) ? payload.requests : []).map(raw => {
+                const request = asObject(raw);
+                return {
+                    callId: String(request.call_id ?? ""),
+                    tool: String(request.tool_name ?? ""),
+                    arguments: JSON.stringify(request.arguments ?? {}),
+                    reason: String(request.reason ?? ""),
+                };
+            }),
+        };
+    }
+    if (action.kind === "load_payload") {
+        return {
+            kind: "load_payload",
+            effectId,
+            handleId: String(payload.handle_id ?? ""),
+            payloadRef: String(payload.payload_ref ?? ""),
+        };
+    }
+    if (action.kind === "evaluate_milestone") {
+        const request = asObject(payload.request);
+        return {
+            kind: "evaluate_milestone",
+            effectId,
+            phaseId: String(request.phase_id ?? ""),
+            criteria: [],
+            requiredEvidence: [],
+        };
+    }
+    if (action.kind === "spawn_tasks") {
+        return {
+            kind: "spawn_workflow",
+            effectId,
+            nodes: (Array.isArray(payload.tasks) ? payload.tasks : []).map(raw => {
+                const task = asObject(raw);
+                const spec = asObject(task.spec);
+                return {
+                    agent_id: String(task.task_id ?? ""), task_id: String(task.task_id ?? ""),
+                    attempt_id: String(task.attempt_id ?? ""), launch_token: String(task.launch_token ?? ""),
+                    node_id: String(task.node_id ?? ""), goal: String(spec.goal ?? ""),
+                    role: String(spec.role ?? "custom"), isolation: String(spec.isolation ?? "shared"),
+                    context_inheritance: String(spec.context_inheritance ?? "none"),
+                    ...(spec.metadata && typeof spec.metadata === "object" ? asObject(spec.metadata) : {}),
+                };
+            }),
+            ...(payload.budget ? { budget: asObject(payload.budget) } : {}),
+        };
+    }
+    if (action.kind === "preempt_tasks") {
+        const attempts = (Array.isArray(payload.attempts) ? payload.attempts : []).map(raw => {
+            const attempt = asObject(raw);
+            return { task_id: String(attempt.task_id ?? ""), attempt_id: String(attempt.attempt_id ?? "") };
+        });
+        return { kind: "preempt_sub_agents", effectId, attempts, agentIds: attempts.map(a => a.task_id), reason: String(payload.reason ?? "") };
+    }
+    if (action.kind === "persist_memory") {
+        return { kind: "persist_memory", effectId, memory: asObject(payload.memory) };
+    }
+    if (action.kind === "archive_page_out") {
+        const archivePayload = asObject(payload.payload);
+        let archived = [];
+        try {
+            const decoded = JSON.parse(String(archivePayload.content ?? ""));
+            if (Array.isArray(decoded))
+                archived = decoded.map(value => kernelMessageToSdk(asObject(value)));
         }
-        case "load_payload":
-            return {
-                kind: "load_payload",
-                effectId,
-                handleId: String(effect.handle_id ?? ""),
-                payloadRef: String(effect.payload_ref ?? ""),
-            };
-        case "evaluate_milestone": {
-            const request = asObject(effect.request);
-            return {
-                kind: "evaluate_milestone",
-                effectId,
-                phaseId: String(request.phase_id ?? ""),
-                criteria: [],
-                requiredEvidence: [],
-            };
+        catch {
+            // The opaque archive payload remains authoritative even when presentation decoding fails.
         }
-        default:
-            return {
-                kind: "unsupported_effect",
-                effectId,
-                effectKind: String(effect.kind),
-            };
+        return {
+            kind: "archive_page_out",
+            effectId,
+            handleId: String(payload.handle_id ?? ""),
+            payload: {
+                content: String(archivePayload.content ?? ""),
+                digest: String(archivePayload.digest ?? ""),
+                original_size: String(archivePayload.original_size ?? "0"),
+                ...(archivePayload.preview ? { preview: String(archivePayload.preview) } : {}),
+            },
+            archived,
+        };
     }
+    return {
+        kind: "unsupported_effect",
+        effectId,
+        effectKind: String(action.kind ?? ""),
+    };
 }
 export class CanonicalKernelRejectedError extends Error {
     fault;
@@ -1165,6 +1111,16 @@ export class CanonicalRunnerRuntime {
                             throw new Error("canonical observation is missing kind");
                         this.hostObservations.push({ ...raw, kind });
                     }
+                    // §7.11 · a committed step that publishes effects is a fact worth recording in the
+                    // host event log: the journal stores only a digest of the step, so this manifest is
+                    // what makes the published effect ids + kinds recoverable post-hoc without replaying.
+                    const published = JSON.parse(this.host.kernel.publishedEffectsManifestJson(JSON.stringify(transition.plannedStep)));
+                    if (published.length > 0) {
+                        this.hostObservations.push({
+                            kind: "step_published_effects",
+                            effects: published,
+                        });
+                    }
                     if (transition.checkpointAdvice) {
                         this.hostObservations.push({
                             kind: "checkpoint_advised",
@@ -1178,7 +1134,7 @@ export class CanonicalRunnerRuntime {
                         });
                     }
                 }
-                this.lastAction = canonicalActionFromPlannedStep(transition.plannedStep);
+                this.lastAction = canonicalActionFromProjectionJson(this.host.kernel.projectPlannedStepJson(JSON.stringify(transition.plannedStep)));
             }
             if (this.lastAction?.kind !== "unsupported_effect")
                 return this.lastAction;
@@ -1186,16 +1142,7 @@ export class CanonicalRunnerRuntime {
         }
     }
     currentAction() {
-        const terminal = this.host.kernel.terminalJson();
-        if (terminal) {
-            return canonicalActionFromPlannedStep({
-                disposition: { kind: "terminal", terminal: JSON.parse(terminal) },
-            });
-        }
-        const effects = this.pendingEffects();
-        return canonicalActionFromPlannedStep({
-            disposition: { kind: "effects", effects },
-        });
+        return canonicalActionFromProjectionJson(this.host.kernel.currentProjectionJson());
     }
     pendingEffects() {
         return JSON.parse(this.host.kernel.pendingEffectsJson());

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

@@ -0,0 +1,118 @@
+/**
+ * P4 (0.2.64 Execution Evidence Plane): wasm mirror of the host-side object model connecting
+ * kernel-minted effects to real provider execution — ModelInvocation / ProviderAttempt /
+ * ResolvedProviderRoute / UsageAccountingPolicy. Everything here is L2 host evidence (B7):
+ * it lands in SessionLog for cross-verification against the journal (C6/C8) and is NEVER
+ * fed back as kernel input (B4/DEC-2 discipline: wall-clock and wire facts stay host-side).
+ */
+import type { ProviderWireEvidence } from "../types.js";
+import type { NormalizedProviderUsage, ResolvedProviderRoute } from "../providers/request-plan.js";
+/** Canonical stop-reason vocabulary already carried on the wire usage frame (types.ts). */
+export type CanonicalStopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "content_filtered";
+/**
+ * P4 §1.1: one logical model call = the fact-connected chain of CallProvider effects the
+ * kernel walked to obtain one turn of model output. Derived identity, zero minting:
+ * `invocationId` IS the first effect's effect_id. Authority = journal; the SessionLog
+ * projection (`llm_completed.invocation_id`) is evidence only.
+ */
+export interface ModelInvocation {
+    invocationId: string;
+    turn: number;
+    /** Every effect_id on the chain, in order. Length 1 = first attempt succeeded. */
+    effectChain: string[];
+    outcome?: InvocationOutcome;
+}
+/** P4 §1.4: the invocation's terminal projection. */
+export interface InvocationOutcome {
+    invocationId: string;
+    /** The effect the kernel adopted as the outcome (the successful one). */
+    selectedEffectId: string;
+    stopReason?: CanonicalStopReason;
+    /** Absent on a failed chain (nothing settled). */
+    settlement?: UsageSettlement;
+}
+export type ProviderAttemptStatus = "success" | "transport_exhausted" | "aborted" | "rejected";
+/**
+ * P4 §1.2: one effect's execution against one route, one physical attempt. The kernel-minted
+ * `effectId` is the primary key (H7 — no parallel id minting). Transport-ladder rungs are
+ * summarized as a count plus the final error class; rung-level evidence belongs to adapter
+ * debug logs, not SessionLog.
+ */
+export interface ProviderAttempt {
+    effectId: string;
+    /** Failover sequence within one effect execution (1-based). Always 1 today (P4 §0.2). */
+    attemptSeq: number;
+    route: ResolvedProviderRoute;
+    /** → ProviderRequestPlan.fingerprint (G2). */
+    requestFingerprint: string;
+    status: ProviderAttemptStatus;
+    transportRungs: number;
+    /** classifyProviderError's class, never the raw vendor text (B1 spirit). */
+    lastErrorClass?: string;
+    /** Host wall-clock, pure evidence, never kernel input (DEC-2 discipline). */
+    startedAtMs: number;
+    finishedAtMs: number;
+    /** Full measurement fields (P4 §2); only the settlement crosses the kernel boundary (B4). */
+    usage?: NormalizedProviderUsage;
+    wireEvidence?: ProviderWireEvidence;
+}
+/**
+ * The SessionLog wire payload of a ProviderAttempt (P4 §3): the §1.2 fields flattened into
+ * the event, snake_case per SessionLog convention. Nested objects keep their native shape
+ * (same convention as `prompt_measured.measurement`).
+ */
+export interface ProviderAttemptRecord {
+    effect_id: string;
+    attempt_seq: number;
+    route: ResolvedProviderRoute;
+    request_fingerprint: string;
+    status: ProviderAttemptStatus;
+    transport_rungs: number;
+    last_error_class?: string;
+    started_at_ms: number;
+    finished_at_ms: number;
+    usage?: NormalizedProviderUsage;
+    wire_evidence?: ProviderWireEvidence;
+    /** P4 §2.1: the accounting policy this attempt's settlement was/will be derived with —
+     *  pinned on the attempt so settlement is deterministically recomputable from
+     *  (measurement, policy_id). */
+    accounting_policy_id?: string;
+}
+export declare function providerAttemptToRecord(attempt: ProviderAttempt, accountingPolicyId?: string): ProviderAttemptRecord;
+/**
+ * P4 §2: the only two numbers that cross the kernel boundary (B4). Field names match the
+ * existing ResolveEffect wire shape — this is what the runner already feeds the kernel as
+ * `observed_input_tokens` / `observed_output_tokens`.
+ */
+export interface UsageSettlement {
+    observed_input_tokens: number;
+    observed_output_tokens: number;
+}
+/**
+ * P4 §2.1: the named, pinnable, replayable policy turning a measurement into a settlement.
+ * `settle` must be a pure function of the measurement — given (usage, policyId) any auditor
+ * recomputes the identical settlement.
+ */
+export interface UsageAccountingPolicy {
+    policyId: string;
+    settle(usage: NormalizedProviderUsage): UsageSettlement;
+}
+/**
+ * The default policy = today's implicit runner behavior exactly (full input footprint + full
+ * output footprint — the two numbers the runner has always fed `observed_*`). P4 changes no
+ * default numbers; it only makes the conversion a named object. The date stamp is the
+ * policy's identity: any future semantics change MUST ship under a new policyId.
+ */
+export declare const FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY: UsageAccountingPolicy;
+/**
+ * Defensive measurement assembly for the attempt evidence path: an invalid frame (cache
+ * subsets exceeding input, etc.) degrades to NO measurement instead of breaking the run —
+ * evidence is never worth a run failure, and the settlement falls back to the raw counts.
+ */
+export declare function tryNormalizeProviderUsage(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    reasoningTokens?: number;
+}): NormalizedProviderUsage | undefined;

package/dist/runtime/execution-evidence.js

@@ -0,0 +1,45 @@
+import { normalizeProviderUsage } from "../providers/request-plan.js";
+export function providerAttemptToRecord(attempt, accountingPolicyId) {
+    return {
+        effect_id: attempt.effectId,
+        attempt_seq: attempt.attemptSeq,
+        route: attempt.route,
+        request_fingerprint: attempt.requestFingerprint,
+        status: attempt.status,
+        transport_rungs: attempt.transportRungs,
+        ...(attempt.lastErrorClass !== undefined ? { last_error_class: attempt.lastErrorClass } : {}),
+        started_at_ms: attempt.startedAtMs,
+        finished_at_ms: attempt.finishedAtMs,
+        ...(attempt.usage !== undefined ? { usage: attempt.usage } : {}),
+        ...(attempt.wireEvidence !== undefined ? { wire_evidence: attempt.wireEvidence } : {}),
+        ...(accountingPolicyId !== undefined ? { accounting_policy_id: accountingPolicyId } : {}),
+    };
+}
+/**
+ * The default policy = today's implicit runner behavior exactly (full input footprint + full
+ * output footprint — the two numbers the runner has always fed `observed_*`). P4 changes no
+ * default numbers; it only makes the conversion a named object. The date stamp is the
+ * policy's identity: any future semantics change MUST ship under a new policyId.
+ */
+export const FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY = {
+    policyId: "deepstrike.full-footprint@2026-09-15",
+    settle(usage) {
+        return {
+            observed_input_tokens: usage.inputTokens,
+            observed_output_tokens: usage.outputTokens,
+        };
+    },
+};
+/**
+ * Defensive measurement assembly for the attempt evidence path: an invalid frame (cache
+ * subsets exceeding input, etc.) degrades to NO measurement instead of breaking the run —
+ * evidence is never worth a run failure, and the settlement falls back to the raw counts.
+ */
+export function tryNormalizeProviderUsage(usage) {
+    try {
+        return normalizeProviderUsage(usage);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/runtime/index.d.ts

@@ -1,5 +1,6 @@
-export type { SessionEvent, SessionLog } from "./session-log.js";
+export type { SessionEvent, SessionEventKind, SessionLog } from "./session-log.js";
 export { InMemorySessionLog } from "./session-log.js";
+export { SESSION_EVENT_KINDS } from "./session-log.js";
 export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
 export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, JournalStorageDriver, KernelJournal, } from "./kernel-journal.js";
 export * from "./context-policy.js";
@@ -9,7 +10,7 @@ export type { MemoryPolicy, MemoryWriteRateLimit, OperationCancellationReason, P
 export { RuntimeRunner, collectText } from "./runner.js";
 export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
 export type { PayloadStorageDriver, PayloadStoreConfig } from "./payload-store.js";
-export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, canonicalActionFromPlannedStep, sha256, } from "./canonical-kernel-step.js";
+export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, sha256, } from "./canonical-kernel-step.js";
 export type { CanonicalKernelInput, CanonicalPlannedStep, CanonicalRunnerRuntimeOptions, CanonicalTransition, CanonicalTransitionOptions, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";

package/dist/runtime/index.js

@@ -1,11 +1,13 @@
 export { InMemorySessionLog } from "./session-log.js";
+// Registered session-event vocabulary (F9/S3; manifest-pinned by sdk-conformance, P7-S4)
+export { SESSION_EVENT_KINDS } from "./session-log.js";
 // Durable transaction capability (Canonical Kernel ABI §9.1)
 export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
 export * from "./context-policy.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export { RuntimeRunner, collectText } from "./runner.js";
 export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
-export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, canonicalActionFromPlannedStep, sha256, } from "./canonical-kernel-step.js";
+export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, sha256, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";

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

@@ -22,6 +22,11 @@ export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-part
 /**
  * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
  * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.
+ *
+ * Byte contract (content-parts-v1, F14/B5): compact JSON with literal UTF-8, insertion key
+ * order, **base64url alphabet, no padding** — identical bytes to the Node and Python SDKs.
+ * Decode stays lenient (both alphabets, optional padding) so payloads written before the
+ * url-alphabet alignment remain readable.
  */
 export declare function encodeCanonicalContentParts(parts: unknown[]): string;
 export declare function decodeCanonicalContentParts(content: string): Array<Record<string, unknown>> | undefined;
@@ -84,11 +89,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    turn?: number;
-    action?: string;
-    summary?: string;
     archived: Message[];
-    tier?: string;
     handleId?: string;
     payload?: {
         content: string;
@@ -204,7 +205,17 @@ export interface KernelObservation {
     rollbacks_in_window?: number;
     window_turns?: number;
     threshold?: number;
+    effects?: Array<{
+        effect_id: string;
+        kind: string;
+    }>;
 }
+/** Presentation/policy facts for archive actions are sourced from committed observations. */
+export declare function archivePresentationFromObservations(observations: readonly KernelObservation[]): {
+    action?: string;
+    summary?: string;
+    tier?: "semantic" | "durable";
+};
 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>;

package/dist/runtime/kernel-step.js

@@ -2,19 +2,28 @@ export const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
 /**
  * Browser/worker-safe transport for typed content. `btoa` and `atob` operate on
  * binary strings, so explicitly bridge UTF-8 bytes rather than assuming Latin-1.
+ *
+ * Byte contract (content-parts-v1, F14/B5): compact JSON with literal UTF-8, insertion key
+ * order, **base64url alphabet, no padding** — identical bytes to the Node and Python SDKs.
+ * Decode stays lenient (both alphabets, optional padding) so payloads written before the
+ * url-alphabet alignment remain readable.
  */
 export function encodeCanonicalContentParts(parts) {
     const bytes = new TextEncoder().encode(JSON.stringify(parts));
     let binary = "";
     for (const byte of bytes)
         binary += String.fromCharCode(byte);
-    return `${CANONICAL_CONTENT_PARTS_PREFIX}${btoa(binary)}`;
+    const payload = btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+    return `${CANONICAL_CONTENT_PARTS_PREFIX}${payload}`;
 }
 export function decodeCanonicalContentParts(content) {
     if (!content.startsWith(CANONICAL_CONTENT_PARTS_PREFIX))
         return undefined;
     try {
-        const binary = atob(content.slice(CANONICAL_CONTENT_PARTS_PREFIX.length));
+        const raw = content.slice(CANONICAL_CONTENT_PARTS_PREFIX.length);
+        const standard = raw.replaceAll("-", "+").replaceAll("_", "/");
+        const padded = standard + "=".repeat((4 - (standard.length % 4)) % 4);
+        const binary = atob(padded);
         const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
         const decoded = JSON.parse(new TextDecoder().decode(bytes));
         return Array.isArray(decoded)
@@ -25,6 +34,18 @@ export function decodeCanonicalContentParts(content) {
         return undefined;
     }
 }
+/** Presentation/policy facts for archive actions are sourced from committed observations. */
+export function archivePresentationFromObservations(observations) {
+    const compressed = [...observations].reverse().find(observation => observation.kind === "compressed");
+    const action = compressed?.action;
+    if (action !== "snip_compact" && action !== "micro_compact" && action !== "context_collapse" && action !== "auto_compact")
+        return {};
+    return {
+        action,
+        ...(compressed?.summary ? { summary: compressed.summary } : {}),
+        tier: action === "context_collapse" || action === "auto_compact" ? "semantic" : "durable",
+    };
+}
 function tryParseJson(s) {
     try {
         return JSON.parse(s);

package/dist/runtime/runner.js

@@ -8,7 +8,7 @@ import { sanitizeReplayText } from "./replay-sanitize.js";
 import { decodeDurableContent, decodeDurableToolResult, durableBlocksToToolOutput, toolOutputBlocksToDurable } from "./durable-content.js";
 import { formatToolError } from "../tools/errors.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, } from "./session-repair.js";
-import { messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { messageToKernelMessage, archivePresentationFromObservations, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
 import { agentRunSpecToKernel, MILESTONE_UNVERIFIED_REASON, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowBudgetNote, workflowNodeSpecToKernel, workflowNodeOutcomeFromKernel, workflowNodeStatusFromTermination, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
@@ -899,8 +899,8 @@ export class RuntimeRunner {
                         error = formatToolError(cause);
                     }
                     const archived = action.archived;
-                    const archiveAction = compressionAction(action.action) ?? "auto_compact";
-                    const archiveTier = action.tier;
+                    const archiveAction = archiveMeta.action ?? "auto_compact";
+                    const archiveTier = archiveMeta.tier;
                     if (!error)
                         this.activePageOutArchive = undefined;
                     action = await this.commitKernelAction(runtime, this.pendingObservations, {
@@ -1767,7 +1767,11 @@ export class RuntimeRunner {
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
                 if ((obs.archived_count ?? 0) > 0) {
-                    this.pendingPageOutArchives.push({ archiveStart: nextArchiveStart, compressedSeq });
+                    this.pendingPageOutArchives.push({
+                        archiveStart: nextArchiveStart,
+                        compressedSeq,
+                        ...archivePresentationFromObservations([obs]),
+                    });
                 }
                 nextArchiveStart = compressedSeq + 1;
             }

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

@@ -1,8 +1,8 @@
-import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+import type { ProviderReplay, 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";
-import type { RecordedPromptMeasurement } from "../providers/request-plan.js";
+import type { NormalizedProviderUsage, RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -22,6 +22,25 @@ export type RollbackReason = {
     kind: "malformed_replay";
     reason: string;
 };
+/**
+ * P4 §3 mirror: the SessionLog wire payload of a ProviderAttempt (P4 §1.2 fields, flattened,
+ * snake_case). Nested objects keep their native shape. The kernel-minted effect_id joins this
+ * host evidence to the journal effect chain 1:1 (C6); step_seq NEVER enters SessionLog (P2 §4).
+ */
+export interface ProviderAttemptRecord {
+    effect_id: string;
+    attempt_seq: number;
+    route: ResolvedProviderRoute;
+    request_fingerprint: string;
+    status: "success" | "transport_exhausted" | "aborted" | "rejected";
+    transport_rungs: number;
+    last_error_class?: string;
+    started_at_ms: number;
+    finished_at_ms: number;
+    usage?: NormalizedProviderUsage;
+    wire_evidence?: ProviderWireEvidence;
+    accounting_policy_id?: string;
+}
 export type SessionEvent = {
     kind: "run_started";
     run_id: string;
@@ -30,6 +49,7 @@ export type SessionEvent = {
     agent_id?: string;
     system_prompt?: string;
     attachments?: import("../types.js").ContentPart[];
+    route?: ResolvedProviderRoute;
 } | {
     kind: "llm_completed";
     turn: number;
@@ -37,11 +57,17 @@ export type SessionEvent = {
     token_count?: number;
     tool_calls: ToolCall[];
     provider_replay?: ProviderReplay;
+    effect_id?: string;
+    invocation_id?: string;
+    wire_evidence?: ProviderWireEvidence;
 } | {
     kind: "prompt_measured";
     turn: number;
     measurement: RecordedPromptMeasurement;
-} | {
+    effect_id?: string;
+} | ({
+    kind: "provider_attempt";
+} & ProviderAttemptRecord) | {
     kind: "tool_requested";
     turn: number;
     calls: ToolCall[];
@@ -59,6 +85,7 @@ export type SessionEvent = {
             blocks: Record<string, unknown>[];
         };
     }>;
+    effect_id?: string;
 } | {
     kind: "tool_argument_repaired";
     turn: number;
@@ -98,6 +125,18 @@ export type SessionEvent = {
     tier_hint?: string;
     message_count?: number;
     archive_ref?: string;
+} | {
+    kind: "semantic_archive_pending";
+    effect_id: string;
+    action?: string;
+} | {
+    kind: "semantic_archive_completed";
+    effect_id: string;
+    record_id: string;
+} | {
+    kind: "semantic_archive_failed";
+    effect_id: string;
+    error: string;
 } | {
     kind: "page_in";
     turn: number;
@@ -228,6 +267,17 @@ export type SessionEvent = {
     turn: number;
     record_id: string;
     error: string;
+} | {
+    kind: "memory_write_failed";
+    turn: number;
+    record_id: string;
+    error: string;
+} | {
+    kind: "memory_query_failed";
+    turn: number;
+    scope: MemoryScope;
+    query: string;
+    error: string;
 } | {
     kind: "memory_retrieval_result";
     hits: MemoryRecall[];
@@ -278,7 +328,39 @@ export type SessionEvent = {
     kind: "summary_upgraded";
     compressed_seq: number;
     summary: string;
+} | {
+    kind: "group_member_joined";
+    session_id: string;
+    role?: string;
+    member_kind?: "peer" | "vehicle";
+} | {
+    kind: "group_budget_charged";
+    tokens: number;
+    subagents: number;
+    rounds?: number;
+} | {
+    kind: "round_started";
+    /** 1-based round number within the loop. */
+    round: number;
+    goal: string;
+} | {
+    kind: "round_paced";
+    round: number;
+    action: "continue" | "sleep" | "stop";
+    delay_ms?: number;
+    /** Absolute wake time for sleep — lets a stateless host re-arm from the log alone. */
+    wake_at_ms?: number;
+    reason: string;
+    coerced_from?: string;
 };
+export type SessionEventKind = SessionEvent["kind"];
+/**
+ * The registered session-event vocabulary (F9 / S3, P7-S4). This list must equal the Node SDK's
+ * `SESSION_EVENT_KINDS` — the cross-SDK manifest fixture
+ * `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"];
 /**
  * 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

@@ -1,5 +1,64 @@
 import { primitiveForKind } from "./kernel-event-log.js";
 import { InMemoryKernelJournal } from "./kernel-journal.js";
+/**
+ * The registered session-event vocabulary (F9 / S3, P7-S4). This list must equal the Node SDK's
+ * `SESSION_EVENT_KINDS` — the cross-SDK manifest fixture
+ * `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 const SESSION_EVENT_KINDS = [
+    "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",
+];
+const _vocabularyCoversUnion = true;
+void _vocabularyCoversUnion;
 /**
  * **Single-isolate dev/test implementation** of both capabilities (spec §9.4: one class may
  * implement several capabilities; the *interfaces* stay separate). Its `KernelJournal` half is

package/dist/types.d.ts

@@ -273,6 +273,21 @@ export interface ProviderReplay {
     native_message?: unknown;
     tool_calls?: unknown[];
 }
+/** P3 §3.3 (D1) mirror of the node ProviderWireEvidence — SessionLog wire evidence bundle. */
+export interface ProviderWireEvidence {
+    protocol: ProviderProtocol;
+    /** → ProviderRequestPlan.fingerprint. Mandatory non-empty (G2). */
+    request_fingerprint: string;
+    response_id?: string;
+    /** BoundedJson semantics: producers truncate to ≤4KB. */
+    raw_usage?: unknown;
+    replay_state?: ProviderReplay;
+}
+/** P4 §1.2 mirror: host-observed transport facts for one provider execution. */
+export interface ProviderTransportTelemetry {
+    rungs: number;
+    responseId?: string;
+}
 export interface LLMProvider {
     createRunState?(): ProviderRunState;
     runtimePolicy?(): {
@@ -291,6 +306,8 @@ export interface LLMProvider {
     };
     peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    /** P4-S1 mirror: transport facts of the most recent execution (host evidence only, B7). */
+    peekTransportTelemetry?(): ProviderTransportTelemetry | undefined;
     countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, 

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.61",
+  "version": "0.2.63",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
+  "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,10 +14,10 @@
     "build:wasm": "wasm-pack build ../crates/deepstrike-wasm --target bundler --out-dir ../../wasm/pkg",
     "build": "tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs"
+    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.61"
+    "@deepstrike/wasm-kernel": "0.2.63"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",