@agentreel/agent 0.1.2 → 0.1.5

package/dist/cli.js

@@ -121,23 +121,15 @@ var init_install = __esm({
   }
 });
 
-// src/cli.ts
-import { Command } from "commander";
-
-// src/commands/init.ts
-init_install();
-import { realpathSync } from "fs";
-import { fileURLToPath } from "url";
-import { sep } from "path";
-import pc from "picocolors";
-
 // src/config.ts
-init_paths();
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, chmodSync } from "fs";
-var DEFAULT = {
-  apiBaseUrl: "https://api.agentreel.dev",
-  schemaVersion: 1
-};
+function isCaptureDisabledByEnv() {
+  const v = process.env.AGENTREEL_DISABLE;
+  return v === "1" || v === "true" || v === "yes";
+}
+function isCapturePaused(cfg = readConfig()) {
+  return isCaptureDisabledByEnv() || cfg.paused === true;
+}
 function readConfig() {
   if (!existsSync2(CONFIG_PATH)) return { ...DEFAULT };
   try {
@@ -158,11 +150,20 @@ function writeConfig(cfg) {
   } catch {
   }
 }
+var DEFAULT;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT = {
+      apiBaseUrl: "https://api.agentreel.dev",
+      schemaVersion: 1
+    };
+  }
+});
 
 // src/db.ts
-init_paths();
 import Database from "better-sqlite3";
