muonroi-cli 1.3.4 → 1.4.1

package/dist/src/storage/__tests__/ui-interaction-log.test.js

@@ -28,6 +28,36 @@ describe("logUIInteraction", () => {
         });
         expect(logInteraction).not.toHaveBeenCalled();
     });
+    it("persists askcard_open option labels + recommended label for measurement", () => {
+        // Observability gap (live obs 2026-06-04): askcard_open only stored
+        // optionCount + defaultIndex, so a DB/forensics audit could see WHICH index
+        // was recommended but never WHAT it pointed at — making the scope-card
+        // recommend fix (#47) unverifiable from past sessions. Persist the labels.
+        logUIInteraction("sess-labels", {
+            subtype: "askcard_open",
+            data: {
+                questionId: "q-scope",
+                question: "Which part of the codebase should this target?",
+                phase: "clarify",
+                optionCount: 3,
+                defaultIndex: 2,
+                optionLabels: ["src/cli (cli)", "src/council (council)", "Entire project"],
+                recommendedLabel: "Entire project",
+            },
+        });
+        expect(logInteraction).toHaveBeenCalledWith("sess-labels", "ui_interaction", {
+            eventSubtype: "askcard_open",
+            data: {
+                questionId: "q-scope",
+                question: "Which part of the codebase should this target?",
+                phase: "clarify",
+                optionCount: 3,
+                defaultIndex: 2,
+                optionLabels: ["src/cli (cli)", "src/council (council)", "Entire project"],
+                recommendedLabel: "Entire project",
+            },
+        });
+    });
     it("writes ui_interaction with subtype and structured payload", () => {
         logUIInteraction("sess-1", {
             subtype: "askcard_answered",

package/dist/src/storage/atomic-io.test.js

@@ -8,10 +8,10 @@ beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "atomic-io-test-"));
 });
 afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
