becki-mcp 1.1.0

package/dist/core/db.js

@@ -0,0 +1,221 @@
+// db.ts — Cross-platform local SQLite cache for Becki Core (#191 sub-task 2)
+//
+// On Studio, the Mac app holds the local SQLite (GRDB). Core has no Mac app,
+// so becki-mcp owns its own cache here.
+//
+// Schema purpose:
+//   config              — key/value store (replaces UserDefaults from Swift)
+//   ai_session_state    — per-jsonl tracking (file_size + processed flag) so
+//                         we don't re-extract from sessions that haven't grown
+//   projects            — user-registered project directories for sweeper
+//   project_activity    — debounced summary state for project file events
+//   vault_rows_cache    — read-through cache of recent NeuraVault rows so
+//                         MCP queries don't hit Supabase on every call
+//
+// Designed for `better-sqlite3` (synchronous, single-process, fast). DB
+// lives at `<BECKI_HOME>/cache.db` — sibling to install.json + mcp-registry.
+import Database from "better-sqlite3";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+const SCHEMA_VERSION = 1;
+const MIGRATIONS = {
+    1: [
+        `CREATE TABLE IF NOT EXISTS config (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )`,
+        `CREATE TABLE IF NOT EXISTS ai_session_state (
+      path TEXT PRIMARY KEY,
+      file_size INTEGER NOT NULL,
+      last_processed_at INTEGER NOT NULL,
+      bootstrap_processed INTEGER NOT NULL DEFAULT 0
+    )`,
+        `CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL UNIQUE,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at INTEGER NOT NULL
+    )`,
+        `CREATE TABLE IF NOT EXISTS project_activity (
+      project_id TEXT PRIMARY KEY,
+      last_summary_at INTEGER NOT NULL,
+      last_summary_text TEXT
+    )`,
+        `CREATE TABLE IF NOT EXISTS vault_rows_cache (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      content TEXT NOT NULL,
+      metadata TEXT,
+      source_type TEXT,
+      source_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )`,
+        `CREATE INDEX IF NOT EXISTS idx_vault_user_created
+       ON vault_rows_cache(user_id, created_at DESC)`,
+        `CREATE INDEX IF NOT EXISTS idx_vault_source
+       ON vault_rows_cache(source_type, source_id)`,
+    ],
+};
+export class BeckiCache {
+    db;
+    constructor(beckiHome) {
+        if (!existsSync(beckiHome))
+            mkdirSync(beckiHome, { recursive: true });
+        this.db = new Database(join(beckiHome, "cache.db"));
+        // WAL gives concurrent readers + one writer without lock contention;
+        // safer for a daemon that might be queried while a sweep is mid-write.
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.migrate();
+    }
+    migrate() {
+        this.db.exec(`CREATE TABLE IF NOT EXISTS schema_meta (version INTEGER PRIMARY KEY)`);
+        const row = this.db
+            .prepare(`SELECT version FROM schema_meta ORDER BY version DESC LIMIT 1`)
+            .get();
+        const current = row?.version ?? 0;
+        for (let v = current + 1; v <= SCHEMA_VERSION; v++) {
+            const steps = MIGRATIONS[v];
+            if (!steps)
+                continue;
+            const tx = this.db.transaction(() => {
+                for (const sql of steps)
+                    this.db.exec(sql);
+                this.db
+                    .prepare(`INSERT INTO schema_meta(version) VALUES (?)`)
+                    .run(v);
+            });
+            tx();
+        }
+    }
+    // ── Config k/v ──────────────────────────────────────────────────────────
+    getConfig(key) {
+        const row = this.db
+            .prepare(`SELECT value FROM config WHERE key = ?`)
+            .get(key);
+        return row?.value ?? null;
+    }
+    getConfigJSON(key) {
+        const raw = this.getConfig(key);
+        if (raw === null)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    setConfig(key, value) {
+        this.db
+            .prepare(`INSERT INTO config(key, value, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+            .run(key, value, Date.now());
+    }
+    setConfigJSON(key, value) {
+        this.setConfig(key, JSON.stringify(value));
+    }
+    // ── AI session tracking ────────────────────────────────────────────────
+    getSessionState(path) {
+        return (this.db
+            .prepare(`SELECT * FROM ai_session_state WHERE path = ?`)
+            .get(path) ?? null);
+    }
+    recordSessionProcessed(path, fileSize, isBootstrap) {
+        this.db
+            .prepare(`INSERT INTO ai_session_state(path, file_size, last_processed_at, bootstrap_processed)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           file_size = excluded.file_size,
+           last_processed_at = excluded.last_processed_at,
+           bootstrap_processed = MAX(ai_session_state.bootstrap_processed, excluded.bootstrap_processed)`)
+            .run(path, fileSize, Date.now(), isBootstrap ? 1 : 0);
+    }
+    isBootstrapProcessed(path) {
+        const row = this.getSessionState(path);
+        return row?.bootstrap_processed === 1;
+    }
+    // ── Projects ───────────────────────────────────────────────────────────
+    upsertProject(p) {
+        const active = (p.active ?? true) ? 1 : 0;
+        this.db
+            .prepare(`INSERT INTO projects(id, name, path, active, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           name = excluded.name,
+           active = excluded.active`)
+            .run(p.id, p.name, p.path, active, Date.now());
+    }
+    listProjects(activeOnly = true) {
+        const sql = activeOnly
+            ? `SELECT * FROM projects WHERE active = 1 ORDER BY name`
+            : `SELECT * FROM projects ORDER BY name`;
+        return this.db.prepare(sql).all();
+    }
+    setProjectActive(id, active) {
+        this.db
+            .prepare(`UPDATE projects SET active = ? WHERE id = ?`)
+            .run(active ? 1 : 0, id);
+    }
+    // ── Project activity (debounced summary state) ─────────────────────────
+    recordProjectSummary(projectId, summary) {
+        this.db
+            .prepare(`INSERT INTO project_activity(project_id, last_summary_at, last_summary_text)
+         VALUES (?, ?, ?)
+         ON CONFLICT(project_id) DO UPDATE SET
+           last_summary_at = excluded.last_summary_at,
+           last_summary_text = excluded.last_summary_text`)
+            .run(projectId, Date.now(), summary);
+    }
+    getLastProjectSummary(projectId) {
+        return (this.db
+            .prepare(`SELECT last_summary_at, last_summary_text FROM project_activity WHERE project_id = ?`)
+            .get(projectId) ?? null);
+    }
+    // ── Vault row read-through cache ───────────────────────────────────────
+    cacheVaultRow(row) {
+        this.db
+            .prepare(`INSERT INTO vault_rows_cache
+           (id, user_id, type, content, metadata, source_type, source_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           content = excluded.content,
+           metadata = excluded.metadata,
+           source_type = excluded.source_type,
+           source_id = excluded.source_id,
+           updated_at = excluded.updated_at`)
+            .run(row.id, row.user_id, row.type, row.content, row.metadata, row.source_type, row.source_id, row.created_at, row.updated_at);
+    }
+    getRecentCachedRows(userId, limit = 50) {
+        return this.db
+            .prepare(`SELECT * FROM vault_rows_cache
+         WHERE user_id = ?
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(userId, limit);
+    }
+    countCachedRows(userId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM vault_rows_cache WHERE user_id = ?`)
+            .get(userId);
+        return row?.n ?? 0;
+    }
+    // ── Maintenance ────────────────────────────────────────────────────────
+    vacuum() {
+        this.db.exec(`VACUUM`);
+    }
+    close() {
+        this.db.close();
+    }
+}
+// Convenience factory — most callers don't need the class directly.
+let cached = null;
+export function getCache(beckiHome) {
+    if (!cached)
+        cached = new BeckiCache(beckiHome);
+    return cached;
+}

package/dist/core/init.js

@@ -0,0 +1,218 @@
+// init.ts — `becki-mcp init` CLI (#191 sub-task 5)
+//
+// First-time setup for Becki Core. Run after `npm i -g becki-mcp`:
+//
+//   becki-mcp init                  → interactive setup
+//   becki-mcp init --scan ~/Repos   → auto-detect git repos under a path
+//   becki-mcp init --bootstrap      → run historical AI session ingest too
+//
+// What it does:
+//   1. Ensures `~/.becki/` (or BECKI_HOME) exists with cache.db
+//   2. Detects git repos in user-specified roots (default: ~/Documents, ~/Repos, ~/Code, ~/src)
+//   3. Prompts (or auto-confirms with --yes) which to register as projects
+//   4. Prints the MCP client snippet to add to Claude Desktop / Cursor / etc.
+//   5. (Optional) runs historical AI session bootstrap to backfill last 90 days
+//
+// Auth: install-token flow stays unchanged from the existing index.ts —
+// user authenticates by visiting becki.io and pasting the token, OR by
+// having Becki.app generate one (Studio path). This CLI just makes the
+// daemon usable; auth lives elsewhere.
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { BeckiCache } from "./db.js";
+// ── Repo discovery ──────────────────────────────────────────────────────────
+const DEFAULT_SCAN_ROOTS = [
+    join(homedir(), "Documents"),
+    join(homedir(), "Repos"),
+    join(homedir(), "Code"),
+    join(homedir(), "src"),
+    join(homedir(), "Projects"),
+    join(homedir(), "Developer"),
+];
+const SCAN_MAX_DEPTH = 3;
+async function isGitRepo(path) {
+    try {
+        const s = await stat(join(path, ".git"));
+        return s.isDirectory() || s.isFile(); // worktrees use a .git file
+    }
+    catch {
+        return false;
+    }
+}
+async function findRepos(roots) {
+    const seen = new Set();
+    async function walk(dir, depth) {
+        if (depth > SCAN_MAX_DEPTH)
+            return;
+        if (seen.has(dir))
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        if (await isGitRepo(dir)) {
+            seen.add(dir);
+            return; // do not descend further once we've found a repo
+        }
+        for (const ent of entries) {
+            if (!ent.isDirectory())
+                continue;
+            if (ent.name.startsWith("."))
+                continue; // skip dotdirs at the root level
+            await walk(join(dir, ent.name), depth + 1);
+        }
+    }
+    for (const root of roots) {
+        if (existsSync(root))
+            await walk(root, 0);
+    }
+    return [...seen].sort();
+}
+function parseArgs(argv) {
+    const out = { scan: [], yes: false, bootstrap: false, help: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--help" || a === "-h")
+            out.help = true;
+        else if (a === "--yes" || a === "-y")
+            out.yes = true;
+        else if (a === "--bootstrap")
+            out.bootstrap = true;
+        else if (a === "--scan") {
+            const next = argv[i + 1];
+            if (next && !next.startsWith("-")) {
+                out.scan.push(next);
+                i++;
+            }
+        }
+    }
+    return out;
+}
+const HELP_TEXT = `becki-mcp init — first-time setup for Becki Core
+
+Usage:
+  becki-mcp init [options]
+
+Options:
+  --scan <path>       Add a directory to scan for git repos (repeatable)
+  --yes, -y           Auto-confirm all detected repos (non-interactive)
+  --bootstrap         After setup, ingest last 90 days of AI sessions
+  --help, -h          Show this help
+
+Defaults scanned: ~/Documents, ~/Repos, ~/Code, ~/src, ~/Projects, ~/Developer
+`;
+// ── Project name heuristic ──────────────────────────────────────────────────
+function projectNameFromPath(repoPath) {
+    const parts = repoPath.split("/").filter(Boolean);
+    return parts[parts.length - 1] ?? "unnamed";
+}
+// ── MCP config snippet ──────────────────────────────────────────────────────
+function printMcpSnippet() {
+    const cmd = process.argv[1] ?? "becki-mcp";
+    console.log(`
+Add this to your AI client's MCP config to use Becki Core:
+
+  Claude Desktop  (~/Library/Application Support/Claude/claude_desktop_config.json):
+    {
+      "mcpServers": {
+        "becki": {
+          "command": "${cmd}"
+        }
+      }
+    }
+
+  Cursor / Windsurf / Codex: same config, under "mcpServers".
+
+Then restart your AI client. The 'becki' tool will appear.
+`);
+}
+// ── Main ────────────────────────────────────────────────────────────────────
+export async function runInit(rawArgv, beckiHome) {
+    const args = parseArgs(rawArgv);
+    if (args.help) {
+        console.log(HELP_TEXT);
+        return 0;
+    }
+    console.log(`becki-mcp init — setting up Becki Core in ${beckiHome}\n`);
+    const cache = new BeckiCache(beckiHome);
+    const existing = cache.listProjects(false);
+    if (existing.length > 0) {
+        console.log(`${existing.length} project(s) already registered:`);
+        for (const p of existing) {
+            console.log(`  ${p.active ? "✓" : " "} ${p.name}  (${p.path})`);
+        }
+        console.log("");
+    }
+    const roots = [...DEFAULT_SCAN_ROOTS, ...args.scan];
+    console.log(`Scanning for git repos in:`);
+    for (const r of roots)
+        console.log(`  ${r}${existsSync(r) ? "" : "  (missing — skipped)"}`);
+    console.log("");
+    const repos = await findRepos(roots);
+    if (repos.length === 0) {
+        console.log("No git repos found. Run with --scan <path> to add custom locations.");
+        printMcpSnippet();
+        cache.close();
+        return 0;
+    }
+    // De-dupe against already-registered
+    const known = new Set(existing.map((p) => p.path));
+    const candidates = repos.filter((r) => !known.has(r));
+    if (candidates.length === 0) {
+        console.log("All discovered repos are already registered.");
+        printMcpSnippet();
+        cache.close();
+        return 0;
+    }
+    console.log(`Found ${candidates.length} new repo(s):\n`);
+    candidates.forEach((r, i) => {
+        console.log(`  ${(i + 1).toString().padStart(2)}.  ${projectNameFromPath(r)}  — ${r}`);
+    });
+    console.log("");
+    let toRegister;
+    if (args.yes) {
+        toRegister = candidates;
+    }
+    else {
+        const rl = createInterface({ input: stdin, output: stdout });
+        const answer = (await rl.question("Register which? (all / none / 1,3,5 / comma-list, default: all): ")).trim().toLowerCase();
+        rl.close();
+        if (answer === "" || answer === "all") {
+            toRegister = candidates;
+        }
+        else if (answer === "none") {
+            toRegister = [];
+        }
+        else {
+            const indices = answer
+                .split(",")
+                .map((s) => parseInt(s.trim(), 10) - 1)
+                .filter((n) => Number.isInteger(n) && n >= 0 && n < candidates.length);
+            toRegister = indices.map((i) => candidates[i]);
+        }
+    }
+    for (const path of toRegister) {
+        cache.upsertProject({
+            id: randomUUID(),
+            name: projectNameFromPath(path),
+            path,
+            active: true,
+        });
+    }
+    console.log(`\nRegistered ${toRegister.length} project(s).\n`);
+    if (args.bootstrap) {
+        console.log("Bootstrap requested — run `becki-mcp bootstrap` separately to ingest last 90 days of AI sessions.");
+        console.log("(Bootstrap is decoupled from init so you can re-run setup without re-paying for extraction.)");
+    }
+    printMcpSnippet();
+    cache.close();
+    return 0;
+}

package/dist/core/project-activity.js

@@ -0,0 +1,225 @@
+// project-activity.ts — Cross-platform project file watcher for Becki Core
+//                       (#191 sub-task 4). Port of ProjectActivityWatcher.swift.
+//
+// Watches user-registered project directories via chokidar (cross-platform
+// FSEvents/inotify abstraction), accumulates touched paths with a 60s
+// debounce, and on quiet fires an activity-summary ingest:
+//   "Active development in project X — <timestamp>
+//    Branch: <git>
+//    Changed: N files across M directories
+//    File types: ts: 12, json: 4, ..."
+//
+// The summary is short and dense — designed to embed cleanly so semantic
+// search can answer "what was I working on Tuesday?" without the watcher
+// having to understand the code itself.
+//
+// Mac equivalent used FSEvents directly via Core Services. Chokidar gives
+// us identical semantics on Mac (FSEvents), Linux (inotify), and Windows
+// (ReadDirectoryChangesW), without us writing any platform code.
+import { watch } from "chokidar";
+import { extname, dirname, relative, sep } from "path";
+import { execSync } from "child_process";
+// ── Constants ───────────────────────────────────────────────────────────────
+/** Path components that mean "build artifact / package cache / VCS junk" —
+ *  changes here don't reflect intentional development work, so they
+ *  shouldn't burn extraction budget. Match Swift's IGNORED set exactly. */
+const IGNORED_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "DerivedData",
+    ".build",
+    ".swiftpm",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "build",
+    "dist",
+    ".next",
+    ".cache",
+    ".turbo",
+    "target", // Rust
+    ".gradle", // Java
+    "Pods", // CocoaPods
+]);
+const DEBOUNCE_MS = 60_000; // 60s quiet before summarize
+const MAX_PATHS_IN_SUMMARY = 5; // sample path count
+const MAX_FILE_TYPES_IN_SUMMARY = 5;
+const MAX_DIRS_IN_SUMMARY = 3;
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/** Returns true if ANY component of the path matches an ignored dir name. */
+function isIgnoredPath(absPath) {
+    const parts = absPath.split(sep);
+    for (const p of parts)
+        if (IGNORED_DIRS.has(p))
+            return true;
+    return false;
+}
+function readGitBranch(cwd) {
+    try {
+        const out = execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2_000,
+        })
+            .toString()
+            .trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function topN(map, n) {
+    return [...map.entries()].sort((a, b) => b[1] - a[1]).slice(0, n);
+}
+// ── Summary generation ─────────────────────────────────────────────────────
+export function summarizeActivity(args) {
+    const now = args.now ?? new Date();
+    const byExt = new Map();
+    const byDir = new Map();
+    const relPaths = [];
+    for (const abs of args.touched) {
+        const ext = extname(abs).replace(/^\./, "").toLowerCase() || "(none)";
+        byExt.set(ext, (byExt.get(ext) ?? 0) + 1);
+        const rel = relative(args.projectPath, abs);
+        const dir = dirname(rel) || ".";
+        byDir.set(dir, (byDir.get(dir) ?? 0) + 1);
+        relPaths.push(rel);
+    }
+    // shortest paths first → typically the most representative (avoid 20-deep
+    // node_modules-style long paths even though we already filter them).
+    relPaths.sort((a, b) => a.length - b.length);
+    const sample = relPaths.slice(0, MAX_PATHS_IN_SUMMARY);
+    const branch = readGitBranch(args.projectPath);
+    const types = topN(byExt, MAX_FILE_TYPES_IN_SUMMARY)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join(", ");
+    const dirs = topN(byDir, MAX_DIRS_IN_SUMMARY)
+        .map(([k, v]) => `${k} (${v})`)
+        .join(", ");
+    const lines = [
+        `Active development in project '${args.projectName}' — ${now.toISOString()}`,
+        branch ? `Branch: ${branch}` : null,
+        `Changed: ${args.touched.size} files across ${byDir.size} directories`,
+        types ? `File types: ${types}` : null,
+        dirs ? `Top dirs: ${dirs}` : null,
+        sample.length > 0 ? `Sample: ${sample.join("; ")}` : null,
+    ].filter((l) => !!l);
+    return lines.join("\n");
+}
+export class ProjectActivityWatcher {
+    opts;
+    watchers = new Map(); // projectId → watcher
+    pending = new Map(); // projectId → touched abs paths
+    timers = new Map(); // projectId → debounce timer
+    projects = new Map(); // projectId → row
+    debounceMs;
+    log;
+    constructor(opts) {
+        this.opts = opts;
+        this.debounceMs = opts.debounceMs ?? DEBOUNCE_MS;
+        this.log = opts.logger ?? (() => { });
+    }
+    /** Start watching every active project from the local DB. Call once on
+     *  daemon startup; safe to call again — re-startWatch is idempotent. */
+    async startAll() {
+        const projects = this.opts.cache.listProjects(true);
+        for (const p of projects)
+            this.startWatch(p);
+    }
+    startWatch(p) {
+        if (this.watchers.has(p.id))
+            return; // already running
+        this.projects.set(p.id, p);
+        const watcher = watch(p.path, {
+            ignored: (path) => isIgnoredPath(path),
+            ignoreInitial: true, // initial scan would flood; only react to changes
+            persistent: true,
+            awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
+            depth: 12, // generous but bounded
+        });
+        const onEvent = (path) => this.recordChange(p.id, path);
+        watcher.on("add", onEvent);
+        watcher.on("change", onEvent);
+        watcher.on("unlink", onEvent);
+        watcher.on("error", (err) => {
+            this.log(`project-activity[${p.name}]: watcher error: ${err.message}`);
+        });
+        this.watchers.set(p.id, watcher);
+        this.log(`project-activity: watching '${p.name}' at ${p.path}`);
+    }
+    stopWatch(projectId) {
+        const w = this.watchers.get(projectId);
+        if (w) {
+            void w.close();
+            this.watchers.delete(projectId);
+        }
+        const t = this.timers.get(projectId);
+        if (t) {
+            clearTimeout(t);
+            this.timers.delete(projectId);
+        }
+        this.pending.delete(projectId);
+        this.projects.delete(projectId);
+    }
+    async stopAll() {
+        for (const id of [...this.watchers.keys()])
+            this.stopWatch(id);
+    }
+    recordChange(projectId, absPath) {
+        let set = this.pending.get(projectId);
+        if (!set) {
+            set = new Set();
+            this.pending.set(projectId, set);
+        }
+        set.add(absPath);
+        // Reset / re-arm debounce. Node's setTimeout drift is fine at 60s scale.
+        const existing = this.timers.get(projectId);
+        if (existing)
+            clearTimeout(existing);
+        const t = setTimeout(() => {
+            // Async fire-and-forget; we don't block the event loop.
+            void this.flush(projectId);
+        }, this.debounceMs);
+        this.timers.set(projectId, t);
+    }
+    /** Drain pending paths for a project, build summary, ingest, persist. */
+    async flush(projectId) {
+        const project = this.projects.get(projectId);
+        const touched = this.pending.get(projectId);
+        if (!project || !touched || touched.size === 0)
+            return;
+        this.pending.delete(projectId);
+        this.timers.delete(projectId);
+        const summary = summarizeActivity({
+            projectName: project.name,
+            projectPath: project.path,
+            touched,
+        });
+        this.opts.cache.recordProjectSummary(projectId, summary);
+        try {
+            await this.opts.ingest({
+                type: "open_loop",
+                content: summary,
+                sourceType: "activity",
+                sourceId: projectId,
+                metadata: {
+                    project_name: project.name,
+                    project_path: project.path,
+                    touched_count: touched.size,
+                },
+            });
+            this.log(`project-activity[${project.name}]: ingested summary (${touched.size} paths)`);
+        }
+        catch (err) {
+            this.log(`project-activity[${project.name}]: ingest failed: ${err.message}`);
+        }
+    }
+}
+// Exposed for unit tests
+export const _internals = {
+    IGNORED_DIRS,
+    DEBOUNCE_MS,
+    isIgnoredPath,
+    readGitBranch,
+};