@deepstrike/wasm 0.2.2 → 0.2.6

package/dist/runtime/runner.js

@@ -1,10 +1,15 @@
+import { resolvePermissionRequest } from "./execution-plane.js";
+import { governancePolicyToKernelEvent } from "../governance.js";
 import { getKernel } from "./kernel.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, repairEventsForRecovery } from "./session-repair.js";
-import { forceCompact, kernelAction, kernelApply, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
-import { agentRunSpecToKernel, subAgentResultToKernel, milestoneCheckPass, milestoneCheckResultToKernel } from "./types/agent.js";
+import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
+import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
+import { assertNativeProfile } from "./os-profile.js";
+import { LargeResultSpool } from "./large-result-spool.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
@@ -12,6 +17,8 @@ export class RuntimeRunner {
     activeKernel = null;
     currentSessionId = null;
     nextArchiveStart = 0;
+    localPageOutCache = [];
+    pendingSpoolOutputs = new Map();
     constructor(opts) {
         this.opts = opts;
     }
@@ -42,21 +49,142 @@ export class RuntimeRunner {
         const start = startEntry.event;
         yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
     }
-    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
-    pushArtifact(message, tokens) {
+    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message. */
+    pushKnowledge(message, tokens) {
         if (!this.activeKernel)
             return;
         kernelApply(this.activeKernel, this.pendingObservations, {
-            kind: "push_artifact",
-            message: messageToKernelMessage(message),
-            ...(tokens !== undefined ? { tokens } : {}),
+            kind: "add_knowledge_message",
+            content: message.content ?? "",
+            tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
         });
     }
+    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
+    async applyKernelPageIn(runtime, sessionId) {
+        const requests = this.pendingObservations.filter((o) => o.kind === "page_in_requested" && typeof o.tool === "string");
+        if (requests.length === 0)
+            return;
+        const entries = [];
+        for (const req of requests) {
+            const query = typeof req.query === "string" ? req.query : "";
+            const topK = typeof req.top_k === "number" ? req.top_k : 5;
+            if (req.tool === "memory") {
+                const localHits = this.localPageOutCache.filter(m => typeof m.content === "string" && m.content.toLowerCase().includes(query.toLowerCase())).slice(0, topK);
+                for (const hit of localHits) {
+                    entries.push({
+                        content: `[local semantic cache] ${hit.role}: ${hit.content}`,
+                        source: "semantic_cache",
+                    });
+                }
+                const remainingK = topK - entries.length;
+                if (remainingK > 0 && this.opts.dreamStore && this.opts.agentId) {
+                    const hits = await this.opts.dreamStore.search(this.opts.agentId, query, remainingK);
+                    for (const hit of hits) {
+                        entries.push({
+                            content: `[memory score=${hit.score.toFixed(3)}] ${hit.text}`,
+                            source: "memory",
+                        });
+                    }
+                }
+            }
+            else if (req.tool === "knowledge" && this.opts.knowledgeSource) {
+                const snippets = await this.opts.knowledgeSource.retrieve(query, topK);
+                for (const snippet of snippets) {
+                    entries.push({ content: snippet, source: "knowledge" });
+                }
+            }
+        }
+        if (entries.length === 0)
+            return;
+        kernelApply(runtime, this.pendingObservations, { kind: "page_in", entries });
+        await this.opts.sessionLog.append(sessionId, withCategory({
+            kind: "page_in",
+            turn: runtime.turn(),
+            entry_count: entries.length,
+        }));
+    }
+    async resolveKernelSuspend(runtime, sessionId) {
+        const gated = this.pendingObservations.filter((o) => o.kind === "tool_gated" && typeof o.call_id === "string" && typeof o.tool === "string");
+        const approved = [];
+        const denied = [];
+        const events = [];
+        const runCtx = { onPermissionRequest: this.opts.onPermissionRequest };
+        for (const g of gated) {
+            const request = {
+                type: "permission_request",
+                callId: g.call_id,
+                toolName: g.tool,
+                arguments: "{}",
+                reason: typeof g.reason === "string" ? g.reason : "",
+            };
+            events.push(request);
+            const decision = await resolvePermissionRequest(request, runCtx);
+            events.push({
+                type: "permission_resolved",
+                callId: g.call_id,
+                toolName: g.tool,
+                approved: decision.approved,
+                responder: decision.responder ?? "host",
+                ...(decision.reason ? { reason: decision.reason } : {}),
+            });
+            await this.opts.sessionLog.append(sessionId, {
+                kind: "permission_requested",
+                turn: runtime.turn(),
+                tool: g.tool,
+                arguments: "{}",
+                reason: request.reason,
+            });
+            await this.opts.sessionLog.append(sessionId, {
+                kind: "permission_resolved",
+                turn: runtime.turn(),
+                approved: decision.approved,
+                responder: decision.responder ?? "host",
+            });
+            if (decision.approved) {
+                approved.push(g.call_id);
+            }
+            else {
+                denied.push(g.call_id);
+                const denyReason = decision.reason ?? "permission denied";
+                events.push({
+                    type: "tool_denied",
+                    callId: g.call_id,
+                    toolName: g.tool,
+                    reason: denyReason,
+                });
+                events.push({
+                    type: "tool_result",
+                    callId: g.call_id,
+                    name: g.tool,
+                    content: `permission denied: ${denyReason}`,
+                    isError: true,
+                    errorKind: "governance_denied",
+                });
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "tool_denied",
+                    turn: runtime.turn(),
+                    call_id: g.call_id,
+                    tool_name: g.tool,
+                    reason: denyReason,
+                });
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "tool_completed",
+                    turn: runtime.turn(),
+                    results: [{
+                            call_id: g.call_id,
+                            output: `permission denied: ${denyReason}`,
+                            is_error: true,
+                            error_kind: "governance_denied",
+                        }],
+                });
+            }
+        }
+        return { approved, denied, events };
+    }
     async dream(agentId, nowMs = Date.now()) {
         if (!this.opts.dreamStore)
             throw new Error("dreamStore not configured");
         const kernel = await getKernel();
-        this.opts.governance?._attach(kernel);
         const sessions = await this.opts.dreamStore.loadSessions(agentId);
         const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
         if (!sessions.length)
@@ -77,13 +205,14 @@ export class RuntimeRunner {
         if (action1.kind !== "synthesize_insights")
             throw new Error(`unexpected: ${action1.kind}`);
         let synthesisText = "";
-        const providerState = this.opts.provider.createRunState?.();
+        const dreamProvider = this.opts.dreamProvider ?? this.opts.provider;
+        const providerState = dreamProvider.createRunState?.();
         const synthMsgs = (action1.messages ?? []);
         const synthContext = {
             systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
             turns: synthMsgs.filter(m => m.role !== "system"),
         };
-        for await (const evt of this.opts.provider.stream(synthContext, [], undefined, providerState)) {
+        for await (const evt of dreamProvider.stream(synthContext, [], undefined, providerState)) {
             if (evt.type === "text_delta")
                 synthesisText += evt.delta;
         }
@@ -115,9 +244,9 @@ export class RuntimeRunner {
     async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
         this.interrupted = false;
         this.pendingObservations = [];
+        this.pendingSpoolOutputs.clear();
         this.currentSessionId = sessionId;
         const kernel = await getKernel();
-        this.opts.governance?._attach(kernel);
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
         const providerState = this.opts.provider.createRunState?.();
         let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
@@ -130,7 +259,18 @@ export class RuntimeRunner {
             timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
         });
         this.activeKernel = runtime;
-        const router = new kernel.SignalRouter(256);
+        if (this.opts.tokenizer) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_tokenizer",
+                name: this.opts.tokenizer,
+            });
+        }
+        if (this.opts.enablePlanTool !== undefined) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_plan_tool_enabled",
+                enabled: this.opts.enablePlanTool,
+            });
+        }
         kernelApply(runtime, this.pendingObservations, {
             kind: "set_tools",
             tools: this.opts.executionPlane.schemas().map(toolSchemaToKernel),
@@ -145,7 +285,7 @@ export class RuntimeRunner {
         if (this.opts.initialMemory) {
             for (const mem of this.opts.initialMemory) {
                 kernelApply(runtime, this.pendingObservations, {
-                    kind: "add_memory_message",
+                    kind: "add_knowledge_message",
                     content: mem,
                     tokens: Math.max(1, Math.ceil(mem.length / 4)),
                 });
@@ -199,11 +339,64 @@ export class RuntimeRunner {
         if (this.opts.runSpec) {
             startPayload.run_spec = agentRunSpecToKernel(this.opts.runSpec);
         }
+        const osProfile = assertNativeProfile(this.opts.osProfile ?? "native");
+        const attentionPolicy = this.opts.attentionPolicy ?? osProfile.attentionPolicy;
+        const governancePolicy = this.opts.governancePolicy ?? osProfile.governancePolicy;
+        kernelApply(runtime, this.pendingObservations, governancePolicyToKernelEvent(governancePolicy));
+        kernelApply(runtime, this.pendingObservations, {
+            kind: "set_attention_policy",
+            ...(attentionPolicy.maxQueueSize !== undefined
+                ? { max_queue_size: attentionPolicy.maxQueueSize }
+                : {}),
+        });
+        if (this.opts.schedulerBudget) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_scheduler_budget",
+                ...(this.opts.schedulerBudget.maxWallMs !== undefined
+                    ? { max_wall_ms: this.opts.schedulerBudget.maxWallMs }
+                    : {}),
+            });
+        }
+        if (this.opts.resourceQuota) {
+            const q = this.opts.resourceQuota;
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_resource_quota",
+                quota: {
+                    ...(q.maxConcurrentSubagents !== undefined
+                        ? { max_concurrent_subagents: q.maxConcurrentSubagents }
+                        : {}),
+                    ...(q.maxSpawnDepth !== undefined ? { max_spawn_depth: q.maxSpawnDepth } : {}),
+                    ...(q.memoryWritesPerWindow !== undefined
+                        ? {
+                            memory_writes_per_window: [
+                                q.memoryWritesPerWindow.maxWrites,
+                                q.memoryWritesPerWindow.windowMs,
+                            ],
+                        }
+                        : {}),
+                },
+            });
+        }
+        if (this.opts.memoryPolicy) {
+            const m = this.opts.memoryPolicy;
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_memory_policy",
+                ...(m.memoryPath !== undefined ? { memory_path: m.memoryPath } : {}),
+                ...(m.staleWarningDays !== undefined ? { stale_warning_days: m.staleWarningDays } : {}),
+                ...(m.retrievalTopK !== undefined ? { retrieval_top_k: m.retrievalTopK } : {}),
+                ...(m.validationEnabled !== undefined ? { validation_enabled: m.validationEnabled } : {}),
+                ...(m.maxContentBytes !== undefined ? { max_content_bytes: m.maxContentBytes } : {}),
+                ...(m.maxNameLength !== undefined ? { max_name_length: m.maxNameLength } : {}),
+            });
+        }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
             : kernelAction(runtime, this.pendingObservations, startPayload);
         let hasAttemptedReactiveCompact = false;
         while (!runtime.isTerminal()) {
+            if (action.kind === "execute_tool") {
+                await this.applyKernelPageIn(runtime, sessionId);
+            }
             nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
             if (this.interrupted) {
                 action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
@@ -212,30 +405,27 @@ export class RuntimeRunner {
             if (this.opts.signalSource) {
                 const sig = await this.opts.signalSource.nextSignal();
                 if (sig) {
-                    const kernelSig = {
-                        id: crypto.randomUUID(),
-                        source: sig.source ?? "custom",
-                        signalType: sig.signalType ?? "event",
-                        urgency: sig.urgency ?? "normal",
-                        summary: String(sig.payload?.goal ?? "signal"),
-                        payload: JSON.stringify(sig.payload ?? {}),
-                        dedupeKey: sig.dedupeKey,
-                        timestampMs: Date.now(),
-                    };
-                    const disposition = router.ingest(kernelSig, action.kind === "execute_tool");
-                    if (disposition === "interrupt_now") {
-                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                        break;
-                    }
-                }
-            }
-            let queued = router.next();
-            while (queued) {
-                if (queued.urgency === "critical") {
-                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                    break;
+                    const id = crypto.randomUUID();
+                    const source = sig.source ?? "custom";
+                    const signalType = sig.signalType ?? "event";
+                    const urgency = sig.urgency ?? "normal";
+                    const summary = String(sig.payload?.goal ?? "signal");
+                    const sigAction = kernelMaybeAction(runtime, this.pendingObservations, {
+                        kind: "signal",
+                        signal: {
+                            id,
+                            source,
+                            signal_type: signalType,
+                            urgency,
+                            summary,
+                            payload: sig.payload ?? {},
+                            ...(sig.dedupeKey ? { dedupe_key: sig.dedupeKey } : {}),
+                            timestamp_ms: Date.now(),
+                        },
+                    });
+                    if (sigAction)
+                        action = sigAction;
                 }
-                queued = router.next();
             }
             if (runtime.isTerminal())
                 break;
@@ -245,11 +435,16 @@ export class RuntimeRunner {
                 const context = action.context;
                 const tools = action.tools;
                 let turnTokens = 0;
+                let turnInputTokens = 0;
+                let turnOutputTokens = 0;
                 let shouldRetry = false;
                 try {
                     for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
                         if (evt.type === "usage") {
-                            turnTokens = evt.totalTokens;
+                            const usageEvt = evt;
+                            turnTokens = usageEvt.totalTokens;
+                            turnInputTokens = usageEvt.inputTokens ?? 0;
+                            turnOutputTokens = usageEvt.outputTokens ?? 0;
                             continue;
                         }
                         yield evt;
@@ -289,17 +484,33 @@ export class RuntimeRunner {
                     role: "assistant",
                     content: finalText,
                     toolCalls: finalToolCalls,
-                    tokenCount: turnTokens || undefined,
+                    tokenCount: turnOutputTokens || turnTokens || undefined,
                 };
-                action = kernelAction(runtime, this.pendingObservations, {
+                const providerEvent = {
                     kind: "provider_result",
                     message: messageToKernelMessage(assistantMessage),
-                });
+                    ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
+                    ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
+                    now_ms: Date.now(),
+                };
+                let nextAction = kernelMaybeAction(runtime, this.pendingObservations, providerEvent);
+                const hasSuspended = this.pendingObservations.some(o => o.kind === "suspended");
+                if (!nextAction && hasSuspended) {
+                    const resolved = await this.resolveKernelSuspend(runtime, sessionId);
+                    for (const evt of resolved.events)
+                        yield evt;
+                    nextAction = kernelAction(runtime, this.pendingObservations, {
+                        kind: "resume",
+                        approved_calls: resolved.approved,
+                        denied_calls: resolved.denied,
+                    });
+                }
+                action = nextAction ?? kernelAction(runtime, this.pendingObservations, providerEvent);
                 const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
                 await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
                     turn: runtime.turn(),
                     content: finalText,
-                    tokenCount: turnTokens || undefined,
+                    tokenCount: turnOutputTokens || turnTokens || undefined,
                     toolCalls: finalToolCalls,
                     providerReplay,
                 }));
@@ -312,8 +523,8 @@ export class RuntimeRunner {
                     skillContentMap: this.opts.skillContentMap,
                     dreamStore: this.opts.dreamStore,
                     knowledgeSource: this.opts.knowledgeSource,
-                    governance: this.opts.governance,
                     onToolSuspend: this.opts.onToolSuspend,
+                    onPermissionRequest: this.opts.onPermissionRequest,
                 };
                 const toolResults = [];
                 for await (const evt of this.opts.executionPlane.executeAll(allCalls, runCtx)) {
@@ -358,18 +569,15 @@ export class RuntimeRunner {
                             arguments: typeof pre.arguments === "string" ? pre.arguments : JSON.stringify(pre.arguments),
                             reason: pre.reason,
                         });
+                    }
+                    else if (evt.type === "permission_resolved") {
+                        const resolved = evt;
+                        const turn = runtime.turn();
                         await this.opts.sessionLog.append(sessionId, {
                             kind: "permission_resolved",
                             turn,
-                            approved: false,
-                            responder: "policy_gate",
-                        });
-                        await this.opts.sessionLog.append(sessionId, {
-                            kind: "tool_denied",
-                            turn,
-                            call_id: pre.callId,
-                            tool_name: pre.toolName,
-                            reason: `permission denied by policy gate: ${pre.reason}`,
+                            approved: resolved.approved,
+                            responder: resolved.responder,
                         });
                     }
                 }
