@a-company/paradigm 3.23.3 → 3.24.0

package/dist/sweep-5POCF2E4.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+import {
+  recordLore,
+  resolveAuthor
+} from "./chunk-BRILIG7Z.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/sweep/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import * as yaml from "js-yaml";
+import { glob } from "glob";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".next", "build", "coverage", "__pycache__", "target"]);
+var CODE_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go", ".java", ".rb", ".ex", ".exs"]);
+var STALE_THRESHOLD_DAYS = 14;
+var COVERAGE_THRESHOLD = 90;
+function todayISO() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function shouldFix(options) {
+  return !options.dry && !options.skipFix;
+}
+function findPurposeFilesSync(rootDir) {
+  const found = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.name === ".purpose") {
+        found.push(full);
+      }
+    }
+  }
+  walk(rootDir);
+  return found;
+}
+function findSourceDirs(rootDir) {
+  const dirs = /* @__PURE__ */ new Set();
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    let hasCode = false;
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (CODE_EXTS.has(path.extname(entry.name))) {
+        hasCode = true;
+      }
+    }
+    if (hasCode) {
+      dirs.add(dir);
+    }
+  }
+  walk(rootDir);
+  return [...dirs];
+}
+function loadScanIndex(rootDir) {
+  const indexPath = path.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function loadFlowIndex(rootDir) {
+  const indexPath = path.join(rootDir, ".paradigm", "flow-index.json");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function extractAllSymbols(index) {
+  const map = /* @__PURE__ */ new Map();
+  const categories = ["components", "features", "flows", "state", "gates", "signals", "aspects"];
+  for (const cat of categories) {
+    const bucket = index[cat];
+    if (!bucket || typeof bucket !== "object") continue;
+    for (const entry of Object.values(bucket)) {
+      if (entry.symbol) {
+        map.set(entry.symbol, entry);
+      }
+    }
+  }
+  return map;
+}
+function countCrossReferences(symbol, purposeFiles, definitionFile) {
+  let count = 0;
+  for (const pf of purposeFiles) {
+    if (pf === definitionFile) continue;
+    try {
+      const content = fs.readFileSync(pf, "utf8");
+      if (content.includes(symbol)) {
+        count++;
+      }
+    } catch {
+    }
+  }
+  return count;
+}
+function checkOrphanedSymbols(_rootDir, index, purposeFiles, options) {
+  const results = [];
+  if (!index) {
+    results.push({ check: "orphaned-symbols", category: "orphaned", status: "ok", message: "Skipped \u2014 no scan-index.json" });
+    return results;
+  }
+  const allSymbols = extractAllSymbols(index);
+  let orphanCount = 0;
+  let fixedCount = 0;
+  for (const [symbol, entry] of allSymbols) {
+    const refs = countCrossReferences(symbol, purposeFiles, entry.path);
+    if (refs === 0) {
+      orphanCount++;
+      if (shouldFix(options)) {
+        const purposePath = entry.path.endsWith(".purpose") ? entry.path : path.join(entry.path, ".purpose");
+        if (fs.existsSync(purposePath)) {
+          try {
+            let content = fs.readFileSync(purposePath, "utf8");
+            if (!content.includes(`# orphan-detected:`) || !content.includes(symbol)) {
+              content += `
+# orphan-detected: ${todayISO()} \u2014 ${symbol} has 0 cross-references
+`;
+              fs.writeFileSync(purposePath, content, "utf8");
+              fixedCount++;
+              results.push({
+                check: "orphaned-symbols",
+                category: "orphaned",
+                status: "fixed",
+                symbol,
+                file: purposePath,
+                message: `${symbol} \u2014 0 cross-references, marked orphan`,
+                fixAction: "Added orphan-detected comment"
+              });
+              continue;
+            }
+          } catch {
+          }
+        }
+      }
+      results.push({
+        check: "orphaned-symbols",
+        category: "orphaned",
+        status: "entropy",
+        symbol,
+        file: entry.path,
+        message: `${symbol} \u2014 0 cross-references from other .purpose files`
+      });
+    }
+  }
+  if (orphanCount === 0) {
+    results.push({ check: "orphaned-symbols", category: "orphaned", status: "ok", message: `All ${allSymbols.size} symbols have cross-references` });
+  }
+  return results;
+}
+function checkStalePurpose(rootDir, purposeFiles, options) {
+  const results = [];
+  let staleCount = 0;
+  for (const pf of purposeFiles) {
+    const dir = path.dirname(pf);
+    let purposeMtime;
+    try {
+      purposeMtime = fs.statSync(pf).mtime.getTime();
+    } catch {
+      continue;
+    }
+    let newestCodeMtime = 0;
+    let newestCodeFile = "";
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        if (!CODE_EXTS.has(path.extname(entry.name))) continue;
+        const stat = fs.statSync(path.join(dir, entry.name));
+        if (stat.mtime.getTime() > newestCodeMtime) {
+          newestCodeMtime = stat.mtime.getTime();
+          newestCodeFile = entry.name;
+        }
+      }
+    } catch {
+      continue;
+    }
+    if (newestCodeMtime === 0) continue;
+    const diffDays = (newestCodeMtime - purposeMtime) / (1e3 * 60 * 60 * 24);
+    if (diffDays > STALE_THRESHOLD_DAYS) {
+      staleCount++;
+      const relPath = path.relative(rootDir, pf);
+      const staleDays = Math.floor(diffDays);
+      if (shouldFix(options)) {
+        try {
+          let content = fs.readFileSync(pf, "utf8");
+          if (!content.includes("# stale-since:")) {
+            content += `
+# stale-since: ${todayISO()} \u2014 code in ${newestCodeFile} is ${staleDays} days newer
+`;
+            fs.writeFileSync(pf, content, "utf8");
+            results.push({
+              check: "stale-purpose",
+              category: "stale",
+              status: "fixed",
+              file: relPath,
+              message: `${relPath} \u2014 ${staleDays} days behind ${newestCodeFile}`,
+              fixAction: "Added stale-since marker"
+            });
+            continue;
+          }
+        } catch {
+        }
+      }
+      results.push({
+        check: "stale-purpose",
+        category: "stale",
+        status: "entropy",
+        file: relPath,
+        message: `${relPath} \u2014 ${staleDays} days behind ${newestCodeFile}`
+      });
+    }
+  }
+  if (staleCount === 0) {
+    results.push({ check: "stale-purpose", category: "stale", status: "ok", message: `All ${purposeFiles.length} .purpose files are fresh (within ${STALE_THRESHOLD_DAYS} days)` });
+  }
+  return results;
+}
+async function checkPhantomGates(rootDir, options) {
+  const results = [];
+  const portalPath = path.join(rootDir, "portal.yaml");
+  if (!fs.existsSync(portalPath)) {
+    results.push({ check: "phantom-gates", category: "phantom", status: "ok", message: "No portal.yaml \u2014 skipped" });
+    return results;
+  }
+  let portalContent;
+  try {
+    portalContent = fs.readFileSync(portalPath, "utf8");
+  } catch {
+    results.push({ check: "phantom-gates", category: "phantom", status: "ok", message: "Could not read portal.yaml \u2014 skipped" });
+    return results;
+  }
+  const portal = yaml.load(portalContent);
+  if (!portal?.gates) {
+    results.push({ check: "phantom-gates", category: "phantom", status: "ok", message: "No gates defined in portal.yaml" });
+    return results;
+  }
+  const gateNames = Object.keys(portal.gates);
+  let phantomCount = 0;
+  const codeFiles = await glob("**/*.{ts,tsx,js,jsx,py,rs,go,java,rb}", {
+    cwd: rootDir,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/build/**", "**/coverage/**"]
+  });
+  for (const gateName of gateNames) {
+    const bareGate = gateName.startsWith("^") ? gateName.slice(1) : gateName;
+    let found = false;
+    for (const codeFile of codeFiles) {
+      try {
+        const content = fs.readFileSync(codeFile, "utf8");
+        if (content.includes(bareGate)) {
+          found = true;
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (!found) {
+      phantomCount++;
+      const symbol = gateName.startsWith("^") ? gateName : `^${gateName}`;
+      if (shouldFix(options)) {
+        try {
+          const freshContent = fs.readFileSync(portalPath, "utf8");
+          const freshPortal = yaml.load(freshContent);
+          if (freshPortal.gates && freshPortal.gates[gateName]) {
+            delete freshPortal.gates[gateName];
+          }
+          if (freshPortal.routes) {
+            for (const [route, gates] of Object.entries(freshPortal.routes)) {
+              if (Array.isArray(gates) && gates.includes(symbol)) {
+                const filtered = gates.filter((g) => g !== symbol);
+                if (filtered.length === 0) {
+                  delete freshPortal.routes[route];
+                } else {
+                  freshPortal.routes[route] = filtered;
+                }
+              }
+            }
+          }
+          fs.writeFileSync(portalPath, yaml.dump(freshPortal, { lineWidth: -1, noRefs: true }), "utf8");
+          results.push({
+            check: "phantom-gates",
+            category: "phantom",
+            status: "fixed",
+            symbol,
+            file: "portal.yaml",
+            message: `${symbol} \u2014 no code implementation found`,
+            fixAction: "Removed from portal.yaml"
+          });
+          continue;
+        } catch {
+        }
+      }
+      results.push({
+        check: "phantom-gates",
+        category: "phantom",
+        status: "entropy",
+        symbol,
+        file: "portal.yaml",
+        message: `${symbol} \u2014 defined in portal.yaml but no code references "${bareGate}"`
+      });
+    }
+  }
+  if (phantomCount === 0) {
+    results.push({ check: "phantom-gates", category: "phantom", status: "ok", message: `All ${gateNames.length} gates have code references` });
+  }
+  return results;
+}
+async function checkDeadSignals(rootDir, index, _purposeFiles, options) {
+  const results = [];
+  if (!index) {
+    results.push({ check: "dead-signals", category: "dead", status: "ok", message: "Skipped \u2014 no scan-index.json" });
+    return results;
+  }
+  const signals = index.signals || {};
+  const signalEntries = Object.values(signals);
+  if (signalEntries.length === 0) {
+    results.push({ check: "dead-signals", category: "dead", status: "ok", message: "No signals defined" });
+    return results;
+  }
+  const codeFiles = await glob("**/*.{ts,tsx,js,jsx,py,rs,go,java,rb}", {
+    cwd: rootDir,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/build/**", "**/coverage/**"]
+  });
+  let deadCount = 0;
+  for (const signal of signalEntries) {
+    const bareSignal = signal.id;
+    let found = false;
+    for (const codeFile of codeFiles) {
+      try {
+        const content = fs.readFileSync(codeFile, "utf8");
+        if (content.includes(bareSignal)) {
+          found = true;
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (!found) {
+      deadCount++;
+      const symbol = signal.symbol;
+      if (shouldFix(options)) {
+        const purposePath = signal.path.endsWith(".purpose") ? signal.path : path.join(signal.path, ".purpose");
+        if (fs.existsSync(purposePath)) {
+          try {
+            let content = fs.readFileSync(purposePath, "utf8");
+            if (!content.includes(`# dead-signal: ${symbol}`)) {
+              content += `
+# dead-signal: ${symbol} \u2014 no handler/listener found (${todayISO()})
+`;
+              fs.writeFileSync(purposePath, content, "utf8");
+              results.push({
+                check: "dead-signals",
+                category: "dead",
+                status: "fixed",
+                symbol,
+                file: purposePath,
+                message: `${symbol} \u2014 no handler or listener in codebase`,
+                fixAction: "Added dead-signal marker"
+              });
+              continue;
+            }
+          } catch {
+          }
+        }
+      }
+      results.push({
+        check: "dead-signals",
+        category: "dead",
+        status: "entropy",
+        symbol,
+        file: signal.path,
+        message: `${symbol} \u2014 no handler or listener references in codebase`
+      });
+    }
+  }
+  if (deadCount === 0) {
+    results.push({ check: "dead-signals", category: "dead", status: "ok", message: `All ${signalEntries.length} signals have code references` });
+  }
+  return results;
+}
+function checkBrokenFlows(rootDir, index, flowIndex, options) {
+  const results = [];
+  if (!flowIndex) {
+    results.push({ check: "broken-flows", category: "broken", status: "ok", message: "No flow-index.json \u2014 skipped" });
+    return results;
+  }
+  if (!index) {
+    results.push({ check: "broken-flows", category: "broken", status: "ok", message: "No scan-index.json \u2014 skipped" });
+    return results;
+  }
+  const allSymbols = extractAllSymbols(index);
+  let brokenCount = 0;
+  for (const [flowId, flow] of Object.entries(flowIndex.flows)) {
+    for (const step of flow.steps) {
+      if (!step.symbol) continue;
+      if (!allSymbols.has(step.symbol)) {
+        brokenCount++;
+        if (shouldFix(options)) {
+          const purposePath = path.join(rootDir, flow.definedIn);
+          if (fs.existsSync(purposePath)) {
+            try {
+              let content = fs.readFileSync(purposePath, "utf8");
+              if (!content.includes(`# broken: ${step.symbol}`)) {
+                content += `
+# broken: ${step.symbol} not found \u2014 ${flowId} step ${step.id} (${todayISO()})
+`;
+                fs.writeFileSync(purposePath, content, "utf8");
+                results.push({
+                  check: "broken-flows",
+                  category: "broken",
+                  status: "fixed",
+                  symbol: step.symbol,
+                  file: flow.definedIn,
+                  message: `${flowId} step ${step.id} references ${step.symbol} \u2014 not found`,
+                  fixAction: "Added broken step comment"
+                });
+                continue;
+              }
+            } catch {
+            }
+          }
+        }
+        results.push({
+          check: "broken-flows",
+          category: "broken",
+          status: "entropy",
+          symbol: step.symbol,
+          file: flow.definedIn,
+          message: `${flowId} step ${step.id} references ${step.symbol} \u2014 symbol not in scan-index`
+        });
+      }
+    }
+  }
+  if (brokenCount === 0) {
+    results.push({ check: "broken-flows", category: "broken", status: "ok", message: `All flow steps reference valid symbols (${Object.keys(flowIndex.flows).length} flows)` });
+  }
+  return results;
+}
+function checkLoreRot(rootDir, index, options) {
+  const results = [];
+  const loreDir = path.join(rootDir, ".paradigm", "lore", "entries");
+  if (!fs.existsSync(loreDir)) {
+    results.push({ check: "lore-rot", category: "lore-rot", status: "ok", message: "No lore entries \u2014 skipped" });
+    return results;
+  }
+  const allSymbols = index ? extractAllSymbols(index) : /* @__PURE__ */ new Map();
+  let rotCount = 0;
+  let dateDirs;
+  try {
+    dateDirs = fs.readdirSync(loreDir).filter((d) => {
+      const full = path.join(loreDir, d);
+      return fs.statSync(full).isDirectory();
+    });
+  } catch {
+    results.push({ check: "lore-rot", category: "lore-rot", status: "ok", message: "Could not read lore directory \u2014 skipped" });
+    return results;
+  }
+  let entryCount = 0;
+  for (const dateDir of dateDirs) {
+    const datePath = path.join(loreDir, dateDir);
+    let files;
+    try {
+      files = fs.readdirSync(datePath).filter((f) => f.endsWith(".yaml") || f.endsWith(".lore"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      entryCount++;
+      const filePath = path.join(datePath, file);
+      let entry;
+      try {
+        entry = yaml.load(fs.readFileSync(filePath, "utf8"));
+      } catch {
+        continue;
+      }
+      const symbolsTouched = entry.symbols_touched || [];
+      const filesModified = entry.files_modified || [];
+      const filesCreated = entry.files_created || [];
+      const tags = entry.tags || [];
+      const deadSymbols = [];
+      if (index) {
+        for (const sym of symbolsTouched) {
+          if (!allSymbols.has(sym)) {
+            deadSymbols.push(sym);
+          }
+        }
+      }
+      const deadFiles = [];
+      for (const f of [...filesModified, ...filesCreated]) {
+        const absFile = path.isAbsolute(f) ? f : path.join(rootDir, f);
+        if (!fs.existsSync(absFile)) {
+          deadFiles.push(f);
+        }
+      }
+      if (deadSymbols.length > 0 || deadFiles.length > 0) {
+        rotCount++;
+        const entryId = entry.id || file;
+        const details = [
+          ...deadSymbols.length > 0 ? [`dead symbols: ${deadSymbols.join(", ")}`] : [],
+          ...deadFiles.length > 0 ? [`missing files: ${deadFiles.length}`] : []
+        ].join("; ");
+        if (shouldFix(options)) {
+          try {
+            if (!tags.includes("stale")) {
+              const updatedTags = [...tags, "stale"];
+              entry.tags = updatedTags;
+              fs.writeFileSync(filePath, yaml.dump(entry, { lineWidth: -1, noRefs: true }), "utf8");
+              results.push({
+                check: "lore-rot",
+                category: "lore-rot",
+                status: "fixed",
+                symbol: entryId,
+                file: filePath,
+                message: `${entryId} \u2014 ${details}`,
+                fixAction: "Added stale tag"
+              });
+              continue;
+            }
+          } catch {
+          }
+        }
+        results.push({
+          check: "lore-rot",
+          category: "lore-rot",
+          status: "entropy",
+          symbol: entryId,
+          file: filePath,
+          message: `${entryId} \u2014 ${details}`
+        });
+      }
+    }
+  }
+  if (rotCount === 0) {
+    results.push({ check: "lore-rot", category: "lore-rot", status: "ok", message: `All ${entryCount} lore entries have valid references` });
+  }
+  return results;
+}
+function checkTagOrphans(rootDir, purposeFiles, options) {
+  const results = [];
+  const tagsPath = path.join(rootDir, ".paradigm", "tags.yaml");
+  if (!fs.existsSync(tagsPath)) {
+    results.push({ check: "tag-orphans", category: "tag-orphan", status: "ok", message: "No tags.yaml \u2014 skipped" });
+    return results;
+  }
+  let tagsData;
+  try {
+    tagsData = yaml.load(fs.readFileSync(tagsPath, "utf8"));
+  } catch {
+    results.push({ check: "tag-orphans", category: "tag-orphan", status: "ok", message: "Could not parse tags.yaml \u2014 skipped" });
+    return results;
+  }
+  const definedTags = /* @__PURE__ */ new Set();
+  for (const section of ["core", "project"]) {
+    const bucket = tagsData[section];
+    if (bucket && typeof bucket === "object") {
+      for (const tag of Object.keys(bucket)) {
+        definedTags.add(tag);
+      }
+    }
+  }
+  if (definedTags.size === 0) {
+    results.push({ check: "tag-orphans", category: "tag-orphan", status: "ok", message: "No tags defined" });
+    return results;
+  }
+  const usedTags = /* @__PURE__ */ new Set();
+  for (const pf of purposeFiles) {
+    try {
+      const content = fs.readFileSync(pf, "utf8");
+      const tagMatches = content.matchAll(/tags:\s*\[([^\]]*)\]/g);
+      for (const match of tagMatches) {
+        const tagList = match[1].split(",").map((t) => t.trim().replace(/['"]/g, "")).filter(Boolean);
+        for (const tag of tagList) {
+          usedTags.add(tag);
+        }
+      }
+      const yamlData = yaml.load(content);
+      if (yamlData) {
+        let collectTags2 = function(obj) {
+          if (Array.isArray(obj)) {
+            for (const item of obj) collectTags2(item);
+          } else if (obj && typeof obj === "object") {
+            const rec = obj;
+            if (Array.isArray(rec.tags)) {
+              for (const t of rec.tags) {
+                if (typeof t === "string") usedTags.add(t);
+              }
+            }
+            for (const v of Object.values(rec)) collectTags2(v);
+          }
+        };
+        var collectTags = collectTags2;
+        collectTags2(yamlData);
+      }
+    } catch {
+      continue;
+    }
+  }
+  let orphanCount = 0;
+  for (const tag of definedTags) {
+    if (!usedTags.has(tag)) {
+      orphanCount++;
+      if (shouldFix(options)) {
+        try {
+          const freshData = yaml.load(fs.readFileSync(tagsPath, "utf8"));
+          let removed = false;
+          for (const section of ["core", "project"]) {
+            if (freshData[section] && freshData[section][tag]) {
+              delete freshData[section][tag];
+              removed = true;
+            }
+          }
+          if (removed) {
+            fs.writeFileSync(tagsPath, yaml.dump(freshData, { lineWidth: -1, noRefs: true }), "utf8");
+            results.push({
+              check: "tag-orphans",
+              category: "tag-orphan",
+              status: "fixed",
+              symbol: tag,
+              file: "tags.yaml",
+              message: `Tag "${tag}" \u2014 not used in any .purpose file`,
+              fixAction: "Removed from tags.yaml"
+            });
+            continue;
+          }
+        } catch {
+        }
+      }
+      results.push({
+        check: "tag-orphans",
+        category: "tag-orphan",
+        status: "entropy",
+        symbol: tag,
+        file: ".paradigm/tags.yaml",
+        message: `Tag "${tag}" \u2014 defined in tag bank but not used in any .purpose file`
+      });
+    }
+  }
+  if (orphanCount === 0) {
+    results.push({ check: "tag-orphans", category: "tag-orphan", status: "ok", message: `All ${definedTags.size} tags are in use` });
+  }
+  return results;
+}
+function checkAspectSemanticDrift(rootDir, index, _options) {
+  const results = [];
+  const dbPath = path.join(rootDir, ".paradigm", "aspect-graph.db");
+  if (!fs.existsSync(dbPath)) {
+    results.push({ check: "aspect-semantic-drift", category: "semantic-drift", status: "ok", message: "No aspect-graph.db \u2014 skipped" });
+    return results;
+  }
+  if (!index || !index.aspects) {
+    results.push({ check: "aspect-semantic-drift", category: "semantic-drift", status: "ok", message: "No aspects in scan-index \u2014 skipped" });
+    return results;
+  }
+  const aspects = index.aspects;
+  let driftCount = 0;
+  for (const [, aspect] of Object.entries(aspects)) {
+    const purposePath = aspect.path.endsWith(".purpose") ? aspect.path : path.join(aspect.path, ".purpose");
+    if (!fs.existsSync(purposePath)) continue;
+    try {
+      const content = fs.readFileSync(purposePath, "utf8");
+      const anchorPattern = /anchors?:\s*\n((?:\s+-\s+.+\n?)*)/g;
+      const anchorMatch = anchorPattern.exec(content);
+      if (!anchorMatch) continue;
+      const anchorLines = anchorMatch[1].split("\n").filter((l) => l.trim().startsWith("-"));
+      for (const line of anchorLines) {
+        const match = line.match(/- (.+):(\d+)(?:-(\d+))?/);
+        if (!match) continue;
+        const anchorFile = match[1].trim();
+        const startLine = parseInt(match[2], 10);
+        const endLine = match[3] ? parseInt(match[3], 10) : startLine;
+        const absAnchorFile = path.isAbsolute(anchorFile) ? anchorFile : path.join(rootDir, anchorFile);
+        if (!fs.existsSync(absAnchorFile)) continue;
+        try {
+          const fileContent = fs.readFileSync(absAnchorFile, "utf8");
+          const lineCount = fileContent.split("\n").length;
+          if (startLine > lineCount || endLine > lineCount) {
+            driftCount++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (driftCount > 0) {
+    results.push({
+      check: "aspect-semantic-drift",
+      category: "semantic-drift",
+      status: "entropy",
+      message: `${driftCount} aspect anchor(s) reference lines beyond file bounds \u2014 run "paradigm drift check" to repair`
+    });
+  } else {
+    results.push({ check: "aspect-semantic-drift", category: "semantic-drift", status: "ok", message: `Aspect anchors stable (use "paradigm drift check" for deep analysis)` });
+  }
+  return results;
+}
+function checkCoverageDecay(rootDir, purposeFiles, options) {
+  const results = [];
+  const sourceDirs = findSourceDirs(rootDir);
+  if (sourceDirs.length === 0) {
+    results.push({ check: "coverage-decay", category: "coverage-decay", status: "ok", message: "No source directories found" });
+    return results;
+  }
+  const purposeDirs = new Set(purposeFiles.map((pf) => path.dirname(pf)));
+  const uncoveredDirs = [];
+  for (const dir of sourceDirs) {
+    let covered = false;
+    let current = dir;
+    while (current.startsWith(rootDir)) {
+      if (purposeDirs.has(current)) {
+        covered = true;
+        break;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    if (!covered) {
+      uncoveredDirs.push(dir);
+    }
+  }
+  const coveragePct = sourceDirs.length > 0 ? Math.round((sourceDirs.length - uncoveredDirs.length) / sourceDirs.length * 100) : 100;
+  if (coveragePct < COVERAGE_THRESHOLD) {
+    if (shouldFix(options)) {
+      let generatedCount = 0;
+      for (const dir of uncoveredDirs) {
+        const purposePath = path.join(dir, ".purpose");
+        if (!fs.existsSync(purposePath)) {
+          try {
+            const dirName = path.basename(dir);
+            const relDir = path.relative(rootDir, dir);
+            const skeleton = [
+              `# ${dirName}`,
+              `# Auto-generated by paradigm sweep \u2014 ${todayISO()}`,
+              `# TODO: Add component descriptions and symbol declarations`,
+              ``,
+              `#${dirName}:`,
+              `  description: "${relDir}"`,
+              `  tags: []`,
+              ``
+            ].join("\n");
+            fs.writeFileSync(purposePath, skeleton, "utf8");
+            generatedCount++;
+          } catch {
+          }
+        }
+      }
+      if (generatedCount > 0) {
+        results.push({
+          check: "coverage-decay",
+          category: "coverage-decay",
+          status: "fixed",
+          message: `Coverage at ${coveragePct}% (threshold: ${COVERAGE_THRESHOLD}%) \u2014 generated ${generatedCount} skeleton .purpose files`,
+          fixAction: `Generated ${generatedCount} skeleton .purpose files`
+        });
+        return results;
+      }
+    }
+    results.push({
+      check: "coverage-decay",
+      category: "coverage-decay",
+      status: "entropy",
+      message: `Coverage at ${coveragePct}% \u2014 below ${COVERAGE_THRESHOLD}% threshold (${uncoveredDirs.length} directories uncovered)`
+    });
+  } else {
+    results.push({
+      check: "coverage-decay",
+      category: "coverage-decay",
+      status: "ok",
+      message: `Coverage at ${coveragePct}% (${sourceDirs.length} source dirs, ${purposeFiles.length} .purpose files)`
+    });
+  }
+  return results;
+}
+async function recordSweepLore(rootDir, allResults) {
+  const entropyResults = allResults.filter((r) => r.status === "entropy");
+  const fixedResults = allResults.filter((r) => r.status === "fixed");
+  const okResults = allResults.filter((r) => r.status === "ok");
+  const categories = new Set(allResults.map((r) => r.category));
+  const symbolsTouched = allResults.filter((r) => r.symbol).map((r) => r.symbol).filter((s, i, arr) => arr.indexOf(s) === i).slice(0, 20);
+  const summary = [
+    `Sweep completed: ${categories.size} categories checked.`,
+    entropyResults.length > 0 ? `${entropyResults.length} entropy issue(s) found.` : "",
+    fixedResults.length > 0 ? `${fixedResults.length} issue(s) auto-resolved.` : "",
+    `${okResults.length} categories healthy.`
+  ].filter(Boolean).join(" ");
+  const entry = {
+    id: "",
+    type: "insight",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    author: resolveAuthor(),
+    title: `Sweep: ${entropyResults.length + fixedResults.length} issues, ${fixedResults.length} fixed`,
+    summary,
+    symbols_touched: symbolsTouched,
+    tags: ["arc:sweep", "automated"]
+  };
+  try {
+    await recordLore(rootDir, entry);
+    return entry.id;
+  } catch {
+    return null;
+  }
+}
+async function sweepCommand(options) {
+  const rootDir = options.rootDir || process.cwd();
+  const quiet = options.quiet;
+  const spinner = ora();
+  const tracker = log.command("sweep").start("Running entropy detection");
+  if (!quiet) {
+    console.log(chalk.blue("\nParadigm Sweep Report") + chalk.gray(` \u2014 ${todayISO()}`));
+    console.log(chalk.gray("==================================="));
+    if (options.dry || options.skipFix) {
+      console.log(chalk.yellow("  Mode: dry run (no fixes applied)\n"));
+    }
+  }
+  spinner.start("Loading project data...");
+  const purposeFiles = findPurposeFilesSync(rootDir);
+  const scanIndex = loadScanIndex(rootDir);
+  const flowIndex = loadFlowIndex(rootDir);
+  spinner.succeed(`Loaded: ${purposeFiles.length} .purpose files, scan-index ${scanIndex ? "present" : "absent"}`);
+  const allResults = [];
+  const checks = [
+    { name: "Orphaned symbols", run: () => checkOrphanedSymbols(rootDir, scanIndex, purposeFiles, options) },
+    { name: "Stale purpose files", run: () => checkStalePurpose(rootDir, purposeFiles, options) },
+    { name: "Phantom gates", run: () => checkPhantomGates(rootDir, options) },
+    { name: "Dead signals", run: () => checkDeadSignals(rootDir, scanIndex, purposeFiles, options) },
+    { name: "Broken flows", run: () => checkBrokenFlows(rootDir, scanIndex, flowIndex, options) },
+    { name: "Lore rot", run: () => checkLoreRot(rootDir, scanIndex, options) },
+    { name: "Tag orphans", run: () => checkTagOrphans(rootDir, purposeFiles, options) },
+    { name: "Aspect semantic drift", run: () => checkAspectSemanticDrift(rootDir, scanIndex, options) },
+    { name: "Coverage decay", run: () => checkCoverageDecay(rootDir, purposeFiles, options) }
+  ];
+  for (const check of checks) {
+    spinner.start(`Checking: ${check.name}...`);
+    const checkResults = await check.run();
+    allResults.push(...checkResults);
+    const hasEntropy2 = checkResults.some((r) => r.status === "entropy");
+    const hasFixed = checkResults.some((r) => r.status === "fixed");
+    if (hasEntropy2) {
+      spinner.warn(chalk.yellow(`${check.name}`));
+    } else if (hasFixed) {
+      spinner.succeed(chalk.green(`${check.name} (auto-fixed)`));
+    } else {
+      spinner.succeed(chalk.green(check.name));
+    }
+  }
+  if (!quiet) {
+    const symbolCount = scanIndex ? extractAllSymbols(scanIndex).size : 0;
+    console.log(chalk.gray(`
+Checked: 9 categories, ${symbolCount} symbols, ${purposeFiles.length} .purpose files
+`));
+    const entropyResults = allResults.filter((r) => r.status === "entropy");
+    if (entropyResults.length > 0) {
+      console.log(chalk.red.bold("ENTROPY FOUND:"));
+      for (const r of entropyResults) {
+        console.log(`  ${chalk.red(`[${r.category}]`)}  ${r.message}`);
+      }
+      console.log();
+    }
+    const okResults = allResults.filter((r) => r.status === "ok");
+    if (okResults.length > 0) {
+      console.log(chalk.green.bold("HEALTHY:"));
+      for (const r of okResults) {
+        console.log(`  ${chalk.green("[ok]")} ${r.check} \u2014 ${r.message}`);
+      }
+      console.log();
+    }
+    const fixedResults = allResults.filter((r) => r.status === "fixed");
+    if (fixedResults.length > 0) {
+      console.log(chalk.cyan.bold("RESOLVED (auto-fixed):"));
+      for (const r of fixedResults) {
+        console.log(`  ${chalk.cyan("[fixed]")}  ${r.message}`);
+        if (r.fixAction) {
+          console.log(chalk.gray(`           ${r.fixAction}`));
+        }
+      }
+      console.log();
+    }
+    const loreId = await recordSweepLore(rootDir, allResults);
+    const issueCount = entropyResults.length + fixedResults.length;
+    const parts = [
+      `${issueCount} issue${issueCount !== 1 ? "s" : ""} found`,
+      fixedResults.length > 0 ? `${fixedResults.length} auto-resolved` : null,
+      loreId ? `Lore recorded: ${loreId}` : null
+    ].filter(Boolean).join(", ");
+    console.log(chalk.gray(`Summary: ${parts}`));
+    console.log();
+  }
+  const hasEntropy = allResults.some((r) => r.status === "entropy");
+  if (hasEntropy) {
+    tracker.error("Entropy detected", {
+      entropy: allResults.filter((r) => r.status === "entropy").length,
+      fixed: allResults.filter((r) => r.status === "fixed").length
+    });
+  } else {
+    tracker.success("Clean sweep", {
+      fixed: allResults.filter((r) => r.status === "fixed").length,
+      ok: allResults.filter((r) => r.status === "ok").length
+    });
+  }
+}
+export {
+  sweepCommand
+};