combobulator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 combobulate contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# combobulate
+
+Unify local chat memory across **Claude Code**, **Codex**, and **Cursor**.
+
+Each desktop AI coding tool keeps its chat history in its own format on your disk.
+If you ask Codex a question and want to pick the conversation up in Claude Code,
+there's normally no way to do it — no shared history.
+
+`combobulate` is a small macOS daemon that watches each tool's session storage
+and mirrors new chats across the others. Open the same project in any of the
+three tools and you'll see the chats you started elsewhere, with proper titles,
+timestamps, and tool-call rendering native to that tool.
+
+## Install
+
+Requires **Node.js ≥ 22** (uses the built-in `node:sqlite` module) and **macOS**
+(the daemon runs under launchd; Linux is a future port).
+
+```bash
+# from a clone
+git clone https://github.com/<you>/combobulate ~/combobulate
+cd ~/combobulate
+npm install -g .
+combobulate install
+```
+
+Or, once published:
+
+```bash
+npm install -g combobulator   # the npm package name (the `combobulate` bare
+                              # name was already taken on npm — the CLI
+                              # binary is still `combobulate`)
+combobulate install
+```
+
+`combobulate install` writes a launchd plist at
+`~/Library/LaunchAgents/com.combobulate.daemon.plist` and loads it. From now on,
+every new chat in any of the three tools mirrors to the others within ~1.5s, and
+the daemon restarts automatically on every login.
+
+## What works
+
+| Surface | Sync direction | How |
+|---|---|---|
+| Claude Code CLI (`claude /resume`) | read + write | direct file mirror under `~/.claude/projects/` |
+| Claude Code VS Code extension | read + write | same files |
+| Claude Code Cursor extension | read + write | same files |
+| Codex CLI (`codex resume`) | read + write | direct rollout mirror under `~/.codex/sessions/` |
+| Codex Desktop project sidebar | read + write | rollout + `codex app` IPC + `state_5.sqlite` row |
+| Cursor | **read-only** | `state.vscdb` sqlite read |
+| Claude Desktop "Claude Code" tab | not supported | cloud-backed, see Limitations |
+
+## How it works
+
+```
+                   ┌──────────────┐
+   Claude Code ──► │              │ ──► Claude Code
+                   │  combobulate │
+   Codex ────────► │   daemon     │ ──► Codex
+                   │              │
+   Cursor ───────► │  (poll @1.5s)│     Cursor (write deferred)
+                   └──────────────┘
+```
+
+Every 1.5s the daemon scans:
+- `~/.claude/projects/<encoded-cwd>/*.jsonl` — Claude Code sessions
+- `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` — Codex rollouts
+- `~/Library/Application Support/Cursor/.../state.vscdb` — Cursor's chat DB
+  (opened read-only with `mode=ro&immutable=1` so we never contend with the
+  running Cursor process)
+
+For each session newer than the install epoch the daemon:
+
+1. **Normalizes** it into a tool-agnostic typed event stream: real user prompts,
+   assistant text responses, tool calls (with input/output), tool results.
+2. **Detects mirrors** via a `__combobulate_mirror__` marker baked into every file
+   we write, so we never re-mirror our own writes.
+3. **Fingerprints** the message stream — skips if nothing has changed since the
+   last sync. Same source updating? Overwrite the same mirror file in place.
+4. **Emits** to each target tool's native format, including:
+   - Per-turn `task_started` / `turn_context` / `user_message` / `reasoning` /
+     `agent_message` / `task_complete` for Codex (the format Codex Desktop's
+     renderer requires — wrong `phase` values or missing events make messages
+     invisible).
+   - Native `function_call` / `exec_command_end` / `function_call_output`
+     events for tool calls (Bash → `exec_command`, Edit/Write/MultiEdit →
+     `custom_tool_call name=apply_patch` with a unified diff).
+   - Real per-message timestamps so the chat sorts under the date the original
+     conversation happened.
+   - A `[Claude Code]` / `[Codex]` / `[Cursor]` tag prepended to every mirrored
+     thread title so you can see at a glance where a chat came from.
+
+For Codex Desktop specifically, the daemon also:
+- Calls `codex app <cwd>` so the project appears in Codex Desktop's sidebar.
+- Inserts a row into `state_5.sqlite`'s `threads` table with `source='cli'`,
+  non-zero `tokens_used`, and a non-empty `preview` — the threads with all three
+  of those missing get filtered out of Codex Desktop's chat list as "empty drafts".
+
+## Commands
+
+```bash
+combobulate install        # set up the launchd agent, start the daemon
+combobulate uninstall      # remove the launchd agent (state in ~/.combobulate is kept)
+combobulate daemon         # run the watcher in the foreground (used by launchd)
+combobulate status         # quick state summary
+combobulate doctor         # diagnose: daemon, paths, state, recent errors
+combobulate sync           # one-shot mirror pass (doesn't need the daemon)
+   --all                   # ignore the install epoch
+   --since-hours=N         # default 24
+   --limit=N               # max sessions per source, default 20
+   --dry-run               # log what would mirror, write nothing
+combobulate fix-codex-projects
+                           # re-register all mirror cwds with Codex Desktop
+combobulate cleanup        # remove broken Codex thread rows we created
+   --dry-run               # list what would be deleted
+combobulate help
+```
+
+**First-time troubleshooting**: run `combobulate doctor`. If it reports
+problems, the message tells you the exact recovery command.
+
+## Files combobulate touches
+
+| Location | What |
+|---|---|
+| `~/.combobulate/state.json` | mirror tracking (source fingerprint → target ids/paths) |
+| `~/.combobulate/daemon.log` | daemon log |
+| `~/.combobulate/synced/` | fallback cwd for sourceless sessions (Cursor) |
+| `~/Library/LaunchAgents/com.combobulate.daemon.plist` | launchd entry |
+| `~/.claude/projects/<cwd>/<uuid>.jsonl` | mirrored Claude sessions |
+| `~/.claude/history.jsonl` | up-arrow entries prefixed `[Codex]` / `[Cursor]` |
+| `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` | mirrored Codex rollouts |
+| `~/.codex/state_5.sqlite` `threads` table | row per mirror so Codex Desktop renders it |
+| `~/.codex/session_index.jsonl` | thread-index entry |
+| `~/.codex/history.jsonl` | up-arrow entries prefixed `[Claude Code]` / `[Cursor]` |
+| `~/.codex/.codex-global-state.json` | workspace-roots additions (one-time per cwd) |
+
+Every mirrored Claude session has a `__combobulate_mirror__` marker on line 1.
+Every mirrored Codex rollout has it nested at `session_meta.payload.combobulate`.
+That's our loop-prevention key. To wipe all mirrors:
+
+```bash
+combobulate uninstall
+grep -rl __combobulate_mirror__ ~/.claude/projects ~/.codex/sessions | xargs rm
+combobulate cleanup    # remove dangling DB rows (still requires Node 22+)
+rm -rf ~/.combobulate
+```
+
+## Known limitations
+
+- **macOS only.** Daemon runs under launchd; Linux/systemd is a small port.
+- **Cursor is read-only.** Cursor holds its 1.3GB `state.vscdb` open with a
+  write lock while the app is running — injecting writes risks corruption.
+  Cursor → others works fully; others → Cursor needs a Cursor extension that
+  runs in-process.
+- **Claude Desktop's "Claude Code" tab doesn't show synced chats.** That tab
+  is cloud-backed — it lists sessions registered in `bridge-state.json` between
+  a local CLI session and a claude.ai cloud session. Our mirrors are local-only
+  files, so they never get bridged. The Claude Code CLI, the VS Code extension,
+  and the Cursor extension all show synced chats correctly; only the
+  Claude Desktop in-app tab is affected.
+- **Codex Desktop's diff card** under an Edit/Write tool call shows
+  "initialize a git repo" if the cwd isn't a git repo, and otherwise shows
+  no diff if the file is already at the final state on disk. Codex's diff
+  renderer reads the live working tree via `git diff`, not the unified diff
+  embedded in the rollout — this is a Codex design choice.
+- **Tool fidelity isn't 100% across tools.** Claude's `Read`/`Glob`/`Grep`/etc.
+  are translated to Codex `exec_command` with a representative shell command;
+  the surface looks right but the tool semantics don't perfectly match. Edit
+  operations translate cleanly via `apply_patch`.
+
+## Hacking / testing
+
+```bash
+npm test                       # runs test-e2e.mjs + test-daemon.mjs in a tmp HOME
+COMBOBULATE_DEBUG=1 combobulate daemon
+tail -f ~/.combobulate/daemon.log
+```
+
+The architecture (sources, sinks, daemon orchestrator) is documented in code.
+The codex sink in particular has long comments capturing every format detail
+we reverse-engineered the hard way — keep them in sync if Codex's format
+shifts.
+
+## License
+
+MIT.

