@deepstrike/wasm 0.1.16 → 0.2.1

package/dist/runtime/runner.js

@@ -1,14 +1,24 @@
 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 { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 export class RuntimeRunner {
     opts;
     interrupted = false;
+    pendingObservations = [];
+    activeKernel = null;
+    currentSessionId = null;
+    nextArchiveStart = 0;
     constructor(opts) {
         this.opts = opts;
     }
+    get hostOptions() { return this.opts; }
     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,6 +42,16 @@ 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) {
+        if (!this.activeKernel)
+            return;
+        kernelApply(this.activeKernel, this.pendingObservations, {
+            kind: "push_artifact",
+            message: messageToKernelMessage(message),
+            ...(tokens !== undefined ? { tokens } : {}),
+        });
+    }
     async dream(agentId, nowMs = Date.now()) {
         if (!this.opts.dreamStore)
             throw new Error("dreamStore not configured");
@@ -94,6 +114,8 @@ export class RuntimeRunner {
     }
     async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
         this.interrupted = false;
+        this.pendingObservations = [];
+        this.currentSessionId = sessionId;
         const kernel = await getKernel();
         this.opts.governance?._attach(kernel);
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
@@ -102,19 +124,31 @@ export class RuntimeRunner {
         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;
         const router = new kernel.SignalRouter(256);
-        sm.setTools(this.opts.executionPlane.schemas());
+        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.skillContentMap && this.opts.skillContentMap.size > 0) {
@@ -123,24 +157,56 @@ export class RuntimeRunner {
                 description: "",
                 estimatedTokens: 0,
             }));
-            sm.setAvailableSkills(metas);
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "set_available_skills",
+                skills: metas.map(skillMetadataToKernel),
+            });
+        }
+        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 ?? [],
+                        verifier: p.verifier ?? null,
+                        required_evidence: p.requiredEvidence ?? [],
+                    })),
+                },
+            });
+        }
+        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);
+            kernelApply(runtime, this.pendingObservations, {
+                kind: "preload_history",
+                messages: replayMessages(repaired, maxBytes).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);
             if (this.interrupted) {
-                sm.feedTimeout();
+                action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                 break;
             }
             if (this.opts.signalSource) {
@@ -156,9 +222,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") {
-                        sm.feedTimeout();
+                        action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                         break;
                     }
                 }
@@ -166,19 +232,20 @@ export class RuntimeRunner {
             let queued = router.next();
             while (queued) {
                 if (queued.urgency === "critical") {
-                    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") {
@@ -195,29 +262,51 @@ export class RuntimeRunner {
                     }
                 }
                 catch (err) {
-                    yield { type: "error", message: String(err) };
-                    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;
+                    }
+                }
+                if (shouldRetry) {
+                    action = {
+                        kind: "call_provider",
+                        context: runtime.render(),
+                        tools,
+                    };
+                    continue;
                 }
-                action = sm.feedLlmResponse({
+                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,
                     skillContentMap: this.opts.skillContentMap,
@@ -231,12 +320,62 @@ export class RuntimeRunner {
                     yield evt;
                     if (evt.type === "tool_result") {
                         const tre = evt;
-                        toolResults.push({ callId: tre.callId, output: tre.content, isError: tre.isError });
+                        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: typeof pre.arguments === "string" ? pre.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}`,
+                        });
                     }
                 }
                 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,
@@ -244,20 +383,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)),
+                    });
+                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                }
+                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),
+                    });
+                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                }
+                else {
+                    nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
+                    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) : 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,
                 tokenCount: m.tokenCount,
@@ -278,22 +459,138 @@ 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 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),
+        });
+        return result;
+    }
+    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;
+                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 ?? [],
+                });
+            }
+            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,7 +598,16 @@ export class RuntimeRunner {
 function isMidRun(events) {
     return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
 }
-function replayMessages(events) {
+function compressionAction(action) {
+    if (action === "snip_compact" ||
+        action === "micro_compact" ||
+        action === "context_collapse" ||
+        action === "auto_compact") {
+        return action;
+    }
+    return undefined;
+}
+function replayMessages(events, maxBytes) {
     const messages = [];
     for (const { event: e } of events) {
         if (e.kind === "run_started") {
@@ -315,10 +621,21 @@ function replayMessages(events) {
                 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: e.content,
+                content: sanitizeReplayText(e.content, maxBytes),
                 toolCalls: e.tool_calls ?? [],
                 tokenCount: e.token_count,
             });
@@ -327,12 +644,18 @@ function replayMessages(events) {
             for (const r of e.results) {
                 messages.push({
                     role: "tool",
-                    content: r.output,
+                    content: sanitizeReplayText(r.output, maxBytes),
                     toolCalls: [],
                     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;
 }