rewound 0.2.0 → 0.4.0

package/README.md

@@ -6,11 +6,11 @@ Grep for everything your AI coding agents ever did.
 
 Heavy users of coding agents accumulate gigabytes of session transcripts that are effectively write-only memory:
 
-- **No search.** Claude Code has no cross-session full-text search. Finding "the session where we fixed the auth bug" means manual archaeology through JSONL files.
+- **No search.** Claude Code and Codex CLI have no cross-session full-text search. Finding "the session where we fixed the auth bug" means manual archaeology through JSONL files.
 - **History is perishable.** Claude Code deletes transcripts older than 30 days by default (`cleanupPeriodDays`, swept at startup) — your reasoning history evaporates.
 - **Agents can't remember.** Every new session rediscovers what a previous session already solved. Nobody serves the agent itself.
 
-rewound indexes every session transcript on your machine into a local SQLite/FTS5 database and exposes it three ways: a CLI, an MCP server your agents can query directly, and a phone-friendly local web UI. Everything runs on your machine. Nothing leaves it.
+rewound indexes every session transcript on your machine — Claude Code and OpenAI Codex CLI today, more harnesses next — into a local SQLite/FTS5 database and exposes it three ways: a CLI, an MCP server your agents can query directly, and a phone-friendly local web UI. Everything runs on your machine. Nothing leaves it.
 
 ## 60-second demo
 
@@ -30,6 +30,19 @@ found and fixed the **fts5** **trigger** bug by rewriting the AFTER UPDATE **tri
 
 Those numbers are real, from indexing a working machine's actual Claude Code history: 3,310 session files / 2+ GB / 368,687 messages, cold-indexed in 30 seconds (target was 5 minutes), incremental re-index in 148ms (target 5s), search in single-digit milliseconds (target 100ms).
 
+![Search results — grouped per session, prose ranked above tool output](docs/media/search.png)
+
+Your own words rank above tool output that merely mentions the term, results are grouped one-per-session (`+N more in this session`), and every hit carries a one-tap resume command. More recall stories in [docs/use-cases.md](docs/use-cases.md).
+
+<details>
+<summary>More screenshots: session transcript · stats · phone</summary>
+
+![Session transcript view](docs/media/session.png)
+![Stats — est. API cost per project](docs/media/stats.png)
+![Phone-friendly over your tailnet](docs/media/phone.png)
+
+</details>
+
 ## Install
 
 ```bash
@@ -37,8 +50,9 @@ npm install -g rewound
 rewound index
 ```
 
-Or without installing: `npx rewound index`. Node 20+ required. The CLI is also installed
-as `rw` — same commands, fewer keystrokes (`rw search "auth bug"`).
+Or with Homebrew: `brew install dashorama/tap/rewound`. Or without installing anything:
+`npx rewound index`. Node 20+ required. The CLI is also installed as `rw` — same
+commands, fewer keystrokes (`rw search "auth bug"`).
 
 <details>
 <summary>Build from source</summary>
@@ -52,17 +66,48 @@ node dist/cli.js index          # or: npm link, then `rewound index`
 
 </details>
 
-By default rewound reads `~/.claude/projects/**/*.jsonl` (read-only — it never modifies your transcripts) and writes its own database to `~/.rewound/rewound.db`. Override the DB path with `--db <path>` or `REWOUND_DB=<path>`.
+By default rewound reads `~/.claude/projects/**/*.jsonl` and Codex CLI sessions from `~/.codex/sessions` (read-only — it never modifies your transcripts) and writes its own database to `~/.rewound/rewound.db`. Override the DB path with `--db <path>` or `REWOUND_DB=<path>`.
 
-### Your history outlives Claude Code's cleanup
+### Multi-machine: your history follows you
 
-Claude Code deletes transcripts older than ~30 days at startup. rewound's index is permanent: once a session is indexed, it stays searchable even after the source file is gone (it's kept as an *archived* session). Anything from before you started indexing is already unrecoverable — so the best moment to run `rewound index` is now, and then regularly. A cron line makes it automatic:
+If you work across machines, two commands per machine give you one merged history with
+zero servers involved:
 
+```bash
+rewound sync ~/GoogleDrive/rewound   # once: any folder your machines already share
+rewound auto --install               # keeps index + sync fresh via cron, hourly
 ```
