@a-company/paradigm 3.34.0 → 3.44.0

package/dist/mcp.js

@@ -14,7 +14,7 @@ import {
   StatsCalculator,
   TimelineBuilder,
   loadAllSeedPatterns
-} from "./chunk-BKMNLROM.js";
+} from "./chunk-ZDHLG5VP.js";
 import {
   addStep,
   addToolBreadcrumb,
@@ -28,6 +28,7 @@ import {
   detectProtocolSuggestion,
   findPurposeFiles,
   getAffectedPersonas,
+  getAffectedUniversityContent,
   getAllEdgesFor,
   getAllSymbols,
   getAnchorsForAspect,
@@ -37,6 +38,7 @@ import {
   getEdgesTo,
   getHeatmap,
   getLoreForAspect,
+  getOnboardingSequence,
   getPersonaCoverage,
   getReferencesFrom,
   getReferencesTo,
@@ -48,22 +50,33 @@ import {
   handleContextTool,
   handleReindexTool,
   incrementHeatmap,
+  loadDiplomas,
   loadGlobalAntipatterns,
   loadGlobalDecisions,
   loadGlobalPreferences,
+  loadNote,
+  loadPath,
   loadPersona,
   loadPersonas,
   loadProtocol,
   loadProtocolIndex,
   loadProtocols,
+  loadQuiz,
+  loadUniversityConfig,
   openAspectGraph,
   parseGateConfig,
   parsePurposeFileDetailed,
   rebuildStaticFiles,
+  rebuildUniversityIndex,
   recordGlobalAntipattern,
   recordGlobalDecision,
   recordProtocol,
   removeStep,
+  saveDiploma,
+  saveNote,
+  savePath,
+  saveQuiz,
+  searchContent,
   searchProtocols,
   searchSymbols,
   serializePurposeFile,
@@ -75,16 +88,19 @@ import {
   validateAgainstSentinel,
   validatePersona,
   validateProtocol,
-  validatePurposeFile
-} from "./chunk-PFLWLC6J.js";
+  validatePurposeFile,
+  validateUniversityContent
+} from "./chunk-ZMQA6SCO.js";
 import {
+  addLoreAssessment,
   deleteLoreEntry,
   loadLoreEntries,
   loadLoreEntry,
   loadLoreTimeline,
   recordLoreEntry,
   updateLoreEntry
-} from "./chunk-3DYYXGDC.js";
+} from "./chunk-CDMAMDSG.js";
+import "./chunk-L27I3CPZ.js";
 import {
   getPluginUpdateNotice,
   schedulePluginUpdateCheck
@@ -754,6 +770,14 @@ async function loadProjectContext(rootDir) {
     try {
       const configContent = fs4.readFileSync(configPath, "utf8");
       const config = yaml4.load(configContent);
+      if (config && typeof config === "object") {
+        if (!config.version) {
+          console.error('[paradigm] Warning: config.yaml missing "version" field');
+        }
+        if (!config.project) {
+          console.error('[paradigm] Warning: config.yaml missing "project" field');
+        }
+      }
       if (config && typeof config.workspace === "string") {
         workspace = loadWorkspaceContext(absoluteRoot, config.workspace);
       }
@@ -2026,8 +2050,8 @@ function registerResources(server, getContext2) {
 }
 
 // ../paradigm-mcp/src/tools/index.ts
-import * as os4 from "os";
-import * as path29 from "path";
+import * as os6 from "os";
+import * as path31 from "path";
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema
@@ -2258,6 +2282,47 @@ async function handleWisdomTool(name, args, ctx) {
       if (totalAntipatterns > 0) {
         result.warning = "There are antipatterns for these symbols - review before implementing";
       }
+      try {
+        const calibration = {};
+        const calibration_warnings = [];
+        for (const sym of symbols) {
+          const assessed = await loadLoreEntries(ctx.rootDir, {
+            symbol: sym,
+            hasAssessment: true,
+            limit: 100
+          });
+          if (assessed.length === 0) continue;
+          const breakdown = { correct: 0, partial: 0, incorrect: 0 };
+          let confSum = 0;
+          let confCount = 0;
+          for (const e of assessed) {
+            const v = e.assessment.verdict;
+            breakdown[v]++;
+            if (e.confidence != null) {
+              confSum += e.confidence;
+              confCount++;
+            }
+          }
+          calibration[sym] = {
+            total: assessed.length,
+            ...breakdown,
+            avgConfidence: confCount > 0 ? Math.round(confSum / confCount * 1e3) / 1e3 : null
+          };
+          const accuracyRate = (breakdown.correct + breakdown.partial * 0.5) / assessed.length;
+          if (accuracyRate < 0.6 && assessed.length >= 3) {
+            calibration_warnings.push(
+              `Low historical accuracy for ${sym}: ${Math.round(accuracyRate * 100)}% across ${assessed.length} entries. Proceed with extra caution.`
+            );
+          }
+        }
+        if (Object.keys(calibration).length > 0) {
+          result.calibration = calibration;
+        }
+        if (calibration_warnings.length > 0) {
+          result.calibration_warnings = calibration_warnings;
+        }
+      } catch {
+      }
       return {
         handled: true,
         text: JSON.stringify(result, null, 2)
@@ -2791,7 +2856,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path30]) => sym.toLowerCase().includes(targetLower) || path30.toLowerCase().includes(targetLower)
+      ([sym, path32]) => sym.toLowerCase().includes(targetLower) || path32.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -7525,6 +7590,16 @@ var SEED_HABITS = [
     check: { type: "lore-recorded", params: {} },
     enabled: true
   },
+  {
+    id: "confidence-on-decisions",
+    name: "Confidence on Decisions",
+    description: "When recording lore, include a confidence score (0.0-1.0) to enable calibration tracking over time",
+    category: "documentation",
+    trigger: "on-stop",
+    severity: "advisory",
+    check: { type: "tool-called", params: { tools: ["paradigm_lore_record"] } },
+    enabled: true
+  },
   {
     id: "gates-for-routes",
     name: "Gates for Routes",
@@ -7534,6 +7609,26 @@ var SEED_HABITS = [
     severity: "warn",
     check: { type: "gates-declared", params: { requireRoutes: true } },
     enabled: true
+  },
+  {
+    id: "university-content-valid",
+    name: "University Content Valid",
+    description: "Validate university content integrity when files in symbol-covered areas change",
+    category: "quality",
+    trigger: "on-stop",
+    severity: "advisory",
+    check: { type: "tool-called", params: { tools: ["paradigm_university_validate"] } },
+    enabled: true
+  },
+  {
+    id: "university-onboarded",
+    name: "University Onboarding",
+    description: "Call paradigm_university_onboard at session start for project-specific learning content",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: { type: "tool-called", params: { tools: ["paradigm_university_onboard"] } },
+    enabled: false
   }
 ];
 var HABITS_CACHE_TTL_MS = 30 * 1e3;
@@ -8292,6 +8387,22 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
       suggestion: "Use paradigm_wisdom_record to capture architectural decisions or antipatterns."
     });
   }
+  for (const symbol of symbolsTouched) {
+    const results = searchSymbols(ctx.index, symbol);
+    if (results.length === 0) continue;
+    const sym = results[0];
+    if (sym.parentSymbol) {
+      const parentResults = searchSymbols(ctx.index, sym.parentSymbol);
+      if (parentResults.length === 0) {
+        violations.push({
+          type: "broken-reference",
+          severity: "warning",
+          message: `Symbol "${symbol}" references parent "${sym.parentSymbol}" which does not exist`,
+          suggestion: `Create the parent symbol or update the parent reference in the .purpose file.`
+        });
+      }
+    }
+  }
   const errors = violations.filter((v) => v.severity === "error").length;
   const warnings = violations.filter((v) => v.severity === "warning").length;
   let status = "pass";
@@ -8352,8 +8463,8 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
     status,
     violations,
     summary: {
-      totalChecks: 6,
-      passed: 6 - (errors > 0 ? 1 : 0) - (warnings > 0 ? 1 : 0),
+      totalChecks: 7,
+      passed: 7 - (errors > 0 ? 1 : 0) - (warnings > 0 ? 1 : 0),
       warnings,
       errors
     },
@@ -8438,6 +8549,14 @@ function getLoreToolsList() {
             type: "boolean",
             description: "Filter for entries with/without reviews"
           },
+          hasConfidence: {
+            type: "boolean",
+            description: "Filter for entries with/without confidence scores"
+          },
+          hasAssessment: {
+            type: "boolean",
+            description: "Filter for entries with/without assessment verdicts"
+          },
           limit: {
             type: "number",
             description: "Maximum results (default: 20)"
@@ -8566,6 +8685,10 @@ function getLoreToolsList() {
             type: "array",
             items: { type: "string" },
             description: "Git commit SHAs related to this entry"
+          },
+          confidence: {
+            type: "number",
+            description: "Agent confidence in correctness of this work (0.0 to 1.0)"
           }
         },
         required: ["title", "summary", "symbols_touched"]
@@ -8664,6 +8787,10 @@ function getLoreToolsList() {
           tags: {
             type: "array",
             items: { type: "string" }
+          },
+          confidence: {
+            type: "number",
+            description: "Agent confidence in correctness (0.0 to 1.0)"
           }
         },
         required: ["id"]
@@ -8673,6 +8800,71 @@ function getLoreToolsList() {
         destructiveHint: false
       }
     },
+    {
+      name: "paradigm_lore_assess",
+      description: "Record a human assessment verdict on a lore entry (correct/partial/incorrect). Computes calibration delta if confidence was recorded. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Lore entry ID to assess"
+          },
+          verdict: {
+            type: "string",
+            enum: ["correct", "partial", "incorrect"],
+            description: "Assessment verdict on the decisions/changes made"
+          },
+          notes: {
+            type: "string",
+            description: "Optional assessment notes"
+          }
+        },
+        required: ["id", "verdict"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_lore_calibration",
+      description: "Query calibration statistics across assessed lore entries. Returns accuracy rate, average confidence, calibration score, and verdict breakdown. Supports groupBy for domain-specific reliability maps. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: 'Filter by symbol (e.g., "#auth-middleware")'
+          },
+          tag: {
+            type: "string",
+            description: "Filter by tag prefix"
+          },
+          author: {
+            type: "string",
+            description: "Filter by author"
+          },
+          dateFrom: {
+            type: "string",
+            description: "Filter from date (ISO 8601)"
+          },
+          dateTo: {
+            type: "string",
+            description: "Filter to date (ISO 8601)"
+          },
+          groupBy: {
+            type: "string",
+            enum: ["symbol", "tag", "type"],
+            description: "Group calibration stats by dimension"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
     {
       name: "paradigm_lore_delete",
       description: "Delete a lore entry. Requires explicit confirmation to prevent accidental deletion. ~100 tokens.",
@@ -8712,6 +8904,8 @@ async function handleLoreTool(name, args, ctx) {
         hasBody: args.hasBody,
         tags: args.tags,
         hasReview: args.hasReview,
+        hasConfidence: args.hasConfidence,
+        hasAssessment: args.hasAssessment,
         limit: args.limit || 20,
         offset: args.offset
       };
@@ -8749,7 +8943,8 @@ async function handleLoreTool(name, args, ctx) {
         body,
         linked_lore,
         linked_tasks,
-        linked_commits
+        linked_commits,
+        confidence
       } = args;
       let habit_compliance;
       try {
@@ -8795,7 +8990,8 @@ async function handleLoreTool(name, args, ctx) {
         body,
         linked_lore,
         linked_tasks,
-        linked_commits
+        linked_commits,
+        confidence: confidence != null && confidence >= 0 && confidence <= 1 ? confidence : void 0
       };
       const id = await recordLoreEntry(ctx.rootDir, entry);
       getSessionTracker().setLastLoreEntryId(id);
@@ -8893,6 +9089,154 @@ async function handleLoreTool(name, args, ctx) {
         })
       };
     }
