@agentreel/agent 0.1.2 → 0.1.4

package/dist/cli.js

@@ -121,23 +121,8 @@ 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 readConfig() {
   if (!existsSync2(CONFIG_PATH)) return { ...DEFAULT };
   try {
@@ -158,11 +143,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 +260,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 +295,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 +378,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 +446,320 @@ 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.\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`;
@@ -587,44 +850,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 +932,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 +959,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 +990,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 +1029,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 +1037,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 +1050,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 +1273,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,6 +1324,7 @@ 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();
 import { nanoid } from "nanoid";
 var IDLE_MS = 5 * 60 * 1e3;
 var GLOBAL_KEY = "__global__";
@@ -1126,38 +1394,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 +1436,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 +1455,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 +1471,123 @@ 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
+// src/cli.ts
+init_daemon();
+
+// src/hooks/handler.ts
+init_db();
 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() {
-  const cfg = readConfig();
-  if (!cfg.apiKey) {
-    console.error(pc6.red("\u2717 Not linked. Run ") + pc6.cyan("agentreel link <api-key>"));
-    process.exit(1);
-  }
-  if (!claimPidFile()) {
-    process.exit(1);
+import { nanoid as nanoid2 } from "nanoid";
+import { appendFileSync } from "fs";
+
+// 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];
   }
-  const release = () => {
+  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 {
-      unlinkSync(DAEMON_PID_PATH);
+      line = JSON.parse(raw);
     } 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;
     }
-    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);
-      }
-    }
-    await waitForTickOrPressure(TICK_INTERVAL_MS, EARLY_FLUSH_BYTES, () => stopping);
-  }
-}
-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;
-    }
-  }
-  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 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);
+    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
-import { nanoid as nanoid2 } from "nanoid";
-import { appendFileSync } from "fs";
-init_paths();
 var HOOK_EVENT_TO_TYPE = {
   SessionStart: "session_start",
   SessionEnd: "session_end",
@@ -1410,13 +1659,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.4" : "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 +1688,11 @@ 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("logout").description("clear local credentials").action(async () => {
   await logoutCommand();