muonroi-cli 1.7.2 → 1.8.1

package/dist/src/router/step-router.js

@@ -26,7 +26,80 @@
  */
 import { getModelByTier } from "../models/registry.js";
 import { detectProviderForModel } from "../providers/runtime.js";
+import { readTimeoutEnv } from "../utils/ee-logger.js";
 import { isModelDisabled, isProviderDisabled, loadUserSettings } from "../utils/settings.js";
+// ─── EE-guided SAMR override ─────────────────────────────────────────────────
+// EE_SAMR_TIMEOUT: per-call budget for consulting the EE brain about SAMR.
+// Default 2s, range 500ms..5s. Falls back to heuristics on timeout/error.
+const EE_SAMR_TIMEOUT_MS = readTimeoutEnv("MUONROI_EE_SAMR_TIMEOUT_MS", 2000, 500, 5000);
+/**
+ * Consult the EE brain + local heuristics to decide whether SAMR should be
+ * enabled for this turn even when the user config has it disabled.
+ *
+ * Resolution order:
+ *   1. Fast heuristic — mechanical/simple tasks skip EE entirely (zero cost).
+ *   2. EE brain — asks classifyViaBrain for a yes/no + execution tier.
+ *   3. Heuristic fallback — when EE is unreachable, uses taskType + complexity.
+ */
+export async function eeSamrGuidance(params) {
+    const { userMessage, taskType, taskConfidence, complexitySize, taskComplexity } = params;
+    // Step 1: fast heuristic — mechanical tasks never benefit from SAMR
+    const mechanicalTypes = new Set(["general", "documentation", "generate", "build", "chitchat"]);
+    if (taskType && mechanicalTypes.has(taskType)) {
+        return { overrideConfig: null, reason: `mechanical taskType=${taskType} — no SAMR benefit` };
+    }
+    // Step 2: fast heuristic — trivial tasks don't need a split
+    if (taskComplexity === "low" && (complexitySize === "small" || complexitySize === undefined)) {
+        return { overrideConfig: null, reason: "low complexity + small — no SAMR benefit" };
+    }
+    // Step 3: ask EE brain
+    try {
+        const { classifyViaBrain } = await import("../ee/bridge.js");
+        const eePrompt = [
+            `Task: ${userMessage.slice(0, 200)}`,
+            `Context: type=${taskType ?? "unknown"} complexity=${taskComplexity ?? "unknown"} size=${complexitySize ?? "unknown"}`,
+            `Question: Would splitting the work into (1) premium reasoning then (2) cheap execution save tokens without hurting quality?`,
+            `Reply valid JSON: {"samr":true,"executionTier":"balanced"} or {"samr":false}`,
+        ].join("\n");
+        const response = await classifyViaBrain(eePrompt, EE_SAMR_TIMEOUT_MS, {
+            systemPrompt: 'You are a SAMR (Step-Aware Model Routing) evaluator. Given a task description, context, and question, reply ONLY with valid JSON: {"samr":true,"executionTier":"balanced"} or {"samr":false}. No extra text, no markdown.',
+            responseFormat: { type: "json_object" },
+            maxTokens: 100,
+        });
+        if (!response) {
+            // Fallback heuristic when EE unreachable
+            return samrHeuristicFallback(taskType, taskComplexity, complexitySize);
+        }
+        const parsed = JSON.parse(response);
+        if (parsed.samr === true) {
+            const tier = parsed.executionTier === "fast" ? "fast" : "balanced";
+            return {
+                overrideConfig: { enabled: true, toolExecutionTier: tier, premiumSynthesis: false },
+                reason: `ee-guided: ${tier} execution phase`,
+            };
+        }
+        return { overrideConfig: null, reason: "ee-declined" };
+    }
+    catch {
+        return samrHeuristicFallback(taskType, taskComplexity, complexitySize);
+    }
+}
+/**
+ * Deterministic fallback when EE brain is unreachable.
+ * Reasoning-heavy tasks with high complexity are strong SAMR candidates.
+ */
+function samrHeuristicFallback(taskType, taskComplexity, complexitySize) {
+    const reasoningTypes = new Set(["plan", "analyze", "refactor", "debug", "architect"]);
+    if (taskType && reasoningTypes.has(taskType)) {
+        if (taskComplexity === "high" || complexitySize === "large") {
+            return {
+                overrideConfig: { enabled: true, toolExecutionTier: "balanced", premiumSynthesis: false },
+                reason: `heuristic: ${taskType}/${taskComplexity ?? "?"}/${complexitySize ?? "?"} benefits from SAMR`,
+            };
+        }
+    }
+    return { overrideConfig: null, reason: "heuristic: no benefit" };
+}
 // ─── Defaults ────────────────────────────────────────────────────────────────
 const DEFAULT_CONFIG = {
     enabled: false,

package/dist/src/self-qa/agentic-loop.js

@@ -128,8 +128,8 @@ export async function createLLMBrain(opts) {
     //    flows without reasoning prose leaking through.
     // biome-ignore lint/suspicious/noExplicitAny: global flag is AI SDK's docs convention
     globalThis.AI_SDK_LOG_WARNINGS = false;
-    if (process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"] === undefined) {
-        process.env["MUONROI_DEEPSEEK_DISABLE_THINKING"] = "1";
+    if (process.env.MUONROI_DEEPSEEK_DISABLE_THINKING === undefined) {
+        process.env.MUONROI_DEEPSEEK_DISABLE_THINKING = "1";
     }
     // Resolve the catalog before any model lookup — resolveModelRuntime needs it
     // loaded or it throws "not found in catalog". self-verify --agentic is a
@@ -281,35 +281,35 @@ function extractJsonCandidates(text) {
 function tryParseDecisionSlice(slice) {
     try {
         const obj = JSON.parse(slice);
-        if (typeof obj["action"] !== "string")
+        if (typeof obj.action !== "string")
             return null;
-        const action = obj["action"];
-        const reason = typeof obj["reason"] === "string" ? obj["reason"] : "";
+        const action = obj.action;
+        const reason = typeof obj.reason === "string" ? obj.reason : "";
         switch (action) {
             case "type":
-                if (typeof obj["text"] === "string")
-                    return { action, text: obj["text"], reason };
+                if (typeof obj.text === "string")
+                    return { action, text: obj.text, reason };
                 return null;
             case "press":
-                if (typeof obj["key"] === "string")
-                    return { action, key: obj["key"], reason };
+                if (typeof obj.key === "string")
+                    return { action, key: obj.key, reason };
                 return null;
             case "wait_for": {
                 const w = {
                     action,
                     reason,
-                    timeoutMs: typeof obj["timeoutMs"] === "number" ? obj["timeoutMs"] : 5_000,
+                    timeoutMs: typeof obj.timeoutMs === "number" ? obj.timeoutMs : 5_000,
                 };
-                if (obj["idle"] === true)
+                if (obj.idle === true)
                     w.idle = true;
-                if (typeof obj["selector"] === "string")
-                    w.selector = obj["selector"];
-                if (typeof obj["event"] === "string")
-                    w.event = obj["event"];
+                if (typeof obj.selector === "string")
+                    w.selector = obj.selector;
+                if (typeof obj.event === "string")
+                    w.event = obj.event;
                 return w;
             }
             case "done": {
-                const v = obj["verdict"];
+                const v = obj.verdict;
                 if (v === "pass" || v === "fail" || v === "inconclusive") {
                     return { action, verdict: v, reason };
                 }
@@ -330,8 +330,14 @@ export async function runAgenticLoop(opts) {
     const events = [];
     let lastFrame = null;
     const entry = opts.entry ?? resolve("src/index.ts");
-    const mockDir = opts.mockLlmDir ?? resolve("tests/harness/fixtures/llm");
-    const args = [entry, "--agent-mode", "--mock-llm", mockDir, ...(opts.extraArgs ?? [])];
+    const args = [entry, "--agent-mode"];
+    if (opts.mockLlmDir !== "none") {
+        const mockDir = opts.mockLlmDir ?? resolve("tests/harness/fixtures/llm");
+        args.push("--mock-llm", mockDir);
+    }
+    if (opts.extraArgs) {
+        args.push(...opts.extraArgs);
+    }
     const env = {
         ...process.env,
         MUONROI_TEST_NO_PERSIST: "1",
@@ -438,6 +444,9 @@ export async function runAgenticLoop(opts) {
             }
             try {
                 await executeDecision(driver, decision);
+                if (decision.action === "type" || decision.action === "press") {
+                    await new Promise((res) => setTimeout(res, 300));
+                }
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -501,11 +510,11 @@ function wireDriver(inWrite, outRead) {
     const splitter = createLineSplitter((line) => {
         try {
             const msg = JSON.parse(line);
-            if (msg["mode"] === "live")
+            if (msg.mode === "live")
                 driver._ingest({ kind: "frame", frame: msg });
-            else if (msg["t"] === "idle")
+            else if (msg.t === "idle")
                 driver._ingest({ kind: "idle" });
-            else if (msg["t"] === "event")
+            else if (msg.t === "event")
                 driver._ingest({ kind: "event", event: msg });
         }
         catch { }

package/dist/src/self-qa/orchestrator.js

@@ -119,19 +119,19 @@ export async function runScenarios(scenarios, opts = {}) {
 }
 function wireDriver(inWrite, outRead) {
     const driver = createDriver({
-        sendKey: (k) => inWrite.write(JSON.stringify({ op: "press", key: k }) + "\n"),
-        sendType: (t) => inWrite.write(JSON.stringify({ op: "type", text: t }) + "\n"),
+        sendKey: (k) => inWrite.write(`${JSON.stringify({ op: "press", key: k })}\n`),
+        sendType: (t) => inWrite.write(`${JSON.stringify({ op: "type", text: t })}\n`),
     });
     const splitter = createLineSplitter((line) => {
         try {
             const msg = JSON.parse(line);
-            if (msg["mode"] === "live") {
+            if (msg.mode === "live") {
                 driver._ingest({ kind: "frame", frame: msg });
             }
-            else if (msg["t"] === "idle") {
+            else if (msg.t === "idle") {
                 driver._ingest({ kind: "idle" });
             }
-            else if (msg["t"] === "event") {
+            else if (msg.t === "event") {
                 driver._ingest({ kind: "event", event: msg });
             }
         }

package/dist/src/self-qa/scenario-planner.js

@@ -99,7 +99,7 @@ function parseAttrs(chunk) {
     }
     // `isModal` may appear without `={true}` in JSX (boolean shorthand). Detect.
     if (/\bisModal\b(?!\s*=)/.test(chunk))
-        out["isModal"] = true;
+        out.isModal = true;
     return out;
 }
 function buildScenariosFromHits(hits, allFiles, maxScenarios) {

package/dist/src/self-qa/spec-emitter.js

@@ -95,12 +95,12 @@ function stepToCode(step) {
         case "wait_for": {
             const obj = {};
             if (step.idle)
-                obj["idle"] = true;
+                obj.idle = true;
             if (step.selector)
-                obj["selector"] = step.selector;
+                obj.selector = step.selector;
             if (step.event)
-                obj["event"] = step.event;
-            obj["timeoutMs"] = step.timeoutMs ?? 5_000;
+                obj.event = step.event;
+            obj.timeoutMs = step.timeoutMs ?? 5_000;
             return `await driver.wait_for(${JSON.stringify(obj)});`;
         }
     }

package/dist/src/storage/__tests__/hierarchical-session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/storage/__tests__/hierarchical-session.test.js

@@ -0,0 +1,161 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const sessionsDb = new Map();
+const messagesDb = new Map();
+const toolCallsDb = new Map();
+const toolResultsDb = new Map();
+const compactionsDb = new Map();
+vi.mock("../db", () => {
+    return {
+        getDatabase: () => ({
+            prepare: (sql) => {
+                const lower = sql.toLowerCase();
+                return {
+                    get: (param) => {
+                        if (lower.includes("from sessions")) {
+                            if (lower.includes("where parent_session_id =")) {
+                                for (const [id, val] of sessionsDb.entries()) {
+                                    if (val.parent_session_id === param) {
+                                        return { id };
+                                    }
+                                }
+                                return undefined;
+                            }
+                            return sessionsDb.get(param) || { parent_session_id: null };
+                        }
+                        if (lower.includes("from tool_calls") && lower.includes("todo_write")) {
+                            const calls = toolCallsDb.get(param) || [];
+                            const todo = calls.find((c) => c.tool_name === "todo_write");
+                            return todo ? { args_json: todo.args_json } : undefined;
+                        }
+                        if (lower.includes("from compactions")) {
+                            return compactionsDb.get(param);
+                        }
+                        return undefined;
+                    },
+                    all: (...params) => {
+                        if (lower.includes("from messages")) {
+                            return messagesDb.get(params[0]) || [];
+                        }
+                        if (lower.includes("from tool_results")) {
+                            return toolResultsDb.get(params[0]) || [];
+                        }
+                        if (lower.includes("from sessions")) {
+                            if (lower.includes("where parent_session_id =")) {
+                                const results = [];
+                                for (const [id, val] of sessionsDb.entries()) {
+                                    if (val.parent_session_id === params[0]) {
+                                        results.push({ id });
+                                    }
+                                }
+                                return results;
+                            }
+                            if (lower.includes("where id in")) {
+                                return params.map((id) => ({ id }));
+                            }
+                        }
+                        return [];
+                    },
+                    run: () => ({ changes: 0 }),
+                };
+            },
+            exec: () => undefined,
+            pragma: () => undefined,
+            transaction: (fn) => fn,
+        }),
+        withTransaction: (fn) => fn({}),
+    };
+});
+import { buildChatEntries, getLastTodoWriteArgs, getSessionChain } from "../transcript.js";
+describe("Hierarchical Sessions (Silent Rotation Support)", () => {
+    beforeEach(() => {
+        sessionsDb.clear();
+        messagesDb.clear();
+        toolCallsDb.clear();
+        toolResultsDb.clear();
+        compactionsDb.clear();
+    });
+    describe("getSessionChain", () => {
+        it("returns correct chain for a single session", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            expect(getSessionChain("sessionA")).toEqual(["sessionA"]);
+        });
+        it("traverses up the parent session chain recursively", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
+            sessionsDb.set("sessionC", { parent_session_id: "sessionB" });
+            expect(getSessionChain("sessionC")).toEqual(["sessionA", "sessionB", "sessionC"]);
+        });
+        it("handles loops gracefully and does not infinite loop", () => {
+            sessionsDb.set("sessionA", { parent_session_id: "sessionB" });
+            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
+            // Should break loop and return traversed list in some order
+            const chain = getSessionChain("sessionB");
+            expect(chain.length).toBe(2);
+            expect(chain).toContain("sessionA");
+            expect(chain).toContain("sessionB");
+        });
+    });
+    describe("getLastTodoWriteArgs", () => {
+        it("returns null if no todo_write exists in chain", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            expect(getLastTodoWriteArgs("sessionA")).toBeNull();
+        });
+        it("retrieves todo_write arguments from the current session", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            toolCallsDb.set("sessionA", [
+                { id: 1, tool_call_id: "call_1", tool_name: "todo_write", args_json: '{"items":[]}' },
+            ]);
+            expect(getLastTodoWriteArgs("sessionA")).toBe('{"items":[]}');
+        });
+        it("retrieves todo_write arguments recursively from parent session", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
+            toolCallsDb.set("sessionA", [
+                { id: 1, tool_call_id: "call_1", tool_name: "todo_write", args_json: '{"items":["task1"]}' },
+            ]);
+            // sessionB has no todo_write calls
+            expect(getLastTodoWriteArgs("sessionB")).toBe('{"items":["task1"]}');
+        });
+    });
+    describe("buildChatEntries", () => {
+        it("merges messages from parent and child session chronologically", () => {
+            sessionsDb.set("sessionA", { parent_session_id: null });
+            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
+            messagesDb.set("sessionA", [
+                {
+                    seq: 1,
+                    role: "user",
+                    message_json: JSON.stringify({ role: "user", content: "Hello A" }),
+                    created_at: "2026-06-25T12:00:00Z",
+                },
+                {
+                    seq: 2,
+                    role: "assistant",
+                    message_json: JSON.stringify({ role: "assistant", content: "Reply A" }),
+                    created_at: "2026-06-25T12:01:00Z",
+                },
+            ]);
+            messagesDb.set("sessionB", [
+                {
+                    seq: 1,
+                    role: "system",
+                    // compaction summary (should be skipped since it's the first message of a child)
+                    message_json: JSON.stringify({ role: "system", content: "[Context checkpoint summary]\nEarlier work" }),
+                    created_at: "2026-06-25T12:02:00Z",
+                },
+                {
+                    seq: 2,
+                    role: "user",
+                    message_json: JSON.stringify({ role: "user", content: "Hello B" }),
+                    created_at: "2026-06-25T12:03:00Z",
+                },
+            ]);
+            const entries = buildChatEntries("sessionB");
+            expect(entries.length).toBe(3);
+            expect(entries[0]).toEqual(expect.objectContaining({ type: "user", content: "Hello A" }));
+            expect(entries[1]).toEqual(expect.objectContaining({ type: "assistant", content: "Reply A" }));
+            expect(entries[2]).toEqual(expect.objectContaining({ type: "user", content: "Hello B" }));
+        });
+    });
+});
+//# sourceMappingURL=hierarchical-session.test.js.map

package/dist/src/storage/__tests__/sweep-stale-pending.test.js

@@ -89,8 +89,8 @@ describe("sweepStalePendingRows", () => {
         vi.spyOn(Date, "now").mockReturnValue(fixedNow);
         sweepStalePendingRows(60_000);
         const toolCallCall = preparedCalls.find((c) => c.sql.toLowerCase().includes("update tool_calls"));
-        // run args: [now, cutoff]
-        const cutoff = toolCallCall?.runArgs[1];
+        // run args: [cutoff]
+        const cutoff = toolCallCall?.runArgs[0];
         expect(cutoff).toBe("2026-05-22T09:59:00.000Z");
     });
 });

package/dist/src/storage/index.d.ts

@@ -3,7 +3,7 @@ export { loadConfig, type MuonroiConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { type InteractionEventType, logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
 export { buildEffectiveTranscript, type LoadedTranscriptState, type PersistedCompaction } from "./transcript-view.js";
 export { logUIInteraction, type UIInteractionSubtype } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent, type TokenUsageLike } from "./usage.js";

package/dist/src/storage/index.js

@@ -4,7 +4,7 @@ export { loadConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
 export { buildEffectiveTranscript } from "./transcript-view.js";
 export { logUIInteraction } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent } from "./usage.js";

package/dist/src/storage/migrations.js

@@ -1,4 +1,4 @@
-const LATEST_DB_VERSION = 7;
+const LATEST_DB_VERSION = 8;
 export function applyMigrations(db) {
     const version = Number(db.pragma("user_version", { simple: true })) || 0;
     if (version >= LATEST_DB_VERSION)
@@ -87,6 +87,15 @@ export function applyMigrations(db) {
             }
             db.pragma("user_version = 7");
         }
+        if (version < 8) {
+            const cols = db.prepare("PRAGMA table_info(sessions)").all();
+            const colNames = new Set(cols.map((c) => c.name));
+            if (!colNames.has("parent_session_id")) {
+                db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL");
+            }
+            db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_parent_id ON sessions(parent_session_id)");
+            db.pragma("user_version = 8");
+        }
     });
     migrate();
 }
@@ -104,6 +113,7 @@ function createInitialSchema(db) {
     CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
       title TEXT,
       model TEXT NOT NULL,
       mode TEXT NOT NULL,
@@ -172,6 +182,8 @@ function createInitialSchema(db) {
 
     CREATE INDEX IF NOT EXISTS idx_sessions_workspace_updated
       ON sessions(workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_sessions_parent_id
+      ON sessions(parent_session_id);
     CREATE INDEX IF NOT EXISTS idx_messages_session_seq
       ON messages(session_id, seq);
     CREATE INDEX IF NOT EXISTS idx_tool_calls_session_seq

package/dist/src/storage/transcript-response-entry.test.js

@@ -18,11 +18,24 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 let MESSAGE_ROWS = [];
 vi.mock("./db", () => ({
     getDatabase: () => ({
-        prepare: (sql) => ({
-            all: () => (sql.includes("FROM messages") ? MESSAGE_ROWS : []),
-            get: () => undefined,
-            run: () => undefined,
-        }),
+        prepare: (sql) => {
+            const lower = sql.toLowerCase();
+            return {
+                all: (...params) => {
+                    if (lower.includes("from messages")) {
+                        return MESSAGE_ROWS;
+                    }
+                    if (lower.includes("from sessions")) {
+                        if (lower.includes("where id in")) {
+                            return params.map((id) => ({ id }));
+                        }
+                    }
+                    return [];
+                },
+                get: () => undefined,
+                run: () => undefined,
+            };
+        },
     }),
     withTransaction: (fn) => fn({}),
 }));

package/dist/src/storage/transcript-view.js

@@ -9,7 +9,13 @@ export function buildEffectiveTranscript(messages, seqs, timestamps, compaction)
         };
     }
     const firstKeptIndex = seqs.findIndex((seq) => seq >= compaction.firstKeptSeq);
-    const keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
+    let keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
+    // Anti-mù / Resilience: if firstKeptSeq landed on a `tool` message (e.g. due to seq array 
+    // misalignment or forced cut), we MUST step back to include its preceding `assistant` message.
+    // Otherwise Vercel AI SDK throws: "Messages with role 'tool' must be a response to a preceding message with 'tool_calls'"
+    if (keptIndex > 0 && messages[keptIndex]?.role === "tool") {
+        keptIndex -= 1;
+    }
     const keptMessages = messages.slice(keptIndex);
     const keptSeqs = seqs.slice(keptIndex);
     const keptTimestamps = timestamps.slice(keptIndex);

package/dist/src/storage/transcript.d.ts

@@ -104,4 +104,7 @@ export declare function sweepStalePendingRows(staleAfterMs?: number): {
 };
 export declare function markToolCallErrored(sessionId: string, toolCallId: string, errorMessage: string): void;
 export declare function appendCompaction(sessionId: string, firstKeptSeq: number, summary: string, tokensBefore: number): void;
+export declare function revertLatestCompaction(sessionId: string): void;
+export declare function getSessionChain(sessionId: string): string[];
 export declare function buildChatEntries(sessionId: string): ChatEntry[];
+export declare function getLastTodoWriteArgs(sessionId: string): string | null;