@deepstrike/wasm 0.2.1 → 0.2.5

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

@@ -1,4 +1,5 @@
 import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+import type { KernelEventCategory, KernelPrimitive } from "./kernel-event-log.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -73,20 +74,51 @@ export type SessionEvent = {
 } | {
     kind: "compressed";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     archived_seq_range: [number, number];
     action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
     summary?: string;
     summary_tokens?: number;
     archive_ref?: string;
     preserved_refs?: string[];
+} | {
+    kind: "page_out";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
+    summary?: string;
+    tier_hint?: string;
+    message_count?: number;
+} | {
+    kind: "page_in";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    entry_count: number;
+} | {
+    kind: "large_result_spooled";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    call_id: string;
+    tool: string;
+    original_size: number;
+    preview_size: number;
+    spool_ref?: string;
 } | {
     kind: "rollbacked";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     checkpoint_history_len: number;
     reason?: RollbackReason;
 } | {
     kind: "capability_changed";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     added: string[];
     removed: string[];
     change_kind?: string;
@@ -94,43 +126,118 @@ export type SessionEvent = {
     version?: string;
     mounted_by?: string;
     mount_reason?: string;
+} | {
+    kind: "context_renewed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    sprint: number;
+    handoff_ref: string;
+} | {
+    kind: "suspended";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    reason: string;
+    pending_calls?: string[];
+} | {
+    kind: "resumed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    approved?: string[];
+    denied?: string[];
+} | {
+    kind: "tool_gated";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    call_id: string;
+    tool: string;
+    reason: string;
+} | {
+    kind: "signal_disposed";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    signal_id: string;
+    disposition: string;
+    queue_depth: number;
+} | {
+    kind: "budget_exceeded";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    budget: string;
 } | {
     kind: "milestone_advanced";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     phase_id: string;
     capabilities_unlocked: string[];
 } | {
     kind: "milestone_blocked";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     phase_id: string;
     reason: string;
 } | {
     kind: "milestone_evidence";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     phase_id: string;
     evidence: string[];
 } | {
     kind: "checkpoint_taken";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     history_len: number;
 } | {
-    kind: "agent_spawned";
+    kind: "agent_process_changed";
     turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
     agent_id: string;
     parent_session_id: string;
     role: string;
     isolation: string;
     context_inheritance: string;
+    state?: string;
     permitted_capability_ids: string[];
+    result_termination?: string;
+} | {
+    kind: "memory_written";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    memory_id: string;
+    memory_kind: string;
+    size_bytes: number;
+} | {
+    kind: "memory_queried";
+    turn: number;
+    category?: KernelEventCategory;
+    primitive?: KernelPrimitive;
+    query_context: string;
+    requested_k: number;
+    requires_async_response: boolean;
 } | {
     kind: "run_terminal";
     reason: string;
     turns_used: number;
     total_tokens: number;
+} | {
+    kind: "summary_upgraded";
+    compressed_seq: number;
+    summary: string;
 };
 export interface SessionLog {
     append(sessionId: string, event: SessionEvent): Promise<number>;
-    read(sessionId: string, fromSeq?: number): Promise<Array<{
+    read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
         seq: number;
         event: SessionEvent;
     }>>;
@@ -139,7 +246,7 @@ export interface SessionLog {
 export declare class InMemorySessionLog implements SessionLog {
     private store;
     append(sessionId: string, event: SessionEvent): Promise<number>;
-    read(sessionId: string, fromSeq?: number): Promise<Array<{
+    read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
         seq: number;
         event: SessionEvent;
     }>>;

package/dist/runtime/session-log.js

@@ -1,3 +1,4 @@
+import { primitiveForKind } from "./kernel-event-log.js";
 export class InMemorySessionLog {
     store = new Map();
     async append(sessionId, event) {
@@ -8,8 +9,15 @@ export class InMemorySessionLog {
         entries.push({ seq, event });
         return seq;
     }
-    async read(sessionId, fromSeq = 0) {
-        return (this.store.get(sessionId) ?? []).filter(e => e.seq >= fromSeq);
+    async read(sessionId, fromSeq = 0, primitiveFilter) {
+        const entries = this.store.get(sessionId) ?? [];
+        return entries.filter(e => {
+            if (e.seq < fromSeq)
+                return false;
+            if (primitiveFilter && primitiveForKind(e.event.kind) !== primitiveFilter)
+                return false;
+            return true;
+        });
     }
     async latestSeq(sessionId) {
         const entries = this.store.get(sessionId);

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -1,11 +1,11 @@
-import type { AgentRunSpec, AgentSpawnedObservation, SubAgentResult } from "./types/agent.js";
+import type { AgentRunSpec, AgentProcessChangedObservation, SubAgentResult } from "./types/agent.js";
 import type { RuntimeOptions } from "./runner.js";
 import type { SessionLog } from "./session-log.js";
 export interface SubAgentRunContext {
     parentOpts: RuntimeOptions;
     parentSessionId: string;
     spec: AgentRunSpec;
-    manifest: AgentSpawnedObservation;
+    manifest: AgentProcessChangedObservation;
     sessionLog: SessionLog;
 }
 /** Host-side driver for kernel-isolated sub-agent runs. */

package/dist/runtime/sub-agent-orchestrator.js

@@ -1,4 +1,4 @@
-import { agentRunSpecToKernel } from "./types/agent.js";
+import { agentRunSpecToKernel, findSpawnProcessObservation, spawnObservationToManifest } from "./types/agent.js";
 import { FilteredExecutionPlane } from "./filtered-plane.js";
 import { kernelApply } from "./kernel-step.js";
 function terminationFromStatus(status) {
@@ -77,31 +77,22 @@ export async function spawnStandalone(parentOpts, parentSessionId, spec, orchest
         spec: agentRunSpecToKernel(spec),
         parent_session_id: parentSessionId,
     });
-    const spawned = observations.find(o => o.kind === "agent_spawned");
-    if (!spawned || typeof spawned.agent_id !== "string") {
-        throw new Error("spawn_sub_agent did not emit agent_spawned");
+    const spawned = findSpawnProcessObservation(observations);
+    if (!spawned) {
+        throw new Error("spawn_sub_agent did not emit agent_process_changed");
     }
-    const turn = spawned.turn ?? 0;
+    const manifest = spawnObservationToManifest(spawned, spec, parentSessionId);
     await parentOpts.sessionLog.append(parentSessionId, {
-        kind: "agent_spawned",
-        turn,
-        agent_id: spawned.agent_id,
-        parent_session_id: spawned.parent_session_id ?? parentSessionId,
-        role: spawned.role ?? spec.role,
-        isolation: spawned.isolation ?? spec.isolation ?? "shared",
-        context_inheritance: spawned.context_inheritance ?? "none",
-        permitted_capability_ids: spawned.permitted_capability_ids ?? [],
+        kind: "agent_process_changed",
+        turn: manifest.turn ?? 0,
+        agent_id: manifest.agent_id,
+        parent_session_id: manifest.parent_session_id,
+        role: manifest.role,
+        isolation: manifest.isolation,
+        context_inheritance: manifest.context_inheritance,
+        state: "running",
+        permitted_capability_ids: manifest.permitted_capability_ids ?? [],
     });
-    const manifest = {
-        kind: "agent_spawned",
-        turn,
-        agent_id: spawned.agent_id,
-        parent_session_id: spawned.parent_session_id ?? parentSessionId,
-        role: spawned.role ?? spec.role,
-        isolation: spawned.isolation ?? spec.isolation ?? "shared",
-        context_inheritance: spawned.context_inheritance ?? "none",
-        permitted_capability_ids: spawned.permitted_capability_ids ?? [],
-    };
     return orchestrator.run({
         parentOpts,
         parentSessionId,

package/dist/runtime/types/agent.d.ts

@@ -24,16 +24,25 @@ export interface AgentRunSpec {
     milestones?: MilestoneContract;
     metadata?: Record<string, unknown>;
 }
-export interface AgentSpawnedObservation {
-    kind: "agent_spawned";
+/** Kernel process-table observation (Phase 3 canonical spawn signal). */
+export interface AgentProcessChangedObservation {
+    kind: "agent_process_changed";
     turn?: number;
     agent_id: string;
     parent_session_id: string;
     role: string;
     isolation: string;
     context_inheritance: string;
-    permitted_capability_ids: string[];
+    state?: string;
+    permitted_capability_ids?: string[];
+    result_termination?: string;
 }
+/** Map kernel spawn observation → host manifest. */
+export declare function spawnObservationToManifest(obs: AgentProcessChangedObservation | Record<string, unknown>, spec: AgentRunSpec, parentSessionId: string): AgentProcessChangedObservation;
+export declare function findSpawnProcessObservation(observations: Array<{
+    kind: string;
+    agent_id?: string;
+}>): AgentProcessChangedObservation | undefined;
 export interface LoopResult {
     termination: TerminationReason | string;
     finalMessage?: Message;

package/dist/runtime/types/agent.js

@@ -1,3 +1,21 @@
+/** Map kernel spawn observation → host manifest. */
+export function spawnObservationToManifest(obs, spec, parentSessionId) {
+    const o = obs;
+    return {
+        kind: "agent_process_changed",
+        turn: o.turn,
+        agent_id: String(o.agent_id ?? spec.identity.agentId),
+        parent_session_id: String(o.parent_session_id ?? parentSessionId),
+        role: String(o.role ?? spec.role),
+        isolation: String(o.isolation ?? spec.isolation ?? "shared"),
+        context_inheritance: String(o.context_inheritance ?? "none"),
+        permitted_capability_ids: o.permitted_capability_ids ?? [],
+    };
+}
+export function findSpawnProcessObservation(observations) {
+    const hit = observations.find(o => o.kind === "agent_process_changed" && typeof o.agent_id === "string");
+    return hit;
+}
 export function agentIdentitySub(agentId, sessionId, parentSessionId) {
     return {
         agentId,

package/dist/types.d.ts

@@ -26,6 +26,9 @@ export interface ToolSchema {
 /** Structured provider context from the kernel (`call_llm` action). */
 export interface RenderedContext {
     systemText: string;
+    systemStable?: string;
+    systemKnowledge?: string;
+    systemVolatile?: string;
     turns: Message[];
 }
 export interface StreamEvent {
@@ -38,6 +41,8 @@ export interface TextDelta extends StreamEvent {
 export interface UsageEvent extends StreamEvent {
     type: "usage";
     totalTokens: number;
+    inputTokens?: number;
+    outputTokens?: number;
 }
 export interface ThinkingDelta extends StreamEvent {
     type: "thinking_delta";
@@ -63,6 +68,7 @@ export interface DoneEvent extends StreamEvent {
     iterations: number;
     totalTokens: number;
     status: string;
+    dreamResult?: import("./memory/index.js").DreamResult;
 }
 export interface ErrorEvent extends StreamEvent {
     type: "error";
@@ -75,6 +81,19 @@ export interface PermissionRequestEvent extends StreamEvent {
     arguments: string;
     reason: string;
 }
+export interface PermissionResponse {
+    approved: boolean;
+    responder?: string;
+    reason?: string;
+}
+export interface PermissionResolvedEvent extends StreamEvent {
+    type: "permission_resolved";
+    callId: string;
+    toolName: string;
+    approved: boolean;
+    responder: string;
+    reason?: string;
+}
 export interface ToolDeniedEvent extends StreamEvent {
     type: "tool_denied";
     callId: string;
@@ -108,3 +127,8 @@ export interface LLMProvider {
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): AsyncIterable<StreamEvent>;
 }
+export interface DreamSummarizer {
+    summarize(archived: Message[], context: {
+        action?: string;
+    }): Promise<string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.1"
+    "@deepstrike/wasm-kernel": "0.2.5"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",