@@ -383,6 +591,12 @@ export class RuntimeRunner {
                         token_count: r.tokenCount,
                     })),
                 });
+                for (const call of allCalls) {
+                    const result = toolResults.find(r => r.callId === call.id);
+                    if (result) {
+                        this.pendingSpoolOutputs.set(call.id, { tool: call.name, output: result.output });
+                    }
+                }
                 action = kernelAction(runtime, this.pendingObservations, {
                     kind: "tool_results",
                     results: toolResults.map(toolResultToKernel),
@@ -474,19 +688,10 @@ export class RuntimeRunner {
             parent_session_id: parentSessionId,
         });
         this.nextArchiveStart = await this.appendObservations(parentSessionId, runtime, this.nextArchiveStart);
-        const spawned = observations.find(o => o.kind === "agent_spawned" && typeof o.agent_id === "string");
+        const spawned = findSpawnProcessObservation(observations);
         if (!spawned)
-            throw new Error("spawn_sub_agent did not emit agent_spawned");
-        const manifest = {
-            kind: "agent_spawned",
-            turn: 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 ?? [],
-        };
+            throw new Error("spawn_sub_agent did not emit agent_process_changed");
+        const manifest = spawnObservationToManifest(spawned, spec, parentSessionId);
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const result = await orchestrator.run({
             parentOpts: this.opts,
@@ -505,95 +710,94 @@ export class RuntimeRunner {
         const turn = runtime.turn();
         const preservedRefs = runtime.preservedRefs();
         const observations = this.pendingObservations.splice(0);
-        for (const obs of observations) {
-            if (obs.kind === "compressed") {
-                const latest = await this.opts.sessionLog.latestSeq(sessionId);
-                if (latest < nextArchiveStart)
-                    continue;
-                const end = latest;
-                const compressedSeq = await this.opts.sessionLog.append(sessionId, {
-                    kind: "compressed",
-                    turn,
-                    archived_seq_range: [nextArchiveStart, end],
-                    action: compressionAction(obs.action),
-                    summary: obs.summary,
-                    summary_tokens: obs.summary
-                        ? Math.max(1, Math.ceil(obs.summary.length / 4))
-                        : undefined,
-                    preserved_refs: preservedRefs,
-                });
-                nextArchiveStart = compressedSeq + 1;
-            }
-            else if (obs.kind === "rollbacked") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "rollbacked",
-                    turn: obs.turn ?? turn,
-                    checkpoint_history_len: obs.checkpoint_history_len ?? 0,
-                    reason: obs.reason,
-                });
-            }
-            else if (obs.kind === "capability_changed") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "capability_changed",
-                    turn: obs.turn ?? turn,
-                    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 }),
-                });
-            }
-            else if (obs.kind === "milestone_advanced") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "milestone_advanced",
-                    turn: obs.turn ?? turn,
-                    phase_id: obs.phase_id ?? "",
-                    capabilities_unlocked: obs.capabilities_unlocked ?? [],
-                });
-            }
-            else if (obs.kind === "milestone_blocked") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "milestone_blocked",
-                    turn: obs.turn ?? turn,
-                    phase_id: obs.phase_id ?? "",
-                    reason: typeof obs.reason === "string" ? obs.reason : "",
-                });
-            }
-            else if (obs.kind === "milestone_evidence") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "milestone_evidence",
-                    turn: obs.turn ?? turn,
-                    phase_id: obs.phase_id ?? "",
-                    evidence: obs.evidence ?? [],
-                });
+        for (let obs of observations) {
+            if (obs.kind === "page_in_requested")
+                continue;
+            let spoolRef;
+            if (obs.kind === "large_result_spooled") {
+                const pending = this.pendingSpoolOutputs.get(obs.call_id ?? "");
+                if (pending) {
+                    const spool = this.opts.resultSpool ?? new LargeResultSpool();
+                    try {
+                        spoolRef = await spool.persistOutput(obs.call_id ?? "", pending.output);
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    if (!obs.tool && pending.tool) {
+                        obs = { ...obs, tool: pending.tool };
+                    }
+                    this.pendingSpoolOutputs.delete(obs.call_id ?? "");
+                }
             }
-            else if (obs.kind === "checkpoint_taken") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "checkpoint_taken",
-                    turn: obs.turn ?? turn,
-                    history_len: obs.history_len ?? 0,
-                });
+            const latest = obs.kind === "compressed" ? await this.opts.sessionLog.latestSeq(sessionId) : undefined;
+            const event = kernelObservationToSessionEvent(obs, turn, {
+                nextArchiveStart,
+                latestSeq: latest,
+                preservedRefs,
+                spoolRef,
+                compressionAction,
+            });
+            if (!event)
+                continue;
+            if (obs.kind === "page_out" && obs.archived) {
+                this.localPageOutCache.push(...obs.archived);
             }