+    case "paradigm_lore_assess": {
+      const id = args.id;
+      const verdict = args.verdict;
+      const notes = args.notes;
+      const entryToAssess = await loadLoreEntry(ctx.rootDir, id);
+      if (!entryToAssess) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Lore entry not found: ${id}` })
+        };
+      }
+      const assessment = {
+        verdict,
+        assessed_by: resolveAuthorForMcp(),
+        assessed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        notes
+      };
+      const success = await addLoreAssessment(ctx.rootDir, id, assessment);
+      const impliedScore = verdict === "correct" ? 1 : verdict === "partial" ? 0.5 : 0;
+      const delta = entryToAssess.confidence != null ? impliedScore - entryToAssess.confidence : null;
+      const deltaDescription = delta != null ? delta > 0.1 ? "Under-confident (actual outcome better than predicted)" : delta < -0.1 ? "Over-confident (actual outcome worse than predicted)" : "Well-calibrated" : "No confidence recorded \u2014 delta not computed";
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success,
+          id,
+          verdict,
+          confidence: entryToAssess.confidence ?? null,
+          delta,
+          deltaDescription,
+          message: success ? `Assessment recorded: ${verdict}${delta != null ? ` (delta: ${delta > 0 ? "+" : ""}${delta.toFixed(2)})` : ""}` : `Failed to assess: ${id}`
+        })
+      };
+    }
+    case "paradigm_lore_calibration": {
+      const filter = {
+        symbol: args.symbol,
+        tag: args.tag,
+        author: args.author,
+        dateFrom: args.dateFrom,
+        dateTo: args.dateTo,
+        hasAssessment: true
+      };
+      const entries = await loadLoreEntries(ctx.rootDir, filter);
+      const withConfidence = entries.filter((e) => e.confidence != null);
+      const totalAssessed = entries.length;
+      const totalWithConfidence = withConfidence.length;
+      const verdictBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+      let totalImpliedScore = 0;
+      let totalConfidence = 0;
+      let totalAbsDelta = 0;
+      for (const e of entries) {
+        const v = e.assessment.verdict;
+        verdictBreakdown[v]++;
+        const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+        totalImpliedScore += implied;
+        if (e.confidence != null) {
+          totalConfidence += e.confidence;
+          totalAbsDelta += Math.abs(implied - e.confidence);
+        }
+      }
+      const accuracyRate = totalAssessed > 0 ? totalImpliedScore / totalAssessed : 0;
+      const avgConfidence = totalWithConfidence > 0 ? totalConfidence / totalWithConfidence : null;
+      const avgDelta = totalWithConfidence > 0 ? totalImpliedScore / totalAssessed - totalConfidence / totalWithConfidence : null;
+      const calibrationScore = totalWithConfidence > 0 ? 1 - totalAbsDelta / totalWithConfidence : null;
+      const groupBy = args.groupBy;
+      let groups;
+      if (groupBy && totalAssessed > 0) {
+        const groupMap = /* @__PURE__ */ new Map();
+        for (const e of entries) {
+          let keys = [];
+          if (groupBy === "symbol") {
+            keys = e.symbols_touched || [];
+          } else if (groupBy === "tag") {
+            keys = e.tags || [];
+          } else if (groupBy === "type") {
+            keys = [e.type || "agent-session"];
+          }
+          for (const key of keys) {
+            if (!groupMap.has(key)) groupMap.set(key, []);
+            groupMap.get(key).push(e);
+          }
+        }
+        groups = Array.from(groupMap.entries()).map(([key, gEntries]) => {
+          const gWithConf = gEntries.filter((e) => e.confidence != null);
+          const gBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+          let gImplied = 0;
+          let gConf = 0;
+          let gAbsDelta = 0;
+          for (const e of gEntries) {
+            const v = e.assessment.verdict;
+            gBreakdown[v]++;
+            const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+            gImplied += implied;
+            if (e.confidence != null) {
+              gConf += e.confidence;
+              gAbsDelta += Math.abs(implied - e.confidence);
+            }
+          }
+          return {
+            key,
+            total: gEntries.length,
+            accuracyRate: gImplied / gEntries.length,
+            avgConfidence: gWithConf.length > 0 ? gConf / gWithConf.length : null,
+            calibrationScore: gWithConf.length > 0 ? 1 - gAbsDelta / gWithConf.length : null,
+            verdictBreakdown: gBreakdown
+          };
+        }).sort((a, b) => b.total - a.total);
+      }
+      const insights = [];
+      const caveat = totalAssessed < 5 ? `Low sample size (N=${totalAssessed}). Stats may not be representative.` : totalAssessed < 15 ? `Moderate sample (N=${totalAssessed}). Trends are directional, not conclusive.` : null;
+      if (caveat) insights.push(caveat);
+      if (calibrationScore != null) {
+        if (calibrationScore >= 0.9) {
+          insights.push("Excellent calibration \u2014 confidence predictions closely match outcomes.");
+        } else if (calibrationScore >= 0.7) {
+          insights.push("Good calibration \u2014 some room for improvement in confidence estimates.");
+        } else if (calibrationScore >= 0.5) {
+          insights.push("Fair calibration \u2014 significant gap between predicted confidence and outcomes.");
+        } else {
+          insights.push("Poor calibration \u2014 confidence predictions diverge substantially from outcomes.");
+        }
+      }
+      if (avgDelta != null) {
+        if (avgDelta > 0.15) {
+          insights.push("Tendency toward under-confidence \u2014 outcomes are better than predicted.");
+        } else if (avgDelta < -0.15) {
+          insights.push("Tendency toward over-confidence \u2014 outcomes are worse than predicted.");
+        }
+      }
+      if (verdictBreakdown.incorrect > totalAssessed * 0.3 && totalAssessed >= 5) {
+        insights.push(`High error rate: ${verdictBreakdown.incorrect}/${totalAssessed} entries assessed as incorrect.`);
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          totalAssessed,
+          totalWithConfidence,
+          accuracyRate: Math.round(accuracyRate * 1e3) / 1e3,
+          avgConfidence: avgConfidence != null ? Math.round(avgConfidence * 1e3) / 1e3 : null,
+          avgDelta: avgDelta != null ? Math.round(avgDelta * 1e3) / 1e3 : null,
+          calibrationScore: calibrationScore != null ? Math.round(calibrationScore * 1e3) / 1e3 : null,
+          verdictBreakdown,
+          ...groups ? { groups } : {},
+          insights
+        }, null, 2)
+      };
+    }
     case "paradigm_lore_delete": {
       const id = args.id;
       const confirm = args.confirm;
@@ -8935,6 +9279,9 @@ function summarizeEntry(entry) {
       completeness: entry.review.completeness,
       quality: entry.review.quality
     } : null,
+    confidence: entry.confidence ?? null,
+    assessment: entry.assessment ? entry.assessment.verdict : null,
+    assessment_delta: entry.assessment_delta ?? null,
     tags: entry.tags
   };
 }
@@ -11301,8 +11648,8 @@ function generateRunId() {
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function interpolate(value, scope) {
   if (typeof value === "string") {
-    return value.replace(TEMPLATE_REGEX, (_match, path30) => {
-      const resolved = resolvePath(path30.trim(), scope);
+    return value.replace(TEMPLATE_REGEX, (_match, path32) => {
+      const resolved = resolvePath(path32.trim(), scope);
       return resolved !== void 0 ? String(resolved) : _match;
     });
   }
@@ -11335,8 +11682,8 @@ function resolvePath(dotPath, scope) {
       return void 0;
   }
 }
-function deepGet(obj, path30) {
-  const parts = path30.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path32) {
+  const parts = path32.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -11572,11 +11919,11 @@ async function runPersonaObject(rootDir, persona, options) {
 }
 async function runChain(rootDir, chainId, options) {
   const start = Date.now();
-  const fs26 = await import("fs");
-  const path30 = await import("path");
-  const yaml15 = await import("js-yaml");
-  const chainPath = path30.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
-  if (!fs26.existsSync(chainPath)) {
+  const fs28 = await import("fs");
+  const path32 = await import("path");
+  const yaml16 = await import("js-yaml");
+  const chainPath = path32.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
+  if (!fs28.existsSync(chainPath)) {
     return {
       chain_id: chainId,
       status: "error",
@@ -11585,7 +11932,7 @@ async function runChain(rootDir, chainId, options) {
       duration_ms: Date.now() - start
     };
   }
-  const chain = yaml15.load(fs26.readFileSync(chainPath, "utf8"));
+  const chain = yaml16.load(fs28.readFileSync(chainPath, "utf8"));
   let permutation;
   if (options.permutation && chain.permutations) {
     permutation = chain.permutations.find((p) => p.id === options.permutation);
@@ -11689,8 +12036,8 @@ function validateInterpolation(persona) {
     const serialized = JSON.stringify(step);
     const templates = serialized.match(TEMPLATE_REGEX) || [];
     for (const template of templates) {
-      const path30 = template.replace("{{", "").replace("}}", "").trim();
-      const [namespace, ...rest] = path30.split(".");
+      const path32 = template.replace("{{", "").replace("}}", "").trim();
+      const [namespace, ...rest] = path32.split(".");
       const key = rest.join(".");
       switch (namespace) {
         case "fixtures":
@@ -11751,7 +12098,7 @@ var PERSONA_SCHEMA = {
 var sentinelSchemaRegistered = false;
 async function emitPersonaEvents(result) {
   try {
-    const { SentinelStorage: SentinelStorage2 } = await import("./dist-IKBGY7FQ.js");
+    const { SentinelStorage: SentinelStorage2 } = await import("./dist-CM3MVWWW.js");
     const storage2 = new SentinelStorage2();
     if (!sentinelSchemaRegistered) {
       try {
@@ -14044,109 +14391,2188 @@ This session is no longer visible in the Conductor overlay.`,
   }
 }
 
-// ../paradigm-mcp/src/tools/fallback-grep.ts
+// ../paradigm-mcp/src/utils/symphony-loader.ts
+import * as fs26 from "fs";
 import * as path28 from "path";
