@vibecheck-ai/mcp 24.5.9 → 24.6.3

package/dist/index.js

@@ -5752,7 +5752,7 @@ var require_util = __commonJS({
       return path10;
     }
     exports2.normalize = normalize4;
-    function join9(aRoot, aPath) {
+    function join10(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -5784,7 +5784,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports2.join = join9;
+    exports2.join = join10;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -5957,7 +5957,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index2 + 1);
           }
         }
-        sourceURL = join9(urlGenerate(parsed), sourceURL);
+        sourceURL = join10(urlGenerate(parsed), sourceURL);
       }
       return normalize4(sourceURL);
     }
@@ -219544,7 +219544,7 @@ var require_bindings = __commonJS({
     var fs7 = __require("fs");
     var path10 = __require("path");
     var fileURLToPath2 = require_file_uri_to_path();
-    var join9 = path10.join;
+    var join10 = path10.join;
     var dirname8 = path10.dirname;
     var exists2 = fs7.accessSync && function(path11) {
       try {
@@ -219604,7 +219604,7 @@ var require_bindings = __commonJS({
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
       var tries = [], i2 = 0, l = opts.try.length, n, b, err2;
       for (; i2 < l; i2++) {
-        n = join9.apply(
+        n = join10.apply(
           null,
           opts.try[i2].map(function(p) {
             return opts[p] || p;
@@ -219665,7 +219665,7 @@ var require_bindings = __commonJS({
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists2(join9(dir, "package.json")) || exists2(join9(dir, "node_modules"))) {
+        if (exists2(join10(dir, "package.json")) || exists2(join10(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -219674,7 +219674,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join9(dir, "..");
+        dir = join10(dir, "..");
       }
     };
   }
@@ -221655,7 +221655,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 dirname4 } from "path";
+import { join as join3, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
 async function initParser() {
   if (ParserClass) return ParserClass;
@@ -221795,7 +221795,7 @@ var init_chunk_3ZE34DAJ = __esm({
       SymbolKind2["Export"] = "export";
       return SymbolKind2;
     })(SymbolKind || {});
-    GRAMMAR_DIR = join3(dirname4(fileURLToPath(import.meta.url)), "../../../../node_modules/tree-sitter-wasms/out");
+    GRAMMAR_DIR = join3(dirname5(fileURLToPath(import.meta.url)), "../../../../node_modules/tree-sitter-wasms/out");
     EXT_TO_GRAMMAR = {
       ".ts": "typescript",
       ".tsx": "tsx",
@@ -278750,10 +278750,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { runOnFiles } from "@vibecheck-ai/cli/runner";
 import {
   computeTrustScore,
@@ -289088,6 +289085,845 @@ rules:
       match: "src/repositories/**"
 `;
 
+// ../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;
+  }
+  /**
+   * Synthesize the full context — the complete brain dump for AI agents.
+   */
+  synthesize() {
+    const projectIdentity = this.buildProjectIdentity();
+    const archRules = this.buildArchRuleSummary();
+    const activeViolations = this.ruleResult?.violations || [];
+    const codebaseDNA = this.buildDNASummary();
+    const fileContexts = this.buildFileContexts();
+    const taskPlaybooks = this.buildTaskPlaybooks();
+    const verificationSteps = this.buildVerificationSteps();
+    const riskBriefing = this.buildRiskBriefing();
+    return {
+      version: "2.0.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectIdentity,
+      architecturalRules: archRules,
+      activeViolations,
+      codebaseDNA,
+      fileContexts,
+      taskPlaybooks,
+      verificationSteps,
+      riskBriefing
+    };
+  }
+  /**
+   * Generate context for a specific file — what an AI agent needs to know
+   * before editing this file.
+   */
+  synthesizeForFile(filePath) {
+    const rel = this.toRelative(filePath);
+    const file = this.data.files.find((f) => f.relativePath === rel || f.path === filePath);
+    if (!file) return null;
+    return this.buildSingleFileContext(file);
+  }
+  /**
+   * Generate a compact markdown context document for IDE rules.
+   * This replaces the old static rule generation with intelligence-driven context.
+   */
+  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}\``);
+      }
+      lines.push("");
+    }
+    if (ctx.riskBriefing.securityConcerns.length > 0 || ctx.riskBriefing.testGaps.length > 0) {
+      lines.push("## Risk Areas");
+      for (const concern of ctx.riskBriefing.securityConcerns) {
+        lines.push(`- ${concern}`);
+      }
+      for (const gap of ctx.riskBriefing.testGaps.slice(0, 5)) {
+        lines.push(`- ${gap}`);
+      }
+      lines.push("");
+    }
+    if (ctx.projectIdentity.noGoZones.length > 0) {
+      lines.push("## No-Go Zones");
+      for (const zone of ctx.projectIdentity.noGoZones) {
+        lines.push(`- ${zone}`);
+      }
+      lines.push("");
+    }
+    if (ctx.taskPlaybooks.length > 0) {
+      lines.push("## Task Playbooks");
+      for (const playbook of ctx.taskPlaybooks) {
+        lines.push(`### ${playbook.taskType}`);
+        for (const step of playbook.steps) {
+          lines.push(`1. ${step}`);
+        }
+        if (playbook.mustVerify.length > 0) {
+          lines.push(`**Verify**: ${playbook.mustVerify.join(", ")}`);
+        }
+        lines.push("");
+      }
+    }
+    if (ctx.verificationSteps.length > 0) {
+      lines.push("## Verification Protocol");
+      for (const step of ctx.verificationSteps) {
+        lines.push(`### On ${step.trigger}`);
+        for (const check of step.checks) {
+          lines.push(`- ${check}`);
+        }
+        if (step.commands.length > 0) {
+          lines.push(`**Run**: \`${step.commands.join(" && ")}\``);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("## Codebase Health");
+    lines.push(`- **Overall**: ${this.dna.healthScore.overall}/100`);
+    const dims = this.dna.healthScore.dimensions;
+    lines.push(`- Architecture: ${dims.architecture} | Tests: ${dims.testCoverage} | Conventions: ${dims.conventions} | Dependencies: ${dims.dependencies}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("<!-- context-engine:v2 -->");
+    return lines.join("\n");
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // IDENTITY
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildProjectIdentity() {
+    const fp = this.dna.fingerprint;
+    const stack = [fp.framework, fp.language, fp.orm, fp.validator, fp.authLib, fp.router].filter(Boolean).join(" | ");
+    const keyPatterns = this.dna.patterns.map((p) => p.name);
+    const criticalPaths = this.dna.hotspots.slice(0, 5).map((h) => h.file);
+    const noGoZones = [];
+    if (this.ruleResult) {
+      const errorRules = this.ruleResult.violations.filter((v) => v.severity === "error");
+      const uniqueMessages = [...new Set(errorRules.map((v) => v.message))];
+      noGoZones.push(...uniqueMessages.slice(0, 5));
+    }
+    for (const cycle of this.graph.cycles) {
+      noGoZones.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}...`);
+    }
+    const architecture = this.dna.conventions.filter((c) => c.area === "structure").map((c) => c.description).join("; ") || fp.framework;
+    return {
+      name: fp.name,
+      stack,
+      architecture,
+      keyPatterns,
+      criticalPaths,
+      noGoZones: noGoZones.slice(0, 10)
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RULES SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildArchRuleSummary() {
+    if (!this.ruleResult) return [];
+    const breakdown = this.ruleResult.ruleBreakdown;
+    return Object.entries(breakdown).map(([ruleId, count]) => {
+      const violation = this.ruleResult.violations.find((v) => v.ruleId === ruleId);
+      return {
+        id: ruleId,
+        name: violation?.ruleName || ruleId,
+        type: "import_forbidden",
+        severity: violation?.severity || "warning",
+        scope: violation?.sourceSymbol.filePath || "",
+        description: violation?.message || "",
+        violationCount: count
+      };
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // DNA SUMMARY
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildDNASummary() {
+    return {
+      conventions: this.dna.conventions.filter((c) => c.confidence > 0.5).map((c) => c.description),
+      patterns: this.dna.patterns.map((p) => `${p.name}: ${p.description}`),
+      boundaries: this.dna.boundaries.filter((b) => b.importCount > 3).map((b) => `${b.from} \u2192 ${b.to} (${b.importCount} imports${b.isCircular ? ", CIRCULAR" : ""})`),
+      hotFiles: this.dna.hotspots.slice(0, 10).map((h) => h.file),
+      riskAreas: this.dna.riskMap.filter((r) => r.riskLevel === "critical" || r.riskLevel === "high").map((r) => `${r.file}: ${r.factors[0]}`)
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // FILE CONTEXTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildFileContexts() {
+    const contexts = /* @__PURE__ */ new Map();
+    for (const file of this.data.files) {
+      contexts.set(file.relativePath, this.buildSingleFileContext(file));
+    }
+    return contexts;
+  }
+  buildSingleFileContext(file) {
+    const rel = file.relativePath;
+    const role = this.classifyRole(file);
+    const graphNode = this.graph.nodes.find((n) => n.relativePath === rel);
+    const layer = graphNode?.layer;
+    const dependsOn = this.graph.edges.filter((e) => e.from === rel).map((e) => e.to);
+    const dependedOnBy = this.graph.edges.filter((e) => e.to === rel).map((e) => e.from);
+    const applicableRules = [];
+    if (this.ruleResult) {
+      for (const v of this.ruleResult.violations) {
+        if (v.sourceSymbol.filePath.includes(rel) || v.targetSymbol && v.targetSymbol.filePath.includes(rel)) {
+          if (!applicableRules.includes(v.ruleId)) applicableRules.push(v.ruleId);
+        }
+      }
+    }
+    const conventions = this.dna.conventions.filter((c) => this.conventionAppliesToFile(c.area, file)).map((c) => c.description);
+    const patterns = this.dna.patterns.filter((p) => p.fileMatches.some((m) => m === rel)).map((p) => p.name);
+    const riskEntry = this.dna.riskMap.find((r) => r.file === rel);
+    const riskLevel = riskEntry?.riskLevel || "low";
+    const relatedFiles = this.findRelatedFiles(file, role).slice(0, 8);
+    const editGuidance = this.generateEditGuidance(file, role, layer, dependedOnBy, conventions);
+    return {
+      filePath: file.path,
+      role,
+      layer,
+      dependsOn,
+      dependedOnBy,
+      applicableRules,
+      conventions,
+      patterns,
+      riskLevel,
+      relatedFiles,
+      editGuidance
+    };
+  }
+  classifyRole(file) {
+    const rel = file.relativePath.toLowerCase();
+    if (rel.includes(".test.") || rel.includes(".spec.") || rel.includes("__tests__")) return "test";
+    if (rel.includes("fixture") || rel.includes("mock")) return "fixture";
+    if (rel.includes("migration")) return "migration";
+    if (rel.match(/\.(css|scss|less|styl)$/)) return "style";
+    if (rel.includes(".config.") || rel.includes("config/") || rel === "tsconfig.json") return "config";
+    if (rel.includes("middleware")) return "middleware";
+    if (rel.includes("/api/") || rel.includes("route")) return "route-handler";
+    if (rel.includes("service") || rel.includes("Service")) return "service";
+    if (rel.includes("repositor") || rel.includes("Repositor")) return "repository";
+    if (rel.endsWith(".tsx") && !rel.includes("page.")) return "component";
+    if (rel.includes("/types") || rel.endsWith(".d.ts")) return "type";
+    if (rel.includes("util") || rel.includes("helper") || rel.includes("lib/")) return "util";
+    if (rel.includes("script") || rel.includes("bin/")) return "script";
+    if (rel.match(/^(src\/)?index\.|^(src\/)?main\.|^(src\/)?app\./)) return "entry";
+    return "unknown";
+  }
+  conventionAppliesToFile(area, file) {
+    switch (area) {
+      case "naming":
+        return true;
+      case "imports":
+        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
+      case "exports":
+        return file.exports.length > 0;
+      case "testing":
+        return file.relativePath.includes(".test.") || file.relativePath.includes(".spec.");
+      case "error-handling":
+        return !file.relativePath.includes(".test.");
+      case "types":
+        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
+      default:
+        return true;
+    }
+  }
+  findRelatedFiles(file, role) {
+    const related = [];
+    const dir = 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;
+  }
+  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;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // VERIFICATION STEPS
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildVerificationSteps() {
+    const fp = this.dna.fingerprint;
+    const steps = [];
+    if (fp.language === "TypeScript") {
+      steps.push({
+        trigger: "Any TypeScript file change",
+        checks: ["TypeScript compilation succeeds", "No new type errors introduced"],
+        commands: [fp.packageManager === "pnpm" ? "pnpm run check-types" : "npm run check-types"],
+        artifacts: []
+      });
+    }
+    if (fp.testRunner) {
+      steps.push({
+        trigger: "Any source file change",
+        checks: ["Related tests pass", "No test regressions"],
+        commands: [`${fp.packageManager} run test`],
+        artifacts: ["test-results.json"]
+      });
+    }
+    if (fp.router) {
+      steps.push({
+        trigger: "Route handler added or modified",
+        checks: ["Route responds with correct status", "Auth middleware is applied", "Input validation works"],
+        commands: ["vibecheck scan"],
+        artifacts: ["truthpack/routes.json"]
+      });
+    }
+    steps.push({
+      trigger: "Any source file change",
+      checks: ["No new architecture rule violations", "No new circular dependencies"],
+      commands: ["vibecheck arch-rules"],
+      artifacts: []
+    });
+    return steps;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // RISK BRIEFING
+  // ═══════════════════════════════════════════════════════════════════════════
+  buildRiskBriefing() {
+    const criticalFiles = this.dna.hotspots.filter((h) => h.score > 30).slice(0, 10).map((h) => h.file);
+    const recentViolations = this.ruleResult?.violations.filter((v) => v.severity === "error").slice(0, 10) || [];
+    const securityConcerns = [];
+    for (const risk of this.dna.riskMap) {
+      if (risk.riskLevel === "critical") {
+        securityConcerns.push(`${risk.file}: ${risk.factors.join(", ")}`);
+      }
+    }
+    const testGaps = [];
+    const sourceFiles = this.data.files.filter(
+      (f) => !f.relativePath.includes(".test.") && !f.relativePath.includes(".spec.") && (f.relativePath.endsWith(".ts") || f.relativePath.endsWith(".tsx")) && !f.relativePath.includes("config") && !f.relativePath.includes(".d.ts")
+    );
+    const testFiles = this.data.files.filter(
+      (f) => f.relativePath.includes(".test.") || f.relativePath.includes(".spec.")
+    );
+    const testedBases = new Set(testFiles.map(
+      (f) => 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 deadInFile = ctx.callGraph.stats.deadFunctions.filter(
+        (d) => d.filePath.includes(shortName(filePath))
+      );
+      if (deadInFile.length > 0) {
+        for (const dead of deadInFile) {
+          warnings.push({
+            message: `\`${dead.name}\` appears to be dead code (exported but never called)`,
+            severity: "info",
+            action: "Verify this function is not called via dynamic dispatch or external consumers, then consider removing it"
+          });
+        }
+      }
+    }
+    if (ctx.temporal) {
+      const hotspot = ctx.temporal.changeHotspots.find((h) => filePath.includes(h.file) || h.file.includes(shortName(filePath)));
+      if (hotspot) {
+        const daysSince = Math.round((Date.now() - new Date(hotspot.lastChanged).getTime()) / 864e5);
+        paragraphs.push({
+          heading: "Recent Activity",
+          text: `Changed ${hotspot.commits} times in the last ${ctx.temporal.stats.analysisWindowDays} days by ${hotspot.authors} author${hotspot.authors !== 1 ? "s" : ""}. Last modified ${daysSince} day${daysSince !== 1 ? "s" : ""} ago.`,
+          importance: hotspot.commits > 10 ? "high" : "medium"
+        });
+        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
+          });
+        }
+      }
+    }
+    if (fc && fc.editGuidance.length > 0) {
+      paragraphs.push({
+        heading: "Edit Guidance",
+        text: fc.editGuidance.join(" "),
+        importance: "medium"
+      });
+    }
+    return {
+      filePath,
+      roleSummary,
+      paragraphs,
+      quickFacts,
+      warnings,
+      relatedFiles,
+      overlays
+    };
+  }
+  /**
+   * Generate a compact markdown explanation for AI agent consumption.
+   */
+  explainForAgent(filePath, ctx) {
+    const explanation = this.explain(filePath, ctx);
+    const lines = [];
+    lines.push(`## ${shortName(filePath)}: ${explanation.roleSummary}`);
+    lines.push("");
+    if (explanation.quickFacts.length > 0) {
+      lines.push(explanation.quickFacts.map((f) => `**${f.label}**: ${f.value}`).join(" \xB7 "));
+      lines.push("");
+    }
+    for (const p of explanation.paragraphs.filter((p2) => p2.importance === "critical" || p2.importance === "high")) {
+      lines.push(`### ${p.heading}`);
+      lines.push(p.text);
+      lines.push("");
+    }
+    if (explanation.warnings.length > 0) {
+      lines.push("### Warnings");
+      for (const w of explanation.warnings) {
+        const icon = w.severity === "error" ? "MUST FIX" : w.severity === "warning" ? "SHOULD FIX" : "NOTE";
+        lines.push(`- **[${icon}]** ${w.message} \u2014 ${w.action}`);
+      }
+      lines.push("");
+    }
+    if (explanation.relatedFiles.length > 0) {
+      lines.push("### Related Files");
+      for (const rf of explanation.relatedFiles.slice(0, 5)) {
+        lines.push(`- \`${rf.filePath}\` \u2014 ${rf.reason}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate IDE overlay data for the VS Code extension to consume.
+   */
+  getIDEOverlays(filePath, ctx) {
+    const explanation = this.explain(filePath, ctx);
+    return explanation.overlays;
+  }
+  /**
+   * 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");
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRIVATE
+  // ═══════════════════════════════════════════════════════════════════════════
+  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(" ");
+  }
+  explainArchScore(score, dna) {
+    if (score >= 80) return `Strong architecture with ${dna.patterns.length} recognized patterns`;
+    if (score >= 50) return `Moderate architecture \u2014 ${dna.patterns.length} patterns detected, room to strengthen boundaries`;
+    return "Architecture needs attention \u2014 few recognized patterns or boundaries";
+  }
+  explainTestScore(score) {
+    if (score >= 80) return "Good test coverage across source files";
+    if (score >= 50) return "Moderate coverage \u2014 some source files lack tests";
+    return "Low test coverage \u2014 many exported modules have no test files";
+  }
+  explainConventionScore(score, dna) {
+    const strong = dna.conventions.filter((c) => c.confidence > 0.6).length;
+    if (score >= 80) return `${strong} strong conventions enforced consistently`;
+    if (score >= 50) return `${strong} conventions detected but inconsistently applied`;
+    return "Few consistent conventions \u2014 codebase style varies across files";
+  }
+  explainDependencyScore(score, dna) {
+    const circular = dna.boundaries.filter((b) => b.isCircular).length;
+    if (score >= 80) return "Clean dependency graph with no circular dependencies";
+    if (circular > 0) return `${circular} circular dependency${circular > 1 ? "ies" : "y"} detected \u2014 these increase coupling and make code harder to reason about`;
+    return "Dependency health needs improvement";
+  }
+  renderBar(score) {
+    const filled = Math.round(score / 10);
+    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  }
+};
+function shortName(filePath) {
+  const parts2 = filePath.split("/");
+  return parts2[parts2.length - 1] ?? filePath;
+}
+
 // ../context-engine/dist/chunk-HMKLYBWJ.js
 var import_better_sqlite3 = __toESM(require_lib(), 1);
 var import_fast_glob2 = __toESM(require_out4(), 1);
@@ -289097,7 +289933,7 @@ 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 { extname as extname2, resolve as resolve2, dirname as dirname6 } from "path";
 import { createHash as createHash22 } from "crypto";
 var SCHEMA_VERSION = 1;
 var PersistentIndex = class {
@@ -289995,7 +290831,7 @@ var DefaultFileParser = class {
   }
   resolveImportPath(sourcePath, fromFile) {
     if (!sourcePath.startsWith(".")) return sourcePath;
-    const dir = dirname5(fromFile);
+    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) {
@@ -290105,845 +290941,6 @@ function flattenCodeSymbols(symbols) {
   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;
-  }
-  /**
-   * Synthesize the full context — the complete brain dump for AI agents.
-   */
-  synthesize() {
-    const projectIdentity = this.buildProjectIdentity();
-    const archRules = this.buildArchRuleSummary();
-    const activeViolations = this.ruleResult?.violations || [];
-    const codebaseDNA = this.buildDNASummary();
-    const fileContexts = this.buildFileContexts();
-    const taskPlaybooks = this.buildTaskPlaybooks();
-    const verificationSteps = this.buildVerificationSteps();
-    const riskBriefing = this.buildRiskBriefing();
-    return {
-      version: "2.0.0",
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectIdentity,
-      architecturalRules: archRules,
-      activeViolations,
-      codebaseDNA,
-      fileContexts,
-      taskPlaybooks,
-      verificationSteps,
-      riskBriefing
-    };
-  }
-  /**
-   * Generate context for a specific file — what an AI agent needs to know
-   * before editing this file.
-   */
-  synthesizeForFile(filePath) {
-    const rel = this.toRelative(filePath);
-    const file = this.data.files.find((f) => f.relativePath === rel || f.path === filePath);
-    if (!file) return null;
-    return this.buildSingleFileContext(file);
-  }
-  /**
-   * Generate a compact markdown context document for IDE rules.
-   * This replaces the old static rule generation with intelligence-driven context.
-   */
-  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}\``);
-      }
-      lines.push("");
-    }
-    if (ctx.riskBriefing.securityConcerns.length > 0 || ctx.riskBriefing.testGaps.length > 0) {
-      lines.push("## Risk Areas");
-      for (const concern of ctx.riskBriefing.securityConcerns) {
-        lines.push(`- ${concern}`);
-      }
-      for (const gap of ctx.riskBriefing.testGaps.slice(0, 5)) {
-        lines.push(`- ${gap}`);
-      }
-      lines.push("");
-    }
-    if (ctx.projectIdentity.noGoZones.length > 0) {
-      lines.push("## No-Go Zones");
-      for (const zone of ctx.projectIdentity.noGoZones) {
-        lines.push(`- ${zone}`);
-      }
-      lines.push("");
-    }
-    if (ctx.taskPlaybooks.length > 0) {
-      lines.push("## Task Playbooks");
-      for (const playbook of ctx.taskPlaybooks) {
-        lines.push(`### ${playbook.taskType}`);
-        for (const step of playbook.steps) {
-          lines.push(`1. ${step}`);
-        }
-        if (playbook.mustVerify.length > 0) {
-          lines.push(`**Verify**: ${playbook.mustVerify.join(", ")}`);
-        }
-        lines.push("");
-      }
-    }
-    if (ctx.verificationSteps.length > 0) {
-      lines.push("## Verification Protocol");
-      for (const step of ctx.verificationSteps) {
-        lines.push(`### On ${step.trigger}`);
-        for (const check of step.checks) {
-          lines.push(`- ${check}`);
-        }
-        if (step.commands.length > 0) {
-          lines.push(`**Run**: \`${step.commands.join(" && ")}\``);
-        }
-        lines.push("");
-      }
-    }
-    lines.push("## Codebase Health");
-    lines.push(`- **Overall**: ${this.dna.healthScore.overall}/100`);
-    const dims = this.dna.healthScore.dimensions;
-    lines.push(`- Architecture: ${dims.architecture} | Tests: ${dims.testCoverage} | Conventions: ${dims.conventions} | Dependencies: ${dims.dependencies}`);
-    lines.push("");
-    lines.push("---");
-    lines.push("<!-- context-engine:v2 -->");
-    return lines.join("\n");
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // IDENTITY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildProjectIdentity() {
-    const fp = this.dna.fingerprint;
-    const stack = [fp.framework, fp.language, fp.orm, fp.validator, fp.authLib, fp.router].filter(Boolean).join(" | ");
-    const keyPatterns = this.dna.patterns.map((p) => p.name);
-    const criticalPaths = this.dna.hotspots.slice(0, 5).map((h) => h.file);
-    const noGoZones = [];
-    if (this.ruleResult) {
-      const errorRules = this.ruleResult.violations.filter((v) => v.severity === "error");
-      const uniqueMessages = [...new Set(errorRules.map((v) => v.message))];
-      noGoZones.push(...uniqueMessages.slice(0, 5));
-    }
-    for (const cycle of this.graph.cycles) {
-      noGoZones.push(`Circular dependency: ${cycle.nodes.slice(0, 3).join(" \u2192 ")}...`);
-    }
-    const architecture = this.dna.conventions.filter((c) => c.area === "structure").map((c) => c.description).join("; ") || fp.framework;
-    return {
-      name: fp.name,
-      stack,
-      architecture,
-      keyPatterns,
-      criticalPaths,
-      noGoZones: noGoZones.slice(0, 10)
-    };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // RULES SUMMARY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildArchRuleSummary() {
-    if (!this.ruleResult) return [];
-    const breakdown = this.ruleResult.ruleBreakdown;
-    return Object.entries(breakdown).map(([ruleId, count]) => {
-      const violation = this.ruleResult.violations.find((v) => v.ruleId === ruleId);
-      return {
-        id: ruleId,
-        name: violation?.ruleName || ruleId,
-        type: "import_forbidden",
-        severity: violation?.severity || "warning",
-        scope: violation?.sourceSymbol.filePath || "",
-        description: violation?.message || "",
-        violationCount: count
-      };
-    });
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // DNA SUMMARY
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildDNASummary() {
-    return {
-      conventions: this.dna.conventions.filter((c) => c.confidence > 0.5).map((c) => c.description),
-      patterns: this.dna.patterns.map((p) => `${p.name}: ${p.description}`),
-      boundaries: this.dna.boundaries.filter((b) => b.importCount > 3).map((b) => `${b.from} \u2192 ${b.to} (${b.importCount} imports${b.isCircular ? ", CIRCULAR" : ""})`),
-      hotFiles: this.dna.hotspots.slice(0, 10).map((h) => h.file),
-      riskAreas: this.dna.riskMap.filter((r) => r.riskLevel === "critical" || r.riskLevel === "high").map((r) => `${r.file}: ${r.factors[0]}`)
-    };
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // FILE CONTEXTS
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildFileContexts() {
-    const contexts = /* @__PURE__ */ new Map();
-    for (const file of this.data.files) {
-      contexts.set(file.relativePath, this.buildSingleFileContext(file));
-    }
-    return contexts;
-  }
-  buildSingleFileContext(file) {
-    const rel = file.relativePath;
-    const role = this.classifyRole(file);
-    const graphNode = this.graph.nodes.find((n) => n.relativePath === rel);
-    const layer = graphNode?.layer;
-    const dependsOn = this.graph.edges.filter((e) => e.from === rel).map((e) => e.to);
-    const dependedOnBy = this.graph.edges.filter((e) => e.to === rel).map((e) => e.from);
-    const applicableRules = [];
-    if (this.ruleResult) {
-      for (const v of this.ruleResult.violations) {
-        if (v.sourceSymbol.filePath.includes(rel) || v.targetSymbol && v.targetSymbol.filePath.includes(rel)) {
-          if (!applicableRules.includes(v.ruleId)) applicableRules.push(v.ruleId);
-        }
-      }
-    }
-    const conventions = this.dna.conventions.filter((c) => this.conventionAppliesToFile(c.area, file)).map((c) => c.description);
-    const patterns = this.dna.patterns.filter((p) => p.fileMatches.some((m) => m === rel)).map((p) => p.name);
-    const riskEntry = this.dna.riskMap.find((r) => r.file === rel);
-    const riskLevel = riskEntry?.riskLevel || "low";
-    const relatedFiles = this.findRelatedFiles(file, role).slice(0, 8);
-    const editGuidance = this.generateEditGuidance(file, role, layer, dependedOnBy, conventions);
-    return {
-      filePath: file.path,
-      role,
-      layer,
-      dependsOn,
-      dependedOnBy,
-      applicableRules,
-      conventions,
-      patterns,
-      riskLevel,
-      relatedFiles,
-      editGuidance
-    };
-  }
-  classifyRole(file) {
-    const rel = file.relativePath.toLowerCase();
-    if (rel.includes(".test.") || rel.includes(".spec.") || rel.includes("__tests__")) return "test";
-    if (rel.includes("fixture") || rel.includes("mock")) return "fixture";
-    if (rel.includes("migration")) return "migration";
-    if (rel.match(/\.(css|scss|less|styl)$/)) return "style";
-    if (rel.includes(".config.") || rel.includes("config/") || rel === "tsconfig.json") return "config";
-    if (rel.includes("middleware")) return "middleware";
-    if (rel.includes("/api/") || rel.includes("route")) return "route-handler";
-    if (rel.includes("service") || rel.includes("Service")) return "service";
-    if (rel.includes("repositor") || rel.includes("Repositor")) return "repository";
-    if (rel.endsWith(".tsx") && !rel.includes("page.")) return "component";
-    if (rel.includes("/types") || rel.endsWith(".d.ts")) return "type";
-    if (rel.includes("util") || rel.includes("helper") || rel.includes("lib/")) return "util";
-    if (rel.includes("script") || rel.includes("bin/")) return "script";
-    if (rel.match(/^(src\/)?index\.|^(src\/)?main\.|^(src\/)?app\./)) return "entry";
-    return "unknown";
-  }
-  conventionAppliesToFile(area, file) {
-    switch (area) {
-      case "naming":
-        return true;
-      case "imports":
-        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
-      case "exports":
-        return file.exports.length > 0;
-      case "testing":
-        return file.relativePath.includes(".test.") || file.relativePath.includes(".spec.");
-      case "error-handling":
-        return !file.relativePath.includes(".test.");
-      case "types":
-        return file.relativePath.endsWith(".ts") || file.relativePath.endsWith(".tsx");
-      default:
-        return true;
-    }
-  }
-  findRelatedFiles(file, role) {
-    const related = [];
-    const dir = 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;
-  }
-  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;
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // 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;
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // VERIFICATION STEPS
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildVerificationSteps() {
-    const fp = this.dna.fingerprint;
-    const steps = [];
-    if (fp.language === "TypeScript") {
-      steps.push({
-        trigger: "Any TypeScript file change",
-        checks: ["TypeScript compilation succeeds", "No new type errors introduced"],
-        commands: [fp.packageManager === "pnpm" ? "pnpm run check-types" : "npm run check-types"],
-        artifacts: []
-      });
-    }
-    if (fp.testRunner) {
-      steps.push({
-        trigger: "Any source file change",
-        checks: ["Related tests pass", "No test regressions"],
-        commands: [`${fp.packageManager} run test`],
-        artifacts: ["test-results.json"]
-      });
-    }
-    if (fp.router) {
-      steps.push({
-        trigger: "Route handler added or modified",
-        checks: ["Route responds with correct status", "Auth middleware is applied", "Input validation works"],
-        commands: ["vibecheck scan"],
-        artifacts: ["truthpack/routes.json"]
-      });
-    }
-    steps.push({
-      trigger: "Any source file change",
-      checks: ["No new architecture rule violations", "No new circular dependencies"],
-      commands: ["vibecheck arch-rules"],
-      artifacts: []
-    });
-    return steps;
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // RISK BRIEFING
-  // ═══════════════════════════════════════════════════════════════════════════
-  buildRiskBriefing() {
-    const criticalFiles = this.dna.hotspots.filter((h) => h.score > 30).slice(0, 10).map((h) => h.file);
-    const recentViolations = this.ruleResult?.violations.filter((v) => v.severity === "error").slice(0, 10) || [];
-    const securityConcerns = [];
-    for (const risk of this.dna.riskMap) {
-      if (risk.riskLevel === "critical") {
-        securityConcerns.push(`${risk.file}: ${risk.factors.join(", ")}`);
-      }
-    }
-    const testGaps = [];
-    const sourceFiles = this.data.files.filter(
-      (f) => !f.relativePath.includes(".test.") && !f.relativePath.includes(".spec.") && (f.relativePath.endsWith(".ts") || f.relativePath.endsWith(".tsx")) && !f.relativePath.includes("config") && !f.relativePath.includes(".d.ts")
-    );
-    const testFiles = this.data.files.filter(
-      (f) => f.relativePath.includes(".test.") || f.relativePath.includes(".spec.")
-    );
-    const testedBases = new Set(testFiles.map(
-      (f) => 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 deadInFile = ctx.callGraph.stats.deadFunctions.filter(
-        (d) => d.filePath.includes(shortName(filePath))
-      );
-      if (deadInFile.length > 0) {
-        for (const dead of deadInFile) {
-          warnings.push({
-            message: `\`${dead.name}\` appears to be dead code (exported but never called)`,
-            severity: "info",
-            action: "Verify this function is not called via dynamic dispatch or external consumers, then consider removing it"
-          });
-        }
-      }
-    }
-    if (ctx.temporal) {
-      const hotspot = ctx.temporal.changeHotspots.find((h) => filePath.includes(h.file) || h.file.includes(shortName(filePath)));
-      if (hotspot) {
-        const daysSince = Math.round((Date.now() - new Date(hotspot.lastChanged).getTime()) / 864e5);
-        paragraphs.push({
-          heading: "Recent Activity",
-          text: `Changed ${hotspot.commits} times in the last ${ctx.temporal.stats.analysisWindowDays} days by ${hotspot.authors} author${hotspot.authors !== 1 ? "s" : ""}. Last modified ${daysSince} day${daysSince !== 1 ? "s" : ""} ago.`,
-          importance: hotspot.commits > 10 ? "high" : "medium"
-        });
-        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
-          });
-        }
-      }
-    }
-    if (fc && fc.editGuidance.length > 0) {
-      paragraphs.push({
-        heading: "Edit Guidance",
-        text: fc.editGuidance.join(" "),
-        importance: "medium"
-      });
-    }
-    return {
-      filePath,
-      roleSummary,
-      paragraphs,
-      quickFacts,
-      warnings,
-      relatedFiles,
-      overlays
-    };
-  }
-  /**
-   * Generate a compact markdown explanation for AI agent consumption.
-   */
-  explainForAgent(filePath, ctx) {
-    const explanation = this.explain(filePath, ctx);
-    const lines = [];
-    lines.push(`## ${shortName(filePath)}: ${explanation.roleSummary}`);
-    lines.push("");
-    if (explanation.quickFacts.length > 0) {
-      lines.push(explanation.quickFacts.map((f) => `**${f.label}**: ${f.value}`).join(" \xB7 "));
-      lines.push("");
-    }
-    for (const p of explanation.paragraphs.filter((p2) => p2.importance === "critical" || p2.importance === "high")) {
-      lines.push(`### ${p.heading}`);
-      lines.push(p.text);
-      lines.push("");
-    }
-    if (explanation.warnings.length > 0) {
-      lines.push("### Warnings");
-      for (const w of explanation.warnings) {
-        const icon = w.severity === "error" ? "MUST FIX" : w.severity === "warning" ? "SHOULD FIX" : "NOTE";
-        lines.push(`- **[${icon}]** ${w.message} \u2014 ${w.action}`);
-      }
-      lines.push("");
-    }
-    if (explanation.relatedFiles.length > 0) {
-      lines.push("### Related Files");
-      for (const rf of explanation.relatedFiles.slice(0, 5)) {
-        lines.push(`- \`${rf.filePath}\` \u2014 ${rf.reason}`);
-      }
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Generate IDE overlay data for the VS Code extension to consume.
-   */
-  getIDEOverlays(filePath, ctx) {
-    const explanation = this.explain(filePath, ctx);
-    return explanation.overlays;
-  }
-  /**
-   * 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");
-  }
-  // ═══════════════════════════════════════════════════════════════════════════
-  // PRIVATE
-  // ═══════════════════════════════════════════════════════════════════════════
-  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(" ");
-  }
-  explainArchScore(score, dna) {
-    if (score >= 80) return `Strong architecture with ${dna.patterns.length} recognized patterns`;
-    if (score >= 50) return `Moderate architecture \u2014 ${dna.patterns.length} patterns detected, room to strengthen boundaries`;
-    return "Architecture needs attention \u2014 few recognized patterns or boundaries";
-  }
-  explainTestScore(score) {
-    if (score >= 80) return "Good test coverage across source files";
-    if (score >= 50) return "Moderate coverage \u2014 some source files lack tests";
-    return "Low test coverage \u2014 many exported modules have no test files";
-  }
-  explainConventionScore(score, dna) {
-    const strong = dna.conventions.filter((c) => c.confidence > 0.6).length;
-    if (score >= 80) return `${strong} strong conventions enforced consistently`;
-    if (score >= 50) return `${strong} conventions detected but inconsistently applied`;
-    return "Few consistent conventions \u2014 codebase style varies across files";
-  }
-  explainDependencyScore(score, dna) {
-    const circular = dna.boundaries.filter((b) => b.isCircular).length;
-    if (score >= 80) return "Clean dependency graph with no circular dependencies";
-    if (circular > 0) return `${circular} circular dependency${circular > 1 ? "ies" : "y"} detected \u2014 these increase coupling and make code harder to reason about`;
-    return "Dependency health needs improvement";
-  }
-  renderBar(score) {
-    const filled = Math.round(score / 10);
-    return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
-  }
-};
-function shortName(filePath) {
-  const parts2 = filePath.split("/");
-  return parts2[parts2.length - 1] ?? filePath;
-}
-
 // ../context-engine/dist/index.js
 import * as fs5 from "fs";
 import * as path6 from "path";
@@ -293677,13 +293674,7 @@ var InputValidator = class {
       errors.push("Null byte detected in path");
       logger.warn("Null byte injection attempt blocked", { input });
     }
-    const suspiciousPatterns = [
-      /\.\.\//,
-      /\.\.\\/,
-      /%2e%2e/i,
-      /%252e/i,
-      /\.\./
-    ];
+    const suspiciousPatterns = [/\.\.\//, /\.\.\\/, /%2e%2e/i, /%252e/i, /\.\./];
     for (const pattern of suspiciousPatterns) {
       if (pattern.test(input)) {
         errors.push(`Suspicious pattern detected: ${pattern}`);
@@ -293732,12 +293723,7 @@ var InputValidator = class {
         break;
       }
     }
-    const scriptPatterns = [
-      /<script/i,
-      /javascript:/i,
-      /on\w+\s*=/i,
-      /<iframe/i
-    ];
+    const scriptPatterns = [/<script/i, /javascript:/i, /on\w+\s*=/i, /<iframe/i];
     for (const pattern of scriptPatterns) {
       if (pattern.test(input)) {
         logger.warn("Potential script injection attempt blocked", { input });
@@ -293885,10 +293871,7 @@ var InputValidator = class {
             }
           }
           if (args2.outcome !== void 0) {
-            const outcomeResult = this.validateEnum(args2.outcome, [
-              "helpful",
-              "not_helpful"
-            ]);
+            const outcomeResult = this.validateEnum(args2.outcome, ["helpful", "not_helpful"]);
             if (!outcomeResult.valid) {
               errors.push(...outcomeResult.errors.map((e) => `outcome: ${e}`));
             }
@@ -293910,7 +293893,9 @@ var InputValidator = class {
           }
         }
         if (args2.enginePreset !== void 0) {
-          const presetResult = this.validateEnum(args2.enginePreset, [...VIBECHECK_SCAN_ENGINE_PRESETS]);
+          const presetResult = this.validateEnum(args2.enginePreset, [
+            ...VIBECHECK_SCAN_ENGINE_PRESETS
+          ]);
           if (!presetResult.valid) {
             errors.push(...presetResult.errors.map((e) => `enginePreset: ${e}`));
           }
@@ -293928,6 +293913,21 @@ var InputValidator = class {
           }
         }
         break;
+      case "vibecheck_ghost": {
+        if (args2.file !== void 0) {
+          const fileResult = this.validatePath(args2.file);
+          if (!fileResult.valid) {
+            errors.push(...fileResult.errors.map((e) => `file: ${e}`));
+          }
+        }
+        if (args2.path !== void 0) {
+          const pathResult = this.validatePath(args2.path);
+          if (!pathResult.valid) {
+            errors.push(...pathResult.errors.map((e) => `path: ${e}`));
+          }
+        }
+        break;
+      }
     }
     if (errors.length > 0) {
       logger.warn("Tool argument validation failed", {
@@ -294001,7 +294001,10 @@ var MCP_TOOLS = [
         path: { type: "string", description: "Workspace root. Defaults to cwd." },
         query: { type: "string", description: "Natural language query." },
         limit: { type: "number", description: "Max results. Default 10." },
-        useSemantic: { type: "boolean", description: "Use semantic search (embeddings) when available. Slower but finds conceptually related code." }
+        useSemantic: {
+          type: "boolean",
+          description: "Use semantic search (embeddings) when available. Slower but finds conceptually related code."
+        }
       },
       required: ["query"]
     }
@@ -294024,7 +294027,11 @@ var MCP_TOOLS = [
       properties: {
         path: { type: "string", description: "Workspace root. Defaults to cwd." },
         file: { type: "string", description: "File path that was (or was not) helpful." },
-        outcome: { type: "string", enum: ["helpful", "not_helpful"], description: "User feedback." }
+        outcome: {
+          type: "string",
+          enum: ["helpful", "not_helpful"],
+          description: "User feedback."
+        }
       },
       required: ["file", "outcome"]
     }
@@ -294098,7 +294105,11 @@ var MCP_TOOLS = [
       type: "object",
       properties: {
         path: { type: "string", description: "Destination path." },
-        type: { type: "string", enum: ["component", "api", "hook", "test"], description: "Type of code to forge." },
+        type: {
+          type: "string",
+          enum: ["component", "api", "hook", "test"],
+          description: "Type of code to forge."
+        },
         name: { type: "string", description: "Name of the component/api/hook." }
       },
       required: ["type", "name"]
@@ -294110,7 +294121,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." },
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        },
         targetUrl: { type: "string", description: "Base URL to test." }
       }
     }
@@ -294121,7 +294135,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294131,8 +294148,15 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." },
-        mode: { type: "string", enum: ["enforce", "observe", "off"], description: "Firewall mode to set." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        },
+        mode: {
+          type: "string",
+          enum: ["enforce", "observe", "off"],
+          description: "Firewall mode to set."
+        }
       },
       required: ["mode"]
     }
@@ -294149,13 +294173,30 @@ var MCP_TOOLS = [
       required: ["action"]
     }
   },
+  {
+    name: "vibecheck_ghost",
+    description: "Ghost Mode \u2014 symbolic execution trace showing how AI-generated code will break at runtime without running it. Returns a line-by-line trace with verdicts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file: {
+          type: "string",
+          description: "File path to trace (relative to workspace or absolute)."
+        }
+      },
+      required: ["file"]
+    }
+  },
   {
     name: "vibecheck_docguard",
     description: "Documentation quality analysis (orphaned, stale, or duplicate docs).",
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294165,7 +294206,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294175,7 +294219,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294185,7 +294232,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." },
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        },
         out: { type: "string", description: "Output path for the truthpack." }
       }
     }
@@ -294196,7 +294246,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." },
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        },
         branch: { type: "string", description: "Branch to compare against." }
       }
     }
@@ -294207,7 +294260,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294218,7 +294274,10 @@ var MCP_TOOLS = [
       type: "object",
       properties: {
         intent: { type: "string", description: "Description of the feature to build." },
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       },
       required: ["intent"]
     }
@@ -294229,7 +294288,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace or project root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace or project root path. Defaults to current directory."
+        }
       }
     }
   },
@@ -294263,9 +294325,19 @@ var MCP_TOOLS = [
       type: "object",
       properties: {
         path: { type: "string", description: "Project path. Defaults to current directory." },
-        severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"], description: "Filter by severity." },
-        engine: { type: "string", description: 'Filter by engine ID (e.g. "phantom_dep", "ghost_route").' },
-        file: { type: "string", description: "Filter findings to a specific file or directory path." }
+        severity: {
+          type: "string",
+          enum: ["critical", "high", "medium", "low", "info"],
+          description: "Filter by severity."
+        },
+        engine: {
+          type: "string",
+          description: 'Filter by engine ID (e.g. "phantom_dep", "ghost_route").'
+        },
+        file: {
+          type: "string",
+          description: "Filter findings to a specific file or directory path."
+        }
       }
     }
   },
@@ -294319,7 +294391,10 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Workspace root path. Defaults to current directory." }
+        path: {
+          type: "string",
+          description: "Workspace root path. Defaults to current directory."
+        }
       }
     }
   }
@@ -294470,7 +294545,7 @@ function createScanIdempotencyKey(prefix) {
 // src/mcp-scan-meter-client.ts
 var MCP_SCAN_METER_CLIENT = {
   type: "mcp",
-  version: "24.5.9"
+  version: "24.6.3"
 };
 
 // src/server.ts
@@ -294626,10 +294701,7 @@ async function runGuard(targetPath) {
 var MCP_TOOL_TIMEOUT_MS = 18e4;
 function withTimeout(promise, ms, label) {
   return new Promise((resolve6, reject) => {
-    const timer = setTimeout(
-      () => reject(new Error(`${label} timed out after ${ms / 1e3}s`)),
-      ms
-    );
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms / 1e3}s`)), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
@@ -294758,10 +294830,8 @@ async function handleCallToolRequest(request, runtimeOverrides = {}) {
   }
   const validation = InputValidator.validateToolArgs(name2, args2);
   if (!validation.valid) {
-    return buildErrorResponse(
-      `Invalid arguments for ${name2}:
-${validation.errors.join("\n")}`
-    );
+    return buildErrorResponse(`Invalid arguments for ${name2}:
+${validation.errors.join("\n")}`);
   }
   const BILLABLE_ENGINE_TOOLS = /* @__PURE__ */ new Set(["vibecheck_scan", "vibecheck_score"]);
   if (BILLABLE_ENGINE_TOOLS.has(name2)) {
@@ -294804,9 +294874,14 @@ ${validation.errors.join("\n")}`
   const recordMcpBillableUsage = async (toolKey) => {
     const tok = process.env.VIBECHECK_TOKEN?.trim();
     if (!tok || shouldSkipServerScanMetering()) return { ok: true };
-    const r = await postServerScanRecord(tok, MCP_SCAN_METER_CLIENT, createScanIdempotencyKey(toolKey), {
-      scanType: toolKey.replace(/^mcp-/, "")
-    });
+    const r = await postServerScanRecord(
+      tok,
+      MCP_SCAN_METER_CLIENT,
+      createScanIdempotencyKey(toolKey),
+      {
+        scanType: toolKey.replace(/^mcp-/, "")
+      }
+    );
     if (!r.ok) {
       return { ok: false, message: r.error };
     }
@@ -294828,9 +294903,18 @@ ${validation.errors.join("\n")}`
           await engine.initialize(data);
           return engine.getProactiveContext({ focusedFile });
         };
-        const context = await withTimeout(run2(), MCP_TOOL_TIMEOUT_MS, "vibecheck_context_proactive");
+        const context = await withTimeout(
+          run2(),
+          MCP_TOOL_TIMEOUT_MS,
+          "vibecheck_context_proactive"
+        );
         return {
-          content: [{ type: "text", text: typeof context === "string" ? context : JSON.stringify(context, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: typeof context === "string" ? context : JSON.stringify(context, null, 2)
+            }
+          ]
         };
       }
       case "vibecheck_context_intent": {
@@ -294877,12 +294961,16 @@ ${validation.errors.join("\n")}`
         const file = args2?.file;
         const outcome = args2?.outcome;
         if (!file || !outcome) {
-          return buildErrorResponse('vibecheck_context_feedback requires "file" and "outcome" (helpful|not_helpful)');
+          return buildErrorResponse(
+            'vibecheck_context_feedback requires "file" and "outcome" (helpful|not_helpful)'
+          );
         }
         const feedbackFile = normalizeRelativeWorkspaceFilePath(file, "file");
         await runtime.recordFeedback(targetPath, feedbackFile, outcome);
         return {
-          content: [{ type: "text", text: JSON.stringify({ ok: true, file: feedbackFile, outcome }) }]
+          content: [
+            { type: "text", text: JSON.stringify({ ok: true, file: feedbackFile, outcome }) }
+          ]
         };
       }
       case "vibecheck_roast": {
@@ -295002,6 +295090,31 @@ ${validation.errors.join("\n")}`
           ]
         };
       }
+      case "vibecheck_ghost": {
+        const fileArg = args2.file;
+        if (!fileArg || typeof fileArg !== "string") {
+          return buildErrorResponse('vibecheck_ghost requires "file"');
+        }
+        let relFile;
+        try {
+          relFile = normalizeRelativeWorkspaceFilePath(fileArg, "file");
+        } catch (e) {
+          return buildErrorResponse(e instanceof Error ? e.message : "Invalid file path");
+        }
+        const absFile = path9.join(targetPath, relFile);
+        if (!fs6.existsSync(absFile) || !fs6.statSync(absFile).isFile()) {
+          return buildErrorResponse(`Not a file: ${relFile}`);
+        }
+        const { runGhostTrace } = await import("@vibecheck/engines");
+        const trace = await withTimeout(
+          runGhostTrace({ workspaceRoot: targetPath, filePath: absFile }),
+          MCP_TOOL_TIMEOUT_MS,
+          "vibecheck_ghost"
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(trace, null, 2) }]
+        };
+      }
       // ── Platform Unification Tool Handlers ──────────────────────────────
       case "vibecheck_trust_score": {
         const result = await withTimeout(
@@ -295040,10 +295153,7 @@ ${validation.errors.join("\n")}`
           const fileFilter = args2.file;
           filtered = filtered.filter((f) => f.file?.includes(fileFilter));
         }
-        const lines = [
-          `## Findings (${filtered.length} of ${gatedReport.summary.total})`,
-          ""
-        ];
+        const lines = [`## Findings (${filtered.length} of ${gatedReport.summary.total})`, ""];
         for (const f of filtered.slice(0, 50)) {
           const loc = f.file ? `${f.file}${f.line ? `:${f.line}` : ""}` : "unknown";
           lines.push(`- **[${f.severity.toUpperCase()}]** ${f.message}`);
@@ -295095,16 +295205,22 @@ ${validation.errors.join("\n")}`
         const token = process.env.VIBECHECK_TOKEN?.trim();
         if (!token) {
           return {
-            content: [{
-              type: "text",
-              text: JSON.stringify({
-                ok: false,
-                message: "Authentication required to dismiss findings across surfaces. Set VIBECHECK_TOKEN or run `vibecheck auth login`.",
-                localOnly: true,
-                findingId,
-                reason
-              }, null, 2)
-            }]
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    ok: false,
+                    message: "Authentication required to dismiss findings across surfaces. Set VIBECHECK_TOKEN or run `vibecheck auth login`.",
+                    localOnly: true,
+                    findingId,
+                    reason
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
           };
         }
         try {
@@ -295112,7 +295228,7 @@ ${validation.errors.join("\n")}`
           const resp = await fetch(`${apiBase}/api/v1/findings/${findingId}`, {
             method: "PATCH",
             headers: {
-              "Authorization": `Bearer ${token}`,
+              Authorization: `Bearer ${token}`,
               "Content-Type": "application/json"
             },
             body: JSON.stringify({ resolved: true })
@@ -295121,31 +295237,37 @@ ${validation.errors.join("\n")}`
             return buildErrorResponse(`Failed to dismiss finding: HTTP ${resp.status}`);
           }
           return {
-            content: [{
-              type: "text",
-              text: `Finding \`${findingId}\` dismissed. Reason: ${reason}
+            content: [
+              {
+                type: "text",
+                text: `Finding \`${findingId}\` dismissed. Reason: ${reason}
 This change is synced across all surfaces.`
-            }]
+              }
+            ]
           };
         } catch (err2) {
-          return buildErrorResponse(`Failed to dismiss finding: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          return buildErrorResponse(
+            `Failed to dismiss finding: ${err2 instanceof Error ? err2.message : String(err2)}`
+          );
         }
       }
       case "vibecheck_history": {
         const token = process.env.VIBECHECK_TOKEN?.trim();
         if (!token) {
           return {
-            content: [{
-              type: "text",
-              text: "Scan history requires authentication. Set VIBECHECK_TOKEN or run `vibecheck auth login`."
-            }]
+            content: [
+              {
+                type: "text",
+                text: "Scan history requires authentication. Set VIBECHECK_TOKEN or run `vibecheck auth login`."
+              }
+            ]
           };
         }
         try {
           const apiBase = process.env.VIBECHECK_API_URL || "https://api.vibecheckai.dev";
           const limit = args2.limit ?? 10;
           const resp = await fetch(`${apiBase}/api/v1/scans/recent?limit=${limit}`, {
-            headers: { "Authorization": `Bearer ${token}` }
+            headers: { Authorization: `Bearer ${token}` }
           });
           if (!resp.ok) {
             return buildErrorResponse(`Failed to fetch scan history: HTTP ${resp.status}`);
@@ -295153,7 +295275,14 @@ This change is synced across all surfaces.`
           const body2 = await resp.json();
           const scans = body2.data ?? [];
           if (scans.length === 0) {
-            return { content: [{ type: "text", text: "No scan history found. Run `vibecheck scan .` to create your first scan." }] };
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No scan history found. Run `vibecheck scan .` to create your first scan."
+                }
+              ]
+            };
           }
           const lines = [`## Scan History (${scans.length} most recent)`, ""];
           for (const s of scans) {
@@ -295164,7 +295293,9 @@ This change is synced across all surfaces.`
           }
           return { content: [{ type: "text", text: lines.join("\n") }] };
         } catch (err2) {
-          return buildErrorResponse(`Failed to fetch history: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          return buildErrorResponse(
+            `Failed to fetch history: ${err2 instanceof Error ? err2.message : String(err2)}`
+          );
         }
       }
       case "vibecheck_engines": {
@@ -295247,7 +295378,9 @@ This change is synced across all surfaces.`
           };
         } catch (error) {
           const err2 = error;
-          return buildErrorResponse(`CLI Execution Error: ${err2.message ?? err2.stdout ?? err2.stderr ?? String(error)}`);
+          return buildErrorResponse(
+            `CLI Execution Error: ${err2.message ?? err2.stdout ?? err2.stderr ?? String(error)}`
+          );
         }
       }
       default:
@@ -295263,7 +295396,7 @@ function createMcpServer(runtimeOverrides = {}) {
   const server2 = new Server(
     {
       name: "vibecheck-mcp",
-      version: "24.5.9"
+      version: "24.6.3"
     },
     {
       capabilities: {