@getverbal/cli 0.3.0 → 0.4.1

package/dist/cli.js

@@ -113,7 +113,7 @@ function compareSemver(a, b) {
   }
   return 0;
 }
-var VERSION = "0.3.0";
+var VERSION = "0.4.1";
 
 // src/auth/credentials.ts
 import { readFileSync, writeFileSync, rmSync, mkdirSync, chmodSync, renameSync } from "node:fs";
@@ -180,19 +180,282 @@ async function clearCredentials() {
 var APP_DIR = "getverbal", CREDENTIALS_FILE = "credentials.json";
 var init_credentials = () => {};
 
+// src/mcp/preflight-state.ts
+var exports_preflight_state = {};
+__export(exports_preflight_state, {
+  updatePreflightStats: () => updatePreflightStats,
+  savePreflightState: () => savePreflightState,
+  loadPreflightState: () => loadPreflightState,
+  isCooldownActive: () => isCooldownActive,
+  getDefaultStateDir: () => getDefaultStateDir,
+  drainPendingFeedback: () => drainPendingFeedback,
+  addPendingFeedback: () => addPendingFeedback,
+  activateCooldown: () => activateCooldown,
+  DEFAULT_PREFLIGHT_CONFIG: () => DEFAULT_PREFLIGHT_CONFIG
+});
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function defaultState() {
+  return {
+    config: { ...DEFAULT_PREFLIGHT_CONFIG },
+    stats: { total_shown: 0, total_accepted: 0, total_dismissed: 0, total_skipped: 0, avg_score_when_shown: 0 },
+    cooldown: { active_until: null },
+    pending_feedback: []
+  };
+}
+function loadPreflightState(stateDir) {
+  const statePath = path.join(stateDir, STATE_FILENAME);
+  try {
+    if (!fs.existsSync(statePath))
+      return defaultState();
+    const raw = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const obj = raw;
+      return {
+        config: { ...DEFAULT_PREFLIGHT_CONFIG, ...obj.config },
+        stats: { ...defaultState().stats, ...obj.stats },
+        cooldown: obj.cooldown ?? { active_until: null },
+        pending_feedback: Array.isArray(obj.pending_feedback) ? obj.pending_feedback : []
+      };
+    }
+  } catch {}
+  return defaultState();
+}
+function savePreflightState(stateDir, state) {
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, STATE_FILENAME), JSON.stringify(state, null, 2));
+}
+function getDefaultStateDir() {
+  return path.join(os.homedir(), ".verbal");
+}
+function updatePreflightStats(state, action, score) {
+  const stats = { ...state.stats };
+  if (action === "shown") {
+    const prevTotal = stats.total_shown;
+    stats.total_shown += 1;
+    stats.avg_score_when_shown = Math.round((stats.avg_score_when_shown * prevTotal + score) / stats.total_shown);
+  } else if (action === "accepted") {
+    stats.total_accepted += 1;
+  } else if (action === "dismissed") {
+    stats.total_dismissed += 1;
+  } else if (action === "skipped") {
+    stats.total_skipped += 1;
+  }
+  return { ...state, stats };
+}
+function isCooldownActive(state) {
+  if (!state.cooldown.active_until)
+    return false;
+  return new Date(state.cooldown.active_until) > new Date;
+}
+function activateCooldown(state, minutes) {
+  const until = new Date(Date.now() + minutes * 60 * 1000).toISOString();
+  return { ...state, cooldown: { active_until: until } };
+}
+function addPendingFeedback(state, entry) {
+  return { ...state, pending_feedback: [...state.pending_feedback, entry] };
+}
+function drainPendingFeedback(state) {
+  return {
+    feedback: [...state.pending_feedback],
+    updatedState: { ...state, pending_feedback: [] }
+  };
+}
+var DEFAULT_PREFLIGHT_CONFIG, STATE_FILENAME = "preflight-state.json";
+var init_preflight_state = __esm(() => {
+  DEFAULT_PREFLIGHT_CONFIG = {
+    threshold: 60,
+    cooldown_minutes: 15,
+    mode: "notify",
+    enable_llm_rewrite: false
+  };
+});
+
+// src/agent-hooks/launchagent.ts
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildUnifiedWatcherPlist(options) {
+  const { nodePath, cliPath, configPath } = options;
+  return `<?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>ai.verbal.watcher</string>
+` + `  <key>ProgramArguments</key>
+` + `  <array>
+` + `    <string>${escapeXml(nodePath)}</string>
+` + `    <string>${escapeXml(cliPath)}</string>
+` + `    <string>watch</string>
+` + `  </array>
+` + `  <key>RunAtLoad</key>
+` + `  <true/>
+` + `  <key>KeepAlive</key>
+` + `  <true/>
+` + `  <key>EnvironmentVariables</key>
+` + `  <dict>
+` + (configPath ? `    <key>VERBAL_CONFIG_PATH</key>
+    <string>${escapeXml(configPath)}</string>
+` : "") + `  </dict>
+` + `</dict>
+` + `</plist>
+`;
+}
+function buildCodexLaunchAgentPlist(options) {
+  const { nodePath, cliPath, configPath } = options;
+  return `<?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>ai.verbal.codex-hooks</string>
+` + `  <key>ProgramArguments</key>
+` + `  <array>
+` + `    <string>${escapeXml(nodePath)}</string>
+` + `    <string>${escapeXml(cliPath)}</string>
+` + `    <string>watch</string>
+` + `    <string>--codex</string>
+` + `  </array>
+` + `  <key>RunAtLoad</key>
+` + `  <true/>
+` + `  <key>KeepAlive</key>
+` + `  <true/>
+` + `  <key>EnvironmentVariables</key>
+` + `  <dict>
+` + (configPath ? `    <key>VERBAL_CONFIG_PATH</key>
+    <string>${escapeXml(configPath)}</string>
+` : "") + `  </dict>
+` + `</dict>
+` + `</plist>
+`;
+}
+
+// src/agent-hooks/hooks-installer.ts
+var exports_hooks_installer = {};
+__export(exports_hooks_installer, {
+  installUnifiedWatcher: () => installUnifiedWatcher,
+  installClaudeHooks: () => installClaudeHooks
+});
+import fs2 from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync as execSync5 } from "node:child_process";
+function installClaudeHooks(useGlobal = false) {
+  const settingsPath = path2.join(os2.homedir(), ".claude", "settings.json");
+  const hooksRoot = path2.resolve(__dirname2, "..", "..", "hooks");
+  const stopHook = path2.join(hooksRoot, "ingest-stop-hook.sh");
+  const endHook = path2.join(hooksRoot, "ingest-session-end-hook.sh");
+  const configPath = findMcpConfigPath();
+  const settings = readJson(settingsPath) ?? {};
+  settings.hooks = settings.hooks ?? {};
+  upsertHook(settings, "Stop", stopHook, {
+    timeout: 30,
+    statusMessage: "Tracking usage in Verbal",
+    async: true,
+    env: configPath ? { VERBAL_CONFIG_PATH: configPath } : undefined
+  });
+  upsertHook(settings, "SessionEnd", endHook, {
+    timeout: 30,
+    statusMessage: "Finalizing usage data",
+    env: configPath ? { VERBAL_CONFIG_PATH: configPath } : undefined
+  });
+  const reviewPromptHook = path2.join(hooksRoot, "session-review-prompt.js");
+  upsertHook(settings, "Stop", `node ${reviewPromptHook}`, {
+    timeout: 5,
+    statusMessage: "Checking session review timer"
+  });
+  const preflightHook = path2.join(hooksRoot, "preflight-hook.sh");
+  if (fs2.existsSync(preflightHook)) {
+    upsertHook(settings, "UserPromptSubmit", preflightHook, {
+      timeout: 10,
+      statusMessage: "Coaching prompt",
+      env: configPath ? { VERBAL_CONFIG_PATH: configPath } : undefined
+    });
+  }
+  fs2.mkdirSync(path2.dirname(settingsPath), { recursive: true });
+  fs2.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+function installUnifiedWatcher(useGlobal = false) {
+  const plistPath = path2.join(os2.homedir(), "Library", "LaunchAgents", "ai.verbal.watcher.plist");
+  const cliPath = useGlobal ? "getverbal" : path2.resolve(__dirname2, "cli.js");
+  const nodePath = process.execPath;
+  const configPath = findMcpConfigPath() ?? undefined;
+  const plist = buildUnifiedWatcherPlist({ nodePath, cliPath, configPath });
+  fs2.mkdirSync(path2.dirname(plistPath), { recursive: true });
+  const oldPlistPath = path2.join(os2.homedir(), "Library", "LaunchAgents", "ai.verbal.codex-hooks.plist");
+  tryUnloadPlist(oldPlistPath);
+  tryUnloadPlist(plistPath);
+  fs2.writeFileSync(plistPath, plist);
+  try {
+    execSync5(`launchctl load "${plistPath}"`, { stdio: "pipe" });
+  } catch {
+    console.error(`Note: Run 'launchctl load "${plistPath}"' to start the background watcher.`);
+  }
+}
+function tryUnloadPlist(plistPath) {
+  if (!fs2.existsSync(plistPath))
+    return;
+  try {
+    execSync5(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+  } catch {}
+}
+function upsertHook(settings, hookName, command, options) {
+  const hookEntry = {
+    matcher: "",
+    hooks: [{ type: "command", command, ...options }]
+  };
+  settings.hooks = settings.hooks ?? {};
+  settings.hooks[hookName] = settings.hooks[hookName] ?? [];
+  const existingIndex = settings.hooks[hookName].findIndex((entry) => entry.hooks?.some((hook) => hook.command.includes(path2.basename(command))));
+  if (existingIndex >= 0) {
+    settings.hooks[hookName][existingIndex] = hookEntry;
+  } else {
+    settings.hooks[hookName].push(hookEntry);
+  }
+}
+function readJson(filePath) {
+  try {
+    if (!fs2.existsSync(filePath))
+      return null;
+    return JSON.parse(fs2.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function findMcpConfigPath() {
+  let current = process.cwd();
+  for (;; ) {
+    const candidate = path2.join(current, ".mcp.json");
+    if (fs2.existsSync(candidate))
+      return candidate;
+    const parent = path2.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+var __filename2, __dirname2;
+var init_hooks_installer = __esm(() => {
+  __filename2 = fileURLToPath(import.meta.url);
+  __dirname2 = path2.dirname(__filename2);
+});
+
 // src/import/index.ts
 var exports_import = {};
 __export(exports_import, {
   detectImportSources: () => detectImportSources
 });
-import { existsSync as existsSync6, readdirSync } from "node:fs";
-import { join as join10 } from "node:path";
-import { homedir as homedir9 } from "node:os";
+import { existsSync as existsSync7, readdirSync } from "node:fs";
+import { join as join11 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 function detectImportSources() {
   const sources = [];
-  const home = homedir9();
-  const claudeDir = join10(home, ".claude");
-  if (existsSync6(claudeDir)) {
+  const home = homedir10();
+  const claudeDir = join11(home, ".claude");
+  if (existsSync7(claudeDir)) {
     const sessions = countSessions(claudeDir, "projects");
     if (sessions > 0) {
       sources.push({
@@ -203,8 +466,8 @@ function detectImportSources() {
       });
     }
   }
-  const codexDir = join10(home, ".codex");
-  if (existsSync6(codexDir)) {
+  const codexDir = join11(home, ".codex");
+  if (existsSync7(codexDir)) {
     const sessions = countSessions(codexDir, "sessions");
     if (sessions > 0) {
       sources.push({
@@ -219,8 +482,8 @@ function detectImportSources() {
 }
 function countSessions(dir, subdir) {
   try {
-    const target = join10(dir, subdir);
-    if (!existsSync6(target))
+    const target = join11(dir, subdir);
+    if (!existsSync7(target))
       return 0;
     return readdirSync(target, { recursive: true }).filter((f) => String(f).endsWith(".jsonl") || String(f).endsWith(".json")).length;
   } catch {
@@ -344,10 +607,10 @@ var init_pricing = __esm(() => {
 });
 
 // src/mcp/git-context.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function gitCommand(cmd, cwd) {
   try {
-    return execSync5(cmd, {
+    return execSync6(cmd, {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
@@ -401,9 +664,9 @@ function getGitContext(cwd) {
 var init_git_context = () => {};
 
 // src/agent-hooks/runtime-context.ts
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
+import fs3 from "node:fs";
+import os3 from "node:os";
+import path3 from "node:path";
 import crypto from "node:crypto";
 function collectRuntimeContext(cwd = process.cwd()) {
   return {
@@ -419,7 +682,7 @@ function readMcpServers(cwd) {
   if (!configPath)
     return [];
   try {
-    const raw = fs.readFileSync(configPath, "utf8");
+    const raw = fs3.readFileSync(configPath, "utf8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers ?? {};
     return Object.entries(servers).map(([name, conf]) => {
@@ -443,22 +706,22 @@ function readMcpServers(cwd) {
 }
 function readInstalledSkills() {
   const roots = [
-    process.env.CODEX_HOME ? path.join(process.env.CODEX_HOME, "skills") : "",
-    path.join(os.homedir(), ".codex", "skills"),
+    process.env.CODEX_HOME ? path3.join(process.env.CODEX_HOME, "skills") : "",
+    path3.join(os3.homedir(), ".codex", "skills"),
     "/opt/codex/skills"
   ].filter(Boolean);
   const seen = new Set;
   const skills = [];
   for (const root of roots) {
-    if (!fs.existsSync(root))
+    if (!fs3.existsSync(root))
       continue;
-    const entries = fs.readdirSync(root, { withFileTypes: true });
+    const entries = fs3.readdirSync(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const skillDir = path.join(root, entry.name);
-      const skillDoc = path.join(skillDir, "SKILL.md");
-      if (!fs.existsSync(skillDoc))
+      const skillDir = path3.join(root, entry.name);
+      const skillDoc = path3.join(skillDir, "SKILL.md");
+      if (!fs3.existsSync(skillDoc))
         continue;
       const key = `${entry.name}:${skillDir}`;
       if (seen.has(key))
@@ -476,10 +739,10 @@ function readActiveSkills() {
 function findMcpConfig(startDir) {
   let current = startDir;
   for (;; ) {
-    const candidate = path.join(current, ".mcp.json");
-    if (fs.existsSync(candidate))
+    const candidate = path3.join(current, ".mcp.json");
+    if (fs3.existsSync(candidate))
       return candidate;
-    const parent = path.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current)
       return null;
     current = parent;
@@ -638,9 +901,9 @@ var init_session_tracker = __esm(() => {
 
 // src/mcp/ingestor.ts
 import crypto2 from "node:crypto";
-import fs2 from "node:fs";
-import os2 from "node:os";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import os4 from "node:os";
+import path4 from "node:path";
 
 class VerbalIngestor {
   config;
@@ -666,7 +929,7 @@ class VerbalIngestor {
       billingType: config.billingType ?? "api",
       maxRetries: config.maxRetries ?? 3,
       retryBaseDelayMs: config.retryBaseDelayMs ?? 200,
-      deadLetterPath: config.deadLetterPath ?? path2.join(os2.homedir(), ".verbal", "dead-letter.jsonl")
+      deadLetterPath: config.deadLetterPath ?? path4.join(os4.homedir(), ".verbal", "dead-letter.jsonl")
     };
     this.runtimeContext = collectRuntimeContext();
     this.gitContext = this.config.gitContextEnabled ? getGitContext(process.cwd()) : null;
@@ -811,135 +1074,998 @@ class VerbalIngestor {
   isUuid(value) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
   }
-  async postToIngest(body) {
-    const payload = JSON.stringify(body);
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.config.apiKey}`
-    };
-    if (this.config.hmacSecret) {
-      const signature = crypto2.createHmac("sha256", this.config.hmacSecret).update(payload).digest("hex");
-      headers["x-verbal-signature"] = signature;
+  async postToIngest(body) {
+    const payload = JSON.stringify(body);
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`
+    };
+    if (this.config.hmacSecret) {
+      const signature = crypto2.createHmac("sha256", this.config.hmacSecret).update(payload).digest("hex");
+      headers["x-verbal-signature"] = signature;
+    }
+    const eventCount = "events" in body ? body.events.length : 1;
+    for (let attempt = 0;attempt <= this.config.maxRetries; attempt++) {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), this.config.httpTimeoutMs);
+      try {
+        const response = await fetch(this.config.endpoint, {
+          method: "POST",
+          headers,
+          body: payload,
+          signal: controller.signal
+        });
+        if (response.ok) {
+          return {
+            ok: true,
+            status: response.status,
+            statusText: response.statusText,
+            sent: eventCount,
+            failed: 0
+          };
+        }
+        if (attempt < this.config.maxRetries && response.status >= 500) {
+          await this.sleepWithJitter(attempt);
+          continue;
+        }
+        await this.writeDeadLetter(body, `HTTP ${response.status} ${response.statusText}`);
+        return {
+          ok: false,
+          status: response.status,
+          statusText: response.statusText,
+          sent: 0,
+          failed: eventCount
+        };
+      } catch (error) {
+        if (attempt < this.config.maxRetries) {
+          await this.sleepWithJitter(attempt);
+          continue;
+        }
+        const statusText = error instanceof Error ? error.message : "Unknown error";
+        await this.writeDeadLetter(body, statusText);
+        return {
+          ok: false,
+          statusText,
+          sent: 0,
+          failed: eventCount
+        };
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    await this.writeDeadLetter(body, "Retry budget exhausted");
+    return {
+      ok: false,
+      statusText: "Retry budget exhausted",
+      sent: 0,
+      failed: eventCount
+    };
+  }
+  async sleepWithJitter(attempt) {
+    const base = this.config.retryBaseDelayMs * Math.pow(2, attempt);
+    const jitter = Math.floor(Math.random() * this.config.retryBaseDelayMs);
+    const delay = base + jitter;
+    await new Promise((resolve2) => setTimeout(resolve2, delay));
+  }
+  async writeDeadLetter(body, reason) {
+    try {
+      const dir = path4.dirname(this.config.deadLetterPath);
+      fs4.mkdirSync(dir, { recursive: true });
+      const record = {
+        timestamp: new Date().toISOString(),
+        reason,
+        body
+      };
+      fs4.appendFileSync(this.config.deadLetterPath, `${JSON.stringify(record)}
+`, "utf8");
+    } catch (error) {
+      console.error("[VerbalIngestor] Failed to write dead-letter record", error);
+    }
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+  }
+}
+function attachExitHooks(ingestor) {
+  const cleanup = () => {
+    ingestor.flush().catch((err) => {
+      console.error("[VerbalIngestor] Exit flush error:", err);
+    });
+    ingestor.destroy();
+    sessionTracker.destroy();
+  };
+  process.on("beforeExit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+var init_ingestor = __esm(() => {
+  init_pricing();
+  init_git_context();
+  init_runtime_context();
+  init_session_tracker();
+});
+
+// src/platforms/state.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+function loadPlatformState(stateDir, platformId) {
+  const statePath = path5.join(stateDir, `platform-${platformId}-state.json`);
+  try {
+    if (!fs5.existsSync(statePath))
+      return null;
+    return JSON.parse(fs5.readFileSync(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function savePlatformState(stateDir, platformId, state) {
+  const statePath = path5.join(stateDir, `platform-${platformId}-state.json`);
+  fs5.mkdirSync(stateDir, { recursive: true });
+  fs5.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+var init_state = () => {};
+
+// src/shared/parsing-utils.ts
+import fs6 from "node:fs";
+function readJsonLines(filePath) {
+  const content = fs6.readFileSync(filePath, "utf8");
+  const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+  const results = [];
+  for (const line of lines) {
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return results;
+}
+function flattenContent(content) {
+  if (!content)
+    return;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const parts = content.map((item) => {
+      if (!item || typeof item !== "object")
+        return "";
+      const typed = item;
+      if (typed.type === "thinking" || typed.type === "tool_use" || typed.type === "reasoning")
+        return "";
+      return typed.text ?? typed.input_text ?? typed.output_text ?? "";
+    }).filter(Boolean);
+    return parts.length ? parts.join(`
+`) : undefined;
+  }
+  return;
+}
+function estimateTokens(prompt, response) {
+  const tokensIn = prompt ? Math.ceil(prompt.length / 4) : 0;
+  const tokensOut = response ? Math.ceil(response.length / 4) : 0;
+  return { tokensIn, tokensOut };
+}
+var init_parsing_utils = () => {};
+
+// src/platforms/parsers/claude-code.ts
+import fs7 from "node:fs";
+import path6 from "node:path";
+import os5 from "node:os";
+function getEntryId(entry) {
+  return entry.uuid ?? entry.message?.id ?? entry.id ?? entry.messageId;
+}
+function findEntryIndex(entries, id) {
+  return entries.findIndex((entry) => getEntryId(entry) === id);
+}
+function extractMessage(entry) {
+  const message = entry.message;
+  const role = message?.role ?? entry.type;
+  const content = flattenContent(message?.content ?? entry.content);
+  return { role, content };
+}
+function findConversationFiles(baseDir) {
+  if (!fs7.existsSync(baseDir))
+    return [];
+  const results = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && full.endsWith(".jsonl")) {
+        results.push(full);
+      }
+    }
+  };
+  walk(baseDir);
+  return results;
+}
+
+class ClaudeCodeParser {
+  info = {
+    id: "claude-code",
+    name: "Claude Code",
+    provider: "anthropic",
+    billing_type: "subscription"
+  };
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? path6.join(os5.homedir(), ".claude", "projects");
+  }
+  discover() {
+    return findConversationFiles(this.baseDir);
+  }
+  async parse(state, opts) {
+    const claudeState = state;
+    const sessions = claudeState?.sessions ?? {};
+    const warnings = [];
+    const events = [];
+    const files = this.discover();
+    for (const filePath of files) {
+      const relative = path6.relative(this.baseDir, filePath);
+      const sessionId = relative.replace(/\.jsonl$/, "").replace(/[\\/]/g, ":");
+      let entries;
+      try {
+        entries = readJsonLines(filePath);
+      } catch (err) {
+        warnings.push(`Failed to read ${filePath}: ${String(err)}`);
+        continue;
+      }
+      if (entries.length === 0)
+        continue;
+      const lastId = sessions[sessionId];
+      const startIndex = lastId ? findEntryIndex(entries, lastId) + 1 : 0;
+      const newEntries = entries.slice(Math.max(startIndex, 0));
+      if (newEntries.length === 0)
+        continue;
+      let lastUserContent;
+      for (const entry of newEntries) {
+        const { role, content } = extractMessage(entry);
+        if (role === "user" || role === "human") {
+          lastUserContent = content;
+          continue;
+        }
+        if (role === "assistant") {
+          const usage = entry.message?.usage ?? entry.usage;
+          if (!usage)
+            continue;
+          const tokensIn = usage.input_tokens ?? 0;
+          const tokensOut = usage.output_tokens ?? 0;
+          if (!tokensIn && !tokensOut)
+            continue;
+          const entryTimestamp = entry.timestamp ?? new Date().toISOString();
+          if (opts.since && entryTimestamp < opts.since)
+            continue;
+          if (opts.until && entryTimestamp > opts.until)
+            continue;
+          const entryId = getEntryId(entry) ?? `${sessionId}:${events.length}`;
+          const dedupKey = `claude-code:${sessionId}:${entryId}`;
+          const event = {
+            event_id: entryId,
+            request_id: dedupKey,
+            session_id: sessionId,
+            provider: "anthropic",
+            model: entry.message?.model ?? entry.model ?? "claude",
+            tokens_in: tokensIn,
+            tokens_out: tokensOut,
+            cache_read_tokens: usage.cache_read_input_tokens ?? 0,
+            cache_write_tokens: usage.cache_creation_input_tokens ?? 0,
+            timestamp: entryTimestamp,
+            billing_type: "subscription",
+            tags: ["claude-code"],
+            metadata: {
+              stop_reason: entry.message?.stop_reason ?? entry.stop_reason,
+              source_file: filePath
+            }
+          };
+          if (opts.captureMode === "full") {
+            event.prompt = lastUserContent;
+            event.response = content;
+          }
+          events.push(event);
+        }
+      }
+      const lastEntry = newEntries[newEntries.length - 1];
+      const lastEntryId = getEntryId(lastEntry);
+      if (lastEntryId) {
+        sessions[sessionId] = lastEntryId;
+      }
+    }
+    const newState = {
+      ...claudeState,
+      sessions,
+      lastSyncTimestamp: new Date().toISOString()
+    };
+    return { events, newState, warnings };
+  }
+}
+var init_claude_code = __esm(() => {
+  init_parsing_utils();
+});
+
+// src/platforms/parsers/codex.ts
+import fs8 from "node:fs";
+import path7 from "node:path";
+import os6 from "node:os";
+function readCodexFile(filePath) {
+  const content = fs8.readFileSync(filePath, "utf8").trim();
+  if (!content)
+    return { entries: [], sessionId: path7.basename(filePath) };
+  const isJsonl = filePath.endsWith(".jsonl");
+  if (!isJsonl && content.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(content);
+      return {
+        entries: parsed.items ?? [],
+        sessionId: parsed.session?.id ?? path7.basename(filePath)
+      };
+    } catch {}
+  }
+  const lines = content.split(`
+`).filter(Boolean);
+  const entries = lines.map((line) => JSON.parse(line));
+  const sessionMeta = entries.find((entry) => entry.type === "session_meta");
+  const sessionId = sessionMeta?.payload?.id ?? path7.basename(filePath);
+  return { entries, sessionId };
+}
+function extractMessage2(entry) {
+  if (entry.type === "response_item" && entry.payload && typeof entry.payload === "object") {
+    const payload = entry.payload;
+    if (payload.type === "message") {
+      const role = payload.role;
+      const content = flattenContent(payload.content);
+      if (role)
+        return { role, content };
+    }
+  }
+  if (entry.type === "message" && entry.role) {
+    return { role: entry.role, content: flattenContent(entry.content) };
+  }
+  if (entry.type === "user" || entry.type === "assistant") {
+    const role = entry.type;
+    const content = flattenContent(entry.content ?? entry.message);
+    return { role, content };
+  }
+  return null;
+}
+function findSessionFiles(baseDir) {
+  if (!fs8.existsSync(baseDir))
+    return [];
+  const results = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && (full.endsWith(".json") || full.endsWith(".jsonl"))) {
+        results.push(full);
+      }
+    }
+  };
+  walk(baseDir);
+  return results;
+}
+
+class CodexParser {
+  info = {
+    id: "codex",
+    name: "OpenAI Codex",
+    provider: "openai",
+    billing_type: "api"
+  };
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? path7.join(os6.homedir(), ".codex", "sessions");
+  }
+  discover() {
+    return findSessionFiles(this.baseDir);
+  }
+  async parse(state, opts) {
+    const codexState = state;
+    const fileStates = codexState?.files ?? {};
+    const warnings = [];
+    const events = [];
+    const files = this.discover();
+    for (const filePath of files) {
+      let fileEntries;
+      let sessionId;
+      try {
+        const result = readCodexFile(filePath);
+        fileEntries = result.entries;
+        sessionId = result.sessionId;
+      } catch (err) {
+        warnings.push(`Failed to read ${filePath}: ${String(err)}`);
+        continue;
+      }
+      if (fileEntries.length === 0)
+        continue;
+      const fileState = fileStates[filePath] ?? { lastIndex: -1 };
+      const startIndex = Math.max(fileState.lastIndex + 1, 0);
+      const newEntries = fileEntries.slice(startIndex);
+      if (newEntries.length === 0) {
+        fileStates[filePath] = fileState;
+        continue;
+      }
+      let lastUserContent;
+      let currentModel;
+      let currentProvider;
+      let lastTokenUsage;
+      let pendingEvent;
+      let pendingPrompt;
+      let pendingResponse;
+      let eventIndex = 0;
+      for (const entry of newEntries) {
+        if (entry.type === "session_meta" && entry.payload && typeof entry.payload === "object") {
+          const payload = entry.payload;
+          currentProvider = payload.model_provider ?? currentProvider;
+          currentModel = payload.model ?? currentModel;
+          continue;
+        }
+        if (entry.type === "turn_context" && entry.payload && typeof entry.payload === "object") {
+          const payload = entry.payload;
+          currentModel = payload.model ?? currentModel;
+          continue;
+        }
+        if (entry.type === "event_msg" && entry.payload) {
+          const payload = entry.payload;
+          if (payload.type === "token_count" && payload.info?.last_token_usage) {
+            lastTokenUsage = payload.info.last_token_usage;
+            if (pendingEvent) {
+              const usage = lastTokenUsage;
+              pendingEvent.tokens_in = usage.input_tokens ?? 0;
+              pendingEvent.tokens_out = usage.output_tokens ?? 0;
+              const entryTs = pendingEvent.timestamp;
+              if (!opts.since || entryTs >= opts.since) {
+                if (!opts.until || entryTs <= opts.until) {
+                  events.push(pendingEvent);
+                }
+              }
+              pendingEvent = undefined;
+              pendingPrompt = undefined;
+              pendingResponse = undefined;
+              lastTokenUsage = undefined;
+            }
+          }
+          continue;
+        }
+        const message = extractMessage2(entry);
+        if (message) {
+          if (message.role === "user") {
+            lastUserContent = message.content;
+            continue;
+          }
+          if (message.role === "assistant") {
+            if (pendingEvent) {
+              const { tokensIn, tokensOut } = estimateTokens(pendingPrompt, pendingResponse);
+              pendingEvent.tokens_in = tokensIn;
+              pendingEvent.tokens_out = tokensOut;
+              pendingEvent.metadata = {
+                ...pendingEvent.metadata,
+                token_estimate_method: "chars/4"
+              };
+              const entryTs = pendingEvent.timestamp;
+              if (!opts.since || entryTs >= opts.since) {
+                if (!opts.until || entryTs <= opts.until) {
+                  events.push(pendingEvent);
+                }
+              }
+              pendingEvent = undefined;
+              pendingPrompt = undefined;
+              pendingResponse = undefined;
+            }
+            const entryTimestamp = entry.timestamp ?? new Date().toISOString();
+            const entryId = entry.id ?? `${sessionId}:${startIndex + eventIndex}`;
+            const dedupKey = `codex:${sessionId}:${startIndex + eventIndex}`;
+            eventIndex++;
+            const event = {
+              event_id: entryId,
+              request_id: dedupKey,
+              session_id: sessionId,
+              provider: currentProvider ?? "openai",
+              model: currentModel ?? "codex",
+              tokens_in: 0,
+              tokens_out: 0,
+              timestamp: entryTimestamp,
+              billing_type: "api",
+              tags: ["codex"],
+              metadata: {
+                source_file: filePath,
+                source: "codex"
+              }
+            };
+            if (opts.captureMode === "full") {
+              event.prompt = lastUserContent;
+              event.response = message.content;
+            }
+            if (lastTokenUsage) {
+              event.tokens_in = lastTokenUsage.input_tokens ?? 0;
+              event.tokens_out = lastTokenUsage.output_tokens ?? 0;
+              lastTokenUsage = undefined;
+              const entryTs = event.timestamp;
+              if (!opts.since || entryTs >= opts.since) {
+                if (!opts.until || entryTs <= opts.until) {
+                  events.push(event);
+                }
+              }
+            } else {
+              pendingEvent = event;
+              pendingPrompt = lastUserContent;
+              pendingResponse = message.content;
+            }
+          }
+          continue;
+        }
+      }
+      if (pendingEvent) {
+        const { tokensIn, tokensOut } = estimateTokens(pendingPrompt, pendingResponse);
+        pendingEvent.tokens_in = tokensIn;
+        pendingEvent.tokens_out = tokensOut;
+        pendingEvent.metadata = {
+          ...pendingEvent.metadata,
+          token_estimate_method: "chars/4"
+        };
+        const entryTs = pendingEvent.timestamp;
+        if (!opts.since || entryTs >= opts.since) {
+          if (!opts.until || entryTs <= opts.until) {
+            events.push(pendingEvent);
+          }
+        }
+      }
+      fileStates[filePath] = { lastIndex: fileEntries.length - 1 };
+    }
+    const newState = {
+      ...codexState,
+      files: fileStates,
+      lastSyncTimestamp: new Date().toISOString()
+    };
+    return { events, newState, warnings };
+  }
+}
+var init_codex = __esm(() => {
+  init_parsing_utils();
+});
+
+// src/platforms/parsers/cursor.ts
+import fs9 from "node:fs";
+import path8 from "node:path";
+import os7 from "node:os";
+function globVscdbFiles(baseDir) {
+  if (!fs9.existsSync(baseDir))
+    return [];
+  const results = [];
+  let workspaceDirs;
+  try {
+    workspaceDirs = fs9.readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of workspaceDirs) {
+    if (!entry.isDirectory())
+      continue;
+    const candidate = path8.join(baseDir, entry.name, "state.vscdb");
+    if (fs9.existsSync(candidate)) {
+      results.push(candidate);
+    }
+  }
+  return results;
+}
+function extractBubbleId(bubble) {
+  return bubble.bubbleId ?? bubble.id;
+}
+function extractBubbleText(bubble) {
+  if (typeof bubble.text === "string" && bubble.text.length > 0)
+    return bubble.text;
+  return;
+}
+function isAssistantBubble(bubble) {
+  const type = (bubble.type ?? "").toLowerCase();
+  const role = (bubble.role ?? "").toLowerCase();
+  return type === "ai" || type === "assistant" || role === "assistant";
+}
+function isUserBubble(bubble) {
+  const type = (bubble.type ?? "").toLowerCase();
+  const role = (bubble.role ?? "").toLowerCase();
+  return type === "user" || role === "user" || type === "human";
+}
+function bubbleTimestamp(bubble) {
+  const ms = bubble.serverTimestamp ?? bubble.timestamp;
+  if (ms)
+    return new Date(ms).toISOString();
+  return new Date().toISOString();
+}
+
+class CursorParser {
+  info = {
+    id: "cursor",
+    name: "Cursor",
+    provider: "anthropic",
+    billing_type: "subscription"
+  };
+  baseDir;
+  constructor(baseDir) {
+    if (baseDir) {
+      this.baseDir = baseDir;
+    } else if (process.platform === "win32") {
+      this.baseDir = path8.join(process.env.APPDATA || path8.join(os7.homedir(), "AppData", "Roaming"), "Cursor", "User", "workspaceStorage");
+    } else if (process.platform === "linux") {
+      this.baseDir = path8.join(os7.homedir(), ".config", "Cursor", "User", "workspaceStorage");
+    } else {
+      this.baseDir = path8.join(os7.homedir(), "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+    }
+  }
+  discover() {
+    return globVscdbFiles(this.baseDir);
+  }
+  async parse(state, opts) {
+    const cursorState = state;
+    const workspaces = { ...cursorState?.workspaces ?? {} };
+    const warnings = [];
+    const events = [];
+    let Database;
+    try {
+      const mod = await import("bun:sqlite");
+      Database = mod.Database;
+    } catch {
+      warnings.push("Cursor parser requires Bun runtime for SQLite access. Run via `bun run` or `bunx getverbal sync`.");
+      return {
+        events: [],
+        newState: { ...cursorState ?? {}, workspaces, lastSyncTimestamp: new Date().toISOString() },
+        warnings
+      };
     }
-    const eventCount = "events" in body ? body.events.length : 1;
-    for (let attempt = 0;attempt <= this.config.maxRetries; attempt++) {
-      const controller = new AbortController;
-      const timeout = setTimeout(() => controller.abort(), this.config.httpTimeoutMs);
+    const dbFiles = this.discover();
+    for (const dbPath of dbFiles) {
+      const workspaceHash = path8.basename(path8.dirname(dbPath));
+      let mtime;
       try {
-        const response = await fetch(this.config.endpoint, {
-          method: "POST",
-          headers,
-          body: payload,
-          signal: controller.signal
-        });
-        if (response.ok) {
-          return {
-            ok: true,
-            status: response.status,
-            statusText: response.statusText,
-            sent: eventCount,
-            failed: 0
-          };
-        }
-        if (attempt < this.config.maxRetries && response.status >= 500) {
-          await this.sleepWithJitter(attempt);
-          continue;
+        mtime = fs9.statSync(dbPath).mtime.toISOString();
+      } catch (err) {
+        warnings.push(`Cannot stat ${dbPath}: ${String(err)}`);
+        continue;
+      }
+      const prevWorkspaceState = workspaces[workspaceHash];
+      if (prevWorkspaceState?.fullyProcessed && prevWorkspaceState.lastMtime === mtime) {
+        continue;
+      }
+      let db;
+      try {
+        db = new Database(dbPath, { readonly: true });
+        db.exec("PRAGMA journal_mode=WAL");
+        const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all();
+        let lastComposerId = prevWorkspaceState?.lastComposerId ?? "";
+        for (const row of rows) {
+          let composerData;
+          try {
+            composerData = JSON.parse(row.value);
+          } catch {
+            warnings.push(`Failed to parse composer JSON for key ${row.key} in ${dbPath}`);
+            continue;
+          }
+          const composerId = composerData.composerId ?? composerData.id ?? row.key;
+          const bubbles = composerData.allBubbles ?? composerData.bubbles ?? composerData.conversation ?? [];
+          if (bubbles.length === 0)
+            continue;
+          let lastUserText;
+          for (let i = 0;i < bubbles.length; i++) {
+            const bubble = bubbles[i];
+            if (isUserBubble(bubble)) {
+              lastUserText = extractBubbleText(bubble);
+              continue;
+            }
+            if (!isAssistantBubble(bubble))
+              continue;
+            const bubbleId = extractBubbleId(bubble) ?? `${composerId}:${i}`;
+            const dedupKey = `cursor:${workspaceHash}:${composerId}:${bubbleId}`;
+            const timestamp = bubbleTimestamp(bubble);
+            if (opts.since && timestamp < opts.since)
+              continue;
+            if (opts.until && timestamp > opts.until)
+              continue;
+            const responseText = extractBubbleText(bubble);
+            const model = bubble.modelType ?? bubble.model ?? composerData.model ?? "claude";
+            let tokensIn = bubble.inputTokenCount ?? 0;
+            let tokensOut = bubble.outputTokenCount ?? bubble.numTokens ?? 0;
+            let tokenEstimateMethod;
+            if (!tokensIn && !tokensOut) {
+              const est = estimateTokens(lastUserText, responseText);
+              tokensIn = est.tokensIn;
+              tokensOut = est.tokensOut;
+              tokenEstimateMethod = "chars/4";
+            }
+            const event = {
+              event_id: bubbleId,
+              request_id: dedupKey,
+              session_id: `cursor:${workspaceHash}:${composerId}`,
+              provider: "anthropic",
+              model,
+              tokens_in: tokensIn,
+              tokens_out: tokensOut,
+              timestamp,
+              billing_type: "subscription",
+              tags: ["cursor"],
+              metadata: {
+                source_file: dbPath,
+                workspace_hash: workspaceHash,
+                composer_id: composerId,
+                bubble_id: bubbleId,
+                ...tokenEstimateMethod ? { token_estimate_method: tokenEstimateMethod } : {}
+              }
+            };
+            if (opts.captureMode === "full") {
+              event.prompt = lastUserText;
+              event.response = responseText;
+            }
+            events.push(event);
+          }
+          lastComposerId = composerId;
         }
-        await this.writeDeadLetter(body, `HTTP ${response.status} ${response.statusText}`);
-        return {
-          ok: false,
-          status: response.status,
-          statusText: response.statusText,
-          sent: 0,
-          failed: eventCount
+        workspaces[workspaceHash] = {
+          lastMtime: mtime,
+          lastComposerId,
+          fullyProcessed: true
         };
-      } catch (error) {
-        if (attempt < this.config.maxRetries) {
-          await this.sleepWithJitter(attempt);
-          continue;
+      } catch (err) {
+        const msg = String(err);
+        if (msg.includes("SQLITE_BUSY") || msg.includes("SQLITE_LOCKED")) {
+          warnings.push(`Database locked, skipping ${dbPath}: ${msg}`);
+        } else {
+          warnings.push(`Error reading ${dbPath}: ${msg}`);
         }
-        const statusText = error instanceof Error ? error.message : "Unknown error";
-        await this.writeDeadLetter(body, statusText);
-        return {
-          ok: false,
-          statusText,
-          sent: 0,
-          failed: eventCount
-        };
       } finally {
-        clearTimeout(timeout);
+        try {
+          db?.close();
+        } catch {}
       }
     }
-    await this.writeDeadLetter(body, "Retry budget exhausted");
-    return {
-      ok: false,
-      statusText: "Retry budget exhausted",
-      sent: 0,
-      failed: eventCount
+    const newState = {
+      ...cursorState ?? {},
+      workspaces,
+      lastSyncTimestamp: new Date().toISOString()
     };
+    return { events, newState, warnings };
   }
-  async sleepWithJitter(attempt) {
-    const base = this.config.retryBaseDelayMs * Math.pow(2, attempt);
-    const jitter = Math.floor(Math.random() * this.config.retryBaseDelayMs);
-    const delay = base + jitter;
-    await new Promise((resolve2) => setTimeout(resolve2, delay));
-  }
-  async writeDeadLetter(body, reason) {
+}
+var init_cursor = __esm(() => {
+  init_parsing_utils();
+});
+
+// src/platforms/parsers/gemini.ts
+import fs10 from "node:fs";
+import path9 from "node:path";
+import os8 from "node:os";
+function flattenParts(parts) {
+  if (!parts || parts.length === 0)
+    return;
+  const texts = parts.map((p) => p.text ?? "").filter(Boolean);
+  return texts.length ? texts.join(`
+`) : undefined;
+}
+function chatDirs(home) {
+  return [
+    path9.join(home, ".gemini", "tmp"),
+    path9.join(home, ".gemini", "chats"),
+    path9.join(home, ".config", "gemini", "chats")
+  ];
+}
+function findJsonFiles(baseDir) {
+  if (!fs10.existsSync(baseDir))
+    return [];
+  const results = [];
+  const walk = (dir) => {
+    let entries;
     try {
-      const dir = path2.dirname(this.config.deadLetterPath);
-      fs2.mkdirSync(dir, { recursive: true });
-      const record = {
-        timestamp: new Date().toISOString(),
-        reason,
-        body
-      };
-      fs2.appendFileSync(this.config.deadLetterPath, `${JSON.stringify(record)}
-`, "utf8");
-    } catch (error) {
-      console.error("[VerbalIngestor] Failed to write dead-letter record", error);
+      entries = fs10.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
     }
-  }
-  destroy() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = undefined;
+    for (const entry of entries) {
+      const full = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && full.endsWith(".json")) {
+        results.push(full);
+      }
     }
+  };
+  walk(baseDir);
+  return results;
+}
+function extractMessages(session) {
+  return session.messages ?? session.contents ?? session.history ?? [];
+}
+function deriveSessionId(filePath, home) {
+  const rel = path9.relative(home, filePath).replace(/\.json$/, "").replace(/[\\/]/g, ":");
+  return rel || path9.basename(filePath, ".json");
+}
+function deriveProjectHash(filePath) {
+  const parts = filePath.split(path9.sep);
+  const tmpIdx = parts.lastIndexOf("tmp");
+  if (tmpIdx !== -1 && parts.length > tmpIdx + 1) {
+    return parts[tmpIdx + 1];
   }
+  return "default";
 }
-function attachExitHooks(ingestor) {
-  const cleanup = () => {
-    ingestor.flush().catch((err) => {
-      console.error("[VerbalIngestor] Exit flush error:", err);
-    });
-    ingestor.destroy();
-    sessionTracker.destroy();
+
+class GeminiParser {
+  info = {
+    id: "gemini",
+    name: "Gemini CLI",
+    provider: "google",
+    billing_type: "api"
   };
-  process.on("beforeExit", cleanup);
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(0);
-  });
+  home;
+  constructor(home) {
+    this.home = home ?? os8.homedir();
+  }
+  discover() {
+    const results = [];
+    for (const dir of chatDirs(this.home)) {
+      results.push(...findJsonFiles(dir));
+    }
+    return [...new Set(results)];
+  }
+  async parse(state, opts) {
+    const geminiState = state;
+    const fileStates = { ...geminiState?.files ?? {} };
+    const warnings = [];
+    const events = [];
+    const files = this.discover();
+    for (const filePath of files) {
+      let mtime;
+      try {
+        mtime = fs10.statSync(filePath).mtime.toISOString();
+      } catch (err) {
+        warnings.push(`Cannot stat ${filePath}: ${String(err)}`);
+        continue;
+      }
+      const prevFileState = fileStates[filePath];
+      if (prevFileState && prevFileState.lastMtime === mtime) {
+        continue;
+      }
+      let session;
+      try {
+        const raw = fs10.readFileSync(filePath, "utf8");
+        session = JSON.parse(raw);
+      } catch (err) {
+        warnings.push(`Failed to read/parse ${filePath}: ${String(err)}`);
+        continue;
+      }
+      const messages = extractMessages(session);
+      if (messages.length === 0) {
+        fileStates[filePath] = { lastMtime: mtime, lastMessageIndex: -1 };
+        continue;
+      }
+      const startIndex = (prevFileState?.lastMessageIndex ?? -1) + 1;
+      const newMessages = messages.slice(startIndex);
+      if (newMessages.length === 0) {
+        fileStates[filePath] = { lastMtime: mtime, lastMessageIndex: messages.length - 1 };
+        continue;
+      }
+      const sessionId = deriveSessionId(filePath, this.home);
+      const projectHash = deriveProjectHash(filePath);
+      const modelFromMeta = session.metadata?.model ?? session.model ?? "gemini";
+      let lastUserText;
+      for (let i = 0;i < newMessages.length; i++) {
+        const msg = newMessages[i];
+        const role = (msg.role ?? "").toLowerCase();
+        const absoluteIndex = startIndex + i;
+        const text = flattenParts(msg.parts);
+        if (role === "user") {
+          lastUserText = text;
+          continue;
+        }
+        if (role !== "model" && role !== "assistant")
+          continue;
+        const usage = msg.usageMetadata ?? msg.metadata?.usageMetadata;
+        const timestamp = mtime;
+        if (opts.since && timestamp < opts.since)
+          continue;
+        if (opts.until && timestamp > opts.until)
+          continue;
+        let tokensIn = usage?.promptTokenCount ?? 0;
+        let tokensOut = usage?.candidatesTokenCount ?? 0;
+        let tokenEstimateMethod;
+        if (!tokensIn && !tokensOut) {
+          const est = estimateTokens(lastUserText, text);
+          tokensIn = est.tokensIn;
+          tokensOut = est.tokensOut;
+          tokenEstimateMethod = "chars/4";
+        }
+        const dedupKey = `gemini:${projectHash}:${sessionId}:${absoluteIndex}`;
+        const event = {
+          event_id: `${sessionId}:${absoluteIndex}`,
+          request_id: dedupKey,
+          session_id: sessionId,
+          provider: "google",
+          model: modelFromMeta,
+          tokens_in: tokensIn,
+          tokens_out: tokensOut,
+          timestamp,
+          billing_type: "api",
+          tags: ["gemini"],
+          metadata: {
+            source_file: filePath,
+            project_hash: projectHash,
+            message_index: absoluteIndex,
+            ...tokenEstimateMethod ? { token_estimate_method: tokenEstimateMethod } : {}
+          }
+        };
+        if (opts.captureMode === "full") {
+          event.prompt = lastUserText;
+          event.response = text;
+        }
+        events.push(event);
+      }
+      fileStates[filePath] = { lastMtime: mtime, lastMessageIndex: messages.length - 1 };
+    }
+    const newState = {
+      ...geminiState ?? {},
+      files: fileStates,
+      lastSyncTimestamp: new Date().toISOString()
+    };
+    return { events, newState, warnings };
+  }
 }
-var init_ingestor = __esm(() => {
-  init_pricing();
-  init_git_context();
-  init_runtime_context();
-  init_session_tracker();
+var init_gemini = __esm(() => {
+  init_parsing_utils();
+});
+
+// src/platforms/parsers/index.ts
+var init_parsers = __esm(() => {
+  init_claude_code();
+  init_codex();
+  init_cursor();
+  init_gemini();
+});
+
+// src/platforms/registry.ts
+function getAllParsers() {
+  return PARSERS;
+}
+function getParser(platformId) {
+  return PARSERS.find((p) => p.info.id === platformId);
+}
+var PARSERS;
+var init_registry = __esm(() => {
+  init_parsers();
+  PARSERS = [
+    new ClaudeCodeParser,
+    new CodexParser,
+    new CursorParser,
+    new GeminiParser
+  ];
 });
 
 // src/agent-hooks/state.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs11 from "node:fs";
+import path10 from "node:path";
 function loadClaudeState(stateDir) {
-  const statePath = path3.join(stateDir, "last-ingested.json");
+  const statePath = path10.join(stateDir, "last-ingested.json");
   try {
-    if (!fs3.existsSync(statePath))
+    if (!fs11.existsSync(statePath))
       return {};
-    const raw = JSON.parse(fs3.readFileSync(statePath, "utf8"));
+    const raw = JSON.parse(fs11.readFileSync(statePath, "utf8"));
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       if ("sessions" in raw) {
         const sessions = raw.sessions;
@@ -953,16 +2079,16 @@ function loadClaudeState(stateDir) {
   return {};
 }
 function saveClaudeState(stateDir, state) {
-  const statePath = path3.join(stateDir, "last-ingested.json");
-  fs3.mkdirSync(stateDir, { recursive: true });
-  fs3.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  const statePath = path10.join(stateDir, "last-ingested.json");
+  fs11.mkdirSync(stateDir, { recursive: true });
+  fs11.writeFileSync(statePath, JSON.stringify(state, null, 2));
 }
 function loadCodexState(stateDir) {
-  const statePath = path3.join(stateDir, "codex-last-ingested.json");
+  const statePath = path10.join(stateDir, "codex-last-ingested.json");
   try {
-    if (!fs3.existsSync(statePath))
+    if (!fs11.existsSync(statePath))
       return { files: {} };
-    const raw = JSON.parse(fs3.readFileSync(statePath, "utf8"));
+    const raw = JSON.parse(fs11.readFileSync(statePath, "utf8"));
     if (raw && typeof raw === "object" && raw.files && typeof raw.files === "object") {
       return raw;
     }
@@ -972,16 +2098,16 @@ function loadCodexState(stateDir) {
   return { files: {} };
 }
 function saveCodexState(stateDir, state) {
-  const statePath = path3.join(stateDir, "codex-last-ingested.json");
-  fs3.mkdirSync(stateDir, { recursive: true });
-  fs3.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  const statePath = path10.join(stateDir, "codex-last-ingested.json");
+  fs11.mkdirSync(stateDir, { recursive: true });
+  fs11.writeFileSync(statePath, JSON.stringify(state, null, 2));
 }
 function loadTokscaleState(stateDir) {
-  const statePath = path3.join(stateDir, "tokscale-state.json");
+  const statePath = path10.join(stateDir, "tokscale-state.json");
   try {
-    if (!fs3.existsSync(statePath))
+    if (!fs11.existsSync(statePath))
       return {};
-    const raw = JSON.parse(fs3.readFileSync(statePath, "utf8"));
+    const raw = JSON.parse(fs11.readFileSync(statePath, "utf8"));
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       return raw;
     }
@@ -990,156 +2116,100 @@ function loadTokscaleState(stateDir) {
   }
   return {};
 }
-function saveTokscaleState(stateDir, state) {
-  const statePath = path3.join(stateDir, "tokscale-state.json");
-  fs3.mkdirSync(stateDir, { recursive: true });
-  fs3.writeFileSync(statePath, JSON.stringify(state, null, 2));
-}
-var init_state = () => {};
+var init_state2 = () => {};
 
-// src/agent-hooks/tokscale.ts
-var exports_tokscale = {};
-__export(exports_tokscale, {
-  syncFromTokscale: () => syncFromTokscale,
-  runTokscale: () => runTokscale,
-  mapTokscaleToEvents: () => mapTokscaleToEvents
+// src/platforms/orchestrator.ts
+var exports_orchestrator = {};
+__export(exports_orchestrator, {
+  syncPlatforms: () => syncPlatforms
 });
-import { spawn } from "node:child_process";
-function inferBillingType(source) {
-  if (!source)
-    return "api";
-  const lower = source.toLowerCase();
-  if (lower.includes("desktop") || lower === "cursor")
-    return "subscription";
-  return "api";
-}
-function normalizeProvider(providerId) {
-  const lower = providerId.toLowerCase();
-  if (lower.includes("anthropic") || lower.includes("claude"))
-    return "anthropic";
-  if (lower.includes("openai") || lower.includes("gpt"))
-    return "openai";
-  if (lower.includes("google") || lower.includes("gemini"))
-    return "google";
-  return providerId;
-}
-async function runTokscale(options) {
-  const args = ["tokscale@latest", "--json"];
-  if (options.since) {
-    args.push("--since", options.since);
-  }
-  if (options.until) {
-    args.push("--until", options.until);
-  }
-  if (options.platforms && options.platforms.length > 0) {
-    args.push("--platforms", options.platforms.join(","));
-  }
-  try {
-    return await spawnTokscale("bunx", args);
-  } catch (err) {
-    const nodeErr = err;
-    if (nodeErr.code === "ENOENT") {
-      return await spawnTokscale("npx", args);
-    }
-    throw err;
-  }
-}
-function spawnTokscale(runner, args) {
-  return new Promise((resolve2, reject) => {
-    const chunks = [];
-    const errChunks = [];
-    const child = spawn(runner, args, { stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout.on("data", (chunk) => chunks.push(chunk));
-    child.stderr.on("data", (chunk) => errChunks.push(chunk));
-    child.on("error", (err) => reject(err));
-    child.on("close", (code) => {
-      if (code !== 0) {
-        const stderr = Buffer.concat(errChunks).toString("utf8");
-        reject(new Error(`tokscale exited with code ${code}: ${stderr}`));
-        return;
-      }
-      const stdout = Buffer.concat(chunks).toString("utf8");
-      try {
-        resolve2(JSON.parse(stdout));
-      } catch (parseErr) {
-        reject(new Error(`Failed to parse tokscale JSON output: ${parseErr.message}`));
-      }
-    });
-  });
-}
-function mapTokscaleToEvents(output, project) {
-  const events = [];
-  for (const daily of output.daily) {
-    for (const source of daily.sources) {
-      const event = {
-        event_type: "usage",
-        provider: normalizeProvider(source.providerId),
-        model: source.modelId,
-        tokens_in: source.tokens.input,
-        tokens_out: source.tokens.output,
-        cache_read_tokens: source.tokens.cacheRead,
-        cache_write_tokens: source.tokens.cacheWrite,
-        cost: source.cost,
-        currency: "USD",
-        billing_type: inferBillingType(source.source),
-        timestamp: `${daily.utcDate}T12:00:00Z`,
-        session_id: `tokscale-${daily.utcDate}`,
-        request_id: `tokscale:${daily.utcDate}:${source.source}:${source.modelId}`,
-        tags: ["tokscale", source.source],
-        ...project ? { project } : {},
-        metadata: {
-          import_source: "tokscale",
-          tokscale_intensity: daily.intensity,
-          tokscale_message_count: source.messageCount,
-          reasoning_tokens: source.tokens.reasoning,
-          day_total_cost: daily.totalCost,
-          day_total_tokens: daily.totalTokens
-        }
-      };
-      events.push(event);
+async function syncPlatforms(config, options = {}) {
+  const targets = options.platforms ? options.platforms.map((id) => getParser(id)).filter((p) => p !== undefined) : getAllParsers();
+  const tokscaleState = loadTokscaleState(config.stateDir);
+  const since = options.since ?? tokscaleState.lastSyncDate;
+  const platformResults = [];
+  let totalEvents = 0;
+  let totalCost = 0;
+  const ingestor = new VerbalIngestor({
+    apiKey: config.apiKey,
+    endpoint: config.ingestUrl,
+    hmacSecret: config.hmacSecret,
+    orgId: config.orgId,
+    batchSize: config.batchSize,
+    flushIntervalMs: config.flushIntervalMs,
+    httpTimeoutMs: config.httpTimeoutMs
+  });
+  for (const parser of targets) {
+    try {
+      const state = loadPlatformState(config.stateDir, parser.info.id);
+      const result = await parser.parse(state, {
+        since,
+        until: options.until,
+        captureMode: options.captureMode
+      });
+      const usageEvents = result.events.map((ev) => mapParsedEventToUsageEvent(ev, options.project));
+      let platformCost = 0;
+      for (const event of usageEvents) {
+        platformCost += event.cost ?? 0;
+        await ingestor.track(event);
+      }
+      savePlatformState(config.stateDir, parser.info.id, result.newState);
+      platformResults.push({
+        id: parser.info.id,
+        events: result.events.length,
+        totalCost: platformCost,
+        warnings: result.warnings
+      });
+      totalEvents += result.events.length;
+      totalCost += platformCost;
+    } catch (err) {
+      platformResults.push({
+        id: parser.info.id,
+        events: 0,
+        totalCost: 0,
+        warnings: [],
+        error: `Parser failed: ${err.message}`
+      });
+      continue;
     }
   }
-  return events;
+  await ingestor.flush();
+  ingestor.destroy();
+  return { platforms: platformResults, totalEvents, totalCost };
 }
-async function syncFromTokscale(config, options) {
-  const state = loadTokscaleState(config.stateDir);
-  const since = options.since ?? state.lastSyncDate;
-  const until = options.until;
-  const platforms = options.platforms;
-  const output = await runTokscale({ since, until, platforms });
-  const events = mapTokscaleToEvents(output, options.project);
-  if (events.length > 0) {
-    const ingestor = new VerbalIngestor({
-      apiKey: config.apiKey,
-      endpoint: config.ingestUrl,
-      hmacSecret: config.hmacSecret,
-      orgId: config.orgId,
-      batchSize: config.batchSize,
-      flushIntervalMs: config.flushIntervalMs,
-      httpTimeoutMs: config.httpTimeoutMs
-    });
-    for (const event of events) {
-      await ingestor.track(event);
-    }
-    await ingestor.flush();
-  }
-  const today = new Date().toISOString().slice(0, 10);
-  const newState = {
-    lastSyncDate: output.metadata.endDate ?? today,
-    lastSyncTimestamp: new Date().toISOString(),
-    platformsSynced: platforms
-  };
-  saveTokscaleState(config.stateDir, newState);
-  const totalCost = events.reduce((sum, e) => sum + (e.cost ?? 0), 0);
+function mapParsedEventToUsageEvent(event, project) {
+  const cost = event.billing_type === "subscription" ? 0 : calculateCost(event.model, event.tokens_in, event.tokens_out, event.cache_read_tokens, event.cache_write_tokens);
   return {
-    days: output.daily.length,
-    events: events.length,
-    totalCost
+    event_id: event.event_id,
+    event_type: "usage",
+    provider: event.provider,
+    model: event.model,
+    tokens_in: event.tokens_in,
+    tokens_out: event.tokens_out,
+    total_tokens: event.tokens_in + event.tokens_out,
+    cache_read_tokens: event.cache_read_tokens,
+    cache_write_tokens: event.cache_write_tokens,
+    cost,
+    billing_type: event.billing_type,
+    timestamp: event.timestamp,
+    session_id: event.session_id,
+    request_id: event.request_id,
+    tags: event.tags,
+    ...project ? { project } : {},
+    prompt: event.prompt,
+    response: event.response,
+    metadata: {
+      ...event.metadata,
+      import_source: "native-parser"
+    }
   };
 }
-var init_tokscale = __esm(() => {
+var init_orchestrator = __esm(() => {
   init_ingestor();
+  init_pricing();
   init_state();
+  init_registry();
+  init_state2();
 });
 
 // src/update-check/check.ts
@@ -1148,9 +2218,9 @@ __export(exports_check, {
   checkForUpdate: () => checkForUpdate
 });
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function getCachePath() {
-  return join12(getCredentialsDir(), CACHE_FILE);
+  return join13(getCredentialsDir(), CACHE_FILE);
 }
 function readCache() {
   try {
@@ -1240,9 +2310,9 @@ var exports_import2 = {};
 __export(exports_import2, {
   runImport: () => runImport
 });
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 import { createInterface as createInterface3 } from "node:readline";
 async function runImport() {
   console.log(`
@@ -1310,10 +2380,9 @@ async function runImport() {
 async function handleLocalImport(source, creds) {
   console.log(`
   Importing ${source.id}...`);
-  const { syncFromTokscale: syncFromTokscale2 } = await Promise.resolve().then(() => (init_tokscale(), exports_tokscale));
-  const stateDir = join13(homedir11(), ".config", "getverbal");
-  const platform = source.id === "claude-code" ? "claude" : "codex";
-  const result = await syncFromTokscale2({
+  const { syncPlatforms: syncPlatforms2 } = await Promise.resolve().then(() => (init_orchestrator(), exports_orchestrator));
+  const stateDir = join14(homedir12(), ".config", "getverbal");
+  const result = await syncPlatforms2({
     apiKey: creds.api_key,
     ingestUrl: creds.ingest_url,
     batchSize: 100,
@@ -1321,12 +2390,12 @@ async function handleLocalImport(source, creds) {
     httpTimeoutMs: 30000,
     stateDir
   }, {
-    platforms: [platform]
+    platforms: [source.id]
   });
-  console.log(import_picocolors6.default.green(`  ✓ ${result.events} events imported from ${source.id}`));
+  console.log(import_picocolors6.default.green(`  ✓ ${result.totalEvents} events imported from ${source.id}`));
 }
 async function handleFileImport(filePath, source, creds) {
-  if (!existsSync8(filePath)) {
+  if (!existsSync9(filePath)) {
     console.error(import_picocolors6.default.red(`  File not found: ${filePath}`));
     process.exitCode = 1;
     return;
@@ -1371,7 +2440,7 @@ var exports_update = {};
 __export(exports_update, {
   runUpdate: () => runUpdate
 });
-import { execSync as execSync7 } from "node:child_process";
+import { execSync as execSync8 } from "node:child_process";
 async function runUpdate(currentVersion) {
   console.log(`
   ${import_picocolors7.default.bold("Verbal")} — Update
@@ -1405,7 +2474,7 @@ async function runUpdate(currentVersion) {
   const installCmd = pm === "bun" ? `bun install -g @getverbal/cli@${latest}` : `npm install -g @getverbal/cli@${latest}`;
   console.log(`  Running: ${import_picocolors7.default.dim(installCmd)}`);
   try {
-    execSync7(installCmd, { stdio: "inherit" });
+    execSync8(installCmd, { stdio: "inherit" });
     console.log(import_picocolors7.default.green(`
   Updated getverbal ${currentVersion} → ${latest}`));
   } catch {
@@ -1417,7 +2486,7 @@ async function runUpdate(currentVersion) {
 }
 function detectPackageManager() {
   try {
-    const which = execSync7("which getverbal", { encoding: "utf-8" }).trim();
+    const which = execSync8("which getverbal", { encoding: "utf-8" }).trim();
     if (which.includes(".bun/"))
       return "bun";
   } catch {}
@@ -1625,10 +2694,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1874,11 +2943,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -10394,8 +11463,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path4) {
-    let input = path4;
+  function removeDotSegments(path11) {
+    let input = path11;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -10585,8 +11654,8 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path4, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path4 && path4 !== "/" ? path4 : undefined;
+      const [path11, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path11 && path11 !== "/" ? path11 : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -13730,12 +14799,12 @@ var require_dist = __commonJS((exports, module) => {
       throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats(ajv, list, fs4, exportName) {
+  function addFormats(ajv, list, fs12, exportName) {
     var _a;
     var _b;
     (_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
     for (const f of list)
-      ajv.addFormat(f, fs4[f]);
+      ajv.addFormat(f, fs12[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -14866,8 +15935,8 @@ var exports_server = {};
 __export(exports_server, {
   startMcpServer: () => startMcpServer
 });
-import os3 from "node:os";
-import path4 from "node:path";
+import os9 from "node:os";
+import path11 from "node:path";
 function ensureString(value) {
   if (typeof value === "string" && value.trim().length > 0)
     return value;
@@ -14902,7 +15971,7 @@ var init_server3 = __esm(() => {
   init_types();
   init_ingestor();
   init_tools();
-  init_tokscale();
+  init_orchestrator();
   init_session_tracker();
   config2 = {
     apiKey: process.env.VERBAL_API_KEY ?? "",
@@ -15128,9 +16197,35 @@ var init_server3 = __esm(() => {
             }
           }
         },
+        {
+          name: "sync_platforms",
+          description: "Sync usage data from local AI tool sessions using native parsers. Scans Claude Code, Codex, Cursor, Gemini, and other supported platforms directly without requiring external tools.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              since: {
+                type: "string",
+                description: "Start date (YYYY-MM-DD). Defaults to last sync date."
+              },
+              until: {
+                type: "string",
+                description: "End date (YYYY-MM-DD). Defaults to today."
+              },
+              platforms: {
+                type: "array",
+                items: { type: "string" },
+                description: "Platforms to sync (e.g. claude-code, codex, cursor, gemini). Defaults to all."
+              },
+              project: {
+                type: "string",
+                description: "Project identifier to tag events with."
+              }
+            }
+          }
+        },
         {
           name: "sync_tokscale",
-          description: "Sync usage data from local AI tool sessions via tokscale. Scans Claude Code, Codex, Cursor, Gemini, and other supported platforms.",
+          description: "[Deprecated: use sync_platforms] Sync usage data from local AI tool sessions. Alias for sync_platforms.",
           inputSchema: {
             type: "object",
             properties: {
@@ -15145,7 +16240,7 @@ var init_server3 = __esm(() => {
               platforms: {
                 type: "array",
                 items: { type: "string" },
-                description: "Platforms to sync (e.g. claude, codex, cursor). Defaults to all."
+                description: "Platforms to sync (e.g. claude-code, codex, cursor, gemini). Defaults to all."
               },
               project: {
                 type: "string",
@@ -15400,7 +16495,7 @@ var init_server3 = __esm(() => {
         ]
       };
     }
-    if (name === "sync_tokscale") {
+    if (name === "sync_platforms" || name === "sync_tokscale") {
       const syncConfig = {
         apiKey: config2.apiKey,
         ingestUrl: config2.endpoint,
@@ -15409,7 +16504,7 @@ var init_server3 = __esm(() => {
         batchSize: config2.batchSize,
         flushIntervalMs: 0,
         httpTimeoutMs: config2.httpTimeoutMs,
-        stateDir: path4.join(os3.homedir(), ".claude", "verbal-logs")
+        stateDir: path11.join(os9.homedir(), ".claude", "verbal-logs")
       };
       const syncOptions = {
         since: typeof args.since === "string" ? args.since : undefined,
@@ -15417,12 +16512,15 @@ var init_server3 = __esm(() => {
         platforms: Array.isArray(args.platforms) ? args.platforms.filter((p) => typeof p === "string") : undefined,
         project: typeof args.project === "string" ? args.project : config2.defaultProject
       };
-      const result = await syncFromTokscale(syncConfig, syncOptions);
+      const result = await syncPlatforms(syncConfig, syncOptions);
+      const lines = result.platforms.map((p) => p.error ? `  ${p.id}: ERROR — ${p.error}` : `  ${p.id}: ${p.events} events, $${p.totalCost.toFixed(2)}`);
       return {
         content: [
           {
             type: "text",
-            text: `Tokscale sync complete: ${result.events} events, ${result.days} days, $${result.totalCost.toFixed(2)} total cost`
+            text: `Platform sync complete: ${result.totalEvents} events, $${result.totalCost.toFixed(2)}
+${lines.join(`
+`)}`
           }
         ]
       };
@@ -15544,9 +16642,9 @@ async function runMcpServe() {
 }
 
 // src/agent-hooks/config.ts
-import fs4 from "node:fs";
-import os4 from "node:os";
-import path5 from "node:path";
+import fs12 from "node:fs";
+import os10 from "node:os";
+import path12 from "node:path";
 function loadHookConfig(options = {}) {
   const env = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
@@ -15562,6 +16660,7 @@ function loadHookConfig(options = {}) {
     apiKey,
     ingestUrl,
     traceUrl,
+    apiUrl: env.VERBAL_API_URL ?? mcpEnv.VERBAL_API_URL ?? deriveApiUrl(ingestUrl),
     hmacSecret: env.VERBAL_HMAC_SECRET ?? mcpEnv.VERBAL_HMAC_SECRET,
     orgId: env.VERBAL_ORG_ID ?? mcpEnv.VERBAL_ORG_ID,
     defaultProject: env.VERBAL_DEFAULT_PROJECT ?? mcpEnv.VERBAL_DEFAULT_PROJECT,
@@ -15578,8 +16677,8 @@ function loadHookConfig(options = {}) {
     gitContextEnabled: parseBoolean(env.VERBAL_GIT_CONTEXT_ENABLED ?? mcpEnv.VERBAL_GIT_CONTEXT_ENABLED, DEFAULTS.gitContextEnabled),
     costCalcEnabled: parseBoolean(env.VERBAL_COST_CALC_ENABLED ?? mcpEnv.VERBAL_COST_CALC_ENABLED, DEFAULTS.costCalcEnabled),
     billingType: parseBillingType(env.VERBAL_BILLING_TYPE ?? mcpEnv.VERBAL_BILLING_TYPE),
-    claudeStateDir: env.VERBAL_CLAUDE_STATE_DIR ?? path5.join(os4.homedir(), ".claude", "verbal-logs"),
-    codexStateDir: env.VERBAL_CODEX_STATE_DIR ?? path5.join(os4.homedir(), ".codex", "verbal-logs")
+    claudeStateDir: env.VERBAL_CLAUDE_STATE_DIR ?? path12.join(os10.homedir(), ".claude", "verbal-logs"),
+    codexStateDir: env.VERBAL_CODEX_STATE_DIR ?? path12.join(os10.homedir(), ".codex", "verbal-logs")
   };
 }
 function redactText(value, patterns) {
@@ -15637,7 +16736,7 @@ function buildRedactionPatterns(value, disableDefault) {
 }
 function loadMcpEnv(configPath) {
   try {
-    const raw = fs4.readFileSync(configPath, "utf8");
+    const raw = fs12.readFileSync(configPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.mcpServers?.verbal?.env ?? {};
   } catch {
@@ -15647,15 +16746,26 @@ function loadMcpEnv(configPath) {
 function findMcpConfig2(startDir) {
   let current = startDir;
   for (;; ) {
-    const candidate = path5.join(current, ".mcp.json");
-    if (fs4.existsSync(candidate))
+    const candidate = path12.join(current, ".mcp.json");
+    if (fs12.existsSync(candidate))
       return candidate;
-    const parent = path5.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current)
       return null;
     current = parent;
   }
 }
+function deriveApiUrl(ingestUrl) {
+  if (!ingestUrl)
+    return "";
+  try {
+    const url = new URL(ingestUrl);
+    url.pathname = "";
+    return url.origin;
+  } catch {
+    return ingestUrl.replace(/\/api\/v1\/ingest\/?$/, "").replace(/\/+$/, "");
+  }
+}
 function deriveTraceUrl(ingestUrl) {
   if (!ingestUrl)
     return "";
@@ -15859,27 +16969,27 @@ var init_tool_extraction = __esm(() => {
 });
 
 // src/agent-hooks/claude.ts
-import fs5 from "node:fs";
+import fs13 from "node:fs";
 async function ingestClaudeHookInput(input, config3) {
   if (input.stop_hook_active)
     return;
   if (!input.session_id || !input.transcript_path) {
     throw new Error("Claude hook input missing session_id or transcript_path");
   }
-  if (!fs5.existsSync(input.transcript_path)) {
+  if (!fs13.existsSync(input.transcript_path)) {
     throw new Error(`Transcript file not found: ${input.transcript_path}`);
   }
-  const entries = readJsonLines(input.transcript_path);
+  const entries = readJsonLines2(input.transcript_path);
   const state = loadClaudeState(config3.claudeStateDir);
   const lastId = state[input.session_id];
-  const startIndex = lastId ? findEntryIndex(entries, lastId) + 1 : 0;
+  const startIndex = lastId ? findEntryIndex2(entries, lastId) + 1 : 0;
   const newEntries = entries.slice(Math.max(startIndex, 0));
   if (newEntries.length === 0)
     return;
   let lastUserContent;
   const ingestor2 = createIngestor(config3);
   for (const entry of newEntries) {
-    const { role, content } = extractMessage(entry);
+    const { role, content } = extractMessage3(entry);
     if (role === "user" || role === "human") {
       lastUserContent = content;
       continue;
@@ -15892,7 +17002,7 @@ async function ingestClaudeHookInput(input, config3) {
       const tokensOut = usage.output_tokens ?? 0;
       if (!tokensIn && !tokensOut)
         continue;
-      const eventId = getEntryId(entry);
+      const eventId = getEntryId2(entry);
       const event = {
         event_id: eventId,
         event_type: "usage",
@@ -16019,24 +17129,24 @@ async function ingestClaudeHookInput(input, config3) {
     await sendTrace(config3, input.session_id, "claude-tool-calls", toolTraceEvents);
   }
   const lastEntry = newEntries[newEntries.length - 1];
-  const lastEntryId = getEntryId(lastEntry);
+  const lastEntryId = getEntryId2(lastEntry);
   if (lastEntryId) {
     state[input.session_id] = lastEntryId;
     saveClaudeState(config3.claudeStateDir, state);
   }
 }
-function readJsonLines(filePath) {
-  const content = fs5.readFileSync(filePath, "utf8");
+function readJsonLines2(filePath) {
+  const content = fs13.readFileSync(filePath, "utf8");
   return content.split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
 }
-function extractMessage(entry) {
+function extractMessage3(entry) {
   const message = entry.message;
   const role = message?.role ?? entry.type;
-  const content = flattenContent(message?.content ?? entry.content);
+  const content = flattenContent2(message?.content ?? entry.content);
   return { role, content };
 }
-function flattenContent(content) {
+function flattenContent2(content) {
   if (!content)
     return;
   if (typeof content === "string")
@@ -16055,26 +17165,26 @@ function flattenContent(content) {
   }
   return;
 }
-function getEntryId(entry) {
+function getEntryId2(entry) {
   return entry.uuid ?? entry.message?.id ?? entry.id ?? entry.messageId;
 }
-function findEntryIndex(entries, id) {
-  return entries.findIndex((entry) => getEntryId(entry) === id);
+function findEntryIndex2(entries, id) {
+  return entries.findIndex((entry) => getEntryId2(entry) === id);
 }
 var init_claude = __esm(() => {
   init_config();
   init_ingest();
-  init_state();
+  init_state2();
   init_tool_extraction();
 });
 
 // src/agent-hooks/codex.ts
-import fs6 from "node:fs";
-import path6 from "node:path";
-import os5 from "node:os";
+import fs14 from "node:fs";
+import path13 from "node:path";
+import os11 from "node:os";
 async function ingestCodexSessions(config3, options = {}) {
-  const baseDir = options.path ?? path6.join(os5.homedir(), ".codex", "sessions");
-  const files = findSessionFiles(baseDir);
+  const baseDir = options.path ?? path13.join(os11.homedir(), ".codex", "sessions");
+  const files = findSessionFiles2(baseDir);
   if (files.length === 0)
     return;
   const state = loadCodexState(config3.codexStateDir);
@@ -16086,11 +17196,11 @@ async function ingestCodexSessions(config3, options = {}) {
   saveCodexState(config3.codexStateDir, state);
 }
 async function watchCodexSessions(config3, options = {}) {
-  const baseDir = options.path ?? path6.join(os5.homedir(), ".codex", "sessions");
+  const baseDir = options.path ?? path13.join(os11.homedir(), ".codex", "sessions");
   const intervalMs = options.intervalMs ?? 3000;
   const state = loadCodexState(config3.codexStateDir);
   setInterval(async () => {
-    const files = findSessionFiles(baseDir);
+    const files = findSessionFiles2(baseDir);
     for (const filePath of files) {
       const updated = await ingestCodexFile(filePath, config3, state.files[filePath]);
       if (updated)
@@ -16100,7 +17210,7 @@ async function watchCodexSessions(config3, options = {}) {
   }, intervalMs);
 }
 async function ingestCodexFile(filePath, config3, fileState) {
-  const { entries, sessionId } = readCodexFile(filePath);
+  const { entries, sessionId } = readCodexFile2(filePath);
   if (entries.length === 0)
     return null;
   const state = fileState ?? { lastIndex: -1 };
@@ -16156,7 +17266,7 @@ async function ingestCodexFile(filePath, config3, fileState) {
       }
       continue;
     }
-    const message = extractMessage2(entry);
+    const message = extractMessage4(entry);
     if (message) {
       if (message.role === "user") {
         lastUserContent = message.content;
@@ -16175,7 +17285,7 @@ async function ingestCodexFile(filePath, config3, fileState) {
         if (pending && !lastTokenUsage) {
           if (config3.allowTokenEstimates) {
             const pendingEvent = pending.event;
-            const { tokensIn, tokensOut } = estimateTokens(pending.prompt, pending.response);
+            const { tokensIn, tokensOut } = estimateTokens2(pending.prompt, pending.response);
             pendingEvent.tokens_in = tokensIn;
             pendingEvent.tokens_out = tokensOut;
             pendingEvent.total_tokens = tokensIn + tokensOut;
@@ -16216,7 +17326,7 @@ async function ingestCodexFile(filePath, config3, fileState) {
           lastTokenUsage = undefined;
           events.push(event);
         } else if (config3.allowTokenEstimates) {
-          const { tokensIn, tokensOut } = estimateTokens(lastUserContent, message.content);
+          const { tokensIn, tokensOut } = estimateTokens2(lastUserContent, message.content);
           event.tokens_in = tokensIn;
           event.tokens_out = tokensOut;
           event.total_tokens = tokensIn + tokensOut;
@@ -16319,17 +17429,17 @@ async function ingestCodexFile(filePath, config3, fileState) {
   state.pending = pending;
   return state;
 }
-function readCodexFile(filePath) {
-  const content = fs6.readFileSync(filePath, "utf8").trim();
+function readCodexFile2(filePath) {
+  const content = fs14.readFileSync(filePath, "utf8").trim();
   if (!content)
-    return { entries: [], sessionId: path6.basename(filePath) };
+    return { entries: [], sessionId: path13.basename(filePath) };
   const isJsonl = filePath.endsWith(".jsonl");
   if (!isJsonl && content.startsWith("{")) {
     try {
       const parsed = JSON.parse(content);
       return {
         entries: parsed.items ?? [],
-        sessionId: parsed.session?.id ?? path6.basename(filePath)
+        sessionId: parsed.session?.id ?? path13.basename(filePath)
       };
     } catch {}
   }
@@ -16337,30 +17447,30 @@ function readCodexFile(filePath) {
 `).filter(Boolean);
   const entries = lines.map((line) => JSON.parse(line));
   const sessionMeta = entries.find((entry) => entry.type === "session_meta");
-  const sessionId = sessionMeta?.payload?.id ?? path6.basename(filePath);
+  const sessionId = sessionMeta?.payload?.id ?? path13.basename(filePath);
   return { entries, sessionId };
 }
-function extractMessage2(entry) {
+function extractMessage4(entry) {
   if (entry.type === "response_item" && entry.payload && typeof entry.payload === "object") {
     const payload = entry.payload;
     if (payload.type === "message") {
       const role = payload.role;
-      const content = flattenContent2(payload.content);
+      const content = flattenContent3(payload.content);
       if (role)
         return { role, content };
     }
   }
   if (entry.type === "message" && entry.role) {
-    return { role: entry.role, content: flattenContent2(entry.content) };
+    return { role: entry.role, content: flattenContent3(entry.content) };
   }
   if (entry.type === "user" || entry.type === "assistant") {
     const role = entry.type;
-    const content = flattenContent2(entry.content ?? entry.message);
+    const content = flattenContent3(entry.content ?? entry.message);
     return { role, content };
   }
   return null;
 }
-function flattenContent2(content) {
+function flattenContent3(content) {
   if (!content)
     return;
   if (typeof content === "string")
@@ -16379,19 +17489,19 @@ function flattenContent2(content) {
   }
   return;
 }
-function estimateTokens(prompt2, response) {
+function estimateTokens2(prompt2, response) {
   const tokensIn = prompt2 ? Math.ceil(prompt2.length / 4) : 0;
   const tokensOut = response ? Math.ceil(response.length / 4) : 0;
   return { tokensIn, tokensOut };
 }
-function findSessionFiles(baseDir) {
-  if (!fs6.existsSync(baseDir))
+function findSessionFiles2(baseDir) {
+  if (!fs14.existsSync(baseDir))
     return [];
   const results = [];
   const walk = (dir) => {
-    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    const entries = fs14.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path6.join(dir, entry.name);
+      const full = path13.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile() && (full.endsWith(".json") || full.endsWith(".jsonl"))) {
@@ -16402,52 +17512,191 @@ function findSessionFiles(baseDir) {
   walk(baseDir);
   return results;
 }
-var init_codex = __esm(() => {
+var init_codex2 = __esm(() => {
   init_config();
   init_ingest();
-  init_state();
+  init_state2();
   init_tool_extraction();
 });
 
-// src/agent-hooks/launchagent.ts
-function buildCodexLaunchAgentPlist(options) {
-  const { nodePath, cliPath, configPath } = options;
-  return `<?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>ai.verbal.codex-hooks</string>
-` + `  <key>ProgramArguments</key>
-` + `  <array>
-` + `    <string>${nodePath}</string>
-` + `    <string>${cliPath}</string>
-` + `    <string>watch</string>
-` + `    <string>--codex</string>
-` + `  </array>
-` + `  <key>RunAtLoad</key>
-` + `  <true/>
-` + `  <key>KeepAlive</key>
-` + `  <true/>
-` + `  <key>EnvironmentVariables</key>
-` + `  <dict>
-` + (configPath ? `    <key>VERBAL_CONFIG_PATH</key>
-    <string>${configPath}</string>
-` : "") + `  </dict>
-` + `</dict>
-` + `</plist>
-`;
+// src/mcp/preflight.ts
+var exports_preflight = {};
+__export(exports_preflight, {
+  runPreflight: () => runPreflight,
+  formatPreflightForTerminal: () => formatPreflightForTerminal,
+  buildSuggestion: () => buildSuggestion,
+  ISSUE_SUGGESTIONS: () => ISSUE_SUGGESTIONS
+});
+function buildSuggestion(issues) {
+  const top = issues.slice(0, 2);
+  if (top.length === 0)
+    return "";
+  const tips = top.map((key) => ISSUE_SUGGESTIONS[key]).filter((tip) => Boolean(tip));
+  if (tips.length === 0)
+    return "";
+  if (tips.length === 1)
+    return tips[0];
+  return `${tips[0]} Also: ${tips[1]}`;
+}
+async function runPreflight(prompt2, options) {
+  const { config: config3, apiKey, apiUrl, cooldownActive } = options;
+  if (prompt2.trim().length < 20) {
+    return { skipped: true, skip_reason: "short_prompt" };
+  }
+  if (cooldownActive) {
+    return { skipped: true, skip_reason: "cooldown" };
+  }
+  const requestThreshold = config3.enable_llm_rewrite ? config3.threshold : 101;
+  let response;
+  try {
+    response = await fetch(`${apiUrl}/api/v1/optimize`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        prompt: prompt2,
+        threshold: requestThreshold
+      })
+    });
+  } catch {
+    return { skipped: true, skip_reason: "error" };
+  }
+  if (response.status === 402) {
+    return { skipped: true, skip_reason: "tier_gate" };
+  }
+  if (!response.ok) {
+    return { skipped: true, skip_reason: "error" };
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    return { skipped: true, skip_reason: "error" };
+  }
+  const score = data.original_score;
+  const issues = Array.isArray(data.issues) ? data.issues : [];
+  if (score >= config3.threshold) {
+    return {
+      skipped: true,
+      skip_reason: "above_threshold",
+      score,
+      issues
+    };
+  }
+  const suggestion = buildSuggestion(issues);
+  return {
+    skipped: false,
+    score,
+    issues,
+    suggestion,
+    optimized_prompt: config3.enable_llm_rewrite ? data.optimized_prompt : null,
+    improvement_delta: config3.enable_llm_rewrite ? data.improvement_delta : null
+  };
+}
+function formatPreflightForTerminal(result) {
+  if (result.skipped)
+    return "";
+  const lines = [];
+  lines.push(`⚡ Prompt score: ${result.score ?? "?"}/100`);
+  if (result.suggestion) {
+    lines.push(`\uD83D\uDCA1 ${result.suggestion}`);
+  }
+  if (result.optimized_prompt) {
+    const delta = result.improvement_delta != null ? ` (+${result.improvement_delta} pts)` : "";
+    lines.push(`✨ Optimized prompt${delta}:`);
+    lines.push("");
+    lines.push(result.optimized_prompt);
+  }
+  return lines.join(`
+`);
+}
+var ISSUE_SUGGESTIONS;
+var init_preflight = __esm(() => {
+  ISSUE_SUGGESTIONS = {
+    vague_instruction: "Be more specific — describe the exact outcome you want, not just the task category.",
+    no_output_format: 'Specify the output format (e.g. "return a JSON object", "write a numbered list", "respond in markdown").',
+    missing_constraints: "Add constraints (e.g. word count, language, framework version) to narrow the solution space.",
+    no_context: "Include relevant context (e.g. language, tech stack, existing code) so the model has what it needs.",
+    ambiguous_subject: "Clarify the subject — what exactly should be modified, created, or explained?",
+    missing_examples: "Provide an example input/output pair to show the pattern you expect.",
+    overly_broad: "Break this into smaller, focused requests rather than asking for everything at once.",
+    passive_voice: 'Use active, imperative phrasing (e.g. "Generate X" instead of "X should be generated").',
+    no_success_criteria: 'State what "done" looks like so the model can self-verify its response.',
+    redundant_preamble: 'Start with the request — cut the "I want you to act as" or similar preambles.'
+  };
+});
+
+// src/agent-hooks/cursor-watcher.ts
+var exports_cursor_watcher = {};
+__export(exports_cursor_watcher, {
+  watchCursorWorkspaces: () => watchCursorWorkspaces
+});
+async function watchCursorWorkspaces(config3, options = {}) {
+  const intervalMs = options.intervalMs ?? 5000;
+  const parser = new CursorParser;
+  const stateDir = config3.claudeStateDir;
+  const sync = async () => {
+    try {
+      const state = loadPlatformState(stateDir, "cursor");
+      const result = await parser.parse(state, {});
+      if (result.events.length > 0) {
+        const ingestor2 = createIngestor(config3);
+        for (const event of result.events) {
+          const cost = event.billing_type === "subscription" ? 0 : calculateCost(event.model, event.tokens_in, event.tokens_out, event.cache_read_tokens, event.cache_write_tokens);
+          const usageEvent = {
+            event_id: event.event_id,
+            event_type: "usage",
+            provider: event.provider,
+            model: event.model,
+            tokens_in: event.tokens_in,
+            tokens_out: event.tokens_out,
+            total_tokens: event.tokens_in + event.tokens_out,
+            cache_read_tokens: event.cache_read_tokens,
+            cache_write_tokens: event.cache_write_tokens,
+            cost,
+            billing_type: event.billing_type,
+            timestamp: event.timestamp,
+            session_id: event.session_id,
+            request_id: event.request_id,
+            tags: event.tags,
+            metadata: { ...event.metadata, import_source: "cursor-watcher" }
+          };
+          await ingestor2.track(usageEvent);
+        }
+        await ingestor2.flush();
+        ingestor2.destroy();
+      }
+      savePlatformState(stateDir, "cursor", result.newState);
+      if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          console.error(`[Cursor watcher] ${warning}`);
+        }
+      }
+    } catch (err) {
+      console.error("[Cursor watcher] Error:", err instanceof Error ? err.message : err);
+    }
+  };
+  await sync();
+  setInterval(sync, intervalMs);
 }
+var init_cursor_watcher = __esm(() => {
+  init_cursor();
+  init_state();
+  init_ingest();
+  init_pricing();
+});
 
 // src/agent-hooks/cli.ts
 var exports_cli = {};
 __export(exports_cli, {
   main: () => main
 });
-import fs7 from "node:fs";
-import os6 from "node:os";
-import path7 from "node:path";
-import { fileURLToPath } from "node:url";
+import fs15 from "node:fs";
+import os12 from "node:os";
+import path14 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function main(args = process.argv) {
   const command = args[2];
   switch (command) {
@@ -16457,6 +17706,53 @@ async function main(args = process.argv) {
       await ingestClaudeHookInput(input, config3);
       return;
     }
+    case "preflight": {
+      const config3 = loadHookConfig();
+      const flags = parseFlags(args.slice(3));
+      const prompt2 = await readStdinText();
+      if (!prompt2 || prompt2.trim().length === 0) {
+        return;
+      }
+      const { runPreflight: runPreflight2, formatPreflightForTerminal: formatPreflightForTerminal2 } = await Promise.resolve().then(() => (init_preflight(), exports_preflight));
+      const {
+        loadPreflightState: loadPreflightState2,
+        savePreflightState: savePreflightState2,
+        getDefaultStateDir: getDefaultStateDir2,
+        isCooldownActive: isCooldownActive2,
+        updatePreflightStats: updatePreflightStats2,
+        addPendingFeedback: addPendingFeedback2
+      } = await Promise.resolve().then(() => (init_preflight_state(), exports_preflight_state));
+      const stateDir = getDefaultStateDir2();
+      const state = loadPreflightState2(stateDir);
+      const mode = flags.mode ?? state.config.mode;
+      const threshold = flags.threshold ?? state.config.threshold;
+      const result = await runPreflight2(prompt2.trim(), {
+        config: { threshold, mode, enable_llm_rewrite: state.config.enable_llm_rewrite, cooldown_minutes: state.config.cooldown_minutes },
+        apiKey: config3.apiKey,
+        apiUrl: config3.apiUrl,
+        cooldownActive: isCooldownActive2(state)
+      });
+      let updatedState = result.skipped ? updatePreflightStats2(state, "skipped", result.score ?? 0) : updatePreflightStats2(state, "shown", result.score ?? 0);
+      if (!result.skipped && mode !== "silent") {
+        const formatted = formatPreflightForTerminal2(result);
+        if (formatted) {
+          process.stderr.write(formatted + `
+`);
+        }
+      }
+      if (!result.skipped) {
+        updatedState = addPendingFeedback2(updatedState, {
+          timestamp: new Date().toISOString(),
+          score: result.score ?? 0,
+          action: "dismissed",
+          issues: result.issues ?? []
+        });
+      }
+      savePreflightState2(stateDir, updatedState);
+      process.stdout.write(JSON.stringify(result) + `
+`);
+      return;
+    }
     case "ingest-now": {
       const config3 = loadHookConfig();
       const flags = parseFlags(args.slice(3));
@@ -16467,9 +17763,9 @@ async function main(args = process.argv) {
         const input = { session_id: `manual-${Date.now()}`, transcript_path: flags.path };
         await ingestClaudeHookInput(input, config3);
       }
-      if (flags.tokscale) {
-        const { syncFromTokscale: syncFromTokscale2 } = await Promise.resolve().then(() => (init_tokscale(), exports_tokscale));
-        const result = await syncFromTokscale2({
+      if (flags.sync || flags.tokscale) {
+        const { syncPlatforms: syncPlatforms2 } = await Promise.resolve().then(() => (init_orchestrator(), exports_orchestrator));
+        const result = await syncPlatforms2({
           apiKey: config3.apiKey,
           ingestUrl: config3.ingestUrl,
           hmacSecret: config3.hmacSecret,
@@ -16484,29 +17780,55 @@ async function main(args = process.argv) {
           platforms: flags.platforms,
           project: config3.defaultProject
         });
-        console.log(`Tokscale sync: ${result.events} events, ${result.days} days, $${result.totalCost.toFixed(2)} total`);
+        console.log(`Platform sync: ${result.totalEvents} events, $${result.totalCost.toFixed(2)} total`);
+        for (const p of result.platforms) {
+          if (p.error)
+            console.log(`  ${p.id}: ERROR — ${p.error}`);
+          else
+            console.log(`  ${p.id}: ${p.events} events, $${p.totalCost.toFixed(2)}`);
+        }
       }
       return;
     }
     case "watch": {
       const config3 = loadHookConfig();
       const flags = parseFlags(args.slice(3));
-      if (flags.codex) {
-        await watchCodexSessions(config3, { path: flags.path });
-        await new Promise(() => {
-          return;
-        });
+      const watchCodex = flags.codex || !flags.codex && !flags.cursor;
+      const watchCursor = flags.cursor || !flags.codex && !flags.cursor;
+      const promises = [];
+      if (watchCodex) {
+        promises.push(watchCodexSessions(config3, { path: flags.path }));
+      }
+      if (watchCursor) {
+        const { watchCursorWorkspaces: watchCursorWorkspaces2 } = await Promise.resolve().then(() => (init_cursor_watcher(), exports_cursor_watcher));
+        promises.push(watchCursorWorkspaces2(config3));
+      }
+      if (promises.length === 0) {
+        console.log("Nothing to watch. Use --codex or --cursor.");
+        return;
       }
-      console.log("Nothing to watch. Use --codex.");
+      await Promise.race(promises);
+      await new Promise(() => {
+        return;
+      });
       return;
     }
     case "install": {
       const flags = parseFlags(args.slice(3));
       if (flags.claude) {
-        installClaudeHooks();
+        const { installClaudeHooks: installClaude } = await Promise.resolve().then(() => (init_hooks_installer(), exports_hooks_installer));
+        installClaude();
+        console.log(`Installed Claude hooks in ${path14.join(os12.homedir(), ".claude", "settings.json")}`);
       }
       if (flags.codex) {
-        installCodexLaunchAgent();
+        if (process.platform === "darwin") {
+          const { installUnifiedWatcher: installUnifiedWatcher2 } = await Promise.resolve().then(() => (init_hooks_installer(), exports_hooks_installer));
+          installUnifiedWatcher2();
+          const plistPath = path14.join(os12.homedir(), "Library", "LaunchAgents", "ai.verbal.watcher.plist");
+          console.log(`Wrote LaunchAgent to ${plistPath}`);
+        } else {
+          installCodexLaunchAgent();
+        }
       }
       return;
     }
@@ -16541,7 +17863,9 @@ function parseFlags(args) {
   const flags = {
     codex: false,
     claude: false,
+    cursor: false,
     tokscale: false,
+    sync: false,
     path: undefined,
     since: undefined,
     until: undefined,
@@ -16553,8 +17877,12 @@ function parseFlags(args) {
       flags.codex = true;
     if (arg === "--claude")
       flags.claude = true;
+    if (arg === "--cursor")
+      flags.cursor = true;
     if (arg === "--tokscale")
       flags.tokscale = true;
+    if (arg === "--sync")
+      flags.sync = true;
     if (arg === "--path") {
       flags.path = args[i + 1];
       i++;
@@ -16572,86 +17900,46 @@ function parseFlags(args) {
       flags.platforms = raw ? raw.split(",").map((p) => p.trim()).filter(Boolean) : [];
       i++;
     }
+    if (arg === "--mode") {
+      flags.mode = args[i + 1];
+      i++;
+    }
+    if (arg === "--threshold") {
+      flags.threshold = parseInt(args[i + 1], 10);
+      i++;
+    }
   }
   return flags;
 }
-function installClaudeHooks() {
-  const settingsPath = path7.join(os6.homedir(), ".claude", "settings.json");
-  const hooksRoot = path7.resolve(__dirname2, "..", "..", "hooks");
-  const stopHook = path7.join(hooksRoot, "ingest-stop-hook.sh");
-  const endHook = path7.join(hooksRoot, "ingest-session-end-hook.sh");
-  const configPath = findMcpConfigPath();
-  const settings = readJson(settingsPath) ?? {};
-  settings.hooks = settings.hooks ?? {};
-  upsertHook(settings, "Stop", stopHook, {
-    timeout: 30,
-    statusMessage: "Tracking usage in Verbal",
-    async: true,
-    env: configPath ? { VERBAL_CONFIG_PATH: configPath } : undefined
-  });
-  upsertHook(settings, "SessionEnd", endHook, {
-    timeout: 30,
-    statusMessage: "Finalizing usage data",
-    env: configPath ? { VERBAL_CONFIG_PATH: configPath } : undefined
-  });
-  const reviewPromptHook = path7.join(hooksRoot, "session-review-prompt.js");
-  upsertHook(settings, "Stop", `node ${reviewPromptHook}`, {
-    timeout: 5,
-    statusMessage: "Checking session review timer"
-  });
-  fs7.mkdirSync(path7.dirname(settingsPath), { recursive: true });
-  fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-  console.log(`Installed Claude hooks in ${settingsPath}`);
-}
 function uninstallClaudeHooks() {
-  const settingsPath = path7.join(os6.homedir(), ".claude", "settings.json");
-  const settings = readJson(settingsPath);
+  const settingsPath = path14.join(os12.homedir(), ".claude", "settings.json");
+  const settings = readJson2(settingsPath);
   if (!settings?.hooks)
     return;
   removeHook(settings, "Stop", "ingest-stop-hook.sh");
   removeHook(settings, "Stop", "session-review-prompt.js");
   removeHook(settings, "SessionEnd", "ingest-session-end-hook.sh");
-  fs7.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  fs15.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
   console.log(`Removed Verbal Claude hooks from ${settingsPath}`);
 }
 function installCodexLaunchAgent() {
-  const plistPath = path7.join(os6.homedir(), "Library", "LaunchAgents", "ai.verbal.codex-hooks.plist");
-  const cliPath = path7.resolve(__dirname2, "cli.js");
+  const plistPath = path14.join(os12.homedir(), "Library", "LaunchAgents", "ai.verbal.codex-hooks.plist");
+  const cliPath = path14.resolve(__dirname3, "cli.js");
   const nodePath = process.execPath;
-  const configPath = findMcpConfigPath() ?? undefined;
+  const configPath = findMcpConfigPath2() ?? undefined;
   const plist = buildCodexLaunchAgentPlist({ nodePath, cliPath, configPath });
-  fs7.mkdirSync(path7.dirname(plistPath), { recursive: true });
-  fs7.writeFileSync(plistPath, plist);
+  fs15.mkdirSync(path14.dirname(plistPath), { recursive: true });
+  fs15.writeFileSync(plistPath, plist);
   console.log(`Wrote LaunchAgent to ${plistPath}`);
   console.log("Load with: launchctl load ~/Library/LaunchAgents/ai.verbal.codex-hooks.plist");
 }
 function uninstallCodexLaunchAgent() {
-  const plistPath = path7.join(os6.homedir(), "Library", "LaunchAgents", "ai.verbal.codex-hooks.plist");
-  if (fs7.existsSync(plistPath)) {
-    fs7.unlinkSync(plistPath);
+  const plistPath = path14.join(os12.homedir(), "Library", "LaunchAgents", "ai.verbal.codex-hooks.plist");
+  if (fs15.existsSync(plistPath)) {
+    fs15.unlinkSync(plistPath);
     console.log(`Removed ${plistPath}`);
   }
 }
-function upsertHook(settings, hookName, command, options) {
-  const hookEntry = {
-    matcher: "",
-    hooks: [
-      {
-        type: "command",
-        command,
-        ...options
-      }
-    ]
-  };
-  settings.hooks = settings.hooks ?? {};
-  settings.hooks[hookName] = settings.hooks[hookName] ?? [];
-  const existingIndex = settings.hooks[hookName].findIndex((entry) => entry.hooks?.some((hook) => hook.command.includes(path7.basename(command))));
-  if (existingIndex >= 0) {
-    settings.hooks[hookName][existingIndex] = hookEntry;
-  } else {
-    settings.hooks[hookName].push(hookEntry);
-  }
-}
 function removeHook(settings, hookName, commandFragment) {
   if (!settings.hooks?.[hookName])
     return;
@@ -16660,22 +17948,22 @@ function removeHook(settings, hookName, commandFragment) {
     return !hooks.some((hook) => hook.command.includes(commandFragment));
   });
 }
-function readJson(filePath) {
+function readJson2(filePath) {
   try {
-    if (!fs7.existsSync(filePath))
+    if (!fs15.existsSync(filePath))
       return null;
-    return JSON.parse(fs7.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs15.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
-function findMcpConfigPath() {
+function findMcpConfigPath2() {
   let current = process.cwd();
   for (;; ) {
-    const candidate = path7.join(current, ".mcp.json");
-    if (fs7.existsSync(candidate))
+    const candidate = path14.join(current, ".mcp.json");
+    if (fs15.existsSync(candidate))
       return candidate;
-    const parent = path7.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current)
       return null;
     current = parent;
@@ -16691,24 +17979,35 @@ async function readStdinJson() {
   const content = Buffer.concat(chunks).toString("utf8");
   return JSON.parse(content);
 }
+async function readStdinText() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
 function printHelp() {
   console.log(`verbal-hooks usage:
   verbal-hooks install --claude --codex
   verbal-hooks ingest-now --codex [--path <dir>]
   verbal-hooks ingest-now --claude --path <transcript.jsonl>
-  verbal-hooks ingest-now --tokscale [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--platforms claude,codex,...]
-  verbal-hooks watch --codex [--path <dir>]
+  verbal-hooks ingest-now --sync [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--platforms claude-code,codex,...]
+  verbal-hooks ingest-now --tokscale [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--platforms claude-code,codex,...]
+  verbal-hooks watch [--codex [--path <dir>]] [--cursor]
+                     (no flags = auto-detect, watches all available sources)
+  verbal-hooks preflight [--mode silent|notify|blocking] [--threshold 60]
+                         (reads prompt from stdin, prints coaching to stderr)
   verbal-hooks status
   verbal-hooks uninstall --claude --codex
 `);
 }
-var __filename2, __dirname2;
+var __filename3, __dirname3;
 var init_cli = __esm(() => {
   init_config();
   init_claude();
-  init_codex();
-  __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = path7.dirname(__filename2);
+  init_codex2();
+  __filename3 = fileURLToPath2(import.meta.url);
+  __dirname3 = path14.dirname(__filename3);
   if (import.meta.url === `file://${process.argv[1]}`) {
     main(process.argv).catch((error2) => {
       console.error(error2 instanceof Error ? error2.message : error2);
@@ -16733,10 +18032,10 @@ __export(exports_notify, {
   printUpdateNotice: () => printUpdateNotice
 });
 import { readFileSync as readFileSync10 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function printUpdateNotice(currentVersion) {
   try {
-    const cachePath = join14(getCredentialsDir(), "update-check.json");
+    const cachePath = join15(getCredentialsDir(), "update-check.json");
     const raw = readFileSync10(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (compareSemver(currentVersion, cache.latest) >= 0)
@@ -16773,10 +18072,10 @@ var import_picocolors9 = __toESM(require_picocolors(), 1);
 // src/commands/init.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
 import { createInterface } from "node:readline/promises";
-import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+import { execSync as execSync7 } from "node:child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { join as join12 } from "node:path";
+import { homedir as homedir11 } from "node:os";
 
 // src/auth/browser-auth.ts
 import { createServer } from "node:http";
@@ -17237,19 +18536,49 @@ async function detectCodex() {
   }
 }
 
+// src/detect/gemini.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+async function detectGemini() {
+  const home = homedir6();
+  const paths = [
+    join6(home, ".gemini"),
+    join6(home, ".config", "gemini")
+  ];
+  const found = paths.find((p) => existsSync5(p));
+  if (!found) {
+    return {
+      tool: "gemini",
+      detected: false,
+      configPath: "",
+      existingConfig: false,
+      details: "Gemini CLI data not found"
+    };
+  }
+  return {
+    tool: "gemini",
+    detected: true,
+    configPath: "",
+    existingConfig: false,
+    details: `Gemini CLI data at ${found}`
+  };
+}
+
 // src/detect/index.ts
 async function detectAll() {
   const results = await Promise.allSettled([
     detectClaudeCode(),
     detectClaudeDesktop(),
     detectCursor(),
-    detectCodex()
+    detectCodex(),
+    detectGemini()
   ]);
   return results.map((result, index) => {
     if (result.status === "fulfilled") {
       return result.value;
     }
-    const tools = ["claude-code", "claude-desktop", "cursor", "codex"];
+    const tools = ["claude-code", "claude-desktop", "cursor", "codex", "gemini"];
     const tool = tools[index];
     return {
       tool,
@@ -17262,28 +18591,28 @@ async function detectAll() {
 }
 
 // src/configure/index.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "node:fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync2, existsSync as existsSync6 } from "node:fs";
 import { dirname, resolve } from "node:path";
 
 // src/configure/claude-code.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 async function configureClaudeCode(_detection, credentials, billingType, useGlobal = false) {
-  const configPath = join6(process.cwd(), ".mcp.json");
+  const configPath = join7(process.cwd(), ".mcp.json");
   mergeConfig(configPath, credentials, billingType, useGlobal);
 }
 
 // src/configure/claude-desktop.ts
-import { homedir as homedir6 } from "node:os";
-import { join as join7 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { join as join8 } from "node:path";
 function getConfigPath2() {
   const platform = process.platform;
   if (platform === "darwin") {
-    return join7(homedir6(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join8(homedir7(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (platform === "win32") {
-    return join7(process.env["APPDATA"] ?? homedir6(), "Claude", "claude_desktop_config.json");
+    return join8(process.env["APPDATA"] ?? homedir7(), "Claude", "claude_desktop_config.json");
   }
-  return join7(homedir6(), ".config", "claude", "claude_desktop_config.json");
+  return join8(homedir7(), ".config", "claude", "claude_desktop_config.json");
 }
 async function configureClaudeDesktop(_detection, credentials, billingType, useGlobal = false) {
   const configPath = getConfigPath2();
@@ -17291,27 +18620,31 @@ async function configureClaudeDesktop(_detection, credentials, billingType, useG
 }
 
 // src/configure/cursor.ts
-import { homedir as homedir7 } from "node:os";
-import { join as join8 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
 async function configureCursor(_detection, credentials, billingType, useGlobal = false) {
-  const configPath = join8(homedir7(), ".cursor", "mcp.json");
+  const configPath = join9(homedir8(), ".cursor", "mcp.json");
   mergeConfig(configPath, credentials, billingType, useGlobal);
 }
 
 // src/configure/codex.ts
-import { homedir as homedir8 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join10 } from "node:path";
 async function configureCodex(_detection, credentials, billingType, useGlobal = false) {
-  const configPath = join9(homedir8(), ".codex", "config.json");
+  const configPath = join10(homedir9(), ".codex", "config.json");
   mergeConfig(configPath, credentials, billingType, useGlobal);
 }
 
+// src/configure/gemini.ts
+async function configureGemini(_detection, _credentials, _billingType, _useGlobal) {}
+
 // src/configure/index.ts
 var TOOL_DEFAULT_BILLING_TYPE = {
   "claude-code": "api",
   "claude-desktop": "subscription",
   cursor: "subscription",
-  codex: "api"
+  codex: "api",
+  gemini: "api"
 };
 function buildVerbalMcpEntry(credentials, billingType = "api", useGlobal = false) {
   return {
@@ -17333,7 +18666,7 @@ function buildVerbalMcpEntry(credentials, billingType = "api", useGlobal = false
 function mergeConfig(configPath, credentials, billingType, useGlobal = false) {
   mkdirSync2(dirname(configPath), { recursive: true });
   let config = {};
-  if (existsSync5(configPath)) {
+  if (existsSync6(configPath)) {
     try {
       config = JSON.parse(readFileSync6(configPath, "utf-8"));
     } catch {
@@ -17350,7 +18683,7 @@ function mergeConfig(configPath, credentials, billingType, useGlobal = false) {
 }
 function removeVerbalConfig(configPath) {
   const resolvedPath = resolve(configPath);
-  if (!existsSync5(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     return;
   }
   let config;
@@ -17398,10 +18731,9 @@ async function configureAll(detections, credentials, useGlobal = false) {
         case "codex":
           await configureCodex(detection, credentials, billingType, useGlobal);
           break;
-        default: {
-          const _exhaustive = detection.tool;
-          throw new Error(`Unknown tool: ${String(_exhaustive)}`);
-        }
+        case "gemini":
+          await configureGemini(detection, credentials, billingType, useGlobal);
+          break;
       }
       success = true;
     } catch (err) {
@@ -17449,6 +18781,7 @@ async function verifyConnection(credentials) {
 }
 
 // src/commands/init.ts
+init_preflight_state();
 async function confirm(rl, message, defaultYes) {
   const hint = defaultYes ? "(Y/n)" : "(y/N)";
   const answer = await rl.question(`${message} ${hint} `);
@@ -17458,8 +18791,8 @@ async function confirm(rl, message, defaultYes) {
   return trimmed === "y" || trimmed === "yes";
 }
 function isInGitignore(filename) {
-  const gitignorePath = join11(process.cwd(), ".gitignore");
-  if (!existsSync7(gitignorePath))
+  const gitignorePath = join12(process.cwd(), ".gitignore");
+  if (!existsSync8(gitignorePath))
     return false;
   try {
     const content = readFileSync7(gitignorePath, "utf-8");
@@ -17479,6 +18812,8 @@ function toolDisplayName(tool) {
       return "Cursor";
     case "codex":
       return "Codex";
+    case "gemini":
+      return "Gemini CLI";
     default: {
       const _exhaustive = tool;
       return String(_exhaustive);
@@ -17487,7 +18822,7 @@ function toolDisplayName(tool) {
 }
 function isGloballyInstalled() {
   try {
-    const which = execSync6("which getverbal", { encoding: "utf-8" }).trim();
+    const which = execSync7("which getverbal", { encoding: "utf-8" }).trim();
     return !which.includes("npx") && !which.includes(".npm/_npx");
   } catch {
     return false;
@@ -17504,7 +18839,7 @@ async function promoteToGlobal(rl) {
   console.log(`
   ${import_picocolors.default.dim("ℹ")} Installing globally...`);
   try {
-    execSync6(`npm install -g @getverbal/cli@${VERSION}`, { stdio: "inherit" });
+    execSync7(`npm install -g @getverbal/cli@${VERSION}`, { stdio: "inherit" });
     console.log(import_picocolors.default.green(`  ✓ Installed getverbal v${VERSION} globally`));
     return true;
   } catch {
@@ -17544,6 +18879,32 @@ async function runInit() {
         process.exit(1);
       }
     }
+    {
+      const stateDir = getDefaultStateDir();
+      const preflightState = loadPreflightState(stateDir);
+      let enableLlmRewrite = false;
+      try {
+        const probeRes = await fetch(`${credentials.api_url}/api/v1/optimize`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${credentials.api_key}`
+          },
+          body: JSON.stringify({ prompt: ".", threshold: 101 })
+        });
+        if (probeRes.status === 200) {
+          enableLlmRewrite = true;
+        }
+      } catch {}
+      preflightState.config.enable_llm_rewrite = enableLlmRewrite;
+      savePreflightState(stateDir, preflightState);
+      if (enableLlmRewrite) {
+        console.log(import_picocolors.default.green("  ✓ Preflight LLM rewrite enabled (Pro/Team)"));
+      } else {
+        console.log(import_picocolors.default.dim("  ✗ Preflight LLM rewrite disabled (Free tier)"));
+      }
+      console.log();
+    }
     console.log(import_picocolors.default.bold("Detecting AI tools..."));
     const detections = await detectAll();
     for (const d of detections) {
@@ -17598,6 +18959,39 @@ async function runInit() {
       }
       console.log();
     }
+    const confirmedTools = confirmed.map((d) => d.tool);
+    if (confirmedTools.includes("claude-code")) {
+      try {
+        const { installClaudeHooks: installClaudeHooks2 } = await Promise.resolve().then(() => (init_hooks_installer(), exports_hooks_installer));
+        installClaudeHooks2(useGlobal);
+        console.log(import_picocolors.default.green("  ✓ Claude Code real-time hooks installed"));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(import_picocolors.default.yellow(`  ⚠ Claude Code hooks: ${msg}`));
+      }
+    }
+    const needsWatcher = confirmedTools.includes("codex") || confirmedTools.includes("cursor");
+    if (needsWatcher && process.platform === "darwin") {
+      try {
+        const { installUnifiedWatcher: installUnifiedWatcher2 } = await Promise.resolve().then(() => (init_hooks_installer(), exports_hooks_installer));
+        installUnifiedWatcher2(useGlobal);
+        console.log(import_picocolors.default.green("  ✓ Background watcher installed (Codex + Cursor)"));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(import_picocolors.default.yellow(`  ⚠ Background watcher: ${msg}`));
+      }
+    }
+    if (confirmedTools.includes("gemini")) {
+      console.log(import_picocolors.default.dim("  ℹ Gemini: batch sync only (run `getverbal import --sync --platforms gemini`)"));
+    }
+    if (confirmedTools.includes("cursor")) {
+      try {
+        await import("bun:sqlite");
+      } catch {
+        console.log(import_picocolors.default.yellow("  ⚠ Cursor detected but bun:sqlite not available."));
+        console.log(import_picocolors.default.yellow("    Cursor sync requires Bun runtime. Run via: bunx getverbal sync"));
+      }
+    }
     process.stdout.write(import_picocolors.default.dim("Verifying connection..."));
     try {
       await verifyConnection(credentials);
@@ -17608,8 +19002,8 @@ async function runInit() {
       console.log(import_picocolors.default.yellow(`⚠  Verification warning: ${message}`));
     }
     console.log();
-    const mcpJsonPath = join11(process.cwd(), ".mcp.json");
-    if (existsSync7(mcpJsonPath) && !isInGitignore(".mcp.json")) {
+    const mcpJsonPath = join12(process.cwd(), ".mcp.json");
+    if (existsSync8(mcpJsonPath) && !isInGitignore(".mcp.json")) {
       console.log(import_picocolors.default.yellow("⚠  .mcp.json contains your API key. Add it to .gitignore to avoid leaking credentials:"));
       console.log(import_picocolors.default.dim('     echo ".mcp.json" >> .gitignore'));
       console.log();
@@ -17635,10 +19029,9 @@ async function runInit() {
         console.log(`
   Importing ${source.id}...`);
         try {
-          const { syncFromTokscale: syncFromTokscale2 } = await Promise.resolve().then(() => (init_tokscale(), exports_tokscale));
-          const stateDir = join11(homedir10(), ".config", "getverbal");
-          const platform = source.id === "claude-code" ? "claude" : "codex";
-          const result = await syncFromTokscale2({
+          const { syncPlatforms: syncPlatforms2 } = await Promise.resolve().then(() => (init_orchestrator(), exports_orchestrator));
+          const stateDir = join12(homedir11(), ".config", "getverbal");
+          const result = await syncPlatforms2({
             apiKey: credentials.api_key,
             ingestUrl: credentials.ingest_url,
             batchSize: 100,
@@ -17646,9 +19039,9 @@ async function runInit() {
             httpTimeoutMs: 30000,
             stateDir
           }, {
-            platforms: [platform]
+            platforms: [source.id]
           });
-          console.log(import_picocolors.default.green(`  ✓ ${result.events} sessions imported`));
+          console.log(import_picocolors.default.green(`  ✓ ${result.totalEvents} sessions imported`));
         } catch (importErr) {
           const message = importErr instanceof Error ? importErr.message : String(importErr);
           console.log(import_picocolors.default.yellow(`  ⚠ Import skipped: ${message}`));