-import { execSync as execSync7 } from "child_process";
-function grepForReferences(rootDir, symbol, options = {}) {
-  const { maxResults = 20 } = options;
-  const results = [];
-  const escapedSymbol = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const grepCommands = [
-    // ripgrep - exclude common directories
-    `rg -n --no-heading "${escapedSymbol}" "${rootDir}" --glob "!node_modules" --glob "!.git" --glob "!dist" --glob "!build" --glob "!coverage" --max-count 50 2>/dev/null`,
-    // fallback to grep
-    `grep -rn "${escapedSymbol}" "${rootDir}" --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist --exclude-dir=build --exclude-dir=coverage 2>/dev/null | head -50`
-  ];
-  let output = "";
-  for (const cmd of grepCommands) {
+import * as os4 from "os";
+import * as crypto from "crypto";
+var SCORE_DIR = path28.join(os4.homedir(), ".paradigm", "score");
+var LEGACY_MAIL_DIR = path28.join(os4.homedir(), ".paradigm", "mail");
+var AGENTS_DIR = path28.join(SCORE_DIR, "agents");
+var THREADS_DIR = path28.join(SCORE_DIR, "threads");
+var FILE_REQUESTS_DIR = path28.join(SCORE_DIR, "file-requests");
+var TRUST_CONFIG_PATH = path28.join(SCORE_DIR, "trust.yaml");
+var FILE_REQUEST_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_TRUST = {
+  users: {},
+  defaults: {
+    level: "restricted",
+    autoApprove: [],
+    neverApprove: [
+      ".env*",
+      "**/*.key",
+      "**/*.pem",
+      "**/credentials*",
+      "**/secrets/**"
+    ]
+  }
+};
+function migrateFromLegacyMail() {
+  if (fs26.existsSync(LEGACY_MAIL_DIR) && !fs26.existsSync(SCORE_DIR)) {
     try {
-      output = execSync7(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
-      if (output.trim()) break;
+      fs26.renameSync(LEGACY_MAIL_DIR, SCORE_DIR);
     } catch {
-      continue;
     }
   }
-  if (!output.trim()) {
-    return results;
+}
+function ensureScoreDirs() {
+  migrateFromLegacyMail();
+  for (const dir of [AGENTS_DIR, THREADS_DIR, FILE_REQUESTS_DIR]) {
+    if (!fs26.existsSync(dir)) {
+      fs26.mkdirSync(dir, { recursive: true });
+    }
   }
-  const lines = output.trim().split("\n");
-  for (const line of lines.slice(0, maxResults)) {
-    const match = line.match(/^(.+?):(\d+):(.*)$/);
-    if (match) {
-      const [, filePath, lineNum, content] = match;
-      const relativePath = path28.relative(rootDir, filePath);
-      let context2 = "unknown";
-      if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
-        context2 = "purpose";
-      } else if (content.includes("//") || content.includes("#") || content.includes("*")) {
-        context2 = "comment";
-      } else {
-        context2 = "code";
-      }
-      results.push({
-        filePath: relativePath,
-        line: parseInt(lineNum, 10),
-        content: content.trim().slice(0, 200),
-        context: context2
-      });
+}
+function getAgentDir(agentId) {
+  return path28.join(AGENTS_DIR, agentId);
+}
+function ensureAgentDir(agentId) {
+  const dir = getAgentDir(agentId);
+  if (!fs26.existsSync(dir)) {
+    fs26.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function readJsonlFile(filePath) {
+  if (!fs26.existsSync(filePath)) return [];
+  const content = fs26.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const items = [];
+  for (const line of lines) {
+    try {
+      items.push(JSON.parse(line));
+    } catch {
     }
   }
-  return results;
+  return items;
 }
-
-// ../paradigm-mcp/src/tools/fuzzy-match.ts
-function levenshteinDistance(a, b) {
-  const matrix = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
+function appendJsonlLine(filePath, item) {
+  const dir = path28.dirname(filePath);
+  if (!fs26.existsSync(dir)) {
+    fs26.mkdirSync(dir, { recursive: true });
   }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
+  fs26.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
+}
+function sanitizeId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "unknown";
+}
+function resolveProjectName(projectDir2) {
+  try {
+    const configPath = path28.join(projectDir2, ".paradigm", "config.yaml");
+    if (fs26.existsSync(configPath)) {
+      const content = fs26.readFileSync(configPath, "utf-8");
+      const match = content.match(/^project:\s*(.+)$/m);
+      if (match) return sanitizeId(match[1].trim().replace(/["']/g, ""));
+    }
+  } catch {
   }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          // substitution
-          matrix[i][j - 1] + 1,
-          // insertion
-          matrix[i - 1][j] + 1
-          // deletion
-        );
+  return sanitizeId(path28.basename(projectDir2));
+}
+function resolveAgentIdentity(projectDir2, role) {
+  const project = resolveProjectName(projectDir2);
+  const agentRole = role || "core";
+  return `${project}/${agentRole}`;
+}
+function registerAgent(projectDir2, role, label) {
+  ensureScoreDirs();
+  const agentId = resolveAgentIdentity(projectDir2, role);
+  const agentDir = ensureAgentDir(agentId);
+  const project = resolveProjectName(projectDir2);
+  const identity = {
+    id: agentId,
+    name: label || `${project} (${role || "core"})`,
+    type: "agent",
+    project,
+    role: role || "core",
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    label
+  };
+  fs26.writeFileSync(
+    path28.join(agentDir, "identity.json"),
+    JSON.stringify(identity, null, 2),
+    "utf-8"
+  );
+  return identity;
+}
+function unregisterAgent(agentId) {
+  const agentDir = getAgentDir(agentId);
+  if (!fs26.existsSync(agentDir)) return false;
+  try {
+    fs26.rmSync(agentDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listAgents() {
+  ensureScoreDirs();
+  if (!fs26.existsSync(AGENTS_DIR)) return [];
+  const agents = [];
+  const projectDirs = fs26.readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDir2 of projectDirs) {
+    const projectPath = path28.join(AGENTS_DIR, projectDir2.name);
+    const roleDirs = fs26.readdirSync(projectPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const roleDir of roleDirs) {
+      const identityPath = path28.join(projectPath, roleDir.name, "identity.json");
+      if (!fs26.existsSync(identityPath)) continue;
+      try {
+        const content = fs26.readFileSync(identityPath, "utf-8");
+        const identity = JSON.parse(content);
+        agents.push(identity);
+      } catch {
       }
     }
   }
-  return matrix[b.length][a.length];
+  return agents;
 }
-function findFuzzyMatches(query, candidates, options = {}) {
-  const { maxDistance = 3, maxResults = 5 } = options;
-  const queryLower = query.toLowerCase();
-  const matches = [];
-  for (const candidate of candidates) {
-    const candidateLower = candidate.toLowerCase();
-    if (candidateLower === queryLower) {
-      matches.push({ match: candidate, distance: 0 });
-      continue;
-    }
-    if (candidateLower.includes(queryLower) || queryLower.includes(candidateLower)) {
-      matches.push({ match: candidate, distance: 1 });
-      continue;
-    }
-    const distance = levenshteinDistance(queryLower, candidateLower);
-    if (distance <= maxDistance) {
-      matches.push({ match: candidate, distance });
+function cleanStaleAgents() {
+  const agents = listAgents();
+  let cleaned = 0;
+  for (const agent of agents) {
+    if (!isProcessAlive2(agent.pid)) {
+      unregisterAgent(agent.id);
+      cleaned++;
     }
   }
-  matches.sort((a, b) => {
-    if (a.distance !== b.distance) return a.distance - b.distance;
-    return a.match.localeCompare(b.match);
-  });
-  return matches.slice(0, maxResults);
+  return cleaned;
 }
-
+function getMyIdentity(projectDir2) {
+  const agentId = resolveAgentIdentity(projectDir2);
+  const identityPath = path28.join(getAgentDir(agentId), "identity.json");
+  if (!fs26.existsSync(identityPath)) return null;
+  try {
+    return JSON.parse(fs26.readFileSync(identityPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function markAgentPollTime(agentId, statusBlurb) {
+  const identityPath = path28.join(getAgentDir(agentId), "identity.json");
+  if (!fs26.existsSync(identityPath)) return;
+  try {
+    const identity = JSON.parse(fs26.readFileSync(identityPath, "utf-8"));
+    identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    if (statusBlurb !== void 0) {
+      identity.statusBlurb = statusBlurb || void 0;
+    }
+    fs26.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isAgentAsleep(identity, thresholdMs = 6e4) {
+  if (!identity.lastPoll) return true;
+  const lastPoll = new Date(identity.lastPoll).getTime();
+  return Date.now() - lastPoll > thresholdMs;
+}
+function inboxPath(agentId) {
+  return path28.join(getAgentDir(agentId), "inbox.jsonl");
+}
+function outboxPath(agentId) {
+  return path28.join(getAgentDir(agentId), "outbox.jsonl");
+}
+function ackPath(agentId) {
+  return path28.join(getAgentDir(agentId), "ack.json");
+}
+function appendToInbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(inboxPath(agentId), message);
+}
+function readInbox(agentId, afterAck) {
+  const messages = readJsonlFile(inboxPath(agentId));
+  if (!afterAck) {
+    const ack = readAck(agentId);
+    if (ack) {
+      const ackIndex2 = messages.findIndex((m) => m.id === ack);
+      if (ackIndex2 >= 0) return messages.slice(ackIndex2 + 1);
+    }
+    return messages;
+  }
+  const ackIndex = messages.findIndex((m) => m.id === afterAck);
+  if (ackIndex >= 0) return messages.slice(ackIndex + 1);
+  return messages;
+}
+function appendToOutbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(outboxPath(agentId), message);
+}
+function acknowledgeMessages(agentId, lastMessageId) {
+  const filePath = ackPath(agentId);
+  ensureAgentDir(agentId);
+  fs26.writeFileSync(filePath, JSON.stringify({ lastAck: lastMessageId }), "utf-8");
+}
+function readAck(agentId) {
+  const filePath = ackPath(agentId);
+  if (!fs26.existsSync(filePath)) return null;
+  try {
+    const content = JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+    return content.lastAck || null;
+  } catch {
+    return null;
+  }
+}
+function garbageCollect(agentId) {
+  const ack = readAck(agentId);
+  if (!ack) return 0;
+  const filePath = inboxPath(agentId);
+  const messages = readJsonlFile(filePath);
+  const ackIndex = messages.findIndex((m) => m.id === ack);
+  if (ackIndex < 0) return 0;
+  const kept = messages.slice(ackIndex + 1);
+  const removed = messages.length - kept.length;
+  if (kept.length === 0) {
+    if (fs26.existsSync(filePath)) fs26.writeFileSync(filePath, "", "utf-8");
+  } else {
+    fs26.writeFileSync(filePath, kept.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
+  }
+  return removed;
+}
+function threadPath(threadId) {
+  return path28.join(THREADS_DIR, `${threadId}.json`);
+}
+function createThread(topic, initiator) {
+  ensureScoreDirs();
+  const id = "thr-" + crypto.randomBytes(4).toString("hex");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const thread = {
+    id,
+    topic,
+    initiator,
+    participants: [initiator],
+    status: "active",
+    createdAt: now,
+    lastActivity: now,
+    messageCount: 0
+  };
+  fs26.writeFileSync(threadPath(id), JSON.stringify(thread, null, 2), "utf-8");
+  return thread;
+}
+function loadThread(threadId) {
+  const filePath = threadPath(threadId);
+  if (!fs26.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listThreads(status) {
+  ensureScoreDirs();
+  if (!fs26.existsSync(THREADS_DIR)) return [];
+  const files = fs26.readdirSync(THREADS_DIR).filter((f) => f.endsWith(".json"));
+  const threads = [];
+  for (const file of files) {
+    try {
+      const content = fs26.readFileSync(path28.join(THREADS_DIR, file), "utf-8");
+      const thread = JSON.parse(content);
+      if (!status || thread.status === status) {
+        threads.push(thread);
+      }
+    } catch {
+    }
+  }
+  return threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+function updateThread(threadId, partial) {
+  const thread = loadThread(threadId);
+  if (!thread) return false;
+  const updated = { ...thread, ...partial };
+  fs26.writeFileSync(threadPath(threadId), JSON.stringify(updated, null, 2), "utf-8");
+  return true;
+}
+function getThreadMessages(threadId) {
+  const agents = listAgents();
+  const messages = [];
+  for (const agent of agents) {
+    const inbox = readJsonlFile(inboxPath(agent.id));
+    const outbox = readJsonlFile(outboxPath(agent.id));
+    for (const msg of [...inbox, ...outbox]) {
+      if (msg.threadRoot === threadId || msg.id === threadId) {
+        if (!messages.some((m) => m.id === msg.id)) {
+          messages.push(msg);
+        }
+      }
+    }
+  }
+  return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+function buildMessage(params) {
+  return {
+    id: crypto.randomUUID(),
+    parentId: params.parentId,
+    threadRoot: params.threadRoot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: params.sender,
+    recipients: params.recipients,
+    intent: params.intent,
+    content: {
+      text: params.text,
+      diff: params.diff,
+      decision: params.decision
+    },
+    symbols: params.symbols || [],
+    attachments: params.attachments,
+    metadata: params.metadata
+  };
+}
+function routeMessage(message) {
+  ensureScoreDirs();
+  appendToOutbox(message.sender.id, message);
+  let deliveryCount = 0;
+  if (message.recipients && message.recipients.length > 0) {
+    for (const recipient of message.recipients) {
+      appendToInbox(recipient.id, message);
+      deliveryCount++;
+    }
+  } else {
+    const agents = listAgents();
+    for (const agent of agents) {
+      if (agent.id !== message.sender.id) {
+        appendToInbox(agent.id, message);
+        deliveryCount++;
+      }
+    }
+  }
+  if (message.threadRoot) {
+    const thread = loadThread(message.threadRoot);
+    if (thread) {
+      const isParticipant = thread.participants.some((p) => p.id === message.sender.id);
+      const updatedParticipants = isParticipant ? thread.participants : [...thread.participants, message.sender];
+      updateThread(message.threadRoot, {
+        participants: updatedParticipants,
+        lastActivity: message.timestamp,
+        messageCount: thread.messageCount + 1
+      });
+    }
+  }
+  return deliveryCount;
+}
+function fileRequestPath(requestId) {
+  return path28.join(FILE_REQUESTS_DIR, `${requestId}.json`);
+}
+function loadTrustConfig() {
+  if (!fs26.existsSync(TRUST_CONFIG_PATH)) return DEFAULT_TRUST;
+  try {
+    const content = fs26.readFileSync(TRUST_CONFIG_PATH, "utf-8");
+    try {
+      return JSON.parse(content);
+    } catch {
+      return DEFAULT_TRUST;
+    }
+  } catch {
+    return DEFAULT_TRUST;
+  }
+}
+function createFileRequest(params) {
+  ensureScoreDirs();
+  const requestId = "freq-" + crypto.randomBytes(4).toString("hex");
+  const record = {
+    request: {
+      requestId,
+      filePath: params.filePath,
+      reason: params.reason,
+      requester: params.requester,
+      urgency: params.urgency || "normal",
+      snippet: params.snippet,
+      threadRoot: params.threadRoot
+    },
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs26.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  return record;
+}
+function loadFileRequest(requestId) {
+  const filePath = fileRequestPath(requestId);
+  if (!fs26.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listFileRequests(status) {
+  ensureScoreDirs();
+  if (!fs26.existsSync(FILE_REQUESTS_DIR)) return [];
+  const files = fs26.readdirSync(FILE_REQUESTS_DIR).filter((f) => f.endsWith(".json"));
+  const requests = [];
+  for (const file of files) {
+    try {
+      const content = fs26.readFileSync(path28.join(FILE_REQUESTS_DIR, file), "utf-8");
+      const record = JSON.parse(content);
+      if (!status || record.status === status) {
+        requests.push(record);
+      }
+    } catch {
+    }
+  }
+  return requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function approveFileRequest(requestId, projectDir2, redact) {
+  const record = loadFileRequest(requestId);
+  if (!record) return { success: false, error: `File request not found: ${requestId}` };
+  if (record.status !== "pending") return { success: false, error: `Request already ${record.status}` };
+  const absolutePath = path28.resolve(projectDir2, record.request.filePath);
+  if (!absolutePath.startsWith(path28.resolve(projectDir2))) {
+    return { success: false, error: "File path escapes project directory" };
+  }
+  if (!fs26.existsSync(absolutePath)) {
+    return { success: false, error: `File not found: ${record.request.filePath}` };
+  }
+  try {
+    let content = fs26.readFileSync(absolutePath, "utf-8");
+    let encoding = "utf8";
+    if (redact) {
+      const secretPatterns = [
+        /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]/i,
+        /(?:^|\s)(?:export\s+)?[A-Z_]+(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=/,
+        /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
+      ];
+      content = content.split("\n").map((line) => {
+        for (const pattern of secretPatterns) {
+          if (pattern.test(line)) return "[REDACTED]";
+        }
+        return line;
+      }).join("\n");
+    }
+    const hash = crypto.createHash("sha256").update(content).digest("hex");
+    const delivery = {
+      requestId,
+      filePath: record.request.filePath,
+      content,
+      encoding,
+      size: Buffer.byteLength(content),
+      hash
+    };
+    record.status = "approved";
+    record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+    record.delivery = delivery;
+    fs26.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+    const deliveryMessage = buildMessage({
+      sender: { id: "system", name: "File Transfer", type: "human" },
+      recipients: [record.request.requester],
+      intent: "fileDelivery",
+      text: `File delivered: ${record.request.filePath} (${delivery.size} bytes, SHA-256: ${hash.slice(0, 12)}...)`,
+      threadRoot: record.request.threadRoot,
+      symbols: []
+    });
+    deliveryMessage.attachments = [{
+      name: path28.basename(record.request.filePath),
+      type: "file",
+      content: delivery.content,
+      encoding: delivery.encoding
+    }];
+    routeMessage(deliveryMessage);
+    return { success: true, delivery };
+  } catch (err2) {
+    return { success: false, error: `Failed to read file: ${err2.message}` };
+  }
+}
+function denyFileRequest(requestId, reason) {
+  const record = loadFileRequest(requestId);
+  if (!record || record.status !== "pending") return false;
+  record.status = "denied";
+  record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  record.denyReason = reason;
+  fs26.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  const denialMessage = buildMessage({
+    sender: { id: "system", name: "File Transfer", type: "human" },
+    recipients: [record.request.requester],
+    intent: "fileDenied",
+    text: `File request denied: ${record.request.filePath}${reason ? ` \u2014 ${reason}` : ""}`,
+    threadRoot: record.request.threadRoot,
+    symbols: []
+  });
+  routeMessage(denialMessage);
+  return true;
+}
+function matchesGlob(filePath, pattern) {
+  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(filePath);
+}
+function isPathDenied(filePath, config, user) {
+  const trust = config || loadTrustConfig();
+  if (user && trust.users[user]) {
+    for (const pattern of trust.users[user].neverApprove) {
+      if (matchesGlob(filePath, pattern)) return true;
+    }
+  }
+  for (const pattern of trust.defaults.neverApprove) {
+    if (matchesGlob(filePath, pattern)) return true;
+  }
+  return false;
+}
+function expireOldRequests() {
+  const requests = listFileRequests("pending");
+  let expired = 0;
+  for (const record of requests) {
+    const age = Date.now() - new Date(record.createdAt).getTime();
+    if (age > FILE_REQUEST_TTL_MS) {
+      record.status = "expired";
+      record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+      fs26.writeFileSync(
+        fileRequestPath(record.request.requestId),
+        JSON.stringify(record, null, 2),
+        "utf-8"
+      );
+      expired++;
+    }
+  }
+  return expired;
+}
+function isProcessAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../paradigm-mcp/src/tools/symphony.ts
+function getSymphonyToolsList() {
+  return [
+    {
+      name: "paradigm_symphony_poll",
+      description: "Poll inbox for new notes. Call via /loop for continuous agent messaging. Returns unread notes formatted as markdown with thread context and suggested actions. Updates heartbeat and optional status blurb. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            description: 'Short status blurb describing what you are currently working on (e.g., "Implementing auth middleware \u2014 3 files modified"). Visible to humans and other agents in the Network view.'
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: false,
+        // Updates ack + poll time
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_symphony_send",
+      description: "Send a note to other agents or broadcast. Auto-creates thread if no threadRoot provided. Supports intents: question, context, proposal, decision, action, etc. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          intent: {
+            type: "string",
+            enum: [
+              "question",
+              "context",
+              "clarification",
+              "proposal",
+              "verification",
+              "action",
+              "decision",
+              "alert",
+              "approval",
+              "rejection",
+              "reference",
+              "handoff"
+            ],
+            description: "Message intent (what kind of message this is)"
+          },
+          text: {
+            type: "string",
+            description: "Message text content"
+          },
+          parentId: {
+            type: "string",
+            description: "ID of message being replied to"
+          },
+          threadRoot: {
+            type: "string",
+            description: "Thread ID to post in (auto-created if omitted)"
+          },
+          recipients: {
+            type: "array",
+            items: { type: "string" },
+            description: "Agent IDs to send to (omit for broadcast)"
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Paradigm symbols referenced (e.g., ["#auth-service", "$login-flow"])'
+          },
+          diff: {
+            type: "string",
+            description: "Code diff to include with the message"
+          },
+          decision: {
+            type: "string",
+            description: "Decision text to record (for intent=decision)"
+          }
+        },
+        required: ["intent", "text"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_symphony_status",
+      description: "Show Symphony network status: linked agents (with awake/asleep detection), active threads, unread count, pending file requests. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_symphony_thread",
+      description: "Get full thread context: all notes in order, participants, extracted decisions, and referenced symbols. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          threadId: {
+            type: "string",
+            description: "Thread ID (thr-XXXXXXXX format)"
+          },
+          depth: {
+            type: "number",
+            description: "Maximum messages to return (default: 50)"
+          }
+        },
+        required: ["threadId"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_symphony_request_file",
+      description: "Request a file from another agent's project. Human approval required (unless auto-approved in trust config). Files matching hard-deny patterns (.env, *.key, etc.) are always blocked. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: 'Relative file path to request (e.g., "src/auth/middleware.ts")'
+          },
+          from: {
+            type: "string",
+            description: 'Agent ID to request file from (e.g., "backend/core")'
+          },
+          reason: {
+            type: "string",
+            description: "Why this file is needed"
+          },
+          snippet: {
+            type: "string",
+            description: 'Specific function or line range needed (e.g., "validateToken function" or "lines 50-100")'
+          }
+        },
+        required: ["filePath", "from", "reason"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_symphony_approve_file",
+      description: 'Approve or deny a pending file request. Use action "approve" to send file, "deny" to reject, or "approve-redacted" to send with secrets stripped. ~100 tokens.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          requestId: {
+            type: "string",
+            description: "File request ID (freq-XXXXXXXX format)"
+          },
+          action: {
+            type: "string",
+            enum: ["approve", "deny", "approve-redacted"],
+            description: "Approve, deny, or approve with redaction"
+          },
+          reason: {
+            type: "string",
+            description: "Reason for denial (required for deny action)"
+          }
+        },
+        required: ["requestId", "action"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handleSymphonyTool(name, args, ctx) {
+  let identity = getMyIdentity(ctx.rootDir);
+  if (!identity) {
+    identity = registerAgent(ctx.rootDir);
+  }
+  switch (name) {
+    case "paradigm_symphony_poll": {
+      cleanStaleAgents();
+      expireOldRequests();
+      const statusBlurb = args.status;
+      markAgentPollTime(identity.id, statusBlurb);
+      const messages = readInbox(identity.id);
+      if (messages.length > 0) {
+        const lastId = messages[messages.length - 1].id;
+        acknowledgeMessages(identity.id, lastId);
+      }
+      garbageCollect(identity.id);
+      const pendingRequests = listFileRequests("pending");
+      if (messages.length === 0 && pendingRequests.length === 0) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            messages: 0,
+            note: "No new notes. Score is quiet.",
+            identity: identity.id
+          })
+        };
+      }
+      const formatted = formatPollOutput(messages, pendingRequests);
+      return {
+        handled: true,
+        text: formatted
+      };
+    }
+    case "paradigm_symphony_send": {
+      const intent = args.intent;
+      const text = args.text;
+      const parentId = args.parentId;
+      let threadRoot = args.threadRoot;
+      const recipientIds = args.recipients;
+      const symbols = args.symbols;
+      const diff = args.diff;
+      const decision = args.decision;
+      let threadCreated = false;
+      if (!threadRoot && !parentId) {
+        const topic = text.length > 60 ? text.slice(0, 60) + "..." : text;
+        const thread = createThread(topic, identityToParticipant(identity));
+        threadRoot = thread.id;
+        threadCreated = true;
+      }
+      let recipients;
+      if (recipientIds && recipientIds.length > 0) {
+        const allAgents = listAgents();
+        recipients = recipientIds.map((id) => {
+          const agent = allAgents.find((a) => a.id === id);
+          if (agent) return identityToParticipant(agent);
+          return { id, name: id, type: "agent" };
+        });
+      }
+      const message = buildMessage({
+        sender: identityToParticipant(identity),
+        recipients,
+        intent,
+        text,
+        parentId,
+        threadRoot,
+        symbols,
+        diff,
+        decision
+      });
+      const deliveryCount = routeMessage(message);
+      emitSymphonyEvent(message).catch(() => {
+      });
+      if (threadCreated && threadRoot) {
+        const threadEvent = {
+          id: `thread-created-${threadRoot}`,
+          threadRoot,
+          timestamp: message.timestamp,
+          sender: message.sender,
+          intent: "context",
+          content: { text: `Thread created: ${message.content.text.slice(0, 60)}` },
+          symbols: []
+        };
+        fetch(`${SENTINEL_URL}/api/events`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            schemaId: "paradigm-symphony",
+            eventType: "thread:created",
+            category: "lifecycle",
+            timestamp: message.timestamp,
+            scopeValue: threadRoot,
+            service: message.sender.project || "symphony",
+            severity: "info",
+            data: {
+              topic: message.content.text.slice(0, 60),
+              initiator: message.sender.name,
+              threadId: threadRoot
+            }
+          })
+        }).catch(() => {
+        });
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          sent: true,
+          messageId: message.id,
+          threadId: threadRoot,
+          threadCreated,
+          deliveredTo: deliveryCount,
+          intent
+        })
+      };
+    }
+    case "paradigm_symphony_status": {
+      cleanStaleAgents();
+      const agents = listAgents();
+      const threads = listThreads("active");
+      const unread = readInbox(identity.id);
+      const pendingRequests = listFileRequests("pending");
+      return {
+        handled: true,
+        text: JSON.stringify({
+          identity: {
+            id: identity.id,
+            project: identity.project,
+            role: identity.role
+          },
+          agents: agents.map((a) => ({
+            id: a.id,
+            name: a.name,
+            project: a.project,
+            role: a.role,
+            status: isAgentAsleep(a) ? "asleep" : "awake",
+            lastPoll: a.lastPoll,
+            statusBlurb: a.statusBlurb
+          })),
+          activeThreads: threads.map((t) => ({
+            id: t.id,
+            topic: t.topic,
+            participants: t.participants.length,
+            messageCount: t.messageCount,
+            lastActivity: t.lastActivity
+          })),
+          unreadCount: unread.length,
+          pendingFileRequests: pendingRequests.length
+        }, null, 2)
+      };
+    }
+    case "paradigm_symphony_thread": {
+      const threadId = args.threadId;
+      const depth = args.depth || 50;
+      const thread = loadThread(threadId);
+      if (!thread) {
+        return {
+          handled: true,
+          text: JSON.stringify({ error: `Thread not found: ${threadId}` })
+        };
+      }
+      const messages = getThreadMessages(threadId).slice(0, depth);
+      const decisions = [];
+      const symbolsDiscussed = /* @__PURE__ */ new Set();
+      const filesReferenced = /* @__PURE__ */ new Set();
+      for (const msg of messages) {
+        if (msg.content.decision) decisions.push(msg.content.decision);
+        if (msg.intent === "decision" && msg.content.text) decisions.push(msg.content.text);
+        for (const sym of msg.symbols) symbolsDiscussed.add(sym);
+        if (msg.attachments) {
+          for (const att of msg.attachments) {
+            if (att.type === "file") filesReferenced.add(att.name);
+          }
+        }
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          thread: {
+            id: thread.id,
+            topic: thread.topic,
+            status: thread.status,
+            createdAt: thread.createdAt,
+            decision: thread.decision
+          },
+          participants: thread.participants,
+          messages: messages.map((m) => ({
+            id: m.id,
+            sender: m.sender.name,
+            intent: m.intent,
+            text: m.content.text,
+            timestamp: m.timestamp,
+            symbols: m.symbols,
+            hasDiff: !!m.content.diff,
+            hasDecision: !!m.content.decision
+          })),
+          decisions,
+          symbolsDiscussed: [...symbolsDiscussed],
+          filesReferenced: [...filesReferenced]
+        }, null, 2)
+      };
+    }
+    case "paradigm_symphony_request_file": {
+      const filePath = args.filePath;
+      const from = args.from;
+      const reason = args.reason;
+      const snippet = args.snippet;
+      const trustConfig = loadTrustConfig();
+      if (isPathDenied(filePath, trustConfig)) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            error: `File path "${filePath}" is on the hard-deny list and cannot be requested.`,
+            deniedPatterns: trustConfig.defaults.neverApprove
+          })
+        };
+      }
+      const record = createFileRequest({
+        filePath,
+        requester: identityToParticipant(identity),
+        reason,
+        snippet,
+        threadRoot: void 0
+      });
+      const requestMessage = buildMessage({
+        sender: identityToParticipant(identity),
+        recipients: [{ id: from, name: from, type: "agent" }],
+        intent: "fileRequest",
+        text: `Requesting file: ${filePath}
+Reason: ${reason}${snippet ? `
+Snippet: ${snippet}` : ""}`,
+        symbols: []
+      });
+      routeMessage(requestMessage);
+      return {
+        handled: true,
+        text: JSON.stringify({
+          requestId: record.request.requestId,
+          status: "pending",
+          filePath,
+          from,
+          message: `File request created. The owning agent's human must approve via "paradigm symphony approve ${record.request.requestId}" or "paradigm_symphony_approve_file".`
+        })
+      };
+    }
+    case "paradigm_symphony_approve_file": {
+      const requestId = args.requestId;
+      const action = args.action;
+      const reason = args.reason;
+      if (action === "deny") {
+        const success = denyFileRequest(requestId, reason);
+        return {
+          handled: true,
+          text: JSON.stringify({
+            success,
+            requestId,
+            action: "denied",
+            reason: reason || "No reason provided"
+          })
+        };
+      }
+      const redact = action === "approve-redacted";
+      const result = approveFileRequest(requestId, ctx.rootDir, redact);
+      if (!result.success) {
+        return {
+          handled: true,
+          text: JSON.stringify({
+            success: false,
+            requestId,
+            error: result.error
+          })
+        };
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          success: true,
+          requestId,
+          action: redact ? "approved-redacted" : "approved",
+          filePath: result.delivery?.filePath,
+          size: result.delivery?.size,
+          hash: result.delivery?.hash
+        })
+      };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+function identityToParticipant(identity) {
+  return {
+    id: identity.id,
+    name: identity.name,
+    type: identity.type || "agent",
+    project: identity.project,
+    role: identity.role
+  };
+}
+function formatPollOutput(messages, pendingRequests) {
+  const parts = [];
+  const byThread = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const threadId = msg.threadRoot || "direct";
+    if (!byThread.has(threadId)) byThread.set(threadId, []);
+    byThread.get(threadId).push(msg);
+  }
+  for (const [threadId, threadMsgs] of byThread) {
+    let threadTopic = threadId;
+    if (threadId !== "direct") {
+      const thread = loadThread(threadId);
+      if (thread) threadTopic = thread.topic;
+    }
+    parts.push(`## Symphony: ${threadMsgs.length} new note${threadMsgs.length !== 1 ? "s" : ""} in "${threadTopic}"
+`);
+    for (let i = 0; i < threadMsgs.length; i++) {
+      const msg = threadMsgs[i];
+      const time = new Date(msg.timestamp).toLocaleTimeString(void 0, { hour: "numeric", minute: "2-digit" });
+      const senderLabel = `${msg.sender.name}${msg.sender.project ? ` (${msg.sender.project})` : ""}`;
+      parts.push(`### ${i + 1}. ${senderLabel} \u2014 ${capitalize(msg.intent)} (${time})`);
+      parts.push(`> ${msg.content.text.split("\n").join("\n> ")}`);
+      if (msg.symbols.length > 0) {
+        parts.push(`> Symbols: ${msg.symbols.join(", ")}`);
+      }
+      if (msg.content.diff) {
+        parts.push(`
+\`\`\`diff
+${msg.content.diff}
+\`\`\``);
+      }
+      if (msg.content.decision) {
+        parts.push(`
+**Decision:** ${msg.content.decision}`);
+      }
+      const action = suggestAction(msg);
+      if (action) parts.push(`
+**Suggested action:** ${action}`);
+      parts.push("");
+    }
+  }
+  if (pendingRequests.length > 0) {
+    parts.push(`## Pending File Requests (${pendingRequests.length})
+`);
+    for (const req of pendingRequests) {
+      parts.push(`- **${req.request.filePath}** from ${req.request.requester.name}: ${req.request.reason}`);
+      parts.push(`  Approve: \`paradigm_symphony_approve_file({ requestId: "${req.request.requestId}", action: "approve" })\``);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function suggestAction(msg) {
+  switch (msg.intent) {
+    case "question":
+      return 'Reply with paradigm_symphony_send using intent "context" or "clarification"';
+    case "proposal":
+      return 'Reply with intent "approval" or "rejection"';
+    case "fileRequest":
+      return "Use paradigm_symphony_approve_file to approve or deny";
+    case "handoff":
+      return "Review handoff context and continue the work";
+    case "alert":
+      return 'Investigate the alert and reply with intent "action"';
+    case "verification":
+      return 'Confirm with intent "approval" or clarify with "clarification"';
+    default:
+      return null;
+  }
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var SENTINEL_URL = "http://localhost:3838";
+var symphonySchemaRegistered = false;
+function intentToEventType(intent) {
+  switch (intent) {
+    case "question":
+      return "note:question";
+    case "context":
+      return "note:context";
+    case "clarification":
+      return "note:clarification";
+    case "proposal":
+      return "note:proposal";
+    case "verification":
+      return "note:verification";
+    case "action":
+      return "note:action";
+    case "decision":
+      return "note:decision";
+    case "alert":
+      return "note:alert";
+    case "approval":
+      return "note:approval";
+    case "rejection":
+      return "note:rejection";
+    case "reference":
+      return "note:reference";
+    case "handoff":
+      return "note:handoff";
+    case "fileRequest":
+      return "file:requested";
+    case "fileApproved":
+      return "file:approved";
+    case "fileDenied":
+      return "file:denied";
+    case "fileDelivery":
+      return "file:delivered";
+    default:
+      return "note:context";
+  }
+}
+function eventTypeToCategory(eventType) {
+  if (eventType.startsWith("note:")) {
+    const intent = eventType.split(":")[1];
+    if (["question", "context", "clarification", "verification", "reference"].includes(intent)) return "dialogue";
+    if (["proposal", "action"].includes(intent)) return "action";
+    if (["decision", "approval", "rejection"].includes(intent)) return "outcome";
+    if (intent === "alert") return "system";
+    if (intent === "handoff") return "lifecycle";
+  }
+  if (eventType.startsWith("thread:") || eventType.startsWith("participant:")) return "lifecycle";
+  if (eventType.startsWith("file:")) return "transfer";
+  return "dialogue";
+}
+async function emitSymphonyEvent(note) {
+  try {
+    if (!symphonySchemaRegistered) {
+      await fetch(`${SENTINEL_URL}/api/schemas`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: "paradigm-symphony",
+          version: "1.0.0",
+          name: "Symphony Conversations",
+          description: "Agent-to-agent messaging events from The Score protocol"
+        })
+      }).catch(() => {
+      });
+      symphonySchemaRegistered = true;
+    }
+    const eventType = intentToEventType(note.intent);
+    const category = eventTypeToCategory(eventType);
+    await fetch(`${SENTINEL_URL}/api/events`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        schemaId: "paradigm-symphony",
+        eventType,
+        category,
+        timestamp: note.timestamp,
+        scopeValue: note.threadRoot || note.id,
+        service: note.sender.project || "symphony",
+        severity: category === "system" ? "error" : category === "outcome" ? "warn" : "info",
+        parentEventId: note.parentId,
+        data: {
+          sender: note.sender.name,
+          senderRole: note.sender.role || "core",
+          text: note.content.text,
+          symbols: note.symbols,
+          diff: note.content.diff,
+          decision: note.content.decision,
+          parentId: note.parentId,
+          threadId: note.threadRoot
+        }
+      })
+    });
+  } catch {
+  }
+}
+
+// ../paradigm-mcp/src/tools/university.ts
+import { execSync as execSync7 } from "child_process";
+import * as os5 from "os";
+function resolveAuthor2() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitize3(envAuthor);
+  try {
+    const gitName = execSync7("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitize3(gitName);
+  } catch {
+  }
+  try {
+    const username = os5.userInfo().username;
+    if (username) return sanitize3(username);
+  } catch {
+  }
+  return "unknown";
+}
+function sanitize3(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
+function todayStr() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function getUniversityToolsList() {
+  return [
+    {
+      name: "paradigm_university_search",
+      description: "Search project university content by type, tag, difficulty, or symbol. Returns matching content items. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["note", "policy", "guide", "runbook", "quiz", "path"],
+            description: "Filter by content type"
+          },
+          tag: {
+            type: "string",
+            description: "Filter by tag prefix"
+          },
+          difficulty: {
+            type: "string",
+            enum: ["beginner", "intermediate", "advanced"],
+            description: "Filter by difficulty level"
+          },
+          symbol: {
+            type: "string",
+            description: 'Filter by Paradigm symbol (e.g., "#api-gateway")'
+          },
+          query: {
+            type: "string",
+            description: "Free-text search in title and tags"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results (default: 20)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_get",
+      description: "Fetch a university content item by ID. Returns full content including body for notes/policies and questions for quizzes. ~300 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Content ID (e.g., "N-architecture-overview", "Q-onboarding-basics", "LP-new-engineer")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_create",
+      description: "Create a new university content item (note, policy, quiz, or learning path). Auto-generates timestamps and resolves author. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["note", "policy", "guide", "runbook", "quiz", "path"],
+            description: "Content type to create"
+          },
+          title: {
+            type: "string",
+            description: "Content title"
+          },
+          body: {
+            type: "string",
+            description: "Markdown body for notes/policies. Quiz/path YAML content for those types."
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Tags for classification"
+          },
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: "Paradigm symbols referenced by this content"
+          },
+          difficulty: {
+            type: "string",
+            enum: ["beginner", "intermediate", "advanced"],
+            description: "Difficulty level (default: beginner)"
+          },
+          estimatedMinutes: {
+            type: "number",
+            description: "Estimated reading/completion time in minutes"
+          },
+          prerequisites: {
+            type: "array",
+            items: { type: "string" },
+            description: "IDs of prerequisite content items"
+          },
+          // Quiz-specific fields
+          passThreshold: {
+            type: "number",
+            description: "For quizzes: pass threshold 0.0-1.0 (default: 0.7)"
+          },
+          questions: {
+            type: "array",
+            description: "For quizzes: array of {id, question, choices: {A:..., B:...}, correct, explanation?}"
+          },
+          // Path-specific fields
+          ordered: {
+            type: "boolean",
+            description: "For learning paths: whether steps must be completed in order"
+          },
+          steps: {
+            type: "array",
+            description: "For learning paths: array of {content, required, passRequired?, note?}"
+          }
+        },
+        required: ["type", "title"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_update",
+      description: "Update an existing university content item. Specify only the fields to change. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Content ID to update"
+          },
+          title: { type: "string", description: "New title" },
+          body: { type: "string", description: "New body content" },
+          tags: { type: "array", items: { type: "string" }, description: "New tags" },
+          symbols: { type: "array", items: { type: "string" }, description: "New symbols" },
+          difficulty: { type: "string", enum: ["beginner", "intermediate", "advanced"] },
+          estimatedMinutes: { type: "number" }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_quiz",
+      description: "Get a quiz for taking \u2014 returns questions WITHOUT answers. Use paradigm_university_submit to submit answers. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: 'Quiz ID (e.g., "Q-onboarding-basics")'
+          }
+        },
+        required: ["id"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_submit",
+      description: "Submit quiz answers for grading. Returns score and saves diploma if passed. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          quizId: {
+            type: "string",
+            description: "Quiz ID"
+          },
+          answers: {
+            type: "object",
+            description: 'Map of question ID to answer key (e.g., {"q1": "B", "q2": "A"})'
+          },
+          student: {
+            type: "string",
+            description: "Student name (auto-resolved if omitted)"
+          }
+        },
+        required: ["quizId", "answers"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_onboard",
+      description: "Get recommended onboarding sequence for the project university. Shows learning paths, suggested content, and completion status. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          student: {
+            type: "string",
+            description: "Student name to check completion (auto-resolved if omitted)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_diplomas",
+      description: "List earned diplomas (PLSAT, quiz completions, path completions). ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          student: {
+            type: "string",
+            description: "Filter by student name"
+          },
+          type: {
+            type: "string",
+            enum: ["plsat", "quiz", "path"],
+            description: "Filter by diploma type"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_university_validate",
+      description: "Validate university content integrity: schema, symbol refs, prerequisites, quiz structure. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Content ID to validate (validates all if omitted)"
+          },
+          deep: {
+            type: "boolean",
+            description: "Enable deep cross-reference checks against scan-index (default: false)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handleUniversityTool(name, args, ctx) {
+  if (name === "paradigm_university_search") {
+    const results = searchContent(ctx.rootDir, {
+      type: args.type,
+      tag: args.tag,
+      difficulty: args.difficulty,
+      symbol: args.symbol,
+      query: args.query,
+      limit: args.limit
+    });
+    const text = JSON.stringify({
+      count: results.length,
+      results: results.map((r) => ({
+        id: r.id,
+        title: r.title,
+        type: r.type,
+        difficulty: r.difficulty,
+        tags: r.tags,
+        symbols: r.symbols
+      }))
+    }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_get") {
+    const id = args.id;
+    if (!id) return { handled: true, text: JSON.stringify({ error: "id is required" }) };
+    const note = loadNote(ctx.rootDir, id);
+    if (note) {
+      const text2 = JSON.stringify({
+        id: note.frontmatter.id,
+        title: note.frontmatter.title,
+        type: note.frontmatter.type,
+        author: note.frontmatter.author,
+        created: note.frontmatter.created,
+        updated: note.frontmatter.updated,
+        tags: note.frontmatter.tags,
+        symbols: note.frontmatter.symbols,
+        difficulty: note.frontmatter.difficulty,
+        prerequisites: note.frontmatter.prerequisites,
+        body: note.body
+      }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const quiz = loadQuiz(ctx.rootDir, id);
+    if (quiz) {
+      const text2 = JSON.stringify(quiz, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const lp = loadPath(ctx.rootDir, id);
+    if (lp) {
+      const text2 = JSON.stringify(lp, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const text = JSON.stringify({ error: `Content "${id}" not found` });
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_create") {
+    const contentType = args.type;
+    const title = args.title;
+    if (!contentType || !title) {
+      return { handled: true, text: JSON.stringify({ error: "type and title are required" }) };
+    }
+    const author = resolveAuthor2();
+    const today = todayStr();
+    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+    if (contentType === "quiz") {
+      const id2 = `Q-${slug}`;
+      const quiz = {
+        id: id2,
+        title,
+        description: args.body || "",
+        author,
+        created: today,
+        updated: today,
+        tags: args.tags || [],
+        symbols: args.symbols || [],
+        difficulty: args.difficulty || "beginner",
+        estimatedMinutes: args.estimatedMinutes,
+        passThreshold: args.passThreshold ?? 0.7,
+        questions: args.questions || []
+      };
+      saveQuiz(ctx.rootDir, quiz);
+      rebuildUniversityIndex(ctx.rootDir);
+      const text2 = JSON.stringify({ created: id2, type: "quiz", file: `content/quizzes/${id2}.yaml` }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    if (contentType === "path") {
+      const id2 = `LP-${slug}`;
+      const lp = {
+        id: id2,
+        title,
+        description: args.body || "",
+        author,
+        created: today,
+        updated: today,
+        tags: args.tags || [],
+        ordered: args.ordered ?? true,
+        steps: args.steps || []
+      };
+      savePath(ctx.rootDir, lp);
+      rebuildUniversityIndex(ctx.rootDir);
+      const text2 = JSON.stringify({ created: id2, type: "path", file: `content/paths/${id2}.yaml` }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const prefix = contentType === "policy" ? "P" : "N";
+    const id = `${prefix}-${slug}`;
+    const frontmatter = {
+      id,
+      title,
+      type: contentType,
+      author,
+      created: today,
+      updated: today,
+      tags: args.tags || [],
+      symbols: args.symbols || [],
+      difficulty: args.difficulty || "beginner",
+      estimatedMinutes: args.estimatedMinutes,
+      prerequisites: args.prerequisites || []
+    };
+    saveNote(ctx.rootDir, frontmatter, args.body || "");
+    rebuildUniversityIndex(ctx.rootDir);
+    const subdir = contentType === "policy" ? "policies" : "notes";
+    const text = JSON.stringify({ created: id, type: contentType, file: `content/${subdir}/${id}.md` }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_update") {
+    const id = args.id;
+    if (!id) return { handled: true, text: JSON.stringify({ error: "id is required" }) };
+    const today = todayStr();
+    const note = loadNote(ctx.rootDir, id);
+    if (note) {
+      const fm = { ...note.frontmatter };
+      if (args.title) fm.title = args.title;
+      if (args.tags) fm.tags = args.tags;
+      if (args.symbols) fm.symbols = args.symbols;
+      if (args.difficulty) fm.difficulty = args.difficulty;
+      if (args.estimatedMinutes !== void 0) fm.estimatedMinutes = args.estimatedMinutes;
+      fm.updated = today;
+      const body = args.body ?? note.body;
+      saveNote(ctx.rootDir, fm, body);
+      rebuildUniversityIndex(ctx.rootDir);
+      const text2 = JSON.stringify({ updated: id, type: fm.type }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const quiz = loadQuiz(ctx.rootDir, id);
+    if (quiz) {
+      if (args.title) quiz.title = args.title;
+      if (args.tags) quiz.tags = args.tags;
+      if (args.symbols) quiz.symbols = args.symbols;
+      if (args.difficulty) quiz.difficulty = args.difficulty;
+      quiz.updated = today;
+      saveQuiz(ctx.rootDir, quiz);
+      rebuildUniversityIndex(ctx.rootDir);
+      const text2 = JSON.stringify({ updated: id, type: "quiz" }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const lp = loadPath(ctx.rootDir, id);
+    if (lp) {
+      if (args.title) lp.title = args.title;
+      if (args.tags) lp.tags = args.tags;
+      lp.updated = today;
+      savePath(ctx.rootDir, lp);
+      rebuildUniversityIndex(ctx.rootDir);
+      const text2 = JSON.stringify({ updated: id, type: "path" }, null, 2);
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const text = JSON.stringify({ error: `Content "${id}" not found` });
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_quiz") {
+    const id = args.id;
+    const quiz = loadQuiz(ctx.rootDir, id);
+    if (!quiz) {
+      const text2 = JSON.stringify({ error: `Quiz "${id}" not found` });
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    const sanitized = {
+      id: quiz.id,
+      title: quiz.title,
+      description: quiz.description,
+      difficulty: quiz.difficulty,
+      passThreshold: quiz.passThreshold,
+      questionCount: quiz.questions.length,
+      questions: quiz.questions.map((q) => ({
+        id: q.id,
+        question: q.question,
+        choices: q.choices
+      }))
+    };
+    const text = JSON.stringify(sanitized, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_submit") {
+    const quizId = args.quizId;
+    const answers = args.answers;
+    const student = args.student || resolveAuthor2();
+    const quiz = loadQuiz(ctx.rootDir, quizId);
+    if (!quiz) {
+      const text2 = JSON.stringify({ error: `Quiz "${quizId}" not found` });
+      trackToolCall(text2.length, name);
+      return { handled: true, text: text2 };
+    }
+    let correct = 0;
+    const total = quiz.questions.length;
+    const feedback = [];
+    for (const q of quiz.questions) {
+      const answer = answers[q.id];
+      const isCorrect = answer === q.correct;
+      if (isCorrect) correct++;
+      feedback.push({
+        id: q.id,
+        correct: isCorrect,
+        ...isCorrect ? {} : { expected: q.correct },
+        ...q.explanation ? { explanation: q.explanation } : {}
+      });
+    }
+    const percentage = total > 0 ? Math.round(correct / total * 1e4) / 100 : 0;
+    const passed = percentage / 100 >= quiz.passThreshold;
+    const diplomaId = `D-${todayStr()}-${student}-${quizId.replace(/^Q-/, "")}`;
+    const diploma = {
+      id: diplomaId,
+      type: "quiz",
+      student,
+      earnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: quizId,
+      score: correct,
+      total,
+      percentage,
+      passed
+    };
+    saveDiploma(ctx.rootDir, diploma);
+    const text = JSON.stringify({
+      quizId,
+      student,
+      score: correct,
+      total,
+      percentage,
+      passThreshold: quiz.passThreshold * 100,
+      passed,
+      diplomaId,
+      feedback
+    }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_onboard") {
+    const student = args.student || resolveAuthor2();
+    const config = loadUniversityConfig(ctx.rootDir);
+    const sequence = getOnboardingSequence(ctx.rootDir, student);
+    const text = JSON.stringify({
+      university: config.branding.name,
+      student,
+      ...sequence
+    }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_diplomas") {
+    const diplomas = loadDiplomas(ctx.rootDir, {
+      student: args.student,
+      type: args.type
+    });
+    const text = JSON.stringify({
+      count: diplomas.length,
+      diplomas: diplomas.map((d) => ({
+        id: d.id,
+        type: d.type,
+        student: d.student,
+        source: d.source,
+        score: d.score,
+        total: d.total,
+        percentage: d.percentage,
+        passed: d.passed,
+        earnedAt: d.earnedAt
+      }))
+    }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  if (name === "paradigm_university_validate") {
+    const result = validateUniversityContent(ctx.rootDir, {
+      id: args.id,
+      deep: args.deep
+    });
+    const text = JSON.stringify(result, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+  return { handled: false, text: "" };
+}
+
+// ../paradigm-mcp/src/utils/platform-bridge.ts
+import * as fs27 from "fs";
+import * as path29 from "path";
+import * as yaml15 from "js-yaml";
+function resolvePlatformPort(projectDir2) {
+  try {
+    const configPath = path29.join(projectDir2, ".paradigm", "config.yaml");
+    if (fs27.existsSync(configPath)) {
+      const config = yaml15.load(fs27.readFileSync(configPath, "utf-8"));
+      const platform2 = config.platform;
+      if (platform2?.port && typeof platform2.port === "number") {
+        return platform2.port;
+      }
+    }
+  } catch {
+  }
+  return 3850;
+}
+function resolveAgentId(projectDir2) {
+  try {
+    const configPath = path29.join(projectDir2, ".paradigm", "config.yaml");
+    if (fs27.existsSync(configPath)) {
+      const config = yaml15.load(fs27.readFileSync(configPath, "utf-8"));
+      const project = config.project || path29.basename(projectDir2);
+      const role = config.role || "core";
+      return `${project}/${role}`;
+    }
+  } catch {
+  }
+  return `${path29.basename(projectDir2)}/core`;
+}
+async function sendAgentCommand(projectDir2, command, payload) {
+  const port = resolvePlatformPort(projectDir2);
+  const agentId = resolveAgentId(projectDir2);
+  const url = `http://localhost:${port}/api/platform/agent-command`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ command, agentId, payload }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      return { ok: false, error: `HTTP ${response.status}: ${text}` };
+    }
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    return { ok: false, error: `Platform server unreachable (${msg}). Is \`paradigm serve\` running?` };
+  }
+}
+
+// ../paradigm-mcp/src/tools/platform.ts
+function getPlatformToolsList() {
+  return [
+    {
+      name: "paradigm_platform_navigate",
+      description: "Navigate the Platform UI to a section, select a symbol, or open a lore entry. The browser updates in real-time. If the user is actively interacting, shows a prompt instead of auto-navigating. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          section: {
+            type: "string",
+            enum: ["overview", "lore", "graph", "sentinel", "university", "symphony"],
+            description: "Section to navigate to"
+          },
+          symbol: {
+            type: "string",
+            description: 'Symbol to select (e.g., "#payment-service")'
+          },
+          loreId: {
+            type: "string",
+            description: "Lore entry ID to open in lore section"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_platform_highlight",
+      description: "Temporarily highlight symbols in the Platform UI with a pulsing glow. Auto-expires after duration. Use to draw attention to specific components during explanations. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbols: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Symbol IDs to highlight (e.g., ["#payment-service", "#api-gateway"])'
+          },
+          color: {
+            type: "string",
+            description: "Highlight color (CSS color, defaults to agent color)"
+          },
+          duration: {
+            type: "number",
+            description: "Duration in milliseconds (default: 5000)"
+          },
+          pulse: {
+            type: "boolean",
+            description: "Whether to pulse the highlight (default: true)"
+          },
+          label: {
+            type: "string",
+            description: "Optional label shown near highlighted symbols"
+          }
+        },
+        required: ["symbols"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_platform_annotate",
+      description: "Show a toast notification, callout on a graph node, or badge in the Platform UI. Use for communicating decisions, warnings, or context to the user visually. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["toast", "callout", "badge"],
+            description: "Annotation type: toast (notification), callout (floating note on graph node), badge (icon on symbol)"
+          },
+          message: {
+            type: "string",
+            description: "Annotation message text"
+          },
+          symbol: {
+            type: "string",
+            description: "Symbol to attach callout/badge to (required for callout/badge)"
+          },
+          severity: {
+            type: "string",
+            enum: ["info", "warning", "error", "success"],
+            description: "Visual severity (default: info)"
+          },
+          duration: {
+            type: "number",
+            description: "Auto-dismiss duration in milliseconds (default: 6000, 0 = persistent)"
+          }
+        },
+        required: ["type", "message"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_platform_observe",
+      description: "Read the current Platform UI state: what section the user is viewing, what symbol is selected, theme, connected agents, and active highlights/annotations. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          detail: {
+            type: "string",
+            enum: ["summary", "full"],
+            description: "Level of detail (default: summary)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_platform_clear",
+      description: "Remove agent highlights, annotations, or all agent effects from the Platform UI. ~50 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          target: {
+            type: "string",
+            enum: ["highlights", "annotations", "all"],
+            description: "What to clear (default: all)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    }
+  ];
+}
+async function handlePlatformTool(name, args, ctx) {
+  switch (name) {
+    case "paradigm_platform_navigate": {
+      const result = await sendAgentCommand(ctx.projectDir, "navigate", {
+        section: args.section,
+        symbol: args.symbol,
+        loreId: args.loreId
+      });
+      if (!result.ok) {
+        return { handled: true, text: `**Navigate failed:** ${result.error}` };
+      }
+      const d = result.data;
+      if (d.navigated) {
+        const parts = [];
+        if (d.section) parts.push(`section: **${d.section}**`);
+        if (d.symbol) parts.push(`symbol: **${d.symbol}**`);
+        const activeNote = d.userActive ? " (user was active \u2014 shown as prompt)" : "";
+        return { handled: true, text: `Navigated to ${parts.join(", ")}${activeNote}` };
+      }
+      return { handled: true, text: `Navigation skipped: ${d.reason}` };
+    }
+    case "paradigm_platform_highlight": {
+      const result = await sendAgentCommand(ctx.projectDir, "highlight", {
+        symbols: args.symbols,
+        color: args.color,
+        duration: args.duration,
+        pulse: args.pulse,
+        label: args.label
+      });
+      if (!result.ok) {
+        return { handled: true, text: `**Highlight failed:** ${result.error}` };
+      }
+      const d = result.data;
+      if (d.highlighted) {
+        return { handled: true, text: `Highlighted **${d.count}** symbol(s)${args.label ? ` with label "${args.label}"` : ""}` };
+      }
+      return { handled: true, text: `Highlight skipped: ${d.reason}` };
+    }
+    case "paradigm_platform_annotate": {
+      const result = await sendAgentCommand(ctx.projectDir, "annotate", {
+        type: args.type,
+        message: args.message,
+        symbol: args.symbol,
+        severity: args.severity,
+        duration: args.duration
+      });
+      if (!result.ok) {
+        return { handled: true, text: `**Annotate failed:** ${result.error}` };
+      }
+      const d = result.data;
+      if (d.annotated) {
+        return { handled: true, text: `Created ${args.type} annotation: "${args.message}"` };
+      }
+      return { handled: true, text: `Annotation skipped: ${d.reason}` };
+    }
+    case "paradigm_platform_observe": {
+      const result = await sendAgentCommand(ctx.projectDir, "observe", {
+        detail: args.detail
+      });
+      if (!result.ok) {
+        return { handled: true, text: `**Observe failed:** ${result.error}` };
+      }
+      const d = result.data;
+      const state = d.state;
+      const lines = ["## Platform UI State\n"];
+      lines.push(`- **Connected:** ${d.connected ? "Yes" : "No"} (${d.users} browser client(s))`);
+      lines.push(`- **Section:** ${state.section}`);
+      lines.push(`- **Selected symbol:** ${state.selectedSymbol || "none"}`);
+      lines.push(`- **Theme:** ${state.theme}`);
+      lines.push(`- **Muted:** ${state.muted ? "Yes \u2014 agent actions silently discarded" : "No"}`);
+      const agents = d.agents;
+      if (agents?.length) {
+        lines.push(`
+### Connected Agents (${agents.length})`);
+        for (const a of agents) {
+          lines.push(`- \`${a.agentId}\` (since ${a.connectedAt})`);
+        }
+      }
+      if (args.detail === "full") {
+        const highlights = d.highlights;
+        const annotations = d.annotations;
+        if (highlights?.length) {
+          lines.push(`
+### Active Highlights: ${highlights.length}`);
+        }
+        if (annotations?.length) {
+          lines.push(`
+### Active Annotations: ${annotations.length}`);
+        }
+      }
+      return { handled: true, text: lines.join("\n") };
+    }
+    case "paradigm_platform_clear": {
+      const result = await sendAgentCommand(ctx.projectDir, "clear", {
+        target: args.target
+      });
+      if (!result.ok) {
+        return { handled: true, text: `**Clear failed:** ${result.error}` };
+      }
+      const d = result.data;
+      return { handled: true, text: `Cleared ${d.target} agent effects` };
+    }
+    default:
+      return { handled: false, text: "" };
+  }
+}
+
+// ../paradigm-mcp/src/tools/fallback-grep.ts
+import * as path30 from "path";
+import { execSync as execSync8 } from "child_process";
+function grepForReferences(rootDir, symbol, options = {}) {
+  const { maxResults = 20 } = options;
+  const results = [];
+  const escapedSymbol = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const grepCommands = [
+    // ripgrep - exclude common directories
+    `rg -n --no-heading "${escapedSymbol}" "${rootDir}" --glob "!node_modules" --glob "!.git" --glob "!dist" --glob "!build" --glob "!coverage" --max-count 50 2>/dev/null`,
+    // fallback to grep
+    `grep -rn "${escapedSymbol}" "${rootDir}" --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist --exclude-dir=build --exclude-dir=coverage 2>/dev/null | head -50`
+  ];
+  let output = "";
+  for (const cmd of grepCommands) {
+    try {
+      output = execSync8(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
+      if (output.trim()) break;
+    } catch {
+      continue;
+    }
+  }
+  if (!output.trim()) {
+    return results;
+  }
+  const lines = output.trim().split("\n");
+  for (const line of lines.slice(0, maxResults)) {
+    const match = line.match(/^(.+?):(\d+):(.*)$/);
+    if (match) {
+      const [, filePath, lineNum, content] = match;
+      const relativePath = path30.relative(rootDir, filePath);
+      let context2 = "unknown";
+      if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
+        context2 = "purpose";
+      } else if (content.includes("//") || content.includes("#") || content.includes("*")) {
+        context2 = "comment";
+      } else {
+        context2 = "code";
+      }
+      results.push({
+        filePath: relativePath,
+        line: parseInt(lineNum, 10),
+        content: content.trim().slice(0, 200),
+        context: context2
+      });
+    }
+  }
+  return results;
+}
+
+// ../paradigm-mcp/src/tools/fuzzy-match.ts
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findFuzzyMatches(query, candidates, options = {}) {
+  const { maxDistance = 3, maxResults = 5 } = options;
+  const queryLower = query.toLowerCase();
+  const matches = [];
+  for (const candidate of candidates) {
+    const candidateLower = candidate.toLowerCase();
+    if (candidateLower === queryLower) {
+      matches.push({ match: candidate, distance: 0 });
+      continue;
+    }
+    if (candidateLower.includes(queryLower) || queryLower.includes(candidateLower)) {
+      matches.push({ match: candidate, distance: 1 });
+      continue;
+    }
+    const distance = levenshteinDistance(queryLower, candidateLower);
+    if (distance <= maxDistance) {
+      matches.push({ match: candidate, distance });
+    }
+  }
+  matches.sort((a, b) => {
+    if (a.distance !== b.distance) return a.distance - b.distance;
+    return a.match.localeCompare(b.match);
+  });
+  return matches.slice(0, maxResults);
+}
+
 // ../paradigm-mcp/src/tools/index.ts
 function calculateRouteSimilarity(route1, route2) {
   const normalize = (r) => r.toLowerCase().replace(/\/+$/, "");
@@ -14349,6 +16775,12 @@ function registerTools(server, getContext2, reloadContext2) {
           ...getPipelineToolsList(),
           // Conductor session registration tools
           ...getConductorToolsList(),
+          // Symphony (The Score) tools
+          ...getSymphonyToolsList(),
+          // University (per-project knowledge base) tools
+          ...getUniversityToolsList(),
+          // Platform agent-driven UI tools
+          ...getPlatformToolsList(),
           // Plugin update check
           {
             name: "paradigm_plugin_check",
@@ -14624,6 +17056,18 @@ function registerTools(server, getContext2, reloadContext2) {
               }
             } catch {
             }
+            try {
+              const universityAffected = getAffectedUniversityContent(ctx.rootDir, symbol);
+              if (universityAffected.length > 0) {
+                response.university_content_affected = universityAffected.map((c) => ({
+                  id: c.id,
+                  title: c.title,
+                  type: c.type,
+                  stale: c.stale
+                }));
+              }
+            } catch {
+            }
             if (includeWorkspace && ctx.workspace) {
               const wsRipple = rippleWorkspace(ctx.workspace, symbol);
               if (wsRipple.length > 0) {
@@ -14744,7 +17188,7 @@ function registerTools(server, getContext2, reloadContext2) {
                 const symbols = getSymbolsByType(ctx.index, type);
                 examples[type] = symbols.slice(0, 3).map((s) => s.symbol);
               }
-              const platform2 = os4.platform();
+              const platform2 = os6.platform();
               const isWindows = platform2 === "win32";
               const shell = isWindows ? "PowerShell/CMD" : platform2 === "darwin" ? "zsh/bash" : "bash";
               let protocols;
@@ -14763,6 +17207,13 @@ function registerTools(server, getContext2, reloadContext2) {
                 }
               }
               const untypedCount = allComponents.filter((c) => !c.componentType).length;
+              let purposeHealthScore;
+              try {
+                const { checkPurposeHealth } = await import("./integrity-checker-J7YXRTBT.js");
+                const healthReport = checkPurposeHealth(ctx.aggregation.purposeFiles, ctx.rootDir);
+                purposeHealthScore = healthReport.healthScore;
+              } catch {
+              }
               return JSON.stringify({
                 project: ctx.projectName,
                 symbolSystem: "v2",
@@ -14783,6 +17234,7 @@ function registerTools(server, getContext2, reloadContext2) {
                 examples,
                 hasPortalYaml: ctx.gateConfig !== null,
                 purposeFiles: ctx.aggregation.purposeFiles.length,
+                ...purposeHealthScore !== void 0 ? { purposeHealthScore } : {},
                 ...protocols ? { protocols } : {},
                 note: "Symbol System v2: Use tags [feature], [state], [integration], [idea] for classification. Use type field for structural role (view, service, tool, etc.)",
                 environment: {
@@ -14998,10 +17450,10 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-YC7LD4MN.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-WIJMCJ4A.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
-              const memberAbsPath = path29.resolve(path29.dirname(ctx.workspace.workspacePath), member.path);
+              const memberAbsPath = path31.resolve(path31.dirname(ctx.workspace.workspacePath), member.path);
               try {
                 const result = await rebuildStaticFiles2(memberAbsPath);
                 memberResults.push({
@@ -15225,6 +17677,33 @@ Update command:
                 };
               }
             }
+            if (name.startsWith("paradigm_symphony_")) {
+              const result = await handleSymphonyTool(name, args, ctx);
+              if (result.handled) {
+                trackToolCall(result.text.length, name);
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
+            if (name.startsWith("paradigm_university_")) {
+              const result = await handleUniversityTool(name, args, ctx);
+              if (result.handled) {
+                trackToolCall(result.text.length, name);
+                return {
+                  content: [{ type: "text", text: result.text }]
+                };
+              }
+            }
+            if (name.startsWith("paradigm_platform_")) {
+              const result = await handlePlatformTool(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 () => {
               });