@vibecheck-ai/mcp 24.6.4 → 24.6.6

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire } from 'module';
 import { fileURLToPath, pathToFileURL } from 'url';
 import * as path2 from 'path';
 import path2__default, { dirname, join, extname, resolve, normalize } from 'path';
-import { SCAN_ENGINE_FOCUS_PRESET_NAMES, FEATURE_NAMES, DAILY_SCAN_LIMIT_UPGRADE_URL, formatDailyScanLimitMessage, dashboardFindingUrl, gateCanonicalScanReportFindings, getTrustScoreStatus, formatTrustScoreMcp, buildGatedScanResponse, formatFindingSeverityBreakdown, ENGINE_FOCUS_PRESETS, computeTrustScore, normalizeCanonicalScanReport, planHasApiSurface, canAccessFeature, getMinPlanForApiSurface, buildCliUpgradeBlock, getMinimumPlanForFeature, getQuotas, normalizePlanId, fetchCanonicalAccess } from './chunk-JIMU4YXW.js';
+import { SCAN_ENGINE_FOCUS_PRESET_NAMES, FEATURE_NAMES, DAILY_SCAN_LIMIT_UPGRADE_URL, formatDailyScanLimitMessage, dashboardFindingUrl, gateCanonicalScanReportFindings, getTrustScoreStatus, formatTrustScoreMcp, buildGatedScanResponse, formatFindingSeverityBreakdown, ENGINE_FOCUS_PRESETS, computeTrustScore, normalizeCanonicalScanReport, planHasApiSurface, canAccessFeature, getMinPlanForApiSurface, buildCliUpgradeBlock, getMinimumPlanForFeature, getQuotas, normalizePlanId, fetchCanonicalAccess } from './chunk-XQUM7V7W.js';
 import './chunk-MUP4JXOF.js';
 import './chunk-DDTUTWRY.js';
 import { require_typescript } from './chunk-QFDZMUGO.js';
@@ -14,7 +14,7 @@ import './chunk-G3FQJC2H.js';
 import './chunk-NR36RTVO.js';
 import './chunk-JZSHXEYP.js';
 import './chunk-QYXENOVK.js';
-import './chunk-HSG3IFNQ.js';
+import './chunk-LQSBUKYZ.js';
 import './chunk-5DADZJ3D.js';
 import './chunk-43XAAYST.js';
 import './chunk-F34MHA6A.js';
