@deepstrike/wasm 0.2.2 → 0.2.5

package/README.md

@@ -75,7 +75,7 @@ src/
 
 The kernel (`@deepstrike/wasm-kernel`, Rust/wasm-bindgen) owns:
 - `KernelRuntime.step()` — drives `call_provider → execute_tool → evaluate_milestone → done`
-- `ContextEngine` — 5-partition context with pressure-based compression
+- `ContextEngine` — 4-slot context with tiered history compression
 - `Governance` — tool veto authority
 - `SignalRouter` — external interrupt queue
 
@@ -146,6 +146,27 @@ plane.register(fetchUrl)
 
 ---
 
+## Context model (four slots)
+
+Same as Node/Python — only **history** is compressed. WASM exposes `systemStable`, `systemKnowledge`, and `turns` on `call_provider.context`.
+
+```typescript
+const runner = new RuntimeRunner({
+  provider,
+  sessionLog: new InMemorySessionLog(),
+  executionPlane: plane,
+  maxTokens: 32_000,
+  initialMemory: ["User prefers concise answers."],  // → Slot 2
+  systemPrompt: "You are a helpful assistant.",       // → Slot 1
+})
+```
+
+IndexedDB / KV can back `DreamStore` for cross-session memory. Meta-tool retrieval still lands in **history**.
+
+See [docs/concepts/context-slots-compression.md](../docs/concepts/context-slots-compression.md).
+
+---
+
 ## Governance
 
 ```typescript
@@ -167,7 +188,7 @@ const runner = new RuntimeRunner({
 
 ## Memory
 
-`WorkingMemory` is an in-process scratch pad for within-run state:
+`WorkingMemory` is an SDK-side scratch pad — not the removed kernel `working` partition. Structured task state renders into Slot 3 (`turns[0]`).
 
 ```typescript
 import { WorkingMemory } from "@deepstrike/wasm"
@@ -177,10 +198,14 @@ mem.set("step", 1)
 mem.get("step")   // 1
 ```
 
+For cross-session recall, implement `DreamStore` and set `agentId` on `RuntimeRunner`. In-session `memory(query)` results appear in **history**; preload durable blocks with `initialMemory` → Slot 2.
+
 ---
 
 ## Knowledge
 
+Runtime `knowledge(query)` results → **history** (tool results). Durable preload → Slot 2 via `initialMemory`.
+
 ```typescript
 import type { KnowledgeSource } from "@deepstrike/wasm"
 
