@a-company/paradigm 3.1.2 → 3.1.5

package/dist/mcp.js

@@ -1,35 +1,11 @@
 #!/usr/bin/env node
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import {
+  __commonJS,
+  __require,
+  __toESM,
+  getPluginUpdateNotice,
+  schedulePluginUpdateCheck
+} from "./chunk-4G54C4VM.js";
 
 // ../../node_modules/sql.js/dist/sql-wasm.js
 var require_sql_wasm = __commonJS({
@@ -525,15 +501,15 @@ var require_sql_wasm = __commonJS({
         "undefined" != typeof __filename ? ya = __filename : ba && (ya = self.location.href);
         var za = "", Aa, Ba;
         if (ca) {
-          var fs26 = __require("fs");
+          var fs27 = __require("fs");
           za = __dirname + "/";
           Ba = (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs26.readFileSync(a);
+            return fs27.readFileSync(a);
           };
           Aa = async (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs26.readFileSync(a, void 0);
+            return fs27.readFileSync(a, void 0);
           };
           1 < process.argv.length && (wa = process.argv[1].replace(/\\/g, "/"));
           process.argv.slice(2);
@@ -815,7 +791,7 @@ var require_sql_wasm = __commonJS({
               if (ca) {
                 var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
                 try {
-                  c = fs26.readSync(d, b, 0, 256);
+                  c = fs27.readSync(d, b, 0, 256);
                 } catch (e) {
                   if (e.toString().includes("EOF")) c = 0;
                   else throw e;
@@ -4291,8 +4267,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path30 = uri.replace("paradigm://", "");
-    const firstPart = path30.split("/")[0];
+    const path31 = uri.replace("paradigm://", "");
+    const firstPart = path31.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -7003,7 +6979,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path30]) => sym.toLowerCase().includes(targetLower) || path30.toLowerCase().includes(targetLower)
+      ([sym, path31]) => sym.toLowerCase().includes(targetLower) || path31.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -12095,6 +12071,10 @@ async function handleTagsTool(name, args, ctx) {
   }
 }
 
+// ../paradigm-mcp/src/tools/purpose-portal.ts
+import * as fs21 from "fs";
+import * as path23 from "path";
+
 // ../paradigm-mcp/src/utils/purpose-writer.ts
 import * as fs19 from "fs";
 import * as path21 from "path";
@@ -13067,6 +13047,21 @@ async function handleAddAspect(args, ctx, reloadContext2) {
     }
   }
   const filePath = resolvePurposeFilePath(purposeFile, ctx.rootDir);
+  const purposeDir = path23.dirname(filePath);
+  for (const anchor of anchors) {
+    const anchorFile = anchor.replace(/:.*$/, "");
+    const resolved = path23.resolve(purposeDir, anchorFile);
+    if (!fs21.existsSync(resolved)) {
+      const rootResolved = path23.resolve(ctx.rootDir, anchorFile);
+      if (fs21.existsSync(rootResolved)) {
+        const corrected = path23.relative(purposeDir, rootResolved);
+        const idx = anchors.indexOf(anchor);
+        anchors[idx] = anchor.replace(anchorFile, corrected);
+      } else {
+        return err(`Anchor file not found: "${anchorFile}". Anchors must be relative to the .purpose file directory (${purposeDir}).`);
+      }
+    }
+  }
   const data = readPurposeFile(filePath);
   if (!data.aspects) data.aspects = {};
   const bareId = stripSymbolPrefix(id);
@@ -13466,12 +13461,12 @@ async function handleValidate(args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/pm.ts
-import * as fs22 from "fs";
-import * as path25 from "path";
+import * as fs23 from "fs";
+import * as path26 from "path";
 
 // ../paradigm-mcp/src/utils/habits-loader.ts
-import * as fs21 from "fs";
-import * as path23 from "path";
+import * as fs22 from "fs";
+import * as path24 from "path";
 import * as yaml13 from "js-yaml";
 var SEED_HABITS = [
   {
@@ -13578,7 +13573,7 @@ var SEED_HABITS = [
 var HABITS_CACHE_TTL_MS = 30 * 1e3;
 var habitsCache = /* @__PURE__ */ new Map();
 function loadHabits(rootDir) {
-  const absoluteRoot = path23.resolve(rootDir);
+  const absoluteRoot = path24.resolve(rootDir);
   const cached = habitsCache.get(absoluteRoot);
   if (cached && Date.now() - cached.loadedAt < HABITS_CACHE_TTL_MS) {
     return cached.habits;
@@ -13593,16 +13588,16 @@ function loadHabitsFresh(rootDir) {
     habitsById.set(seed.id, { ...seed });
   }
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  const globalConfig = loadHabitsYaml(path23.join(home, ".paradigm", "habits.yaml"));
+  const globalConfig = loadHabitsYaml(path24.join(home, ".paradigm", "habits.yaml"));
   if (globalConfig) mergeHabits(habitsById, globalConfig);
-  const projectConfig = loadHabitsYaml(path23.join(rootDir, ".paradigm", "habits.yaml"));
+  const projectConfig = loadHabitsYaml(path24.join(rootDir, ".paradigm", "habits.yaml"));
   if (projectConfig) mergeHabits(habitsById, projectConfig);
   return Array.from(habitsById.values());
 }
 function loadHabitsYaml(filePath) {
-  if (!fs21.existsSync(filePath)) return null;
+  if (!fs22.existsSync(filePath)) return null;
   try {
-    const content = fs21.readFileSync(filePath, "utf8");
+    const content = fs22.readFileSync(filePath, "utf8");
     return yaml13.load(content);
   } catch {
     return null;
@@ -13749,7 +13744,7 @@ function evalFileModified(habit, ctx) {
   const patterns = habit.check.params.patterns || [];
   if (patterns.length === 0) return { habit, result: "followed", reason: "No patterns specified" };
   const matched = ctx.filesModified.filter(
-    (f) => patterns.some((p) => f.includes(p) || path23.basename(f) === p)
+    (f) => patterns.some((p) => f.includes(p) || path24.basename(f) === p)
   );
   if (matched.length > 0) {
     return { habit, result: "followed", reason: `Matching files: ${matched.join(", ")}`, evidence: matched };
@@ -13768,12 +13763,12 @@ function evalGitClean(habit, ctx) {
 }
 
 // ../paradigm-mcp/src/utils/practice-store.ts
-import * as path24 from "path";
+import * as path25 from "path";
 var storageInstance = null;
 var storageInitialized2 = false;
 async function getStorage2(rootDir) {
   if (!storageInstance) {
-    const dbPath = path24.join(rootDir, ".paradigm", "sentinel", "sentinel.db");
+    const dbPath = path25.join(rootDir, ".paradigm", "sentinel", "sentinel.db");
     storageInstance = new SentinelStorage(dbPath);
     await storageInstance.ensureReady();
     storageInitialized2 = true;
@@ -14064,11 +14059,11 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
   const violations = [];
   const declaredRoutes = ctx.gateConfig?.routes ? Object.keys(ctx.gateConfig.routes) : [];
   for (const file of filesModified) {
-    const absPath = path25.isAbsolute(file) ? file : path25.join(ctx.rootDir, file);
-    if (!fs22.existsSync(absPath)) continue;
+    const absPath = path26.isAbsolute(file) ? file : path26.join(ctx.rootDir, file);
+    if (!fs23.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs22.readFileSync(absPath, "utf-8");
+      content = fs23.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -14086,8 +14081,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
             violations.push({
               type: "missing-portal-gate",
               severity: "warning",
-              message: `Route "${routePath}" in ${path25.relative(ctx.rootDir, absPath)} not in portal.yaml`,
-              file: path25.relative(ctx.rootDir, absPath),
+              message: `Route "${routePath}" in ${path26.relative(ctx.rootDir, absPath)} not in portal.yaml`,
+              file: path26.relative(ctx.rootDir, absPath),
               suggestion: "Add route to portal.yaml with ^gates. Use paradigm_gates_for_route for suggestions."
             });
           } else if (!ctx.gateConfig && routePath.startsWith("/api/")) {
@@ -14095,7 +14090,7 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
               type: "missing-portal-gate",
               severity: "warning",
               message: `API route "${routePath}" found but no portal.yaml exists`,
-              file: path25.relative(ctx.rootDir, absPath),
+              file: path26.relative(ctx.rootDir, absPath),
               suggestion: "Create portal.yaml to declare gates for API routes."
             });
           }
@@ -14153,8 +14148,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
             });
           } else {
             for (const anchor of anchors) {
-              const filePath = path25.isAbsolute(anchor.path) ? anchor.path : path25.join(ctx.rootDir, anchor.path);
-              if (!fs22.existsSync(filePath)) {
+              const filePath = path26.isAbsolute(anchor.path) ? anchor.path : path26.join(ctx.rootDir, anchor.path);
+              if (!fs23.existsSync(filePath)) {
                 violations.push({
                   type: "stale-aspect",
                   severity: "warning",
@@ -14235,12 +14230,12 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
         reason: e.reason
       }))
     };
-    const markerPath = path25.join(ctx.rootDir, ".paradigm", ".habits-blocking");
+    const markerPath = path26.join(ctx.rootDir, ".paradigm", ".habits-blocking");
     if (evalResult.blocksCompletion) {
       const blocking = evalResult.evaluations.filter((e) => e.result === "skipped" && e.habit.severity === "block").map((e) => `${e.habit.name}: ${e.reason}`);
-      fs22.writeFileSync(markerPath, blocking.join("\n"), "utf8");
-    } else if (fs22.existsSync(markerPath)) {
-      fs22.unlinkSync(markerPath);
+      fs23.writeFileSync(markerPath, blocking.join("\n"), "utf8");
+    } else if (fs23.existsSync(markerPath)) {
+      fs23.unlinkSync(markerPath);
     }
   } catch {
   }
@@ -14259,8 +14254,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs23 from "fs";
-import * as path26 from "path";
+import * as fs24 from "fs";
+import * as path27 from "path";
 import * as yaml14 from "js-yaml";
 
 // ../probe/core/dist/generator.js
@@ -14599,10 +14594,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path26.basename(rootDir);
-  const paradigmDir = path26.join(rootDir, ".paradigm");
-  if (!fs23.existsSync(paradigmDir)) {
-    fs23.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path27.basename(rootDir);
+  const paradigmDir = path27.join(rootDir, ".paradigm");
+  if (!fs24.existsSync(paradigmDir)) {
+    fs24.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -14612,12 +14607,12 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path26.join(paradigmDir, "scan-index.json");
-  fs23.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path27.join(paradigmDir, "scan-index.json");
+  fs24.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path26.join(paradigmDir, "navigator.yaml");
-  fs23.writeFileSync(
+  const navigatorPath = path27.join(paradigmDir, "navigator.yaml");
+  fs24.writeFileSync(
     navigatorPath,
     yaml14.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
@@ -14626,8 +14621,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
-    const flowIndexPath = path26.join(paradigmDir, "flow-index.json");
-    fs23.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path27.join(paradigmDir, "flow-index.json");
+    fs24.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -14656,7 +14651,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs23.existsSync(path26.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs24.existsSync(path27.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 || "@" };
@@ -14667,7 +14662,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs23.existsSync(path26.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs24.existsSync(path27.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -14683,10 +14678,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path26.join(rootDir, ".gitignore");
-  if (fs23.existsSync(gitignorePath)) {
+  const gitignorePath = path27.join(rootDir, ".gitignore");
+  if (fs24.existsSync(gitignorePath)) {
     try {
-      const content = fs23.readFileSync(gitignorePath, "utf8");
+      const content = fs24.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);
@@ -14735,11 +14730,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path26.dirname(pf);
+        const dir = path27.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path26.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path27.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -14750,7 +14745,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs23.readFileSync(filePath, "utf8");
+      const content = fs24.readFileSync(filePath, "utf8");
       const data = yaml14.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
@@ -14764,7 +14759,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path26.relative(rootDir, filePath)
+              definedIn: path27.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -14780,7 +14775,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path26.relative(rootDir, filePath)
+              definedIn: path27.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -14833,28 +14828,28 @@ function indexFlowSymbols(flowId, steps, symbolToFlows) {
 }
 
 // ../paradigm-mcp/src/utils/lore-loader.ts
-import * as fs24 from "fs";
-import * as path27 from "path";
+import * as fs25 from "fs";
+import * as path28 from "path";
 import * as yaml15 from "js-yaml";
 var LORE_DIR = ".paradigm/lore";
 var ENTRIES_DIR = "entries";
 var TIMELINE_FILE = "timeline.yaml";
 async function loadLoreEntries(rootDir, filter) {
-  const entriesPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) {
+  const entriesPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) {
     return [];
   }
   migrateLegacyEntries(rootDir);
   const entries = [];
-  const dateDirs = fs24.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  const dateDirs = fs25.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 = path27.join(entriesPath, dateDir);
-    const files = fs24.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    const dirPath = path28.join(entriesPath, dateDir);
+    const files = fs25.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
     for (const file of files) {
       try {
-        const content = fs24.readFileSync(path27.join(dirPath, file), "utf8");
+        const content = fs25.readFileSync(path28.join(dirPath, file), "utf8");
         const entry = yaml15.load(content);
         entries.push(entry);
       } catch {
@@ -14867,10 +14862,10 @@ async function loadLoreEntry(rootDir, entryId) {
   const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
   if (dateMatch) {
     const dateStr = dateMatch[1];
-    const entryPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-    if (fs24.existsSync(entryPath)) {
+    const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+    if (fs25.existsSync(entryPath)) {
       try {
-        const content = fs24.readFileSync(entryPath, "utf8");
+        const content = fs25.readFileSync(entryPath, "utf8");
         return yaml15.load(content);
       } catch {
         return null;
@@ -14881,47 +14876,47 @@ async function loadLoreEntry(rootDir, entryId) {
   return entries.find((e) => e.id === entryId) || null;
 }
 async function loadLoreTimeline(rootDir) {
-  const timelinePath = path27.join(rootDir, LORE_DIR, TIMELINE_FILE);
-  if (!fs24.existsSync(timelinePath)) {
+  const timelinePath = path28.join(rootDir, LORE_DIR, TIMELINE_FILE);
+  if (!fs25.existsSync(timelinePath)) {
     return null;
   }
   try {
-    const content = fs24.readFileSync(timelinePath, "utf8");
+    const content = fs25.readFileSync(timelinePath, "utf8");
     return yaml15.load(content);
   } catch {
     return null;
   }
 }
 async function recordLoreEntry(rootDir, entry) {
-  const lorePath = path27.join(rootDir, LORE_DIR);
+  const lorePath = path28.join(rootDir, LORE_DIR);
   const dateStr = entry.timestamp.slice(0, 10);
-  const datePath = path27.join(lorePath, ENTRIES_DIR, dateStr);
-  if (!fs24.existsSync(datePath)) {
-    fs24.mkdirSync(datePath, { recursive: true });
+  const datePath = path28.join(lorePath, ENTRIES_DIR, dateStr);
+  if (!fs25.existsSync(datePath)) {
+    fs25.mkdirSync(datePath, { recursive: true });
   }
   if (!entry.id) {
     entry.id = generateLoreId(rootDir, dateStr);
   }
-  const entryPath = path27.join(datePath, `${entry.id}.yaml`);
-  fs24.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
+  const entryPath = path28.join(datePath, `${entry.id}.yaml`);
+  fs25.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return entry.id;
 }
 async function rebuildTimeline(rootDir) {
-  const lorePath = path27.join(rootDir, LORE_DIR);
-  const entriesPath = path27.join(lorePath, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) return;
+  const lorePath = path28.join(rootDir, LORE_DIR);
+  const entriesPath = path28.join(lorePath, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) return;
   migrateLegacyEntries(rootDir);
   const authors = /* @__PURE__ */ new Set();
   let entryCount = 0;
   let lastUpdated = "";
-  const dateDirs = fs24.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+  const dateDirs = fs25.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
   for (const dateDir of dateDirs) {
-    const dirPath = path27.join(entriesPath, dateDir);
-    const files = fs24.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    const dirPath = path28.join(entriesPath, dateDir);
+    const files = fs25.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
     for (const file of files) {
       try {
-        const content = fs24.readFileSync(path27.join(dirPath, file), "utf8");
+        const content = fs25.readFileSync(path28.join(dirPath, file), "utf8");
         const entry = yaml15.load(content);
         authors.add(entry.author.id);
         entryCount++;
@@ -14933,10 +14928,10 @@ async function rebuildTimeline(rootDir) {
     }
   }
   let project = "unknown";
-  const configPath = path27.join(rootDir, ".paradigm", "config.yaml");
-  if (fs24.existsSync(configPath)) {
+  const configPath = path28.join(rootDir, ".paradigm", "config.yaml");
+  if (fs25.existsSync(configPath)) {
     try {
-      const config = yaml15.load(fs24.readFileSync(configPath, "utf8"));
+      const config = yaml15.load(fs25.readFileSync(configPath, "utf8"));
       project = config.project || config.name || "unknown";
     } catch {
     }
@@ -14948,31 +14943,31 @@ async function rebuildTimeline(rootDir) {
     last_updated: lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
     authors: Array.from(authors)
   };
-  if (!fs24.existsSync(lorePath)) {
-    fs24.mkdirSync(lorePath, { recursive: true });
+  if (!fs25.existsSync(lorePath)) {
+    fs25.mkdirSync(lorePath, { recursive: true });
   }
-  fs24.writeFileSync(
-    path27.join(lorePath, TIMELINE_FILE),
+  fs25.writeFileSync(
+    path28.join(lorePath, TIMELINE_FILE),
     yaml15.dump(timeline, { lineWidth: -1, noRefs: true })
   );
 }
 function migrateLegacyEntries(rootDir) {
-  const entriesPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs24.existsSync(entriesPath)) return 0;
-  const rootFiles = fs24.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
+  const entriesPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs25.existsSync(entriesPath)) return 0;
+  const rootFiles = fs25.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
   let migrated = 0;
   for (const file of rootFiles) {
-    const filePath = path27.join(entriesPath, file);
-    const stat = fs24.statSync(filePath);
+    const filePath = path28.join(entriesPath, file);
+    const stat = fs25.statSync(filePath);
     if (!stat.isFile()) continue;
     try {
-      const content = fs24.readFileSync(filePath, "utf8");
+      const content = fs25.readFileSync(filePath, "utf8");
       const raw = yaml15.load(content);
       if (raw.author && typeof raw.author === "object") continue;
       const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const datePath = path27.join(entriesPath, dateStr);
-      if (!fs24.existsSync(datePath)) {
-        fs24.mkdirSync(datePath, { recursive: true });
+      const datePath = path28.join(entriesPath, dateStr);
+      if (!fs25.existsSync(datePath)) {
+        fs25.mkdirSync(datePath, { recursive: true });
       }
       const id = generateLoreId(rootDir, dateStr);
       const oldType = String(raw.type || "agent-session");
@@ -14997,11 +14992,11 @@ function migrateLegacyEntries(rootDir) {
         ...verification ? { verification } : {},
         tags: ["migrated", oldType]
       };
-      fs24.writeFileSync(
-        path27.join(datePath, `${id}.yaml`),
+      fs25.writeFileSync(
+        path28.join(datePath, `${id}.yaml`),
         yaml15.dump(v2Entry, { lineWidth: -1, noRefs: true })
       );
-      fs24.unlinkSync(filePath);
+      fs25.unlinkSync(filePath);
       migrated++;
     } catch {
     }
@@ -15012,8 +15007,8 @@ 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 = path27.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs24.existsSync(entryPath)) return false;
+  const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs25.existsSync(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;
@@ -15030,7 +15025,7 @@ async function updateLoreEntry(rootDir, entryId, partial) {
   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;
-  fs24.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
+  fs25.writeFileSync(entryPath, yaml15.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return true;
 }
@@ -15038,13 +15033,13 @@ async function deleteLoreEntry(rootDir, entryId) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs24.existsSync(entryPath)) return false;
-  fs24.unlinkSync(entryPath);
-  const dateDir = path27.dirname(entryPath);
-  const remaining = fs24.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
+  const entryPath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs25.existsSync(entryPath)) return false;
+  fs25.unlinkSync(entryPath);
+  const dateDir = path28.dirname(entryPath);
+  const remaining = fs25.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
   if (remaining.length === 0) {
-    fs24.rmdirSync(dateDir);
+    fs25.rmdirSync(dateDir);
   }
   await rebuildTimeline(rootDir);
   return true;
@@ -15085,11 +15080,11 @@ function applyFilter(entries, filter) {
   return result;
 }
 function generateLoreId(rootDir, dateStr) {
-  const datePath = path27.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
-  if (!fs24.existsSync(datePath)) {
+  const datePath = path28.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  if (!fs25.existsSync(datePath)) {
     return `L-${dateStr}-001`;
   }
-  const existing = fs24.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
+  const existing = fs25.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
     const match = f.match(/L-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
     return match ? parseInt(match[1], 10) : 0;
   });
@@ -15592,8 +15587,8 @@ function summarizeEntry(entry) {
 }
 
 // ../paradigm-mcp/src/tools/habits.ts
-import * as fs25 from "fs";
-import * as path28 from "path";
+import * as fs26 from "fs";
+import * as path29 from "path";
 import { execSync as execSync2 } from "child_process";
 function getHabitsToolsList() {
   return [
@@ -15842,13 +15837,13 @@ async function handleHabitsCheck(args, ctx) {
     } catch {
     }
   }
-  const markerPath = path28.join(ctx.rootDir, ".paradigm", ".habits-blocking");
+  const markerPath = path29.join(ctx.rootDir, ".paradigm", ".habits-blocking");
   try {
     if (trigger === "on-stop" && evaluation.blocksCompletion) {
       const blocking = evaluation.evaluations.filter((e) => e.result === "skipped" && e.habit.severity === "block").map((e) => `${e.habit.name}: ${e.reason}`);
-      fs25.writeFileSync(markerPath, blocking.join("\n"), "utf8");
+      fs26.writeFileSync(markerPath, blocking.join("\n"), "utf8");
     } else if (trigger === "on-stop") {
-      if (fs25.existsSync(markerPath)) fs25.unlinkSync(markerPath);
+      if (fs26.existsSync(markerPath)) fs26.unlinkSync(markerPath);
     }
   } catch {
   }
@@ -16061,7 +16056,7 @@ async function handlePracticeContext(args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/fallback-grep.ts
-import * as path29 from "path";
+import * as path30 from "path";
 import { execSync as execSync3 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
@@ -16090,7 +16085,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path29.relative(rootDir, filePath);
+      const relativePath = path30.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -16335,7 +16330,20 @@ function registerTools(server, getContext2, reloadContext2) {
           // Lore tools
           ...getLoreToolsList(),
           // Habits tools
-          ...getHabitsToolsList()
+          ...getHabitsToolsList(),
+          // Plugin update check
+          {
+            name: "paradigm_plugin_check",
+            description: "Check for updates to installed Claude Code plugins. Reports which marketplace clones have newer remote commits and which cached versions are stale.",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
+            }
+          }
         ]
       };
     }
@@ -16349,8 +16357,11 @@ function registerTools(server, getContext2, reloadContext2) {
       const tracker2 = getSessionTracker();
       tracker2.setRootDir(ctx.rootDir);
       let recoveryPreamble = null;
+      let updateNotice = null;
       if (!tracker2.hasRecoveredThisSession()) {
         recoveryPreamble = buildRecoveryPreamble(ctx.rootDir);
+        updateNotice = getPluginUpdateNotice();
+        schedulePluginUpdateCheck();
         tracker2.markRecovered();
       }
       const toolResult = await (async () => {
@@ -16783,6 +16794,37 @@ function registerTools(server, getContext2, reloadContext2) {
               }]
             };
           }
+          case "paradigm_plugin_check": {
+            const { runPluginUpdateCheck } = await import("./plugin-update-checker-EWT7YMDF.js");
+            const results = await runPluginUpdateCheck();
+            const updatable = results.filter((r) => r.hasRemoteUpdate || r.hasCacheStale);
+            if (updatable.length === 0) {
+              const msg = results.length === 0 ? "No Claude Code plugins found in ~/.claude/plugins/marketplaces/." : "All installed plugins are up to date.";
+              trackToolCall(msg.length, name);
+              return { content: [{ type: "text", text: msg }] };
+            }
+            const lines = ["Plugin updates available:\n"];
+            const pullCmds = [];
+            for (const r of updatable) {
+              if (r.hasRemoteUpdate) {
+                lines.push(`  ${r.plugin} (${r.repo}): remote has newer commits`);
+                pullCmds.push(`git -C ${r.marketplacePath} pull origin main`);
+              } else if (r.hasCacheStale) {
+                lines.push(`  ${r.plugin} (${r.repo}): ${r.installedVersion} \u2192 ${r.localVersion} (restart needed)`);
+              }
+            }
+            if (pullCmds.length > 0) {
+              lines.push(`
+Update command:
+  ${pullCmds.join(" && \\\n  ")}`);
+              lines.push("\nAfter running, restart the session to apply updates.");
+            } else {
+              lines.push("\nRestart the session to apply cached updates.");
+            }
+            const pluginText = lines.join("\n");
+            trackToolCall(pluginText.length, name);
+            return { content: [{ type: "text", text: pluginText }] };
+          }
           default: {
             if (name === "paradigm_navigate") {
               const result = await handleNavigateTool(name, args, ctx);
@@ -16915,10 +16957,11 @@ function registerTools(server, getContext2, reloadContext2) {
           }
         }
       })();
-      if (recoveryPreamble) {
+      if (recoveryPreamble || updateNotice) {
         const first = toolResult.content?.[0];
         if (first && typeof first === "object" && "text" in first && typeof first.text === "string") {
-          first.text = recoveryPreamble + "\n\n" + first.text;
+          const preamble = [updateNotice, recoveryPreamble].filter(Boolean).join("\n\n");
+          first.text = preamble + "\n\n" + first.text;
         }
       }
       return toolResult;