parallelclaw 1.0.0

package/ingest.js

@@ -0,0 +1,2712 @@
+#!/usr/bin/env node
+/**
+ * memex-sync — long-running daemon that auto-captures Claude Code and
+ * Cowork sessions into memex's inbox in near-realtime.
+ *
+ * CLI usage:
+ *   memex-sync             # run in foreground (debug / launchctl ProgramArguments)
+ *   memex-sync install     # register autostart daemon (macOS LaunchAgent or Linux systemd-user)
+ *   memex-sync uninstall   # stop + remove daemon (data is preserved)
+ *   memex-sync status      # show daemon state, watched files, last activity
+ *   memex-sync logs        # tail -f the daemon log
+ *
+ * Architecture (variant C — hybrid):
+ *   - chokidar (FSEvents on macOS, inotify on Linux) watches the source
+ *     directories for add/change events.
+ *   - Per-file state in ~/.memex/data/ingest-state.json:
+ *       fingerprint (sha1 of first 256 bytes — robust to inode reuse)
+ *       size, mtime, last dialogue count
+ *   - On change: re-parse the full source JSONL, write a dialogue-only
+ *     snapshot to ~/.memex/inbox/<prefix>-<short_id>.jsonl atomically
+ *     (temp + rename). Memex's MCP server picks it up via its existing
+ *     chokidar inbox watcher and imports → memex.db. UNIQUE(msg_id)
+ *     dedupes, so re-emits are idempotent.
+ *   - Backstop: every 30 minutes, walk both source dirs and re-trigger
+ *     processing for any file whose (size, mtime) differs from state.
+ *     Catches FSEvents coalescing during sleep / lid-close.
+ *
+ * Compatible with claude-backup's feed-memex format (same record shape,
+ * same msg_id hash seed: sha1(role|timestamp|text[:200])).
+ */
+
+import chokidar from 'chokidar';
+import Database from 'better-sqlite3';
+import { homedir, platform } from 'node:os';
+import { join, basename, dirname, sep, resolve, relative } from 'node:path';
+import {
+  existsSync, statSync, readFileSync, writeFileSync, renameSync,
+  mkdirSync, openSync, readSync, closeSync, unlinkSync, readdirSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
+import { execSync, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  extractMessageFromRecord,
+  extractCompactBoundary,
+  extractAiTitle,
+} from './lib/parse.js';
+import {
+  defaultCursorDbPath,
+  openCursorDB,
+  iterComposers,
+  extractDialogue,
+  composerToInboxRecords,
+} from './lib/parse-cursor.js';
+import { renderConversationMarkdown, suggestFilename } from './lib/render-markdown.js';
+import {
+  autodetectObsidianVaults,
+  walkVault,
+  parseNote,
+  noteShortId,
+  vaultSlug,
+  shouldSkipPath,
+} from './lib/parse-obsidian.js';
+import { installHook as installSessionStartHook } from './lib/hook/install.js';
+import { createInterface } from 'node:readline';
+import {
+  CONFIG_PATH,
+  KNOWN_SOURCES,
+  loadConfig,
+  saveConfig,
+  isSourceEnabled,
+  setSourceEnabled,
+  obsidianVaultsFromConfig,
+  addObsidianVault,
+  removeObsidianVault,
+  normalizeSourceName,
+} from './lib/config.js';
+
+// -------------------- Paths & config --------------------
+const HOME = homedir();
+const MEMEX_DIR = process.env.MEMEX_DIR || join(HOME, '.memex');
+const INBOX = join(MEMEX_DIR, 'inbox');
+// Staging area for in-flight inbox snapshots. We write the .tmp here and then
+// cross-directory rename into INBOX so server.js's chokidar watcher never sees
+// a partially-written .tmp and races us by importing it (and worse, moving it
+// to archive before our rename completes — the source of the ENOENT noise).
+const STAGING = join(MEMEX_DIR, 'staging');
+const DATA = join(MEMEX_DIR, 'data');
+const STATE_PATH = join(DATA, 'ingest-state.json');
+const LOG_PATH = join(DATA, 'ingest.log');
+const DB_PATH = join(DATA, 'memex.db');
+
+// Daemon metadata — per-platform. macOS uses LaunchAgents (plist),
+// Linux uses systemd user-service. v0.10.14 added Linux support so memex
+// can run on VPSes alongside OpenClaw / Hermes etc.
+const LAUNCH_LABEL = 'com.parallelclaw.memex.sync';
+const LEGACY_LABEL = 'com.parallelclaw.memex.ingest'; // pre-rename, migrated transparently
+const PLIST_PATH = join(HOME, 'Library', 'LaunchAgents', `${LAUNCH_LABEL}.plist`);
+const LEGACY_PLIST_PATH = join(HOME, 'Library', 'LaunchAgents', `${LEGACY_LABEL}.plist`);
+const SYSTEMD_USER_DIR = join(HOME, '.config', 'systemd', 'user');
+const SYSTEMD_SERVICE_NAME = 'memex-sync.service';
+const SYSTEMD_SERVICE_PATH = join(SYSTEMD_USER_DIR, SYSTEMD_SERVICE_NAME);
+
+// Chokidar-watched JSONL roots. Declared here (not below the dispatch
+// block) so CLI subcommands that run BEFORE the daemon body — e.g.
+// `backfill-projects` — can see this binding without tripping TDZ.
+const SOURCES = [
+  {
+    name: 'claude-code',
+    prefix: 'code',
+    dir: join(HOME, '.claude', 'projects'),
+  },
+  {
+    name: 'claude-cowork',
+    prefix: 'cowork',
+    dir: join(HOME, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions'),
+  },
+  // OpenClaw (v0.10.14+): used primarily on VPS deployments where OpenClaw
+  // agents run. Sessions live as flat <uuid>.jsonl files; the watcher filters
+  // out OpenClaw internal state (.checkpoint., .trajectory., .reset., .lock,
+  // trajectory-path, usage-cost-cache) via shouldIngest() below.
+  {
+    name: 'openclaw',
+    prefix: 'openclaw',
+    dir: join(HOME, '.openclaw', 'agents', 'main', 'sessions'),
+  },
+];
+
+// -------------------- Subcommand dispatch --------------------
+const subcommand = process.argv[2];
+if (subcommand && subcommand !== '--help' && subcommand.startsWith('-') === false) {
+  // Run as CLI tool, not as daemon
+  const handlers = {
+    install: cmdInstall,
+    uninstall: cmdUninstall,
+    status: cmdStatus,
+    logs: cmdLogs,
+    restart: cmdRestart,
+    sources: cmdSources,
+    vault: cmdVault,
+    'backfill-projects': cmdBackfillProjects,
+    'backfill-channels': cmdBackfillChannels, // v0.11+
+    'wire-openclaw': cmdWireOpenclaw,         // v0.11.7+
+    // v0.11.11 experimental sync — all gated behind MEMEX_SYNC_EXPERIMENTAL=1
+    'sync-server':  async () => (await import('./lib/sync/cli.js')).cmdSyncServer(),
+    'sync-add':     async () => (await import('./lib/sync/cli.js')).cmdSyncAdd(),
+    'sync-pair':    async () => (await import('./lib/sync/cli.js')).cmdSyncPair(),
+    'sync-list':    async () => (await import('./lib/sync/cli.js')).cmdSyncList(),
+    'sync-remove':  async () => (await import('./lib/sync/cli.js')).cmdSyncRemove(),
+    'sync-run':      async () => (await import('./lib/sync/cli.js')).cmdSyncRun(),
+    'sync-status':   async () => (await import('./lib/sync/cli.js')).cmdSyncStatus(),
+    'sync-schedule': async () => (await import('./lib/sync/cli.js')).cmdSyncSchedule(),
+    // v0.13 lazy-user flow — one-command join + silent-failure watchdog
+    'sync-join':     async () => (await import('./lib/sync/cli.js')).cmdSyncJoin(),
+    'sync-watchdog': async () => (await import('./lib/sync/cli.js')).cmdSyncWatchdog(),
+    // Foreman tracer (v0) — agent-to-agent task ledger (tasks = agent-task messages)
+    'task-delegate': async () => (await import('./lib/tasks.js')).cmdTaskDelegate(),
+    'task-list':     async () => (await import('./lib/tasks.js')).cmdTaskList(),
+    'task-update':   async () => (await import('./lib/tasks.js')).cmdTaskUpdate(),
+    serve: cmdServe, // explicit foreground; same as no-arg
+    // All scan / export modes fall through to module-level logic at EOF.
+    // cmdServe is a no-op marker so the dispatch doesn't error.
+    scan: cmdServe,
+    'scan-claude': cmdServe,
+    'scan-cursor': cmdServe,
+    'scan-obsidian': cmdServe,
+    'export-markdown': cmdServe,
+  };
+  const handler = handlers[subcommand];
+  if (!handler) {
+    console.error(`unknown command: ${subcommand}`);
+    console.error(`usage: memex-sync [install|uninstall|status|logs|serve]`);
+    process.exit(2);
+  }
+
+  // Commands that intentionally fall through to the daemon-mode code at EOF.
+  // For these, the handler is a no-op marker (cmdServe) and the real work is
+  // the module-level scan/watch logic below. Everything NOT in this set is a
+  // pure CLI command that must run to completion and exit BEFORE the daemon
+  // code starts — otherwise the daemon (chokidar watchers + drainDb) races
+  // the command on the shared MEMEX_DIR. That race corrupted sync-* cursor
+  // state on Linux (faster inotify than macOS FSEvents) during testing.
+  const DAEMON_FALLTHROUGH = new Set([
+    'serve', 'scan', 'scan-claude', 'scan-cursor', 'scan-obsidian', 'export-markdown',
+  ]);
+
+  if (DAEMON_FALLTHROUGH.has(subcommand)) {
+    // Kick off the marker handler, then let the module continue into the
+    // daemon-mode code below.
+    Promise.resolve(handler()).catch((e) => {
+      console.error(`error in ${subcommand}: ${e.stack || e.message}`);
+      process.exit(1);
+    });
+  } else {
+    // Pure CLI command — await to completion then exit deterministically,
+    // so the daemon-mode code at EOF never starts for this invocation.
+    // (Handlers may also process.exit() on their own; the await simply
+    // never resolves in that case, which is fine.)
+    try {
+      await handler();
+      process.exit(0);
+    } catch (e) {
+      console.error(`error in ${subcommand}: ${e.stack || e.message}`);
+      process.exit(1);
+    }
+  }
+} else if (subcommand === '--help' || subcommand === '-h') {
+  console.log(`memex-sync — auto-capture daemon for memex memory
+
+daemon mode:
+  memex-sync                    run in foreground (default; same as 'serve')
+  memex-sync install            register autostart daemon (macOS LaunchAgent / Linux systemd-user)
+  memex-sync uninstall          stop and remove daemon (data preserved)
+  memex-sync restart            restart the LaunchAgent (after config changes)
+  memex-sync status             show daemon health, watched files, last activity
+  memex-sync logs               tail the daemon log
+
+maintenance:
+  memex-sync backfill-projects  populate project_path on conversations that
+                                were ingested before this column existed
+                                (Claude Code/Cowork cwd, Obsidian vault root)
+
+openclaw integration:
+  memex-sync wire-openclaw      add memex to ~/.openclaw/openclaw.json
+                                (cfg.mcp.servers.memex) and schedule a
+                                gateway restart so it takes effect.
+                                --json for LLM agents driving install.
+                                --no-auto-restart to skip the restart.
+
+source control:
+  memex-sync sources            list which sources are enabled / disabled
+  memex-sync sources <name> enable
+  memex-sync sources <name> disable
+                                turn on/off a source (claude_code, claude_cowork,
+                                cursor, obsidian). 'code' / 'cowork' aliases work.
+  memex-sync vault              list configured Obsidian vaults
+  memex-sync vault add <path>   add an Obsidian vault to the watched list
+  memex-sync vault remove <p>   remove a vault
+
+one-shot scans (no daemon needed — handy for cron / manual import):
+  memex-sync scan               import everything once
+  memex-sync scan-claude        Claude Code + Cowork only
+  memex-sync scan-cursor        Cursor IDE history only
+  memex-sync scan-obsidian      Obsidian vaults only
+
+export to Obsidian / file system:
+  memex-sync export-markdown --output <dir> [--source <s>] [--since <date>]
+                                bulk-render conversations as Markdown files
+
+paths:
+  state:   ${STATE_PATH}
+  log:     ${LOG_PATH}
+  config:  ${CONFIG_PATH}
+  plist:   ${PLIST_PATH}`);
+  process.exit(0);
+}
+
+// -------------------- CLI command handlers --------------------
+
+// ── Platform-specific daemon installers ─────────────────────────────────────
+
+function installLaunchAgent() {
+  // Migrate legacy plist (pre-rename) if present.
+  if (existsSync(LEGACY_PLIST_PATH)) {
+    console.log('migrating legacy LaunchAgent (com.parallelclaw.memex.ingest → .sync)...');
+    try { execSync(`launchctl unload ${JSON.stringify(LEGACY_PLIST_PATH)}`, { stdio: 'ignore' }); }
+    catch (_) {}
+    try { unlinkSync(LEGACY_PLIST_PATH); } catch (_) {}
+  }
+
+  const nodePath = process.execPath;
+  const scriptPath = resolve(fileURLToPath(import.meta.url));
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ProcessType</key><string>Background</string>
+  <key>LowPriorityIO</key><true/>
+  <key>Nice</key><integer>5</integer>
+  <key>StandardOutPath</key><string>${join(DATA, 'launchd.out.log')}</string>
+  <key>StandardErrorPath</key><string>${join(DATA, 'launchd.err.log')}</string>
+  <key>WorkingDirectory</key><string>${resolve(scriptPath, '..')}</string>
+</dict>
+</plist>
+`;
+
+  mkdirSync(join(HOME, 'Library', 'LaunchAgents'), { recursive: true });
+  // Stop existing instance first (idempotent)
+  try { execSync(`launchctl unload ${JSON.stringify(PLIST_PATH)}`, { stdio: 'ignore' }); }
+  catch (_) {}
+  writeFileSync(PLIST_PATH, plist);
+  try {
+    execSync(`launchctl load ${JSON.stringify(PLIST_PATH)}`, { stdio: 'inherit' });
+  } catch (e) {
+    console.error(`launchctl load failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  console.log(`✓ memex-sync installed and running`);
+  console.log(`  plist: ${PLIST_PATH}`);
+  console.log(`  log:   ${LOG_PATH}`);
+}
+
+function installSystemdUserService() {
+  // Sanity-check: systemd user-instance must be available. On many container
+  // distros (e.g. minimal Docker images) it isn't.
+  try { execSync('systemctl --user --version', { stdio: 'ignore' }); }
+  catch (_) {
+    console.error('systemctl --user not available on this system.');
+    console.error('Either:');
+    console.error('  • Install systemd-user-session (Ubuntu/Debian: it should be on by default),');
+    console.error('  • Or run memex-sync in the foreground: `nohup memex-sync >/tmp/memex.log 2>&1 &`');
+    process.exit(1);
+  }
+
+  const nodePath = process.execPath;
+  const scriptPath = resolve(fileURLToPath(import.meta.url));
+  const workingDir = resolve(scriptPath, '..');
+
+  // ExecStart needs absolute paths. Logs go to ~/.memex/data/ — systemd
+  // doesn't include them in StandardOutput inheritance by default.
+  const unit = `[Unit]
+Description=memex auto-capture daemon
+Documentation=https://memex.parallelclaw.ai
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath}
+WorkingDirectory=${workingDir}
+Restart=on-failure
+RestartSec=10s
+StartLimitIntervalSec=60
+StartLimitBurst=5
+StandardOutput=append:${join(DATA, 'systemd.out.log')}
+StandardError=append:${join(DATA, 'systemd.err.log')}
+# Make sure the daemon's child processes see the right HOME / MEMEX_DIR
+# (systemd-user inherits these from the login session, but be explicit).
+Environment=HOME=${HOME}
+Environment=MEMEX_DIR=${MEMEX_DIR}
+# Low priority — capture is background work, never compete with user processes.
+Nice=5
+IOSchedulingClass=best-effort
+IOSchedulingPriority=7
+
+[Install]
+WantedBy=default.target
+`;
+
+  mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+  // Stop existing instance first (idempotent). Errors are fine — service
+  // might not exist yet on first install.
+  try { execSync(`systemctl --user stop ${SYSTEMD_SERVICE_NAME}`, { stdio: 'ignore' }); } catch (_) {}
+  writeFileSync(SYSTEMD_SERVICE_PATH, unit);
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+    execSync(`systemctl --user enable ${SYSTEMD_SERVICE_NAME}`, { stdio: 'inherit' });
+    execSync(`systemctl --user start ${SYSTEMD_SERVICE_NAME}`, { stdio: 'inherit' });
+  } catch (e) {
+    console.error(`systemctl operation failed: ${e.message}`);
+    console.error(`Service file written at ${SYSTEMD_SERVICE_PATH}.`);
+    console.error('Diagnose with: systemctl --user status ' + SYSTEMD_SERVICE_NAME);
+    process.exit(1);
+  }
+
+  console.log(`✓ memex-sync installed and running (systemd user-service)`);
+  console.log(`  unit:  ${SYSTEMD_SERVICE_PATH}`);
+  console.log(`  log:   ${LOG_PATH}`);
+
+  // Linger: without this, the user-systemd instance dies when the user logs
+  // out of SSH. On a VPS that means daemon stops between SSH sessions. We
+  // try to enable it; if we lack sudo, print a clear next step.
+  const user = process.env.USER || process.env.USERNAME || '';
+  if (user) {
+    try {
+      execSync(`loginctl show-user ${user} -p Linger 2>/dev/null | grep -q Linger=yes`, { stdio: 'ignore' });
+      console.log(`  ✓ linger already enabled — daemon survives SSH logout`);
+    } catch (_) {
+      try {
+        execSync(`loginctl enable-linger ${user}`, { stdio: 'pipe' });
+        console.log(`  ✓ linger enabled — daemon survives SSH logout`);
+      } catch (_) {
+        console.log(`  ⚠ could not enable linger automatically (need sudo).`);
+        console.log(`    Daemon may stop on SSH logout. To fix:`);
+        console.log(`      sudo loginctl enable-linger ${user}`);
+      }
+    }
+  }
+}
+
+async function cmdInstall() {
+  if (platform() === 'darwin') {
+    installLaunchAgent();
+  } else if (platform() === 'linux') {
+    installSystemdUserService();
+  } else {
+    console.error(`install: unsupported platform "${platform()}". Supported: darwin, linux.`);
+    console.error('Workaround for unsupported OS: run `nohup memex-sync &` in your shell.');
+    process.exit(1);
+  }
+  console.log('');
+
+  // ── Auto-context prompt (v0.8+) ─────────────────────────────────────
+  // Bundle Claude Code SessionStart hook install into the same flow
+  // the user is already running. Single [Y/n] beats a separate command
+  // they'd never remember.
+  //
+  // Honor non-interactive flags / env for CI:
+  //   --auto-context yes    explicit opt-in
+  //   --auto-context no     explicit opt-out
+  //   --yes / -y            accept all defaults (yes)
+  //   $MEMEX_AUTO_CONTEXT=yes|no   env override
+  await maybeInstallAutoContextHook();
+
+  // Show what daemon will actually capture, based on current config.
+  const cfg = loadConfig();
+  console.log('memex-sync will capture from these sources:');
+  for (const name of KNOWN_SOURCES) {
+    const enabled = isSourceEnabled(name, cfg);
+    const mark = enabled ? '✓' : '✗';
+    let detail = '';
+    if (name === 'claude_code') {
+      const dir = join(HOME, '.claude', 'projects');
+      detail = existsSync(dir) ? `(${dir})` : '(not found — won\'t capture)';
+    } else if (name === 'claude_cowork') {
+      // Cowork lives under macOS Application Support; doesn't exist on Linux.
+      const dir = join(HOME, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
+      detail = existsSync(dir) ? '(Cowork sessions found)' : '(not found — won\'t capture)';
+    } else if (name === 'cursor') {
+      const dbPath = defaultCursorDbPath();
+      detail = dbPath && existsSync(dbPath) ? '(Cursor detected)' : '(not found — won\'t capture)';
+    } else if (name === 'obsidian') {
+      const vaults = obsidianVaultsFromConfig(cfg);
+      const auto = vaults.length === 0 ? autodetectObsidianVaults() : vaults;
+      detail = auto.length > 0 ? `(${auto.length} vault${auto.length > 1 ? 's' : ''}: ${auto.map((v) => v.replace(HOME, '~')).join(', ')})` : '(no vaults detected)';
+    } else if (name === 'openclaw') {
+      const dir = join(HOME, '.openclaw', 'agents', 'main', 'sessions');
+      detail = existsSync(dir) ? `(${dir})` : '(not found — won\'t capture)';
+    }
+    console.log(`  ${mark} ${name.padEnd(15)} ${detail}`);
+  }
+  console.log('');
+  console.log(`To opt out of any source:`);
+  console.log(`  npx memex-sync sources <name> disable`);
+  console.log(`  npx memex-sync vault remove <path>     (for Obsidian)`);
+  console.log(`Then: npx memex-sync restart`);
+  console.log('');
+  console.log(`config: ${CONFIG_PATH} (auto-created on first edit)`);
+  console.log(`status: npx memex-sync status`);
+
+  // v0.10.15: pre-create memex.db with full schema so post-install
+  // commands (memex overview, memex search) and the post-scan back-fill
+  // flow work IMMEDIATELY — without waiting for the MCP server to spawn
+  // for the first time. On clean machines this was the most-common
+  // first-time confusion: `memex-sync scan` populates ~/.memex/inbox/
+  // but `memex overview` errored with "memex.db not found" until the
+  // user restarted their MCP client. Now the daemon creates an empty
+  // DB at install-time; the MCP server picks up where it left off.
+  try {
+    const { initializeDb } = await import('./lib/db-init.js');
+    const db = initializeDb(DB_PATH);
+    db.close();
+    console.log(`db:     ${DB_PATH} (schema initialised)`);
+  } catch (e) {
+    // Non-fatal — install succeeded; DB just isn't pre-created.
+    console.warn(`warn: could not pre-initialise DB at ${DB_PATH}: ${e.message}`);
+    console.warn(`      (DB will be created on first MCP server start instead)`);
+  }
+
+  // v0.10.13: back-fill any Telegram exports that already exist in
+  // ~/Downloads/Telegram Desktop/. The daemon's chokidar watcher with
+  // ignoreInitial:false SHOULD pick them up, but in practice users hit
+  // race conditions (daemon started before Downloads dir was scanned,
+  // FSEvents lag, etc.) and end up with empty pending despite having
+  // exports on disk (tester-8 case). Doing a one-shot scan here closes
+  // that gap before the user even tries `memex telegram pending`.
+  try {
+    const { discoverExports, defaultDownloadsPaths } = await import('./lib/telegram-discovery.js');
+    const { stageExport, listPending } = await import('./lib/telegram-pending.js');
+    const downloadsPaths = defaultDownloadsPaths();
+    const found = discoverExports(downloadsPaths);
+    if (found.length > 0) {
+      const beforeCount = listPending().length;
+      let staged = 0;
+      for (const f of found) {
+        try {
+          stageExport(f.path, { moveOrCopy: 'copy' });
+          staged++;
+        } catch (_) { /* race with watcher — fine, watcher will pick up */ }
+      }
+      const afterCount = listPending().length;
+      const newly = afterCount - beforeCount;
+      if (newly > 0) {
+        console.log('');
+        console.log(`📬 Found ${found.length} pre-existing Telegram export(s) in Downloads — `);
+        console.log(`   staged ${newly} new into ~/.memex/pending/`);
+        console.log(`   Review: ${'npx memex telegram pending'}`);
+      }
+    }
+  } catch (_) {
+    /* discovery / pending modules optional — skip silently */
+  }
+
+  // v0.10.10: surface the new web dashboard so manual installers actually
+  // discover it. (curl-bash flow has its own [Y/n] prompt in install.sh —
+  // it suppresses this output via `>/dev/null 2>&1`, so this callout is
+  // for the `memex-sync install` direct-call path only.)
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('🌐 NEW in v0.10.8: open your memory in a browser');
+  console.log('');
+  console.log('  memex web --open');
+  console.log('');
+  console.log('5 pages, read-only, localhost-only. Every captured');
+  console.log('conversation, verbatim — not summarized. Ctrl+C to stop.');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  process.exit(0);
+}
+
+// ──────────────────────────────────────────────────────────────────
+// Auto-context hook prompt — bundled into `memex-sync install` so the
+// user doesn't need to remember an extra `memex hook install` step.
+//
+// Decision priority:
+//   1. CLI flag --auto-context=yes|no  (explicit)
+//   2. CLI flag --yes / -y             (accept all defaults: yes)
+//   3. env MEMEX_AUTO_CONTEXT=yes|no    (for CI / scripts)
+//   4. Interactive [Y/n] prompt        (TTY only)
+//   5. Default: SKIP if no TTY (don't hang on stdin in non-TTY contexts)
+async function maybeInstallAutoContextHook() {
+  const argv = process.argv.slice(3); // drop ["node", "ingest.js", "install"]
+
+  // Parse flags
+  let explicit = null; // 'yes' | 'no' | null
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--auto-context') {
+      const v = (argv[++i] || '').toLowerCase();
+      if (v === 'yes' || v === 'y' || v === 'true') explicit = 'yes';
+      else if (v === 'no' || v === 'n' || v === 'false') explicit = 'no';
+    } else if (a === '--auto-context=yes') explicit = 'yes';
+    else if (a === '--auto-context=no') explicit = 'no';
+    else if (a === '--yes' || a === '-y') explicit = 'yes';
+  }
+
+  // Env fallback
+  if (explicit === null) {
+    const env = (process.env.MEMEX_AUTO_CONTEXT || '').toLowerCase();
+    if (env === 'yes' || env === 'y' || env === 'true' || env === '1') explicit = 'yes';
+    else if (env === 'no' || env === 'n' || env === 'false' || env === '0') explicit = 'no';
+  }
+
+  // Interactive prompt as last resort
+  if (explicit === null) {
+    if (!process.stdin.isTTY) {
+      // Non-interactive (CI, scripts, install-skill flows that don't pipe stdin):
+      // skip silently. User can run `memex hook install` later.
+      console.log('Auto-context hook: skipped (non-interactive). Enable with: memex hook install');
+      console.log('');
+      return;
+    }
+    explicit = await promptYesNo(
+      `Auto-context (Brian Chesky mode):\n` +
+      `  When you open Claude Code in a project, memex can inject 500-1500 tokens\n` +
+      `  of relevant context so Claude knows what you were doing — without you\n` +
+      `  having to ask. Adds a SessionStart hook to ~/.claude/settings.json.\n` +
+      `  Other hooks (e.g. gstack) are preserved.\n\n` +
+      `  Enable?`,
+      'yes' // default Y
+    );
+  }
+
+  if (explicit !== 'yes') {
+    console.log('Auto-context hook: skipped. Enable later with: memex hook install');
+    console.log('');
+    return;
+  }
+
+  const r = installSessionStartHook();
+  if (r.error) {
+    console.log(`Auto-context hook: ✗ ${r.error}`);
+    console.log('  (memex-sync daemon still works — only the auto-context hook failed)');
+    console.log('');
+    return;
+  }
+  if (r.alreadyPresent) {
+    console.log('Auto-context hook: already installed (no-op).');
+  } else {
+    console.log('Auto-context hook: ✓ installed.');
+    console.log(`  settings: ${r.settingsPath}`);
+    console.log(`  command:  ${r.command}`);
+    console.log('  Restart Claude Code (Cmd+Q + reopen) to activate.');
+  }
+  console.log('');
+}
+
+function promptYesNo(question, defaultAnswer) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultAnswer === 'yes' ? ' [Y/n] ' : ' [y/N] ';
+    rl.question(question + suffix, (answer) => {
+      rl.close();
+      const v = (answer || '').trim().toLowerCase();
+      if (v === 'y' || v === 'yes') resolve('yes');
+      else if (v === 'n' || v === 'no') resolve('no');
+      else resolve(defaultAnswer); // empty enter → default
+    });
+  });
+}
+
+function cmdUninstall() {
+  let removed = 0;
+  if (platform() === 'darwin') {
+    for (const p of [PLIST_PATH, LEGACY_PLIST_PATH]) {
+      if (existsSync(p)) {
+        try { execSync(`launchctl unload ${JSON.stringify(p)}`, { stdio: 'ignore' }); } catch (_) {}
+        try { unlinkSync(p); removed++; } catch (_) {}
+      }
+    }
+    if (removed > 0) {
+      console.log(`✓ memex-sync uninstalled (${removed} LaunchAgent file${removed > 1 ? 's' : ''} removed)`);
+    } else {
+      console.log(`memex-sync was not installed (nothing to remove).`);
+    }
+  } else if (platform() === 'linux') {
+    if (existsSync(SYSTEMD_SERVICE_PATH)) {
+      try { execSync(`systemctl --user stop ${SYSTEMD_SERVICE_NAME}`, { stdio: 'ignore' }); } catch (_) {}
+      try { execSync(`systemctl --user disable ${SYSTEMD_SERVICE_NAME}`, { stdio: 'ignore' }); } catch (_) {}
+      try { unlinkSync(SYSTEMD_SERVICE_PATH); removed++; } catch (_) {}
+      try { execSync('systemctl --user daemon-reload', { stdio: 'ignore' }); } catch (_) {}
+      console.log(`✓ memex-sync uninstalled (systemd user-service removed)`);
+    } else {
+      console.log(`memex-sync was not installed (no service unit found).`);
+    }
+  } else {
+    console.error(`uninstall: unsupported platform "${platform()}". Supported: darwin, linux.`);
+    process.exit(1);
+  }
+  if (removed > 0) {
+    console.log(`\nMemory database at ~/.memex/data/memex.db is preserved.`);
+    console.log(`To fully purge: rm -rf ~/.memex`);
+  }
+  process.exit(0);
+}
+
+function cmdStatus() {
+  // Discover state + daemon state per-platform
+  const isLinux = platform() === 'linux';
+  const isMac = platform() === 'darwin';
+  const installed = isMac ? existsSync(PLIST_PATH) : isLinux ? existsSync(SYSTEMD_SERVICE_PATH) : false;
+  const legacyInstalled = isMac && existsSync(LEGACY_PLIST_PATH);
+
+  let runningPid = null;
+  if (isMac) {
+    const label = installed ? LAUNCH_LABEL : (legacyInstalled ? LEGACY_LABEL : null);
+    if (label) {
+      try {
+        const out = execSync(`launchctl list | grep ${label}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        const m = out.match(/^(\d+|-)\s+(\d+|-)\s+\S+/m);
+        if (m && m[1] !== '-') runningPid = parseInt(m[1], 10);
+      } catch (_) {}
+    }
+  } else if (isLinux && installed) {
+    try {
+      const out = execSync(`systemctl --user show -p MainPID --value ${SYSTEMD_SERVICE_NAME}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+      const pid = parseInt(out, 10);
+      if (Number.isFinite(pid) && pid > 0) runningPid = pid;
+    } catch (_) {}
+  }
+
+  let state = {};
+  let stateFresh = null;
+  if (existsSync(STATE_PATH)) {
+    try { state = JSON.parse(readFileSync(STATE_PATH, 'utf-8')); }
+    catch (_) {}
+    try {
+      const ageMs = Date.now() - statSync(STATE_PATH).mtimeMs;
+      stateFresh = ageMs;
+    } catch (_) {}
+  }
+  const watchedCount = Object.keys(state).length;
+  let codeCount = 0, coworkCount = 0, cursorCount = 0, cursorEmptyCount = 0,
+      obsidianCount = 0, subagentCount = 0;
+  for (const [p, v] of Object.entries(state)) {
+    if (p.startsWith('cursor::')) {
+      // Cursor creates an empty placeholder composer per "new tab" click.
+      // Distinguish those from real sessions with content.
+      if (v && v.bubbleCount > 0) cursorCount++;
+      else cursorEmptyCount++;
+      continue;
+    }
+    if (v && v.isObsidian) { obsidianCount++; continue; }
+    if (p.endsWith('.md')) { obsidianCount++; continue; }
+    // Subagent transcripts under .../subagents/ are tool-spawned helpers,
+    // not standalone main sessions — count separately for honest reporting.
+    if (p.includes('/subagents/')) { subagentCount++; continue; }
+    // Cowork paths embed `.claude/projects/` too (inside Application Support);
+    // check the cowork-specific marker first.
+    if (p.includes('local-agent-mode-sessions')) coworkCount++;
+    else if (p.includes('/.claude/projects/')) codeCount++;
+  }
+
+  // Output
+  console.log('memex-sync status\n');
+  if (installed) {
+    const path = isLinux ? SYSTEMD_SERVICE_PATH : PLIST_PATH;
+    const kind = isLinux ? 'systemd user-service' : 'LaunchAgent';
+    console.log(`  daemon:    installed (${kind} · ${path})`);
+  } else if (legacyInstalled) {
+    console.log(`  daemon:    installed under legacy label (run 'memex-sync install' to migrate)`);
+  } else {
+    console.log(`  daemon:    NOT installed`);
+    console.log(`             enable autostart with: memex-sync install`);
+  }
+  if (runningPid) {
+    console.log(`  process:   running (PID ${runningPid})`);
+  } else {
+    console.log(`  process:   not running`);
+  }
+  if (watchedCount > 0) {
+    const parts = [];
+    if (codeCount > 0) parts.push(`${codeCount} Claude Code`);
+    if (coworkCount > 0) parts.push(`${coworkCount} Cowork`);
+    if (cursorCount > 0) parts.push(`${cursorCount} Cursor`);
+    if (obsidianCount > 0) parts.push(`${obsidianCount} Obsidian`);
+    const extras = [];
+    if (subagentCount > 0) extras.push(`${subagentCount} subagent transcript${subagentCount === 1 ? '' : 's'}`);
+    if (cursorEmptyCount > 0) extras.push(`${cursorEmptyCount} empty Cursor placeholder${cursorEmptyCount === 1 ? '' : 's'}`);
+    const extrasSuffix = extras.length > 0 ? ` (+ ${extras.join(', ')})` : '';
+    console.log(`  watching:  ${parts.join(' · ')} main session(s)${extrasSuffix} · ${watchedCount} entries total`);
+  } else {
+    console.log(`  watching:  no sessions seen yet`);
+  }
+  if (stateFresh !== null) {
+    const min = Math.floor(stateFresh / 60000);
+    const human = min < 1 ? 'just now' : (min < 60 ? `${min} min ago` : `${Math.floor(min / 60)}h ${min % 60}m ago`);
+    console.log(`  last activity: ${human}`);
+  }
+  console.log('');
+  console.log(`  log:       ${LOG_PATH}`);
+  console.log(`  state:     ${STATE_PATH}`);
+
+  process.exit(0);
+}
+
+function cmdLogs() {
+  if (!existsSync(LOG_PATH)) {
+    console.error(`no log file at ${LOG_PATH} — daemon never started?`);
+    process.exit(1);
+  }
+  // tail -f via spawn
+  const tail = spawn('tail', ['-n', '50', '-f', LOG_PATH], { stdio: 'inherit' });
+  process.on('SIGINT', () => { tail.kill('SIGINT'); process.exit(0); });
+  tail.on('exit', (code) => process.exit(code || 0));
+}
+
+function cmdServe() {
+  // Fall through to the daemon body below
+}
+
+function cmdRestart() {
+  if (platform() === 'darwin') {
+    if (!existsSync(PLIST_PATH)) {
+      console.error('memex-sync is not installed (no LaunchAgent plist found).');
+      console.error('Run: npx memex-sync install');
+      process.exit(1);
+    }
+    try { execSync(`launchctl unload ${JSON.stringify(PLIST_PATH)}`, { stdio: 'ignore' }); } catch (_) {}
+    try {
+      execSync(`launchctl load ${JSON.stringify(PLIST_PATH)}`, { stdio: 'ignore' });
+    } catch (e) {
+      console.error('launchctl load failed:', e.message);
+      process.exit(1);
+    }
+  } else if (platform() === 'linux') {
+    if (!existsSync(SYSTEMD_SERVICE_PATH)) {
+      console.error('memex-sync is not installed (no systemd unit found).');
+      console.error('Run: npx memex-sync install');
+      process.exit(1);
+    }
+    try {
+      execSync(`systemctl --user restart ${SYSTEMD_SERVICE_NAME}`, { stdio: 'inherit' });
+    } catch (e) {
+      console.error('systemctl restart failed:', e.message);
+      process.exit(1);
+    }
+  } else {
+    console.error(`restart: unsupported platform "${platform()}". Supported: darwin, linux.`);
+    process.exit(1);
+  }
+  console.log(`✓ memex-sync restarted`);
+  process.exit(0);
+}
+
+// ──────────────────────────────────────────────────────────────────
+// v0.11.7: `memex-sync wire-openclaw` — one-shot OpenClaw setup
+//
+// Adds memex to ~/.openclaw/openclaw.json (correct nested key
+// cfg.mcp.servers.memex — the older cfg.mcpServers is silently
+// ignored by OpenClaw 2026.5+'s MCP runtime adapter) and, by
+// default, schedules a delayed self-restart of the OpenClaw gateway
+// so the new MCP server takes effect without the user touching a
+// terminal — same pattern memex-hermes `setup --auto-restart` uses.
+//
+// Designed for the lazy-install flow off memex.parallelclaw.ai/openclaw:
+// the OpenClaw LLM agent pastes a URL, sees this command in the
+// instructions, runs it, schedules a restart, dies during it, comes
+// back online in the next session with memex_search in its toolset.
+// Terminal-only users (most Telegram-bot OpenClaw deployments)
+// never have to do anything else.
+//
+// JSON output for agents: status, next_action, agent_instructions,
+// restart.{method,command,auto_restart,delay_seconds,log_path}.
+// ──────────────────────────────────────────────────────────────────
+
+function _wireOpenclawConfig({ configPath, force = false, memexBin = null }) {
+  // Returns { action, memex_bin, cleaned_stale, warning?, existing_command? }
+  if (!existsSync(configPath)) {
+    return { action: 'config_missing', warning: `not found: ${configPath}` };
+  }
+  let raw;
+  try { raw = readFileSync(configPath, 'utf8'); }
+  catch (e) { return { action: 'read_failed', warning: e.message }; }
+  let cfg;
+  try { cfg = JSON.parse(raw); }
+  catch (e) { return { action: 'parse_failed', warning: e.message }; }
+
+  if (!memexBin) {
+    // Resolve `memex` via PATH the same way the user's shell would.
+    try {
+      const out = execSync('command -v memex', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+      memexBin = out.trim() || null;
+    } catch (_) { memexBin = null; }
+  }
+  if (!memexBin) {
+    return {
+      action: 'memex_missing',
+      warning: 'memex binary not on PATH — install parallelclaw first (npm i -g parallelclaw)',
+    };
+  }
+
+  // Clean any stale top-level mcpServers.memex (pre-v3 skill versions wrote there).
+  let cleanedStale = false;
+  if (cfg.mcpServers && typeof cfg.mcpServers === 'object' && cfg.mcpServers.memex) {
+    delete cfg.mcpServers.memex;
+    cleanedStale = true;
+    if (Object.keys(cfg.mcpServers).length === 0) delete cfg.mcpServers;
+  }
+
+  cfg.mcp = cfg.mcp || {};
+  cfg.mcp.servers = cfg.mcp.servers || {};
+  const existing = cfg.mcp.servers.memex;
+  const desired = { command: memexBin, args: [], env: {} };
+  const changed = !existing
+    || existing.command !== desired.command
+    || JSON.stringify(existing.args || []) !== JSON.stringify(desired.args)
+    || JSON.stringify(existing.env || {}) !== JSON.stringify(desired.env);
+
+  if (existing && existing.command && existing.command !== memexBin && !force) {
+    return {
+      action: 'conflict',
+      memex_bin: memexBin,
+      existing_command: existing.command,
+      cleaned_stale: cleanedStale,
+      warning: `mcp.servers.memex already points to "${existing.command}". `
+             + `Refusing to overwrite without --force.`,
+    };
+  }
+
+  // Actually set the entry. (Bug fix during initial smoke — without this
+  // line the cfg object got rewritten to disk without our addition.)
+  cfg.mcp.servers.memex = desired;
+
+  if (changed || cleanedStale) {
+    // Backup before we write, so a wrong --force is recoverable.
+    try {
+      const ts = new Date().toISOString().replace(/[:.]/g, '-');
+      writeFileSync(`${configPath}.before-wire-openclaw-${ts}`, raw, 'utf8');
+    } catch (_) { /* non-fatal */ }
+    try {
+      writeFileSync(configPath, JSON.stringify(cfg, null, 2), 'utf8');
+    } catch (e) {
+      return { action: 'write_failed', memex_bin: memexBin, warning: e.message };
+    }
+  }
+
+  return {
+    action: changed ? 'wired' : 'already_correct',
+    memex_bin: memexBin,
+    cleaned_stale: cleanedStale,
+  };
+}
+
+function _which(name) {
+  try {
+    const out = execSync(`command -v ${JSON.stringify(name)}`, {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out.trim() || null;
+  } catch { return null; }
+}
+
+function _tryCmd(file, args, timeoutMs = 3000) {
+  try {
+    const stdout = execSync(`${file} ${args.map((a) => JSON.stringify(a)).join(' ')}`, {
+      timeout: timeoutMs,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return { ok: true, stdout: String(stdout || '') };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function _detectOpenclawRestart() {
+  if (_which('systemctl')) {
+    for (const probe of [
+      { scope: '--user', method: 'systemd-user' },
+      { scope: null,     method: 'systemd-system' },
+    ]) {
+      for (const unit of ['openclaw', 'openclaw-gateway']) {
+        const args = ['is-active'];
+        if (probe.scope) args.unshift(probe.scope);
+        args.push(unit);
+        const r = _tryCmd('systemctl', args);
+        if (r.ok && r.stdout.trim() === 'active') {
+          return {
+            method: probe.method,
+            command: probe.scope ? `systemctl --user restart ${unit}` : `sudo systemctl restart ${unit}`,
+            detail: `systemd unit '${unit}' active`,
+          };
+        }
+      }
+    }
+  }
+  if (platform() === 'darwin' && _which('launchctl')) {
+    const r = _tryCmd('launchctl', ['list']);
+    if (r.ok) {
+      for (const line of r.stdout.split('\n')) {
+        if (/openclaw/i.test(line)) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 3) {
+            const label = parts[parts.length - 1];
+            return {
+              method: 'launchd',
+              command: `launchctl kickstart -k gui/$(id -u)/${label}`,
+              detail: `launchd label '${label}'`,
+            };
+          }
+        }
+      }
+    }
+  }
+  if (_which('pgrep')) {
+    const r = _tryCmd('pgrep', ['-f', 'openclaw']);
+    if (r.ok && r.stdout.trim()) {
+      const pids = r.stdout.trim().split(/\s+/).filter(Boolean);
+      return {
+        method: 'pkill',
+        command: 'pkill -HUP -f openclaw',
+        detail: `openclaw process(es): ${pids.slice(0, 4).join(',')}`,
+      };
+    }
+  }
+  return { method: 'manual', command: '', detail: '' };
+}
+
+function _scheduleSelfRestart(restartCommand, { delaySeconds = 3, logPath = '/tmp/memex-openclaw-restart.log' } = {}) {
+  if (!restartCommand || !String(restartCommand).trim()) {
+    return { scheduled: false, error: 'empty restart_command' };
+  }
+  const delay = Math.max(1, parseInt(delaySeconds, 10) || 3);
+  const shellScript =
+    `(echo '--- memex wire-openclaw auto-restart '"$(date -Iseconds)"' ---' >> ${logPath}; ` +
+    `sleep ${delay}; ` +
+    `echo 'restart_command: ${restartCommand}' >> ${logPath}; ` +
+    `${restartCommand} >> ${logPath} 2>&1; ` +
+    `echo "rc=$?" >> ${logPath})`;
+  try {
+    const child = spawn('/bin/sh', ['-c', shellScript], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    return { scheduled: true, delaySeconds: delay, logPath };
+  } catch (err) {
+    return { scheduled: false, error: err.message };
+  }
+}
+
+function _formatAgentInstructions(report) {
+  const lines = [];
+  const mcp = report.mcp || {};
+  if (mcp.action === 'wired') {
+    lines.push(
+      'I wired memex as an MCP server in ~/.openclaw/openclaw.json so the '
+      + 'LLM can search your memory from inside conversations.',
+    );
+    // Pin a URL-handling tip into the install reply. The install agent is
+    // about to die from the restart anyway, but if it relays this to the
+    // user, the user sees what to expect from future sessions. (The same
+    // knowledge lives in SERVER_INSTRUCTIONS top-of-file + memex_help, so
+    // post-restart agents pick it up natively.)
+    lines.push(
+      'Tip for future sessions: when you (or any next OpenClaw agent) sees a '
+      + 'URL the user wants to read or save — Perplexity, npm.com, X/Twitter, '
+      + 'Medium, AI-chat shares — DO NOT lead with browser_navigate or naked '
+      + 'curl. Most modern pages are Cloudflare-protected. The reliable recipe: '
+      + '`curl -H "Accept: text/markdown" https://r.jina.ai/https://<original-url>` '
+      + '(keep the `https://` after r.jina.ai/, NOT http://; add the Accept '
+      + 'header for clean markdown). For Perplexity, the URL in the address bar '
+      + 'is the owner\'s private one — only the Share→Public link is fetchable. '
+      + 'Call memex_help anytime for the full cheat-sheet.',
+    );
+  } else if (mcp.action === 'already_correct') {
+    lines.push('Your OpenClaw config already had memex wired correctly — nothing to do.');
+  } else if (mcp.action === 'conflict') {
+    lines.push(`⚠️ ${mcp.warning}`);
+  } else if (mcp.action === 'memex_missing') {
+    lines.push(`⚠️ ${mcp.warning}`);
+  } else if (mcp.warning) {
+    lines.push(`⚠️ ${mcp.warning}`);
+  }
+
+  // v0.11.8: only mention restart if there's ACTUALLY a reason to restart.
+  // When status='already_in_sync' the config wasn't touched — restarting is
+  // a no-op and would mislead the user that something needs activating.
+  // Same for failed/partial: don't suggest restart, the user has bigger
+  // problems to deal with first.
+  const r = report.restart || {};
+  const restartActionable = report.status === 'ready';
+  if (restartActionable) {
+    if (r.auto_restart === 'scheduled') {
+      lines.push(
+        `I'm restarting the OpenClaw gateway in ${r.delay_seconds} seconds — `
+        + `send me any message after that and memex search will be active in the new session.`,
+      );
+    } else if (r.auto_restart === 'opt_out') {
+      if (r.command) {
+        lines.push(`Restart skipped (--no-auto-restart). Run \`${r.command}\` when ready.`);
+      } else {
+        lines.push(`Restart skipped (--no-auto-restart). You'll need to restart the OpenClaw gateway manually.`);
+      }
+    } else if (r.method === 'manual') {
+      lines.push(
+        `I couldn't auto-detect how OpenClaw is running on this host. `
+        + `Tell me "restart yourself" if you want me to try \`pkill -HUP -f openclaw\`, `
+        + `or ask your server admin to restart the gateway.`,
+      );
+    } else if (r.auto_restart === 'failed') {
+      lines.push(`⚠️ Auto-restart failed: ${r.error || 'unknown'}. Run \`${r.command || 'openclaw gateway restart'}\` manually.`);
+    }
+  }
+  return lines.join(' ');
+}
+
+function _printHumanWireSummary(report) {
+  console.log('');
+  console.log('────────────────────────────────────────────────────────────');
+  console.log('  memex wire-openclaw');
+  console.log('────────────────────────────────────────────────────────────');
+  const mcp = report.mcp || {};
+  if (mcp.action === 'wired') {
+    console.log(`🔌 MCP server:         wired memex → ${mcp.memex_bin}`);
+    if (mcp.cleaned_stale) console.log('                       (also cleaned stale top-level mcpServers.memex)');
+  } else if (mcp.action === 'already_correct') {
+    console.log('🔌 MCP server:         already correct (no change)');
+  } else {
+    console.log(`🔌 MCP server:         ⚠️ ${mcp.warning || mcp.action}`);
+  }
+
+  // v0.11.8: only print restart info when there's actually a reason to
+  // restart. status='already_in_sync' → config didn't change → restarting
+  // would be a no-op; misleading to ask the user to run it.
+  const r = report.restart || {};
+  const restartActionable = report.status === 'ready';
+  if (restartActionable) {
+    if (r.auto_restart === 'scheduled') {
+      console.log(`🔄 Auto-restart:       scheduled in ${r.delay_seconds}s (${r.method} — ${r.command})`);
+      console.log(`                       log: ${r.log_path}`);
+      console.log('');
+      console.log('💬 After restart, send OpenClaw any message — memex search will be active.');
+    } else if (r.method === 'manual') {
+      console.log('🔄 Restart needed:     could not auto-detect mechanism');
+      console.log('                       Ask the OpenClaw agent to "restart yourself", or restart manually.');
+    } else if (r.auto_restart === 'opt_out') {
+      console.log(`🔄 Restart needed:     ${r.command} (auto-restart skipped per flag)`);
+    } else if (r.command) {
+      console.log(`🔄 Restart needed:     ${r.command}`);
+    }
+  } else if (report.status === 'already_in_sync') {
+    console.log('✓ No restart needed — config was already correct.');
+  }
+  console.log('');
+}
+
+function cmdWireOpenclaw() {
+  // Parse flags from argv (slice past 'wire-openclaw' subcommand)
+  const args = process.argv.slice(3);
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const eat = () => args[++i];
+    switch (a) {
+      case '--json':            opts.json = true; break;
+      case '--auto-restart':    opts.autoRestart = true; break;
+      case '--no-auto-restart': opts.noAutoRestart = true; break;
+      case '--force':           opts.force = true; break;
+      case '--restart-delay':   opts.restartDelay = parseInt(eat(), 10) || 3; break;
+      case '--config':          opts.configPath = eat(); break;
+      case '--memex-bin':       opts.memexBin = eat(); break;
+      case '-h':
+      case '--help':
+        console.log(`memex-sync wire-openclaw — wire memex into ~/.openclaw/openclaw.json + schedule restart
+
+Adds memex to cfg.mcp.servers (correct nested key) so the OpenClaw LLM gets
+memex_search + friends. By default, also schedules a self-restart of the
+gateway in 3 seconds so the new MCP server takes effect without the user
+touching a terminal.
+
+flags:
+  --json                       machine-parseable JSON output for LLM agents
+  --no-auto-restart            wire only; don't trigger restart
+  --force                      overwrite a conflicting mcp.servers.memex entry
+  --restart-delay <seconds>    seconds to wait before triggering restart (default 3)
+  --config <path>              override ~/.openclaw/openclaw.json
+  --memex-bin <path>           override \`which memex\` lookup
+
+exit codes:
+  0   ready / already_in_sync
+  1   partial (memex missing, conflict — review the report)
+  2   failed (can't read/write openclaw.json — manual intervention)
+`);
+        process.exit(0);
+    }
+  }
+
+  const configPath = opts.configPath || join(homedir(), '.openclaw', 'openclaw.json');
+  const report = { config_path: configPath, mcp: {}, restart: {} };
+
+  // Step 1: wire config
+  report.mcp = _wireOpenclawConfig({
+    configPath,
+    force: !!opts.force,
+    memexBin: opts.memexBin,
+  });
+
+  // Step 2: detect restart mechanism
+  const detected = _detectOpenclawRestart();
+  report.restart.method = detected.method;
+  report.restart.command = detected.command;
+  report.restart.detail = detected.detail;
+
+  // Step 3: decide auto-restart
+  // Default: try auto-restart UNLESS --no-auto-restart was passed AND we
+  // succeeded in wiring something (no point restarting if config is broken)
+  const wiredOk = report.mcp.action === 'wired' || report.mcp.action === 'already_correct';
+  if (opts.noAutoRestart) {
+    report.restart.auto_restart = 'opt_out';
+  } else if (!wiredOk) {
+    // Don't restart if wire failed — no benefit
+    report.restart.auto_restart = 'skipped_wire_failed';
+  } else if (detected.method === 'manual' || !detected.command) {
+    report.restart.auto_restart = 'unavailable';
+  } else {
+    const sched = _scheduleSelfRestart(detected.command, {
+      delaySeconds: opts.restartDelay || 3,
+    });
+    if (sched.scheduled) {
+      report.restart.auto_restart = 'scheduled';
+      report.restart.delay_seconds = sched.delaySeconds;
+      report.restart.log_path = sched.logPath;
+    } else {
+      report.restart.auto_restart = 'failed';
+      report.restart.error = sched.error;
+    }
+  }
+
+  // Step 4: overall status + next_action
+  if (report.mcp.action === 'config_missing' || report.mcp.action === 'parse_failed'
+      || report.mcp.action === 'read_failed' || report.mcp.action === 'write_failed') {
+    report.status = 'failed';
+    report.next_action = 'manual_intervention';
+  } else if (report.mcp.action === 'memex_missing') {
+    report.status = 'partial';
+    report.next_action = 'install_memex_mvp';
+  } else if (report.mcp.action === 'conflict') {
+    report.status = 'partial';
+    report.next_action = 'use_force_or_resolve_conflict';
+  } else if (report.mcp.action === 'wired') {
+    report.status = 'ready';
+    report.next_action = report.restart.auto_restart === 'scheduled'
+      ? 'wait_for_restart' : 'restart_required';
+  } else {
+    report.status = 'already_in_sync';
+    report.next_action = report.restart.auto_restart === 'scheduled'
+      ? 'wait_for_restart' : 'none';
+  }
+
+  report.agent_instructions = _formatAgentInstructions(report);
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+  } else {
+    _printHumanWireSummary(report);
+  }
+
+  // Exit code maps to status for shell-friendly use.
+  if (report.status === 'failed') process.exit(2);
+  if (report.status === 'partial') process.exit(1);
+  process.exit(0);
+}
+
+function cmdSources() {
+  const action = process.argv[3];
+  const target = process.argv[4];
+  const cfg = loadConfig();
+
+  if (!action || action === 'list' || action === '--list') {
+    // Pretty status table
+    console.log(`memex-sync sources (config: ${CONFIG_PATH})\n`);
+    for (const name of KNOWN_SOURCES) {
+      const enabled = isSourceEnabled(name, cfg);
+      const mark = enabled ? '✓' : '✗';
+      const label = name.padEnd(15);
+      let extra = '';
+      if (name === 'obsidian') {
+        const vaults = obsidianVaultsFromConfig(cfg);
+        if (vaults.length > 0) extra = `· vaults: ${vaults.join(', ')}`;
+        else if (enabled) extra = '· vaults: (autodetect)';
+      }
+      console.log(`  ${mark} ${label} ${enabled ? 'enabled' : 'disabled'}  ${extra}`);
+    }
+    console.log(`\n  · telegram      manual-import only (drop result.json into ~/.memex/inbox/)`);
+    console.log('\nuse: memex-sync sources <name> <enable|disable>');
+    process.exit(0);
+  }
+
+  // memex-sync sources <name> <enable|disable>
+  const sourceName = normalizeSourceName(action);
+  const verb = target;
+  if (!sourceName) {
+    console.error(`unknown source: "${action}". Known: ${KNOWN_SOURCES.join(', ')} (or aliases code/cowork).`);
+    process.exit(2);
+  }
+  if (verb !== 'enable' && verb !== 'disable') {
+    console.error(`expected 'enable' or 'disable' as third arg.`);
+    console.error(`usage: memex-sync sources ${sourceName} <enable|disable>`);
+    process.exit(2);
+  }
+  setSourceEnabled(sourceName, verb === 'enable', cfg);
+  saveConfig(cfg);
+  console.log(`✓ ${sourceName} ${verb}d (saved to ${CONFIG_PATH})`);
+  // Hint for restart if daemon installed
+  if (existsSync(PLIST_PATH)) {
+    console.log(`\nrestart the daemon to apply: npx memex-sync restart`);
+  }
+  process.exit(0);
+}
+
+function cmdVault() {
+  const action = process.argv[3];
+  const target = process.argv[4];
+  const cfg = loadConfig();
+
+  if (!action || action === 'list' || action === '--list') {
+    const vaults = obsidianVaultsFromConfig(cfg);
+    if (vaults.length === 0) {
+      console.log('no Obsidian vaults configured.');
+      console.log('Without explicit configuration, autodetect runs against standard');
+      console.log('locations (~/Documents, ~/Obsidian, ~/Library/Mobile Documents/');
+      console.log('iCloud~md~obsidian/Documents) when the daemon starts.');
+      console.log('\nadd one with: memex-sync vault add <path>');
+    } else {
+      console.log('configured Obsidian vaults:');
+      for (const v of vaults) console.log(`  · ${v}`);
+    }
+    process.exit(0);
+  }
+
+  if (action === 'add') {
+    if (!target) {
+      console.error('expected a path: memex-sync vault add /path/to/vault');
+      process.exit(2);
+    }
+    const abs = addObsidianVault(target, cfg);
+    if (!existsSync(abs)) {
+      console.error(`warning: ${abs} doesn't exist yet — config saved anyway.`);
+    } else if (!existsSync(join(abs, '.obsidian'))) {
+      console.error(`warning: ${abs} doesn't look like an Obsidian vault (no .obsidian/ subfolder).`);
+    }
+    saveConfig(cfg);
+    console.log(`✓ added ${abs}`);
+    if (existsSync(PLIST_PATH)) {
+      console.log(`\nrestart the daemon to apply: npx memex-sync restart`);
+    }
+    process.exit(0);
+  }
+
+  if (action === 'remove' || action === 'rm') {
+    if (!target) {
+      console.error('expected a path: memex-sync vault remove /path/to/vault');
+      process.exit(2);
+    }
+    const removed = removeObsidianVault(target, cfg);
+    if (!removed) {
+      console.log(`no vault matching "${target}" was configured.`);
+      process.exit(1);
+    }
+    saveConfig(cfg);
+    console.log(`✓ removed ${target}`);
+    if (existsSync(PLIST_PATH)) {
+      console.log(`\nrestart the daemon to apply: npx memex-sync restart`);
+    }
+    process.exit(0);
+  }
+
+  console.error(`unknown action: "${action}". Use list / add / remove.`);
+  process.exit(2);
+}
+
+/**
+ * Backfill project_path on conversations that were ingested before the
+ * column existed. Walks the on-disk source directories (Claude Code,
+ * Cowork, Obsidian via memex-sync's state file), extracts the project
+ * path for each session, and UPDATEs the matching memex.db row.
+ *
+ * One-shot, idempotent: only fills rows where project_path is NULL/empty,
+ * so re-running won't clobber values set by the live ingest path or a
+ * prior backfill.
+ *
+ * Cursor: not backfilled (no workspace path captured by the current
+ * parser). Telegram: skipped by design — chats have no project concept.
+ */
+// v0.11+ — re-parse archived OpenClaw files into channel-aware conversations.
+// Old (pre-0.11) data sat in `openclaw-openclaw-<file8>` convs with mixed
+// channels; this command deletes those and re-imports each archive file via
+// the new ingestOpenclawJsonl, which splits per channel/sender.
+async function cmdBackfillChannels() {
+  const archiveOpenclawDir = join(MEMEX_DIR, 'archive', 'openclaw');
+  if (!existsSync(archiveOpenclawDir)) {
+    console.log('No OpenClaw archive found at ' + archiveOpenclawDir);
+    console.log('Nothing to back-fill. (Run the daemon for a while first.)');
+    process.exit(0);
+  }
+  const dbPath = join(MEMEX_DIR, 'data', 'memex.db');
+  if (!existsSync(dbPath)) {
+    console.error('memex.db not found at ' + dbPath + ' — install first.');
+    process.exit(1);
+  }
+
+  const files = readdirSync(archiveOpenclawDir).filter((n) => n.endsWith('.jsonl'));
+  if (files.length === 0) {
+    console.log('No .jsonl files in ' + archiveOpenclawDir + '. Nothing to do.');
+    process.exit(0);
+  }
+
+  const { initializeDb } = await import('./lib/db-init.js');
+  const { ingestFile } = await import('./lib/ingest-file.js');
+  const channelMod = await import('./lib/openclaw-channel.js');
+  const db = initializeDb(dbPath);
+  db.pragma('busy_timeout = 5000');
+
+  // v0.11.2: --mode flag for users who want to override auto-detection.
+  // 'auto' (default) - per-file detection via sessions.json
+  // 'kimi-claw'      - assume merged-file Moonshot deployment (ingest checkpoints)
+  // 'self-hosted'    - assume separate-file deployment (skip checkpoints)
+  const modeIdx = process.argv.findIndex((a) => a === '--mode');
+  let mode = 'auto';
+  if (modeIdx >= 0 && process.argv[modeIdx + 1]) {
+    const v = process.argv[modeIdx + 1];
+    if (['auto', 'kimi-claw', 'self-hosted'].includes(v)) mode = v;
+    else {
+      console.error(`Invalid --mode value: ${v}. Use: auto | kimi-claw | self-hosted`);
+      process.exit(1);
+    }
+  }
+
+  // Count current openclaw rows (informational + safety check)
+  const before = db.prepare("SELECT COUNT(*) AS n FROM messages WHERE source = 'openclaw'").get().n;
+  const beforeConvs = db.prepare("SELECT COUNT(*) AS n FROM conversations WHERE source = 'openclaw'").get().n;
+
+  // Pre-scan: categorise files + probe session type so the banner
+  // tells the user upfront what we'll skip.
+  const checkpoints = files.filter((n) => channelMod.isCheckpointFile(n));
+  const resets = files.filter((n) => channelMod.isResetFile(n));
+  const mainFiles = files.filter(
+    (n) => !channelMod.isCheckpointFile(n) && !channelMod.isResetFile(n),
+  );
+  let detectedMode = mode;
+  if (mode === 'auto' && mainFiles.length > 0) {
+    const probePath = join(archiveOpenclawDir, mainFiles[0]);
+    const sessionsJsonPath = channelMod.findSessionsJson(probePath);
+    const channelMap = sessionsJsonPath
+      ? channelMod.loadSessionsJsonChannelMap(sessionsJsonPath)
+      : new Map();
+    let kimi = 0, hosted = 0, unknown = 0;
+    for (const n of mainFiles) {
+      const t = channelMod.detectSessionType(join(archiveOpenclawDir, n), channelMap);
+      if (t === 'kimi-claw') kimi++;
+      else if (t === 'self-hosted') hosted++;
+      else unknown++;
+    }
+    if (kimi > hosted) detectedMode = 'kimi-claw';
+    else if (hosted > 0) detectedMode = 'self-hosted';
+    else detectedMode = 'unknown (treating as self-hosted)';
+  }
+
+  console.log(
+    `Backfill: ${files.length} archived OpenClaw file(s) ` +
+    `(${mainFiles.length} main + ${checkpoints.length} checkpoint + ${resets.length} reset)`,
+  );
+  console.log(`  mode:          ${mode}${mode === 'auto' ? ` -> detected: ${detectedMode}` : ''}`);
+  console.log(`  current state: ${before} messages in ${beforeConvs} conversation(s)`);
+  if (mode !== 'kimi-claw' && detectedMode !== 'kimi-claw' && checkpoints.length > 0) {
+    console.log(`  ${checkpoints.length} checkpoint file(s) will be SKIPPED ` +
+                `(snapshots - avoid 30-40x duplication). Override: --mode kimi-claw`);
+  }
+  if (resets.length > 0) {
+    console.log(`  ${resets.length} reset file(s) will be ingested ` +
+                `(full archives of pre-reset session history).`);
+  }
+  console.log('');
+
+  const yesFlag = process.argv.includes('--yes') || process.argv.includes('-y');
+  if (!yesFlag && before > 0) {
+    console.log('This will DELETE current `source = openclaw` rows in messages + conversations');
+    console.log('and re-import each archived file with channel-aware splitting.');
+    console.log('');
+    console.log('Re-run with `--yes` to proceed:');
+    console.log('  memex-sync backfill-channels --yes');
+    process.exit(0);
+  }
+
+  // Wipe existing openclaw data — re-import will repopulate with proper channel routing.
+  db.exec("DELETE FROM messages WHERE source = 'openclaw'");
+  db.exec("DELETE FROM conversations WHERE source = 'openclaw'");
+
+  let imported = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (let i = 0; i < files.length; i++) {
+    const filePath = join(archiveOpenclawDir, files[i]);
+    process.stdout.write(`  [${i + 1}/${files.length}] ${files[i]}... `);
+    try {
+      const r = await ingestFile(db, filePath, {
+        format: 'openclaw-jsonl',
+        force: true,
+        mode, // 'auto' | 'kimi-claw' | 'self-hosted'
+      });
+      if (r.status === 'imported') {
+        imported += r.total_imported || 0;
+        process.stdout.write(`${r.total_imported || 0} msgs into ${r.conversations?.length || 0} conv(s)\n`);
+      } else if (r.status === 'skipped') {
+        skipped++;
+        process.stdout.write(`SKIP (${r.reason || ''})\n`);
+      } else {
+        failed++;
+        process.stdout.write(`FAIL (${r.status}: ${r.error || ''})\n`);
+      }
+    } catch (e) {
+      failed++;
+      process.stdout.write(`ERROR (${e.message})\n`);
+    }
+  }
+
+  const after = db.prepare("SELECT COUNT(*) AS n FROM messages WHERE source = 'openclaw'").get().n;
+  const afterConvs = db.prepare("SELECT COUNT(*) AS n FROM conversations WHERE source = 'openclaw'").get().n;
+  const channels = db.prepare(`
+    SELECT channel, COUNT(*) AS n FROM messages
+    WHERE source = 'openclaw' AND channel IS NOT NULL
+    GROUP BY channel ORDER BY n DESC
+  `).all();
+
+  console.log('');
+  console.log('Done.');
+  console.log(`  before: ${before} msgs / ${beforeConvs} convs`);
+  console.log(`  after:  ${after} msgs / ${afterConvs} convs (${skipped} skipped, ${failed} failed)`);
+  if (channels.length > 0) {
+    console.log('  channels:');
+    for (const c of channels) console.log(`    • ${c.channel}: ${c.n} msgs`);
+  }
+  const nullChannel = db.prepare("SELECT COUNT(*) AS n FROM messages WHERE source='openclaw' AND channel IS NULL").get().n;
+  if (nullChannel > 0) {
+    console.log(`    • (no channel): ${nullChannel} msgs   ${''}(records where text didn't match a known marker)${''}`);
+  }
+
+  db.close();
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+function cmdBackfillProjects() {
+  const dbPath = join(MEMEX_DIR, 'data', 'memex.db');
+  if (!existsSync(dbPath)) {
+    console.error(`memex.db not found at ${dbPath} — nothing to backfill yet.`);
+    process.exit(1);
+  }
+  const db = new Database(dbPath);
+  // Coexist with the running MCP server (also WAL) — wait up to 5s on
+  // contention rather than failing the whole backfill on a single SQLITE_BUSY.
+  db.pragma('busy_timeout = 5000');
+  const update = db.prepare(
+    `UPDATE conversations SET project_path = ?
+      WHERE conversation_id = ?
+        AND (project_path IS NULL OR project_path = '')`
+  );
+  const updateTx = db.transaction((items) => {
+    let n = 0;
+    for (const it of items) n += update.run(it.path, it.convId).changes;
+    return n;
+  });
+
+  let scanned = 0;
+  const pending = [];
+
+  // --- Claude Code + Cowork ---
+  for (const source of SOURCES) {
+    if (!existsSync(source.dir)) {
+      console.log(`- skipping ${source.name}: directory not found at ${source.dir}`);
+      continue;
+    }
+    console.log(`scanning ${source.name}: ${source.dir}`);
+    walkDir(source.dir, (p) => {
+      if (!shouldIngest(p)) return;
+      scanned++;
+      const inboxName = inboxNameFor(p, source);
+      if (!inboxName) return;
+      const stem = basename(inboxName, '.jsonl');
+      const convId = `${source.name}-${stem}`;
+      const cwd = readFirstCwd(p);
+      if (!cwd) return;
+      pending.push({ convId, path: cwd });
+    });
+  }
+
+  // --- Obsidian ---
+  // The memex-sync state file maps note path → { vault, ... }. That's the
+  // only place we recorded the vault root after import; rebuilding it from
+  // scratch would require autodetecting vaults again, which can miss
+  // user-configured ones. State-file-driven backfill is precise.
+  if (existsSync(STATE_PATH)) {
+    let state = {};
+    try { state = JSON.parse(readFileSync(STATE_PATH, 'utf-8')); }
+    catch (_) {}
+    let obsCount = 0;
+    for (const [notePath, v] of Object.entries(state)) {
+      if (!v || !v.vault) continue;
+      if (!notePath.endsWith('.md')) continue;
+      obsCount++;
+      const rel = relative(v.vault, notePath);
+      const slug = vaultSlug(v.vault);
+      const short = noteShortId(v.vault, rel);
+      const convId = `obsidian-obsidian-${slug}-${short}`;
+      pending.push({ convId, path: v.vault });
+    }
+    if (obsCount > 0) console.log(`scanning obsidian state: ${obsCount} note(s)`);
+  }
+
+  const updated = updateTx(pending);
+  db.close();
+
+  console.log('');
+  console.log(`scanned ${scanned} session file(s) · queued ${pending.length} update(s) · ${updated} row(s) updated`);
+  if (pending.length > updated) {
+    const skipped = pending.length - updated;
+    console.log(`(${skipped} skipped: conversation row missing OR project_path already set)`);
+  }
+  process.exit(0);
+}
+
+/**
+ * Read the first non-empty `cwd` field from a Claude Code / Cowork JSONL
+ * file. Sessions don't change cwd mid-conversation in practice, so first
+ * hit wins. Reads only the first 64 KB to avoid loading multi-megabyte
+ * transcripts — cwd lands on the very first system event in every sample
+ * we've inspected.
+ */
+function readFirstCwd(filePath) {
+  let fd;
+  try {
+    fd = openSync(filePath, 'r');
+    const buf = Buffer.alloc(64 * 1024);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    const text = buf.subarray(0, n).toString('utf-8');
+    // The last chunk-line may be truncated — drop it.
+    const lines = text.split('\n');
+    if (lines.length > 1) lines.pop();
+    for (const line of lines) {
+      if (!line) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch (_) { continue; }
+      if (obj && typeof obj.cwd === 'string' && obj.cwd.trim()) return obj.cwd.trim();
+    }
+    return null;
+  } catch (_) {
+    return null;
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch (_) {}
+  }
+}
+
+
+const RESCAN_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+const DEBOUNCE_MS = 1500;
+
+[INBOX, STAGING, DATA].forEach((d) => mkdirSync(d, { recursive: true }));
+
+// -------------------- Config --------------------
+// Loaded once at module init; CLI subcommands that mutate config exit immediately
+// before the daemon body runs, so the daemon always uses the latest on-disk state.
+const CONFIG = loadConfig();
+
+// -------------------- State --------------------
+let state = {};
+if (existsSync(STATE_PATH)) {
+  try { state = JSON.parse(readFileSync(STATE_PATH, 'utf-8')); }
+  catch (_) { state = {}; }
+}
+
+function saveState() {
+  // v0.11.2: ensure ~/.memex/data/ exists before writing the tmp file.
+  // On a fresh box where memex-sync runs before the MCP server has ever
+  // opened the DB, the data/ dir doesn't exist yet — writeFileSync
+  // would succeed nowhere (or fail), and the subsequent renameSync
+  // crashed with ENOENT on Linux. Discovered by a self-hosted OpenClaw
+  // tester running install-memex-claw on Ubuntu 24.04.
+  mkdirSync(DATA, { recursive: true });
+  const tmp = STATE_PATH + '.tmp';
+  writeFileSync(tmp, JSON.stringify(state, null, 2));
+  renameSync(tmp, STATE_PATH);
+}
+
+// -------------------- Logging --------------------
+import { appendFileSync } from 'node:fs';
+function log(...args) {
+  const line = `[${new Date().toISOString()}] ${args.map(String).join(' ')}\n`;
+  process.stderr.write(line);
+  try { appendFileSync(LOG_PATH, line); } catch (_) {}
+}
+
+// -------------------- Fingerprint --------------------
+function fingerprint(filePath) {
+  let fd;
+  try {
+    fd = openSync(filePath, 'r');
+    const buf = Buffer.alloc(256);
+    const n = readSync(fd, buf, 0, 256, 0);
+    return createHash('sha1').update(buf.subarray(0, n)).digest('hex').slice(0, 16);
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch (_) {}
+  }
+}
+
+// -------------------- File filter --------------------
+function shouldIngest(filePath) {
+  const name = basename(filePath);
+  // v0.11.5: reset files on self-hosted OpenClaw have a SURPRISING format
+  // discovered live —
+  //   "<uuid>.jsonl.reset.<ISO-timestamp>"
+  //   e.g. "722c711b-….jsonl.reset.2026-05-05T19-37-01.833Z"
+  // Note: the file does NOT end in .jsonl (it ends in the timestamp's
+  // millisecond tail like ".833Z"). v0.11.4's first-line check
+  // `endsWith('.jsonl')` silently rejected these, making the rest of the
+  // v0.11.4 "now we ingest resets" logic dead code. Fix: let .reset.
+  // files through even without the .jsonl tail — the staging pipeline
+  // adds .jsonl in inboxNameFor() so downstream parsers still see a
+  // clean JSONL file.
+  if (!filePath.endsWith('.jsonl') && !/\.reset\./.test(name)) return false;
+  if (name === 'audit.jsonl') return false; // tool-call audit log, not dialogue
+  // OpenClaw v0.10.14+ — its sessions dir holds internal state files alongside
+  // the dialogue .jsonl. Filter the noise:
+  //   <uuid>.trajectory.jsonl     ← agent reasoning trace, not dialogue
+  //   trajectory-path*            ← execution paths
+  //   usage-cost-cache            ← billing cache
+  //   *.lock                      ← file locks
+  //
+  // INGEST these dialogue-bearing files:
+  //   <uuid>.jsonl                       — main live session
+  //   <uuid>.checkpoint.<chkpt>.jsonl    — periodic snapshot of current session
+  //   <uuid>.jsonl.reset.<timestamp>     — FULL ARCHIVE of session before reset
+  //                                        (note: ISO timestamp suffix, not .jsonl).
+  //                                        Critical for self-hosted OpenClaw:
+  //                                        on long-running deployments the main
+  //                                        Telegram chat lives ONLY in 30+
+  //                                        .checkpoint files plus 1+ .reset files
+  //                                        (~140 MB of full conversation history,
+  //                                        ~3.2K user messages deduplicated).
+  if (/\.trajectory\./.test(name)) return false;
+  if (name.includes('trajectory-path')) return false;
+  if (name.includes('usage-cost-cache')) return false;
+  return true;
+}
+
+/**
+ * Decide what inbox filename to use for a given source file.
+ *
+ * Cowork main session:
+ *   .../local_<MAIN>/.claude/projects/<encoded>/<INNER>.jsonl
+ *   → inbox/cowork-<INNER first 8>.jsonl
+ *
+ * Cowork subagent (parented to a main session):
+ *   .../local_<MAIN>/.claude/projects/<encoded>/<INNER>/subagents/agent-<AGENT>.jsonl
+ *   → inbox/cowork-<INNER first 8>-sub-<AGENT first 8>.jsonl
+ *
+ * Plain Claude Code session:
+ *   ~/.claude/projects/<encoded>/<UUID>.jsonl
+ *   → inbox/code-<UUID first 8>.jsonl
+ */
+function inboxNameFor(srcPath, source) {
+  // OpenClaw — sessions live at flat <uuid>.jsonl. Background-channel
+  // messages (Telegram while agent busy on main session) land in sibling
+  // <base>.checkpoint.<chkpt>.jsonl files. v0.10.17+ ingests both forms.
+  // Each produces a SEPARATE inbox-name (and thus a separate
+  // conversation_id downstream) — these are conceptually different
+  // threads (Telegram-channel vs Kimi-web-channel) even though they
+  // share a base session uuid. Channel-aware routing (Telegram →
+  // openclaw-tg-<sender>, Kimi → openclaw-kimi-<base8>, system →
+  // openclaw-sys-<base8>) is implemented in v0.11 inside
+  // lib/ingest-file.js → ingestOpenclawJsonl.
+  if (source.name === 'openclaw') {
+    const stem = basename(srcPath, '.jsonl');
+    // Checkpoint pattern: <base-uuid>.checkpoint.<chkpt-uuid>
+    const mC = stem.match(/^([0-9a-f]+(?:-[0-9a-f]+)*)\.checkpoint\.([0-9a-f]+(?:-[0-9a-f]+)*)$/i);
+    if (mC) {
+      const base = mC[1].replace(/-/g, '').slice(0, 8);
+      const chkpt = mC[2].replace(/-/g, '').slice(0, 8);
+      return `${source.prefix}-${base}-ckpt-${chkpt}.jsonl`;
+    }
+    // Reset pattern (v0.11.5): real production format on self-hosted is
+    //   <base-uuid>.jsonl.reset.<ISO-timestamp>
+    // e.g. "722c711b-….jsonl.reset.2026-05-05T19-37-01.833Z"
+    // The reset-suffix is a timestamp (NOT a uuid as we initially
+    // guessed). It contains dots, dashes, colons stripped/converted —
+    // hash it into a stable 8-hex short id so the inbox name follows
+    // our `-reset-<8hex>` convention.
+    //
+    // Note: `basename(p, '.jsonl')` only strips `.jsonl` at the END.
+    // For reset files (ending in `.833Z`) it strips nothing, so the
+    // stem still contains `.jsonl` in the middle — the optional
+    // `(?:\.jsonl)?` in the regex matches that.
+    const mR = basename(srcPath).match(/^([0-9a-f]+(?:-[0-9a-f]+)*)(?:\.jsonl)?\.reset\.(.+)$/i);
+    if (mR) {
+      const base = mR[1].replace(/-/g, '').slice(0, 8);
+      const resetId = createHash('sha1').update(mR[2]).digest('hex').slice(0, 8);
+      return `${source.prefix}-${base}-reset-${resetId}.jsonl`;
+    }
+    // Plain main-session file
+    return `${source.prefix}-${stem.replace(/-/g, '').slice(0, 8)}.jsonl`;
+  }
+  const parts = srcPath.split(sep);
+  const subIdx = parts.indexOf('subagents');
+  if (subIdx > 0) {
+    // Subagent transcript. Parent inner UUID is the dir containing subagents/.
+    const innerUUID = parts[subIdx - 1];
+    const innerShort = innerUUID.slice(0, 8);
+    const agentName = basename(srcPath, '.jsonl'); // 'agent-<...>'
+    const m = agentName.match(/^agent-(.+)$/);
+    if (!m) return null;
+    // Strip non-alphanumerics (handles names like 'agent-acompact-d7a9...').
+    const agentShort = m[1].replace(/[^a-zA-Z0-9]/g, '').slice(0, 8);
+    return `${source.prefix}-${innerShort}-sub-${agentShort}.jsonl`;
+  }
+  // Main session — use file stem.
+  const stem = basename(srcPath, '.jsonl');
+  const shortId = stem.slice(0, 8);
+  return `${source.prefix}-${shortId}.jsonl`;
+}
+
+// -------------------- Codepoint-aware slice --------------------
+// Match Python's text[:n] codepoint indexing so msg_id hashes line up
+// with claude-backup's feed-memex output.
+function slicePy(text, n) {
+  return [...text].slice(0, n).join('');
+}
+
+// -------------------- Parse + emit --------------------
+function parseFileForDialogue(filePath) {
+  const lines = readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+  let aiTitle = null;
+  // Claude Code / Cowork write `cwd` (absolute project directory) on most
+  // top-level records. First non-empty value wins — sessions don't change
+  // cwd mid-conversation in practice, and the first record is usually the
+  // initialisation event that carries it.
+  let projectPath = null;
+  const dialogue = [];
+  // /compact (auto or manual) writes a `compact_boundary` system record into
+  // the JSONL — we forward it to the inbox as its own record type so memex
+  // can persist boundary markers AND skip the synthetic summary turn from
+  // FTS indexing. See lib/parse.js extractCompactBoundary for shape details.
+  const boundaries = [];
+  for (const line of lines) {
+    let obj;
+    try { obj = JSON.parse(line); } catch (_) { continue; }
+    if (!projectPath && obj && typeof obj.cwd === 'string' && obj.cwd.trim()) {
+      projectPath = obj.cwd.trim();
+    }
+    const t = extractAiTitle(obj);
+    if (t) { aiTitle = t; continue; }
+    const boundary = extractCompactBoundary(obj);
+    if (boundary) { boundaries.push(boundary); continue; }
+    const msg = extractMessageFromRecord(obj);
+    if (!msg) continue;
+    // 'summary' = compaction-summary turn (extractMessageFromRecord re-tags
+    // isCompactSummary:true records). Forward it so memex can store it with
+    // role='summary' for transcript reconstruction; FTS trigger excludes it.
+    if (msg.role !== 'user' && msg.role !== 'assistant' && msg.role !== 'summary') continue;
+    dialogue.push(msg);
+  }
+  return { aiTitle, projectPath, dialogue, boundaries };
+}
+
+function emitToInbox(srcPath, source) {
+  let stat;
+  try { stat = statSync(srcPath); }
+  catch (_) { return { changed: false }; }
+  if (!stat.isFile() || stat.size === 0) return { changed: false };
+
+  let fp;
+  try { fp = fingerprint(srcPath); }
+  catch (e) { return { error: 'fingerprint: ' + e.message }; }
+
+  // Cache hit: same content as last time → skip.
+  const prev = state[srcPath];
+  if (
+    prev &&
+    prev.fingerprint === fp &&
+    prev.size === stat.size &&
+    prev.mtime === stat.mtimeMs
+  ) {
+    return { changed: false };
+  }
+
+  const inboxName = inboxNameFor(srcPath, source);
+  if (!inboxName) return { error: 'cannot-name' };
+  const targetPath = join(INBOX, inboxName);
+  // Write tmp into STAGING (sibling dir on the same filesystem) so the inbox
+  // watcher in server.js never sees it. Cross-dir rename stays atomic.
+  const tmpPath = join(STAGING, inboxName + '.tmp');
+  // Reuse first 8 chars of the inbox stem for record-id seeding.
+  const shortId = inboxName.replace(new RegExp(`^${source.prefix}-`), '').replace(/\.jsonl$/, '');
+
+  let parsed;
+  try { parsed = parseFileForDialogue(srcPath); }
+  catch (e) { return { error: 'parse: ' + e.message }; }
+
+  const records = [];
+  if (parsed.aiTitle) {
+    records.push({ type: 'ai-title', aiTitle: parsed.aiTitle });
+  }
+  if (parsed.projectPath) {
+    records.push({ type: 'project-path', projectPath: parsed.projectPath });
+  }
+  for (const b of parsed.boundaries) {
+    // Seed the synthetic id off the source uuid so re-emits collide via
+    // the messages UNIQUE(source, conv, msg_id) index. Falls back to
+    // timestamp if uuid is somehow absent (defensive — Claude Code always
+    // writes one on real compact_boundary records).
+    const seed = `compact-boundary|${b.uuid || b.timestamp || ''}`;
+    const msgId = createHash('sha1').update(seed).digest('hex').slice(0, 16);
+    records.push({
+      type: 'compact-boundary',
+      timestamp: b.timestamp,
+      uuid: b.uuid || null,
+      parentUuid: b.parentUuid || null,
+      logicalParentUuid: b.logicalParentUuid || null,
+      metadata: b.metadata || {},
+      id: `${source.prefix}-${shortId}-${msgId}`,
+    });
+  }
+  for (const m of parsed.dialogue) {
+    const seed = `${m.role}|${m.timestamp}|${slicePy(m.text, 200)}`;
+    const msgId = createHash('sha1').update(seed).digest('hex').slice(0, 16);
+    records.push({
+      role: m.role,
+      content: m.text,
+      timestamp: m.timestamp,
+      // Pass uuid/parentUuid through so server.js can stitch cross-file
+      // continuation chains (new JSONL after /compact references the
+      // previous file's last uuid). Stays null for sources that don't
+      // emit uuids (Cursor, Obsidian, Telegram).
+      uuid: m.uuid || null,
+      parentUuid: m.parentUuid || null,
+      id: `${source.prefix}-${shortId}-${msgId}`,
+    });
+  }
+
+  // Update state regardless — so we don't keep retrying empty files.
+  state[srcPath] = {
+    fingerprint: fp,
+    size: stat.size,
+    mtime: stat.mtimeMs,
+    dialogueCount: parsed.dialogue.length,
+    boundaryCount: parsed.boundaries.length,
+  };
+
+  if (records.length === 0) {
+    saveState();
+    return { changed: false };
+  }
+
+  try {
+    writeFileSync(tmpPath, records.map((r) => JSON.stringify(r)).join('\n') + '\n');
+    renameSync(tmpPath, targetPath);
+  } catch (e) {
+    try { unlinkSync(tmpPath); } catch (_) {}
+    return { error: 'write: ' + e.message };
+  }
+
+  saveState();
+  return { changed: true, msgCount: parsed.dialogue.length, hadTitle: !!parsed.aiTitle };
+}
+
+// -------------------- Debounce --------------------
+const pending = new Map();
+function schedule(srcPath, source) {
+  if (!shouldIngest(srcPath)) return;
+  if (pending.has(srcPath)) clearTimeout(pending.get(srcPath));
+  pending.set(srcPath, setTimeout(() => {
+    pending.delete(srcPath);
+    const r = emitToInbox(srcPath, source);
+    if (r.error) {
+      log(`! ${basename(srcPath)} (${source.name}): ${r.error}`);
+    } else if (r.changed) {
+      const inboxName = inboxNameFor(srcPath, source) || basename(srcPath);
+      const isSubagent = inboxName.includes('-sub-');
+      log(`+ ${inboxName} ← ${r.msgCount} msgs from ${source.name}` +
+          (isSubagent ? ' [subagent]' : '') +
+          (r.hadTitle ? ' (with ai-title)' : ''));
+    }
+  }, DEBOUNCE_MS));
+}
+
+// -------------------- Watchers --------------------
+// In any one-shot scan mode the watchers and timers are skipped; the scan
+// runs at the end of the file and exits. See the conditional block at EOF.
+const SCAN_CURSOR_MODE   = subcommand === 'scan-cursor';
+const SCAN_CLAUDE_MODE   = subcommand === 'scan-claude';
+const SCAN_OBSIDIAN_MODE = subcommand === 'scan-obsidian';
+const SCAN_ALL_MODE      = subcommand === 'scan';
+const EXPORT_MD_MODE     = subcommand === 'export-markdown';
+const ANY_SCAN_MODE = SCAN_CURSOR_MODE || SCAN_CLAUDE_MODE || SCAN_OBSIDIAN_MODE || SCAN_ALL_MODE;
+const ANY_ONESHOT_MODE = ANY_SCAN_MODE || EXPORT_MD_MODE;
+
+const watchers = [];
+// Per-source enablement check. SOURCES is the FSEvents-watched JSONL set
+// (Claude Code + Cowork); each maps to a config key.
+const SOURCE_TO_CONFIG_KEY = {
+  'claude-code': 'claude_code',
+  'claude-cowork': 'claude_cowork',
+  'openclaw': 'openclaw',
+};
+function isJsonlSourceEnabled(source) {
+  const key = SOURCE_TO_CONFIG_KEY[source.name] || source.name;
+  return isSourceEnabled(key, CONFIG);
+}
+if (!ANY_ONESHOT_MODE) for (const source of SOURCES) {
+  if (!isJsonlSourceEnabled(source)) { log(`- ${source.name} disabled by config — skipping`); continue; }
+  if (!existsSync(source.dir)) {
+    log(`- skipping ${source.name}: directory not found at ${source.dir}`);
+    continue;
+  }
+  log(`watching ${source.name}: ${source.dir}`);
+  const w = chokidar
+    .watch(source.dir, {
+      ignoreInitial: false,
+      awaitWriteFinish: { stabilityThreshold: 1000, pollInterval: 200 },
+      depth: 12,
+    })
+    .on('add', (p) => schedule(p, source))
+    .on('change', (p) => schedule(p, source))
+    .on('error', (e) => log(`watcher error (${source.name}): ${e.message}`));
+  watchers.push(w);
+}
+
+// -------------------- Backstop rescan --------------------
+function walkDir(dir, visit) {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); }
+  catch (_) { return; }
+  for (const e of entries) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walkDir(p, visit);
+    else if (e.isFile()) visit(p);
+  }
+}
+
+function safetyRescan() {
+  log('safety rescan starting');
+  let triggered = 0;
+  for (const source of SOURCES) {
+    if (!existsSync(source.dir)) continue;
+    walkDir(source.dir, (p) => {
+      if (!shouldIngest(p)) return;
+      let stat;
+      try { stat = statSync(p); } catch (_) { return; }
+      const prev = state[p];
+      if (!prev || prev.size !== stat.size || prev.mtime !== stat.mtimeMs) {
+        schedule(p, source);
+        triggered++;
+      }
+    });
+  }
+  log(`safety rescan done · ${triggered} file(s) re-scheduled`);
+}
+if (!ANY_ONESHOT_MODE) setInterval(safetyRescan, RESCAN_INTERVAL_MS);
+
+// -------------------- Inbox-drainer (v0.10.16+) --------------------
+//
+// Closes a long-standing UX trap: with the old two-stage pipeline
+// (daemon → inbox → MCP server → DB), DB freshness depended on the MCP
+// server being ALIVE. When the user's MCP client (Claude Code / OpenClaw
+// gateway) wasn't running, inbox accumulated and `memex overview` /
+// `memex search` returned stale data — even though the daemon was
+// happily writing inbox every few seconds.
+//
+// Fix: daemon ALSO drains inbox into the DB itself, every 10 seconds.
+// This way DB is always at-most ~10s behind the live source, regardless
+// of MCP-server lifecycle. Inbox files are processed via the shared
+// lib/ingest-file.js ingestFile() (handles all formats correctly:
+// claude-jsonl / cowork-jsonl / openclaw-jsonl / telegram-json /
+// telegram-html). After a successful ingest the file is moved to
+// ~/.memex/archive/<source>/ — same destination server.js's inbox
+// watcher would use. UNIQUE(source, conversation_id, msg_id) makes
+// the operation idempotent so a still-running MCP server (or two
+// daemons in some weird setup) can't double-import.
+
+const DRAIN_INTERVAL_MS = 10 * 1000; // 10 seconds
+let drainDb = null;
+
+function archiveForInboxName(name) {
+  let source = 'claude-code';
+  if (name.startsWith('cowork-')) source = 'claude-cowork';
+  else if (name.startsWith('cursor-')) source = 'cursor';
+  else if (name.startsWith('obsidian-')) source = 'obsidian';
+  else if (name.startsWith('openclaw-')) source = 'openclaw';
+  return join(MEMEX_DIR, 'archive', source, name);
+}
+
+async function drainInbox() {
+  if (!drainDb) return;
+  let entries;
+  try { entries = readdirSync(INBOX); }
+  catch (_) { return; }
+  let imported = 0;
+  let archived = 0;
+  for (const name of entries) {
+    if (name.startsWith('.')) continue; // hidden
+    if (!name.endsWith('.jsonl')) continue; // only inbox snapshots
+    const path = join(INBOX, name);
+    let stat;
+    try { stat = statSync(path); }
+    catch (_) { continue; }
+    if (!stat.isFile() || stat.size === 0) continue;
+
+    try {
+      const { ingestFile } = await import('./lib/ingest-file.js');
+      const r = await ingestFile(drainDb, path, { format: 'auto', force: true });
+      if (r.status === 'imported') {
+        imported += r.total_imported || 0;
+        // Move to archive, same destination as server.js's inbox watcher
+        const target = archiveForInboxName(name);
+        try {
+          mkdirSync(dirname(target), { recursive: true });
+          renameSync(path, target);
+          archived++;
+        } catch (_) {
+          // archive failed (e.g. file locked) — leave it; next cycle retries
+        }
+      }
+      // Non-'imported' statuses ('needs_consent' / 'skipped' / 'error') — leave file
+      // in inbox so MCP-server / next drain can decide. Telegram-needs-consent
+      // exports are handled by the separate ~/.memex/pending/ flow, not this
+      // path, so they shouldn't appear here.
+    } catch (_) {
+      // dynamic import error — skip this cycle, will retry
+      return;
+    }
+  }
+  if (archived > 0) {
+    log(`drained ${archived} inbox file(s) → DB · ${imported} new row(s)`);
+  }
+}
+
+if (!ANY_ONESHOT_MODE) {
+  // Open shared writable DB handle for the inbox-drainer + future
+  // change_log writes (Stage B sync). Failure is non-fatal — daemon
+  // still writes inbox; the MCP server will drain it on next start.
+  (async () => {
+    try {
+      const { initializeDb } = await import('./lib/db-init.js');
+      drainDb = initializeDb(DB_PATH);
+      log(`drainDb opened (${DB_PATH}) — inbox→DB every ${DRAIN_INTERVAL_MS / 1000}s`);
+    } catch (e) {
+      log(`could not open drainDb: ${e.message} — inbox-drain disabled`);
+    }
+  })();
+  setInterval(drainInbox, DRAIN_INTERVAL_MS);
+}
+
+// -------------------- Cursor scanner --------------------
+// Cursor stores history in SQLite (state.vscdb), not flat files. We can't
+// usefully chokidar-watch it because the WAL journal flips on every keystroke
+// and the main file mtime is unreliable. So instead: poll the DB every few
+// minutes, compare each composer's lastUpdatedAt against state, and re-emit
+// inbox JSONL only for composers that actually changed.
+//
+// Initial scan runs ~2s after startup (lets the inbox watchers settle first).
+
+const CURSOR_DB_PATH = defaultCursorDbPath();
+const CURSOR_POLL_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+function cursorStateKey(composerId) {
+  return `cursor::${composerId}`;
+}
+
+function emitCursorComposer(db, composer) {
+  const dialogue = extractDialogue(db, composer);
+  const stateKey = cursorStateKey(composer.composerId);
+
+  if (dialogue.length === 0) {
+    // Empty / thinking-only / tool-only session — record state so we don't
+    // re-process every tick, but don't write to inbox.
+    state[stateKey] = {
+      lastUpdatedAt: composer.lastUpdatedAt,
+      bubbleCount: 0,
+      composerName: composer.name,
+    };
+    saveState();
+    return { changed: false };
+  }
+
+  const shortId = composer.composerId.slice(0, 8);
+  const targetPath = join(INBOX, `cursor-${shortId}.jsonl`);
+  // Write tmp into STAGING so the inbox watcher doesn't race us. See the
+  // matching note in emitToInbox above for the full rationale.
+  const tmpPath = join(STAGING, `cursor-${shortId}.jsonl.tmp`);
+
+  const records = composerToInboxRecords(
+    composer,
+    dialogue,
+    'cursor',
+    shortId,
+    (seed) => createHash('sha1').update(seed).digest('hex').slice(0, 16)
+  );
+
+  try {
+    writeFileSync(tmpPath, records.map((r) => JSON.stringify(r)).join('\n') + '\n');
+    renameSync(tmpPath, targetPath);
+  } catch (e) {
+    try { unlinkSync(tmpPath); } catch (_) {}
+    return { error: 'write: ' + e.message };
+  }
+
+  state[stateKey] = {
+    lastUpdatedAt: composer.lastUpdatedAt,
+    bubbleCount: dialogue.length,
+    composerName: composer.name,
+  };
+  saveState();
+
+  return { changed: true, msgCount: dialogue.length, name: composer.name };
+}
+
+function scanCursor() {
+  if (!CURSOR_DB_PATH) return; // unsupported platform
+  if (!existsSync(CURSOR_DB_PATH)) return; // Cursor not installed
+
+  // Cleanup: drop any stale empty-placeholder entries we may have
+  // tracked under earlier daemon versions. Cursor opens a new
+  // composerData row every "+ new tab" click; tracking them in state
+  // bloats it without value. We now skip those at scan time (below);
+  // this cleans up entries left over from before the change.
+  let cleanedEmpty = 0;
+  for (const [k, v] of Object.entries(state)) {
+    if (k.startsWith('cursor::') && v && (!v.bubbleCount || v.bubbleCount === 0)) {
+      delete state[k];
+      cleanedEmpty++;
+    }
+  }
+  if (cleanedEmpty > 0) {
+    saveState();
+    log(`cursor: cleaned ${cleanedEmpty} empty placeholder entries from state`);
+  }
+
+  let db;
+  try {
+    db = openCursorDB(CURSOR_DB_PATH);
+  } catch (e) {
+    log(`! cursor db open failed: ${e.message}`);
+    return;
+  }
+  if (!db) return;
+
+  let scanned = 0;
+  let skippedEmpty = 0;
+  let emitted = 0;
+  try {
+    for (const composer of iterComposers(db)) {
+      scanned++;
+
+      // Skip empty placeholders entirely — composers with no headers are
+      // tabs the user opened and closed without sending a message.
+      // No content to capture; tracking them in state is pointless.
+      if (!composer.headers || composer.headers.length === 0) {
+        skippedEmpty++;
+        continue;
+      }
+
+      const prev = state[cursorStateKey(composer.composerId)];
+      if (prev && prev.lastUpdatedAt === composer.lastUpdatedAt) continue;
+
+      const r = emitCursorComposer(db, composer);
+      if (r.error) {
+        log(`! cursor ${composer.composerId.slice(0, 8)}: ${r.error}`);
+      } else if (r.changed) {
+        emitted++;
+        const tag = r.name ? ` "${r.name.slice(0, 50)}"` : '';
+        log(`+ cursor-${composer.composerId.slice(0, 8)}.jsonl ← ${r.msgCount} msgs${tag}`);
+      }
+    }
+  } finally {
+    db.close();
+  }
+
+  if (emitted > 0) {
+    const skippedNote = skippedEmpty > 0 ? `, ${skippedEmpty} empty placeholders skipped` : '';
+    log(`cursor scan · ${scanned - skippedEmpty} active composers, ${emitted} updated${skippedNote}`);
+  }
+}
+
+// Initial scan ~2s after start, then poll every 5 minutes.
+const CURSOR_ENABLED = isSourceEnabled('cursor', CONFIG);
+if (!ANY_ONESHOT_MODE && CURSOR_ENABLED) {
+  setTimeout(scanCursor, 2000);
+  setInterval(scanCursor, CURSOR_POLL_INTERVAL_MS);
+}
+
+// -------------------- Obsidian watcher --------------------
+// Vault paths: explicit env var first (comma-separated), then auto-detect
+// of standard macOS locations. User opt-in via path discovery — we don't
+// recurse into ~/Documents wholesale, only confirmed vaults (folders
+// with a .obsidian/ subdir, found at depths 0-3).
+const OBSIDIAN_ENABLED = isSourceEnabled('obsidian', CONFIG);
+const OBSIDIAN_VAULTS = (() => {
+  if (!OBSIDIAN_ENABLED) return [];
+  // Priority: config.sources.obsidian.vaults + MEMEX_OBSIDIAN_VAULTS env.
+  // If both are empty, fall back to autodetect (preserves zero-config UX).
+  const explicit = obsidianVaultsFromConfig(CONFIG);
+  if (explicit.length > 0) return explicit.filter((v) => existsSync(v));
+  return autodetectObsidianVaults();
+})();
+
+function emitObsidianNote(notePath, vaultRoot) {
+  // Defensive — chokidar's ignored may not catch every case
+  const rel = relative(vaultRoot, notePath);
+  if (shouldSkipPath(rel)) return { changed: false };
+
+  const note = parseNote(notePath, vaultRoot);
+  if (!note) return { changed: false };
+
+  // Hash-based dedupe — body content, not file mtime, decides
+  const prev = state[notePath];
+  if (prev && prev.hash === note.hash) return { changed: false };
+
+  const slug = vaultSlug(vaultRoot);
+  const short = noteShortId(vaultRoot, note.relativePath);
+  const inboxName = `obsidian-${slug}-${short}.jsonl`;
+  const targetPath = join(INBOX, inboxName);
+  // Tmp goes to STAGING; see emitToInbox for the race-condition rationale.
+  const tmpPath = join(STAGING, inboxName + '.tmp');
+
+  const updatedIso = new Date(note.updated).toISOString();
+  const seedText = slicePy(note.body, 200);
+  const msgId = createHash('sha1').update(`user|${updatedIso}|${seedText}`).digest('hex').slice(0, 16);
+
+  const records = [
+    { type: 'ai-title', aiTitle: note.title },
+    { type: 'project-path', projectPath: vaultRoot },
+    {
+      role: 'user',
+      content: note.body,
+      timestamp: updatedIso,
+      id: `obsidian-${slug}-${short}-${msgId}`,
+    },
+  ];
+
+  try {
+    writeFileSync(tmpPath, records.map((r) => JSON.stringify(r)).join('\n') + '\n');
+    renameSync(tmpPath, targetPath);
+  } catch (e) {
+    try { unlinkSync(tmpPath); } catch (_) {}
+    return { error: 'write: ' + e.message };
+  }
+
+  state[notePath] = {
+    hash: note.hash,
+    updated: note.updated,
+    title: note.title,
+    vault: vaultRoot,
+    isObsidian: true,
+  };
+  saveState();
+
+  return { changed: true, title: note.title, bodyChars: note.body.length };
+}
+
+const obsidianPending = new Map();
+function scheduleObsidian(notePath, vaultRoot) {
+  if (obsidianPending.has(notePath)) clearTimeout(obsidianPending.get(notePath));
+  obsidianPending.set(notePath, setTimeout(() => {
+    obsidianPending.delete(notePath);
+    const r = emitObsidianNote(notePath, vaultRoot);
+    if (r.error) {
+      log(`! obsidian ${basename(notePath)}: ${r.error}`);
+    } else if (r.changed) {
+      log(`+ obsidian "${r.title}" (${r.bodyChars} chars)`);
+    }
+  }, DEBOUNCE_MS));
+}
+
+if (!ANY_ONESHOT_MODE && OBSIDIAN_ENABLED) {
+  for (const vault of OBSIDIAN_VAULTS) {
+    log(`watching obsidian: ${vault}`);
+    const w = chokidar
+      .watch(vault, {
+        ignoreInitial: false,
+        awaitWriteFinish: { stabilityThreshold: 800, pollInterval: 200 },
+        ignored: [
+          '**/.obsidian/**',
+          '**/.trash/**',
+          '**/.git/**',
+          '**/.DS_Store',
+          '**/*.sync-conflict-*',
+        ],
+        depth: 12,
+      })
+      .on('add', (p) => p.endsWith('.md') && scheduleObsidian(p, vault))
+      .on('change', (p) => p.endsWith('.md') && scheduleObsidian(p, vault))
+      .on('error', (e) => log(`watcher error (obsidian): ${e.message}`));
+    watchers.push(w);
+  }
+}
+
+// -------------------- Telegram Downloads watcher (v0.10+) --------------------
+// Watches ~/Downloads/Telegram Desktop/ for new ChatExport_* folders or
+// result.json files. On detection, moves them to ~/.memex/pending/ so the
+// user can review with `memex telegram pending` before any data lands in
+// memex.db. Privacy-first — nothing is auto-imported here.
+const TG_DOWNLOADS_ENABLED = isSourceEnabled('telegram-downloads', CONFIG);
+// Default Telegram Desktop export location is identical across platforms:
+// ~/Downloads/Telegram Desktop/. Config can override via sources.telegram-downloads.paths.
+const TG_DOWNLOADS_PATHS = (() => {
+  if (!TG_DOWNLOADS_ENABLED) return [];
+  const configured = (CONFIG.sources?.['telegram-downloads']?.paths) || [];
+  const defaults = [join(homedir(), 'Downloads', 'Telegram Desktop')];
+  const all = (configured.length ? configured : defaults).map((p) =>
+    p.startsWith('~') ? join(homedir(), p.slice(1)) : p
+  );
+  return all.filter((p) => existsSync(p));
+})();
+
+if (!ANY_ONESHOT_MODE && TG_DOWNLOADS_ENABLED && TG_DOWNLOADS_PATHS.length) {
+  for (const dlPath of TG_DOWNLOADS_PATHS) {
+    log(`watching telegram-downloads: ${dlPath}`);
+    const w = chokidar
+      .watch(dlPath, {
+        ignoreInitial: false,
+        awaitWriteFinish: { stabilityThreshold: 2000, pollInterval: 400 },
+        depth: 0,
+      })
+      .on('addDir', (p) => {
+        if (p === dlPath) return; // root itself
+        if (!basename(p).toLowerCase().startsWith('chatexport_')) return;
+        scheduleTelegramStaging(p);
+      })
+      .on('add', (p) => {
+        if (basename(p).toLowerCase() === 'result.json') {
+          scheduleTelegramStaging(p);
+        }
+      })
+      .on('error', (e) => log(`watcher error (telegram-downloads): ${e.message}`));
+    watchers.push(w);
+  }
+}
+
+const tgStagingPending = new Map();
+function scheduleTelegramStaging(srcPath) {
+  if (tgStagingPending.has(srcPath)) clearTimeout(tgStagingPending.get(srcPath));
+  // Use a longer debounce — exports can take several seconds to finish writing
+  tgStagingPending.set(srcPath, setTimeout(async () => {
+    tgStagingPending.delete(srcPath);
+    if (!existsSync(srcPath)) return;
+    try {
+      const { stageExport, listPending } = await import('./lib/telegram-pending.js');
+      // v0.11.6: COPY (not move) — leave the user's original export
+      // untouched in ~/Downloads/Telegram Desktop/. Pre-v0.11.6 we moved
+      // exports into ~/.memex/pending/ which surprised users who later
+      // looked in their Downloads folder and found nothing. Now they
+      // see the original file where Telegram Desktop put it, AND we
+      // have a staged copy for the review flow. Re-stages of the same
+      // export are still deduped by basename+suffix in stageExport.
+      const dest = stageExport(srcPath, { moveOrCopy: 'copy' });
+      log(`+ telegram-export staged (copy) → pending/: ${basename(dest)}`);
+
+      // Channel C: macOS native notification (v0.10.4+ — clickable).
+      // Default OFF, opt-in via `memex telegram notifications on`. Dedup
+      // by path hash so re-stages of same export don't re-notify.
+      //
+      // Click behavior priority (auto): Claude Code CLI → Claude Desktop
+      // → Terminal. terminal-notifier required for click-through; without
+      // it banner is shown via osascript (informative text, no click).
+      try {
+        const notify = await import('./lib/telegram-notify.js');
+        const clickLib = await import('./lib/notify-click-action.js');
+        const state = notify.loadNotifyState();
+        if (state.notifications.enabled && !notify.notifShownFor(state, dest)) {
+          const list = listPending();
+          const justStaged = list.find((e) => e.path === dest) || {};
+          const totalPending = list.length;
+          const showTitles = !!state.notifications.show_titles;
+          const env = clickLib.detectEnvironment();
+          const target = clickLib.pickTarget(state.notifications.click_target || 'auto', env);
+          const clickable = !!env.terminal_notifier && target !== 'none';
+          const cta = clickLib.bannerCallToAction(target, clickable);
+
+          const title = 'memex';
+          const subtitle = `${totalPending} new Telegram chat${totalPending === 1 ? '' : 's'} ready to review`;
+          const message = showTitles && justStaged.chat_title
+            ? `"${justStaged.chat_title}" — ${(justStaged.message_count || 0).toLocaleString()} msgs · ${cta}`
+            : `${cta}`;
+
+          const r = clickLib.fireClickableNotification({
+            title, subtitle, message,
+            target: state.notifications.click_target || 'auto',
+            env,
+          });
+          if (r.backend !== 'noop') {
+            notify.markNotifShown(state, [dest]);
+            notify.saveNotifyState(state);
+            log(`  notif fired (${r.backend}, target=${r.target}, titles=${showTitles ? 'yes' : 'no'})`);
+          }
+        }
+      } catch (e) {
+        log(`  notif skipped: ${e.message}`);
+      }
+    } catch (e) {
+      log(`! telegram-export stage failed (${basename(srcPath)}): ${e.message}`);
+    }
+  }, 5000));
+}
+
+// Synchronous one-shot walk for scan-obsidian / scan modes.
+function scanObsidian() {
+  if (OBSIDIAN_VAULTS.length === 0) {
+    console.log('no Obsidian vaults configured/detected — skipping');
+    return;
+  }
+  let scanned = 0;
+  let emitted = 0;
+  for (const vault of OBSIDIAN_VAULTS) {
+    if (!existsSync(vault)) continue;
+    console.log(`scanning obsidian: ${vault}`);
+    for (const f of walkVault(vault)) {
+      scanned++;
+      const r = emitObsidianNote(f.absolute, vault);
+      if (r.error) {
+        console.error(`  ! ${f.relative}: ${r.error}`);
+      } else if (r.changed) {
+        emitted++;
+        console.log(`  + "${r.title}" (${r.bodyChars} chars)`);
+      }
+    }
+  }
+  console.log(`scanned ${scanned} notes · ${emitted} updated`);
+}
+
+// -------------------- One-shot scan modes --------------------
+// Synchronous walk-and-emit for Claude Code / Cowork directories. Bypasses
+// the debounce queue (we want eager processing in one-shot mode).
+function scanClaudeSync() {
+  let scanned = 0;
+  let emitted = 0;
+  for (const source of SOURCES) {
+    if (!existsSync(source.dir)) {
+      console.log(`- skipping ${source.name}: directory not found at ${source.dir}`);
+      continue;
+    }
+    console.log(`scanning ${source.name}: ${source.dir}`);
+    walkDir(source.dir, (p) => {
+      if (!shouldIngest(p)) return;
+      scanned++;
+      const r = emitToInbox(p, source);
+      if (r.error) {
+        console.error(`! ${basename(p)} (${source.name}): ${r.error}`);
+      } else if (r.changed) {
+        emitted++;
+        const inboxName = inboxNameFor(p, source) || basename(p);
+        const isSubagent = inboxName.includes('-sub-');
+        console.log(`+ ${inboxName} ← ${r.msgCount} msgs from ${source.name}` +
+                    (isSubagent ? ' [subagent]' : '') +
+                    (r.hadTitle ? ' (with ai-title)' : ''));
+      }
+    });
+  }
+  console.log(`scanned ${scanned} files · ${emitted} updated`);
+}
+
+if (SCAN_CLAUDE_MODE || SCAN_ALL_MODE) {
+  console.log(`=== Claude Code + Cowork ===`);
+  scanClaudeSync();
+}
+
+if (SCAN_OBSIDIAN_MODE || SCAN_ALL_MODE) {
+  console.log(`=== Obsidian ===`);
+  scanObsidian();
+}
+
+if (SCAN_CURSOR_MODE || SCAN_ALL_MODE) {
+  if (SCAN_ALL_MODE || SCAN_CURSOR_MODE) console.log(`=== Cursor ===`);
+  if (!CURSOR_DB_PATH) {
+    if (SCAN_CURSOR_MODE) {
+      console.error('Cursor not supported on this platform.');
+      process.exit(2);
+    } else {
+      console.log('Cursor not supported on this platform — skipping.');
+    }
+  } else if (!existsSync(CURSOR_DB_PATH)) {
+    if (SCAN_CURSOR_MODE) {
+      console.error(`Cursor not detected — no state.vscdb at:\n  ${CURSOR_DB_PATH}`);
+      console.error(`Install Cursor and use it at least once before running this.`);
+      process.exit(2);
+    } else {
+      console.log('Cursor not detected — skipping.');
+    }
+  } else {
+    console.log(`scanning Cursor at ${CURSOR_DB_PATH} ...`);
+    try {
+      scanCursor();
+    } catch (e) {
+      console.error('cursor scan failed:', e.message);
+      if (SCAN_CURSOR_MODE) process.exit(1);
+    }
+  }
+}
+
+if (ANY_SCAN_MODE) {
+  console.log(`done. New inbox files (if any) are in: ${INBOX}`);
+  console.log(`memex MCP server will pick them up next time it starts (or now, if running).`);
+  process.exit(0);
+}
+
+// -------------------- One-shot export-markdown mode --------------------
+// `memex-sync export-markdown --output <dir> [--source S] [--since DATE]
+//                              [--include-subagents]`
+async function runExportMarkdown() {
+  // Parse argv
+  const argv = process.argv.slice(3);
+  const opts = { output: null, source: null, since: null, includeSubagents: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--output' || a === '-o') opts.output = argv[++i];
+    else if (a === '--source' || a === '-s') opts.source = argv[++i];
+    else if (a === '--since') opts.since = argv[++i];
+    else if (a === '--include-subagents') opts.includeSubagents = true;
+  }
+  if (!opts.output) {
+    console.error('error: --output <dir> is required');
+    console.error('example: memex-sync export-markdown --output ~/Obsidian/memex/');
+    process.exit(2);
+  }
+  // Tilde expansion + ensure dir exists
+  let outDir = opts.output;
+  if (outDir === '~') outDir = HOME;
+  else if (outDir.startsWith('~/')) outDir = join(HOME, outDir.slice(2));
+  mkdirSync(outDir, { recursive: true });
+
+  // Open memex.db readonly
+  const dbPath = join(MEMEX_DIR, 'data', 'memex.db');
+  if (!existsSync(dbPath)) {
+    console.error(`error: memex.db not found at ${dbPath}`);
+    console.error('Has memex ever ingested anything? Run a scan first.');
+    process.exit(2);
+  }
+  const Database = (await import('better-sqlite3')).default;
+  const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+
+  // Build conversation query
+  const where = ['(archived_at IS NULL OR archived_at = 0)', 'parent_conversation_id IS NULL'];
+  const params = [];
+  if (opts.source) { where.push('source = ?'); params.push(opts.source); }
+  if (opts.since) {
+    const ts = Math.floor(new Date(opts.since).getTime() / 1000);
+    if (Number.isFinite(ts) && ts > 0) {
+      where.push('last_ts >= ?');
+      params.push(ts);
+    } else {
+      console.error(`warning: --since "${opts.since}" not parseable, ignoring`);
+    }
+  }
+  const convs = db
+    .prepare(
+      `SELECT conversation_id, source, title, first_ts, last_ts, message_count
+         FROM conversations
+        WHERE ${where.join(' AND ')}
+     ORDER BY last_ts DESC`
+    )
+    .all(...params);
+
+  if (convs.length === 0) {
+    console.log('no conversations match the filter.');
+    db.close();
+    process.exit(0);
+  }
+  console.log(`exporting ${convs.length} conversation(s) to ${outDir}`);
+  console.log('');
+
+  let written = 0;
+  for (const conv of convs) {
+    // Fetch messages (with subagents if requested)
+    const ids = [conv.conversation_id];
+    if (opts.includeSubagents) {
+      const subs = db
+        .prepare(`SELECT conversation_id FROM conversations WHERE parent_conversation_id = ?`)
+        .all(conv.conversation_id);
+      for (const s of subs) ids.push(s.conversation_id);
+    }
+    const placeholders = ids.map(() => '?').join(',');
+    const messages = db
+      .prepare(
+        `SELECT conversation_id, role, sender, text, ts
+           FROM messages
+          WHERE conversation_id IN (${placeholders})
+       ORDER BY ts ASC`
+      )
+      .all(...ids);
+    if (messages.length === 0) continue;
+    for (const m of messages) {
+      if (m.conversation_id !== conv.conversation_id) m.from_subagent = m.conversation_id;
+    }
+
+    const md = renderConversationMarkdown(conv, messages, {
+      includeFrontmatter: true,
+      includeSubagentTag: opts.includeSubagents,
+    });
+    const filename = suggestFilename(conv);
+    const target = join(outDir, filename);
+    const tmp = target + '.tmp';
+    try {
+      writeFileSync(tmp, md);
+      renameSync(tmp, target);
+      written++;
+      console.log(`  ✓ ${filename} (${messages.length} msgs)`);
+    } catch (e) {
+      console.error(`  ✗ ${filename}: ${e.message}`);
+    }
+  }
+  db.close();
+
+  console.log('');
+  console.log(`done. ${written} file(s) written to ${outDir}`);
+  console.log(`tip: drop the directory into your Obsidian vault to get full Dataview support.`);
+}
+
+if (EXPORT_MD_MODE) {
+  // Need writeFileSync — already imported above.
+  runExportMarkdown().catch((e) => {
+    console.error('export failed:', e.message);
+    process.exit(1);
+  });
+}
+
+// -------------------- Lifecycle --------------------
+if (!ANY_ONESHOT_MODE) {
+  log(`memex-ingest started`);
+  log(`  inbox:        ${INBOX}`);
+  log(`  state:        ${STATE_PATH}`);
+  log(`  log:          ${LOG_PATH}`);
+  log(`  debounce:     ${DEBOUNCE_MS}ms`);
+  log(`  rescan every: ${RESCAN_INTERVAL_MS / 60000} min`);
+  if (CURSOR_DB_PATH && existsSync(CURSOR_DB_PATH)) {
+    log(`  cursor poll:  ${CURSOR_POLL_INTERVAL_MS / 60000} min · ${CURSOR_DB_PATH}`);
+  } else {
+    log(`  cursor poll:  skipped (Cursor not detected on this machine)`);
+  }
+  if (OBSIDIAN_VAULTS.length > 0) {
+    log(`  obsidian:     ${OBSIDIAN_VAULTS.length} vault(s) — ${OBSIDIAN_VAULTS.join(', ')}`);
+  } else {
+    log(`  obsidian:     skipped (no vaults detected, set MEMEX_OBSIDIAN_VAULTS to override)`);
+  }
+}
+
+function shutdown(sig) {
+  log(`received ${sig}, shutting down`);
+  for (const w of watchers) try { w.close(); } catch (_) {}
+  // flush any pending state write
+  try { saveState(); } catch (_) {}
+  process.exit(0);
+}
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));