@@ -18048,1850 +18048,1850 @@ rules:
     target:
       match: "src/repositories/**"
 `;
-
-// ../context-engine/dist/chunk-HMKLYBWJ.js
-var import_better_sqlite3 = __toESM(require_lib(), 1);
-var import_fast_glob2 = __toESM(require_out4(), 1);
-var SCHEMA_VERSION = 1;
-var PersistentIndex = class {
-  db;
-  config;
+var ContextSynthesizer = class {
   rootPath;
-  constructor(config) {
-    this.rootPath = config.rootPath;
-    this.config = {
-      rootPath: config.rootPath,
-      dbPath: config.dbPath ?? join(config.rootPath, ".vibecheck", "index.db"),
-      includePatterns: config.includePatterns ?? ["**/*.{ts,tsx,js,jsx,py,rs,go,java,c,cpp,h,hpp,rb,swift,kt,lua,zig}"],
-      excludePatterns: config.excludePatterns ?? [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.next/**",
-        "**/.git/**",
-        "**/coverage/**",
-        "**/.turbo/**",
-        "**/__pycache__/**",
-        "**/target/**",
-        "**/.mcp_data/**"
-      ],
-      maxFileSize: config.maxFileSize ?? 5e5,
-      maxFiles: config.maxFiles ?? 1e4,
-      storeContent: config.storeContent ?? true
-    };
-    const dbDir = join(this.config.dbPath, "..");
-    mkdirSync(dbDir, { recursive: true });
-    this.db = new import_better_sqlite3.default(this.config.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("synchronous = NORMAL");
-    this.db.pragma("cache_size = -64000");
-    this.initSchema();
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SCHEMA
-  // ═══════════════════════════════════════════════════════════════════════════
-  initSchema() {
-    const version = this.getSchemaVersion();
-    if (version === SCHEMA_VERSION) return;
-    this.db.exec(`
-      DROP TABLE IF EXISTS file_hashes;
-      DROP TABLE IF EXISTS files;
-      DROP TABLE IF EXISTS symbols;
-      DROP TABLE IF EXISTS imports;
-      DROP TABLE IF EXISTS call_edges;
-      DROP TABLE IF EXISTS routes;
-      DROP TABLE IF EXISTS services;
-      DROP TABLE IF EXISTS embeddings;
-      DROP TABLE IF EXISTS meta;
-
-      CREATE TABLE meta (
-        key   TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-
-      CREATE TABLE file_hashes (
-        relative_path TEXT PRIMARY KEY,
-        content_hash  TEXT NOT NULL,
-        size_bytes    INTEGER NOT NULL,
-        modified_ms   INTEGER NOT NULL,
-        indexed_at    INTEGER NOT NULL DEFAULT (unixepoch('now'))
-      );
-
-      CREATE TABLE files (
-        id            TEXT PRIMARY KEY,
-        path          TEXT NOT NULL,
-        relative_path TEXT NOT NULL UNIQUE,
-        language      TEXT NOT NULL,
-        line_count    INTEGER NOT NULL,
-        exports       TEXT NOT NULL DEFAULT '[]',
-        content       TEXT
-      );
-
-      CREATE TABLE symbols (
-        id         TEXT PRIMARY KEY,
-        name       TEXT NOT NULL,
-        kind       TEXT NOT NULL,
-        file_path  TEXT NOT NULL,
-        start_line INTEGER NOT NULL,
-        end_line   INTEGER NOT NULL,
-        exported   INTEGER NOT NULL DEFAULT 0,
-        async      INTEGER NOT NULL DEFAULT 0,
-        params     INTEGER,
-        branches   INTEGER,
-        signature  TEXT
-      );
-
-      CREATE TABLE imports (
-        id               INTEGER PRIMARY KEY AUTOINCREMENT,
-        file_id          TEXT NOT NULL,
-        file_path        TEXT NOT NULL,
-        source_path      TEXT NOT NULL,
-        resolved_path    TEXT NOT NULL DEFAULT '',
-        imported_symbols TEXT NOT NULL DEFAULT '[]',
-        is_type_only     INTEGER NOT NULL DEFAULT 0,
-        is_dynamic       INTEGER NOT NULL DEFAULT 0,
-        line             INTEGER NOT NULL DEFAULT 0
-      );
-
-      CREATE TABLE call_edges (
-        id          INTEGER PRIMARY KEY AUTOINCREMENT,
-        caller_id   TEXT NOT NULL,
-        callee_id   TEXT NOT NULL,
-        caller_name TEXT NOT NULL,
-        callee_name TEXT NOT NULL,
-        caller_file TEXT NOT NULL,
-        callee_file TEXT NOT NULL
-      );
-
-      CREATE TABLE routes (
-        id         INTEGER PRIMARY KEY AUTOINCREMENT,
-        path       TEXT NOT NULL,
-        method     TEXT NOT NULL,
-        handler    TEXT NOT NULL,
-        file       TEXT NOT NULL,
-        line       INTEGER NOT NULL DEFAULT 0,
-        middleware TEXT NOT NULL DEFAULT '[]',
-        auth       INTEGER
-      );
-
-      CREATE TABLE services (
-        id        TEXT PRIMARY KEY,
-        name      TEXT NOT NULL,
-        root_path TEXT NOT NULL DEFAULT ''
-      );
-
-      CREATE TABLE embeddings (
-        path         TEXT NOT NULL,
-        chunk_id     TEXT NOT NULL,
-        chunk_type   TEXT NOT NULL DEFAULT 'file',
-        content_hash TEXT NOT NULL,
-        vector       BLOB NOT NULL,
-        metadata     TEXT NOT NULL DEFAULT '{}',
-        PRIMARY KEY (path, chunk_id)
-      );
-
-      -- Indexes for fast lookups
-      CREATE INDEX idx_symbols_file ON symbols(file_path);
-      CREATE INDEX idx_symbols_name ON symbols(name);
-      CREATE INDEX idx_symbols_kind ON symbols(kind);
-      CREATE INDEX idx_imports_file ON imports(file_path);
-      CREATE INDEX idx_imports_source ON imports(source_path);
-      CREATE INDEX idx_imports_resolved ON imports(resolved_path);
-      CREATE INDEX idx_call_edges_caller ON call_edges(caller_file);
-      CREATE INDEX idx_call_edges_callee ON call_edges(callee_file);
-      CREATE INDEX idx_embeddings_type ON embeddings(chunk_type);
-    `);
-    this.setMeta("schema_version", String(SCHEMA_VERSION));
-    this.setMeta("created_at", (/* @__PURE__ */ new Date()).toISOString());
-  }
-  getSchemaVersion() {
-    try {
-      const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get("schema_version");
-      return row ? Number.parseInt(row.value, 10) : 0;
-    } catch {
-      return 0;
-    }
-  }
-  setMeta(key, value) {
-    this.db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
+  data;
+  dna;
+  graph;
+  ruleResult;
+  constructor(rootPath, data, dna, graph, ruleResult) {
+    this.rootPath = rootPath;
+    this.data = data;
+    this.dna = dna;
+    this.graph = graph;
+    this.ruleResult = ruleResult || null;
   }
-  getMeta(key) {
-    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
-    return row?.value ?? null;
+  /**
+   * Synthesize the full context — the complete brain dump for AI agents.
+   */
+  synthesize() {
+    const projectIdentity = this.buildProjectIdentity();
+    const archRules = this.buildArchRuleSummary();
+    const activeViolations = this.ruleResult?.violations || [];
+    const codebaseDNA = this.buildDNASummary();
+    const fileContexts = this.buildFileContexts();
+    const taskPlaybooks = this.buildTaskPlaybooks();
+    const verificationSteps = this.buildVerificationSteps();
+    const riskBriefing = this.buildRiskBriefing();
+    return {
+      version: "2.0.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectIdentity,
+      architecturalRules: archRules,
+      activeViolations,
+      codebaseDNA,
+      fileContexts,
+      taskPlaybooks,
+      verificationSteps,
+      riskBriefing
+    };
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // INCREMENTAL INDEXING
-  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * Discover files, diff against stored hashes, return only changed files.
+   * Generate context for a specific file — what an AI agent needs to know
+   * before editing this file.
    */
-  async diffFiles() {
-    const discoveredFiles = await this.discoverFiles();
-    const storedHashes = this.getStoredHashes();
-    const changed = [];
-    const unchanged = [];
-    const currentPaths = /* @__PURE__ */ new Set();
-    for (const file of discoveredFiles) {
-      currentPaths.add(file.relativePath);
-      const stored = storedHashes.get(file.relativePath);
-      if (!stored || stored.contentHash !== file.contentHash) {
-        changed.push(file.relativePath);
-      } else {
-        unchanged.push(file.relativePath);
-      }
-    }
-    const deleted = [];
-    for (const storedPath of storedHashes.keys()) {
-      if (!currentPaths.has(storedPath)) {
-        deleted.push(storedPath);
-      }
-    }
-    return { changed, deleted, unchanged };
+  synthesizeForFile(filePath) {
+    const rel = this.toRelative(filePath);
+    const file = this.data.files.find((f) => f.relativePath === rel || f.path === filePath);
+    if (!file) return null;
+    return this.buildSingleFileContext(file);
   }
   /**
-   * Full reindex — scan all files and store data.
-   * Returns parsed CodebaseData + stats.
+   * Generate a compact markdown context document for IDE rules.
+   * This replaces the old static rule generation with intelligence-driven context.
    */
-  async reindex(parser4) {
-    const startMs = Date.now();
-    const { changed, deleted, unchanged } = await this.diffFiles();
-    if (deleted.length > 0) {
-      this.removeFiles(deleted);
+  generateContextDocument() {
+    const ctx = this.synthesize();
+    const lines = [];
+    lines.push(`# ${ctx.projectIdentity.name} \u2014 AI Context`);
+    lines.push(`<!-- Generated by @repo/context-engine at ${ctx.generatedAt} -->`);
+    lines.push("");
+    lines.push("## Project Identity");
+    lines.push(`- **Stack**: ${ctx.projectIdentity.stack}`);
+    lines.push(`- **Architecture**: ${ctx.projectIdentity.architecture}`);
+    if (ctx.projectIdentity.keyPatterns.length > 0) {
+      lines.push(`- **Key Patterns**: ${ctx.projectIdentity.keyPatterns.join(", ")}`);
     }
-    const parsedFiles = [];
-    for (const relPath of changed) {
-      const absPath = join(this.rootPath, relPath);
-      try {
-        const parsed = await parser4.parseFile(absPath, relPath);
-        parsedFiles.push(parsed);
-      } catch {
+    lines.push("");
+    if (ctx.codebaseDNA.conventions.length > 0) {
+      lines.push("## Conventions (Auto-Discovered)");
+      for (const conv of ctx.codebaseDNA.conventions) {
+        lines.push(`- ${conv}`);
       }
+      lines.push("");
     }
-    this.storeFiles(parsedFiles);
-    const data = this.loadCodebaseData();
-    const stats = {
-      totalFiles: data.files.length,
-      totalSymbols: data.symbols.length,
-      totalImports: data.imports.length,
-      indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      reindexedFiles: changed.length,
-      skippedFiles: unchanged.length,
-      durationMs: Date.now() - startMs
-    };
-    this.setMeta("last_index_at", stats.indexedAt);
-    this.setMeta("last_index_stats", JSON.stringify(stats));
-    return { data, stats };
-  }
-  /**
-   * Incremental update — only reindex specific files.
-   */
-  async reindexFiles(relativePaths, parser4) {
-    const startMs = Date.now();
-    this.removeFiles(relativePaths);
-    const parsedFiles = [];
-    for (const relPath of relativePaths) {
-      const absPath = join(this.rootPath, relPath);
-      try {
-        const parsed = await parser4.parseFile(absPath, relPath);
-        parsedFiles.push(parsed);
-      } catch {
+    if (ctx.architecturalRules.length > 0) {
+      lines.push("## Architecture Rules");
+      for (const rule of ctx.architecturalRules) {
+        const icon = rule.severity === "error" ? "MUST" : rule.severity === "warning" ? "SHOULD" : "MAY";
+        lines.push(`- **[${icon}]** ${rule.name}: ${rule.description}`);
+        if (rule.violationCount > 0) {
+          lines.push(`  - ${rule.violationCount} active violations`);
+        }
       }
+      lines.push("");
     }
-    this.storeFiles(parsedFiles);
-    const totalFiles = this.db.prepare("SELECT COUNT(*) as cnt FROM files").get();
-    const totalSymbols = this.db.prepare("SELECT COUNT(*) as cnt FROM symbols").get();
-    const totalImports = this.db.prepare("SELECT COUNT(*) as cnt FROM imports").get();
-    return {
-      totalFiles: totalFiles.cnt,
-      totalSymbols: totalSymbols.cnt,
-      totalImports: totalImports.cnt,
-      indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      reindexedFiles: parsedFiles.length,
-      skippedFiles: 0,
-      durationMs: Date.now() - startMs
-    };
+    if (ctx.codebaseDNA.boundaries.length > 0) {
+      lines.push("## Module Boundaries");
+      for (const boundary of ctx.codebaseDNA.boundaries) {
+        lines.push(`- ${boundary}`);
+      }
+      lines.push("");
+    }
+    if (ctx.codebaseDNA.hotFiles.length > 0) {
+      lines.push("## High-Impact Files (Edit With Care)");
+      for (const file of ctx.codebaseDNA.hotFiles.slice(0, 10)) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+    if (ctx.riskBriefing.securityConcerns.length > 0 || ctx.riskBriefing.testGaps.length > 0) {
+      lines.push("## Risk Areas");
+      for (const concern of ctx.riskBriefing.securityConcerns) {
+        lines.push(`- ${concern}`);
+      }
+      for (const gap of ctx.riskBriefing.testGaps.slice(0, 5)) {
+        lines.push(`- ${gap}`);
+      }
+      lines.push("");
+    }
+    if (ctx.projectIdentity.noGoZones.length > 0) {
+      lines.push("## No-Go Zones");
+      for (const zone of ctx.projectIdentity.noGoZones) {
+        lines.push(`- ${zone}`);
+      }
+      lines.push("");
+    }
+    if (ctx.taskPlaybooks.length > 0) {
+      lines.push("## Task Playbooks");
+      for (const playbook of ctx.taskPlaybooks) {
+        lines.push(`### ${playbook.taskType}`);
+        for (const step of playbook.steps) {
+          lines.push(`1. ${step}`);
+        }
+        if (playbook.mustVerify.length > 0) {
+          lines.push(`**Verify**: ${playbook.mustVerify.join(", ")}`);
+        }
+        lines.push("");
+      }
+    }
+    if (ctx.verificationSteps.length > 0) {
+      lines.push("## Verification Protocol");
+      for (const step of ctx.verificationSteps) {
+        lines.push(`### On ${step.trigger}`);
+        for (const check of step.checks) {
+          lines.push(`- ${check}`);
+        }
+        if (step.commands.length > 0) {
+          lines.push(`**Run**: \`${step.commands.join(" && ")}\``);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("## Codebase Health");
+    lines.push(`- **Overall**: ${this.dna.healthScore.overall}/100`);
+    const dims = this.dna.healthScore.dimensions;
+    lines.push(`- Architecture: ${dims.architecture} | Tests: ${dims.testCoverage} | Conventions: ${dims.conventions} | Dependencies: ${dims.dependencies}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("<!-- context-engine:v2 -->");
+    return lines.join("\n");
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // DATA LOADING (warm start)
+  // IDENTITY
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Load full CodebaseData from the persistent store.
-   * This is the warm-start path — sub-second for indexed repos.
-   */
-  loadCodebaseData() {
-    const files = this.loadFiles();
-    const symbols = this.loadSymbols();
-    const imports = this.loadImports();
-    const callEdges = this.loadCallEdges();
-    const routes = this.loadRoutes();
-    const services = this.loadServices();
-    return { files, symbols, imports, callEdges, routes, services };
-  }
-  /**
-   * Check if the index exists and has data.
-   */
-  isPopulated() {
-    try {
-      const row = this.db.prepare("SELECT COUNT(*) as cnt FROM files").get();
-      return row.cnt > 0;
-    } catch {
-      return false;
+  buildProjectIdentity() {
+    const fp = this.dna.fingerprint;
+    const stack = [fp.framework, fp.language, fp.orm, fp.validator, fp.authLib, fp.router].filter(Boolean).join(" | ");
+    const keyPatterns = this.dna.patterns.map((p) => p.name);
+    const criticalPaths = this.dna.hotspots.slice(0, 5).map((h) => h.file);
+    const noGoZones = [];
+    if (this.ruleResult) {
+      const errorRules = this.ruleResult.violations.filter((v) => v.severity === "error");
+      const uniqueMessages = [...new Set(errorRules.map((v) => v.message))];
+      noGoZones.push(...uniqueMessages.slice(0, 5));
     }
-  }
-  /**
-   * Get the last index timestamp.
-   */
-  getLastIndexedAt() {
-    return this.getMeta("last_index_at");
-  }
-  /**
-   * Get the last index stats.
-   */
-  getLastIndexStats() {
-    const raw = this.getMeta("last_index_stats");
-    if (!raw) return null;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return null;
+    for (const cycle of this.graph.cycles) {
+      noGoZones.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}...`);
     }
+    const architecture = this.dna.conventions.filter((c) => c.area === "structure").map((c) => c.description).join("; ") || fp.framework;
+    return {
+      name: fp.name,
+      stack,
+      architecture,
+      keyPatterns,
+      criticalPaths,
+      noGoZones: noGoZones.slice(0, 10)
+    };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // EMBEDDING STORAGE
+  // RULES SUMMARY
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Store a chunk embedding (file-level, function-level, etc.)
-   */
-  storeEmbedding(path10, chunkId, chunkType, contentHash, vector, metadata) {
-    const vectorBuf = Buffer.from(new Float32Array(vector).buffer);
-    this.db.prepare(`
-      INSERT OR REPLACE INTO embeddings (path, chunk_id, chunk_type, content_hash, vector, metadata)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(path10, chunkId, chunkType, contentHash, vectorBuf, JSON.stringify(metadata ?? {}));
+  buildArchRuleSummary() {
+    if (!this.ruleResult) return [];
+    const breakdown = this.ruleResult.ruleBreakdown;
+    return Object.entries(breakdown).map(([ruleId, count]) => {
+      const violation = this.ruleResult.violations.find((v) => v.ruleId === ruleId);
+      return {
+        id: ruleId,
+        name: violation?.ruleName || ruleId,
+        type: "import_forbidden",
+        severity: violation?.severity || "warning",
+        scope: violation?.sourceSymbol.filePath || "",
+        description: violation?.message || "",
+        violationCount: count
+      };
+    });
   }
-  /**
-   * Load embedding for a specific chunk.
-   */
-  loadEmbedding(path10, chunkId) {
-    const row = this.db.prepare("SELECT vector, content_hash, metadata FROM embeddings WHERE path = ? AND chunk_id = ?").get(path10, chunkId);
-    if (!row) return null;
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DNA SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildDNASummary() {
     return {
-      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
-      contentHash: row.content_hash,
-      metadata: JSON.parse(row.metadata)
+      conventions: this.dna.conventions.filter((c) => c.confidence > 0.5).map((c) => c.description),
+      patterns: this.dna.patterns.map((p) => `${p.name}: ${p.description}`),
+      boundaries: this.dna.boundaries.filter((b) => b.importCount > 3).map((b) => `${b.from} \u2192 ${b.to} (${b.importCount} imports${b.isCircular ? ", CIRCULAR" : ""})`),
+      hotFiles: this.dna.hotspots.slice(0, 10).map((h) => h.file),
+      riskAreas: this.dna.riskMap.filter((r) => r.riskLevel === "critical" || r.riskLevel === "high").map((r) => `${r.file}: ${r.factors[0]}`)
     };
   }
-  /**
-   * Load all embeddings of a given type for vector search.
-   */
-  loadEmbeddingsByType(chunkType) {
-    const rows = this.db.prepare("SELECT path, chunk_id, vector, content_hash, metadata FROM embeddings WHERE chunk_type = ?").all(chunkType);
-    return rows.map((row) => ({
-      path: row.path,
-      chunkId: row.chunk_id,
-      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
-      contentHash: row.content_hash,
-      metadata: JSON.parse(row.metadata)
-    }));
-  }
-  /**
-   * Remove stale embeddings for files no longer in the index.
-   */
-  pruneStaleEmbeddings() {
-    const result = this.db.prepare(`
-      DELETE FROM embeddings WHERE path NOT IN (SELECT relative_path FROM files)
-    `).run();
-    return result.changes;
-  }
   // ═══════════════════════════════════════════════════════════════════════════
-  // QUERYING
+  // FILE CONTEXTS
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Get all symbols in a specific file.
-   */
-  getSymbolsForFile(filePath) {
-    return this.loadSymbolsWhere("file_path = ?", [filePath]);
-  }
-  /**
-   * Search symbols by name pattern.
-   */
-  searchSymbols(namePattern, limit = 50) {
-    return this.loadSymbolsWhere("name LIKE ?", [`%${namePattern}%`]).slice(0, limit);
-  }
-  /**
-   * Get files that import a given file.
-   */
-  getDependents(filePath) {
-    const rows = this.db.prepare("SELECT DISTINCT file_path FROM imports WHERE resolved_path = ?").all(filePath);
-    return rows.map((r) => r.file_path);
+  buildFileContexts() {
+    const contexts = /* @__PURE__ */ new Map();
+    for (const file of this.data.files) {
+      contexts.set(file.relativePath, this.buildSingleFileContext(file));
+    }
+    return contexts;
   }
-  /**
-   * Get files that a given file imports.
-   */
-  getDependencies(filePath) {
-    const rows = this.db.prepare('SELECT DISTINCT resolved_path FROM imports WHERE file_path = ? AND resolved_path != ""').all(filePath);
-    return rows.map((r) => r.resolved_path);
+  buildSingleFileContext(file) {
+    const rel = file.relativePath;
+    const role = this.classifyRole(file);
+    const graphNode = this.graph.nodes.find((n) => n.relativePath === rel);
+    const layer = graphNode?.layer;
+    const dependsOn = this.graph.edges.filter((e) => e.from === rel).map((e) => e.to);
+    const dependedOnBy = this.graph.edges.filter((e) => e.to === rel).map((e) => e.from);
+    const applicableRules = [];
+    if (this.ruleResult) {
+      for (const v of this.ruleResult.violations) {
+        if (v.sourceSymbol.filePath.includes(rel) || v.targetSymbol && v.targetSymbol.filePath.includes(rel)) {
+          if (!applicableRules.includes(v.ruleId)) applicableRules.push(v.ruleId);
+        }
+      }
+    }
+    const conventions = this.dna.conventions.filter((c) => this.conventionAppliesToFile(c.area, file)).map((c) => c.description);
+    const patterns = this.dna.patterns.filter((p) => p.fileMatches.some((m) => m === rel)).map((p) => p.name);
+    const riskEntry = this.dna.riskMap.find((r) => r.file === rel);
+    const riskLevel = riskEntry?.riskLevel || "low";
+    const relatedFiles = this.findRelatedFiles(file, role).slice(0, 8);
+    const editGuidance = this.generateEditGuidance(file, role, layer, dependedOnBy, conventions);
+    return {
+      filePath: file.path,
+      role,
+      layer,
+      dependsOn,
+      dependedOnBy,
+      applicableRules,
+      conventions,
+      patterns,
+      riskLevel,
+      relatedFiles,
+      editGuidance
+    };
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CLEANUP
-  // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Close the database connection.
-   */
-  close() {
-    this.db.close();
+  classifyRole(file) {
+    const rel = file.relativePath.toLowerCase();
+    if (rel.includes(".test.") || rel.includes(".spec.") || rel.includes("__tests__")) return "test";
+    if (rel.includes("fixture") || rel.includes("mock")) return "fixture";
+    if (rel.includes("migration")) return "migration";
+    if (rel.match(/\.(css|scss|less|styl)$/)) return "style";
+    if (rel.includes(".config.") || rel.includes("config/") || rel === "tsconfig.json") return "config";
+    if (rel.includes("middleware")) return "middleware";
+    if (rel.includes("/api/") || rel.includes("route")) return "route-handler";
+    if (rel.includes("service") || rel.includes("Service")) return "service";
+    if (rel.includes("repositor") || rel.includes("Repositor")) return "repository";
+    if (rel.endsWith(".tsx") && !rel.includes("page.")) return "component";
+    if (rel.includes("/types") || rel.endsWith(".d.ts")) return "type";
+    if (rel.includes("util") || rel.includes("helper") || rel.includes("lib/")) return "util";
+    if (rel.includes("script") || rel.includes("bin/")) return "script";
+    if (rel.match(/^(src\/)?index\.|^(src\/)?main\.|^(src\/)?app\./)) return "entry";
+    return "unknown";
   }
-  /**
-   * Wipe all data and rebuild schema.
-   */
-  reset() {
-    this.db.exec("DROP TABLE IF EXISTS file_hashes");
-    this.db.exec("DROP TABLE IF EXISTS files");
-    this.db.exec("DROP TABLE IF EXISTS symbols");
-    this.db.exec("DROP TABLE IF EXISTS imports");
-    this.db.exec("DROP TABLE IF EXISTS call_edges");
-    this.db.exec("DROP TABLE IF EXISTS routes");
-    this.db.exec("DROP TABLE IF EXISTS services");
-    this.db.exec("DROP TABLE IF EXISTS embeddings");
-    this.db.exec("DROP TABLE IF EXISTS meta");
-    this.initSchema();
+  conventionAppliesToFile(area, file) {
+    switch (area) {
+      case "naming":
+        return true;
+      case "imports":
+        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
+      case "exports":
+        return file.exports.length > 0;
+      case "testing":
+        return file.relativePath.includes(".test.") || file.relativePath.includes(".spec.");
+      case "error-handling":
+        return !file.relativePath.includes(".test.");
+      case "types":
+        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
+      default:
+        return true;
+    }
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE — File Discovery
-  // ═══════════════════════════════════════════════════════════════════════════
-  async discoverFiles() {
-    const files = await (0, import_fast_glob2.glob)(this.config.includePatterns, {
-      cwd: this.rootPath,
-      ignore: this.config.excludePatterns,
-      absolute: false,
-      dot: false,
-      onlyFiles: true
-    });
-    const hashes = [];
-    const limit = this.config.maxFiles;
-    for (const relPath of files.slice(0, limit)) {
-      const absPath = join(this.rootPath, relPath);
-      try {
-        const fileStat = await stat(absPath);
-        if (fileStat.size > this.config.maxFileSize) continue;
-        const content = await readFile(absPath, "utf-8");
-        hashes.push({
-          relativePath: relPath.replace(/\\/g, "/"),
-          contentHash: hashContent2(content),
-          sizeBytes: fileStat.size,
-          modifiedMs: Math.floor(fileStat.mtimeMs)
-        });
-      } catch {
+  findRelatedFiles(file, role) {
+    const related = [];
+    const dir = path2.dirname(file.relativePath);
+    for (const other of this.data.files) {
+      if (other.path === file.path) continue;
+      if (path2.dirname(other.relativePath) === dir) {
+        related.push(other.relativePath);
       }
     }
-    return hashes;
+    if (related.length < 5) {
+      for (const other of this.data.files) {
+        if (other.path === file.path) continue;
+        if (related.includes(other.relativePath)) continue;
+        if (this.classifyRole(other) === role) {
+          related.push(other.relativePath);
+          if (related.length >= 8) break;
+        }
+      }
+    }
+    return related;
   }
-  getStoredHashes() {
-    const rows = this.db.prepare("SELECT relative_path, content_hash, size_bytes, modified_ms FROM file_hashes").all();
-    const map = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      map.set(row.relative_path, {
-        relativePath: row.relative_path,
-        contentHash: row.content_hash,
-        sizeBytes: row.size_bytes,
-        modifiedMs: row.modified_ms
-      });
+  generateEditGuidance(file, role, layer, dependedOnBy, conventions) {
+    const guidance = [];
+    if (dependedOnBy.length > 10) {
+      guidance.push(`HIGH IMPACT: ${dependedOnBy.length} files depend on this. Changes have wide blast radius.`);
     }
-    return map;
+    switch (role) {
+      case "route-handler":
+        guidance.push("Validate all inputs with schemas before processing.");
+        guidance.push("Return consistent response shapes ({ success, data } or { success, error }).");
+        guidance.push("Ensure authentication middleware is applied to protected endpoints.");
+        break;
+      case "service":
+        guidance.push("Keep business logic here, not in controllers/routes.");
+        guidance.push("Use dependency injection for testability.");
+        if (layer) guidance.push(`This is in the ${layer} layer \u2014 only import from lower layers.`);
+        break;
+      case "repository":
+        guidance.push("Only data access logic belongs here \u2014 no business rules.");
+        guidance.push("Return domain objects, not raw database rows.");
+        break;
+      case "component":
+        guidance.push("Keep components focused and composable.");
+        guidance.push("Extract complex logic to custom hooks.");
+        break;
+      case "middleware":
+        guidance.push("Middleware must call next() or return a response \u2014 never leave the request hanging.");
+        guidance.push("Keep middleware focused on a single concern.");
+        break;
+      case "test":
+        guidance.push("Follow Arrange-Act-Assert pattern.");
+        guidance.push("Test edge cases and error conditions, not just happy path.");
+        break;
+    }
+    for (const conv of conventions.slice(0, 3)) {
+      guidance.push(`Convention: ${conv}`);
+    }
+    return guidance;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE — Storage
+  // TASK PLAYBOOKS
   // ═══════════════════════════════════════════════════════════════════════════
-  storeFiles(parsedFiles) {
-    if (parsedFiles.length === 0) return;
-    const insertHash = this.db.prepare(
-      "INSERT OR REPLACE INTO file_hashes (relative_path, content_hash, size_bytes, modified_ms) VALUES (?, ?, ?, ?)"
-    );
-    const insertFile = this.db.prepare(
-      "INSERT OR REPLACE INTO files (id, path, relative_path, language, line_count, exports, content) VALUES (?, ?, ?, ?, ?, ?, ?)"
-    );
-    const insertSymbol = this.db.prepare(
-      "INSERT OR REPLACE INTO symbols (id, name, kind, file_path, start_line, end_line, exported, async, params, branches, signature) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
-    );
-    const insertImport = this.db.prepare(
-      "INSERT INTO imports (file_id, file_path, source_path, resolved_path, imported_symbols, is_type_only, is_dynamic, line) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
-    );
-    const insertCallEdge = this.db.prepare(
-      "INSERT INTO call_edges (caller_id, callee_id, caller_name, callee_name, caller_file, callee_file) VALUES (?, ?, ?, ?, ?, ?)"
-    );
-    const txn = this.db.transaction(() => {
-      for (const parsed of parsedFiles) {
-        const { file, symbols, imports, callEdges, contentHash } = parsed;
-        insertHash.run(file.relativePath, contentHash, 0, Date.now());
-        insertFile.run(
-          file.id,
-          file.path,
-          file.relativePath,
-          file.language,
-          file.lineCount,
-          JSON.stringify(file.exports),
-          this.config.storeContent ? file.content ?? null : null
-        );
-        for (const sym of symbols) {
-          insertSymbol.run(
-            sym.id,
-            sym.name,
-            sym.kind,
-            sym.filePath,
-            sym.startLine,
-            sym.endLine,
-            sym.exported ? 1 : 0,
-            sym.async ? 1 : 0,
-            sym.params ?? null,
-            sym.branches ?? null,
-            sym.signature ?? null
-          );
-        }
-        for (const imp of imports) {
-          insertImport.run(
-            imp.fileId,
-            imp.filePath,
-            imp.sourcePath,
-            imp.resolvedPath,
-            JSON.stringify(imp.importedSymbols),
-            imp.isTypeOnly ? 1 : 0,
-            imp.isDynamic ? 1 : 0,
-            imp.line
-          );
-        }
-        for (const edge of callEdges) {
-          insertCallEdge.run(
-            edge.callerId,
-            edge.calleeId,
-            edge.callerName,
-            edge.calleeName,
-            edge.callerFile,
-            edge.calleeFile
-          );
-        }
-      }
+  buildTaskPlaybooks() {
+    const fp = this.dna.fingerprint;
+    const playbooks = [];
+    playbooks.push({
+      taskType: "Bug Fix",
+      steps: [
+        "Reproduce the bug and understand the expected vs actual behavior",
+        "Identify the root cause file(s) using the dependency graph",
+        "Write a failing test that reproduces the bug",
+        "Apply the minimal fix at the root cause",
+        "Verify the fix passes the test and does not break existing tests",
+        "Check that the fix does not violate any architecture rules"
+      ],
+      mustRead: this.dna.hotspots.slice(0, 3).map((h) => h.file),
+      mustUpdate: ["The buggy file", "Related test file"],
+      mustVerify: ["All existing tests pass", "New regression test passes", "No new arch rule violations"],
+      stopConditions: ["Never modify tests to make them pass \u2014 fix the code", "Do not change public API signatures without discussion"]
     });
-    txn();
-  }
-  removeFiles(relativePaths) {
-    if (relativePaths.length === 0) return;
-    const txn = this.db.transaction(() => {
-      for (const relPath of relativePaths) {
-        const absPath = join(this.rootPath, relPath);
-        this.db.prepare("DELETE FROM file_hashes WHERE relative_path = ?").run(relPath);
-        this.db.prepare("DELETE FROM files WHERE relative_path = ?").run(relPath);
-        this.db.prepare("DELETE FROM symbols WHERE file_path = ? OR file_path = ?").run(absPath, relPath);
-        this.db.prepare("DELETE FROM imports WHERE file_path = ? OR file_path = ?").run(absPath, relPath);
-        this.db.prepare("DELETE FROM call_edges WHERE caller_file = ? OR callee_file = ? OR caller_file = ? OR callee_file = ?").run(absPath, absPath, relPath, relPath);
-        this.db.prepare("DELETE FROM embeddings WHERE path = ?").run(relPath);
-      }
+    if (fp.router) {
+      playbooks.push({
+        taskType: "Add API Endpoint",
+        steps: [
+          "Check existing routes in truthpack to avoid duplicates",
+          "Create the route handler following existing patterns",
+          "Add input validation using the project validator",
+          "Add authentication middleware if the route is protected",
+          "Write tests for success, validation failure, and auth failure",
+          "Update the truthpack (run vibecheck scan)"
+        ],
+        mustRead: ["truthpack/routes.json", ...this.dna.patterns.filter((p) => p.category === "api").map((p) => p.exemplar)],
+        mustUpdate: ["Route file", "Test file", "Truthpack"],
+        mustVerify: ["Route responds correctly", "Input validation works", "Auth is enforced", "Test passes"],
+        stopConditions: ["Do not create duplicate routes", "Do not hardcode mock data in handlers"]
+      });
+    }
+    if (fp.framework.includes("Next") || fp.framework.includes("React")) {
+      playbooks.push({
+        taskType: "Add UI Component",
+        steps: [
+          "Check if a similar component already exists",
+          "Create the component following existing naming and structure patterns",
+          "Add TypeScript props interface",
+          "Add unit test for the component",
+          "If using state, determine if it should be a client component"
+        ],
+        mustRead: this.dna.patterns.filter((p) => p.category === "ui" || p.category === "state").map((p) => p.exemplar),
+        mustUpdate: ["Component file", "Test file", "Parent component that uses it"],
+        mustVerify: ["Component renders correctly", "Props are typed", "Test passes"],
+        stopConditions: ['Do not use "any" type for props', 'Do not add useState in server components without "use client"']
+      });
+    }
+    playbooks.push({
+      taskType: "Refactor",
+      steps: [
+        "Identify all callers/dependents of the code being refactored",
+        "Ensure comprehensive tests exist before refactoring",
+        "Apply changes incrementally, testing after each step",
+        "Update all dependents to use the new API",
+        "Remove old code only after all dependents are migrated",
+        "Verify no architecture rules are violated"
+      ],
+      mustRead: ["Dependency graph for affected files"],
+      mustUpdate: ["Refactored file", "All dependent files", "Tests"],
+      mustVerify: ["All tests pass", "No new violations", "No regressions"],
+      stopConditions: ["Never break existing public APIs without migration path", "Do not refactor and add features in the same change"]
     });
-    txn();
+    return playbooks;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE — Loading
+  // VERIFICATION STEPS
   // ═══════════════════════════════════════════════════════════════════════════
-  loadFiles() {
-    const rows = this.db.prepare("SELECT id, path, relative_path, language, line_count, exports, content FROM files").all();
-    return rows.map((row) => ({
-      id: row.id,
-      path: row.path,
-      relativePath: row.relative_path,
-      language: row.language,
-      lineCount: row.line_count,
-      exports: JSON.parse(row.exports),
-      content: row.content ?? void 0
-    }));
-  }
-  loadSymbols() {
-    const rows = this.db.prepare("SELECT id, name, kind, file_path, start_line, end_line, exported, async, params, branches FROM symbols").all();
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      kind: row.kind,
-      filePath: row.file_path,
-      startLine: row.start_line,
-      endLine: row.end_line,
-      exported: row.exported === 1,
-      async: row.async === 1,
-      params: row.params ?? void 0,
-      branches: row.branches ?? void 0
-    }));
-  }
-  loadSymbolsWhere(where, params) {
-    const rows = this.db.prepare(`SELECT id, name, kind, file_path, start_line, end_line, exported, async, params, branches FROM symbols WHERE ${where}`).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      kind: row.kind,
-      filePath: row.file_path,
-      startLine: row.start_line,
-      endLine: row.end_line,
-      exported: row.exported === 1,
-      async: row.async === 1,
-      params: row.params ?? void 0,
-      branches: row.branches ?? void 0
-    }));
+  buildVerificationSteps() {
+    const fp = this.dna.fingerprint;
+    const steps = [];
+    if (fp.language === "TypeScript") {
+      steps.push({
+        trigger: "Any TypeScript file change",
+        checks: ["TypeScript compilation succeeds", "No new type errors introduced"],
+        commands: [fp.packageManager === "pnpm" ? "pnpm run check-types" : "npm run check-types"],
+        artifacts: []
+      });
+    }
+    if (fp.testRunner) {
+      steps.push({
+        trigger: "Any source file change",
+        checks: ["Related tests pass", "No test regressions"],
+        commands: [`${fp.packageManager} run test`],
+        artifacts: ["test-results.json"]
+      });
+    }
+    if (fp.router) {
+      steps.push({
+        trigger: "Route handler added or modified",
+        checks: ["Route responds with correct status", "Auth middleware is applied", "Input validation works"],
+        commands: ["vibecheck scan"],
+        artifacts: ["truthpack/routes.json"]
+      });
+    }
+    steps.push({
+      trigger: "Any source file change",
+      checks: ["No new architecture rule violations", "No new circular dependencies"],
+      commands: ["vibecheck arch-rules"],
+      artifacts: []
+    });
+    return steps;
   }
-  loadImports() {
-    const rows = this.db.prepare("SELECT file_id, file_path, source_path, resolved_path, imported_symbols, is_type_only, is_dynamic, line FROM imports").all();
-    return rows.map((row) => ({
-      fileId: row.file_id,
-      filePath: row.file_path,
-      sourcePath: row.source_path,
-      resolvedPath: row.resolved_path,
-      importedSymbols: JSON.parse(row.imported_symbols),
-      isTypeOnly: row.is_type_only === 1,
-      isDynamic: row.is_dynamic === 1,
-      line: row.line
-    }));
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RISK BRIEFING
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildRiskBriefing() {
+    const criticalFiles = this.dna.hotspots.filter((h) => h.score > 30).slice(0, 10).map((h) => h.file);
+    const recentViolations = this.ruleResult?.violations.filter((v) => v.severity === "error").slice(0, 10) || [];
+    const securityConcerns = [];
+    for (const risk of this.dna.riskMap) {
+      if (risk.riskLevel === "critical") {
+        securityConcerns.push(`${risk.file}: ${risk.factors.join(", ")}`);
+      }
+    }
+    const testGaps = [];
+    const sourceFiles = this.data.files.filter(
+      (f) => !f.relativePath.includes(".test.") && !f.relativePath.includes(".spec.") && (f.relativePath.endsWith(".ts") || f.relativePath.endsWith(".tsx")) && !f.relativePath.includes("config") && !f.relativePath.includes(".d.ts")
+    );
+    const testFiles = this.data.files.filter(
+      (f) => f.relativePath.includes(".test.") || f.relativePath.includes(".spec.")
+    );
+    const testedBases = new Set(testFiles.map(
+      (f) => path2.basename(f.relativePath).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, "")
+    ));
+    for (const file of sourceFiles) {
+      const baseName = path2.basename(file.relativePath).replace(/\.(ts|tsx|js|jsx)$/, "");
+      if (!testedBases.has(baseName) && file.exports.length > 0) {
+        testGaps.push(`${file.relativePath} has exports but no test file`);
+      }
+    }
+    const driftWarnings = [];
+    for (const cycle of this.graph.cycles) {
+      driftWarnings.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}${cycle.nodes.length > 3 ? "..." : ""}`);
+    }
+    return {
+      criticalFiles,
+      recentViolations,
+      securityConcerns: securityConcerns.slice(0, 5),
+      testGaps: testGaps.slice(0, 10),
+      driftWarnings: driftWarnings.slice(0, 5)
+    };
   }
-  loadCallEdges() {
-    const rows = this.db.prepare("SELECT caller_id, callee_id, caller_name, callee_name, caller_file, callee_file FROM call_edges").all();
-    return rows.map((row) => ({
-      callerId: row.caller_id,
-      calleeId: row.callee_id,
-      callerName: row.caller_name,
-      calleeName: row.callee_name,
-      callerFile: row.caller_file,
-      calleeFile: row.callee_file
-    }));
+  // ═══════════════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═══════════════════════════════════════════════════════════════════════════
+  toRelative(filePath) {
+    if (filePath.startsWith(this.rootPath)) {
+      return filePath.slice(this.rootPath.length + 1).replace(/\\/g, "/");
+    }
+    return filePath.replace(/\\/g, "/");
   }
-  loadRoutes() {
-    const rows = this.db.prepare("SELECT path, method, handler, file, line, middleware, auth FROM routes").all();
-    return rows.map((row) => ({
-      path: row.path,
-      method: row.method,
-      handler: row.handler,
-      file: row.file,
-      line: row.line,
-      middleware: JSON.parse(row.middleware),
-      auth: row.auth === null ? void 0 : row.auth === 1
-    }));
-  }
-  loadServices() {
-    const rows = this.db.prepare("SELECT id, name, root_path FROM services").all();
-    return rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      rootPath: row.root_path
-    }));
-  }
-};
-function hashContent2(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-var EXT_LANG = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".rs": "rust",
-  ".go": "go",
-  ".java": "java",
-  ".c": "c",
-  ".h": "c",
-  ".cpp": "cpp",
-  ".hpp": "cpp",
-  ".rb": "ruby",
-  ".swift": "swift",
-  ".kt": "kotlin",
-  ".lua": "lua",
-  ".zig": "zig",
-  ".cs": "csharp"
 };
-var TS_IMPORT_RE = /^import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+(?:\s*,\s*\{[^}]*\})?)\s+from\s+['"]([^'"]+)['"]/gm;
-var TS_IMPORT_TYPE_RE = /^import\s+type\s+/;
-var TS_DYNAMIC_IMPORT_RE = /(?:import|require)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-var PY_IMPORT_RE = /^(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm;
-var GO_IMPORT_RE = /import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
-var DefaultFileParser = class {
-  rootPath;
-  treeSitterParser = null;
-  treeSitterLoaded = false;
-  constructor(rootPath) {
-    this.rootPath = rootPath;
-  }
-  async parseFile(absolutePath, relativePath2) {
-    const content = await readFile(absolutePath, "utf-8");
-    const lines = content.split("\n");
-    const ext2 = extname(absolutePath).toLowerCase();
-    const language = EXT_LANG[ext2] ?? "unknown";
-    const contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
-    const exports$1 = this.extractExports(content, language);
-    const symbols = await this.extractSymbols(content, lines, absolutePath, relativePath2, language);
-    const imports = this.extractImports(content, absolutePath, relativePath2, language);
-    const callEdges = this.extractCallEdges(content, symbols, absolutePath);
-    const fileId = `file:${relativePath2}`;
-    const file = {
-      id: fileId,
-      path: absolutePath,
-      relativePath: relativePath2,
-      language,
-      lineCount: lines.length,
-      exports: exports$1,
-      content
-    };
-    return { file, symbols, imports, callEdges, contentHash };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // EXPORTS
-  // ═══════════════════════════════════════════════════════════════════════════
-  extractExports(content, language) {
-    if (language !== "typescript" && language !== "javascript") return [];
-    const exports$1 = [];
-    const exportRe = /export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+(\w+)/g;
-    for (const match2 of content.matchAll(exportRe)) {
-      if (match2[1]) exports$1.push(match2[1]);
-    }
-    if (/export\s+default\s/.test(content) && !exports$1.includes("default")) {
-      exports$1.push("default");
-    }
-    const reExportRe = /export\s+\{([^}]+)\}\s+from/g;
-    for (const match2 of content.matchAll(reExportRe)) {
-      for (const sym of match2[1].split(",")) {
-        const name = sym.trim().split(/\s+as\s+/).pop()?.trim();
-        if (name) exports$1.push(name);
+var ContextExplainer = class {
+  /**
+   * Generate a rich explanation for a file.
+   */
+  explain(filePath, ctx) {
+    const fc = ctx.fileContext;
+    const paragraphs = [];
+    const quickFacts = [];
+    const warnings = [];
+    const relatedFiles = [];
+    const overlays = [];
+    const role = fc?.role ?? "unknown";
+    const roleSummary = this.buildRoleSummary(filePath, role, ctx);
+    if (fc) {
+      const depCount = fc.dependedOnBy.length;
+      const depsOnCount = fc.dependsOn.length;
+      if (depCount > 0 || depsOnCount > 0) {
+        const parts = [];
+        if (depCount > 0) {
+          const critical = depCount > 10 ? " \u2014 changes here have wide blast radius" : "";
+          parts.push(`${depCount} file${depCount > 1 ? "s" : ""} depend on this${critical}`);
+        }
+        if (depsOnCount > 0) {
+          parts.push(`it imports from ${depsOnCount} file${depsOnCount > 1 ? "s" : ""}`);
+        }
+        paragraphs.push({
+          heading: "Dependencies",
+          text: parts.join(". ") + ".",
+          importance: depCount > 10 ? "critical" : depCount > 5 ? "high" : "medium"
+        });
       }
-    }
-    return [...new Set(exports$1)];
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // SYMBOLS
-  // ═══════════════════════════════════════════════════════════════════════════
-  async extractSymbols(content, lines, absolutePath, relativePath2, language) {
-    const tsSymbols = await this.tryTreeSitter(content, absolutePath);
-    if (tsSymbols) {
-      return tsSymbols.map((sym, i) => ({
-        id: `sym:${relativePath2}:${sym.name}:${sym.line}`,
-        name: sym.name,
-        kind: mapTreeSitterKind(sym.kind),
-        filePath: absolutePath,
-        startLine: sym.line,
-        endLine: sym.endLine,
-        exported: this.isExported(content, sym.name, language),
-        async: sym.signature.includes("async "),
-        params: this.countParams(sym.signature),
-        branches: void 0,
-        signature: sym.signature
-      }));
-    }
-    return this.extractSymbolsRegex(content, lines, absolutePath, relativePath2, language);
-  }
-  async tryTreeSitter(content, filePath) {
-    if (!this.treeSitterLoaded) {
-      this.treeSitterLoaded = true;
-      try {
-        const mod = await import('./tree-sitter-H5E7LKR4-MKO3NNLJ.js');
-        this.treeSitterParser = mod.parseWithTreeSitter;
-      } catch {
-        this.treeSitterParser = null;
+      quickFacts.push({ label: "Role", value: role, icon: "layer" });
+      if (fc.layer) quickFacts.push({ label: "Layer", value: fc.layer, icon: "layer" });
+      quickFacts.push({ label: "Dependents", value: String(depCount), icon: "dependency" });
+      quickFacts.push({ label: "Dependencies", value: String(depsOnCount), icon: "dependency" });
+      if (fc.riskLevel === "critical" || fc.riskLevel === "high") {
+        quickFacts.push({ label: "Risk", value: fc.riskLevel.toUpperCase(), icon: "warning" });
+        warnings.push({
+          message: `This file is classified as ${fc.riskLevel} risk`,
+          severity: fc.riskLevel === "critical" ? "error" : "warning",
+          action: "Add comprehensive tests and review carefully before merging changes"
+        });
+      }
+      for (const dep of fc.dependedOnBy.slice(0, 5)) {
+        relatedFiles.push({
+          filePath: dep,
+          reason: `Imports from this file`,
+          relationship: "depended-by",
+          confidence: 0.9
+        });
       }
+      overlays.push({
+        type: "code-lens",
+        line: 1,
+        text: `${depCount} dependent${depCount !== 1 ? "s" : ""} \xB7 ${depsOnCount} import${depsOnCount !== 1 ? "s" : ""} \xB7 ${role}`,
+        tooltip: `This ${role} file has ${depCount} files that depend on it and imports from ${depsOnCount} files`
+      });
     }
-    if (!this.treeSitterParser) return null;
-    try {
-      const ext2 = extname(filePath).toLowerCase();
-      const symbols = await this.treeSitterParser(content, ext2);
-      if (!symbols || symbols.length === 0) return null;
-      return flattenCodeSymbols(symbols);
-    } catch {
-      return null;
+    if (fc && fc.conventions.length > 0) {
+      paragraphs.push({
+        heading: "Conventions",
+        text: `Follow these discovered conventions: ${fc.conventions.slice(0, 3).join("; ")}.`,
+        importance: "medium"
+      });
     }
-  }
-  extractSymbolsRegex(content, lines, absolutePath, relativePath2, language) {
-    const symbols = [];
-    if (language === "typescript" || language === "javascript") {
-      const patterns = [
-        { re: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)/gm, kind: "function" },
-        { re: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/gm, kind: "class" },
-        { re: /^(?:export\s+)?interface\s+(\w+)/gm, kind: "interface" },
-        { re: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/gm, kind: "type" },
-        { re: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/gm, kind: "enum" },
-        { re: /^(?:export\s+)?const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\(/gm, kind: "function" }
-      ];
-      for (const { re, kind } of patterns) {
-        for (const match2 of content.matchAll(re)) {
-          const name = match2[1];
-          if (!name) continue;
-          const line = content.slice(0, match2.index).split("\n").length;
-          const endLine = this.findBlockEnd(lines, line - 1);
-          symbols.push({
-            id: `sym:${relativePath2}:${name}:${line}`,
-            name,
-            kind,
-            filePath: absolutePath,
-            startLine: line,
-            endLine,
-            exported: this.isExported(content, name, language),
-            async: match2[0].includes("async"),
-            params: this.countParams(match2[0]),
-            branches: this.countBranches(lines, line - 1, endLine - 1),
-            signature: match2[0].trim().replace(/\s*\{?\s*$/, "")
+    if (ctx.rules) {
+      const fileViolations = ctx.rules.violations.filter(
+        (v) => v.sourceSymbol.filePath.includes(shortName(filePath)) || v.targetSymbol && v.targetSymbol.filePath.includes(shortName(filePath))
+      );
+      if (fileViolations.length > 0) {
+        const errors = fileViolations.filter((v) => v.severity === "error");
+        const warns = fileViolations.filter((v) => v.severity === "warning");
+        paragraphs.push({
+          heading: "Architecture Violations",
+          text: `${errors.length} error${errors.length !== 1 ? "s" : ""} and ${warns.length} warning${warns.length !== 1 ? "s" : ""} from architecture rules.`,
+          importance: errors.length > 0 ? "critical" : "high"
+        });
+        for (const v of fileViolations.slice(0, 5)) {
+          warnings.push({
+            message: v.message,
+            severity: v.severity === "error" ? "error" : "warning",
+            action: v.suggestedFix ?? "Review and fix the violation",
+            ruleId: v.ruleId
+          });
+          overlays.push({
+            type: "diagnostic",
+            line: v.sourceSymbol.line,
+            text: v.message,
+            severity: v.severity === "error" ? "error" : "warning",
+            tooltip: v.suggestedFix
           });
         }
       }
     }
-    if (language === "python") {
-      const re = /^(?:async\s+)?(?:def|class)\s+(\w+)/gm;
-      for (const match2 of content.matchAll(re)) {
-        const name = match2[1];
-        const kind = match2[0].includes("class") ? "class" : "function";
-        const line = content.slice(0, match2.index).split("\n").length;
-        symbols.push({
-          id: `sym:${relativePath2}:${name}:${line}`,
-          name,
-          kind,
-          filePath: absolutePath,
-          startLine: line,
-          endLine: line + 10,
-          exported: true,
-          async: match2[0].includes("async"),
-          params: this.countParams(match2[0]),
-          branches: void 0,
-          signature: match2[0].trim()
+    if (ctx.callGraph) {
+      const fileNodes = ctx.callGraph.nodes.filter((n) => n.filePath.includes(shortName(filePath)));
+      const hotFunctions = fileNodes.filter((n) => n.callerCount > 5);
+      if (hotFunctions.length > 0) {
+        paragraphs.push({
+          heading: "Hot Functions",
+          text: hotFunctions.map(
+            (f) => `\`${f.name}\` is called by ${f.callerCount} function${f.callerCount !== 1 ? "s" : ""}${f.calleeCount > 0 ? ` and calls ${f.calleeCount}` : ""}`
+          ).join(". ") + ".",
+          importance: "high"
         });
+        for (const fn of hotFunctions) {
+          overlays.push({
+            type: "code-lens",
+            line: 0,
+            // Would need symbol line mapping
+            text: `${fn.callerCount} callers \xB7 ${fn.calleeCount} callees`,
+            tooltip: `Function ${fn.name} has ${fn.callerCount} callers and ${fn.calleeCount} callees`
+          });
+        }
+      }
+      const deadInFile = ctx.callGraph.stats.deadFunctions.filter(
+        (d) => d.filePath.includes(shortName(filePath))
+      );
+      if (deadInFile.length > 0) {
+        for (const dead of deadInFile) {
+          warnings.push({
+            message: `\`${dead.name}\` appears to be dead code (exported but never called)`,
+            severity: "info",
+            action: "Verify this function is not called via dynamic dispatch or external consumers, then consider removing it"
+          });
+        }
       }
     }
-    return symbols;
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // IMPORTS
-  // ═══════════════════════════════════════════════════════════════════════════
-  extractImports(content, absolutePath, relativePath2, language) {
-    const imports = [];
-    const fileId = `file:${relativePath2}`;
-    if (language === "typescript" || language === "javascript") {
-      for (const match2 of content.matchAll(TS_IMPORT_RE)) {
-        const sourcePath = match2[1];
-        const line = content.slice(0, match2.index).split("\n").length;
-        const isTypeOnly = TS_IMPORT_TYPE_RE.test(match2[0]);
-        const importedSymbols = this.extractImportedSymbols(match2[0]);
-        const resolvedPath = this.resolveImportPath(sourcePath, absolutePath);
-        imports.push({
-          fileId,
-          filePath: absolutePath,
-          sourcePath,
-          resolvedPath,
-          importedSymbols,
-          isTypeOnly,
-          isDynamic: false,
-          line
+    if (ctx.temporal) {
+      const hotspot = ctx.temporal.changeHotspots.find((h) => filePath.includes(h.file) || h.file.includes(shortName(filePath)));
+      if (hotspot) {
+        const daysSince = Math.round((Date.now() - new Date(hotspot.lastChanged).getTime()) / 864e5);
+        paragraphs.push({
+          heading: "Recent Activity",
+          text: `Changed ${hotspot.commits} times in the last ${ctx.temporal.stats.analysisWindowDays} days by ${hotspot.authors} author${hotspot.authors !== 1 ? "s" : ""}. Last modified ${daysSince} day${daysSince !== 1 ? "s" : ""} ago.`,
+          importance: hotspot.commits > 10 ? "high" : "medium"
         });
+        quickFacts.push({ label: "Recent commits", value: String(hotspot.commits), icon: "git" });
+        quickFacts.push({ label: "Last changed", value: `${daysSince}d ago`, icon: "git" });
+        quickFacts.push({ label: "Authors", value: String(hotspot.authors), icon: "git" });
       }
-      for (const match2 of content.matchAll(TS_DYNAMIC_IMPORT_RE)) {
-        const sourcePath = match2[1];
-        const line = content.slice(0, match2.index).split("\n").length;
-        imports.push({
-          fileId,
-          filePath: absolutePath,
-          sourcePath,
-          resolvedPath: this.resolveImportPath(sourcePath, absolutePath),
-          importedSymbols: [],
-          isTypeOnly: false,
-          isDynamic: true,
-          line
+      const churn = ctx.temporal.churnFiles.find((c) => filePath.includes(c.file) || c.file.includes(shortName(filePath)));
+      if (churn && churn.severity !== "low") {
+        warnings.push({
+          message: churn.reason,
+          severity: churn.severity === "high" ? "warning" : "info",
+          action: "Consider whether this file needs refactoring to reduce change frequency"
         });
       }
-    }
-    if (language === "python") {
-      for (const match2 of content.matchAll(PY_IMPORT_RE)) {
-        const sourcePath = match2[1] || match2[2];
-        if (!sourcePath) continue;
-        const line = content.slice(0, match2.index).split("\n").length;
-        imports.push({
-          fileId,
-          filePath: absolutePath,
-          sourcePath,
-          resolvedPath: "",
-          importedSymbols: [],
-          isTypeOnly: false,
-          isDynamic: false,
-          line
+      const expertise = ctx.temporal.authorExpertise.find(
+        (e) => filePath.startsWith(e.area) || filePath.includes(e.area)
+      );
+      if (expertise && expertise.busFactor === 1) {
+        warnings.push({
+          message: `Bus factor of 1 \u2014 ${expertise.primaryAuthor} has made ${expertise.authors[0]?.percentage}% of changes to this area`,
+          severity: "info",
+          action: "Consider knowledge sharing or pair programming for this area"
         });
       }
     }
-    if (language === "go") {
-      for (const match2 of content.matchAll(GO_IMPORT_RE)) {
-        const block = match2[1] || match2[2];
-        if (!block) continue;
-        const paths = block.match(/"([^"]+)"/g) ?? [];
-        for (const p of paths) {
-          const sourcePath = p.replace(/"/g, "");
-          imports.push({
-            fileId,
-            filePath: absolutePath,
-            sourcePath,
-            resolvedPath: "",
-            importedSymbols: [],
-            isTypeOnly: false,
-            isDynamic: false,
-            line: 0
+    if (ctx.learned) {
+      const coEdits = ctx.learned.coEdits.filter((p) => p.files[0].includes(shortName(filePath)) || p.files[1].includes(shortName(filePath))).slice(0, 3);
+      if (coEdits.length > 0) {
+        for (const pair of coEdits) {
+          const other = pair.files[0].includes(shortName(filePath)) ? pair.files[1] : pair.files[0];
+          relatedFiles.push({
+            filePath: other,
+            reason: `Often edited together (${pair.count} times)`,
+            relationship: "co-edited",
+            confidence: pair.weight
           });
         }
       }
     }
-    return imports;
-  }
-  extractImportedSymbols(importLine) {
-    const braceMatch = importLine.match(/\{([^}]+)\}/);
-    if (!braceMatch) {
-      const defaultMatch = importLine.match(/import\s+(?:type\s+)?(\w+)\s+from/);
-      return defaultMatch?.[1] ? [defaultMatch[1]] : [];
+    if (fc && fc.editGuidance.length > 0) {
+      paragraphs.push({
+        heading: "Edit Guidance",
+        text: fc.editGuidance.join(" "),
+        importance: "medium"
+      });
     }
-    return braceMatch[1].split(",").map((s) => {
-      const parts = s.trim().split(/\s+as\s+/);
-      return parts[parts.length - 1].trim();
-    }).filter(Boolean);
+    return {
+      filePath,
+      roleSummary,
+      paragraphs,
+      quickFacts,
+      warnings,
+      relatedFiles,
+      overlays
+    };
   }
-  resolveImportPath(sourcePath, fromFile) {
-    if (!sourcePath.startsWith(".")) return sourcePath;
-    const dir = dirname(fromFile);
-    const resolved = resolve(dir, sourcePath);
-    const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
-    for (const ext2 of extensions) {
-      const candidate = resolved + ext2;
-      try {
-        accessSync(candidate);
-        return candidate;
-      } catch {
+  /**
+   * Generate a compact markdown explanation for AI agent consumption.
+   */
+  explainForAgent(filePath, ctx) {
+    const explanation = this.explain(filePath, ctx);
+    const lines = [];
+    lines.push(`## ${shortName(filePath)}: ${explanation.roleSummary}`);
+    lines.push("");
+    if (explanation.quickFacts.length > 0) {
+      lines.push(explanation.quickFacts.map((f) => `**${f.label}**: ${f.value}`).join(" \xB7 "));
+      lines.push("");
+    }
+    for (const p of explanation.paragraphs.filter((p2) => p2.importance === "critical" || p2.importance === "high")) {
+      lines.push(`### ${p.heading}`);
+      lines.push(p.text);
+      lines.push("");
+    }
+    if (explanation.warnings.length > 0) {
+      lines.push("### Warnings");
+      for (const w of explanation.warnings) {
+        const icon = w.severity === "error" ? "MUST FIX" : w.severity === "warning" ? "SHOULD FIX" : "NOTE";
+        lines.push(`- **[${icon}]** ${w.message} \u2014 ${w.action}`);
       }
+      lines.push("");
     }
-    return resolved;
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CALL EDGES (basic extraction)
-  // ═══════════════════════════════════════════════════════════════════════════
-  extractCallEdges(content, symbols, filePath) {
-    const edges = [];
-    const functionNames = new Set(symbols.filter((s) => s.kind === "function" || s.kind === "method").map((s) => s.name));
-    for (const caller of symbols) {
-      if (caller.kind !== "function" && caller.kind !== "method") continue;
-      const body = content.split("\n").slice(caller.startLine - 1, caller.endLine).join("\n");
-      for (const calleeName of functionNames) {
-        if (calleeName === caller.name) continue;
-        const callRe = new RegExp(`\\b${calleeName}\\s*\\(`, "g");
-        if (callRe.test(body)) {
-          const callee = symbols.find((s) => s.name === calleeName);
-          if (callee) {
-            edges.push({
-              callerId: caller.id,
-              calleeId: callee.id,
-              callerName: caller.name,
-              calleeName: callee.name,
-              callerFile: filePath,
-              calleeFile: filePath
-            });
-          }
-        }
+    if (explanation.relatedFiles.length > 0) {
+      lines.push("### Related Files");
+      for (const rf of explanation.relatedFiles.slice(0, 5)) {
+        lines.push(`- \`${rf.filePath}\` \u2014 ${rf.reason}`);
       }
+      lines.push("");
     }
-    return edges;
+    return lines.join("\n");
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // HELPERS
-  // ═══════════════════════════════════════════════════════════════════════════
-  isExported(content, name, language) {
-    if (language === "python") return true;
-    const re = new RegExp(`export\\s+(?:default\\s+)?(?:async\\s+)?(?:function|class|const|let|var|type|interface|enum)\\s+${name}\\b`);
-    if (re.test(content)) return true;
-    const reExport = new RegExp(`export\\s+\\{[^}]*\\b${name}\\b[^}]*\\}`);
-    return reExport.test(content);
-  }
-  countParams(signature) {
-    const parenMatch = signature.match(/\(([^)]*)\)/);
-    if (!parenMatch || !parenMatch[1].trim()) return 0;
-    return parenMatch[1].split(",").length;
-  }
-  countBranches(lines, startIdx, endIdx) {
-    let branches = 0;
-    const branchRe = /\b(if|else if|case|for|while|catch|&&|\|\||\?\?)\b/g;
-    for (let i = startIdx; i < Math.min(endIdx, lines.length); i++) {
-      const matches = lines[i].match(branchRe);
-      if (matches) branches += matches.length;
-    }
-    return branches;
-  }
-  findBlockEnd(lines, startIdx) {
-    let depth = 0;
-    let seenOpen = false;
-    for (let i = startIdx; i < lines.length; i++) {
-      for (const ch of lines[i]) {
-        if (ch === "{") {
-          depth++;
-          seenOpen = true;
-        } else if (ch === "}" && seenOpen) {
-          depth--;
-          if (depth <= 0) return i + 1;
-        }
-      }
-    }
-    return startIdx + 1;
-  }
-};
-function mapTreeSitterKind(kind) {
-  const map = {
-    function: "function",
-    method: "method",
-    class: "class",
-    interface: "interface",
-    type: "type",
-    enum: "enum",
-    const: "variable",
-    variable: "variable",
-    struct: "class",
-    trait: "interface",
-    export: "variable"
-  };
-  return map[kind] ?? "function";
-}
-function flattenCodeSymbols(symbols) {
-  const flat = [];
-  for (const sym of symbols) {
-    flat.push({ name: sym.name, kind: sym.kind, line: sym.line, endLine: sym.endLine, signature: sym.signature });
-    if (sym.children && Array.isArray(sym.children)) {
-      flat.push(...flattenCodeSymbols(sym.children));
-    }
-  }
-  return flat;
-}
-var ContextSynthesizer = class {
-  rootPath;
-  data;
-  dna;
-  graph;
-  ruleResult;
-  constructor(rootPath, data, dna, graph, ruleResult) {
-    this.rootPath = rootPath;
-    this.data = data;
-    this.dna = dna;
-    this.graph = graph;
-    this.ruleResult = ruleResult || null;
-  }
-  /**
-   * Synthesize the full context — the complete brain dump for AI agents.
-   */
-  synthesize() {
-    const projectIdentity = this.buildProjectIdentity();
-    const archRules = this.buildArchRuleSummary();
-    const activeViolations = this.ruleResult?.violations || [];
-    const codebaseDNA = this.buildDNASummary();
-    const fileContexts = this.buildFileContexts();
-    const taskPlaybooks = this.buildTaskPlaybooks();
-    const verificationSteps = this.buildVerificationSteps();
-    const riskBriefing = this.buildRiskBriefing();
-    return {
-      version: "2.0.0",
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectIdentity,
-      architecturalRules: archRules,
-      activeViolations,
-      codebaseDNA,
-      fileContexts,
-      taskPlaybooks,
-      verificationSteps,
-      riskBriefing
-    };
-  }
-  /**
-   * Generate context for a specific file — what an AI agent needs to know
-   * before editing this file.
-   */
-  synthesizeForFile(filePath) {
-    const rel = this.toRelative(filePath);
-    const file = this.data.files.find((f) => f.relativePath === rel || f.path === filePath);
-    if (!file) return null;
-    return this.buildSingleFileContext(file);
+  /**
+   * Generate IDE overlay data for the VS Code extension to consume.
+   */
+  getIDEOverlays(filePath, ctx) {
+    const explanation = this.explain(filePath, ctx);
+    return explanation.overlays;
   }
   /**
-   * Generate a compact markdown context document for IDE rules.
-   * This replaces the old static rule generation with intelligence-driven context.
+   * Generate a health report explanation.
    */
-  generateContextDocument() {
-    const ctx = this.synthesize();
+  explainHealth(health, dna) {
     const lines = [];
-    lines.push(`# ${ctx.projectIdentity.name} \u2014 AI Context`);
-    lines.push(`<!-- Generated by @repo/context-engine at ${ctx.generatedAt} -->`);
-    lines.push("");
-    lines.push("## Project Identity");
-    lines.push(`- **Stack**: ${ctx.projectIdentity.stack}`);
-    lines.push(`- **Architecture**: ${ctx.projectIdentity.architecture}`);
-    if (ctx.projectIdentity.keyPatterns.length > 0) {
-      lines.push(`- **Key Patterns**: ${ctx.projectIdentity.keyPatterns.join(", ")}`);
-    }
+    const dims = health.dimensions;
+    lines.push(`## Codebase Health: ${health.overall}/100`);
     lines.push("");
-    if (ctx.codebaseDNA.conventions.length > 0) {
-      lines.push("## Conventions (Auto-Discovered)");
-      for (const conv of ctx.codebaseDNA.conventions) {
-        lines.push(`- ${conv}`);
-      }
-      lines.push("");
-    }
-    if (ctx.architecturalRules.length > 0) {
-      lines.push("## Architecture Rules");
-      for (const rule of ctx.architecturalRules) {
-        const icon = rule.severity === "error" ? "MUST" : rule.severity === "warning" ? "SHOULD" : "MAY";
-        lines.push(`- **[${icon}]** ${rule.name}: ${rule.description}`);
-        if (rule.violationCount > 0) {
-          lines.push(`  - ${rule.violationCount} active violations`);
-        }
-      }
-      lines.push("");
-    }
-    if (ctx.codebaseDNA.boundaries.length > 0) {
-      lines.push("## Module Boundaries");
-      for (const boundary of ctx.codebaseDNA.boundaries) {
-        lines.push(`- ${boundary}`);
-      }
-      lines.push("");
-    }
-    if (ctx.codebaseDNA.hotFiles.length > 0) {
-      lines.push("## High-Impact Files (Edit With Care)");
-      for (const file of ctx.codebaseDNA.hotFiles.slice(0, 10)) {
-        lines.push(`- \`${file}\``);
-      }
-      lines.push("");
-    }
-    if (ctx.riskBriefing.securityConcerns.length > 0 || ctx.riskBriefing.testGaps.length > 0) {
-      lines.push("## Risk Areas");
-      for (const concern of ctx.riskBriefing.securityConcerns) {
-        lines.push(`- ${concern}`);
-      }
-      for (const gap of ctx.riskBriefing.testGaps.slice(0, 5)) {
-        lines.push(`- ${gap}`);
-      }
-      lines.push("");
-    }
-    if (ctx.projectIdentity.noGoZones.length > 0) {
-      lines.push("## No-Go Zones");
-      for (const zone of ctx.projectIdentity.noGoZones) {
-        lines.push(`- ${zone}`);
-      }
-      lines.push("");
-    }
-    if (ctx.taskPlaybooks.length > 0) {
-      lines.push("## Task Playbooks");
-      for (const playbook of ctx.taskPlaybooks) {
-        lines.push(`### ${playbook.taskType}`);
-        for (const step of playbook.steps) {
-          lines.push(`1. ${step}`);
-        }
-        if (playbook.mustVerify.length > 0) {
-          lines.push(`**Verify**: ${playbook.mustVerify.join(", ")}`);
-        }
-        lines.push("");
-      }
-    }
-    if (ctx.verificationSteps.length > 0) {
-      lines.push("## Verification Protocol");
-      for (const step of ctx.verificationSteps) {
-        lines.push(`### On ${step.trigger}`);
-        for (const check of step.checks) {
-          lines.push(`- ${check}`);
-        }
-        if (step.commands.length > 0) {
-          lines.push(`**Run**: \`${step.commands.join(" && ")}\``);
-        }
-        lines.push("");
-      }
+    const entries = [
+      { name: "Architecture", score: dims.architecture, explain: this.explainArchScore(dims.architecture, dna) },
+      { name: "Test Coverage", score: dims.testCoverage, explain: this.explainTestScore(dims.testCoverage) },
+      { name: "Conventions", score: dims.conventions, explain: this.explainConventionScore(dims.conventions, dna) },
+      { name: "Dependencies", score: dims.dependencies, explain: this.explainDependencyScore(dims.dependencies, dna) },
+      { name: "Security", score: dims.security, explain: dims.security >= 80 ? "No critical security concerns detected" : "Critical risk areas identified" },
+      { name: "Complexity", score: dims.complexity, explain: dims.complexity >= 80 ? "Complexity is well-managed" : "High-complexity hotspots detected" }
+    ];
+    for (const entry of entries) {
+      const bar = this.renderBar(entry.score);
+      lines.push(`${bar} **${entry.name}**: ${entry.score}/100 \u2014 ${entry.explain}`);
     }
-    lines.push("## Codebase Health");
-    lines.push(`- **Overall**: ${this.dna.healthScore.overall}/100`);
-    const dims = this.dna.healthScore.dimensions;
-    lines.push(`- Architecture: ${dims.architecture} | Tests: ${dims.testCoverage} | Conventions: ${dims.conventions} | Dependencies: ${dims.dependencies}`);
-    lines.push("");
-    lines.push("---");
-    lines.push("<!-- context-engine:v2 -->");
     return lines.join("\n");
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // IDENTITY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildProjectIdentity() {
-    const fp = this.dna.fingerprint;
-    const stack = [fp.framework, fp.language, fp.orm, fp.validator, fp.authLib, fp.router].filter(Boolean).join(" | ");
-    const keyPatterns = this.dna.patterns.map((p) => p.name);
-    const criticalPaths = this.dna.hotspots.slice(0, 5).map((h) => h.file);
-    const noGoZones = [];
-    if (this.ruleResult) {
-      const errorRules = this.ruleResult.violations.filter((v) => v.severity === "error");
-      const uniqueMessages = [...new Set(errorRules.map((v) => v.message))];
-      noGoZones.push(...uniqueMessages.slice(0, 5));
-    }
-    for (const cycle of this.graph.cycles) {
-      noGoZones.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}...`);
-    }
-    const architecture = this.dna.conventions.filter((c) => c.area === "structure").map((c) => c.description).join("; ") || fp.framework;
-    return {
-      name: fp.name,
-      stack,
-      architecture,
-      keyPatterns,
-      criticalPaths,
-      noGoZones: noGoZones.slice(0, 10)
-    };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // RULES SUMMARY
+  // PRIVATE
   // ═══════════════════════════════════════════════════════════════════════════
-  buildArchRuleSummary() {
-    if (!this.ruleResult) return [];
-    const breakdown = this.ruleResult.ruleBreakdown;
-    return Object.entries(breakdown).map(([ruleId, count]) => {
-      const violation = this.ruleResult.violations.find((v) => v.ruleId === ruleId);
-      return {
-        id: ruleId,
-        name: violation?.ruleName || ruleId,
-        type: "import_forbidden",
-        severity: violation?.severity || "warning",
-        scope: violation?.sourceSymbol.filePath || "",
-        description: violation?.message || "",
-        violationCount: count
-      };
-    });
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // DNA SUMMARY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildDNASummary() {
-    return {
-      conventions: this.dna.conventions.filter((c) => c.confidence > 0.5).map((c) => c.description),
-      patterns: this.dna.patterns.map((p) => `${p.name}: ${p.description}`),
-      boundaries: this.dna.boundaries.filter((b) => b.importCount > 3).map((b) => `${b.from} \u2192 ${b.to} (${b.importCount} imports${b.isCircular ? ", CIRCULAR" : ""})`),
-      hotFiles: this.dna.hotspots.slice(0, 10).map((h) => h.file),
-      riskAreas: this.dna.riskMap.filter((r) => r.riskLevel === "critical" || r.riskLevel === "high").map((r) => `${r.file}: ${r.factors[0]}`)
-    };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // FILE CONTEXTS
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildFileContexts() {
-    const contexts = /* @__PURE__ */ new Map();
-    for (const file of this.data.files) {
-      contexts.set(file.relativePath, this.buildSingleFileContext(file));
-    }
-    return contexts;
-  }
-  buildSingleFileContext(file) {
-    const rel = file.relativePath;
-    const role = this.classifyRole(file);
-    const graphNode = this.graph.nodes.find((n) => n.relativePath === rel);
-    const layer = graphNode?.layer;
-    const dependsOn = this.graph.edges.filter((e) => e.from === rel).map((e) => e.to);
-    const dependedOnBy = this.graph.edges.filter((e) => e.to === rel).map((e) => e.from);
-    const applicableRules = [];
-    if (this.ruleResult) {
-      for (const v of this.ruleResult.violations) {
-        if (v.sourceSymbol.filePath.includes(rel) || v.targetSymbol && v.targetSymbol.filePath.includes(rel)) {
-          if (!applicableRules.includes(v.ruleId)) applicableRules.push(v.ruleId);
-        }
-      }
-    }
-    const conventions = this.dna.conventions.filter((c) => this.conventionAppliesToFile(c.area, file)).map((c) => c.description);
-    const patterns = this.dna.patterns.filter((p) => p.fileMatches.some((m) => m === rel)).map((p) => p.name);
-    const riskEntry = this.dna.riskMap.find((r) => r.file === rel);
-    const riskLevel = riskEntry?.riskLevel || "low";
-    const relatedFiles = this.findRelatedFiles(file, role).slice(0, 8);
-    const editGuidance = this.generateEditGuidance(file, role, layer, dependedOnBy, conventions);
-    return {
-      filePath: file.path,
-      role,
-      layer,
-      dependsOn,
-      dependedOnBy,
-      applicableRules,
-      conventions,
-      patterns,
-      riskLevel,
-      relatedFiles,
-      editGuidance
-    };
-  }
-  classifyRole(file) {
-    const rel = file.relativePath.toLowerCase();
-    if (rel.includes(".test.") || rel.includes(".spec.") || rel.includes("__tests__")) return "test";
-    if (rel.includes("fixture") || rel.includes("mock")) return "fixture";
-    if (rel.includes("migration")) return "migration";
-    if (rel.match(/\.(css|scss|less|styl)$/)) return "style";
-    if (rel.includes(".config.") || rel.includes("config/") || rel === "tsconfig.json") return "config";
-    if (rel.includes("middleware")) return "middleware";
-    if (rel.includes("/api/") || rel.includes("route")) return "route-handler";
-    if (rel.includes("service") || rel.includes("Service")) return "service";
-    if (rel.includes("repositor") || rel.includes("Repositor")) return "repository";
-    if (rel.endsWith(".tsx") && !rel.includes("page.")) return "component";
-    if (rel.includes("/types") || rel.endsWith(".d.ts")) return "type";
-    if (rel.includes("util") || rel.includes("helper") || rel.includes("lib/")) return "util";
-    if (rel.includes("script") || rel.includes("bin/")) return "script";
-    if (rel.match(/^(src\/)?index\.|^(src\/)?main\.|^(src\/)?app\./)) return "entry";
-    return "unknown";
-  }
-  conventionAppliesToFile(area, file) {
-    switch (area) {
-      case "naming":
-        return true;
-      case "imports":
-        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
-      case "exports":
-        return file.exports.length > 0;
-      case "testing":
-        return file.relativePath.includes(".test.") || file.relativePath.includes(".spec.");
-      case "error-handling":
-        return !file.relativePath.includes(".test.");
-      case "types":
-        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
-      default:
-        return true;
-    }
-  }
-  findRelatedFiles(file, role) {
-    const related = [];
-    const dir = path2.dirname(file.relativePath);
-    for (const other of this.data.files) {
-      if (other.path === file.path) continue;
-      if (path2.dirname(other.relativePath) === dir) {
-        related.push(other.relativePath);
-      }
-    }
-    if (related.length < 5) {
-      for (const other of this.data.files) {
-        if (other.path === file.path) continue;
-        if (related.includes(other.relativePath)) continue;
-        if (this.classifyRole(other) === role) {
-          related.push(other.relativePath);
-          if (related.length >= 8) break;
-        }
-      }
-    }
-    return related;
-  }
-  generateEditGuidance(file, role, layer, dependedOnBy, conventions) {
-    const guidance = [];
-    if (dependedOnBy.length > 10) {
-      guidance.push(`HIGH IMPACT: ${dependedOnBy.length} files depend on this. Changes have wide blast radius.`);
-    }
+  buildRoleSummary(filePath, role, ctx) {
+    const parts = [];
     switch (role) {
-      case "route-handler":
-        guidance.push("Validate all inputs with schemas before processing.");
-        guidance.push("Return consistent response shapes ({ success, data } or { success, error }).");
-        guidance.push("Ensure authentication middleware is applied to protected endpoints.");
-        break;
       case "service":
-        guidance.push("Keep business logic here, not in controllers/routes.");
-        guidance.push("Use dependency injection for testability.");
-        if (layer) guidance.push(`This is in the ${layer} layer \u2014 only import from lower layers.`);
+        parts.push("Business logic service");
         break;
-      case "repository":
-        guidance.push("Only data access logic belongs here \u2014 no business rules.");
-        guidance.push("Return domain objects, not raw database rows.");
+      case "route-handler":
+        parts.push("API route handler");
         break;
       case "component":
-        guidance.push("Keep components focused and composable.");
-        guidance.push("Extract complex logic to custom hooks.");
+        parts.push("UI component");
+        break;
+      case "repository":
+        parts.push("Data access layer");
         break;
       case "middleware":
-        guidance.push("Middleware must call next() or return a response \u2014 never leave the request hanging.");
-        guidance.push("Keep middleware focused on a single concern.");
+        parts.push("Request middleware");
         break;
       case "test":
-        guidance.push("Follow Arrange-Act-Assert pattern.");
-        guidance.push("Test edge cases and error conditions, not just happy path.");
+        parts.push("Test file");
+        break;
+      case "config":
+        parts.push("Configuration");
+        break;
+      case "type":
+        parts.push("Type definitions");
+        break;
+      case "util":
+        parts.push("Utility module");
+        break;
+      case "entry":
+        parts.push("Entry point");
         break;
+      default:
+        parts.push("Source file");
     }
-    for (const conv of conventions.slice(0, 3)) {
-      guidance.push(`Convention: ${conv}`);
+    if (ctx.fileContext) {
+      if (ctx.fileContext.layer) parts.push(`in ${ctx.fileContext.layer} layer`);
+      if (ctx.fileContext.dependedOnBy.length > 10) parts.push("(high-impact)");
     }
-    return guidance;
+    return parts.join(" ");
+  }
+  explainArchScore(score, dna) {
+    if (score >= 80) return `Strong architecture with ${dna.patterns.length} recognized patterns`;
+    if (score >= 50) return `Moderate architecture \u2014 ${dna.patterns.length} patterns detected, room to strengthen boundaries`;
+    return "Architecture needs attention \u2014 few recognized patterns or boundaries";
+  }
+  explainTestScore(score) {
+    if (score >= 80) return "Good test coverage across source files";
+    if (score >= 50) return "Moderate coverage \u2014 some source files lack tests";
+    return "Low test coverage \u2014 many exported modules have no test files";
+  }
+  explainConventionScore(score, dna) {
+    const strong = dna.conventions.filter((c) => c.confidence > 0.6).length;
+    if (score >= 80) return `${strong} strong conventions enforced consistently`;
+    if (score >= 50) return `${strong} conventions detected but inconsistently applied`;
+    return "Few consistent conventions \u2014 codebase style varies across files";
+  }
+  explainDependencyScore(score, dna) {
+    const circular = dna.boundaries.filter((b) => b.isCircular).length;
+    if (score >= 80) return "Clean dependency graph with no circular dependencies";
+    if (circular > 0) return `${circular} circular dependency${circular > 1 ? "ies" : "y"} detected \u2014 these increase coupling and make code harder to reason about`;
+    return "Dependency health needs improvement";
+  }
+  renderBar(score) {
+    const filled = Math.round(score / 10);
+    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  }
+};
+function shortName(filePath) {
+  const parts = filePath.split("/");
+  return parts[parts.length - 1] ?? filePath;
+}
+
+// ../context-engine/dist/chunk-HMKLYBWJ.js
+var import_better_sqlite3 = __toESM(require_lib(), 1);
+var import_fast_glob2 = __toESM(require_out4(), 1);
+var SCHEMA_VERSION = 1;
+var PersistentIndex = class {
+  db;
+  config;
+  rootPath;
+  constructor(config) {
+    this.rootPath = config.rootPath;
+    this.config = {
+      rootPath: config.rootPath,
+      dbPath: config.dbPath ?? join(config.rootPath, ".vibecheck", "index.db"),
+      includePatterns: config.includePatterns ?? ["**/*.{ts,tsx,js,jsx,py,rs,go,java,c,cpp,h,hpp,rb,swift,kt,lua,zig}"],
+      excludePatterns: config.excludePatterns ?? [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.next/**",
+        "**/.git/**",
+        "**/coverage/**",
+        "**/.turbo/**",
+        "**/__pycache__/**",
+        "**/target/**",
+        "**/.mcp_data/**"
+      ],
+      maxFileSize: config.maxFileSize ?? 5e5,
+      maxFiles: config.maxFiles ?? 1e4,
+      storeContent: config.storeContent ?? true
+    };
+    const dbDir = join(this.config.dbPath, "..");
+    mkdirSync(dbDir, { recursive: true });
+    this.db = new import_better_sqlite3.default(this.config.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("cache_size = -64000");
+    this.initSchema();
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // TASK PLAYBOOKS
+  // SCHEMA
   // ═══════════════════════════════════════════════════════════════════════════
-  buildTaskPlaybooks() {
-    const fp = this.dna.fingerprint;
-    const playbooks = [];
-    playbooks.push({
-      taskType: "Bug Fix",
-      steps: [
-        "Reproduce the bug and understand the expected vs actual behavior",
-        "Identify the root cause file(s) using the dependency graph",
-        "Write a failing test that reproduces the bug",
-        "Apply the minimal fix at the root cause",
-        "Verify the fix passes the test and does not break existing tests",
-        "Check that the fix does not violate any architecture rules"
-      ],
-      mustRead: this.dna.hotspots.slice(0, 3).map((h) => h.file),
-      mustUpdate: ["The buggy file", "Related test file"],
-      mustVerify: ["All existing tests pass", "New regression test passes", "No new arch rule violations"],
-      stopConditions: ["Never modify tests to make them pass \u2014 fix the code", "Do not change public API signatures without discussion"]
+  initSchema() {
+    const version = this.getSchemaVersion();
+    if (version === SCHEMA_VERSION) return;
+    this.db.exec(`
+      DROP TABLE IF EXISTS file_hashes;
+      DROP TABLE IF EXISTS files;
+      DROP TABLE IF EXISTS symbols;
+      DROP TABLE IF EXISTS imports;
+      DROP TABLE IF EXISTS call_edges;
+      DROP TABLE IF EXISTS routes;
+      DROP TABLE IF EXISTS services;
+      DROP TABLE IF EXISTS embeddings;
+      DROP TABLE IF EXISTS meta;
+
+      CREATE TABLE meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE file_hashes (
+        relative_path TEXT PRIMARY KEY,
+        content_hash  TEXT NOT NULL,
+        size_bytes    INTEGER NOT NULL,
+        modified_ms   INTEGER NOT NULL,
+        indexed_at    INTEGER NOT NULL DEFAULT (unixepoch('now'))
+      );
+
+      CREATE TABLE files (
+        id            TEXT PRIMARY KEY,
+        path          TEXT NOT NULL,
+        relative_path TEXT NOT NULL UNIQUE,
+        language      TEXT NOT NULL,
+        line_count    INTEGER NOT NULL,
+        exports       TEXT NOT NULL DEFAULT '[]',
+        content       TEXT
+      );
+
+      CREATE TABLE symbols (
+        id         TEXT PRIMARY KEY,
+        name       TEXT NOT NULL,
+        kind       TEXT NOT NULL,
+        file_path  TEXT NOT NULL,
+        start_line INTEGER NOT NULL,
+        end_line   INTEGER NOT NULL,
+        exported   INTEGER NOT NULL DEFAULT 0,
+        async      INTEGER NOT NULL DEFAULT 0,
+        params     INTEGER,
+        branches   INTEGER,
+        signature  TEXT
+      );
+
+      CREATE TABLE imports (
+        id               INTEGER PRIMARY KEY AUTOINCREMENT,
+        file_id          TEXT NOT NULL,
+        file_path        TEXT NOT NULL,
+        source_path      TEXT NOT NULL,
+        resolved_path    TEXT NOT NULL DEFAULT '',
+        imported_symbols TEXT NOT NULL DEFAULT '[]',
+        is_type_only     INTEGER NOT NULL DEFAULT 0,
+        is_dynamic       INTEGER NOT NULL DEFAULT 0,
+        line             INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE TABLE call_edges (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        caller_id   TEXT NOT NULL,
+        callee_id   TEXT NOT NULL,
+        caller_name TEXT NOT NULL,
+        callee_name TEXT NOT NULL,
+        caller_file TEXT NOT NULL,
+        callee_file TEXT NOT NULL
+      );
+
+      CREATE TABLE routes (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        path       TEXT NOT NULL,
+        method     TEXT NOT NULL,
+        handler    TEXT NOT NULL,
+        file       TEXT NOT NULL,
+        line       INTEGER NOT NULL DEFAULT 0,
+        middleware TEXT NOT NULL DEFAULT '[]',
+        auth       INTEGER
+      );
+
+      CREATE TABLE services (
+        id        TEXT PRIMARY KEY,
+        name      TEXT NOT NULL,
+        root_path TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE embeddings (
+        path         TEXT NOT NULL,
+        chunk_id     TEXT NOT NULL,
+        chunk_type   TEXT NOT NULL DEFAULT 'file',
+        content_hash TEXT NOT NULL,
+        vector       BLOB NOT NULL,
+        metadata     TEXT NOT NULL DEFAULT '{}',
+        PRIMARY KEY (path, chunk_id)
+      );
+
+      -- Indexes for fast lookups
+      CREATE INDEX idx_symbols_file ON symbols(file_path);
+      CREATE INDEX idx_symbols_name ON symbols(name);
+      CREATE INDEX idx_symbols_kind ON symbols(kind);
+      CREATE INDEX idx_imports_file ON imports(file_path);
+      CREATE INDEX idx_imports_source ON imports(source_path);
+      CREATE INDEX idx_imports_resolved ON imports(resolved_path);
+      CREATE INDEX idx_call_edges_caller ON call_edges(caller_file);
+      CREATE INDEX idx_call_edges_callee ON call_edges(callee_file);
+      CREATE INDEX idx_embeddings_type ON embeddings(chunk_type);
+    `);
+    this.setMeta("schema_version", String(SCHEMA_VERSION));
+    this.setMeta("created_at", (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getSchemaVersion() {
+    try {
+      const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get("schema_version");
+      return row ? Number.parseInt(row.value, 10) : 0;
+    } catch {
+      return 0;
+    }
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // INCREMENTAL INDEXING
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Discover files, diff against stored hashes, return only changed files.
+   */
+  async diffFiles() {
+    const discoveredFiles = await this.discoverFiles();
+    const storedHashes = this.getStoredHashes();
+    const changed = [];
+    const unchanged = [];
+    const currentPaths = /* @__PURE__ */ new Set();
+    for (const file of discoveredFiles) {
+      currentPaths.add(file.relativePath);
+      const stored = storedHashes.get(file.relativePath);
+      if (!stored || stored.contentHash !== file.contentHash) {
+        changed.push(file.relativePath);
+      } else {
+        unchanged.push(file.relativePath);
+      }
+    }
+    const deleted = [];
+    for (const storedPath of storedHashes.keys()) {
+      if (!currentPaths.has(storedPath)) {
+        deleted.push(storedPath);
+      }
+    }
+    return { changed, deleted, unchanged };
+  }
+  /**
+   * Full reindex — scan all files and store data.
+   * Returns parsed CodebaseData + stats.
+   */
+  async reindex(parser4) {
+    const startMs = Date.now();
+    const { changed, deleted, unchanged } = await this.diffFiles();
+    if (deleted.length > 0) {
+      this.removeFiles(deleted);
+    }
+    const parsedFiles = [];
+    for (const relPath of changed) {
+      const absPath = join(this.rootPath, relPath);
+      try {
+        const parsed = await parser4.parseFile(absPath, relPath);
+        parsedFiles.push(parsed);
+      } catch {
+      }
+    }
+    this.storeFiles(parsedFiles);
+    const data = this.loadCodebaseData();
+    const stats = {
+      totalFiles: data.files.length,
+      totalSymbols: data.symbols.length,
+      totalImports: data.imports.length,
+      indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reindexedFiles: changed.length,
+      skippedFiles: unchanged.length,
+      durationMs: Date.now() - startMs
+    };
+    this.setMeta("last_index_at", stats.indexedAt);
+    this.setMeta("last_index_stats", JSON.stringify(stats));
+    return { data, stats };
+  }
+  /**
+   * Incremental update — only reindex specific files.
+   */
+  async reindexFiles(relativePaths, parser4) {
+    const startMs = Date.now();
+    this.removeFiles(relativePaths);
+    const parsedFiles = [];
+    for (const relPath of relativePaths) {
+      const absPath = join(this.rootPath, relPath);
+      try {
+        const parsed = await parser4.parseFile(absPath, relPath);
+        parsedFiles.push(parsed);
+      } catch {
+      }
+    }
+    this.storeFiles(parsedFiles);
+    const totalFiles = this.db.prepare("SELECT COUNT(*) as cnt FROM files").get();
+    const totalSymbols = this.db.prepare("SELECT COUNT(*) as cnt FROM symbols").get();
+    const totalImports = this.db.prepare("SELECT COUNT(*) as cnt FROM imports").get();
+    return {
+      totalFiles: totalFiles.cnt,
+      totalSymbols: totalSymbols.cnt,
+      totalImports: totalImports.cnt,
+      indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reindexedFiles: parsedFiles.length,
+      skippedFiles: 0,
+      durationMs: Date.now() - startMs
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DATA LOADING (warm start)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Load full CodebaseData from the persistent store.
+   * This is the warm-start path — sub-second for indexed repos.
+   */
+  loadCodebaseData() {
+    const files = this.loadFiles();
+    const symbols = this.loadSymbols();
+    const imports = this.loadImports();
+    const callEdges = this.loadCallEdges();
+    const routes = this.loadRoutes();
+    const services = this.loadServices();
+    return { files, symbols, imports, callEdges, routes, services };
+  }
+  /**
+   * Check if the index exists and has data.
+   */
+  isPopulated() {
+    try {
+      const row = this.db.prepare("SELECT COUNT(*) as cnt FROM files").get();
+      return row.cnt > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the last index timestamp.
+   */
+  getLastIndexedAt() {
+    return this.getMeta("last_index_at");
+  }
+  /**
+   * Get the last index stats.
+   */
+  getLastIndexStats() {
+    const raw = this.getMeta("last_index_stats");
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // EMBEDDING STORAGE
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Store a chunk embedding (file-level, function-level, etc.)
+   */
+  storeEmbedding(path10, chunkId, chunkType, contentHash, vector, metadata) {
+    const vectorBuf = Buffer.from(new Float32Array(vector).buffer);
+    this.db.prepare(`
+      INSERT OR REPLACE INTO embeddings (path, chunk_id, chunk_type, content_hash, vector, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(path10, chunkId, chunkType, contentHash, vectorBuf, JSON.stringify(metadata ?? {}));
+  }
+  /**
+   * Load embedding for a specific chunk.
+   */
+  loadEmbedding(path10, chunkId) {
+    const row = this.db.prepare("SELECT vector, content_hash, metadata FROM embeddings WHERE path = ? AND chunk_id = ?").get(path10, chunkId);
+    if (!row) return null;
+    return {
+      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
+      contentHash: row.content_hash,
+      metadata: JSON.parse(row.metadata)
+    };
+  }
+  /**
+   * Load all embeddings of a given type for vector search.
+   */
+  loadEmbeddingsByType(chunkType) {
+    const rows = this.db.prepare("SELECT path, chunk_id, vector, content_hash, metadata FROM embeddings WHERE chunk_type = ?").all(chunkType);
+    return rows.map((row) => ({
+      path: row.path,
+      chunkId: row.chunk_id,
+      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
+      contentHash: row.content_hash,
+      metadata: JSON.parse(row.metadata)
+    }));
+  }
+  /**
+   * Remove stale embeddings for files no longer in the index.
+   */
+  pruneStaleEmbeddings() {
+    const result = this.db.prepare(`
+      DELETE FROM embeddings WHERE path NOT IN (SELECT relative_path FROM files)
+    `).run();
+    return result.changes;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // QUERYING
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Get all symbols in a specific file.
+   */
+  getSymbolsForFile(filePath) {
+    return this.loadSymbolsWhere("file_path = ?", [filePath]);
+  }
+  /**
+   * Search symbols by name pattern.
+   */
+  searchSymbols(namePattern, limit = 50) {
+    return this.loadSymbolsWhere("name LIKE ?", [`%${namePattern}%`]).slice(0, limit);
+  }
+  /**
+   * Get files that import a given file.
+   */
+  getDependents(filePath) {
+    const rows = this.db.prepare("SELECT DISTINCT file_path FROM imports WHERE resolved_path = ?").all(filePath);
+    return rows.map((r) => r.file_path);
+  }
+  /**
+   * Get files that a given file imports.
+   */
+  getDependencies(filePath) {
+    const rows = this.db.prepare('SELECT DISTINCT resolved_path FROM imports WHERE file_path = ? AND resolved_path != ""').all(filePath);
+    return rows.map((r) => r.resolved_path);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CLEANUP
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Close the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Wipe all data and rebuild schema.
+   */
+  reset() {
+    this.db.exec("DROP TABLE IF EXISTS file_hashes");
+    this.db.exec("DROP TABLE IF EXISTS files");
+    this.db.exec("DROP TABLE IF EXISTS symbols");
+    this.db.exec("DROP TABLE IF EXISTS imports");
+    this.db.exec("DROP TABLE IF EXISTS call_edges");
+    this.db.exec("DROP TABLE IF EXISTS routes");
+    this.db.exec("DROP TABLE IF EXISTS services");
+    this.db.exec("DROP TABLE IF EXISTS embeddings");
+    this.db.exec("DROP TABLE IF EXISTS meta");
+    this.initSchema();
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRIVATE — File Discovery
+  // ═══════════════════════════════════════════════════════════════════════════
+  async discoverFiles() {
+    const files = await (0, import_fast_glob2.glob)(this.config.includePatterns, {
+      cwd: this.rootPath,
+      ignore: this.config.excludePatterns,
+      absolute: false,
+      dot: false,
+      onlyFiles: true
     });
-    if (fp.router) {
-      playbooks.push({
-        taskType: "Add API Endpoint",
-        steps: [
-          "Check existing routes in truthpack to avoid duplicates",
-          "Create the route handler following existing patterns",
-          "Add input validation using the project validator",
-          "Add authentication middleware if the route is protected",
-          "Write tests for success, validation failure, and auth failure",
-          "Update the truthpack (run vibecheck scan)"
-        ],
-        mustRead: ["truthpack/routes.json", ...this.dna.patterns.filter((p) => p.category === "api").map((p) => p.exemplar)],
-        mustUpdate: ["Route file", "Test file", "Truthpack"],
-        mustVerify: ["Route responds correctly", "Input validation works", "Auth is enforced", "Test passes"],
-        stopConditions: ["Do not create duplicate routes", "Do not hardcode mock data in handlers"]
-      });
+    const hashes = [];
+    const limit = this.config.maxFiles;
+    for (const relPath of files.slice(0, limit)) {
+      const absPath = join(this.rootPath, relPath);
+      try {
+        const fileStat = await stat(absPath);
+        if (fileStat.size > this.config.maxFileSize) continue;
+        const content = await readFile(absPath, "utf-8");
+        hashes.push({
+          relativePath: relPath.replace(/\\/g, "/"),
+          contentHash: hashContent2(content),
+          sizeBytes: fileStat.size,
+          modifiedMs: Math.floor(fileStat.mtimeMs)
+        });
+      } catch {
+      }
     }
-    if (fp.framework.includes("Next") || fp.framework.includes("React")) {
-      playbooks.push({
-        taskType: "Add UI Component",
-        steps: [
-          "Check if a similar component already exists",
-          "Create the component following existing naming and structure patterns",
-          "Add TypeScript props interface",
-          "Add unit test for the component",
-          "If using state, determine if it should be a client component"
-        ],
-        mustRead: this.dna.patterns.filter((p) => p.category === "ui" || p.category === "state").map((p) => p.exemplar),
-        mustUpdate: ["Component file", "Test file", "Parent component that uses it"],
-        mustVerify: ["Component renders correctly", "Props are typed", "Test passes"],
-        stopConditions: ['Do not use "any" type for props', 'Do not add useState in server components without "use client"']
+    return hashes;
+  }
+  getStoredHashes() {
+    const rows = this.db.prepare("SELECT relative_path, content_hash, size_bytes, modified_ms FROM file_hashes").all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      map.set(row.relative_path, {
+        relativePath: row.relative_path,
+        contentHash: row.content_hash,
+        sizeBytes: row.size_bytes,
+        modifiedMs: row.modified_ms
       });
     }
-    playbooks.push({
-      taskType: "Refactor",
-      steps: [
-        "Identify all callers/dependents of the code being refactored",
-        "Ensure comprehensive tests exist before refactoring",
-        "Apply changes incrementally, testing after each step",
-        "Update all dependents to use the new API",
-        "Remove old code only after all dependents are migrated",
-        "Verify no architecture rules are violated"
-      ],
-      mustRead: ["Dependency graph for affected files"],
-      mustUpdate: ["Refactored file", "All dependent files", "Tests"],
-      mustVerify: ["All tests pass", "No new violations", "No regressions"],
-      stopConditions: ["Never break existing public APIs without migration path", "Do not refactor and add features in the same change"]
+    return map;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRIVATE — Storage
+  // ═══════════════════════════════════════════════════════════════════════════
+  storeFiles(parsedFiles) {
+    if (parsedFiles.length === 0) return;
+    const insertHash = this.db.prepare(
+      "INSERT OR REPLACE INTO file_hashes (relative_path, content_hash, size_bytes, modified_ms) VALUES (?, ?, ?, ?)"
+    );
+    const insertFile = this.db.prepare(
+      "INSERT OR REPLACE INTO files (id, path, relative_path, language, line_count, exports, content) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    );
+    const insertSymbol = this.db.prepare(
+      "INSERT OR REPLACE INTO symbols (id, name, kind, file_path, start_line, end_line, exported, async, params, branches, signature) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    const insertImport = this.db.prepare(
+      "INSERT INTO imports (file_id, file_path, source_path, resolved_path, imported_symbols, is_type_only, is_dynamic, line) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    const insertCallEdge = this.db.prepare(
+      "INSERT INTO call_edges (caller_id, callee_id, caller_name, callee_name, caller_file, callee_file) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    const txn = this.db.transaction(() => {
+      for (const parsed of parsedFiles) {
+        const { file, symbols, imports, callEdges, contentHash } = parsed;
+        insertHash.run(file.relativePath, contentHash, 0, Date.now());
+        insertFile.run(
+          file.id,
+          file.path,
+          file.relativePath,
+          file.language,
+          file.lineCount,
+          JSON.stringify(file.exports),
+          this.config.storeContent ? file.content ?? null : null
+        );
+        for (const sym of symbols) {
+          insertSymbol.run(
+            sym.id,
+            sym.name,
+            sym.kind,
+            sym.filePath,
+            sym.startLine,
+            sym.endLine,
+            sym.exported ? 1 : 0,
+            sym.async ? 1 : 0,
+            sym.params ?? null,
+            sym.branches ?? null,
+            sym.signature ?? null
+          );
+        }
+        for (const imp of imports) {
+          insertImport.run(
+            imp.fileId,
+            imp.filePath,
+            imp.sourcePath,
+            imp.resolvedPath,
+            JSON.stringify(imp.importedSymbols),
+            imp.isTypeOnly ? 1 : 0,
+            imp.isDynamic ? 1 : 0,
+            imp.line
+          );
+        }
+        for (const edge of callEdges) {
+          insertCallEdge.run(
+            edge.callerId,
+            edge.calleeId,
+            edge.callerName,
+            edge.calleeName,
+            edge.callerFile,
+            edge.calleeFile
+          );
+        }
+      }
     });
-    return playbooks;
+    txn();
+  }
+  removeFiles(relativePaths) {
+    if (relativePaths.length === 0) return;
+    const txn = this.db.transaction(() => {
+      for (const relPath of relativePaths) {
+        const absPath = join(this.rootPath, relPath);
+        this.db.prepare("DELETE FROM file_hashes WHERE relative_path = ?").run(relPath);
+        this.db.prepare("DELETE FROM files WHERE relative_path = ?").run(relPath);
+        this.db.prepare("DELETE FROM symbols WHERE file_path = ? OR file_path = ?").run(absPath, relPath);
+        this.db.prepare("DELETE FROM imports WHERE file_path = ? OR file_path = ?").run(absPath, relPath);
+        this.db.prepare("DELETE FROM call_edges WHERE caller_file = ? OR callee_file = ? OR caller_file = ? OR callee_file = ?").run(absPath, absPath, relPath, relPath);
+        this.db.prepare("DELETE FROM embeddings WHERE path = ?").run(relPath);
+      }
+    });
+    txn();
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRIVATE — Loading
+  // ═══════════════════════════════════════════════════════════════════════════
+  loadFiles() {
+    const rows = this.db.prepare("SELECT id, path, relative_path, language, line_count, exports, content FROM files").all();
+    return rows.map((row) => ({
+      id: row.id,
+      path: row.path,
+      relativePath: row.relative_path,
+      language: row.language,
+      lineCount: row.line_count,
+      exports: JSON.parse(row.exports),
+      content: row.content ?? void 0
+    }));
+  }
+  loadSymbols() {
+    const rows = this.db.prepare("SELECT id, name, kind, file_path, start_line, end_line, exported, async, params, branches FROM symbols").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      exported: row.exported === 1,
+      async: row.async === 1,
+      params: row.params ?? void 0,
+      branches: row.branches ?? void 0
+    }));
+  }
+  loadSymbolsWhere(where, params) {
+    const rows = this.db.prepare(`SELECT id, name, kind, file_path, start_line, end_line, exported, async, params, branches FROM symbols WHERE ${where}`).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      kind: row.kind,
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      exported: row.exported === 1,
+      async: row.async === 1,
+      params: row.params ?? void 0,
+      branches: row.branches ?? void 0
+    }));
+  }
+  loadImports() {
+    const rows = this.db.prepare("SELECT file_id, file_path, source_path, resolved_path, imported_symbols, is_type_only, is_dynamic, line FROM imports").all();
+    return rows.map((row) => ({
+      fileId: row.file_id,
+      filePath: row.file_path,
+      sourcePath: row.source_path,
+      resolvedPath: row.resolved_path,
+      importedSymbols: JSON.parse(row.imported_symbols),
+      isTypeOnly: row.is_type_only === 1,
+      isDynamic: row.is_dynamic === 1,
+      line: row.line
+    }));
+  }
+  loadCallEdges() {
+    const rows = this.db.prepare("SELECT caller_id, callee_id, caller_name, callee_name, caller_file, callee_file FROM call_edges").all();
+    return rows.map((row) => ({
+      callerId: row.caller_id,
+      calleeId: row.callee_id,
+      callerName: row.caller_name,
+      calleeName: row.callee_name,
+      callerFile: row.caller_file,
+      calleeFile: row.callee_file
+    }));
+  }
+  loadRoutes() {
+    const rows = this.db.prepare("SELECT path, method, handler, file, line, middleware, auth FROM routes").all();
+    return rows.map((row) => ({
+      path: row.path,
+      method: row.method,
+      handler: row.handler,
+      file: row.file,
+      line: row.line,
+      middleware: JSON.parse(row.middleware),
+      auth: row.auth === null ? void 0 : row.auth === 1
+    }));
+  }
+  loadServices() {
+    const rows = this.db.prepare("SELECT id, name, root_path FROM services").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      rootPath: row.root_path
+    }));
+  }
+};
+function hashContent2(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+var EXT_LANG = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".hpp": "cpp",
+  ".rb": "ruby",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".lua": "lua",
+  ".zig": "zig",
+  ".cs": "csharp"
+};
+var TS_IMPORT_RE = /^import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+(?:\s*,\s*\{[^}]*\})?)\s+from\s+['"]([^'"]+)['"]/gm;
+var TS_IMPORT_TYPE_RE = /^import\s+type\s+/;
+var TS_DYNAMIC_IMPORT_RE = /(?:import|require)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var PY_IMPORT_RE = /^(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm;
+var GO_IMPORT_RE = /import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
+var DefaultFileParser = class {
+  rootPath;
+  treeSitterParser = null;
+  treeSitterLoaded = false;
+  constructor(rootPath) {
+    this.rootPath = rootPath;
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // VERIFICATION STEPS
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildVerificationSteps() {
-    const fp = this.dna.fingerprint;
-    const steps = [];
-    if (fp.language === "TypeScript") {
-      steps.push({
-        trigger: "Any TypeScript file change",
-        checks: ["TypeScript compilation succeeds", "No new type errors introduced"],
-        commands: [fp.packageManager === "pnpm" ? "pnpm run check-types" : "npm run check-types"],
-        artifacts: []
-      });
-    }
-    if (fp.testRunner) {
-      steps.push({
-        trigger: "Any source file change",
-        checks: ["Related tests pass", "No test regressions"],
-        commands: [`${fp.packageManager} run test`],
-        artifacts: ["test-results.json"]
-      });
-    }
-    if (fp.router) {
-      steps.push({
-        trigger: "Route handler added or modified",
-        checks: ["Route responds with correct status", "Auth middleware is applied", "Input validation works"],
-        commands: ["vibecheck scan"],
-        artifacts: ["truthpack/routes.json"]
-      });
-    }
-    steps.push({
-      trigger: "Any source file change",
-      checks: ["No new architecture rule violations", "No new circular dependencies"],
-      commands: ["vibecheck arch-rules"],
-      artifacts: []
-    });
-    return steps;
+  async parseFile(absolutePath, relativePath2) {
+    const content = await readFile(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const ext2 = extname(absolutePath).toLowerCase();
+    const language = EXT_LANG[ext2] ?? "unknown";
+    const contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+    const exports$1 = this.extractExports(content, language);
+    const symbols = await this.extractSymbols(content, lines, absolutePath, relativePath2, language);
+    const imports = this.extractImports(content, absolutePath, relativePath2, language);
+    const callEdges = this.extractCallEdges(content, symbols, absolutePath);
+    const fileId = `file:${relativePath2}`;
+    const file = {
+      id: fileId,
+      path: absolutePath,
+      relativePath: relativePath2,
+      language,
+      lineCount: lines.length,
+      exports: exports$1,
+      content
+    };
+    return { file, symbols, imports, callEdges, contentHash };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // RISK BRIEFING
+  // EXPORTS
   // ═══════════════════════════════════════════════════════════════════════════
-  buildRiskBriefing() {
-    const criticalFiles = this.dna.hotspots.filter((h) => h.score > 30).slice(0, 10).map((h) => h.file);
-    const recentViolations = this.ruleResult?.violations.filter((v) => v.severity === "error").slice(0, 10) || [];
-    const securityConcerns = [];
-    for (const risk of this.dna.riskMap) {
-      if (risk.riskLevel === "critical") {
-        securityConcerns.push(`${risk.file}: ${risk.factors.join(", ")}`);
-      }
+  extractExports(content, language) {
+    if (language !== "typescript" && language !== "javascript") return [];
+    const exports$1 = [];
+    const exportRe = /export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\s+(\w+)/g;
+    for (const match2 of content.matchAll(exportRe)) {
+      if (match2[1]) exports$1.push(match2[1]);
     }
-    const testGaps = [];
-    const sourceFiles = this.data.files.filter(
-      (f) => !f.relativePath.includes(".test.") && !f.relativePath.includes(".spec.") && (f.relativePath.endsWith(".ts") || f.relativePath.endsWith(".tsx")) && !f.relativePath.includes("config") && !f.relativePath.includes(".d.ts")
-    );
-    const testFiles = this.data.files.filter(
-      (f) => f.relativePath.includes(".test.") || f.relativePath.includes(".spec.")
-    );
-    const testedBases = new Set(testFiles.map(
-      (f) => path2.basename(f.relativePath).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, "")
-    ));
-    for (const file of sourceFiles) {
-      const baseName = path2.basename(file.relativePath).replace(/\.(ts|tsx|js|jsx)$/, "");
-      if (!testedBases.has(baseName) && file.exports.length > 0) {
-        testGaps.push(`${file.relativePath} has exports but no test file`);
-      }
+    if (/export\s+default\s/.test(content) && !exports$1.includes("default")) {
+      exports$1.push("default");
     }
-    const driftWarnings = [];
-    for (const cycle of this.graph.cycles) {
-      driftWarnings.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}${cycle.nodes.length > 3 ? "..." : ""}`);
+    const reExportRe = /export\s+\{([^}]+)\}\s+from/g;
+    for (const match2 of content.matchAll(reExportRe)) {
+      for (const sym of match2[1].split(",")) {
+        const name = sym.trim().split(/\s+as\s+/).pop()?.trim();
+        if (name) exports$1.push(name);
+      }
     }
-    return {
-      criticalFiles,
-      recentViolations,
-      securityConcerns: securityConcerns.slice(0, 5),
-      testGaps: testGaps.slice(0, 10),
-      driftWarnings: driftWarnings.slice(0, 5)
-    };
+    return [...new Set(exports$1)];
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // HELPERS
+  // SYMBOLS
   // ═══════════════════════════════════════════════════════════════════════════
-  toRelative(filePath) {
-    if (filePath.startsWith(this.rootPath)) {
-      return filePath.slice(this.rootPath.length + 1).replace(/\\/g, "/");
+  async extractSymbols(content, lines, absolutePath, relativePath2, language) {
+    const tsSymbols = await this.tryTreeSitter(content, absolutePath);
+    if (tsSymbols) {
+      return tsSymbols.map((sym, i) => ({
+        id: `sym:${relativePath2}:${sym.name}:${sym.line}`,
+        name: sym.name,
+        kind: mapTreeSitterKind(sym.kind),
+        filePath: absolutePath,
+        startLine: sym.line,
+        endLine: sym.endLine,
+        exported: this.isExported(content, sym.name, language),
+        async: sym.signature.includes("async "),
+        params: this.countParams(sym.signature),
+        branches: void 0,
+        signature: sym.signature
+      }));
     }
-    return filePath.replace(/\\/g, "/");
+    return this.extractSymbolsRegex(content, lines, absolutePath, relativePath2, language);
   }
-};
-var ContextExplainer = class {
-  /**
-   * Generate a rich explanation for a file.
-   */
-  explain(filePath, ctx) {
-    const fc = ctx.fileContext;
-    const paragraphs = [];
-    const quickFacts = [];
-    const warnings = [];
-    const relatedFiles = [];
-    const overlays = [];
-    const role = fc?.role ?? "unknown";
-    const roleSummary = this.buildRoleSummary(filePath, role, ctx);
-    if (fc) {
-      const depCount = fc.dependedOnBy.length;
-      const depsOnCount = fc.dependsOn.length;
-      if (depCount > 0 || depsOnCount > 0) {
-        const parts = [];
-        if (depCount > 0) {
-          const critical = depCount > 10 ? " \u2014 changes here have wide blast radius" : "";
-          parts.push(`${depCount} file${depCount > 1 ? "s" : ""} depend on this${critical}`);
-        }
-        if (depsOnCount > 0) {
-          parts.push(`it imports from ${depsOnCount} file${depsOnCount > 1 ? "s" : ""}`);
-        }
-        paragraphs.push({
-          heading: "Dependencies",
-          text: parts.join(". ") + ".",
-          importance: depCount > 10 ? "critical" : depCount > 5 ? "high" : "medium"
-        });
-      }
-      quickFacts.push({ label: "Role", value: role, icon: "layer" });
-      if (fc.layer) quickFacts.push({ label: "Layer", value: fc.layer, icon: "layer" });
-      quickFacts.push({ label: "Dependents", value: String(depCount), icon: "dependency" });
-      quickFacts.push({ label: "Dependencies", value: String(depsOnCount), icon: "dependency" });
-      if (fc.riskLevel === "critical" || fc.riskLevel === "high") {
-        quickFacts.push({ label: "Risk", value: fc.riskLevel.toUpperCase(), icon: "warning" });
-        warnings.push({
-          message: `This file is classified as ${fc.riskLevel} risk`,
-          severity: fc.riskLevel === "critical" ? "error" : "warning",
-          action: "Add comprehensive tests and review carefully before merging changes"
-        });
-      }
-      for (const dep of fc.dependedOnBy.slice(0, 5)) {
-        relatedFiles.push({
-          filePath: dep,
-          reason: `Imports from this file`,
-          relationship: "depended-by",
-          confidence: 0.9
-        });
+  async tryTreeSitter(content, filePath) {
+    if (!this.treeSitterLoaded) {
+      this.treeSitterLoaded = true;
+      try {
+        const mod = await import('./tree-sitter-H5E7LKR4-MKO3NNLJ.js');
+        this.treeSitterParser = mod.parseWithTreeSitter;
+      } catch {
+        this.treeSitterParser = null;
       }
-      overlays.push({
-        type: "code-lens",
-        line: 1,
-        text: `${depCount} dependent${depCount !== 1 ? "s" : ""} \xB7 ${depsOnCount} import${depsOnCount !== 1 ? "s" : ""} \xB7 ${role}`,
-        tooltip: `This ${role} file has ${depCount} files that depend on it and imports from ${depsOnCount} files`
-      });
     }
-    if (fc && fc.conventions.length > 0) {
-      paragraphs.push({
-        heading: "Conventions",
-        text: `Follow these discovered conventions: ${fc.conventions.slice(0, 3).join("; ")}.`,
-        importance: "medium"
-      });
+    if (!this.treeSitterParser) return null;
+    try {
+      const ext2 = extname(filePath).toLowerCase();
+      const symbols = await this.treeSitterParser(content, ext2);
+      if (!symbols || symbols.length === 0) return null;
+      return flattenCodeSymbols(symbols);
+    } catch {
+      return null;
     }
-    if (ctx.rules) {
-      const fileViolations = ctx.rules.violations.filter(
-        (v) => v.sourceSymbol.filePath.includes(shortName(filePath)) || v.targetSymbol && v.targetSymbol.filePath.includes(shortName(filePath))
-      );
-      if (fileViolations.length > 0) {
-        const errors = fileViolations.filter((v) => v.severity === "error");
-        const warns = fileViolations.filter((v) => v.severity === "warning");
-        paragraphs.push({
-          heading: "Architecture Violations",
-          text: `${errors.length} error${errors.length !== 1 ? "s" : ""} and ${warns.length} warning${warns.length !== 1 ? "s" : ""} from architecture rules.`,
-          importance: errors.length > 0 ? "critical" : "high"
-        });
-        for (const v of fileViolations.slice(0, 5)) {
-          warnings.push({
-            message: v.message,
-            severity: v.severity === "error" ? "error" : "warning",
-            action: v.suggestedFix ?? "Review and fix the violation",
-            ruleId: v.ruleId
-          });
-          overlays.push({
-            type: "diagnostic",
-            line: v.sourceSymbol.line,
-            text: v.message,
-            severity: v.severity === "error" ? "error" : "warning",
-            tooltip: v.suggestedFix
+  }
+  extractSymbolsRegex(content, lines, absolutePath, relativePath2, language) {
+    const symbols = [];
+    if (language === "typescript" || language === "javascript") {
+      const patterns = [
+        { re: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)/gm, kind: "function" },
+        { re: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/gm, kind: "class" },
+        { re: /^(?:export\s+)?interface\s+(\w+)/gm, kind: "interface" },
+        { re: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/gm, kind: "type" },
+        { re: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/gm, kind: "enum" },
+        { re: /^(?:export\s+)?const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\(/gm, kind: "function" }
+      ];
+      for (const { re, kind } of patterns) {
+        for (const match2 of content.matchAll(re)) {
+          const name = match2[1];
+          if (!name) continue;
+          const line = content.slice(0, match2.index).split("\n").length;
+          const endLine = this.findBlockEnd(lines, line - 1);
+          symbols.push({
+            id: `sym:${relativePath2}:${name}:${line}`,
+            name,
+            kind,
+            filePath: absolutePath,
+            startLine: line,
+            endLine,
+            exported: this.isExported(content, name, language),
+            async: match2[0].includes("async"),
+            params: this.countParams(match2[0]),
+            branches: this.countBranches(lines, line - 1, endLine - 1),
+            signature: match2[0].trim().replace(/\s*\{?\s*$/, "")
           });
         }
       }
     }
-    if (ctx.callGraph) {
-      const fileNodes = ctx.callGraph.nodes.filter((n) => n.filePath.includes(shortName(filePath)));
-      const hotFunctions = fileNodes.filter((n) => n.callerCount > 5);
-      if (hotFunctions.length > 0) {
-        paragraphs.push({
-          heading: "Hot Functions",
-          text: hotFunctions.map(
-            (f) => `\`${f.name}\` is called by ${f.callerCount} function${f.callerCount !== 1 ? "s" : ""}${f.calleeCount > 0 ? ` and calls ${f.calleeCount}` : ""}`
-          ).join(". ") + ".",
-          importance: "high"
+    if (language === "python") {
+      const re = /^(?:async\s+)?(?:def|class)\s+(\w+)/gm;
+      for (const match2 of content.matchAll(re)) {
+        const name = match2[1];
+        const kind = match2[0].includes("class") ? "class" : "function";
+        const line = content.slice(0, match2.index).split("\n").length;
+        symbols.push({
+          id: `sym:${relativePath2}:${name}:${line}`,
+          name,
+          kind,
+          filePath: absolutePath,
+          startLine: line,
+          endLine: line + 10,
+          exported: true,
+          async: match2[0].includes("async"),
+          params: this.countParams(match2[0]),
+          branches: void 0,
+          signature: match2[0].trim()
         });
-        for (const fn of hotFunctions) {
-          overlays.push({
-            type: "code-lens",
-            line: 0,
-            // Would need symbol line mapping
-            text: `${fn.callerCount} callers \xB7 ${fn.calleeCount} callees`,
-            tooltip: `Function ${fn.name} has ${fn.callerCount} callers and ${fn.calleeCount} callees`
-          });
-        }
-      }
-      const deadInFile = ctx.callGraph.stats.deadFunctions.filter(
-        (d) => d.filePath.includes(shortName(filePath))
-      );
-      if (deadInFile.length > 0) {
-        for (const dead of deadInFile) {
-          warnings.push({
-            message: `\`${dead.name}\` appears to be dead code (exported but never called)`,
-            severity: "info",
-            action: "Verify this function is not called via dynamic dispatch or external consumers, then consider removing it"
-          });
-        }
       }
     }
-    if (ctx.temporal) {
-      const hotspot = ctx.temporal.changeHotspots.find((h) => filePath.includes(h.file) || h.file.includes(shortName(filePath)));
-      if (hotspot) {
-        const daysSince = Math.round((Date.now() - new Date(hotspot.lastChanged).getTime()) / 864e5);
-        paragraphs.push({
-          heading: "Recent Activity",
-          text: `Changed ${hotspot.commits} times in the last ${ctx.temporal.stats.analysisWindowDays} days by ${hotspot.authors} author${hotspot.authors !== 1 ? "s" : ""}. Last modified ${daysSince} day${daysSince !== 1 ? "s" : ""} ago.`,
-          importance: hotspot.commits > 10 ? "high" : "medium"
+    return symbols;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // IMPORTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  extractImports(content, absolutePath, relativePath2, language) {
+    const imports = [];
+    const fileId = `file:${relativePath2}`;
+    if (language === "typescript" || language === "javascript") {
+      for (const match2 of content.matchAll(TS_IMPORT_RE)) {
+        const sourcePath = match2[1];
+        const line = content.slice(0, match2.index).split("\n").length;
+        const isTypeOnly = TS_IMPORT_TYPE_RE.test(match2[0]);
+        const importedSymbols = this.extractImportedSymbols(match2[0]);
+        const resolvedPath = this.resolveImportPath(sourcePath, absolutePath);
+        imports.push({
+          fileId,
+          filePath: absolutePath,
+          sourcePath,
+          resolvedPath,
+          importedSymbols,
+          isTypeOnly,
+          isDynamic: false,
+          line
         });
-        quickFacts.push({ label: "Recent commits", value: String(hotspot.commits), icon: "git" });
-        quickFacts.push({ label: "Last changed", value: `${daysSince}d ago`, icon: "git" });
-        quickFacts.push({ label: "Authors", value: String(hotspot.authors), icon: "git" });
       }
-      const churn = ctx.temporal.churnFiles.find((c) => filePath.includes(c.file) || c.file.includes(shortName(filePath)));
-      if (churn && churn.severity !== "low") {
-        warnings.push({
-          message: churn.reason,
-          severity: churn.severity === "high" ? "warning" : "info",
-          action: "Consider whether this file needs refactoring to reduce change frequency"
+      for (const match2 of content.matchAll(TS_DYNAMIC_IMPORT_RE)) {
+        const sourcePath = match2[1];
+        const line = content.slice(0, match2.index).split("\n").length;
+        imports.push({
+          fileId,
+          filePath: absolutePath,
+          sourcePath,
+          resolvedPath: this.resolveImportPath(sourcePath, absolutePath),
+          importedSymbols: [],
+          isTypeOnly: false,
+          isDynamic: true,
+          line
         });
       }
-      const expertise = ctx.temporal.authorExpertise.find(
-        (e) => filePath.startsWith(e.area) || filePath.includes(e.area)
-      );
-      if (expertise && expertise.busFactor === 1) {
-        warnings.push({
-          message: `Bus factor of 1 \u2014 ${expertise.primaryAuthor} has made ${expertise.authors[0]?.percentage}% of changes to this area`,
-          severity: "info",
-          action: "Consider knowledge sharing or pair programming for this area"
+    }
+    if (language === "python") {
+      for (const match2 of content.matchAll(PY_IMPORT_RE)) {
+        const sourcePath = match2[1] || match2[2];
+        if (!sourcePath) continue;
+        const line = content.slice(0, match2.index).split("\n").length;
+        imports.push({
+          fileId,
+          filePath: absolutePath,
+          sourcePath,
+          resolvedPath: "",
+          importedSymbols: [],
+          isTypeOnly: false,
+          isDynamic: false,
+          line
         });
       }
     }
-    if (ctx.learned) {
-      const coEdits = ctx.learned.coEdits.filter((p) => p.files[0].includes(shortName(filePath)) || p.files[1].includes(shortName(filePath))).slice(0, 3);
-      if (coEdits.length > 0) {
-        for (const pair of coEdits) {
-          const other = pair.files[0].includes(shortName(filePath)) ? pair.files[1] : pair.files[0];
-          relatedFiles.push({
-            filePath: other,
-            reason: `Often edited together (${pair.count} times)`,
-            relationship: "co-edited",
-            confidence: pair.weight
+    if (language === "go") {
+      for (const match2 of content.matchAll(GO_IMPORT_RE)) {
+        const block = match2[1] || match2[2];
+        if (!block) continue;
+        const paths = block.match(/"([^"]+)"/g) ?? [];
+        for (const p of paths) {
+          const sourcePath = p.replace(/"/g, "");
+          imports.push({
+            fileId,
+            filePath: absolutePath,
+            sourcePath,
+            resolvedPath: "",
+            importedSymbols: [],
+            isTypeOnly: false,
+            isDynamic: false,
+            line: 0
           });
         }
       }
     }
-    if (fc && fc.editGuidance.length > 0) {
-      paragraphs.push({
-        heading: "Edit Guidance",
-        text: fc.editGuidance.join(" "),
-        importance: "medium"
-      });
-    }
-    return {
-      filePath,
-      roleSummary,
-      paragraphs,
-      quickFacts,
-      warnings,
-      relatedFiles,
-      overlays
-    };
-  }
-  /**
-   * Generate a compact markdown explanation for AI agent consumption.
-   */
-  explainForAgent(filePath, ctx) {
-    const explanation = this.explain(filePath, ctx);
-    const lines = [];
-    lines.push(`## ${shortName(filePath)}: ${explanation.roleSummary}`);
-    lines.push("");
-    if (explanation.quickFacts.length > 0) {
-      lines.push(explanation.quickFacts.map((f) => `**${f.label}**: ${f.value}`).join(" \xB7 "));
-      lines.push("");
-    }
-    for (const p of explanation.paragraphs.filter((p2) => p2.importance === "critical" || p2.importance === "high")) {
-      lines.push(`### ${p.heading}`);
-      lines.push(p.text);
-      lines.push("");
-    }
-    if (explanation.warnings.length > 0) {
-      lines.push("### Warnings");
-      for (const w of explanation.warnings) {
-        const icon = w.severity === "error" ? "MUST FIX" : w.severity === "warning" ? "SHOULD FIX" : "NOTE";
-        lines.push(`- **[${icon}]** ${w.message} \u2014 ${w.action}`);
-      }
-      lines.push("");
-    }
-    if (explanation.relatedFiles.length > 0) {
-      lines.push("### Related Files");
-      for (const rf of explanation.relatedFiles.slice(0, 5)) {
-        lines.push(`- \`${rf.filePath}\` \u2014 ${rf.reason}`);
-      }
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Generate IDE overlay data for the VS Code extension to consume.
-   */
-  getIDEOverlays(filePath, ctx) {
-    const explanation = this.explain(filePath, ctx);
-    return explanation.overlays;
+    return imports;
   }
-  /**
-   * Generate a health report explanation.
-   */
-  explainHealth(health, dna) {
-    const lines = [];
-    const dims = health.dimensions;
-    lines.push(`## Codebase Health: ${health.overall}/100`);
-    lines.push("");
-    const entries = [
-      { name: "Architecture", score: dims.architecture, explain: this.explainArchScore(dims.architecture, dna) },
-      { name: "Test Coverage", score: dims.testCoverage, explain: this.explainTestScore(dims.testCoverage) },
-      { name: "Conventions", score: dims.conventions, explain: this.explainConventionScore(dims.conventions, dna) },
-      { name: "Dependencies", score: dims.dependencies, explain: this.explainDependencyScore(dims.dependencies, dna) },
-      { name: "Security", score: dims.security, explain: dims.security >= 80 ? "No critical security concerns detected" : "Critical risk areas identified" },
-      { name: "Complexity", score: dims.complexity, explain: dims.complexity >= 80 ? "Complexity is well-managed" : "High-complexity hotspots detected" }
-    ];
-    for (const entry of entries) {
-      const bar = this.renderBar(entry.score);
-      lines.push(`${bar} **${entry.name}**: ${entry.score}/100 \u2014 ${entry.explain}`);
+  extractImportedSymbols(importLine) {
+    const braceMatch = importLine.match(/\{([^}]+)\}/);
+    if (!braceMatch) {
+      const defaultMatch = importLine.match(/import\s+(?:type\s+)?(\w+)\s+from/);
+      return defaultMatch?.[1] ? [defaultMatch[1]] : [];
     }
-    return lines.join("\n");
+    return braceMatch[1].split(",").map((s) => {
+      const parts = s.trim().split(/\s+as\s+/);
+      return parts[parts.length - 1].trim();
+    }).filter(Boolean);
+  }
+  resolveImportPath(sourcePath, fromFile) {
+    if (!sourcePath.startsWith(".")) return sourcePath;
+    const dir = dirname(fromFile);
+    const resolved = resolve(dir, sourcePath);
+    const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+    for (const ext2 of extensions) {
+      const candidate = resolved + ext2;
+      try {
+        accessSync(candidate);
+        return candidate;
+      } catch {
+      }
+    }
+    return resolved;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE
+  // CALL EDGES (basic extraction)
   // ═══════════════════════════════════════════════════════════════════════════
-  buildRoleSummary(filePath, role, ctx) {
-    const parts = [];
-    switch (role) {
-      case "service":
-        parts.push("Business logic service");
-        break;
-      case "route-handler":
-        parts.push("API route handler");
-        break;
-      case "component":
-        parts.push("UI component");
-        break;
-      case "repository":
-        parts.push("Data access layer");
-        break;
-      case "middleware":
-        parts.push("Request middleware");
-        break;
-      case "test":
-        parts.push("Test file");
-        break;
-      case "config":
-        parts.push("Configuration");
-        break;
-      case "type":
-        parts.push("Type definitions");
-        break;
-      case "util":
-        parts.push("Utility module");
-        break;
-      case "entry":
-        parts.push("Entry point");
-        break;
-      default:
-        parts.push("Source file");
-    }
-    if (ctx.fileContext) {
-      if (ctx.fileContext.layer) parts.push(`in ${ctx.fileContext.layer} layer`);
-      if (ctx.fileContext.dependedOnBy.length > 10) parts.push("(high-impact)");
+  extractCallEdges(content, symbols, filePath) {
+    const edges = [];
+    const functionNames = new Set(symbols.filter((s) => s.kind === "function" || s.kind === "method").map((s) => s.name));
+    for (const caller of symbols) {
+      if (caller.kind !== "function" && caller.kind !== "method") continue;
+      const body = content.split("\n").slice(caller.startLine - 1, caller.endLine).join("\n");
+      for (const calleeName of functionNames) {
+        if (calleeName === caller.name) continue;
+        const callRe = new RegExp(`\\b${calleeName}\\s*\\(`, "g");
+        if (callRe.test(body)) {
+          const callee = symbols.find((s) => s.name === calleeName);
+          if (callee) {
+            edges.push({
+              callerId: caller.id,
+              calleeId: callee.id,
+              callerName: caller.name,
+              calleeName: callee.name,
+              callerFile: filePath,
+              calleeFile: filePath
+            });
+          }
+        }
+      }
     }
-    return parts.join(" ");
-  }
-  explainArchScore(score, dna) {
-    if (score >= 80) return `Strong architecture with ${dna.patterns.length} recognized patterns`;
-    if (score >= 50) return `Moderate architecture \u2014 ${dna.patterns.length} patterns detected, room to strengthen boundaries`;
-    return "Architecture needs attention \u2014 few recognized patterns or boundaries";
+    return edges;
   }
-  explainTestScore(score) {
-    if (score >= 80) return "Good test coverage across source files";
-    if (score >= 50) return "Moderate coverage \u2014 some source files lack tests";
-    return "Low test coverage \u2014 many exported modules have no test files";
+  // ═══════════════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═══════════════════════════════════════════════════════════════════════════
+  isExported(content, name, language) {
+    if (language === "python") return true;
+    const re = new RegExp(`export\\s+(?:default\\s+)?(?:async\\s+)?(?:function|class|const|let|var|type|interface|enum)\\s+${name}\\b`);
+    if (re.test(content)) return true;
+    const reExport = new RegExp(`export\\s+\\{[^}]*\\b${name}\\b[^}]*\\}`);
+    return reExport.test(content);
   }
-  explainConventionScore(score, dna) {
-    const strong = dna.conventions.filter((c) => c.confidence > 0.6).length;
-    if (score >= 80) return `${strong} strong conventions enforced consistently`;
-    if (score >= 50) return `${strong} conventions detected but inconsistently applied`;
-    return "Few consistent conventions \u2014 codebase style varies across files";
+  countParams(signature) {
+    const parenMatch = signature.match(/\(([^)]*)\)/);
+    if (!parenMatch || !parenMatch[1].trim()) return 0;
+    return parenMatch[1].split(",").length;
   }
-  explainDependencyScore(score, dna) {
-    const circular = dna.boundaries.filter((b) => b.isCircular).length;
-    if (score >= 80) return "Clean dependency graph with no circular dependencies";
-    if (circular > 0) return `${circular} circular dependency${circular > 1 ? "ies" : "y"} detected \u2014 these increase coupling and make code harder to reason about`;
-    return "Dependency health needs improvement";
+  countBranches(lines, startIdx, endIdx) {
+    let branches = 0;
+    const branchRe = /\b(if|else if|case|for|while|catch|&&|\|\||\?\?)\b/g;
+    for (let i = startIdx; i < Math.min(endIdx, lines.length); i++) {
+      const matches = lines[i].match(branchRe);
+      if (matches) branches += matches.length;
+    }
+    return branches;
   }
-  renderBar(score) {
-    const filled = Math.round(score / 10);
-    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  findBlockEnd(lines, startIdx) {
+    let depth = 0;
+    let seenOpen = false;
+    for (let i = startIdx; i < lines.length; i++) {
+      for (const ch of lines[i]) {
+        if (ch === "{") {
+          depth++;
+          seenOpen = true;
+        } else if (ch === "}" && seenOpen) {
+          depth--;
+          if (depth <= 0) return i + 1;
+        }
+      }
+    }
+    return startIdx + 1;
   }
 };
-function shortName(filePath) {
-  const parts = filePath.split("/");
-  return parts[parts.length - 1] ?? filePath;
+function mapTreeSitterKind(kind) {
+  const map = {
+    function: "function",
+    method: "method",
+    class: "class",
+    interface: "interface",
+    type: "type",
+    enum: "enum",
+    const: "variable",
+    variable: "variable",
+    struct: "class",
+    trait: "interface",
+    export: "variable"
+  };
+  return map[kind] ?? "function";
+}
+function flattenCodeSymbols(symbols) {
+  const flat = [];
+  for (const sym of symbols) {
+    flat.push({ name: sym.name, kind: sym.kind, line: sym.line, endLine: sym.endLine, signature: sym.signature });
+    if (sym.children && Array.isArray(sym.children)) {
+      flat.push(...flattenCodeSymbols(sym.children));
+    }
+  }
+  return flat;
 }
 function normalizePath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -19910,26 +19910,41 @@ function getGraphNeighbors(graph, filePath) {
 async function getProactiveContext(engine, rootPath, options) {
   const lines = [];
   const { focusedFile } = options;
+  const maxItems = Math.max(1, options.maxItems ?? 5);
   const fileCtx = engine.getFileContext(focusedFile);
   if (fileCtx) {
-    lines.push(`## Focused: ${focusedFile}`);
-    lines.push(`Role: ${fileCtx.role}`);
+    lines.push(`## Focus: ${focusedFile}`);
+    lines.push(`Role: ${fileCtx.role} | Risk: ${fileCtx.riskLevel}`);
+    if (fileCtx.editGuidance.length > 0) {
+      lines.push(`Top guidance: ${fileCtx.editGuidance[0]}`);
+    }
+    lines.push("");
+    lines.push("## Stay On Target");
+    lines.push("- Edit only this file and direct neighbors unless requirements force expansion.");
+    lines.push("- Reuse existing patterns from related files before creating new abstractions.");
+    lines.push("- If uncertain about API/type existence, verify before generating code.");
+    lines.push("");
+    lines.push("## Immediate Neighbors");
     if (fileCtx.dependsOn.length > 0) {
-      lines.push(`Depends on: ${fileCtx.dependsOn.slice(0, 5).join(", ")}`);
+      lines.push(`- Depends on: ${fileCtx.dependsOn.slice(0, maxItems).join(", ")}`);
     }
     if (fileCtx.dependedOnBy.length > 0) {
-      lines.push(`Depended on by: ${fileCtx.dependedOnBy.slice(0, 5).join(", ")}`);
+      lines.push(`- Depended on by: ${fileCtx.dependedOnBy.slice(0, maxItems).join(", ")}`);
     }
     if (fileCtx.relatedFiles.length > 0) {
-      lines.push(`Related: ${fileCtx.relatedFiles.slice(0, 5).join(", ")}`);
+      lines.push(`- Related: ${fileCtx.relatedFiles.slice(0, maxItems).join(", ")}`);
     }
     lines.push("");
+  } else {
+    lines.push(`## Focus: ${focusedFile}`);
+    lines.push("File context unavailable \u2014 keep scope minimal and verify dependencies manually.");
+    lines.push("");
   }
   const graph = engine.getGraph();
   const neighbors = getGraphNeighbors(graph, focusedFile);
   if (neighbors.length > 0) {
-    lines.push("## Graph neighbors");
-    for (const n of neighbors.slice(0, 8)) {
+    lines.push("## Graph Adjacency");
+    for (const n of neighbors.slice(0, maxItems)) {
       lines.push(`- ${n}`);
     }
     lines.push("");
@@ -19938,16 +19953,16 @@ async function getProactiveContext(engine, rootPath, options) {
     const evolution = await import('./dist-JUOVMQEA.js');
     const boosted = await evolution.getBoostedFiles(rootPath, focusedFile);
     if (boosted.length > 0) {
-      lines.push("## Often edited together (learned)");
-      for (const { file, weight } of boosted.slice(0, 5)) {
-        lines.push(`- ${file} (weight: ${weight.toFixed(2)})`);
+      lines.push("## Learned Co-Edit Priors");
+      for (const { file, weight } of boosted.slice(0, maxItems)) {
+        lines.push(`- ${file} (affinity: ${weight.toFixed(2)})`);
       }
       lines.push("");
     }
     const sequential = await evolution.getSequentialFiles(rootPath, focusedFile);
     if (sequential.length > 0) {
-      lines.push("## Often edited next (sequence)");
-      for (const { file, weight } of sequential.slice(0, 5)) {
+      lines.push("## Likely Next Files");
+      for (const { file, weight } of sequential.slice(0, maxItems)) {
         lines.push(`- ${file} (weight: ${weight.toFixed(2)})`);
       }
       lines.push("");
@@ -19963,26 +19978,33 @@ function runKeywordSearch(data, query, limit) {
   const symbols = [];
   const seenFiles = /* @__PURE__ */ new Set();
   const seenSymbols = /* @__PURE__ */ new Set();
+  const overlapScores = [];
   for (const file of data.files) {
     const pathLower = file.relativePath.toLowerCase();
-    if (words.some((w) => pathLower.includes(w)) && !seenFiles.has(file.relativePath)) {
+    const overlapCount = words.filter((w) => pathLower.includes(w)).length;
+    if (overlapCount > 0 && !seenFiles.has(file.relativePath)) {
       seenFiles.add(file.relativePath);
       files.push(file.relativePath);
+      overlapScores.push(overlapCount / Math.max(1, words.length));
     }
   }
   for (const sym of data.symbols) {
     const nameLower = sym.name.toLowerCase();
-    if (words.some((w) => nameLower.includes(w))) {
+    const overlapCount = words.filter((w) => nameLower.includes(w)).length;
+    if (overlapCount > 0) {
       const key = `${sym.filePath}:${sym.name}`;
       if (!seenSymbols.has(key)) {
         seenSymbols.add(key);
         symbols.push({ name: sym.name, file: sym.filePath, kind: sym.kind });
+        overlapScores.push(overlapCount / Math.max(1, words.length));
       }
     }
   }
+  const confidence = overlapScores.length > 0 ? Math.max(...overlapScores) : 0;
   return {
     files: files.slice(0, limit),
-    symbols: symbols.slice(0, limit)
+    symbols: symbols.slice(0, limit),
+    confidence
   };
 }
 function parseSymbolLocation(loc) {
@@ -19998,18 +20020,23 @@ function parseSymbolLocation(loc) {
 async function intentQuery(rootPath, data, query, options = {}) {
   const limit = options.limit ?? 10;
   const useSemantic = options.useSemantic ?? false;
+  const strictGrounding = options.strictGrounding ?? true;
+  const minConfidence = options.minConfidence ?? 0.35;
   const degradations = [];
   let files = [];
   let symbols = [];
   let usedSemantic = false;
   let semanticResults = [];
+  let confidence = 0;
   if (useSemantic) {
     try {
-      const { semanticSearch } = await import('./semantic-PYRDZSHX.js');
+      const { semanticSearch } = await import('./semantic-3IRDVTDG.js');
       const results = await semanticSearch(rootPath, query, { topK: limit * 2, embeddingProvider: options.embeddingProvider });
       if (results.length > 0) {
         usedSemantic = true;
         semanticResults = results;
+        const topSemantic = results.slice(0, Math.max(1, Math.min(3, results.length)));
+        confidence = topSemantic.reduce((sum, r) => sum + Math.max(0, r.score / 100), 0) / topSemantic.length;
         const seenFiles = /* @__PURE__ */ new Set();
         const seenSymbols = /* @__PURE__ */ new Set();
         for (const r of results) {
@@ -20042,6 +20069,7 @@ async function intentQuery(rootPath, data, query, options = {}) {
     const kw = runKeywordSearch(data, query, limit);
     files = kw.files;
     symbols = kw.symbols;
+    confidence = kw.confidence;
   }
   const snippets = [];
   for (const sym of symbols.slice(0, limit)) {
@@ -20063,16 +20091,28 @@ async function intentQuery(rootPath, data, query, options = {}) {
       content: `${sym.kind} ${sym.name}`
     });
   }
-  const summary = files.length > 0 || symbols.length > 0 ? `Found ${files.length} files and ${symbols.length} symbols matching "${query}"${usedSemantic ? " (semantic)" : ""}` : `No files or symbols directly matching "${query}"`;
+  const hasMatches = files.length > 0 || symbols.length > 0;
+  const grounded = !strictGrounding || confidence >= minConfidence;
+  const finalFiles = grounded ? files : [];
+  const finalSymbols = grounded ? symbols : [];
+  const finalSnippets = grounded ? snippets : [];
+  const summary = !grounded ? `Withheld low-confidence matches for "${query}" (confidence ${confidence.toFixed(2)} < ${minConfidence.toFixed(2)}). Refine the query or disable strict grounding.` : hasMatches ? `Found ${files.length} files and ${symbols.length} symbols matching "${query}"${usedSemantic ? " (semantic)" : ""}` : `No files or symbols directly matching "${query}"`;
   return {
     summary,
-    files,
-    symbols,
-    snippets,
+    files: finalFiles,
+    symbols: finalSymbols,
+    snippets: finalSnippets,
     execution: {
       semanticRequested: useSemantic,
       semanticUsed: usedSemantic,
-      degradations
+      degradations,
+      confidence,
+      grounding: {
+        strict: strictGrounding,
+        minConfidence,
+        evidenceCount: finalFiles.length + finalSymbols.length + finalSnippets.length,
+        decision: grounded ? "pass" : "withheld"
+      }
     }
   };
 }
@@ -21744,6 +21784,64 @@ var MCP_TOOLS = [
         }
       }
     }
+  },
+  {
+    name: "isl_studio_apply",
+    description: "Push code into the live ISL Studio editor running inside the user's VS Code / Cursor / Windsurf. Use when the user has ISL Studio open and you want changes to land in the live preview. Writes to .vibecheck/isl-studio-inbox.jsonl which the panel watches. The studio rebuilds the live preview automatically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Workspace root path. Defaults to current directory."
+        },
+        lang: {
+          type: "string",
+          enum: ["html", "css", "js"],
+          description: "Which editor pane to update."
+        },
+        code: { type: "string", description: "Source code to write." },
+        mode: {
+          type: "string",
+          enum: ["replace", "append"],
+          description: "replace = overwrite the pane contents (default). append = add to end."
+        }
+      },
+      required: ["lang", "code"]
+    }
+  },
+  {
+    name: "isl_studio_send_message",
+    description: "Post a system or assistant message into the ISL Studio chat transcript. Use to surface progress updates, explanations, or follow-up questions while the user has ISL Studio open.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Workspace root path. Defaults to current directory."
+        },
+        role: {
+          type: "string",
+          enum: ["assistant", "system"],
+          description: "Display role for the message."
+        },
+        content: { type: "string", description: "Message body. Markdown is rendered as plain text but fenced code blocks become applyable." }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "isl_studio_get_state",
+    description: "Read the current ISL Studio editor state (last saved html/css/js snapshot) from the workspace. Use before generating changes so you have full context of what the user is working on.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Workspace root path. Defaults to current directory."
+        }
+      }
+    }
   }
 ];
 function isKnownToolName(toolName) {
@@ -21888,7 +21986,7 @@ function createScanIdempotencyKey(prefix) {
 // src/mcp-scan-meter-client.ts
 var MCP_SCAN_METER_CLIENT = {
   type: "mcp",
-  version: "24.6.4"
+  version: "24.6.6"
 };
 
 // ../shared/dist/chunk-YYSV5CG4.js
@@ -22187,6 +22285,36 @@ function resolveWorkspaceRoot(cwd) {
   const resolvedRoot = path2.resolve(cwd);
   return fs4.existsSync(resolvedRoot) ? fs4.realpathSync(resolvedRoot) : resolvedRoot;
 }
+async function appendIslStudioInbox(workspaceRoot, jsonLine) {
+  try {
+    const dir = path2.join(workspaceRoot, ".vibecheck");
+    await fs4.promises.mkdir(dir, { recursive: true });
+    const target = path2.join(dir, "isl-studio-inbox.jsonl");
+    await fs4.promises.appendFile(target, jsonLine + "\n", "utf-8");
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function readIslStudioState(workspaceRoot) {
+  try {
+    const target = path2.join(workspaceRoot, ".vibecheck", "isl-studio", "editor-state.json");
+    const raw = await fs4.promises.readFile(target, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      available: true,
+      html: typeof parsed.html === "string" ? parsed.html : "",
+      css: typeof parsed.css === "string" ? parsed.css : "",
+      js: typeof parsed.js === "string" ? parsed.js : "",
+      source: "editor-state.json"
+    };
+  } catch {
+    return {
+      available: false,
+      hint: "ISL Studio editor state not found. The user must open the ISL Studio panel and edit at least once for state to be persisted to .vibecheck/isl-studio/editor-state.json."
+    };
+  }
+}
 function resolveWorkspaceTargetPath(workspaceRoot, requestedPath) {
   const resolvedTarget = path2.resolve(workspaceRoot, requestedPath);
   const normalizedTarget = fs4.existsSync(resolvedTarget) ? fs4.realpathSync(resolvedTarget) : path2.normalize(resolvedTarget);
@@ -22536,7 +22664,7 @@ ${validation.errors.join("\n")}`);
         if (!fs4.existsSync(absFile) || !fs4.statSync(absFile).isFile()) {
           return buildErrorResponse(`Not a file: ${relFile}`);
         }
-        const { runGhostTrace } = await import('./dist-PVKUO7NU.js');
+        const { runGhostTrace } = await import('./dist-2TGNIDV6.js');
         const trace = await withTimeout(
           runGhostTrace({ workspaceRoot: targetPath, filePath: absFile }),
           MCP_TOOL_TIMEOUT_MS,
@@ -22814,6 +22942,59 @@ This change is synced across all surfaces.`
           );
         }
       }
+      case "isl_studio_apply": {
+        const lang = args?.lang;
+        const code = args?.code;
+        const mode = args?.mode === "append" ? "append" : "replace";
+        if (lang !== "html" && lang !== "css" && lang !== "js") {
+          return buildErrorResponse('isl_studio_apply requires lang to be "html", "css", or "js"');
+        }
+        if (typeof code !== "string") {
+          return buildErrorResponse('isl_studio_apply requires "code" (string)');
+        }
+        const ISL_APPLY_MAX_BYTES = 1024 * 1024;
+        const codeByteLen = Buffer.byteLength(code, "utf-8");
+        if (codeByteLen > ISL_APPLY_MAX_BYTES) {
+          return buildErrorResponse(
+            `isl_studio_apply rejected: code is ${(codeByteLen / 1024).toFixed(1)} KB, max is ${ISL_APPLY_MAX_BYTES / 1024} KB. Split the change into smaller updates.`
+          );
+        }
+        const evt = JSON.stringify({ type: "apply", lang, code, mode });
+        const r = await appendIslStudioInbox(workspaceRoot, evt);
+        if (!r.ok) return buildErrorResponse(`isl_studio_apply failed: ${r.message}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Wrote ${code.length} chars of ${lang} to ISL Studio (mode: ${mode}). The live preview will rebuild.`
+            }
+          ]
+        };
+      }
+      case "isl_studio_send_message": {
+        const role = args?.role === "system" ? "system" : "assistant";
+        const content = args?.content;
+        if (typeof content !== "string" || !content.trim()) {
+          return buildErrorResponse('isl_studio_send_message requires non-empty "content"');
+        }
+        const ISL_MSG_MAX_BYTES = 64 * 1024;
+        const msgByteLen = Buffer.byteLength(content, "utf-8");
+        if (msgByteLen > ISL_MSG_MAX_BYTES) {
+          return buildErrorResponse(
+            `isl_studio_send_message rejected: content is ${(msgByteLen / 1024).toFixed(1)} KB, max is ${ISL_MSG_MAX_BYTES / 1024} KB.`
+          );
+        }
+        const evt = JSON.stringify({ type: "message", role, content });
+        const r = await appendIslStudioInbox(workspaceRoot, evt);
+        if (!r.ok) return buildErrorResponse(`isl_studio_send_message failed: ${r.message}`);
+        return { content: [{ type: "text", text: "Message posted to ISL Studio chat." }] };
+      }
+      case "isl_studio_get_state": {
+        const r = await readIslStudioState(workspaceRoot);
+        return {
+          content: [{ type: "text", text: JSON.stringify(r, null, 2) }]
+        };
+      }
       default:
         return buildErrorResponse(`Unknown tool: ${name}`);
     }
@@ -22827,7 +23008,7 @@ function createMcpServer(runtimeOverrides = {}) {
   const server = new Server(
     {
       name: "vibecheck-mcp",
-      version: "24.6.4"
+      version: "24.6.6"
     },
     {
       capabilities: {