agentgui 1.0.882 → 1.0.884

package/README.md

@@ -29,7 +29,7 @@ Multi-agent GUI client for AI coding agents with real-time streaming, WebSocket
 | Kiro CLI | ACP | - |
 | fast-agent | ACP | - |
 
-![Main Interface](docs/screenshot-dark.png)
+![Main Interface](docs/screenshots/home-light.png)
 
 ## Why AgentGUI?
 
@@ -65,11 +65,17 @@ Modern AI coding requires juggling multiple agents, each in their own terminal.
 
 | Light Mode | Dark Mode |
 |------------|-----------|
-| ![Light](docs/screenshot-light.png) | ![Dark](docs/screenshot-dark.png) |
+| ![Light](docs/screenshots/home-light.png) | ![Dark](docs/screenshots/home-dark.png) |
 
-| Active Conversation |
-|---------------------|
-| ![Conversation](docs/screenshot-dark-conversation.png) |
+| Active Conversation (light) | Active Conversation (dark) |
+|-----------------------------|----------------------------|
+| ![Conversation Light](docs/screenshots/conversation-light.png) | ![Conversation Dark](docs/screenshots/conversation-dark.png) |
+
+| Tools Manager |
+|---------------|
+| ![Tools](docs/screenshots/tools-manager.png) |
+
+> Screenshots are regenerated on every push to `main` by `.github/workflows/gh-pages.yml` using the committed fixture DB (`fixtures/data.db`) so the gallery stays in sync with the UI.
 
 ## Quick Start
 

package/lib/server-startup.js

@@ -22,12 +22,16 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
       try { queries.cleanup(); console.log('[cleanup] Scheduled DB cleanup complete'); } catch (e) { console.error('[cleanup] Error:', e.message); }
     }, 6 * 60 * 60 * 1000);
 
-    try {
-      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries });
-      jsonlWatcher.start();
-      if (setWatcher) setWatcher(jsonlWatcher);
-      console.log('[JSONL] Watcher started');
-    } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }
+    if (process.env.AGENTGUI_SKIP_AUTO_IMPORT === '1') {
+      console.log('[JSONL] Watcher skipped (AGENTGUI_SKIP_AUTO_IMPORT=1)');
+    } else {
+      try {
+        jsonlWatcher = new JsonlWatcher({ broadcastSync, queries });
+        jsonlWatcher.start();
+        if (setWatcher) setWatcher(jsonlWatcher);
+        console.log('[JSONL] Watcher started');
+      } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }
+    }
 
     resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 

package/lib/server-startup2.js

@@ -26,6 +26,7 @@ export function createAutoImport({ queries, broadcastSync }) {
 
   function performAutoImport() {
     try {
+      if (process.env.AGENTGUI_SKIP_AUTO_IMPORT === '1') return;
       if (!hasIndexFilesChanged()) return;
       const imported = queries.importClaudeCodeConversations();
       if (imported.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.882",
+  "version": "1.0.884",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",
@@ -61,6 +61,8 @@
     "onnxruntime-node": "1.21.0"
   },
   "devDependencies": {
-    "electron": "^35.0.0"
+    "electron": "^35.0.0",
+    "playwright": "^1.59.1",
+    "rippleui": "^1.12.1"
   }
 }

package/scripts/build-rippleui.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// One-time build: produces static/vendor/rippleui.css from the rippleui npm package.
+// Buildless at runtime — commit the output so `npm install` is enough to serve.
+//
+// Source files (from node_modules/rippleui/dist/css/):
+//   base.css        - Tailwind preflight/reset         (~2KB)
+//   components.css  - RippleUI components (.btn etc.)  (~143KB)
+//   utilities.css   - RippleUI extra utilities         (~0.05KB)
+//   styles.css      - full TW + RippleUI monolith      (~4.7MB) — we only mine token defs
+//
+// Output: static/vendor/rippleui.css containing
+//   1. :root / html.dark token blocks extracted from styles.css (so components.css works)
+//   2. base.css
+//   3. components.css
+//   4. utilities.css
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const RUI = path.join(ROOT, 'node_modules/rippleui/dist/css');
+const OUT = path.join(ROOT, 'static/vendor/rippleui.css');
+
+if (!fs.existsSync(RUI)) {
+    console.error('rippleui not installed. Run: bun add --dev rippleui');
+    process.exit(1);
+}
+
+const base = fs.readFileSync(path.join(RUI, 'base.css'), 'utf8');
+const components = fs.readFileSync(path.join(RUI, 'components.css'), 'utf8');
+const utilities = fs.readFileSync(path.join(RUI, 'utilities.css'), 'utf8');
+const styles = fs.readFileSync(path.join(RUI, 'styles.css'), 'utf8');
+
+// Extract token blocks. RippleUI defines its design tokens in :root { ... } and html.dark { ... }
+// Find every block that contains a RippleUI-signature token like --backgroundPrimary or --gray-3.
+const tokenBlocks = [];
+const blockRe = /([:a-z.][^{}]*\{[^{}]*\})/gi;
+let m;
+while ((m = blockRe.exec(styles))) {
+    const block = m[1];
+    if (/--backgroundPrimary|--gray-\d|--content1|--primary:\s*\d/.test(block)) {
+        tokenBlocks.push(block);
+        if (tokenBlocks.length > 20) break;
+    }
+}
+
+if (tokenBlocks.length === 0) {
+    console.error('Could not find token blocks in styles.css — rippleui shape changed?');
+    process.exit(1);
+}
+
+const header = `/* RippleUI v${readPkgVersion()} — localized for AgentGUI.\n` +
+    ` * Generated by scripts/build-rippleui.mjs — do not edit by hand.\n` +
+    ` * Regenerate: bun run scripts/build-rippleui.mjs\n` +
+    ` */\n`;
+
+// RippleUI targets [data-theme=dark] for dark mode; AgentGUI uses `html.dark`.
+// Duplicate every `[data-theme=dark]` selector with `html.dark` so both work.
+function mirrorDarkSelector(css) {
+    return css.replace(/\[data-theme=dark\]/g, 'html.dark, [data-theme=dark]');
+}
+
+const bundled = header +
+    '/* --- rippleui design tokens (extracted from styles.css) --- */\n' +
+    mirrorDarkSelector(tokenBlocks.join('\n')) + '\n\n' +
+    '/* --- base.css (tailwind preflight) --- */\n' +
+    base + '\n\n' +
+    '/* --- components.css --- */\n' +
+    mirrorDarkSelector(components) + '\n\n' +
+    '/* --- utilities.css --- */\n' +
+    mirrorDarkSelector(utilities) + '\n';
+
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+fs.writeFileSync(OUT, bundled);
+const kb = (bundled.length / 1024).toFixed(1);
+console.log(`wrote ${OUT} (${kb}KB, ${tokenBlocks.length} token blocks)`);
+
+function readPkgVersion() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(ROOT, 'node_modules/rippleui/package.json'), 'utf8')).version;
+    } catch { return 'unknown'; }
+}

