@deepstrike/wasm 0.2.76 → 0.2.78

package/dist/providers/anthropic.js

@@ -1,6 +1,7 @@
 import { requestSnapshot } from "./prepared-request.js";
 import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from "./base.js";
 import { malformedToolArguments, toolArgumentsText } from "../runtime/tool-arguments.js";
+import { OnDemandCompactor, THRESHOLD_COMPACTION_BETA, compactionBlock, resolveCompaction, resumeAfterCompactionPause, withoutCompactionPause, } from "./anthropic-compaction.js";
 /** Anthropic accepts at most this many cache_control breakpoints per request. */
 const MAX_CACHE_BREAKPOINTS = 4;
 /** Rolling cache breakpoints reserved for the message history (system uses ≤2). */
@@ -117,15 +118,53 @@ function assertCacheBudget(system, toolCount) {
         throw new Error(`Anthropic cache_control budget exceeded: ${systemBreakpoints} system + ${toolBreakpoints} tool + ${MESSAGE_CACHE_BREAKPOINTS} message > ${MAX_CACHE_BREAKPOINTS}`);
     }
 }
+const CONTEXT_MANAGEMENT_BETA = "context-management-2025-06-27";
+const PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
+/** The leading wire messages that are history; the state turn follows them. */
+function historyCount(wireTurns) {
+    return wireTurns.filter(index => index >= 0).length;
+}
+function clearToolUsesEdit(config) {
+    const c = config === true ? {} : config;
+    return {
+        type: "clear_tool_uses_20250919",
+        ...(c.triggerInputTokens !== undefined ? { trigger: { type: "input_tokens", value: c.triggerInputTokens } } : {}),
+        ...(c.keepToolUses !== undefined ? { keep: { type: "tool_uses", value: c.keepToolUses } } : {}),
+        ...(c.clearAtLeastInputTokens !== undefined ? { clear_at_least: { type: "input_tokens", value: c.clearAtLeastInputTokens } } : {}),
+        ...(c.excludeTools?.length ? { exclude_tools: [...c.excludeTools] } : {}),
+        ...(c.clearToolInputs !== undefined ? { clear_tool_inputs: c.clearToolInputs } : {}),
+    };
+}
 export class AnthropicProvider {
     apiKey;
     model;
     maxTokens;
     nativeAssistantBlocks = new Map();
-    constructor(apiKey, model = "claude-sonnet-4-6", maxTokens = 8096) {
+    /** Server-side context edits and the beta each needs. */
+    nativeContextEdits = [];
+    /** Threshold compaction with a pause: how many history messages stay verbatim behind the block. */
+    compactionPauseKeep;
+    onDemandCompactor;
+    constructor(apiKey, model = "claude-sonnet-4-6", maxTokens = 8096, options = {}) {
         this.apiKey = apiKey;
         this.model = model;
         this.maxTokens = maxTokens;
+        // Clearing runs first so the compaction trigger reads the input after tool results are cleared.
+        if (options.contextEditing)
+            this.nativeContextEdits.push({ beta: CONTEXT_MANAGEMENT_BETA, edit: clearToolUsesEdit(options.contextEditing) });
+        const compaction = options.compaction ? resolveCompaction(options.compaction) : undefined;
+        if (compaction?.mode === "threshold") {
+            this.nativeContextEdits.push({ beta: THRESHOLD_COMPACTION_BETA, edit: compaction.edit });
+            if (compaction.edit.pause_after_compaction)
+                this.compactionPauseKeep = compaction.keepRecentMessages ?? 0;
+        }
+        else if (compaction?.mode === "on_demand") {
+            this.onDemandCompactor = new OnDemandCompactor(compaction.config, body => this.createMessage(body));
+        }
+    }
+    /** On-demand compaction in flight settles; for tests and orderly shutdown. */
+    compactionIdle() {
+        return this.onDemandCompactor?.idle() ?? Promise.resolve();
     }
     descriptor() {
         return {
@@ -141,6 +180,12 @@ export class AnthropicProvider {
                 supported: true,
                 requiresStrictPairing: true,
             },
+            ...(this.nativeContextEdits.length || this.onDemandCompactor ? {
+                nativeContext: {
+                    ...(this.nativeContextEdits.some(native => native.edit.type === "clear_tool_uses_20250919") ? { toolResultClearing: true } : {}),
+                    ...(this.onDemandCompactor || this.nativeContextEdits.some(native => native.edit.type === "compact_20260112") ? { compaction: true } : {}),
+                },
+            } : {}),
         };
     }
     requestPlanIdentity() {
@@ -174,16 +219,37 @@ export class AnthropicProvider {
             systemBlocks.push({ type: "text", text: context.systemKnowledge, ...(emitOnSystemBlocks ? { cache_control: cc } : {}) });
         }
         const system = systemBlocks.length ? systemBlocks : (context.systemText || undefined);
-        const msgs = toAnthropicMessages(context, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
-        applyMessageCacheControl(msgs, context.frozenPrefixLen, strategy);
+        const replay = (message) => this.nativeAssistantBlocks.get(assistantReplayKey(message));
+        let msgs = [];
+        // For each wire message, the index of the rendered turn it came from; the state turn is -1.
+        let wireTurns = [];
+        context.turns.forEach((turn, index) => {
+            for (const message of toAnthropicMessages({ systemText: "", turns: [turn] }, replay)) {
+                msgs.push(message);
+                wireTurns.push(index);
+            }
+        });
+        // The API ignores everything before a compaction block, so it is not sent.
+        let head = -1;
+        for (let index = msgs.length - 1; index >= 0 && head < 0; index--) {
+            const content = msgs[index].content;
+            if (Array.isArray(content) && content.some(block => block.type === "compaction"))
+                head = index;
+        }
+        if (head > 0) {
+            msgs = msgs.slice(head);
+            wireTurns = wireTurns.slice(head);
+        }
+        applyMessageCacheControl(msgs, typeof context.frozenPrefixLen === "number" && head > 0 ? context.frozenPrefixLen - head : context.frozenPrefixLen, strategy);
         // Append the volatile State turn AFTER the cache breakpoints (uncached tail);
         // absent on un-rebuilt bindings, where the state is already inside `turns`.
         // Render through toAnthropicMessages so assistant tool_use blocks are
         // serialized correctly — raw content would silently drop toolCalls.
         if (context.stateTurn) {
             const stateCtx = { systemText: "", turns: [context.stateTurn] };
-            const stateMsgs = toAnthropicMessages(stateCtx, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
+            const stateMsgs = toAnthropicMessages(stateCtx, replay);
             msgs.push(...stateMsgs);
+            wireTurns.push(...stateMsgs.map(() => -1));
         }
         assertCacheBudget(system, tools.length);
         const builtTools = tools.length ? buildAnthropicTools(tools, !Array.isArray(system), strategy) : undefined;
@@ -200,25 +266,113 @@ export class AnthropicProvider {
         if (extensions?.enable_thinking) {
             body.thinking = { type: "enabled", budget_tokens: 8000 };
         }
+        // The kernel stopped running these tiers on the strength of the edits, so they ride on every
+        // request beside any betas or edits the caller passed.
+        if (this.nativeContextEdits.length) {
+            const betas = Array.isArray(extensions?.betas) ? extensions.betas.filter((value) => typeof value === "string") : [];
+            const callerManagement = extensions?.context_management && typeof extensions.context_management === "object"
+                ? extensions.context_management
+                : {};
+            const edits = Array.isArray(callerManagement.edits) ? [...callerManagement.edits] : [];
+            for (const native of this.nativeContextEdits) {
+                if (!betas.includes(native.beta))
+                    betas.push(native.beta);
+                if (!edits.some(edit => edit?.type === native.edit.type))
+                    edits.push(native.edit);
+            }
+            body.betas = betas;
+            body.context_management = { ...callerManagement, edits };
+        }
+        this.onDemandCompactor?.apply(body);
         const frozenBody = requestSnapshot(body);
         return {
             scope: "encoded_body", request: requestSnapshot(frozenBody), state: requestSnapshot(state ?? null),
-            stream: signal => this.streamBody(frozenBody, slotBp, signal),
+            stream: signal => this.streamTurn(context, frozenBody, wireTurns, slotBp, signal),
         };
     }
+    /** One turn: the response's events, or — when a compaction pause stops the response at the
+     *  summary — the continuation's. With a pause configured, events are held until the response
+     *  shows it is not a pause (any non-usage event) or ends. */
+    async *streamTurn(context, body, wireTurns, slotBp, signal) {
+        const first = this.streamBody(body, slotBp, signal)[Symbol.asyncIterator]();
+        let held = this.compactionPauseKeep !== undefined ? [] : undefined;
+        let outcome;
+        for (;;) {
+            const next = await first.next();
+            if (next.done) {
+                outcome = next.value;
+                break;
+            }
+            if (held && next.value.type !== "usage") {
+                yield* held;
+                held = undefined;
+            }
+            if (held)
+                held.push(next.value);
+            else
+                yield next.value;
+        }
+        const paused = held && outcome.stopReason === "compaction" ? compactionBlock(outcome.nativeBlocks) : undefined;
+        let unanchoredBlock;
+        if (paused) {
+            const resumed = resumeAfterCompactionPause(body.messages, historyCount(wireTurns), paused, this.compactionPauseKeep);
+            if (resumed.anchor) {
+                const turn = context.turns[wireTurns[resumed.anchor.wireIndex]];
+                if (turn)
+                    this.nativeAssistantBlocks.set(assistantReplayKey(turn), resumed.anchor.content);
+            }
+            else {
+                unanchoredBlock = paused;
+            }
+            const continuation = this.streamBody({ ...withoutCompactionPause(body), messages: resumed.messages }, slotBp, signal)[Symbol.asyncIterator]();
+            for (;;) {
+                const next = await continuation.next();
+                if (next.done) {
+                    outcome = next.value;
+                    break;
+                }
+                yield next.value;
+            }
+        }
+        else if (held) {
+            yield* held;
+        }
+        this.rememberNativeBlocks({ content: outcome.finalText, toolCalls: outcome.finalToolCalls }, [...(unanchoredBlock ? [unanchoredBlock] : []), ...outcome.nativeBlocks]);
+        this.onDemandCompactor?.observe(body, historyCount(wireTurns), outcome.totalTokens);
+    }
+    headers(body) {
+        return {
+            "x-api-key": this.apiKey,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+            "anthropic-beta": [
+                PROMPT_CACHING_BETA,
+                ...(Array.isArray(body.betas) ? body.betas.filter((value) => typeof value === "string" && value !== PROMPT_CACHING_BETA) : []),
+            ].filter((value, index, values) => values.indexOf(value) === index).join(","),
+        };
+    }
+    /** A non-streaming request; the on-demand compaction request goes this way. */
+    async createMessage(body) {
+        const resp = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: this.headers(body),
+            // Betas travel in the header; the Messages API refuses them as a body field.
+            body: JSON.stringify({ ...body, stream: undefined, betas: undefined }),
+        });
+        if (!resp.ok) {
+            throw Object.assign(new Error(`Anthropic ${resp.status}: ${await resp.text()}`), { status: resp.status });
+        }
+        return await resp.json();
+    }
     async *stream(context, tools, extensions, state, signal) {
         yield* this.prepareRequest(context, tools, extensions, state).stream(signal);
     }
     async *streamBody(body, slotBp, signal) {
         const resp = await fetch("https://api.anthropic.com/v1/messages", {
             method: "POST",
-            headers: {
-                "x-api-key": this.apiKey,
-                "anthropic-version": "2023-06-01",
-                "content-type": "application/json",
-                "anthropic-beta": "prompt-caching-2024-07-31",
-            },
-            body: JSON.stringify(body),
+            headers: this.headers(body),
+            // Betas travel in the header; the Messages API refuses them as a body field.
+            body: JSON.stringify({ ...body, betas: undefined }),
             ...(signal ? { signal } : {}), // #2-B-ii: a preempt aborts the in-flight request at the socket.
         });
         if (!resp.ok) {
@@ -235,6 +389,14 @@ export class AnthropicProvider {
         let cacheReadTokens = 0;
         let cacheCreationTokens = 0;
         let outputTokens = 0;
+        let stopReason;
+        const outcome = () => ({
+            nativeBlocks: Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]),
+            finalText,
+            finalToolCalls,
+            ...(stopReason ? { stopReason } : {}),
+            totalTokens: uncachedInput + cacheReadTokens + cacheCreationTokens + outputTokens,
+        });
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -247,10 +409,15 @@ export class AnthropicProvider {
                     continue;
                 const data = line.slice(6).trim();
                 if (data === "[DONE]")
-                    return;
+                    return outcome();
                 try {
                     const evt = JSON.parse(data);
                     if (evt.type === "message_start" || evt.type === "message_delta") {
+                        // stop_reason rides on message_delta; "max_tokens" drives output-cap recovery and
+                        // "compaction" marks a paused threshold compaction.
+                        const eventStopReason = evt.delta?.stop_reason ?? undefined;
+                        if (eventStopReason)
+                            stopReason = eventStopReason;
                         const usage = (evt.usage ?? evt.message?.usage);
                         if (usage) {
                             // input + cache counts are pinned at message_start; a later
@@ -264,8 +431,6 @@ export class AnthropicProvider {
                             const inputTokens = uncachedInput + cacheReadTokens + cacheCreationTokens;
                             if (inputTokens > 0 || outputTokens > 0) {
                                 const bySlot = estimateCacheReadBySlot(cacheReadTokens, slotBp);
-                                // stop_reason rides on message_delta; "max_tokens" drives output-cap recovery.
-                                const stopReason = evt.delta?.stop_reason;
                                 yield {
                                     type: "usage",
                                     totalTokens: inputTokens + outputTokens,
@@ -274,7 +439,7 @@ export class AnthropicProvider {
                                     cacheReadInputTokens: cacheReadTokens,
                                     cacheCreationInputTokens: cacheCreationTokens,
                                     ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
-                                    ...(stopReason ? { stopReason } : {}),
+                                    ...(eventStopReason ? { stopReason: eventStopReason } : {}),
                                 };
                             }
                         }
@@ -298,6 +463,10 @@ export class AnthropicProvider {
                             nativeBlocks[idx] = { ...nativeBlocks[idx], thinking: String(nativeBlocks[idx]?.thinking ?? "") + d.thinking };
                             yield { type: "thinking_delta", delta: d.thinking };
                         }
+                        else if (d.type === "compaction_delta") {
+                            // The summary arrives whole in one delta; it is replayed, never shown.
+                            nativeBlocks[idx] = { ...nativeBlocks[idx], content: String(nativeBlocks[idx]?.content ?? "") + String(d.content ?? "") };
+                        }
                         else if (d.type === "signature_delta") {
                             nativeBlocks[idx] = { ...nativeBlocks[idx], signature: String(nativeBlocks[idx]?.signature ?? "") + d.signature };
                         }
@@ -326,12 +495,12 @@ export class AnthropicProvider {
                 catch { /* skip malformed */ }
             }
         }
-        this.rememberNativeBlocks({ content: finalText, toolCalls: finalToolCalls }, Object.keys(nativeBlocks).map(Number).sort((a, b) => a - b).map(index => nativeBlocks[index]));
+        return outcome();
     }
     rememberNativeBlocks(message, blocks) {
         if (!blocks.length)
             return;
-        if (!message.toolCalls?.length && !blocks.some(b => b.type === "thinking"))
+        if (!message.toolCalls?.length && !blocks.some(b => b.type === "thinking" || b.type === "compaction"))
             return;
         this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }

package/dist/providers/base.js

@@ -110,10 +110,20 @@ export function toAnthropicMessages(context, nativeReplay) {
             }
             continue;
         }
+        if (msg.role === "assistant" && !msg.toolCalls?.length) {
+            // A turn that carries a server compaction block goes back as the API sent it: the block is
+            // what tells the API to drop everything before it.
+            const replay = nativeReplay?.(msg);
+            if (replay?.some(block => block.type === "compaction")) {
+                // Copies: request-time annotations such as `cache_control` must not land on the replay.
+                result.push({ role: "assistant", content: replay.map(block => ({ ...block })) });
+                continue;
+            }
+        }
         if (msg.role === "assistant" && msg.toolCalls?.length) {
             const replay = nativeReplay?.(msg);
             if (replay) {
-                result.push({ role: "assistant", content: replay });
+                result.push({ role: "assistant", content: replay.map(block => ({ ...block })) });
                 continue;
             }
             const blocks = [];

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

@@ -38,7 +38,7 @@ export interface CanonicalTransition {
 }
 export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
 /** Adapt the core-owned KernelProjection JSON into the WASM action surface. */
-export declare function canonicalActionFromProjectionJson(raw: string): KernelRunnerAction | null;
+export declare function canonicalActionFromProjectionJson(raw: string, observations?: readonly KernelObservation[]): KernelRunnerAction | null;
 export declare class CanonicalKernelRejectedError extends Error {
     readonly fault: Record<string, unknown>;
     constructor(faultJson: string);
@@ -98,7 +98,6 @@ export interface CanonicalRunnerRuntimeOptions {
     maxTurns?: number;
     maxTotalTokens?: number;
     maxWallMs?: number;
-    artifactSetDigest?: string;
     memoryBindingId?: string;
     persistPayload?: (callId: string, content: string, previewBytes: number) => Promise<{
         payloadRef: string;

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

@@ -1,13 +1,23 @@
 import { normalizeProviderStopReason } from "../providers/stop-reason.js";
 import { sha256Hex } from "./sha256.js";
 import { JournalCasConflictError, MAX_CHAIN_POSITION as JOURNAL_MAX_CHAIN_POSITION, } from "./kernel-journal.js";
-import { encodeCanonicalContentParts, kernelMessageToSdk, renderedContextToSdk, } from "./kernel-step.js";
+import { archivePresentationFromObservations, encodeCanonicalContentParts, kernelMessageToSdk, renderedContextToSdk, } from "./kernel-step.js";
 import { toolArgumentsFromWire } from "./tool-arguments.js";
 export const MAX_CHAIN_POSITION = JOURNAL_MAX_CHAIN_POSITION;
 const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
 function asObject(value) {
     return value && typeof value === "object" ? value : {};
 }
+// Keep structured candidate errors compact and deterministic across SDKs.
+function memoryCandidateErrorJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(memoryCandidateErrorJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const object = value;
+        return `{${Object.keys(object).sort().map(key => `${JSON.stringify(key)}:${memoryCandidateErrorJson(object[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
 function totalUsageTokens(terminal) {
     const usage = asObject(terminal.usage);
     const input = Number(usage.input_tokens ?? 0);
@@ -68,7 +78,7 @@ function canonicalDoneFromTerminal(terminal) {
     return { kind: "done", effectId: "", result: { termination, turnsUsed, totalTokensUsed: totalUsageTokens(terminal) } };
 }
 /** Adapt the core-owned KernelProjection JSON into the WASM action surface. */
-export function canonicalActionFromProjectionJson(raw) {
+export function canonicalActionFromProjectionJson(raw, observations = []) {
     const projection = asObject(JSON.parse(raw));
     const state = String(projection.state ?? "idle");
     if (state === "idle")
@@ -107,7 +117,6 @@ export function canonicalActionFromProjectionJson(raw) {
             kind: "call_provider",
             effectId,
             context: renderedContextToSdk(context),
-            contextEffect: payload,
             tools: (Array.isArray(payload.tools) ? payload.tools : []).map(raw => {
                 const tool = asObject(raw);
                 return {
@@ -193,6 +202,7 @@ export function canonicalActionFromProjectionJson(raw) {
         }
         return {
             kind: "archive_page_out",
+            ...archivePresentationFromObservations(observations),
             effectId,
             handleId: String(payload.handle_id ?? ""),
             payload: {
@@ -781,9 +791,6 @@ export class CanonicalRunnerRuntime {
         this.host = new CanonicalKernelHost(kernel, journal, operationId);
         this.memoryBindingId = options.memoryBindingId ?? "wasm-memory";
         this.config = {
-            ...(options.artifactSetDigest
-                ? { artifact_set_binding: { artifact_set_digest: options.artifactSetDigest } }
-                : {}),
             execution_policy: {
                 max_context_tokens: options.maxContextTokens,
                 ...(options.maxTurns !== undefined ? { max_turns: options.maxTurns } : {}),
@@ -1142,6 +1149,46 @@ export class CanonicalRunnerRuntime {
                             },
                         });
                 break;
+            case "memory_candidate_result":
+                // M2 · the host's answer for a write it holds as a candidate. `pending` is terminal for the
+                // effect and carries no record: nothing is persisted, and the kernel must not present it as
+                // remembered. `accepted` names the record the store now holds, as `memory_persist_result`
+                // does. Malformed receipts and rejections fail non-retryably; a non-null error takes
+                // precedence and fails retryably (the same candidate id is redelivered).
+                if (event.error !== undefined && event.error !== null) {
+                    input = this.failedEffect(event, "storage_unavailable", typeof event.error === "string" ? event.error : memoryCandidateErrorJson(event.error), true);
+                    break;
+                }
+                if (event.status === "pending") {
+                    input = typeof event.candidate_id !== "string" || !event.candidate_id
+                        || typeof event.receipt_id !== "string" || !event.receipt_id
+                        ? this.failedEffect(event, "storage_unavailable", "memory candidate receipt names no candidate_id/receipt_id", false)
+                        : this.succeededEffect(event, {
+                            kind: "memory_persisted",
+                            candidate: {
+                                binding_id: this.memoryBindingId,
+                                candidate_id: event.candidate_id,
+                                receipt_id: event.receipt_id,
+                            },
+                        });
+                    break;
+                }
+                if (event.status === "accepted") {
+                    input = typeof event.record_ref !== "string" || !event.record_ref
+                        || typeof event.digest !== "string" || !event.digest
+                        ? this.failedEffect(event, "storage_unavailable", "memory candidate accepted without record_ref/digest", false)
+                        : this.succeededEffect(event, {
+                            kind: "memory_persisted",
+                            receipt: {
+                                binding_id: this.memoryBindingId,
+                                record_ref: event.record_ref,
+                                digest: event.digest,
+                            },
+                        });
+                    break;
+                }
+                input = this.failedEffect(event, "storage_unavailable", `memory candidate rejected: ${typeof event.reason_code === "string" && event.reason_code ? event.reason_code : "unspecified"}`, false);
+                break;
             case "memory_query_result":
                 input = event.error
                     ? this.failedEffect(event, "storage_unavailable", String(event.error), true)
@@ -1157,6 +1204,10 @@ export class CanonicalRunnerRuntime {
                                 name: String(record.name ?? ""),
                                 kind: String(record.kind ?? "reference"),
                                 content: String(record.content ?? ""),
+                                ...(typeof record.description === "string" && record.description.trim()
+                                    ? { description: record.description } : {}),
+                                ...(typeof asObject(record.provenance).trust === "string"
+                                    ? { trust: String(asObject(record.provenance).trust) } : {}),
                                 ...(typeof hit.score === "number" ? { score: hit.score } : {}),
                                 // M3: the store reports the count it holds; the kernel derives the next one.
                                 ...(Number(record.recall_count) > 0
@@ -1342,7 +1393,7 @@ export class CanonicalRunnerRuntime {
             }
             if (transition) {
                 this.absorbTransition(transition);
-                this.lastAction = canonicalActionFromProjectionJson(this.host.kernel.projectPlannedStepJson(JSON.stringify(transition.plannedStep)));
+                this.lastAction = canonicalActionFromProjectionJson(this.host.kernel.projectPlannedStepJson(JSON.stringify(transition.plannedStep)), transition.plannedStep.observations);
             }
             if (this.lastAction?.kind !== "unsupported_effect")
                 return this.lastAction;
@@ -1506,6 +1557,12 @@ export class CanonicalRunnerRuntime {
                     ...(event.tokens !== undefined ? { tokens: Number(event.tokens) } : {}),
                 });
                 return true;
+            case "add_dependency_output":
+                (this.initialContext.dependencies ??= []).push({
+                    agent_id: String(event.agent_id ?? ""),
+                    content: String(event.content ?? ""),
+                });
+                return true;
             case "add_knowledge_message":
                 this.initialContext.knowledge.push({
                     content: String(event.content ?? ""),
@@ -1522,10 +1579,18 @@ export class CanonicalRunnerRuntime {
                 return true;
             case "set_memory_enabled":
                 this.featurePolicy().memory_enabled = Boolean(event.enabled);
+                // Only sent when on, so kernels that predate the field still accept memory-enabled runs.
+                if (event.propose_memory)
+                    this.featurePolicy().propose_memory_enabled = true;
+                else
+                    delete this.featurePolicy().propose_memory_enabled;
+                if (event.enabled && event.recall) {
+                    this.config.memory_policy = { ...asObject(this.config.memory_policy), recall: true };
+                }
                 if (event.enabled) {
                     this.config.memory_access = {
                         binding_id: this.memoryBindingId,
-                        capabilities: { read: true, write: true },
+                        capabilities: { read: event.read !== false, write: event.write !== false },
                     };
                 }
                 return true;
@@ -1534,6 +1599,7 @@ export class CanonicalRunnerRuntime {
                 return true;
             case "set_memory_policy":
                 this.config.memory_policy = {
+                    ...(asObject(this.config.memory_policy).recall ? { recall: true } : {}),
                     ...(event.stale_warning_days !== undefined ? { stale_warning_days: event.stale_warning_days } : {}),
                     ...(event.retrieval_top_k !== undefined ? { retrieval_top_k: event.retrieval_top_k } : {}),
                     ...(event.validation_enabled !== undefined ? { validation_enabled: event.validation_enabled } : {}),

package/dist/runtime/execution-plane.js

@@ -49,7 +49,7 @@ export class LocalExecutionPlane {
                 ? await ctx.memoryStore.search(ctx.agentId, { scope: ctx.memoryScope, query: String(args?.query ?? ""), top_k: topK, kinds: [] })
                 : [];
             const content = entries.length
-                ? entries.map(e => `[memory record_id=${e.record.record_id} score=${e.score.toFixed(3)}] ${e.record.content}`).join("\n---\n")
+                ? entries.map(e => `[memory record_id=${e.record.record_id} trust=${e.record.provenance.trust} score=${e.score.toFixed(3)}] ${e.record.content}`).join("\n---\n")
                 : "No relevant memories found.";
             yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
         }

package/dist/runtime/index.d.ts

@@ -16,8 +16,6 @@ export { runAgent, runFanout } from "./facade.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
 export { McpExecutionPlane } from "./mcp-transport.js";
 export type { McpConnection, McpConnectionFactory, McpCredentialVault, McpServerConfig } from "./mcp-transport.js";
-export { builtinReducers, resolveReducer } from "./reducers.js";
-export type { Reducer, ReducerRegistry, ReducerInput } from "./reducers.js";
 export { getKernel } from "./kernel.js";
 export { ReplayProvider } from "./replay-provider.js";
 export type { ReplayProviderOpts } from "./replay-provider.js";

package/dist/runtime/index.js

@@ -10,7 +10,6 @@ export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
 export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, sha256, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export { McpExecutionPlane } from "./mcp-transport.js";
-export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";
 export { ReplayProvider } from "./replay-provider.js";
 export { extractRecordedMessages } from "./replay-fixture.js";

package/dist/runtime/kernel-event-log.d.ts

@@ -6,6 +6,14 @@ export declare function categoryForKind(kind: string): KernelEventCategory;
 type CompressionAction = Extract<SessionEvent, {
     kind: "compressed";
 }>["action"];
+/** The kernel's pressure actions that name a session-level compression action; any other
+ *  action (e.g. `none`) is omitted from the event. Shared rule across all four SDKs. */
+export declare function canonicalCompressionAction(action?: string): CompressionAction;
+/**
+ * Project one kernel observation onto its session event (null = not persisted). Pinned across
+ * SDKs by the `kernel_observation_projection` conformance fixture: an absent optional field is
+ * omitted, never written as `null`.
+ */
 export declare function kernelObservationToSessionEvent(obs: KernelObservation, turn: number, opts?: {
     nextArchiveStart?: number;
     latestSeq?: number;