@vibecheck-ai/mcp 24.4.0 → 24.4.3

package/dist/index.js

@@ -221643,7 +221643,7 @@ ${JSON.stringify(t2, null, 2)}`);
 
 // ../context-engine/dist/chunk-3ZE34DAJ.js
 import { readFile as readFile2 } from "fs/promises";
-import { join as join3, dirname as dirname5 } from "path";
+import { join as join3, dirname as dirname4 } from "path";
 import { fileURLToPath } from "url";
 async function initParser() {
   if (ParserClass) return ParserClass;
@@ -221783,7 +221783,7 @@ var init_chunk_3ZE34DAJ = __esm({
       SymbolKind2["Export"] = "export";
       return SymbolKind2;
     })(SymbolKind || {});
-    GRAMMAR_DIR = join3(dirname5(fileURLToPath(import.meta.url)), "../../../../node_modules/tree-sitter-wasms/out");
+    GRAMMAR_DIR = join3(dirname4(fileURLToPath(import.meta.url)), "../../../../node_modules/tree-sitter-wasms/out");
     EXT_TO_GRAMMAR = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -289071,1860 +289071,1860 @@ rules:
       match: "src/repositories/**"
 `;
 
-// ../context-engine/dist/chunk-INBCP46U.js
-import * as path5 from "path";
-var ContextSynthesizer = class {
+// ../context-engine/dist/chunk-HMKLYBWJ.js
+var import_better_sqlite3 = __toESM(require_lib(), 1);
+var import_fast_glob2 = __toESM(require_out4(), 1);
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3, stat } from "fs/promises";
+import { mkdirSync } from "fs";
+import { join as join4 } from "path";
+import { readFile as readFile22 } from "fs/promises";
+import { accessSync } from "fs";
+import { extname as extname2, resolve as resolve2, dirname as dirname5 } from "path";
+import { createHash as createHash22 } from "crypto";
+var SCHEMA_VERSION = 1;
+var PersistentIndex = class {
+  db;
+  config;
   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
+  constructor(config) {
+    this.rootPath = config.rootPath;
+    this.config = {
+      rootPath: config.rootPath,
+      dbPath: config.dbPath ?? join4(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 = join4(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();
   }
-  /**
-   * 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);
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SCHEMA
+  // ═══════════════════════════════════════════════════════════════════════════
+  initSchema() {
+    const version3 = this.getSchemaVersion();
+    if (version3 === 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
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * Generate a compact markdown context document for IDE rules.
-   * This replaces the old static rule generation with intelligence-driven context.
+   * Discover files, diff against stored hashes, return only changed files.
    */
-  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(", ")}`);
-    }
-    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}\``);
+  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);
       }
-      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}`);
+    const deleted = [];
+    for (const storedPath of storedHashes.keys()) {
+      if (!currentPaths.has(storedPath)) {
+        deleted.push(storedPath);
       }
-      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("");
+    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);
     }
-    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("");
+    const parsedFiles = [];
+    for (const relPath of changed) {
+      const absPath = join4(this.rootPath, relPath);
+      try {
+        const parsed = await parser4.parseFile(absPath, relPath);
+        parsedFiles.push(parsed);
+      } catch {
       }
     }
-    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("");
+    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 = join4(this.rootPath, relPath);
+      try {
+        const parsed = await parser4.parseFile(absPath, relPath);
+        parsedFiles.push(parsed);
+      } catch {
       }
     }
-    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");
+    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
+    };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // IDENTITY
+  // DATA LOADING (warm start)
   // ═══════════════════════════════════════════════════════════════════════════
-  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));
+  /**
+   * 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;
     }
-    for (const cycle of this.graph.cycles) {
-      noGoZones.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}...`);
+  }
+  /**
+   * 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;
     }
-    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
+  // EMBEDDING STORAGE
   // ═══════════════════════════════════════════════════════════════════════════
-  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
-      };
-    });
+  /**
+   * Store a chunk embedding (file-level, function-level, etc.)
+   */
+  storeEmbedding(path10, chunkId, chunkType, contentHash, vector, metadata2) {
+    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(metadata2 ?? {}));
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // DNA SUMMARY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildDNASummary() {
+  /**
+   * 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 {
-      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]}`)
+      vector: Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4)),
+      contentHash: row.content_hash,
+      metadata: JSON.parse(row.metadata)
     };
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // 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
-    };
+  /**
+   * 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)
+    }));
   }
-  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";
+  /**
+   * 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;
   }
-  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;
-    }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // QUERYING
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Get all symbols in a specific file.
+   */
+  getSymbolsForFile(filePath) {
+    return this.loadSymbolsWhere("file_path = ?", [filePath]);
   }