package/scripts/capture-screenshots.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Boot agentgui with a fixture DB on an ephemeral port and capture a set of PNGs.
+// Uses puppeteer-core with a system-provided chromium (set CHROME or it autodetects).
+//
+// Usage: node scripts/capture-screenshots.mjs [--fixtures=./fixtures] [--out=./docs/screenshots]
+
+import fs from 'fs';
+import path from 'path';
+import net from 'net';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+
+const argMap = Object.fromEntries(process.argv.slice(2).map(a => {
+    const [k, v] = a.replace(/^--/, '').split('=');
+    return [k, v ?? true];
+}));
+const FIXTURES = path.resolve(argMap.fixtures || path.join(ROOT, 'fixtures'));
+const OUT = path.resolve(argMap.out || path.join(ROOT, 'docs/screenshots'));
+
+function pickChrome() {
+    if (process.env.CHROME && fs.existsSync(process.env.CHROME)) return process.env.CHROME;
+    const candidates = [
+        '/usr/bin/chromium',
+        '/usr/bin/chromium-browser',
+        '/usr/bin/google-chrome',
+        '/usr/bin/google-chrome-stable',
+        '/snap/bin/chromium',
+        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    ];
+    for (const c of candidates) if (fs.existsSync(c)) return c;
+    throw new Error('No chromium binary found. Set CHROME env var or apt install chromium.');
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const s = net.createServer();
+        s.unref();
+        s.on('error', reject);
+        s.listen(0, () => {
+            const p = s.address().port;
+            s.close(() => resolve(p));
+        });
+    });
+}
+
+async function waitForHealthy(url, timeoutMs = 20000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const r = await fetch(url);
+            if (r.ok) return true;
+        } catch {}
+        await new Promise(r => setTimeout(r, 250));
+    }
+    throw new Error(`Server did not become healthy at ${url} within ${timeoutMs}ms`);
+}
+
+async function main() {
+    fs.mkdirSync(OUT, { recursive: true });
+    if (!fs.existsSync(FIXTURES)) {
+        console.warn(`[capture] fixture dir does not exist: ${FIXTURES} — using empty data dir`);
+        fs.mkdirSync(FIXTURES, { recursive: true });
+    }
+
+    const port = await findFreePort();
+    const BASE = `http://localhost:${port}/gm`;
+
+    console.log(`[capture] booting server on :${port} with data=${FIXTURES}`);
+    const serverEnv = {
+        ...process.env,
+        PASSWORD: '',
+        PORT: String(port),
+        HOT_RELOAD: 'false',
+        STARTUP_CWD: FIXTURES,
+        PORTABLE_DATA_DIR: FIXTURES,
+        BASE_URL: '/gm',
+        AGENTGUI_SKIP_AUTO_IMPORT: '1',   // do not merge user's ~/.claude/projects into the fixture DB
+    };
+    const server = spawn(process.execPath, [path.join(ROOT, 'server.js')], {
+        env: serverEnv,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: ROOT,
+    });
+    const srvLog = [];
+    server.stdout.on('data', d => srvLog.push(d));
+    server.stderr.on('data', d => srvLog.push(d));
+
+    const cleanup = () => {
+        try { server.kill('SIGTERM'); } catch {}
+        setTimeout(() => { try { server.kill('SIGKILL'); } catch {} }, 1500);
+    };
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => { cleanup(); process.exit(130); });
+
+    try {
+        await waitForHealthy(`${BASE}/api/health`);
+        console.log('[capture] server healthy — launching browser');
+
+        const { default: puppeteer } = await import('puppeteer-core');
+        const browser = await puppeteer.launch({
+            executablePath: pickChrome(),
+            headless: 'new',
+            args: ['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu', '--hide-scrollbars'],
+            defaultViewport: { width: 1440, height: 900, deviceScaleFactor: 1 },
+        });
+
+        const shots = [
+            { name: 'home-light',          theme: 'light', url: `${BASE}/` },
+            { name: 'home-dark',           theme: 'dark',  url: `${BASE}/` },
+            { name: 'conversation-light',  theme: 'light', url: `${BASE}/`, firstConv: true },
+            { name: 'conversation-dark',   theme: 'dark',  url: `${BASE}/`, firstConv: true },
+            { name: 'tools-manager',       theme: 'light', url: `${BASE}/`, openTools: true },
+        ];
+
+        for (const s of shots) {
+            const page = await browser.newPage();
+            page.setDefaultNavigationTimeout(15000);
+            await page.emulateMediaFeatures([{ name: 'prefers-reduced-motion', value: 'reduce' }]);
+            await page.evaluateOnNewDocument((theme) => {
+                try { localStorage.setItem('theme', theme); } catch {}
+                if (theme === 'dark') {
+                    document.documentElement.classList.add('dark');
+                    document.documentElement.setAttribute('data-theme', 'dark');
+                }
+                // Determinism: disable transitions/animations so repeated shots match byte-for-byte
+                const style = document.createElement('style');
+                style.textContent = `*,*::before,*::after{transition:none!important;animation:none!important;caret-color:transparent!important}`;
+                if (document.head) document.head.appendChild(style);
+                else document.addEventListener('DOMContentLoaded', () => document.head.appendChild(style));
+            }, s.theme);
+
+            console.log(`[capture] -> ${s.name} (${s.theme})`);
+            await page.goto(s.url, { waitUntil: 'networkidle2' });
+            // Determinism: wait until the sidebar has transitioned out of "Loading..."
+            // and rendered at least one conversation row.
+            await page.waitForFunction(() => {
+                const ul = document.querySelector('.sidebar-list');
+                if (!ul) return false;
+                const rows = ul.querySelectorAll('li:not(.sidebar-empty)');
+                return rows.length > 0;
+            }, { timeout: 8000 }).catch(() => {});
+            await new Promise(r => setTimeout(r, 600));
+
+            if (s.firstConv) {
+                const clicked = await page.evaluate(() => {
+                    const row = document.querySelector('.sidebar-list li:not(.sidebar-empty), .conversation-item:not(.sidebar-empty)');
+                    if (row) { row.click(); return true; }
+                    return false;
+                });
+                if (clicked) {
+                    await page.waitForFunction(() => {
+                        const out = document.querySelector('#output');
+                        return out && out.children.length > 0;
+                    }, { timeout: 5000 }).catch(() => {});
+                    await new Promise(r => setTimeout(r, 600));
+                }
+            }
+            if (s.openTools) {
+                const clicked = await page.evaluate(() => {
+                    const btn = document.getElementById('toolsManagerBtn');
+                    if (btn) { btn.click(); return true; }
+                    return false;
+                });
+                if (clicked) await new Promise(r => setTimeout(r, 400));
+            }
+
+            const outPath = path.join(OUT, `${s.name}.png`);
+            await page.screenshot({ path: outPath, type: 'png', fullPage: false });
+            const sz = fs.statSync(outPath).size;
+            console.log(`   wrote ${outPath} (${(sz/1024).toFixed(1)}KB)`);
+            await page.close();
+        }
+
+        await browser.close();
+    } finally {
+        cleanup();
+    }
+
+    // Final summary
+    const produced = fs.readdirSync(OUT).filter(f => f.endsWith('.png')).sort();
+    console.log(`\n[capture] done. ${produced.length} png(s) in ${OUT}`);
+    for (const f of produced) {
+        const p = path.join(OUT, f);
+        console.log(`   ${f}  ${(fs.statSync(p).size/1024).toFixed(1)}KB`);
+    }
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/scripts/harvest-fixtures.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+// Build fixtures/demo.sqlite from ~/.claude/projects/*.jsonl.
+// Output is deterministic (seeded timestamps, sorted inserts) so the same source
+// JSONL produces byte-identical DB output.
+//
+// Anonymisation: absolute paths -> /home/demo/..., emails redacted, API-key-looking
+// strings redacted, real session IDs replaced with deterministic uuids per-conv.
+//
+// If ~/.claude/projects is missing or has no usable JSONL, the script still produces
+// a valid DB using six synthesized reference conversations.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const Database = require('better-sqlite3');
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const OUT_DIR = path.join(ROOT, 'fixtures');
+const OUT_DB = path.join(OUT_DIR, 'data.db');
+const SRC_DIR = path.join(os.homedir(), '.claude', 'projects');
+
+// Fixed base timestamp so the DB is reproducible
+const BASE_TS = Date.parse('2026-03-15T10:00:00Z');
+
+// Titles we want in the demo sidebar
+const DEMO_TITLES = [
+    'Fix failing tests in db-queries',
+    'Refactor auth middleware',
+    'Add dark mode toggle',
+    'Write migration for user schema',
+    'Debug WebSocket reconnect loop',
+    'Generate API docs from handlers',
+];
+
+function det(prefix, ...seeds) {
+    const h = crypto.createHash('sha256').update(prefix + '::' + seeds.join('|')).digest('hex');
+    return `${prefix}-${h.slice(0, 16)}`;
+}
+
+// Anonymise — returns cleaned text
+function scrub(text) {
+    if (typeof text !== 'string') return text;
+    return text
+        .replace(/\/(?:config|home|root|Users)\/[A-Za-z0-9_\-./]+/g, '/home/demo/workspace')
+        .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, 'dev@example.com')
+        .replace(/sk-[A-Za-z0-9]{20,}/g, 'sk-REDACTED')
+        .replace(/ghp_[A-Za-z0-9]{20,}/g, 'ghp_REDACTED')
+        .replace(/Bearer\s+[A-Za-z0-9._-]{20,}/gi, 'Bearer REDACTED');
+}
+
+// Synthesize a realistic assistant reply given a user prompt theme
+function synthAssistant(title) {
+    const lookup = {
+        'Fix failing tests in db-queries':
+            `I'll run the test suite first to see which specs are failing, then trace the errors.\n\n` +
+            `After running \`bun test\`, I can see three assertions in \`createConversation\` are failing ` +
+            `because the \`agentId\` column was renamed. I'll update the query builder in ` +
+            `\`lib/db-queries.js\` to use the new column and patch the associated tests.\n\n` +
+            `The fix is a one-line change to the INSERT statement. All 19 tests pass now.`,
+        'Refactor auth middleware':
+            `The current auth middleware has three responsibilities — rate limiting, basic-auth check, ` +
+            `and CORS — packed into a single 80-line function. I'll split them into three small ` +
+            `middlewares in \`lib/http-middlewares/\` and compose them in \`http-handler.js\`. ` +
+            `No behaviour change, just readability.`,
+        'Add dark mode toggle':
+            `Dark mode is already wired through CSS custom properties in \`main.css\` (\`:root\` + \`html.dark\`). ` +
+            `We just need a toggle button in the header and a listener that flips the class on \`<html>\` ` +
+            `and persists the choice in \`localStorage\`. I'll also respect \`prefers-color-scheme\` for the ` +
+            `first visit.`,
+        'Write migration for user schema':
+            `Adding \`last_login_at INTEGER\` and \`preferences JSON\` to the users table. I'll write the ` +
+            `migration as \`database-migrations-user.js\`, gate it on a schema-version row, and backfill ` +
+            `\`last_login_at\` from the \`sessions\` table's most-recent entry per user. Safe under concurrent writes.`,
+        'Debug WebSocket reconnect loop':
+            `Found it. The ws-machine transitions to \`reconnecting\` on \`close\`, but the timer was never ` +
+            `cleared when a message arrived mid-wait, so two sockets were briefly open. I added a guard in ` +
+            `\`static/js/ws-machine.js\` and the duplicate connection disappears.`,
+        'Generate API docs from handlers':
+            `Scanning \`lib/routes-*.js\` for \`router.handle\` / \`app.<method>\` declarations and producing a ` +
+            `markdown doc grouped by module. Output goes to \`docs/api.md\`. I'll add a JSDoc-style comment ` +
+            `parser so handler descriptions can live inline with the route.`,
+    };
+    return lookup[title] || 'Done — see the diff for details.';
+}
+
+function synthUser(title) {
+    const lookup = {
+        'Fix failing tests in db-queries':
+            'Hey — the test suite has been flaky since yesterday. Can you figure out which specs are failing and fix them? Start with `bun test` and work from there.',
+        'Refactor auth middleware':
+            `The auth middleware in lib/http-handler.js has grown into a monster. Please split it into single-responsibility pieces.`,
+        'Add dark mode toggle':
+            `Can we add a theme toggle button in the header? It should remember the user's choice and default to the system preference.`,
+        'Write migration for user schema':
+            `Add last_login_at and a preferences JSON column to the users table. Include a backfill for existing rows.`,
+        'Debug WebSocket reconnect loop':
+            `Clients are getting stuck in a reconnect loop — the network tab shows two sockets opening before one closes. Can you trace it in ws-machine and fix?`,
+        'Generate API docs from handlers':
+            `We need API docs. Generate them from the route handler declarations and dump to docs/api.md.`,
+    };
+    return lookup[title] || 'Please take a look.';
+}
+
+// If we can harvest a user message that looks natural from real JSONL, use it,
+// otherwise fall back to the synthesized one.
+function harvestPrompts() {
+    const pool = [];
+    if (!fs.existsSync(SRC_DIR)) return pool;
+    try {
+        for (const projDir of fs.readdirSync(SRC_DIR)) {
+            const full = path.join(SRC_DIR, projDir);
+            if (!fs.statSync(full).isDirectory()) continue;
+            for (const f of fs.readdirSync(full)) {
+                if (!f.endsWith('.jsonl')) continue;
+                const lines = fs.readFileSync(path.join(full, f), 'utf8').split('\n').filter(Boolean);
+                for (const l of lines) {
+                    try {
+                        const e = JSON.parse(l);
+                        if (e.type !== 'user') continue;
+                        const msg = e.message?.content;
+                        if (!msg) continue;
+                        const text = Array.isArray(msg)
+                            ? msg.find(c => c.type === 'text')?.text
+                            : typeof msg === 'string' ? msg : null;
+                        if (!text) continue;
+                        // Keep only naturally-phrased (no tool_use_id etc.) prompts, 40-400 chars
+                        if (text.length < 40 || text.length > 400) continue;
+                        if (/tool_use|tool_result|<function_calls/.test(text)) continue;
+                        pool.push(scrub(text));
+                        if (pool.length > 50) return pool;
+                    } catch {}
+                }
+            }
+        }
+    } catch {}
+    return pool;
+}
+
+function build() {
+    fs.mkdirSync(OUT_DIR, { recursive: true });
+    if (fs.existsSync(OUT_DB)) fs.unlinkSync(OUT_DB);
+
+    const db = new Database(OUT_DB);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+
+    // Inline the subset of the schema needed to render conversations.
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS conversations (
+            id TEXT PRIMARY KEY, agentId TEXT NOT NULL, title TEXT,
+            created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+            status TEXT DEFAULT 'active'
+        );
+        CREATE INDEX IF NOT EXISTS idx_conversations_agent ON conversations(agentId);
+        CREATE INDEX IF NOT EXISTS idx_conversations_updated ON conversations(updated_at DESC);
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY, conversationId TEXT NOT NULL, role TEXT NOT NULL,
+            content TEXT NOT NULL, created_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversationId);
+
+        CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY, conversationId TEXT NOT NULL, status TEXT NOT NULL,
+            started_at INTEGER NOT NULL, completed_at INTEGER, response TEXT, error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_sessions_conversation ON sessions(conversationId);
+    `);
+
+    const insConv = db.prepare(`INSERT INTO conversations (id, agentId, title, created_at, updated_at, status)
+        VALUES (?, ?, ?, ?, ?, ?)`);
+    const insMsg = db.prepare(`INSERT INTO messages (id, conversationId, role, content, created_at)
+        VALUES (?, ?, ?, ?, ?)`);
+    const insSess = db.prepare(`INSERT INTO sessions (id, conversationId, status, started_at, completed_at, response, error)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`);
+
+    const realPrompts = harvestPrompts();
+    const tx = db.transaction(() => {
+        DEMO_TITLES.forEach((title, idx) => {
+            const convId = det('conv', title);
+            const ts = BASE_TS - idx * 3600 * 1000;            // newest first
+            insConv.run(convId, 'claude-code', title, ts, ts, 'active');
+
+            const userText = realPrompts[idx] || synthUser(title);
+            const assistantText = synthAssistant(title);
+            const userMsgId = det('msg', convId, 'user');
+            const asstMsgId = det('msg', convId, 'asst');
+            const sessId = det('sess', convId);
+
+            insMsg.run(userMsgId, convId, 'user', userText, ts);
+            insSess.run(sessId, convId, 'completed', ts + 1000, ts + 12000, assistantText, null);
+            insMsg.run(asstMsgId, convId, 'assistant', assistantText, ts + 12000);
+        });
+    });
+    tx();
+
+    const count = db.prepare('SELECT COUNT(*) AS n FROM conversations').get().n;
+    const msgCount = db.prepare('SELECT COUNT(*) AS n FROM messages').get().n;
+    db.close();
+    const sz = fs.statSync(OUT_DB).size;
+    console.log(`[harvest] wrote ${OUT_DB} (${(sz/1024).toFixed(1)}KB, ${count} conversations, ${msgCount} messages)`);
+    console.log(`[harvest] harvested ${realPrompts.length} real prompt(s) from ${SRC_DIR}`);
+}
+
+build();