package/bin/combobulate.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.js';
+main(process.argv.slice(2)).catch((e) => {
+  console.error(e?.stack || e?.message || e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "combobulator",
+  "version": "0.1.0",
+  "description": "Unify local chat memory across Claude Code, Codex, and Cursor — your prompts and assistant replies follow you across tools.",
+  "type": "module",
+  "bin": {
+    "combobulate": "bin/combobulate.js"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "start": "node bin/combobulate.js",
+    "daemon": "node bin/combobulate.js daemon",
+    "test": "node test-e2e.mjs && node test-daemon.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "cursor",
+    "chat-history",
+    "memory",
+    "sync",
+    "cli",
+    "developer-tools"
+  ],
+  "os": ["darwin"],
+  "license": "MIT",
+  "author": "Panchangam18",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Panchangam18/combobulator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Panchangam18/combobulator/issues"
+  },
+  "homepage": "https://github.com/Panchangam18/combobulator#readme"
+}

package/src/cli.js

@@ -0,0 +1,92 @@
+import { install } from './commands/install.js';
+import { uninstall } from './commands/uninstall.js';
+import { status } from './commands/status.js';
+import { sync } from './commands/sync.js';
+import { fixCodexProjects } from './commands/fix-codex-projects.js';
+import { cleanup } from './commands/cleanup.js';
+import { doctor } from './commands/doctor.js';
+import { runDaemon } from './daemon.js';
+
+const HELP = `combobulate — unify chat history across Claude Code, Codex, and Cursor
+
+USAGE
+  combobulate <command> [options]
+
+COMMANDS
+  install           Set up the background daemon (launchd agent on macOS) and
+                    start mirroring new sessions from now on.
+  uninstall         Remove the launchd agent. State at ~/.combobulate is kept.
+  daemon            Run the watcher in the foreground (used by launchd).
+  status            Show what's installed, last mirrored sessions, watched paths.
+  sync [opts]       One-shot mirror pass over recent sessions.
+                    --all                ignore install epoch (mirror anything new-looking)
+                    --since-hours=N      look back N hours (default 24)
+                    --limit=N            max sessions per source (default 20)
+                    --dry-run            log what would be mirrored, write nothing
+  fix-codex-projects
+                    Register every cwd from existing mirrors in Codex Desktop's
+                    workspace list. Called automatically by install; rerun if
+                    Codex stopped surfacing a synced project.
+  cleanup [--dry-run]
+                    Remove broken Codex thread rows we created (source='unknown'
+                    or orphaned). Safe — won't touch your real threads or
+                    rollout files.
+  doctor            Diagnose the setup: daemon, paths, state, recent errors.
+                    Run this first when sync isn't working.
+  help              Show this message.
+
+How it works
+  Daemon polls each tool's session storage every 1.5s. New chats get mirrored
+  to the other tools' native formats: per-turn replay with proper task_started
+  / agent_message / tool calls, real timestamps, and a [Source] tag prepended
+  to the title. Mirrored files are tagged so we never replay our own writes.
+
+  Cursor is read-only — its sqlite chat DB is locked while the app runs.
+  Claude Desktop's "Claude Code" tab is cloud-backed and out of scope; the
+  Claude CLI, VS Code extension, Cursor extension, Codex CLI, and Codex Desktop
+  all see the synced chats. Run \`combobulate doctor\` if something looks off.
+`;
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (const arg of argv) {
+    if (arg.startsWith('--')) {
+      const [k, v] = arg.slice(2).split('=');
+      out[k] = v === undefined ? true : v;
+    } else {
+      out._.push(arg);
+    }
+  }
+  return out;
+}
+
+export async function main(argv) {
+  const args = parseArgs(argv);
+  const cmd = args._[0] || 'help';
+
+  switch (cmd) {
+    case 'install':    return install();
+    case 'uninstall':  return uninstall();
+    case 'daemon':     return runDaemon();
+    case 'status':     return status();
+    case 'fix-codex-projects': return fixCodexProjects();
+    case 'cleanup': return cleanup({ dryRun: !!args['dry-run'] });
+    case 'doctor': return doctor();
+    case 'sync':
+      return sync({
+        all: !!args.all,
+        sinceHours: args['since-hours'] ? Number(args['since-hours']) : 24,
+        limit: args.limit ? Number(args.limit) : 20,
+        dryRun: !!args['dry-run'],
+      });
+    case 'help':
+    case '-h':
+    case '--help':
+      console.log(HELP);
+      return;
+    default:
+      console.error(`unknown command: ${cmd}\n`);
+      console.log(HELP);
+      process.exitCode = 1;
+  }
+}

