@deepstrike/sdk 0.1.15 → 0.2.0

package/dist/runtime/runner.js

@@ -1,14 +1,104 @@
 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 { capabilityMarker, capabilitySkill, capabilityTool, capabilityCommandMount, capabilityCommandUnmount, kernelAction, kernelApply, forceCompact, messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { agentRunSpecToKernel, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel } from "../types/agent.js";
+import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
+    activeKernel = null;
+    pendingObservations = [];
+    currentSessionId = null;
+    nextArchiveStart = 0;
     constructor(opts) {
         this.opts = opts;
     }
+    /** Host configuration (for coordinator / sub-agent spawn). */
+    get hostOptions() {
+        return this.opts;
+    }
+    /** Mount a tool capability on the currently-running kernel runtime. No-op if not running. */
+    mountTool(schema) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityTool(schema)));
+    }
+    /** Mount a skill capability on the currently-running kernel runtime. No-op if not running. */
+    mountSkill(name, description) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilitySkill({ name, description, estimatedTokens: 0 })));
+    }
+    /** Mount a generic marker capability (e.g. MCP server, agent) on the active run. No-op if not running. */
+    mountMarker(kind, id, description) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandMount(capabilityMarker(kind, id, description)));
+    }
+    /** Unmount a capability by kind + id from the active run. No-op if not running. */
+    unmountCapability(kind, id) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, capabilityCommandUnmount(kind, id));
+    }
+    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
+    pushArtifact(message, tokens) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, {
+            kind: "push_artifact",
+            message: messageToKernelMessage(message),
+            ...(tokens !== undefined ? { tokens } : {}),
+        });
+    }
+    /**
+     * Spawn an isolated sub-agent via the kernel, run it on the host, and feed the result back.
+     * Requires an active parent run (`run()` / `wake()` in progress or paused at milestone).
+     */
+    async *spawnSubAgent(spec) {
+        if (!this.activeKernel || !this.currentSessionId) {
+            throw new Error("spawnSubAgent requires an active parent run");
+        }
+        const parentSessionId = this.currentSessionId;
+        const runtime = this.activeKernel;
+        const observations = kernelApply(runtime, this.pendingObservations, {
+            kind: "spawn_sub_agent",
+            spec: agentRunSpecToKernel(spec),
+            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");
+        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 ?? [],
+        };
+        const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
+        const result = await orchestrator.run({
+            parentOpts: this.opts,
+            parentSessionId,
+            spec,
+            manifest,
+            sessionLog: this.opts.sessionLog,
+        });
+        kernelApply(runtime, this.pendingObservations, {
+            kind: "sub_agent_completed",
+            result: subAgentResultToKernel(result),
+        });
+        yield { type: "done", iterations: result.result.turnsUsed, totalTokens: result.result.totalTokensUsed, status: result.result.termination };
+    }
     interrupt() { this.interrupted = true; }
     async *run(req) {
-        const prior = await this.opts.sessionLog.read(req.sessionId);
+        const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
         if (!midRun) {
             await this.opts.sessionLog.append(req.sessionId, {
@@ -32,14 +122,16 @@ export class RuntimeRunner {
         const start = startEntry.event;
         yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
     }
-    async dream(agentId, nowMs = Date.now()) {
+    async *dream(agentId, nowMs = Date.now()) {
         if (!this.opts.dreamStore)
             throw new Error("dreamStore not configured");
         const kernel = getKernel();
         const sessions = await this.opts.dreamStore.loadSessions(agentId);
         const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
-        if (!sessions.length)
-            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        if (!sessions.length) {
+            yield { type: "done", iterations: 0, totalTokens: 0, status: "completed", dreamResult: { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 } };
+            return;
+        }
         const pipeline = new kernel.IdlePipeline(agentId);
         const action1 = pipeline.feedTrigger(sessions.map(s => ({
             sessionId: s.sessionId, agentId: s.agentId,
@@ -51,20 +143,27 @@ export class RuntimeRunner {
             createdAtMs: s.createdAtMs, updatedAtMs: s.updatedAtMs,
         })), existingMemories.map(e => ({ text: e.text, score: e.score, metadata: JSON.stringify(e.metadata ?? null) })), nowMs);
         if (action1.kind === "noop" || action1.kind === "aborted") {
-            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+            yield { type: "done", iterations: 0, totalTokens: 0, status: "completed", dreamResult: { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 } };
+            return;
         }
         if (action1.kind !== "synthesize_insights")
             throw new Error(`unexpected: ${action1.kind}`);
         let synthesisText = "";
         const providerState = this.opts.provider.createRunState?.();
         const synthMsgs = (action1.messages ?? []);
+        const kernelSystemText = synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n");
         const synthContext = {
-            systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
+            systemText: [kernelSystemText, this.opts.dreamSystemPrompt].filter(Boolean).join("\n\n"),
             turns: synthMsgs.filter(m => m.role !== "system"),
         };
+        let totalTokens = 0;
         for await (const evt of this.opts.provider.stream(synthContext, [], undefined, providerState)) {
-            if (evt.type === "text_delta")
+            if (evt.type === "text_delta") {
                 synthesisText += evt.delta;
+                yield evt;
+            }
+            else if (evt.type === "usage")
+                totalTokens = evt.totalTokens;
         }
         const action2 = pipeline.feedSynthesisResult(synthesisText);
         if (action2.kind !== "commit_memories")
@@ -84,62 +183,131 @@ export class RuntimeRunner {
             },
         };
         await this.opts.dreamStore.commit(agentId, dsResult, existingMemories);
-        return {
-            sessionsProcessed: rr.sessionsProcessed,
-            insightsExtracted: rr.insightsExtracted,
-            entriesAdded: cr.stats?.entriesAdded ?? 0,
-            entriesRemoved: (cr.toRemoveIndices ?? []).length,
+        yield {
+            type: "done", iterations: 1, totalTokens, status: "completed",
+            dreamResult: {
+                sessionsProcessed: rr.sessionsProcessed,
+                insightsExtracted: rr.insightsExtracted,
+                entriesAdded: cr.stats?.entriesAdded ?? 0,
+                entriesRemoved: (cr.toRemoveIndices ?? []).length,
+            },
         };
     }
     async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
         this.interrupted = false;
+        this.pendingObservations = [];
+        this.currentSessionId = sessionId;
         const kernel = getKernel();
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
         const providerState = this.opts.provider.createRunState?.();
         let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
-        // Three-layer policy merge: explicit RuntimeOptions > provider.runtimePolicy() > defaults
         const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
         const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
         const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
-        const sm = new kernel.LoopStateMachine({
+        const runtime = new kernel.KernelRuntime({
             maxTokens: this.opts.maxTokens,
             maxTurns: effectiveMaxTurns,
             timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
         });
+        this.activeKernel = runtime;
+        this.nextArchiveStart = nextCompressedArchiveStart;
         const router = new kernel.SignalRouter(256);
-        sm.setTools(this.opts.executionPlane.schemas());
+        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),
+        });
         if (this.opts.systemPrompt) {
-            sm.addSystemMessage(this.opts.systemPrompt, Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)));
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "add_system_message",
+                content: this.opts.systemPrompt,
+                tokens: Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)),
+            });
         }
         if (this.opts.initialMemory) {
             for (const mem of this.opts.initialMemory) {
-                sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+                kernelApply(runtime, this.pendingObservations, {
+                    kind: "add_memory_message",
+                    content: mem,
+                    tokens: Math.max(1, Math.ceil(mem.length / 4)),
+                });
             }
         }
         if (this.opts.skillDir) {
             const { scanSkillDir } = await import("../skills/loader.js");
             const metas = await scanSkillDir(this.opts.skillDir);
-            sm.setAvailableSkills(metas.map((m) => ({
-                name: m.name, description: m.description, whenToUse: m.whenToUse,
-                effort: m.effort, estimatedTokens: m.estimatedTokens ?? 0,
-            })));
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_available_skills",
+                skills: metas.map((m) => skillMetadataToKernel({
+                    name: m.name,
+                    description: m.description,
+                    whenToUse: m.whenToUse,
+                    effort: m.effort,
+                    estimatedTokens: m.estimatedTokens ?? 0,
+                })),
+            });
+        }
+        if (this.opts.dreamStore && this.opts.agentId) {
+            kernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true });
+        }
+        if (this.opts.knowledgeSource) {
+            kernelApply(runtime, this.pendingObservations, { kind: "set_knowledge_enabled", enabled: true });
         }