-  findRelatedFiles(file, role) {
-    const related = [];
-    const dir = path5.dirname(file.relativePath);
-    for (const other of this.data.files) {
-      if (other.path === file.path) continue;
-      if (path5.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;
+  /**
+   * Search symbols by name pattern.
+   */
+  searchSymbols(namePattern, limit = 50) {
+    return this.loadSymbolsWhere("name LIKE ?", [`%${namePattern}%`]).slice(0, limit);
   }
-  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.`);
-    }
-    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;
+  /**
+   * 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);
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // TASK PLAYBOOKS
+  // CLEANUP
   // ═══════════════════════════════════════════════════════════════════════════
-  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"]
-    });
-    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"]
-    });
-    return playbooks;
+  /**
+   * 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();
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // VERIFICATION STEPS
+  // PRIVATE — File Discovery
   // ═══════════════════════════════════════════════════════════════════════════
-  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"]
-      });
+  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 = join4(this.rootPath, relPath);
+      try {
+        const fileStat = await stat(absPath);
+        if (fileStat.size > this.config.maxFileSize) continue;
+        const content = await readFile3(absPath, "utf-8");
+        hashes.push({
+          relativePath: relPath.replace(/\\/g, "/"),
+          contentHash: hashContent2(content),
+          sizeBytes: fileStat.size,
+          modifiedMs: Math.floor(fileStat.mtimeMs)
+        });
+      } catch {
+      }
     }
-    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"]
+    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
       });
     }
-    steps.push({
-      trigger: "Any source file change",
-      checks: ["No new architecture rule violations", "No new circular dependencies"],
-      commands: ["vibecheck arch-rules"],
-      artifacts: []
-    });
-    return steps;
+    return map;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // RISK BRIEFING
+  // PRIVATE — Storage
   // ═══════════════════════════════════════════════════════════════════════════
-  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")
+  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 testFiles = this.data.files.filter(
-      (f) => f.relativePath.includes(".test.") || f.relativePath.includes(".spec.")
+    const insertFile = this.db.prepare(
+      "INSERT OR REPLACE INTO files (id, path, relative_path, language, line_count, exports, content) VALUES (?, ?, ?, ?, ?, ?, ?)"
     );
-    const testedBases = new Set(testFiles.map(
-      (f) => path5.basename(f.relativePath).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, "")
-    ));
-    for (const file of sourceFiles) {
-      const baseName = path5.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)
-    };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // HELPERS
-  // ═══════════════════════════════════════════════════════════════════════════
-  toRelative(filePath) {
-    if (filePath.startsWith(this.rootPath)) {
-      return filePath.slice(this.rootPath.length + 1).replace(/\\/g, "/");
-    }
-    return filePath.replace(/\\/g, "/");
-  }
-};
-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 parts2 = [];
-        if (depCount > 0) {
-          const critical = depCount > 10 ? " \u2014 changes here have wide blast radius" : "";
-          parts2.push(`${depCount} file${depCount > 1 ? "s" : ""} depend on this${critical}`);
-        }
-        if (depsOnCount > 0) {
-          parts2.push(`it imports from ${depsOnCount} file${depsOnCount > 1 ? "s" : ""}`);
-        }
-        paragraphs.push({
-          heading: "Dependencies",
-          text: parts2.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
-        });
-      }
-      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 (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 (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 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
+          );
         }
-      }
-      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"
-          });
+        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
+          );
         }
-      }
-    }
-    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" });
-      }
-      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"
-        });
-      }
-      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 (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
-          });
+        for (const edge of callEdges) {
+          insertCallEdge.run(
+            edge.callerId,
+            edge.calleeId,
+            edge.callerName,
+            edge.calleeName,
+            edge.callerFile,
+            edge.calleeFile
+          );
         }
       }
-    }
-    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
-    };
+    });
+    txn();
   }
-  /**
-   * 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}`);
+  removeFiles(relativePaths) {
+    if (relativePaths.length === 0) return;
+    const txn = this.db.transaction(() => {
+      for (const relPath of relativePaths) {
+        const absPath = join4(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);
       }
-      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;
-  }
-  /**
-   * 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}`);
-    }
-    return lines.join("\n");
+    });
+    txn();
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE
+  // PRIVATE — Loading
   // ═══════════════════════════════════════════════════════════════════════════
-  buildRoleSummary(filePath, role, ctx) {
-    const parts2 = [];
-    switch (role) {
-      case "service":
-        parts2.push("Business logic service");
-        break;
-      case "route-handler":
-        parts2.push("API route handler");
-        break;
-      case "component":
-        parts2.push("UI component");
-        break;
-      case "repository":
-        parts2.push("Data access layer");
-        break;
-      case "middleware":
-        parts2.push("Request middleware");
-        break;
-      case "test":
-        parts2.push("Test file");
-        break;
-      case "config":
-        parts2.push("Configuration");
-        break;
-      case "type":
-        parts2.push("Type definitions");
-        break;
-      case "util":
-        parts2.push("Utility module");
-        break;
-      case "entry":
-        parts2.push("Entry point");
-        break;
-      default:
-        parts2.push("Source file");
-    }
-    if (ctx.fileContext) {
-      if (ctx.fileContext.layer) parts2.push(`in ${ctx.fileContext.layer} layer`);
-      if (ctx.fileContext.dependedOnBy.length > 10) parts2.push("(high-impact)");
-    }
-    return parts2.join(" ");
+  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
+    }));
   }
-  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";
+  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
+    }));
   }
-  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";
+  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
+    }));
   }
-  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";
+  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
+    }));
   }
-  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";
+  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
+    }));
   }
-  renderBar(score) {
-    const filled = Math.round(score / 10);
-    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  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 shortName(filePath) {
-  const parts2 = filePath.split("/");
-  return parts2[parts2.length - 1] ?? filePath;
+function hashContent2(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
 }
-
-// ../context-engine/dist/chunk-HMKLYBWJ.js
-var import_better_sqlite3 = __toESM(require_lib(), 1);
-var import_fast_glob2 = __toESM(require_out4(), 1);
-import { createHash as createHash2 } from "crypto";
-import { readFile as readFile3, stat } from "fs/promises";
-import { mkdirSync } from "fs";
-import { join as join4 } from "path";
-import { readFile as readFile22 } from "fs/promises";
-import { accessSync } from "fs";
-import { extname as extname2, resolve as resolve2, dirname as dirname6 } from "path";
-import { createHash as createHash22 } from "crypto";
-var SCHEMA_VERSION = 1;
-var PersistentIndex = class {
-  db;
-  config;
+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;
-  constructor(config) {
-    this.rootPath = config.rootPath;
-    this.config = {
-      rootPath: config.rootPath,
-      dbPath: config.dbPath ?? join4(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
+  treeSitterParser = null;
+  treeSitterLoaded = false;
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+  async parseFile(absolutePath, relativePath) {
+    const content = await readFile22(absolutePath, "utf-8");
+    const lines = content.split("\n");
+    const ext2 = extname2(absolutePath).toLowerCase();
+    const language = EXT_LANG[ext2] ?? "unknown";
+    const contentHash = createHash22("sha256").update(content).digest("hex").slice(0, 16);
+    const exports2 = this.extractExports(content, language);
+    const symbols = await this.extractSymbols(content, lines, absolutePath, relativePath, language);
+    const imports = this.extractImports(content, absolutePath, relativePath, language);
+    const callEdges = this.extractCallEdges(content, symbols, absolutePath);
+    const fileId = `file:${relativePath}`;
+    const file = {
+      id: fileId,
+      path: absolutePath,
+      relativePath,
+      language,
+      lineCount: lines.length,
+      exports: exports2,
+      content
     };
-    const dbDir = join4(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();
+    return { file, symbols, imports, callEdges, contentHash };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // SCHEMA
+  // EXPORTS
   // ═══════════════════════════════════════════════════════════════════════════
-  initSchema() {
-    const version3 = this.getSchemaVersion();
-    if (version3 === 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());
+  extractExports(content, language) {
+    if (language !== "typescript" && language !== "javascript") return [];
+    const exports2 = [];
+    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]) exports2.push(match2[1]);
+    }
+    if (/export\s+default\s/.test(content) && !exports2.includes("default")) {
+      exports2.push("default");
+    }
+    const reExportRe = /export\s+\{([^}]+)\}\s+from/g;
+    for (const match2 of content.matchAll(reExportRe)) {
+      for (const sym of match2[1].split(",")) {
+        const name2 = sym.trim().split(/\s+as\s+/).pop()?.trim();
+        if (name2) exports2.push(name2);
+      }
+    }
+    return [...new Set(exports2)];
   }
-  getSchemaVersion() {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SYMBOLS
+  // ═══════════════════════════════════════════════════════════════════════════
+  async extractSymbols(content, lines, absolutePath, relativePath, language) {
+    const tsSymbols = await this.tryTreeSitter(content, absolutePath);
+    if (tsSymbols) {
+      return tsSymbols.map((sym, i2) => ({
+        id: `sym:${relativePath}:${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, relativePath, language);
+  }
+  async tryTreeSitter(content, filePath) {
+    if (!this.treeSitterLoaded) {
+      this.treeSitterLoaded = true;
+      try {
+        const mod = await Promise.resolve().then(() => (init_tree_sitter_H5E7LKR4(), tree_sitter_H5E7LKR4_exports));
+        this.treeSitterParser = mod.parseWithTreeSitter;
+      } catch {
+        this.treeSitterParser = null;
+      }
+    }
+    if (!this.treeSitterParser) return null;
     try {
-      const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get("schema_version");
-      return row ? Number.parseInt(row.value, 10) : 0;
+      const ext2 = extname2(filePath).toLowerCase();
+      const symbols = await this.treeSitterParser(content, ext2);
+      if (!symbols || symbols.length === 0) return null;
+      return flattenCodeSymbols(symbols);
     } catch {
-      return 0;
+      return null;
     }
   }
-  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;
+  extractSymbolsRegex(content, lines, absolutePath, relativePath, 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 name2 = match2[1];
+          if (!name2) continue;
+          const line = content.slice(0, match2.index).split("\n").length;
+          const endLine = this.findBlockEnd(lines, line - 1);
+          symbols.push({
+            id: `sym:${relativePath}:${name2}:${line}`,
+            name: name2,
+            kind,
+            filePath: absolutePath,
+            startLine: line,
+            endLine,
+            exported: this.isExported(content, name2, 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 (language === "python") {
+      const re = /^(?:async\s+)?(?:def|class)\s+(\w+)/gm;
+      for (const match2 of content.matchAll(re)) {
+        const name2 = match2[1];
+        const kind = match2[0].includes("class") ? "class" : "function";
+        const line = content.slice(0, match2.index).split("\n").length;
+        symbols.push({
+          id: `sym:${relativePath}:${name2}:${line}`,
+          name: name2,
+          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()
+        });
+      }
+    }
+    return symbols;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // INCREMENTAL INDEXING
+  // IMPORTS
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * 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);
+  extractImports(content, absolutePath, relativePath, language) {
+    const imports = [];
+    const fileId = `file:${relativePath}`;
+    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
+        });
       }
-    }
-    const deleted = [];
-    for (const storedPath of storedHashes.keys()) {
-      if (!currentPaths.has(storedPath)) {
-        deleted.push(storedPath);
+      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
+        });
       }
     }
-    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);
+    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 parsedFiles = [];
-    for (const relPath of changed) {
-      const absPath = join4(this.rootPath, relPath);
-      try {
-        const parsed = await parser4.parseFile(absPath, relPath);
-        parsedFiles.push(parsed);
-      } catch {
+    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
+          });
+        }
       }
     }
-    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 };
+    return imports;
   }
-  /**
-   * 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 = join4(this.rootPath, relPath);
+  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 braceMatch[1].split(",").map((s) => {
+      const parts2 = s.trim().split(/\s+as\s+/);
+      return parts2[parts2.length - 1].trim();
+    }).filter(Boolean);
+  }
+  resolveImportPath(sourcePath, fromFile) {
+    if (!sourcePath.startsWith(".")) return sourcePath;
+    const dir = dirname5(fromFile);
+    const resolved = resolve2(dir, sourcePath);
+    const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+    for (const ext2 of extensions) {
+      const candidate = resolved + ext2;
       try {
-        const parsed = await parser4.parseFile(absPath, relPath);
-        parsedFiles.push(parsed);
+        accessSync(candidate);
+        return candidate;
       } 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
-    };
+    return resolved;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // DATA LOADING (warm start)
+  // CALL EDGES (basic extraction)
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * 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;
+  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 body2 = 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(body2)) {
+          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 edges;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // EMBEDDING STORAGE
+  // HELPERS
   // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Store a chunk embedding (file-level, function-level, etc.)
-   */
-  storeEmbedding(path10, chunkId, chunkType, contentHash, vector, metadata2) {
-    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(metadata2 ?? {}));
-  }
-  /**
-   * 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)
-    };
+  isExported(content, name2, 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+${name2}\\b`);
+    if (re.test(content)) return true;
+    const reExport = new RegExp(`export\\s+\\{[^}]*\\b${name2}\\b[^}]*\\}`);
+    return reExport.test(content);
   }
-  /**
-   * 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)
-    }));
+  countParams(signature) {
+    const parenMatch = signature.match(/\(([^)]*)\)/);
+    if (!parenMatch || !parenMatch[1].trim()) return 0;
+    return parenMatch[1].split(",").length;
   }
-  /**
-   * 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;
+  countBranches(lines, startIdx, endIdx) {
+    let branches = 0;
+    const branchRe = /\b(if|else if|case|for|while|catch|&&|\|\||\?\?)\b/g;
+    for (let i2 = startIdx; i2 < Math.min(endIdx, lines.length); i2++) {
+      const matches = lines[i2].match(branchRe);
+      if (matches) branches += matches.length;
+    }
+    return branches;
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // QUERYING
-  // ═══════════════════════════════════════════════════════════════════════════
-  /**
-   * Get all symbols in a specific file.
-   */
-  getSymbolsForFile(filePath) {
-    return this.loadSymbolsWhere("file_path = ?", [filePath]);
+  findBlockEnd(lines, startIdx) {
+    let depth = 0;
+    let seenOpen = false;
+    for (let i2 = startIdx; i2 < lines.length; i2++) {
+      for (const ch of lines[i2]) {
+        if (ch === "{") {
+          depth++;
+          seenOpen = true;
+        } else if (ch === "}" && seenOpen) {
+          depth--;
+          if (depth <= 0) return i2 + 1;
+        }
+      }
+    }
+    return startIdx + 1;
   }
-  /**
-   * Search symbols by name pattern.
-   */
-  searchSymbols(namePattern, limit = 50) {
-    return this.loadSymbolsWhere("name LIKE ?", [`%${namePattern}%`]).slice(0, limit);
+};
+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));
+    }
   }
