claude-deck 0.1.0

package/dist/db/queries.js

@@ -0,0 +1,388 @@
+// ─── Insert/Update ───
+export function upsertSession(db, session) {
+    const txn = db.transaction(() => {
+        // Delete existing data for this session (re-insert on sync)
+        db.prepare("DELETE FROM tool_calls WHERE session_id = ?").run(session.id);
+        db.prepare("DELETE FROM messages WHERE session_id = ?").run(session.id);
+        db.prepare("DELETE FROM subagents WHERE session_id = ?").run(session.id);
+        db.prepare("DELETE FROM compactions WHERE session_id = ?").run(session.id);
+        db.prepare("DELETE FROM sessions WHERE id = ?").run(session.id);
+        // Insert session
+        db.prepare(`
+      INSERT INTO sessions (
+        id, project, project_hash, first_prompt, model, status,
+        input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, estimated_cost_usd,
+        message_count, tool_call_count, subagent_count, turn_count, peak_context_tokens,
+        started_at, ended_at, duration_ms, synced_at, jsonl_path, jsonl_mtime
+      ) VALUES (?, ?, ?, ?, ?, 'completed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(session.id, session.project, session.projectHash, session.firstPrompt, session.model, session.inputTokens, session.outputTokens, session.cacheReadTokens, session.cacheCreateTokens, session.estimatedCostUsd, session.messageCount, session.toolCallCount, session.subagentCount, session.turnCount, session.peakContextTokens, session.startedAt, session.endedAt, session.durationMs, new Date().toISOString(), session.jsonlPath, session.jsonlMtime);
+        // Insert tool calls
+        const insertTc = db.prepare(`
+      INSERT INTO tool_calls (session_id, subagent_id, tool_use_id, tool_name, tool_input, tool_response, status, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const tc of session.toolCalls) {
+            insertTc.run(session.id, tc.subagentId, tc.toolUseId, tc.toolName, tc.toolInput, tc.toolResponse, tc.status, tc.timestamp);
+        }
+        // Insert messages
+        const insertMsg = db.prepare(`
+      INSERT INTO messages (session_id, role, content, timestamp, model, cost_usd) VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        for (const msg of session.messages) {
+            insertMsg.run(session.id, msg.role, msg.content, msg.timestamp, msg.model, msg.costUsd);
+        }
+        // Insert subagents
+        const insertSub = db.prepare(`
+      INSERT INTO subagents (id, session_id, agent_type, model, prompt, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, estimated_cost_usd, tool_call_count, duration_ms, result_summary)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const sub of session.subagents) {
+            insertSub.run(sub.id, session.id, sub.agentType, sub.model, sub.prompt, sub.inputTokens, sub.outputTokens, sub.cacheReadTokens, sub.cacheCreateTokens, sub.estimatedCostUsd, sub.toolCallCount, sub.durationMs, sub.resultSummary);
+        }
+        // Insert compactions
+        const insertCompact = db.prepare(`
+      INSERT INTO compactions (session_id, trigger, pre_tokens, timestamp) VALUES (?, ?, ?, ?)
+    `);
+        for (const c of session.compactions) {
+            insertCompact.run(session.id, c.trigger, c.preTokens, c.timestamp);
+        }
+    });
+    txn();
+}
+// ─── Queries ───
+export function listSessions(db, opts = {}) {
+    const conditions = [];
+    const params = [];
+    if (opts.project) {
+        conditions.push("project LIKE ?");
+        params.push(`%${opts.project}%`);
+    }
+    if (opts.model) {
+        conditions.push("model LIKE ?");
+        params.push(`%${opts.model}%`);
+    }
+    if (opts.after) {
+        conditions.push("started_at >= ?");
+        params.push(opts.after);
+    }
+    if (opts.before) {
+        conditions.push("started_at <= ?");
+        params.push(opts.before);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sortCol = {
+        cost: "estimated_cost_usd DESC",
+        tokens: "(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens) DESC",
+        date: "started_at DESC",
+        duration: "duration_ms DESC",
+    };
+    const orderBy = sortCol[opts.sort ?? "date"] ?? sortCol.date;
+    const limit = opts.limit ?? 50;
+    const offset = opts.offset ?? 0;
+    const total = db.prepare(`SELECT COUNT(*) as count FROM sessions ${where}`).get(...params);
+    const sessions = db
+        .prepare(`SELECT s.*,
+        COALESCE((SELECT COUNT(*) FROM compactions c WHERE c.session_id = s.id), 0) as compaction_count,
+        ROUND(MAX(s.peak_context_tokens, COALESCE((SELECT MAX(c.pre_tokens) FROM compactions c WHERE c.session_id = s.id), 0)) * 100.0 / 200000, 1) as peak_context_pct
+      FROM sessions s ${where ? where.replace(/\b(started_at|project|model)\b/g, "s.$1") : ""} ORDER BY ${orderBy.replace(/\b(started_at|estimated_cost_usd|input_tokens|output_tokens|cache_read_tokens|cache_create_tokens|duration_ms)\b/g, "s.$1")} LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset);
+    return { sessions, total: total.count };
+}
+export function getSession(db, id) {
+    return db
+        .prepare(`SELECT s.*,
+        COALESCE((SELECT COUNT(*) FROM compactions c WHERE c.session_id = s.id), 0) as compaction_count,
+        ROUND(MAX(s.peak_context_tokens, COALESCE((SELECT MAX(c.pre_tokens) FROM compactions c WHERE c.session_id = s.id), 0)) * 100.0 / 200000, 1) as peak_context_pct
+      FROM sessions s WHERE s.id = ?`)
+        .get(id);
+}
+export function getTimeline(db, sessionId) {
+    const toolCalls = db
+        .prepare("SELECT *, 'tool_call' as _type FROM tool_calls WHERE session_id = ? ORDER BY timestamp")
+        .all(sessionId);
+    const messages = db
+        .prepare("SELECT *, 'message' as _type FROM messages WHERE session_id = ? ORDER BY timestamp")
+        .all(sessionId);
+    // Merge and sort by timestamp
+    const all = [...toolCalls, ...messages].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return all;
+}
+export function getSubagents(db, sessionId) {
+    return db
+        .prepare("SELECT * FROM subagents WHERE session_id = ? ORDER BY id")
+        .all(sessionId);
+}
+export function getStats(db, opts = {}) {
+    const conditions = [];
+    const params = [];
+    if (opts.after) {
+        conditions.push("started_at >= ?");
+        params.push(opts.after);
+    }
+    if (opts.before) {
+        conditions.push("started_at <= ?");
+        params.push(opts.before);
+    }
+    if (opts.model) {
+        conditions.push("model LIKE ?");
+        params.push(`%${opts.model}%`);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const agg = db
+        .prepare(`
+    SELECT
+      COUNT(*) as totalSessions,
+      COALESCE(SUM(estimated_cost_usd), 0) as totalCost,
+      COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as totalTokens,
+      COALESCE(SUM(input_tokens), 0) as inputTokens,
+      COALESCE(SUM(output_tokens), 0) as outputTokens,
+      COALESCE(SUM(cache_read_tokens), 0) as cacheReadTokens,
+      COALESCE(SUM(cache_create_tokens), 0) as cacheCreateTokens
+    FROM sessions ${where}
+  `)
+        .get(...params);
+    const byModel = db
+        .prepare(`
+    SELECT model, COUNT(*) as sessions, SUM(estimated_cost_usd) as cost,
+      SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens) as tokens
+    FROM sessions ${where}
+    GROUP BY model ORDER BY cost DESC
+  `)
+        .all(...params);
+    const byProject = db
+        .prepare(`
+    SELECT project, COUNT(*) as sessions, SUM(estimated_cost_usd) as cost,
+      SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens) as tokens
+    FROM sessions ${where}
+    GROUP BY project ORDER BY cost DESC
+  `)
+        .all(...params);
+    const byDay = db
+        .prepare(`
+    SELECT DATE(started_at) as date, COUNT(*) as sessions, SUM(estimated_cost_usd) as cost,
+      SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens) as tokens
+    FROM sessions ${where}
+    GROUP BY DATE(started_at) ORDER BY date
+  `)
+        .all(...params);
+    const topTools = db
+        .prepare(`
+    SELECT tool_name as tool, COUNT(*) as count
+    FROM tool_calls tc JOIN sessions s ON tc.session_id = s.id ${where ? where.replace("started_at", "s.started_at") : ""}
+    GROUP BY tool_name ORDER BY count DESC LIMIT 15
+  `)
+        .all(...params);
+    return {
+        ...agg,
+        avgCostPerSession: agg.totalSessions > 0 ? agg.totalCost / agg.totalSessions : 0,
+        byModel,
+        byProject,
+        byDay,
+        topTools,
+    };
+}
+export function getSessionMtime(db, id) {
+    const row = db.prepare("SELECT jsonl_mtime FROM sessions WHERE id = ?").get(id);
+    return row?.jsonl_mtime;
+}
+// ─── Session Insights ───
+const TOOL_CATEGORIES = {
+    Read: "explore",
+    Glob: "explore",
+    Grep: "explore",
+    Explore: "explore",
+    WebFetch: "research",
+    WebSearch: "research",
+    Write: "write",
+    Edit: "write",
+    NotebookEdit: "write",
+    Bash: "execute",
+    Task: "other",
+    TaskCreate: "other",
+    TaskUpdate: "other",
+    TaskList: "other",
+    TaskGet: "other",
+    EnterPlanMode: "other",
+    ExitPlanMode: "other",
+    AskUserQuestion: "other",
+    Skill: "other",
+};
+function getCategory(toolName) {
+    return TOOL_CATEGORIES[toolName] ?? "other";
+}
+export function getSessionInsights(db, sessionId) {
+    // File read patterns — files read 2+ times
+    const allReads = db
+        .prepare(`SELECT tool_input FROM tool_calls WHERE session_id = ? AND tool_name = 'Read' AND tool_input IS NOT NULL`)
+        .all(sessionId);
+    const fileCounts = new Map();
+    for (const row of allReads) {
+        try {
+            const input = JSON.parse(row.tool_input);
+            const file = input.file_path;
+            if (file)
+                fileCounts.set(file, (fileCounts.get(file) ?? 0) + 1);
+        }
+        catch {
+            /* skip */
+        }
+    }
+    const fileReads = [...fileCounts.entries()]
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .map(([file, count]) => ({ file, count }));
+    // Tool distribution
+    const toolDistribution = db
+        .prepare(`SELECT tool_name as tool, COUNT(*) as count FROM tool_calls WHERE session_id = ? GROUP BY tool_name ORDER BY count DESC`)
+        .all(sessionId);
+    const totalToolCalls = toolDistribution.reduce((sum, t) => sum + t.count, 0);
+    // All tool calls ordered by time for phase + gap analysis
+    const allCalls = db
+        .prepare(`SELECT tool_name, timestamp FROM tool_calls WHERE session_id = ? AND subagent_id IS NULL ORDER BY timestamp`)
+        .all(sessionId);
+    // Phase analysis — group consecutive tools of the same category
+    const phases = [];
+    const CATEGORY_LABELS = {
+        explore: "Exploration",
+        research: "Research",
+        write: "Writing",
+        execute: "Execution",
+        other: "Other",
+    };
+    if (allCalls.length > 0) {
+        let currentCategory = getCategory(allCalls[0].tool_name);
+        let phaseStart = allCalls[0].timestamp;
+        let phaseToolCount = 1;
+        for (let i = 1; i < allCalls.length; i++) {
+            const cat = getCategory(allCalls[i].tool_name);
+            if (cat !== currentCategory) {
+                // Close current phase
+                const endTs = allCalls[i - 1].timestamp;
+                phases.push({
+                    name: CATEGORY_LABELS[currentCategory],
+                    category: currentCategory,
+                    toolCount: phaseToolCount,
+                    durationMs: new Date(endTs).getTime() - new Date(phaseStart).getTime(),
+                });
+                currentCategory = cat;
+                phaseStart = allCalls[i].timestamp;
+                phaseToolCount = 1;
+            }
+            else {
+                phaseToolCount++;
+            }
+        }
+        // Close last phase
+        const lastTs = allCalls[allCalls.length - 1].timestamp;
+        phases.push({
+            name: CATEGORY_LABELS[currentCategory],
+            category: currentCategory,
+            toolCount: phaseToolCount,
+            durationMs: new Date(lastTs).getTime() - new Date(phaseStart).getTime(),
+        });
+    }
+    // Merge tiny phases (< 2 tool calls) into neighbors of the same category
+    // and aggregate by category for summary
+    const phaseSummary = new Map();
+    for (const p of phases) {
+        const existing = phaseSummary.get(p.category);
+        if (existing) {
+            existing.toolCount += p.toolCount;
+            existing.durationMs += p.durationMs;
+        }
+        else {
+            phaseSummary.set(p.category, { toolCount: p.toolCount, durationMs: p.durationMs });
+        }
+    }
+    // Web fetch details
+    const webRows = db
+        .prepare(`SELECT tool_name, tool_input, tool_response, timestamp FROM tool_calls WHERE session_id = ? AND tool_name IN ('WebFetch', 'WebSearch') ORDER BY timestamp`)
+        .all(sessionId);
+    const webFetchDetails = [];
+    let webErrors = 0;
+    for (const row of webRows) {
+        let url = "";
+        let query = "";
+        try {
+            const input = JSON.parse(row.tool_input ?? "{}");
+            url = input.url ?? "";
+            query = input.query ?? "";
+        }
+        catch {
+            /* skip */
+        }
+        let isError = false;
+        let errorDetail = "";
+        if (!row.tool_response) {
+            isError = true;
+            errorDetail = "No response";
+        }
+        else {
+            // Only flag as error if the response is clearly an error object, not just
+            // content that happens to mention error-related words
+            try {
+                const resp = JSON.parse(row.tool_response);
+                if (resp.error || resp.is_error === true) {
+                    isError = true;
+                    errorDetail = resp.error ?? resp.message ?? "Failed";
+                }
+            }
+            catch {
+                // Non-JSON response — check for short error-like responses only
+                if (row.tool_response.length < 200) {
+                    const lower = row.tool_response.toLowerCase();
+                    if (lower.includes("error") || lower.includes("failed") || lower.includes("timeout")) {
+                        isError = true;
+                        errorDetail = row.tool_response.slice(0, 100);
+                    }
+                }
+            }
+        }
+        if (isError)
+            webErrors++;
+        webFetchDetails.push({
+            tool: row.tool_name,
+            url: url || query || "(unknown)",
+            timestamp: row.timestamp,
+            isError,
+            errorDetail,
+        });
+    }
+    const session = db.prepare("SELECT duration_ms FROM sessions WHERE id = ?").get(sessionId);
+    // Compaction events
+    const compactionRows = db
+        .prepare(`SELECT trigger, pre_tokens, timestamp FROM compactions WHERE session_id = ? ORDER BY timestamp`)
+        .all(sessionId);
+    return {
+        fileReads,
+        phases: [...phaseSummary.entries()].map(([cat, data]) => ({
+            name: CATEGORY_LABELS[cat],
+            category: cat,
+            toolCount: data.toolCount,
+            durationMs: data.durationMs,
+        })),
+        webFetches: {
+            total: webRows.length,
+            errors: webErrors,
+            successRate: webRows.length > 0 ? (webRows.length - webErrors) / webRows.length : 1,
+            details: webFetchDetails,
+        },
+        toolDistribution,
+        totalToolCalls,
+        sessionDurationMs: session?.duration_ms ?? 0,
+        compaction: {
+            count: compactionRows.length,
+            compactions: compactionRows.map((r) => ({
+                timestamp: r.timestamp,
+                trigger: r.trigger,
+                preTokens: r.pre_tokens,
+            })),
+        },
+    };
+}
+export function getSyncStatus(db) {
+    const row = db
+        .prepare("SELECT MAX(synced_at) as lastSyncedAt, COUNT(*) as sessionCount FROM sessions")
+        .get();
+    return row;
+}

package/dist/db/schema.d.ts

@@ -0,0 +1 @@
+export declare const SCHEMA = "\nPRAGMA journal_mode = WAL;\nPRAGMA busy_timeout = 5000;\nPRAGMA synchronous = NORMAL;\nPRAGMA foreign_keys = ON;\n\nCREATE TABLE IF NOT EXISTS sessions (\n  id              TEXT PRIMARY KEY,\n  project         TEXT NOT NULL,\n  project_hash    TEXT NOT NULL,\n  first_prompt    TEXT,\n  model           TEXT,\n  status          TEXT NOT NULL DEFAULT 'completed',\n  input_tokens         INTEGER NOT NULL DEFAULT 0,\n  output_tokens        INTEGER NOT NULL DEFAULT 0,\n  cache_read_tokens    INTEGER NOT NULL DEFAULT 0,\n  cache_create_tokens  INTEGER NOT NULL DEFAULT 0,\n  estimated_cost_usd   REAL NOT NULL DEFAULT 0,\n  message_count   INTEGER NOT NULL DEFAULT 0,\n  tool_call_count INTEGER NOT NULL DEFAULT 0,\n  subagent_count  INTEGER NOT NULL DEFAULT 0,\n  turn_count      INTEGER NOT NULL DEFAULT 0,\n  peak_context_tokens INTEGER NOT NULL DEFAULT 0,\n  started_at      TEXT,\n  ended_at        TEXT,\n  duration_ms     INTEGER,\n  synced_at       TEXT NOT NULL,\n  jsonl_path      TEXT NOT NULL,\n  jsonl_mtime     TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);\nCREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);\n\nCREATE TABLE IF NOT EXISTS tool_calls (\n  id              INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,\n  subagent_id     TEXT,\n  tool_use_id     TEXT,\n  tool_name       TEXT NOT NULL,\n  tool_input      TEXT,\n  tool_response   TEXT,\n  status          TEXT NOT NULL DEFAULT 'success',\n  timestamp       TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_tc_session ON tool_calls(session_id);\nCREATE INDEX IF NOT EXISTS idx_tc_tool ON tool_calls(tool_name);\n\nCREATE TABLE IF NOT EXISTS messages (\n  id              INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,\n  role            TEXT NOT NULL,\n  content         TEXT NOT NULL,\n  timestamp       TEXT NOT NULL,\n  model           TEXT,\n  cost_usd        REAL\n);\n\nCREATE INDEX IF NOT EXISTS idx_msg_session ON messages(session_id);\n\nCREATE TABLE IF NOT EXISTS subagents (\n  id              TEXT NOT NULL,\n  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,\n  agent_type      TEXT,\n  model           TEXT,\n  prompt          TEXT,\n  input_tokens         INTEGER NOT NULL DEFAULT 0,\n  output_tokens        INTEGER NOT NULL DEFAULT 0,\n  cache_read_tokens    INTEGER NOT NULL DEFAULT 0,\n  cache_create_tokens  INTEGER NOT NULL DEFAULT 0,\n  estimated_cost_usd   REAL NOT NULL DEFAULT 0,\n  tool_call_count      INTEGER NOT NULL DEFAULT 0,\n  duration_ms          INTEGER,\n  result_summary       TEXT,\n  PRIMARY KEY (id, session_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_sub_session ON subagents(session_id);\n\nCREATE TABLE IF NOT EXISTS compactions (\n  id              INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,\n  trigger         TEXT NOT NULL DEFAULT 'auto',\n  pre_tokens      INTEGER NOT NULL DEFAULT 0,\n  timestamp       TEXT NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_compact_session ON compactions(session_id);\n";

package/dist/db/schema.js

@@ -0,0 +1,90 @@
+export const SCHEMA = `
+PRAGMA journal_mode = WAL;
+PRAGMA busy_timeout = 5000;
+PRAGMA synchronous = NORMAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id              TEXT PRIMARY KEY,
+  project         TEXT NOT NULL,
+  project_hash    TEXT NOT NULL,
+  first_prompt    TEXT,
+  model           TEXT,
+  status          TEXT NOT NULL DEFAULT 'completed',
+  input_tokens         INTEGER NOT NULL DEFAULT 0,
+  output_tokens        INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens    INTEGER NOT NULL DEFAULT 0,
+  cache_create_tokens  INTEGER NOT NULL DEFAULT 0,
+  estimated_cost_usd   REAL NOT NULL DEFAULT 0,
+  message_count   INTEGER NOT NULL DEFAULT 0,
+  tool_call_count INTEGER NOT NULL DEFAULT 0,
+  subagent_count  INTEGER NOT NULL DEFAULT 0,
+  turn_count      INTEGER NOT NULL DEFAULT 0,
+  peak_context_tokens INTEGER NOT NULL DEFAULT 0,
+  started_at      TEXT,
+  ended_at        TEXT,
+  duration_ms     INTEGER,
+  synced_at       TEXT NOT NULL,
+  jsonl_path      TEXT NOT NULL,
+  jsonl_mtime     TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  subagent_id     TEXT,
+  tool_use_id     TEXT,
+  tool_name       TEXT NOT NULL,
+  tool_input      TEXT,
+  tool_response   TEXT,
+  status          TEXT NOT NULL DEFAULT 'success',
+  timestamp       TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tc_session ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tc_tool ON tool_calls(tool_name);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  role            TEXT NOT NULL,
+  content         TEXT NOT NULL,
+  timestamp       TEXT NOT NULL,
+  model           TEXT,
+  cost_usd        REAL
+);
+
+CREATE INDEX IF NOT EXISTS idx_msg_session ON messages(session_id);
+
+CREATE TABLE IF NOT EXISTS subagents (
+  id              TEXT NOT NULL,
+  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  agent_type      TEXT,
+  model           TEXT,
+  prompt          TEXT,
+  input_tokens         INTEGER NOT NULL DEFAULT 0,
+  output_tokens        INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens    INTEGER NOT NULL DEFAULT 0,
+  cache_create_tokens  INTEGER NOT NULL DEFAULT 0,
+  estimated_cost_usd   REAL NOT NULL DEFAULT 0,
+  tool_call_count      INTEGER NOT NULL DEFAULT 0,
+  duration_ms          INTEGER,
+  result_summary       TEXT,
+  PRIMARY KEY (id, session_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_sub_session ON subagents(session_id);
+
+CREATE TABLE IF NOT EXISTS compactions (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  trigger         TEXT NOT NULL DEFAULT 'auto',
+  pre_tokens      INTEGER NOT NULL DEFAULT 0,
+  timestamp       TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_compact_session ON compactions(session_id);
+`;

package/dist/parser/cost.d.ts

@@ -0,0 +1,3 @@
+import type { Usage } from "../types.js";
+export declare function estimateCost(model: string, usage: Usage): number;
+export declare function shortModelName(model: string): string;

package/dist/parser/cost.js

@@ -0,0 +1,88 @@
+// Prices per million tokens — from https://platform.claude.com/docs/en/about-claude/pricing
+// Cache read = 0.1x input, cache write 5min = 1.25x input, cache write 1hr = 2x input
+const PRICING = {
+    // Current models
+    "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite5m: 6.25, cacheWrite1h: 10 },
+    "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite5m: 6.25, cacheWrite1h: 10 },
+    "claude-sonnet-4-6": {
+        input: 3,
+        output: 15,
+        cacheRead: 0.3,
+        cacheWrite5m: 3.75,
+        cacheWrite1h: 6,
+    },
+    "claude-sonnet-4-5": {
+        input: 3,
+        output: 15,
+        cacheRead: 0.3,
+        cacheWrite5m: 3.75,
+        cacheWrite1h: 6,
+    },
+    "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite5m: 3.75, cacheWrite1h: 6 },
+    "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 2 },
+    // Older models
+    "claude-opus-4-1": {
+        input: 15,
+        output: 75,
+        cacheRead: 1.5,
+        cacheWrite5m: 18.75,
+        cacheWrite1h: 30,
+    },
+    "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite5m: 18.75, cacheWrite1h: 30 },
+    "claude-sonnet-4-5-20250514": {
+        input: 3,
+        output: 15,
+        cacheRead: 0.3,
+        cacheWrite5m: 3.75,
+        cacheWrite1h: 6,
+    },
+    "claude-3-5-sonnet-20241022": {
+        input: 3,
+        output: 15,
+        cacheRead: 0.3,
+        cacheWrite5m: 3.75,
+        cacheWrite1h: 6,
+    },
+    "claude-3-5-haiku-20241022": {
+        input: 0.8,
+        output: 4,
+        cacheRead: 0.08,
+        cacheWrite5m: 1,
+        cacheWrite1h: 1.6,
+    },
+    "claude-haiku-3": {
+        input: 0.25,
+        output: 1.25,
+        cacheRead: 0.03,
+        cacheWrite5m: 0.3,
+        cacheWrite1h: 0.5,
+    },
+};
+/** Strip date suffix like "-20251001" from model IDs */
+function stripDateSuffix(model) {
+    return model.replace(/-\d{8,}$/, "");
+}
+export function estimateCost(model, usage) {
+    // 1. Exact match  2. Strip date suffix  3. Fallback to sonnet
+    const p = PRICING[model] ?? PRICING[stripDateSuffix(model)] ?? PRICING["claude-sonnet-4-6"];
+    // Use granular cache write tiers when available, otherwise default to 5-min pricing
+    const cache5m = usage.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+    const cache1h = usage.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+    const cacheWriteCost = cache5m + cache1h > 0
+        ? cache5m * p.cacheWrite5m + cache1h * p.cacheWrite1h
+        : (usage.cache_creation_input_tokens ?? 0) * p.cacheWrite5m;
+    return ((usage.input_tokens * p.input +
+        usage.output_tokens * p.output +
+        (usage.cache_read_input_tokens ?? 0) * p.cacheRead +
+        cacheWriteCost) /
+        1_000_000);
+}
+export function shortModelName(model) {
+    if (model.includes("opus"))
+        return "opus";
+    if (model.includes("sonnet"))
+        return "sonnet";
+    if (model.includes("haiku"))
+        return "haiku";
+    return model;
+}

package/dist/parser/index.d.ts

@@ -0,0 +1,9 @@
+import type Database from "better-sqlite3";
+interface SyncResult {
+    parsed: number;
+    skipped: number;
+    errors: number;
+    totalSessions: number;
+}
+export declare function syncAll(db: Database.Database, claudeDir: string): Promise<SyncResult>;
+export {};

package/dist/parser/index.js

@@ -0,0 +1,89 @@
+import { readdirSync, statSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { parseSessionJsonl } from "./session-parser.js";
+import { parseSubagentJsonl } from "./subagent-parser.js";
+import { upsertSession } from "../db/queries.js";
+import { getSessionMtime } from "../db/queries.js";
+function decodeProjectPath(dirName) {
+    // ~/.claude/projects/ directory names are the project path with / replaced by -
+    // e.g., "-Users-nehadeodhar-work-gypsum-org-code-polos" → "/Users/nehadeodhar/work/gypsum-org/code/polos"
+    // We return the last 2 segments for display
+    const parts = dirName.split("-").filter(Boolean);
+    const fullPath = "/" + parts.join("/");
+    const segments = fullPath.split("/").filter(Boolean);
+    return segments.length >= 2 ? segments.slice(-2).join("/") : segments.join("/") || dirName;
+}
+export async function syncAll(db, claudeDir) {
+    const projectsDir = join(claudeDir, "projects");
+    if (!existsSync(projectsDir)) {
+        return { parsed: 0, skipped: 0, errors: 0, totalSessions: 0 };
+    }
+    let parsed = 0;
+    let skipped = 0;
+    let errors = 0;
+    const projectDirs = readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projectDir of projectDirs) {
+        const projectPath = join(projectsDir, projectDir.name);
+        const project = decodeProjectPath(projectDir.name);
+        const projectHash = projectDir.name;
+        // Find JSONL files at depth 1
+        let entries;
+        try {
+            entries = readdirSync(projectPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.name.endsWith(".jsonl"))
+                continue;
+            if (!entry.isFile())
+                continue;
+            const jsonlPath = join(projectPath, entry.name);
+            const sessionId = basename(entry.name, ".jsonl");
+            try {
+                const stat = statSync(jsonlPath);
+                const mtime = stat.mtime.toISOString();
+                // Skip if not modified since last sync
+                const existingMtime = getSessionMtime(db, sessionId);
+                if (existingMtime === mtime) {
+                    skipped++;
+                    continue;
+                }
+                // Parse session
+                const session = await parseSessionJsonl(jsonlPath, sessionId, project, projectHash, mtime);
+                // Parse subagents
+                const subagentDir = join(projectPath, sessionId, "subagents");
+                if (existsSync(subagentDir)) {
+                    try {
+                        const subFiles = readdirSync(subagentDir).filter((f) => f.endsWith(".jsonl"));
+                        for (const subFile of subFiles) {
+                            const agentId = basename(subFile, ".jsonl");
+                            try {
+                                const { subagent, toolCalls: subToolCalls } = await parseSubagentJsonl(join(subagentDir, subFile), agentId, sessionId);
+                                session.subagents.push(subagent);
+                                session.toolCalls.push(...subToolCalls);
+                            }
+                            catch {
+                                // Skip malformed subagent files
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip if can't read subagent dir
+                    }
+                }
+                session.subagentCount = session.subagents.length;
+                // Store in DB
+                upsertSession(db, session);
+                parsed++;
+            }
+            catch (err) {
+                errors++;
+                console.error(`Error parsing ${jsonlPath}:`, err);
+            }
+        }
+    }
+    const totalRow = db.prepare("SELECT COUNT(*) as count FROM sessions").get();
+    return { parsed, skipped, errors, totalSessions: totalRow.count };
+}

package/dist/parser/session-parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSession } from "../types.js";
+export declare function parseSessionJsonl(jsonlPath: string, sessionId: string, project: string, projectHash: string, jsonlMtime: string): Promise<ParsedSession>;