slopbrick 0.11.0 → 0.11.2

package/dist/index.js

@@ -30,7 +30,7 @@ var VERSION, AI_SECURITY_NUMERIC, REPOSITORY_HEALTH_WEIGHTS;
 var init_types = __esm({
   "src/types.ts"() {
     "use strict";
-    VERSION = "0.10.0";
+    VERSION = "0.11.2";
     AI_SECURITY_NUMERIC = {
       low: 100,
       medium: 75,
@@ -3482,7 +3482,7 @@ function discoverTestFiles(cwd) {
   }
   return found;
 }
-function walk(dir, out, readdirSync6, statSync7) {
+function walk(dir, out, readdirSync6, statSync8) {
   let entries;
   try {
     entries = readdirSync6(dir);
@@ -3494,12 +3494,12 @@ function walk(dir, out, readdirSync6, statSync7) {
     const full = `${dir}/${entry}`;
     let stat;
     try {
-      stat = statSync7(full);
+      stat = statSync8(full);
     } catch {
       continue;
     }
     if (stat.isDirectory()) {
-      walk(full, out, readdirSync6, statSync7);
+      walk(full, out, readdirSync6, statSync8);
     } else if (stat.isFile()) {
       if (/\.(test|spec)\.[jt]sx?$/.test(entry) || /\.stories\.[jt]sx?$/.test(entry)) {
         out.push(full);
@@ -9408,8 +9408,8 @@ function hasExtendedSibling(filePath) {
   const base = basename(filePath);
   for (const ext of SOURCE_EXTENSIONS) {
     try {
-      const { statSync: statSync7 } = __require("fs");
-      statSync7(join7(dir, base + ext));
+      const { statSync: statSync8 } = __require("fs");
+      statSync8(join7(dir, base + ext));
       return true;
     } catch {
     }
@@ -9566,8 +9566,8 @@ var init_git = __esm({
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync2, renameSync, mkdirSync, unlinkSync } from "fs";
 import { dirname as dirname4, isAbsolute, resolve as resolve7 } from "path";
-function loadCache(cachePath6) {
-  const abs = isAbsolute(cachePath6) ? cachePath6 : resolve7(process.cwd(), cachePath6);
+function loadCache(cachePath4) {
+  const abs = isAbsolute(cachePath4) ? cachePath4 : resolve7(process.cwd(), cachePath4);
   if (!existsSync8(abs)) return void 0;
   try {
     const raw = readFileSync9(abs, "utf-8");
@@ -9578,8 +9578,8 @@ function loadCache(cachePath6) {
     return void 0;
   }
 }
-function saveCache(cachePath6, cache) {
-  const abs = isAbsolute(cachePath6) ? cachePath6 : resolve7(process.cwd(), cachePath6);
+function saveCache(cachePath4, cache) {
+  const abs = isAbsolute(cachePath4) ? cachePath4 : resolve7(process.cwd(), cachePath4);
   mkdirSync(dirname4(abs), { recursive: true });
   const tmp = abs + ".tmp";
   if (existsSync8(tmp)) {
@@ -12876,38 +12876,46 @@ var init_heatmap = __esm({
   }
 });
 
+// ../core/dist/index.js
+import { writeFileSync as writeFileSync5, renameSync as renameSync2, existsSync as existsSync12, readFileSync as readFileSync15, statSync as statSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join10, dirname as dirname6 } from "path";
+function inventoryPath(workspaceDir) {
+  return join10(workspaceDir, ".slopbrick", INVENTORY_FILENAME);
+}
+function constitutionPath(workspaceDir) {
+  return join10(workspaceDir, ".slopbrick", CONSTITUTION_FILENAME);
+}
+function ensureSlopbrickDir(workspaceDir) {
+  mkdirSync3(join10(workspaceDir, ".slopbrick"), { recursive: true });
+}
+function writeJsonAtomic(filePath, payload) {
+  ensureSlopbrickDir(dirname6(filePath));
+  const tmp = `${filePath}.tmp`;
+  writeFileSync5(tmp, JSON.stringify(payload, null, 2), "utf-8");
+  renameSync2(tmp, filePath);
+}
+function saveInventory(workspaceDir, inventory) {
+  writeJsonAtomic(inventoryPath(workspaceDir), inventory);
+}
+function saveConstitution(workspaceDir, constitution) {
+  writeJsonAtomic(constitutionPath(workspaceDir), constitution);
+}
+var MEMORY_SCHEMA_VERSION, INVENTORY_FILENAME, CONSTITUTION_FILENAME;
+var init_dist = __esm({
+  "../core/dist/index.js"() {
+    "use strict";
+    MEMORY_SCHEMA_VERSION = "2";
+    INVENTORY_FILENAME = "inventory.json";
+    CONSTITUTION_FILENAME = "constitution.json";
+  }
+});
+
 // src/engine/memory.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync15, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname6, join as join10 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join11 } from "path";
 import { createHash as createHash6 } from "crypto";
-import {
-  MEMORY_SCHEMA_VERSION,
-  writeCacheFromInventory
-} from "@usebrick/core";
-import {
-  MEMORY_SCHEMA_VERSION as MEMORY_SCHEMA_VERSION2,
-  isMemoryPattern as isMemoryPattern2,
-  isComponentFingerprint as isComponentFingerprint2,
-  isInventoryFile as isInventoryFile2,
-  isConstitutionFile as isConstitutionFile2,
-  isFileMtimeEntry as isFileMtimeEntry2,
-  inventoryPath as inventoryPath2,
-  constitutionPath as constitutionPath2,
-  cachePath as cachePath3,
-  loadInventory as loadInventory2,
-  loadConstitution as loadConstitution2,
-  saveConstitution as saveConstitution2,
-  readCache as readCache3,
-  isInventoryFresh as isInventoryFresh2,
-  invalidateFile as invalidateFile2
-} from "@usebrick/core";
-async function saveInventory(workspaceDir, inventory, computeHash = computeFileHash) {
-  const { saveInventory: coreSave } = await import("@usebrick/core");
-  coreSave(workspaceDir, inventory);
-  writeCacheFromInventory(workspaceDir, inventory, computeHash);
-}
 function telemetryPath(cwd) {
-  return join10(cwd, TELEMETRY_FILE);
+  return join11(cwd, TELEMETRY_FILE);
 }
 function isSlopAuditRun(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -12916,9 +12924,9 @@ function isSlopAuditRun(value) {
 }
 function readRuns(cwd) {
   const path = telemetryPath(cwd);
-  if (!existsSync12(path)) return [];
+  if (!existsSync13(path)) return [];
   try {
-    const raw = readFileSync15(path, "utf-8");
+    const raw = readFileSync16(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed.filter(isSlopAuditRun);
@@ -12948,8 +12956,8 @@ function appendRun(cwd, report, thresholdExceeded2) {
     runs.splice(0, runs.length - MAX_RUNS);
   }
   const path = telemetryPath(cwd);
-  mkdirSync3(dirname6(path), { recursive: true });
-  writeFileSync5(path, JSON.stringify(runs, null, 2));
+  mkdirSync4(dirname7(path), { recursive: true });
+  writeFileSync6(path, JSON.stringify(runs, null, 2));
   return run2;
 }
 async function buildInventoryFromScan(scanResult, config, durationMs) {
@@ -13068,7 +13076,8 @@ var init_memory = __esm({
     init_types();
     init_patterns();
     init_cache_incremental();
-    TELEMETRY_FILE = join10(".slopbrick", "memory.json");
+    init_dist();
+    TELEMETRY_FILE = join11(".slopbrick", "memory.json");
     MAX_RUNS = 1e3;
   }
 });
@@ -13076,18 +13085,18 @@ var init_memory = __esm({
 // src/engine/telemetry.ts
 import {
   appendFileSync,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync16,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync17,
   readdirSync as readdirSync5,
-  renameSync as renameSync2,
+  renameSync as renameSync3,
   rmSync,
-  statSync as statSync5
+  statSync as statSync6
 } from "fs";
 import { createHash as createHash7 } from "crypto";
-import { dirname as dirname7, join as join11, relative as relative7 } from "path";
+import { dirname as dirname8, join as join12, relative as relative7 } from "path";
 function telemetryPath2(cwd) {
-  return join11(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
+  return join12(cwd, TELEMETRY_DIR, TELEMETRY_FILE2);
 }
 function hashString(input) {
   return createHash7("sha256").update(input).digest("hex").slice(0, 16);
@@ -13140,33 +13149,33 @@ function isTelemetryFile(name) {
 }
 function rotateTelemetry(cwd) {
   const path = telemetryPath2(cwd);
-  if (!existsSync13(path)) {
+  if (!existsSync14(path)) {
     return;
   }
-  const stats = statSync5(path);
+  const stats = statSync6(path);
   if (stats.size < MAX_TELEMETRY_BYTES) {
     return;
   }
-  const dir = dirname7(path);
+  const dir = dirname8(path);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  renameSync2(path, join11(dir, `scans-${timestamp}.jsonl`));
-  const rotated = readdirSync5(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: statSync5(join11(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
+  renameSync3(path, join12(dir, `scans-${timestamp}.jsonl`));
+  const rotated = readdirSync5(dir).filter(isTelemetryFile).map((name) => ({ name, mtime: statSync6(join12(dir, name)).mtimeMs })).sort((a, b) => a.mtime - b.mtime);
   while (rotated.length > MAX_ROTATED_FILES) {
     const oldest = rotated.shift();
     if (oldest) {
-      rmSync(join11(dir, oldest.name), { force: true });
+      rmSync(join12(dir, oldest.name), { force: true });
     }
   }
 }
 function readTelemetry(cwd) {
-  const dir = join11(cwd, TELEMETRY_DIR);
-  if (!existsSync13(dir)) {
+  const dir = join12(cwd, TELEMETRY_DIR);
+  if (!existsSync14(dir)) {
     return [];
   }
-  const files = readdirSync5(dir).filter(isTelemetryFile).sort().map((name) => join11(dir, name));
+  const files = readdirSync5(dir).filter(isTelemetryFile).sort().map((name) => join12(dir, name));
   const payloads = [];
   for (const file of files) {
-    const raw = readFileSync16(file, "utf-8");
+    const raw = readFileSync17(file, "utf-8");
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -13198,9 +13207,9 @@ function recordTelemetry(cwd, report, results, config) {
     files: buildFileRecords(cwd, report, results)
   };
   const path = telemetryPath2(cwd);
-  const dir = dirname7(path);
-  if (!existsSync13(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = dirname8(path);
+  if (!existsSync14(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   rotateTelemetry(cwd);
   appendFileSync(path, JSON.stringify(payload) + "\n", "utf-8");
@@ -13210,7 +13219,7 @@ var TELEMETRY_DIR, TELEMETRY_FILE2, MAX_TELEMETRY_BYTES, MAX_ROTATED_FILES;
 var init_telemetry = __esm({
   "src/engine/telemetry.ts"() {
     "use strict";
-    TELEMETRY_DIR = join11(".slopbrick", "flywheel");
+    TELEMETRY_DIR = join12(".slopbrick", "flywheel");
     TELEMETRY_FILE2 = "scans.jsonl";
     MAX_TELEMETRY_BYTES = 10 * 1024 * 1024;
     MAX_ROTATED_FILES = 5;
@@ -13219,8 +13228,8 @@ var init_telemetry = __esm({
 
 // src/engine/flywheel.ts
 import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "fs";
+import { join as join13 } from "path";
 function severityBump(severity) {
   const order = ["low", "medium", "high"];
   const idx = order.indexOf(severity);
@@ -13321,30 +13330,30 @@ function migrateFlywheelState(state) {
   };
 }
 function loadFlywheelState(cwd) {
-  const path = join12(cwd, FLYWHEEL_DIR, STATE_FILE);
-  if (!existsSync14(path)) {
+  const path = join13(cwd, FLYWHEEL_DIR, STATE_FILE);
+  if (!existsSync15(path)) {
     return migrateFlywheelState({});
   }
   try {
-    const parsed = JSON.parse(readFileSync17(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync18(path, "utf-8"));
     return migrateFlywheelState(parsed);
   } catch {
     return migrateFlywheelState({});
   }
 }
 function loadResearchMetricsFromDisk(cwd) {
-  const flywheelDir = join12(cwd, FLYWHEEL_DIR);
-  const analysisPath = join12(flywheelDir, "analysis.json");
-  const candidatesPath = join12(flywheelDir, "rule-candidates.json");
-  const hasAnalysis = existsSync14(analysisPath);
-  const hasCandidates = existsSync14(candidatesPath);
+  const flywheelDir = join13(cwd, FLYWHEEL_DIR);
+  const analysisPath = join13(flywheelDir, "analysis.json");
+  const candidatesPath = join13(flywheelDir, "rule-candidates.json");
+  const hasAnalysis = existsSync15(analysisPath);
+  const hasCandidates = existsSync15(candidatesPath);
   if (!hasAnalysis && !hasCandidates) return void 0;
   let generatedSampleCount = 0;
   let generatedRuleCoverage = 0;
   let candidateYield = 0;
   if (hasAnalysis) {
     try {
-      const raw = JSON.parse(readFileSync17(analysisPath, "utf8"));
+      const raw = JSON.parse(readFileSync18(analysisPath, "utf8"));
       generatedSampleCount = raw.summary?.total ?? 0;
       generatedRuleCoverage = raw.summary?.coverage ?? 0;
     } catch {
@@ -13352,7 +13361,7 @@ function loadResearchMetricsFromDisk(cwd) {
   }
   if (hasCandidates) {
     try {
-      const raw = JSON.parse(readFileSync17(candidatesPath, "utf8"));
+      const raw = JSON.parse(readFileSync18(candidatesPath, "utf8"));
       candidateYield = raw.candidates?.length ?? 0;
     } catch {
     }
@@ -13365,9 +13374,9 @@ function loadResearchMetricsFromDisk(cwd) {
   };
 }
 function saveFlywheelState(cwd, state) {
-  const dir = join12(cwd, FLYWHEEL_DIR);
-  if (!existsSync14(dir)) mkdirSync5(dir, { recursive: true });
-  writeFileSync6(join12(dir, STATE_FILE), JSON.stringify(state, null, 2));
+  const dir = join13(cwd, FLYWHEEL_DIR);
+  if (!existsSync15(dir)) mkdirSync6(dir, { recursive: true });
+  writeFileSync7(join13(dir, STATE_FILE), JSON.stringify(state, null, 2));
 }
 function hashFile(filePath) {
   return createHash8("sha256").update(filePath).digest("hex").slice(0, 16);
@@ -13660,7 +13669,7 @@ var init_signal_strength2 = __esm({
 });
 
 // src/cli/tokens.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 function parseDtcgTokens(raw) {
   let parsed;
   try {
@@ -13675,7 +13684,7 @@ function parseDtcgTokens(raw) {
 }
 function readDtcgTokensFile(path) {
   try {
-    const raw = readFileSync18(path, "utf-8");
+    const raw = readFileSync19(path, "utf-8");
     return parseDtcgTokens(raw);
   } catch (error) {
     return { ok: false, error: `Cannot read ${path}: ${error.message}` };
@@ -14115,8 +14124,8 @@ __export(doc_freshness_exports, {
   extractInlineCodeSpans: () => extractInlineCodeSpans,
   extractMarkdownLinks: () => extractMarkdownLinks
 });
-import { readFileSync as readFileSync19, existsSync as existsSync15 } from "fs";
-import { join as join13, dirname as dirname9, relative as relative8 } from "path";
+import { readFileSync as readFileSync20, existsSync as existsSync16 } from "fs";
+import { join as join14, dirname as dirname10, relative as relative8 } from "path";
 import { globby as globby2 } from "globby";
 function extractInlineCodeSpans(source) {
   const hits = [];
@@ -14180,10 +14189,10 @@ function extractMarkdownLinks(source) {
 }
 function declaredPackages(cwd) {
   const out = /* @__PURE__ */ new Set();
-  const pkgPath = join13(cwd, "package.json");
-  if (!existsSync15(pkgPath)) return out;
+  const pkgPath = join14(cwd, "package.json");
+  if (!existsSync16(pkgPath)) return out;
   try {
-    const raw = readFileSync19(pkgPath, "utf-8");
+    const raw = readFileSync20(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     for (const k of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
       const v = pkg[k];
@@ -14219,7 +14228,7 @@ async function extractExports(cwd, config, maxFiles = 500) {
   for (const abs of limited) {
     let source;
     try {
-      source = readFileSync19(abs, "utf-8");
+      source = readFileSync20(abs, "utf-8");
     } catch {
       continue;
     }
@@ -14318,10 +14327,10 @@ function detectExpiredCodeExamples(source, relPath, cwd, packages) {
     const imports = extractImports(block.body);
     for (const imp of imports) {
       if (imp.startsWith(".") || imp.startsWith("/")) {
-        const docDir = dirname9(join13(cwd, relPath));
-        const candidate = join13(docDir, imp);
+        const docDir = dirname10(join14(cwd, relPath));
+        const candidate = join14(docDir, imp);
         const exts = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
-        const found = exts.some((e) => existsSync15(candidate + e));
+        const found = exts.some((e) => existsSync16(candidate + e));
         if (!found) {
           findings.push({
             ruleId: "docs/expired-code-example",
@@ -14360,7 +14369,7 @@ function detectExpiredCodeExamples(source, relPath, cwd, packages) {
 function detectBrokenLinks(source, relPath, cwd) {
   const findings = [];
   const links = extractMarkdownLinks(source);
-  const docDir = dirname9(join13(cwd, relPath));
+  const docDir = dirname10(join14(cwd, relPath));
   for (const link of links) {
     const target = link.target;
     if (target.startsWith("http://") || target.startsWith("https://")) continue;
@@ -14368,8 +14377,8 @@ function detectBrokenLinks(source, relPath, cwd) {
     if (target.startsWith("#")) continue;
     if (target.startsWith("//")) continue;
     if (target.startsWith("/")) continue;
-    const resolved = join13(docDir, target);
-    if (!existsSync15(resolved)) {
+    const resolved = join14(docDir, target);
+    if (!existsSync16(resolved)) {
       findings.push({
         ruleId: "docs/broken-link",
         severity: "low",
@@ -14406,7 +14415,7 @@ async function buildDocFreshness(cwd, config, options = {}) {
   for (const abs of docLimited) {
     let source;
     try {
-      source = readFileSync19(abs, "utf-8");
+      source = readFileSync20(abs, "utf-8");
     } catch {
       continue;
     }
@@ -14713,7 +14722,7 @@ __export(db_health_exports, {
   DB_RULE_WEIGHTS: () => DB_RULE_WEIGHTS,
   buildDbHealth: () => buildDbHealth
 });
-import { readFileSync as readFileSync20 } from "fs";
+import { readFileSync as readFileSync21 } from "fs";
 import { relative as relative9 } from "path";
 import { globby as globby3 } from "globby";
 import { parse as parseSql, loadModule as loadSqlModule } from "pgsql-parser";
@@ -14724,7 +14733,7 @@ function ensureSqlModule() {
 async function parseSqlFile(filePath) {
   let raw;
   try {
-    raw = readFileSync20(filePath, "utf-8");
+    raw = readFileSync21(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -14964,7 +14973,7 @@ async function buildDbHealth(cwd, _config, options = {}) {
   for (const abs of tsFiles.slice(0, maxFiles)) {
     let source;
     try {
-      source = readFileSync20(abs, "utf-8");
+      source = readFileSync21(abs, "utf-8");
     } catch {
       continue;
     }
@@ -15417,8 +15426,8 @@ __export(scan_exports, {
   scanProject: () => scanProject,
   watchProject: () => watchProject
 });
-import { existsSync as existsSync16, writeFileSync as writeFileSync7, watch, statSync as statSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync21 } from "fs";
-import { resolve as resolve9, join as join15, relative as relative10, extname as extname6, sep as sep2 } from "path";
+import { existsSync as existsSync17, writeFileSync as writeFileSync8, watch, statSync as statSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync22 } from "fs";
+import { resolve as resolve9, join as join16, relative as relative10, extname as extname6, sep as sep2 } from "path";
 function buildBaselineCache(report, configHash, gitHead, cwd) {
   const scores = {};
   for (const component of report.components) {
@@ -15441,10 +15450,10 @@ async function runScan(options, explicitPaths) {
   setLoggerQuiet(!!options.quiet);
   const startTime = Date.now();
   const cwd = resolve9(options.workspace ?? process.cwd());
-  if (!existsSync16(cwd)) {
+  if (!existsSync17(cwd)) {
     throw new Error(`Workspace not found: ${cwd}`);
   }
-  const cwdStat = statSync6(cwd);
+  const cwdStat = statSync7(cwd);
   if (!cwdStat.isDirectory()) {
     throw new Error(`Workspace is not a directory: ${cwd}`);
   }
@@ -15486,8 +15495,8 @@ async function runScan(options, explicitPaths) {
     const resolved = explicitPaths.map((p) => resolve9(cwd, p));
     const expanded = [];
     for (const p of resolved) {
-      if (existsSync16(p) && statSync6(p).isDirectory()) {
-        const found = await globby4(join15(p, "**/*"), { absolute: true, onlyFiles: true });
+      if (existsSync17(p) && statSync7(p).isDirectory()) {
+        const found = await globby4(join16(p, "**/*"), { absolute: true, onlyFiles: true });
         for (const f of found) {
           if (!ALL_SOURCE_EXTENSIONS.has(extname6(f).toLowerCase())) continue;
           const rel = relative10(cwd, f).split(sep2).join("/");
@@ -15525,8 +15534,8 @@ async function runScan(options, explicitPaths) {
   }
   let incrementalSummary;
   if (options.incremental) {
-    const cachePath6 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath6);
+    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath4);
     const { toScan, unchanged } = partitionByCache(files, existing);
     files = toScan;
     incrementalSummary = { skipped: unchanged.length, rescanned: toScan.length };
@@ -15631,7 +15640,7 @@ async function runScan(options, explicitPaths) {
     const scannedPaths = new Set(results.map((result) => result.filePath));
     for (const [filePath, cached] of Object.entries(baseline.scores)) {
       if (scannedPaths.has(filePath)) continue;
-      if (!existsSync16(filePath)) continue;
+      if (!existsSync17(filePath)) continue;
       scores.push({
         filePath,
         rawScore: 0,
@@ -15945,8 +15954,8 @@ async function runScan(options, explicitPaths) {
     appendRun(cwd, report, thresholdExceeded(report, config));
   }
   if (options.incremental) {
-    const cachePath6 = options.cachePath ?? ".slopbrick-cache.json";
-    const existing = loadCache(cachePath6) ?? emptyCache();
+    const cachePath4 = options.cachePath ?? ".slopbrick-cache.json";
+    const existing = loadCache(cachePath4) ?? emptyCache();
     const next = { ...existing, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
     for (const result of results) {
       try {
@@ -15960,7 +15969,7 @@ async function runScan(options, explicitPaths) {
       } catch {
       }
     }
-    saveCache(cachePath6, next);
+    saveCache(cachePath4, next);
     if (incrementalSummary && !options.quiet) {
       logger.info(
         `Incremental: re-scanned ${incrementalSummary.rescanned}, skipped ${incrementalSummary.skipped} (unchanged).`
@@ -15992,10 +16001,10 @@ async function runScan(options, explicitPaths) {
       report.research = state.research;
     }
     if (flywheelOutput.suggestions.length > 0) {
-      const suggestionsDir = join15(cwd, ".slopbrick", "flywheel");
-      if (!existsSync16(suggestionsDir)) mkdirSync6(suggestionsDir, { recursive: true });
-      writeFileSync7(
-        join15(suggestionsDir, "rule-suggestions.json"),
+      const suggestionsDir = join16(cwd, ".slopbrick", "flywheel");
+      if (!existsSync17(suggestionsDir)) mkdirSync7(suggestionsDir, { recursive: true });
+      writeFileSync8(
+        join16(suggestionsDir, "rule-suggestions.json"),
         JSON.stringify(flywheelOutput.suggestions, null, 2)
       );
     }
@@ -16012,7 +16021,7 @@ async function runScan(options, explicitPaths) {
       );
       await saveInventory(cwd, inventory);
       const constitution = buildConstitutionFromConfig(config, cwd);
-      await saveConstitution2(cwd, constitution);
+      await saveConstitution(cwd, constitution);
       if (!options.quiet && !machineReadableStdout) {
         logger.info(`Memory persisted to .slopbrick/ (${inventory.patterns.length} patterns, ${inventory.components.length} components).`);
       }
@@ -16043,7 +16052,7 @@ function collectBusinessLogicIssues(cwd, filePaths) {
   for (const absPath of filePaths) {
     let source;
     try {
-      source = readFileSync21(absPath, "utf-8");
+      source = readFileSync22(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -16112,7 +16121,7 @@ function renderOutput(report, options, cwd) {
   if (options.html) {
     const html = formatHtml(report);
     if (typeof options.html === "string") {
-      writeFileSync7(resolve9(options.html), html);
+      writeFileSync8(resolve9(options.html), html);
       if (!options.quiet) {
         logger.info(`Wrote HTML report to ${options.html}`);
       }
@@ -16124,7 +16133,7 @@ function renderOutput(report, options, cwd) {
   if (options.json) {
     const json = formatJson(report);
     if (typeof options.json === "string") {
-      writeFileSync7(resolve9(options.json), json);
+      writeFileSync8(resolve9(options.json), json);
       if (!options.quiet) {
         logger.info(`Wrote JSON report to ${options.json}`);
       }
@@ -16170,7 +16179,7 @@ async function watchProject(options, cwd, paths) {
   let currentBaseline;
   function getBaselineMtime() {
     try {
-      return statSync6(baselinePath(cwd)).mtimeMs;
+      return statSync7(baselinePath(cwd)).mtimeMs;
     } catch {
       return void 0;
     }
@@ -16327,6 +16336,7 @@ var init_scan = __esm({
     init_unified_diff();
     init_heatmap();
     init_memory();
+    init_dist();
     init_telemetry();
     init_flywheel();
     init_logger();
@@ -16340,17 +16350,17 @@ var init_scan = __esm({
 });
 
 // src/engine/memory-md.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync30, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname14, join as join21 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync13, readFileSync as readFileSync31, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname15, join as join22 } from "path";
 async function readMemoryMarkdown(workspaceDir) {
   return new Promise((resolve15) => {
     try {
-      const path = join21(workspaceDir, MEMORY_MD_FILE);
-      if (!existsSync21(path)) {
+      const path = join22(workspaceDir, MEMORY_MD_FILE);
+      if (!existsSync22(path)) {
         resolve15(null);
         return;
       }
-      const content = readFileSync30(path, "utf-8");
+      const content = readFileSync31(path, "utf-8");
       resolve15(content);
     } catch {
       resolve15(null);
@@ -16361,7 +16371,7 @@ var MEMORY_MD_FILE;
 var init_memory_md = __esm({
   "src/engine/memory-md.ts"() {
     "use strict";
-    MEMORY_MD_FILE = join21(".slopbrick", "memory.md");
+    MEMORY_MD_FILE = join22(".slopbrick", "memory.md");
   }
 });
 
@@ -16574,7 +16584,7 @@ __export(tools_exports, {
   TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
   handleToolCall: () => handleToolCall
 });
-import { readFileSync as readFileSync31 } from "fs";
+import { readFileSync as readFileSync32 } from "fs";
 import { resolve as resolve13 } from "path";
 function toolError(message) {
   return {
@@ -16718,7 +16728,7 @@ function runCheckConstitution(args, ctx) {
   const absPath = resolve13(ctx.cwd, path);
   let source;
   try {
-    source = readFileSync31(absPath, "utf-8");
+    source = readFileSync32(absPath, "utf-8");
   } catch (err) {
     return toolError(
       `Cannot read file ${absPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -16780,14 +16790,14 @@ async function runBusinessLogicScore(args, ctx) {
   const maxFiles = typeof maxFilesRaw === "number" && Number.isFinite(maxFilesRaw) && maxFilesRaw > 0 ? Math.min(2e3, Math.floor(maxFilesRaw)) : 500;
   try {
     const { discoverFiles: discoverFiles2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-    const { readFileSync: readFileSync37 } = await import("fs");
+    const { readFileSync: readFileSync39 } = await import("fs");
     const allFiles = await discoverFiles2(ctx.cwd, ctx.config);
     const limited = allFiles.slice(0, maxFiles);
     const issues = [];
     for (const absPath of limited) {
       let source;
       try {
-        source = readFileSync37(absPath, "utf-8");
+        source = readFileSync39(absPath, "utf-8");
       } catch {
         continue;
       }
@@ -17052,13 +17062,186 @@ var init_tools = __esm({
   }
 });
 
+// src/cli/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  applyMigration: () => applyMigration,
+  formatMigrate: () => formatMigrate,
+  isAlreadyMigrated: () => isAlreadyMigrated,
+  logger: () => logger,
+  planMigration: () => planMigration,
+  runMigrate: () => runMigrate
+});
+import { existsSync as existsSync25, readFileSync as readFileSync37, renameSync as renameSync4, writeFileSync as writeFileSync18 } from "fs";
+import { join as join26 } from "path";
+function planMigration(workspaceDir) {
+  const moves = [];
+  const rewrites = [];
+  const gitignoreEdits = [];
+  const oldDir = join26(workspaceDir, ".slop-audit");
+  const newDir = join26(workspaceDir, ".slopbrick");
+  if (existsSync25(oldDir)) {
+    moves.push({ from: oldDir, to: newDir, kind: "dir" });
+    rewrites.push({
+      path: join26(newDir, "inventory.json"),
+      field: "version",
+      from: '"1"',
+      to: '"2"'
+    });
+    rewrites.push({
+      path: join26(newDir, "constitution.json"),
+      field: "version",
+      from: '"1"',
+      to: '"2"'
+    });
+  }
+  const oldCache = join26(workspaceDir, ".slop-audit-cache.json");
+  const newCache = join26(workspaceDir, ".slopbrick-cache.json");
+  if (existsSync25(oldCache)) {
+    moves.push({ from: oldCache, to: newCache, kind: "file" });
+  }
+  for (const ext of ["mjs", "cjs", "js"]) {
+    const oldCfg = join26(workspaceDir, `slop-audit.config.${ext}`);
+    const newCfg = join26(workspaceDir, `slopbrick.config.${ext}`);
+    if (existsSync25(oldCfg)) {
+      moves.push({ from: oldCfg, to: newCfg, kind: "config" });
+    }
+  }
+  const gi = join26(workspaceDir, ".gitignore");
+  if (existsSync25(gi)) {
+    const content = readFileSync37(gi, "utf-8");
+    if (content.includes(".slop-audit/")) {
+      gitignoreEdits.push({
+        path: gi,
+        from: ".slop-audit/",
+        to: ".slopbrick/"
+      });
+    }
+    if (content.includes(".slop-audit-cache.json")) {
+      gitignoreEdits.push({
+        path: gi,
+        from: ".slop-audit-cache.json",
+        to: ".slopbrick-cache.json"
+      });
+    }
+  }
+  return { moves, rewrites, gitignoreEdits };
+}
+function isAlreadyMigrated(workspaceDir) {
+  return existsSync25(join26(workspaceDir, ".slopbrick")) && !existsSync25(join26(workspaceDir, ".slop-audit"));
+}
+function applyMigration(plan, options = {}) {
+  if (options.dryRun) return;
+  for (const m of plan.moves) {
+    renameSync4(m.from, m.to);
+  }
+  for (const r of plan.rewrites) {
+    if (!existsSync25(r.path)) continue;
+    const content = readFileSync37(r.path, "utf-8");
+    const next = content.replace(`"version": ${r.from}`, `"version": ${r.to}`);
+    writeFileSync18(r.path, next);
+  }
+  for (const g of plan.gitignoreEdits) {
+    const content = readFileSync37(g.path, "utf-8");
+    const next = content.replaceAll(g.from, g.to);
+    writeFileSync18(g.path, next);
+  }
+}
+function runMigrate(options) {
+  const { workspace, dryRun = false, force = false } = options;
+  if (!existsSync25(workspace)) {
+    return {
+      ok: false,
+      alreadyMigrated: false,
+      planned: { moves: [], rewrites: [], gitignoreEdits: [] },
+      applied: false,
+      reason: `Workspace ${workspace} does not exist`
+    };
+  }
+  const alreadyMigrated = isAlreadyMigrated(workspace);
+  const newDir = join26(workspace, ".slopbrick");
+  const oldDir = join26(workspace, ".slop-audit");
+  if (existsSync25(newDir) && existsSync25(oldDir) && !force) {
+    return {
+      ok: false,
+      alreadyMigrated: false,
+      planned: { moves: [], rewrites: [], gitignoreEdits: [] },
+      applied: false,
+      reason: `Both .slopbrick/ and .slop-audit/ exist. Use --force to overwrite the .slopbrick/ directory, or manually resolve the conflict.`
+    };
+  }
+  const planned = planMigration(workspace);
+  const nothingToDo = planned.moves.length === 0 && planned.rewrites.length === 0 && planned.gitignoreEdits.length === 0;
+  if (nothingToDo) {
+    return {
+      ok: true,
+      alreadyMigrated,
+      planned,
+      applied: false
+    };
+  }
+  applyMigration(planned, { dryRun });
+  return {
+    ok: true,
+    alreadyMigrated: false,
+    planned,
+    applied: !dryRun
+  };
+}
+function formatMigrate(result) {
+  const lines = [];
+  if (result.alreadyMigrated) {
+    lines.push("Already migrated to v2 (no work needed).");
+    return lines.join("\n");
+  }
+  if (!result.ok) {
+    lines.push(`ERROR: ${result.reason ?? "unknown failure"}`);
+    return lines.join("\n");
+  }
+  if (result.planned.moves.length === 0 && result.planned.gitignoreEdits.length === 0) {
+    lines.push("Nothing to migrate \u2014 workspace is already on slopbrick v0.11.0+.");
+  }
+  if (result.planned.moves.length > 0) {
+    lines.push("Moves:");
+    for (const m of result.planned.moves) {
+      lines.push(`  ${m.from}`);
+      lines.push(`    \u2192 ${m.to}  (${m.kind})`);
+    }
+  }
+  if (result.planned.rewrites.length > 0) {
+    lines.push("Schema version bumps:");
+    for (const r of result.planned.rewrites) {
+      lines.push(`  ${r.path}  ${r.field}: ${r.from} \u2192 ${r.to}`);
+    }
+  }
+  if (result.planned.gitignoreEdits.length > 0) {
+    lines.push(".gitignore edits:");
+    for (const g of result.planned.gitignoreEdits) {
+      lines.push(`  ${g.path}: ${g.from} \u2192 ${g.to}`);
+    }
+  }
+  lines.push("");
+  if (result.applied) {
+    lines.push("Migration applied. Run `slopbrick scan` to regenerate inventory at v2.");
+  } else {
+    lines.push("DRY RUN \u2014 no files were changed. Re-run without --dry-run to apply.");
+  }
+  return lines.join("\n");
+}
+var init_migrate = __esm({
+  "src/cli/migrate.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // src/index.ts
 init_types();
 init_config();
 
 // src/cli/program.ts
-import { existsSync as existsSync24, writeFileSync as writeFileSync17, readFileSync as readFileSync36, mkdirSync as mkdirSync13 } from "fs";
-import { resolve as resolve14, join as join25, dirname as dirname15, extname as extname8 } from "path";
+import { existsSync as existsSync26, writeFileSync as writeFileSync19, readFileSync as readFileSync38, mkdirSync as mkdirSync14 } from "fs";
+import { resolve as resolve14, join as join27, dirname as dirname16, extname as extname8 } from "path";
 import { performance } from "perf_hooks";
 import { Command } from "commander";
 
@@ -17103,7 +17286,7 @@ init_scan();
 // src/cli/drift.ts
 init_discover();
 init_patterns();
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { basename as basename4, relative as relative11 } from "path";
 async function runDrift(cwd, config, options = {}) {
   const maxFiles = options.maxFiles ?? 1e3;
@@ -17115,7 +17298,7 @@ async function runDrift(cwd, config, options = {}) {
   for (const absPath of limited) {
     let source;
     try {
-      source = readFileSync22(absPath, "utf-8");
+      source = readFileSync23(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -17310,7 +17493,7 @@ init_worker();
 init_metrics();
 init_patterns();
 init_discover();
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { extname as extname7, relative as relative12, resolve as resolve11 } from "path";
 import { execFile as execFileCb } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -17383,7 +17566,7 @@ async function runPrScan(cwd, config, options = {}) {
   for (const absPath of candidates) {
     let source;
     try {
-      source = readFileSync23(absPath, "utf-8");
+      source = readFileSync24(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -17888,7 +18071,7 @@ function dbExitCode(result, options = {}) {
 // src/cli/business-logic.ts
 init_discover();
 init_business_logic();
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { relative as relative13 } from "path";
 async function runBusinessLogicScan(cwd, config, options = {}) {
   const maxFiles = options.maxFiles ?? 500;
@@ -17899,7 +18082,7 @@ async function runBusinessLogicScan(cwd, config, options = {}) {
   for (const absPath of limited) {
     let source;
     try {
-      source = readFileSync24(absPath, "utf-8");
+      source = readFileSync25(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -18004,7 +18187,7 @@ function capitalize(s) {
 // src/engine/patterns.ts
 init_patterns();
 init_discover();
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import { basename as basename5, relative as relative14 } from "path";
 var PATTERN_CATEGORIES = [
   "modal",
@@ -18107,7 +18290,7 @@ function detectFormsFromFiles(files) {
   for (const f of files) {
     let source;
     try {
-      source = readFileSync25(f, "utf-8");
+      source = readFileSync26(f, "utf-8");
     } catch {
       continue;
     }
@@ -18329,13 +18512,13 @@ init_discover();
 init_git();
 init_cache();
 init_logger();
-import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync8, rmSync as rmSync2 } from "fs";
-import { join as join17, dirname as dirname11 } from "path";
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, rmSync as rmSync2 } from "fs";
+import { join as join18, dirname as dirname12 } from "path";
 import { createInterface } from "readline";
 
 // src/rules/registry-loader.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync26, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readFileSync as readFileSync27, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, join as join17 } from "path";
 
 // src/data/shadcn-registry.json
 var shadcn_registry_default = {
@@ -18468,13 +18651,13 @@ 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 cachePath4(cwd) {
-  return join16(cwd, ".slopbrick", "cache", "registry-snapshot.json");
+function cachePath3(cwd) {
+  return join17(cwd, ".slopbrick", "cache", "registry-snapshot.json");
 }
 function ensureCacheDir(cwd) {
-  const dir = dirname10(cachePath4(cwd));
-  if (!existsSync17(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  const dir = dirname11(cachePath3(cwd));
+  if (!existsSync18(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
 }
 function isValidSnapshot(value) {
@@ -18485,10 +18668,10 @@ function isValidSnapshot(value) {
   return true;
 }
 function isRegistryFresh(cwd) {
-  const cached = cachePath4(cwd);
-  if (!existsSync17(cached)) return false;
+  const cached = cachePath3(cwd);
+  if (!existsSync18(cached)) return false;
   try {
-    const parsed = JSON.parse(readFileSync26(cached, "utf8"));
+    const parsed = JSON.parse(readFileSync27(cached, "utf8"));
     if (!isValidSnapshot(parsed)) return false;
     return parsed.version === BUNDLED_REGISTRY_VERSION;
   } catch {
@@ -18522,7 +18705,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
     };
   }
   ensureCacheDir(cwd);
-  writeFileSync8(cachePath4(cwd), JSON.stringify(fetched, null, 2));
+  writeFileSync9(cachePath3(cwd), JSON.stringify(fetched, null, 2));
   const fresh = fetched.version === BUNDLED_REGISTRY_VERSION;
   return {
     ok: true,
@@ -18532,7 +18715,7 @@ async function refreshRegistrySnapshot(cwd, url = REGISTRY_URL, timeoutMs = 5e3)
 }
 function copyBundledSnapshotToCache(cwd) {
   ensureCacheDir(cwd);
-  writeFileSync8(cachePath4(cwd), JSON.stringify(shadcn_registry_default, null, 2));
+  writeFileSync9(cachePath3(cwd), JSON.stringify(shadcn_registry_default, null, 2));
 }
 
 // src/cli/init.ts
@@ -18685,9 +18868,9 @@ async function runDoctor(cwd) {
   }
   try {
     const { parseFile: tryParse } = await Promise.resolve().then(() => (init_parser(), parser_exports));
-    const testFile = join17(cwd, ".slopbrick", ".doctor-test.ts");
-    mkdirSync8(dirname11(testFile), { recursive: true });
-    writeFileSync9(testFile, "export const x = 1;\n");
+    const testFile = join18(cwd, ".slopbrick", ".doctor-test.ts");
+    mkdirSync9(dirname12(testFile), { recursive: true });
+    writeFileSync10(testFile, "export const x = 1;\n");
     await tryParse(testFile);
     rmSync2(testFile, { force: true });
     ok("Parser is working.");
@@ -18746,12 +18929,12 @@ init_git();
 // src/cli/installer.ts
 import {
   chmodSync,
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync28,
-  writeFileSync as writeFileSync10
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync29,
+  writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname12, join as join18 } from "path";
+import { dirname as dirname13, join as join19 } from "path";
 var BEGIN_SENTINEL = "# slopbrick-hook-begin";
 var END_SENTINEL = "# slopbrick-hook-end";
 var SENTINEL_BLOCK = `${BEGIN_SENTINEL}
@@ -18759,14 +18942,14 @@ npx slopbrick --staged
 ${END_SENTINEL}
 `;
 function hookPath(gitRoot) {
-  const huskyDir = join18(gitRoot, ".husky");
-  if (existsSync19(huskyDir)) {
-    return join18(huskyDir, "pre-commit");
+  const huskyDir = join19(gitRoot, ".husky");
+  if (existsSync20(huskyDir)) {
+    return join19(huskyDir, "pre-commit");
   }
-  return join18(gitRoot, ".git", "hooks", "pre-commit");
+  return join19(gitRoot, ".git", "hooks", "pre-commit");
 }
 function readHookContent(path) {
-  return readFileSync28(path, "utf8");
+  return readFileSync29(path, "utf8");
 }
 function sentinelsPresent(content) {
   const lines = content.split(/\r?\n/);
@@ -18788,7 +18971,7 @@ function replaceSentinelBlock(content) {
 }
 function installHook(gitRoot) {
   const path = hookPath(gitRoot);
-  if (existsSync19(path)) {
+  if (existsSync20(path)) {
     const content = readHookContent(path);
     const { begin, end } = sentinelsPresent(content);
     if (begin && end) {
@@ -18800,7 +18983,7 @@ function installHook(gitRoot) {
           exitCode: 0
         };
       }
-      writeFileSync10(path, replaced.endsWith("\n") ? replaced : `${replaced}
+      writeFileSync11(path, replaced.endsWith("\n") ? replaced : `${replaced}
 `);
       chmodSync(path, 493);
       return {
@@ -18820,7 +19003,7 @@ function installHook(gitRoot) {
     }
     const normalized = content.length > 0 && !content.endsWith("\n") ? `${content}
 ` : content;
-    writeFileSync10(path, `${normalized}${SENTINEL_BLOCK}`);
+    writeFileSync11(path, `${normalized}${SENTINEL_BLOCK}`);
     chmodSync(path, 493);
     return {
       ok: true,
@@ -18828,8 +19011,8 @@ function installHook(gitRoot) {
       exitCode: 0
     };
   }
-  mkdirSync9(dirname12(path), { recursive: true });
-  writeFileSync10(path, SENTINEL_BLOCK, { mode: 493 });
+  mkdirSync10(dirname13(path), { recursive: true });
+  writeFileSync11(path, SENTINEL_BLOCK, { mode: 493 });
   chmodSync(path, 493);
   return {
     ok: true,
@@ -18839,7 +19022,7 @@ function installHook(gitRoot) {
 }
 function uninstallHook(gitRoot) {
   const path = hookPath(gitRoot);
-  if (!existsSync19(path)) {
+  if (!existsSync20(path)) {
     return {
       ok: true,
       message: "Hook not installed",
@@ -18875,7 +19058,7 @@ function uninstallHook(gitRoot) {
   }
   const remaining = [...lines.slice(0, start), ...lines.slice(end + 1)];
   const result = remaining.join("\n");
-  writeFileSync10(path, result.endsWith("\n") ? result : `${result}
+  writeFileSync11(path, result.endsWith("\n") ? result : `${result}
 `);
   return {
     ok: true,
@@ -18941,8 +19124,8 @@ function createProvider(config) {
 }
 
 // src/research/generator.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { join as join19 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { join as join20 } from "path";
 
 // src/research/prompts.ts
 var DEFAULT_PROMPT_TEMPLATES = [
@@ -19005,14 +19188,14 @@ async function generateSamples(options) {
   }
   const samples = [];
   const ext = extForFramework(framework);
-  const dir = join19(outputDir, framework, componentType);
-  mkdirSync10(dir, { recursive: true });
+  const dir = join20(outputDir, framework, componentType);
+  mkdirSync11(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 = join19(dir, fileName);
-    writeFileSync11(filePath, code, "utf8");
+    const filePath = join20(dir, fileName);
+    writeFileSync12(filePath, code, "utf8");
     const sample = {
       filePath,
       framework,
@@ -19023,8 +19206,8 @@ async function generateSamples(options) {
     };
     samples.push(sample);
   }
-  const metadataPath = join19(dir, "metadata.json");
-  writeFileSync11(metadataPath, JSON.stringify(samples, null, 2), "utf8");
+  const metadataPath = join20(dir, "metadata.json");
+  writeFileSync12(metadataPath, JSON.stringify(samples, null, 2), "utf8");
   return samples;
 }
 
@@ -19230,37 +19413,37 @@ function slugify(value) {
 
 // src/research/calibrator.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join20, resolve as resolve12 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync13, mkdirSync as mkdirSync12 } from "fs";
+import { join as join21, resolve as resolve12 } from "path";
 var DEFAULT_POSITIVE = "/Users/cheng/ai-slop-baseline/extracted/positive";
 var DEFAULT_NEGATIVE = "/Users/cheng/ai-slop-baseline/extracted/negative";
 function buildFileList(dir, extensions) {
-  const tmpList = join20("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const tmpList = join21("/tmp", `cal-build-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
   const expr = extensions.map((e) => `-name '*.${e}'`).join(" -o ");
   execFileSync2("bash", ["-c", `find ${dir} -maxdepth 8 -type f \\( ${expr} \\) -print0 | xargs -0 realpath > ${tmpList}`]);
-  const out = readFileSync29(tmpList, "utf8");
+  const out = readFileSync30(tmpList, "utf8");
   execFileSync2("rm", ["-f", tmpList]);
   return out.trim().split("\n").filter(Boolean);
 }
 function runScan2(fileListPath) {
-  const files = readFileSync29(fileListPath, "utf8").trim().split("\n").filter(Boolean);
+  const files = readFileSync30(fileListPath, "utf8").trim().split("\n").filter(Boolean);
   const CHUNK = 600;
   const ruleFires = /* @__PURE__ */ new Map();
   const uniqueFilesPerRule = /* @__PURE__ */ new Map();
   let fileCount = 0;
-  const tmpOut = join20("/tmp", `calibrate-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  const tmpOut = join21("/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 {
       execFileSync2(
         "node",
-        [join20(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
+        [join21(process.cwd(), "bin", "slopbrick.js"), "scan", ...chunk, "--json", tmpOut, "--no-telemetry", "--quiet"],
         { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
       );
     } catch {
     }
-    if (!existsSync20(tmpOut)) continue;
-    const report = JSON.parse(readFileSync29(tmpOut, "utf8"));
+    if (!existsSync21(tmpOut)) continue;
+    const report = JSON.parse(readFileSync30(tmpOut, "utf8"));
     fileCount += report.fileCount;
     for (const issue of report.issues) {
       ruleFires.set(issue.ruleId, (ruleFires.get(issue.ruleId) ?? 0) + 1);
@@ -19288,16 +19471,16 @@ function classify(posFiles, negFiles) {
 async function calibrate(cwd, options = {}) {
   const positiveDir = options.positiveDir ?? DEFAULT_POSITIVE;
   const negativeDir = options.negativeDir ?? DEFAULT_NEGATIVE;
-  if (!existsSync20(positiveDir)) throw new Error(`Positive corpus not found: ${positiveDir}`);
-  if (!existsSync20(negativeDir)) throw new Error(`Negative corpus not found: ${negativeDir}`);
+  if (!existsSync21(positiveDir)) throw new Error(`Positive corpus not found: ${positiveDir}`);
+  if (!existsSync21(negativeDir)) throw new Error(`Negative corpus not found: ${negativeDir}`);
   const positiveFiles = buildFileList(positiveDir, ["tsx", "ts", "jsx", "js"]);
   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 = join20("/tmp", `cal-pos-${Date.now()}.txt`);
-  const negListPath = join20("/tmp", `cal-neg-${Date.now()}.txt`);
-  writeFileSync12(posListPath, posSample.join("\n"));
-  writeFileSync12(negListPath, negSample.join("\n"));
+  const posListPath = join21("/tmp", `cal-pos-${Date.now()}.txt`);
+  const negListPath = join21("/tmp", `cal-neg-${Date.now()}.txt`);
+  writeFileSync13(posListPath, posSample.join("\n"));
+  writeFileSync13(negListPath, negSample.join("\n"));
   const builtins = await Promise.resolve().then(() => (init_builtins(), builtins_exports));
   const builtinRules2 = builtins.builtinRules ?? [];
   const metaById = /* @__PURE__ */ new Map();
@@ -19706,7 +19889,7 @@ var RULE_HINTS = {
 };
 
 // src/snippet/targets.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/snippet/render.ts
 function aiSpecificRules(rules) {
@@ -19937,7 +20120,7 @@ var SNIPPET_TARGETS = [
   }
 ];
 function resolveTargetPath(target) {
-  return target.isFolder ? join23(target.path, target.filename) : target.path;
+  return target.isFolder ? join24(target.path, target.filename) : target.path;
 }
 function renderMatrix() {
   const lines = [];
@@ -20078,8 +20261,8 @@ init_unified_diff();
 init_heatmap();
 
 // src/report/flywheel.ts
-import { existsSync as existsSync22, readFileSync as readFileSync32 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync33 } from "fs";
+import { join as join25 } from "path";
 function average(values) {
   if (values.length === 0) return 0;
   return values.reduce((a, b) => a + b, 0) / values.length;
@@ -20170,8 +20353,8 @@ init_telemetry();
 init_memory();
 
 // src/fix/focus-ring.ts
-import { existsSync as existsSync23 } from "fs";
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync24 } from "fs";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync15 } from "fs";
 var ANCHOR_START = "/* @slopbrick:v1.0.0:fix:focus-ring */";
 var CSS_BLOCK = `/* @slopbrick:v1.0.0:fix:focus-ring */
 :focus-visible {
@@ -20180,15 +20363,15 @@ var CSS_BLOCK = `/* @slopbrick:v1.0.0:fix:focus-ring */
 }
 /* @slopbrick:v1.0.0:fix:focus-ring-end */`;
 function applyFocusRingFix(targetFile) {
-  if (!existsSync23(targetFile)) {
+  if (!existsSync24(targetFile)) {
     return { applied: false, reason: "missing-global-css-target" };
   }
-  const content = readFileSync33(targetFile, "utf-8");
+  const content = readFileSync34(targetFile, "utf-8");
   if (content.includes(ANCHOR_START)) {
     return { applied: false, reason: "already-present" };
   }
   const separator = content.endsWith("\n") ? "" : "\n";
-  writeFileSync14(targetFile, `${content}${separator}${CSS_BLOCK}
+  writeFileSync15(targetFile, `${content}${separator}${CSS_BLOCK}
 `);
   return { applied: true };
 }
@@ -20197,21 +20380,21 @@ function applyFocusRingFix(targetFile) {
 init_layout_token();
 
 // src/fix/use-client.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync15 } from "fs";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync16 } from "fs";
 function applyUseClientFix(filePath) {
-  const content = readFileSync34(filePath, "utf-8");
+  const content = readFileSync35(filePath, "utf-8");
   const trimmed = content.trimStart();
   if (trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"')) {
     return { applied: false, reason: "already-present" };
   }
-  writeFileSync15(filePath, `"use client";
+  writeFileSync16(filePath, `"use client";
 
 ${content}`);
   return { applied: true };
 }
 
 // src/fix/visual-codemod.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync16 } from "fs";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync17 } from "fs";
 
 // src/fix/visual-codemods/tailwind.ts
 var ARBITRARY_ESCAPE_RE = /\b(p|m|px|py|pt|pb|pl|pr|mx|my|mt|mb|ml|mr|gap|space-[xy]|w|h|min-w|max-w|min-h|max-h|text-\w+|leading-\w+|rounded|border)-?\[(-?\d+(?:\.\d+)?)(px|rem|em|%|vh|vw)?\]/g;
@@ -20437,7 +20620,7 @@ var ALL_CODEMODS = [
   { name: "aria-attr-typo", fn: applyAriaAttrTypoCodemod }
 ];
 function applyVisualCodemods(filePath) {
-  const original = readFileSync35(filePath, "utf-8");
+  const original = readFileSync36(filePath, "utf-8");
   let content = original;
   const reasons = [];
   const seen = /* @__PURE__ */ new Set();
@@ -20453,7 +20636,7 @@ function applyVisualCodemods(filePath) {
     }
   }
   if (content !== original) {
-    writeFileSync16(filePath, content);
+    writeFileSync17(filePath, content);
   }
   return {
     filePath,
@@ -20609,12 +20792,12 @@ async function runCli({ start }) {
         process.exit(0);
       }
       const cwd = resolve14(options.workspace ?? process.cwd());
-      const configPath = join25(cwd, "slopbrick.config.mjs");
+      const configPath = join27(cwd, "slopbrick.config.mjs");
       const detected = detectStack(cwd);
       const fallbackConfig = { ...DEFAULT_CONFIG, ...detected };
       const proposed = serializeConfig(fallbackConfig);
-      if (existsSync24(configPath) && !cmdOptions.yes) {
-        const current = readFileSync36(configPath, "utf8");
+      if (existsSync26(configPath) && !cmdOptions.yes) {
+        const current = readFileSync38(configPath, "utf8");
         logger.error(`A config file already exists at ${configPath}.`);
         logger.error("To overwrite it with defaults, run `slopbrick init --yes`.");
         logger.error("");
@@ -20635,7 +20818,7 @@ async function runCli({ start }) {
         config = buildInitConfig(detected, answers);
         usedWizard = true;
       }
-      writeFileSync17(configPath, serializeConfig(config));
+      writeFileSync19(configPath, serializeConfig(config));
       appendGitignore(cwd);
       const refresh = await refreshRegistrySnapshot(cwd);
       if (!refresh.ok) {
@@ -20665,21 +20848,21 @@ async function runCli({ start }) {
         return Boolean(opts[t.flag]);
       });
       for (const target of targetsToWrite) {
-        const snippetPath = join25(cwd, resolveTargetPath(target));
-        mkdirSync13(dirname15(snippetPath), { recursive: true });
+        const snippetPath = join27(cwd, resolveTargetPath(target));
+        mkdirSync14(dirname16(snippetPath), { recursive: true });
         const generated = target.generator(builtinRules);
-        if (!target.isFolder && existsSync24(snippetPath)) {
-          const existing = readFileSync36(snippetPath, "utf8");
+        if (!target.isFolder && existsSync26(snippetPath)) {
+          const existing = readFileSync38(snippetPath, "utf8");
           if (existing.includes("<!-- slopbrick:begin -->")) {
             const updated = existing.replace(
               /<!-- slopbrick:begin -->[\s\S]*?<!-- slopbrick:end -->/,
               "<!-- slopbrick:begin -->\n" + generated + "<!-- slopbrick:end -->"
             );
-            writeFileSync17(snippetPath, updated, "utf8");
+            writeFileSync19(snippetPath, updated, "utf8");
             if (!options.quiet) logger.info(`Updated ${snippetPath}`);
             continue;
           }
-          writeFileSync17(
+          writeFileSync19(
             snippetPath,
             existing + (existing.endsWith("\n") ? "\n" : "\n\n") + generated,
             "utf8"
@@ -20687,7 +20870,7 @@ async function runCli({ start }) {
           if (!options.quiet) logger.info(`Wrote ${snippetPath}`);
           continue;
         }
-        writeFileSync17(snippetPath, generated, "utf8");
+        writeFileSync19(snippetPath, generated, "utf8");
         if (!options.quiet) logger.info(`Wrote ${snippetPath}`);
       }
       if (options.baseline) {
@@ -20756,8 +20939,8 @@ async function runCli({ start }) {
       const summary = summarizeTelemetry(payloads);
       if (cmdOptions.export) {
         const exportPath = resolve14(cmdOptions.export);
-        mkdirSync13(dirname15(exportPath), { recursive: true });
-        writeFileSync17(exportPath, JSON.stringify(summary, null, 2), "utf-8");
+        mkdirSync14(dirname16(exportPath), { recursive: true });
+        writeFileSync19(exportPath, JSON.stringify(summary, null, 2), "utf-8");
         logger.info(`Wrote flywheel summary to ${exportPath}`);
         process.exit(0);
       }
@@ -20915,16 +21098,16 @@ async function runCli({ start }) {
     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 = resolve14(cmdOptions.inputDir, "metadata.json");
-        if (!existsSync24(metadataPath)) {
+        if (!existsSync26(metadataPath)) {
           logger.error(`No metadata.json found in ${cmdOptions.inputDir}`);
           process.exit(2);
         }
-        const samples = JSON.parse(readFileSync36(metadataPath, "utf8"));
+        const samples = JSON.parse(readFileSync38(metadataPath, "utf8"));
         const config = cmdOptions.config ? await loadConfig(cmdOptions.config) : { ...DEFAULT_CONFIG, framework: cmdOptions.framework };
         const analysis = await analyzeSamples(samples, config);
         const outputPath = resolve14(cmdOptions.output);
-        mkdirSync13(dirname15(outputPath), { recursive: true });
-        writeFileSync17(outputPath, JSON.stringify(analysis, null, 2), "utf8");
+        mkdirSync14(dirname16(outputPath), { recursive: true });
+        writeFileSync19(outputPath, JSON.stringify(analysis, null, 2), "utf8");
         logger.info(`Analyzed ${analysis.summary.total} samples; coverage: ${analysis.summary.coverage}%`);
         logger.info(`Wrote analysis to ${outputPath}`);
       } catch (error) {
@@ -20935,11 +21118,11 @@ async function runCli({ start }) {
     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 = resolve14(cmdOptions.inputDir, "metadata.json");
-        if (!existsSync24(metadataPath)) {
+        if (!existsSync26(metadataPath)) {
           logger.error(`No metadata.json found in ${cmdOptions.inputDir}`);
           process.exit(2);
         }
-        const samples = JSON.parse(readFileSync36(metadataPath, "utf8"));
+        const samples = JSON.parse(readFileSync38(metadataPath, "utf8"));
         const config = cmdOptions.config ? await loadConfig(cmdOptions.config) : { ...DEFAULT_CONFIG, framework: cmdOptions.framework };
         const analysis = await analyzeSamples(samples, config);
         const extraction = extractAndCluster(analysis.samples, {
@@ -20950,7 +21133,7 @@ async function runCli({ start }) {
           minFrequency: cmdOptions.minFrequency
         });
         const outputPath = resolve14(cmdOptions.output);
-        mkdirSync13(dirname15(outputPath), { recursive: true });
+        mkdirSync14(dirname16(outputPath), { recursive: true });
         const payload = {
           generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
           sampleCount: analysis.summary.total,
@@ -20958,7 +21141,7 @@ async function runCli({ start }) {
           fingerprintCount: extraction.total,
           candidates
         };
-        writeFileSync17(outputPath, JSON.stringify(payload, null, 2), "utf8");
+        writeFileSync19(outputPath, JSON.stringify(payload, null, 2), "utf8");
         logger.info(`Extracted ${extraction.total} fingerprints across ${analysis.summary.total} samples`);
         logger.info(`Wrote ${candidates.length} candidate rule(s) to ${outputPath}`);
       } catch (error) {
@@ -20976,8 +21159,8 @@ async function runCli({ start }) {
           negativeLimit: cmdOptions.negativeLimit
         });
         const outputPath = cmdOptions.output ? resolve14(cwd, cmdOptions.output) : resolve14(cwd, "corpus", "calibration-empirical.md");
-        mkdirSync13(dirname15(outputPath), { recursive: true });
-        writeFileSync17(outputPath, reportToMarkdown(report), "utf8");
+        mkdirSync14(dirname16(outputPath), { recursive: true });
+        writeFileSync19(outputPath, reportToMarkdown(report), "utf8");
         logger.info(
           "Calibrated " + report.rules.length + " rules across " + report.positiveFileCount + " positive + " + report.negativeFileCount + " negative files."
         );
@@ -21273,6 +21456,27 @@ async function runCli({ start }) {
       const exitCode = await runDoctor(process.cwd());
       if (exitCode !== 0) process.exit(exitCode);
     });
+    program.command("migrate").description(
+      "Migrate from slop-audit v0.10.x (.slop-audit/) to slopbrick v0.11.0+ (.slopbrick/). Renames artifact dir + cache + config file + bumps schema to v2 + updates .gitignore. Idempotent. Pass --dry-run to preview."
+    ).option("--dry-run", "print the planned changes without touching the filesystem").option("--force", "overwrite .slopbrick/ if both old and new artifacts exist").option("--workspace <path>", "workspace directory", process.cwd()).option("--format <pretty|json>", "output format", "pretty").action(
+      (cmdOptions, command) => {
+        const globals = command.optsWithGlobals();
+        const format = (cmdOptions.format ?? globals.format) === "json" ? "json" : "pretty";
+        const cwd = resolve14(cmdOptions.workspace ?? process.cwd());
+        const { runMigrate: runMigrate2, formatMigrate: formatMigrate2 } = (init_migrate(), __toCommonJS(migrate_exports));
+        const result = runMigrate2({
+          workspace: cwd,
+          dryRun: cmdOptions.dryRun,
+          force: cmdOptions.force
+        });
+        if (format === "json") {
+          logger.info(JSON.stringify(result, null, 2));
+        } else {
+          logger.info(formatMigrate2(result));
+        }
+        process.exit(result.ok ? 0 : 1);
+      }
+    );
     program.command("rules").description("list all built-in rules with their categories, severities, and descriptions").option("--category <name>", "filter to a single category (visual, typo, layout, etc.)").option("--ai-only", "only show AI-specific rules").option("--json", "emit JSON instead of a pretty table").option("--show-signal-strength", "print per-rule precision/recall table").action((cmdOptions, command) => {
       const globals = command.optsWithGlobals();
       const wantJson = Boolean(cmdOptions.json || globals.json);
@@ -21360,7 +21564,7 @@ async function runCli({ start }) {
     });
     program.command("validate-config [path]").description("Statically validate a slopbrick.config.mjs without scanning").action(async (configPath) => {
       const path = configPath ? resolve14(configPath) : resolve14(process.cwd(), "slopbrick.config.mjs");
-      if (!existsSync24(path)) {
+      if (!existsSync26(path)) {
         logger.error(`Error: config file not found: ${path}`);
         process.exit(2);
       }
@@ -21436,26 +21640,6 @@ ${formatMarkdown3(result.report)}`);
 init_threshold();
 init_render();
 init_find_similar();
-import {
-  MEMORY_SCHEMA_VERSION as MEMORY_SCHEMA_VERSION3,
-  loadInventory as loadInventory3,
-  saveInventory as saveInventory2,
-  loadConstitution as loadConstitution3,
-  saveConstitution as saveConstitution3,
-  isInventoryFresh as isInventoryFresh3,
-  invalidateFile as invalidateFile3,
-  inventoryPath as inventoryPath3,
-  constitutionPath as constitutionPath3,
-  cachePath as cachePath5,
-  INVENTORY_FILENAME,
-  CONSTITUTION_FILENAME,
-  CACHE_FILENAME,
-  isMemoryPattern as isMemoryPattern3,
-  isComponentFingerprint as isComponentFingerprint3,
-  isInventoryFile as isInventoryFile3,
-  isConstitutionFile as isConstitutionFile3,
-  isFileMtimeEntry as isFileMtimeEntry3
-} from "@usebrick/core";
 process.on("uncaughtException", (err) => {
   const { logger: logger6 } = (init_logger(), __toCommonJS(logger_exports));
   logger6.error(`Unexpected error: ${err.message}`);
@@ -21463,17 +21647,11 @@ process.on("uncaughtException", (err) => {
 });
 export {
   AI_SECURITY_NUMERIC,
-  CACHE_FILENAME,
-  CONSTITUTION_FILENAME,
   DEFAULT_CONFIG,
-  INVENTORY_FILENAME,
-  MEMORY_SCHEMA_VERSION3 as MEMORY_SCHEMA_VERSION,
   REPOSITORY_HEALTH_WEIGHTS,
   VERSION,
   baselineStatusMessage,
-  cachePath5 as cachePath,
   colorForSlop,
-  constitutionPath3 as constitutionPath,
   extractSignatures,
   failedThresholdCount,
   filterByDisabledDirectives,
@@ -21483,22 +21661,10 @@ export {
   formatBadge,
   formatReportFromFile,
   formatSparkline,
-  invalidateFile3 as invalidateFile,
-  inventoryPath3 as inventoryPath,
-  isComponentFingerprint3 as isComponentFingerprint,
-  isConstitutionFile3 as isConstitutionFile,
-  isFileMtimeEntry3 as isFileMtimeEntry,
-  isInventoryFile3 as isInventoryFile,
-  isInventoryFresh3 as isInventoryFresh,
-  isMemoryPattern3 as isMemoryPattern,
   loadConfig,
-  loadConstitution3 as loadConstitution,
-  loadInventory3 as loadInventory,
   readReportFile,
   runCli,
   runInitWizard,
-  saveConstitution3 as saveConstitution,
-  saveInventory2 as saveInventory,
   scanProject,
   serializeConfig,
   signatureSimilarity,