-  /**
-   * 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);
+  return flat;
+}
+
+// ../context-engine/dist/chunk-INBCP46U.js
+import * as path5 from "path";
+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;
   }
   /**
-   * Get files that a given file imports.
+   * Synthesize the full context — the complete brain dump for AI agents.
    */
-  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);
+  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
+    };
   }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // CLEANUP
-  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * Close the database connection.
+   * Generate context for a specific file — what an AI agent needs to know
+   * before editing this file.
    */
-  close() {
-    this.db.close();
+  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);
   }
   /**
-   * Wipe all data and rebuild schema.
+   * Generate a compact markdown context document for IDE rules.
+   * This replaces the old static rule generation with intelligence-driven context.
    */
-  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
-    });
-    const hashes = [];
-    const limit = this.config.maxFiles;
-    for (const relPath of files.slice(0, limit)) {
-      const absPath = join4(this.rootPath, relPath);
-      try {
-        const fileStat = await stat(absPath);
-        if (fileStat.size > this.config.maxFileSize) continue;
-        const content = await readFile3(absPath, "utf-8");
-        hashes.push({
-          relativePath: relPath.replace(/\\/g, "/"),
-          contentHash: hashContent2(content),
-          sizeBytes: fileStat.size,
-          modifiedMs: Math.floor(fileStat.mtimeMs)
-        });
-      } catch {
+  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(", ")}`);
+    }
+    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("");
     }
-    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
-      });
+    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("");
     }
-    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
-          );
+    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}`);
         }
-        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
-          );
+        if (playbook.mustVerify.length > 0) {
+          lines.push(`**Verify**: ${playbook.mustVerify.join(", ")}`);
         }
-        for (const edge of callEdges) {
-          insertCallEdge.run(
-            edge.callerId,
-            edge.calleeId,
-            edge.callerName,
-            edge.calleeName,
-            edge.callerFile,
-            edge.calleeFile
-          );
+        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("");
       }
-    });
-    txn();
+    }
+    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");
   }
-  removeFiles(relativePaths) {
-    if (relativePaths.length === 0) return;
-    const txn = this.db.transaction(() => {
-      for (const relPath of relativePaths) {
-        const absPath = join4(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();
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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)
+    };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE — Loading
+  // RULES SUMMARY
   // ═══════════════════════════════════════════════════════════════════════════
-  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
-    }));
+  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
+      };
+    });
   }
-  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
-    }));
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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]}`)
+    };
   }
-  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
-    }));
+  // ═══════════════════════════════════════════════════════════════════════════
+  // FILE CONTEXTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildFileContexts() {
+    const contexts = /* @__PURE__ */ new Map();
+    for (const file of this.data.files) {
+      contexts.set(file.relativePath, this.buildSingleFileContext(file));
+    }
+    return contexts;
   }
-  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
-    }));
+  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
+    };
   }
-  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
-    }));
+  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";
   }
-  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
-    }));
+  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;
+    }
   }
-  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
-    }));
+  findRelatedFiles(file, role) {
+    const related = [];
+    const dir = path5.dirname(file.relativePath);
+    for (const other of this.data.files) {
+      if (other.path === file.path) continue;
+      if (path5.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;
   }
-};
-function hashContent2(content) {
-  return createHash2("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;
+  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.`);
+    }
+    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;
   }
-  async parseFile(absolutePath, relativePath) {
-    const content = await readFile22(absolutePath, "utf-8");
-    const lines = content.split("\n");
-    const ext2 = extname2(absolutePath).toLowerCase();
-    const language = EXT_LANG[ext2] ?? "unknown";
-    const contentHash = createHash22("sha256").update(content).digest("hex").slice(0, 16);
-    const exports2 = this.extractExports(content, language);
-    const symbols = await this.extractSymbols(content, lines, absolutePath, relativePath, language);
-    const imports = this.extractImports(content, absolutePath, relativePath, language);
-    const callEdges = this.extractCallEdges(content, symbols, absolutePath);
-    const fileId = `file:${relativePath}`;
-    const file = {
-      id: fileId,
-      path: absolutePath,
-      relativePath,
-      language,
-      lineCount: lines.length,
-      exports: exports2,
-      content
-    };
-    return { file, symbols, imports, callEdges, contentHash };
+  // ═══════════════════════════════════════════════════════════════════════════
+  // TASK PLAYBOOKS
+  // ═══════════════════════════════════════════════════════════════════════════
+  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"]
+    });
+    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"]
+    });
+    return playbooks;
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // EXPORTS
+  // VERIFICATION STEPS
   // ═══════════════════════════════════════════════════════════════════════════
-  extractExports(content, language) {
-    if (language !== "typescript" && language !== "javascript") return [];
-    const exports2 = [];
-    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]) exports2.push(match2[1]);
+  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 (/export\s+default\s/.test(content) && !exports2.includes("default")) {
-      exports2.push("default");
+    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"]
+      });
     }
-    const reExportRe = /export\s+\{([^}]+)\}\s+from/g;
-    for (const match2 of content.matchAll(reExportRe)) {
-      for (const sym of match2[1].split(",")) {
-        const name2 = sym.trim().split(/\s+as\s+/).pop()?.trim();
-        if (name2) exports2.push(name2);
+    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;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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(", ")}`);
       }
     }
-    return [...new Set(exports2)];
+    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) => path5.basename(f.relativePath).replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, "")
+    ));
+    for (const file of sourceFiles) {
+      const baseName = path5.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)
+    };
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // SYMBOLS
+  // HELPERS
   // ═══════════════════════════════════════════════════════════════════════════
-  async extractSymbols(content, lines, absolutePath, relativePath, language) {
-    const tsSymbols = await this.tryTreeSitter(content, absolutePath);
-    if (tsSymbols) {
-      return tsSymbols.map((sym, i2) => ({
-        id: `sym:${relativePath}:${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
-      }));
+  toRelative(filePath) {
+    if (filePath.startsWith(this.rootPath)) {
+      return filePath.slice(this.rootPath.length + 1).replace(/\\/g, "/");
     }
-    return this.extractSymbolsRegex(content, lines, absolutePath, relativePath, language);
+    return filePath.replace(/\\/g, "/");
   }