-        if (this.opts.dreamStore && this.opts.agentId)
-            sm.setMemoryEnabled(true);
-        if (this.opts.knowledgeSource)
-            sm.setKnowledgeEnabled(true);
+        if (this.opts.milestoneContract) {
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "load_milestone_contract",
+                contract: {
+                    phases: this.opts.milestoneContract.phases.map(p => ({
+                        id: p.id,
+                        criteria: p.criteria ?? [],
+                        unlocks: p.unlocks ?? [],
+                        required_evidence: p.requiredEvidence ?? [],
+                        ...(p.verifier ? { verifier: p.verifier } : {}),
+                    })),
+                },
+            });
+        }
+        const maxBytes = runtime.recoveryContentBytes();
         if (priorEvents && priorEvents.length > 0) {
-            seedProviderReplayFromEvents(this.opts.provider, priorEvents);
-            sm.preloadHistory(replayMessages(priorEvents));
+            const repaired = repairEventsForRecovery(priorEvents, maxBytes);
+            seedProviderReplayFromEvents(this.opts.provider, repaired);
+            const loadArchive = this.opts.compressionStore
+                ? (ref) => this.opts.compressionStore.read(ref)
+                : undefined;
+            const replayed = await replayMessagesAsync(repaired, maxBytes, loadArchive);
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "preload_history",
+                messages: replayed.map(messageToKernelMessage),
+            });
         }
         const sessionStart = Date.now();