-var _db = null;
 function getDb() {
   if (_db) return _db;
   ensureAgentreelDir();
@@ -266,79 +267,16 @@ function listRecentSessions(limit = 10) {
        FROM sessions ORDER BY started_at DESC LIMIT ?`
   ).all(limit);
 }
-
-// src/commands/init.ts
-init_paths();
-var PACKAGE_NAME = "@agentreel/agent";
-function resolveAgentBinary() {
-  const here = fileURLToPath(import.meta.url);
-  const real = realpathSync(here);
-  const isEphemeral = real.includes(`${sep}_npx${sep}`) || real.includes("/_npx/");
-  return { absolutePath: real, isEphemeral };
-}
-function chooseHookPrefix(bin) {
-  if (process.env.AGENTREEL_HOOK_COMMAND) {
-    return { prefix: process.env.AGENTREEL_HOOK_COMMAND, mode: "absolute" };
-  }
-  if (bin.isEphemeral) {
-    return { prefix: `npx -y ${PACKAGE_NAME}`, mode: "npx" };
-  }
-  return { prefix: quotePath(bin.absolutePath), mode: "absolute" };
-}
-async function initCommand() {
-  ensureAgentreelDir();
-  getDb();
-  const cfg = readConfig();
-  if (!cfg.installedAt) cfg.installedAt = Date.now();
-  cfg.hooksInstalled = true;
-  writeConfig(cfg);
-  const binary = resolveAgentBinary();
-  const { prefix, mode } = chooseHookPrefix(binary);
-  const result = installClaudeCodeHooks(prefix);
-  console.log(pc.bold(pc.cyan("\n  AgentReel  ")) + pc.dim("Loom for AI coding sessions\n"));
-  console.log(pc.green("\u2713") + " Created ~/.agentreel/sessions.db");
-  console.log(pc.green("\u2713") + " Wrote ~/.agentreel/config.json");
-  console.log(
-    pc.green("\u2713") + ` Installed ${result.installedEvents.length} Claude Code hooks \u2192 ~/.claude/settings.json`
-  );
-  if (result.backup) {
-    console.log(pc.dim(`  (backup: ${result.backup})`));
-  }
-  console.log();
-  console.log(pc.dim("  Hook command: ") + pc.dim(`${prefix} hook <Event>`));
-  if (mode === "npx") {
-    console.log(
-      pc.dim("  ") + pc.yellow("\u2022") + pc.dim(
-        ` Hooks resolve via npx every time Claude Code fires an event.
-    For faster cold starts, run: npm i -g ${PACKAGE_NAME}`
-      )
-    );
+var _db;
+var init_db = __esm({
+  "src/db.ts"() {
+    "use strict";
+    init_paths();
+    _db = null;
   }
-  console.log();
-  console.log(pc.bold("Next:") + " open Claude Code and run a prompt.");
-  console.log("      then " + pc.cyan("agentreel status") + " to see captured events.\n");
-}
-
-// src/commands/status.ts
-init_paths();
-import pc2 from "picocolors";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+});
 
 // src/upload/client.ts
-var IngestError = class extends Error {
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "IngestError";
-  }
-  status;
-  body;
-  /** 4xx (except 408/429) — payload-shaped problem the agent can't fix by retrying. */
-  get isPermanent() {
-    return this.status >= 400 && this.status < 500 && this.status !== 408 && this.status !== 429;
-  }
-};
 async function postIngest(cfg, body) {
   if (!cfg.apiKey) {
     throw new Error("Not linked. Run: agentreel link <key>");
@@ -364,10 +302,28 @@ async function postIngest(cfg, body) {
   }
   return data;
 }
+var IngestError;
+var init_client = __esm({
+  "src/upload/client.ts"() {
+    "use strict";
+    IngestError = class extends Error {
+      constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "IngestError";
+      }
+      status;
+      body;
+      /** 4xx (except 408/429) — payload-shaped problem the agent can't fix by retrying. */
+      get isPermanent() {
+        return this.status >= 400 && this.status < 500 && this.status !== 408 && this.status !== 429;
+      }
+    };
+  }
+});
 
 // src/upload/queue.ts
-var MAX_BATCH_BYTES = 1024 * 1024;
-var MAX_BATCH_EVENTS = 500;
 function takePendingBatch(maxEvents = MAX_BATCH_EVENTS, maxBytes = MAX_BATCH_BYTES) {
   const db = getDb();
   const candidateRows = db.prepare(
@@ -429,15 +385,17 @@ function safeParse(s) {
     return s;
   }
 }
+var MAX_BATCH_BYTES, MAX_BATCH_EVENTS;
+var init_queue = __esm({
+  "src/upload/queue.ts"() {
+    "use strict";
+    init_db();
+    MAX_BATCH_BYTES = 1024 * 1024;
+    MAX_BATCH_EVENTS = 500;
+  }
+});
 
 // src/upload/flush.ts
-var META_LAST_SYNC_AT = "last_sync_at";
-var META_LAST_ERROR_AT = "last_error_at";
-var META_LAST_ERROR_MSG = "last_error_msg";
-var META_CONSECUTIVE_FAILS = "consecutive_failures";
-var META_NEXT_ATTEMPT_AT = "next_attempt_at";
-var BACKOFF_BASE_MS = 1e3;
-var BACKOFF_MAX_MS = 5 * 6e4;
 function nextAttemptAt() {
   const raw = getMeta(META_NEXT_ATTEMPT_AT);
   return raw ? Number(raw) : 0;
@@ -495,8 +453,326 @@ async function flushOnce() {
     throw err;
   }
 }
+var META_LAST_SYNC_AT, META_LAST_ERROR_AT, META_LAST_ERROR_MSG, META_CONSECUTIVE_FAILS, META_NEXT_ATTEMPT_AT, BACKOFF_BASE_MS, BACKOFF_MAX_MS;
+var init_flush = __esm({
+  "src/upload/flush.ts"() {
+    "use strict";
+    init_db();
+    init_config();
+    init_client();
+    init_queue();
+    META_LAST_SYNC_AT = "last_sync_at";
+    META_LAST_ERROR_AT = "last_error_at";
+    META_LAST_ERROR_MSG = "last_error_msg";
+    META_CONSECUTIVE_FAILS = "consecutive_failures";
+    META_NEXT_ATTEMPT_AT = "next_attempt_at";
+    BACKOFF_BASE_MS = 1e3;
+    BACKOFF_MAX_MS = 5 * 6e4;
+  }
+});
+
+// src/commands/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  daemonCommand: () => daemonCommand,
+  stopCommand: () => stopCommand
+});
+import pc3 from "picocolors";
+import { spawn } from "child_process";
+import {
+  existsSync as existsSync4,
+  openSync,
+  readFileSync as readFileSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+async function daemonCommand(opts = {}) {
+  const cfg = readConfig();
+  if (!cfg.apiKey) {
+    console.error(pc3.red("\u2717 Not linked. Run ") + pc3.cyan("agentreel link <api-key>"));
+    process.exit(1);
+  }
+  if (opts.detach) {
+    spawnDetached();
+    return;
+  }
+  if (!claimPidFile()) {
+    process.exit(1);
+  }
+  const release = () => {
+    try {
+      unlinkSync(DAEMON_PID_PATH);
+    } catch {
+    }
+  };
+  let stopping = false;
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    console.log(pc3.dim("\n  daemon stopping\u2026"));
+    release();
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  process.on("beforeExit", release);
+  console.log(pc3.green("\u25CF") + " agentreel daemon running");
+  console.log(pc3.dim(`  api: ${cfg.apiBaseUrl}`));
+  console.log(pc3.dim(`  tick: every ${TICK_INTERVAL_MS / 1e3}s, early flush at ${(EARLY_FLUSH_BYTES / 1024).toFixed(0)} KB`));
+  console.log(pc3.dim("  Ctrl-C to stop"));
+  for (; ; ) {
+    if (stopping) return;
+    const nextAt = nextAttemptAt();
+    const now = Date.now();
+    if (nextAt > now) {
+      await sleepInterruptible(nextAt - now, () => stopping);
+      continue;
+    }
+    try {
+      for (; ; ) {
+        const res = await flushOnce();
+        if (res.uploadedEvents > 0) {
+          console.log(
+            pc3.dim(`  [${ts()}]`) + pc3.green(" \u2713") + ` ${res.uploadedEvents} events \xB7 ${res.uploadedSessions} sessions`
+          );
+        }
+        if (!res.moreAvailable) break;
+      }
+    } catch (err) {
+      const e = err;
+      if (err instanceof IngestError && err.isPermanent) {
+        console.error(
+          pc3.dim(`  [${ts()}]`) + pc3.red(" \u2717 ") + e.message + pc3.dim(" (5min backoff)")
+        );
+      } else {
+        console.error(pc3.dim(`  [${ts()}]`) + pc3.yellow(" \xB7 ") + e.message);
+      }
+    }
+    await waitForTickOrPressure(TICK_INTERVAL_MS, EARLY_FLUSH_BYTES, () => stopping);
+  }
+}
+function claimPidFile() {
+  ensureAgentreelDir();
+  if (existsSync4(DAEMON_PID_PATH)) {
+    const raw = readFileSync4(DAEMON_PID_PATH, "utf8").trim();
+    const pid = Number(raw);
+    if (Number.isFinite(pid) && pid > 0 && isAlive(pid)) {
+      console.error(pc3.red(`\u2717 daemon already running (pid ${pid})`));
+      console.error(pc3.dim(`  if this is wrong, remove ${DAEMON_PID_PATH}`));
+      return false;
+    }
+  }
+  writeFileSync3(DAEMON_PID_PATH, String(process.pid), { encoding: "utf8", mode: 384 });
+  return true;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleepInterruptible(ms, shouldStop) {
+  return new Promise((resolve2) => {
+    if (ms <= 0) return resolve2();
+    const start = Date.now();
+    const t = setInterval(() => {
+      if (shouldStop() || Date.now() - start >= ms) {
+        clearInterval(t);
+        resolve2();
+      }
+    }, 250);
+  });
+}
+function spawnDetached() {
+  ensureAgentreelDir();
+  if (existsSync4(DAEMON_PID_PATH)) {
+    const raw = readFileSync4(DAEMON_PID_PATH, "utf8").trim();
+    const pid = Number(raw);
+    if (Number.isFinite(pid) && pid > 0 && isAlive(pid)) {
+      console.error(pc3.red(`\u2717 daemon already running (pid ${pid})`));
+      console.error(pc3.dim("  use ") + pc3.cyan("agentreel stop") + pc3.dim(" first"));
+      process.exit(1);
+    }
+  }
+  const out = openSync(DAEMON_LOG_PATH, "a");
+  const err = openSync(DAEMON_LOG_PATH, "a");
+  const child = spawn(process.execPath, [process.argv[1], "daemon"], {
+    detached: true,
+    stdio: ["ignore", out, err],
+    env: process.env
+  });
+  child.unref();
+  console.log(pc3.green("\u25CF") + ` daemon started (pid ${child.pid})`);
+  console.log(pc3.dim(`  log: ${DAEMON_LOG_PATH}`));
+  console.log(pc3.dim(`  stop: agentreel stop`));
+}
+function stopCommand() {
+  if (!existsSync4(DAEMON_PID_PATH)) {
+    console.log(pc3.dim("\xB7 daemon not running"));
+    return;
+  }
+  const raw = readFileSync4(DAEMON_PID_PATH, "utf8").trim();
+  const pid = Number(raw);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    try {
+      unlinkSync(DAEMON_PID_PATH);
+    } catch {
+    }
+    console.log(pc3.dim("\xB7 cleared stale pid file"));
+    return;
+  }
+  if (!isAlive(pid)) {
+    try {
+      unlinkSync(DAEMON_PID_PATH);
+    } catch {
+    }
+    console.log(pc3.dim(`\xB7 no live daemon for pid ${pid} \u2014 cleared stale pid file`));
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(pc3.green("\u2713") + ` sent SIGTERM to pid ${pid}`);
+  } catch (err) {
+    console.error(pc3.red("\u2717 ") + err.message);
+    process.exit(1);
+  }
+}
+function waitForTickOrPressure(tickMs, pressureBytes, shouldStop) {
+  return new Promise((resolve2) => {
+    const start = Date.now();
+    const t = setInterval(() => {
+      if (shouldStop()) {
+        clearInterval(t);
+        return resolve2();
+      }
+      if (Date.now() - start >= tickMs) {
+        clearInterval(t);
+        return resolve2();
+      }
+      try {
+        if (pendingByteSize() >= pressureBytes) {
+          clearInterval(t);
+          return resolve2();
+        }
+      } catch {
+      }
+    }, 1e3);
+  });
+}
+function ts() {
+  const d = /* @__PURE__ */ new Date();
+  return d.toTimeString().slice(0, 8);
+}
+var TICK_INTERVAL_MS, EARLY_FLUSH_BYTES;
+var init_daemon = __esm({
+  "src/commands/daemon.ts"() {
+    "use strict";
+    init_paths();
+    init_db();
+    init_flush();
+    init_queue();
+    init_client();
+    init_config();
+    TICK_INTERVAL_MS = 3e4;
+    EARLY_FLUSH_BYTES = MAX_BATCH_BYTES;
+  }
+});
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+init_install();
+init_config();
+init_db();
+init_paths();
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { sep } from "path";
+import pc from "picocolors";
+var PACKAGE_NAME = "@agentreel/agent";
+function resolveAgentBinary() {
+  const here = fileURLToPath(import.meta.url);
+  const real = realpathSync(here);
+  const isEphemeral = real.includes(`${sep}_npx${sep}`) || real.includes("/_npx/");
+  return { absolutePath: real, isEphemeral };
+}
+function chooseHookPrefix(bin) {
+  if (process.env.AGENTREEL_HOOK_COMMAND) {
+    return { prefix: process.env.AGENTREEL_HOOK_COMMAND, mode: "absolute" };
+  }
+  if (bin.isEphemeral) {
+    return { prefix: `npx -y ${PACKAGE_NAME}`, mode: "npx" };
+  }
+  return { prefix: quotePath(bin.absolutePath), mode: "absolute" };
+}
+async function initCommand() {
+  ensureAgentreelDir();
+  getDb();
+  const cfg = readConfig();
+  if (!cfg.installedAt) cfg.installedAt = Date.now();
+  cfg.hooksInstalled = true;
+  writeConfig(cfg);
+  const binary = resolveAgentBinary();
+  const { prefix, mode } = chooseHookPrefix(binary);
+  const result = installClaudeCodeHooks(prefix);
+  console.log(pc.bold(pc.cyan("\n  AgentReel  ")) + pc.dim("Loom for AI coding sessions\n"));
+  console.log(pc.green("\u2713") + " Created ~/.agentreel/sessions.db");
+  console.log(pc.green("\u2713") + " Wrote ~/.agentreel/config.json");
+  console.log(
+    pc.green("\u2713") + ` Installed ${result.installedEvents.length} Claude Code hooks \u2192 ~/.claude/settings.json`
+  );
+  if (result.backup) {
+    console.log(pc.dim(`  (backup: ${result.backup})`));
+  }
+  console.log();
+  console.log(pc.dim("  Hook command: ") + pc.dim(`${prefix} hook <Event>`));
+  if (mode === "npx") {
+    console.log(
+      pc.dim("  ") + pc.yellow("\u2022") + pc.dim(
+        ` Hooks resolve via npx every time Claude Code fires an event.
+    For faster cold starts, run: npm i -g ${PACKAGE_NAME}`
+      )
+    );
+  }
+  console.log();
+  if (!cfg.apiKey) {
+    console.log(pc.bold("Next steps:"));
+    console.log(
+      "  " + pc.dim("1.") + " " + pc.cyan("agentreel link <key>") + pc.dim("   \u2014 get a key from https://agentreel.dev/dashboard/settings")
+    );
+    console.log(
+      "  " + pc.dim("2.") + " " + pc.cyan("agentreel daemon --detach") + pc.dim("  \u2014 start the background uploader")
+    );
+    console.log(
+      "  " + pc.dim("3.") + " open Claude Code and work as normal."
+    );
+  } else {
+    console.log(pc.bold("Next:"));
+    console.log(
+      "  " + pc.cyan("agentreel daemon --detach") + pc.dim("  \u2014 start the background uploader (already linked)")
+    );
+  }
+  console.log(
+    "\n" + pc.dim("Anything: ") + pc.cyan("agentreel status") + pc.dim(" shows queue, last sync, last error.")
+  );
+  console.log(
+    pc.dim("Privacy: ") + pc.cyan("agentreel pause") + pc.dim(" to stop capturing temporarily, ") + pc.cyan("agentreel forget --all") + pc.dim(" to wipe local sessions.")
+  );
+  console.log(
+    pc.dim("         Or set ") + pc.cyan("AGENTREEL_DISABLE=1") + pc.dim(" before launching Claude Code to skip a single session.\n")
+  );
+}
 
 // src/commands/status.ts
+init_paths();
+init_db();
+init_config();
+init_flush();
+import pc2 from "picocolors";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 function fmtDuration(ms) {
   const s = Math.round(ms / 1e3);
   if (s < 60) return `${s}s`;
@@ -534,6 +810,15 @@ async function statusCommand() {
   );
   console.log("  api base:      " + cfg.apiBaseUrl);
   console.log("  authenticated: " + (cfg.apiKey ? pc2.green("yes") : pc2.yellow("no")));
+  if (cfg.paused) {
+    const since = cfg.pausedAt ? new Date(cfg.pausedAt).toLocaleString() : "?";
+    console.log("  capture:       " + pc2.yellow(`paused (since ${since})`));
+    console.log(pc2.dim("                 run `agentreel resume` to capture again"));
+  } else if (isCaptureDisabledByEnv()) {
+    console.log("  capture:       " + pc2.yellow("disabled (AGENTREEL_DISABLE in env)"));
+  } else {
+    console.log("  capture:       " + pc2.green("active"));
+  }
   const d = daemonStatus();
   console.log(
     "  daemon:        " + (d.running ? pc2.green(`running (pid ${d.pid})`) : pc2.dim("stopped"))
@@ -587,44 +872,48 @@ function numMeta(key) {
 }
 
 // src/commands/auth.ts
-import pc3 from "picocolors";
+init_config();
+init_client();
+import pc4 from "picocolors";
 async function logoutCommand() {
   const cfg = readConfig();
   cfg.apiKey = void 0;
   cfg.workspaceId = void 0;
   writeConfig(cfg);
-  console.log(pc3.green("\u2713") + " Cleared local credentials.");
+  console.log(pc4.green("\u2713") + " Cleared local credentials.");
 }
 async function linkCommand(rawKey, opts) {
   const key = (rawKey ?? await promptHidden("Paste your AgentReel API key: ")).trim();
   if (!key) {
-    console.error(pc3.red("\u2717 No key provided."));
+    console.error(pc4.red("\u2717 No key provided."));
     process.exit(1);
   }
   if (!key.startsWith("ar_live_")) {
-    console.error(pc3.red("\u2717 Keys start with `ar_live_`. Did you paste the right value?"));
+    console.error(pc4.red("\u2717 Keys start with `ar_live_`. Did you paste the right value?"));
     process.exit(1);
   }
   const cfg = readConfig();
   cfg.apiKey = key;
   if (opts.api) cfg.apiBaseUrl = opts.api;
-  console.log(pc3.dim(`  validating against ${cfg.apiBaseUrl}\u2026`));
+  console.log(pc4.dim(`  validating against ${cfg.apiBaseUrl}\u2026`));
   try {
     await postIngest(cfg, {});
   } catch (err) {
-    console.error(pc3.red("\u2717 Validation failed: ") + err.message);
+    console.error(pc4.red("\u2717 Validation failed: ") + err.message);
     process.exit(1);
   }
   writeConfig(cfg);
-  console.log(pc3.green("\u2713") + " Linked.");
-  console.log(pc3.dim("  api: ") + cfg.apiBaseUrl);
-  console.log(pc3.dim("  key: ") + key.slice(0, 12) + "\u2026");
+  console.log(pc4.green("\u2713") + " Linked.");
+  console.log(pc4.dim("  api: ") + cfg.apiBaseUrl);
+  console.log(pc4.dim("  key: ") + key.slice(0, 12) + "\u2026");
 }
 async function uninstallCommand() {
   const { uninstallClaudeCodeHooks: uninstallClaudeCodeHooks2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+  const { stopCommand: stopCommand2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  stopCommand2();
   const { backup } = uninstallClaudeCodeHooks2();
-  console.log(pc3.green("\u2713") + " Removed AgentReel hooks from ~/.claude/settings.json");
-  if (backup) console.log(pc3.dim(`  (backup: ${backup})`));
+  console.log(pc4.green("\u2713") + " Removed AgentReel hooks from ~/.claude/settings.json");
+  if (backup) console.log(pc4.dim(`  (backup: ${backup})`));
 }
 var CTRL_C = 3;
 var BACKSPACE = 127;
@@ -665,8 +954,8 @@ function promptHidden(prompt) {
 }
 
 // src/commands/watch.ts
-import pc4 from "picocolors";
-import { existsSync as existsSync7 } from "fs";
+import pc5 from "picocolors";
+import { existsSync as existsSync8 } from "fs";
 import { basename as basename2 } from "path";
 
 // src/cursor/paths.ts
@@ -692,17 +981,17 @@ function cursorHistoryDir() {
 // src/cursor/watcher.ts
 import chokidar from "chokidar";
 import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { basename, dirname as dirname3, join as join5 } from "path";
 
 // src/cursor/entries.ts
 import { readFile } from "fs/promises";
-import { existsSync as existsSync4, statSync } from "fs";
+import { existsSync as existsSync5, statSync } from "fs";
 import { join as join3, dirname as dirname2, resolve, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function readEntries(historyFolder) {
   const path = join3(historyFolder, "entries.json");
-  if (!existsSync4(path)) return null;
+  if (!existsSync5(path)) return null;
   try {
     const raw = await readFile(path, "utf8");
     return JSON.parse(raw);
@@ -723,7 +1012,7 @@ function findWorkspaceRoot(path) {
   while (dir && dir !== sep2) {
     const git = join3(dir, ".git");
     try {
-      if (existsSync4(git)) return dir;
+      if (existsSync5(git)) return dir;
     } catch {
     }
     const parent = dirname2(dir);
@@ -762,7 +1051,7 @@ function computeDiff(before, after) {
 }
 
 // src/redact/ignore.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join4, relative, sep as sep3 } from "path";
 import ignore from "ignore";
 var FILENAME = ".agentreelignore";
@@ -770,9 +1059,9 @@ var TTL_MS = 5e3;
 var cache = /* @__PURE__ */ new Map();
 function loadFor(workspace) {
   const path = join4(workspace, FILENAME);
-  if (!existsSync5(path)) return null;
+  if (!existsSync6(path)) return null;
   try {
-    const raw = readFileSync4(path, "utf8");
+    const raw = readFileSync5(path, "utf8");
     return ignore({ allowRelativePaths: true }).add(raw);
   } catch {
     return null;
@@ -783,7 +1072,7 @@ function getCached(workspace) {
   const path = join4(workspace, FILENAME);
   let mtime = 0;
   try {
-    mtime = existsSync5(path) ? statSync2(path).mtimeMs : 0;
+    mtime = existsSync6(path) ? statSync2(path).mtimeMs : 0;
   } catch {
     mtime = 0;
   }
@@ -1006,11 +1295,11 @@ async function processSnapshot(folder, ctx, skipFirst, onSnapshot) {
   let after = "";
   if (ctx.previous) {
     const prevPath = join5(folder, ctx.previous.id);
-    if (existsSync6(prevPath)) {
+    if (existsSync7(prevPath)) {
       before = await safeRead(prevPath);
     }
   }
-  if (existsSync6(newSnapshot)) {
+  if (existsSync7(newSnapshot)) {
     after = await safeRead(newSnapshot);
   }
   if (before === after) return;
@@ -1057,12 +1346,17 @@ function sleep(ms) {
 var NOISY_PATH = /[\\/](node_modules|\.next|\.turbo|dist|build|\.git|coverage|\.cache|\.venv|venv|target|out)[\\/]/;
 
 // src/cursor/session.ts
+init_db();
+init_config();
 import { nanoid } from "nanoid";
 var IDLE_MS = 5 * 60 * 1e3;
 var GLOBAL_KEY = "__global__";
 var CursorSessionManager = class {
   open = /* @__PURE__ */ new Map();
   ingest(snapshot) {
+    if (isCapturePaused()) {
+      return { sessionId: "__paused__", isNew: false };
+    }
     const key = snapshot.workspace ?? GLOBAL_KEY;
     const ts2 = snapshot.timestamp;
     const cwd = snapshot.workspace ?? "";
@@ -1126,38 +1420,39 @@ var CursorSessionManager = class {
 
 // src/commands/watch.ts
 init_paths();
+init_db();
 async function watchCommand() {
   ensureAgentreelDir();
   getDb();
   const dir = cursorHistoryDir();
-  if (!existsSync7(dir)) {
-    console.error(pc4.red("\u2717 Cursor history directory not found:"));
+  if (!existsSync8(dir)) {
+    console.error(pc5.red("\u2717 Cursor history directory not found:"));
     console.error("  " + dir);
     console.error();
-    console.error(pc4.dim("Open Cursor at least once, edit a file, then re-run."));
-    console.error(pc4.dim("(Or set AGENTREEL_CURSOR_HISTORY_DIR to a custom path.)"));
+    console.error(pc5.dim("Open Cursor at least once, edit a file, then re-run."));
+    console.error(pc5.dim("(Or set AGENTREEL_CURSOR_HISTORY_DIR to a custom path.)"));
     process.exit(1);
   }
-  console.log(pc4.bold(pc4.cyan("AgentReel \xB7 Cursor watcher\n")));
-  console.log(pc4.dim("  watching ") + dir);
-  console.log(pc4.dim("  press Ctrl+C to stop\n"));
+  console.log(pc5.bold(pc5.cyan("AgentReel \xB7 Cursor watcher\n")));
+  console.log(pc5.dim("  watching ") + dir);
+  console.log(pc5.dim("  press Ctrl+C to stop\n"));
   const sessions = new CursorSessionManager();
   const watcher = startCursorWatcher(dir, async (snap) => {
     const { sessionId, isNew } = sessions.ingest(snap);
     const ts2 = new Date(snap.timestamp).toLocaleTimeString();
-    const ws = snap.workspace ? basename2(snap.workspace) : pc4.dim("no-workspace");
+    const ws = snap.workspace ? basename2(snap.workspace) : pc5.dim("no-workspace");
     const file = snap.filePath.split("/").slice(-2).join("/");
-    const sourceLabel = snap.source === "cursor-ai" ? pc4.magenta("ai") : snap.source === "cursor-manual" ? pc4.cyan("man") : pc4.dim("?");
-    const stats = snap.binary ? pc4.dim("binary") : `${pc4.green("+" + snap.added)} ${pc4.red("-" + snap.removed)}`;
+    const sourceLabel = snap.source === "cursor-ai" ? pc5.magenta("ai") : snap.source === "cursor-manual" ? pc5.cyan("man") : pc5.dim("?");
+    const stats = snap.binary ? pc5.dim("binary") : `${pc5.green("+" + snap.added)} ${pc5.red("-" + snap.removed)}`;
     if (isNew) {
       console.log(
-        `${pc4.dim(ts2)}  ${pc4.yellow("session")}  ${pc4.dim(sessionId)}  ${ws}`
+        `${pc5.dim(ts2)}  ${pc5.yellow("session")}  ${pc5.dim(sessionId)}  ${ws}`
       );
     }
-    console.log(`${pc4.dim(ts2)}  edit     ${sourceLabel}  ${file.padEnd(36)}  ${stats}`);
+    console.log(`${pc5.dim(ts2)}  edit     ${sourceLabel}  ${file.padEnd(36)}  ${stats}`);
   });
   const shutdown = async () => {
-    console.log(pc4.dim("\n  closing sessions\u2026"));
+    console.log(pc5.dim("\n  closing sessions\u2026"));
     sessions.closeAll();
     await watcher.close();
     process.exit(0);
@@ -1167,11 +1462,14 @@ async function watchCommand() {
 }
 
 // src/commands/push.ts
-import pc5 from "picocolors";
+init_config();
+init_flush();
+init_client();
+import pc6 from "picocolors";
 async function pushCommand() {
   const cfg = readConfig();
   if (!cfg.apiKey) {
-    console.error(pc5.red("\u2717 Not linked. Run ") + pc5.cyan("agentreel link <api-key>"));
+    console.error(pc6.red("\u2717 Not linked. Run ") + pc6.cyan("agentreel link <api-key>"));
     process.exit(1);
   }
   let totalSessions = 0;
@@ -1183,14 +1481,14 @@ async function pushCommand() {
     } catch (err) {
       const e = err;
       if (err instanceof IngestError) {
-        console.error(pc5.red("\u2717 ") + e.message);
+        console.error(pc6.red("\u2717 ") + e.message);
         if (err.isPermanent) {
           console.error(
-            pc5.dim("  not retrying \u2014 fix the cause (re-link, upgrade plan, etc.) and run push again.")
+            pc6.dim("  not retrying \u2014 fix the cause (re-link, upgrade plan, etc.) and run push again.")
           );
         }
       } else {
-        console.error(pc5.red("\u2717 ") + e.message);
+        console.error(pc6.red("\u2717 ") + e.message);
       }
       process.exit(1);
     }
@@ -1199,146 +1497,253 @@ async function pushCommand() {
     if (!res.moreAvailable) break;
   }
   if (totalEvents === 0) {
-    console.log(pc5.green("\u2713") + " queue is empty \u2014 nothing to upload.");
+    console.log(pc6.green("\u2713") + " queue is empty \u2014 nothing to upload.");
     return;
   }
   console.log(
-    pc5.green("\u2713") + ` uploaded ${totalEvents} events \xB7 ${totalSessions} session rows touched`
+    pc6.green("\u2713") + ` uploaded ${totalEvents} events \xB7 ${totalSessions} session rows touched`
   );
 }
 
-// src/commands/daemon.ts
-init_paths();
-import pc6 from "picocolors";
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync } from "fs";
-var TICK_INTERVAL_MS = 3e4;
-var EARLY_FLUSH_BYTES = MAX_BATCH_BYTES;
-async function daemonCommand() {
+// src/cli.ts
+init_daemon();
+
+// src/commands/privacy.ts
+init_config();
+init_db();
+import pc7 from "picocolors";
+import { createInterface } from "readline";
+function pauseCommand() {
   const cfg = readConfig();
-  if (!cfg.apiKey) {
-    console.error(pc6.red("\u2717 Not linked. Run ") + pc6.cyan("agentreel link <api-key>"));
-    process.exit(1);
+  if (cfg.paused) {
+    console.log(pc7.dim("\xB7 already paused"));
+    if (cfg.pausedAt) {
+      console.log(pc7.dim(`  since ${new Date(cfg.pausedAt).toLocaleString()}`));
+    }
+    return;
   }
-  if (!claimPidFile()) {
-    process.exit(1);
+  cfg.paused = true;
+  cfg.pausedAt = Date.now();
+  writeConfig(cfg);
+  console.log(pc7.yellow("\u23F8  capture paused"));
+  console.log(
+    pc7.dim(
+      "  Claude Code hooks and the Cursor watcher will no-op until you " + pc7.cyan("agentreel resume") + pc7.dim(".")
+    )
+  );
+  console.log(
+    pc7.dim(
+      "  Existing local events stay put. They won't upload while paused (the daemon still runs, but the queue won't grow)."
+    )
+  );
+}
+function resumeCommand() {
+  const cfg = readConfig();
+  if (!cfg.paused) {
+    console.log(pc7.dim("\xB7 capture is already active"));
+    return;
   }
-  const release = () => {
-    try {
-      unlinkSync(DAEMON_PID_PATH);
-    } catch {
-    }
-  };
-  let stopping = false;
-  const stop = () => {
-    if (stopping) return;
-    stopping = true;
-    console.log(pc6.dim("\n  daemon stopping\u2026"));
-    release();
-    process.exit(0);
-  };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-  process.on("beforeExit", release);
-  console.log(pc6.green("\u25CF") + " agentreel daemon running");
-  console.log(pc6.dim(`  api: ${cfg.apiBaseUrl}`));
-  console.log(pc6.dim(`  tick: every ${TICK_INTERVAL_MS / 1e3}s, early flush at ${(EARLY_FLUSH_BYTES / 1024).toFixed(0)} KB`));
-  console.log(pc6.dim("  Ctrl-C to stop"));
-  for (; ; ) {
-    if (stopping) return;
-    const nextAt = nextAttemptAt();
-    const now = Date.now();
-    if (nextAt > now) {
-      await sleepInterruptible(nextAt - now, () => stopping);
-      continue;
+  const pausedAt = cfg.pausedAt;
+  cfg.paused = false;
+  cfg.pausedAt = void 0;
+  writeConfig(cfg);
+  const duration = pausedAt ? fmtDuration2(Date.now() - pausedAt) : null;
+  console.log(pc7.green("\u25B6  capture resumed"));
+  if (duration) {
+    console.log(pc7.dim(`  paused for ${duration}`));
+  }
+}
+async function forgetCommand(ids, opts) {
+  const db = getDb();
+  if (opts.all) {
+    const total = db.prepare(`SELECT COUNT(*) AS c FROM sessions`).get().c;
+    if (total === 0) {
+      console.log(pc7.dim("\xB7 nothing to forget \u2014 local DB is empty"));
+      return;
     }
-    try {
-      for (; ; ) {
-        const res = await flushOnce();
-        if (res.uploadedEvents > 0) {
-          console.log(
-            pc6.dim(`  [${ts()}]`) + pc6.green(" \u2713") + ` ${res.uploadedEvents} events \xB7 ${res.uploadedSessions} sessions`
-          );
-        }
-        if (!res.moreAvailable) break;
-      }
-    } catch (err) {
-      const e = err;
-      if (err instanceof IngestError && err.isPermanent) {
-        console.error(
-          pc6.dim(`  [${ts()}]`) + pc6.red(" \u2717 ") + e.message + pc6.dim(" (5min backoff)")
-        );
-      } else {
-        console.error(pc6.dim(`  [${ts()}]`) + pc6.yellow(" \xB7 ") + e.message);
-      }
+    if (!opts.force && !await confirm(`Delete all ${total} local sessions? `)) {
+      console.log(pc7.dim("\xB7 cancelled"));
+      return;
     }
-    await waitForTickOrPressure(TICK_INTERVAL_MS, EARLY_FLUSH_BYTES, () => stopping);
+    db.transaction(() => {
+      db.exec(`DELETE FROM events`);
+      db.exec(`DELETE FROM sessions`);
+      db.exec(`DELETE FROM meta WHERE key LIKE 'cost_%'`);
+    })();
+    console.log(pc7.green("\u2713") + ` forgot ${total} sessions and their events`);
+    console.log(
+      pc7.dim(
+        "  Cloud-side rows are untouched. Delete them from the dashboard if you also want them gone from agentreel.dev."
+      )
+    );
+    return;
   }
-}
-function claimPidFile() {
-  ensureAgentreelDir();
-  if (existsSync8(DAEMON_PID_PATH)) {
-    const raw = readFileSync5(DAEMON_PID_PATH, "utf8").trim();
-    const pid = Number(raw);
-    if (Number.isFinite(pid) && pid > 0 && isAlive(pid)) {
-      console.error(pc6.red(`\u2717 daemon already running (pid ${pid})`));
-      console.error(pc6.dim(`  if this is wrong, remove ${DAEMON_PID_PATH}`));
-      return false;
+  if (ids.length === 0) {
+    console.error(
+      pc7.red("\u2717 provide one or more session ids, or --all to wipe everything")
+    );
+    console.error(pc7.dim(`  example: agentreel forget abcd1234`));
+    process.exit(1);
+  }
+  const stmt = db.prepare(
+    `SELECT id FROM sessions WHERE id = ? OR id LIKE ?`
+  );
+  const delEvents = db.prepare(`DELETE FROM events WHERE session_id = ?`);
+  const delSession = db.prepare(`DELETE FROM sessions WHERE id = ?`);
+  const delMeta = db.prepare(`DELETE FROM meta WHERE key LIKE ?`);
+  const matched = [];
+  for (const raw of ids) {
+    const rows = stmt.all(raw, `${raw}%`);
+    if (rows.length === 0) {
+      console.error(pc7.yellow(`\xB7 no session matched "${raw}"`));
+      continue;
     }
+    for (const r of rows) matched.push(r.id);
   }
-  writeFileSync3(DAEMON_PID_PATH, String(process.pid), { encoding: "utf8", mode: 384 });
-  return true;
-}
-function isAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+  if (matched.length === 0) {
+    console.error(pc7.red("\u2717 nothing matched, nothing deleted"));
+    process.exit(1);
   }
+  if (!opts.force && !await confirm(`Delete ${matched.length} session(s) and their events? `)) {
+    console.log(pc7.dim("\xB7 cancelled"));
+    return;
+  }
+  db.transaction(() => {
+    for (const id of matched) {
+      delEvents.run(id);
+      delSession.run(id);
+      delMeta.run(`cost_%:${id}`);
+    }
+  })();
+  console.log(pc7.green("\u2713") + ` forgot ${matched.length} session(s)`);
 }
-function sleepInterruptible(ms, shouldStop) {
-  return new Promise((resolve2) => {
-    if (ms <= 0) return resolve2();
-    const start = Date.now();
-    const t = setInterval(() => {
-      if (shouldStop() || Date.now() - start >= ms) {
-        clearInterval(t);
-        resolve2();
-      }
-    }, 250);
-  });
-}
-function waitForTickOrPressure(tickMs, pressureBytes, shouldStop) {
+function confirm(prompt) {
   return new Promise((resolve2) => {
-    const start = Date.now();
-    const t = setInterval(() => {
-      if (shouldStop()) {
-        clearInterval(t);
-        return resolve2();
-      }
-      if (Date.now() - start >= tickMs) {
-        clearInterval(t);
-        return resolve2();
-      }
-      try {
-        if (pendingByteSize() >= pressureBytes) {
-          clearInterval(t);
-          return resolve2();
-        }
-      } catch {
-      }
-    }, 1e3);
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt + "[y/N] ", (answer) => {
+      rl.close();
+      resolve2(/^y(es)?$/i.test(answer.trim()));
+    });
   });
 }
-function ts() {
-  const d = /* @__PURE__ */ new Date();
-  return d.toTimeString().slice(0, 8);
+function fmtDuration2(ms) {
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return `${d}d ${h % 24}h`;
 }
 
 // src/hooks/handler.ts
+init_db();
+init_paths();
 import { nanoid as nanoid2 } from "nanoid";
 import { appendFileSync } from "fs";
-init_paths();
+
+// src/cost/transcript.ts
+init_db();
+import { existsSync as existsSync9, statSync as statSync3, openSync as openSync2, readSync, closeSync } from "fs";
+
+// src/cost/pricing.ts
+var MODEL_RATES = {
+  // Claude 4.x
+  "claude-opus-4-7": { input: 1500, output: 7500, cacheRead: 150, cacheCreation: 1875 },
+  "claude-opus-4-6": { input: 1500, output: 7500, cacheRead: 150, cacheCreation: 1875 },
+  "claude-sonnet-4-6": { input: 300, output: 1500, cacheRead: 30, cacheCreation: 375 },
+  "claude-sonnet-4-5": { input: 300, output: 1500, cacheRead: 30, cacheCreation: 375 },
+  "claude-haiku-4-5": { input: 80, output: 400, cacheRead: 8, cacheCreation: 100 },
+  // Legacy 3.x (still seen in older transcripts)
+  "claude-3-5-sonnet": { input: 300, output: 1500, cacheRead: 30, cacheCreation: 375 },
+  "claude-3-5-haiku": { input: 80, output: 400, cacheRead: 8, cacheCreation: 100 },
+  "claude-3-opus": { input: 1500, output: 7500, cacheRead: 150, cacheCreation: 1875 }
+};
+var FALLBACK = MODEL_RATES["claude-sonnet-4-6"];
+function ratesFor(model) {
+  if (!model) return FALLBACK;
+  if (MODEL_RATES[model]) return MODEL_RATES[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_RATES[stripped]) return MODEL_RATES[stripped];
+  for (const key of Object.keys(MODEL_RATES)) {
+    if (model.startsWith(key)) return MODEL_RATES[key];
+  }
+  return FALLBACK;
+}
+function costCentsFor(usage, rates) {
+  const c = (usage.inputTokens * rates.input + usage.outputTokens * rates.output + usage.cacheReadTokens * rates.cacheRead + usage.cacheCreationTokens * rates.cacheCreation) / 1e6;
+  return Math.ceil(c);
+}
+
+// src/cost/transcript.ts
+var KEY_OFFSET = (sid) => `cost_offset:${sid}`;
+var KEY_TOKENS = (sid) => `cost_tokens:${sid}`;
+var KEY_CENTS = (sid) => `cost_cents:${sid}`;
+var KEY_PATH = (sid) => `cost_path:${sid}`;
+function recomputeSessionCost(sessionId, transcriptPath) {
+  if (!transcriptPath) {
+    transcriptPath = getMeta(KEY_PATH(sessionId)) ?? void 0;
+  } else {
+    setMeta(KEY_PATH(sessionId), transcriptPath);
+  }
+  if (!transcriptPath || !existsSync9(transcriptPath)) return;
+  const stat = statSync3(transcriptPath);
+  const totalSize = stat.size;
+  const offset = Number(getMeta(KEY_OFFSET(sessionId)) ?? "0");
+  if (offset >= totalSize) return;
+  const buf = Buffer.alloc(totalSize - offset);
+  const fd = openSync2(transcriptPath, "r");
+  try {
+    readSync(fd, buf, 0, buf.length, offset);
+  } finally {
+    closeSync(fd);
+  }
+  const text = buf.toString("utf8");
+  const lastNewline = text.lastIndexOf("\n");
+  if (lastNewline === -1) return;
+  const consumable = text.slice(0, lastNewline);
+  const consumedBytes = Buffer.byteLength(consumable, "utf8") + 1;
+  let addedTokens = 0;
+  let addedCents = 0;
+  for (const raw of consumable.split("\n")) {
+    if (!raw) continue;
+    let line;
+    try {
+      line = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (line.type !== "assistant") continue;
+    const usage = line.message?.usage;
+    if (!usage) continue;
+    const u = {
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+      cacheCreationTokens: usage.cache_creation_input_tokens ?? 0
+    };
+    const rates = ratesFor(line.message?.model);
+    addedCents += costCentsFor(u, rates);
+    addedTokens += u.inputTokens + u.outputTokens + u.cacheReadTokens + u.cacheCreationTokens;
+  }
+  const prevTokens = Number(getMeta(KEY_TOKENS(sessionId)) ?? "0");
+  const prevCents = Number(getMeta(KEY_CENTS(sessionId)) ?? "0");
+  const newTokens = prevTokens + addedTokens;
+  const newCents = prevCents + addedCents;
+  setMeta(KEY_OFFSET(sessionId), String(offset + consumedBytes));
+  setMeta(KEY_TOKENS(sessionId), String(newTokens));
+  setMeta(KEY_CENTS(sessionId), String(newCents));
+  const db = getDb();
+  db.prepare(
+    `UPDATE sessions
+       SET total_cost_cents = ?, total_tokens = ?
+     WHERE id = ?`
+  ).run(newCents, newTokens, sessionId);
+}
+
+// src/hooks/handler.ts
+init_config();
 var HOOK_EVENT_TO_TYPE = {
   SessionStart: "session_start",
   SessionEnd: "session_end",
@@ -1369,6 +1774,10 @@ function logError(err) {
 }
 async function runHook(eventArg) {
   try {
+    if (isCapturePaused()) {
+      await readStdin().catch(() => "");
+      return;
+    }
     const raw = await readStdin();
     if (!raw.trim()) return;
     const input = JSON.parse(raw);
@@ -1410,13 +1819,18 @@ async function runHook(eventArg) {
       payload: safePayload
     };
     insertEvent(event);
+    try {
+      recomputeSessionCost(sessionId, input.transcript_path);
+    } catch (err) {
+      logError(err);
+    }
   } catch (err) {
     logError(err);
   }
 }
 
 // src/cli.ts
-var VERSION = true ? "0.1.2" : "dev";
+var VERSION = true ? "0.1.5" : "dev";
 var program = new Command();
 program.name("agentreel").description("AgentReel \u2014 capture Claude Code and Cursor sessions locally").version(VERSION);
 program.command("init").description("install Claude Code hooks and create the local SQLite buffer").action(async () => {
@@ -1434,8 +1848,20 @@ program.command("link [api-key]").description("authenticate the local agent with
 program.command("push").description("upload pending events to agentreel.dev").action(async () => {
   await pushCommand();
 });
-program.command("daemon").description("run the background uploader (30s ticks, 1MB early-flush, exponential backoff)").action(async () => {
-  await daemonCommand();
+program.command("daemon").description("run the background uploader (30s ticks, 1MB early-flush, exponential backoff)").option("--detach", "fork into the background and return immediately; logs to ~/.agentreel/daemon.log").action(async (opts) => {
+  await daemonCommand({ detach: opts.detach });
+});
+program.command("stop").description("stop the running background uploader").action(() => {
+  stopCommand();
+});
+program.command("pause").description("pause local capture \u2014 hooks and watcher no-op until `resume`").action(() => {
+  pauseCommand();
+});
+program.command("resume").description("resume local capture after `pause`").action(() => {
+  resumeCommand();
+});
+program.command("forget [session-ids...]").description("delete captured sessions from the local SQLite buffer").option("--all", "wipe every session (asks for confirmation)").option("--force", "skip the confirmation prompt (use with care)").action(async (ids, opts) => {
+  await forgetCommand(ids ?? [], opts);
 });
 program.command("logout").description("clear local credentials").action(async () => {
   await logoutCommand();