@a-company/paradigm 3.44.0 → 5.3.3

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

@@ -1,17 +1,266 @@
 #!/usr/bin/env node
 import {
+  init_lore_loader,
   loadLoreEntries,
   loadLoreEntry
-} from "./chunk-CDMAMDSG.js";
+} from "./chunk-5VKJBNJL.js";
 import {
   checkComponentAnchors,
   checkIntegrity,
   checkPurposeHealth
 } from "./chunk-L27I3CPZ.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-7N7GSU6K.js";
+
+// ../paradigm-mcp/src/utils/aspect-fingerprint.ts
+var aspect_fingerprint_exports = {};
+__export(aspect_fingerprint_exports, {
+  contentSearch: () => contentSearch,
+  detectFileRename: () => detectFileRename,
+  generateFingerprint: () => generateFingerprint,
+  levenshteinDistance: () => levenshteinDistance,
+  levenshteinSimilarity: () => levenshteinSimilarity,
+  searchSiblingFiles: () => searchSiblingFiles,
+  slidingWindowSearch: () => slidingWindowSearch
+});
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as crypto2 from "crypto";
+import { execSync } from "child_process";
+function generateFingerprint(content) {
+  const lines = content.split("\n").filter((l) => l.trim() !== "");
+  return {
+    firstLine: normalizeLine(lines[0] || ""),
+    lastLine: normalizeLine(lines[lines.length - 1] || ""),
+    lineCount: lines.length,
+    structuralHash: extractStructuralHash(lines)
+  };
+}
+function extractStructuralHash(lines) {
+  const structural = lines.map((l) => l.trim()).filter((l) => STRUCTURAL_TOKENS.test(l)).map((l) => {
+    const match = l.match(STRUCTURAL_TOKENS);
+    return match ? match[1].trim() : "";
+  }).join("|");
+  return crypto2.createHash("sha256").update(structural).digest("hex").slice(0, 16);
+}
+function normalizeLine(line) {
+  return line.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function levenshteinDistance(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  if (a.length > b.length) [a, b] = [b, a];
+  const aLen = a.length;
+  const bLen = b.length;
+  if (aLen > 5e3 || bLen > 5e3) {
+    return Math.abs(aLen - bLen);
+  }
+  let prev = new Array(aLen + 1);
+  let curr = new Array(aLen + 1);
+  for (let i = 0; i <= aLen; i++) prev[i] = i;
+  for (let j = 1; j <= bLen; j++) {
+    curr[0] = j;
+    for (let i = 1; i <= aLen; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[i] = Math.min(
+        prev[i] + 1,
+        // deletion
+        curr[i - 1] + 1,
+        // insertion
+        prev[i - 1] + cost
+        // substitution
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[aLen];
+}
+function levenshteinSimilarity(a, b) {
+  if (a.length === 0 && b.length === 0) return 1;
+  const maxLen = Math.max(a.length, b.length);
+  const distance = levenshteinDistance(a, b);
+  return 1 - distance / maxLen;
+}
+function slidingWindowSearch(fileLines, fingerprint, originalContent, maxResults = 3) {
+  const { lineCount } = fingerprint;
+  const minWindow = Math.max(1, Math.floor(lineCount * 0.8));
+  const maxWindow = Math.ceil(lineCount * 1.2);
+  const results = [];
+  const normalizedOriginal = normalizeBlock(originalContent);
+  for (const windowSize of [lineCount, minWindow, maxWindow]) {
+    if (windowSize > fileLines.length) continue;
+    for (let start = 0; start <= fileLines.length - windowSize; start++) {
+      const windowLines = fileLines.slice(start, start + windowSize);
+      const score = scoreWindow(windowLines, fingerprint, normalizedOriginal);
+      if (score >= 0.5) {
+        const windowContent = windowLines.join("\n");
+        results.push({
+          windowStart: start + 1,
+          // 1-indexed
+          windowEnd: start + windowSize,
+          similarity: levenshteinSimilarity(normalizeBlock(windowContent), normalizedOriginal),
+          score
+        });
+      }
+    }
+  }
+  const byStart = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const existing = byStart.get(r.windowStart);
+    if (!existing || r.score > existing.score) {
+      byStart.set(r.windowStart, r);
+    }
+  }
+  return Array.from(byStart.values()).sort((a, b) => b.score - a.score).slice(0, maxResults);
+}
+function scoreWindow(windowLines, fingerprint, normalizedOriginal) {
+  const nonEmpty = windowLines.filter((l) => l.trim() !== "");
+  if (nonEmpty.length === 0) return 0;
+  let score = 0;
+  const firstLine = normalizeLine(nonEmpty[0]);
+  const lastLine = normalizeLine(nonEmpty[nonEmpty.length - 1]);
+  let firstLastScore = 0;
+  if (firstLine === fingerprint.firstLine) firstLastScore += 0.5;
+  if (lastLine === fingerprint.lastLine) firstLastScore += 0.5;
+  score += firstLastScore * W_FIRST_LAST;
+  const windowStructural = extractStructuralHash(nonEmpty);
+  if (windowStructural === fingerprint.structuralHash) {
+    score += W_STRUCTURAL;
+  }
+  const windowContent = nonEmpty.join("\n");
+  const similarity = levenshteinSimilarity(normalizeBlock(windowContent), normalizedOriginal);
+  if (similarity >= 0.8) {
+    score += (similarity - 0.8) / 0.2 * W_LEVENSHTEIN;
+  }
+  const countRatio = nonEmpty.length / fingerprint.lineCount;
+  if (countRatio >= 0.8 && countRatio <= 1.2) {
+    const countScore = 1 - Math.abs(1 - countRatio) / 0.2;
+    score += countScore * W_LINE_COUNT;
+  }
+  return score;
+}
+function normalizeBlock(content) {
+  return content.split("\n").map((l) => l.trim()).filter((l) => l !== "").join("\n");
+}
+function detectFileRename(rootDir, oldPath) {
+  try {
+    const result = execSync(
+      `git log --follow --diff-filter=R --name-status --format="" -- "${oldPath}"`,
+      { cwd: rootDir, encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    if (!result) return null;
+    const lines = result.split("\n");
+    for (const line of lines) {
+      const parts = line.split("	");
+      if (parts.length >= 3 && parts[0].startsWith("R")) {
+        return parts[2];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function searchSiblingFiles(rootDir, dirPath, fingerprint, originalContent, maxFiles = 10) {
+  const absoluteDir = path6.isAbsolute(dirPath) ? dirPath : path6.join(rootDir, dirPath);
+  if (!fs5.existsSync(absoluteDir)) return [];
+  const results = [];
+  try {
+    const files = fs5.readdirSync(absoluteDir).filter((f) => !f.startsWith(".") && fs5.statSync(path6.join(absoluteDir, f)).isFile()).slice(0, maxFiles);
+    for (const file of files) {
+      try {
+        const content = fs5.readFileSync(path6.join(absoluteDir, file), "utf8");
+        const lines = content.split("\n");
+        const matches = slidingWindowSearch(lines, fingerprint, originalContent, 1);
+        if (matches.length > 0 && matches[0].score >= 0.7) {
+          const relPath = path6.relative(rootDir, path6.join(absoluteDir, file));
+          results.push({
+            file: relPath,
+            score: matches[0].score,
+            start: matches[0].windowStart,
+            end: matches[0].windowEnd
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function contentSearch(rootDir, filePath, originalContent, autoHeal = true) {
+  const fingerprint = generateFingerprint(originalContent);
+  const absolutePath = path6.isAbsolute(filePath) ? filePath : path6.join(rootDir, filePath);
+  if (fs5.existsSync(absolutePath)) {
+    const fileContent = fs5.readFileSync(absolutePath, "utf8");
+    const fileLines = fileContent.split("\n");
+    const matches = slidingWindowSearch(fileLines, fingerprint, originalContent);
+    if (matches.length > 0) {
+      const best = matches[0];
+      return {
+        found: best.score >= 0.7,
+        score: best.score,
+        suggestedStart: best.windowStart,
+        suggestedEnd: best.windowEnd,
+        similarity: best.similarity
+      };
+    }
+  }
+  const renamedTo = detectFileRename(rootDir, filePath);
+  if (renamedTo) {
+    const renamedPath = path6.join(rootDir, renamedTo);
+    if (fs5.existsSync(renamedPath)) {
+      const renamedContent = fs5.readFileSync(renamedPath, "utf8");
+      const renamedLines = renamedContent.split("\n");
+      const matches = slidingWindowSearch(renamedLines, fingerprint, originalContent);
+      if (matches.length > 0 && matches[0].score >= 0.7) {
+        return {
+          found: true,
+          score: matches[0].score,
+          suggestedStart: matches[0].windowStart,
+          suggestedEnd: matches[0].windowEnd,
+          suggestedPath: renamedTo,
+          similarity: matches[0].similarity
+        };
+      }
+    }
+  }
+  const dirPath = path6.dirname(filePath);
+  const siblingResults = searchSiblingFiles(rootDir, dirPath, fingerprint, originalContent);
+  if (siblingResults.length > 0 && siblingResults[0].score >= 0.7) {
+    const best = siblingResults[0];
+    return {
+      found: true,
+      score: best.score,
+      suggestedStart: best.start,
+      suggestedEnd: best.end,
+      suggestedPath: best.file !== filePath ? best.file : void 0,
+      similarity: best.score
+      // approximate
+    };
+  }
+  return { found: false, score: 0 };
+}
+var STRUCTURAL_TOKENS, W_FIRST_LAST, W_STRUCTURAL, W_LEVENSHTEIN, W_LINE_COUNT;
+var init_aspect_fingerprint = __esm({
+  "../paradigm-mcp/src/utils/aspect-fingerprint.ts"() {
+    "use strict";
+    STRUCTURAL_TOKENS = /^\s*(function |class |if |else |for |while |switch |case |return |export |import |const |let |var |async |await |try |catch |throw |struct |enum |protocol |guard |def |fn )/;
+    W_FIRST_LAST = 0.4;
+    W_STRUCTURAL = 0.3;
+    W_LEVENSHTEIN = 0.2;
+    W_LINE_COUNT = 0.1;
+  }
+});
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import * as yaml8 from "js-yaml";
 
 // ../premise/core/dist/index.js
@@ -1979,6 +2228,7 @@ var SessionTracker = class {
       context: data.context,
       timestamp: Date.now(),
       sessionId: this.session.sessionId,
+      externalId: data.externalId,
       plan: data.plan,
       modifiedFiles: data.modifiedFiles,
       symbolsTouched: data.symbolsTouched,
@@ -2185,8 +2435,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path11 = uri.replace("paradigm://", "");
-    const firstPart = path11.split("/")[0];
+    const path12 = uri.replace("paradigm://", "");
+    const firstPart = path12.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -2531,6 +2781,10 @@ function getContextToolsList() {
             type: "string",
             description: "What's top-of-mind right now (1-3 sentences)"
           },
+          externalId: {
+            type: "string",
+            description: 'Optional: deterministic ID from external source for automatic session recovery (e.g. "linear:PROJ-123", "github:owner/repo#42")'
+          },
           plan: {
             type: "string",
             description: "Optional: the current plan or approach"
@@ -2573,6 +2827,10 @@ function getContextToolsList() {
             type: "string",
             description: "What's top-of-mind right now (1-3 sentences)"
           },
+          externalId: {
+            type: "string",
+            description: 'Optional: deterministic ID from external source for automatic session recovery (e.g. "linear:PROJ-123", "github:owner/repo#42")'
+          },
           plan: {
             type: "string",
             description: "Optional: the current plan or approach"
@@ -2852,6 +3110,7 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     tracker2.setRootDir(_ctx.rootDir);
     const phase = args.phase;
     const context = args.context;
+    const externalId = args.externalId;
     const plan = args.plan;
     const modifiedFiles = args.modifiedFiles;
     const symbolsTouched = args.symbolsTouched;
@@ -2859,6 +3118,7 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     const { checkpoint, persisted } = tracker2.saveCheckpoint({
       phase,
       context,
+      externalId,
       plan,
       modifiedFiles,
       symbolsTouched,
@@ -2874,6 +3134,7 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
           phase: checkpoint.phase,
           context: checkpoint.context,
           sessionId: checkpoint.sessionId,
+          ...checkpoint.externalId ? { externalId: checkpoint.externalId } : {},
           timestamp: new Date(checkpoint.timestamp).toISOString(),
           modifiedFiles: checkpoint.modifiedFiles?.length || 0,
           symbolsTouched: checkpoint.symbolsTouched?.length || 0,
@@ -2927,7 +3188,7 @@ async function buildRecoveryPreamble(rootDir) {
     }
   }
   try {
-    const { loadTasks } = await import("./task-loader-7M2FCBX6.js");
+    const { loadTasks } = await import("./task-loader-LDYWQSLM.js");
     const openTasks = await loadTasks(rootDir, { status: "open", limit: 5 });
     if (openTasks.length > 0) {
       lines.push("");
@@ -2940,7 +3201,7 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadLoreEntries: loadLoreEntries2 } = await import("./lore-loader-VTEEZDX3.js");
+    const { loadLoreEntries: loadLoreEntries2 } = await import("./lore-loader-7NO6N6FT.js");
     const arcEntries = await loadLoreEntries2(rootDir, { limit: 10 });
     const entriesWithArcs = arcEntries.filter((e) => e.tags?.some((t) => t.startsWith("arc:")));
     if (entriesWithArcs.length > 0) {
@@ -2961,6 +3222,21 @@ async function buildRecoveryPreamble(rootDir) {
     }
   } catch {
   }
+  try {
+    const { loadNominations } = await import("./nomination-engine-Q4XSXFKT.js");
+    const urgent = loadNominations(rootDir, { pending_only: true }).filter((n) => n.urgency === "critical" || n.urgency === "high");
+    if (urgent.length > 0) {
+      lines.push("");
+      lines.push("Ambient nominations (urgent):");
+      for (const n of urgent.slice(0, 5)) {
+        lines.push(`  [${n.urgency}] ${n.brief}`);
+      }
+      if (urgent.length > 5) {
+        lines.push(`  ... and ${urgent.length - 5} more. Use paradigm_ambient_nominations to see all.`);
+      }
+    }
+  } catch {
+  }
   lines.push("");
   lines.push("IMPORTANT: Present a brief summary of this recovery data to the user, then ask what they would like to do: (1) Continue \u2014 pick up where the last session left off, (2) Discard \u2014 ignore the previous session and start fresh, or (3) let them describe what they want to work on instead. Do NOT automatically continue without asking.");
   lines.push("---");
@@ -3018,10 +3294,10 @@ var ToolCache = class {
 var toolCache = new ToolCache(3e4);
 
 // ../paradigm-mcp/src/utils/aspect-graph.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
-import * as crypto2 from "crypto";
-import { execSync } from "child_process";
+import * as fs6 from "fs";
+import * as path7 from "path";
+import * as crypto3 from "crypto";
+import { execSync as execSync2 } from "child_process";
 import initSqlJs from "sql.js";
 var cachedSQL = null;
 async function getSqlJs() {
@@ -3097,6 +3373,23 @@ var SCHEMA_STATEMENTS = [
     PRIMARY KEY (aspect_id, access_type)
   )`
 ];
+var MIGRATIONS = [
+  `ALTER TABLE anchors ADD COLUMN original_content TEXT`,
+  `CREATE TABLE IF NOT EXISTS anchor_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    anchor_id INTEGER NOT NULL,
+    action TEXT NOT NULL,
+    old_start INTEGER,
+    old_end INTEGER,
+    new_start INTEGER,
+    new_end INTEGER,
+    old_path TEXT,
+    new_path TEXT,
+    confidence REAL,
+    commit_hash TEXT,
+    healed_at TEXT NOT NULL
+  )`
+];
 var FTS_SQL = `CREATE VIRTUAL TABLE IF NOT EXISTS aspects_fts USING fts5(id, description, enforcement, tags)`;
 function queryRows(db, sql, params) {
   const stmt = db.prepare(sql);
@@ -3124,15 +3417,15 @@ function queryOne(db, sql, params) {
 }
 async function openAspectGraph(rootDir) {
   const SQL = await getSqlJs();
-  const dbDir = path6.join(rootDir, ".paradigm");
-  const dbPath = path6.join(dbDir, "aspect-graph.db");
+  const dbDir = path7.join(rootDir, ".paradigm");
+  const dbPath = path7.join(dbDir, "aspect-graph.db");
   let db;
-  if (fs5.existsSync(dbPath)) {
-    const buffer = fs5.readFileSync(dbPath);
+  if (fs6.existsSync(dbPath)) {
+    const buffer = fs6.readFileSync(dbPath);
     db = new SQL.Database(buffer);
   } else {
-    if (!fs5.existsSync(dbDir)) {
-      fs5.mkdirSync(dbDir, { recursive: true });
+    if (!fs6.existsSync(dbDir)) {
+      fs6.mkdirSync(dbDir, { recursive: true });
     }
     db = new SQL.Database();
   }
@@ -3143,17 +3436,23 @@ async function openAspectGraph(rootDir) {
     db.run(FTS_SQL);
   } catch {
   }
+  for (const migration of MIGRATIONS) {
+    try {
+      db.run(migration);
+    } catch {
+    }
+  }
   return db;
 }
 function closeAspectGraph(db, rootDir) {
   if (rootDir) {
-    const dbDir = path6.join(rootDir, ".paradigm");
-    if (!fs5.existsSync(dbDir)) {
-      fs5.mkdirSync(dbDir, { recursive: true });
+    const dbDir = path7.join(rootDir, ".paradigm");
+    if (!fs6.existsSync(dbDir)) {
+      fs6.mkdirSync(dbDir, { recursive: true });
     }
-    const dbPath = path6.join(dbDir, "aspect-graph.db");
+    const dbPath = path7.join(dbDir, "aspect-graph.db");
     const data = db.export();
-    fs5.writeFileSync(dbPath, Buffer.from(data));
+    fs6.writeFileSync(dbPath, Buffer.from(data));
   }
   db.close();
 }
@@ -3162,7 +3461,7 @@ function materializeAspects(db, symbols, rootDir) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let headCommit = null;
   try {
-    headCommit = execSync("git rev-parse HEAD", { cwd: rootDir, encoding: "utf8" }).trim();
+    headCommit = execSync2("git rev-parse HEAD", { cwd: rootDir, encoding: "utf8" }).trim();
   } catch {
   }
   db.run("DELETE FROM anchors");
@@ -3200,9 +3499,9 @@ function materializeAspects(db, symbols, rootDir) {
         const { startLine, endLine } = resolveAnchorLines(anchor);
         const hashes = computeAnchorHash(anchor, null);
         db.run(
-          `INSERT INTO anchors (aspect_id, file_path, start_line, end_line, content_hash, normalized_hash, materialized_at_commit, last_verified)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-          [entry.symbol, anchor.path, startLine, endLine, hashes.exact, hashes.normalized, headCommit, now]
+          `INSERT INTO anchors (aspect_id, file_path, start_line, end_line, content_hash, normalized_hash, materialized_at_commit, last_verified, original_content)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [entry.symbol, anchor.path, startLine, endLine, hashes.exact, hashes.normalized, headCommit, now, hashes.normalizedContent]
         );
       }
     }
@@ -3289,8 +3588,8 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
   const anchorRows = aspectId ? queryRows(db, "SELECT * FROM anchors WHERE aspect_id = ?", [aspectId]) : queryRows(db, "SELECT * FROM anchors");
   const results = [];
   for (const anchor of anchorRows) {
-    const absolutePath = path6.isAbsolute(anchor.file_path) ? anchor.file_path : path6.join(rootDir, anchor.file_path);
-    if (!fs5.existsSync(absolutePath)) {
+    const absolutePath = path7.isAbsolute(anchor.file_path) ? anchor.file_path : path7.join(rootDir, anchor.file_path);
+    if (!fs6.existsSync(absolutePath)) {
       results.push({
         aspectId: anchor.aspect_id,
         path: anchor.file_path,
@@ -3304,12 +3603,12 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
       continue;
     }
     try {
-      const fileContent = fs5.readFileSync(absolutePath, "utf8");
+      const fileContent = fs6.readFileSync(absolutePath, "utf8");
       const lines = fileContent.split("\n");
       const startIdx = Math.max(0, anchor.start_line - 1);
       const endIdx = Math.min(lines.length, anchor.end_line);
       const sliceContent = lines.slice(startIdx, endIdx).join("\n");
-      const currentExactHash = crypto2.createHash("sha256").update(sliceContent).digest("hex");
+      const currentExactHash = crypto3.createHash("sha256").update(sliceContent).digest("hex");
       if (anchor.content_hash != null && currentExactHash === anchor.content_hash) {
         results.push({
           aspectId: anchor.aspect_id,
@@ -3326,7 +3625,7 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
         }
         continue;
       }
-      const currentNormalizedHash = crypto2.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+      const currentNormalizedHash = crypto3.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
       if (anchor.normalized_hash != null && currentNormalizedHash === anchor.normalized_hash) {
         db.run("UPDATE anchors SET content_hash = ?, drifted = 0 WHERE id = ?", [currentExactHash, anchor.id]);
         results.push({
@@ -3371,7 +3670,7 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
           const shiftedStartIdx = Math.max(0, mapping.currentStart - 1);
           const shiftedEndIdx = Math.min(lines.length, mapping.currentEnd);
           const shiftedContent = lines.slice(shiftedStartIdx, shiftedEndIdx).join("\n");
-          const shiftedExactHash = crypto2.createHash("sha256").update(shiftedContent).digest("hex");
+          const shiftedExactHash = crypto3.createHash("sha256").update(shiftedContent).digest("hex");
           if (anchor.content_hash != null && shiftedExactHash === anchor.content_hash) {
             const healed = autoHeal;
             if (healed) {
@@ -3411,10 +3710,10 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
             });
             resolvedByGit = true;
           } else {
-            const shiftedNormalized = crypto2.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
+            const shiftedNormalized = crypto3.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
             if (anchor.normalized_hash != null && shiftedNormalized === anchor.normalized_hash) {
               if (autoHeal) {
-                const shiftedNewHash = crypto2.createHash("sha256").update(shiftedContent).digest("hex");
+                const shiftedNewHash = crypto3.createHash("sha256").update(shiftedContent).digest("hex");
                 db.run(
                   "UPDATE anchors SET start_line = ?, end_line = ?, content_hash = ?, drifted = 0 WHERE id = ?",
                   [mapping.currentStart, mapping.currentEnd, shiftedNewHash, anchor.id]
@@ -3455,6 +3754,73 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
         }
       }
       if (resolvedByGit) continue;
+      if (anchor.original_content) {
+        const { contentSearch: contentSearch2 } = (init_aspect_fingerprint(), __toCommonJS(aspect_fingerprint_exports));
+        const searchResult = contentSearch2(rootDir, anchor.file_path, anchor.original_content, autoHeal);
+        if (searchResult.found && searchResult.score >= 0.7) {
+          const isAutoHeal = autoHeal && searchResult.score >= 0.85 && !searchResult.suggestedPath;
+          if (isAutoHeal && searchResult.suggestedStart && searchResult.suggestedEnd) {
+            db.run(
+              "UPDATE anchors SET start_line = ?, end_line = ?, drifted = 0 WHERE id = ?",
+              [searchResult.suggestedStart, searchResult.suggestedEnd, anchor.id]
+            );
+            try {
+              db.run(
+                `INSERT INTO anchor_history (anchor_id, action, old_start, old_end, new_start, new_end, confidence, healed_at)
+                 VALUES (?, 'relocated', ?, ?, ?, ?, ?, ?)`,
+                [anchor.id, anchor.start_line, anchor.end_line, searchResult.suggestedStart, searchResult.suggestedEnd, searchResult.score, (/* @__PURE__ */ new Date()).toISOString()]
+              );
+            } catch {
+            }
+            const aspectRow = queryRows(
+              db,
+              "SELECT defined_in FROM aspects WHERE id = ?",
+              [anchor.aspect_id]
+            );
+            if (aspectRow.length > 0) {
+              healAnchorInPurposeFile(
+                rootDir,
+                aspectRow[0].defined_in,
+                anchor.file_path,
+                anchor.start_line,
+                anchor.end_line,
+                searchResult.suggestedStart,
+                searchResult.suggestedEnd
+              );
+            }
+            results.push({
+              aspectId: anchor.aspect_id,
+              path: anchor.file_path,
+              startLine: searchResult.suggestedStart,
+              endLine: searchResult.suggestedEnd,
+              status: "relocated",
+              resolvedBy: "content-search",
+              exists: true,
+              similarity: searchResult.similarity,
+              suggestedStart: searchResult.suggestedStart,
+              suggestedEnd: searchResult.suggestedEnd,
+              autoHealed: true,
+              drifted: false
+            });
+            continue;
+          }
+          results.push({
+            aspectId: anchor.aspect_id,
+            path: searchResult.suggestedPath || anchor.file_path,
+            startLine: anchor.start_line,
+            endLine: anchor.end_line,
+            status: "relocated",
+            resolvedBy: "content-search",
+            exists: true,
+            similarity: searchResult.similarity,
+            suggestedStart: searchResult.suggestedStart,
+            suggestedEnd: searchResult.suggestedEnd,
+            autoHealed: false,
+            drifted: true
+          });
+          continue;
+        }
+      }
       db.run("UPDATE anchors SET drifted = 1 WHERE id = ?", [anchor.id]);
       results.push({
         aspectId: anchor.aspect_id,
@@ -3515,7 +3881,7 @@ function parseUnifiedDiffHunks(diffOutput) {
 function computeLineShift(rootDir, filePath, fromCommit, originalStart, originalEnd) {
   let diff;
   try {
-    diff = execSync(
+    diff = execSync2(
       `git diff ${fromCommit}..HEAD --unified=0 -- "${filePath}"`,
       { cwd: rootDir, encoding: "utf8", timeout: 5e3 }
     );
@@ -3547,15 +3913,15 @@ function computeLineShift(rootDir, filePath, fromCommit, originalStart, original
   };
 }
 function healAnchorInPurposeFile(rootDir, purposeFilePath, anchorFilePath, oldStart, oldEnd, newStart, newEnd) {
-  const absolutePurpose = path6.isAbsolute(purposeFilePath) ? purposeFilePath : path6.join(rootDir, purposeFilePath);
-  if (!fs5.existsSync(absolutePurpose)) return false;
+  const absolutePurpose = path7.isAbsolute(purposeFilePath) ? purposeFilePath : path7.join(rootDir, purposeFilePath);
+  if (!fs6.existsSync(absolutePurpose)) return false;
   try {
-    const content = fs5.readFileSync(absolutePurpose, "utf8");
+    const content = fs6.readFileSync(absolutePurpose, "utf8");
     const oldAnchor = oldStart === oldEnd ? `${anchorFilePath}:${oldStart}` : `${anchorFilePath}:${oldStart}-${oldEnd}`;
     const newAnchor = newStart === newEnd ? `${anchorFilePath}:${newStart}` : `${anchorFilePath}:${newStart}-${newEnd}`;
     if (!content.includes(oldAnchor)) return false;
     const updated = content.replace(oldAnchor, newAnchor);
-    fs5.writeFileSync(absolutePurpose, updated, "utf8");
+    fs6.writeFileSync(absolutePurpose, updated, "utf8");
     return true;
   } catch {
     return false;
@@ -3565,21 +3931,22 @@ function normalizeForHash(content) {
   return content.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "").map((line) => line.replace(/\s+/g, " ")).join("\n");
 }
 function computeAnchorHash(anchor, rootDir) {
-  if (!rootDir) return { exact: null, normalized: null };
-  const absolutePath = path6.isAbsolute(anchor.path) ? anchor.path : path6.join(rootDir, anchor.path);
-  if (!fs5.existsSync(absolutePath)) return { exact: null, normalized: null };
+  if (!rootDir) return { exact: null, normalized: null, normalizedContent: null };
+  const absolutePath = path7.isAbsolute(anchor.path) ? anchor.path : path7.join(rootDir, anchor.path);
+  if (!fs6.existsSync(absolutePath)) return { exact: null, normalized: null, normalizedContent: null };
   try {
-    const fileContent = fs5.readFileSync(absolutePath, "utf8");
+    const fileContent = fs6.readFileSync(absolutePath, "utf8");
     const lines = fileContent.split("\n");
     const { startLine, endLine } = resolveAnchorLines(anchor);
     const startIdx = Math.max(0, startLine - 1);
     const endIdx = Math.min(lines.length, endLine);
     const sliceContent = lines.slice(startIdx, endIdx).join("\n");
-    const exact = crypto2.createHash("sha256").update(sliceContent).digest("hex");
-    const normalized = crypto2.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
-    return { exact, normalized };
+    const normalizedContent = normalizeForHash(sliceContent);
+    const exact = crypto3.createHash("sha256").update(sliceContent).digest("hex");
+    const normalized = crypto3.createHash("sha256").update(normalizedContent).digest("hex");
+    return { exact, normalized, normalizedContent };
   } catch {
-    return { exact: null, normalized: null };
+    return { exact: null, normalized: null, normalizedContent: null };
   }
 }
 function inferCategory(data, entry) {
@@ -3600,6 +3967,7 @@ function inferSeverity(data, entry) {
 }
 
 // ../paradigm-mcp/src/utils/aspect-lore-bridge.ts
+init_lore_loader();
 var LORE_ID_PATTERN = /L-\d{4}-\d{2}-\d{2}-\d{3}/g;
 async function materializeLoreLinks(db, rootDir) {
   db.run("DELETE FROM lore_links");
@@ -3795,19 +4163,19 @@ function toLoreSummary(entry) {
 }
 
 // ../paradigm-mcp/src/utils/personas-loader.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 import * as yaml5 from "js-yaml";
 var PERSONAS_ROOT = ".paradigm/personas";
 var INDEX_FILE = "index.yaml";
 async function loadPersonas(rootDir, filter) {
-  const personasDir = path7.join(rootDir, PERSONAS_ROOT);
-  if (!fs6.existsSync(personasDir)) return [];
-  const files = fs6.readdirSync(personasDir).filter((f) => f.endsWith(".persona"));
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  if (!fs7.existsSync(personasDir)) return [];
+  const files = fs7.readdirSync(personasDir).filter((f) => f.endsWith(".persona"));
   const personas = [];
   for (const file of files) {
     try {
-      const content = fs6.readFileSync(path7.join(personasDir, file), "utf8");
+      const content = fs7.readFileSync(path8.join(personasDir, file), "utf8");
       const persona = yaml5.load(content);
       if (persona && persona.id) {
         personas.push(persona);
@@ -3818,10 +4186,10 @@ async function loadPersonas(rootDir, filter) {
   return applyFilter(personas, filter);
 }
 async function loadPersona(rootDir, id) {
-  const filePath = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
-  if (!fs6.existsSync(filePath)) return null;
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs7.existsSync(filePath)) return null;
   try {
-    return yaml5.load(fs6.readFileSync(filePath, "utf8"));
+    return yaml5.load(fs7.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -3851,10 +4219,10 @@ function applyFilter(personas, filter) {
   return result;
 }
 async function createPersona(rootDir, data) {
-  const personasDir = path7.join(rootDir, PERSONAS_ROOT);
-  fs6.mkdirSync(personasDir, { recursive: true });
-  const filePath = path7.join(personasDir, `${data.id}.persona`);
-  if (fs6.existsSync(filePath)) {
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  fs7.mkdirSync(personasDir, { recursive: true });
+  const filePath = path8.join(personasDir, `${data.id}.persona`);
+  if (fs7.existsSync(filePath)) {
     throw new Error(`Persona ${data.id} already exists`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3871,14 +4239,14 @@ async function createPersona(rootDir, data) {
     created: now,
     updated: now
   };
-  fs6.writeFileSync(filePath, yaml5.dump(persona, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs7.writeFileSync(filePath, yaml5.dump(persona, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
   await rebuildPersonaIndex(rootDir);
   return data.id;
 }
 async function updatePersona(rootDir, id, partial) {
   const persona = await loadPersona(rootDir, id);
   if (!persona) return false;
-  const filePath = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
   const updated = {
     ...persona,
     ...partial,
@@ -3890,13 +4258,13 @@ async function updatePersona(rootDir, id, partial) {
     // immutable
     updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs6.writeFileSync(filePath, yaml5.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs7.writeFileSync(filePath, yaml5.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
   await rebuildPersonaIndex(rootDir);
   return true;
 }
 async function deletePersona(rootDir, id) {
-  const filePath = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
-  if (!fs6.existsSync(filePath)) {
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs7.existsSync(filePath)) {
     return { deleted: false, warnings: [] };
   }
   const warnings = [];
@@ -3912,7 +4280,7 @@ async function deletePersona(rootDir, id) {
       }
     }
   }
-  fs6.unlinkSync(filePath);
+  fs7.unlinkSync(filePath);
   await rebuildPersonaIndex(rootDir);
   return { deleted: true, warnings };
 }
@@ -4014,12 +4382,12 @@ async function validatePersona(rootDir, persona, deep = false) {
     }
   }
   if (deep) {
-    const portalPath = path7.join(rootDir, "portal.yaml");
+    const portalPath = path8.join(rootDir, "portal.yaml");
     let portalGates = [];
     let portalRoutes = [];
-    if (fs6.existsSync(portalPath)) {
+    if (fs7.existsSync(portalPath)) {
       try {
-        const portal = yaml5.load(fs6.readFileSync(portalPath, "utf8"));
+        const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
         if (portal.gates && typeof portal.gates === "object") {
           portalGates = Object.keys(portal.gates);
         }
@@ -4070,10 +4438,10 @@ async function validatePersona(rootDir, persona, deep = false) {
         }
       }
       let allFlows = [];
-      const flowIndexPath = path7.join(rootDir, ".paradigm", "flow-index.json");
-      if (fs6.existsSync(flowIndexPath)) {
+      const flowIndexPath = path8.join(rootDir, ".paradigm", "flow-index.json");
+      if (fs7.existsSync(flowIndexPath)) {
         try {
-          const flowIndex = JSON.parse(fs6.readFileSync(flowIndexPath, "utf8"));
+          const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
           allFlows = Object.keys(flowIndex.flows || {});
         } catch {
         }
@@ -4150,8 +4518,8 @@ async function detectSpawnCycle(rootDir, startId) {
   return visit(startId);
 }
 async function rebuildPersonaIndex(rootDir) {
-  const personasDir = path7.join(rootDir, PERSONAS_ROOT);
-  fs6.mkdirSync(personasDir, { recursive: true });
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  fs7.mkdirSync(personasDir, { recursive: true });
   const personas = await loadPersonas(rootDir);
   const entries = {};
   const gateCoverage = {};
@@ -4190,10 +4558,10 @@ async function rebuildPersonaIndex(rootDir) {
     }
   }
   let uncoveredRoutes = [];
-  const portalPath = path7.join(rootDir, "portal.yaml");
-  if (fs6.existsSync(portalPath)) {
+  const portalPath = path8.join(rootDir, "portal.yaml");
+  if (fs7.existsSync(portalPath)) {
     try {
-      const portal = yaml5.load(fs6.readFileSync(portalPath, "utf8"));
+      const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
       if (portal.routes && typeof portal.routes === "object") {
         const portalRoutes = Object.keys(portal.routes);
         uncoveredRoutes = portalRoutes.filter((pr) => {
@@ -4204,12 +4572,12 @@ async function rebuildPersonaIndex(rootDir) {
     }
   }
   const chains = {};
-  const chainsDir = path7.join(personasDir, "chains");
-  if (fs6.existsSync(chainsDir)) {
-    const chainFiles = fs6.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
+  const chainsDir = path8.join(personasDir, "chains");
+  if (fs7.existsSync(chainsDir)) {
+    const chainFiles = fs7.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
     for (const file of chainFiles) {
       try {
-        const content = fs6.readFileSync(path7.join(chainsDir, file), "utf8");
+        const content = fs7.readFileSync(path8.join(chainsDir, file), "utf8");
         const chain = yaml5.load(content);
         if (chain && chain.id) {
           const orderIds = chain.order.map((o) => o.persona);
@@ -4242,8 +4610,8 @@ async function rebuildPersonaIndex(rootDir) {
     route_coverage: routeCoverage,
     uncovered_routes: uncoveredRoutes
   };
-  fs6.writeFileSync(
-    path7.join(personasDir, INDEX_FILE),
+  fs7.writeFileSync(
+    path8.join(personasDir, INDEX_FILE),
     yaml5.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
   );
   return index;
@@ -4262,20 +4630,20 @@ async function getPersonaCoverage(rootDir) {
   }
   let portalGates = [];
   let portalRoutes = [];
-  const portalPath = path7.join(rootDir, "portal.yaml");
-  if (fs6.existsSync(portalPath)) {
+  const portalPath = path8.join(rootDir, "portal.yaml");
+  if (fs7.existsSync(portalPath)) {
     try {
-      const portal = yaml5.load(fs6.readFileSync(portalPath, "utf8"));
+      const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
       if (portal.gates && typeof portal.gates === "object") portalGates = Object.keys(portal.gates);
       if (portal.routes && typeof portal.routes === "object") portalRoutes = Object.keys(portal.routes);
     } catch {
     }
   }
   let allFlows = [];
-  const flowIndexPath = path7.join(rootDir, ".paradigm", "flow-index.json");
-  if (fs6.existsSync(flowIndexPath)) {
+  const flowIndexPath = path8.join(rootDir, ".paradigm", "flow-index.json");
+  if (fs7.existsSync(flowIndexPath)) {
     try {
-      const flowIndex = JSON.parse(fs6.readFileSync(flowIndexPath, "utf8"));
+      const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
       allFlows = Object.keys(flowIndex.flows || {});
     } catch {
     }
@@ -4324,8 +4692,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path11) {
-  const parts = path11.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path12) {
+  const parts = path12.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -4405,7 +4773,7 @@ function assertStep(step, event) {
 async function validateAgainstSentinel(persona, options = {}) {
   const steps = [];
   try {
-    const { SentinelStorage } = await import("./dist-CM3MVWWW.js");
+    const { SentinelStorage } = await import("./dist-77JDTVAY.js");
     const storage = new SentinelStorage();
     const events = storage.queryEvents?.({
       schemaId: "paradigm-personas",
@@ -4494,21 +4862,21 @@ async function validateAgainstSentinel(persona, options = {}) {
 }
 
 // ../paradigm-mcp/src/utils/protocol-loader.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 import * as yaml6 from "js-yaml";
 var PROTOCOLS_DIR = ".paradigm/protocols";
 var INDEX_FILE2 = "index.yaml";
 async function loadProtocols(rootDir) {
-  const protocolsDir = path8.join(rootDir, PROTOCOLS_DIR);
-  if (!fs7.existsSync(protocolsDir)) {
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (!fs8.existsSync(protocolsDir)) {
     return [];
   }
-  const files = fs7.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
+  const files = fs8.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
   const protocols = [];
   for (const file of files) {
     try {
-      const content = fs7.readFileSync(path8.join(protocolsDir, file), "utf8");
+      const content = fs8.readFileSync(path9.join(protocolsDir, file), "utf8");
       const protocol = yaml6.load(content);
       if (protocol?.id && protocol?.name) {
         protocols.push(protocol);
@@ -4520,10 +4888,10 @@ async function loadProtocols(rootDir) {
 }
 async function loadProtocol(rootDir, id) {
   const slug = id.replace(/^P-/, "");
-  const filePath = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-  if (fs7.existsSync(filePath)) {
+  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  if (fs8.existsSync(filePath)) {
     try {
-      const content = fs7.readFileSync(filePath, "utf8");
+      const content = fs8.readFileSync(filePath, "utf8");
       return yaml6.load(content);
     } catch {
       return null;
@@ -4533,12 +4901,12 @@ async function loadProtocol(rootDir, id) {
   return protocols.find((p) => p.id === id) || null;
 }
 async function loadProtocolIndex(rootDir) {
-  const indexPath = path8.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
-  if (!fs7.existsSync(indexPath)) {
+  const indexPath = path9.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
+  if (!fs8.existsSync(indexPath)) {
     return null;
   }
   try {
-    const content = fs7.readFileSync(indexPath, "utf8");
+    const content = fs8.readFileSync(indexPath, "utf8");
     return yaml6.load(content);
   } catch {
     return null;
@@ -4590,9 +4958,9 @@ async function searchProtocols(rootDir, task, limit = 3) {
   return scored.slice(0, limit);
 }
 async function recordProtocol(rootDir, protocol) {
-  const protocolsDir = path8.join(rootDir, PROTOCOLS_DIR);
-  if (!fs7.existsSync(protocolsDir)) {
-    fs7.mkdirSync(protocolsDir, { recursive: true });
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (!fs8.existsSync(protocolsDir)) {
+    fs8.mkdirSync(protocolsDir, { recursive: true });
   }
   const slug = slugify(protocol.name);
   const id = `P-${slug}`;
@@ -4612,8 +4980,8 @@ async function recordProtocol(rootDir, protocol) {
     verified_by: protocol.verified_by || "claude-opus-4-6",
     status: "current"
   };
-  const filePath = path8.join(protocolsDir, `${slug}.protocol`);
-  fs7.writeFileSync(filePath, yaml6.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path9.join(protocolsDir, `${slug}.protocol`);
+  fs8.writeFileSync(filePath, yaml6.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
   return id;
 }
 async function updateProtocol(rootDir, id, partial, refresh = false) {
@@ -4633,20 +5001,20 @@ async function updateProtocol(rootDir, id, partial, refresh = false) {
     protocol.verified_by = partial.verified_by || "claude-opus-4-6";
   }
   const slug = id.replace(/^P-/, "");
-  const filePath = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-  fs7.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  fs8.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
   return true;
 }
 function validateProtocol(rootDir, protocol) {
   const issues = [];
   let status = "current";
   if (protocol.exemplar) {
-    const exemplarPath = path8.join(rootDir, protocol.exemplar);
-    if (!fs7.existsSync(exemplarPath)) {
+    const exemplarPath = path9.join(rootDir, protocol.exemplar);
+    if (!fs8.existsSync(exemplarPath)) {
       issues.push(`Exemplar missing: ${protocol.exemplar}`);
       status = "broken";
     } else {
-      const stat = fs7.statSync(exemplarPath);
+      const stat = fs8.statSync(exemplarPath);
       if (stat.mtime.toISOString() > protocol.last_verified) {
         issues.push(`Exemplar modified since last verified: ${protocol.exemplar}`);
         if (status !== "broken") status = "stale";
@@ -4655,15 +5023,15 @@ function validateProtocol(rootDir, protocol) {
   }
   for (const step of protocol.steps) {
     if (step.template_from) {
-      const templatePath = path8.join(rootDir, step.template_from);
-      if (!fs7.existsSync(templatePath)) {
+      const templatePath = path9.join(rootDir, step.template_from);
+      if (!fs8.existsSync(templatePath)) {
         issues.push(`Template file missing: ${step.template_from}`);
         status = "broken";
       }
     }
     if (step.action === "modify" && step.target) {
-      const targetPath = path8.join(rootDir, step.target);
-      if (!step.target.includes("{") && !fs7.existsSync(targetPath)) {
+      const targetPath = path9.join(rootDir, step.target);
+      if (!step.target.includes("{") && !fs8.existsSync(targetPath)) {
         issues.push(`Modify target missing: ${step.target}`);
         status = "broken";
       }
@@ -4682,9 +5050,9 @@ async function rebuildProtocolIndex(rootDir) {
     if (protocol.status !== validation.status) {
       protocol.status = validation.status;
       const slug = protocol.id.replace(/^P-/, "");
-      const filePath = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-      if (fs7.existsSync(filePath)) {
-        fs7.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+      const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+      if (fs8.existsSync(filePath)) {
+        fs8.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
       }
     }
     switch (validation.status) {
@@ -4718,13 +5086,13 @@ async function rebuildProtocolIndex(rootDir) {
       broken
     }
   };
-  const protocolsDir = path8.join(rootDir, PROTOCOLS_DIR);
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
   if (protocols.length > 0) {
-    if (!fs7.existsSync(protocolsDir)) {
-      fs7.mkdirSync(protocolsDir, { recursive: true });
+    if (!fs8.existsSync(protocolsDir)) {
+      fs8.mkdirSync(protocolsDir, { recursive: true });
     }
-    const indexPath = path8.join(protocolsDir, INDEX_FILE2);
-    fs7.writeFileSync(indexPath, yaml6.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+    const indexPath = path9.join(protocolsDir, INDEX_FILE2);
+    fs8.writeFileSync(indexPath, yaml6.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
   }
   return index;
 }
@@ -4732,21 +5100,21 @@ function detectProtocolSuggestion(rootDir, filesCreated, filesModified) {
   if (!filesCreated || filesCreated.length < 2) return null;
   const dirGroups = {};
   for (const file of filesCreated) {
-    const dir = path8.dirname(file);
+    const dir = path9.dirname(file);
     if (!dirGroups[dir]) dirGroups[dir] = [];
     dirGroups[dir].push(file);
   }
   for (const [dir, created] of Object.entries(dirGroups)) {
     if (created.length < 2) continue;
-    const absDir = path8.join(rootDir, dir);
-    if (!fs7.existsSync(absDir)) continue;
-    const existing = fs7.readdirSync(absDir).filter((f) => {
-      const ext = path8.extname(f);
+    const absDir = path9.join(rootDir, dir);
+    if (!fs8.existsSync(absDir)) continue;
+    const existing = fs8.readdirSync(absDir).filter((f) => {
+      const ext = path9.extname(f);
       return [".ts", ".tsx", ".js", ".jsx", ".rs", ".py"].includes(ext);
     });
-    const preExisting = existing.filter((f) => !created.some((c) => path8.basename(c) === f));
+    const preExisting = existing.filter((f) => !created.some((c) => path9.basename(c) === f));
     if (preExisting.length > 0) {
-      const exemplar = path8.join(dir, preExisting[0]);
+      const exemplar = path9.join(dir, preExisting[0]);
       const steps = [
         ...created.map((f) => ({ action: "create", target: f })),
         ...filesModified.map((f) => ({ action: "modify", target: f }))
@@ -4754,7 +5122,7 @@ function detectProtocolSuggestion(rootDir, filesCreated, filesModified) {
       return {
         hint: `This session created ${created.length} new files in ${dir}/ following existing patterns. Consider recording a protocol.`,
         draft: {
-          name: `Add a ${path8.basename(dir).replace(/s$/, "")}`,
+          name: `Add a ${path9.basename(dir).replace(/s$/, "")}`,
           exemplar,
           steps
         }
@@ -4829,8 +5197,8 @@ function slugify(name) {
 }
 
 // ../paradigm-mcp/src/utils/university-loader.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 import * as yaml7 from "js-yaml";
 var UNIVERSITY_DIR = ".paradigm/university";
 var CONTENT_DIR = "content";
@@ -4872,12 +5240,12 @@ var DEFAULT_CONFIG = {
   }
 };
 function loadUniversityConfig(rootDir) {
-  const configPath = path9.join(rootDir, UNIVERSITY_DIR, CONFIG_FILE);
-  if (!fs8.existsSync(configPath)) {
+  const configPath = path10.join(rootDir, UNIVERSITY_DIR, CONFIG_FILE);
+  if (!fs9.existsSync(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const raw = fs8.readFileSync(configPath, "utf8");
+    const raw = fs9.readFileSync(configPath, "utf8");
     const data = yaml7.load(raw);
     if (!data) return { ...DEFAULT_CONFIG };
     return {
@@ -4886,7 +5254,8 @@ function loadUniversityConfig(rootDir) {
       content: {
         categories: data.content?.categories || [],
         defaultDifficulty: data.content?.defaultDifficulty || "beginner",
-        requireApproval: data.content?.requireApproval ?? false
+        requireApproval: data.content?.requireApproval ?? false,
+        defaultCategory: data.content?.defaultCategory
       },
       diplomas: {
         includeGlobalPLSAT: data.diplomas?.includeGlobalPLSAT ?? true,
@@ -4898,10 +5267,10 @@ function loadUniversityConfig(rootDir) {
   }
 }
 function loadUniversityIndex(rootDir) {
-  const indexPath = path9.join(rootDir, UNIVERSITY_DIR, INDEX_FILE3);
-  if (!fs8.existsSync(indexPath)) return null;
+  const indexPath = path10.join(rootDir, UNIVERSITY_DIR, INDEX_FILE3);
+  if (!fs9.existsSync(indexPath)) return null;
   try {
-    const raw = fs8.readFileSync(indexPath, "utf8");
+    const raw = fs9.readFileSync(indexPath, "utf8");
     return yaml7.load(raw);
   } catch {
     return null;
@@ -4929,7 +5298,7 @@ function loadNote(rootDir, id) {
   const filePath = resolveContentFile(rootDir, id, ".md");
   if (!filePath) return null;
   try {
-    const raw = fs8.readFileSync(filePath, "utf8");
+    const raw = fs9.readFileSync(filePath, "utf8");
     const parsed = parseFrontmatter(raw);
     if (!parsed) return null;
     const fm = parsed.frontmatter;
@@ -4940,18 +5309,18 @@ function loadNote(rootDir, id) {
 }
 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 dir = path10.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
+  fs9.mkdirSync(dir, { recursive: true });
+  const filePath = path10.join(dir, `${frontmatter.id}.md`);
   const content = serializeFrontmatter(frontmatter, body);
-  fs8.writeFileSync(filePath, content, "utf8");
+  fs9.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 raw = fs9.readFileSync(filePath, "utf8");
     const data = yaml7.load(raw);
     if (!data || !data.id) return null;
     return normalizeQuiz(data);
@@ -4960,17 +5329,17 @@ function loadQuiz(rootDir, id) {
   }
 }
 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");
+  const dir = path10.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, QUIZZES_DIR);
+  fs9.mkdirSync(dir, { recursive: true });
+  const filePath = path10.join(dir, `${quiz.id}.yaml`);
+  fs9.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 raw = fs9.readFileSync(filePath, "utf8");
     const data = yaml7.load(raw);
     if (!data || !data.id) return null;
     return data;
@@ -4979,21 +5348,21 @@ function loadPath(rootDir, id) {
   }
 }
 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");
+  const dir = path10.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, PATHS_DIR);
+  fs9.mkdirSync(dir, { recursive: true });
+  const filePath = path10.join(dir, `${lp.id}.yaml`);
+  fs9.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 dir = path10.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  if (!fs9.existsSync(dir)) return [];
   const results = [];
   try {
-    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+    const files = fs9.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
     for (const file of files) {
       try {
-        const raw = fs8.readFileSync(path9.join(dir, file), "utf8");
+        const raw = fs9.readFileSync(path10.join(dir, file), "utf8");
         const diploma = yaml7.load(raw);
         if (!diploma || !diploma.id) continue;
         if (filter?.student && diploma.student !== filter.student) continue;
@@ -5007,10 +5376,10 @@ function loadDiplomas(rootDir, filter) {
   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");
+  const dir = path10.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  fs9.mkdirSync(dir, { recursive: true });
+  const filePath = path10.join(dir, `${diploma.id}.yaml`);
+  fs9.writeFileSync(filePath, yaml7.dump(diploma, { lineWidth: -1, noRefs: true }), "utf8");
   return filePath;
 }
 function searchContent(rootDir, filter) {
@@ -5038,20 +5407,34 @@ function searchContent(rootDir, filter) {
       (e) => e.title.toLowerCase().includes(q) || e.id.toLowerCase().includes(q) || e.tags.some((t) => t.toLowerCase().includes(q))
     );
   }
+  if (filter.category) {
+    results = results.filter((e) => e.category === filter.category);
+  }
+  if (filter.track) {
+    const config = loadUniversityConfig(rootDir);
+    const categoryTrackMap = /* @__PURE__ */ new Map();
+    for (const cat of config.content.categories) {
+      categoryTrackMap.set(cat.id, cat.track || "core");
+    }
+    results = results.filter((e) => {
+      const entryTrack = e.category ? categoryTrackMap.get(e.category) || "core" : "core";
+      return entryTrack === filter.track;
+    });
+  }
   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 uniDir = path10.join(rootDir, UNIVERSITY_DIR);
+  const contentDir = path10.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;
+    const dir = path10.join(contentDir, subdir);
+    if (!fs9.existsSync(dir)) continue;
     try {
-      for (const file of fs8.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+      for (const file of fs9.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
         try {
-          const raw = fs8.readFileSync(path9.join(dir, file), "utf8");
+          const raw = fs9.readFileSync(path10.join(dir, file), "utf8");
           const parsed = parseFrontmatter(raw);
           if (!parsed) continue;
           const fm = parsed.frontmatter;
@@ -5065,7 +5448,8 @@ function rebuildUniversityIndex(rootDir) {
             tags: Array.isArray(fm.tags) ? fm.tags : [],
             symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
             difficulty: fm.difficulty || "beginner",
-            file: `${CONTENT_DIR}/${subdir}/${file}`
+            file: `${CONTENT_DIR}/${subdir}/${file}`,
+            ...fm.category ? { category: fm.category } : {}
           });
         } catch {
         }
@@ -5073,12 +5457,12 @@ function rebuildUniversityIndex(rootDir) {
     } catch {
     }
   }
-  const quizDir = path9.join(contentDir, QUIZZES_DIR);
-  if (fs8.existsSync(quizDir)) {
+  const quizDir = path10.join(contentDir, QUIZZES_DIR);
+  if (fs9.existsSync(quizDir)) {
     try {
-      for (const file of fs8.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+      for (const file of fs9.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
         try {
-          const raw = fs8.readFileSync(path9.join(quizDir, file), "utf8");
+          const raw = fs9.readFileSync(path10.join(quizDir, file), "utf8");
           const quiz = yaml7.load(raw);
           if (!quiz || !quiz.id) continue;
           entries.push({
@@ -5091,7 +5475,8 @@ function rebuildUniversityIndex(rootDir) {
             tags: quiz.tags || [],
             symbols: quiz.symbols || [],
             difficulty: quiz.difficulty || "beginner",
-            file: `${CONTENT_DIR}/${QUIZZES_DIR}/${file}`
+            file: `${CONTENT_DIR}/${QUIZZES_DIR}/${file}`,
+            ...quiz.category ? { category: quiz.category } : {}
           });
         } catch {
         }
@@ -5099,12 +5484,12 @@ function rebuildUniversityIndex(rootDir) {
     } catch {
     }
   }
-  const pathDir = path9.join(contentDir, PATHS_DIR);
-  if (fs8.existsSync(pathDir)) {
+  const pathDir = path10.join(contentDir, PATHS_DIR);
+  if (fs9.existsSync(pathDir)) {
     try {
-      for (const file of fs8.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+      for (const file of fs9.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
         try {
-          const raw = fs8.readFileSync(path9.join(pathDir, file), "utf8");
+          const raw = fs9.readFileSync(path10.join(pathDir, file), "utf8");
           const lp = yaml7.load(raw);
           if (!lp || !lp.id) continue;
           entries.push({
@@ -5116,7 +5501,8 @@ function rebuildUniversityIndex(rootDir) {
             updated: lp.updated || "",
             tags: lp.tags || [],
             symbols: [],
-            file: `${CONTENT_DIR}/${PATHS_DIR}/${file}`
+            file: `${CONTENT_DIR}/${PATHS_DIR}/${file}`,
+            ...lp.category ? { category: lp.category } : {}
           });
         } catch {
         }
@@ -5125,10 +5511,10 @@ function rebuildUniversityIndex(rootDir) {
     }
   }
   let diplomaCount = 0;
-  const diplomaDir = path9.join(uniDir, DIPLOMAS_DIR);
-  if (fs8.existsSync(diplomaDir)) {
+  const diplomaDir = path10.join(uniDir, DIPLOMAS_DIR);
+  if (fs9.existsSync(diplomaDir)) {
     try {
-      diplomaCount = fs8.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
+      diplomaCount = fs9.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
     } catch {
     }
   }
@@ -5139,9 +5525,9 @@ function rebuildUniversityIndex(rootDir) {
     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");
+  fs9.mkdirSync(uniDir, { recursive: true });
+  const indexPath = path10.join(uniDir, INDEX_FILE3);
+  fs9.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
   return index;
 }
 function validateUniversityContent(rootDir, options) {
@@ -5173,11 +5559,14 @@ function validateUniversityContent(rootDir, options) {
       validatePathContent(rootDir, entry.id, allContentIds, issues);
     }
     if (knownSymbols && entry.symbols.length > 0) {
+      const config = loadUniversityConfig(rootDir);
+      const entryCat = config.content.categories.find((c) => c.id === entry.category);
+      const isRelaxed = entryCat?.validationStrictness === "relaxed";
       for (const sym of entry.symbols) {
         if (!knownSymbols.has(sym)) {
           issues.push({
             contentId: entry.id,
-            severity: "warning",
+            severity: isRelaxed ? "warning" : "warning",
             check: "broken-symbol-ref",
             message: `Symbol "${sym}" not found in scan-index`,
             fix: `Remove or update the symbol reference in ${entry.id}`
@@ -5297,9 +5686,18 @@ function getAffectedUniversityContent(rootDir, symbol) {
 function getOnboardingSequence(rootDir, student) {
   const index = loadUniversityIndex(rootDir);
   if (!index) {
-    return { paths: [], suggestedContent: [], diplomaCount: 0, totalContent: 0 };
+    return { paths: [], suggestedContent: [], extracurricular: [], diplomaCount: 0, totalContent: 0 };
+  }
+  const config = loadUniversityConfig(rootDir);
+  const excludedCategories = /* @__PURE__ */ new Set();
+  for (const cat of config.content.categories) {
+    if (cat.excludeFromOnboarding) {
+      excludedCategories.add(cat.id);
+    }
   }
-  const pathEntries = index.entries.filter((e) => e.type === "path");
+  const coreEntries = index.entries.filter((e) => !e.category || !excludedCategories.has(e.category));
+  const extracurricularEntries = index.entries.filter((e) => e.category && excludedCategories.has(e.category));
+  const pathEntries = coreEntries.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) => {
@@ -5311,19 +5709,20 @@ function getOnboardingSequence(rootDir, student) {
       completed: diplomaSourceIds.has(pe.id)
     };
   });
-  const suggestedContent = index.entries.filter((e) => e.type !== "path" && (e.difficulty === "beginner" || e.tags.includes("onboarding"))).slice(0, 10);
+  const suggestedContent = coreEntries.filter((e) => e.type !== "path" && (e.difficulty === "beginner" || e.tags.includes("onboarding"))).slice(0, 10);
   return {
     paths,
     suggestedContent,
+    extracurricular: extracurricularEntries,
     diplomaCount: diplomas.length,
     totalContent: index.totalContent
   };
 }
 function resolveContentFile(rootDir, id, ext) {
-  const contentDir = path9.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
+  const contentDir = path10.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;
+    const filePath = path10.join(contentDir, subdir, `${id}${ext}`);
+    if (fs9.existsSync(filePath)) return filePath;
   }
   return null;
 }
@@ -5339,7 +5738,8 @@ function normalizeFrontmatter(fm) {
     symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
     difficulty: fm.difficulty || "beginner",
     estimatedMinutes: fm.estimatedMinutes,
-    prerequisites: Array.isArray(fm.prerequisites) ? fm.prerequisites : []
+    prerequisites: Array.isArray(fm.prerequisites) ? fm.prerequisites : [],
+    ...fm.category ? { category: fm.category } : {}
   };
 }
 function normalizeQuiz(quiz) {
@@ -5354,10 +5754,10 @@ function normalizeQuiz(quiz) {
 }
 function loadKnownSymbols(rootDir) {
   const symbols = /* @__PURE__ */ new Set();
-  const scanIndexPath = path9.join(rootDir, ".paradigm", "scan-index.json");
-  if (!fs8.existsSync(scanIndexPath)) return symbols;
+  const scanIndexPath = path10.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs9.existsSync(scanIndexPath)) return symbols;
   try {
-    const raw = fs8.readFileSync(scanIndexPath, "utf8");
+    const raw = fs9.readFileSync(scanIndexPath, "utf8");
     const index = JSON.parse(raw);
     if (index.symbols && Array.isArray(index.symbols)) {
       for (const sym of index.symbols) {
@@ -5389,17 +5789,17 @@ 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;
+  const scanIndexPath = path10.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs9.existsSync(scanIndexPath)) return false;
   try {
-    const raw = fs8.readFileSync(scanIndexPath, "utf8");
+    const raw = fs9.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);
+          const purposePath = path10.join(rootDir, sym.filePath);
+          if (fs9.existsSync(purposePath)) {
+            const stat = fs9.statSync(purposePath);
             if (stat.mtime.getTime() > contentUpdated) {
               return true;
             }
@@ -5514,10 +5914,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path10.basename(rootDir);
-  const paradigmDir = path10.join(rootDir, ".paradigm");
-  if (!fs9.existsSync(paradigmDir)) {
-    fs9.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path11.basename(rootDir);
+  const paradigmDir = path11.join(rootDir, ".paradigm");
+  if (!fs10.existsSync(paradigmDir)) {
+    fs10.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -5527,12 +5927,12 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path10.join(paradigmDir, "scan-index.json");
-  fs9.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path11.join(paradigmDir, "scan-index.json");
+  fs10.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path10.join(paradigmDir, "navigator.yaml");
-  fs9.writeFileSync(
+  const navigatorPath = path11.join(paradigmDir, "navigator.yaml");
+  fs10.writeFileSync(
     navigatorPath,
     yaml8.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
@@ -5541,8 +5941,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
-    const flowIndexPath = path10.join(paradigmDir, "flow-index.json");
-    fs9.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path11.join(paradigmDir, "flow-index.json");
+    fs10.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -5585,8 +5985,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   }
   let universityStats;
   try {
-    const uniDir = path10.join(rootDir, ".paradigm", "university");
-    if (fs9.existsSync(uniDir)) {
+    const uniDir = path11.join(rootDir, ".paradigm", "university");
+    if (fs10.existsSync(uniDir)) {
       const uniIndex = rebuildUniversityIndex(rootDir);
       if (uniIndex.totalContent > 0 || uniIndex.diplomaCount > 0) {
         universityStats = {
@@ -5684,7 +6084,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs10.existsSync(path11.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 || "@" };
@@ -5695,7 +6095,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs10.existsSync(path11.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -5711,10 +6111,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path10.join(rootDir, ".gitignore");
-  if (fs9.existsSync(gitignorePath)) {
+  const gitignorePath = path11.join(rootDir, ".gitignore");
+  if (fs10.existsSync(gitignorePath)) {
     try {
-      const content = fs9.readFileSync(gitignorePath, "utf8");
+      const content = fs10.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);
@@ -5763,11 +6163,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path10.dirname(pf);
+        const dir = path11.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path10.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path11.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -5778,7 +6178,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs9.readFileSync(filePath, "utf8");
+      const content = fs10.readFileSync(filePath, "utf8");
       const data = yaml8.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
@@ -5792,7 +6192,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path10.relative(rootDir, filePath)
+              definedIn: path11.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -5808,7 +6208,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path10.relative(rootDir, filePath)
+              definedIn: path11.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }