@a-company/paradigm 2.0.13 → 3.0.1

package/dist/mcp.js

@@ -525,15 +525,15 @@ var require_sql_wasm = __commonJS({
         "undefined" != typeof __filename ? ya = __filename : ba && (ya = self.location.href);
         var za = "", Aa, Ba;
         if (ca) {
-          var fs22 = __require("fs");
+          var fs24 = __require("fs");
           za = __dirname + "/";
           Ba = (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs22.readFileSync(a);
+            return fs24.readFileSync(a);
           };
           Aa = async (a) => {
             a = Ca(a) ? new URL(a) : a;
-            return fs22.readFileSync(a, void 0);
+            return fs24.readFileSync(a, void 0);
           };
           1 < process.argv.length && (wa = process.argv[1].replace(/\\/g, "/"));
           process.argv.slice(2);
@@ -815,7 +815,7 @@ var require_sql_wasm = __commonJS({
               if (ca) {
                 var b = Buffer.alloc(256), c = 0, d = process.stdin.fd;
                 try {
-                  c = fs22.readSync(d, b, 0, 256);
+                  c = fs24.readSync(d, b, 0, 256);
                 } catch (e) {
                   if (e.toString().includes("EOF")) c = 0;
                   else throw e;
@@ -2323,12 +2323,12 @@ function parsePurposeFileDetailed(filePath) {
   const parseResult = PurposeFileSchema.safeParse(data);
   if (!parseResult.success) {
     for (const issue of parseResult.error.issues) {
-      const path26 = issue.path.join(".");
+      const path27 = issue.path.join(".");
       const message = issue.message;
-      errors.push(`Schema error at ${path26 || "/"}: ${message}`);
+      errors.push(`Schema error at ${path27 || "/"}: ${message}`);
       detailedErrors.push({
         message,
-        path: path26 || "/",
+        path: path27 || "/",
         type: "schema"
       });
     }
@@ -2716,19 +2716,19 @@ function validatePurposeFile(data, filePath) {
   };
 }
 function validatePurposeItem(id, item, itemType, prefix, issues) {
-  const path26 = `${itemType}s.${id}`;
+  const path27 = `${itemType}s.${id}`;
   if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(id)) {
     issues.push({
       type: "warning",
       message: `${prefix}${itemType} ID "${id}" should use alphanumeric characters and hyphens`,
-      path: path26
+      path: path27
     });
   }
   if (!item.description || item.description.trim() === "") {
     issues.push({
       type: "warning",
       message: `${prefix}${itemType} "${id}" has no description`,
-      path: path26
+      path: path27
     });
   }
   if (item.endpoints) {
@@ -2737,7 +2737,7 @@ function validatePurposeItem(id, item, itemType, prefix, issues) {
         issues.push({
           type: "warning",
           message: `${prefix}Endpoint "${endpoint}" in ${itemType} "${id}" may not be in standard format (e.g., "GET /api/users")`,
-          path: `${path26}.endpoints`
+          path: `${path27}.endpoints`
         });
       }
     }
@@ -4278,8 +4278,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path26 = uri.replace("paradigm://", "");
-    const firstPart = path26.split("/")[0];
+    const path27 = uri.replace("paradigm://", "");
+    const firstPart = path27.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -4510,6 +4510,10 @@ function getContextToolsList() {
             description: "Context window size in tokens (default: 200000)"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -4548,6 +4552,10 @@ function getContextToolsList() {
           }
         },
         required: ["summary"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -4556,6 +4564,10 @@ function getContextToolsList() {
       inputSchema: {
         type: "object",
         properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -4564,6 +4576,52 @@ function getContextToolsList() {
       inputSchema: {
         type: "object",
         properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_session_checkpoint",
+      description: "Save a cognitive-transition checkpoint for crash recovery. Call when transitioning between phases (planning \u2192 implementing \u2192 validating \u2192 complete).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phase: {
+            type: "string",
+            enum: ["planning", "implementing", "validating", "complete"],
+            description: "Current workflow phase"
+          },
+          context: {
+            type: "string",
+            description: "What's top-of-mind right now (1-3 sentences)"
+          },
+          plan: {
+            type: "string",
+            description: "Optional: the current plan or approach"
+          },
+          modifiedFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: files modified so far"
+          },
+          symbolsTouched: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: symbols touched so far"
+          },
+          decisions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: key decisions made so far"
+          }
+        },
+        required: ["phase", "context"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -6194,6 +6252,10 @@ function getWisdomToolsList() {
           }
         },
         required: ["symbols"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -6275,6 +6337,33 @@ function getWisdomToolsList() {
           }
         },
         required: ["type", "id", "symbols"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_wisdom_promote",
+      description: "Promote a project-local antipattern or decision to global scope (~/.paradigm/wisdom/). Makes it available across all projects.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["antipattern", "decision"],
+            description: "Type of wisdom to promote"
+          },
+          id: {
+            type: "string",
+            description: "ID of the antipattern or decision to promote"
+          }
+        },
+        required: ["type", "id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -6311,6 +6400,10 @@ function getWisdomToolsList() {
             description: 'General area to find experts for (e.g., "payments", "auth")'
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -6574,6 +6667,10 @@ function getHistoryToolsList() {
           }
         },
         required: ["symbols"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -6616,6 +6713,10 @@ function getHistoryToolsList() {
           }
         },
         required: ["type", "symbols", "description"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -6644,6 +6745,10 @@ function getHistoryToolsList() {
           }
         },
         required: ["result"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -6659,6 +6764,10 @@ function getHistoryToolsList() {
           }
         },
         required: ["symbols"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -6880,7 +6989,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path26]) => sym.toLowerCase().includes(targetLower) || path26.toLowerCase().includes(targetLower)
+      ([sym, path27]) => sym.toLowerCase().includes(targetLower) || path27.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -7035,6 +7144,10 @@ var navigateTool = {
       }
     },
     required: ["intent"]
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false
   }
 };
 function getNavigateToolsList() {
@@ -7202,7 +7315,7 @@ function generateMinimalNavigator(ctx) {
   };
 }
 
-// ../sentinel/dist/chunk-CL7K7CMH.js
+// ../sentinel/dist/chunk-WNZBSJR7.js
 var import_sql = __toESM(require_sql_wasm(), 1);
 
 // ../sentinel/node_modules/uuid/dist/esm-node/rng.js
@@ -7252,7 +7365,7 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// ../sentinel/dist/chunk-CL7K7CMH.js
+// ../sentinel/dist/chunk-WNZBSJR7.js
 import * as path14 from "path";
 import * as fs12 from "fs";
 var SCHEMA_VERSION = 1;
@@ -7272,8 +7385,8 @@ var SentinelStorage = class {
     this.dbPath = dbPath || this.getDefaultDbPath();
   }
   getDefaultDbPath() {
-    const paradigmDir = process.env.PARADIGM_DATA_DIR || path14.join(process.cwd(), ".paradigm", "sentinel");
-    return path14.join(paradigmDir, "sentinel.db");
+    const dataDir = process.env.SENTINEL_DATA_DIR || process.env.PARADIGM_DATA_DIR || path14.join(process.cwd(), ".paradigm", "sentinel");
+    return path14.join(dataDir, "sentinel.db");
   }
   createSchema() {
     if (!this.db) return;
@@ -8252,8 +8365,8 @@ var SentinelStorage = class {
 };
 
 // ../sentinel/dist/index.js
-import * as path22 from "path";
-import * as fs32 from "fs";
+import * as path15 from "path";
+import * as fs13 from "fs";
 import { fileURLToPath } from "url";
 var DEFAULT_CONFIG = {
   minScore: 30,
@@ -8474,6 +8587,27 @@ var PatternMatcher = class {
     return pattern.pattern.environment.includes(incident.environment);
   }
 };
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path15.dirname(__filename2);
+function loadUniversalPatterns() {
+  const filePath = path15.join(__dirname2, "universal-patterns.json");
+  const content = fs13.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadParadigmPatterns() {
+  const filePath = path15.join(__dirname2, "paradigm-patterns.json");
+  const content = fs13.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadAllSeedPatterns() {
+  const universal = loadUniversalPatterns();
+  const paradigm = loadParadigmPatterns();
+  return {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    patterns: [...universal.patterns, ...paradigm.patterns]
+  };
+}
 var TimelineBuilder = class {
   /**
    * Build a timeline from an incident with flow position
@@ -9247,27 +9381,6 @@ var PatternSuggester = class {
     return "low";
   }
 };
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path22.dirname(__filename2);
-function loadUniversalPatterns() {
-  const filePath = path22.join(__dirname2, "universal-patterns.json");
-  const content = fs32.readFileSync(filePath, "utf-8");
-  return JSON.parse(content);
-}
-function loadParadigmPatterns() {
-  const filePath = path22.join(__dirname2, "paradigm-patterns.json");
-  const content = fs32.readFileSync(filePath, "utf-8");
-  return JSON.parse(content);
-}
-function loadAllSeedPatterns() {
-  const universal = loadUniversalPatterns();
-  const paradigm = loadParadigmPatterns();
-  return {
-    version: "1.0.0",
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    patterns: [...universal.patterns, ...paradigm.patterns]
-  };
-}
 
 // ../paradigm-mcp/src/tools/sentinel.ts
 var storage = null;
@@ -9322,6 +9435,10 @@ function getSentinelToolsList() {
             description: "Max results (default: 10)"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -9344,6 +9461,10 @@ function getSentinelToolsList() {
           }
         },
         required: ["incidentId"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -9366,6 +9487,10 @@ function getSentinelToolsList() {
           }
         },
         required: ["incidentId"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -9388,6 +9513,10 @@ function getSentinelToolsList() {
             description: "Filter by source"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -9445,6 +9574,10 @@ function getSentinelToolsList() {
           }
         },
         required: ["id", "name", "pattern", "resolution"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -9490,6 +9623,10 @@ function getSentinelToolsList() {
           }
         },
         required: ["error", "symbols", "environment"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -9507,6 +9644,10 @@ function getSentinelToolsList() {
             description: "Get health for specific symbol"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -9524,6 +9665,10 @@ function getSentinelToolsList() {
             description: "Min similar incidents for suggestion"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -9853,17 +9998,17 @@ async function handleSentinelTool(name, args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/flows.ts
-import * as fs14 from "fs";
-import * as path16 from "path";
+import * as fs15 from "fs";
+import * as path17 from "path";
 import * as yaml8 from "js-yaml";
 
 // ../paradigm-mcp/src/utils/flow-loader.ts
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs14 from "fs";
+import * as path16 from "path";
 var FLOW_CACHE_TTL_MS = 30 * 1e3;
 var flowCache = /* @__PURE__ */ new Map();
 async function loadFlowIndex(rootDir) {
-  const absoluteRoot = path15.resolve(rootDir);
+  const absoluteRoot = path16.resolve(rootDir);
   const cached = flowCache.get(absoluteRoot);
   if (cached && Date.now() - cached.loadedAt < FLOW_CACHE_TTL_MS) {
     return cached.index;
@@ -9878,12 +10023,12 @@ async function loadFlowIndex(rootDir) {
   return index;
 }
 async function loadFlowIndexFresh(rootDir) {
-  const flowIndexPath = path15.join(rootDir, ".paradigm", "flow-index.json");
-  if (!fs13.existsSync(flowIndexPath)) {
+  const flowIndexPath = path16.join(rootDir, ".paradigm", "flow-index.json");
+  if (!fs14.existsSync(flowIndexPath)) {
     return null;
   }
   try {
-    const content = fs13.readFileSync(flowIndexPath, "utf8");
+    const content = fs14.readFileSync(flowIndexPath, "utf8");
     return JSON.parse(content);
   } catch (error) {
     console.error("[flow-loader] Error parsing flow-index.json:", error);
@@ -9964,6 +10109,10 @@ function getFlowsToolsList() {
           }
         },
         required: ["symbol"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -9981,6 +10130,10 @@ function getFlowsToolsList() {
             description: "Deep check: verify actions and signals exist in codebase (default: false)"
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -10047,11 +10200,11 @@ flows:
     }
     case "paradigm_flow_validate": {
       const { flowId, checkImplementation = false } = args;
-      const flowsPath = path16.join(ctx.rootDir, ".paradigm", "flows.yaml");
+      const flowsPath = path17.join(ctx.rootDir, ".paradigm", "flows.yaml");
       let flowsConfig = null;
-      if (fs14.existsSync(flowsPath)) {
+      if (fs15.existsSync(flowsPath)) {
         try {
-          const content = fs14.readFileSync(flowsPath, "utf-8");
+          const content = fs15.readFileSync(flowsPath, "utf-8");
           flowsConfig = yaml8.load(content);
         } catch (e) {
           const text2 = JSON.stringify({
@@ -10087,11 +10240,11 @@ flows:
         }, null, 2);
         return { handled: true, text: text2 };
       }
-      const portalPath = path16.join(ctx.rootDir, "portal.yaml");
+      const portalPath = path17.join(ctx.rootDir, "portal.yaml");
       let declaredGates = [];
-      if (fs14.existsSync(portalPath)) {
+      if (fs15.existsSync(portalPath)) {
         try {
-          const portalContent = fs14.readFileSync(portalPath, "utf-8");
+          const portalContent = fs15.readFileSync(portalPath, "utf-8");
           const portalConfig = yaml8.load(portalContent);
           if (portalConfig?.gates) {
             declaredGates = Object.keys(portalConfig.gates).map(
@@ -10194,13 +10347,13 @@ function parseSymbolSimple(symbol) {
 }
 
 // ../paradigm-mcp/src/utils/fixtures-loader.ts
-import * as fs15 from "fs";
-import * as path17 from "path";
+import * as fs16 from "fs";
+import * as path18 from "path";
 import * as yaml9 from "js-yaml";
 var FIXTURES_CACHE_TTL_MS = 60 * 1e3;
 var fixturesCache = /* @__PURE__ */ new Map();
 async function loadFixtures(rootDir) {
-  const absoluteRoot = path17.resolve(rootDir);
+  const absoluteRoot = path18.resolve(rootDir);
   const cached = fixturesCache.get(absoluteRoot);
   if (cached && Date.now() - cached.loadedAt < FIXTURES_CACHE_TTL_MS) {
     return cached.fixtures;
@@ -10215,12 +10368,12 @@ async function loadFixtures(rootDir) {
   return fixtures;
 }
 async function loadFixturesFresh(rootDir) {
-  const fixturesPath = path17.join(rootDir, ".paradigm", "fixtures.yaml");
-  if (!fs15.existsSync(fixturesPath)) {
+  const fixturesPath = path18.join(rootDir, ".paradigm", "fixtures.yaml");
+  if (!fs16.existsSync(fixturesPath)) {
     return null;
   }
   try {
-    const content = fs15.readFileSync(fixturesPath, "utf8");
+    const content = fs16.readFileSync(fixturesPath, "utf8");
     return yaml9.load(content);
   } catch (error) {
     console.error("[fixtures-loader] Error parsing fixtures.yaml:", error);
@@ -10276,6 +10429,10 @@ function getFixturesToolsList() {
             description: 'Specific fixture name within the category (e.g., "admin", "createTask")'
           }
         }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -10367,8 +10524,8 @@ payloads:
 }
 
 // ../paradigm-mcp/src/tools/orchestration.ts
-import * as fs16 from "fs";
-import * as path18 from "path";
+import * as fs17 from "fs";
+import * as path19 from "path";
 import * as yaml10 from "js-yaml";
 var SYMBOL_PATTERN = /[@#$%^!?&~][a-zA-Z0-9_-]+/g;
 var DEFAULT_MODELS = {
@@ -10584,6 +10741,10 @@ Examples:
           }
         },
         required: ["task"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -10611,6 +10772,10 @@ Examples:
           }
         },
         required: ["agent", "task"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -11217,23 +11382,23 @@ function suggestAgentsForTask(task, agents) {
   return suggestions.sort((a, b) => scoreMap[b.confidence] - scoreMap[a.confidence]);
 }
 function loadAgentsManifest(rootDir) {
-  const manifestPath = path18.join(rootDir, ".paradigm", "agents.yaml");
-  if (!fs16.existsSync(manifestPath)) {
+  const manifestPath = path19.join(rootDir, ".paradigm", "agents.yaml");
+  if (!fs17.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const content = fs16.readFileSync(manifestPath, "utf-8");
+    const content = fs17.readFileSync(manifestPath, "utf-8");
     return yaml10.load(content);
   } catch {
     return null;
   }
 }
 function logOrchestration(rootDir, orchestrationId, task, plan) {
-  const orchestrationsDir = path18.join(rootDir, ".paradigm", "orchestrations");
-  if (!fs16.existsSync(orchestrationsDir)) {
-    fs16.mkdirSync(orchestrationsDir, { recursive: true });
+  const orchestrationsDir = path19.join(rootDir, ".paradigm", "orchestrations");
+  if (!fs17.existsSync(orchestrationsDir)) {
+    fs17.mkdirSync(orchestrationsDir, { recursive: true });
   }
-  const logPath = path18.join(orchestrationsDir, `${orchestrationId}.yaml`);
+  const logPath = path19.join(orchestrationsDir, `${orchestrationId}.yaml`);
   const logContent = {
     id: orchestrationId,
     task,
@@ -11246,31 +11411,31 @@ function logOrchestration(rootDir, orchestrationId, task, plan) {
     stages: plan.stages
   };
   try {
-    fs16.writeFileSync(logPath, yaml10.dump(logContent));
+    fs17.writeFileSync(logPath, yaml10.dump(logContent));
   } catch {
   }
 }
 
 // ../paradigm-mcp/src/tools/tags.ts
-import * as fs17 from "fs";
-import * as path19 from "path";
+import * as fs18 from "fs";
+import * as path20 from "path";
 import * as yaml11 from "js-yaml";
 function loadTagBank(rootDir) {
-  const tagPath = path19.join(rootDir, ".paradigm", "tags.yaml");
-  if (!fs17.existsSync(tagPath)) {
+  const tagPath = path20.join(rootDir, ".paradigm", "tags.yaml");
+  if (!fs18.existsSync(tagPath)) {
     return null;
   }
   try {
-    const content = fs17.readFileSync(tagPath, "utf-8");
+    const content = fs18.readFileSync(tagPath, "utf-8");
     return yaml11.load(content);
   } catch {
     return null;
   }
 }
 function saveTagBank(rootDir, tagBank) {
-  const tagPath = path19.join(rootDir, ".paradigm", "tags.yaml");
+  const tagPath = path20.join(rootDir, ".paradigm", "tags.yaml");
   const content = yaml11.dump(tagBank, { lineWidth: -1 });
-  fs17.writeFileSync(tagPath, content, "utf-8");
+  fs18.writeFileSync(tagPath, content, "utf-8");
 }
 function getTagsToolsList() {
   return [
@@ -11300,6 +11465,10 @@ function getTagsToolsList() {
           }
         },
         required: ["action"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -11332,6 +11501,10 @@ function getTagsToolsList() {
           }
         },
         required: ["tag", "description", "reason"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
       }
     },
     {
@@ -11346,6 +11519,10 @@ function getTagsToolsList() {
           }
         },
         required: ["aspect"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -11585,12 +11762,12 @@ async function handleTagsTool(name, args, ctx) {
       const anchors = entry.anchors || [];
       const anchorResults = [];
       for (const anchor of anchors) {
-        const filePath = path19.isAbsolute(anchor.path) ? anchor.path : path19.join(ctx.rootDir, anchor.path);
-        const exists = fs17.existsSync(filePath);
+        const filePath = path20.isAbsolute(anchor.path) ? anchor.path : path20.join(ctx.rootDir, anchor.path);
+        const exists = fs18.existsSync(filePath);
         let lineCount;
         if (exists) {
           try {
-            const content = fs17.readFileSync(filePath, "utf-8");
+            const content = fs18.readFileSync(filePath, "utf-8");
             const lines = content.split("\n");
             if (typeof anchor.lines === "number") {
               lineCount = 1;
@@ -11660,8 +11837,8 @@ async function handleTagsTool(name, args, ctx) {
 }
 
 // ../paradigm-mcp/src/utils/purpose-writer.ts
-import * as fs18 from "fs";
-import * as path20 from "path";
+import * as fs19 from "fs";
+import * as path21 from "path";
 var SYMBOL_PREFIXES = ["#", "$", "^", "!", "~"];
 function stripSymbolPrefix(name) {
   if (name.length > 1 && SYMBOL_PREFIXES.includes(name[0])) {
@@ -11674,14 +11851,14 @@ function ensurePrefix(name, prefix) {
   return `${prefix}${stripped}`;
 }
 function resolvePurposeFilePath(fileOrDir, rootDir) {
-  const resolved = path20.isAbsolute(fileOrDir) ? fileOrDir : path20.resolve(rootDir, fileOrDir);
+  const resolved = path21.isAbsolute(fileOrDir) ? fileOrDir : path21.resolve(rootDir, fileOrDir);
   if (resolved.endsWith(".purpose")) {
     return resolved;
   }
-  return path20.join(resolved, ".purpose");
+  return path21.join(resolved, ".purpose");
 }
 function readPurposeFile(filePath) {
-  if (!fs18.existsSync(filePath)) {
+  if (!fs19.existsSync(filePath)) {
     return {};
   }
   const result = parsePurposeFileDetailed(filePath);
@@ -11691,12 +11868,12 @@ function readPurposeFile(filePath) {
   return result.data;
 }
 function writePurposeFile(filePath, data) {
-  const dir = path20.dirname(filePath);
-  if (!fs18.existsSync(dir)) {
-    fs18.mkdirSync(dir, { recursive: true });
+  const dir = path21.dirname(filePath);
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true });
   }
   const content = serializePurposeFile(data);
-  fs18.writeFileSync(filePath, content, "utf8");
+  fs19.writeFileSync(filePath, content, "utf8");
 }
 function normalizeToRecord(items) {
   if (!items) return {};
@@ -11885,18 +12062,18 @@ function renameInRefArrays(item, oldRef, newRef) {
 }
 
 // ../paradigm-mcp/src/utils/portal-writer.ts
-import * as fs19 from "fs";
-import * as path21 from "path";
+import * as fs20 from "fs";
+import * as path22 from "path";
 import * as yaml12 from "js-yaml";
 function readPortalFile(rootDir) {
-  const filePath = path21.join(rootDir, "portal.yaml");
-  if (!fs19.existsSync(filePath)) {
+  const filePath = path22.join(rootDir, "portal.yaml");
+  if (!fs20.existsSync(filePath)) {
     return {
       data: { version: "1.0.0", gates: {} },
       filePath
     };
   }
-  const content = fs19.readFileSync(filePath, "utf8");
+  const content = fs20.readFileSync(filePath, "utf8");
   const data = yaml12.load(content);
   return {
     data: data || { version: "1.0.0", gates: {} },
@@ -11910,7 +12087,7 @@ function writePortalFile(filePath, data) {
     noRefs: true,
     sortKeys: false
   });
-  fs19.writeFileSync(filePath, content, "utf8");
+  fs20.writeFileSync(filePath, content, "utf8");
 }
 function addGateToPortal(rootDir, params) {
   const { data, filePath } = readPortalFile(rootDir);
@@ -11979,6 +12156,10 @@ var purposeInitTool = {
       }
     },
     required: ["purposeFile", "name"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddComponentTool = {
@@ -12049,6 +12230,10 @@ var purposeAddComponentTool = {
       }
     },
     required: ["purposeFile", "id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddAspectTool = {
@@ -12090,6 +12275,10 @@ var purposeAddAspectTool = {
       }
     },
     required: ["purposeFile", "id", "description", "anchors"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddSignalTool = {
@@ -12135,6 +12324,10 @@ var purposeAddSignalTool = {
       }
     },
     required: ["purposeFile", "id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddFlowTool = {
@@ -12185,6 +12378,10 @@ var purposeAddFlowTool = {
       }
     },
     required: ["purposeFile", "id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddGateTool = {
@@ -12222,6 +12419,10 @@ var purposeAddGateTool = {
       }
     },
     required: ["purposeFile", "id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeAddStateTool = {
@@ -12255,6 +12456,10 @@ var purposeAddStateTool = {
       }
     },
     required: ["purposeFile", "id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeLinkTool = {
@@ -12303,6 +12508,10 @@ var purposeLinkTool = {
       }
     },
     required: ["purposeFile", "componentId"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeRemoveTool = {
@@ -12326,6 +12535,10 @@ var purposeRemoveTool = {
       }
     },
     required: ["purposeFile", "section", "id"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true
   }
 };
 var purposeRenameTool = {
@@ -12349,6 +12562,10 @@ var purposeRenameTool = {
       }
     },
     required: ["oldId", "newId", "symbolType"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var portalAddGateTool = {
@@ -12406,6 +12623,10 @@ var portalAddGateTool = {
       }
     },
     required: ["id", "description"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var portalAddRouteTool = {
@@ -12430,6 +12651,10 @@ var portalAddRouteTool = {
       }
     },
     required: ["route", "method", "gates"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false
   }
 };
 var purposeValidateTool = {
@@ -12447,6 +12672,10 @@ var purposeValidateTool = {
         description: "Also validate portal.yaml (default: true)"
       }
     }
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false
   }
 };
 function getPurposePortalToolsList() {
@@ -12978,7 +13207,7 @@ async function handleValidate(args, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/pm.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path23 from "path";
 var SYMBOL_PATTERN2 = /[@#$%^!?&~][a-zA-Z][a-zA-Z0-9_-]*/g;
 var ROUTE_KEYWORDS = [
@@ -13015,6 +13244,10 @@ function getPmToolsList() {
           }
         },
         required: ["task"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     },
     {
@@ -13035,6 +13268,10 @@ function getPmToolsList() {
           }
         },
         required: ["filesModified", "symbolsTouched"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
       }
     }
   ];
@@ -13158,10 +13395,10 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
   const declaredRoutes = ctx.gateConfig?.routes ? Object.keys(ctx.gateConfig.routes) : [];
   for (const file of filesModified) {
     const absPath = path23.isAbsolute(file) ? file : path23.join(ctx.rootDir, file);
-    if (!fs20.existsSync(absPath)) continue;
+    if (!fs21.existsSync(absPath)) continue;
     let content;
     try {
-      content = fs20.readFileSync(absPath, "utf-8");
+      content = fs21.readFileSync(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -13247,7 +13484,7 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
           } else {
             for (const anchor of anchors) {
               const filePath = path23.isAbsolute(anchor.path) ? anchor.path : path23.join(ctx.rootDir, anchor.path);
-              if (!fs20.existsSync(filePath)) {
+              if (!fs21.existsSync(filePath)) {
                 violations.push({
                   type: "stale-aspect",
                   severity: "warning",
@@ -13300,7 +13537,7 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path24 from "path";
 import * as yaml13 from "js-yaml";
 
@@ -13608,6 +13845,10 @@ function getReindexToolsList() {
       inputSchema: {
         type: "object",
         properties: {}
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true
       }
     }
   ];
@@ -13638,8 +13879,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
   }
   const projectName = ctx?.projectName || path24.basename(rootDir);
   const paradigmDir = path24.join(rootDir, ".paradigm");
-  if (!fs21.existsSync(paradigmDir)) {
-    fs21.mkdirSync(paradigmDir, { recursive: true });
+  if (!fs22.existsSync(paradigmDir)) {
+    fs22.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -13650,11 +13891,11 @@ async function rebuildStaticFiles(rootDir, ctx) {
     { projectName }
   );
   const scanIndexPath = path24.join(paradigmDir, "scan-index.json");
-  fs21.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  fs22.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
   const navigatorPath = path24.join(paradigmDir, "navigator.yaml");
-  fs21.writeFileSync(
+  fs22.writeFileSync(
     navigatorPath,
     yaml13.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
     "utf8"
@@ -13664,7 +13905,7 @@ async function rebuildStaticFiles(rootDir, ctx) {
   let flowCount = 0;
   if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
     const flowIndexPath = path24.join(paradigmDir, "flow-index.json");
-    fs21.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    fs22.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -13693,7 +13934,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs21.existsSync(path24.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs22.existsSync(path24.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 || "@" };
@@ -13704,7 +13945,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs21.existsSync(path24.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs22.existsSync(path24.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -13721,9 +13962,9 @@ function buildSkipPatterns(rootDir) {
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
   const gitignorePath = path24.join(rootDir, ".gitignore");
-  if (fs21.existsSync(gitignorePath)) {
+  if (fs22.existsSync(gitignorePath)) {
     try {
-      const content = fs21.readFileSync(gitignorePath, "utf8");
+      const content = fs22.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);
@@ -13787,7 +14028,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs21.readFileSync(filePath, "utf8");
+      const content = fs22.readFileSync(filePath, "utf8");
       const data = yaml13.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
@@ -13869,8 +14110,478 @@ function indexFlowSymbols(flowId, steps, symbolToFlows) {
   }
 }
 
-// ../paradigm-mcp/src/tools/fallback-grep.ts
+// ../paradigm-mcp/src/utils/lore-loader.ts
+import * as fs23 from "fs";
 import * as path25 from "path";
+import * as yaml14 from "js-yaml";
+var LORE_DIR = ".paradigm/lore";
+var ENTRIES_DIR = "entries";
+var TIMELINE_FILE = "timeline.yaml";
+async function loadLoreEntries(rootDir, filter) {
+  const entriesPath = path25.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs23.existsSync(entriesPath)) {
+    return [];
+  }
+  const entries = [];
+  const dateDirs = fs23.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 = path25.join(entriesPath, dateDir);
+    const files = fs23.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs23.readFileSync(path25.join(dirPath, file), "utf8");
+        const entry = yaml14.load(content);
+        entries.push(entry);
+      } catch {
+      }
+    }
+  }
+  return filter ? applyFilter(entries, filter) : entries;
+}
+async function loadLoreTimeline(rootDir) {
+  const timelinePath = path25.join(rootDir, LORE_DIR, TIMELINE_FILE);
+  if (!fs23.existsSync(timelinePath)) {
+    return null;
+  }
+  try {
+    const content = fs23.readFileSync(timelinePath, "utf8");
+    return yaml14.load(content);
+  } catch {
+    return null;
+  }
+}
+async function recordLoreEntry(rootDir, entry) {
+  const lorePath = path25.join(rootDir, LORE_DIR);
+  const dateStr = entry.timestamp.slice(0, 10);
+  const datePath = path25.join(lorePath, ENTRIES_DIR, dateStr);
+  if (!fs23.existsSync(datePath)) {
+    fs23.mkdirSync(datePath, { recursive: true });
+  }
+  if (!entry.id) {
+    entry.id = generateLoreId(rootDir, dateStr);
+  }
+  const entryPath = path25.join(datePath, `${entry.id}.yaml`);
+  fs23.writeFileSync(entryPath, yaml14.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return entry.id;
+}
+async function rebuildTimeline(rootDir) {
+  const lorePath = path25.join(rootDir, LORE_DIR);
+  const entriesPath = path25.join(lorePath, ENTRIES_DIR);
+  if (!fs23.existsSync(entriesPath)) return;
+  const authors = /* @__PURE__ */ new Set();
+  let entryCount = 0;
+  let lastUpdated = "";
+  const dateDirs = fs23.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+  for (const dateDir of dateDirs) {
+    const dirPath = path25.join(entriesPath, dateDir);
+    const files = fs23.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const content = fs23.readFileSync(path25.join(dirPath, file), "utf8");
+        const entry = yaml14.load(content);
+        authors.add(entry.author.id);
+        entryCount++;
+        if (!lastUpdated || entry.timestamp > lastUpdated) {
+          lastUpdated = entry.timestamp;
+        }
+      } catch {
+      }
+    }
+  }
+  let project = "unknown";
+  const configPath = path25.join(rootDir, ".paradigm", "config.yaml");
+  if (fs23.existsSync(configPath)) {
+    try {
+      const config = yaml14.load(fs23.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 (!fs23.existsSync(lorePath)) {
+    fs23.mkdirSync(lorePath, { recursive: true });
+  }
+  fs23.writeFileSync(
+    path25.join(lorePath, TIMELINE_FILE),
+    yaml14.dump(timeline, { lineWidth: -1, noRefs: true })
+  );
+}
+function applyFilter(entries, filter) {
+  let result = entries;
+  if (filter.author) {
+    result = result.filter((e) => e.author.id === filter.author);
+  }
+  if (filter.authorType) {
+    result = result.filter((e) => e.author.type === filter.authorType);
+  }
+  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) {
+  const datePath = path25.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  if (!fs23.existsSync(datePath)) {
+    return `L-${dateStr}-001`;
+  }
+  const existing = fs23.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;
+  });
+  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `L-${dateStr}-${String(next).padStart(3, "0")}`;
+}
+
+// ../paradigm-mcp/src/tools/lore.ts
+function getLoreToolsList() {
+  return [
+    {
+      name: "paradigm_lore_search",
+      description: "Search lore entries by symbol, author, date range, type, or tags. Returns project history records.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: 'Filter by symbol (e.g., "#sentinel-sdk", "^authenticated")'
+          },
+          author: {
+            type: "string",
+            description: 'Filter by author ID (e.g., "ascend", "claude-opus-4")'
+          },
+          authorType: {
+            type: "string",
+            enum: ["human", "agent"],
+            description: "Filter by author type"
+          },
+          type: {
+            type: "string",
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            description: "Filter by entry type"
+          },
+          dateFrom: {
+            type: "string",
+            description: 'Filter from date (ISO 8601, e.g., "2026-02-20")'
+          },
+          dateTo: {
+            type: "string",
+            description: "Filter to date (ISO 8601)"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by tags (OR logic)"
+          },
+          hasReview: {
+            type: "boolean",
+            description: "Filter for entries with/without reviews"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results (default: 20)"
+          },
+          offset: {
+            type: "number",
+            description: "Offset for pagination"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_lore_record",
+      description: "Record a new lore entry (agent session, decision, milestone, etc.). Call after completing significant work.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            description: "Entry type"
+          },
+          title: {
+            type: "string",
+            description: 'Short title (e.g., "Built Sentinel Phase 1")'
+          },
+          summary: {
+            type: "string",
+            description: "2-3 sentence narrative summary"
+          },
+          symbols_touched: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Symbols affected (e.g., ["#sentinel-sdk", "^authenticated"])'
+          },
+          symbols_created: {
+            type: "array",
+            items: { type: "string" },
+            description: "New symbols introduced"
+          },
+          files_created: {
+            type: "array",
+            items: { type: "string" },
+            description: "Files created"
+          },
+          files_modified: {
+            type: "array",
+            items: { type: "string" },
+            description: "Files modified"
+          },
+          lines_added: { type: "number", description: "Lines of code added" },
+          lines_removed: { type: "number", description: "Lines of code removed" },
+          commit: { type: "string", description: "Git commit hash" },
+          duration_minutes: { type: "number", description: "Duration in minutes" },
+          decisions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                decision: { type: "string" },
+                rationale: { type: "string" }
+              },
+              required: ["id", "decision", "rationale"]
+            },
+            description: "Decisions made during this work"
+          },
+          errors_encountered: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                description: { type: "string" },
+                resolution: { type: "string" },
+                time_to_fix: { type: "string" }
+              },
+              required: ["description", "resolution"]
+            }
+          },
+          learnings: {
+            type: "array",
+            items: { type: "string" },
+            description: "Key learnings from this work"
+          },
+          verification: {
+            type: "object",
+            properties: {
+              status: {
+                type: "string",
+                enum: ["pass", "fail", "partial", "untested"]
+              },
+              details: {
+                type: "object",
+                description: 'Per-check results (e.g., { "build": "pass", "tests": "fail" })'
+              }
+            }
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for categorization"
+          }
+        },
+        required: ["type", "title", "summary", "symbols_touched"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_lore_timeline",
+      description: "Get lore timeline overview: recent entries, active authors, hot symbols. Call for project history orientation.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Number of recent entries to include (default: 10)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handleLoreTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_lore_search": {
+      const filter = {
+        author: args.author,
+        authorType: args.authorType,
+        symbol: args.symbol,
+        dateFrom: args.dateFrom,
+        dateTo: args.dateTo,
+        type: args.type,
+        tags: args.tags,
+        hasReview: args.hasReview,
+        limit: args.limit || 20,
+        offset: args.offset
+      };
+      const entries = await loadLoreEntries(ctx.rootDir, filter);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          count: entries.length,
+          filter: Object.fromEntries(
+            Object.entries(filter).filter(([, v]) => v !== void 0)
+          ),
+          entries: entries.map(summarizeEntry)
+        }, null, 2)
+      };
+    }
+    case "paradigm_lore_record": {
+      const {
+        type,
+        title,
+        summary,
+        symbols_touched,
+        symbols_created,
+        files_created,
+        files_modified,
+        lines_added,
+        lines_removed,
+        commit,
+        duration_minutes,
+        decisions,
+        errors_encountered,
+        learnings,
+        verification,
+        tags
+      } = args;
+      const entry = {
+        id: "",
+        // Will be generated
+        type,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration_minutes,
+        author: { type: "agent", id: "claude", model: "claude-opus-4-6" },
+        title,
+        summary,
+        symbols_touched,
+        symbols_created,
+        files_created,
+        files_modified,
+        lines_added,
+        lines_removed,
+        commit,
+        decisions,
+        errors_encountered,
+        learnings,
+        verification,
+        tags
+      };
+      const id = await recordLoreEntry(ctx.rootDir, entry);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success: true,
+          id,
+          type,
+          title,
+          message: "Lore entry recorded successfully"
+        })
+      };
+    }
+    case "paradigm_lore_timeline": {
+      const limit = args.limit || 10;
+      const timeline = await loadLoreTimeline(ctx.rootDir);
+      const entries = await loadLoreEntries(ctx.rootDir, { limit });
+      const symbolCounts = {};
+      for (const entry of entries) {
+        for (const sym of entry.symbols_touched) {
+          symbolCounts[sym] = (symbolCounts[sym] || 0) + 1;
+        }
+      }
+      const hotSymbols = Object.entries(symbolCounts).sort(([, a], [, b]) => b - a).slice(0, 10).map(([symbol, count]) => ({ symbol, count }));
+      const authorActivity = {};
+      for (const entry of entries) {
+        const aid = entry.author.id;
+        if (!authorActivity[aid]) {
+          authorActivity[aid] = { count: 0, lastActive: entry.timestamp, type: entry.author.type };
+        }
+        authorActivity[aid].count++;
+        if (entry.timestamp > authorActivity[aid].lastActive) {
+          authorActivity[aid].lastActive = entry.timestamp;
+        }
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          timeline: timeline || { version: "1.0", project: "unknown", entries: 0, last_updated: "", authors: [] },
+          recentEntries: entries.map(summarizeEntry),
+          hotSymbols,
+          authors: Object.entries(authorActivity).map(([id, info]) => ({
+            id,
+            type: info.type,
+            entries: info.count,
+            lastActive: info.lastActive
+          }))
+        }, null, 2)
+      };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+function summarizeEntry(entry) {
+  return {
+    id: entry.id,
+    type: entry.type,
+    title: entry.title,
+    summary: entry.summary,
+    author: entry.author,
+    timestamp: entry.timestamp,
+    duration_minutes: entry.duration_minutes,
+    symbols_touched: entry.symbols_touched,
+    verification: entry.verification?.status,
+    review: entry.review ? {
+      completeness: entry.review.completeness,
+      quality: entry.review.quality
+    } : null,
+    tags: entry.tags
+  };
+}
+
+// ../paradigm-mcp/src/tools/fallback-grep.ts
+import * as path26 from "path";
 import { execSync } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
@@ -13899,7 +14610,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path25.relative(rootDir, filePath);
+      const relativePath = path26.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -14036,6 +14747,10 @@ function registerTools(server, getContext2, reloadContext2) {
                 }
               },
               required: ["query"]
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
             }
           },
           {
@@ -14054,6 +14769,10 @@ function registerTools(server, getContext2, reloadContext2) {
                 }
               },
               required: ["symbol"]
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
             }
           },
           {
@@ -14068,6 +14787,10 @@ function registerTools(server, getContext2, reloadContext2) {
                 }
               },
               required: ["symbol"]
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
             }
           },
           {
@@ -14076,6 +14799,10 @@ function registerTools(server, getContext2, reloadContext2) {
             inputSchema: {
               type: "object",
               properties: {}
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
             }
           },
           {
@@ -14095,6 +14822,10 @@ function registerTools(server, getContext2, reloadContext2) {
                 }
               },
               required: ["route"]
+            },
+            annotations: {
+              readOnlyHint: true,
+              destructiveHint: false
             }
           },
           // Wisdom tools
@@ -14120,7 +14851,9 @@ function registerTools(server, getContext2, reloadContext2) {
           // PM governance tools
           ...getPmToolsList(),
           // Reindex tool
-          ...getReindexToolsList()
+          ...getReindexToolsList(),
+          // Lore tools
+          ...getLoreToolsList()
         ]
       };
     }
@@ -14668,6 +15401,15 @@ function registerTools(server, getContext2, reloadContext2) {
                 };
               }
             }
+            if (name.startsWith("paradigm_lore_")) {
+              const result = await handleLoreTool(name, args, ctx);
+              if (result.handled) {
+                trackToolCall(result.text.length, name);
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
             if (name === "paradigm_reindex") {
               const reload = reloadContext2 || (async () => {
               });