-@hourly rewound index
+
+That's the whole setup. The folder is remembered after the first run — from then on bare
+`rewound sync` (and the cron entry `rewound auto` installs) just works. Any shared folder
+qualifies: Google Drive, Dropbox, Syncthing, a private git repo you pull/push, a mounted
+NAS.
+
+How it works: each machine writes its own snapshot (`<hostname>.rewound.db`) into the
+folder and merges everyone else's — the richer copy of a session wins and repeat runs are
+no-ops. Because every host only ever writes its own file, eventually-consistent syncers
+like Drive and Dropbox never see write conflicts. `rewound merge <file.db>` is the
+underlying primitive if you'd rather move snapshots by hand (scp, USB stick).
+
+**No shared folder? Using object storage (S3, Supabase Storage, R2...)?** The easy road
+is still any file-sync client. If you'd rather use a bucket, wrap the sync in two rclone
+copies (Supabase Storage is S3-compatible — create S3 access keys in project settings →
+Storage, then `rclone config` an S3 remote with your project's storage endpoint):
+
+```bash
+rclone copy bucket:rewound ~/.rewound/sync   # pull other machines' snapshots
+rewound sync ~/.rewound/sync                 # merge + write this machine's snapshot
+rclone copy ~/.rewound/sync bucket:rewound   # push
 ```
 
-Incremental runs take well under a second when little has changed.
+Put those three lines in cron and it's just as automatic — no mounts needed.
+
+Privacy stance unchanged: rewound itself never opens a network connection — *you* choose
+the transport, and your data only ever lands on storage you control.
+
+### Your history outlives Claude Code's cleanup
+
+Claude Code deletes transcripts older than ~30 days at startup. rewound's index is permanent: once a session is indexed, it stays searchable even after the source file is gone (it's kept as an *archived* session). Anything from before you started indexing is already unrecoverable — so the best moment to run `rewound index` is now, and then let `rewound auto --install` keep it fresh hourly. Incremental runs take well under a second when little has changed.
 
 ## The surfaces
 