package/src/codex-registry.js

@@ -0,0 +1,73 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME } from './config.js';
+import { info, warn } from './log.js';
+
+const execFileP = promisify(execFile);
+
+const STATE_FILE = path.join(HOME, '.codex', '.codex-global-state.json');
+
+// Tell Codex Desktop to treat `cwd` as one of its workspace roots so the mirrored
+// chats become visible in the per-cwd sidebar.
+//
+// We discovered the hard way that editing `.codex-global-state.json` directly is
+// unreliable: Codex Desktop caches the file in memory and writes it back on
+// shutdown, clobbering our additions. The correct mechanism is `codex app <path>`
+// — Codex's own CLI command that sends an IPC to the running app to register the
+// workspace (or launch + register if it isn't running). This persists.
+//
+// Side effect: `codex app` focuses Codex Desktop on the registered workspace.
+// We accept that for one-time registration but skip the call entirely if the
+// cwd is already in workspace-roots — so daemon-driven mirroring of an
+// already-tracked cwd doesn't cause focus theft.
+export async function registerCodexWorkspaceRoot(cwd) {
+  if (!cwd || !cwd.startsWith('/')) return false;
+  if (!fs.existsSync(cwd)) return false;
+  if (isAlreadyRegistered(cwd)) return false;
+
+  try {
+    await execFileP('codex', ['app', cwd], { timeout: 8000 });
+    info(`registered Codex workspace root via codex app: ${cwd}`);
+    return true;
+  } catch (e) {
+    warn(`codex app failed for ${cwd}: ${e.message}`);
+    // Fallback: try the direct JSON write. May get overwritten on Codex shutdown,
+    // but better than nothing for fresh installs where Codex isn't running yet.
+    return jsonFallback(cwd);
+  }
+}
+
+function isAlreadyRegistered(cwd) {
+  if (!fs.existsSync(STATE_FILE)) return false;
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    return Array.isArray(state['electron-saved-workspace-roots']) &&
+      state['electron-saved-workspace-roots'].includes(cwd);
+  } catch {
+    return false;
+  }
+}
+
+function jsonFallback(cwd) {
+  if (!fs.existsSync(STATE_FILE)) return false;
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    const roots = state['electron-saved-workspace-roots'];
+    const order = state['project-order'];
+    if (!Array.isArray(roots) || !Array.isArray(order)) return false;
+    let changed = false;
+    if (!roots.includes(cwd)) { roots.push(cwd); changed = true; }
+    if (!order.includes(cwd)) { order.unshift(cwd); changed = true; }
+    if (!changed) return false;
+    const tmp = STATE_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, STATE_FILE);
+    info(`registered Codex workspace root via JSON fallback: ${cwd} (may be overwritten by Codex on shutdown)`);
+    return true;
+  } catch (e) {
+    warn(`JSON fallback failed for ${cwd}: ${e.message}`);
+    return false;
+  }
+}

