@a-company/paradigm 3.18.0 → 3.19.1

package/dist/{chunk-TUW27EIC.js → chunk-EZ6XW6FB.js}

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
+import {
+  loadLoreEntries,
+  loadLoreEntry
+} from "./chunk-3DYYXGDC.js";
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs9 from "fs";
-import * as path10 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";
@@ -1993,8 +1997,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path11 = uri.replace("paradigm://", "");
-    const firstPart = path11.split("/")[0];
+    const path10 = uri.replace("paradigm://", "");
+    const firstPart = path10.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -2748,16 +2752,22 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadArcs } = await import("./assessment-loader-C5EOUM47.js");
-    const activeArcs = await loadArcs(rootDir, "active");
-    if (activeArcs.length > 0) {
+    const { loadLoreEntries: loadLoreEntries2 } = await import("./lore-loader-S5BXMH27.js");
+    const arcEntries = await loadLoreEntries2(rootDir, { limit: 10 });
+    const entriesWithArcs = arcEntries.filter((e) => e.tags?.some((t) => t.startsWith("arc:")));
+    if (entriesWithArcs.length > 0) {
+      const arcGroups = /* @__PURE__ */ new Map();
+      for (const e of entriesWithArcs) {
+        const arcTag = e.tags?.find((t) => t.startsWith("arc:")) || "";
+        arcGroups.set(arcTag, (arcGroups.get(arcTag) || 0) + 1);
+      }
       const checkpointSymbols = checkpoint?.symbolsTouched || [];
-      const relevantArcs = checkpointSymbols.length > 0 ? activeArcs.filter((arc) => arc.symbols.some((s) => checkpointSymbols.includes(s))) : activeArcs.slice(0, 3);
-      if (relevantArcs.length > 0) {
+      const relevantArcs = checkpointSymbols.length > 0 ? entriesWithArcs.filter((e) => e.symbols_touched?.some((s) => checkpointSymbols.includes(s))) : entriesWithArcs.slice(0, 3);
+      if (relevantArcs.length > 0 || arcGroups.size > 0) {
         lines.push("");
-        lines.push("Active assessment arcs:");
-        for (const arc of relevantArcs) {
-          lines.push(`  ${arc.id}: ${arc.name} (${arc.entry_count} entries)`);
+        lines.push("Active lore arcs:");
+        for (const [arcTag, count] of arcGroups) {
+          lines.push(`  ${arcTag} (${count} entries)`);
         }
       }
     }
@@ -3401,369 +3411,6 @@ function inferSeverity(data, entry) {
   return "medium";
 }
 
-// ../paradigm-mcp/src/utils/lore-loader.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
-import * as yaml5 from "js-yaml";
-import { execSync as execSync2 } from "child_process";
-import * as os2 from "os";
-var LORE_DIR = ".paradigm/lore";
-var ENTRIES_DIR = "entries";
-var TIMELINE_FILE = "timeline.yaml";
-function inferProvider(model) {
-  const lower = model.toLowerCase();
-  if (lower.includes("claude") || lower.includes("anthropic")) return "anthropic";
-  if (lower.includes("gpt") || lower.includes("openai") || lower.includes("o1") || lower.includes("o3")) return "openai";
-  if (lower.includes("gemini") || lower.includes("google") || lower.includes("palm")) return "google";
-  if (lower.includes("llama") || lower.includes("meta")) return "meta";
-  if (lower.includes("mistral") || lower.includes("mixtral")) return "mistral";
-  if (lower.includes("deepseek")) return "deepseek";
-  if (lower.includes("cohere") || lower.includes("command")) return "cohere";
-  return "unknown";
-}
-function normalizeLoreEntry(raw) {
-  const entry = raw;
-  const author = entry.author;
-  if (typeof author === "string") {
-    return raw;
-  }
-  if (author && typeof author === "object" && !Array.isArray(author)) {
-    const old = author;
-    if (old.type === "agent") {
-      entry.author = "unknown";
-      entry.agent = {
-        provider: old.model ? inferProvider(old.model) : inferProvider(old.id),
-        model: old.model || old.id
-      };
-    } else {
-      entry.author = old.id || "unknown";
-    }
-    delete entry.assistedBy;
-  }
-  return entry;
-}
-function sanitizeAuthor(name) {
-  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
-}
-function resolveAuthor() {
-  const envAuthor = process.env.PARADIGM_AUTHOR;
-  if (envAuthor) return sanitizeAuthor(envAuthor);
-  try {
-    const gitName = execSync2("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
-    if (gitName) return sanitizeAuthor(gitName);
-  } catch {
-  }
-  try {
-    const username = os2.userInfo().username;
-    if (username) return sanitizeAuthor(username);
-  } catch {
-  }
-  return "unknown";
-}
-function isLoreFile(filename) {
-  return filename.endsWith(".yaml") || filename.endsWith(".lore");
-}
-function resolveEntryPath(rootDir, dateStr, entryId) {
-  const dirPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
-  const lorePath = path7.join(dirPath, `${entryId}.lore`);
-  if (fs6.existsSync(lorePath)) return lorePath;
-  const yamlPath = path7.join(dirPath, `${entryId}.yaml`);
-  if (fs6.existsSync(yamlPath)) return yamlPath;
-  return null;
-}
-async function loadLoreEntries(rootDir, filter) {
-  const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs6.existsSync(entriesPath)) {
-    return [];
-  }
-  migrateLegacyEntries(rootDir);
-  const entries = [];
-  const dateDirs = fs6.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
-  for (const dateDir of dateDirs) {
-    if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
-    if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
-    const dirPath = path7.join(entriesPath, dateDir);
-    const files = fs6.readdirSync(dirPath).filter(isLoreFile).sort();
-    for (const file of files) {
-      try {
-        const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
-        const raw = yaml5.load(content);
-        entries.push(normalizeLoreEntry(raw));
-      } catch {
-      }
-    }
-  }
-  return filter ? applyFilter(entries, filter) : entries;
-}
-async function loadLoreEntry(rootDir, entryId) {
-  const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
-  if (dateMatch) {
-    const dateStr = dateMatch[1];
-    const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
-    if (entryPath) {
-      try {
-        const content = fs6.readFileSync(entryPath, "utf8");
-        const raw = yaml5.load(content);
-        return normalizeLoreEntry(raw);
-      } catch {
-        return null;
-      }
-    }
-  }
-  const entries = await loadLoreEntries(rootDir);
-  return entries.find((e) => e.id === entryId) || null;
-}
-async function loadLoreTimeline(rootDir) {
-  const timelinePath = path7.join(rootDir, LORE_DIR, TIMELINE_FILE);
-  if (!fs6.existsSync(timelinePath)) {
-    return null;
-  }
-  try {
-    const content = fs6.readFileSync(timelinePath, "utf8");
-    return yaml5.load(content);
-  } catch {
-    return null;
-  }
-}
-function captureGitContext(cwd) {
-  try {
-    const ref = execSync2("git rev-parse HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const branch = execSync2("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const status = execSync2("git status --porcelain", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return { ref, branch, dirty: status.length > 0 };
-  } catch {
-    return void 0;
-  }
-}
-async function recordLoreEntry(rootDir, entry) {
-  const lorePath = path7.join(rootDir, LORE_DIR);
-  const dateStr = entry.timestamp.slice(0, 10);
-  const datePath = path7.join(lorePath, ENTRIES_DIR, dateStr);
-  if (!fs6.existsSync(datePath)) {
-    fs6.mkdirSync(datePath, { recursive: true });
-  }
-  if (!entry.author) {
-    entry.author = resolveAuthor();
-  }
-  if (!entry.git_context) {
-    entry.git_context = captureGitContext(rootDir);
-  }
-  if (!entry.id) {
-    entry.id = generateLoreId(rootDir, dateStr, entry.author, entry.timestamp);
-  }
-  const entryPath = path7.join(datePath, `${entry.id}.lore`);
-  fs6.writeFileSync(entryPath, yaml5.dump(entry, { lineWidth: -1, noRefs: true }));
-  await rebuildTimeline(rootDir);
-  return entry.id;
-}
-async function rebuildTimeline(rootDir) {
-  const lorePath = path7.join(rootDir, LORE_DIR);
-  const entriesPath = path7.join(lorePath, ENTRIES_DIR);
-  if (!fs6.existsSync(entriesPath)) return;
-  migrateLegacyEntries(rootDir);
-  const authors = /* @__PURE__ */ new Set();
-  let entryCount = 0;
-  let lastUpdated = "";
-  const dateDirs = fs6.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
-  for (const dateDir of dateDirs) {
-    const dirPath = path7.join(entriesPath, dateDir);
-    const files = fs6.readdirSync(dirPath).filter(isLoreFile);
-    for (const file of files) {
-      try {
-        const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
-        const raw = yaml5.load(content);
-        const entry = normalizeLoreEntry(raw);
-        authors.add(entry.author);
-        entryCount++;
-        if (!lastUpdated || entry.timestamp > lastUpdated) {
-          lastUpdated = entry.timestamp;
-        }
-      } catch {
-      }
-    }
-  }
-  let project = "unknown";
-  const configPath = path7.join(rootDir, ".paradigm", "config.yaml");
-  if (fs6.existsSync(configPath)) {
-    try {
-      const config = yaml5.load(fs6.readFileSync(configPath, "utf8"));
-      project = config.project || config.name || "unknown";
-    } catch {
-    }
-  }
-  const timeline = {
-    version: "1.0",
-    project,
-    entries: entryCount,
-    last_updated: lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
-    authors: Array.from(authors)
-  };
-  if (!fs6.existsSync(lorePath)) {
-    fs6.mkdirSync(lorePath, { recursive: true });
-  }
-  fs6.writeFileSync(
-    path7.join(lorePath, TIMELINE_FILE),
-    yaml5.dump(timeline, { lineWidth: -1, noRefs: true })
-  );
-}
-function migrateLegacyEntries(rootDir) {
-  const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs6.existsSync(entriesPath)) return 0;
-  const rootFiles = fs6.readdirSync(entriesPath).filter((f) => isLoreFile(f) && !f.startsWith("."));
-  let migrated = 0;
-  for (const file of rootFiles) {
-    const filePath = path7.join(entriesPath, file);
-    const stat = fs6.statSync(filePath);
-    if (!stat.isFile()) continue;
-    try {
-      const content = fs6.readFileSync(filePath, "utf8");
-      const raw = yaml5.load(content);
-      if (raw.author && typeof raw.author === "object") continue;
-      if (typeof raw.author === "string" && raw.timestamp) continue;
-      const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const datePath = path7.join(entriesPath, dateStr);
-      if (!fs6.existsSync(datePath)) {
-        fs6.mkdirSync(datePath, { recursive: true });
-      }
-      const author = resolveAuthor();
-      const timestamp = `${dateStr}T00:00:00.000Z`;
-      const id = generateLoreId(rootDir, dateStr, author, timestamp);
-      const oldType = String(raw.type || "agent-session");
-      const v2Type = ["agent-session", "human-note", "decision", "review", "incident", "milestone"].includes(oldType) ? oldType : "agent-session";
-      let verification;
-      if (raw.test_results && typeof raw.test_results === "object") {
-        const tr = raw.test_results;
-        verification = {
-          status: tr.total === tr.passed ? "pass" : "partial",
-          details: { tests: tr.total === tr.passed ? "pass" : "fail" }
-        };
-      }
-      const v2Entry = {
-        id,
-        type: v2Type,
-        timestamp,
-        author: "unknown",
-        agent: { provider: "unknown", model: "unknown" },
-        title: String(raw.title || file.replace(/\.(yaml|lore)$/, "")),
-        summary: String(raw.summary || ""),
-        symbols_touched: Array.isArray(raw.symbols_touched) ? raw.symbols_touched : [],
-        files_modified: Array.isArray(raw.files_modified) ? raw.files_modified : void 0,
-        ...verification ? { verification } : {},
-        tags: ["migrated", oldType]
-      };
-      fs6.writeFileSync(
-        path7.join(datePath, `${id}.lore`),
-        yaml5.dump(v2Entry, { lineWidth: -1, noRefs: true })
-      );
-      fs6.unlinkSync(filePath);
-      migrated++;
-    } catch {
-    }
-  }
-  return migrated;
-}
-async function updateLoreEntry(rootDir, entryId, partial) {
-  const entry = await loadLoreEntry(rootDir, entryId);
-  if (!entry) return false;
-  const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
-  if (!entryPath) return false;
-  if (partial.title !== void 0) entry.title = partial.title;
-  if (partial.summary !== void 0) entry.summary = partial.summary;
-  if (partial.type !== void 0) entry.type = partial.type;
-  if (partial.duration_minutes !== void 0) entry.duration_minutes = partial.duration_minutes;
-  if (partial.symbols_touched !== void 0) entry.symbols_touched = partial.symbols_touched;
-  if (partial.symbols_created !== void 0) entry.symbols_created = partial.symbols_created;
-  if (partial.files_created !== void 0) entry.files_created = partial.files_created;
-  if (partial.files_modified !== void 0) entry.files_modified = partial.files_modified;
-  if (partial.lines_added !== void 0) entry.lines_added = partial.lines_added;
-  if (partial.lines_removed !== void 0) entry.lines_removed = partial.lines_removed;
-  if (partial.commit !== void 0) entry.commit = partial.commit;
-  if (partial.decisions !== void 0) entry.decisions = partial.decisions;
-  if (partial.errors_encountered !== void 0) entry.errors_encountered = partial.errors_encountered;
-  if (partial.learnings !== void 0) entry.learnings = partial.learnings;
-  if (partial.verification !== void 0) entry.verification = partial.verification;
-  if (partial.tags !== void 0) entry.tags = partial.tags;
-  fs6.writeFileSync(entryPath, yaml5.dump(entry, { lineWidth: -1, noRefs: true }));
-  await rebuildTimeline(rootDir);
-  return true;
-}
-async function deleteLoreEntry(rootDir, entryId) {
-  const entry = await loadLoreEntry(rootDir, entryId);
-  if (!entry) return false;
-  const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
-  if (!entryPath) return false;
-  fs6.unlinkSync(entryPath);
-  const dateDir = path7.dirname(entryPath);
-  const remaining = fs6.readdirSync(dateDir).filter(isLoreFile);
-  if (remaining.length === 0) {
-    fs6.rmdirSync(dateDir);
-  }
-  await rebuildTimeline(rootDir);
-  return true;
-}
-function applyFilter(entries, filter) {
-  let result = entries;
-  if (filter.author) {
-    result = result.filter((e) => e.author === filter.author);
-  }
-  if (filter.hasAgent !== void 0) {
-    result = result.filter(
-      (e) => filter.hasAgent ? e.agent != null : e.agent == null
-    );
-  } else if (filter.authorType) {
-    result = result.filter(
-      (e) => filter.authorType === "agent" ? e.agent != null : e.agent == null
-    );
-  }
-  if (filter.symbol) {
-    result = result.filter(
-      (e) => e.symbols_touched.includes(filter.symbol) || e.symbols_created?.includes(filter.symbol)
-    );
-  }
-  if (filter.dateFrom) {
-    const from = new Date(filter.dateFrom).getTime();
-    result = result.filter((e) => new Date(e.timestamp).getTime() >= from);
-  }
-  if (filter.dateTo) {
-    const to = new Date(filter.dateTo).getTime();
-    result = result.filter((e) => new Date(e.timestamp).getTime() <= to);
-  }
-  if (filter.type) {
-    result = result.filter((e) => e.type === filter.type);
-  }
-  if (filter.tags && filter.tags.length > 0) {
-    result = result.filter((e) => filter.tags.some((tag) => e.tags?.includes(tag)));
-  }
-  if (filter.hasReview !== void 0) {
-    result = result.filter((e) => filter.hasReview ? e.review != null : e.review == null);
-  }
-  result.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-  if (filter.offset) result = result.slice(filter.offset);
-  if (filter.limit) result = result.slice(0, filter.limit);
-  return result;
-}
-function generateLoreId(rootDir, dateStr, author, timestamp) {
-  const sanitized = sanitizeAuthor(author);
-  const ts = new Date(timestamp);
-  const hh = String(ts.getUTCHours()).padStart(2, "0");
-  const mm = String(ts.getUTCMinutes()).padStart(2, "0");
-  const ss = String(ts.getUTCSeconds()).padStart(2, "0");
-  const timeStr = `${hh}${mm}${ss}`;
-  const prefix = `L-${dateStr}-${sanitized}-${timeStr}`;
-  const datePath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
-  if (!fs6.existsSync(datePath)) {
-    return `${prefix}-001`;
-  }
-  const existing = fs6.readdirSync(datePath).filter((f) => f.startsWith(prefix) && isLoreFile(f)).map((f) => {
-    const match = f.match(/-(\d{3})\.(yaml|lore)$/);
-    return match ? parseInt(match[1], 10) : 0;
-  });
-  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
-  return `${prefix}-${String(next).padStart(3, "0")}`;
-}
-
 // ../paradigm-mcp/src/utils/aspect-lore-bridge.ts
 var LORE_ID_PATTERN = /L-\d{4}-\d{2}-\d{2}-\d{3}/g;
 async function materializeLoreLinks(db, rootDir) {
@@ -3960,38 +3607,38 @@ function toLoreSummary(entry) {
 }
 
 // ../paradigm-mcp/src/utils/personas-loader.ts
-import * as fs7 from "fs";
-import * as path8 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 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 = path7.join(rootDir, PERSONAS_ROOT);
+  if (!fs6.existsSync(personasDir)) return [];
+  const files = fs6.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 = yaml6.load(content);
+      const content = fs6.readFileSync(path7.join(personasDir, file), "utf8");
+      const persona = yaml5.load(content);
       if (persona && persona.id) {
         personas.push(persona);
       }
     } catch {
     }
   }
-  return applyFilter2(personas, 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 = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs6.existsSync(filePath)) return null;
   try {
-    return yaml6.load(fs7.readFileSync(filePath, "utf8"));
+    return yaml5.load(fs6.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
-function applyFilter2(personas, filter) {
+function applyFilter(personas, filter) {
   if (!filter) return personas;
   let result = personas;
   if (filter.tag) {
@@ -4016,10 +3663,10 @@ function applyFilter2(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 = path7.join(rootDir, PERSONAS_ROOT);
+  fs6.mkdirSync(personasDir, { recursive: true });
+  const filePath = path7.join(personasDir, `${data.id}.persona`);
+  if (fs6.existsSync(filePath)) {
     throw new Error(`Persona ${data.id} already exists`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4036,14 +3683,14 @@ async function createPersona(rootDir, data) {
     created: now,
     updated: now
   };
-  fs7.writeFileSync(filePath, yaml6.dump(persona, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs6.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 = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  const filePath = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
   const updated = {
     ...persona,
     ...partial,
@@ -4055,13 +3702,13 @@ async function updatePersona(rootDir, id, partial) {
     // immutable
     updated: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs7.writeFileSync(filePath, yaml6.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  fs6.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 = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
-  if (!fs7.existsSync(filePath)) {
+  const filePath = path7.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs6.existsSync(filePath)) {
     return { deleted: false, warnings: [] };
   }
   const warnings = [];
@@ -4077,7 +3724,7 @@ async function deletePersona(rootDir, id) {
       }
     }
   }
-  fs7.unlinkSync(filePath);
+  fs6.unlinkSync(filePath);
   await rebuildPersonaIndex(rootDir);
   return { deleted: true, warnings };
 }
@@ -4179,12 +3826,12 @@ async function validatePersona(rootDir, persona, deep = false) {
     }
   }
   if (deep) {
-    const portalPath = path8.join(rootDir, "portal.yaml");
+    const portalPath = path7.join(rootDir, "portal.yaml");
     let portalGates = [];
     let portalRoutes = [];
-    if (fs7.existsSync(portalPath)) {
+    if (fs6.existsSync(portalPath)) {
       try {
-        const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+        const portal = yaml5.load(fs6.readFileSync(portalPath, "utf8"));
         if (portal.gates && typeof portal.gates === "object") {
           portalGates = Object.keys(portal.gates);
         }
@@ -4235,10 +3882,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 = path7.join(rootDir, ".paradigm", "flow-index.json");
+      if (fs6.existsSync(flowIndexPath)) {
         try {
-          const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+          const flowIndex = JSON.parse(fs6.readFileSync(flowIndexPath, "utf8"));
           allFlows = Object.keys(flowIndex.flows || {});
         } catch {
         }
@@ -4315,8 +3962,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 = path7.join(rootDir, PERSONAS_ROOT);
+  fs6.mkdirSync(personasDir, { recursive: true });
   const personas = await loadPersonas(rootDir);
   const entries = {};
   const gateCoverage = {};
@@ -4355,10 +4002,10 @@ async function rebuildPersonaIndex(rootDir) {
     }
   }
   let uncoveredRoutes = [];
-  const portalPath = path8.join(rootDir, "portal.yaml");
-  if (fs7.existsSync(portalPath)) {
+  const portalPath = path7.join(rootDir, "portal.yaml");
+  if (fs6.existsSync(portalPath)) {
     try {
-      const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+      const portal = yaml5.load(fs6.readFileSync(portalPath, "utf8"));
       if (portal.routes && typeof portal.routes === "object") {
         const portalRoutes = Object.keys(portal.routes);
         uncoveredRoutes = portalRoutes.filter((pr) => {
@@ -4369,13 +4016,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 = path7.join(personasDir, "chains");
+  if (fs6.existsSync(chainsDir)) {
+    const chainFiles = fs6.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
     for (const file of chainFiles) {
       try {
-        const content = fs7.readFileSync(path8.join(chainsDir, file), "utf8");
-        const chain = yaml6.load(content);
+        const content = fs6.readFileSync(path7.join(chainsDir, file), "utf8");
+        const chain = yaml5.load(content);
         if (chain && chain.id) {
           const orderIds = chain.order.map((o) => o.persona);
           let totalSteps = 0;
@@ -4407,9 +4054,9 @@ async function rebuildPersonaIndex(rootDir) {
     route_coverage: routeCoverage,
     uncovered_routes: uncoveredRoutes
   };
-  fs7.writeFileSync(
-    path8.join(personasDir, INDEX_FILE),
-    yaml6.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
+  fs6.writeFileSync(
+    path7.join(personasDir, INDEX_FILE),
+    yaml5.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
   );
   return index;
 }
@@ -4427,20 +4074,20 @@ async function getPersonaCoverage(rootDir) {
   }
   let portalGates = [];
   let portalRoutes = [];
-  const portalPath = path8.join(rootDir, "portal.yaml");
-  if (fs7.existsSync(portalPath)) {
+  const portalPath = path7.join(rootDir, "portal.yaml");
+  if (fs6.existsSync(portalPath)) {
     try {
-      const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+      const portal = yaml5.load(fs6.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 = path7.join(rootDir, ".paradigm", "flow-index.json");
+  if (fs6.existsSync(flowIndexPath)) {
     try {
-      const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+      const flowIndex = JSON.parse(fs6.readFileSync(flowIndexPath, "utf8"));
       allFlows = Object.keys(flowIndex.flows || {});
     } catch {
     }
@@ -4489,8 +4136,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path11) {
-  const parts = path11.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;
@@ -4659,22 +4306,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 yaml7 from "js-yaml";
+import * as fs7 from "fs";
+import * as path8 from "path";
+import * as yaml6 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 = path8.join(rootDir, PROTOCOLS_DIR);
+  if (!fs7.existsSync(protocolsDir)) {
     return [];
   }
-  const files = fs8.readdirSync(protocolsDir).filter((f) => f.endsWith(".protocol")).sort();
+  const files = fs7.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 = yaml7.load(content);
+      const content = fs7.readFileSync(path8.join(protocolsDir, file), "utf8");
+      const protocol = yaml6.load(content);
       if (protocol?.id && protocol?.name) {
         protocols.push(protocol);
       }
@@ -4685,11 +4332,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 = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  if (fs7.existsSync(filePath)) {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
-      return yaml7.load(content);
+      const content = fs7.readFileSync(filePath, "utf8");
+      return yaml6.load(content);
     } catch {
       return null;
     }
@@ -4698,13 +4345,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 = path8.join(rootDir, PROTOCOLS_DIR, INDEX_FILE2);
+  if (!fs7.existsSync(indexPath)) {
     return null;
   }
   try {
-    const content = fs8.readFileSync(indexPath, "utf8");
-    return yaml7.load(content);
+    const content = fs7.readFileSync(indexPath, "utf8");
+    return yaml6.load(content);
   } catch {
     return null;
   }
@@ -4755,9 +4402,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 = path8.join(rootDir, PROTOCOLS_DIR);
+  if (!fs7.existsSync(protocolsDir)) {
+    fs7.mkdirSync(protocolsDir, { recursive: true });
   }
   const slug = slugify(protocol.name);
   const id = `P-${slug}`;
@@ -4777,8 +4424,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, yaml7.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path8.join(protocolsDir, `${slug}.protocol`);
+  fs7.writeFileSync(filePath, yaml6.dump(full, { lineWidth: -1, noRefs: true }), "utf8");
   return id;
 }
 async function updateProtocol(rootDir, id, partial, refresh = false) {
@@ -4798,20 +4445,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, yaml7.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+  const filePath = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  fs7.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 = path9.join(rootDir, protocol.exemplar);
-    if (!fs8.existsSync(exemplarPath)) {
+    const exemplarPath = path8.join(rootDir, protocol.exemplar);
+    if (!fs7.existsSync(exemplarPath)) {
       issues.push(`Exemplar missing: ${protocol.exemplar}`);
       status = "broken";
     } else {
-      const stat = fs8.statSync(exemplarPath);
+      const stat = fs7.statSync(exemplarPath);
       if (stat.mtime.toISOString() > protocol.last_verified) {
         issues.push(`Exemplar modified since last verified: ${protocol.exemplar}`);
         if (status !== "broken") status = "stale";
@@ -4820,15 +4467,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 = path8.join(rootDir, step.template_from);
+      if (!fs7.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 = path8.join(rootDir, step.target);
+      if (!step.target.includes("{") && !fs7.existsSync(targetPath)) {
         issues.push(`Modify target missing: ${step.target}`);
         status = "broken";
       }
@@ -4847,9 +4494,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, yaml7.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
+      const filePath = path8.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+      if (fs7.existsSync(filePath)) {
+        fs7.writeFileSync(filePath, yaml6.dump(protocol, { lineWidth: -1, noRefs: true }), "utf8");
       }
     }
     switch (validation.status) {
@@ -4883,13 +4530,13 @@ async function rebuildProtocolIndex(rootDir) {
       broken
     }
   };
-  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  const protocolsDir = path8.join(rootDir, PROTOCOLS_DIR);
   if (protocols.length > 0) {
-    if (!fs8.existsSync(protocolsDir)) {
-      fs8.mkdirSync(protocolsDir, { recursive: true });
+    if (!fs7.existsSync(protocolsDir)) {
+      fs7.mkdirSync(protocolsDir, { recursive: true });
     }
-    const indexPath = path9.join(protocolsDir, INDEX_FILE2);
-    fs8.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+    const indexPath = path8.join(protocolsDir, INDEX_FILE2);
+    fs7.writeFileSync(indexPath, yaml6.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
   }
   return index;
 }
@@ -4897,21 +4544,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 = path8.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 = path8.join(rootDir, dir);
+    if (!fs7.existsSync(absDir)) continue;
+    const existing = fs7.readdirSync(absDir).filter((f) => {
+      const ext = path8.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) => path8.basename(c) === f));
     if (preExisting.length > 0) {
-      const exemplar = path9.join(dir, preExisting[0]);
+      const exemplar = path8.join(dir, preExisting[0]);
       const steps = [
         ...created.map((f) => ({ action: "create", target: f })),
         ...filesModified.map((f) => ({ action: "modify", target: f }))
@@ -4919,7 +4566,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 ${path8.basename(dir).replace(/s$/, "")}`,
           exemplar,
           steps
         }
@@ -5081,10 +4728,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 || path9.basename(rootDir);
+  const paradigmDir = path9.join(rootDir, ".paradigm");
+  if (!fs8.existsSync(paradigmDir)) {
+    fs8.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -5094,22 +4741,22 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path10.join(paradigmDir, "scan-index.json");
-  fs9.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 = path10.join(paradigmDir, "navigator.yaml");
-  fs9.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 = path10.join(paradigmDir, "flow-index.json");
-    fs9.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;
   }
@@ -5178,7 +4825,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) => 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 || "@" };
@@ -5189,7 +4836,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) => fs8.existsSync(path9.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -5205,10 +4852,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 = path9.join(rootDir, ".gitignore");
+  if (fs8.existsSync(gitignorePath)) {
     try {
-      const content = fs9.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);
@@ -5257,11 +4904,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path10.dirname(pf);
+        const dir = path9.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path10.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -5272,8 +4919,8 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs9.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) {
@@ -5286,7 +4933,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path10.relative(rootDir, filePath)
+              definedIn: path9.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -5302,7 +4949,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path10.relative(rootDir, filePath)
+              definedIn: path9.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -5392,12 +5039,6 @@ export {
   incrementHeatmap,
   getHeatmap,
   checkDrift,
-  loadLoreEntries,
-  loadLoreEntry,
-  loadLoreTimeline,
-  recordLoreEntry,
-  updateLoreEntry,
-  deleteLoreEntry,
   getLoreForAspect,
   loadPersonas,
   loadPersona,