autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/commands/vaccine.ts

@@ -0,0 +1,177 @@
+/**
+ * afd vaccine — Vaccine registry CLI
+ *
+ * Sub-commands:
+ *   afd vaccine list              — list available packages
+ *   afd vaccine search <query>    — search packages
+ *   afd vaccine install <name>    — install a vaccine package
+ *   afd vaccine publish <file>    — publish a vaccine package
+ *   afd vaccine installed         — list installed packages
+ */
+
+import { readFileSync, existsSync } from "fs";
+import {
+  publishPackage,
+  searchPackages,
+  installPackage,
+  listInstalled,
+  getPackage,
+} from "../core/vaccine-registry";
+import type { VaccinePackage } from "../core/vaccine-registry";
+import { getSystemLanguage } from "../core/locale";
+
+const msgs = {
+  en: {
+    title: "afd vaccine — Registry",
+    list: "Available Packages",
+    search: "Search Results",
+    install: "Install",
+    publish: "Publish",
+    installed: "Installed Packages",
+    noPackages: "No packages found.",
+    noResults: "No matching packages.",
+    notFound: "Package not found.",
+    usage: `Usage:
+  afd vaccine list              List available packages
+  afd vaccine search <query>    Search packages
+  afd vaccine install <name>    Install a vaccine package
+  afd vaccine publish <file>    Publish from vaccine.json
+  afd vaccine installed         List installed packages`,
+  },
+  ko: {
+    title: "afd vaccine — 레지스트리",
+    list: "사용 가능한 패키지",
+    search: "검색 결과",
+    install: "설치",
+    publish: "발행",
+    installed: "설치된 패키지",
+    noPackages: "패키지가 없습니다.",
+    noResults: "일치하는 패키지가 없습니다.",
+    notFound: "패키지를 찾을 수 없습니다.",
+    usage: `사용법:
+  afd vaccine list              사용 가능한 패키지 목록
+  afd vaccine search <query>    패키지 검색
+  afd vaccine install <name>    백신 패키지 설치
+  afd vaccine publish <file>    vaccine.json에서 발행
+  afd vaccine installed         설치된 패키지 목록`,
+  },
+};
+
+const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+const W = 54;
+function hline(l: string, r: string) { return `${l}${BOX.h.repeat(W)}${r}`; }
+function row(s: string) {
+  const pad = Math.max(0, W - 2 - s.length);
+  return `${BOX.v} ${s}${" ".repeat(pad)} ${BOX.v}`;
+}
+
+export async function vaccineCommand(subcommand?: string, arg?: string) {
+  const lang = getSystemLanguage();
+  const m = msgs[lang];
+
+  if (!subcommand) {
+    console.log(m.usage);
+    return;
+  }
+
+  switch (subcommand) {
+    case "list": {
+      const packages = searchPackages();
+      console.log(hline(BOX.tl, BOX.tr));
+      console.log(row(`💉 ${m.title} — ${m.list}`));
+      console.log(hline(BOX.ml, BOX.mr));
+      if (packages.length === 0) {
+        console.log(row(m.noPackages));
+      } else {
+        for (const p of packages) {
+          console.log(row(`📦 ${p.name}@${p.version} (${p.antibodyCount} rules)`));
+          console.log(row(`   ${p.description}`));
+          console.log(row(`   ${p.ecosystem} | by ${p.author}`));
+          console.log(row(""));
+        }
+      }
+      console.log(hline(BOX.bl, BOX.br));
+      break;
+    }
+
+    case "search": {
+      const results = searchPackages(arg);
+      console.log(hline(BOX.tl, BOX.tr));
+      console.log(row(`🔍 ${m.title} — ${m.search}: "${arg ?? ""}"`));
+      console.log(hline(BOX.ml, BOX.mr));
+      if (results.length === 0) {
+        console.log(row(m.noResults));
+      } else {
+        for (const p of results) {
+          console.log(row(`📦 ${p.name}@${p.version} — ${p.description}`));
+        }
+      }
+      console.log(hline(BOX.bl, BOX.br));
+      break;
+    }
+
+    case "install": {
+      if (!arg) {
+        console.error("Usage: afd vaccine install <name>");
+        process.exit(1);
+      }
+      const result = installPackage(arg);
+      if (!result.success) {
+        console.error(`[afd vaccine] ${result.message}`);
+        process.exit(1);
+      }
+      console.log(hline(BOX.tl, BOX.tr));
+      console.log(row(`✅ ${m.install}: ${arg}`));
+      console.log(hline(BOX.ml, BOX.mr));
+      console.log(row(result.message));
+      console.log(hline(BOX.bl, BOX.br));
+      break;
+    }
+
+    case "publish": {
+      const filePath = arg ?? "vaccine.json";
+      if (!existsSync(filePath)) {
+        console.error(`[afd vaccine] File not found: ${filePath}`);
+        process.exit(1);
+      }
+      let pkg: VaccinePackage;
+      try {
+        pkg = JSON.parse(readFileSync(filePath, "utf-8"));
+      } catch {
+        console.error("[afd vaccine] Invalid JSON in vaccine file.");
+        process.exit(1);
+      }
+      const result = publishPackage(pkg);
+      console.log(hline(BOX.tl, BOX.tr));
+      console.log(row(`📤 ${m.publish}`));
+      console.log(hline(BOX.ml, BOX.mr));
+      console.log(row(result.message));
+      console.log(hline(BOX.bl, BOX.br));
+      break;
+    }
+
+    case "installed": {
+      const pkgs = listInstalled();
+      console.log(hline(BOX.tl, BOX.tr));
+      console.log(row(`📋 ${m.title} — ${m.installed}`));
+      console.log(hline(BOX.ml, BOX.mr));
+      if (pkgs.length === 0) {
+        console.log(row(m.noPackages));
+      } else {
+        for (const name of pkgs) {
+          const pkg = getPackage(name);
+          if (pkg) {
+            console.log(row(`📦 ${pkg.name}@${pkg.version} (${pkg.antibodies.length} rules)`));
+          } else {
+            console.log(row(`📦 ${name}`));
+          }
+        }
+      }
+      console.log(hline(BOX.bl, BOX.br));
+      break;
+    }
+
+    default:
+      console.log(m.usage);
+  }
+}