+    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
 });
 describe("atomicWriteJSON", () => {
-    it("Test 1: writes file and removes .tmp on success", async () => {
+    it("Test 1: writes file and removes .tmp on success", { retry: 2 }, async () => {
         const filePath = path.join(tmpDir, "foo.json");
         await atomicWriteJSON(filePath, { hello: 1 });
         const raw = await fs.readFile(filePath, "utf8");

package/dist/src/storage/config.test.js

@@ -9,7 +9,7 @@ beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "config-test-"));
 });
 afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
+    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
 });
 describe("loadConfig", () => {
     it("Test 5: bootstraps default config when ~/.muonroi-cli/config.json absent", async () => {

package/dist/src/storage/interaction-log.d.ts

@@ -4,7 +4,7 @@
  * Fire-and-forget interaction logging for detailed user-agent event tracking.
  * All calls are fail-open — logging never breaks the main flow.
  */
-export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry";
+export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer";
 export interface EEInjectionRow {
     session_id: string;
     event_subtype: string | null;

package/dist/src/storage/interaction-log.js

@@ -43,10 +43,10 @@ export function selectEEInjectionsForRun(runId, limit = 20) {
     try {
         const db = getDatabase();
         return db
-            .prepare(`SELECT session_id, event_subtype, duration_ms, metadata_json, created_at
-         FROM interaction_logs
-         WHERE session_id = ? AND event_type = 'ee_injection'
-         ORDER BY created_at DESC
+            .prepare(`SELECT session_id, event_subtype, duration_ms, metadata_json, created_at
+         FROM interaction_logs
+         WHERE session_id = ? AND event_type = 'ee_injection'
+         ORDER BY created_at DESC
          LIMIT ?`)
             .all(runId, limit);
     }
@@ -62,7 +62,7 @@ export function logInteraction(sessionId, eventType, metadata) {
     try {
         const db = getDatabase();
         const metadataJson = metadata?.data ? JSON.stringify(metadata.data) : null;
-        db.prepare(`INSERT INTO interaction_logs (session_id, event_type, event_subtype, model, duration_ms, input_tokens, output_tokens, metadata_json, created_at)
+        db.prepare(`INSERT INTO interaction_logs (session_id, event_type, event_subtype, model, duration_ms, input_tokens, output_tokens, metadata_json, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, eventType, metadata?.eventSubtype ?? null, metadata?.model ?? null, metadata?.durationMs ?? null, metadata?.inputTokens ?? null, metadata?.outputTokens ?? null, metadataJson, new Date().toISOString());
         maybePruneOld();
     }

package/dist/src/storage/migrations.js

@@ -13,9 +13,9 @@ export function applyMigrations(db) {
             db.pragma("user_version = 2");
         }
         if (version < 3) {
-            db.exec(`
-        ALTER TABLE usage_events ADD COLUMN pil_active INTEGER NOT NULL DEFAULT 0;
-        ALTER TABLE usage_events ADD COLUMN enrichment_delta INTEGER NOT NULL DEFAULT 0;
+            db.exec(`
+        ALTER TABLE usage_events ADD COLUMN pil_active INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE usage_events ADD COLUMN enrichment_delta INTEGER NOT NULL DEFAULT 0;
       `);
             db.pragma("user_version = 3");
         }
@@ -34,24 +34,24 @@ export function applyMigrations(db) {
             db.pragma("user_version = 4");
         }
         if (version < 5) {
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS interaction_logs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-          event_type TEXT NOT NULL,
-          event_subtype TEXT,
-          model TEXT,
-          duration_ms INTEGER,
-          input_tokens INTEGER,
-          output_tokens INTEGER,
-          metadata_json TEXT,
-          created_at TEXT NOT NULL
-        ) STRICT;
-
-        CREATE INDEX IF NOT EXISTS idx_interaction_logs_session
-          ON interaction_logs(session_id, created_at DESC);
-        CREATE INDEX IF NOT EXISTS idx_interaction_logs_event_type
-          ON interaction_logs(event_type, created_at DESC);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS interaction_logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          event_type TEXT NOT NULL,
+          event_subtype TEXT,
+          model TEXT,
+          duration_ms INTEGER,
+          input_tokens INTEGER,
+          output_tokens INTEGER,
+          metadata_json TEXT,
+          created_at TEXT NOT NULL
+        ) STRICT;
+
+        CREATE INDEX IF NOT EXISTS idx_interaction_logs_session
+          ON interaction_logs(session_id, created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_interaction_logs_event_type
+          ON interaction_logs(event_type, created_at DESC);
       `);
             db.pragma("user_version = 5");
         }
@@ -91,110 +91,110 @@ export function applyMigrations(db) {
     migrate();
 }
 function createInitialSchema(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS workspaces (
-      id TEXT PRIMARY KEY,
-      scope_key TEXT NOT NULL UNIQUE,
-      canonical_path TEXT NOT NULL,
-      git_root TEXT,
-      display_name TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
-      title TEXT,
-      model TEXT NOT NULL,
-      mode TEXT NOT NULL,
-      cwd_at_start TEXT NOT NULL,
-      cwd_last TEXT NOT NULL,
-      status TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS messages (
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      seq INTEGER NOT NULL,
-      role TEXT NOT NULL,
-      message_json TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      status TEXT,
-      PRIMARY KEY (session_id, seq)
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS tool_calls (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      message_seq INTEGER NOT NULL,
-      tool_call_id TEXT NOT NULL,
-      tool_name TEXT NOT NULL,
-      args_json TEXT NOT NULL,
-      status TEXT NOT NULL,
-      started_at TEXT NOT NULL,
-      completed_at TEXT,
-      UNIQUE(session_id, tool_call_id)
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS tool_results (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      tool_call_row_id INTEGER NOT NULL REFERENCES tool_calls(id) ON DELETE CASCADE,
-      output_kind TEXT NOT NULL,
-      output_json TEXT NOT NULL,
-      success INTEGER NOT NULL,
-      created_at TEXT NOT NULL
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS usage_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      message_seq INTEGER,
-      source TEXT NOT NULL,
-      model TEXT NOT NULL,
-      input_tokens INTEGER NOT NULL DEFAULT 0,
-      output_tokens INTEGER NOT NULL DEFAULT 0,
-      total_tokens INTEGER NOT NULL DEFAULT 0,
-      cost_micros INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL,
-      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
-      cache_creation_tokens INTEGER NOT NULL DEFAULT 0
-    ) STRICT;
-
-    CREATE TABLE IF NOT EXISTS compactions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      first_kept_seq INTEGER NOT NULL,
-      summary TEXT NOT NULL,
-      tokens_before INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL
-    ) STRICT;
-
-    CREATE INDEX IF NOT EXISTS idx_sessions_workspace_updated
-      ON sessions(workspace_id, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_messages_session_seq
-      ON messages(session_id, seq);
-    CREATE INDEX IF NOT EXISTS idx_tool_calls_session_seq
-      ON tool_calls(session_id, message_seq);
-    CREATE INDEX IF NOT EXISTS idx_usage_events_session_created
-      ON usage_events(session_id, created_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
-      ON compactions(session_id, created_at DESC);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      scope_key TEXT NOT NULL UNIQUE,
+      canonical_path TEXT NOT NULL,
+      git_root TEXT,
+      display_name TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      title TEXT,
+      model TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      cwd_at_start TEXT NOT NULL,
+      cwd_last TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS messages (
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      seq INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      message_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      status TEXT,
+      PRIMARY KEY (session_id, seq)
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_seq INTEGER NOT NULL,
+      tool_call_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      UNIQUE(session_id, tool_call_id)
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS tool_results (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_call_row_id INTEGER NOT NULL REFERENCES tool_calls(id) ON DELETE CASCADE,
+      output_kind TEXT NOT NULL,
+      output_json TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS usage_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_seq INTEGER,
+      source TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_micros INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_creation_tokens INTEGER NOT NULL DEFAULT 0
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS compactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      first_kept_seq INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      tokens_before INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_workspace_updated
+      ON sessions(workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_messages_session_seq
+      ON messages(session_id, seq);
+    CREATE INDEX IF NOT EXISTS idx_tool_calls_session_seq
+      ON tool_calls(session_id, message_seq);
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session_created
+      ON usage_events(session_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
+      ON compactions(session_id, created_at DESC);
   `);
 }
 function createCompactionSchema(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS compactions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      first_kept_seq INTEGER NOT NULL,
-      summary TEXT NOT NULL,
-      tokens_before INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL
-    ) STRICT;
-
-    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
-      ON compactions(session_id, created_at DESC);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS compactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      first_kept_seq INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      tokens_before INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
+      ON compactions(session_id, created_at DESC);
   `);
 }
 //# sourceMappingURL=migrations.js.map

package/dist/src/storage/sessions.js

@@ -1,6 +1,10 @@
 import { randomUUID } from "crypto";
 import { getDatabase } from "./db.js";
+import { sweepStalePendingRows } from "./transcript.js";
 import { ensureWorkspace } from "./workspaces.js";
+// Best-effort sweep is done once per process — repeated openSession() calls
+// (e.g. user runs /sessions then picks one) do not re-scan the DB.
+let _sweepDone = false;
 export class SessionStore {
     workspace;
     constructor(cwd) {
@@ -10,6 +14,17 @@ export class SessionStore {
         return this.workspace;
     }
     openSession(selector, model, mode, cwd) {
+        // One-shot cleanup of write-ahead rows orphaned by a prior process that
+        // was killed mid-turn (Ctrl+C on `gh run watch`, OOM, taskkill /F).
+        // Without this, tool_calls and messages stay status='pending' forever,
+        // skewing forensics + filling the DB with dead state.
+        if (!_sweepDone) {
+            _sweepDone = true;
+            const swept = sweepStalePendingRows();
+            if (swept.toolCalls > 0 || swept.messages > 0) {
+                console.error(`[muonroi-cli] swept stale write-ahead rows from prior run: ${swept.toolCalls} tool_calls, ${swept.messages} messages`);
+            }
+        }
         if (!selector) {
             return this.createSession(model, mode, cwd);
         }
@@ -28,12 +43,12 @@ export class SessionStore {
         const now = new Date().toISOString();
         const id = createSessionId();
         const db = getDatabase();
-        db.prepare(`
-      INSERT INTO sessions (
-        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      ) VALUES (
-        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at
-      )
+        db.prepare(`
+      INSERT INTO sessions (
+        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      ) VALUES (
+        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at
+      )
     `).run({
             id,
             workspace_id: this.workspace.id,
@@ -52,34 +67,34 @@ export class SessionStore {
      */
     listRecentSessions(limit = 20) {
         const rows = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE workspace_id = ?
-      ORDER BY updated_at DESC
-      LIMIT ?
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT ?
     `)
             .all(this.workspace.id, limit);
         return rows.map(toSessionInfo);
     }
     getLatestSession() {
         const row = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE workspace_id = ?
-      ORDER BY updated_at DESC
-      LIMIT 1
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
     `)
             .get(this.workspace.id);
         return row ? toSessionInfo(row) : null;
     }
     getSessionById(id) {
         const row = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE id = ?
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE id = ?
     `)
             .get(id);
         return row ? toSessionInfo(row) : null;
@@ -94,49 +109,49 @@ export class SessionStore {
     setStatus(id, status) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET status = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET status = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(status, now, id);
     }
     setTitle(id, title) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET title = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET title = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(title, now, id);
     }
     setModel(id, model) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET model = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET model = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(model, now, id);
     }
     setMode(id, mode) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET mode = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET mode = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(mode, now, id);
     }
     touchSession(id, cwd) {
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET cwd_last = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET cwd_last = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(cwd, new Date().toISOString(), id);
     }

package/dist/src/storage/transcript-response-entry.test.d.ts

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

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

@@ -0,0 +1,98 @@
+/**
+ * src/storage/transcript-response-entry.test.ts
+ *
+ * Regression: buildChatEntries must rebuild a `respond_*` tool-result as a
+ * `structured_response` ChatEntry — NOT a bare `tool_result`.
+ *
+ * Why this matters (live repro, session 9d3d371ca1bd): the live stream yields
+ * the terminal answer as a `structured_response` chunk (message-processor.ts),
+ * which the UI renders as the answer block. But finalizeActiveTurn (app.tsx)
+ * replaces the live message list with `getChatEntries()` → `buildChatEntries()`
+ * on EVERY normal turn. If buildChatEntries rebuilt the persisted respond_*
+ * tool-call/result pair as a generic tool_result, the rendered answer was
+ * silently dropped the instant streaming ended — the user saw only the
+ * "→ respond_general" indicator with no answer. This test pins the rebuild to
+ * a structured_response entry so the persisted view matches the live view.
+ */
+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,
+        }),
+    }),
+    withTransaction: (fn) => fn({}),
+}));
+// Pass-through transcript view: no compaction in these fixtures, so the
+// effective transcript is the raw message list unchanged.
+vi.mock("./transcript-view", () => ({
+    buildEffectiveTranscript: (messages, seqs, timestamps) => ({
+        messages,
+        seqs,
+        timestamps,
+    }),
+}));
+const { buildChatEntries } = await import("./transcript.js");
+afterEach(() => {
+    MESSAGE_ROWS = [];
+});
+function row(seq, role, content) {
+    return {
+        session_id: "s1",
+        seq,
+        role,
+        message_json: JSON.stringify({ role, content }),
+        created_at: "2026-06-09T07:27:38.420Z",
+    };
+}
+describe("buildChatEntries — respond_* terminal answer", () => {
+    it("rebuilds a respond_general tool-result as a structured_response entry", () => {
+        const callId = "call-respond-1";
+        MESSAGE_ROWS = [
+            row(1, "user", "how does this CLI affect you?"),
+            row(2, "assistant", [
+                { type: "reasoning", text: "investigated, now answer" },
+                { type: "tool-call", toolCallId: callId, toolName: "respond_general", input: { response: "The answer." } },
+            ]),
+            row(3, "tool", [
+                {
+                    type: "tool-result",
+                    toolCallId: callId,
+                    toolName: "respond_general",
+                    output: { type: "json", value: { response: "The answer." } },
+                },
+            ]),
+        ];
+        const entries = buildChatEntries("s1");
+        const sr = entries.find((e) => e.type === "structured_response");
+        expect(sr).toBeDefined();
+        expect(sr?.structuredResponse?.taskType).toBe("general");
+        expect((sr?.structuredResponse?.data).response).toBe("The answer.");
+        // The respond_* result must NOT also appear as a bare tool_result.
+        expect(entries.some((e) => e.type === "tool_result")).toBe(false);
+    });
+    it("still rebuilds a non-response tool-result as a tool_result entry", () => {
+        const callId = "call-read-1";
+        MESSAGE_ROWS = [
+            row(1, "user", "read the file"),
+            row(2, "assistant", [
+                { type: "tool-call", toolCallId: callId, toolName: "read_file", input: { file_path: "a.ts" } },
+            ]),
+            row(3, "tool", [
+                {
+                    type: "tool-result",
+                    toolCallId: callId,
+                    toolName: "read_file",
+                    output: { type: "json", value: { success: true, output: "file body" } },
+                },
+            ]),
+        ];
+        const entries = buildChatEntries("s1");
+        expect(entries.some((e) => e.type === "structured_response")).toBe(false);
+        expect(entries.some((e) => e.type === "tool_result")).toBe(true);
+    });
+});
+//# sourceMappingURL=transcript-response-entry.test.js.map

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

@@ -80,6 +80,28 @@ export declare function markMessageCompleted(sessionId: string, seq: number): vo
  * forever, indistinguishable from "stream still in-flight" in forensics.
  */
 export declare function markMessageErrored(sessionId: string, seq: number): void;
+/**
+ * Mark write-ahead rows orphaned by an earlier process kill (Ctrl+C, OOM,
+ * `taskkill /F`) as `aborted` instead of leaving them `pending` forever.
+ *
+ * Triggered by SessionStore.openSession() so a fresh launch cleans up after
+ * the previous run that died mid-turn. Only rows older than `staleAfterMs`
+ * are touched — leaving a 5-minute safety margin so a concurrently-running
+ * muonroi-cli process never has its live in-flight rows clobbered.
+ *
+ * Two row classes:
+ *  - `tool_calls.status = 'pending'`  and `started_at` older than threshold
+ *    → set status='aborted', completed_at=now (so forensics can distinguish
+ *    "tool exec threw" (errored) from "process died before result" (aborted))
+ *  - `messages.status = 'pending'`    and `created_at` older than threshold
+ *    → set status='aborted'
+ *
+ * Returns the row counts changed (mostly for tests + ops visibility).
+ */
+export declare function sweepStalePendingRows(staleAfterMs?: number): {
+    toolCalls: number;
+    messages: 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 buildChatEntries(sessionId: string): ChatEntry[];