carto-md 2.0.9 → 2.1.1

package/src/rules/rules/money-as-float.js

@@ -0,0 +1,166 @@
+'use strict';
+
+/**
+ * money-as-float
+ *
+ * Money fields (`price`, `amount`, `total`, `balance`, `fee`, ...)
+ * should never be stored in a floating-point type. Floats lose
+ * precision at scale — a checkout total that ends in
+ * `0.30000000000000004` is the friendly version; the ugly version is
+ * an accounting ledger that doesn't balance. Use fixed-point instead:
+ * Prisma's `Decimal`, Postgres `numeric(12,2)`, or minor-units integers.
+ *
+ * This rule reads the `models` table (specifically the `fields_json`
+ * blob) and fires per bad field — one gap per (model, field) pair,
+ * not one per model. `line` is left null; the extractor doesn't
+ * currently record per-field line numbers and we don't fabricate one.
+ *
+ * The rule stays conservative so we don't burn trust:
+ *   - Only Prisma / Zod / TS-interface / Pydantic / Drizzle /
+ *     SQLAlchemy models. Generic Go/Rust structs stay silent —
+ *     `float64 Balance` in a physics sim is a legitimate use.
+ *   - Both predicates must hold: a money-shaped field name AND a
+ *     floating-point type. `amount_cents Int` never fires.
+ *   - `Decimal` and `numeric(...)` types are treated as safe.
+ *   - Names match as whole tokens, never as substrings — `sprinkler`
+ *     doesn't collide with `price`.
+ */
+
+// Money field names → matched as whole-word tokens.
+// Keep this list conservative. Adding a name here means every
+// Float/Number model field with that name will fire — false positives
+// destroy trust permanently, so err on the side of missing a case.
+const MONEY_TOKENS = new Set([
+  'price',
+  'amount',
+  'total',
+  'subtotal',
+  'balance',
+  'fee',
+  'cost',
+  'tax',
+  'discount',
+  'refund',
+  'payout',
+  'salary',
+  'wage',
+  'revenue',
+  'profit',
+  'charge',
+]);
+
+// Field kinds this rule looks at. Skipping unrestricted struct kinds
+// keeps FP rate at zero for repos that mix domain code with numeric
+// / scientific work.
+const APPLICABLE_KINDS = new Set([
+  'prisma',
+  'zod',
+  'typescript',
+  'ts-interface',
+  'pydantic',
+  'drizzle',
+  'sqlalchemy',
+]);
+
+// Floating-point-ish types across the model kinds we look at.
+// Match is case-insensitive and takes whichever cleaned type token
+// appears first in the field's declared type.
+const FLOAT_TYPES = new Set([
+  'float',
+  'double',
+  'number',
+  'real',
+  'floating',
+  // Prisma-specific:
+  'float32',
+  'float64',
+]);
+
+function tokenize(name) {
+  if (!name || typeof name !== 'string') return [];
+  // Split camelCase, snake_case, kebab-case → lowercase tokens.
+  return name
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+function looksLikeMoney(fieldName) {
+  const tokens = tokenize(fieldName);
+  for (const t of tokens) {
+    if (MONEY_TOKENS.has(t)) return t;
+  }
+  return null;
+}
+
+function cleanType(raw) {
+  if (!raw || typeof raw !== 'string') return '';
+  // Strip Prisma modifiers: `Float?`, `Float[]`, `Decimal(10, 2)`
+  // Strip TS generics/unions: `number | null`
+  const first = raw.trim().split(/[\s|<[\(]/)[0];
+  return first.replace(/[?!]$/, '').toLowerCase();
+}
+
+function isFloating(rawType) {
+  return FLOAT_TYPES.has(cleanType(rawType));
+}
+
+function parseFieldsJson(row) {
+  if (!row || !row.fields_json) return [];
+  try {
+    const arr = JSON.parse(row.fields_json);
+    return Array.isArray(arr) ? arr : [];
+  } catch {
+    return [];
+  }
+}
+
+module.exports = {
+  id: 'money-as-float',
+  severity: 'HIGH',
+  reversibility: 'moderate',
+  concept: 'money-as-float',
+  description: 'A model field whose name means money is declared as a floating-point type. Money must use fixed-point (Decimal / minor-units BigInt).',
+
+  appliesWhen(intent) {
+    return intent && intent.product_type === 'saas-with-auth';
+  },
+
+  run({ store }) {
+    if (!store) return [];
+    let rows = [];
+    try {
+      rows = store.db
+        .prepare(
+          `SELECT m.name AS model_name, m.kind AS model_kind, m.fields_json,
+                  f.path AS file
+           FROM models m JOIN files f ON m.file_id = f.id`
+        )
+        .all();
+    } catch {
+      return [];
+    }
+
+    const gaps = [];
+    for (const row of rows) {
+      const kind = (row.model_kind || '').toLowerCase();
+      if (!APPLICABLE_KINDS.has(kind)) continue;
+
+      const fields = parseFieldsJson(row);
+      for (const field of fields) {
+        if (!field || typeof field !== 'object') continue;
+        const moneyToken = looksLikeMoney(field.name);
+        if (!moneyToken) continue;
+        if (!isFloating(field.type)) continue;
+
+        gaps.push({
+          file: row.file,
+          line: null,
+          evidence: `Model ${row.model_name}.${field.name} is declared as ${field.type} — money-named field on a floating-point type. Use Decimal (or minor-units integer) to avoid precision loss.`,
+        });
+      }
+    }
+    return gaps;
+  },
+};

package/src/store/config-loader.js

@@ -39,11 +39,15 @@ function loadCartoConfig(projectRoot) {
     const key = name.toUpperCase();
     if (Array.isArray(value)) {
       // Legacy flat-array form: ["keyword1", "keyword2"]
-      domains[key] = { keywords: value.map(String), anchor: [] };
+      domains[key] = { keywords: value.map(String), anchor: [], globs: [] };
     } else if (value && typeof value === 'object') {
       domains[key] = {
         keywords: Array.isArray(value.keywords) ? value.keywords.map(String) : [],
         anchor: Array.isArray(value.anchor) ? value.anchor.map(String) : [],
+        // Declared path globs → domain. These are the PRIMARY, deterministic
+        // source of truth: any file matching a domain's globs is assigned that
+        // domain regardless of what inference would have guessed (CF-3).
+        globs: Array.isArray(value.globs) ? value.globs.map(String) : [],
       };
     }
   }
@@ -51,6 +55,75 @@ function loadCartoConfig(projectRoot) {
   return { domains };
 }
 
+/**
+ * globToRegExp(glob) → RegExp
+ *
+ * Minimal, dependency-free glob → RegExp compiler for path matching.
+ * Supports the subset needed for domain declarations:
+ *   **  → any number of path segments (including none)
+ *   *   → any run of characters except '/'
+ *   ?   → a single character except '/'
+ * Everything else is matched literally. Paths are compared with '/'
+ * separators (callers normalize backslashes first). Anchored full-match.
+ */
+function globToRegExp(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*') {
+      if (glob[i + 1] === '*') {
+        // '**' → match across segment boundaries.
+        i++;
+        if (glob[i + 1] === '/') { i++; re += '(?:.*/)?'; }
+        else re += '.*';
+      } else {
+        re += '[^/]*';
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+    } else if ('.+^${}()|[]\\'.includes(c)) {
+      re += '\\' + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp('^' + re + '$');
+}
+
+/**
+ * applyDeclaredGlobs(fileAssignments, config, confidenceByFile?) → fileAssignments
+ *
+ * Repo-declared globs are the PRIMARY source: any file whose path matches a
+ * domain's declared globs is force-assigned to that domain (confidence 1.0),
+ * overriding whatever inference produced. When a file matches globs from more
+ * than one domain, the first matching domain in declaration order wins (config
+ * authors control precedence by ordering). Mutates and returns fileAssignments.
+ */
+function applyDeclaredGlobs(fileAssignments, config, confidenceByFile = null) {
+  if (!config || !config.domains) return fileAssignments;
+
+  // Precompile globs per domain, preserving declaration order.
+  const compiled = [];
+  for (const [domainName, domainConfig] of Object.entries(config.domains)) {
+    const globs = (domainConfig.globs || []).map(globToRegExp);
+    if (globs.length > 0) compiled.push([domainName, globs]);
+  }
+  if (compiled.length === 0) return fileAssignments;
+
+  for (const fp of fileAssignments.keys()) {
+    const normalized = fp.replace(/\\/g, '/');
+    for (const [domainName, globs] of compiled) {
+      if (globs.some(re => re.test(normalized))) {
+        fileAssignments.set(fp, domainName);
+        if (confidenceByFile instanceof Map) confidenceByFile.set(fp, 1.0);
+        break;
+      }
+    }
+  }
+
+  return fileAssignments;
+}
+
 /**
  * applyAnchors(fileAssignments, config) → fileAssignments (mutated)
  *
@@ -58,7 +131,7 @@ function loadCartoConfig(projectRoot) {
  * Then propagates via 2-pass graph expansion from the existing
  * buildFileAssignments logic in domains.js.
  */
-function applyAnchors(fileAssignments, config) {
+function applyAnchors(fileAssignments, config, confidenceByFile = null) {
   if (!config || !config.domains) return fileAssignments;
 
   for (const [domainName, domainConfig] of Object.entries(config.domains)) {
@@ -67,6 +140,7 @@ function applyAnchors(fileAssignments, config) {
       const normalized = anchorPath.replace(/\\/g, '/');
       if (fileAssignments.has(normalized)) {
         fileAssignments.set(normalized, domainName);
+        if (confidenceByFile instanceof Map) confidenceByFile.set(normalized, 1.0);
       }
     }
   }
@@ -74,4 +148,4 @@ function applyAnchors(fileAssignments, config) {
   return fileAssignments;
 }
 
-module.exports = { loadCartoConfig, applyAnchors };
+module.exports = { loadCartoConfig, applyAnchors, applyDeclaredGlobs, globToRegExp };

package/src/store/sqlite-store.js

@@ -4,11 +4,15 @@ const Database = require('better-sqlite3');
 const path = require('path');
 const fs = require('fs');
 
-// Schema version 3 — adds the Episodic Memory tables
-// (ai_sessions, decisions, interventions). The full _ensureSchema() body
-// is idempotent (CREATE TABLE IF NOT EXISTS), so existing v1/v2 DBs
-// cleanly pick up the new tables on next open.
-const SCHEMA_VERSION = '3';
+// Schema version 4 — adds the `gaps` table (derived view of what
+// the rule engine currently finds). Prior versions:
+//   1 — initial schema
+//   2 — reverse_deps + centrality
+//   3 — episodic memory (ai_sessions, decisions, interventions)
+//   4 — gaps table for the rule engine
+// _ensureSchema() is idempotent (CREATE TABLE IF NOT EXISTS on every
+// table), so older DBs cleanly pick up the new tables on next open.
+const SCHEMA_VERSION = '4';
 
 /**
  * normalizePath(p) — Canonicalize a relative path for storage and query.
@@ -319,6 +323,39 @@ class SQLiteStore {
       CREATE INDEX IF NOT EXISTS idx_interventions_session ON interventions(session_id);
     `);
 
+    // ─── Rule Engine gaps ───────────────────────────────────────────
+    // A gap is a claim, grounded in a Carto fact, that the code
+    // violates a rule ("SHOULD − IS"). The `gaps` table is derived
+    // state — it's completely replaced on every rule-engine run
+    // (`replaceGaps()`). Persistence lets get_gaps be a cheap query
+    // instead of re-running the engine on every MCP call.
+    //
+    //   gap_hash    — sha1(rule_id + file + line). Stable across
+    //                 runs; used to dedup against dismissals.
+    //   dismissed   — 1 if the user marked this gap intentional
+    //                 (via dismiss_gap). Preserved across gap
+    //                 replacements — see replaceGaps() logic.
+    //   reason      — user's dismissal reason, free text.
+    this._db.exec(`
+      CREATE TABLE IF NOT EXISTS gaps (
+        id INTEGER PRIMARY KEY,
+        gap_hash TEXT UNIQUE NOT NULL,
+        rule_id TEXT NOT NULL,
+        file TEXT,
+        line INTEGER,
+        severity TEXT NOT NULL,
+        reversibility TEXT,
+        concept TEXT,
+        evidence TEXT,
+        detected_at INTEGER NOT NULL,
+        dismissed INTEGER DEFAULT 0,
+        reason TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_gaps_rule ON gaps(rule_id);
+      CREATE INDEX IF NOT EXISTS idx_gaps_file ON gaps(file);
+      CREATE INDEX IF NOT EXISTS idx_gaps_dismissed ON gaps(dismissed);
+    `);
+
     this.setMeta('schema_version', SCHEMA_VERSION);
   }
 
@@ -423,7 +460,13 @@ class SQLiteStore {
         for (const imp of data.imports) {
           const toFileId = imp.resolvedFileId || null;
           const resolved = toFileId ? 1 : 0;
-          ins.run(fileId, toFileId, imp.path, imp.symbol || null, resolved);
+          // Normalize to_path to POSIX at the write boundary. Import
+          // resolvers use path.relative() which yields native separators
+          // (backslashes on Windows); files.path is always POSIX. Without
+          // this, resolveUnresolvedImports() (WHERE path = to_path) never
+          // matches on Windows → imports stay unresolved → blast radius
+          // reports zero dependents. Same code, same results, all OSes.
+          ins.run(fileId, toFileId, normalizePath(imp.path), imp.symbol || null, resolved);
         }
       }
 
@@ -456,7 +499,11 @@ class SQLiteStore {
           'INSERT INTO models (file_id, name, kind, fields_json) VALUES (?,?,?,?)'
         );
         for (const m of data.models) {
-          const name = m.name || m.model || (typeof m === 'string' ? m : null);
+          // Extractors are inconsistent: prisma/zod/interface/etc. emit
+          // `className`, drizzle emits both `name` and `className`,
+          // pydantic emits `className`. Fall through the whole chain so
+          // no extractor's models silently vanish.
+          const name = m.name || m.className || m.model || (typeof m === 'string' ? m : null);
           if (!name) continue; // skip models without a name
           const fields = m.fields ? JSON.stringify(m.fields) : null;
           ins.run(fileId, name, m.kind || m.type || 'unknown', fields);
@@ -830,15 +877,26 @@ class SQLiteStore {
   }
 
   assignFileToDomain(fileId, domainId, confidence = 1.0) {
+    // domain_assignments is the single source of truth. files.domain_id is a
+    // denormalized mirror written here in the same call so that every reader —
+    // whether it queries domain_assignments (getDomainForFile, getCrossDomainDeps,
+    // the bitmap sidecar) or JOINs on files.domain_id (brain/predictive/retrieval
+    // SQL) — always sees the same domain for a file. The two can never drift
+    // because they are written together and cleared together (see
+    // clearDomainAssignments). This is the CF-3 single-source-of-truth fix.
     this._db.prepare(`
       INSERT OR REPLACE INTO domain_assignments (file_id, domain_id, confidence)
       VALUES (?, ?, ?)
     `).run(fileId, domainId, confidence);
+    this._db.prepare('UPDATE files SET domain_id = ? WHERE id = ?').run(domainId, fileId);
   }
 
   clearDomainAssignments() {
     this._db.prepare('DELETE FROM domain_assignments').run();
     this._db.prepare('DELETE FROM domains').run();
+    // Reset the denormalized mirror so files that lose an assignment on the
+    // next full re-cluster don't retain a stale domain_id.
+    this._db.prepare('UPDATE files SET domain_id = NULL').run();
   }
 
   _getDomainForFileId(fileId) {
@@ -857,6 +915,23 @@ class SQLiteStore {
     return this._getDomainForFileId(file.id);
   }
 
+  /**
+   * getDomainOf(fileIdOrPath) → domain name (string) or null
+   *
+   * The single canonical accessor every tool should use to answer
+   * "what domain is this file in?". Accepts either a numeric file id or a
+   * relative path, and always resolves against domain_assignments (the source
+   * of truth) so no two tools can disagree. Returns null when the file is
+   * unknown or unassigned; callers decide whether to display 'CORE'.
+   */
+  getDomainOf(fileIdOrPath) {
+    if (fileIdOrPath == null) return null;
+    if (typeof fileIdOrPath === 'number') {
+      return this._getDomainForFileId(fileIdOrPath);
+    }
+    return this.getDomainForFile(String(fileIdOrPath));
+  }
+
   // ─── Reverse deps (blast radius) ──────────────────────────────────────
 
   /**
@@ -1145,6 +1220,172 @@ class SQLiteStore {
     ).all();
   }
 
+  // ─── Rule Engine gaps ─────────────────────────────────────────────────
+
+  /**
+   * replaceGaps(newGaps) → { inserted, preserved, removed }
+   *
+   * The rule engine calls this once per run. Semantics:
+   *   - Rows for gaps present in `newGaps` are refreshed (detected_at
+   *     bumped). If the same gap_hash was previously dismissed, the
+   *     `dismissed` + `reason` fields carry over — dismissals persist
+   *     across runs.
+   *   - Rows whose gap_hash is NOT in `newGaps` are deleted. Gaps
+   *     that no longer fire disappear from the table.
+   *
+   * `newGaps` is an array of `{ gap_hash, rule_id, file, line,
+   * severity, reversibility, concept, evidence }`.
+   *
+   * Runs in a single transaction. Requires a writable connection.
+   */
+  replaceGaps(newGaps) {
+    if (!Array.isArray(newGaps)) return { inserted: 0, preserved: 0, removed: 0 };
+    const now = Date.now();
+    let inserted = 0;
+    let preserved = 0;
+    let removed = 0;
+
+    const tx = this._db.transaction(() => {
+      // 1. Snapshot existing dismissals so they survive the rewrite.
+      const priorDismissals = new Map();
+      const priorRows = this._db.prepare(
+        'SELECT gap_hash, dismissed, reason FROM gaps WHERE dismissed = 1'
+      ).all();
+      for (const r of priorRows) priorDismissals.set(r.gap_hash, { dismissed: r.dismissed, reason: r.reason });
+
+      // 2. Collect surviving hashes.
+      const surviving = new Set(newGaps.map((g) => g.gap_hash));
+
+      // 3. Delete rows no longer emitted by the engine.
+      const existing = this._db.prepare('SELECT gap_hash FROM gaps').all();
+      const del = this._db.prepare('DELETE FROM gaps WHERE gap_hash = ?');
+      for (const r of existing) {
+        if (!surviving.has(r.gap_hash)) {
+          del.run(r.gap_hash);
+          removed++;
+        }
+      }
+
+      // 4. Upsert the new set. Preserve dismissed/reason when the row
+      //    was already dismissed.
+      const upsert = this._db.prepare(`
+        INSERT INTO gaps (gap_hash, rule_id, file, line, severity, reversibility, concept, evidence, detected_at, dismissed, reason)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(gap_hash) DO UPDATE SET
+          rule_id = excluded.rule_id,
+          file = excluded.file,
+          line = excluded.line,
+          severity = excluded.severity,
+          reversibility = excluded.reversibility,
+          concept = excluded.concept,
+          evidence = excluded.evidence,
+          detected_at = excluded.detected_at
+      `);
+      for (const g of newGaps) {
+        const wasDismissed = priorDismissals.get(g.gap_hash);
+        const dismissed = wasDismissed ? 1 : 0;
+        const reason = wasDismissed ? wasDismissed.reason : null;
+        const info = upsert.run(
+          g.gap_hash,
+          g.rule_id,
+          g.file ? normalizePath(g.file) : null,
+          g.line != null ? g.line : null,
+          g.severity,
+          g.reversibility || null,
+          g.concept || null,
+          g.evidence || null,
+          now,
+          dismissed,
+          reason
+        );
+        if (info.changes === 1 && info.lastInsertRowid) {
+          if (wasDismissed) preserved++;
+          else inserted++;
+        }
+      }
+    });
+    tx();
+    return { inserted, preserved, removed };
+  }
+
+  /**
+   * getGaps({ includeDismissed = false, rule_id, file, severity }?) → [row, ...]
+   *
+   * Read-only. Returns the current gap set, filtered by the given
+   * predicates. Dismissed gaps are excluded by default — `get_gaps`
+   * surfaces "what still fires and hasn't been intentionally accepted."
+   * Ranked by severity (HIGH > MEDIUM > LOW) then by detected_at DESC.
+   */
+  getGaps(opts = {}) {
+    const where = [];
+    const params = [];
+    if (!opts.includeDismissed) where.push('dismissed = 0');
+    if (opts.rule_id) { where.push('rule_id = ?'); params.push(String(opts.rule_id)); }
+    if (opts.file) { where.push('file = ?'); params.push(normalizePath(opts.file)); }
+    if (opts.severity) { where.push('severity = ?'); params.push(String(opts.severity)); }
+    const clause = where.length > 0 ? 'WHERE ' + where.join(' AND ') : '';
+    return this._db.prepare(`
+      SELECT id, gap_hash, rule_id, file, line, severity, reversibility, concept, evidence, detected_at, dismissed, reason
+      FROM gaps
+      ${clause}
+      ORDER BY
+        CASE severity WHEN 'HIGH' THEN 0 WHEN 'MEDIUM' THEN 1 WHEN 'LOW' THEN 2 ELSE 3 END,
+        detected_at DESC,
+        id DESC
+    `).all(...params);
+  }
+
+  /**
+   * getGapByHash(gap_hash) → row | null
+   */
+  getGapByHash(gap_hash) {
+    if (!gap_hash) return null;
+    return this._db.prepare(
+      'SELECT id, gap_hash, rule_id, file, line, severity, reversibility, concept, evidence, detected_at, dismissed, reason FROM gaps WHERE gap_hash = ?'
+    ).get(String(gap_hash)) || null;
+  }
+
+  /**
+   * dismissGap(gap_hash, reason) → { dismissed: boolean, gap: row | null }
+   *
+   * Marks a gap as intentionally accepted by the user. Idempotent —
+   * re-dismissing the same gap updates the reason and stamps a new
+   * timestamp but doesn't create a second row. Requires a writable
+   * connection. Returns { dismissed: false, gap: null } if the hash
+   * doesn't correspond to a known gap (fresh hashes only enter the
+   * table via replaceGaps).
+   */
+  dismissGap(gap_hash, reason) {
+    if (!gap_hash) return { dismissed: false, gap: null };
+    const gap = this.getGapByHash(gap_hash);
+    if (!gap) return { dismissed: false, gap: null };
+    this._db.prepare(
+      'UPDATE gaps SET dismissed = 1, reason = ? WHERE gap_hash = ?'
+    ).run(reason ? String(reason).slice(0, 2000) : null, String(gap_hash));
+    return { dismissed: true, gap: this.getGapByHash(gap_hash) };
+  }
+
+  /**
+   * countGaps({ includeDismissed = false }?) → { total, bySeverity, byRule }
+   */
+  countGaps(opts = {}) {
+    const clause = opts.includeDismissed ? '' : 'WHERE dismissed = 0';
+    const total = this._db.prepare(`SELECT COUNT(*) as n FROM gaps ${clause}`).get().n;
+    const bySeverity = {};
+    for (const r of this._db.prepare(
+      `SELECT severity, COUNT(*) as n FROM gaps ${clause} GROUP BY severity`
+    ).all()) {
+      bySeverity[r.severity] = r.n;
+    }
+    const byRule = {};
+    for (const r of this._db.prepare(
+      `SELECT rule_id, COUNT(*) as n FROM gaps ${clause} GROUP BY rule_id`
+    ).all()) {
+      byRule[r.rule_id] = r.n;
+    }
+    return { total, bySeverity, byRule };
+  }
+
   // ─── Lifecycle ─────────────────────────────────────────────────────────
 
   close() {

package/src/store/store-adapter.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { SQLiteStore } = require('./sqlite-store');
-const { runSyncV2 } = require('./sync-v2');
+const { runSync } = require('./sync');
 
 /**
  * StoreAdapter — V1-compatible API wrapping SQLiteStore.
@@ -18,7 +18,7 @@ class StoreAdapter {
 
   /**
    * index(projectRoot, opts?)
-   * Opens the SQLite DB; runs runSyncV2 if DB is missing.
+   * Opens the SQLite DB; runs runSync if DB is missing.
    * opts.force — re-extract all files
    * opts.writeOutputs — if false, skip AGENTS.md + context file generation (default: false)
    */
@@ -28,7 +28,7 @@ class StoreAdapter {
     const dbExists = fs.existsSync(dbPath);
 
     if (!dbExists || opts.force) {
-      await runSyncV2({
+      await runSync({
         projectRoot,
         output: opts.writeOutputs ? path.resolve(projectRoot, 'AGENTS.md') : null,
       });