package/src/codex-thread-db.js

@@ -0,0 +1,72 @@
+import { DatabaseSync } from 'node:sqlite';
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME } from './config.js';
+import { warn } from './log.js';
+
+const DB = path.join(HOME, '.codex', 'state_5.sqlite');
+
+// Insert or replace a row in Codex Desktop's threads table so the mirrored
+// chat is visible in the per-cwd sidebar. The schema is in state_5.sqlite —
+// idx_threads_archived_cwd_updated_at_ms is the index the sidebar queries.
+// The DB is WAL'd, so concurrent writes alongside a running Codex Desktop are
+// safe (SQLite serializes them at the page level).
+export function upsertCodexThread({
+  sessionId,
+  rolloutPath,
+  cwd,
+  title,
+  firstUserMessage,
+  createdAtMs,
+  updatedAtMs,
+  approxTokens,
+}) {
+  if (!fs.existsSync(DB)) return false;
+
+  let db;
+  try {
+    db = new DatabaseSync(DB);
+    // Match Codex's pragmas — WAL with NORMAL synchronous so we don't fsync
+    // every transaction and slow Codex down.
+    db.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;");
+
+    // IMPORTANT: Codex Desktop's chat sidebar filters out threads with
+    //   source='cli' AND tokens_used=0 AND preview=''
+    // (treating them as empty drafts and hiding them). To make mirrored chats
+    // actually show up, we set preview to a snippet of the first user message
+    // and tokens_used to a positive estimate. This matches what Codex itself
+    // writes for "real" threads.
+    const fum = (firstUserMessage || '').slice(0, 2000);
+    const preview = fum ? fum.slice(0, 200) : 'Synced from combobulate';
+    const tokens = Math.max(1, approxTokens || Math.ceil(fum.length / 4));
+
+    const stmt = db.prepare(`
+      INSERT OR REPLACE INTO threads
+        (id, rollout_path, created_at, updated_at, source, model_provider, cwd,
+         title, sandbox_policy, approval_mode, has_user_event, archived,
+         cli_version, first_user_message, memory_mode, preview, tokens_used)
+      VALUES
+        (?, ?, ?, ?, 'cli', 'openai', ?,
+         ?, '{"type":"danger-full-access"}', 'never', 1, 0,
+         '0.1.0', ?, 'enabled', ?, ?)
+    `);
+
+    stmt.run(
+      sessionId,
+      rolloutPath,
+      Math.floor(createdAtMs / 1000),
+      Math.floor(updatedAtMs / 1000),
+      cwd,
+      (title || 'Synced from combobulate').slice(0, 200),
+      fum,
+      preview,
+      tokens,
+    );
+    return true;
+  } catch (e) {
+    warn(`codex threads upsert failed: ${e.message}`);
+    return false;
+  } finally {
+    try { db?.close(); } catch {}
+  }
+}

