@a-company/paradigm 5.9.0 → 5.10.0

package/dist/{chunk-3UCH56D5.js → chunk-4BLYIB7J.js}

@@ -4,15 +4,18 @@ import {
   checkIntegrity,
   checkPurposeHealth
 } from "./chunk-L27I3CPZ.js";
-import {
-  init_session_work_log,
-  session_work_log_exports
-} from "./chunk-SDDCVUCV.js";
 import {
   init_lore_loader,
   loadLoreEntries,
   loadLoreEntry
 } from "./chunk-5VKJBNJL.js";
+import {
+  getSessionTracker,
+  loadPendingHandoffs,
+  markHandoffDelivered,
+  resetSessionTracker,
+  writePendingHandoff
+} from "./chunk-4L3UTYQX.js";
 import {
   __esm,
   __export,
@@ -30,9 +33,9 @@ __export(aspect_fingerprint_exports, {
   searchSiblingFiles: () => searchSiblingFiles,
   slidingWindowSearch: () => slidingWindowSearch
 });
-import * as fs5 from "fs";
-import * as path6 from "path";
-import * as crypto2 from "crypto";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as crypto from "crypto";
 import { execSync } from "child_process";
 function generateFingerprint(content) {
   const lines = content.split("\n").filter((l) => l.trim() !== "");
@@ -48,7 +51,7 @@ function extractStructuralHash(lines) {
     const match = l.match(STRUCTURAL_TOKENS);
     return match ? match[1].trim() : "";
   }).join("|");
-  return crypto2.createHash("sha256").update(structural).digest("hex").slice(0, 16);
+  return crypto.createHash("sha256").update(structural).digest("hex").slice(0, 16);
 }
 function normalizeLine(line) {
   return line.trim().replace(/\s+/g, " ").toLowerCase();
@@ -170,18 +173,18 @@ function detectFileRename(rootDir, oldPath) {
   }
 }
 function searchSiblingFiles(rootDir, dirPath, fingerprint, originalContent, maxFiles = 10) {
-  const absoluteDir = path6.isAbsolute(dirPath) ? dirPath : path6.join(rootDir, dirPath);
-  if (!fs5.existsSync(absoluteDir)) return [];
+  const absoluteDir = path4.isAbsolute(dirPath) ? dirPath : path4.join(rootDir, dirPath);
+  if (!fs3.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);
+    const files = fs3.readdirSync(absoluteDir).filter((f) => !f.startsWith(".") && fs3.statSync(path4.join(absoluteDir, f)).isFile()).slice(0, maxFiles);
     for (const file of files) {
       try {
-        const content = fs5.readFileSync(path6.join(absoluteDir, file), "utf8");
+        const content = fs3.readFileSync(path4.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));
+          const relPath = path4.relative(rootDir, path4.join(absoluteDir, file));
           results.push({
             file: relPath,
             score: matches[0].score,
@@ -199,9 +202,9 @@ function searchSiblingFiles(rootDir, dirPath, fingerprint, originalContent, maxF
 }
 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 absolutePath = path4.isAbsolute(filePath) ? filePath : path4.join(rootDir, filePath);
+  if (fs3.existsSync(absolutePath)) {
+    const fileContent = fs3.readFileSync(absolutePath, "utf8");
     const fileLines = fileContent.split("\n");
     const matches = slidingWindowSearch(fileLines, fingerprint, originalContent);
     if (matches.length > 0) {
@@ -217,9 +220,9 @@ function contentSearch(rootDir, filePath, originalContent, autoHeal = true) {
   }
   const renamedTo = detectFileRename(rootDir, filePath);
   if (renamedTo) {
-    const renamedPath = path6.join(rootDir, renamedTo);
-    if (fs5.existsSync(renamedPath)) {
-      const renamedContent = fs5.readFileSync(renamedPath, "utf8");
+    const renamedPath = path4.join(rootDir, renamedTo);
+    if (fs3.existsSync(renamedPath)) {
+      const renamedContent = fs3.readFileSync(renamedPath, "utf8");
       const renamedLines = renamedContent.split("\n");
       const matches = slidingWindowSearch(renamedLines, fingerprint, originalContent);
       if (matches.length > 0 && matches[0].score >= 0.7) {
@@ -234,7 +237,7 @@ function contentSearch(rootDir, filePath, originalContent, autoHeal = true) {
       }
     }
   }
-  const dirPath = path6.dirname(filePath);
+  const dirPath = path4.dirname(filePath);
   const siblingResults = searchSiblingFiles(rootDir, dirPath, fingerprint, originalContent);
   if (siblingResults.length > 0 && siblingResults[0].score >= 0.7) {
     const best = siblingResults[0];
@@ -263,9 +266,9 @@ var init_aspect_fingerprint = __esm({
 });
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
-import * as yaml8 from "js-yaml";
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as yaml7 from "js-yaml";
 
 // ../premise/core/dist/index.js
 import * as yaml3 from "js-yaml";
@@ -1932,661 +1935,6 @@ function serializeScanIndex(index) {
   return JSON.stringify(index, null, 2);
 }
 
-// ../paradigm-mcp/src/utils/session-tracker.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
-
-// ../paradigm-mcp/src/utils/global-store.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-import * as yaml4 from "js-yaml";
-function getGlobalDir() {
-  const dir = path4.join(os.homedir(), ".paradigm");
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function getProjectHash(rootDir) {
-  const absolute = path4.resolve(rootDir);
-  return crypto.createHash("sha256").update(absolute).digest("hex").slice(0, 12);
-}
-function getSessionDir(rootDir) {
-  const hash = getProjectHash(rootDir);
-  const dir = path4.join(getGlobalDir(), "sessions", hash);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  const handoffsDir = path4.join(dir, "pending-handoffs");
-  if (!fs3.existsSync(handoffsDir)) {
-    fs3.mkdirSync(handoffsDir, { recursive: true });
-  }
-  return dir;
-}
-function writeProjectMeta(rootDir) {
-  const sessionDir = getSessionDir(rootDir);
-  const metaPath = path4.join(sessionDir, "_project-meta.json");
-  const projectName = path4.basename(path4.resolve(rootDir));
-  const meta = {
-    name: projectName,
-    path: path4.resolve(rootDir),
-    lastSeen: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs3.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-}
-function writePendingHandoff(rootDir, handoff) {
-  const sessionDir = getSessionDir(rootDir);
-  const filePath = path4.join(sessionDir, "pending-handoffs", `${handoff.id}.json`);
-  fs3.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
-}
-function loadPendingHandoffs(rootDir) {
-  const sessionDir = getSessionDir(rootDir);
-  const handoffsDir = path4.join(sessionDir, "pending-handoffs");
-  if (!fs3.existsSync(handoffsDir)) {
-    return [];
-  }
-  const handoffs = [];
-  try {
-    const files = fs3.readdirSync(handoffsDir);
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      try {
-        const content = fs3.readFileSync(path4.join(handoffsDir, file), "utf8");
-        const handoff = JSON.parse(content);
-        if (handoff.status === "pending") {
-          handoffs.push(handoff);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  handoffs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-  return handoffs;
-}
-function markHandoffDelivered(rootDir, handoffId) {
-  const sessionDir = getSessionDir(rootDir);
-  const filePath = path4.join(sessionDir, "pending-handoffs", `${handoffId}.json`);
-  if (!fs3.existsSync(filePath)) return;
-  try {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const handoff = JSON.parse(content);
-    handoff.status = "delivered";
-    fs3.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
-  } catch {
-  }
-}
-function getGlobalWisdomDir() {
-  const dir = path4.join(getGlobalDir(), "wisdom");
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function loadGlobalAntipatterns() {
-  const filePath = path4.join(getGlobalWisdomDir(), "antipatterns.yaml");
-  if (!fs3.existsSync(filePath)) return [];
-  try {
-    const content = fs3.readFileSync(filePath, "utf8");
-    const data = yaml4.load(content);
-    return data?.antipatterns || [];
-  } catch {
-    return [];
-  }
-}
-function loadGlobalDecisions() {
-  const decisionsDir = path4.join(getGlobalWisdomDir(), "decisions");
-  if (!fs3.existsSync(decisionsDir)) return [];
-  const decisions = [];
-  try {
-    const files = fs3.readdirSync(decisionsDir);
-    for (const file of files) {
-      if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
-      try {
-        const content = fs3.readFileSync(path4.join(decisionsDir, file), "utf8");
-        const decision = yaml4.load(content);
-        decisions.push(decision);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  decisions.sort((a, b) => a.id.localeCompare(b.id));
-  return decisions;
-}
-function loadGlobalPreferences() {
-  const filePath = path4.join(getGlobalWisdomDir(), "preferences.yaml");
-  if (!fs3.existsSync(filePath)) return null;
-  try {
-    const content = fs3.readFileSync(filePath, "utf8");
-    return yaml4.load(content);
-  } catch {
-    return null;
-  }
-}
-function recordGlobalAntipattern(antipattern) {
-  const filePath = path4.join(getGlobalWisdomDir(), "antipatterns.yaml");
-  let data = { version: "1.0", antipatterns: [] };
-  if (fs3.existsSync(filePath)) {
-    try {
-      const content = fs3.readFileSync(filePath, "utf8");
-      data = yaml4.load(content);
-      if (!data.antipatterns) data.antipatterns = [];
-    } catch {
-    }
-  }
-  data.antipatterns.push({
-    ...antipattern,
-    added: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  fs3.writeFileSync(filePath, yaml4.dump(data, { lineWidth: -1 }));
-}
-function recordGlobalDecision(decision) {
-  const decisionsDir = path4.join(getGlobalWisdomDir(), "decisions");
-  if (!fs3.existsSync(decisionsDir)) {
-    fs3.mkdirSync(decisionsDir, { recursive: true });
-  }
-  const slug = decision.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  const fileName = `${decision.id}-${slug}.yaml`;
-  const filePath = path4.join(decisionsDir, fileName);
-  fs3.writeFileSync(filePath, yaml4.dump(decision, { lineWidth: -1 }));
-}
-
-// ../paradigm-mcp/src/utils/session-tracker.ts
-var MODEL_PRICING = {
-  "claude-opus-4": { input: 15, output: 75, name: "Claude Opus 4" },
-  "claude-sonnet-4": { input: 3, output: 15, name: "Claude Sonnet 4" },
-  "claude-haiku-3.5": { input: 0.8, output: 4, name: "Claude Haiku 3.5" }
-};
-var MAX_BREADCRUMBS = 50;
-var BREADCRUMBS_FILE = ".paradigm/session-breadcrumbs.json";
-var CHECKPOINT_FILE = ".paradigm/session-checkpoint.json";
-var CHECKPOINT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var SessionTracker = class {
-  session;
-  rootDir = null;
-  _recovered = false;
-  lastLoreEntryId = null;
-  constructor() {
-    this.session = this.createNewSession();
-  }
-  /**
-   * Set the project root directory (for persisting breadcrumbs)
-   */
-  setRootDir(rootDir) {
-    this.rootDir = rootDir;
-    try {
-      const { clearSessionWorkLog } = (init_session_work_log(), __toCommonJS(session_work_log_exports));
-      clearSessionWorkLog(rootDir);
-    } catch {
-    }
-  }
-  createNewSession() {
-    return {
-      sessionId: `s${Date.now().toString(36)}`,
-      startTime: Date.now(),
-      lastActivity: Date.now(),
-      model: "claude-sonnet-4",
-      resourceReads: [],
-      toolCalls: [],
-      breadcrumbs: [],
-      totals: {
-        resourceReadCount: 0,
-        toolCallCount: 0,
-        totalBytes: 0,
-        totalTokens: 0,
-        estimatedCostUsd: 0
-      }
-    };
-  }
-  /**
-   * Add a breadcrumb (summarized action for session recovery)
-   */
-  addBreadcrumb(action, summary, options = {}) {
-    this.session.breadcrumbs.push({
-      timestamp: Date.now(),
-      action,
-      tool: options.tool,
-      symbol: options.symbol,
-      summary
-    });
-    if (this.session.breadcrumbs.length > MAX_BREADCRUMBS) {
-      this.session.breadcrumbs = this.session.breadcrumbs.slice(-MAX_BREADCRUMBS);
-    }
-    this.persistBreadcrumbs();
-  }
-  /**
-   * Get recent breadcrumbs
-   */
-  getBreadcrumbs(limit = 20) {
-    return this.session.breadcrumbs.slice(-limit);
-  }
-  /**
-   * Persist breadcrumbs to file (dual-write: local + global)
-   */
-  persistBreadcrumbs() {
-    if (!this.rootDir) return;
-    const data = {
-      sessionId: this.session.sessionId,
-      startTime: this.session.startTime,
-      lastActivity: this.session.lastActivity,
-      breadcrumbs: this.session.breadcrumbs,
-      symbolsModified: this.extractSymbolsFromBreadcrumbs(),
-      filesExplored: this.extractFilesFromBreadcrumbs()
-    };
-    let jsonData;
-    try {
-      jsonData = JSON.stringify(data, null, 2);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: JSON.stringify failed:", err.message);
-      return;
-    }
-    try {
-      const filePath = path5.join(this.rootDir, BREADCRUMBS_FILE);
-      const dir = path5.dirname(filePath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
-      }
-      fs4.writeFileSync(filePath, jsonData);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: local write failed:", err.message);
-    }
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      fs4.writeFileSync(path5.join(globalSessionDir, "breadcrumbs.json"), jsonData);
-      writeProjectMeta(this.rootDir);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistBreadcrumbs: global write failed:", err.message);
-    }
-  }
-  /**
-   * Load previous session breadcrumbs from file.
-   * Prefers global path (~/.paradigm/sessions/{hash}/breadcrumbs.json),
-   * falls back to local (.paradigm/session-breadcrumbs.json).
-   */
-  loadPreviousSession() {
-    if (!this.rootDir) return null;
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      const globalPath = path5.join(globalSessionDir, "breadcrumbs.json");
-      if (fs4.existsSync(globalPath)) {
-        const content = fs4.readFileSync(globalPath, "utf8");
-        return JSON.parse(content);
-      }
-    } catch {
-    }
-    try {
-      const filePath = path5.join(this.rootDir, BREADCRUMBS_FILE);
-      if (!fs4.existsSync(filePath)) return null;
-      const content = fs4.readFileSync(filePath, "utf8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Save a cognitive-transition checkpoint for crash recovery.
-   * Fills in timestamp, sessionId, and snapshots recent breadcrumbs.
-   * Returns the checkpoint and whether it was persisted to disk.
-   */
-  saveCheckpoint(data) {
-    const checkpoint = {
-      phase: data.phase,
-      context: data.context,
-      timestamp: Date.now(),
-      sessionId: this.session.sessionId,
-      externalId: data.externalId,
-      plan: data.plan,
-      modifiedFiles: data.modifiedFiles,
-      symbolsTouched: data.symbolsTouched,
-      decisions: data.decisions,
-      recentBreadcrumbs: this.session.breadcrumbs.slice(-10)
-    };
-    const persisted = this.persistCheckpoint(checkpoint);
-    return { checkpoint, persisted };
-  }
-  /**
-   * Load the most recent checkpoint.
-   * Prefers global path, falls back to local.
-   * Returns null for checkpoints older than 7 days.
-   */
-  loadCheckpoint() {
-    if (!this.rootDir) return null;
-    let checkpoint = null;
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      const globalPath = path5.join(globalSessionDir, "checkpoint.json");
-      if (fs4.existsSync(globalPath)) {
-        const content = fs4.readFileSync(globalPath, "utf8");
-        checkpoint = JSON.parse(content);
-      }
-    } catch {
-    }
-    if (!checkpoint) {
-      try {
-        const localPath = path5.join(this.rootDir, CHECKPOINT_FILE);
-        if (fs4.existsSync(localPath)) {
-          const content = fs4.readFileSync(localPath, "utf8");
-          checkpoint = JSON.parse(content);
-        }
-      } catch {
-      }
-    }
-    if (checkpoint && Date.now() - checkpoint.timestamp > CHECKPOINT_MAX_AGE_MS) {
-      return null;
-    }
-    if (checkpoint) {
-      for (const key of ["modifiedFiles", "symbolsTouched", "decisions"]) {
-        const val = checkpoint[key];
-        if (typeof val === "string") {
-          try {
-            checkpoint[key] = JSON.parse(val);
-          } catch {
-            checkpoint[key] = [];
-          }
-        }
-      }
-    }
-    return checkpoint;
-  }
-  /**
-   * Persist checkpoint to both local and global paths.
-   * Returns which writes succeeded so callers can report accurately.
-   */
-  persistCheckpoint(checkpoint) {
-    const result = { local: false, global: false };
-    if (!this.rootDir) {
-      console.error("[paradigm-mcp] persistCheckpoint: rootDir not set, skipping write");
-      return result;
-    }
-    let jsonData;
-    try {
-      jsonData = JSON.stringify(checkpoint, null, 2);
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: JSON.stringify failed:", err.message);
-      return result;
-    }
-    try {
-      const filePath = path5.join(this.rootDir, CHECKPOINT_FILE);
-      const dir = path5.dirname(filePath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
-      }
-      fs4.writeFileSync(filePath, jsonData);
-      result.local = true;
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: local write failed:", err.message);
-    }
-    try {
-      const globalSessionDir = getSessionDir(this.rootDir);
-      fs4.writeFileSync(path5.join(globalSessionDir, "checkpoint.json"), jsonData);
-      writeProjectMeta(this.rootDir);
-      result.global = true;
-    } catch (err) {
-      console.error("[paradigm-mcp] persistCheckpoint: global write failed:", err.message);
-    }
-    return result;
-  }
-  /**
-   * Set the last lore entry ID recorded in this session
-   */
-  setLastLoreEntryId(id) {
-    this.lastLoreEntryId = id;
-  }
-  /**
-   * Get the last lore entry ID recorded in this session
-   */
-  getLastLoreEntryId() {
-    return this.lastLoreEntryId;
-  }
-  /**
-   * Check whether auto-recovery has already fired this session.
-   */
-  hasRecoveredThisSession() {
-    return this._recovered;
-  }
-  /**
-   * Mark that auto-recovery has fired (so it only fires once per session).
-   */
-  markRecovered() {
-    this._recovered = true;
-  }
-  /**
-   * Extract symbols from breadcrumbs
-   */
-  extractSymbolsFromBreadcrumbs() {
-    const symbols = /* @__PURE__ */ new Set();
-    for (const bc of this.session.breadcrumbs) {
-      if (bc.symbol) symbols.add(bc.symbol);
-    }
-    return Array.from(symbols);
-  }
-  /**
-   * Extract files from breadcrumbs
-   */
-  extractFilesFromBreadcrumbs() {
-    const files = /* @__PURE__ */ new Set();
-    for (const bc of this.session.breadcrumbs) {
-      const matches = bc.summary.match(/\b[\w./]+\.(ts|js|tsx|jsx|py|go|rs|yaml|json|md)\b/g);
-      if (matches) {
-        for (const m of matches) {
-          files.add(m);
-        }
-      }
-    }
-    return Array.from(files);
-  }
-  /**
-   * Estimate tokens from text (approx 3.5 chars per token)
-   */
-  estimateTokens(text) {
-    const len = typeof text === "number" ? text : text.length;
-    return Math.ceil(len / 3.5);
-  }
-  /**
-   * Calculate cost for tokens using current model pricing
-   */
-  calculateCost(tokens, isOutput = true) {
-    const pricing = MODEL_PRICING[this.session.model];
-    const rate = isOutput ? pricing.output : pricing.input;
-    return tokens / 1e6 * rate;
-  }
-  /**
-   * Set the model for cost calculations
-   */
-  setModel(model) {
-    this.session.model = model;
-    this.recalculateTotals();
-  }
-  /**
-   * Get current model
-   */
-  getModel() {
-    return this.session.model;
-  }
-  /**
-   * Track a resource read
-   */
-  trackResourceRead(uri, bytes) {
-    const resourceType = this.extractResourceType(uri);
-    const tokens = this.estimateTokens(bytes);
-    this.session.resourceReads.push({
-      timestamp: Date.now(),
-      resourceType,
-      uri,
-      bytes,
-      tokens
-    });
-    this.session.lastActivity = Date.now();
-    this.updateTotals(bytes, tokens);
-  }
-  /**
-   * Track a tool call
-   */
-  trackToolCall(toolName, responseBytes) {
-    const tokens = this.estimateTokens(responseBytes);
-    this.session.toolCalls.push({
-      timestamp: Date.now(),
-      toolName,
-      responseBytes,
-      responseTokens: tokens
-    });
-    this.session.lastActivity = Date.now();
-    this.updateTotals(responseBytes, tokens);
-  }
-  /**
-   * Update running totals
-   */
-  updateTotals(bytes, tokens) {
-    this.session.totals.resourceReadCount = this.session.resourceReads.length;
-    this.session.totals.toolCallCount = this.session.toolCalls.length;
-    this.session.totals.totalBytes += bytes;
-    this.session.totals.totalTokens += tokens;
-    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
-  }
-  /**
-   * Recalculate totals (used when model changes)
-   */
-  recalculateTotals() {
-    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
-  }
-  /**
-   * Extract resource type from URI
-   */
-  extractResourceType(uri) {
-    const path12 = uri.replace("paradigm://", "");
-    const firstPart = path12.split("/")[0];
-    return firstPart || "unknown";
-  }
-  /**
-   * Get session statistics
-   */
-  getStats() {
-    return { ...this.session };
-  }
-  /**
-   * Get detailed cost breakdown
-   */
-  getCostBreakdown() {
-    const resourcesByType = {};
-    let resourceBytes = 0;
-    let resourceTokens = 0;
-    for (const read of this.session.resourceReads) {
-      if (!resourcesByType[read.resourceType]) {
-        resourcesByType[read.resourceType] = { count: 0, bytes: 0, tokens: 0 };
-      }
-      resourcesByType[read.resourceType].count++;
-      resourcesByType[read.resourceType].bytes += read.bytes;
-      resourcesByType[read.resourceType].tokens += read.tokens;
-      resourceBytes += read.bytes;
-      resourceTokens += read.tokens;
-    }
-    const toolsByName = {};
-    let toolBytes = 0;
-    let toolTokens = 0;
-    for (const call of this.session.toolCalls) {
-      if (!toolsByName[call.toolName]) {
-        toolsByName[call.toolName] = { count: 0, bytes: 0, tokens: 0 };
-      }
-      toolsByName[call.toolName].count++;
-      toolsByName[call.toolName].bytes += call.responseBytes;
-      toolsByName[call.toolName].tokens += call.responseTokens;
-      toolBytes += call.responseBytes;
-      toolTokens += call.responseTokens;
-    }
-    const totalTokens = resourceTokens + toolTokens;
-    const totalCost = this.calculateCost(totalTokens);
-    return {
-      model: MODEL_PRICING[this.session.model].name,
-      modelId: this.session.model,
-      pricing: MODEL_PRICING[this.session.model],
-      resources: {
-        count: this.session.resourceReads.length,
-        bytes: resourceBytes,
-        tokens: resourceTokens,
-        costUsd: this.calculateCost(resourceTokens),
-        byType: resourcesByType
-      },
-      tools: {
-        count: this.session.toolCalls.length,
-        bytes: toolBytes,
-        tokens: toolTokens,
-        costUsd: this.calculateCost(toolTokens),
-        byName: toolsByName
-      },
-      total: {
-        tokens: totalTokens,
-        costUsd: totalCost
-      }
-    };
-  }
-  /**
-   * Get handoff recommendation based on context usage
-   */
-  getHandoffRecommendation(contextWindowSize = 2e5, estimatedTotalTokens) {
-    const mcpTokens = this.session.totals.totalTokens;
-    const estimatedConversationOverhead = mcpTokens * 4;
-    const totalEstimate = estimatedTotalTokens || mcpTokens + estimatedConversationOverhead;
-    const usagePercent = Math.round(totalEstimate / contextWindowSize * 100);
-    let recommendation;
-    let message;
-    if (usagePercent >= 85) {
-      recommendation = "handoff-urgent";
-      message = "Context is nearly full. Initiate handoff immediately to preserve session continuity.";
-    } else if (usagePercent >= 70) {
-      recommendation = "handoff-recommended";
-      message = "Context usage is high. Consider initiating handoff soon to ensure smooth transition.";
-    } else if (usagePercent >= 50) {
-      recommendation = "consider-handoff";
-      message = "Context usage is moderate. Plan a good stopping point for potential handoff.";
-    } else {
-      recommendation = "continue";
-      message = "Context usage is healthy. Continue working.";
-    }
-    const signals = [];
-    const durationMin = Math.round((Date.now() - this.session.startTime) / 6e4);
-    const totalCalls = this.session.toolCalls.length + this.session.resourceReads.length;
-    if (totalCalls > 50) {
-      signals.push(`High number of MCP interactions (${totalCalls})`);
-    }
-    if (durationMin > 30) {
-      signals.push(`Session duration >30 min (${durationMin} min)`);
-    }
-    if (this.session.totals.totalBytes > 5e5) {
-      signals.push(`Large data volume (${Math.round(this.session.totals.totalBytes / 1024)}KB)`);
-    }
-    return { recommendation, message, usagePercent, signals };
-  }
-  /**
-   * Get session duration in minutes
-   */
-  getDurationMinutes() {
-    return Math.round((Date.now() - this.session.startTime) / 6e4);
-  }
-  /**
-   * Reset session (for handoff or new session)
-   */
-  reset() {
-    this.session = this.createNewSession();
-    this._recovered = false;
-    this.lastLoreEntryId = null;
-  }
-};
-var tracker = null;
-function getSessionTracker() {
-  if (!tracker) {
-    tracker = new SessionTracker();
-  }
-  return tracker;
-}
-function resetSessionTracker() {
-  if (tracker) {
-    tracker.reset();
-  }
-}
-
 // ../paradigm-mcp/src/tools/context.ts
 function trackToolCall(responseSize, toolName = "unknown") {
   getSessionTracker().trackToolCall(toolName, responseSize);
@@ -2694,9 +2042,9 @@ function extractBreadcrumbInfo(toolName, args) {
   }
 }
 function addToolBreadcrumb(toolName, args) {
-  const tracker2 = getSessionTracker();
+  const tracker = getSessionTracker();
   const { summary, symbol } = extractBreadcrumbInfo(toolName, args);
-  tracker2.addBreadcrumb("tool-call", summary, { tool: toolName, symbol });
+  tracker.addBreadcrumb("tool-call", summary, { tool: toolName, symbol });
 }
 function getContextToolsList() {
   return [
@@ -2878,16 +2226,16 @@ function getContextToolsList() {
   ];
 }
 async function handleContextTool(name, args, _ctx) {
-  const tracker2 = getSessionTracker();
+  const tracker = getSessionTracker();
   if (name === "paradigm_context_check") {
     const contextWindowSize = args.contextWindowSize || 2e5;
     const estimatedTotal = args.estimatedTotalTokens;
-    const stats = tracker2.getStats();
-    const { recommendation, message, usagePercent, signals } = tracker2.getHandoffRecommendation(
+    const stats = tracker.getStats();
+    const { recommendation, message, usagePercent, signals } = tracker.getHandoffRecommendation(
       contextWindowSize,
       estimatedTotal
     );
-    const durationMin = tracker2.getDurationMinutes();
+    const durationMin = tracker.getDurationMinutes();
     return {
       handled: true,
       text: JSON.stringify({
@@ -2914,8 +2262,8 @@ async function handleContextTool(name, args, _ctx) {
     const modifiedFiles = args.modifiedFiles || [];
     const symbolsTouched = args.symbolsTouched || [];
     const openQuestions = args.openQuestions || [];
-    const stats = tracker2.getStats();
-    const breakdown = tracker2.getCostBreakdown();
+    const stats = tracker.getStats();
+    const breakdown = tracker.getCostBreakdown();
     const handoffId = `h${Date.now().toString(36)}`;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const handoffPayload = {
@@ -2929,7 +2277,7 @@ async function handleContextTool(name, args, _ctx) {
       symbolsTouched,
       openQuestions,
       sessionStats: {
-        duration: tracker2.getDurationMinutes(),
+        duration: tracker.getDurationMinutes(),
         mcpCalls: stats.totals.toolCallCount + stats.totals.resourceReadCount,
         estimatedTokens: stats.totals.totalTokens,
         estimatedCostUsd: breakdown.total.costUsd,
@@ -2966,9 +2314,9 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     };
   }
   if (name === "paradigm_session_stats") {
-    const stats = tracker2.getStats();
-    const breakdown = tracker2.getCostBreakdown();
-    const durationMin = tracker2.getDurationMinutes();
+    const stats = tracker.getStats();
+    const breakdown = tracker.getCostBreakdown();
+    const durationMin = tracker.getDurationMinutes();
     return {
       handled: true,
       text: JSON.stringify({
@@ -3013,9 +2361,9 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     };
   }
   if (name === "paradigm_session_recover") {
-    tracker2.setRootDir(_ctx.rootDir);
-    const previousSession = tracker2.loadPreviousSession();
-    const checkpoint = tracker2.loadCheckpoint();
+    tracker.setRootDir(_ctx.rootDir);
+    const previousSession = tracker.loadPreviousSession();
+    const checkpoint = tracker.loadCheckpoint();
     let pendingHandoffs = [];
     try {
       pendingHandoffs = loadPendingHandoffs(_ctx.rootDir);
@@ -3121,14 +2469,14 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     }
     result.suggestion = suggestion;
     result.agentInstruction = "Present a brief summary of the previous session, then ask the user 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.";
-    tracker2.markRecovered();
+    tracker.markRecovered();
     return {
       handled: true,
       text: JSON.stringify(result, null, 2)
     };
   }
   if (name === "paradigm_session_checkpoint") {
-    tracker2.setRootDir(_ctx.rootDir);
+    tracker.setRootDir(_ctx.rootDir);
     const phase = args.phase;
     const context = args.context;
     const externalId = args.externalId;
@@ -3136,7 +2484,7 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
     const modifiedFiles = args.modifiedFiles;
     const symbolsTouched = args.symbolsTouched;
     const decisions = args.decisions;
-    const { checkpoint, persisted } = tracker2.saveCheckpoint({
+    const { checkpoint, persisted } = tracker.saveCheckpoint({
       phase,
       context,
       externalId,
@@ -3169,9 +2517,9 @@ ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified
   return { handled: false, text: "" };
 }
 async function buildRecoveryPreamble(rootDir) {
-  const tracker2 = getSessionTracker();
-  tracker2.setRootDir(rootDir);
-  const checkpoint = tracker2.loadCheckpoint();
+  const tracker = getSessionTracker();
+  tracker.setRootDir(rootDir);
+  const checkpoint = tracker.loadCheckpoint();
   let pendingHandoffs = [];
   try {
     pendingHandoffs = loadPendingHandoffs(rootDir);
@@ -3244,7 +2592,7 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadNominations } = await import("./nomination-engine-LLREC5BZ.js");
+    const { loadNominations } = await import("./nomination-engine-RV5CNO5B.js");
     const urgent = loadNominations(rootDir, { pending_only: true }).filter((n) => n.urgency === "critical" || n.urgency === "high");
     if (urgent.length > 0) {
       lines.push("");
@@ -3315,9 +2663,9 @@ var ToolCache = class {
 var toolCache = new ToolCache(3e4);
 
 // ../paradigm-mcp/src/utils/aspect-graph.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
-import * as crypto3 from "crypto";
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as crypto2 from "crypto";
 import { execSync as execSync2 } from "child_process";
 import initSqlJs from "sql.js";
 var cachedSQL = null;
@@ -3438,15 +2786,15 @@ function queryOne(db, sql, params) {
 }
 async function openAspectGraph(rootDir) {
   const SQL = await getSqlJs();
-  const dbDir = path7.join(rootDir, ".paradigm");
-  const dbPath = path7.join(dbDir, "aspect-graph.db");
+  const dbDir = path5.join(rootDir, ".paradigm");
+  const dbPath = path5.join(dbDir, "aspect-graph.db");
   let db;
-  if (fs6.existsSync(dbPath)) {
-    const buffer = fs6.readFileSync(dbPath);
+  if (fs4.existsSync(dbPath)) {
+    const buffer = fs4.readFileSync(dbPath);
     db = new SQL.Database(buffer);
   } else {
-    if (!fs6.existsSync(dbDir)) {
-      fs6.mkdirSync(dbDir, { recursive: true });
+    if (!fs4.existsSync(dbDir)) {
+      fs4.mkdirSync(dbDir, { recursive: true });
     }
     db = new SQL.Database();
   }
@@ -3467,13 +2815,13 @@ async function openAspectGraph(rootDir) {
 }
 function closeAspectGraph(db, rootDir) {
   if (rootDir) {
-    const dbDir = path7.join(rootDir, ".paradigm");
-    if (!fs6.existsSync(dbDir)) {
-      fs6.mkdirSync(dbDir, { recursive: true });
+    const dbDir = path5.join(rootDir, ".paradigm");
+    if (!fs4.existsSync(dbDir)) {
+      fs4.mkdirSync(dbDir, { recursive: true });
     }
-    const dbPath = path7.join(dbDir, "aspect-graph.db");
+    const dbPath = path5.join(dbDir, "aspect-graph.db");
     const data = db.export();
-    fs6.writeFileSync(dbPath, Buffer.from(data));
+    fs4.writeFileSync(dbPath, Buffer.from(data));
   }
   db.close();
 }
@@ -3609,8 +2957,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 = path7.isAbsolute(anchor.file_path) ? anchor.file_path : path7.join(rootDir, anchor.file_path);
-    if (!fs6.existsSync(absolutePath)) {
+    const absolutePath = path5.isAbsolute(anchor.file_path) ? anchor.file_path : path5.join(rootDir, anchor.file_path);
+    if (!fs4.existsSync(absolutePath)) {
       results.push({
         aspectId: anchor.aspect_id,
         path: anchor.file_path,
@@ -3624,12 +2972,12 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
       continue;
     }
     try {
-      const fileContent = fs6.readFileSync(absolutePath, "utf8");
+      const fileContent = fs4.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 = crypto3.createHash("sha256").update(sliceContent).digest("hex");
+      const currentExactHash = crypto2.createHash("sha256").update(sliceContent).digest("hex");
       if (anchor.content_hash != null && currentExactHash === anchor.content_hash) {
         results.push({
           aspectId: anchor.aspect_id,
@@ -3646,7 +2994,7 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
         }
         continue;
       }
-      const currentNormalizedHash = crypto3.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+      const currentNormalizedHash = crypto2.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({
@@ -3691,7 +3039,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 = crypto3.createHash("sha256").update(shiftedContent).digest("hex");
+          const shiftedExactHash = crypto2.createHash("sha256").update(shiftedContent).digest("hex");
           if (anchor.content_hash != null && shiftedExactHash === anchor.content_hash) {
             const healed = autoHeal;
             if (healed) {
@@ -3731,10 +3079,10 @@ function checkDrift(db, rootDir, aspectId, autoHeal = true) {
             });
             resolvedByGit = true;
           } else {
-            const shiftedNormalized = crypto3.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
+            const shiftedNormalized = crypto2.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
             if (anchor.normalized_hash != null && shiftedNormalized === anchor.normalized_hash) {
               if (autoHeal) {
-                const shiftedNewHash = crypto3.createHash("sha256").update(shiftedContent).digest("hex");
+                const shiftedNewHash = crypto2.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]
@@ -3934,15 +3282,15 @@ function computeLineShift(rootDir, filePath, fromCommit, originalStart, original
   };
 }
 function healAnchorInPurposeFile(rootDir, purposeFilePath, anchorFilePath, oldStart, oldEnd, newStart, newEnd) {
-  const absolutePurpose = path7.isAbsolute(purposeFilePath) ? purposeFilePath : path7.join(rootDir, purposeFilePath);
-  if (!fs6.existsSync(absolutePurpose)) return false;
+  const absolutePurpose = path5.isAbsolute(purposeFilePath) ? purposeFilePath : path5.join(rootDir, purposeFilePath);
+  if (!fs4.existsSync(absolutePurpose)) return false;
   try {
-    const content = fs6.readFileSync(absolutePurpose, "utf8");
+    const content = fs4.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);
-    fs6.writeFileSync(absolutePurpose, updated, "utf8");
+    fs4.writeFileSync(absolutePurpose, updated, "utf8");
     return true;
   } catch {
     return false;
@@ -3953,18 +3301,18 @@ function normalizeForHash(content) {
 }
 function computeAnchorHash(anchor, rootDir) {
   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 };
+  const absolutePath = path5.isAbsolute(anchor.path) ? anchor.path : path5.join(rootDir, anchor.path);
+  if (!fs4.existsSync(absolutePath)) return { exact: null, normalized: null, normalizedContent: null };
   try {
-    const fileContent = fs6.readFileSync(absolutePath, "utf8");
+    const fileContent = fs4.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 normalizedContent = normalizeForHash(sliceContent);
-    const exact = crypto3.createHash("sha256").update(sliceContent).digest("hex");
-    const normalized = crypto3.createHash("sha256").update(normalizedContent).digest("hex");
+    const exact = crypto2.createHash("sha256").update(sliceContent).digest("hex");
+    const normalized = crypto2.createHash("sha256").update(normalizedContent).digest("hex");
     return { exact, normalized, normalizedContent };
   } catch {
     return { exact: null, normalized: null, normalizedContent: null };
@@ -4184,20 +3532,20 @@ function toLoreSummary(entry) {
 }
 
 // ../paradigm-mcp/src/utils/personas-loader.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
-import * as yaml5 from "js-yaml";
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as yaml4 from "js-yaml";
 var PERSONAS_ROOT = ".paradigm/personas";
 var INDEX_FILE = "index.yaml";
 async function loadPersonas(rootDir, filter) {
-  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
-  if (!fs7.existsSync(personasDir)) return [];
-  const files = fs7.readdirSync(personasDir).filter((f) => f.endsWith(".persona"));
+  const personasDir = path6.join(rootDir, PERSONAS_ROOT);
+  if (!fs5.existsSync(personasDir)) return [];
+  const files = fs5.readdirSync(personasDir).filter((f) => f.endsWith(".persona"));
   const personas = [];
   for (const file of files) {
     try {
-      const content = fs7.readFileSync(path8.join(personasDir, file), "utf8");
-      const persona = yaml5.load(content);
+      const content = fs5.readFileSync(path6.join(personasDir, file), "utf8");
+      const persona = yaml4.load(content);
       if (persona && persona.id) {
         personas.push(persona);
       }
@@ -4207,10 +3555,10 @@ async function loadPersonas(rootDir, filter) {
   return applyFilter(personas, filter);
 }
 async function loadPersona(rootDir, id) {
-  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
-  if (!fs7.existsSync(filePath)) return null;
+  const filePath = path6.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs5.existsSync(filePath)) return null;
   try {
-    return yaml5.load(fs7.readFileSync(filePath, "utf8"));
+    return yaml4.load(fs5.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -4240,10 +3588,10 @@ function applyFilter(personas, filter) {
   return result;
 }
 async function createPersona(rootDir, data) {
-  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
-  fs7.mkdirSync(personasDir, { recursive: true });
-  const filePath = path8.join(personasDir, `${data.id}.persona`);
-  if (fs7.existsSync(filePath)) {
+  const personasDir = path6.join(rootDir, PERSONAS_ROOT);
+  fs5.mkdirSync(personasDir, { recursive: true });
+  const filePath = path6.join(personasDir, `${data.id}.persona`);
+  if (fs5.existsSync(filePath)) {
     throw new Error(`Persona ${data.id} already exists`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4260,14 +3608,14 @@ async function createPersona(rootDir, data) {
     created: now,
     updated: now
   };
-  fs7.writeFileSync(filePath, yaml5.dump(persona, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs5.writeFileSync(filePath, yaml4.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 = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  const filePath = path6.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
   const updated = {
     ...persona,
     ...partial,
@@ -4279,13 +3627,13 @@ async function updatePersona(rootDir, id, partial) {
     // immutable
     updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs7.writeFileSync(filePath, yaml5.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs5.writeFileSync(filePath, yaml4.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
   await rebuildPersonaIndex(rootDir);
   return true;
 }
 async function deletePersona(rootDir, id) {
-  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
-  if (!fs7.existsSync(filePath)) {
+  const filePath = path6.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs5.existsSync(filePath)) {
     return { deleted: false, warnings: [] };
   }
   const warnings = [];
@@ -4301,7 +3649,7 @@ async function deletePersona(rootDir, id) {
       }
     }
   }
-  fs7.unlinkSync(filePath);
+  fs5.unlinkSync(filePath);
   await rebuildPersonaIndex(rootDir);
   return { deleted: true, warnings };
 }
@@ -4403,12 +3751,12 @@ async function validatePersona(rootDir, persona, deep = false) {
     }
   }
   if (deep) {
-    const portalPath = path8.join(rootDir, "portal.yaml");
+    const portalPath = path6.join(rootDir, "portal.yaml");
     let portalGates = [];
     let portalRoutes = [];
-    if (fs7.existsSync(portalPath)) {
+    if (fs5.existsSync(portalPath)) {
       try {
-        const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
+        const portal = yaml4.load(fs5.readFileSync(portalPath, "utf8"));
         if (portal.gates && typeof portal.gates === "object") {
           portalGates = Object.keys(portal.gates);
         }
@@ -4459,10 +3807,10 @@ async function validatePersona(rootDir, persona, deep = false) {
         }
       }
       let allFlows = [];
-      const flowIndexPath = path8.join(rootDir, ".paradigm", "flow-index.json");
-      if (fs7.existsSync(flowIndexPath)) {
+      const flowIndexPath = path6.join(rootDir, ".paradigm", "flow-index.json");
+      if (fs5.existsSync(flowIndexPath)) {
         try {
-          const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+          const flowIndex = JSON.parse(fs5.readFileSync(flowIndexPath, "utf8"));
           allFlows = Object.keys(flowIndex.flows || {});
         } catch {
         }
@@ -4539,8 +3887,8 @@ async function detectSpawnCycle(rootDir, startId) {
   return visit(startId);
 }
 async function rebuildPersonaIndex(rootDir) {
-  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
-  fs7.mkdirSync(personasDir, { recursive: true });
+  const personasDir = path6.join(rootDir, PERSONAS_ROOT);
+  fs5.mkdirSync(personasDir, { recursive: true });
   const personas = await loadPersonas(rootDir);
   const entries = {};
   const gateCoverage = {};
@@ -4579,10 +3927,10 @@ async function rebuildPersonaIndex(rootDir) {
     }
   }
   let uncoveredRoutes = [];
-  const portalPath = path8.join(rootDir, "portal.yaml");
-  if (fs7.existsSync(portalPath)) {
+  const portalPath = path6.join(rootDir, "portal.yaml");
+  if (fs5.existsSync(portalPath)) {
     try {
-      const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
+      const portal = yaml4.load(fs5.readFileSync(portalPath, "utf8"));
       if (portal.routes && typeof portal.routes === "object") {
         const portalRoutes = Object.keys(portal.routes);
         uncoveredRoutes = portalRoutes.filter((pr) => {
@@ -4593,13 +3941,13 @@ async function rebuildPersonaIndex(rootDir) {
     }
   }
   const chains = {};
-  const chainsDir = path8.join(personasDir, "chains");
-  if (fs7.existsSync(chainsDir)) {
-    const chainFiles = fs7.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
+  const chainsDir = path6.join(personasDir, "chains");
+  if (fs5.existsSync(chainsDir)) {
+    const chainFiles = fs5.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
     for (const file of chainFiles) {
       try {
-        const content = fs7.readFileSync(path8.join(chainsDir, file), "utf8");
-        const chain = yaml5.load(content);
+        const content = fs5.readFileSync(path6.join(chainsDir, file), "utf8");
+        const chain = yaml4.load(content);
         if (chain && chain.id) {
           const orderIds = chain.order.map((o) => o.persona);
           let totalSteps = 0;
@@ -4631,9 +3979,9 @@ async function rebuildPersonaIndex(rootDir) {
     route_coverage: routeCoverage,
     uncovered_routes: uncoveredRoutes
   };
-  fs7.writeFileSync(
-    path8.join(personasDir, INDEX_FILE),
-    yaml5.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
+  fs5.writeFileSync(
+    path6.join(personasDir, INDEX_FILE),
+    yaml4.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
   );
   return index;
 }
@@ -4651,20 +3999,20 @@ async function getPersonaCoverage(rootDir) {
   }
   let portalGates = [];
   let portalRoutes = [];
-  const portalPath = path8.join(rootDir, "portal.yaml");
-  if (fs7.existsSync(portalPath)) {
+  const portalPath = path6.join(rootDir, "portal.yaml");
+  if (fs5.existsSync(portalPath)) {
     try {
-      const portal = yaml5.load(fs7.readFileSync(portalPath, "utf8"));
+      const portal = yaml4.load(fs5.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 = path8.join(rootDir, ".paradigm", "flow-index.json");
-  if (fs7.existsSync(flowIndexPath)) {
+  const flowIndexPath = path6.join(rootDir, ".paradigm", "flow-index.json");
+  if (fs5.existsSync(flowIndexPath)) {
     try {
-      const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+      const flowIndex = JSON.parse(fs5.readFileSync(flowIndexPath, "utf8"));
       allFlows = Object.keys(flowIndex.flows || {});
     } catch {
     }
@@ -4713,8 +4061,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path12) {
-  const parts = path12.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path10) {
+  const parts = path10.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -4883,22 +4231,22 @@ async function validateAgainstSentinel(persona, options = {}) {
 }
 
 // ../paradigm-mcp/src/utils/protocol-loader.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
-import * as yaml6 from "js-yaml";
+import * as fs6 from "fs";
+import * as path7 from "path";
+import * as yaml5 from "js-yaml";
 var PROTOCOLS_DIR = ".paradigm/protocols";
 var INDEX_FILE2 = "index.yaml";
 async function loadProtocols(rootDir) {
-  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
-  if (!fs8.existsSync(protocolsDir)) {
+  const protocolsDir = path7.join(rootDir, PROTOCOLS_DIR);
+  if (!fs6.existsSync(protocolsDir)) {
     return [];
   }
-  const files = fs8.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
+  const files = fs6.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
   const protocols = [];
   for (const file of files) {
     try {
-      const content = fs8.readFileSync(path9.join(protocolsDir, file), "utf8");
-      const protocol = yaml6.load(content);
+      const content = fs6.readFileSync(path7.join(protocolsDir, file), "utf8");
+      const protocol = yaml5.load(content);
       if (protocol?.id && protocol?.name) {
         protocols.push(protocol);
       }
@@ -4909,11 +4257,11 @@ async function loadProtocols(rootDir) {
 }
 async function loadProtocol(rootDir, id) {
   const slug = id.replace(/^P-/, "");
-  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-  if (fs8.existsSync(filePath)) {
+  const filePath = path7.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  if (fs6.existsSync(filePath)) {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
-      return yaml6.load(content);
+      const content = fs6.readFileSync(filePath, "utf8");
+      return yaml5.load(content);
     } catch {
       return null;
     }
@@ -4922,13 +4270,13 @@ async function loadProtocol(rootDir, id) {
   return protocols.find((p) => p.id === id) || null;
 }
 async function loadProtocolIndex(rootDir) {
-  const indexPath = path9.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
-  if (!fs8.existsSync(indexPath)) {
+  const indexPath = path7.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
+  if (!fs6.existsSync(indexPath)) {
     return null;
   }
   try {
-    const content = fs8.readFileSync(indexPath, "utf8");
-    return yaml6.load(content);
+    const content = fs6.readFileSync(indexPath, "utf8");
+    return yaml5.load(content);
   } catch {
     return null;
   }
@@ -4979,9 +4327,9 @@ async function searchProtocols(rootDir, task, limit = 3) {
   return scored.slice(0, limit);
 }
 async function recordProtocol(rootDir, protocol) {
-  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
-  if (!fs8.existsSync(protocolsDir)) {
-    fs8.mkdirSync(protocolsDir, { recursive: true });
+  const protocolsDir = path7.join(rootDir, PROTOCOLS_DIR);
+  if (!fs6.existsSync(protocolsDir)) {
+    fs6.mkdirSync(protocolsDir, { recursive: true });
   }
   const slug = slugify(protocol.name);
   const id = `P-${slug}`;
@@ -5001,8 +4349,8 @@ async function recordProtocol(rootDir, protocol) {
     verified_by: protocol.verified_by || "claude-opus-4-6",
     status: "current"
   };
-  const filePath = path9.join(protocolsDir, `${slug}.protocol`);
-  fs8.writeFileSync(filePath, yaml6.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path7.join(protocolsDir, `${slug}.protocol`);
+  fs6.writeFileSync(filePath, yaml5.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
   return id;
 }
 async function updateProtocol(rootDir, id, partial, refresh = false) {
@@ -5022,20 +4370,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 = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-  fs8.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path7.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  fs6.writeFileSync(filePath, yaml5.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
   return true;
 }
 function validateProtocol(rootDir, protocol) {
   const issues = [];
   let status = "current";
   if (protocol.exemplar) {
-    const exemplarPath = path9.join(rootDir, protocol.exemplar);
-    if (!fs8.existsSync(exemplarPath)) {
+    const exemplarPath = path7.join(rootDir, protocol.exemplar);
+    if (!fs6.existsSync(exemplarPath)) {
       issues.push(`Exemplar missing: ${protocol.exemplar}`);
       status = "broken";
     } else {
-      const stat = fs8.statSync(exemplarPath);
+      const stat = fs6.statSync(exemplarPath);
       if (stat.mtime.toISOString() > protocol.last_verified) {
         issues.push(`Exemplar modified since last verified: ${protocol.exemplar}`);
         if (status !== "broken") status = "stale";
@@ -5044,15 +4392,15 @@ function validateProtocol(rootDir, protocol) {
   }
   for (const step of protocol.steps) {
     if (step.template_from) {
-      const templatePath = path9.join(rootDir, step.template_from);
-      if (!fs8.existsSync(templatePath)) {
+      const templatePath = path7.join(rootDir, step.template_from);
+      if (!fs6.existsSync(templatePath)) {
         issues.push(`Template file missing: ${step.template_from}`);
         status = "broken";
       }
     }
     if (step.action === "modify" && step.target) {
-      const targetPath = path9.join(rootDir, step.target);
-      if (!step.target.includes("{") && !fs8.existsSync(targetPath)) {
+      const targetPath = path7.join(rootDir, step.target);
+      if (!step.target.includes("{") && !fs6.existsSync(targetPath)) {
         issues.push(`Modify target missing: ${step.target}`);
         status = "broken";
       }
@@ -5071,9 +4419,9 @@ async function rebuildProtocolIndex(rootDir) {
     if (protocol.status !== validation.status) {
       protocol.status = validation.status;
       const slug = protocol.id.replace(/^P-/, "");
-      const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
-      if (fs8.existsSync(filePath)) {
-        fs8.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+      const filePath = path7.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+      if (fs6.existsSync(filePath)) {
+        fs6.writeFileSync(filePath, yaml5.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
       }
     }
     switch (validation.status) {
@@ -5107,13 +4455,13 @@ async function rebuildProtocolIndex(rootDir) {
       broken
     }
   };
-  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  const protocolsDir = path7.join(rootDir, PROTOCOLS_DIR);
   if (protocols.length > 0) {
-    if (!fs8.existsSync(protocolsDir)) {
-      fs8.mkdirSync(protocolsDir, { recursive: true });
+    if (!fs6.existsSync(protocolsDir)) {
+      fs6.mkdirSync(protocolsDir, { recursive: true });
     }
-    const indexPath = path9.join(protocolsDir, INDEX_FILE2);
-    fs8.writeFileSync(indexPath, yaml6.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+    const indexPath = path7.join(protocolsDir, INDEX_FILE2);
+    fs6.writeFileSync(indexPath, yaml5.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
   }
   return index;
 }
@@ -5121,21 +4469,21 @@ function detectProtocolSuggestion(rootDir, filesCreated, filesModified) {
   if (!filesCreated || filesCreated.length < 2) return null;
   const dirGroups = {};
   for (const file of filesCreated) {
-    const dir = path9.dirname(file);
+    const dir = path7.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 = path9.join(rootDir, dir);
-    if (!fs8.existsSync(absDir)) continue;
-    const existing = fs8.readdirSync(absDir).filter((f) => {
-      const ext = path9.extname(f);
+    const absDir = path7.join(rootDir, dir);
+    if (!fs6.existsSync(absDir)) continue;
+    const existing = fs6.readdirSync(absDir).filter((f) => {
+      const ext = path7.extname(f);
       return [".ts", ".tsx", ".js", ".jsx", ".rs", ".py"].includes(ext);
     });
-    const preExisting = existing.filter((f) => !created.some((c) => path9.basename(c) === f));
+    const preExisting = existing.filter((f) => !created.some((c) => path7.basename(c) === f));
     if (preExisting.length > 0) {
-      const exemplar = path9.join(dir, preExisting[0]);
+      const exemplar = path7.join(dir, preExisting[0]);
       const steps = [
         ...created.map((f) => ({ action: "create", target: f })),
         ...filesModified.map((f) => ({ action: "modify", target: f }))
@@ -5143,7 +4491,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 ${path9.basename(dir).replace(/s$/, "")}`,
+          name: `Add a ${path7.basename(dir).replace(/s$/, "")}`,
           exemplar,
           steps
         }
@@ -5218,9 +4566,9 @@ function slugify(name) {
 }
 
 // ../paradigm-mcp/src/utils/university-loader.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
-import * as yaml7 from "js-yaml";
+import * as fs7 from "fs";
+import * as path8 from "path";
+import * as yaml6 from "js-yaml";
 var UNIVERSITY_DIR = ".paradigm/university";
 var CONTENT_DIR = "content";
 var NOTES_DIR = "notes";
@@ -5261,13 +4609,13 @@ var DEFAULT_CONFIG = {
   }
 };
 function loadUniversityConfig(rootDir) {
-  const configPath = path10.join(rootDir, UNIVERSITY_DIR, CONFIG_FILE);
-  if (!fs9.existsSync(configPath)) {
+  const configPath = path8.join(rootDir, UNIVERSITY_DIR, CONFIG_FILE);
+  if (!fs7.existsSync(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const raw = fs9.readFileSync(configPath, "utf8");
-    const data = yaml7.load(raw);
+    const raw = fs7.readFileSync(configPath, "utf8");
+    const data = yaml6.load(raw);
     if (!data) return { ...DEFAULT_CONFIG };
     return {
       branding: { ...DEFAULT_BRANDING, ...data.branding || {} },
@@ -5288,11 +4636,11 @@ function loadUniversityConfig(rootDir) {
   }
 }
 function loadUniversityIndex(rootDir) {
-  const indexPath = path10.join(rootDir, UNIVERSITY_DIR, INDEX_FILE3);
-  if (!fs9.existsSync(indexPath)) return null;
+  const indexPath = path8.join(rootDir, UNIVERSITY_DIR, INDEX_FILE3);
+  if (!fs7.existsSync(indexPath)) return null;
   try {
-    const raw = fs9.readFileSync(indexPath, "utf8");
-    return yaml7.load(raw);
+    const raw = fs7.readFileSync(indexPath, "utf8");
+    return yaml6.load(raw);
   } catch {
     return null;
   }
@@ -5301,14 +4649,14 @@ 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]);
+    const frontmatter = yaml6.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 });
+  const fm = yaml6.dump(frontmatter, { lineWidth: -1, noRefs: true, sortKeys: false });
   return `---
 ${fm}---
 
@@ -5319,7 +4667,7 @@ function loadNote(rootDir, id) {
   const filePath = resolveContentFile(rootDir, id, ".md");
   if (!filePath) return null;
   try {
-    const raw = fs9.readFileSync(filePath, "utf8");
+    const raw = fs7.readFileSync(filePath, "utf8");
     const parsed = parseFrontmatter(raw);
     if (!parsed) return null;
     const fm = parsed.frontmatter;
@@ -5330,19 +4678,19 @@ function loadNote(rootDir, id) {
 }
 function saveNote(rootDir, frontmatter, body) {
   const subdir = frontmatter.type === "policy" ? POLICIES_DIR : NOTES_DIR;
-  const dir = path10.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
-  fs9.mkdirSync(dir, { recursive: true });
-  const filePath = path10.join(dir, `${frontmatter.id}.md`);
+  const dir = path8.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
+  fs7.mkdirSync(dir, { recursive: true });
+  const filePath = path8.join(dir, `${frontmatter.id}.md`);
   const content = serializeFrontmatter(frontmatter, body);
-  fs9.writeFileSync(filePath, content, "utf8");
+  fs7.writeFileSync(filePath, content, "utf8");
   return filePath;
 }
 function loadQuiz(rootDir, id) {
   const filePath = resolveContentFile(rootDir, id, ".yaml");
   if (!filePath) return null;
   try {
-    const raw = fs9.readFileSync(filePath, "utf8");
-    const data = yaml7.load(raw);
+    const raw = fs7.readFileSync(filePath, "utf8");
+    const data = yaml6.load(raw);
     if (!data || !data.id) return null;
     return normalizeQuiz(data);
   } catch {
@@ -5350,18 +4698,18 @@ function loadQuiz(rootDir, id) {
   }
 }
 function saveQuiz(rootDir, quiz) {
-  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");
+  const dir = path8.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, QUIZZES_DIR);
+  fs7.mkdirSync(dir, { recursive: true });
+  const filePath = path8.join(dir, `${quiz.id}.yaml`);
+  fs7.writeFileSync(filePath, yaml6.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 = fs9.readFileSync(filePath, "utf8");
-    const data = yaml7.load(raw);
+    const raw = fs7.readFileSync(filePath, "utf8");
+    const data = yaml6.load(raw);
     if (!data || !data.id) return null;
     return data;
   } catch {
@@ -5369,22 +4717,22 @@ function loadPath(rootDir, id) {
   }
 }
 function savePath(rootDir, lp) {
-  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");
+  const dir = path8.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, PATHS_DIR);
+  fs7.mkdirSync(dir, { recursive: true });
+  const filePath = path8.join(dir, `${lp.id}.yaml`);
+  fs7.writeFileSync(filePath, yaml6.dump(lp, { lineWidth: -1, noRefs: true }), "utf8");
   return filePath;
 }
 function loadDiplomas(rootDir, filter) {
-  const dir = path10.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
-  if (!fs9.existsSync(dir)) return [];
+  const dir = path8.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  if (!fs7.existsSync(dir)) return [];
   const results = [];
   try {
-    const files = fs9.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+    const files = fs7.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
     for (const file of files) {
       try {
-        const raw = fs9.readFileSync(path10.join(dir, file), "utf8");
-        const diploma = yaml7.load(raw);
+        const raw = fs7.readFileSync(path8.join(dir, file), "utf8");
+        const diploma = yaml6.load(raw);
         if (!diploma || !diploma.id) continue;
         if (filter?.student && diploma.student !== filter.student) continue;
         if (filter?.type && diploma.type !== filter.type) continue;
@@ -5397,10 +4745,10 @@ function loadDiplomas(rootDir, filter) {
   return results.sort((a, b) => b.earnedAt.localeCompare(a.earnedAt));
 }
 function saveDiploma(rootDir, diploma) {
-  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");
+  const dir = path8.join(rootDir, UNIVERSITY_DIR, DIPLOMAS_DIR);
+  fs7.mkdirSync(dir, { recursive: true });
+  const filePath = path8.join(dir, `${diploma.id}.yaml`);
+  fs7.writeFileSync(filePath, yaml6.dump(diploma, { lineWidth: -1, noRefs: true }), "utf8");
   return filePath;
 }
 function searchContent(rootDir, filter) {
@@ -5446,16 +4794,16 @@ function searchContent(rootDir, filter) {
   return results.slice(0, limit);
 }
 function rebuildUniversityIndex(rootDir) {
-  const uniDir = path10.join(rootDir, UNIVERSITY_DIR);
-  const contentDir = path10.join(uniDir, CONTENT_DIR);
+  const uniDir = path8.join(rootDir, UNIVERSITY_DIR);
+  const contentDir = path8.join(uniDir, CONTENT_DIR);
   const entries = [];
   for (const subdir of [NOTES_DIR, POLICIES_DIR]) {
-    const dir = path10.join(contentDir, subdir);
-    if (!fs9.existsSync(dir)) continue;
+    const dir = path8.join(contentDir, subdir);
+    if (!fs7.existsSync(dir)) continue;
     try {
-      for (const file of fs9.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+      for (const file of fs7.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
         try {
-          const raw = fs9.readFileSync(path10.join(dir, file), "utf8");
+          const raw = fs7.readFileSync(path8.join(dir, file), "utf8");
           const parsed = parseFrontmatter(raw);
           if (!parsed) continue;
           const fm = parsed.frontmatter;
@@ -5478,13 +4826,13 @@ function rebuildUniversityIndex(rootDir) {
     } catch {
     }
   }
-  const quizDir = path10.join(contentDir, QUIZZES_DIR);
-  if (fs9.existsSync(quizDir)) {
+  const quizDir = path8.join(contentDir, QUIZZES_DIR);
+  if (fs7.existsSync(quizDir)) {
     try {
-      for (const file of fs9.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+      for (const file of fs7.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
         try {
-          const raw = fs9.readFileSync(path10.join(quizDir, file), "utf8");
-          const quiz = yaml7.load(raw);
+          const raw = fs7.readFileSync(path8.join(quizDir, file), "utf8");
+          const quiz = yaml6.load(raw);
           if (!quiz || !quiz.id) continue;
           entries.push({
             id: quiz.id,
@@ -5505,13 +4853,13 @@ function rebuildUniversityIndex(rootDir) {
     } catch {
     }
   }
-  const pathDir = path10.join(contentDir, PATHS_DIR);
-  if (fs9.existsSync(pathDir)) {
+  const pathDir = path8.join(contentDir, PATHS_DIR);
+  if (fs7.existsSync(pathDir)) {
     try {
-      for (const file of fs9.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+      for (const file of fs7.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
         try {
-          const raw = fs9.readFileSync(path10.join(pathDir, file), "utf8");
-          const lp = yaml7.load(raw);
+          const raw = fs7.readFileSync(path8.join(pathDir, file), "utf8");
+          const lp = yaml6.load(raw);
           if (!lp || !lp.id) continue;
           entries.push({
             id: lp.id,
@@ -5532,10 +4880,10 @@ function rebuildUniversityIndex(rootDir) {
     }
   }
   let diplomaCount = 0;
-  const diplomaDir = path10.join(uniDir, DIPLOMAS_DIR);
-  if (fs9.existsSync(diplomaDir)) {
+  const diplomaDir = path8.join(uniDir, DIPLOMAS_DIR);
+  if (fs7.existsSync(diplomaDir)) {
     try {
-      diplomaCount = fs9.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
+      diplomaCount = fs7.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
     } catch {
     }
   }
@@ -5546,9 +4894,9 @@ function rebuildUniversityIndex(rootDir) {
     entries,
     diplomaCount
   };
-  fs9.mkdirSync(uniDir, { recursive: true });
-  const indexPath = path10.join(uniDir, INDEX_FILE3);
-  fs9.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  fs7.mkdirSync(uniDir, { recursive: true });
+  const indexPath = path8.join(uniDir, INDEX_FILE3);
+  fs7.writeFileSync(indexPath, yaml6.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
   return index;
 }
 function validateUniversityContent(rootDir, options) {
@@ -5740,10 +5088,10 @@ function getOnboardingSequence(rootDir, student) {
   };
 }
 function resolveContentFile(rootDir, id, ext) {
-  const contentDir = path10.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
+  const contentDir = path8.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
   for (const subdir of [NOTES_DIR, POLICIES_DIR, QUIZZES_DIR, PATHS_DIR]) {
-    const filePath = path10.join(contentDir, subdir, `${id}${ext}`);
-    if (fs9.existsSync(filePath)) return filePath;
+    const filePath = path8.join(contentDir, subdir, `${id}${ext}`);
+    if (fs7.existsSync(filePath)) return filePath;
   }
   return null;
 }
@@ -5775,10 +5123,10 @@ function normalizeQuiz(quiz) {
 }
 function loadKnownSymbols(rootDir) {
   const symbols = /* @__PURE__ */ new Set();
-  const scanIndexPath = path10.join(rootDir, ".paradigm", "scan-index.json");
-  if (!fs9.existsSync(scanIndexPath)) return symbols;
+  const scanIndexPath = path8.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs7.existsSync(scanIndexPath)) return symbols;
   try {
-    const raw = fs9.readFileSync(scanIndexPath, "utf8");
+    const raw = fs7.readFileSync(scanIndexPath, "utf8");
     const index = JSON.parse(raw);
     if (index.symbols && Array.isArray(index.symbols)) {
       for (const sym of index.symbols) {
@@ -5810,17 +5158,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 = path10.join(rootDir, ".paradigm", "scan-index.json");
-  if (!fs9.existsSync(scanIndexPath)) return false;
+  const scanIndexPath = path8.join(rootDir, ".paradigm", "scan-index.json");
+  if (!fs7.existsSync(scanIndexPath)) return false;
   try {
-    const raw = fs9.readFileSync(scanIndexPath, "utf8");
+    const raw = fs7.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 = path10.join(rootDir, sym.filePath);
-          if (fs9.existsSync(purposePath)) {
-            const stat = fs9.statSync(purposePath);
+          const purposePath = path8.join(rootDir, sym.filePath);
+          if (fs7.existsSync(purposePath)) {
+            const stat = fs7.statSync(purposePath);
             if (stat.mtime.getTime() > contentUpdated) {
               return true;
             }
@@ -5935,10 +5283,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path11.basename(rootDir);
-  const paradigmDir = path11.join(rootDir, ".paradigm");
-  if (!fs10.existsSync(paradigmDir)) {
-    fs10.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path9.basename(rootDir);
+  const paradigmDir = path9.join(rootDir, ".paradigm");
+  if (!fs8.existsSync(paradigmDir)) {
+    fs8.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -5948,22 +5296,22 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path11.join(paradigmDir, "scan-index.json");
-  fs10.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path9.join(paradigmDir, "scan-index.json");
+  fs8.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path11.join(paradigmDir, "navigator.yaml");
-  fs10.writeFileSync(
+  const navigatorPath = path9.join(paradigmDir, "navigator.yaml");
+  fs8.writeFileSync(
     navigatorPath,
-    yaml8.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
+    yaml7.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 = path11.join(paradigmDir, "flow-index.json");
-    fs10.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path9.join(paradigmDir, "flow-index.json");
+    fs8.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -6006,8 +5354,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   }
   let universityStats;
   try {
-    const uniDir = path11.join(rootDir, ".paradigm", "university");
-    if (fs10.existsSync(uniDir)) {
+    const uniDir = path9.join(rootDir, ".paradigm", "university");
+    if (fs8.existsSync(uniDir)) {
       const uniIndex = rebuildUniversityIndex(rootDir);
       if (uniIndex.totalContent > 0 || uniIndex.diplomaCount > 0) {
         universityStats = {
@@ -6105,7 +5453,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs10.existsSync(path11.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.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 || "@" };
@@ -6116,7 +5464,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs10.existsSync(path11.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -6132,10 +5480,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path11.join(rootDir, ".gitignore");
-  if (fs10.existsSync(gitignorePath)) {
+  const gitignorePath = path9.join(rootDir, ".gitignore");
+  if (fs8.existsSync(gitignorePath)) {
     try {
-      const content = fs10.readFileSync(gitignorePath, "utf8");
+      const content = fs8.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);
@@ -6184,11 +5532,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path11.dirname(pf);
+        const dir = path9.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path11.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -6199,8 +5547,8 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs10.readFileSync(filePath, "utf8");
-      const data = yaml8.load(content);
+      const content = fs8.readFileSync(filePath, "utf8");
+      const data = yaml7.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
         for (const flowItem of data.flows) {
@@ -6213,7 +5561,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path11.relative(rootDir, filePath)
+              definedIn: path9.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -6229,7 +5577,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path11.relative(rootDir, filePath)
+              definedIn: path9.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -6296,12 +5644,6 @@ export {
   getReferencesFrom,
   getSymbolCounts,
   getAllSymbols,
-  loadGlobalAntipatterns,
-  loadGlobalDecisions,
-  loadGlobalPreferences,
-  recordGlobalAntipattern,
-  recordGlobalDecision,
-  getSessionTracker,
   trackToolCall,
   trackResourceRead,
   addToolBreadcrumb,