@@ -119,7 +164,7 @@ Server-rendered with zero frontend build step, colorblind-safe palette (blue/ora
 
 ## Roadmap
 
-Keyword-first search is deliberate for v0.x — it's fast, local, and predictable. Local hybrid/semantic search (vector index built with a local embedding model, no API keys, fused with FTS ranking) is planned once the keyword surface has proven itself; the gap it closes is vocabulary mismatch ("that time the port was already taken" vs `EADDRINUSE`).
+More harness adapters are next: Copilot CLI and OpenCode transcripts are already mapped (see repo issues/roadmap). Keyword-first search is deliberate for v0.x — it's fast, local, and predictable. Local hybrid/semantic search (vector index built with a local embedding model, no API keys, fused with FTS ranking) is planned once the keyword surface has proven itself; the gap it closes is vocabulary mismatch ("that time the port was already taken" vs `EADDRINUSE`).
 
 ## License & pricing
 

package/dist/adapters/claude-code.js

@@ -1,5 +1,5 @@
-import fs from "node:fs";
 import path from "node:path";
+import { consumeCompleteLines, walkJsonlFiles } from "./jsonl.js";
 function extractBlockText(block) {
     if (block == null)
         return "";
@@ -59,46 +59,19 @@ function decodeProjectDir(filePath) {
     const dirName = path.basename(path.dirname(filePath));
     return dirName.replace(/-/g, "/");
 }
-function walk(dir, found) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            walk(full, found);
-        }
-        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-            found.push(full);
-        }
-    }
-}
 export class ClaudeCodeAdapter {
     id = "claude-code";
     discover(roots) {
         const found = [];
         for (const root of roots)
-            walk(root, found);
-        return found;
+            walkJsonlFiles(root, found);
+        // rollout-*.jsonl are Codex CLI files (CodexAdapter's territory) — keep the
+        // two adapters disjoint even when a user points --roots at a mixed tree.
+        return found.filter((f) => !/^rollout-.*\.jsonl$/.test(path.basename(f)));
     }
     parse(filePath, fromByte = 0) {
         const id = path.basename(filePath, ".jsonl");
-        const buf = fs.readFileSync(filePath);
-        const slice = buf.subarray(fromByte);
-        // Only ever consume complete, newline-terminated lines. If the file is
-        // mid-write (the writer appended a record's bytes but hasn't flushed its
-        // trailing "\n" yet), the last fragment in `slice` is torn — leave it
-        // unconsumed and unparsed so the next incremental call re-reads it whole,
-        // rather than either erroring on it or silently skipping past it.
-        const lastNewline = slice.lastIndexOf(0x0a); // "\n"
-        const consumedSlice = lastNewline === -1 ? slice.subarray(0, 0) : slice.subarray(0, lastNewline + 1);
-        const bytesConsumed = fromByte + consumedSlice.length;
-        const text = consumedSlice.length > 0 ? consumedSlice.toString("utf8") : "";
-        const lines = text.length > 0 ? text.split("\n") : [];
+        const { lines, bytesConsumed } = consumeCompleteLines(filePath, fromByte);
         const messages = [];
         let title;
         let gitBranch;

package/dist/adapters/codex.js

@@ -0,0 +1,127 @@
+import crypto from "node:crypto";
+import path from "node:path";
+import { consumeCompleteLines, walkJsonlFiles } from "./jsonl.js";
+const ROLLOUT_RE = /rollout-.*\.jsonl$/;
+const UUID_RE = /([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/;
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const item of content) {
+        if (item && typeof item === "object") {
+            const t = item.text;
+            if (typeof t === "string" && t)
+                parts.push(t);
+        }
+    }
+    return parts.join("\n\n");
+}
+function messageUuid(ts, role, text) {
+    return crypto.createHash("sha1").update(`${ts}|${role}|${text}`).digest("hex").slice(0, 16);
+}
+export class CodexAdapter {
+    id = "codex";
+    discover(roots) {
+        const found = [];
+        for (const root of roots)
+            walkJsonlFiles(root, found);
+        return found.filter((f) => ROLLOUT_RE.test(path.basename(f)));
+    }
+    parse(filePath, fromByte = 0) {
+        const uuidMatch = UUID_RE.exec(path.basename(filePath));
+        const id = uuidMatch ? uuidMatch[1] : path.basename(filePath, ".jsonl");
+        const { lines, bytesConsumed } = consumeCompleteLines(filePath, fromByte);
+        const messages = [];
+        let projectDir;
+        let gitBranch;
+        let model;
+        let startedAt;
+        let endedAt;
+        let parseErrors = 0;
+        const push = (m) => {
+            messages.push({ ...m, uuid: messageUuid(m.ts, m.role, m.text || m.toolText || ""), isSidechain: false });
+            if (m.ts) {
+                if (!startedAt || m.ts < startedAt)
+                    startedAt = m.ts;
+                if (!endedAt || m.ts > endedAt)
+                    endedAt = m.ts;
+            }
+        };
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            }
+            catch {
+                parseErrors++;
+                continue;
+            }
+            if (!record || typeof record !== "object" || typeof record.type !== "string") {
+                parseErrors++;
+                continue;
+            }
+            const ts = record.timestamp ?? "";
+            const p = record.payload;
+            if (!p || typeof p !== "object")
+                continue;
+            if (record.type === "session_meta") {
+                if (typeof p.cwd === "string" && !projectDir)
+                    projectDir = p.cwd;
+                const git = p.git;
+                if (git && typeof git.branch === "string" && !gitBranch)
+                    gitBranch = git.branch;
+                continue;
+            }
+            if (record.type === "turn_context") {
+                if (typeof p.model === "string")
+                    model = p.model;
+                continue;
+            }
+            if (record.type !== "response_item")
+                continue; // compacted, event_msg, drift: skip
+            const itemType = p.type;
+            if (itemType === "message") {
+                const role = p.role === "assistant" ? "assistant" : p.role === "user" ? "user" : undefined;
+                if (!role)
+                    continue;
+                const text = contentText(p.content);
+                if (!text)
+                    continue;
+                push({ role, ts, text, tools: [], model: role === "assistant" ? model : undefined });
+            }
+            else if (itemType === "reasoning") {
+                const text = [contentText(p.summary), contentText(p.content)].filter(Boolean).join("\n\n");
+                if (text)
+                    push({ role: "assistant", ts, text, tools: [], model });
+            }
+            else if (itemType === "function_call" || itemType === "local_shell_call" || itemType === "custom_tool_call") {
+                const name = typeof p.name === "string" ? p.name : itemType === "local_shell_call" ? "shell" : "tool";
+                push({ role: "assistant", ts, text: "", tools: [name], model });
+            }
+            else if (itemType === "function_call_output" || itemType === "custom_tool_call_output") {
+                const out = typeof p.output === "string" ? p.output : contentText(p.output);
+                if (out)
+                    push({ role: "user", ts, text: "", toolText: out, tools: [] });
+            }
+            // unknown response_item types: skip silently (format drift tolerance)
+        }
+        return {
+            id,
+            source: "codex",
+            projectDir: projectDir ?? "(unknown project)",
+            projectDirSource: projectDir ? "cwd" : "fallback",
+            filePath,
+            gitBranch,
+            startedAt,
+            endedAt,
+            messages,
+            parseErrors,
+            bytesConsumed,
+        };
+    }
+}

