@a-company/paradigm 5.10.0 → 5.21.0

package/dist/sweep-QMHNSIY5.js

@@ -1,934 +0,0 @@
-#!/usr/bin/env node
-import {
-  recordLore,
-  resolveAuthor
-} from "./chunk-EKGMAM62.js";
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.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
-};