package/src/constants.ts

@@ -1,7 +1,32 @@
 import { join } from "path";
+import { findWorkspaceRoot } from "./core/workspace";
 
+// Relative paths (used when cwd is already the workspace root)
 export const AFD_DIR = ".afd";
 export const PID_FILE = join(AFD_DIR, "daemon.pid");
 export const PORT_FILE = join(AFD_DIR, "daemon.port");
 export const DB_FILE = join(AFD_DIR, "antibodies.sqlite");
-export const WATCH_TARGETS = [".claude/", "CLAUDE.md", ".cursorrules"];
+export const LOG_FILE = join(AFD_DIR, "daemon.log");
+export const QUARANTINE_DIR = join(AFD_DIR, "quarantine");
+export const WATCH_TARGETS = [
+  ".claude/", "CLAUDE.md", ".cursorrules", ".claudeignore", ".gitignore",
+  ".windsurfrules", ".windsurf/", "codex.md", ".codex/",
+  ".cursorignore", ".windsurfignore", ".codexignore",
+];
+
+/**
+ * Resolve all `.afd/` paths against the workspace root.
+ * Works correctly even when CLI is invoked from a subdirectory.
+ */
+export function resolveWorkspacePaths(from?: string) {
+  const root = findWorkspaceRoot(from);
+  return {
+    root,
+    afdDir: join(root, AFD_DIR),
+    pidFile: join(root, PID_FILE),
+    portFile: join(root, PORT_FILE),
+    dbFile: join(root, DB_FILE),
+    logFile: join(root, LOG_FILE),
+    quarantineDir: join(root, QUARANTINE_DIR),
+  };
+}

package/src/core/boast.ts

