@a-company/paradigm 3.34.0 → 3.44.0

package/dist/{chunk-PFLWLC6J.js → chunk-ZMQA6SCO.js}

@@ -2,12 +2,17 @@
 import {
   loadLoreEntries,
   loadLoreEntry
-} from "./chunk-3DYYXGDC.js";
+} from "./chunk-CDMAMDSG.js";
+import {
+  checkComponentAnchors,
+  checkIntegrity,
+  checkPurposeHealth
+} from "./chunk-L27I3CPZ.js";
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
-import * as yaml7 from "js-yaml";
+import * as fs9 from "fs";
+import * as path10 from "path";
+import * as yaml8 from "js-yaml";
 
 // ../premise/core/dist/index.js
 import * as yaml3 from "js-yaml";
@@ -625,6 +630,138 @@ function validatePurposeItem(id, item, itemType, prefix, issues) {
     }
   }
 }
+function validateCrossFile(allFiles) {
+  const issues = [];
+  const definedSymbols = /* @__PURE__ */ new Set();
+  for (const { data } of allFiles) {
+    const components = normalizeToEntries(data.components);
+    for (const [id] of components) {
+      definedSymbols.add(`#${id}`);
+      definedSymbols.add(id);
+    }
+    const features = normalizeToEntries(data.features);
+    for (const [id] of features) {
+      definedSymbols.add(`#${id}`);
+      definedSymbols.add(id);
+    }
+    if (data.gates) {
+      for (const id of Object.keys(data.gates)) {
+        definedSymbols.add(`^${id}`);
+        definedSymbols.add(id);
+      }
+    }
+    if (data.signals) {
+      for (const id of Object.keys(data.signals)) {
+        definedSymbols.add(`!${id}`);
+        definedSymbols.add(id);
+      }
+    }
+    if (data.flows) {
+      if (Array.isArray(data.flows)) {
+        for (const flow of data.flows) {
+          if (flow?.name) {
+            definedSymbols.add(`$${flow.name}`);
+            definedSymbols.add(flow.name);
+          }
+        }
+      } else {
+        for (const id of Object.keys(data.flows)) {
+          definedSymbols.add(`$${id}`);
+          definedSymbols.add(id);
+        }
+      }
+    }
+    if (data.aspects) {
+      for (const id of Object.keys(data.aspects)) {
+        definedSymbols.add(`~${id}`);
+        definedSymbols.add(id);
+      }
+    }
+    if (data.states) {
+      for (const id of Object.keys(data.states)) {
+        definedSymbols.add(`#${id}`);
+        definedSymbols.add(id);
+      }
+    }
+  }
+  for (const { filePath, data } of allFiles) {
+    const prefix = filePath ? `${filePath}: ` : "";
+    const allEntries = [
+      ...normalizeToEntries(data.components),
+      ...normalizeToEntries(data.features)
+    ];
+    for (const [id, item] of allEntries) {
+      if (item.parent) {
+        const parentRef = item.parent.replace(/^["']|["']$/g, "");
+        const bareRef = parentRef.replace(/^[#$^!~@%?&]/, "");
+        if (!definedSymbols.has(parentRef) && !definedSymbols.has(bareRef)) {
+          issues.push({
+            type: "warning",
+            message: `${prefix}Component "${id}" references parent "${parentRef}" which is not defined in any .purpose file`,
+            path: `components.${id}.parent`
+          });
+        }
+      }
+      const refLists = [
+        { field: "gates", refs: item.gates },
+        { field: "signals", refs: item.signals },
+        { field: "flows", refs: item.flows },
+        { field: "components", refs: item.components },
+        { field: "aspects", refs: item.aspects }
+      ];
+      for (const { field, refs } of refLists) {
+        if (!refs) continue;
+        for (const ref of refs) {
+          const bareRef = ref.replace(/^[#$^!~@%?&]/, "");
+          if (!definedSymbols.has(ref) && !definedSymbols.has(bareRef)) {
+            issues.push({
+              type: "warning",
+              message: `${prefix}Symbol "${id}" references ${field} "${ref}" which is not defined`,
+              path: `components.${id}.${field}`
+            });
+          }
+        }
+      }
+    }
+    if (data.flows) {
+      if (Array.isArray(data.flows)) {
+        for (const flow of data.flows) {
+          if (!flow?.steps) continue;
+          for (const step of flow.steps) {
+            if (typeof step === "string" || !step?.component) continue;
+            const bareRef = step.component.replace(/^#/, "");
+            if (!definedSymbols.has(step.component) && !definedSymbols.has(bareRef)) {
+              issues.push({
+                type: "warning",
+                message: `${prefix}Flow "${flow.name}" step references "${step.component}" which is not defined`,
+                path: `flows.${flow.name}.steps`
+              });
+            }
+          }
+        }
+      } else {
+        for (const [flowId, flowDef] of Object.entries(data.flows)) {
+          if (!flowDef?.steps) continue;
+          for (const step of flowDef.steps) {
+            if (typeof step === "string" || !step?.component) continue;
+            const bareRef = step.component.replace(/^#/, "");
+            if (!definedSymbols.has(step.component) && !definedSymbols.has(bareRef)) {
+              issues.push({
+                type: "warning",
+                message: `${prefix}Flow "${flowId}" step references "${step.component}" which is not defined`,
+                path: `flows.${flowId}.steps`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.type === "error").length === 0,
+    issues
+  };
+}
 
 // ../portal/core/dist/index.js
 import * as fs2 from "fs";
@@ -1046,12 +1183,27 @@ async function aggregateFromPremise(premiseFile, rootDir) {
     }));
   }
   resolveReferences(symbols);
+  const symbolFileMap = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const files = symbolFileMap.get(sym.symbol) || [];
+    if (!files.includes(sym.filePath)) {
+      files.push(sym.filePath);
+    }
+    symbolFileMap.set(sym.symbol, files);
+  }
+  const duplicateSymbols = [];
+  for (const [symbol, files] of symbolFileMap) {
+    if (files.length > 1) {
+      duplicateSymbols.push({ symbol, files });
+    }
+  }
   return {
     symbols,
     purposeFiles,
     portalFiles,
     errors,
-    timestamp: Date.now()
+    timestamp: Date.now(),
+    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
   };
 }
 function createSymbolEntry(partial) {
@@ -2033,8 +2185,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path10 = uri.replace("paradigm://", "");
-    const firstPart = path10.split("/")[0];
+    const path11 = uri.replace("paradigm://", "");
+    const firstPart = path11.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -2788,7 +2940,7 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadLoreEntries: loadLoreEntries2 } = await import("./lore-loader-S5BXMH27.js");
+    const { loadLoreEntries: loadLoreEntries2 } = await import("./lore-loader-VTEEZDX3.js");
     const arcEntries = await loadLoreEntries2(rootDir, { limit: 10 });
     const entriesWithArcs = arcEntries.filter((e) => e.tags?.some((t) => t.startsWith("arc:")));
     if (entriesWithArcs.length > 0) {
@@ -4172,8 +4324,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path10) {
-  const parts = path10.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path11) {
+  const parts = path11.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -4253,7 +4405,7 @@ function assertStep(step, event) {
 async function validateAgainstSentinel(persona, options = {}) {
   const steps = [];
   try {
-    const { SentinelStorage } = await import("./dist-IKBGY7FQ.js");
+    const { SentinelStorage } = await import("./dist-CM3MVWWW.js");
     const storage = new SentinelStorage();
     const events = storage.queryEvents?.({
       schemaId: "paradigm-personas",
@@ -4676,6 +4828,604 @@ function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 
+// ../paradigm-mcp/src/utils/university-loader.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as yaml7 from "js-yaml";
+var UNIVERSITY_DIR = ".paradigm/university";
+var CONTENT_DIR = "content";
+var NOTES_DIR = "notes";
+var POLICIES_DIR = "policies";
+var QUIZZES_DIR = "quizzes";
+var PATHS_DIR = "paths";
+var DIPLOMAS_DIR = "diplomas";
+var INDEX_FILE3 = "index.yaml";
+var CONFIG_FILE = "config.yaml";
+var DEFAULT_BRANDING = {
+  name: "Project University",
+  tagline: "Learn the codebase",
+  institution: "Paradigm"
+};
+var DEFAULT_THEME = {
+  primary: "#6366f1",
+  secondary: "#8b5cf6",
+  accent: "#f59e0b",
+  background: "#0f172a",
+  surface: "#1e293b",
+  text: "#f8fafc",
+  textMuted: "#94a3b8",
+  success: "#22c55e",
+  error: "#ef4444",
+  font: "Inter, system-ui, sans-serif"
+};
+var DEFAULT_CONFIG = {
+  branding: DEFAULT_BRANDING,
+  theme: DEFAULT_THEME,
+  content: {
+    categories: [],
+    defaultDifficulty: "beginner",
+    requireApproval: false
+  },
+  diplomas: {
+    includeGlobalPLSAT: true,
+    customCertStyle: null
+  }
+};
+function loadUniversityConfig(rootDir) {
+  const configPath = path9.join(rootDir, UNIVERSITY_DIR, CONFIG_FILE);
+  if (!fs8.existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = fs8.readFileSync(configPath, "utf8");
+    const data = yaml7.load(raw);
+    if (!data) return { ...DEFAULT_CONFIG };
+    return {
+      branding: { ...DEFAULT_BRANDING, ...data.branding || {} },
+      theme: { ...DEFAULT_THEME, ...data.theme || {} },
+      content: {
+        categories: data.content?.categories || [],
+        defaultDifficulty: data.content?.defaultDifficulty || "beginner",
+        requireApproval: data.content?.requireApproval ?? false
+      },
+      diplomas: {
+        includeGlobalPLSAT: data.diplomas?.includeGlobalPLSAT ?? true,
+        customCertStyle: data.diplomas?.customCertStyle ?? null
+      }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function loadUniversityIndex(rootDir) {
+  const indexPath = path9.join(rootDir, UNIVERSITY_DIR, INDEX_FILE3);
+  if (!fs8.existsSync(indexPath)) return null;
+  try {
+    const raw = fs8.readFileSync(indexPath, "utf8");
+    return yaml7.load(raw);
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = yaml7.load(match[1]);
+    return { frontmatter, body: match[2].trim() };
+  } catch {
+    return null;
+  }
+}
+function serializeFrontmatter(frontmatter, body) {
+  const fm = yaml7.dump(frontmatter, { lineWidth: -1, noRefs: true, sortKeys: false });
+  return `---
+${fm}---
+
+${body}
+`;
+}
+function loadNote(rootDir, id) {
+  const filePath = resolveContentFile(rootDir, id, ".md");
+  if (!filePath) return null;
+  try {
+    const raw = fs8.readFileSync(filePath, "utf8");
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) return null;
+    const fm = parsed.frontmatter;
+    return { frontmatter: normalizeFrontmatter(fm), body: parsed.body };
+  } catch {
+    return null;
+  }
+}
+function saveNote(rootDir, frontmatter, body) {
+  const subdir = frontmatter.type === "policy" ? POLICIES_DIR : NOTES_DIR;
+  const dir = path9.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
+  fs8.mkdirSync(dir, { recursive: true });
+  const filePath = path9.join(dir, `${frontmatter.id}.md`);
+  const content = serializeFrontmatter(frontmatter, body);
+  fs8.writeFileSync(filePath, content, "utf8");
+  return filePath;
+}
+function loadQuiz(rootDir, id) {
+  const filePath = resolveContentFile(rootDir, id, ".yaml");
+  if (!filePath) return null;
+  try {
+    const raw = fs8.readFileSync(filePath, "utf8");
+    const data = yaml7.load(raw);
+    if (!data || !data.id) return null;
+    return normalizeQuiz(data);
+  } catch {
+    return null;
+  }
+}
+function saveQuiz(rootDir, quiz) {
+  const dir = path9.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, QUIZZES_DIR);
+  fs8.mkdirSync(dir, { recursive: true });
+  const filePath = path9.join(dir, `${quiz.id}.yaml`);
+  fs8.writeFileSync(filePath, yaml7.dump(quiz, { lineWidth: -1, noRefs: true }), "utf8");
+  return filePath;
+}
+function loadPath(rootDir, id) {
+  const filePath = resolveContentFile(rootDir, id, ".yaml");
+  if (!filePath) return null;
+  try {
+    const raw = fs8.readFileSync(filePath, "utf8");
+    const data = yaml7.load(raw);
+    if (!data || !data.id) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function savePath(rootDir, lp) {
+  const dir = path9.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, PATHS_DIR);
+  fs8.mkdirSync(dir, { recursive: true });
+  const filePath = path9.join(dir, `${lp.id}.yaml`);
+  fs8.writeFileSync(filePath, yaml7.dump(lp, { lineWidth: -1, noRefs: true }), "utf8");
+  return filePath;
+}
+function loadDiplomas(rootDir, filter) {
+  const dir = path9.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  if (!fs8.existsSync(dir)) return [];
+  const results = [];
+  try {
+    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const raw = fs8.readFileSync(path9.join(dir, file), "utf8");
+        const diploma = yaml7.load(raw);
+        if (!diploma || !diploma.id) continue;
+        if (filter?.student && diploma.student !== filter.student) continue;
+        if (filter?.type && diploma.type !== filter.type) continue;
+        results.push(diploma);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results.sort((a, b) => b.earnedAt.localeCompare(a.earnedAt));
+}
+function saveDiploma(rootDir, diploma) {
+  const dir = path9.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  fs8.mkdirSync(dir, { recursive: true });
+  const filePath = path9.join(dir, `${diploma.id}.yaml`);
+  fs8.writeFileSync(filePath, yaml7.dump(diploma, { lineWidth: -1, noRefs: true }), "utf8");
+  return filePath;
+}
+function searchContent(rootDir, filter) {
+  const index = loadUniversityIndex(rootDir);
+  if (!index) return [];
+  let results = [...index.entries];
+  if (filter.type) {
+    results = results.filter((e) => e.type === filter.type);
+  }
+  if (filter.tag) {
+    results = results.filter((e) => e.tags.some((t) => t.startsWith(filter.tag)));
+  }
+  if (filter.difficulty) {
+    results = results.filter((e) => e.difficulty === filter.difficulty);
+  }
+  if (filter.symbol) {
+    results = results.filter((e) => e.symbols.some((s) => s === filter.symbol));
+  }
+  if (filter.author) {
+    results = results.filter((e) => e.author === filter.author);
+  }
+  if (filter.query) {
+    const q = filter.query.toLowerCase();
+    results = results.filter(
+      (e) => e.title.toLowerCase().includes(q) || e.id.toLowerCase().includes(q) || e.tags.some((t) => t.toLowerCase().includes(q))
+    );
+  }
+  const limit = filter.limit || 20;
+  return results.slice(0, limit);
+}
+function rebuildUniversityIndex(rootDir) {
+  const uniDir = path9.join(rootDir, UNIVERSITY_DIR);
+  const contentDir = path9.join(uniDir, CONTENT_DIR);
+  const entries = [];
+  for (const subdir of [NOTES_DIR, POLICIES_DIR]) {
+    const dir = path9.join(contentDir, subdir);
+    if (!fs8.existsSync(dir)) continue;
+    try {
+      for (const file of fs8.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+        try {
+          const raw = fs8.readFileSync(path9.join(dir, file), "utf8");
+          const parsed = parseFrontmatter(raw);
+          if (!parsed) continue;
+          const fm = parsed.frontmatter;
+          entries.push({
+            id: fm.id || file.replace(".md", ""),
+            title: fm.title || file,
+            type: fm.type || (subdir === POLICIES_DIR ? "policy" : "note"),
+            author: fm.author || "unknown",
+            created: fm.created || "",
+            updated: fm.updated || "",
+            tags: Array.isArray(fm.tags) ? fm.tags : [],
+            symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
+            difficulty: fm.difficulty || "beginner",
+            file: `${CONTENT_DIR}/${subdir}/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const quizDir = path9.join(contentDir, QUIZZES_DIR);
+  if (fs8.existsSync(quizDir)) {
+    try {
+      for (const file of fs8.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const raw = fs8.readFileSync(path9.join(quizDir, file), "utf8");
+          const quiz = yaml7.load(raw);
+          if (!quiz || !quiz.id) continue;
+          entries.push({
+            id: quiz.id,
+            title: quiz.title || file,
+            type: "quiz",
+            author: quiz.author || "unknown",
+            created: quiz.created || "",
+            updated: quiz.updated || "",
+            tags: quiz.tags || [],
+            symbols: quiz.symbols || [],
+            difficulty: quiz.difficulty || "beginner",
+            file: `${CONTENT_DIR}/${QUIZZES_DIR}/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const pathDir = path9.join(contentDir, PATHS_DIR);
+  if (fs8.existsSync(pathDir)) {
+    try {
+      for (const file of fs8.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const raw = fs8.readFileSync(path9.join(pathDir, file), "utf8");
+          const lp = yaml7.load(raw);
+          if (!lp || !lp.id) continue;
+          entries.push({
+            id: lp.id,
+            title: lp.title || file,
+            type: "path",
+            author: lp.author || "unknown",
+            created: lp.created || "",
+            updated: lp.updated || "",
+            tags: lp.tags || [],
+            symbols: [],
+            file: `${CONTENT_DIR}/${PATHS_DIR}/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let diplomaCount = 0;
+  const diplomaDir = path9.join(uniDir, DIPLOMAS_DIR);
+  if (fs8.existsSync(diplomaDir)) {
+    try {
+      diplomaCount = fs8.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
+    } catch {
+    }
+  }
+  const index = {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalContent: entries.length,
+    entries,
+    diplomaCount
+  };
+  fs8.mkdirSync(uniDir, { recursive: true });
+  const indexPath = path9.join(uniDir, INDEX_FILE3);
+  fs8.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  return index;
+}
+function validateUniversityContent(rootDir, options) {
+  const index = loadUniversityIndex(rootDir) || rebuildUniversityIndex(rootDir);
+  const issues = [];
+  let entriesToCheck = index.entries;
+  if (options?.id) {
+    entriesToCheck = entriesToCheck.filter((e) => e.id === options.id);
+  }
+  let knownSymbols = null;
+  if (options?.deep) {
+    knownSymbols = loadKnownSymbols(rootDir);
+  }
+  const allContentIds = new Set(index.entries.map((e) => e.id));
+  for (const entry of entriesToCheck) {
+    if (!entry.title) {
+      issues.push({
+        contentId: entry.id,
+        severity: "error",
+        check: "missing-title",
+        message: "Content is missing a title",
+        fix: "Add a title field to the content frontmatter"
+      });
+    }
+    if (entry.type === "quiz") {
+      validateQuizContent(rootDir, entry.id, issues);
+    }
+    if (entry.type === "path") {
+      validatePathContent(rootDir, entry.id, allContentIds, issues);
+    }
+    if (knownSymbols && entry.symbols.length > 0) {
+      for (const sym of entry.symbols) {
+        if (!knownSymbols.has(sym)) {
+          issues.push({
+            contentId: entry.id,
+            severity: "warning",
+            check: "broken-symbol-ref",
+            message: `Symbol "${sym}" not found in scan-index`,
+            fix: `Remove or update the symbol reference in ${entry.id}`
+          });
+        }
+      }
+    }
+    if (options?.deep && entry.symbols.length > 0 && entry.updated) {
+      checkContentStaleness(rootDir, entry, issues);
+    }
+  }
+  const diplomas = loadDiplomas(rootDir);
+  for (const diploma of diplomas) {
+    if (diploma.total > 0 && diploma.percentage !== Math.round(diploma.score / diploma.total * 1e4) / 100) {
+      const expected = Math.round(diploma.score / diploma.total * 1e4) / 100;
+      if (Math.abs(diploma.percentage - expected) > 0.1) {
+        issues.push({
+          contentId: diploma.id,
+          severity: "warning",
+          check: "diploma-score-mismatch",
+          message: `Diploma percentage ${diploma.percentage} doesn't match score ${diploma.score}/${diploma.total} (expected ${expected})`
+        });
+      }
+    }
+  }
+  const symbolCoverage = computeSymbolCoverage(rootDir, index);
+  return {
+    status: issues.some((i) => i.severity === "error") ? "errors" : issues.length > 0 ? "warnings" : "healthy",
+    totalContent: index.totalContent,
+    checked: entriesToCheck.length,
+    issues,
+    symbolCoverage
+  };
+}
+function validateQuizContent(rootDir, id, issues) {
+  const quiz = loadQuiz(rootDir, id);
+  if (!quiz) {
+    issues.push({
+      contentId: id,
+      severity: "error",
+      check: "unreadable-quiz",
+      message: "Quiz file could not be parsed"
+    });
+    return;
+  }
+  if (!quiz.passThreshold || quiz.passThreshold < 0 || quiz.passThreshold > 1) {
+    issues.push({
+      contentId: id,
+      severity: "warning",
+      check: "invalid-pass-threshold",
+      message: `passThreshold should be between 0 and 1, got ${quiz.passThreshold}`,
+      fix: "Set passThreshold to a value between 0.0 and 1.0"
+    });
+  }
+  for (const q of quiz.questions) {
+    if (!q.choices || typeof q.choices !== "object") {
+      issues.push({
+        contentId: id,
+        severity: "error",
+        check: "invalid-quiz-choices",
+        message: `Question ${q.id} has no choices defined`
+      });
+      continue;
+    }
+    if (!q.correct || !(q.correct in q.choices)) {
+      issues.push({
+        contentId: id,
+        severity: "error",
+        check: "invalid-quiz-answer",
+        message: `Question ${q.id}: correct answer "${q.correct}" not found in choices [${Object.keys(q.choices).join(", ")}]`,
+        fix: `Set correct to one of: ${Object.keys(q.choices).join(", ")}`
+      });
+    }
+  }
+}
+function validatePathContent(rootDir, id, allContentIds, issues) {
+  const lp = loadPath(rootDir, id);
+  if (!lp) {
+    issues.push({
+      contentId: id,
+      severity: "error",
+      check: "unreadable-path",
+      message: "Learning path file could not be parsed"
+    });
+    return;
+  }
+  for (const step of lp.steps) {
+    if (step.content.startsWith("plsat:")) continue;
+    if (!allContentIds.has(step.content)) {
+      issues.push({
+        contentId: id,
+        severity: "error",
+        check: "broken-path-step",
+        message: `Learning path step references "${step.content}" which doesn't exist`,
+        fix: `Create content with id "${step.content}" or remove this step`
+      });
+    }
+  }
+}
+function getAffectedUniversityContent(rootDir, symbol) {
+  const index = loadUniversityIndex(rootDir);
+  if (!index) return [];
+  const affected = [];
+  for (const entry of index.entries) {
+    if (entry.symbols.includes(symbol)) {
+      const stale = isContentStale(rootDir, entry, symbol);
+      affected.push({
+        id: entry.id,
+        title: entry.title,
+        type: entry.type,
+        stale
+      });
+    }
+  }
+  return affected;
+}
+function getOnboardingSequence(rootDir, student) {
+  const index = loadUniversityIndex(rootDir);
+  if (!index) {
+    return { paths: [], suggestedContent: [], diplomaCount: 0, totalContent: 0 };
+  }
+  const pathEntries = index.entries.filter((e) => e.type === "path");
+  const diplomas = student ? loadDiplomas(rootDir, { student }) : [];
+  const diplomaSourceIds = new Set(diplomas.map((d) => d.source));
+  const paths = pathEntries.map((pe) => {
+    const lp = loadPath(rootDir, pe.id);
+    return {
+      id: pe.id,
+      title: pe.title,
+      steps: lp?.steps.length || 0,
+      completed: diplomaSourceIds.has(pe.id)
+    };
+  });
+  const suggestedContent = index.entries.filter((e) => e.type !== "path" && (e.difficulty === "beginner" || e.tags.includes("onboarding"))).slice(0, 10);
+  return {
+    paths,
+    suggestedContent,
+    diplomaCount: diplomas.length,
+    totalContent: index.totalContent
+  };
+}
+function resolveContentFile(rootDir, id, ext) {
+  const contentDir = path9.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
+  for (const subdir of [NOTES_DIR, POLICIES_DIR, QUIZZES_DIR, PATHS_DIR]) {
+    const filePath = path9.join(contentDir, subdir, `${id}${ext}`);
+    if (fs8.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function normalizeFrontmatter(fm) {
+  return {
+    id: fm.id || "",
+    title: fm.title || "",
+    type: fm.type || "note",
+    author: fm.author || "unknown",
+    created: fm.created || "",
+    updated: fm.updated || "",
+    tags: Array.isArray(fm.tags) ? fm.tags : [],
+    symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
+    difficulty: fm.difficulty || "beginner",
+    estimatedMinutes: fm.estimatedMinutes,
+    prerequisites: Array.isArray(fm.prerequisites) ? fm.prerequisites : []
+  };
+}
+function normalizeQuiz(quiz) {
+  return {
+    ...quiz,
+    tags: quiz.tags || [],
+    symbols: quiz.symbols || [],
+    difficulty: quiz.difficulty || "beginner",
+    passThreshold: quiz.passThreshold ?? 0.7,
+    questions: quiz.questions || []
+  };
+}
+function loadKnownSymbols(rootDir) {
+  const symbols = /* @__PURE__ */ new Set();
+  const scanIndexPath = path9.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs8.existsSync(scanIndexPath)) return symbols;
+  try {
+    const raw = fs8.readFileSync(scanIndexPath, "utf8");
+    const index = JSON.parse(raw);
+    if (index.symbols && Array.isArray(index.symbols)) {
+      for (const sym of index.symbols) {
+        if (sym.symbol) symbols.add(sym.symbol);
+      }
+    }
+  } catch {
+  }
+  return symbols;
+}
+function computeSymbolCoverage(rootDir, index) {
+  const knownSymbols = loadKnownSymbols(rootDir);
+  const coveredSymbols = /* @__PURE__ */ new Set();
+  for (const entry of index.entries) {
+    for (const sym of entry.symbols) {
+      if (knownSymbols.has(sym)) {
+        coveredSymbols.add(sym);
+      }
+    }
+  }
+  const total = knownSymbols.size;
+  return {
+    totalSymbols: total,
+    coveredByContent: coveredSymbols.size,
+    percentage: total > 0 ? Math.round(coveredSymbols.size / total * 100) : 0
+  };
+}
+function isContentStale(rootDir, entry, _symbol) {
+  if (!entry.updated) return false;
+  const contentUpdated = new Date(entry.updated).getTime();
+  if (isNaN(contentUpdated)) return false;
+  const scanIndexPath = path9.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs8.existsSync(scanIndexPath)) return false;
+  try {
+    const raw = fs8.readFileSync(scanIndexPath, "utf8");
+    const index = JSON.parse(raw);
+    if (index.symbols && Array.isArray(index.symbols)) {
+      for (const sym of index.symbols) {
+        if (sym.symbol === _symbol && sym.filePath) {
+          const purposePath = path9.join(rootDir, sym.filePath);
+          if (fs8.existsSync(purposePath)) {
+            const stat = fs8.statSync(purposePath);
+            if (stat.mtime.getTime() > contentUpdated) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function checkContentStaleness(rootDir, entry, issues) {
+  for (const sym of entry.symbols) {
+    if (isContentStale(rootDir, entry, sym)) {
+      issues.push({
+        contentId: entry.id,
+        severity: "warning",
+        check: "stale-content",
+        message: `Content may be stale: symbol "${sym}" was updated after content was last modified`,
+        fix: `Review and update ${entry.id} to reflect changes to ${sym}`
+      });
+      break;
+    }
+  }
+}
+
 // ../paradigm-mcp/src/tools/reindex.ts
 var SYMBOL_CATEGORIES = {
   "@": { category: "features", prefix: "@" },
@@ -4764,10 +5514,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path9.basename(rootDir);
-  const paradigmDir = path9.join(rootDir, ".paradigm");
-  if (!fs8.existsSync(paradigmDir)) {
-    fs8.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path10.basename(rootDir);
+  const paradigmDir = path10.join(rootDir, ".paradigm");
+  if (!fs9.existsSync(paradigmDir)) {
+    fs9.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -4777,22 +5527,22 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path9.join(paradigmDir, "scan-index.json");
-  fs8.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path10.join(paradigmDir, "scan-index.json");
+  fs9.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path9.join(paradigmDir, "navigator.yaml");
-  fs8.writeFileSync(
+  const navigatorPath = path10.join(paradigmDir, "navigator.yaml");
+  fs9.writeFileSync(
     navigatorPath,
-    yaml7.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
+    yaml8.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
   );
   filesWritten.push(".paradigm/navigator.yaml");
   const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
-    const flowIndexPath = path9.join(paradigmDir, "flow-index.json");
-    fs8.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path10.join(paradigmDir, "flow-index.json");
+    fs9.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -4833,6 +5583,58 @@ async function rebuildStaticFiles(rootDir, ctx) {
     }
   } catch {
   }
+  let universityStats;
+  try {
+    const uniDir = path10.join(rootDir, ".paradigm", "university");
+    if (fs9.existsSync(uniDir)) {
+      const uniIndex = rebuildUniversityIndex(rootDir);
+      if (uniIndex.totalContent > 0 || uniIndex.diplomaCount > 0) {
+        universityStats = {
+          totalContent: uniIndex.totalContent,
+          diplomaCount: uniIndex.diplomaCount
+        };
+        filesWritten.push(".paradigm/university/index.yaml");
+      }
+    }
+  } catch {
+  }
+  let integrityReport;
+  try {
+    integrityReport = checkIntegrity(aggregation, rootDir);
+  } catch {
+  }
+  let componentAnchorIssues;
+  try {
+    const anchorReport = checkComponentAnchors(aggregation.symbols, rootDir);
+    const issues = anchorReport.missing + anchorReport.outOfBounds;
+    if (issues > 0) {
+      componentAnchorIssues = issues;
+    }
+  } catch {
+  }
+  let purposeHealth;
+  try {
+    purposeHealth = checkPurposeHealth(aggregation.purposeFiles, rootDir);
+  } catch {
+  }
+  let crossFileIssues;
+  try {
+    const parsedFiles = [];
+    for (const filePath of aggregation.purposeFiles) {
+      const result = parsePurposeFile(filePath);
+      if (result.data) {
+        parsedFiles.push({ filePath, data: result.data });
+      }
+    }
+    if (parsedFiles.length > 0) {
+      const crossResult = validateCrossFile(parsedFiles);
+      const warningCount = crossResult.issues.length;
+      if (warningCount > 0) {
+        crossFileIssues = warningCount;
+      }
+    }
+  } catch {
+  }
   const breakdown = {};
   for (const sym of aggregation.symbols) {
     breakdown[sym.type] = (breakdown[sym.type] || 0) + 1;
@@ -4852,7 +5654,12 @@ async function rebuildStaticFiles(rootDir, ctx) {
     aspectGraphStats,
     personaCount,
     protocolHealth,
-    ...Object.keys(componentTypeBreakdown).length > 0 ? { componentTypeBreakdown } : {}
+    ...Object.keys(componentTypeBreakdown).length > 0 ? { componentTypeBreakdown } : {},
+    ...universityStats ? { universityStats } : {},
+    ...integrityReport ? { integrityReport } : {},
+    ...componentAnchorIssues !== void 0 ? { componentAnchorIssues } : {},
+    ...purposeHealth ? { purposeHealth } : {},
+    ...crossFileIssues !== void 0 ? { crossFileIssues } : {}
   };
 }
 function buildNavigatorData(rootDir, aggregation) {
@@ -4877,7 +5684,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
     if (existingPaths.length > 0) {
       const symbolInfo = Object.values(SYMBOL_CATEGORIES).find((s) => s.category === category);
       structure[category] = { paths: existingPaths, symbol: symbolInfo?.prefix || "@" };
@@ -4888,7 +5695,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -4904,10 +5711,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path9.join(rootDir, ".gitignore");
-  if (fs8.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(rootDir, ".gitignore");
+  if (fs9.existsSync(gitignorePath)) {
     try {
-      const content = fs8.readFileSync(gitignorePath, "utf8");
+      const content = fs9.readFileSync(gitignorePath, "utf8");
       const gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter(
         (line) => line.endsWith("/") || line.includes("*") || ["node_modules", "dist", "build", ".cache"].some((p) => line.includes(p))
       ).slice(0, 20);
@@ -4956,11 +5763,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path9.dirname(pf);
+        const dir = path10.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path10.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -4971,8 +5778,8 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
-      const data = yaml7.load(content);
+      const content = fs9.readFileSync(filePath, "utf8");
+      const data = yaml8.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
         for (const flowItem of data.flows) {
@@ -4985,7 +5792,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -5001,7 +5808,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -5111,6 +5918,20 @@ export {
   updateProtocol,
   validateProtocol,
   detectProtocolSuggestion,
+  loadUniversityConfig,
+  loadNote,
+  saveNote,
+  loadQuiz,
+  saveQuiz,
+  loadPath,
+  savePath,
+  loadDiplomas,
+  saveDiploma,
+  searchContent,
+  rebuildUniversityIndex,
+  validateUniversityContent,
+  getAffectedUniversityContent,
+  getOnboardingSequence,
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles