slopbrick 0.18.2 → 0.18.3

package/dist/index.cjs

@@ -35284,10 +35284,10 @@ function parseSvelte(source) {
   const ast = parseScriptContent(script.content, isTypeScriptScript(script.openTag));
   return { ast, source };
 }
-function cacheEnabled() {
+function legacyCacheEnabled() {
   return process.env.SLOP_AUDIT_CACHE === "1" || process.env.SLOP_AUDIT_CACHE === "true";
 }
-function cacheRoot() {
+function legacyCacheRoot() {
   const override = process.env.SLOP_AUDIT_CACHE_ROOT;
   if (override) return override;
   return (0, import_path2.join)(process.cwd(), ".slopbrick", "cache", "ast");
@@ -35295,11 +35295,11 @@ function cacheRoot() {
 function hashContent(content) {
   return (0, import_crypto.createHash)("md5").update(content, "utf-8").digest("hex");
 }
-function cachePath2(content) {
-  return (0, import_path2.join)(cacheRoot(), `${hashContent(content)}.json`);
+function cachePathWithRoot(content, root) {
+  return (0, import_path2.join)(root, `${hashContent(content)}.json`);
 }
-async function readCache2(filePath, content) {
-  const path = cachePath2(content);
+async function readCacheWithRoot(filePath, content, root) {
+  const path = cachePathWithRoot(content, root);
   try {
     await (0, import_promises.access)(path);
     const raw = await (0, import_promises.readFile)(path, "utf8");
@@ -35312,8 +35312,8 @@ async function readCache2(filePath, content) {
   }
   return void 0;
 }
-async function writeCache(content, result) {
-  const path = cachePath2(content);
+async function writeCacheWithRoot(content, result, root) {
+  const path = cachePathWithRoot(content, root);
   await (0, import_promises.mkdir)((0, import_path2.dirname)(path), { recursive: true });
   await (0, import_promises.writeFile)(path, JSON.stringify(result), "utf8");
 }
@@ -35344,15 +35344,17 @@ function parseSource(source, filePath) {
       return parseWithSwc(source, filePath);
   }
 }
-async function parseFile(filePath) {
+async function parseFile(filePath, opts) {
   const source = await (0, import_promises.readFile)(filePath, "utf-8");
-  if (cacheEnabled()) {
-    const cached = await readCache2(filePath, source);
+  const useCache = opts?.cache?.enabled ?? legacyCacheEnabled();
+  const cacheDir = opts?.cache?.root ?? legacyCacheRoot();
+  if (useCache) {
+    const cached = await readCacheWithRoot(filePath, source, cacheDir);
     if (cached) return cached;
   }
   const result = parseSource(source, filePath);
-  if (cacheEnabled()) {
-    await writeCache(source, result);
+  if (useCache) {
+    await writeCacheWithRoot(source, result, cacheDir);
   }
   return result;
 }
@@ -45790,8 +45792,8 @@ var init_git = __esm({
 });
 
 // src/engine/cache-incremental.ts
-function loadCache(cachePath4) {
-  const abs = (0, import_node_path12.isAbsolute)(cachePath4) ? cachePath4 : (0, import_node_path12.resolve)(process.cwd(), cachePath4);
+function loadCache(cachePath3) {
+  const abs = (0, import_node_path12.isAbsolute)(cachePath3) ? cachePath3 : (0, import_node_path12.resolve)(process.cwd(), cachePath3);
   if (!(0, import_node_fs13.existsSync)(abs)) return void 0;
   try {
     const raw = (0, import_node_fs13.readFileSync)(abs, "utf-8");
@@ -45802,8 +45804,8 @@ function loadCache(cachePath4) {
     return void 0;
   }
 }
-function saveCache(cachePath4, cache) {
-  const abs = (0, import_node_path12.isAbsolute)(cachePath4) ? cachePath4 : (0, import_node_path12.resolve)(process.cwd(), cachePath4);
+function saveCache(cachePath3, cache) {
+  const abs = (0, import_node_path12.isAbsolute)(cachePath3) ? cachePath3 : (0, import_node_path12.resolve)(process.cwd(), cachePath3);
   (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(abs), { recursive: true });
   const tmp = abs + ".tmp";
   if ((0, import_node_fs13.existsSync)(tmp)) {
@@ -47147,6 +47149,12 @@ var init_signal_strength2 = __esm({
 });
 
 // src/engine/worker.ts
+function buildParserCacheConfig(cwd) {
+  const envVal = process.env.SLOP_AUDIT_CACHE;
+  const enabled = envVal === "1" || envVal === "true";
+  const root = process.env.SLOP_AUDIT_CACHE_ROOT ?? (0, import_node_path14.join)(cwd, ".slopbrick", "cache", "ast");
+  return { enabled, root };
+}
 function applyRuleOverrides(issues, rules) {
   const result = [];
   for (const issue of issues) {
@@ -47161,6 +47169,7 @@ function applyRuleOverrides(issues, rules) {
   return result;
 }
 async function scanFile(filePath, config, registry, cwd = process.cwd()) {
+  const cache = buildParserCacheConfig(cwd);
   const ext = (0, import_node_path13.extname)(filePath).toLowerCase();
   const UNSUPPORTED_LANGS = /* @__PURE__ */ new Set([
     ".swift",
@@ -47191,7 +47200,7 @@ async function scanFile(filePath, config, registry, cwd = process.cwd()) {
     };
   }
   try {
-    const { ast, source } = await parseFile(filePath);
+    const { ast, source } = await parseFile(filePath, { cache });
     const facts = extractFacts(filePath, ast, source, config.supportsRsc ?? true, config.framework ?? "react", config);
     const activeRegistry = registry ?? new RuleRegistry();
     if (!registry) {
@@ -47278,12 +47287,13 @@ function collectStyleSources(facts) {
   }
   return sources;
 }
-var import_node_worker_threads, import_node_path13;
+var import_node_worker_threads, import_node_path13, import_node_path14;
 var init_worker = __esm({
   "src/engine/worker.ts"() {
     "use strict";
     import_node_worker_threads = require("worker_threads");
     import_node_path13 = require("path");
+    import_node_path14 = require("path");
     init_dist2();
     init_visitor();
     init_registry();
@@ -47401,7 +47411,7 @@ function migrateFlywheelState(state) {
   };
 }
 function loadFlywheelState(cwd) {
-  const path = (0, import_node_path14.join)(cwd, FLYWHEEL_DIR, STATE_FILE);
+  const path = (0, import_node_path15.join)(cwd, FLYWHEEL_DIR, STATE_FILE);
   if (!(0, import_node_fs15.existsSync)(path)) {
     return migrateFlywheelState({});
   }
@@ -47413,9 +47423,9 @@ function loadFlywheelState(cwd) {
   }
 }
 function loadResearchMetricsFromDisk(cwd) {
-  const flywheelDir = (0, import_node_path14.join)(cwd, FLYWHEEL_DIR);
-  const analysisPath = (0, import_node_path14.join)(flywheelDir, "analysis.json");
-  const candidatesPath = (0, import_node_path14.join)(flywheelDir, "rule-candidates.json");
+  const flywheelDir = (0, import_node_path15.join)(cwd, FLYWHEEL_DIR);
+  const analysisPath = (0, import_node_path15.join)(flywheelDir, "analysis.json");
+  const candidatesPath = (0, import_node_path15.join)(flywheelDir, "rule-candidates.json");
   const hasAnalysis = (0, import_node_fs15.existsSync)(analysisPath);
   const hasCandidates = (0, import_node_fs15.existsSync)(candidatesPath);
   if (!hasAnalysis && !hasCandidates) return void 0;
@@ -47445,20 +47455,20 @@ function loadResearchMetricsFromDisk(cwd) {
   };
 }
 function saveFlywheelState(cwd, state) {
-  const dir = (0, import_node_path14.join)(cwd, FLYWHEEL_DIR);
+  const dir = (0, import_node_path15.join)(cwd, FLYWHEEL_DIR);
   if (!(0, import_node_fs15.existsSync)(dir)) (0, import_node_fs15.mkdirSync)(dir, { recursive: true });
-  (0, import_node_fs15.writeFileSync)((0, import_node_path14.join)(dir, STATE_FILE), JSON.stringify(state, null, 2));
+  (0, import_node_fs15.writeFileSync)((0, import_node_path15.join)(dir, STATE_FILE), JSON.stringify(state, null, 2));
 }
 function hashFile(filePath) {
   return (0, import_node_crypto3.createHash)("sha256").update(filePath).digest("hex").slice(0, 16);
 }
-var import_node_crypto3, import_node_fs15, import_node_path14, FLYWHEEL_DIR, STATE_FILE, CONSECUTIVE_THRESHOLD, FLYWHEEL_VERSION;
+var import_node_crypto3, import_node_fs15, import_node_path15, FLYWHEEL_DIR, STATE_FILE, CONSECUTIVE_THRESHOLD, FLYWHEEL_VERSION;
 var init_flywheel = __esm({
   "src/engine/flywheel.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
     import_node_fs15 = require("fs");
-    import_node_path14 = require("path");
+    import_node_path15 = require("path");
     FLYWHEEL_DIR = ".slopbrick/flywheel";
     STATE_FILE = "auto-tuned.json";
     CONSECUTIVE_THRESHOLD = 3;
@@ -47596,7 +47606,7 @@ function scoreFile(result, frameworkMultiplier, config, baseline, cwd) {
     100,
     rawScore * frameworkMultiplier * CONTEXT_DENSITY_MULTIPLIER
   );
-  const baselineKey = cwd ? (0, import_node_path15.isAbsolute)(result.filePath) ? (0, import_node_path15.relative)(cwd, result.filePath) : result.filePath : result.filePath;
+  const baselineKey = cwd ? (0, import_node_path16.isAbsolute)(result.filePath) ? (0, import_node_path16.relative)(cwd, result.filePath) : result.filePath : result.filePath;
   const baselineScore = baseline?.scores[baselineKey]?.baselineScore ?? 0;
   const adjustedScore = baseline ? Math.max(0, componentScore - baselineScore) : componentScore;
   return {
@@ -47735,11 +47745,11 @@ function aggregateReport(scores, issueGroups, config, compositeScores) {
     ...compositeAggregate && { compositeScore: compositeAggregate }
   };
 }
-var import_node_path15, SEVERITY_WEIGHTS, CONTEXT_DENSITY_MULTIPLIER, COMPOSITE_WEIGHTS, RULE_TO_BUCKET;
+var import_node_path16, SEVERITY_WEIGHTS, CONTEXT_DENSITY_MULTIPLIER, COMPOSITE_WEIGHTS, RULE_TO_BUCKET;
 var init_metrics = __esm({
   "src/engine/metrics.ts"() {
     "use strict";
-    import_node_path15 = require("path");
+    import_node_path16 = require("path");
     init_ai_security_risk();
     init_test_quality();
     SEVERITY_WEIGHTS = {
@@ -47878,7 +47888,7 @@ function hashConfig(config) {
   return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(sanitizeForHash(pickBaselineConfig(config)))).digest("hex");
 }
 function baselinePath(projectPath) {
-  return (0, import_node_path16.join)(projectPath, ".slopbrick", "cache", "baseline.json");
+  return (0, import_node_path17.join)(projectPath, ".slopbrick", "cache", "baseline.json");
 }
 function isBaselineCache(value) {
   if (!value || typeof value !== "object") return false;
@@ -47921,7 +47931,7 @@ function loadBaseline(projectPath) {
 }
 function saveBaseline(projectPath, cache) {
   const path = baselinePath(projectPath);
-  (0, import_node_fs16.mkdirSync)((0, import_node_path16.join)(projectPath, ".slopbrick", "cache"), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path17.join)(projectPath, ".slopbrick", "cache"), { recursive: true });
   (0, import_node_fs16.writeFileSync)(path, JSON.stringify(cache, null, 2));
 }
 function tightenBaseline(cache) {
@@ -47955,13 +47965,13 @@ function validateBaseline(cache, configHash, gitHead) {
   if (cache.git_head !== gitHead) return { valid: false, reason: "git_head mismatch" };
   return { valid: true };
 }
-var import_node_crypto4, import_node_fs16, import_node_path16, BASELINE_VERSION, BASELINE_HASH_KEYS;
+var import_node_crypto4, import_node_fs16, import_node_path17, BASELINE_VERSION, BASELINE_HASH_KEYS;
 var init_cache = __esm({
   "src/engine/cache.ts"() {
     "use strict";
     import_node_crypto4 = require("crypto");
     import_node_fs16 = require("fs");
-    import_node_path16 = require("path");
+    import_node_path17 = require("path");
     init_types();
     init_config();
     BASELINE_VERSION = VERSION;
@@ -48093,15 +48103,15 @@ var init_tokens = __esm({
 });
 
 // src/cli/memory-io.ts
-var import_promises3, import_node_path17, fsMemoryIO;
+var import_promises3, import_node_path18, fsMemoryIO;
 var init_memory_io = __esm({
   "src/cli/memory-io.ts"() {
     "use strict";
     import_promises3 = require("fs/promises");
-    import_node_path17 = require("path");
+    import_node_path18 = require("path");
     fsMemoryIO = {
       read: (path) => (0, import_promises3.readFile)(path, "utf-8").catch(() => null),
-      write: (path, content) => (0, import_promises3.mkdir)((0, import_node_path17.dirname)(path), { recursive: true }).then(
+      write: (path, content) => (0, import_promises3.mkdir)((0, import_node_path18.dirname)(path), { recursive: true }).then(
         () => (0, import_promises3.writeFile)(path, content, "utf-8")
       ),
       exists: (path) => (0, import_promises3.access)(path).then(
@@ -48989,7 +48999,7 @@ async function buildDbHealth(cwd, _config, options = {}) {
   for (const abs of sqlFiles.slice(0, maxFiles)) {
     const parsed = await parseSqlFile(abs);
     if (!parsed) continue;
-    const relPath = (0, import_node_path18.relative)(cwd, abs);
+    const relPath = (0, import_node_path19.relative)(cwd, abs);
     parsedFiles.push({ relPath, parsed });
     for (const stmt of parsed.statements) {
       if (stmt.type !== "IndexStmt") continue;
@@ -49044,7 +49054,7 @@ async function buildDbHealth(cwd, _config, options = {}) {
     } catch {
       continue;
     }
-    const relPath = (0, import_node_path18.relative)(cwd, abs);
+    const relPath = (0, import_node_path19.relative)(cwd, abs);
     const context = { config: _config, filePath: relPath, cwd };
     const facts = { filePath: relPath, v2: { _source: source } };
     const ruleContext = sqlConcatRule.create(context);
@@ -49090,12 +49100,12 @@ async function buildDbHealth(cwd, _config, options = {}) {
     byRule
   };
 }
-var import_node_fs18, import_node_path18, import_globby3, import_pgsql_parser6, moduleLoaded, DB_RULE_WEIGHTS, DB_FRESHNESS_THRESHOLDS;
+var import_node_fs18, import_node_path19, import_globby3, import_pgsql_parser6, moduleLoaded, DB_RULE_WEIGHTS, DB_FRESHNESS_THRESHOLDS;
 var init_db_health = __esm({
   "src/engine/db-health.ts"() {
     "use strict";
     import_node_fs18 = require("fs");
-    import_node_path18 = require("path");
+    import_node_path19 = require("path");
     import_globby3 = require("globby");
     import_pgsql_parser6 = require("pgsql-parser");
     init_duplicate_index();
@@ -49445,7 +49455,7 @@ function collectBusinessLogicIssues(cwd, filePaths) {
     for (const issue of fileIssues) {
       issues.push({
         ...issue,
-        filePath: (0, import_node_path19.relative)(cwd, absPath) || absPath
+        filePath: (0, import_node_path20.relative)(cwd, absPath) || absPath
       });
     }
   }
@@ -49709,12 +49719,12 @@ async function enrichReport(input) {
     domainIssues
   };
 }
-var import_node_fs19, import_node_path19;
+var import_node_fs19, import_node_path20;
 var init_enrichReport = __esm({
   "src/cli/report/enrichReport.ts"() {
     "use strict";
     import_node_fs19 = require("fs");
-    import_node_path19 = require("path");
+    import_node_path20 = require("path");
     init_logger();
     init_error();
     init_architecture_score();
@@ -49829,14 +49839,14 @@ var init_assembleScanReport = __esm({
 
 // src/engine/telemetry.ts
 function telemetryPath2(cwd) {
-  return (0, import_node_path20.join)(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
+  return (0, import_node_path21.join)(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
 }
 function hashString(input) {
   return (0, import_node_crypto5.createHash)("sha256").update(input).digest("hex").slice(0, 16);
 }
 function safeRelative(cwd, filePath) {
   try {
-    return (0, import_node_path20.relative)(cwd, filePath);
+    return (0, import_node_path21.relative)(cwd, filePath);
   } catch {
     return filePath;
   }
@@ -49889,23 +49899,23 @@ function rotateTelemetry(cwd) {
   if (stats.size < MAX_TELEMETRY_BYTES) {
     return;
   }
-  const dir = (0, import_node_path20.dirname)(path);
+  const dir = (0, import_node_path21.dirname)(path);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  (0, import_node_fs20.renameSync)(path, (0, import_node_path20.join)(dir, `scans-${timestamp}.jsonl`));
-  const rotated = (0, import_node_fs20.readdirSync)(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: (0, import_node_fs20.statSync)((0, import_node_path20.join)(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
+  (0, import_node_fs20.renameSync)(path, (0, import_node_path21.join)(dir, `scans-${timestamp}.jsonl`));
+  const rotated = (0, import_node_fs20.readdirSync)(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: (0, import_node_fs20.statSync)((0, import_node_path21.join)(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
   while (rotated.length > MAX_ROTATED_FILES) {
     const oldest = rotated.shift();
     if (oldest) {
-      (0, import_node_fs20.rmSync)((0, import_node_path20.join)(dir, oldest.name), { force: true });
+      (0, import_node_fs20.rmSync)((0, import_node_path21.join)(dir, oldest.name), { force: true });
     }
   }
 }
 function readTelemetry(cwd) {
-  const dir = (0, import_node_path20.join)(cwd, TELEMETRY_DIR);
+  const dir = (0, import_node_path21.join)(cwd, TELEMETRY_DIR);
   if (!(0, import_node_fs20.existsSync)(dir)) {
     return [];
   }
-  const files = (0, import_node_fs20.readdirSync)(dir).filter(isTelemetryFile).sort().map((name) => (0, import_node_path20.join)(dir, name));
+  const files = (0, import_node_fs20.readdirSync)(dir).filter(isTelemetryFile).sort().map((name) => (0, import_node_path21.join)(dir, name));
   const payloads = [];
   for (const file of files) {
     const raw = (0, import_node_fs20.readFileSync)(file, "utf-8");
@@ -49944,7 +49954,7 @@ function recordTelemetry(cwd, report, results, config) {
     files: buildFileRecords(cwd, report, results)
   };
   const path = telemetryPath2(cwd);
-  const dir = (0, import_node_path20.dirname)(path);
+  const dir = (0, import_node_path21.dirname)(path);
   if (!(0, import_node_fs20.existsSync)(dir)) {
     (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
   }
@@ -49952,14 +49962,14 @@ function recordTelemetry(cwd, report, results, config) {
   (0, import_node_fs20.appendFileSync)(path, JSON.stringify(payload) + "\n", "utf-8");
   return payload;
 }
-var import_node_fs20, import_node_crypto5, import_node_path20, TELEMETRY_DIR, TELEMETRY_FILE2, MAX_TELEMETRY_BYTES, MAX_ROTATED_FILES;
+var import_node_fs20, import_node_crypto5, import_node_path21, TELEMETRY_DIR, TELEMETRY_FILE2, MAX_TELEMETRY_BYTES, MAX_ROTATED_FILES;
 var init_telemetry = __esm({
   "src/engine/telemetry.ts"() {
     "use strict";
     import_node_fs20 = require("fs");
     import_node_crypto5 = require("crypto");
-    import_node_path20 = require("path");
-    TELEMETRY_DIR = (0, import_node_path20.join)(".slopbrick", "flywheel");
+    import_node_path21 = require("path");
+    TELEMETRY_DIR = (0, import_node_path21.join)(".slopbrick", "flywheel");
     TELEMETRY_FILE2 = "scans.jsonl";
     MAX_TELEMETRY_BYTES = 10 * 1024 * 1024;
     MAX_ROTATED_FILES = 5;
@@ -50115,8 +50125,8 @@ function renderStructureMarkdown(inventory, constitution) {
 async function writeStructureMarkdown(workspaceDir, md) {
   await new Promise((resolve42, reject) => {
     try {
-      const path = (0, import_node_path21.join)(workspaceDir, STRUCTURE_MD_FILE);
-      (0, import_node_fs21.mkdirSync)((0, import_node_path21.dirname)(path), { recursive: true });
+      const path = (0, import_node_path22.join)(workspaceDir, STRUCTURE_MD_FILE);
+      (0, import_node_fs21.mkdirSync)((0, import_node_path22.dirname)(path), { recursive: true });
       (0, import_node_fs21.writeFileSync)(path, md, "utf-8");
       resolve42();
     } catch (err) {
@@ -50127,7 +50137,7 @@ async function writeStructureMarkdown(workspaceDir, md) {
 async function readStructureMarkdown(workspaceDir) {
   return new Promise((resolve42) => {
     try {
-      const path = (0, import_node_path21.join)(workspaceDir, STRUCTURE_MD_FILE);
+      const path = (0, import_node_path22.join)(workspaceDir, STRUCTURE_MD_FILE);
       if (!(0, import_node_fs21.existsSync)(path)) {
         resolve42(null);
         return;
@@ -50139,13 +50149,13 @@ async function readStructureMarkdown(workspaceDir) {
     }
   });
 }
-var import_node_fs21, import_node_path21, STRUCTURE_MD_FILE, CATEGORY_LABELS, CATEGORY_ORDER, DECLARED_FIELDS;
+var import_node_fs21, import_node_path22, STRUCTURE_MD_FILE, CATEGORY_LABELS, CATEGORY_ORDER, DECLARED_FIELDS;
 var init_structure_md = __esm({
   "src/engine/structure-md.ts"() {
     "use strict";
     import_node_fs21 = require("fs");
-    import_node_path21 = require("path");
-    STRUCTURE_MD_FILE = (0, import_node_path21.join)(".slopbrick", "structure.md");
+    import_node_path22 = require("path");
+    STRUCTURE_MD_FILE = (0, import_node_path22.join)(".slopbrick", "structure.md");
     CATEGORY_LABELS = {
       stateManagement: "State management",
       dataFetching: "Data fetching",
@@ -50219,8 +50229,8 @@ async function persistRun(input) {
     );
   }
   if (options.incremental) {
-    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath4) ?? emptyCache();
+    const cachePath3 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath3) ?? emptyCache();
     const next = { ...existing, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
     for (const result of results) {
       try {
@@ -50234,7 +50244,7 @@ async function persistRun(input) {
       } catch {
       }
     }
-    saveCache(cachePath4, next);
+    saveCache(cachePath3, next);
     if (incrementalSummary && !options.quiet) {
       logger.info(
         `Incremental: re-scanned ${incrementalSummary.rescanned}, skipped ${incrementalSummary.skipped} (unchanged).`
@@ -50247,7 +50257,7 @@ async function persistRun(input) {
     const recentTopHashes = telemetryPayloads.map(
       (payload) => [...payload.files].sort((a, b) => b.score - a.score).slice(0, 10).map((file) => file.hash)
     );
-    const currentTopFiles = [...report.components].sort((a, b) => b.adjustedScore - a.adjustedScore).slice(0, 10).map((c) => ({ filePath: c.filePath, hash: hashFile((0, import_node_path22.relative)(cwd, c.filePath)) }));
+    const currentTopFiles = [...report.components].sort((a, b) => b.adjustedScore - a.adjustedScore).slice(0, 10).map((c) => ({ filePath: c.filePath, hash: hashFile((0, import_node_path23.relative)(cwd, c.filePath)) }));
     const unmatchedStringLiterals = results.flatMap((r) => r.unmatchedStringLiterals ?? []);
     const flywheelOutput = computeFlywheelOutput(
       runs,
@@ -50266,10 +50276,10 @@ async function persistRun(input) {
       report.research = state.research;
     }
     if (flywheelOutput.suggestions.length > 0) {
-      const suggestionsDir = (0, import_node_path22.join)(cwd, ".slopbrick", "flywheel");
+      const suggestionsDir = (0, import_node_path23.join)(cwd, ".slopbrick", "flywheel");
       if (!(0, import_node_fs22.existsSync)(suggestionsDir)) (0, import_node_fs22.mkdirSync)(suggestionsDir, { recursive: true });
       (0, import_node_fs22.writeFileSync)(
-        (0, import_node_path22.join)(suggestionsDir, "rule-suggestions.json"),
+        (0, import_node_path23.join)(suggestionsDir, "rule-suggestions.json"),
         JSON.stringify(flywheelOutput.suggestions, null, 2)
       );
     }
@@ -50314,12 +50324,12 @@ async function persistRun(input) {
     }
   }
 }
-var import_node_fs22, import_node_path22;
+var import_node_fs22, import_node_path23;
 var init_persistRun = __esm({
   "src/cli/report/persistRun.ts"() {
     "use strict";
     import_node_fs22 = require("fs");
-    import_node_path22 = require("path");
+    import_node_path23 = require("path");
     init_logger();
     init_cache_incremental();
     init_flywheel();
@@ -50458,7 +50468,7 @@ var init_finalizeReport = __esm({
 function buildBaselineCache(report, configHash, gitHead, cwd) {
   const scores = {};
   for (const component of report.components) {
-    scores[(0, import_node_path23.relative)(cwd, component.filePath)] = {
+    scores[(0, import_node_path24.relative)(cwd, component.filePath)] = {
       baselineScore: component.componentScore,
       componentCount: component.componentCount
     };
@@ -50473,11 +50483,11 @@ function buildBaselineCache(report, configHash, gitHead, cwd) {
     scores
   };
 }
-var import_node_path23;
+var import_node_path24;
 var init_baseline_cache = __esm({
   "src/cli/report/baseline-cache.ts"() {
     "use strict";
-    import_node_path23 = require("path");
+    import_node_path24 = require("path");
     init_types();
   }
 });
@@ -50541,24 +50551,24 @@ function buildArtifactUri(filePath, cwd) {
     return ".";
   }
   if (cwd) {
-    const absoluteFilePath = (0, import_node_path24.isAbsolute)(filePath) ? filePath : (0, import_node_path24.resolve)(cwd, filePath);
-    const rel = (0, import_node_path24.relative)(cwd, absoluteFilePath);
+    const absoluteFilePath = (0, import_node_path25.isAbsolute)(filePath) ? filePath : (0, import_node_path25.resolve)(cwd, filePath);
+    const rel = (0, import_node_path25.relative)(cwd, absoluteFilePath);
     if (rel.startsWith("..")) {
-      return (0, import_node_path24.basename)(filePath);
+      return (0, import_node_path25.basename)(filePath);
     }
     return rel;
   }
-  if ((0, import_node_path24.isAbsolute)(filePath)) {
-    return (0, import_node_path24.basename)(filePath);
+  if ((0, import_node_path25.isAbsolute)(filePath)) {
+    return (0, import_node_path25.basename)(filePath);
   }
   return filePath;
 }
 function resolveSourcePath(filePath, cwd) {
   if (!filePath) return null;
   if (cwd) {
-    return (0, import_node_path24.isAbsolute)(filePath) ? filePath : (0, import_node_path24.resolve)(cwd, filePath);
+    return (0, import_node_path25.isAbsolute)(filePath) ? filePath : (0, import_node_path25.resolve)(cwd, filePath);
   }
-  return (0, import_node_path24.isAbsolute)(filePath) ? filePath : null;
+  return (0, import_node_path25.isAbsolute)(filePath) ? filePath : null;
 }
 function severityToSarifLevel(severity) {
   switch (severity) {
@@ -50713,13 +50723,13 @@ function formatSarif(report, options) {
   };
   return JSON.stringify(log, null, 2);
 }
-var import_node_crypto6, import_node_fs23, import_node_path24, REPO_INFORMATION_URI, RULES_BASE_URL;
+var import_node_crypto6, import_node_fs23, import_node_path25, REPO_INFORMATION_URI, RULES_BASE_URL;
 var init_sarif = __esm({
   "src/report/sarif.ts"() {
     "use strict";
     import_node_crypto6 = require("crypto");
     import_node_fs23 = require("fs");
-    import_node_path24 = require("path");
+    import_node_path25 = require("path");
     REPO_INFORMATION_URI = "https://github.com/brickdotdev/slopbrick";
     RULES_BASE_URL = "https://github.com/Dystx/slopbrick/blob/main/src/rules";
   }
@@ -52005,7 +52015,7 @@ function formatUnifiedDiff(report, cwd) {
       parts.push("");
       hasHunk = true;
     }
-    const rel = (0, import_node_path25.relative)(cwd, filePath);
+    const rel = (0, import_node_path26.relative)(cwd, filePath);
     parts.push(`--- a/${rel}`);
     parts.push(`+++ b/${rel}`);
     parts.push(...formatHunk(original, patched));
@@ -52016,12 +52026,12 @@ function formatUnifiedDiff(report, cwd) {
   }
   return parts.join("\n");
 }
-var import_node_fs25, import_node_path25;
+var import_node_fs25, import_node_path26;
 var init_unified_diff = __esm({
   "src/report/unified-diff.ts"() {
     "use strict";
     import_node_fs25 = require("fs");
-    import_node_path25 = require("path");
+    import_node_path26 = require("path");
     init_layout_token();
   }
 });
@@ -52047,7 +52057,7 @@ async function buildHeatmap(report, cwd, helpers = { getFileEditCount, getFileLa
   const reference = new Date(report.generatedAt);
   const entries = await Promise.all(
     report.components.map(async (component) => {
-      const relPath = (0, import_node_path26.relative)(cwd, component.filePath) || component.filePath;
+      const relPath = (0, import_node_path27.relative)(cwd, component.filePath) || component.filePath;
       const [edits, lastModified] = await Promise.all([
         helpers.getFileEditCount(cwd, relPath, RECENCY_DAYS),
         helpers.getFileLastModifiedDate(cwd, relPath)
@@ -52092,11 +52102,11 @@ function formatHeatmap(entries, options = {}) {
   );
   return [header, ...rows].join("\n");
 }
-var import_node_path26, RECENCY_DAYS, MAX_EDITS;
+var import_node_path27, RECENCY_DAYS, MAX_EDITS;
 var init_heatmap = __esm({
   "src/report/heatmap.ts"() {
     "use strict";
-    import_node_path26 = require("path");
+    import_node_path27 = require("path");
     init_git();
     RECENCY_DAYS = 30;
     MAX_EDITS = 10;
@@ -52137,7 +52147,7 @@ function renderOutput(report, options, cwd) {
   if (options.html) {
     const html = formatHtml(report);
     if (typeof options.html === "string") {
-      (0, import_node_fs26.writeFileSync)((0, import_node_path27.resolve)(options.html), html);
+      (0, import_node_fs26.writeFileSync)((0, import_node_path28.resolve)(options.html), html);
       if (!options.quiet) {
         logger.info(`Wrote HTML report to ${options.html}`);
       }
@@ -52149,7 +52159,7 @@ function renderOutput(report, options, cwd) {
   if (options.json) {
     const json = formatJson(report);
     if (typeof options.json === "string") {
-      (0, import_node_fs26.writeFileSync)((0, import_node_path27.resolve)(options.json), json);
+      (0, import_node_fs26.writeFileSync)((0, import_node_path28.resolve)(options.json), json);
       if (!options.quiet) {
         logger.info(`Wrote JSON report to ${options.json}`);
       }
@@ -52163,7 +52173,7 @@ function renderOutput(report, options, cwd) {
     return;
   }
   if (options.format === "sarif") {
-    const cwdSarif = (0, import_node_path27.resolve)(options.workspace ?? process.cwd());
+    const cwdSarif = (0, import_node_path28.resolve)(options.workspace ?? process.cwd());
     logger.info(formatSarif(report, { cwd: cwdSarif }));
     return;
   }
@@ -52184,11 +52194,11 @@ async function outputScanResults(report, options, cwd) {
   }
   renderOutput(report, options, cwd);
 }
-var import_node_path27, import_node_fs26, VALID_FORMATS;
+var import_node_path28, import_node_fs26, VALID_FORMATS;
 var init_renderOutput = __esm({
   "src/cli/report/renderOutput.ts"() {
     "use strict";
-    import_node_path27 = require("path");
+    import_node_path28 = require("path");
     import_node_fs26 = require("fs");
     init_logger();
     init_json();
@@ -52327,7 +52337,7 @@ async function watchProject(options, cwd, paths) {
     { recursive: true },
     (_eventType, filename) => {
       if (closed || !filename) return;
-      const changedPath = (0, import_node_path28.resolve)(cwd, filename.toString());
+      const changedPath = (0, import_node_path29.resolve)(cwd, filename.toString());
       if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(() => {
         debounceTimer = void 0;
@@ -52362,12 +52372,12 @@ async function watchProject(options, cwd, paths) {
     }
   );
 }
-var import_node_fs27, import_node_path28;
+var import_node_fs27, import_node_path29;
 var init_watch = __esm({
   "src/cli/watch.ts"() {
     "use strict";
     import_node_fs27 = require("fs");
-    import_node_path28 = require("path");
+    import_node_path29 = require("path");
     init_metrics();
     init_worker();
     init_threshold();
@@ -52396,7 +52406,7 @@ __export(scan_exports, {
 async function runScan(options, explicitPaths) {
   setLoggerQuiet(!!options.quiet);
   const startTime = Date.now();
-  const cwd = (0, import_node_path29.resolve)(options.workspace ?? process.cwd());
+  const cwd = (0, import_node_path30.resolve)(options.workspace ?? process.cwd());
   if (!(0, import_node_fs28.existsSync)(cwd)) {
     throw new Error(`Workspace not found: ${cwd}`);
   }
@@ -52427,7 +52437,7 @@ async function runScan(options, explicitPaths) {
     process.env.SLOP_AUDIT_CACHE = "1";
   }
   if (options.tokens) {
-    const tokenResult = readDtcgTokensFile((0, import_node_path29.resolve)(cwd, options.tokens));
+    const tokenResult = readDtcgTokensFile((0, import_node_path30.resolve)(cwd, options.tokens));
     if (tokenResult.ok) {
       const extra = tokensToAllowlist(tokenResult.tree);
       config.arbitraryValueAllowlist = [...config.arbitraryValueAllowlist, ...extra];
@@ -52439,14 +52449,14 @@ async function runScan(options, explicitPaths) {
   if (explicitPaths && explicitPaths.length > 0) {
     const { globby: globby4 } = await import("globby");
     const { minimatch: minimatch3 } = await import("minimatch");
-    const resolved = explicitPaths.map((p) => (0, import_node_path29.resolve)(cwd, p));
+    const resolved = explicitPaths.map((p) => (0, import_node_path30.resolve)(cwd, p));
     const expanded = [];
     for (const p of resolved) {
       if ((0, import_node_fs28.existsSync)(p) && (0, import_node_fs28.statSync)(p).isDirectory()) {
         const found = await globby4(`${p}/**/*`, { absolute: true, onlyFiles: true });
         for (const f of found) {
-          if (!ALL_SOURCE_EXTENSIONS.has((0, import_node_path29.extname)(f).toLowerCase())) continue;
-          const rel = (0, import_node_path29.relative)(cwd, f).split(import_node_path29.sep).join("/");
+          if (!ALL_SOURCE_EXTENSIONS.has((0, import_node_path30.extname)(f).toLowerCase())) continue;
+          const rel = (0, import_node_path30.relative)(cwd, f).split(import_node_path30.sep).join("/");
           if (config.include.length > 0 && !config.include.some((pattern) => minimatch3(rel, pattern))) {
             continue;
           }
@@ -52481,8 +52491,8 @@ async function runScan(options, explicitPaths) {
   }
   let incrementalSummary;
   if (options.incremental) {
-    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath4);
+    const cachePath3 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath3);
     const { toScan, unchanged } = partitionByCache(files, existing);
     files = toScan;
     incrementalSummary = { skipped: unchanged.length, rescanned: toScan.length };
@@ -52656,12 +52666,12 @@ async function scanProject(options) {
   const { report } = await runScan({ ...options, workspace: options.cwd });
   return report;
 }
-var import_node_fs28, import_node_path29;
+var import_node_fs28, import_node_path30;
 var init_scan = __esm({
   "src/cli/scan.ts"() {
     "use strict";
     import_node_fs28 = require("fs");
-    import_node_path29 = require("path");
+    import_node_path30 = require("path");
     init_render();
     init_threshold();
     init_config();
@@ -52867,7 +52877,7 @@ async function runGovernance(args, ctx) {
 function runCheckConstitution(args, ctx) {
   const path = args.path;
   if (!path) return toolError("Missing required argument: path");
-  const absPath = (0, import_node_path37.resolve)(ctx.cwd, path);
+  const absPath = (0, import_node_path38.resolve)(ctx.cwd, path);
   let source;
   try {
     source = (0, import_node_fs32.readFileSync)(absPath, "utf-8");
@@ -53057,12 +53067,12 @@ function canonicalToolNames() {
 function getDeprecation(toolName) {
   return TOOL_DEFINITIONS.find((t) => t.name === toolName)?.deprecated;
 }
-var import_node_fs32, import_node_path37, TOOL_DEFINITIONS;
+var import_node_fs32, import_node_path38, TOOL_DEFINITIONS;
 var init_tools = __esm({
   "src/mcp/tools.ts"() {
     "use strict";
     import_node_fs32 = require("fs");
-    import_node_path37 = require("path");
+    import_node_path38 = require("path");
     init_worker();
     init_patterns();
     init_architecture_score();
@@ -53320,7 +53330,7 @@ init_config();
 init_dist2();
 
 // src/cli/program.ts
-var import_node_path69 = require("path");
+var import_node_path70 = require("path");
 var import_node_perf_hooks = require("perf_hooks");
 var import_commander2 = require("commander");
 
@@ -53365,7 +53375,7 @@ init_scan();
 
 // src/cli/init.ts
 var import_node_fs30 = require("fs");
-var import_node_path31 = require("path");
+var import_node_path32 = require("path");
 var import_node_readline = require("readline");
 init_config();
 init_discover();
@@ -53375,7 +53385,7 @@ init_logger();
 
 // src/rules/registry-loader.ts
 var import_node_fs29 = require("fs");
-var import_node_path30 = require("path");
+var import_node_path31 = require("path");
 
 // src/data/shadcn-registry.json
 var shadcn_registry_default = {
@@ -53508,11 +53518,11 @@ var shadcn_registry_default = {
 // src/rules/registry-loader.ts
 var REGISTRY_URL = "https://ui.shadcn.com/registry.json";
 var BUNDLED_REGISTRY_VERSION = shadcn_registry_default.version;
-function cachePath3(cwd) {
-  return (0, import_node_path30.join)(cwd, ".slopbrick", "cache", "registry-snapshot.json");
+function cachePath2(cwd) {
+  return (0, import_node_path31.join)(cwd, ".slopbrick", "cache", "registry-snapshot.json");
 }
 function ensureCacheDir(cwd) {
-  const dir = (0, import_node_path30.dirname)(cachePath3(cwd));
+  const dir = (0, import_node_path31.dirname)(cachePath2(cwd));
   if (!(0, import_node_fs29.existsSync)(dir)) {
     (0, import_node_fs29.mkdirSync)(dir, { recursive: true });
   }
@@ -53525,7 +53535,7 @@ function isValidSnapshot(value) {
   return true;
 }
 function isRegistryFresh(cwd) {
-  const cached = cachePath3(cwd);
+  const cached = cachePath2(cwd);
   if (!(0, import_node_fs29.existsSync)(cached)) return false;
   try {
     const parsed = JSON.parse((0, import_node_fs29.readFileSync)(cached, "utf8"));
@@ -53562,7 +53572,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
     };
   }
   ensureCacheDir(cwd);
-  (0, import_node_fs29.writeFileSync)(cachePath3(cwd), JSON.stringify(fetched, null, 2));
+  (0, import_node_fs29.writeFileSync)(cachePath2(cwd), JSON.stringify(fetched, null, 2));
   const fresh = fetched.version === BUNDLED_REGISTRY_VERSION;
   return {
     ok: true,
@@ -53572,7 +53582,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
 }
 function copyBundledSnapshotToCache(cwd) {
   ensureCacheDir(cwd);
-  (0, import_node_fs29.writeFileSync)(cachePath3(cwd), JSON.stringify(shadcn_registry_default, null, 2));
+  (0, import_node_fs29.writeFileSync)(cachePath2(cwd), JSON.stringify(shadcn_registry_default, null, 2));
 }
 
 // src/cli/init.ts
@@ -53761,8 +53771,8 @@ async function runDoctor(cwd) {
   }
   try {
     const { parseFile: tryParse } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
-    const testFile = (0, import_node_path31.join)(cwd, ".slopbrick", ".doctor-test.ts");
-    (0, import_node_fs30.mkdirSync)((0, import_node_path31.dirname)(testFile), { recursive: true });
+    const testFile = (0, import_node_path32.join)(cwd, ".slopbrick", ".doctor-test.ts");
+    (0, import_node_fs30.mkdirSync)((0, import_node_path32.dirname)(testFile), { recursive: true });
     (0, import_node_fs30.writeFileSync)(testFile, "export const x = 1;\n");
     await tryParse(testFile);
     (0, import_node_fs30.rmSync)(testFile, { force: true });
@@ -53854,7 +53864,7 @@ async function runDoctor(cwd) {
 }
 
 // src/cli/commands/badge.ts
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 init_render();
 init_logger();
 init_scan();
@@ -53863,7 +53873,7 @@ function registerBadge(program) {
     "print a shields.io slop-index badge. Reads .slopbrick/health.json if present (no re-scan); falls back to a fresh scan."
   ).action(async (_cmdOptions, command) => {
     const options = command.optsWithGlobals();
-    const cwd = (0, import_node_path32.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path33.resolve)(options.workspace ?? process.cwd());
     const { loadHealth: loadHealth2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const health = loadHealth2(cwd);
     if (health) {
@@ -53880,7 +53890,7 @@ function registerBadge(program) {
 }
 
 // src/cli/commands/suggest.ts
-var import_node_path33 = require("path");
+var import_node_path34 = require("path");
 init_advice();
 init_unified_diff();
 init_logger();
@@ -53889,7 +53899,7 @@ function registerSuggest(program) {
   program.command("suggest").description("print remediation advice").action(async (_cmdOptions, command) => {
     const options = command.optsWithGlobals();
     const { report } = await runScan(options);
-    const cwd = (0, import_node_path33.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path34.resolve)(options.workspace ?? process.cwd());
     logger.info(formatAdvice(report));
     const diff = formatUnifiedDiff(report, cwd);
     if (diff) logger.info(diff);
@@ -54082,13 +54092,13 @@ function registerExplain(program) {
 }
 
 // src/cli/commands/install.ts
-var import_node_path35 = require("path");
+var import_node_path36 = require("path");
 init_logger();
 init_git();
 
 // src/cli/installer.ts
 var import_node_fs31 = require("fs");
-var import_node_path34 = require("path");
+var import_node_path35 = require("path");
 var BEGIN_SENTINEL = "# slopbrick-hook-begin";
 var END_SENTINEL = "# slopbrick-hook-end";
 var SENTINEL_BLOCK = `${BEGIN_SENTINEL}
@@ -54096,11 +54106,11 @@ npx slopbrick --staged
 ${END_SENTINEL}
 `;
 function hookPath(gitRoot) {
-  const huskyDir = (0, import_node_path34.join)(gitRoot, ".husky");
+  const huskyDir = (0, import_node_path35.join)(gitRoot, ".husky");
   if ((0, import_node_fs31.existsSync)(huskyDir)) {
-    return (0, import_node_path34.join)(huskyDir, "pre-commit");
+    return (0, import_node_path35.join)(huskyDir, "pre-commit");
   }
-  return (0, import_node_path34.join)(gitRoot, ".git", "hooks", "pre-commit");
+  return (0, import_node_path35.join)(gitRoot, ".git", "hooks", "pre-commit");
 }
 function readHookContent(path) {
   return (0, import_node_fs31.readFileSync)(path, "utf8");
@@ -54165,7 +54175,7 @@ function installHook(gitRoot) {
       exitCode: 0
     };
   }
-  (0, import_node_fs31.mkdirSync)((0, import_node_path34.dirname)(path), { recursive: true });
+  (0, import_node_fs31.mkdirSync)((0, import_node_path35.dirname)(path), { recursive: true });
   (0, import_node_fs31.writeFileSync)(path, SENTINEL_BLOCK, { mode: 493 });
   (0, import_node_fs31.chmodSync)(path, 493);
   return {
@@ -54225,7 +54235,7 @@ function uninstallHook(gitRoot) {
 function registerInstall(program) {
   program.command("install").description("install the git pre-commit hook").action(async (_cmdOptions, command) => {
     const options = command.optsWithGlobals();
-    const cwd = (0, import_node_path35.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path36.resolve)(options.workspace ?? process.cwd());
     const root = getGitRoot(cwd);
     if (!root) {
       logger.error("Not a Git repository. Run `git init` first, or remove --staged from your command.");
@@ -54240,13 +54250,13 @@ function registerInstall(program) {
 }
 
 // src/cli/commands/uninstall.ts
-var import_node_path36 = require("path");
+var import_node_path37 = require("path");
 init_logger();
 init_git();
 function registerUninstall(program) {
   program.command("uninstall").description("uninstall the git pre-commit hook").action(async (_cmdOptions, command) => {
     const options = command.optsWithGlobals();
-    const cwd = (0, import_node_path36.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path37.resolve)(options.workspace ?? process.cwd());
     const root = getGitRoot(cwd);
     if (!root) {
       logger.error("Not a Git repository. Run `git init` first, or remove --staged from your command.");
@@ -54392,7 +54402,7 @@ function registerDoctor(program) {
 }
 
 // src/cli/commands/watch.ts
-var import_node_path38 = require("path");
+var import_node_path39 = require("path");
 init_watch();
 function registerWatch(program, scanAction) {
   program.command("watch").description("re-run scan on every file change. Flags new violations as you write. The LockBrick prevention loop entry.").action(async (_cmdOptions, command) => {
@@ -54401,19 +54411,19 @@ function registerWatch(program, scanAction) {
       ...rawGlobals,
       noIncrease: rawGlobals.increase === false
     };
-    const cwd = (0, import_node_path38.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path39.resolve)(options.workspace ?? process.cwd());
     await scanAction([], options, command);
     await watchProject(options, cwd, []);
   });
 }
 
 // src/cli/commands/lock.ts
-var import_node_path39 = require("path");
+var import_node_path40 = require("path");
 init_logger();
 function registerLock(program) {
   program.command("lock").description("install a Git pre-commit hook that runs `slopbrick scan --staged` on every commit. The LockBrick prevention loop: block AI-introduced slop from ever reaching the repo.").option("--uninstall", "remove the pre-commit hook instead of installing it").option("--husky", "force-install under .husky/pre-commit (Husky v9). Default auto-detects via .husky/ dir.").option("--workspace <path>", "workspace directory", process.cwd()).action(
     (cmdOptions) => {
-      const cwd = (0, import_node_path39.resolve)(cmdOptions.workspace ?? process.cwd());
+      const cwd = (0, import_node_path40.resolve)(cmdOptions.workspace ?? process.cwd());
       if (cmdOptions.uninstall) {
         const result2 = uninstallHook(cwd);
         logger.info(result2.message);
@@ -54434,7 +54444,7 @@ function registerLock(program) {
 }
 
 // src/cli/commands/ci.ts
-var import_node_path40 = require("path");
+var import_node_path41 = require("path");
 init_logger();
 init_dist();
 function registerCi(program, scanAction) {
@@ -54449,7 +54459,7 @@ function registerCi(program, scanAction) {
         // scan only changed files
         format: cmdOptions.format ?? "json"
       };
-      const cwd = (0, import_node_path40.resolve)(options.workspace ?? process.cwd());
+      const cwd = (0, import_node_path41.resolve)(options.workspace ?? process.cwd());
       await scanAction([], options, command);
       const health = loadHealth(cwd);
       if (!health) {
@@ -54477,12 +54487,12 @@ function registerCi(program, scanAction) {
 }
 
 // src/cli/commands/memory.ts
-var import_node_path41 = require("path");
+var import_node_path42 = require("path");
 init_logger();
 function registerMemory(program) {
   program.command("memory").description("show or regenerate .slopbrick/structure.md (the agent-readable repository summary) without re-scanning").option("--show", "print the current .slopbrick/structure.md to stdout (default if no flag is passed)").option("--regenerate", "re-render structure.md from the existing inventory.json + constitution.json (no scan)").option("--workspace <path>", "workspace directory", process.cwd()).action(
     async (cmdOptions) => {
-      const cwd = (0, import_node_path41.resolve)(cmdOptions.workspace ?? process.cwd());
+      const cwd = (0, import_node_path42.resolve)(cmdOptions.workspace ?? process.cwd());
       const { renderStructureMarkdown: renderStructureMarkdown2, readStructureMarkdown: readStructureMarkdown2, writeStructureMarkdown: writeStructureMarkdown2 } = await Promise.resolve().then(() => (init_structure_md(), structure_md_exports));
       const { loadInventory: loadInventory2, loadConstitution: loadConstitution2, inventoryPath: invPath, constitutionPath: conPath } = await Promise.resolve().then(() => (init_dist(), dist_exports));
       if (cmdOptions.regenerate) {
@@ -54512,47 +54522,47 @@ function registerMemory(program) {
 }
 
 // src/cli/commands/migrate.ts
-var import_node_path43 = require("path");
+var import_node_path44 = require("path");
 init_logger();
 
 // src/cli/migrate.ts
 var import_node_fs33 = require("fs");
-var import_node_path42 = require("path");
+var import_node_path43 = require("path");
 init_logger();
 function planMigration(workspaceDir) {
   const moves = [];
   const rewrites = [];
   const gitignoreEdits = [];
-  const oldDir = (0, import_node_path42.join)(workspaceDir, ".slop-audit");
-  const newDir = (0, import_node_path42.join)(workspaceDir, ".slopbrick");
+  const oldDir = (0, import_node_path43.join)(workspaceDir, ".slop-audit");
+  const newDir = (0, import_node_path43.join)(workspaceDir, ".slopbrick");
   if ((0, import_node_fs33.existsSync)(oldDir)) {
     moves.push({ from: oldDir, to: newDir, kind: "dir" });
     rewrites.push({
-      path: (0, import_node_path42.join)(newDir, "inventory.json"),
+      path: (0, import_node_path43.join)(newDir, "inventory.json"),
       field: "version",
       from: '"1"',
       to: '"2"'
     });
     rewrites.push({
-      path: (0, import_node_path42.join)(newDir, "constitution.json"),
+      path: (0, import_node_path43.join)(newDir, "constitution.json"),
       field: "version",
       from: '"1"',
       to: '"2"'
     });
   }
-  const oldCache = (0, import_node_path42.join)(workspaceDir, ".slop-audit-cache.json");
-  const newCache = (0, import_node_path42.join)(workspaceDir, ".slopbrick-cache.json");
+  const oldCache = (0, import_node_path43.join)(workspaceDir, ".slop-audit-cache.json");
+  const newCache = (0, import_node_path43.join)(workspaceDir, ".slopbrick-cache.json");
   if ((0, import_node_fs33.existsSync)(oldCache)) {
     moves.push({ from: oldCache, to: newCache, kind: "file" });
   }
   for (const ext of ["mjs", "cjs", "js"]) {
-    const oldCfg = (0, import_node_path42.join)(workspaceDir, `slop-audit.config.${ext}`);
-    const newCfg = (0, import_node_path42.join)(workspaceDir, `slopbrick.config.${ext}`);
+    const oldCfg = (0, import_node_path43.join)(workspaceDir, `slop-audit.config.${ext}`);
+    const newCfg = (0, import_node_path43.join)(workspaceDir, `slopbrick.config.${ext}`);
     if ((0, import_node_fs33.existsSync)(oldCfg)) {
       moves.push({ from: oldCfg, to: newCfg, kind: "config" });
     }
   }
-  const gi = (0, import_node_path42.join)(workspaceDir, ".gitignore");
+  const gi = (0, import_node_path43.join)(workspaceDir, ".gitignore");
   if ((0, import_node_fs33.existsSync)(gi)) {
     const content = (0, import_node_fs33.readFileSync)(gi, "utf-8");
     if (content.includes(".slop-audit/")) {
@@ -54573,7 +54583,7 @@ function planMigration(workspaceDir) {
   return { moves, rewrites, gitignoreEdits };
 }
 function isAlreadyMigrated(workspaceDir) {
-  return (0, import_node_fs33.existsSync)((0, import_node_path42.join)(workspaceDir, ".slopbrick")) && !(0, import_node_fs33.existsSync)((0, import_node_path42.join)(workspaceDir, ".slop-audit"));
+  return (0, import_node_fs33.existsSync)((0, import_node_path43.join)(workspaceDir, ".slopbrick")) && !(0, import_node_fs33.existsSync)((0, import_node_path43.join)(workspaceDir, ".slop-audit"));
 }
 function applyMigration(plan, options = {}) {
   if (options.dryRun) return;
@@ -54604,8 +54614,8 @@ function runMigrate(options) {
     };
   }
   const alreadyMigrated = isAlreadyMigrated(workspace);
-  const newDir = (0, import_node_path42.join)(workspace, ".slopbrick");
-  const oldDir = (0, import_node_path42.join)(workspace, ".slop-audit");
+  const newDir = (0, import_node_path43.join)(workspace, ".slopbrick");
+  const oldDir = (0, import_node_path43.join)(workspace, ".slop-audit");
   if ((0, import_node_fs33.existsSync)(newDir) && (0, import_node_fs33.existsSync)(oldDir) && !force) {
     return {
       ok: false,
@@ -54682,7 +54692,7 @@ function registerMigrate(program) {
     (cmdOptions, command) => {
       const globals = command.optsWithGlobals();
       const format = (cmdOptions.format ?? globals.format) === "json" ? "json" : "pretty";
-      const cwd = (0, import_node_path43.resolve)(cmdOptions.workspace ?? process.cwd());
+      const cwd = (0, import_node_path44.resolve)(cmdOptions.workspace ?? process.cwd());
       const result = runMigrate({
         workspace: cwd,
         dryRun: cmdOptions.dryRun,
@@ -54787,18 +54797,18 @@ function registerRules(program) {
 
 // src/cli/commands/validate-config.ts
 var import_node_fs34 = require("fs");
-var import_node_path44 = require("path");
+var import_node_path45 = require("path");
 init_logger();
 init_validation();
 function registerValidateConfig(program) {
   program.command("validate-config [path]").description("Statically validate a slopbrick.config.mjs without scanning").action(async (configPath) => {
-    const path = configPath ? (0, import_node_path44.resolve)(configPath) : (0, import_node_path44.resolve)(process.cwd(), "slopbrick.config.mjs");
+    const path = configPath ? (0, import_node_path45.resolve)(configPath) : (0, import_node_path45.resolve)(process.cwd(), "slopbrick.config.mjs");
     if (!(0, import_node_fs34.existsSync)(path)) {
       logger.error(`Error: config file not found: ${path}`);
       process.exit(2);
     }
     try {
-      const mod = (0, import_node_path44.extname)(path) === ".cjs" ? require(path) : await import(path);
+      const mod = (0, import_node_path45.extname)(path) === ".cjs" ? require(path) : await import(path);
       const userConfig = mod.default ?? mod;
       const result = validateConfig(userConfig);
       if (result.errors.length === 0) {
@@ -55019,7 +55029,7 @@ ${formatMarkdown(result.report)}`);
 
 // src/cli/commands/calibrate.ts
 var import_node_fs37 = require("fs");
-var import_node_path48 = require("path");
+var import_node_path49 = require("path");
 init_logger();
 
 // src/research/providers/openai.ts
@@ -55076,7 +55086,7 @@ function createProvider(config) {
 
 // src/research/generator.ts
 var import_node_fs35 = require("fs");
-var import_node_path45 = require("path");
+var import_node_path46 = require("path");
 
 // src/research/prompts.ts
 var DEFAULT_PROMPT_TEMPLATES = [
@@ -55139,13 +55149,13 @@ async function generateSamples(options) {
   }
   const samples = [];
   const ext = extForFramework(framework);
-  const dir = (0, import_node_path45.join)(outputDir, framework, componentType);
+  const dir = (0, import_node_path46.join)(outputDir, framework, componentType);
   (0, import_node_fs35.mkdirSync)(dir, { recursive: true });
   for (let i = 1; i <= count; i += 1) {
     const raw = await provider.generateSample(renderPrompt(template), { temperature });
     const code = extractCodeFromMarkdown(raw);
     const fileName = `sample-${i}${ext}`;
-    const filePath = (0, import_node_path45.join)(dir, fileName);
+    const filePath = (0, import_node_path46.join)(dir, fileName);
     (0, import_node_fs35.writeFileSync)(filePath, code, "utf8");
     const sample = {
       filePath,
@@ -55157,7 +55167,7 @@ async function generateSamples(options) {
     };
     samples.push(sample);
   }
-  const metadataPath = (0, import_node_path45.join)(dir, "metadata.json");
+  const metadataPath = (0, import_node_path46.join)(dir, "metadata.json");
   (0, import_node_fs35.writeFileSync)(metadataPath, JSON.stringify(samples, null, 2), "utf8");
   return samples;
 }
@@ -55365,20 +55375,20 @@ function slugify(value) {
 // src/research/calibrator.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs36 = require("fs");
-var import_node_path47 = require("path");
+var import_node_path48 = require("path");
 
 // src/corpus-paths.ts
-var import_node_path46 = require("path");
+var import_node_path47 = require("path");
 var CORPUS_ROOT = process.env["SLOPBRICK_CORPUS_DIR"] ?? "/Users/cheng/corpus-expansion";
-var POSITIVE_DIR = (0, import_node_path46.join)(CORPUS_ROOT, "positive");
-var NEGATIVE_DIR = (0, import_node_path46.join)(CORPUS_ROOT, "negative");
-var FILELISTS_DIR = (0, import_node_path46.join)(CORPUS_ROOT, "filelists");
+var POSITIVE_DIR = (0, import_node_path47.join)(CORPUS_ROOT, "positive");
+var NEGATIVE_DIR = (0, import_node_path47.join)(CORPUS_ROOT, "negative");
+var FILELISTS_DIR = (0, import_node_path47.join)(CORPUS_ROOT, "filelists");
 
 // src/research/calibrator.ts
 var DEFAULT_POSITIVE = POSITIVE_DIR;
 var DEFAULT_NEGATIVE = NEGATIVE_DIR;
 function buildFileList(dir, extensions) {
-  const tmpList = (0, import_node_path47.join)("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const tmpList = (0, import_node_path48.join)("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
   const expr = extensions.map((e) => `-name '*.${e}'`).join(" -o ");
   (0, import_node_child_process2.execFileSync)("bash", ["-c", `find ${dir} -maxdepth 8 -type f \\( ${expr} \\) -print0 | xargs -0 realpath > ${tmpList}`]);
   const out = (0, import_node_fs36.readFileSync)(tmpList, "utf8");
@@ -55391,13 +55401,13 @@ function runScan2(fileListPath) {
   const ruleFires = /* @__PURE__ */ new Map();
   const uniqueFilesPerRule = /* @__PURE__ */ new Map();
   let fileCount = 0;
-  const tmpOut = (0, import_node_path47.join)("/tmp", `calibrate-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  const tmpOut = (0, import_node_path48.join)("/tmp", `calibrate-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
   for (let i = 0; i < files.length; i += CHUNK) {
     const chunk = files.slice(i, i + CHUNK);
     try {
       (0, import_node_child_process2.execFileSync)(
         "node",
-        [(0, import_node_path47.join)(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
+        [(0, import_node_path48.join)(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
         { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
       );
     } catch {
@@ -55437,8 +55447,8 @@ async function calibrate(cwd, options = {}) {
   const negativeFiles = buildFileList(negativeDir, ["tsx", "ts"]);
   const posSample = options.positiveLimit ? positiveFiles.slice(0, options.positiveLimit) : positiveFiles;
   const negSample = options.negativeLimit ? negativeFiles.slice(0, options.negativeLimit) : negativeFiles;
-  const posListPath = (0, import_node_path47.join)("/tmp", `cal-pos-${Date.now()}.txt`);
-  const negListPath = (0, import_node_path47.join)("/tmp", `cal-neg-${Date.now()}.txt`);
+  const posListPath = (0, import_node_path48.join)("/tmp", `cal-pos-${Date.now()}.txt`);
+  const negListPath = (0, import_node_path48.join)("/tmp", `cal-neg-${Date.now()}.txt`);
   (0, import_node_fs36.writeFileSync)(posListPath, posSample.join("\n"));
   (0, import_node_fs36.writeFileSync)(negListPath, negSample.join("\n"));
   const builtins = await Promise.resolve().then(() => (init_builtins(), builtins_exports));
@@ -55554,8 +55564,8 @@ function registerCalibrate(program) {
         positiveLimit: cmdOptions.positiveLimit,
         negativeLimit: cmdOptions.negativeLimit
       });
-      const outputPath = cmdOptions.output ? (0, import_node_path48.resolve)(cwd, cmdOptions.output) : (0, import_node_path48.resolve)(cwd, "corpus", "calibration-empirical.md");
-      (0, import_node_fs37.mkdirSync)((0, import_node_path48.dirname)(outputPath), { recursive: true });
+      const outputPath = cmdOptions.output ? (0, import_node_path49.resolve)(cwd, cmdOptions.output) : (0, import_node_path49.resolve)(cwd, "corpus", "calibration-empirical.md");
+      (0, import_node_fs37.mkdirSync)((0, import_node_path49.dirname)(outputPath), { recursive: true });
       (0, import_node_fs37.writeFileSync)(outputPath, reportToMarkdown(report), "utf8");
       logger.info(
         "Calibrated " + report.rules.length + " rules across " + report.positiveFileCount + " positive + " + report.negativeFileCount + " negative files."
@@ -55693,13 +55703,13 @@ function registerTrend(program) {
 }
 
 // src/cli/commands/drift.ts
-var import_node_path50 = require("path");
+var import_node_path51 = require("path");
 init_logger();
 init_scan();
 
 // src/cli/drift.ts
 var import_node_fs38 = require("fs");
-var import_node_path49 = require("path");
+var import_node_path50 = require("path");
 init_discover();
 init_patterns();
 async function runDrift(cwd, config, options = {}) {
@@ -55723,7 +55733,7 @@ async function runDrift(cwd, config, options = {}) {
       byCategory[v.category] = (byCategory[v.category] ?? 0) + 1;
       byFile.push({
         file: absPath,
-        relPath: (0, import_node_path49.relative)(cwd, absPath),
+        relPath: (0, import_node_path50.relative)(cwd, absPath),
         category: v.category,
         import: v.import,
         declared: v.declared,
@@ -55820,7 +55830,7 @@ function registerDrift(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "pretty";
         const format = rawFormat === "json" || rawFormat === "pretty" ? rawFormat : "pretty";
-        const cwd = (0, import_node_path50.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path51.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runDrift(cwd, config, { maxFiles: cmdOptions.maxFiles });
         logger.info(formatDrift(result, { json: format === "json" }));
@@ -55834,13 +55844,13 @@ function registerDrift(program) {
 }
 
 // src/cli/commands/pr.ts
-var import_node_path52 = require("path");
+var import_node_path53 = require("path");
 init_logger();
 init_scan();
 
 // src/cli/pr.ts
 var import_node_fs39 = require("fs");
-var import_node_path51 = require("path");
+var import_node_path52 = require("path");
 var import_node_child_process3 = require("child_process");
 var import_node_util2 = require("util");
 var import_minimatch2 = require("minimatch");
@@ -55886,10 +55896,10 @@ async function discoverPrFiles(cwd, config, base, head, maxFiles) {
   if (gitFiles.length === 0) return [];
   const sourceFiles = [];
   for (const relOrAbs of gitFiles) {
-    const abs = (0, import_node_path51.resolve)(cwd, relOrAbs);
-    const ext = (0, import_node_path51.extname)(abs).toLowerCase();
+    const abs = (0, import_node_path52.resolve)(cwd, relOrAbs);
+    const ext = (0, import_node_path52.extname)(abs).toLowerCase();
     if (!PR_EXTENSIONS.has(ext)) continue;
-    const rel = (0, import_node_path51.relative)(cwd, abs).split("\\").join("/");
+    const rel = (0, import_node_path52.relative)(cwd, abs).split("\\").join("/");
     if (config.include.length > 0 && !config.include.some((pattern) => (0, import_minimatch2.minimatch)(rel, pattern))) {
       continue;
     }
@@ -55960,7 +55970,7 @@ async function runPrScan(cwd, config, options = {}) {
     totalScore += fileScore;
     files.push({
       file: absPath,
-      relPath: (0, import_node_path51.relative)(cwd, absPath).split("\\").join("/"),
+      relPath: (0, import_node_path52.relative)(cwd, absPath).split("\\").join("/"),
       score: fileScore,
       issueCount: issues.length,
       constitutionViolationCount: constitutionViolations.length,
@@ -56101,7 +56111,7 @@ function registerPr(program) {
     async (cmdOptions, command) => {
       try {
         const options = command.optsWithGlobals();
-        const cwd = (0, import_node_path52.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path53.resolve)(options.workspace ?? process.cwd());
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "markdown" || rawFormat === "text" ? rawFormat : "text";
         const { config } = await runScan({ ...options, workspace: cwd });
@@ -56123,7 +56133,7 @@ function registerPr(program) {
 }
 
 // src/cli/commands/security.ts
-var import_node_path53 = require("path");
+var import_node_path54 = require("path");
 init_logger();
 init_scan();
 init_ai_security_risk();
@@ -56136,7 +56146,7 @@ function registerSecurity(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "pretty";
         const format = rawFormat === "json" || rawFormat === "pretty" ? rawFormat : "pretty";
-        const cwd = (0, import_node_path53.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path54.resolve)(options.workspace ?? process.cwd());
         const { report } = await runScan({ ...options, workspace: cwd });
         const securityIssues = report.issues.filter((i) => i.category === "security");
         const { risk, findings } = computeAiSecurityRisk(securityIssues);
@@ -56182,12 +56192,12 @@ function registerSecurity(program) {
 }
 
 // src/cli/commands/test.ts
-var import_node_path55 = require("path");
+var import_node_path56 = require("path");
 init_logger();
 init_scan();
 
 // src/cli/test.ts
-var import_node_path54 = require("path");
+var import_node_path55 = require("path");
 init_scan();
 init_test_quality();
 init_logger();
@@ -56258,7 +56268,7 @@ function formatTestReport(result, opts = {}) {
     const sortedFiles = [...byFile.keys()].sort();
     for (const file of sortedFiles) {
       const issues = byFile.get(file) ?? [];
-      const rel = file.startsWith((0, import_node_path54.resolve)(process.cwd())) ? file : file;
+      const rel = file.startsWith((0, import_node_path55.resolve)(process.cwd())) ? file : file;
       lines.push("");
       lines.push(`  ${rel}`);
       for (const issue of issues.slice(0, 20)) {
@@ -56287,7 +56297,7 @@ function registerTest(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "pretty";
         const format = rawFormat === "json" || rawFormat === "pretty" ? rawFormat : "pretty";
-        const cwd = (0, import_node_path55.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path56.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const { result } = await runTestScan(cwd, config, { strict: options.strict });
         logger.info(formatTestReport(result, { json: format === "json" }));
@@ -56301,7 +56311,7 @@ function registerTest(program) {
 }
 
 // src/cli/commands/architecture.ts
-var import_node_path56 = require("path");
+var import_node_path57 = require("path");
 init_logger();
 init_scan();
 init_architecture_score();
@@ -56314,7 +56324,7 @@ function registerArchitecture(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "pretty";
         const format = rawFormat === "json" || rawFormat === "pretty" ? rawFormat : "pretty";
-        const cwd = (0, import_node_path56.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path57.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const score = await buildArchitectureScore(cwd, config, cmdOptions.maxFiles);
         const out = format === "json" ? JSON.stringify(score, null, 2) : formatArchitectureScore(score);
@@ -56329,13 +56339,13 @@ function registerArchitecture(program) {
 }
 
 // src/cli/commands/business-logic.ts
-var import_node_path58 = require("path");
+var import_node_path59 = require("path");
 init_logger();
 init_scan();
 
 // src/cli/business-logic.ts
 var import_node_fs40 = require("fs");
-var import_node_path57 = require("path");
+var import_node_path58 = require("path");
 init_discover();
 init_business_logic();
 async function runBusinessLogicScan(cwd, config, options = {}) {
@@ -56356,7 +56366,7 @@ async function runBusinessLogicScan(cwd, config, options = {}) {
     for (const issue of fileIssues) {
       issues.push({
         ...issue,
-        filePath: (0, import_node_path57.relative)(cwd, absPath) || absPath
+        filePath: (0, import_node_path58.relative)(cwd, absPath) || absPath
       });
     }
   }
@@ -56459,7 +56469,7 @@ function registerBusinessLogic(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "markdown" || rawFormat === "text" ? rawFormat : "text";
-        const cwd = (0, import_node_path58.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path59.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runBusinessLogicScan(cwd, config, {
           maxFiles: cmdOptions.maxFiles
@@ -56475,7 +56485,7 @@ function registerBusinessLogic(program) {
 }
 
 // src/cli/commands/maintenance-cost.ts
-var import_node_path59 = require("path");
+var import_node_path60 = require("path");
 init_logger();
 init_scan();
 
@@ -56601,7 +56611,7 @@ function registerMaintenanceCost(program) {
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "text" ? rawFormat : "text";
         const strict = options.strict ?? cmdOptions.strict ?? false;
-        const cwd = (0, import_node_path59.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path60.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runMaintenanceCostScan(cwd, config, {
           maxFiles: cmdOptions.maxFiles,
@@ -56618,7 +56628,7 @@ function registerMaintenanceCost(program) {
 }
 
 // src/cli/commands/docs.ts
-var import_node_path60 = require("path");
+var import_node_path61 = require("path");
 init_logger();
 init_scan();
 
@@ -56745,7 +56755,7 @@ function registerDocs(program) {
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "markdown" || rawFormat === "text" ? rawFormat : "text";
         const strict = options.strict ?? cmdOptions.strict ?? false;
-        const cwd = (0, import_node_path60.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path61.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runDocsScan(cwd, config, {
           maxDocFiles: cmdOptions.maxFiles,
@@ -56767,7 +56777,7 @@ function registerDocs(program) {
 }
 
 // src/cli/commands/db.ts
-var import_node_path61 = require("path");
+var import_node_path62 = require("path");
 init_logger();
 init_scan();
 
@@ -56888,7 +56898,7 @@ function registerDb(program) {
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "markdown" || rawFormat === "text" ? rawFormat : "text";
         const strict = options.strict ?? cmdOptions.strict ?? false;
-        const cwd = (0, import_node_path61.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path62.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runDbScan(cwd, config, {
           maxFiles: cmdOptions.maxFiles,
@@ -56910,13 +56920,13 @@ function registerDb(program) {
 }
 
 // src/cli/commands/patterns.ts
-var import_node_path63 = require("path");
+var import_node_path64 = require("path");
 init_logger();
 init_scan();
 
 // src/engine/patterns.ts
 var import_node_fs41 = require("fs");
-var import_node_path62 = require("path");
+var import_node_path63 = require("path");
 init_patterns();
 init_discover();
 var PATTERN_CATEGORIES = [
@@ -56951,7 +56961,7 @@ var TOAST_NAME_RE = /^(?:[A-Z][a-zA-Z0-9]+)?(Toast|Notification|Snackbar|Alert|B
 var CARD_NAME_RE = /^(?:[A-Z][a-zA-Z0-9]+)?(Card|Tile|Chip|Badge)$/;
 var API_PATH_RE2 = /(?:^|\/)(?:lib\/api|services|api-client|clients)\//;
 function baseName(filePath) {
-  return (0, import_node_path62.basename)(filePath).replace(/\.(tsx|ts|jsx|js|vue|svelte|astro)$/i, "");
+  return (0, import_node_path63.basename)(filePath).replace(/\.(tsx|ts|jsx|js|vue|svelte|astro)$/i, "");
 }
 function makeStats(patterns) {
   const seen = /* @__PURE__ */ new Set();
@@ -57010,7 +57020,7 @@ function detectApiFromFiles(files, cwd) {
   const out = [];
   for (const f of files) {
     if (API_PATH_RE2.test(f)) {
-      out.push((0, import_node_path62.relative)(cwd, f).split("\\").join("/"));
+      out.push((0, import_node_path63.relative)(cwd, f).split("\\").join("/"));
     }
   }
   return out;
@@ -57241,7 +57251,7 @@ function registerPatterns(program) {
         const options = command.optsWithGlobals();
         const rawFormat = options.format ?? cmdOptions.format ?? "text";
         const format = rawFormat === "json" || rawFormat === "markdown" || rawFormat === "text" ? rawFormat : "text";
-        const cwd = (0, import_node_path63.resolve)(options.workspace ?? process.cwd());
+        const cwd = (0, import_node_path64.resolve)(options.workspace ?? process.cwd());
         const { config } = await runScan({ ...options, workspace: cwd });
         const result = await runPatternsScan(cwd, config, {
           maxFiles: cmdOptions.maxFiles,
@@ -57259,7 +57269,7 @@ function registerPatterns(program) {
 
 // src/cli/commands/research.ts
 var import_node_fs42 = require("fs");
-var import_node_path64 = require("path");
+var import_node_path65 = require("path");
 init_logger();
 init_config();
 function registerResearch(program) {
@@ -57276,14 +57286,14 @@ function registerResearch(program) {
       framework: cmdOptions.framework,
       componentType: cmdOptions.componentType,
       provider,
-      outputDir: (0, import_node_path64.resolve)(cmdOptions.outputDir),
+      outputDir: (0, import_node_path65.resolve)(cmdOptions.outputDir),
       temperature: cmdOptions.temperature
     });
     logger.info(`Generated ${samples.length} samples in ${cmdOptions.outputDir}`);
   });
   research.command("analyze").description("analyze generated samples and report coverage").requiredOption("--input-dir <path>", "directory with generated samples containing metadata.json").option("--output <path>", "analysis output path", ".slopbrick/flywheel/analysis.json").option("--config <path>", "slopbrick config path").option("--framework <name>", "framework multiplier to apply", "react").action(async (cmdOptions) => {
     try {
-      const metadataPath = (0, import_node_path64.resolve)(cmdOptions.inputDir, "metadata.json");
+      const metadataPath = (0, import_node_path65.resolve)(cmdOptions.inputDir, "metadata.json");
       if (!(0, import_node_fs42.existsSync)(metadataPath)) {
         logger.error(`No metadata.json found in ${cmdOptions.inputDir}`);
         process.exit(2);
@@ -57291,8 +57301,8 @@ function registerResearch(program) {
       const samples = JSON.parse((0, import_node_fs42.readFileSync)(metadataPath, "utf8"));
       const config = cmdOptions.config ? await loadConfig(cmdOptions.config) : { ...DEFAULT_CONFIG, framework: cmdOptions.framework };
       const analysis = await analyzeSamples(samples, config);
-      const outputPath = (0, import_node_path64.resolve)(cmdOptions.output);
-      (0, import_node_fs42.mkdirSync)((0, import_node_path64.dirname)(outputPath), { recursive: true });
+      const outputPath = (0, import_node_path65.resolve)(cmdOptions.output);
+      (0, import_node_fs42.mkdirSync)((0, import_node_path65.dirname)(outputPath), { recursive: true });
       (0, import_node_fs42.writeFileSync)(outputPath, JSON.stringify(analysis, null, 2), "utf8");
       logger.info(`Analyzed ${analysis.summary.total} samples; coverage: ${analysis.summary.coverage}%`);
       logger.info(`Wrote analysis to ${outputPath}`);
@@ -57303,7 +57313,7 @@ function registerResearch(program) {
   });
   research.command("candidates").description("extract patterns from generated samples and emit candidate rules").requiredOption("--input-dir <path>", "directory with generated samples containing metadata.json").option("--output <path>", "output path", ".slopbrick/flywheel/rule-candidates.json").option("--config <path>", "slopbrick config path").option("--framework <name>", "framework multiplier to apply", "react").option("--min-frequency <n>", "minimum cluster frequency", parseCount, 2).option("--include-covered", "include samples already covered by AI-specific rules").action(async (cmdOptions) => {
     try {
-      const metadataPath = (0, import_node_path64.resolve)(cmdOptions.inputDir, "metadata.json");
+      const metadataPath = (0, import_node_path65.resolve)(cmdOptions.inputDir, "metadata.json");
       if (!(0, import_node_fs42.existsSync)(metadataPath)) {
         logger.error(`No metadata.json found in ${cmdOptions.inputDir}`);
         process.exit(2);
@@ -57318,8 +57328,8 @@ function registerResearch(program) {
       const candidates = clustersToCandidates(extraction.clusters, {
         minFrequency: cmdOptions.minFrequency
       });
-      const outputPath = (0, import_node_path64.resolve)(cmdOptions.output);
-      (0, import_node_fs42.mkdirSync)((0, import_node_path64.dirname)(outputPath), { recursive: true });
+      const outputPath = (0, import_node_path65.resolve)(cmdOptions.output);
+      (0, import_node_fs42.mkdirSync)((0, import_node_path65.dirname)(outputPath), { recursive: true });
       const payload = {
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         sampleCount: analysis.summary.total,
@@ -57339,7 +57349,7 @@ function registerResearch(program) {
 
 // src/cli/commands/init.ts
 var import_node_fs43 = require("fs");
-var import_node_path66 = require("path");
+var import_node_path67 = require("path");
 init_logger();
 init_builtins();
 init_scan();
@@ -57349,7 +57359,7 @@ init_git();
 init_cache();
 
 // src/snippet/targets.ts
-var import_node_path65 = require("path");
+var import_node_path66 = require("path");
 
 // src/snippet/render.ts
 function aiSpecificRules(rules) {
@@ -57580,7 +57590,7 @@ var SNIPPET_TARGETS = [
   }
 ];
 function resolveTargetPath(target) {
-  return target.isFolder ? (0, import_node_path65.join)(target.path, target.filename) : target.path;
+  return target.isFolder ? (0, import_node_path66.join)(target.path, target.filename) : target.path;
 }
 function renderMatrix() {
   const lines = [];
@@ -57602,8 +57612,8 @@ function registerInit(program) {
       logger.info(renderMatrix());
       process.exit(0);
     }
-    const cwd = (0, import_node_path66.resolve)(options.workspace ?? process.cwd());
-    const configPath = (0, import_node_path66.join)(cwd, "slopbrick.config.mjs");
+    const cwd = (0, import_node_path67.resolve)(options.workspace ?? process.cwd());
+    const configPath = (0, import_node_path67.join)(cwd, "slopbrick.config.mjs");
     const detected = detectStack(cwd);
     const fallbackConfig = { ...DEFAULT_CONFIG, ...detected };
     const proposed = serializeConfig(fallbackConfig);
@@ -57659,8 +57669,8 @@ function registerInit(program) {
       return Boolean(opts[t.flag]);
     });
     for (const target of targetsToWrite) {
-      const snippetPath = (0, import_node_path66.join)(cwd, resolveTargetPath(target));
-      (0, import_node_fs43.mkdirSync)((0, import_node_path66.dirname)(snippetPath), { recursive: true });
+      const snippetPath = (0, import_node_path67.join)(cwd, resolveTargetPath(target));
+      (0, import_node_fs43.mkdirSync)((0, import_node_path67.dirname)(snippetPath), { recursive: true });
       const generated = target.generator(builtinRules);
       if (!target.isFolder && (0, import_node_fs43.existsSync)(snippetPath)) {
         const existing = (0, import_node_fs43.readFileSync)(snippetPath, "utf8");
@@ -57700,13 +57710,13 @@ function registerInit(program) {
 
 // src/cli/commands/flywheel.ts
 var import_node_fs45 = require("fs");
-var import_node_path68 = require("path");
+var import_node_path69 = require("path");
 init_logger();
 init_telemetry();
 
 // src/report/flywheel.ts
 var import_node_fs44 = require("fs");
-var import_node_path67 = require("path");
+var import_node_path68 = require("path");
 function average(values) {
   if (values.length === 0) return 0;
   return values.reduce((a, b) => a + b, 0) / values.length;
@@ -57796,7 +57806,7 @@ function formatFlywheel(summary, options = {}) {
 function registerFlywheel(program) {
   program.command("flywheel").description("summarize aggregated scan telemetry").option("--format <pretty|json>", "output format", "pretty").option("--export <path>", "write summary as JSON to <path>").action(async (cmdOptions, command) => {
     const options = command.optsWithGlobals();
-    const cwd = (0, import_node_path68.resolve)(options.workspace ?? process.cwd());
+    const cwd = (0, import_node_path69.resolve)(options.workspace ?? process.cwd());
     const payloads = readTelemetry(cwd);
     if (payloads.length === 0) {
       logger.info("No flywheel telemetry found. Run a scan first.");
@@ -57804,8 +57814,8 @@ function registerFlywheel(program) {
     }
     const summary = summarizeTelemetry(payloads);
     if (cmdOptions.export) {
-      const exportPath = (0, import_node_path68.resolve)(cmdOptions.export);
-      (0, import_node_fs45.mkdirSync)((0, import_node_path68.dirname)(exportPath), { recursive: true });
+      const exportPath = (0, import_node_path69.resolve)(cmdOptions.export);
+      (0, import_node_fs45.mkdirSync)((0, import_node_path69.dirname)(exportPath), { recursive: true });
       (0, import_node_fs45.writeFileSync)(exportPath, JSON.stringify(summary, null, 2), "utf-8");
       logger.info(`Wrote flywheel summary to ${exportPath}`);
       process.exit(0);
@@ -58288,7 +58298,7 @@ async function runCli({ start }) {
         logger.error("--heatmap and --suggest can't be used together. Pick one: a heatmap of severity, or text advice.");
         process.exit(2);
       }
-      const cwd = (0, import_node_path69.resolve)(options.workspace ?? process.cwd());
+      const cwd = (0, import_node_path70.resolve)(options.workspace ?? process.cwd());
       if (options.trend !== void 0) {
         const runs = await readRuns(cwd, fsMemoryIO);
         if (runs.length === 0) {
@@ -58321,7 +58331,7 @@ async function runCli({ start }) {
       const scanElapsed = Math.round(import_node_perf_hooks.performance.now() - scanStart);
       const totalElapsed = Math.round(import_node_perf_hooks.performance.now() - start);
       if (options.baseline) {
-        const cwd2 = (0, import_node_path69.resolve)(options.workspace ?? process.cwd());
+        const cwd2 = (0, import_node_path70.resolve)(options.workspace ?? process.cwd());
         const configHash = hashConfig(config);
         const gitHead = await getGitHead(cwd2) ?? "unknown";
         const cache = buildBaselineCache(report, configHash, gitHead, cwd2);