package/src/commands/cleanup.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { PATHS, HOME, MIRROR_MARKER } from '../config.js';
+import { info, warn } from '../log.js';
+
+const CODEX_DB = path.join(HOME, '.codex', 'state_5.sqlite');
+
+// Sweep any combobulate-authored rows that Codex's app-server has flipped to
+// source='unknown' (typically rollouts written before the format was
+// production-correct), plus orphaned thread rows whose rollout_path no longer
+// exists on disk. Safe to run anytime — only touches combobulate-authored rows.
+//
+// What we DON'T touch: rollout files themselves, claude session files, your
+// own non-mirror Codex threads. If you need a truly clean slate use
+// `combobulate uninstall && rm -rf ~/.combobulate`.
+export async function cleanup({ dryRun = false } = {}) {
+  if (!fs.existsSync(CODEX_DB)) {
+    info('Codex state_5.sqlite not present — nothing to clean up.');
+    return;
+  }
+
+  const db = new DatabaseSync(CODEX_DB);
+  db.exec('PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;');
+
+  // Pull every row that LOOKS like one of ours (we'll confirm by peeking the
+  // rollout file). We can't rely on `source` alone because Codex rewrites it.
+  const rows = db.prepare(`SELECT id, source, rollout_path FROM threads WHERE archived = 0`).all();
+
+  const toDelete = [];
+  let combobulateConfirmed = 0;
+  let orphaned = 0;
+  let unknownSource = 0;
+
+  for (const r of rows) {
+    const isOurs = looksLikeCombobulateRollout(r.rollout_path);
+    const exists = r.rollout_path && fs.existsSync(r.rollout_path);
+
+    if (isOurs) combobulateConfirmed++;
+
+    // Three deletion criteria:
+    //  (a) Our mirror file is gone — orphaned row
+    //  (b) Marked unknown source AND the rollout file is missing too
+    //  (c) Marked unknown source AND the file IS ours (we have a fresh rewrite
+    //      pending and want Codex to re-import from scratch)
+    if (isOurs && !exists) { toDelete.push(r); orphaned++; }
+    else if (r.source === 'unknown' && !exists) { toDelete.push(r); orphaned++; }
+    else if (r.source === 'unknown' && isOurs) { toDelete.push(r); unknownSource++; }
+  }
+
+  info(`scanned ${rows.length} threads.`);
+  info(`  combobulate-authored: ${combobulateConfirmed}`);
+  info(`  to delete: ${toDelete.length} (${orphaned} orphaned, ${unknownSource} unknown-source)`);
+
+  if (!toDelete.length) {
+    db.close();
+    return;
+  }
+
+  if (dryRun) {
+    info('(dry-run) would delete:');
+    for (const r of toDelete.slice(0, 20)) info(`  ${r.id}  source=${r.source}  path=${r.rollout_path}`);
+    if (toDelete.length > 20) info(`  ... and ${toDelete.length - 20} more`);
+    db.close();
+    return;
+  }
+
+  const stmt = db.prepare('DELETE FROM threads WHERE id = ?');
+  for (const r of toDelete) {
+    try { stmt.run(r.id); } catch (e) { warn(`failed to delete ${r.id}: ${e.message}`); }
+  }
+  db.close();
+  info(`deleted ${toDelete.length} row(s).`);
+  info('Restart Codex Desktop to refresh its in-memory chat list.');
+}
+
+// Cheap check: peek the first ~16KB of a rollout file and look for our marker
+// (either the legacy top-level field or the new nested location). Returns
+// false for any file we didn't author.
+function looksLikeCombobulateRollout(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return false;
+  let fd;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(16 * 1024);
+    const n = fs.readSync(fd, buf, 0, buf.length, 0);
+    const lines = buf.subarray(0, n).toString('utf8').split('\n').slice(0, 3);
+    for (const line of lines) {
+      if (!line) continue;
+      let d;
+      try { d = JSON.parse(line); } catch { continue; }
+      if (d[MIRROR_MARKER]) return true;
+      if (d.type === 'session_meta') {
+        if (d.payload?.originator === 'combobulate') return true;
+        if (d.payload?.combobulate?.[MIRROR_MARKER]) return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) try { fs.closeSync(fd); } catch {}
+  }
+}