package/dist/adapters/jsonl.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+// Shared machinery for append-only JSONL transcript files.
+//
+// Only ever consume complete, newline-terminated lines. If the file is
+// mid-write (the writer appended a record's bytes but hasn't flushed its
+// trailing "\n" yet), the last fragment is torn — leave it unconsumed and
+// unparsed so the next incremental call re-reads it whole, rather than either
+// erroring on it or silently skipping past it.
+export function consumeCompleteLines(filePath, fromByte) {
+    const buf = fs.readFileSync(filePath);
+    const slice = buf.subarray(fromByte);
+    const lastNewline = slice.lastIndexOf(0x0a); // "\n"
+    const consumedSlice = lastNewline === -1 ? slice.subarray(0, 0) : slice.subarray(0, lastNewline + 1);
+    const bytesConsumed = fromByte + consumedSlice.length;
+    const text = consumedSlice.length > 0 ? consumedSlice.toString("utf8") : "";
+    const lines = text.length > 0 ? text.split("\n") : [];
+    return { lines, bytesConsumed };
+}
+export function walkJsonlFiles(dir, found) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkJsonlFiles(full, found);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            found.push(full);
+        }
+    }
+}

package/dist/auto.js

@@ -0,0 +1,37 @@
+import { spawnSync } from "node:child_process";
+// Pure crontab-text manipulation for `rewound auto` — kept side-effect-free so
+// the scheduling logic is testable without touching a real crontab.
+export const AUTO_MARKER = "# managed-by-rewound-auto";
+export function buildAutoLine(schedule, haveSyncDir) {
+    const cmd = haveSyncDir ? "rewound index && rewound sync" : "rewound index";
+    return `${schedule} ${cmd} ${AUTO_MARKER}`;
+}
+export function listAutoLines(crontab) {
+    return crontab.split("\n").filter((l) => l.includes(AUTO_MARKER));
+}
+export function removeAutoLines(crontab) {
+    const kept = crontab.split("\n").filter((l) => !l.includes(AUTO_MARKER));
+    while (kept.length > 0 && kept[kept.length - 1] === "")
+        kept.pop();
+    return kept.length ? kept.join("\n") + "\n" : "";
+}
+export function upsertAutoLines(crontab, line) {
+    const base = removeAutoLines(crontab);
+    return base + line + "\n";
+}
+// Thin wrappers around the crontab binary. Return undefined when crontab is
+// unavailable (e.g. Windows, minimal containers) so the CLI can fall back to
+// printing the line for manual setup.
+export function readCrontab() {
+    const res = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+    if (res.error)
+        return undefined;
+    // `crontab -l` exits 1 with "no crontab for <user>" when empty — treat as "".
+    if (res.status !== 0)
+        return "";
+    return res.stdout ?? "";
+}
+export function writeCrontab(contents) {
+    const res = spawnSync("crontab", ["-"], { input: contents, encoding: "utf8" });
+    return !res.error && res.status === 0;
+}

package/dist/cli.js

@@ -6,11 +6,16 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { openDb, resolveDbPath, getSessionByIdOrPrefix, getMessagesForSession, listSessions, getStats, getNewestMessageTs, parseJsonStringArray, } from "./db.js";
 import { ClaudeCodeAdapter } from "./adapters/claude-code.js";