@@ -0,0 +1,280 @@
+/**
+ * Boastful Doctor — Gamification & Delightful Logging
+ *
+ * O(1) math only — no I/O, no async. All strings localized via i18n.
+ */
+
+import { getSystemLanguage } from "./locale";
+import type { SupportedLang } from "./locale";
+import { getMessages, t } from "./i18n/messages";
+import type { MessageDict } from "./i18n/messages";
+
+// ── Token & Cost Estimation ──
+
+const CHARS_PER_TOKEN = 3.5;
+const COST_PER_1K_TOKENS = 0.003;
+const DEBUG_MINUTES_BASE = 8;
+const DEBUG_MINUTES_PER_KB = 2;
+
+export interface HealMetrics {
+  fileSize: number;
+  healTimeMs: number;
+  tokensSaved: number;
+  minutesSaved: number;
+  costSaved: number;
+}
+
+/** Calculate mock "value saved" from a heal event. O(1), no I/O. */
+export function calcHealMetrics(fileSize: number, healTimeMs: number): HealMetrics {
+  const tokensSaved = Math.round(fileSize / CHARS_PER_TOKEN);
+  const fileSizeKB = fileSize / 1024;
+  const minutesSaved = Math.round(DEBUG_MINUTES_BASE + fileSizeKB * DEBUG_MINUTES_PER_KB);
+  const costSaved = Math.round(tokensSaved / 1000 * COST_PER_1K_TOKENS * 100) / 100;
+  return { fileSize, healTimeMs, tokensSaved, minutesSaved, costSaved };
+}
+
+export interface ShiftSummary {
+  uptimeFormatted: string;
+  totalEvents: number;
+  healsPerformed: number;
+  totalTokensSaved: number;
+  totalMinutesSaved: number;
+  totalCostSaved: number;
+  suppressionsSkipped: number;
+  dormantTransitions: number;
+  boast: string;
+  // Unified ROI breakdown
+  healTokensSaved: number;
+  healCostSaved: number;
+  hologramTokensSaved: number;
+  hologramCostSaved: number;
+}
+
+/** Build a shift summary from aggregated daemon stats. */
+export function buildShiftSummary(stats: {
+  uptimeSeconds: number;
+  totalEvents: number;
+  healsPerformed: number;
+  totalFileBytesSaved: number;
+  suppressionsSkipped: number;
+  dormantTransitions: number;
+  hologramSavedChars?: number;
+}, lang?: SupportedLang): ShiftSummary {
+  const l = lang ?? getSystemLanguage();
+  const m = getMessages(l);
+
+  // Auto-Heal ROI
+  const healTokensSaved = Math.round(stats.totalFileBytesSaved / CHARS_PER_TOKEN);
+  const healCostSaved = Math.round(healTokensSaved / 1000 * COST_PER_1K_TOKENS * 100) / 100;
+
+  // Hologram ROI
+  const holoSavedChars = stats.hologramSavedChars ?? 0;
+  const hologramTokensSaved = Math.round(holoSavedChars / CHARS_PER_TOKEN);
+  const hologramCostSaved = Math.round(hologramTokensSaved / 1000 * COST_PER_1K_TOKENS * 100) / 100;
+
+  // Unified totals
+  const totalTokensSaved = healTokensSaved + hologramTokensSaved;
+  const totalMinutesSaved = stats.healsPerformed * DEBUG_MINUTES_BASE;
+  const totalCostSaved = Math.round((healCostSaved + hologramCostSaved) * 100) / 100;
+
+  return {
+    uptimeFormatted: formatUptime(stats.uptimeSeconds),
+    totalEvents: stats.totalEvents,
+    healsPerformed: stats.healsPerformed,
+    totalTokensSaved,
+    totalMinutesSaved,
+    totalCostSaved,
+    suppressionsSkipped: stats.suppressionsSkipped,
+    dormantTransitions: stats.dormantTransitions,
+    boast: pick(m.BOAST_SHIFT_END),
+    healTokensSaved,
+    healCostSaved,
+    hologramTokensSaved,
+    hologramCostSaved,
+  };
+}
+
+// ── Boast Selection ──
+
+function msg(lang?: SupportedLang): MessageDict {
+  return getMessages(lang ?? getSystemLanguage());
+}
+
+/** Pick a random heal boast. 1-in-N chance (anti-annoyance). */
+export function maybeHealBoast(triggerChance = 5, lang?: SupportedLang): string | null {
+  if (Math.floor(Math.random() * triggerChance) !== 0) return null;
+  const m = msg(lang);
+  return pick(m.BOAST_HEAL);
+}
+
+/** Always returns a dormant boast (rare event, always worth noting). */
+export function dormantBoast(lang?: SupportedLang): string {
+  return pick(msg(lang).BOAST_DORMANT);
+}
+
+/** Pick a random shift-end boast in the given locale. */
+export function localizedBoast(lang?: SupportedLang): string {
+  return pick(msg(lang).BOAST_SHIFT_END);
+}
+
+/** Format a single heal log line with metrics. */
+export function formatHealLog(
+  fileName: string,
+  metrics: HealMetrics,
+  boast: string | null,
+  lang?: SupportedLang,
+): string {
+  const m = msg(lang);
+  const vars = {
+    fileName,
+    ms: metrics.healTimeMs,
+    tokens: metrics.tokensSaved,
+    mins: metrics.minutesSaved,
+  };
+  const base = t(m.HEAL_LOG, vars);
+  if (!boast) return base;
+  const boastLine = t(boast, vars);
+  return `${base}\n${m.BOAST_HEAL_PREFIX} ${boastLine}`;
+}
+
+/** Format dormant log line. */
+export function formatDormantLog(
+  antibodyId: string,
+  lang?: SupportedLang,
+): string {
+  const m = msg(lang);
+  const boast = pick(m.BOAST_DORMANT);
+  return t(m.DORMANT_LOG, { id: antibodyId, boast });
+}
+
+/** Format the full shift summary for terminal output. */
+export function formatShiftSummary(s: ShiftSummary, lang?: SupportedLang): string {
+  const m = msg(lang);
+  const lines = [
+    "",
+    "┌──────────────────────────────────────────────┐",
+    pad(`  ${m.SHIFT_TITLE}`),
+    "├──────────────────────────────────────────────┤",
+    padKV(m.SHIFT_ON_DUTY, s.uptimeFormatted),
+    padKV(m.SHIFT_EVENTS, String(s.totalEvents)),
+    padKV(m.SHIFT_HEALS, String(s.healsPerformed)),
+    padKV(m.SHIFT_TOKENS, `~${fmtNum(s.totalTokensSaved)}`),
+    padKV(m.SHIFT_TIME, `~${s.totalMinutesSaved} min`),
+    padKV(m.SHIFT_COST, `~$${s.totalCostSaved.toFixed(2)}`),
+  ];
+
+  if (s.suppressionsSkipped > 0) {
+    padKVPush(lines, m.SHIFT_SUPPRESSED, `${s.suppressionsSkipped} mass events`);
+  }
+  if (s.dormantTransitions > 0) {
+    padKVPush(lines, m.SHIFT_RETIRED, `${s.dormantTransitions} antibodies`);
+  }
+
+  lines.push("├──────────────────────────────────────────────┤");
+  // Override server-side boast with locale-appropriate one
+  const localBoast = pick(m.BOAST_SHIFT_END);
+  lines.push(pad(`  ${localBoast}`));
+  lines.push("└──────────────────────────────────────────────┘");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+/** Format value section for score command. */
+export function formatValueSection(s: ShiftSummary, lang?: SupportedLang): string[] {
+  const m = msg(lang);
+  const lines: string[] = [];
+  lines.push(m.SCORE_VALUE_TITLE);
+  lines.push(`${m.SHIFT_TOKENS}: ~${fmtNum(s.totalTokensSaved)}`);
+  lines.push(`${m.SHIFT_TIME}: ~${s.totalMinutesSaved} min`);
+  lines.push(`${m.SHIFT_COST}: ~$${s.totalCostSaved.toFixed(2)}`);
+  return lines;
+}
+
+// ── Helpers ──
+
+function pick<T>(arr: T[]): T {
+  if (arr.length === 0) return "" as unknown as T;
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function formatUptime(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  return `${h}h ${m}m`;
+}
+
+const W = 46;
+
+function pad(content: string): string {
+  const visual = visualWidth(content);
+  if (visual > W) {
+    let len = 0;
+    let cut = 0;
+    for (const ch of content) {
+      const cw = isWideChar(ch) ? 2 : 1;
+      if (len + cw > W - 1) break;
+      len += cw;
+      cut += ch.length;
+    }
+    const trimmed = content.slice(0, cut) + "…";
+    const trimVw = visualWidth(trimmed);
+    return `│${trimmed}${" ".repeat(Math.max(0, W - trimVw))}│`;
+  }
+  return `│${content}${" ".repeat(Math.max(0, W - visual))}│`;
+}
+
+/** Pad a key-value row with aligned colon, visual-width-aware. */
+function padKV(key: string, value: string): string {
+  const keyVw = visualWidth(key);
+  const padSize = Math.max(0, 13 - keyVw);
+  return pad(`  ${key}${" ".repeat(padSize)}: ${value}`);
+}
+
+function padKVPush(lines: string[], key: string, value: string): void {
+  lines.push(padKV(key, value));
+}
+
+export function visualWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) {
+    w += isWideChar(ch) ? 2 : 1;
+  }
+  return w;
+}
+
+function isWideChar(ch: string): boolean {
+  const code = ch.codePointAt(0) ?? 0;
+  return (
+    // CJK Unified Ideographs
+    (code >= 0x4E00 && code <= 0x9FFF) ||
+    // CJK Extension A
+    (code >= 0x3400 && code <= 0x4DBF) ||
+    // Hangul Syllables
+    (code >= 0xAC00 && code <= 0xD7AF) ||
+    // Hangul Jamo
+    (code >= 0x1100 && code <= 0x11FF) ||
+    // Hangul Compatibility Jamo
+    (code >= 0x3130 && code <= 0x318F) ||
+    // CJK Compatibility
+    (code >= 0x3300 && code <= 0x33FF) ||
+    // Fullwidth Forms
+    (code >= 0xFF01 && code <= 0xFF60) ||
+    // Common emoji ranges
+    (code >= 0x1F300 && code <= 0x1FBFF) ||
+    (code >= 0x2600 && code <= 0x27BF) ||
+    (code >= 0xFE00 && code <= 0xFE0F) ||
+    (code >= 0x200D && code <= 0x200D) ||
+    (code >= 0x231A && code <= 0x23FA) ||
+    code === 0x2764 ||
+    code === 0x2139
+  );
+}
+
+export function fmtNum(n: number): string {
+  if (n < 1000) return `${n}`;
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}K`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}

package/src/core/config.ts

@@ -0,0 +1,49 @@
+/**
+ * Persistent user configuration — ~/.afdrc
+ *
+ * JSON file with user preferences. Created on first `afd lang` call.
+ * Read is sync and cached; write is sync (rare operation).
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+export interface AfdConfig {
+  lang?: string;
+}
+
+const RC_PATH = join(homedir(), ".afdrc");
+
+let configCache: AfdConfig | null = null;
+
+/** Read ~/.afdrc. Returns empty object if missing or invalid. */
+export function readConfig(): AfdConfig {
+  if (configCache) return configCache;
+  if (!existsSync(RC_PATH)) {
+    configCache = {};
+    return configCache;
+  }
+  try {
+    configCache = JSON.parse(readFileSync(RC_PATH, "utf-8"));
+    return configCache!;
+  } catch {
+    configCache = {};
+    return configCache;
+  }
+}
+
+/** Write a key to ~/.afdrc. Merges with existing config. */
+export function writeConfig(partial: Partial<AfdConfig>): AfdConfig {
+  const current = readConfig();
+  const merged = { ...current, ...partial };
+  mkdirSync(dirname(RC_PATH), { recursive: true });
+  writeFileSync(RC_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  configCache = merged;
+  return merged;
+}
+
+/** Get the RC file path (for display). */
+export function getConfigPath(): string {
+  return RC_PATH;
+}

package/src/core/db.ts

@@ -1,10 +1,11 @@
 import { mkdirSync } from "fs";
 import { Database } from "bun:sqlite";
-import { AFD_DIR, DB_FILE } from "../constants";
+import { resolveWorkspacePaths } from "../constants";
 
 export function initDb(): Database {
-  mkdirSync(AFD_DIR, { recursive: true });
-  const db = new Database(DB_FILE);
+  const paths = resolveWorkspacePaths();
+  mkdirSync(paths.afdDir, { recursive: true });
+  const db = new Database(paths.dbFile);
   db.exec("PRAGMA journal_mode = WAL");
 
   db.exec(`