@@ -230,6 +255,8 @@ for await (const event of loop.runStreaming({
 
 ## Signals & interrupts
 
+Delivered signals fold into Slot 3 (`turns[0]`) and are cleared after each render — they do not survive renewal.
+
 ```typescript
 import { ScheduledPrompt } from "@deepstrike/wasm"
 import type { SignalSource, RuntimeSignal } from "@deepstrike/wasm"

package/dist/governance.d.ts

@@ -23,4 +23,36 @@ export declare class Governance {
     setTime(nowMs: number): this;
     evaluate(toolName: string, argsJson: string): GovernanceVerdict;
 }
+type GovernancePolicyAction = "allow" | "deny" | "ask_user";
+export interface GovernancePolicy {
+    defaultAction?: GovernancePolicyAction;
+    rules?: {
+        pattern: string;
+        action: GovernancePolicyAction;
+    }[];
+    vetoes?: string[];
+    rateLimits?: {
+        tool: string;
+        maxCalls: number;
+        windowMs: number;
+    }[];
+    constraints?: GovernanceConstraint[];
+}
+export type GovernanceConstraint = {
+    kind: "required";
+    tool: string;
+    path: string;
+} | {
+    kind: "enum";
+    tool: string;
+    path: string;
+    values: string[];
+} | {
+    kind: "range";
+    tool: string;
+    path: string;
+    min?: number;
+    max?: number;
+};
+export declare function governancePolicyToKernelEvent(policy: GovernancePolicy): Record<string, unknown>;
 export {};

package/dist/governance.js

@@ -51,3 +51,21 @@ export class Governance {
         return this._inner.evaluate(toolName, argsJson);
     }
 }
+export function governancePolicyToKernelEvent(policy) {
+    return {
+        kind: "load_governance_policy",
+        ...(policy.defaultAction ? { default_action: policy.defaultAction } : {}),
+        rules: (policy.rules ?? []).map(r => ({ tool_pattern: r.pattern, action: r.action })),
+        vetoed_tools: policy.vetoes ?? [],
+        rate_limits: (policy.rateLimits ?? []).map(rl => ({
+            tool: rl.tool,
+            max_calls: rl.maxCalls,
+            window_ms: rl.windowMs,
+        })),
+        constraints: (policy.constraints ?? []).map(c => c.kind === "enum"
+            ? { kind: "enum", tool: c.tool, path: c.path, values: c.values }
+            : c.kind === "range"
+                ? { kind: "range", tool: c.tool, path: c.path, ...(c.min !== undefined ? { min: c.min } : {}), ...(c.max !== undefined ? { max: c.max } : {}) }
+                : { kind: "required", tool: c.tool, path: c.path }),
+    };
+}

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { RuntimeOptions, SessionEvent, SessionLog, RunContext, ExecutionPla
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentSpawnedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./runtime/types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./runtime/types/agent.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
@@ -19,4 +19,4 @@ export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, } from "./types.js";

package/dist/providers/anthropic.js

@@ -1,6 +1,11 @@
 import { assistantReplayKey, collectStreamMessage, toAnthropicMessages } from "./base.js";
 function buildAnthropicTools(tools) {
-    return tools.map(t => ({ name: t.name, description: t.description, input_schema: JSON.parse(t.parameters) }));
+    return tools.map((t, i) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: JSON.parse(t.parameters),
+        ...(i === tools.length - 1 ? { cache_control: { type: "ephemeral" } } : {}),
+    }));
 }
 export class AnthropicProvider {
     apiKey;
@@ -25,7 +30,14 @@ export class AnthropicProvider {
         return collectStreamMessage(this.stream(context, tools, extensions));
     }
     async *stream(context, tools, extensions) {
-        const system = context.systemText || undefined;
+        const systemBlocks = [];
+        if (context.systemStable) {
+            systemBlocks.push({ type: "text", text: context.systemStable, cache_control: { type: "ephemeral" } });
+        }
+        if (context.systemKnowledge) {
+            systemBlocks.push({ type: "text", text: context.systemKnowledge, cache_control: { type: "ephemeral" } });
+        }
+        const system = systemBlocks.length ? systemBlocks : (context.systemText || undefined);
         const msgs = toAnthropicMessages(context, message => this.nativeAssistantBlocks.get(assistantReplayKey(message)));
         const body = {
             model: this.model,
@@ -44,6 +56,7 @@ export class AnthropicProvider {
                 "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),
         });
@@ -74,9 +87,13 @@ export class AnthropicProvider {
                     if (evt.type === "message_start" || evt.type === "message_delta") {
                         const usage = (evt.usage ?? evt.message?.usage);
                         if (usage?.input_tokens != null) {
+                            const inputTokens = usage.input_tokens ?? 0;
+                            const outputTokens = usage.output_tokens ?? 0;
                             yield {
                                 type: "usage",
-                                totalTokens: usage.input_tokens + (usage.output_tokens ?? 0),
+                                totalTokens: inputTokens + outputTokens,
+                                inputTokens,
+                                outputTokens,
                             };
                         }
                     }

package/dist/providers/base.js

@@ -57,19 +57,29 @@ export function toAnthropicMessages(context, nativeReplay) {
         }
         result.push({ role: msg.role, content: msg.content });
     }
+    if (context.systemVolatile && result.length > 0) {
+        const last = result[result.length - 1];
+        if (last.role === "user") {
+            last.content = `${String(last.content ?? "")}\n\n[SYSTEM REMINDER]\n${context.systemVolatile}`;
+        }
+    }
     return result;
 }
 /** Collect a non-streaming assistant Message from stream events. */
 export async function collectStreamMessage(stream) {
     let content = "";
     const toolCalls = [];
+    let outputTokens;
     for await (const evt of stream) {
         if (evt.type === "text_delta" && evt.delta)
             content += evt.delta;
         else if (evt.type === "tool_call" && evt.id && evt.name) {
             toolCalls.push({ id: evt.id, name: evt.name, arguments: JSON.stringify(evt.arguments ?? {}) });
         }
+        else if (evt.type === "usage") {
+            outputTokens = evt.outputTokens ?? evt.totalTokens;
+        }
     }
-    return { role: "assistant", content, ...(toolCalls.length ? { toolCalls } : {}) };
+    return { role: "assistant", content, ...(outputTokens ? { tokenCount: outputTokens } : {}), ...(toolCalls.length ? { toolCalls } : {}) };
 }
 export { assistantReplayKey };

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

@@ -1,8 +1,8 @@
-import type { ToolCall, ToolSchema, StreamEvent } from "../types.js";
+import type { ToolCall, ToolSchema, StreamEvent, PermissionRequestEvent, PermissionResponse } from "../types.js";
 import type { RegisteredTool } from "../tools/index.js";
 import type { DreamStore } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
-import type { Governance } from "../governance.js";
+import { LargeResultSpool } from "./large-result-spool.js";
 export interface ToolSuspendEvent {
     type: "tool_suspend";
     callId: string;
@@ -15,8 +15,9 @@ export interface RunContext {
     skillContentMap?: Map<string, string>;
     dreamStore?: DreamStore;
     knowledgeSource?: KnowledgeSource;
-    governance?: Governance;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+    onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
+    resultSpool?: LargeResultSpool;
 }
 export interface ExecutionPlane {
     register(...tools: RegisteredTool[]): this;
@@ -30,4 +31,6 @@ export declare class LocalExecutionPlane implements ExecutionPlane {
     unregister(name: string): this;
     schemas(): ToolSchema[];
     executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
+    private tryReadSpooledArgument;
 }
+export declare function resolvePermissionRequest(request: PermissionRequestEvent, ctx: RunContext): Promise<PermissionResponse>;

package/dist/runtime/execution-plane.js

@@ -1,3 +1,4 @@
+import { LargeResultSpool } from "./large-result-spool.js";
 function stripFrontmatter(content) {
     const s = content.trimStart();
     if (!s.startsWith("---"))
@@ -21,29 +22,7 @@ export class LocalExecutionPlane {
         return Array.from(this.tools.values()).map(t => t.schema);
     }
     async *executeAll(calls, ctx) {
-        const permitted = [];
-        for (const c of calls) {
-            if (ctx.governance) {
-                ctx.governance.setTime(Date.now());
-                const v = ctx.governance.evaluate(c.name, c.arguments);
-                if (v.kind === "deny") {
-                    yield { type: "tool_denied", callId: c.id, toolName: c.name, reason: v.reason ?? "" };
-                    yield { type: "tool_result", callId: c.id, name: c.name, content: `permission denied: ${v.reason ?? ""}`, isError: true, isFatal: false, errorKind: "governance_denied" };
-                    continue;
-                }
-                if (v.kind === "rate_limited") {
-                    yield { type: "tool_denied", callId: c.id, toolName: c.name, reason: "rate limited" };
-                    yield { type: "tool_result", callId: c.id, name: c.name, content: "rate limited", isError: true, isFatal: false, errorKind: "recoverable" };
-                    continue;
-                }
-                if (v.kind === "ask_user") {
-                    yield { type: "permission_request", callId: c.id, toolName: c.name, arguments: c.arguments, reason: v.reason ?? "" };
-                    yield { type: "tool_result", callId: c.id, name: c.name, content: "awaiting user approval", isError: true, isFatal: false, errorKind: "recoverable" };
-                    continue;
-                }
-            }
-            permitted.push(c);
-        }
+        const permitted = calls;
         const skillCalls = permitted.filter(c => c.name === "skill");
         const memoryCalls = permitted.filter(c => c.name === "memory");
         const knowledgeCalls = permitted.filter(c => c.name === "knowledge");
@@ -82,6 +61,11 @@ export class LocalExecutionPlane {
             yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
         }
         for (const call of regularCalls) {
+            const spooledContent = await this.tryReadSpooledArgument(call, ctx);
+            if (spooledContent !== null) {
+                yield { type: "tool_result", callId: call.id, name: call.name, content: spooledContent, isError: false };
+                continue;
+            }
             const registered = this.tools.get(call.name);
             if (!registered) {
                 yield { type: "tool_result", callId: call.id, name: call.name, content: `unknown tool: ${call.name}`, isError: true, isFatal: false, errorKind: "recoverable" };
@@ -105,6 +89,25 @@ export class LocalExecutionPlane {
             }
         }
     }
+    async tryReadSpooledArgument(call, ctx) {
+        const isReadTool = ["read", "read_file", "view_file", "read_spooled_result"].includes(call.name);
+        if (!isReadTool)
+            return null;
+        try {
+            const args = JSON.parse(call.arguments || "{}");
+            for (const val of Object.values(args)) {
+                if (typeof val === "string" && (val.startsWith(".spool/") || val.includes("/.spool/"))) {
+                    const spool = ctx.resultSpool ?? new LargeResultSpool();
+                    const content = await spool.readSpooledResult(val);
+                    return content;
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return null;
+    }
 }
 function tryParseJson(s) {
     try {
@@ -114,3 +117,31 @@ function tryParseJson(s) {
         return null;
     }
 }
+export async function resolvePermissionRequest(request, ctx) {
+    if (!ctx.onPermissionRequest) {
+        return {
+            approved: false,
+            responder: "policy_gate",
+            reason: "no permission handler configured",
+        };
+    }
+    try {
+        return normalizePermissionResponse(await ctx.onPermissionRequest(request));
+    }
+    catch (err) {
+        return {
+            approved: false,
+            responder: "permission_handler",
+            reason: `permission handler failed: ${String(err)}`,
+        };
+    }
+}
+function normalizePermissionResponse(value) {
+    if (typeof value === "boolean")
+        return { approved: value, responder: "host" };
+    return {
+        approved: Boolean(value.approved),
+        responder: value.responder ?? "host",
+        ...(value.reason ? { reason: value.reason } : {}),
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { KernelObservation } from "./kernel-step.js";
+import type { SessionEvent } from "./session-log.js";
+/** Agent OS kernel event category (Phase 5). */
+export type KernelEventCategory = "syscall" | "sched" | "mm" | "proc" | "ipc";
+export declare function categoryForKind(kind: string): KernelEventCategory;
+export declare function withCategory<T extends {
+    kind: string;
+}>(event: T): T & {
+    category: KernelEventCategory;
+    primitive: KernelPrimitive;
+};
+type CompressionAction = Extract<SessionEvent, {
+    kind: "compressed";
+}>["action"];
+export declare function kernelObservationToSessionEvent(obs: KernelObservation, turn: number, opts?: {
+    nextArchiveStart?: number;
+    latestSeq?: number;
+    archiveRef?: string;
+    preservedRefs?: string[];
+    compressionAction?: (action?: string) => CompressionAction;
+    spoolRef?: string;
+}): SessionEvent | null;
+export type KernelPrimitive = "syscall" | "sched" | "mm";
+export declare function primitiveForCategory(category: KernelEventCategory): KernelPrimitive;
+export declare function primitiveForKind(kind: string): KernelPrimitive;
+export {};

package/dist/runtime/kernel-event-log.js

@@ -0,0 +1,212 @@
+export function categoryForKind(kind) {
+    switch (kind) {
+        case "tool_gated":
+        case "capability_changed":
+            return "syscall";
+        case "compressed":
+        case "page_out":
+        case "page_in":
+        case "page_in_requested":
+        case "renewed":
+        case "context_renewed":
+        case "large_result_spooled":
+        case "memory_written":
+        case "memory_queried":
+            return "mm";
+        case "agent_process_changed":
+            return "proc";
+        case "signal_disposed":
+            return "ipc";
+        default:
+            return "sched";
+    }
+}
+export function withCategory(event) {
+    const category = categoryForKind(event.kind);
+    return {
+        ...event,
+        category,
+        primitive: primitiveForCategory(category),
+    };
+}
+export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
+    const t = obs.turn ?? turn;
+    const compressionAction = opts.compressionAction ?? (() => undefined);
+    switch (obs.kind) {
+        case "page_out":
+            return withCategory({
+                kind: "page_out",
+                turn: t,
+                action: compressionAction(obs.action),
+                summary: obs.summary,
+                tier_hint: obs.tier_hint ?? "durable",
+                message_count: Array.isArray(obs.archived) ? obs.archived.length : 0,
+            });
+        case "compressed": {
+            const latest = opts.latestSeq ?? -1;
+            const start = opts.nextArchiveStart ?? 0;
+            if (latest < start)
+                return null;
+            return withCategory({
+                kind: "compressed",
+                turn: t,
+                archived_seq_range: [start, latest],
+                action: compressionAction(obs.action),
+                summary: obs.summary,
+                summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
+                archive_ref: opts.archiveRef,
+                preserved_refs: opts.preservedRefs ?? [],
+            });
+        }
+        case "renewed":
+            return withCategory({
+                kind: "context_renewed",
+                turn: t,
+                sprint: obs.sprint ?? 0,
+                handoff_ref: "",
+            });
+        case "rollbacked":
+            return withCategory({
+                kind: "rollbacked",
+                turn: t,
+                checkpoint_history_len: obs.checkpoint_history_len ?? 0,
+                reason: obs.reason,
+            });
+        case "capability_changed":
+            return withCategory({
+                kind: "capability_changed",
+                turn: t,
+                added: obs.added ?? [],
+                removed: obs.removed ?? [],
+                ...(obs.change_kind != null && { change_kind: obs.change_kind }),
+                ...(obs.capability_id != null && { capability_id: obs.capability_id }),
+                ...(obs.version != null && { version: obs.version }),
+                ...(obs.mounted_by != null && { mounted_by: obs.mounted_by }),
+                ...(obs.mount_reason != null && { mount_reason: obs.mount_reason }),
+            });
+        case "milestone_advanced":
+            return withCategory({
+                kind: "milestone_advanced",
+                turn: t,
+                phase_id: obs.phase_id ?? "",
+                capabilities_unlocked: obs.capabilities_unlocked ?? [],
+            });
+        case "milestone_blocked":
+            return withCategory({
+                kind: "milestone_blocked",
+                turn: t,
+                phase_id: obs.phase_id ?? "",
+                reason: typeof obs.reason === "string" ? obs.reason : "",
+            });
+        case "milestone_evidence":
+            return withCategory({
+                kind: "milestone_evidence",
+                turn: t,
+                phase_id: obs.phase_id ?? "",
+                evidence: obs.evidence ?? [],
+            });
+        case "checkpoint_taken":
+            return withCategory({
+                kind: "checkpoint_taken",
+                turn: t,
+                history_len: obs.history_len ?? 0,
+            });
+        case "agent_process_changed":
+            return withCategory({
+                kind: "agent_process_changed",
+                turn: t,
+                agent_id: obs.agent_id ?? "",
+                parent_session_id: obs.parent_session_id ?? "",
+                role: obs.role ?? "",
+                isolation: obs.isolation ?? "",
+                context_inheritance: obs.context_inheritance ?? "",
+                state: obs.state ?? "running",
+                permitted_capability_ids: obs.permitted_capability_ids ?? [],
+                ...(obs.result_termination
+                    ? { result_termination: obs.result_termination }
+                    : {}),
+            });
+        case "tool_gated":
+            return withCategory({
+                kind: "tool_gated",
+                turn: t,
+                call_id: obs.call_id ?? "",
+                tool: obs.tool ?? "",
+                reason: typeof obs.reason === "string" ? obs.reason : "",
+            });
+        case "signal_disposed":
+            return withCategory({
+                kind: "signal_disposed",
+                turn: t,
+                signal_id: obs.signal_id ?? "",
+                disposition: obs.disposition ?? "",
+                queue_depth: obs.queue_depth ?? 0,
+            });
+        case "budget_exceeded":
+            return withCategory({
+                kind: "budget_exceeded",
+                turn: t,
+                budget: obs.budget ?? "",
+            });
+        case "suspended":
+            return withCategory({
+                kind: "suspended",
+                turn: t,
+                reason: typeof obs.reason === "string" ? obs.reason : "",
+                pending_calls: obs.pending_calls ?? [],
+            });
+        case "resumed":
+            return withCategory({
+                kind: "resumed",
+                turn: t,
+                approved: obs.approved ?? [],
+                denied: obs.denied ?? [],
+            });
+        case "page_in_requested":
+            return null;
+        case "large_result_spooled":
+            return withCategory({
+                kind: "large_result_spooled",
+                turn: t,
+                call_id: obs.call_id ?? "",
+                tool: obs.tool ?? "",
+                original_size: obs.original_size ?? 0,
+                preview_size: obs.preview_size ?? 0,
+                spool_ref: opts.spoolRef,
+            });
+        case "memory_written":
+            return withCategory({
+                kind: "memory_written",
+                turn: t,
+                memory_id: obs.memory_id ?? "",
+                memory_kind: obs.memory_kind ?? "",
+                size_bytes: obs.size_bytes ?? 0,
+            });
+        case "memory_queried":
+            return withCategory({
+                kind: "memory_queried",
+                turn: t,
+                query_context: obs.query_context ?? "",
+                requested_k: obs.requested_k ?? 0,
+                requires_async_response: obs.requires_async_response ?? false,
+            });
+        default:
+            return null;
+    }
+}
+export function primitiveForCategory(category) {
+    switch (category) {
+        case "syscall":
+            return "syscall";
+        case "mm":
+            return "mm";
+        case "proc":
+        case "ipc":
+        case "sched":
+        default:
+            return "sched";
+    }
+}
+export function primitiveForKind(kind) {
+    return primitiveForCategory(categoryForKind(kind));
+}

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

@@ -65,7 +65,7 @@ export interface KernelObservation {
     phase_id?: string;
     capabilities_unlocked?: string[];
     evidence?: string[];
-    reason?: RollbackReason;
+    reason?: RollbackReason | string;
     agent_id?: string;
     parent_session_id?: string;
     role?: string;
@@ -73,6 +73,24 @@ export interface KernelObservation {
     context_inheritance?: string;
     permitted_capability_ids?: string[];
     history_len?: number;
+    tier_hint?: string;
+    call_id?: string;
+    tool?: string;
+    signal_id?: string;
+    disposition?: string;
+    queue_depth?: number;
+    budget?: string;
+    pending_calls?: string[];
+    approved?: string[];
+    denied?: string[];
+    original_size?: number;
+    preview_size?: number;
+    memory_id?: string;
+    memory_kind?: string;
+    size_bytes?: number;
+    query_context?: string;
+    requested_k?: number;
+    requires_async_response?: boolean;
 }
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
@@ -84,5 +102,7 @@ export declare function capabilitySkill(skill: SkillMetadata): Record<string, un
 export declare function capabilityMarker(kind: string, id: string, description: string): Record<string, unknown>;
 export declare function kernelApply(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelObservation[];
 export declare function kernelAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction;
+/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
+export declare function kernelMaybeAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction | null;
 export declare function forceCompact(runtime: KernelRuntimeHandle, pending: KernelObservation[]): boolean;
 export {};

package/dist/runtime/kernel-step.js

@@ -114,6 +114,8 @@ function kernelMessageToSdk(raw) {
 function renderedContextToSdk(raw) {
     return {
         systemText: String(raw.system_text ?? raw.systemText ?? ""),
+        systemStable: String(raw.system_stable ?? raw.systemStable ?? ""),
+        systemKnowledge: String(raw.system_knowledge ?? raw.systemKnowledge ?? ""),
         turns: (raw.turns ?? []).map(kernelMessageToSdk),
     };
 }
@@ -176,6 +178,13 @@ export function kernelAction(runtime, pending, event) {
         throw new Error("kernel transition must return one action");
     return mapKernelAction(raw);
 }
+/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
+export function kernelMaybeAction(runtime, pending, event) {
+    const step = parseStep(runtime.step(stepInput(event)));
+    pending.push(...step.observations);
+    const raw = step.actions[0];
+    return raw ? mapKernelAction(raw) : null;
+}
 export function forceCompact(runtime, pending) {
     return kernelApply(runtime, pending, { kind: "force_compact" }).some(o => o.kind === "compressed");
 }