+import { CodexAdapter } from "./adapters/codex.js";
 import { indexAll } from "./indexer.js";
-import { search, collapseSnippetWhitespace } from "./search.js";
+import { search, collapseSnippetWhitespace, resumeCommand } from "./search.js";
+import { mergeDb, syncDir, sanitizeHostName } from "./sync.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { buildAutoLine, upsertAutoLines, removeAutoLines, listAutoLines, readCrontab, writeCrontab, } from "./auto.js";
 import { startMcpServer } from "./mcp.js";
 import { buildServer } from "./server.js";
 const DEFAULT_ROOTS = [path.join(os.homedir(), ".claude", "projects")];
+const DEFAULT_CODEX_ROOTS = [path.join(os.homedir(), ".codex", "sessions")];
 const defaultLog = (line) => console.log(line);
 export function highlightSnippet(snippet) {
     return snippet.replace(/\x01/g, "\x1b[1m").replace(/\x02/g, "\x1b[0m");
@@ -27,10 +32,19 @@ export function parsePositiveInt(value) {
 }
 export function runIndex(opts, log = defaultLog) {
     const db = openDb(resolveDbPath(opts.db));
-    const adapter = new ClaudeCodeAdapter();
-    const roots = opts.roots && opts.roots.length > 0 ? opts.roots : DEFAULT_ROOTS;
-    const stats = indexAll(db, adapter, roots);
+    const claudeRoots = opts.roots && opts.roots.length > 0 ? opts.roots : DEFAULT_ROOTS;
+    const codexRoots = opts.codexRoots && opts.codexRoots.length > 0 ? opts.codexRoots : DEFAULT_CODEX_ROOTS;
+    const a = indexAll(db, new ClaudeCodeAdapter(), claudeRoots);
+    const b = indexAll(db, new CodexAdapter(), codexRoots);
     db.close();
+    const stats = {
+        filesScanned: a.filesScanned + b.filesScanned,
+        filesNew: a.filesNew + b.filesNew,
+        filesUpdated: a.filesUpdated + b.filesUpdated,
+        messagesIndexed: a.messagesIndexed + b.messagesIndexed,
+        parseErrors: a.parseErrors + b.parseErrors,
+        elapsedMs: a.elapsedMs + b.elapsedMs,
+    };
     if (opts.json) {
         log(JSON.stringify(stats));
         return;
@@ -63,7 +77,7 @@ export function runSearch(query, opts, log = defaultLog) {
             const extra = hit.matchesInSession - 1;
             log(`  (+${extra} more ${extra === 1 ? "match" : "matches"} in this session)`);
         }
-        log(`  ↳ resume: claude --resume ${hit.sessionId}`);
+        log(`  ↳ resume: ${resumeCommand(hit.source, hit.sessionId)}`);
         log("");
     }
     if (newestTs) {
@@ -71,6 +85,75 @@ export function runSearch(query, opts, log = defaultLog) {
     }
     log(`(${hits.length} ${hits.length === 1 ? "hit" : "hits"} in ${elapsedMs}ms)`);
 }
+export function runMerge(otherPath, opts, log = defaultLog) {
+    const db = openDb(resolveDbPath(opts.db));
+    const stats = mergeDb(db, otherPath);
+    db.close();
+    if (opts.json) {
+        log(JSON.stringify(stats));
+        return;
+    }
+    log(`sessions added: ${stats.sessionsAdded}  updated: ${stats.sessionsUpdated}`);
+}
+export function runSync(dir, opts, log = defaultLog) {
+    const dbPath = resolveDbPath(opts.db);
+    const cfg = loadConfig(dbPath);
+    const target = dir ?? cfg.syncDir;
+    if (!target) {
+        log("no sync folder configured yet — run `rewound sync <dir>` once with any folder");
+        log("your machines already share (Drive, Dropbox, Syncthing, a git repo...); after");
+        log("that, bare `rewound sync` reuses it everywhere, including cron.");
+        return;
+    }
+    if (dir && path.resolve(dir) !== cfg.syncDir) {
+        saveConfig(dbPath, { ...cfg, syncDir: path.resolve(dir) });
+    }
+    const db = openDb(dbPath);
+    const stats = syncDir(db, path.resolve(target), opts.host);
+    db.close();
+    if (opts.json) {
+        log(JSON.stringify(stats));
+        return;
+    }
+    const host = sanitizeHostName(opts.host ?? os.hostname());
+    log(`exported snapshot: ${host}.rewound.db`);
+    log(`snapshots merged: ${stats.snapshotsMerged}  sessions added: ${stats.sessionsAdded}  updated: ${stats.sessionsUpdated}`);
+}
+export function runAuto(opts, log = defaultLog) {
+    const haveSyncDir = Boolean(loadConfig(resolveDbPath(opts.db)).syncDir);
+    const line = buildAutoLine(opts.schedule ?? "@hourly", haveSyncDir);
+    const current = readCrontab();
+    if (current === undefined) {
+        log("crontab isn't available on this system — schedule this yourself:");
+        log(`  ${line}`);
+        return;
+    }
+    if (opts.install) {
+        if (!writeCrontab(upsertAutoLines(current, line))) {
+            log("failed to write crontab — add manually:");
+            log(`  ${line}`);
+            return;
+        }
+        log(`installed: ${line}`);
+        if (!haveSyncDir) {
+            log("(index only — run `rewound sync <dir>` once, then `rewound auto --install` again to add syncing)");
+        }
+        return;
+    }
+    if (opts.remove) {
+        writeCrontab(removeAutoLines(current));
+        log("removed rewound's cron entry");
+        return;
+    }
+    const managed = listAutoLines(current);
+    if (managed.length === 0) {
+        log("not scheduled — run `rewound auto --install` to keep the index fresh automatically");
+    }
+    else {
+        for (const l of managed)
+            log(l);
+    }
+}
 export function runSessions(opts, log = defaultLog) {
     const db = openDb(resolveDbPath(opts.db));
     const rows = listSessions(db, { project: opts.project, limit: opts.limit });
@@ -160,7 +243,8 @@ export function buildProgram() {
     program.name("rewound").description("Grep for everything your AI coding agents ever did.");
     program
         .command("index")
-        .option("--roots <dirs...>", "root directories to scan")
+        .option("--roots <dirs...>", "Claude Code root directories to scan")
+        .option("--codex-roots <dirs...>", "Codex CLI session roots (default: ~/.codex/sessions)")
         .option("--db <path>", "database path")
         .option("--json", "output JSON")
         .action((opts) => runIndex(opts));
@@ -188,6 +272,27 @@ export function buildProgram() {
         .option("--db <path>", "database path")
         .option("--json", "output JSON")
         .action((idOrPrefix, opts) => runShow(idOrPrefix, opts));
+    program
+        .command("merge <db-file>")
+        .description("merge another rewound database into this one (union; richer session copy wins)")
+        .option("--db <path>", "database path")
+        .option("--json", "output JSON")
+        .action((file, opts) => runMerge(file, opts));
+    program
+        .command("sync [dir]")
+        .description("multi-machine continuity: exchange snapshots via any folder you already sync (dir is remembered after first use)")
+        .option("--host <name>", "snapshot name for this machine (default: hostname)")
+        .option("--db <path>", "database path")
+        .option("--json", "output JSON")
+        .action((dir, opts) => runSync(dir, opts));
+    program
+        .command("auto")
+        .description("keep the index (and sync, if configured) fresh automatically via cron")
+        .option("--install", "install the cron entry")
+        .option("--remove", "remove the cron entry")
+        .option("--schedule <cron>", "cron schedule expression", "@hourly")
+        .option("--db <path>", "database path")
+        .action((opts) => runAuto(opts));
     program
         .command("stats")
         .option("--db <path>", "database path")

package/dist/config.js

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+function configPath(dbPath) {
+    return path.join(path.dirname(dbPath), "config.json");
+}
+export function loadConfig(dbPath) {
+    try {
+        const raw = fs.readFileSync(configPath(dbPath), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(dbPath, cfg) {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    fs.writeFileSync(configPath(dbPath), JSON.stringify(cfg, null, 2) + "\n");
+}

package/dist/db.js

@@ -316,7 +316,7 @@ export function searchMessagesRaw(db, matchExpr, opts) {
       FROM (
         SELECT m.session_id as sessionId, m.uuid as uuid, m.role as role, m.ts as ts,
                m.text as text, m.model as model, m.is_sidechain as isSidechain,
-               s.project_dir as projectDir, s.title as title, s.est_cost_usd as estCostUsd,
+               s.project_dir as projectDir, s.title as title, s.est_cost_usd as estCostUsd, s.source as source,
                snippet(messages_fts, -1, '
', '', '...', 12) as snippet,
                bm25(messages_fts, ${PROSE_BM25_WEIGHT}, ${TOOL_BM25_WEIGHT}) as rank
         FROM messages_fts
@@ -343,6 +343,7 @@ export function searchMessagesRaw(db, matchExpr, opts) {
         title: r.title ?? undefined,
         estCostUsd: r.estCostUsd,
         matchesInSession: r.matchesInSession,
+        source: r.source,
     }));
 }
 export function listSessions(db, opts = {}) {

package/dist/search.js

@@ -1,4 +1,10 @@
 import { searchMessagesRaw } from "./db.js";
+// Every source harness has its own resume incantation; hits know their source.
+export function resumeCommand(source, sessionId) {
+    if (source === "codex")
+        return `codex resume ${sessionId}`;
+    return `claude --resume ${sessionId}`;
+}
 // Snippets lifted from code/tool dumps carry embedded newlines, tabs and
 // indentation that wreck scannability in a result list. Collapse for display
 // only — stored text and raw snippet data are untouched.
@@ -58,5 +64,6 @@ export function search(db, query, opts) {
         isSidechain: r.isSidechain,
         estCostUsd: r.estCostUsd,
         matchesInSession: r.matchesInSession,
+        source: r.source,
     }));
 }

package/dist/sync.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { openDb } from "./db.js";
+// Merge another rewound database into `local`: union by session id, and on
+// collision the richer copy wins (more messages; tie broken by newer ended_at).
+// The source file is never written to — it is copied aside first, because sync
+// snapshots belong to other hosts and mutating them (e.g. a schema migration)
+// would fight their next export through the user's file-sync service.
+export function mergeDb(local, otherPath) {
+    const tmpCopy = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "rewound-merge-")), "snapshot.db");
+    fs.copyFileSync(otherPath, tmpCopy);
+    // Round-trip through openDb so pre-v2 snapshots are migrated before ATTACH.
+    openDb(tmpCopy).close();
+    const stats = { sessionsAdded: 0, sessionsUpdated: 0 };
+    local.prepare("ATTACH DATABASE ? AS other").run(tmpCopy);
+    try {
+        const merge = local.transaction(() => {
+            const otherSessions = local
+                .prepare("SELECT id, message_count, ended_at FROM other.sessions")
+                .all();
+            const getLocal = local.prepare("SELECT message_count, ended_at FROM sessions WHERE id = ?");
+            const copySession = local.prepare("INSERT INTO sessions SELECT * FROM other.sessions WHERE id = ?");
+            const copyMessages = local.prepare(`INSERT INTO messages (session_id, uuid, role, ts, text, tools, model, is_sidechain, tool_text)
+         SELECT session_id, uuid, role, ts, text, tools, model, is_sidechain, tool_text
+         FROM other.messages WHERE session_id = ?`);
+            const deleteSession = local.prepare("DELETE FROM sessions WHERE id = ?");
+            const deleteMessages = local.prepare("DELETE FROM messages WHERE session_id = ?");
+            for (const o of otherSessions) {
+                const l = getLocal.get(o.id);
+                if (!l) {
+                    copySession.run(o.id);
+                    copyMessages.run(o.id);
+                    stats.sessionsAdded++;
+                    continue;
+                }
+                const richer = o.message_count > l.message_count ||
+                    (o.message_count === l.message_count && (o.ended_at ?? "") > (l.ended_at ?? ""));
+                if (richer) {
+                    deleteMessages.run(o.id); // FTS delete-triggers fire per row
+                    deleteSession.run(o.id);
+                    copySession.run(o.id);
+                    copyMessages.run(o.id);
+                    stats.sessionsUpdated++;
+                }
+            }
+        });
+        merge();
+    }
+    finally {
+        local.prepare("DETACH DATABASE other").run();
+        fs.rmSync(path.dirname(tmpCopy), { recursive: true, force: true });
+    }
+    return stats;
+}
+// Write a compact single-file snapshot of the database, atomically (tmp +
+// rename), so eventually-consistent file syncers never observe a half-written
+// or WAL-split database.
+export function exportSnapshot(db, outPath) {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    const tmp = `${outPath}.tmp-${process.pid}`;
+    fs.rmSync(tmp, { force: true });
+    db.prepare("VACUUM INTO ?").run(tmp);
+    fs.renameSync(tmp, outPath);
+}
+export function sanitizeHostName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "host";
+}
+// One-command multi-host continuity over any user-synced folder (Drive,
+// Dropbox, Syncthing, a git repo, an rclone mount of S3/Supabase storage...):
+// merge every other host's snapshot, then export ours — so each snapshot also
+// propagates what its host has learned from the others. Each host only ever
+// writes its own <host>.rewound.db: no write conflicts on the sync medium.
+export function syncDir(db, dir, hostName) {
+    const host = sanitizeHostName(hostName ?? os.hostname());
+    const ownSnapshot = `${host}.rewound.db`;
+    fs.mkdirSync(dir, { recursive: true });
+    const stats = { exported: false, snapshotsMerged: 0, sessionsAdded: 0, sessionsUpdated: 0 };
+    const snapshots = fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith(".rewound.db") && f !== ownSnapshot);
+    for (const snap of snapshots) {
+        const m = mergeDb(db, path.join(dir, snap));
+        stats.snapshotsMerged++;
+        stats.sessionsAdded += m.sessionsAdded;
+        stats.sessionsUpdated += m.sessionsUpdated;
+    }
+    exportSnapshot(db, path.join(dir, ownSnapshot));
+    stats.exported = true;
+    return stats;
+}

package/dist/web/layout.js

@@ -333,7 +333,7 @@ export function renderLayout(opts) {
 </head>
 <body>
 <header class="site">
-  <span class="brand">agent<span class="brand-accent">grep</span></span>
+  <span class="brand">re<span class="brand-accent">wound</span></span>
   <nav class="site-nav">${navHtml}</nav>
 </header>
 <main>${opts.body}</main>

package/dist/web/pages/search.js

@@ -1,5 +1,5 @@
 import { escapeHtml, highlightSnippetHtml } from "../html.js";
-import { collapseSnippetWhitespace } from "../../search.js";
+import { collapseSnippetWhitespace, resumeCommand } from "../../search.js";
 const EXAMPLE_QUERIES = ["auth bug", "database migration", "failing test", "refactor", "TODO"];
 function pageQueryString(opts, page) {
     const params = new URLSearchParams();
@@ -58,7 +58,7 @@ function renderHero(opts) {
 function renderHitCard(hit, index) {
     const heading = escapeHtml(hit.title ?? hit.sessionId);
     const sidechainBadge = hit.isSidechain ? `<span class="badge accent">subagent</span>` : "";
-    const resumeCmd = `claude --resume ${hit.sessionId}`;
+    const resumeCmd = resumeCommand(hit.source, hit.sessionId);
     const resumeId = `resume-hit-${index}`;
     return `
 <article class="card hit-card">

package/dist/web/pages/session.js

@@ -1,4 +1,5 @@
 import { escapeHtml } from "../html.js";
+import { resumeCommand } from "../../search.js";
 function renderMessage(m) {
     const sidechainBadge = m.isSidechain ? `<span class="badge accent">subagent</span>` : "";
     const modelBadge = m.model ? `<span class="badge">${escapeHtml(m.model)}</span>` : "";
@@ -28,7 +29,7 @@ export function renderSessionPage(session, messages, pagination) {
     const archivedBadge = session.archived
         ? `<span class="badge accent">archived</span>`
         : "";
-    const resumeCmd = `claude --resume ${session.id}`;
+    const resumeCmd = resumeCommand(session.source, session.id);
     const header = `
 <header class="session-header">
   <h1>${heading} ${archivedBadge}</h1>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rewound",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Grep for everything your AI coding agents ever did. Local SQLite/FTS5 search over Claude Code session transcripts: CLI, MCP server, and web UI.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "David Erner",