@@ -42,5 +43,75 @@ export function initDb(): Database {
     )
   `);
 
+  // ── Hologram Stats: lifetime (single row) + daily (7-day rolling) ──
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS hologram_lifetime (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      total_requests INTEGER NOT NULL DEFAULT 0,
+      total_original_chars INTEGER NOT NULL DEFAULT 0,
+      total_hologram_chars INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+  db.exec(`INSERT OR IGNORE INTO hologram_lifetime (id) VALUES (1)`);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS hologram_daily (
+      date TEXT PRIMARY KEY,
+      requests INTEGER NOT NULL DEFAULT 0,
+      original_chars INTEGER NOT NULL DEFAULT 0,
+      hologram_chars INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+  // Purge entries older than 7 days
+  db.exec(`DELETE FROM hologram_daily WHERE date < date('now', '-7 days')`);
+
+  // ── Telemetry: feature usage tracking ──
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS telemetry (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      category TEXT NOT NULL,
+      action TEXT NOT NULL,
+      detail TEXT,
+      duration_ms REAL,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_telemetry_cat_ts ON telemetry(category, timestamp)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_telemetry_action ON telemetry(action)`);
+  // Purge raw telemetry older than 30 days
+  db.exec(`DELETE FROM telemetry WHERE timestamp < unixepoch() * 1000 - 30 * 86400000`);
+
+  // ── Mistake History: passive defense tracking ──
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS mistake_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL,
+      mistake_type TEXT NOT NULL,
+      description TEXT NOT NULL,
+      antibody_id TEXT,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_mistake_history_path ON mistake_history(file_path)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_mistake_history_ts ON mistake_history(timestamp)`);
+  db.exec(`DELETE FROM mistake_history WHERE timestamp < unixepoch() * 1000 - 30 * 86400000`);
+
+  // Migration: move data from old hologram_stats table if it exists
+  try {
+    const old = db.prepare("SELECT total_requests, total_original_chars, total_hologram_chars FROM hologram_stats WHERE id = 1").get() as {
+      total_requests: number; total_original_chars: number; total_hologram_chars: number;
+    } | null;
+    if (old && old.total_requests > 0) {
+      db.transaction(() => {
+        db.prepare(
+          "UPDATE hologram_lifetime SET total_requests = ?, total_original_chars = ?, total_hologram_chars = ? WHERE id = 1"
+        ).run(old.total_requests, old.total_original_chars, old.total_hologram_chars);
+        db.exec("DROP TABLE hologram_stats");
+      })();
+    }
+  } catch {
+    // Old table doesn't exist — clean install
+  }
+
   return db;
 }

package/src/core/discovery.ts

@@ -0,0 +1,65 @@
+/**
+ * Smart Discovery — scans project root for AI-agent config patterns.
+ *
+ * Runs ONCE at startup. O(n) existsSync calls on a known candidate list.
+ * No directory traversal, no glob — just fast stat checks (< 5ms).
+ */
+
+import { existsSync } from "fs";
+
+/** All known AI-agent config patterns to probe. */
+const DISCOVERY_CANDIDATES = [
+  // Claude Code ecosystem
+  ".claude/",
+  "CLAUDE.md",
+  ".claudeignore",
+  // Cursor ecosystem
+  ".cursorrules",
+  ".cursorignore",
+  // Git essentials
+  ".gitignore",
+  // MCP configs
+  "mcp-config.json",
+  ".mcp.json",
+  // Generic AI config directories
+  ".ai/",
+  // Custom rules (various tools)
+  ".customrules",
+  ".windsurfrules",
+  // Copilot
+  ".github/copilot-instructions.md",
+] as const;
+
+export interface DiscoveryResult {
+  /** All targets that exist on disk (merged with defaults, deduplicated). */
+  targets: string[];
+  /** How many were found via smart discovery (beyond the hardcoded defaults). */
+  discoveredCount: number;
+  /** Elapsed time in ms. */
+  elapsedMs: number;
+}
+
+/**
+ * Discover AI-context files in the project root.
+ * Merges found targets with the provided defaults, deduplicates, and returns.
+ */
+export function discoverWatchTargets(defaults: readonly string[]): DiscoveryResult {
+  const t0 = performance.now();
+  const seen = new Set<string>(defaults);
+  let discoveredCount = 0;
+
+  for (const candidate of DISCOVERY_CANDIDATES) {
+    if (seen.has(candidate)) continue;
+    if (existsSync(candidate)) {
+      seen.add(candidate);
+      discoveredCount++;
+    }
+  }
+
+  const elapsedMs = Math.round((performance.now() - t0) * 100) / 100;
+  return {
+    targets: [...seen],
+    discoveredCount,
+    elapsedMs,
+  };
+}