-            else if (obs.kind === "agent_spawned") {
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "agent_spawned",
-                    turn: obs.turn ?? turn,
-                    agent_id: obs.agent_id ?? "",
-                    parent_session_id: obs.parent_session_id ?? "",
-                    role: obs.role ?? "",
-                    isolation: obs.isolation ?? "",
-                    context_inheritance: obs.context_inheritance ?? "",
-                    permitted_capability_ids: obs.permitted_capability_ids ?? [],
-                });
+            const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
+            if (event.kind === "compressed") {
+                nextArchiveStart = compressedSeq + 1;
             }
-            else if (obs.kind !== "renewed") {
-                console.warn(`[deepstrike] unhandled KernelObservation kind: ${obs.kind}`);
+            if (obs.kind === "page_out"
+                && obs.tier_hint === "semantic"
+                && Array.isArray(obs.archived)
+                && obs.archived.length > 0) {
+                void this.archiveSemanticPageOut(obs.archived, compressionAction(obs.action));
             }
         }
         return nextArchiveStart;
     }
+    async archiveSemanticPageOut(archived, action) {
+        if (!this.opts.dreamStore || !this.opts.agentId)
+            return;
+        try {
+            const summary = this.opts.dreamSummarizer
+                ? await this.opts.dreamSummarizer.summarize(archived, { action })
+                : await summarizeForLongTermMemory(this.opts.dreamProvider ?? this.opts.provider, archived, this.opts.dreamSystemPrompt);
+            const existing = await this.opts.dreamStore.loadMemories(this.opts.agentId);
+            await this.opts.dreamStore.commit(this.opts.agentId, {
+                toAdd: [{ text: summary, score: 1.0, metadata: { source: "semantic_page_out", action } }],
+                toRemoveIndices: [],
+                stats: {
+                    insightsProcessed: 1,
+                    duplicatesRemoved: 0,
+                    conflictsResolved: 0,
+                    entriesAdded: 1,
+                },
+            }, existing);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+}
+async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
+    const transcript = archived
+        .map(m => `${m.role}: ${m.content}`)
+        .join("\n");
+    const context = {
+        systemText: [
+            systemPrompt,
+            "Summarize the following conversation for long-term memory. Preserve key facts, decisions, and open questions.",
+        ].filter(Boolean).join("\n\n"),
+        turns: [{ role: "user", content: transcript, toolCalls: [] }],
+    };
+    let text = "";
+    const state = provider.createRunState?.();
+    for await (const evt of provider.stream(context, [], undefined, state)) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+    }
+    return text.trim() || transcript.slice(0, 2000);
 }
 function isMidRun(events) {
     return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
@@ -608,8 +812,14 @@ function compressionAction(action) {
     return undefined;
 }
 function replayMessages(events, maxBytes) {
-    const messages = [];
+    // Build upgraded-summary index: compressed_seq -> upgraded summary
+    const upgradedSummaries = new Map();
     for (const { event: e } of events) {
+        if (e.kind === "summary_upgraded")
+            upgradedSummaries.set(e.compressed_seq, e.summary);
+    }
+    const messages = [];
+    for (const { seq, event: e } of events) {
         if (e.kind === "run_started") {
             const userText = e.criteria.length
                 ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
@@ -622,8 +832,9 @@ function replayMessages(events, maxBytes) {
             });
         }
         else if (e.kind === "compressed") {
-            if (e.summary) {
-                const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+            const summary = upgradedSummaries.get(seq) ?? e.summary;
+            if (summary) {
+                const systemText = `[Compressed context: turn ${e.turn}]\n${summary}`;
                 messages.push({
                     role: "system",
                     content: systemText,