-  async tryTreeSitter(content, filePath) {
-    if (!this.treeSitterLoaded) {
-      this.treeSitterLoaded = true;
-      try {
-        const mod = await Promise.resolve().then(() => (init_tree_sitter_H5E7LKR4(), tree_sitter_H5E7LKR4_exports));
-        this.treeSitterParser = mod.parseWithTreeSitter;
-      } catch {
-        this.treeSitterParser = null;
+};
+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 parts2 = [];
+        if (depCount > 0) {
+          const critical = depCount > 10 ? " \u2014 changes here have wide blast radius" : "";
+          parts2.push(`${depCount} file${depCount > 1 ? "s" : ""} depend on this${critical}`);
+        }
+        if (depsOnCount > 0) {
+          parts2.push(`it imports from ${depsOnCount} file${depsOnCount > 1 ? "s" : ""}`);
+        }
+        paragraphs.push({
+          heading: "Dependencies",
+          text: parts2.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
+        });
       }
+      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 = extname2(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, relativePath, 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 name2 = match2[1];
-          if (!name2) continue;
-          const line = content.slice(0, match2.index).split("\n").length;
-          const endLine = this.findBlockEnd(lines, line - 1);
-          symbols.push({
-            id: `sym:${relativePath}:${name2}:${line}`,
-            name: name2,
-            kind,
-            filePath: absolutePath,
-            startLine: line,
-            endLine,
-            exported: this.isExported(content, name2, 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 name2 = match2[1];
-        const kind = match2[0].includes("class") ? "class" : "function";
-        const line = content.slice(0, match2.index).split("\n").length;
-        symbols.push({
-          id: `sym:${relativePath}:${name2}:${line}`,
-          name: name2,
-          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, relativePath, language) {
-    const imports = [];
-    const fileId = `file:${relativePath}`;
-    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 parts2 = s.trim().split(/\s+as\s+/);
-      return parts2[parts2.length - 1].trim();
-    }).filter(Boolean);
+    return {
+      filePath,
+      roleSummary,
+      paragraphs,
+      quickFacts,
+      warnings,
+      relatedFiles,
+      overlays
+    };
   }
-  resolveImportPath(sourcePath, fromFile) {
-    if (!sourcePath.startsWith(".")) return sourcePath;
-    const dir = dirname6(fromFile);
-    const resolved = resolve2(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 body2 = 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(body2)) {
-          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");
+  }
+  /**
+   * 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 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}`);
+    }
+    return lines.join("\n");
   }
   // ═══════════════════════════════════════════════════════════════════════════
-  // HELPERS
+  // PRIVATE
   // ═══════════════════════════════════════════════════════════════════════════
-  isExported(content, name2, 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+${name2}\\b`);
-    if (re.test(content)) return true;
-    const reExport = new RegExp(`export\\s+\\{[^}]*\\b${name2}\\b[^}]*\\}`);
-    return reExport.test(content);
+  buildRoleSummary(filePath, role, ctx) {
+    const parts2 = [];
+    switch (role) {
+      case "service":
+        parts2.push("Business logic service");
+        break;
+      case "route-handler":
+        parts2.push("API route handler");
+        break;
+      case "component":
+        parts2.push("UI component");
+        break;
+      case "repository":
+        parts2.push("Data access layer");
+        break;
+      case "middleware":
+        parts2.push("Request middleware");
+        break;
+      case "test":
+        parts2.push("Test file");
+        break;
+      case "config":
+        parts2.push("Configuration");
+        break;
+      case "type":
+        parts2.push("Type definitions");
+        break;
+      case "util":
+        parts2.push("Utility module");
+        break;
+      case "entry":
+        parts2.push("Entry point");
+        break;
+      default:
+        parts2.push("Source file");
+    }
+    if (ctx.fileContext) {
+      if (ctx.fileContext.layer) parts2.push(`in ${ctx.fileContext.layer} layer`);
+      if (ctx.fileContext.dependedOnBy.length > 10) parts2.push("(high-impact)");
+    }
+    return parts2.join(" ");
   }
-  countParams(signature) {
-    const parenMatch = signature.match(/\(([^)]*)\)/);
-    if (!parenMatch || !parenMatch[1].trim()) return 0;
-    return parenMatch[1].split(",").length;
+  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";
   }
-  countBranches(lines, startIdx, endIdx) {
-    let branches = 0;
-    const branchRe = /\b(if|else if|case|for|while|catch|&&|\|\||\?\?)\b/g;
-    for (let i2 = startIdx; i2 < Math.min(endIdx, lines.length); i2++) {
-      const matches = lines[i2].match(branchRe);
-      if (matches) branches += matches.length;
-    }
-    return branches;
+  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";
   }
-  findBlockEnd(lines, startIdx) {
-    let depth = 0;
-    let seenOpen = false;
-    for (let i2 = startIdx; i2 < lines.length; i2++) {
-      for (const ch of lines[i2]) {
-        if (ch === "{") {
-          depth++;
-          seenOpen = true;
-        } else if (ch === "}" && seenOpen) {
-          depth--;
-          if (depth <= 0) return i2 + 1;
-        }
-      }
-    }
-    return startIdx + 1;
+  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";
   }
-};
-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));
-    }
+  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";
   }
-  return flat;
+  renderBar(score) {
+    const filled = Math.round(score / 10);
+    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  }
+};
+function shortName(filePath) {
+  const parts2 = filePath.split("/");
+  return parts2[parts2.length - 1] ?? filePath;
 }
 
 // ../context-engine/dist/index.js
@@ -291808,7 +291808,7 @@ var ContextEngine = class {
 // src/server.ts
 init_dist();
 
-// ../subscriptions/dist/chunk-SS6N4T7D.js
+// ../subscriptions/dist/chunk-PGIBAA63.js
 var PLAN_IDS = ["free", "pro", "team", "enterprise"];
 var PLAN_RANK = Object.fromEntries(
   PLAN_IDS.map((id, index2) => [id, index2])
@@ -291877,19 +291877,16 @@ if (typeof process !== "undefined") {
 var PLAN_DEFINITIONS = {
   free: {
     displayName: "Free",
-    tagline: "Real scans and truthpack on your repo \u2014 upgrade when you want automation.",
+    tagline: "$0 forever, no credit card required.",
     monthlyPriceUsd: 0,
     priceLabel: "$0",
     billingInterval: "month",
     badgeToken: "tier-free",
     highlights: [
-      "5 scans per day",
-      "Full scan summaries (counts & severity) on every run",
-      "Deep detail (why, fix, snippets) on 5 findings per scan",
-      "Ship score & basic report",
-      "PDF/HTML scan reports (CLI)",
-      "Firewall observe mode",
-      "No AI auto-fix on Free (upgrade to apply fixes)"
+      "Unlimited scans",
+      "Issue counts + severity",
+      "Trust score",
+      "All 16 detection engines"
     ],
     bestFor: "Individual devs exploring AI code quality",
     popular: false,
@@ -291899,29 +291896,33 @@ var PLAN_DEFINITIONS = {
   },
   pro: {
     displayName: "Pro",
-    tagline: "Full verification for you and your team \u2014 fix, prove, and gate AI-generated code.",
-    monthlyPriceUsd: 19,
-    priceLabel: "$19/mo",
+    tagline: "$9.99/mo or $99.99/yr (save 17%).",
+    monthlyPriceUsd: 9.99,
+    priceLabel: "$9.99/mo",
     billingInterval: "month",
     badgeToken: "tier-pro",
     highlights: [
-      "Everything in Free, plus unlimited daily scans, full finding details, and AI auto-fix",
-      "Sandbox, Reality Mode, ISL Studio, and advanced scan / proof workflows",
-      "CommitShield, CI integration, PR comments, status checks, and merge protection",
-      "Context Engine, Firewall Agent, MCP server, and API access",
-      "Cloud sync, proof history, verified badges, and priority support"
+      "Unlimited scans",
+      "Full evidence reports",
+      "Line-level detail (file, line number, fix path)",
+      "All 16 detection engines + fix suggestions",
+      "Fix suggestions",
+      "Scan history & trends",
+      "SARIF export for CI/CD",
+      "CLI with no throttle",
+      "Project-wide scanning"
     ],
-    bestFor: "Builders and teams shipping AI-assisted code with proof",
+    bestFor: "Builders shipping AI-assisted code with proof",
     popular: true,
-    cta: "Get Pro",
+    cta: "Start Pro",
     ctaVariant: "default",
     supportLevel: "standard"
   },
   team: {
     displayName: "Team",
     tagline: "Verification-first building at scale.",
-    monthlyPriceUsd: 19,
-    priceLabel: "$19/mo",
+    monthlyPriceUsd: 9.99,
+    priceLabel: "$9.99/mo",
     billingInterval: "month",
     badgeToken: "tier-team",
     highlights: [
@@ -291944,8 +291945,8 @@ var PLAN_DEFINITIONS = {
   enterprise: {
     displayName: "Enterprise",
     tagline: "Teams, compliance, and scale.",
-    monthlyPriceUsd: 19,
-    priceLabel: "$19/mo",
+    monthlyPriceUsd: 9.99,
+    priceLabel: "$9.99/mo",
     billingInterval: "month",
     badgeToken: "tier-enterprise",
     highlights: [
@@ -292077,6 +292078,7 @@ var PLAN_QUOTAS = {
     maxSeats: 1,
     autoFixesPerMonth: 0,
     scansPerMonth: Infinity,
+    /** Taste-then-gate: daily scan cap enforced server-side for signed-in free users (see server-scan-meter). */
     scansPerDay: 5,
     vibePromptGenerationsPerMonth: 0,
     workflowCopiesPerMonth: 0,
@@ -292302,10 +292304,11 @@ var ENTITLEMENTS = {
 };
 var FREE_SET = /* @__PURE__ */ new Set([
   // ── Core free features (product spec: sign-in required for all) ──────────
-  // Free users ONLY get: 5 scans/day, kickoff, doctor, roast, reports,
+  // Free users get: unlimited scans (summary only), kickoff, doctor, roast, reports,
   // truthpack, codegraph, wikicode, vibe flow. Everything else is PAID.
+  // For new features, prefer isPaidPlan() over adding new entitlement keys.
   ENTITLEMENTS.SCAN_BASIC,
-  // 5 scans/day (quota enforced server-side)
+  // unlimited scans, gated evidence (summary only for free)
   ENTITLEMENTS.KICKOFF_CONNECT,
   // vibecheckAI-Official kickoff / connect my project
   ENTITLEMENTS.DOCTOR,
@@ -292525,6 +292528,210 @@ if (typeof process !== "undefined") {
     }
   }
 }
+var ENTITLEMENTS_V2 = {
+  // ── FREE ────────────────────────────────────────────────────────────────
+  SCAN: "v2.scan",
+  SCAN_WORKSPACE: "v2.scan_workspace",
+  // ── PRO ─────────────────────────────────────────────────────────────────
+  GITHUB_ACTION: "v2.github_action",
+  FULL_EVIDENCE: "v2.full_evidence",
+  SARIF_EXPORT: "v2.sarif_export",
+  API_ACCESS: "v2.api_access",
+  PRIORITY_ENGINES: "v2.priority_engines",
+  ADVANCED_REPORT: "v2.advanced_report",
+  AUTOFIX: "v2.autofix",
+  CI_BLOCK: "v2.ci_block",
+  CONTEXT_ENGINE: "v2.context_engine",
+  SANDBOX: "v2.sandbox",
+  SUPPORT: "v2.support",
+  // ── TEAM ────────────────────────────────────────────────────────────────
+  TEAM_COLLABORATION: "v2.team_collaboration",
+  // ── ENTERPRISE ──────────────────────────────────────────────────────────
+  ENTERPRISE_COMPLIANCE: "v2.enterprise_compliance"
+};
+var LEGACY_TO_V2_MAP = {
+  // ── FREE tier keys ──────────────────────────────────────────────────────
+  [ENTITLEMENTS.SCAN_BASIC]: ENTITLEMENTS_V2.SCAN,
+  [ENTITLEMENTS.SCAN_UNLIMITED]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.SHIP_SCORE]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.DOCTOR]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.ROAST]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.REPORTS_HTML]: ENTITLEMENTS_V2.SCAN,
+  [ENTITLEMENTS.CHECKPOINT]: null,
+  // Not visible in UI
+  [ENTITLEMENTS.MISSIONS_VIEW]: null,
+  // Missions merged into autofix
+  [ENTITLEMENTS.TEMPLATES_BROWSE]: null,
+  // Templates culled (P8)
+  [ENTITLEMENTS.TEMPLATES_INSTALL]: null,
+  // Templates culled (P8)
+  [ENTITLEMENTS.TRUTHPACK_GENERATE]: null,
+  // Truthpack culled (P8)
+  [ENTITLEMENTS.TRUTHPACK_VALIDATE]: null,
+  // Truthpack culled (P8)
+  [ENTITLEMENTS.KICKOFF_CONNECT]: null,
+  // Merged into onboarding
+  [ENTITLEMENTS.CODEGRAPH_VIEW]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.WIKICODE_VIEW]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.VIBE_FLOW]: null,
+  // Culled (P8)
+  [ENTITLEMENTS.REVIEW_WORKFLOWS]: null,
+  // Culled (P8)
+  [ENTITLEMENTS.FLOW_WORKFLOWS]: null,
+  // Culled (P8)
+  [ENTITLEMENTS.ATLAS]: ENTITLEMENTS_V2.SCAN_WORKSPACE,
+  [ENTITLEMENTS.ISL_STUDIO]: null,
+  // Free to browse; generation is credit-based
+  [ENTITLEMENTS.REPORTS_PDF]: ENTITLEMENTS_V2.ADVANCED_REPORT,
+  // ── PRO tier keys ───────────────────────────────────────────────────────
+  [ENTITLEMENTS.FORGE_BASIC]: null,
+  // Forge culled
+  [ENTITLEMENTS.PROMPT_TEMPLATES_BASIC]: null,
+  // Part of context_engine
+  [ENTITLEMENTS.WATCH_MODE]: null,
+  // Not actively used
+  [ENTITLEMENTS.TRACE_ANALYSIS]: null,
+  // Not visible
+  [ENTITLEMENTS.FIREWALL_OBSERVE]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.FILE_LOCKING]: null,
+  // Feature incomplete
+  [ENTITLEMENTS.AUTOFIX_LIMITED]: ENTITLEMENTS_V2.AUTOFIX,
+  [ENTITLEMENTS.COMMIT_SHIELD_WARNINGS]: ENTITLEMENTS_V2.AUTOFIX,
+  [ENTITLEMENTS.GITHUB_ACTION_WARN]: ENTITLEMENTS_V2.GITHUB_ACTION,
+  [ENTITLEMENTS.VIBE_PROMPT]: null,
+  // Culled
+  [ENTITLEMENTS.PROOF_VIEW]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.AUTOFIX_UNLIMITED]: ENTITLEMENTS_V2.AUTOFIX,
+  [ENTITLEMENTS.AUTOFIX_APPLY]: ENTITLEMENTS_V2.AUTOFIX,
+  [ENTITLEMENTS.REALITY_MODE]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.COMMIT_SHIELD_FULL]: ENTITLEMENTS_V2.CI_BLOCK,
+  [ENTITLEMENTS.COMMIT_SHIELD_AUDITOR]: null,
+  // Auditor culled
+  [ENTITLEMENTS.REPORTS_EXECUTIVE]: ENTITLEMENTS_V2.ADVANCED_REPORT,
+  [ENTITLEMENTS.CLOUD_SYNC]: null,
+  // Implicit in paid
+  [ENTITLEMENTS.CERTIFY]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.BADGE_VERIFIED]: null,
+  // Badges culled (P8)
+  [ENTITLEMENTS.PROOF_HISTORY]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.SHAREABLE_REPORTS]: ENTITLEMENTS_V2.ADVANCED_REPORT,
+  [ENTITLEMENTS.PRIORITY_SUPPORT]: ENTITLEMENTS_V2.SUPPORT,
+  [ENTITLEMENTS.GITHUB_ACTION]: ENTITLEMENTS_V2.GITHUB_ACTION,
+  [ENTITLEMENTS.CI_INTEGRATION]: ENTITLEMENTS_V2.GITHUB_ACTION,
+  [ENTITLEMENTS.API_ACCESS]: ENTITLEMENTS_V2.API_ACCESS,
+  [ENTITLEMENTS.PR_COMMENTS]: ENTITLEMENTS_V2.GITHUB_ACTION,
+  [ENTITLEMENTS.STATUS_CHECKS]: ENTITLEMENTS_V2.GITHUB_ACTION,
+  [ENTITLEMENTS.BRANCH_PROTECTION]: ENTITLEMENTS_V2.CI_BLOCK,
+  [ENTITLEMENTS.WEBHOOK_INTEGRATION]: null,
+  // Webhooks culled
+  [ENTITLEMENTS.CI_GATE_BLOCK]: ENTITLEMENTS_V2.CI_BLOCK,
+  [ENTITLEMENTS.CONTEXT_ENGINE]: ENTITLEMENTS_V2.CONTEXT_ENGINE,
+  [ENTITLEMENTS.ISL_VERIFY]: null,
+  // ISL culled
+  [ENTITLEMENTS.DEEP_SCAN]: ENTITLEMENTS_V2.PRIORITY_ENGINES,
+  [ENTITLEMENTS.SCAN_PRO_ENGINES]: ENTITLEMENTS_V2.PRIORITY_ENGINES,
+  [ENTITLEMENTS.DRIFT_DETECTION]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.CHAOS_AGENT]: null,
+  // Chaos culled
+  [ENTITLEMENTS.MODEL_FINGERPRINT]: null,
+  // Model fingerprint culled
+  [ENTITLEMENTS.PROVENANCE_TRACKING]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.FIREWALL_AGENT]: ENTITLEMENTS_V2.FULL_EVIDENCE,
+  [ENTITLEMENTS.FIREWALL_ENFORCE]: ENTITLEMENTS_V2.CI_BLOCK,
+  [ENTITLEMENTS.FIREWALL_LOCKDOWN]: null,
+  // Lockdown not implemented
+  [ENTITLEMENTS.FORGE_EXTENDED]: null,
+  // Forge culled
+  [ENTITLEMENTS.PROMPT_TEMPLATES_PRO]: null,
+  // Part of context_engine
+  [ENTITLEMENTS.AI_GENERATION]: ENTITLEMENTS_V2.SANDBOX,
+  [ENTITLEMENTS.REPLAY_VIEWER_FULL]: null,
+  // Replay culled
+  // ── Sandbox & AI ────────────────────────────────────────────────────────
+  [ENTITLEMENTS.SANDBOX_ACCESS]: ENTITLEMENTS_V2.SANDBOX,
+  [ENTITLEMENTS.SANDBOX_GENERATIONS]: ENTITLEMENTS_V2.SANDBOX,
+  [ENTITLEMENTS.SANDBOX_PREMIUM_MODELS]: null,
+  // Not offered
+  [ENTITLEMENTS.SANDBOX_SLASH_COMMANDS]: ENTITLEMENTS_V2.SANDBOX,
+  [ENTITLEMENTS.SANDBOX_AGENT_MODES]: null,
+  // Agent modes culled
+  [ENTITLEMENTS.SANDBOX_PROOF_BUNDLES]: null,
+  // Proof bundles culled
+  [ENTITLEMENTS.SANDBOX_CLAUDE_SKILLS]: null,
+  // Skills culled
+  [ENTITLEMENTS.AI_CONFIDENCE_METER]: null,
+  // Not visible
+  [ENTITLEMENTS.AI_HALLUCINATION_SHIELD]: null,
+  // Part of core scanning
+  [ENTITLEMENTS.VERIFIED_BUILD_CERT]: null,
+  // Build certs culled
+  // ── Team keys ───────────────────────────────────────────────────────────
+  [ENTITLEMENTS.TEAM_DASHBOARD]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_COLLABORATION]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_CROSS_REPO_SCANNING]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_SHARED_POLICIES]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_PROVENANCE_INSIGHTS]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_ADMIN_POLICY_ENFORCEMENT]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_AUDIT_LOG_EXPORT]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.TEAM_CONTEXT_ENGINE_SHARED]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_PRIORITY_QUEUE]: null,
+  // Not implemented
+  [ENTITLEMENTS.TEAM_ANALYTICS]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_SLACK_ALERTS]: null,
+  // Slack culled
+  [ENTITLEMENTS.TEAM_LEADERBOARDS]: null,
+  // Gamification culled
+  [ENTITLEMENTS.TEAM_BULK_INVITE]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_ROLES]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.TEAM_SCAN_BUDGETS]: null,
+  // Budgeting not implemented
+  // ── Enterprise keys ─────────────────────────────────────────────────────
+  [ENTITLEMENTS.COMPLIANCE_SOC2]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMPLIANCE_HIPAA]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMPLIANCE_PCI_DSS]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMPLIANCE_GDPR]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMPLIANCE_ISO27001]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.SDK_GENERATOR]: null,
+  // SDK gen culled
+  [ENTITLEMENTS.POLICY_ENGINE]: null,
+  // Part of context_engine
+  [ENTITLEMENTS.SSO_SAML]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.ON_PREMISE]: null,
+  // On-premise not offered
+  [ENTITLEMENTS.DEDICATED_SLA]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMMIT_SHIELD_TEAM]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.COMMIT_SHIELD_ENTERPRISE]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.COMMIT_SHIELD_COMPLIANCE]: ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE,
+  [ENTITLEMENTS.ENTERPRISE_MULTI_REPO]: ENTITLEMENTS_V2.TEAM_COLLABORATION,
+  [ENTITLEMENTS.ENTERPRISE_SIGNED_BUNDLES]: null
+  // Not implemented
+};
+var V2_FREE_SET = /* @__PURE__ */ new Set([
+  ENTITLEMENTS_V2.SCAN,
+  ENTITLEMENTS_V2.SCAN_WORKSPACE
+]);
+var V2_PRO_SET = /* @__PURE__ */ new Set([
+  ...V2_FREE_SET,
+  ENTITLEMENTS_V2.GITHUB_ACTION,
+  ENTITLEMENTS_V2.FULL_EVIDENCE,
+  ENTITLEMENTS_V2.SARIF_EXPORT,
+  ENTITLEMENTS_V2.API_ACCESS,
+  ENTITLEMENTS_V2.PRIORITY_ENGINES,
+  ENTITLEMENTS_V2.ADVANCED_REPORT,
+  ENTITLEMENTS_V2.AUTOFIX,
+  ENTITLEMENTS_V2.CI_BLOCK,
+  ENTITLEMENTS_V2.CONTEXT_ENGINE,
+  ENTITLEMENTS_V2.SANDBOX,
+  ENTITLEMENTS_V2.SUPPORT
+]);
+var V2_TEAM_SET = /* @__PURE__ */ new Set([
+  ...V2_PRO_SET,
+  ENTITLEMENTS_V2.TEAM_COLLABORATION
+]);
+var V2_ENTERPRISE_SET = /* @__PURE__ */ new Set([
+  ...V2_TEAM_SET,
+  ENTITLEMENTS_V2.ENTERPRISE_COMPLIANCE
+]);
 var FEATURE_REGISTRY = {
   "Unlimited Auto-Fix": {
     entitlement: ENTITLEMENTS.AUTOFIX_UNLIMITED,
@@ -292761,7 +292968,7 @@ var FEATURE_REGISTRY = {
     entitlement: ENTITLEMENTS.DEEP_SCAN,
     title: "Deep Scan",
     subtitle: "Advanced security analysis",
-    benefits: ["14 engines", "Runtime proof", "Mock detection"],
+    benefits: ["18 production engines", "Runtime proof", "Mock detection"],
     requiredPlan: "pro",
     category: "analysis"
   },
@@ -293997,7 +294204,7 @@ function createScanIdempotencyKey(prefix) {
 // src/mcp-scan-meter-client.ts
 var MCP_SCAN_METER_CLIENT = {
   type: "mcp",
-  version: "24.4.0"
+  version: "24.4.3"
 };
 
 // src/server.ts
@@ -294171,10 +294378,10 @@ async function runRoast(targetPath, opts) {
   const preset = opts?.enginePreset ?? "full";
   const engineToggles = preset === "full" ? null : ENGINE_FOCUS_PRESETS[preset]();
   const { findings, workspaceRoot } = await executeScan(targetPath, engineToggles);
-  const score = findings.length > 0 ? computeTrustScore(findings).overall : 100;
+  const score = findings.length > 0 ? computeTrustScore(findings).overall : void 0;
   const roast = formatRoastHtml(findings, {
     workspaceRoot,
-    score,
+    ...score !== void 0 ? { score } : {},
     displayLimit: 25
   });
   return roast.text;