+        const startPayload = {
+            kind: "start_run",
+            task: { goal, criteria },
+        };
+        if (this.opts.runSpec) {
+            startPayload.run_spec = agentRunSpecToKernel(this.opts.runSpec);
+        }
         let action = resumeMidRun
-            ? sm.resumeAfterPreload()
-            : sm.start({ goal, criteria });
-        while (!sm.isTerminal()) {
-            nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+            ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
+            : kernelAction(runtime, this.pendingObservations, startPayload);
+        let hasAttemptedReactiveCompact = false;
+        while (!runtime.isTerminal()) {
+            nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+            this.nextArchiveStart = nextCompressedArchiveStart;
             if (this.interrupted) {
-                action = sm.feedTimeout();
+                action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                 break;
             }
             if (this.opts.signalSource) {
@@ -155,9 +323,9 @@ export class RuntimeRunner {
                         dedupeKey: sig.dedupeKey,
                         timestampMs: Date.now(),
                     };
-                    const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
+                    const disposition = router.ingest(kernelSig, action.kind === "execute_tool");
                     if (disposition === "interrupt_now") {
-                        action = sm.feedTimeout();
+                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                         break;
                     }
                 }
@@ -165,19 +333,20 @@ export class RuntimeRunner {
             let queued = router.next();
             while (queued) {
                 if (queued.urgency === "critical") {
-                    action = sm.feedTimeout();
+                    action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                     break;
                 }
                 queued = router.next();
             }
-            if (sm.isTerminal())
+            if (runtime.isTerminal())
                 break;
-            if (action.kind === "call_llm") {
+            if (action.kind === "call_provider") {
                 const finalToolCalls = [];
                 let finalText = "";
                 const context = action.context;
-                const tools = (action.tools ?? []);
+                const tools = action.tools;
                 let turnTokens = 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") {
@@ -194,29 +363,51 @@ export class RuntimeRunner {
                     }
                 }
                 catch (err) {
-                    yield { type: "error", message: String(err) };
-                    action = sm.feedTimeout();
-                    break;
+                    const errMsg = String(err).toLowerCase();
+                    if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
+                        !hasAttemptedReactiveCompact) {
+                        hasAttemptedReactiveCompact = true;
+                        if (forceCompact(runtime, this.pendingObservations)) {
+                            nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                            shouldRetry = true;
+                        }
+                    }
+                    if (!shouldRetry) {
+                        yield { type: "error", message: String(err) };
+                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
+                        break;
+                    }
                 }
-                action = sm.feedLlmResponse({
+                if (shouldRetry) {
+                    action = {
+                        kind: "call_provider",
+                        context: runtime.render(),
+                        tools,
+                    };
+                    continue;
+                }
+                const assistantMessage = {
                     role: "assistant",
                     content: finalText,
                     toolCalls: finalToolCalls,
                     tokenCount: turnTokens || undefined,
+                };
+                action = kernelAction(runtime, this.pendingObservations, {
+                    kind: "provider_result",
+                    message: messageToKernelMessage(assistantMessage),
                 });
                 const providerReplay = peekProviderReplay(this.opts.provider, finalText, finalToolCalls);
-                await this.opts.sessionLog.append(sessionId, {
-                    kind: "llm_completed",
-                    turn: sm.turn,
+                await this.opts.sessionLog.append(sessionId, buildLlmCompletedEvent({
+                    turn: runtime.turn(),
                     content: finalText,
-                    token_count: turnTokens || undefined,
-                    tool_calls: finalToolCalls,
-                    ...(providerReplay ? { provider_replay: providerReplay } : {}),
-                });
+                    tokenCount: turnTokens || undefined,
+                    toolCalls: finalToolCalls,
+                    providerReplay,
+                }));
             }
-            else if (action.kind === "execute_tools") {
-                const allCalls = action.calls ?? [];
-                await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: sm.turn, calls: allCalls });
+            else if (action.kind === "execute_tool") {
+                const allCalls = action.calls;
+                await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: runtime.turn(), calls: allCalls });
                 const runCtx = {
                     agentId: this.opts.agentId,
                     skillDir: this.opts.skillDir,
@@ -226,16 +417,85 @@ export class RuntimeRunner {
                     onToolSuspend: this.opts.onToolSuspend,
                 };
                 const toolResults = [];
-                for await (const evt of this.opts.executionPlane.executeAll(allCalls, runCtx)) {
-                    yield evt;
-                    if (evt.type === "tool_result") {
-                        const tre = evt;
-                        toolResults.push({ callId: tre.callId, output: tre.content, isError: tre.isError });
+                const normalCalls = allCalls.filter(c => c.name !== "update_plan");
+                const planCalls = allCalls.filter(c => c.name === "update_plan");
+                for (const call of planCalls) {
+                    const update = parseUpdatePlanArgs(call.arguments);
+                    kernelApply(runtime, this.pendingObservations, {
+                        kind: "update_task",
+                        update: taskUpdateToKernel(update),
+                    });
+                    const result = { callId: call.id, output: "success", isError: false };
+                    toolResults.push(result);
+                    yield { type: "tool_result", callId: call.id, content: "success", isError: false };
+                }
+                if (normalCalls.length > 0) {
+                    for await (const evt of this.opts.executionPlane.executeAll(normalCalls, runCtx)) {
+                        yield evt;
+                        if (evt.type === "tool_result") {
+                            const tre = evt;
+                            toolResults.push({
+                                callId: tre.callId,
+                                output: tre.content,
+                                isError: tre.isError,
+                                isFatal: tre.isFatal,
+                                errorKind: tre.errorKind,
+                            });
+                        }
+                        else if (evt.type === "tool_argument_repaired") {
+                            const tare = evt;
+                            await this.opts.sessionLog.append(sessionId, {
+                                kind: "tool_argument_repaired",
+                                turn: runtime.turn(),
+                                tool: tare.name,
+                                original_arguments: tare.originalArguments,
+                                repaired_arguments: tare.repairedArguments,
+                            });
+                        }
+                        else if (evt.type === "tool_denied") {
+                            const tde = evt;
+                            await this.opts.sessionLog.append(sessionId, {
+                                kind: "tool_denied",
+                                turn: runtime.turn(),
+                                call_id: tde.callId,
+                                tool_name: tde.toolName,
+                                reason: tde.reason,
+                            });
+                        }
+                        else if (evt.type === "permission_request") {
+                            const pre = evt;
+                            const turn = runtime.turn();
+                            await this.opts.sessionLog.append(sessionId, {
+                                kind: "permission_requested",
+                                turn,
+                                tool: pre.toolName,
+                                arguments: JSON.stringify(pre.arguments),
+                                reason: pre.reason,
+                            });
+                            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}`,
+                            });
+                        }
                     }
+                    const names = normalCalls.map(c => c.name).join(", ");
+                    kernelApply(runtime, this.pendingObservations, {
+                        kind: "update_task",
+                        update: taskUpdateToKernel({ progress: `Executed tools: ${names}` }),
+                    });
                 }
                 await this.opts.sessionLog.append(sessionId, {
                     kind: "tool_completed",
-                    turn: sm.turn,
+                    turn: runtime.turn(),
                     results: toolResults.map(r => ({
                         call_id: r.callId,
                         output: r.output,
@@ -243,20 +503,62 @@ export class RuntimeRunner {
                         token_count: r.tokenCount,
                     })),
                 });
-                action = sm.feedToolResults(toolResults);
+                action = kernelAction(runtime, this.pendingObservations, {
+                    kind: "tool_results",
+                    results: toolResults.map(toolResultToKernel),
+                });
+            }
+            else if (action.kind === "evaluate_milestone") {
+                const milestonePolicy = this.opts.milestonePolicy ?? "require_verifier";
+                if (milestonePolicy === "auto_pass") {
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "milestone_result",
+                        result: milestoneCheckResultToKernel(milestoneCheckPass(action.phaseId)),
+                    });
+                    this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
+                }
+                else if (this.opts.onMilestoneEvaluate) {
+                    const check = await this.opts.onMilestoneEvaluate({
+                        phaseId: action.phaseId,
+                        criteria: action.criteria,
+                        requiredEvidence: action.requiredEvidence,
+                    });
+                    action = kernelAction(runtime, this.pendingObservations, {
+                        kind: "milestone_result",
+                        result: milestoneCheckResultToKernel(check),
+                    });
+                    this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
+                }
+                else {
+                    this.nextArchiveStart = await this.appendObservations(sessionId, runtime, this.nextArchiveStart);
+                    const turnsUsed = Math.max(1, runtime.turn());
+                    await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
+                        reason: "milestone_pending",
+                        turnsUsed,
+                        totalTokens: 0,
+                    }));
+                    yield { type: "done", iterations: turnsUsed, totalTokens: 0, status: "milestone_pending" };
+                    this.activeKernel = null;
+                    this.currentSessionId = null;
+                    return;
+                }
             }
             else if (action.kind === "done") {
                 break;
             }
         }
-        const result = action.result;
+        const result = action.kind === "done" ? action.result : undefined;
         const status = result?.termination ?? "error";
-        const turnsUsed = result ? Math.max(1, result.turnsUsed) : 0;
-        const totalTokens = result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0;
-        nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
-        await this.opts.sessionLog.append(sessionId, { kind: "run_terminal", reason: status, turns_used: turnsUsed, total_tokens: totalTokens });
+        const turnsUsed = result ? Math.max(1, result.turnsUsed) : runtime.turn() || 0;
+        const totalTokens = result?.totalTokensUsed ?? 0;
+        nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+        await this.opts.sessionLog.append(sessionId, buildRunTerminalEvent({
+            reason: status,
+            turnsUsed,
+            totalTokens,
+        }));
         if (this.opts.dreamStore && this.opts.agentId) {
-            const newMsgs = sm.drainNewMessages().map(m => ({
+            const newMsgs = runtime.drainNewMessages().map(m => ({
                 role: m.role,
                 content: m.content,
                 contentParts: m.contentParts,
@@ -278,22 +580,110 @@ export class RuntimeRunner {
             }
         }
         yield { type: "done", iterations: turnsUsed, totalTokens, status };
+        this.activeKernel = null;
+        this.currentSessionId = null;
     }
-    async appendObservations(sessionId, sm, nextArchiveStart) {
-        const observations = sm.takeObservations();
+    async appendObservations(sessionId, runtime, nextArchiveStart) {
+        const turn = runtime.turn();
+        const preservedRefs = runtime.preservedRefs();
+        const observations = this.pendingObservations.splice(0);
         for (const obs of observations) {
-            if (obs.kind !== "compressed")
-                continue;
-            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: sm.turn,
-                archived_seq_range: [nextArchiveStart, end],
-            });
-            nextArchiveStart = compressedSeq + 1;
+            if (obs.kind === "compressed") {
+                const latest = await this.opts.sessionLog.latestSeq(sessionId);
+                if (latest < nextArchiveStart)
+                    continue;
+                const end = latest;
+                let archiveRef = undefined;
+                const archived = obs.archived;
+                if (this.opts.compressionStore && archived && archived.length > 0) {
+                    try {
+                        const pathRef = await this.opts.compressionStore.write(sessionId, nextArchiveStart, archived);
+                        if (pathRef)
+                            archiveRef = pathRef;
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                }
+                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,
+                    archive_ref: archiveRef,
+                    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 ?? [],
+                });
+            }
+            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,
+                });
+            }
+            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 ?? [],
+                });
+            }
+            else if (obs.kind !== "renewed") {
+                console.warn(`[deepstrike] unhandled KernelObservation kind: ${obs.kind}`);
+            }
         }
         return nextArchiveStart;
     }
@@ -301,11 +691,69 @@ export class RuntimeRunner {
 function isMidRun(events) {
     return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
 }
-/**
- * Replay session events into Message[] for preloadHistory.
- * run_started → user turn; llm_completed → assistant; tool_completed → tool messages.
- */
-function replayMessages(events) {
+function compressionAction(action) {
+    if (action === "snip_compact" ||
+        action === "micro_compact" ||
+        action === "context_collapse" ||
+        action === "auto_compact") {
+        return action;
+    }
+    return undefined;
+}
+export function replayMessages(events, maxBytes) {
+    const messages = [];
+    for (const { 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")}`
+                : e.goal;
+            messages.push({
+                role: "user",
+                content: userText,
+                toolCalls: [],
+                tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
+            });
+        }
+        else if (e.kind === "compressed") {
+            if (e.summary) {
+                const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+                messages.push({
+                    role: "system",
+                    content: systemText,
+                    toolCalls: [],
+                    tokenCount: Math.max(1, Math.ceil(systemText.length / 4)),
+                });
+            }
+        }
+        else if (e.kind === "llm_completed") {
+            messages.push({
+                role: "assistant",
+                content: sanitizeReplayText(e.content, maxBytes),
+                toolCalls: e.tool_calls ?? [],
+                tokenCount: e.token_count,
+            });
+        }
+        else if (e.kind === "tool_completed") {
+            for (const r of e.results) {
+                messages.push({
+                    role: "tool",
+                    content: "",
+                    toolCalls: [],
+                    contentParts: [{ type: "tool_result", callId: r.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: r.is_error ?? false }],
+                    tokenCount: r.token_count,
+                });
+            }
+        }
+        else if (e.kind === "rollbacked") {
+            const len = e.checkpoint_history_len ?? 0;
+            if (messages.length > len) {
+                messages.length = len;
+            }
+        }
+    }
+    return messages;
+}
+export async function replayMessagesAsync(events, maxBytes, loadArchive) {
     const messages = [];
     for (const { event: e } of events) {
         if (e.kind === "run_started") {
@@ -319,10 +767,41 @@ function replayMessages(events) {
                 tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
             });
         }
+        else if (e.kind === "compressed") {
+            let loadedSuccessfully = false;
+            if (e.archive_ref && loadArchive) {
+                try {
+                    const archivedMsgs = await loadArchive(e.archive_ref);
+                    for (const msg of archivedMsgs) {
+                        messages.push({
+                            role: msg.role,
+                            content: sanitizeReplayText(msg.content, maxBytes),
+                            toolCalls: msg.toolCalls ?? [],
+                            tokenCount: msg.tokenCount,
+                        });
+                    }
+                    loadedSuccessfully = true;
+                }
+                catch (err) {
+                    // Loader failed (e.g. MissingArchive). We degrade and fallback.
+                }
+            }
+            if (!loadedSuccessfully) {
+                if (e.summary) {
+                    const systemText = `[Compressed context: turn ${e.turn}]\n${e.summary}`;
+                    messages.push({
+                        role: "system",
+                        content: systemText,
+                        toolCalls: [],
+                        tokenCount: Math.max(1, Math.ceil(systemText.length / 4)),
+                    });
+                }
+            }
+        }
         else if (e.kind === "llm_completed") {
             messages.push({
                 role: "assistant",
-                content: e.content,
+                content: sanitizeReplayText(e.content, maxBytes),
                 toolCalls: e.tool_calls ?? [],
                 tokenCount: e.token_count,
             });
@@ -333,11 +812,17 @@ function replayMessages(events) {
                     role: "tool",
                     content: "",
                     toolCalls: [],
-                    contentParts: [{ type: "tool_result", callId: r.call_id, output: r.output, isError: r.is_error ?? false }],
+                    contentParts: [{ type: "tool_result", callId: r.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: r.is_error ?? false }],
                     tokenCount: r.token_count,
                 });
             }
         }
+        else if (e.kind === "rollbacked") {
+            const len = e.checkpoint_history_len ?? 0;
+            if (messages.length > len) {
+                messages.length = len;
+            }
+        }
     }
     return messages;
 }
@@ -366,3 +851,21 @@ export async function collectText(stream) {
     }
     return text;
 }
+function parseUpdatePlanArgs(argsStr) {
+    let parsed = {};
+    try {
+        parsed = JSON.parse(argsStr);
+    }
+    catch {
+        // Ignore parse error
+    }
+    return {
+        plan: parsed.plan,
+        currentStep: parsed.currentStep !== undefined ? Number(parsed.currentStep) : parsed.current_step !== undefined ? Number(parsed.current_step) : undefined,
+        progress: parsed.progress,
+        scratchpad: parsed.scratchpad,
+        blockedOn: parsed.blockedOn !== undefined
+            ? parsed.blockedOn
+            : parsed.blocked_on,
+    };
+}