@a-company/paradigm 3.14.1 → 3.16.0

package/dist/{chunk-O5ZO5LSW.js → chunk-D4VBBKGV.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // ../paradigm-mcp/src/tools/reindex.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
-import * as yaml7 from "js-yaml";
+import * as fs9 from "fs";
+import * as path10 from "path";
+import * as yaml8 from "js-yaml";
 
 // ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
 import * as yaml3 from "js-yaml";
@@ -1991,8 +1991,8 @@ var SessionTracker = class {
    * Extract resource type from URI
    */
   extractResourceType(uri) {
-    const path10 = uri.replace("paradigm://", "");
-    const firstPart = path10.split("/")[0];
+    const path11 = uri.replace("paradigm://", "");
+    const firstPart = path11.split("/")[0];
     return firstPart || "unknown";
   }
   /**
@@ -4389,8 +4389,8 @@ async function getAffectedPersonas(rootDir, symbol) {
   }
   return results;
 }
-function deepGet(obj, path10) {
-  const parts = path10.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path11) {
+  const parts = path11.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -4558,6 +4558,341 @@ 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";
+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)) {
+    return [];
+  }
+  const files = fs8.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);
+      if (protocol?.id && protocol?.name) {
+        protocols.push(protocol);
+      }
+    } catch {
+    }
+  }
+  return protocols;
+}
+async function loadProtocol(rootDir, id) {
+  const slug = id.replace(/^P-/, "");
+  const filePath = path9.join(rootDir, PROTOCOLS_DIR, `${slug}.protocol`);
+  if (fs8.existsSync(filePath)) {
+    try {
+      const content = fs8.readFileSync(filePath, "utf8");
+      return yaml7.load(content);
+    } catch {
+      return null;
+    }
+  }
+  const protocols = await loadProtocols(rootDir);
+  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)) {
+    return null;
+  }
+  try {
+    const content = fs8.readFileSync(indexPath, "utf8");
+    return yaml7.load(content);
+  } catch {
+    return null;
+  }
+}
+async function searchProtocols(rootDir, task, limit = 3) {
+  const protocols = await loadProtocols(rootDir);
+  if (protocols.length === 0) return [];
+  const keywords = tokenize(task);
+  if (keywords.length === 0) return [];
+  const scored = [];
+  for (const protocol of protocols) {
+    let score = 0;
+    for (const trigger of protocol.trigger) {
+      const triggerLower = trigger.toLowerCase();
+      for (const kw of keywords) {
+        if (triggerLower.includes(kw)) {
+          score += 3;
+        }
+      }
+    }
+    for (const tag of protocol.tags) {
+      const tagLower = tag.toLowerCase();
+      for (const kw of keywords) {
+        if (tagLower.includes(kw) || kw.includes(tagLower)) {
+          score += 2;
+        }
+      }
+    }
+    const nameLower = protocol.name.toLowerCase();
+    const descLower = protocol.description.toLowerCase();
+    for (const kw of keywords) {
+      if (nameLower.includes(kw)) score += 1;
+      if (descLower.includes(kw)) score += 1;
+    }
+    for (const step of protocol.steps) {
+      if (step.notes) {
+        const notesLower = step.notes.toLowerCase();
+        for (const kw of keywords) {
+          if (notesLower.includes(kw)) score += 0.5;
+        }
+      }
+    }
+    if (score > 0) {
+      scored.push({ protocol, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  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 slug = slugify(protocol.name);
+  const id = `P-${slug}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const full = {
+    id,
+    name: protocol.name,
+    description: protocol.description,
+    trigger: protocol.trigger,
+    tags: protocol.tags,
+    symbols: protocol.symbols || [],
+    exemplar: protocol.exemplar,
+    steps: protocol.steps,
+    recorded_from: protocol.recorded_from,
+    recorded_at: now,
+    last_verified: now,
+    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");
+  return id;
+}
+async function updateProtocol(rootDir, id, partial, refresh = false) {
+  const protocol = await loadProtocol(rootDir, id);
+  if (!protocol) return false;
+  if (partial.name !== void 0) protocol.name = partial.name;
+  if (partial.description !== void 0) protocol.description = partial.description;
+  if (partial.trigger !== void 0) protocol.trigger = partial.trigger;
+  if (partial.tags !== void 0) protocol.tags = partial.tags;
+  if (partial.symbols !== void 0) protocol.symbols = partial.symbols;
+  if (partial.exemplar !== void 0) protocol.exemplar = partial.exemplar;
+  if (partial.steps !== void 0) protocol.steps = partial.steps;
+  if (partial.status !== void 0) protocol.status = partial.status;
+  if (partial.verified_by !== void 0) protocol.verified_by = partial.verified_by;
+  if (refresh) {
+    protocol.last_verified = (/* @__PURE__ */ new Date()).toISOString();
+    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");
+  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)) {
+      issues.push(`Exemplar missing: ${protocol.exemplar}`);
+      status = "broken";
+    } else {
+      const stat = fs8.statSync(exemplarPath);
+      if (stat.mtime.toISOString() > protocol.last_verified) {
+        issues.push(`Exemplar modified since last verified: ${protocol.exemplar}`);
+        if (status !== "broken") status = "stale";
+      }
+    }
+  }
+  for (const step of protocol.steps) {
+    if (step.template_from) {
+      const templatePath = path9.join(rootDir, step.template_from);
+      if (!fs8.existsSync(templatePath)) {
+        issues.push(`Template file missing: ${step.template_from}`);
+        status = "broken";
+      }
+    }
+    if (step.action === "modify" && step.target) {
+      const targetPath = path9.join(rootDir, step.target);
+      if (!step.target.includes("{") && !fs8.existsSync(targetPath)) {
+        issues.push(`Modify target missing: ${step.target}`);
+        status = "broken";
+      }
+    }
+  }
+  return { status, issues };
+}
+async function rebuildProtocolIndex(rootDir) {
+  const protocols = await loadProtocols(rootDir);
+  const entries = [];
+  let current = 0;
+  let stale = 0;
+  let broken = 0;
+  for (const protocol of protocols) {
+    const validation = validateProtocol(rootDir, protocol);
+    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");
+      }
+    }
+    switch (validation.status) {
+      case "current":
+        current++;
+        break;
+      case "stale":
+        stale++;
+        break;
+      case "broken":
+        broken++;
+        break;
+    }
+    entries.push({
+      id: protocol.id,
+      name: protocol.name,
+      status: validation.status,
+      last_verified: protocol.last_verified,
+      trigger: protocol.trigger,
+      tags: protocol.tags
+    });
+  }
+  const index = {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    protocols: entries,
+    health: {
+      total: protocols.length,
+      current,
+      stale,
+      broken
+    }
+  };
+  const protocolsDir = path9.join(rootDir, PROTOCOLS_DIR);
+  if (protocols.length > 0) {
+    if (!fs8.existsSync(protocolsDir)) {
+      fs8.mkdirSync(protocolsDir, { recursive: true });
+    }
+    const indexPath = path9.join(protocolsDir, INDEX_FILE2);
+    fs8.writeFileSync(indexPath, yaml7.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  }
+  return index;
+}
+function detectProtocolSuggestion(rootDir, filesCreated, filesModified) {
+  if (!filesCreated || filesCreated.length < 2) return null;
+  const dirGroups = {};
+  for (const file of filesCreated) {
+    const dir = path9.dirname(file);
+    if (!dirGroups[dir]) dirGroups[dir] = [];
+    dirGroups[dir].push(file);
+  }
+  for (const [dir, created] of Object.entries(dirGroups)) {
+    if (created.length < 2) continue;
+    const absDir = path9.join(rootDir, dir);
+    if (!fs8.existsSync(absDir)) continue;
+    const existing = fs8.readdirSync(absDir).filter((f) => {
+      const ext = path9.extname(f);
+      return [".ts", ".tsx", ".js", ".jsx", ".rs", ".py"].includes(ext);
+    });
+    const preExisting = existing.filter((f) => !created.some((c) => path9.basename(c) === f));
+    if (preExisting.length > 0) {
+      const exemplar = path9.join(dir, preExisting[0]);
+      const steps = [
+        ...created.map((f) => ({ action: "create", target: f })),
+        ...filesModified.map((f) => ({ action: "modify", target: f }))
+      ];
+      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$/, "")}`,
+          exemplar,
+          steps
+        }
+      };
+    }
+  }
+  return null;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 1).filter((w) => !STOP_WORDS.has(w));
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "it",
+  "this",
+  "that",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "so",
+  "as",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "how",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "whom"
+]);
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
 // ../paradigm-mcp/src/tools/reindex.ts
 var SYMBOL_CATEGORIES = {
   "@": { category: "features", prefix: "@" },
@@ -4646,10 +4981,10 @@ async function rebuildStaticFiles(rootDir, ctx) {
   } else {
     aggregation = await aggregateFromDirectory(rootDir);
   }
-  const projectName = ctx?.projectName || path9.basename(rootDir);
-  const paradigmDir = path9.join(rootDir, ".paradigm");
-  if (!fs8.existsSync(paradigmDir)) {
-    fs8.mkdirSync(paradigmDir, { recursive: true });
+  const projectName = ctx?.projectName || path10.basename(rootDir);
+  const paradigmDir = path10.join(rootDir, ".paradigm");
+  if (!fs9.existsSync(paradigmDir)) {
+    fs9.mkdirSync(paradigmDir, { recursive: true });
   }
   const scanIndex = generateScanIndex(
     {
@@ -4659,22 +4994,22 @@ async function rebuildStaticFiles(rootDir, ctx) {
     },
     { projectName }
   );
-  const scanIndexPath = path9.join(paradigmDir, "scan-index.json");
-  fs8.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  const scanIndexPath = path10.join(paradigmDir, "scan-index.json");
+  fs9.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
   filesWritten.push(".paradigm/scan-index.json");
   const navigatorData = buildNavigatorData(rootDir, aggregation);
-  const navigatorPath = path9.join(paradigmDir, "navigator.yaml");
-  fs8.writeFileSync(
+  const navigatorPath = path10.join(paradigmDir, "navigator.yaml");
+  fs9.writeFileSync(
     navigatorPath,
-    yaml7.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
+    yaml8.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 = path9.join(paradigmDir, "flow-index.json");
-    fs8.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    const flowIndexPath = path10.join(paradigmDir, "flow-index.json");
+    fs9.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
     filesWritten.push(".paradigm/flow-index.json");
     flowCount = Object.keys(flowIndex.flows).length;
   }
@@ -4706,6 +5041,15 @@ async function rebuildStaticFiles(rootDir, ctx) {
     }
   } catch {
   }
+  let protocolHealth;
+  try {
+    const protocolIndex = await rebuildProtocolIndex(rootDir);
+    if (protocolIndex.health.total > 0) {
+      protocolHealth = protocolIndex.health;
+      filesWritten.push(".paradigm/protocols/index.yaml");
+    }
+  } catch {
+  }
   const breakdown = {};
   for (const sym of aggregation.symbols) {
     breakdown[sym.type] = (breakdown[sym.type] || 0) + 1;
@@ -4717,7 +5061,8 @@ async function rebuildStaticFiles(rootDir, ctx) {
     breakdown,
     flowCount,
     aspectGraphStats,
-    personaCount
+    personaCount,
+    protocolHealth
   };
 }
 function buildNavigatorData(rootDir, aggregation) {
@@ -4733,7 +5078,7 @@ function buildNavigatorData(rootDir, aggregation) {
 function buildStructure(rootDir) {
   const structure = {};
   for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.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 || "@" };
@@ -4744,7 +5089,7 @@ function buildStructure(rootDir) {
 function buildKeyFiles(rootDir) {
   const keyFiles = {};
   for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
-    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    const existingPaths = patterns.filter((p) => fs9.existsSync(path10.join(rootDir, p)));
     if (existingPaths.length > 0) {
       keyFiles[category] = existingPaths;
     }
@@ -4760,10 +5105,10 @@ function buildSkipPatterns(rootDir) {
     unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
     unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
   };
-  const gitignorePath = path9.join(rootDir, ".gitignore");
-  if (fs8.existsSync(gitignorePath)) {
+  const gitignorePath = path10.join(rootDir, ".gitignore");
+  if (fs9.existsSync(gitignorePath)) {
     try {
-      const content = fs8.readFileSync(gitignorePath, "utf8");
+      const content = fs9.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);
@@ -4812,11 +5157,11 @@ function buildSymbolMap(symbols, purposeFiles, _rootDir) {
       symbolMap[symbolId] = symbol.filePath;
     } else {
       const matchingPurpose = purposeFiles.find((pf) => {
-        const dir = path9.dirname(pf);
+        const dir = path10.dirname(pf);
         return dir.toLowerCase().includes(symbol.id.toLowerCase());
       });
       if (matchingPurpose) {
-        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
+        symbolMap[symbolId] = path10.dirname(matchingPurpose) + "/";
       }
     }
   }
@@ -4827,8 +5172,8 @@ function generateFlowIndex(rootDir, purposeFiles) {
   const symbolToFlows = {};
   for (const filePath of purposeFiles) {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
-      const data = yaml7.load(content);
+      const content = fs9.readFileSync(filePath, "utf8");
+      const data = yaml8.load(content);
       if (!data?.flows) continue;
       if (Array.isArray(data.flows)) {
         for (const flowItem of data.flows) {
@@ -4841,7 +5186,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               id: flowId,
               description: flow.description || "",
               steps,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -4857,7 +5202,7 @@ function generateFlowIndex(rootDir, purposeFiles) {
               trigger: flowDef.trigger,
               steps,
               validation: flowDef.validation,
-              definedIn: path9.relative(rootDir, filePath)
+              definedIn: path10.relative(rootDir, filePath)
             };
             indexFlowSymbols(flowId, steps, symbolToFlows);
           }
@@ -4965,6 +5310,14 @@ export {
   getPersonaCoverage,
   getAffectedPersonas,
   validateAgainstSentinel,
+  loadProtocols,
+  loadProtocol,
+  loadProtocolIndex,
+  searchProtocols,
+  recordProtocol,
+  updateProtocol,
+  validateProtocol,
+  detectProtocolSuggestion,
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles

package/dist/mcp.js

@@ -36,6 +36,7 @@ import {
   createPersona,
   deleteLoreEntry,
   deletePersona,
+  detectProtocolSuggestion,
   findPurposeFiles,
   getAffectedPersonas,
   getAllEdgesFor,
@@ -66,6 +67,9 @@ import {
   loadLoreTimeline,
   loadPersona,
   loadPersonas,
+  loadProtocol,
+  loadProtocolIndex,
+  loadProtocols,
   openAspectGraph,
   parseGateConfig,
   parsePurposeFileDetailed,
@@ -73,7 +77,9 @@ import {
   recordGlobalAntipattern,
   recordGlobalDecision,
   recordLoreEntry,
+  recordProtocol,
   removeStep,
+  searchProtocols,
   searchSymbols,
   serializePurposeFile,
   toolCache,
@@ -81,10 +87,12 @@ import {
   trackToolCall,
   updateLoreEntry,
   updatePersona,
+  updateProtocol,
   validateAgainstSentinel,
   validatePersona,
+  validateProtocol,
   validatePurposeFile
-} from "./chunk-O5ZO5LSW.js";
+} from "./chunk-D4VBBKGV.js";
 import {
   getPluginUpdateNotice,
   schedulePluginUpdateCheck
@@ -8574,6 +8582,17 @@ async function handleLoreTool(name, args, ctx) {
       };
       const id = await recordLoreEntry(ctx.rootDir, entry);
       getSessionTracker().setLastLoreEntryId(id);
+      let protocol_suggestion = null;
+      try {
+        if (files_created && files_created.length >= 2) {
+          protocol_suggestion = detectProtocolSuggestion(
+            ctx.rootDir,
+            files_created,
+            files_modified || []
+          );
+        }
+      } catch {
+      }
       return {
         handled: true,
         text: JSON.stringify({
@@ -8581,7 +8600,8 @@ async function handleLoreTool(name, args, ctx) {
           id,
           type,
           title,
-          message: "Lore entry recorded successfully"
+          message: "Lore entry recorded successfully",
+          ...protocol_suggestion ? { protocol_suggestion } : {}
         })
       };
     }
@@ -11553,6 +11573,364 @@ async function handlePersonaTool(name, args, ctx) {
   }
 }
 
+// ../paradigm-mcp/src/tools/protocols.ts
+function getProtocolsToolsList() {
+  return [
+    {
+      name: "paradigm_protocol_search",
+      description: "Search for protocols matching a task description. Call BEFORE exploring the codebase \u2014 if a matching protocol exists, follow its steps instead of discovering the pattern from scratch. Returns top matches with steps, exemplar, and freshness info. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: 'Task description to search for (e.g., "add a new page", "add API route")'
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results (default: 3)"
+          }
+        },
+        required: ["task"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_protocol_get",
+      description: "Get a specific protocol by ID with full details and freshness check. ~300 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Protocol ID (e.g., "P-add-view")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_protocol_record",
+      description: "Record a new protocol after completing repeatable work. Captures the steps you followed so future agents can skip exploration. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'Protocol name (e.g., "Add a new view")'
+          },
+          description: {
+            type: "string",
+            description: "What this protocol accomplishes"
+          },
+          trigger: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Phrases that should match this protocol (e.g., ["add view", "new page"])'
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Classification tags (e.g., ["ui", "frontend"])'
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Paradigm symbols involved (e.g., ["#logs-view"])'
+          },
+          exemplar: {
+            type: "string",
+            description: 'Canonical file to study for this pattern (e.g., "ui/src/views/LogsView.tsx")'
+          },
+          steps: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                action: {
+                  type: "string",
+                  enum: ["create", "modify", "run", "verify"],
+                  description: "Step action type"
+                },
+                target: {
+                  type: "string",
+                  description: "File path (supports {Name}/{name} placeholders)"
+                },
+                template_from: {
+                  type: "string",
+                  description: "File to use as template (for create actions)"
+                },
+                reference: {
+                  type: "string",
+                  description: "Where in the file to make changes (for modify actions)"
+                },
+                command: {
+                  type: "string",
+                  description: "Command to execute (for run actions)"
+                },
+                notes: {
+                  type: "string",
+                  description: "Additional guidance for this step"
+                }
+              },
+              required: ["action"]
+            },
+            description: "Ordered steps to follow"
+          },
+          recorded_from: {
+            type: "string",
+            description: 'Lore entry ID this protocol was learned from (e.g., "L-2026-03-01-001")'
+          }
+        },
+        required: ["name", "description", "trigger", "tags", "steps"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_protocol_update",
+      description: "Update an existing protocol. Use refresh:true after successfully following a protocol to bump last_verified. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Protocol ID to update (e.g., "P-add-view")'
+          },
+          refresh: {
+            type: "boolean",
+            description: "Set true to bump last_verified to now (use after successfully following the protocol)"
+          },
+          name: { type: "string", description: "Updated name" },
+          description: { type: "string", description: "Updated description" },
+          trigger: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated trigger phrases"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated tags"
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: "Updated symbols"
+          },
+          exemplar: { type: "string", description: "Updated exemplar path" },
+          steps: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                action: { type: "string", enum: ["create", "modify", "run", "verify"] },
+                target: { type: "string" },
+                template_from: { type: "string" },
+                reference: { type: "string" },
+                command: { type: "string" },
+                notes: { type: "string" }
+              },
+              required: ["action"]
+            },
+            description: "Updated steps"
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_protocol_validate",
+      description: "Validate protocol references \u2014 check that referenced files exist, exemplars haven't drifted. Validates all protocols if no ID given. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Protocol ID to validate (omit to validate all)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handleProtocolsTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_protocol_search": {
+      const task = args.task;
+      const limit = args.limit || 3;
+      const results = await searchProtocols(ctx.rootDir, task, limit);
+      if (results.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            count: 0,
+            task,
+            message: "No matching protocol found. Consider recording one after completing this task."
+          })
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          count: results.length,
+          task,
+          matches: results.map((r) => ({
+            id: r.protocol.id,
+            name: r.protocol.name,
+            description: r.protocol.description,
+            score: r.score,
+            status: r.protocol.status,
+            exemplar: r.protocol.exemplar,
+            last_verified: r.protocol.last_verified,
+            steps: r.protocol.steps.map(summarizeStep)
+          }))
+        }, null, 2)
+      };
+    }
+    case "paradigm_protocol_get": {
+      const id = args.id;
+      const protocol = await loadProtocol(ctx.rootDir, id);
+      if (!protocol) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Protocol not found: ${id}` })
+        };
+      }
+      const validation = validateProtocol(ctx.rootDir, protocol);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          ...protocol,
+          freshness: {
+            status: validation.status,
+            issues: validation.issues
+          }
+        }, null, 2)
+      };
+    }
+    case "paradigm_protocol_record": {
+      const steps = args.steps || [];
+      const id = await recordProtocol(ctx.rootDir, {
+        name: args.name,
+        description: args.description,
+        trigger: args.trigger || [],
+        tags: args.tags || [],
+        symbols: args.symbols || [],
+        exemplar: args.exemplar,
+        steps,
+        recorded_from: args.recorded_from,
+        verified_by: "claude-opus-4-6"
+      });
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success: true,
+          id,
+          name: args.name,
+          message: "Protocol recorded successfully"
+        })
+      };
+    }
+    case "paradigm_protocol_update": {
+      const id = args.id;
+      const refresh = args.refresh;
+      const partial = {};
+      if (args.name !== void 0) partial.name = args.name;
+      if (args.description !== void 0) partial.description = args.description;
+      if (args.trigger !== void 0) partial.trigger = args.trigger;
+      if (args.tags !== void 0) partial.tags = args.tags;
+      if (args.symbols !== void 0) partial.symbols = args.symbols;
+      if (args.exemplar !== void 0) partial.exemplar = args.exemplar;
+      if (args.steps !== void 0) partial.steps = args.steps;
+      const success = await updateProtocol(ctx.rootDir, id, partial, refresh === true);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success,
+          id,
+          refreshed: refresh === true,
+          message: success ? refresh ? "Protocol updated and verified" : "Protocol updated" : `Protocol not found: ${id}`
+        })
+      };
+    }
+    case "paradigm_protocol_validate": {
+      const id = args.id;
+      if (id) {
+        const protocol = await loadProtocol(ctx.rootDir, id);
+        if (!protocol) {
+          return {
+            handled: true,
+            text: JSON.stringify({ error: `Protocol not found: ${id}` })
+          };
+        }
+        const result = validateProtocol(ctx.rootDir, protocol);
+        return {
+          handled: true,
+          text: JSON.stringify({
+            id: protocol.id,
+            name: protocol.name,
+            status: result.status,
+            issues: result.issues,
+            last_verified: protocol.last_verified
+          }, null, 2)
+        };
+      }
+      const protocols = await loadProtocols(ctx.rootDir);
+      const results = protocols.map((p) => {
+        const v = validateProtocol(ctx.rootDir, p);
+        return {
+          id: p.id,
+          name: p.name,
+          status: v.status,
+          issues: v.issues,
+          last_verified: p.last_verified
+        };
+      });
+      const health = {
+        total: results.length,
+        current: results.filter((r) => r.status === "current").length,
+        stale: results.filter((r) => r.status === "stale").length,
+        broken: results.filter((r) => r.status === "broken").length
+      };
+      return {
+        handled: true,
+        text: JSON.stringify({ protocols: results, health }, null, 2)
+      };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+function summarizeStep(step) {
+  const result = {
+    action: step.action
+  };
+  if (step.target) result.target = step.target;
+  if (step.template_from) result.template_from = step.template_from;
+  if (step.reference) result.reference = step.reference;
+  if (step.command) result.command = step.command;
+  if (step.notes) result.notes = step.notes;
+  return result;
+}
+
 // ../paradigm-mcp/src/tools/fallback-grep.ts
 import * as path23 from "path";
 import { execSync as execSync3 } from "child_process";
@@ -11844,6 +12222,8 @@ function registerTools(server, getContext2, reloadContext2) {
           // Assessment loop tools
           ...getAssessmentToolsList(),
           ...getPersonaToolsList(),
+          // Protocol tools
+          ...getProtocolsToolsList(),
           // Plugin update check
           {
             name: "paradigm_plugin_check",
@@ -12226,7 +12606,7 @@ function registerTools(server, getContext2, reloadContext2) {
             };
           }
           case "paradigm_status": {
-            const text = await toolCache.getOrCompute("status", () => {
+            const text = await toolCache.getOrCompute("status", async () => {
               const counts = getSymbolCounts(ctx.index);
               const total = Object.values(counts).reduce((a, b) => a + b, 0);
               const examples = {};
@@ -12237,6 +12617,14 @@ function registerTools(server, getContext2, reloadContext2) {
               const platform2 = os.platform();
               const isWindows = platform2 === "win32";
               const shell = isWindows ? "PowerShell/CMD" : platform2 === "darwin" ? "zsh/bash" : "bash";
+              let protocols;
+              try {
+                const protocolIndex = await loadProtocolIndex(ctx.rootDir);
+                if (protocolIndex && protocolIndex.health.total > 0) {
+                  protocols = protocolIndex.health;
+                }
+              } catch {
+              }
               return JSON.stringify({
                 project: ctx.projectName,
                 symbolSystem: "v2",
@@ -12251,6 +12639,7 @@ function registerTools(server, getContext2, reloadContext2) {
                 examples,
                 hasPortalYaml: ctx.gateConfig !== null,
                 purposeFiles: ctx.aggregation.purposeFiles.length,
+                ...protocols ? { protocols } : {},
                 note: "Symbol System v2: Use tags [feature], [state], [integration], [idea] for classification",
                 environment: {
                   os: platform2,
@@ -12465,7 +12854,7 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-4OOME3TT.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-T4N3NG73.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
               const memberAbsPath = path24.resolve(path24.dirname(ctx.workspace.workspacePath), member.path);
@@ -12648,6 +13037,15 @@ Update command:
                 };
               }
             }
+            if (name.startsWith("paradigm_protocol_")) {
+              const result = await handleProtocolsTool(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 () => {
               });

package/dist/{reindex-4OOME3TT.js → reindex-T4N3NG73.js}

@@ -3,7 +3,7 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-O5ZO5LSW.js";
+} from "./chunk-D4VBBKGV.js";
 export {
   getReindexToolsList,
   handleReindexTool,

package/dist/university-content/courses/para-301.json

@@ -574,10 +574,77 @@
         }
       ]
     },
+    {
+      "id": "protocols",
+      "title": "Protocols — Repeatable Patterns",
+      "content": "## Protocols — Repeatable Patterns\n\nAI agents routinely spend tens of thousands of tokens exploring codebases to reverse-engineer implementation patterns before they can start working. In a well-structured project, the answer to \"how do I add a new view?\" is the same every time: create a component file, create a store, register a route, add CSS. But this knowledge lives nowhere explicit, so every agent re-discovers it from scratch.\n\nProtocols solve this problem. They are procedural, step-by-step instructions with exact file references, learned from actual completed work. When an agent receives a task like \"add a Settings page,\" it first calls `paradigm_protocol_search` with the task description. If a matching protocol exists, the agent gets back ordered steps, an exemplar file to study, and freshness information -- all within a few hundred tokens instead of exploring for thousands.\n\n### Storage and Format\n\nProtocols are stored as `.protocol` files (YAML syntax, semantic extension) in `.paradigm/protocols/`. Each protocol has an ID, a name, a description, trigger phrases for fuzzy matching, tags for classification, an exemplar file (the canonical example to follow), and an ordered list of steps.\n\n```\n.paradigm/protocols/\n  index.yaml            # Auto-generated by reindex\n  add-view.protocol     # One file per protocol\n  add-api-route.protocol\n```\n\n### Step Types\n\nProtocol steps use four action types:\n\n- **create** -- Create a new file. Specifies `target` (the file to create, with placeholders) and `template_from` (an existing file to follow as a model).\n- **modify** -- Edit an existing file. Specifies `target`, `reference` (where in the file to make changes), and `notes` explaining what to add.\n- **run** -- Execute a command. Specifies `command` and `notes`.\n- **verify** -- Confirm something works. Specifies `notes` with what to check.\n\nSteps support placeholders: `{Name}` for PascalCase and `{name}` for kebab-case. When following the protocol, the agent substitutes the actual name.\n\n### Searching for Protocols\n\nThe primary entry point is `paradigm_protocol_search`. Pass a natural language task description and it returns matching protocols ranked by relevance.\n\n```\nparadigm_protocol_search({ task: \"add a new settings page\" })\n```\n\nThe search uses weighted fuzzy matching: trigger phrases (weight 3), tags (weight 2), name and description (weight 1), and step notes (weight 0.5). The protocol set per project is small (5-30 entries), so a full scan is efficient.\n\nTo get full details for a specific protocol, use `paradigm_protocol_get`:\n\n```\nparadigm_protocol_get({ id: \"P-add-view\" })\n```\n\n### Recording Protocols\n\nProtocols are captured *after* completing work, not before. Two paths lead to a new protocol:\n\n1. **Agent-initiated** -- After implementing a repeatable task, the agent calls `paradigm_protocol_record` with the steps it followed:\n\n```\nparadigm_protocol_record({\n  name: \"Add a new view\",\n  description: \"Create a new page with store, route, and CSS\",\n  trigger: [\"add view\", \"new page\", \"create view\"],\n  tags: [\"ui\", \"frontend\"],\n  exemplar: \"ui/src/views/LogsView.tsx\",\n  steps: [\n    { action: \"create\", target: \"ui/src/views/{Name}View.tsx\", template_from: \"ui/src/views/LogsView.tsx\" },\n    { action: \"modify\", target: \"ui/src/App.tsx\", reference: \"Route elements\", notes: \"Add Route\" },\n    { action: \"verify\", notes: \"Run build, check route loads\" }\n  ],\n  recorded_from: \"L-2026-03-01-001\"\n})\n```\n\n2. **Lore-prompted** -- When `paradigm_lore_record` is called, the response includes a `protocol_suggestion` if the session created new files following existing patterns. This nudges agents to capture repeatable work without manual intervention.\n\n### Freshness and Maintenance\n\nProtocols go stale as code evolves. Three mechanisms keep them fresh:\n\n- **Reindex validation** -- During `paradigm_reindex`, all protocol references are checked. Missing files mark the protocol as `broken`. An exemplar modified since `last_verified` marks it `stale`. All references valid means `current`.\n- **On-use refresh** -- After successfully following a protocol, the agent calls `paradigm_protocol_update` with `refresh: true` to bump `last_verified` and fix outdated references.\n- **Status visibility** -- `paradigm_status` includes protocol health (X current, Y stale, Z broken). Stale protocols surface naturally during normal workflow.\n\nYou can also explicitly validate protocols:\n\n```\nparadigm_protocol_validate({ id: \"P-add-view\" })\n```\n\n### The Workflow\n\nThe protocol workflow integrates into the Paradigm operational loop:\n\n1. **Before implementing**: Call `paradigm_protocol_search` with your task description. If a match exists, follow the steps -- skip codebase exploration.\n2. **During implementation**: Use the protocol's exemplar as a reference. Follow each step in order.\n3. **After completion**: If no protocol existed and the work was repeatable, record one. If a protocol existed and you followed it successfully, call `paradigm_protocol_update` to refresh its timestamp.\n\nThis creates a virtuous cycle: each agent session that follows a protocol validates it, and each session that does repeatable work without a protocol can create one for future agents.",
+      "keyConcepts": [
+        "Protocols as repeatable implementation patterns with exact file references",
+        "paradigm_protocol_search — find protocols by task description",
+        "paradigm_protocol_record — capture patterns after completing work",
+        "Step types: create, modify, run, verify",
+        "Freshness tracking: current, stale, broken",
+        "Lore integration: protocol_suggestion on repeatable work"
+      ],
+      "quiz": [
+        {
+          "id": "q1",
+          "question": "What is the PRIMARY purpose of Paradigm protocols?",
+          "choices": {
+            "A": "To enforce coding standards through automated linting",
+            "B": "To provide step-by-step implementation patterns that save agents from re-exploring codebases",
+            "C": "To track all changes made to the codebase in a history log",
+            "D": "To generate code automatically from templates",
+            "E": "To replace .purpose files with more detailed documentation"
+          },
+          "correct": "B",
+          "explanation": "Protocols are repeatable implementation patterns with exact file references. Their primary value is saving AI agents from spending thousands of tokens exploring a codebase to reverse-engineer patterns that are the same every time. They do not enforce linting (A), track history (C), generate code (D), or replace .purpose files (E)."
+        },
+        {
+          "id": "q2",
+          "question": "When should an agent call paradigm_protocol_search?",
+          "choices": {
+            "A": "After completing a task to verify the work matches a known pattern",
+            "B": "Before implementing a task, to check if a repeatable pattern already exists",
+            "C": "Only when the user explicitly asks for protocol guidance",
+            "D": "During reindex to validate protocol references",
+            "E": "When recording lore to check for protocol suggestions"
+          },
+          "correct": "B",
+          "explanation": "paradigm_protocol_search is the agent's first stop before exploring the codebase. When receiving a task like 'add a Settings page,' the agent searches for a matching protocol BEFORE spending tokens on exploration. If a match exists, the steps and exemplar provide everything needed. After completion (A) is when you record or refresh, not search."
+        },
+        {
+          "id": "q3",
+          "question": "When are protocols recorded?",
+          "choices": {
+            "A": "Before starting work, to plan the implementation steps",
+            "B": "During implementation, as each step is completed",
+            "C": "After completing work, capturing the steps that were actually followed",
+            "D": "During reindex, by analyzing git history",
+            "E": "Only by project maintainers, never by AI agents"
+          },
+          "correct": "C",
+          "explanation": "Protocols are captured AFTER completing work, not before. This ensures the steps reflect what actually works, not what was planned. Two paths lead to recording: agent-initiated (calling paradigm_protocol_record with the steps followed) and lore-prompted (the lore_record response includes a protocol_suggestion hint when it detects repeatable patterns)."
+        },
+        {
+          "id": "q4",
+          "question": "A protocol's status is 'stale'. What does this mean?",
+          "choices": {
+            "A": "The protocol has a syntax error in its YAML",
+            "B": "The protocol's exemplar file has been modified since the protocol was last verified",
+            "C": "The protocol has never been used by any agent",
+            "D": "The protocol references files that no longer exist",
+            "E": "The protocol was recorded more than 30 days ago"
+          },
+          "correct": "B",
+          "explanation": "A 'stale' status means the protocol's exemplar or referenced files have been modified since last_verified — the protocol's steps might no longer match the actual code patterns. 'Broken' (D) means referenced files are missing entirely. Stale protocols still work but should be reviewed and refreshed after successful use."
+        }
+      ]
+    },
     {
       "id": "operations-review",
       "title": "Operational Excellence",
-      "content": "## Operational Excellence\n\nThis lesson brings together everything from PARA 301 into a cohesive daily workflow. Operational excellence in Paradigm is not about memorizing individual tools -- it is about building habits that keep your project healthy, your metadata accurate, and your development sessions productive.\n\n### The Operational Loop\n\nEvery development session follows a predictable pattern:\n\n**1. Orient** -- Start by calling `paradigm_status` to see the project overview: how many symbols are defined, recent changes, any outstanding issues. If this is a continuation session, call `paradigm_session_recover` to load context from the previous session.\n\n**2. Discover** -- Before touching code, understand the area you will work in. Call `paradigm_wisdom_context` with the symbols you plan to modify to learn team conventions and avoid known pitfalls. Use `paradigm_navigate` with the \"context\" intent to find all relevant files for your task.\n\n**3. Assess Risk** -- Run `paradigm_ripple` on every symbol you plan to modify to understand the blast radius. Check `paradigm_history_fragility` on anything flagged as a dependency. If the task is complex (3+ files, security + implementation), call `paradigm_orchestrate_inline` with mode=\"plan\" to get the right agent team.\n\n**4. Implement** -- Write code, updating `.purpose` files as you go. If you add routes, update `portal.yaml`. If you add signals, register them. Do not defer metadata updates to \"later\" -- later never comes.\n\n**5. Validate** -- Run `paradigm doctor` or `paradigm_purpose_validate` to catch any drift. Use `paradigm_flow_validate` if you modified flows. Record the implementation with `paradigm_history_record`.\n\n**6. Capture Knowledge** -- Did you discover an antipattern? Record it with `paradigm_wisdom_record`. Did you make an architectural decision? Record that too. Did the implementation reveal a fragile area? Note it for the team.\n\n**7. Monitor Context** -- Check `paradigm_context_check` periodically. If approaching limits, prepare a handoff.\n\n### Common Pitfalls\n\n- **Skipping wisdom checks**: Leads to repeating mistakes the team already knows about\n- **Skipping ripple analysis**: Leads to breaking downstream dependencies\n- **Deferring metadata updates**: Leads to stale `.purpose` files and misleading navigation\n- **Ignoring fragility warnings**: Leads to cascading failures in unstable areas\n- **Not recording history**: Loses the trail that fragility analysis depends on\n\n### The Measure of Excellence\n\nA well-operated Paradigm project has: accurate `.purpose` files that match the code, a `portal.yaml` that reflects all protected routes, wisdom entries that prevent repeated mistakes, history records that enable fragility analysis, and context handoffs that allow seamless multi-session work. When all of these are in place, every AI agent session starts with full context and every change is informed by the project's complete institutional knowledge.",
+      "content": "## Operational Excellence\n\nThis lesson brings together everything from PARA 301 into a cohesive daily workflow. Operational excellence in Paradigm is not about memorizing individual tools -- it is about building habits that keep your project healthy, your metadata accurate, and your development sessions productive.\n\n### The Operational Loop\n\nEvery development session follows a predictable pattern:\n\n**1. Orient** -- Start by calling `paradigm_status` to see the project overview: how many symbols are defined, recent changes, any outstanding issues. If this is a continuation session, call `paradigm_session_recover` to load context from the previous session.\n\n**2. Discover** -- Before touching code, check for existing protocols: call `paradigm_protocol_search` with your task description. If a match exists, follow its steps and skip exploration. Otherwise, call `paradigm_wisdom_context` with the symbols you plan to modify to learn team conventions and avoid known pitfalls. Use `paradigm_navigate` with the \"context\" intent to find all relevant files for your task.\n\n**3. Assess Risk** -- Run `paradigm_ripple` on every symbol you plan to modify to understand the blast radius. Check `paradigm_history_fragility` on anything flagged as a dependency. If the task is complex (3+ files, security + implementation), call `paradigm_orchestrate_inline` with mode=\"plan\" to get the right agent team.\n\n**4. Implement** -- Write code, updating `.purpose` files as you go. If you add routes, update `portal.yaml`. If you add signals, register them. Do not defer metadata updates to \"later\" -- later never comes.\n\n**5. Validate** -- Run `paradigm doctor` or `paradigm_purpose_validate` to catch any drift. Use `paradigm_flow_validate` if you modified flows. Record the implementation with `paradigm_history_record`.\n\n**6. Capture Knowledge** -- Did you discover an antipattern? Record it with `paradigm_wisdom_record`. Did you make an architectural decision? Record that too. Did the implementation follow a repeatable pattern? Record a protocol with `paradigm_protocol_record`. Did the implementation reveal a fragile area? Note it for the team.\n\n**7. Monitor Context** -- Check `paradigm_context_check` periodically. If approaching limits, prepare a handoff.\n\n### Common Pitfalls\n\n- **Skipping wisdom checks**: Leads to repeating mistakes the team already knows about\n- **Skipping ripple analysis**: Leads to breaking downstream dependencies\n- **Deferring metadata updates**: Leads to stale `.purpose` files and misleading navigation\n- **Ignoring fragility warnings**: Leads to cascading failures in unstable areas\n- **Not recording history**: Loses the trail that fragility analysis depends on\n\n### The Measure of Excellence\n\nA well-operated Paradigm project has: accurate `.purpose` files that match the code, a `portal.yaml` that reflects all protected routes, wisdom entries that prevent repeated mistakes, history records that enable fragility analysis, and context handoffs that allow seamless multi-session work. When all of these are in place, every AI agent session starts with full context and every change is informed by the project's complete institutional knowledge.",
       "keyConcepts": [
         "The operational loop: orient, discover, assess, implement, validate, capture, monitor",
         "Combining tools for comprehensive safety",

package/dist/university-content/plsat/v3.0.json

@@ -2,10 +2,10 @@
   "version": "3.0",
   "frameworkVersion": "2.0",
   "timeLimit": 5400,
-  "totalSlots": 90,
+  "totalSlots": 99,
   "passThreshold": 0.8,
   "title": "The PLSAT \u2014 Paradigm Licensure Standardized Assessment Test",
-  "description": "90 questions. 90 minutes. 80% to pass. Good luck, scholar.",
+  "description": "99 questions. 90 minutes. 80% to pass. Good luck, scholar.",
   "items": [
     {
       "type": "standalone",
@@ -2279,6 +2279,111 @@
           "explanation": "Paradigm's three-layer knowledge model is: Commits (raw facts \u2014 what code changed, captured by git), Lore (session events \u2014 what happened during a work session and why, captured by the post-commit hook into `.paradigm/history/`), and Assessments (synthesized insight \u2014 what the team learned across multiple sessions, recorded into `.paradigm/assessments/`). Each layer adds interpretation: commits are mechanical diffs, lore adds narrative context, and assessments distill patterns and decisions. All three layers persist and remain valuable \u2014 none replaces or supersedes the others."
         }
       ]
+    },
+    {
+      "type": "standalone",
+      "slot": "slot-094",
+      "course": "para-301",
+      "variants": [
+        {
+          "id": "plsat-094",
+          "scenario": "You receive a task: \"Add a new Settings page to the application.\" The project has a `.paradigm/protocols/` directory with several `.protocol` files. You know that previous agents added similar pages (Logs, Events, Dashboard) following the same pattern each time.",
+          "question": "What should you do FIRST before exploring the codebase?",
+          "choices": {
+            "A": "Read every existing page component to understand the pattern",
+            "B": "Call `paradigm_protocol_search` with your task description to check for a matching protocol",
+            "C": "Call `paradigm_lore_record` to document that you are starting the task",
+            "D": "Call `paradigm_protocol_record` to create a new protocol for the Settings page",
+            "E": "Read the `.paradigm/protocols/index.yaml` file directly to scan for relevant entries"
+          },
+          "correct": "B",
+          "explanation": "paradigm_protocol_search is the agent's first stop before exploring the codebase. It takes a natural language task description and returns matching protocols with steps, exemplar files, and freshness info — typically saving thousands of exploration tokens. Reading existing pages (A) is exactly the expensive exploration that protocols prevent. Recording lore (C) is done after work, not before. Recording a protocol (D) is done after completing repeatable work. Reading index.yaml directly (E) bypasses the fuzzy search that matches task descriptions to protocols."
+        },
+        {
+          "id": "plsat-094b",
+          "scenario": "An agent needs to add a new API endpoint to the project. The project has 15 recorded protocols covering common tasks. The agent calls `paradigm_protocol_search({ task: \"add a new API endpoint\" })` and gets back a protocol with 4 steps: create route file, add handler, register route, verify with build.",
+          "question": "What should the agent do next?",
+          "choices": {
+            "A": "Ignore the protocol and explore the codebase to find its own approach",
+            "B": "Call `paradigm_protocol_get` with the protocol ID to get full details, then follow the steps using the exemplar as reference",
+            "C": "Call `paradigm_protocol_record` to save the protocol it just found",
+            "D": "Run `paradigm_reindex` to make sure the protocol is up to date",
+            "E": "Call `paradigm_protocol_validate` to check all protocols before proceeding"
+          },
+          "correct": "B",
+          "explanation": "After finding a matching protocol via search, the next step is paradigm_protocol_get to retrieve full details (including the exemplar file path and detailed step notes), then follow the steps. The exemplar is the canonical file to study for the pattern. Ignoring the protocol (A) wastes the lookup. Recording (C) is for new protocols. Reindex (D) and full validation (E) are maintenance operations, not implementation steps."
+        }
+      ]
+    },
+    {
+      "type": "standalone",
+      "slot": "slot-095",
+      "course": "para-301",
+      "variants": [
+        {
+          "id": "plsat-095",
+          "scenario": "An agent just finished adding a new Sentinel event schema — the third such schema added to the project this month. Each time, the agent followed the same steps: create a schema file, register it in the schema index, add a migration, and verify. No protocol exists for this task yet.",
+          "question": "What should the agent do regarding protocols?",
+          "choices": {
+            "A": "Nothing — protocols are only created by project maintainers, not agents",
+            "B": "Call `paradigm_protocol_record` to capture the repeatable pattern it just followed",
+            "C": "Edit an existing protocol to add the schema steps as a sub-procedure",
+            "D": "Wait for `paradigm_reindex` to auto-generate a protocol from git history",
+            "E": "File an issue asking a human to write the protocol later"
+          },
+          "correct": "B",
+          "explanation": "Protocols are captured AFTER completing work, by the agent that did the work. When an agent completes a repeatable task and no protocol existed, it should call paradigm_protocol_record with the steps it followed, trigger phrases, tags, and an exemplar file. This ensures the next agent that receives a similar task can skip exploration entirely. Reindex (D) validates existing protocols but does not auto-generate new ones from git history."
+        },
+        {
+          "id": "plsat-095b",
+          "scenario": "After recording lore for a session where the agent created two new view components following the existing LogsView pattern, the `paradigm_lore_record` response includes a `protocol_suggestion` field with a draft protocol.",
+          "question": "What triggered this protocol suggestion?",
+          "choices": {
+            "A": "The agent explicitly asked for protocol suggestions in the lore_record call",
+            "B": "The lore system detected that the session created new files following existing patterns in the same directory",
+            "C": "All lore entries automatically include protocol suggestions",
+            "D": "The protocol suggestion was cached from a previous session",
+            "E": "The lore system runs paradigm_protocol_search on every lore entry"
+          },
+          "correct": "B",
+          "explanation": "When paradigm_lore_record is called, it runs a detection heuristic: if the session created 2+ new files in a directory that already has similar files, or modified the same 'registration' files that existing protocols touch, it includes a protocol_suggestion in the response. This nudges agents to capture repeatable patterns without manual intervention. Not all lore entries trigger suggestions (C) — only those with detectable repeatable patterns."
+        }
+      ]
+    },
+    {
+      "type": "standalone",
+      "slot": "slot-096",
+      "course": "para-301",
+      "variants": [
+        {
+          "id": "plsat-096",
+          "scenario": "During `paradigm_reindex`, the system validates all protocols. Protocol P-add-view references `ui/src/views/LogsView.tsx` as its exemplar. The file still exists but was significantly refactored two weeks after the protocol was last verified.",
+          "question": "What status will the reindex assign to this protocol?",
+          "choices": {
+            "A": "`current` — the file still exists, so the protocol is valid",
+            "B": "`stale` — the exemplar has been modified since the protocol was last verified",
+            "C": "`broken` — any change to a referenced file invalidates the protocol",
+            "D": "`deprecated` — protocols older than 30 days are automatically deprecated",
+            "E": "`unknown` — reindex cannot determine status without running the protocol"
+          },
+          "correct": "B",
+          "explanation": "During reindex validation, a protocol is marked 'stale' when its exemplar or referenced files have been modified since last_verified. The file still exists (so it is not 'broken'), but the protocol's steps might no longer match the current code pattern. A 'broken' status (C) is reserved for when referenced files are missing entirely. Stale protocols still work but should be reviewed and refreshed after successful use via paradigm_protocol_update with refresh: true."
+        },
+        {
+          "id": "plsat-096b",
+          "scenario": "An agent calls `paradigm_protocol_validate({ id: \"P-add-api-route\" })`. The protocol's step 2 references the file `src/routes/index.ts`, but that file was deleted during a recent refactoring.",
+          "question": "What status will the validation assign?",
+          "choices": {
+            "A": "`stale` — a referenced file has changed",
+            "B": "`current` — the protocol itself is still syntactically valid",
+            "C": "`broken` — a referenced file no longer exists",
+            "D": "`warning` — the file might be temporarily missing",
+            "E": "`archived` — protocols with missing references are auto-archived"
+          },
+          "correct": "C",
+          "explanation": "A 'broken' status means one or more files referenced by the protocol (targets, exemplars, or template_from) no longer exist. This is more severe than 'stale' (where files exist but have been modified). A broken protocol cannot be reliably followed until its references are updated to point to existing files via paradigm_protocol_update."
+        }
+      ]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-company/paradigm",
-  "version": "3.14.1",
+  "version": "3.16.0",
   "description": "Unified CLI for Paradigm developer tools",
   "type": "module",
   "main": "./dist/index.js",