muonroi-cli 1.8.3 → 1.8.5

package/dist/src/storage/transcript.js

@@ -43,11 +43,11 @@ function isInternalCouncilMarker(content) {
 }
 function loadMessageRows(sessionId) {
     const rows = getDatabase()
-        .prepare(`
-    SELECT session_id, seq, role, message_json, created_at
-    FROM messages
-    WHERE session_id = ?
-    ORDER BY seq ASC
+        .prepare(`
+    SELECT session_id, seq, role, message_json, created_at
+    FROM messages
+    WHERE session_id = ?
+    ORDER BY seq ASC
   `)
         .all(sessionId);
     for (const row of rows) {
@@ -67,12 +67,12 @@ function toPersistedCompaction(row) {
 }
 export function loadLatestCompaction(sessionId) {
     const row = getDatabase()
-        .prepare(`
-    SELECT session_id, first_kept_seq, summary, tokens_before, created_at
-    FROM compactions
-    WHERE session_id = ?
-    ORDER BY id DESC
-    LIMIT 1
+        .prepare(`
+    SELECT session_id, first_kept_seq, summary, tokens_before, created_at
+    FROM compactions
+    WHERE session_id = ?
+    ORDER BY id DESC
+    LIMIT 1
   `)
         .get(sessionId);
     return toPersistedCompaction(row);
@@ -99,6 +99,119 @@ export function loadTranscriptState(sessionId) {
 export function loadTranscript(sessionId) {
     return loadTranscriptState(sessionId).messages;
 }
+/**
+ * Resume a session together with every session in its conversation tree.
+ *
+ * When a session has spawned child sessions (silent rotations, sub-agents,
+ * sub-sessions), resuming only the parent loses the work that happened in the
+ * children. This loader walks up to the root and then down through all
+ * descendants, applies each session's own compaction, merges the messages
+ * chronologically, and returns them as one flat transcript for the model.
+ *
+ * Sequence numbers from sessions other than the one being resumed are replaced
+ * with `null` so that usage attribution and compaction still belong to the
+ * resumed session.
+ */
+export function loadSessionChainTranscriptState(sessionId) {
+    const chain = getSessionChain(sessionId);
+    if (chain.length <= 1) {
+        return loadTranscriptState(sessionId);
+    }
+    const records = [];
+    for (const sid of chain) {
+        const rows = loadMessageRows(sid);
+        const messages = rows.map((row) => JSON.parse(row.message_json));
+        const seqs = rows.map((row) => row.seq);
+        const timestamps = rows.map((row) => new Date(row.created_at));
+        const effective = buildEffectiveTranscript(messages, seqs, timestamps, loadLatestCompaction(sid));
+        for (let i = 0; i < effective.messages.length; i++) {
+            records.push({
+                sessionId: sid,
+                message: effective.messages[i],
+                seq: effective.seqs[i],
+                timestamp: effective.timestamps[i],
+            });
+        }
+    }
+    // getSessionChain already orders sessions by creation time. Preserve each
+    // session's internal effective-transcript order (especially compaction
+    // summaries, which must precede their kept tail) instead of re-sorting by
+    // individual message timestamps.
+    return {
+        messages: records.map((r) => r.message),
+        seqs: records.map((r) => (r.sessionId === sessionId ? r.seq : null)),
+        timestamps: records.map((r) => r.timestamp),
+        compaction: loadLatestCompaction(sessionId),
+    };
+}
+/**
+ * Enumerate the full session chain (root + all descendants) with per-session
+ * metadata, ordered root-first then by creation time. Read-only; safe to call
+ * on every render. Returns a single-node array for a session with no children.
+ */
+export function getSessionChainInfos(sessionId) {
+    const chain = getSessionChain(sessionId);
+    if (chain.length === 0)
+        return [];
+    const db = getDatabase();
+    const placeholders = chain.map(() => "?").join(",");
+    let rows = [];
+    try {
+        rows = db
+            .prepare(`
+        SELECT s.id, s.parent_session_id, s.kind, s.model, s.status, s.created_at,
+               (SELECT COUNT(*) FROM messages m WHERE m.session_id = s.id) AS msgs
+        FROM sessions s
+        WHERE s.id IN (${placeholders})
+      `)
+            .all(...chain);
+    }
+    catch (err) {
+        logger.error("storage", "getSessionChainInfos query failed", {
+            sessionId,
+            message: err?.message,
+        });
+        return [];
+    }
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const depthOf = (id) => {
+        let depth = 0;
+        let cur = id;
+        const seen = new Set();
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const parent = byId.get(cur)?.parent_session_id ?? null;
+            // Only count parents that are inside this chain (the walk-up root has none).
+            if (parent && byId.has(parent)) {
+                depth++;
+                cur = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return depth;
+    };
+    const nodes = chain
+        .map((id) => byId.get(id))
+        .filter((r) => r !== undefined)
+        .map((r) => ({
+        id: r.id,
+        kind: r.kind ?? null,
+        model: r.model,
+        status: r.status,
+        messageCount: r.msgs,
+        parentId: r.parent_session_id,
+        depth: depthOf(r.id),
+        isCurrent: r.id === sessionId,
+    }));
+    // Render order: shallowest first (root → children → grandchildren) so the rail
+    // always shows the parent on top with descendants indented under it. Ties keep
+    // getSessionChain's created_at order. A stable index-carrying sort — chain
+    // created_at can tie at second granularity, so depth is the deterministic key.
+    const chainIndex = new Map(nodes.map((n, i) => [n.id, i]));
+    return nodes.sort((a, b) => a.depth - b.depth || chainIndex.get(a.id) - chainIndex.get(b.id));
+}
 export function getNextMessageSequence(sessionId) {
     return getNextSequence(getDatabase(), sessionId);
 }
@@ -113,43 +226,44 @@ export function appendMessages(sessionId, messages) {
         // with `status='completed'` and the full message_json. Pre-A5 callers
         // hit this path identically: there is no pending row so the IGNORE
         // branch is unused and the INSERT wins.
-        const insertMessage = db.prepare(`
-      INSERT INTO messages (session_id, seq, role, message_json, created_at, status)
-      VALUES (?, ?, ?, ?, ?, 'completed')
-      ON CONFLICT(session_id, seq) DO UPDATE SET
-        role = excluded.role,
-        message_json = excluded.message_json,
-        status = 'completed'
+        const insertMessage = db.prepare(`
+      INSERT INTO messages (session_id, seq, role, message_json, created_at, status)
+      VALUES (?, ?, ?, ?, ?, 'completed')
+      ON CONFLICT(session_id, seq) DO UPDATE SET
+        role = excluded.role,
+        message_json = excluded.message_json,
+        status = 'completed'
     `);
-        const insertToolCall = db.prepare(`
-      INSERT OR IGNORE INTO tool_calls (
-        session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        const insertToolCall = db.prepare(`
+      INSERT OR IGNORE INTO tool_calls (
+        session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        const updateToolCall = db.prepare(`
-      UPDATE tool_calls
-      SET tool_name = ?, args_json = ?, status = ?, completed_at = ?
-      WHERE session_id = ? AND tool_call_id = ?
+        const updateToolCall = db.prepare(`
+      UPDATE tool_calls
+      SET tool_name = ?, args_json = ?, status = ?, completed_at = ?
+      WHERE session_id = ? AND tool_call_id = ?
     `);
-        const selectToolCall = db.prepare(`
-      SELECT id, tool_call_id, tool_name, args_json
-      FROM tool_calls
-      WHERE session_id = ? AND tool_call_id = ?
+        const selectToolCall = db.prepare(`
+      SELECT id, tool_call_id, tool_name, args_json
+      FROM tool_calls
+      WHERE session_id = ? AND tool_call_id = ?
     `);
-        const insertToolResult = db.prepare(`
-      INSERT INTO tool_results (tool_call_row_id, output_kind, output_json, success, created_at)
-      VALUES (?, ?, ?, ?, ?)
+        const insertToolResult = db.prepare(`
+      INSERT INTO tool_results (tool_call_row_id, output_kind, output_json, success, created_at)
+      VALUES (?, ?, ?, ?, ?)
     `);
-        const updateSession = db.prepare(`
-      UPDATE sessions
-      SET updated_at = ?
-      WHERE id = ?
+        const updateSession = db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
     `);
         messages.forEach((message, index) => {
             const seq = nextSeq + index;
             const createdAt = new Date().toISOString();
             insertedSeqs.push(seq);
             insertMessage.run(sessionId, seq, message.role, JSON.stringify(message), createdAt);
+            indexMessageInFts(db, sessionId, seq, message.role, JSON.stringify(message));
             if (message.role === "assistant" && Array.isArray(message.content)) {
                 for (const part of message.content) {
                     if (part.type !== "tool-call")
@@ -205,16 +319,20 @@ export function persistToolCallWriteAhead(sessionId, messageSeq, toolCallId, too
     const now = new Date().toISOString();
     try {
         getDatabase()
-            .prepare(`
-        INSERT OR IGNORE INTO tool_calls (
-          session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at
-        ) VALUES (?, ?, ?, ?, ?, 'pending', ?, NULL)
+            .prepare(`
+        INSERT OR IGNORE INTO tool_calls (
+          session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at
+        ) VALUES (?, ?, ?, ?, ?, 'pending', ?, NULL)
       `)
             .run(sessionId, messageSeq, toolCallId, toolName, argsJson, now);
     }
-    catch {
-        // Fail-open: write-ahead is best-effort. The post-stream UPDATE path
-        // will still finalize the row from `appendMessages(...)`.
+    catch (err) {
+        logger.error("storage", `[transcript] persistToolCallWriteAhead failed: ${err.message}`, {
+            sessionId,
+            messageSeq,
+            toolCallId,
+            toolName,
+        });
     }
 }
 /**
@@ -253,16 +371,20 @@ export function persistToolCallWriteAhead(sessionId, messageSeq, toolCallId, too
 export function persistMessageWriteAhead(sessionId, seq, role, messageJson) {
     const now = new Date().toISOString();
     try {
-        getDatabase()
-            .prepare(`
-        INSERT OR IGNORE INTO messages (
-          session_id, seq, role, message_json, created_at, status
-        ) VALUES (?, ?, ?, ?, ?, 'pending')
-      `)
-            .run(sessionId, seq, role, messageJson, now);
+        const db = getDatabase();
+        db.prepare(`
+        INSERT OR IGNORE INTO messages (
+          session_id, seq, role, message_json, created_at, status
+        ) VALUES (?, ?, ?, ?, ?, 'pending')
+      `).run(sessionId, seq, role, messageJson, now);
+        indexMessageInFts(db, sessionId, seq, role, messageJson);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] persistMessageWriteAhead failed: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
     }
 }
 /**
@@ -275,15 +397,15 @@ export function persistMessageWriteAhead(sessionId, seq, role, messageJson) {
 export function markMessageCompleted(sessionId, seq) {
     try {
         getDatabase()
-            .prepare(`
-        UPDATE messages
-        SET status = 'completed'
-        WHERE session_id = ? AND seq = ? AND status = 'pending'
+            .prepare(`
+        UPDATE messages
+        SET status = 'completed'
+        WHERE session_id = ? AND seq = ? AND status = 'pending'
       `)
             .run(sessionId, seq);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] markMessageCompleted failed: ${err.message}`, { sessionId, seq });
     }
 }
 /**
@@ -297,15 +419,15 @@ export function markMessageCompleted(sessionId, seq) {
 export function markMessageErrored(sessionId, seq) {
     try {
         getDatabase()
-            .prepare(`
-        UPDATE messages
-        SET status = 'errored'
-        WHERE session_id = ? AND seq = ? AND status = 'pending'
+            .prepare(`
+        UPDATE messages
+        SET status = 'errored'
+        WHERE session_id = ? AND seq = ? AND status = 'pending'
       `)
             .run(sessionId, seq);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] markMessageErrored failed: ${err.message}`, { sessionId, seq });
     }
 }
 /**
@@ -331,17 +453,17 @@ export function sweepStalePendingRows(staleAfterMs = 5 * 60 * 1000) {
     try {
         const db = getDatabase();
         const toolCalls = db
-            .prepare(`
-        UPDATE tool_calls
-        SET status = 'aborted', completed_at = started_at
-        WHERE status = 'pending' AND started_at < ?
+            .prepare(`
+        UPDATE tool_calls
+        SET status = 'aborted', completed_at = started_at
+        WHERE status = 'pending' AND started_at < ?
       `)
             .run(cutoff);
         const messages = db
-            .prepare(`
-        UPDATE messages
-        SET status = 'aborted'
-        WHERE status = 'pending' AND created_at < ?
+            .prepare(`
+        UPDATE messages
+        SET status = 'aborted'
+        WHERE status = 'pending' AND created_at < ?
       `)
             .run(cutoff);
         return { toolCalls: toolCalls.changes, messages: messages.changes };
@@ -355,10 +477,10 @@ export function markToolCallErrored(sessionId, toolCallId, errorMessage) {
     const now = new Date().toISOString();
     try {
         getDatabase()
-            .prepare(`
-        UPDATE tool_calls
-        SET status = 'errored', completed_at = ?, args_json = COALESCE(args_json, ?)
-        WHERE session_id = ? AND tool_call_id = ?
+            .prepare(`
+        UPDATE tool_calls
+        SET status = 'errored', completed_at = ?, args_json = COALESCE(args_json, ?)
+        WHERE session_id = ? AND tool_call_id = ?
       `)
             .run(now, JSON.stringify({ error: errorMessage.slice(0, 500) }), sessionId, toolCallId);
     }
@@ -368,28 +490,28 @@ export function markToolCallErrored(sessionId, toolCallId, errorMessage) {
 }
 export function appendCompaction(sessionId, firstKeptSeq, summary, tokensBefore) {
     withTransaction((db) => {
-        db.prepare(`
-      INSERT INTO compactions (session_id, first_kept_seq, summary, tokens_before, created_at)
-      VALUES (?, ?, ?, ?, ?)
+        db.prepare(`
+      INSERT INTO compactions (session_id, first_kept_seq, summary, tokens_before, created_at)
+      VALUES (?, ?, ?, ?, ?)
     `).run(sessionId, firstKeptSeq, summary, tokensBefore, new Date().toISOString());
-        db.prepare(`
-      UPDATE sessions
-      SET updated_at = ?
-      WHERE id = ?
+        db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
     `).run(new Date().toISOString(), sessionId);
     });
 }
 export function revertLatestCompaction(sessionId) {
     withTransaction((db) => {
-        db.prepare(`
-      DELETE FROM compactions 
-      WHERE session_id = ? 
-      AND id = (SELECT MAX(id) FROM compactions WHERE session_id = ?)
+        db.prepare(`
+      DELETE FROM compactions 
+      WHERE session_id = ? 
+      AND id = (SELECT MAX(id) FROM compactions WHERE session_id = ?)
     `).run(sessionId, sessionId);
-        db.prepare(`
-      UPDATE sessions
-      SET updated_at = ?
-      WHERE id = ?
+        db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
     `).run(new Date().toISOString(), sessionId);
     });
 }
@@ -439,10 +561,10 @@ export function getSessionChain(sessionId) {
             .map(() => "?")
             .join(",");
         const sortedRows = db
-            .prepare(`
-      SELECT id FROM sessions 
-      WHERE id IN (${placeholders}) 
-      ORDER BY created_at ASC
+            .prepare(`
+      SELECT id FROM sessions 
+      WHERE id IN (${placeholders}) 
+      ORDER BY created_at ASC
     `)
             .all(...Array.from(allIds));
         chain = sortedRows.map((r) => r.id);
@@ -624,10 +746,10 @@ export function buildChatEntries(sessionId) {
 }
 function getNextSequence(db, sessionId) {
     const row = db
-        .prepare(`
-    SELECT COALESCE(MAX(seq), 0) AS max_seq
-    FROM messages
-    WHERE session_id = ?
+        .prepare(`
+    SELECT COALESCE(MAX(seq), 0) AS max_seq
+    FROM messages
+    WHERE session_id = ?
   `)
         .get(sessionId);
     return (row?.max_seq ?? 0) + 1;
@@ -677,12 +799,12 @@ function renderAssistantContent(content, callMap) {
 }
 function loadStoredToolResults(sessionId) {
     const rows = getDatabase()
-        .prepare(`
-    SELECT tc.tool_call_id, tr.output_json
-    FROM tool_results tr
-    JOIN tool_calls tc ON tc.id = tr.tool_call_row_id
-    WHERE tc.session_id = ?
-    ORDER BY tr.id ASC
+        .prepare(`
+    SELECT tc.tool_call_id, tr.output_json
+    FROM tool_results tr
+    JOIN tool_calls tc ON tc.id = tr.tool_call_row_id
+    WHERE tc.session_id = ?
+    ORDER BY tr.id ASC
   `)
         .all(sessionId);
     return new Map(rows.map((row) => [row.tool_call_id, JSON.parse(row.output_json)]));
@@ -703,12 +825,12 @@ export function getLastTodoWriteArgs(sessionId) {
     for (let i = chain.length - 1; i >= 0; i--) {
         try {
             const row = db
-                .prepare(`
-          SELECT args_json
-          FROM tool_calls
-          WHERE session_id = ? AND tool_name = 'todo_write'
-          ORDER BY id DESC
-          LIMIT 1
+                .prepare(`
+          SELECT args_json
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name = 'todo_write'
+          ORDER BY id DESC
+          LIMIT 1
         `)
                 .get(chain[i]);
             if (row?.args_json) {
@@ -721,4 +843,153 @@ export function getLastTodoWriteArgs(sessionId) {
     }
     return null;
 }
+/**
+ * Persist the approved plan text for a session so that "tiếp tục"/"continue"
+ * turns (which are classified as chitchat/general by PIL Pass 0) can re-inject
+ * the APPROVED PLAN section into the system prompt instead of forgetting context.
+ *
+ * Stored as a synthetic tool_call row (tool_name='__approved_plan') so we reuse
+ * the existing schema and getLast* query pattern without a new table/migration.
+ * The planText is stored verbatim in args_json.
+ */
+export function persistApprovedPlan(sessionId, planText) {
+    if (!sessionId || !planText)
+        return;
+    const db = getDatabase();
+    const toolCallId = `approved-plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const now = new Date().toISOString();
+    try {
+        db.prepare(`
+      INSERT OR REPLACE INTO tool_calls (session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at)
+      VALUES (?, 0, ?, '__approved_plan', ?, 'completed', ?, ?)
+    `).run(sessionId, toolCallId, planText, now, now);
+    }
+    catch {
+        /* best-effort persistence; never block the turn */
+    }
+}
+/** Load the most recent persisted approved plan for this session (or parent chain). */
+export function getLastApprovedPlan(sessionId) {
+    const chain = getSessionChain(sessionId);
+    const db = getDatabase();
+    for (let i = chain.length - 1; i >= 0; i--) {
+        try {
+            // 1) Prefer our synthetic persisted row (written by setPlanContext + persistApprovedPlan).
+            const synthetic = db
+                .prepare(`
+          SELECT args_json
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name = '__approved_plan'
+          ORDER BY id DESC
+          LIMIT 1
+        `)
+                .get(chain[i]);
+            if (synthetic?.args_json) {
+                return synthetic.args_json;
+            }
+            // 2) Fallback: scan real plan tool_calls (respond_plan / generate_plan) written by
+            //    council, PIL response-tools, or generate_plan UI. Extract a human-readable slice.
+            const planRow = db
+                .prepare(`
+          SELECT args_json, tool_name
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name IN ('respond_plan', 'generate_plan')
+          ORDER BY id DESC
+          LIMIT 1
+        `)
+                .get(chain[i]);
+            if (planRow?.args_json) {
+                try {
+                    const parsed = JSON.parse(planRow.args_json);
+                    // respond_plan shape typically has { steps, assumptions?, risks? } or { plan: {...} }
+                    const candidate = parsed?.plan ?? parsed;
+                    if (candidate && (Array.isArray(candidate.steps) || typeof candidate === "object")) {
+                        return JSON.stringify(candidate, null, 2);
+                    }
+                    // generate_plan may carry raw text or { content, steps }
+                    if (typeof parsed === "string")
+                        return parsed;
+                    if (parsed && typeof parsed === "object")
+                        return JSON.stringify(parsed, null, 2);
+                }
+                catch {
+                    // not JSON — return as-is (may be a raw string payload)
+                    if (typeof planRow.args_json === "string" && planRow.args_json.trim().length > 0) {
+                        return planRow.args_json;
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore and check parent
+        }
+    }
+    return null;
+}
+function indexMessageInFts(db, sessionId, seq, role, messageJsonStr) {
+    db.prepare(`DELETE FROM session_history_fts WHERE session_id = ? AND seq = ?`).run(sessionId, seq);
+    let message;
+    try {
+        message = JSON.parse(messageJsonStr);
+    }
+    catch (err) {
+        logger.error("storage", `[transcript] Failed to parse message JSON for FTS indexing: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
+        return;
+    }
+    let content = "";
+    let toolName = "";
+    let toolArgs = "";
+    let toolOutput = "";
+    const msgContent = message.content;
+    if (typeof msgContent === "string") {
+        content = msgContent;
+    }
+    else if (Array.isArray(msgContent)) {
+        const textParts = [];
+        const toolNames = [];
+        const argParts = [];
+        const outputParts = [];
+        for (const part of msgContent) {
+            if (part && typeof part === "object") {
+                if (part.type === "text" && typeof part.text === "string") {
+                    textParts.push(part.text);
+                }
+                else if (part.type === "tool-call" && typeof part.toolName === "string") {
+                    toolNames.push(part.toolName);
+                    if (part.input !== undefined) {
+                        argParts.push(typeof part.input === "string" ? part.input : JSON.stringify(part.input));
+                    }
+                }
+                else if (part.type === "tool-result" && typeof part.toolName === "string") {
+                    toolNames.push(part.toolName);
+                    if (part.output !== undefined) {
+                        outputParts.push(typeof part.output === "string" ? part.output : JSON.stringify(part.output));
+                    }
+                }
+            }
+        }
+        content = textParts.join("\n").trim();
+        toolName = toolNames.join(", ").trim();
+        toolArgs = argParts.join("\n").trim();
+        toolOutput = outputParts.join("\n").trim();
+    }
+    try {
+        db.prepare(`
+      INSERT INTO session_history_fts (session_id, seq, role, tool_name, content, tool_args, tool_output)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(sessionId, seq, role, toolName || null, content || null, toolArgs || null, toolOutput || null);
+    }
+    catch (err) {
+        logger.error("storage", `[transcript] Failed to execute FTS indexing query: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
+        throw err;
+    }
+}
 //# sourceMappingURL=transcript.js.map

package/dist/src/storage/usage.js

@@ -14,11 +14,11 @@ export function recordUsageEvent(sessionId, source, model, usage, messageSeq, pi
     const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
     const costMicros = estimateCostMicros(model, inputTokens, outputTokens, cacheReadTokens);
     getDatabase()
-        .prepare(`
-    INSERT INTO usage_events (
-      session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at,
-      pil_active, enrichment_delta, cache_read_tokens, cache_creation_tokens, provider_options_shape
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        .prepare(`
+    INSERT INTO usage_events (
+      session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at,
+      pil_active, enrichment_delta, cache_read_tokens, cache_creation_tokens, provider_options_shape
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `)
         .run(sessionId, messageSeq ?? null, source, model, inputTokens, outputTokens, totalTokens, costMicros, new Date().toISOString(), pilActive ? 1 : 0, enrichmentDelta, cacheReadTokens, cacheCreationTokens, providerOptionsShape);
 }
@@ -26,10 +26,10 @@ export function getSessionTotalTokens(sessionId) {
     const chain = getSessionChain(sessionId);
     const placeholders = chain.map(() => "?").join(",");
     const row = getDatabase()
-        .prepare(`
-    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
-    FROM usage_events
-    WHERE session_id IN (${placeholders})
+        .prepare(`
+    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
+    FROM usage_events
+    WHERE session_id IN (${placeholders})
   `)
         .get(...chain);
     const total = row?.total_tokens ?? 0;
@@ -44,11 +44,11 @@ export function listSessionUsage(sessionId) {
     const chain = getSessionChain(sessionId);
     const placeholders = chain.map(() => "?").join(",");
     const rows = getDatabase()
-        .prepare(`
-    SELECT id, session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at, cache_read_tokens, cache_creation_tokens
-    FROM usage_events
-    WHERE session_id IN (${placeholders})
-    ORDER BY id ASC
+        .prepare(`
+    SELECT id, session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at, cache_read_tokens, cache_creation_tokens
+    FROM usage_events
+    WHERE session_id IN (${placeholders})
+    ORDER BY id ASC
   `)
         .all(...chain);
     logger.debug("storage", "Retrieved session usage events from chain", {