@a-company/paradigm 3.23.3 → 3.24.1

package/dist/{chunk-C3BK3E23.js → chunk-OXG5GVDJ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-UI3XXVJ6.js";
+} from "./chunk-W4VFKZVF.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";

package/dist/{chunk-XKAFTZOZ.js → chunk-VHSTF72C.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-Z42FOOVT.js";
+} from "./chunk-GC6X3YM7.js";
 import {
   AGENT_MODEL_RECOMMENDATIONS,
   addActivity,

package/dist/{chunk-UI3XXVJ6.js → chunk-W4VFKZVF.js}

@@ -6,6 +6,9 @@ import {
 import {
   aggregateFromDirectory
 } from "./chunk-6P4IFIK2.js";
+import {
+  cliBuildGraphState
+} from "./chunk-Z7W7HNRG.js";
 
 // src/commands/scan/navigator.ts
 import * as fs from "fs";
@@ -264,6 +267,8 @@ async function indexCommand(targetPath, options) {
     console.log(chalk2.blue("\n\u{1F52D} Generating Paradigm Scan Index\n"));
   }
   let scanConfig;
+  let graphConfig;
+  let tierConfig;
   const configPaths = [
     path2.join(rootDir, ".paradigm"),
     path2.join(rootDir, ".paradigm", "config.yaml")
@@ -273,7 +278,11 @@ async function indexCommand(targetPath, options) {
       try {
         const content = fs2.readFileSync(configPath, "utf8");
         const config = parseHorizonConfig(content);
-        scanConfig = config.scan;
+        const typedConfig = config;
+        scanConfig = typedConfig.scan;
+        graphConfig = typedConfig.graph;
+        const contextConfig = typedConfig.context;
+        tierConfig = contextConfig?.tiers;
         break;
       } catch {
       }
@@ -318,6 +327,7 @@ async function indexCommand(targetPath, options) {
       screenDefinitions: scanConfig?.screens
     }
   );
+  classifyTiers(index, { hot: tierConfig?.["hot-threshold"], warm: tierConfig?.["warm-threshold"] });
   try {
     fs2.writeFileSync(outputPath, serializeScanIndex(index), "utf8");
     spinner.succeed(chalk2.green("Scan index generated"));
@@ -335,6 +345,23 @@ async function indexCommand(targetPath, options) {
       spinner.succeed(chalk2.green(`Flow index generated (${Object.keys(flowIndex.flows).length} flows)`));
     }
   }
+  const autoGenerate = graphConfig?.["auto-generate"] !== false;
+  if (autoGenerate) {
+    try {
+      const graphState = cliBuildGraphState(rootDir);
+      const graphsDir = path2.join(rootDir, ".paradigm", "graphs");
+      if (!fs2.existsSync(graphsDir)) fs2.mkdirSync(graphsDir, { recursive: true });
+      const graphPath = path2.join(graphsDir, "auto.graph.json");
+      fs2.writeFileSync(graphPath, JSON.stringify(graphState, null, 2), "utf8");
+      if (!options.quiet) {
+        spinner.succeed(chalk2.green(`Symbol graph updated (${graphState.nodes.length} nodes)`));
+      }
+    } catch {
+      if (!options.quiet) {
+        spinner.warn(chalk2.yellow("Could not auto-generate symbol graph"));
+      }
+    }
+  }
   if (!options.quiet) {
     console.log(chalk2.gray(`
   Output: ${outputPath}`));
@@ -350,6 +377,36 @@ async function indexCommand(targetPath, options) {
   }
   return index;
 }
+function classifyTiers(index, config) {
+  const hotThreshold = config?.hot ?? 15;
+  const warmThreshold = config?.warm ?? 5;
+  const refCounts = /* @__PURE__ */ new Map();
+  const allSections = ["components", "flows", "gates", "signals", "aspects", "features", "state"];
+  for (const section of allSections) {
+    const entries = index[section];
+    if (!entries) continue;
+    for (const [, entry] of Object.entries(entries)) {
+      const refs = entry.related;
+      if (refs) {
+        for (const ref of refs) {
+          const stripped = ref.replace(/^[#$^!~]/, "");
+          refCounts.set(stripped, (refCounts.get(stripped) || 0) + 1);
+        }
+      }
+    }
+  }
+  for (const section of allSections) {
+    const entries = index[section];
+    if (!entries) continue;
+    for (const [id, entry] of Object.entries(entries)) {
+      const refs = refCounts.get(id) || 0;
+      const visualTags = entry.visualTags || [];
+      const centrality = visualTags.length;
+      const score = refs * 3 + centrality;
+      entry.tier = score > hotThreshold ? "hot" : score > warmThreshold ? "warm" : "cold";
+    }
+  }
+}
 async function generateFlowIndex(rootDir, purposeFiles, options) {
   const flows = {};
   const symbolToFlows = {};

package/dist/{chunk-K34C7NAN.js → chunk-XKI55IFI.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-CHSHON3O.js";
 import {
   indexCommand
-} from "./chunk-UI3XXVJ6.js";
+} from "./chunk-W4VFKZVF.js";
 import {
   getDefaultPremiseContent
 } from "./chunk-6P4IFIK2.js";
@@ -530,7 +530,7 @@ function applyDisciplineToConfig(paradigmDir, rootDir) {
   const config = getDisciplineConfig(discipline);
   const mappingLines = Object.entries(config.symbolMapping).map(([pattern, symbol]) => `    "${pattern}": "${symbol}"`).join("\n");
   content = content.replace(
-    /  symbol-mapping:\n(?:    .*\n)*/,
+    /  symbol-mapping:\n(?:(?:    .*| *)\n)*/,
     `  symbol-mapping:
 ${mappingLines}
 `

package/dist/{graph-5VSRBRKZ.js → chunk-Z7W7HNRG.js}

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
 
 // src/commands/graph.ts
 import chalk from "chalk";
@@ -157,7 +156,9 @@ View: paradigm graph`));
     process.exit(1);
   }
 }
+
 export {
   graphCommand,
+  cliBuildGraphState,
   graphGenerateCommand
 };

package/dist/context-audit-RI4R2WRH.js

@@ -0,0 +1,549 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/doctor/context-audit.ts
+import * as fs from "fs";
+import * as path from "path";
+var INSTRUCTION_FILES = ["CLAUDE.md", ".cursorrules", "AGENTS.md"];
+function loadInstructionFiles(rootDir) {
+  const results = [];
+  for (const name of INSTRUCTION_FILES) {
+    const filePath = path.join(rootDir, name);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, "utf8");
+      results.push({ name, content, lines: content.split("\n") });
+    }
+  }
+  return results;
+}
+function findSourceDirs(dir, extensions) {
+  const dirs = /* @__PURE__ */ new Set();
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".paradigm", "coverage", "build", "__pycache__", "target", ".next", ".nuxt"]);
+  function walk(current) {
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    let hasSource = false;
+    for (const entry of entries) {
+      if (skipDirs.has(entry.name)) continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (extensions.includes(ext)) {
+          hasSource = true;
+        }
+      }
+    }
+    if (hasSource) {
+      dirs.add(current);
+    }
+  }
+  walk(dir);
+  return dirs;
+}
+function hasPurposeCoverage(dir, rootDir) {
+  let current = dir;
+  while (true) {
+    if (fs.existsSync(path.join(current, ".purpose"))) return true;
+    if (current === rootDir) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return false;
+}
+async function checkStaleReferences(rootDir) {
+  const results = [];
+  const files = loadInstructionFiles(rootDir);
+  if (files.length === 0) {
+    results.push({
+      check: "stale-references",
+      status: "advisory",
+      message: "No instruction files found (CLAUDE.md, .cursorrules, AGENTS.md)"
+    });
+    return results;
+  }
+  const pathPattern = /(?:^|\s|`|"|')([.a-zA-Z0-9_-]+(?:\/[.a-zA-Z0-9_*{}-]+)+\/?)/gm;
+  const extPattern = /(?:^|\s|`|"|')([a-zA-Z0-9_-]+\.(?:ts|js|py|rs|go|yaml|yml|json|md|toml))\b/gm;
+  const stale = [];
+  const checked = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const allMatches = [];
+    let match;
+    pathPattern.lastIndex = 0;
+    while ((match = pathPattern.exec(file.content)) !== null) {
+      allMatches.push(match[1]);
+    }
+    extPattern.lastIndex = 0;
+    while ((match = extPattern.exec(file.content)) !== null) {
+      allMatches.push(match[1]);
+    }
+    for (const ref of allMatches) {
+      const cleaned = ref.replace(/\/+$/, "").replace(/`/g, "");
+      if (cleaned.startsWith("http") || cleaned.startsWith("//")) continue;
+      if (cleaned.includes("*") || cleaned.includes("{")) continue;
+      if (cleaned.startsWith("paradigm://")) continue;
+      if (cleaned.startsWith("node_modules/")) continue;
+      if (checked.has(cleaned)) continue;
+      checked.add(cleaned);
+      const fullPath = path.join(rootDir, cleaned);
+      if (!fs.existsSync(fullPath)) {
+        stale.push(`${file.name}: ${cleaned}`);
+      }
+    }
+  }
+  if (stale.length > 0) {
+    results.push({
+      check: "stale-references",
+      status: "error",
+      message: `${stale.length} dead path reference${stale.length > 1 ? "s" : ""} in instruction files`,
+      details: stale,
+      fix: "Update or remove dead paths from instruction files"
+    });
+  } else {
+    results.push({
+      check: "stale-references",
+      status: "ok",
+      message: "All referenced paths exist"
+    });
+  }
+  return results;
+}
+async function checkConventionContradictions(rootDir) {
+  const results = [];
+  const files = loadInstructionFiles(rootDir);
+  const configPath = path.join(rootDir, ".paradigm", "config.yaml");
+  if (fs.existsSync(configPath)) {
+    const content = fs.readFileSync(configPath, "utf8");
+    files.push({ name: "config.yaml", content, lines: content.split("\n") });
+  }
+  if (files.length === 0) {
+    results.push({
+      check: "convention-contradictions",
+      status: "ok",
+      message: "No instruction files to check"
+    });
+    return results;
+  }
+  const conventions = [];
+  const contradictions = [];
+  const namingPatterns = [
+    [/\bcamelCase\b/i, "camelCase"],
+    [/\bkebab[- ]?case\b/i, "kebab-case"],
+    [/\bsnake[_ ]?case\b/i, "snake_case"],
+    [/\bPascalCase\b/i, "PascalCase"]
+  ];
+  for (const file of files) {
+    for (let i = 0; i < file.lines.length; i++) {
+      const line = file.lines[i];
+      for (const [pattern, name] of namingPatterns) {
+        if (pattern.test(line)) {
+          const scopeMatch = line.match(/\b(file|variable|function|class|component|symbol|directory|folder|module|import)\s*nam/i);
+          const scope = scopeMatch ? scopeMatch[1].toLowerCase() : "general";
+          conventions.push({ scope, directive: name, source: file.name, line: i + 1 });
+        }
+      }
+    }
+  }
+  const byScope = /* @__PURE__ */ new Map();
+  for (const conv of conventions) {
+    const existing = byScope.get(conv.scope) || [];
+    existing.push(conv);
+    byScope.set(conv.scope, existing);
+  }
+  for (const [scope, rules] of byScope) {
+    const directives = new Set(rules.map((r) => r.directive));
+    const conflictPairs = [
+      ["camelCase", "kebab-case"],
+      ["camelCase", "snake_case"],
+      ["kebab-case", "snake_case"]
+    ];
+    for (const [a, b] of conflictPairs) {
+      if (directives.has(a) && directives.has(b)) {
+        const ruleA = rules.find((r) => r.directive === a);
+        const ruleB = rules.find((r) => r.directive === b);
+        contradictions.push(
+          `${scope} naming: ${a} (${ruleA.source}:${ruleA.line}) vs ${b} (${ruleB.source}:${ruleB.line})`
+        );
+      }
+    }
+  }
+  if (contradictions.length > 0) {
+    results.push({
+      check: "convention-contradictions",
+      status: "warn",
+      message: `${contradictions.length} potential convention contradiction${contradictions.length > 1 ? "s" : ""}`,
+      details: contradictions,
+      fix: "Reconcile conflicting naming/style conventions in instruction files"
+    });
+  } else {
+    results.push({
+      check: "convention-contradictions",
+      status: "ok",
+      message: "No contradictions detected"
+    });
+  }
+  return results;
+}
+var SKIP_DEPS = /* @__PURE__ */ new Set([
+  "typescript",
+  "tsup",
+  "vitest",
+  "eslint",
+  "prettier",
+  "rimraf",
+  "tsx",
+  "ts-node",
+  "nodemon",
+  "concurrently",
+  "husky",
+  "lint-staged",
+  "unbuild",
+  "turbo",
+  "lerna",
+  "changesets"
+]);
+var SKIP_PREFIXES = ["@types/", "@typescript-eslint/", "@eslint/"];
+async function checkUndocumentedStack(rootDir) {
+  const results = [];
+  const pkgPath = path.join(rootDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    results.push({
+      check: "undocumented-stack",
+      status: "ok",
+      message: "No package.json found (not a JS/TS project or monorepo root)"
+    });
+    return results;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  } catch {
+    results.push({
+      check: "undocumented-stack",
+      status: "advisory",
+      message: "Could not parse package.json"
+    });
+    return results;
+  }
+  const allDeps = /* @__PURE__ */ new Set([
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.devDependencies || {})
+  ]);
+  const majorDeps = [];
+  for (const dep of allDeps) {
+    if (SKIP_DEPS.has(dep)) continue;
+    if (SKIP_PREFIXES.some((p) => dep.startsWith(p))) continue;
+    majorDeps.push(dep);
+  }
+  if (majorDeps.length === 0) {
+    results.push({
+      check: "undocumented-stack",
+      status: "ok",
+      message: "No major dependencies to document"
+    });
+    return results;
+  }
+  const files = loadInstructionFiles(rootDir);
+  const allContent = files.map((f) => f.content).join("\n").toLowerCase();
+  const undocumented = [];
+  for (const dep of majorDeps) {
+    const depLower = dep.toLowerCase();
+    const shortName = dep.includes("/") ? dep.split("/").pop() : dep;
+    if (!allContent.includes(depLower) && !allContent.includes(shortName.toLowerCase())) {
+      undocumented.push(dep);
+    }
+  }
+  if (undocumented.length > 0) {
+    results.push({
+      check: "undocumented-stack",
+      status: "advisory",
+      message: `${undocumented.length} dependenc${undocumented.length > 1 ? "ies" : "y"} not mentioned in instruction files`,
+      details: undocumented.slice(0, 20),
+      // Cap at 20 to avoid noise
+      fix: "Consider documenting major dependencies in CLAUDE.md for AI context"
+    });
+  } else {
+    results.push({
+      check: "undocumented-stack",
+      status: "ok",
+      message: "All major dependencies are documented"
+    });
+  }
+  return results;
+}
+async function checkPurposeCoverage(rootDir) {
+  const results = [];
+  const sourceExtensions = [".ts", ".js", ".py", ".rs", ".go", ".tsx", ".jsx"];
+  const sourceDirs = findSourceDirs(rootDir, sourceExtensions);
+  if (sourceDirs.size === 0) {
+    results.push({
+      check: "purpose-coverage",
+      status: "ok",
+      message: "No source directories found"
+    });
+    return results;
+  }
+  let covered = 0;
+  const uncovered = [];
+  for (const dir of sourceDirs) {
+    if (hasPurposeCoverage(dir, rootDir)) {
+      covered++;
+    } else {
+      const rel = path.relative(rootDir, dir);
+      uncovered.push(rel);
+    }
+  }
+  const total = sourceDirs.size;
+  const pct = Math.round(covered / total * 100);
+  if (pct < 80) {
+    results.push({
+      check: "purpose-coverage",
+      status: "warn",
+      message: `${pct}% purpose coverage (${covered}/${total} source directories) \u2014 below 80% threshold`,
+      details: uncovered.slice(0, 15),
+      fix: "Create .purpose files in uncovered source directories"
+    });
+  } else {
+    results.push({
+      check: "purpose-coverage",
+      status: "ok",
+      message: `${pct}% purpose coverage (${covered}/${total} source directories)`
+    });
+  }
+  return results;
+}
+async function checkOrphanedSymbols(rootDir) {
+  const results = [];
+  const indexPath = path.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs.existsSync(indexPath)) {
+    results.push({
+      check: "orphaned-symbols",
+      status: "advisory",
+      message: "No scan-index.json found \u2014 run paradigm scan first"
+    });
+    return results;
+  }
+  let index;
+  try {
+    index = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    results.push({
+      check: "orphaned-symbols",
+      status: "advisory",
+      message: "Could not parse scan-index.json"
+    });
+    return results;
+  }
+  const categories = ["components", "gates", "signals", "flows", "aspects"];
+  const allSymbols = /* @__PURE__ */ new Map();
+  const referencedSymbols = /* @__PURE__ */ new Set();
+  for (const cat of categories) {
+    const entries = index[cat];
+    if (!entries || typeof entries !== "object") continue;
+    for (const [id, entry] of Object.entries(entries)) {
+      if (entry.symbol) {
+        allSymbols.set(entry.symbol, id);
+      }
+      if (entry.related && Array.isArray(entry.related)) {
+        for (const ref of entry.related) {
+          referencedSymbols.add(ref);
+        }
+      }
+    }
+  }
+  const orphaned = [];
+  for (const [symbol] of allSymbols) {
+    if (!referencedSymbols.has(symbol)) {
+      orphaned.push(symbol);
+    }
+  }
+  if (orphaned.length > 0) {
+    results.push({
+      check: "orphaned-symbols",
+      status: "advisory",
+      message: `${orphaned.length} symbol${orphaned.length > 1 ? "s" : ""} with zero cross-references`,
+      details: orphaned.slice(0, 20),
+      fix: "Add cross-references in .purpose files to connect orphaned symbols"
+    });
+  } else {
+    results.push({
+      check: "orphaned-symbols",
+      status: "ok",
+      message: "All symbols have cross-references"
+    });
+  }
+  return results;
+}
+async function checkStalePortal(rootDir) {
+  const results = [];
+  const portalPath = path.join(rootDir, "portal.yaml");
+  if (!fs.existsSync(portalPath)) {
+    results.push({
+      check: "stale-portal",
+      status: "ok",
+      message: "No portal.yaml found (no routes to check)"
+    });
+    return results;
+  }
+  let portal;
+  try {
+    const { parse } = await import("./dist-PSF5CP4I.js");
+    portal = parse(fs.readFileSync(portalPath, "utf8"));
+  } catch {
+    results.push({
+      check: "stale-portal",
+      status: "error",
+      message: "Could not parse portal.yaml"
+    });
+    return results;
+  }
+  if (!portal?.routes || typeof portal.routes !== "object") {
+    results.push({
+      check: "stale-portal",
+      status: "ok",
+      message: "No routes defined in portal.yaml"
+    });
+    return results;
+  }
+  const routePatterns = Object.keys(portal.routes);
+  const staleRoutes = [];
+  const sourceExtensions = [".ts", ".js", ".py", ".rs", ".go"];
+  const allSourceFiles = [];
+  function collectSourceFiles(dir) {
+    const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".paradigm", "coverage", "build", "target"]);
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (skipDirs.has(entry.name)) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          collectSourceFiles(full);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (sourceExtensions.includes(ext)) {
+            allSourceFiles.push(full);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  collectSourceFiles(rootDir);
+  const filenameLower = allSourceFiles.map((f) => ({
+    full: f,
+    name: path.basename(f, path.extname(f)).toLowerCase(),
+    relPath: path.relative(rootDir, f).toLowerCase()
+  }));
+  for (const route of routePatterns) {
+    const pathPart = route.replace(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+/i, "");
+    const segments = pathPart.split("/").filter((s) => s && !s.startsWith(":") && s !== "api");
+    if (segments.length === 0) continue;
+    const resource = segments[0].toLowerCase();
+    const hasMatch = filenameLower.some(
+      (f) => f.name.includes(resource) || f.relPath.includes(resource)
+    );
+    if (!hasMatch) {
+      staleRoutes.push(route);
+    }
+  }
+  if (staleRoutes.length > 0) {
+    results.push({
+      check: "stale-portal",
+      status: "error",
+      message: `${staleRoutes.length} portal route${staleRoutes.length > 1 ? "s" : ""} with no matching implementation file`,
+      details: staleRoutes,
+      fix: "Implement missing route handlers or remove stale routes from portal.yaml"
+    });
+  } else {
+    results.push({
+      check: "stale-portal",
+      status: "ok",
+      message: `All ${routePatterns.length} portal routes have matching implementation files`
+    });
+  }
+  return results;
+}
+var VAGUE_PATTERNS = [
+  { pattern: /\btry to\b/i, label: "try to" },
+  { pattern: /\bmaybe\b/i, label: "maybe" },
+  { pattern: /\bif possible\b/i, label: "if possible" },
+  { pattern: /\bconsider\b/i, label: "consider" },
+  { pattern: /\bmight want to\b/i, label: "might want to" },
+  { pattern: /\byou could\b/i, label: "you could" },
+  { pattern: /\boptionally\b/i, label: "optionally" }
+];
+async function checkInstructionVagueness(rootDir) {
+  const results = [];
+  const files = loadInstructionFiles(rootDir);
+  if (files.length === 0) {
+    results.push({
+      check: "instruction-vagueness",
+      status: "ok",
+      message: "No instruction files to check"
+    });
+    return results;
+  }
+  const instances = [];
+  for (const file of files) {
+    for (let i = 0; i < file.lines.length; i++) {
+      const line = file.lines[i];
+      if (line.trimStart().startsWith("```")) continue;
+      if (line.trim().startsWith("|---")) continue;
+      for (const { pattern, label } of VAGUE_PATTERNS) {
+        if (pattern.test(line)) {
+          const trimmed = line.trim();
+          const preview = trimmed.length > 80 ? trimmed.slice(0, 77) + "..." : trimmed;
+          instances.push(`${file.name}:${i + 1} \u2014 "${label}" \u2014 ${preview}`);
+        }
+      }
+    }
+  }
+  if (instances.length > 0) {
+    results.push({
+      check: "instruction-vagueness",
+      status: "advisory",
+      message: `${instances.length} vague phrase${instances.length > 1 ? "s" : ""} in instruction files`,
+      details: instances.slice(0, 20),
+      fix: "Replace vague language with clear, actionable directives"
+    });
+  } else {
+    results.push({
+      check: "instruction-vagueness",
+      status: "ok",
+      message: "No vague language detected"
+    });
+  }
+  return results;
+}
+async function runContextAudit(rootDir, _options) {
+  const tracker = log.command("doctor:context-audit").start("Running context audit checks");
+  const results = [];
+  results.push(...await checkStaleReferences(rootDir));
+  results.push(...await checkConventionContradictions(rootDir));
+  results.push(...await checkUndocumentedStack(rootDir));
+  results.push(...await checkPurposeCoverage(rootDir));
+  results.push(...await checkOrphanedSymbols(rootDir));
+  results.push(...await checkStalePortal(rootDir));
+  results.push(...await checkInstructionVagueness(rootDir));
+  const errorCount = results.filter((r) => r.status === "error").length;
+  const warnCount = results.filter((r) => r.status === "warn").length;
+  const advisoryCount = results.filter((r) => r.status === "advisory").length;
+  if (errorCount > 0) {
+    tracker.error("Context audit found issues", { errors: errorCount, warnings: warnCount, advisories: advisoryCount });
+  } else {
+    tracker.success("Context audit complete", { warnings: warnCount, advisories: advisoryCount });
+  }
+  return results;
+}
+export {
+  runContextAudit
+};