@a-company/paradigm 3.17.2 → 3.19.0

package/dist/mcp.js

@@ -7,16 +7,6 @@ import {
   shelveTask,
   updateTask
 } from "./chunk-CSD7IHSN.js";
-import {
-  closeArc,
-  createArc,
-  loadArc,
-  loadArcs,
-  loadEntries,
-  loadEntry,
-  recordEntry,
-  searchEntries
-} from "./chunk-DSXS42FY.js";
 import {
   PatternMatcher,
   PatternSuggester,
@@ -24,7 +14,7 @@ import {
   StatsCalculator,
   TimelineBuilder,
   loadAllSeedPatterns
-} from "./chunk-ZRPEI35Q.js";
+} from "./chunk-BKMNLROM.js";
 import {
   addStep,
   addToolBreadcrumb,
@@ -34,7 +24,6 @@ import {
   checkDrift,
   closeAspectGraph,
   createPersona,
-  deleteLoreEntry,
   deletePersona,
   detectProtocolSuggestion,
   findPurposeFiles,
@@ -62,9 +51,6 @@ import {
   loadGlobalAntipatterns,
   loadGlobalDecisions,
   loadGlobalPreferences,
-  loadLoreEntries,
-  loadLoreEntry,
-  loadLoreTimeline,
   loadPersona,
   loadPersonas,
   loadProtocol,
@@ -76,7 +62,6 @@ import {
   rebuildStaticFiles,
   recordGlobalAntipattern,
   recordGlobalDecision,
-  recordLoreEntry,
   recordProtocol,
   removeStep,
   searchProtocols,
@@ -85,14 +70,21 @@ import {
   toolCache,
   trackResourceRead,
   trackToolCall,
-  updateLoreEntry,
   updatePersona,
   updateProtocol,
   validateAgainstSentinel,
   validatePersona,
   validateProtocol,
   validatePurposeFile
-} from "./chunk-D4VBBKGV.js";
+} from "./chunk-EZ6XW6FB.js";
+import {
+  deleteLoreEntry,
+  loadLoreEntries,
+  loadLoreEntry,
+  loadLoreTimeline,
+  recordLoreEntry,
+  updateLoreEntry
+} from "./chunk-3DYYXGDC.js";
 import {
   getPluginUpdateNotice,
   schedulePluginUpdateCheck
@@ -2033,8 +2025,8 @@ function registerResources(server, getContext2) {
 }
 
 // ../paradigm-mcp/src/tools/index.ts
-import * as os from "os";
-import * as path24 from "path";
+import * as os3 from "os";
+import * as path25 from "path";
 import {
   ListToolsRequestSchema,
   CallToolRequestSchema
@@ -2798,7 +2790,7 @@ function navigateExplore(config, target, rootDir) {
   }
   if (result.paths.length === 0) {
     const areaSymbols = Object.entries(config.symbols).filter(
-      ([sym, path25]) => sym.toLowerCase().includes(targetLower) || path25.toLowerCase().includes(targetLower)
+      ([sym, path26]) => sym.toLowerCase().includes(targetLower) || path26.toLowerCase().includes(targetLower)
     ).slice(0, 10);
     result.paths = [...new Set(areaSymbols.map(([, p]) => p))];
     result.symbols = areaSymbols.map(([s]) => s);
@@ -8215,6 +8207,26 @@ function runPostflightCheck(filesModified, symbolsTouched, ctx) {
 }
 
 // ../paradigm-mcp/src/tools/lore.ts
+import { execSync as execSync2 } from "child_process";
+import * as os from "os";
+function resolveAuthorForMcp() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitize(envAuthor);
+  try {
+    const gitName = execSync2("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitize(gitName);
+  } catch {
+  }
+  try {
+    const username = os.userInfo().username;
+    if (username) return sanitize(username);
+  } catch {
+  }
+  return "unknown";
+}
+function sanitize(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
 function getLoreToolsList() {
   return [
     {
@@ -8229,18 +8241,30 @@ function getLoreToolsList() {
           },
           author: {
             type: "string",
-            description: 'Filter by author ID (e.g., "ascend", "claude-opus-4")'
+            description: 'Filter by author (human user name, e.g., "ascend")'
+          },
+          hasAgent: {
+            type: "boolean",
+            description: "Filter by AI assistance: true = AI-assisted entries, false = human-only"
           },
           authorType: {
             type: "string",
             enum: ["human", "agent"],
-            description: "Filter by author type"
+            description: "(Deprecated, use hasAgent) Filter by old author type"
           },
           type: {
             type: "string",
-            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone", "retro", "insight"],
             description: "Filter by entry type"
           },
+          tag: {
+            type: "string",
+            description: 'Filter by tag prefix (e.g., "arc:lore-evolution" for arc entries)'
+          },
+          hasBody: {
+            type: "boolean",
+            description: "Filter for entries with/without long-form body content"
+          },
           dateFrom: {
             type: "string",
             description: 'Filter from date (ISO 8601, e.g., "2026-02-20")'
@@ -8281,7 +8305,7 @@ function getLoreToolsList() {
         properties: {
           type: {
             type: "string",
-            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone", "retro", "insight"],
             description: "Entry type"
           },
           title: {
@@ -8363,9 +8387,32 @@ function getLoreToolsList() {
             type: "array",
             items: { type: "string" },
             description: "Tags for categorization"
+          },
+          meta: {
+            type: "object",
+            description: 'Project-defined metadata (open-ended key-value pairs, e.g., { meeting_type: "design-review", sprint: 12 })'
+          },
+          body: {
+            type: "string",
+            description: "Long-form content (detailed retrospective notes, decision rationale, etc.)"
+          },
+          linked_lore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Cross-references to other lore entry IDs"
+          },
+          linked_tasks: {
+            type: "array",
+            items: { type: "string" },
+            description: "References to paradigm task IDs"
+          },
+          linked_commits: {
+            type: "array",
+            items: { type: "string" },
+            description: "Git commit SHAs related to this entry"
           }
         },
-        required: ["type", "title", "summary", "symbols_touched"]
+        required: ["title", "summary", "symbols_touched"]
       },
       annotations: {
         readOnlyHint: false,
@@ -8397,7 +8444,7 @@ function getLoreToolsList() {
         properties: {
           id: {
             type: "string",
-            description: 'Lore entry ID (e.g., "L-2026-02-23-001")'
+            description: 'Lore entry ID (e.g., "L-2026-02-23-001" or "L-2026-03-02-ascend-143025-001")'
           }
         },
         required: ["id"]
@@ -8421,7 +8468,7 @@ function getLoreToolsList() {
           summary: { type: "string", description: "New summary" },
           type: {
             type: "string",
-            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone"],
+            enum: ["agent-session", "human-note", "decision", "review", "incident", "milestone", "retro", "insight"],
             description: "New entry type"
           },
           symbols_touched: {
@@ -8499,11 +8546,14 @@ async function handleLoreTool(name, args, ctx) {
     case "paradigm_lore_search": {
       const filter = {
         author: args.author,
+        hasAgent: args.hasAgent,
         authorType: args.authorType,
         symbol: args.symbol,
         dateFrom: args.dateFrom,
         dateTo: args.dateTo,
         type: args.type,
+        tag: args.tag,
+        hasBody: args.hasBody,
         tags: args.tags,
         hasReview: args.hasReview,
         limit: args.limit || 20,
@@ -8538,7 +8588,12 @@ async function handleLoreTool(name, args, ctx) {
         errors_encountered,
         learnings,
         verification,
-        tags
+        tags,
+        meta,
+        body,
+        linked_lore,
+        linked_tasks,
+        linked_commits
       } = args;
       let habit_compliance;
       try {
@@ -8560,10 +8615,11 @@ async function handleLoreTool(name, args, ctx) {
       const entry = {
         id: "",
         // Will be generated
-        type,
+        type: type || "agent-session",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         duration_minutes,
-        author: { type: "agent", id: "claude", model: "claude-opus-4-6" },
+        author: resolveAuthorForMcp(),
+        agent: { provider: "anthropic", model: "claude-opus-4-6" },
         title,
         summary,
         symbols_touched,
@@ -8578,7 +8634,12 @@ async function handleLoreTool(name, args, ctx) {
         learnings,
         verification,
         tags,
-        habit_compliance
+        meta: meta || void 0,
+        habit_compliance,
+        body,
+        linked_lore,
+        linked_tasks,
+        linked_commits
       };
       const id = await recordLoreEntry(ctx.rootDir, entry);
       getSessionTracker().setLastLoreEntryId(id);
@@ -8618,11 +8679,12 @@ async function handleLoreTool(name, args, ctx) {
       const hotSymbols = Object.entries(symbolCounts).sort(([, a], [, b]) => b - a).slice(0, 10).map(([symbol, count]) => ({ symbol, count }));
       const authorActivity = {};
       for (const entry of entries) {
-        const aid = entry.author.id;
+        const aid = entry.author;
         if (!authorActivity[aid]) {
-          authorActivity[aid] = { count: 0, lastActive: entry.timestamp, type: entry.author.type };
+          authorActivity[aid] = { count: 0, lastActive: entry.timestamp, hasAgent: entry.agent != null };
         }
         authorActivity[aid].count++;
+        if (entry.agent) authorActivity[aid].hasAgent = true;
         if (entry.timestamp > authorActivity[aid].lastActive) {
           authorActivity[aid].lastActive = entry.timestamp;
         }
@@ -8635,7 +8697,7 @@ async function handleLoreTool(name, args, ctx) {
           hotSymbols,
           authors: Object.entries(authorActivity).map(([id, info]) => ({
             id,
-            type: info.type,
+            hasAgent: info.hasAgent,
             entries: info.count,
             lastActive: info.lastActive
           }))
@@ -8708,6 +8770,7 @@ function summarizeEntry(entry) {
     title: entry.title,
     summary: entry.summary,
     author: entry.author,
+    agent: entry.agent,
     timestamp: entry.timestamp,
     duration_minutes: entry.duration_minutes,
     symbols_touched: entry.symbols_touched,
@@ -8723,7 +8786,7 @@ function summarizeEntry(entry) {
 // ../paradigm-mcp/src/tools/habits.ts
 import * as fs19 from "fs";
 import * as path21 from "path";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getHabitsToolsList() {
   return [
     {
@@ -8927,7 +8990,7 @@ async function handleHabitsCheck(args, ctx) {
   ].some((k) => taskLower.includes(k));
   let gitClean;
   try {
-    const status = execSync2("git status --porcelain", {
+    const status = execSync3("git status --porcelain", {
       cwd: ctx.rootDir,
       encoding: "utf8",
       timeout: 5e3
@@ -10191,8 +10254,8 @@ function getTasksToolsList() {
           priority: { type: "string", enum: ["high", "medium", "low"] },
           status: { type: "string", enum: ["open", "done", "shelved"] },
           tags: { type: "array", items: { type: "string" }, description: "Replace tags" },
-          related_lore: { type: "array", items: { type: "string" } },
-          related_assessments: { type: "array", items: { type: "string" } }
+          related_lore: { type: "array", items: { type: "string" }, description: "Related lore entry IDs (includes former assessment entries)" },
+          related_assessments: { type: "array", items: { type: "string" }, description: "(Deprecated \u2014 use related_lore) Alias for related_lore" }
         },
         required: ["id"]
       },
@@ -10282,7 +10345,7 @@ async function handleTasksTool(name, args, ctx) {
         text: JSON.stringify({
           completed: id,
           task,
-          hint: "Consider updating related assessment arcs if this was a significant milestone."
+          hint: "Consider recording a lore entry with arc:* tags if this was a significant milestone."
         }, null, 2)
       };
     }
@@ -10300,18 +10363,228 @@ async function handleTasksTool(name, args, ctx) {
   }
 }
 
+// ../paradigm-mcp/src/utils/assessment-loader.ts
+import * as fs21 from "fs";
+import * as path23 from "path";
+import * as yaml12 from "js-yaml";
+var ASSESSMENTS_DIR = ".paradigm/assessments";
+var ARCS_DIR = "arcs";
+var INDEX_FILE = "index.yaml";
+function computeArcStats(rootDir, arc) {
+  const entriesPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arc.id, "entries");
+  const symbolSet = /* @__PURE__ */ new Set();
+  let entryCount = 0;
+  let latestDate;
+  if (fs21.existsSync(entriesPath)) {
+    const files = fs21.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const entry = yaml12.load(fs21.readFileSync(path23.join(entriesPath, file), "utf8"));
+        entryCount++;
+        if (entry.symbols) entry.symbols.forEach((s) => symbolSet.add(s));
+        if (!latestDate || entry.date > latestDate) latestDate = entry.date;
+      } catch {
+      }
+    }
+  }
+  return { ...arc, entry_count: entryCount, symbols: Array.from(symbolSet), latest_entry: latestDate };
+}
+async function loadArcs(rootDir, status) {
+  const arcsPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs21.existsSync(arcsPath)) return [];
+  const arcDirs = fs21.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs21.statSync(path23.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const arcs = [];
+  for (const arcDir of arcDirs) {
+    const arcFile = path23.join(arcsPath, arcDir, "arc.yaml");
+    if (!fs21.existsSync(arcFile)) continue;
+    try {
+      const arc = yaml12.load(fs21.readFileSync(arcFile, "utf8"));
+      if (status && status !== "all" && arc.status !== status) continue;
+      arcs.push(computeArcStats(rootDir, arc));
+    } catch {
+    }
+  }
+  arcs.sort((a, b) => {
+    const aDate = a.latest_entry || a.created;
+    const bDate = b.latest_entry || b.created;
+    return bDate.localeCompare(aDate);
+  });
+  return arcs;
+}
+async function loadArc(rootDir, arcId) {
+  const arcFile = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
+  if (!fs21.existsSync(arcFile)) return null;
+  try {
+    const arc = yaml12.load(fs21.readFileSync(arcFile, "utf8"));
+    return computeArcStats(rootDir, arc);
+  } catch {
+    return null;
+  }
+}
+async function closeArc(rootDir, arcId, status) {
+  const arcFile = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
+  if (!fs21.existsSync(arcFile)) return false;
+  try {
+    const arc = yaml12.load(fs21.readFileSync(arcFile, "utf8"));
+    arc.status = status;
+    fs21.writeFileSync(arcFile, yaml12.dump(arc, { lineWidth: -1, noRefs: true }));
+    await rebuildAssessmentIndex(rootDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadEntries(rootDir, arcId) {
+  const entriesPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "entries");
+  if (!fs21.existsSync(entriesPath)) return [];
+  const entries = [];
+  const files = fs21.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).sort();
+  for (const file of files) {
+    try {
+      const entry = yaml12.load(fs21.readFileSync(path23.join(entriesPath, file), "utf8"));
+      entries.push(entry);
+    } catch {
+    }
+  }
+  entries.sort((a, b) => b.date.localeCompare(a.date));
+  return entries;
+}
+async function loadEntry(rootDir, entryId) {
+  const arcsPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs21.existsSync(arcsPath)) return null;
+  const arcDirs = fs21.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs21.statSync(path23.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  for (const arcDir of arcDirs) {
+    const entryFile = path23.join(arcsPath, arcDir, "entries", `${entryId}.yaml`);
+    if (fs21.existsSync(entryFile)) {
+      try {
+        const entry = yaml12.load(fs21.readFileSync(entryFile, "utf8"));
+        const arcFile = path23.join(arcsPath, arcDir, "arc.yaml");
+        const arc = yaml12.load(fs21.readFileSync(arcFile, "utf8"));
+        return { entry, arc };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+async function searchEntries(rootDir, filter) {
+  const arcsPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  if (!fs21.existsSync(arcsPath)) return [];
+  const limit = filter.limit || 20;
+  const results = [];
+  const arcDirs = fs21.readdirSync(arcsPath).filter((d) => {
+    try {
+      return fs21.statSync(path23.join(arcsPath, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  for (const arcDir of arcDirs) {
+    const entriesPath = path23.join(arcsPath, arcDir, "entries");
+    if (!fs21.existsSync(entriesPath)) continue;
+    const files = fs21.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const entry = yaml12.load(fs21.readFileSync(path23.join(entriesPath, file), "utf8"));
+        if (filter.symbol && !(entry.symbols || []).includes(filter.symbol)) continue;
+        if (filter.tag && !(entry.tags || []).includes(filter.tag)) continue;
+        if (filter.type && entry.type !== filter.type) continue;
+        if (filter.dateFrom && entry.date < filter.dateFrom) continue;
+        if (filter.dateTo && entry.date > filter.dateTo) continue;
+        results.push(entry);
+      } catch {
+      }
+    }
+  }
+  results.sort((a, b) => b.date.localeCompare(a.date));
+  return results.slice(0, limit);
+}
+async function rebuildAssessmentIndex(rootDir) {
+  const arcsPath = path23.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
+  const assessmentsPath = path23.join(rootDir, ASSESSMENTS_DIR);
+  let totalArcs = 0, totalEntries = 0, activeArcs = 0;
+  const arcSummaries = [];
+  if (fs21.existsSync(arcsPath)) {
+    const arcDirs = fs21.readdirSync(arcsPath).filter((d) => {
+      try {
+        return fs21.statSync(path23.join(arcsPath, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const arcDir of arcDirs) {
+      const arcFile = path23.join(arcsPath, arcDir, "arc.yaml");
+      if (!fs21.existsSync(arcFile)) continue;
+      try {
+        const arc = yaml12.load(fs21.readFileSync(arcFile, "utf8"));
+        const entriesPath = path23.join(arcsPath, arcDir, "entries");
+        const entryCount = fs21.existsSync(entriesPath) ? fs21.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).length : 0;
+        totalArcs++;
+        totalEntries += entryCount;
+        if (arc.status === "active") activeArcs++;
+        arcSummaries.push({ id: arc.id, name: arc.name, status: arc.status, entries: entryCount });
+      } catch {
+      }
+    }
+  }
+  const index = {
+    version: "1.0",
+    total_arcs: totalArcs,
+    total_entries: totalEntries,
+    active_arcs: activeArcs,
+    last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+    arcs: arcSummaries
+  };
+  fs21.mkdirSync(assessmentsPath, { recursive: true });
+  fs21.writeFileSync(path23.join(assessmentsPath, INDEX_FILE), yaml12.dump(index, { lineWidth: -1, noRefs: true }));
+  return index;
+}
+
 // ../paradigm-mcp/src/tools/assessment.ts
+import { execSync as execSync4 } from "child_process";
+import * as os2 from "os";
+function resolveAuthor() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitize2(envAuthor);
+  try {
+    const gitName = execSync4("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitize2(gitName);
+  } catch {
+  }
+  try {
+    const username = os2.userInfo().username;
+    if (username) return sanitize2(username);
+  } catch {
+  }
+  return "unknown";
+}
+function sanitize2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
 function getAssessmentToolsList() {
   return [
     {
       name: "paradigm_assessment_record",
-      description: "Add a reflection entry to an assessment arc. Creates the arc if it does not exist (provide arc_name). Returns entry ID. ~150 tokens.",
+      description: "[DEPRECATED \u2014 use paradigm_lore_record with arc:* tags] Add a reflection entry. Forwards to lore with arc:{arc_id} and assessment:{type} tags. ~150 tokens.",
       inputSchema: {
         type: "object",
         properties: {
-          arc_id: { type: "string", description: 'Arc ID (e.g., "arc-telemetry"). Created automatically if new.' },
-          arc_name: { type: "string", description: "Human-readable arc name (required when creating a new arc)" },
-          arc_description: { type: "string", description: "Arc description (used when creating a new arc)" },
+          arc_id: { type: "string", description: "Arc ID (becomes arc:{id} tag on the lore entry)" },
+          arc_name: { type: "string", description: "Human-readable arc name (ignored \u2014 arcs are now just tags)" },
+          arc_description: { type: "string", description: "Arc description (ignored \u2014 arcs are now just tags)" },
           title: { type: "string", description: "Entry title" },
           summary: { type: "string", description: "Short summary (1-2 sentences)" },
           body: { type: "string", description: "Full reflection \u2014 what happened, what was learned, what changed" },
@@ -10319,7 +10592,7 @@ function getAssessmentToolsList() {
           tags: { type: "array", items: { type: "string" } },
           type: { type: "string", enum: ["retro", "insight", "decision", "milestone"], description: "Entry type (default: retro)" },
           linked_lore: { type: "array", items: { type: "string" }, description: "Lore entry IDs" },
-          linked_tasks: { type: "array", items: { type: "string" }, description: "Task IDs completed as part of this" },
+          linked_tasks: { type: "array", items: { type: "string" }, description: "Task IDs" },
           linked_commits: { type: "array", items: { type: "string" }, description: "Commit hashes" }
         },
         required: ["arc_id", "title", "summary"]
@@ -10328,7 +10601,7 @@ function getAssessmentToolsList() {
     },
     {
       name: "paradigm_assessment_list",
-      description: "List assessment arcs, or entries within a specific arc. Returns arc summaries or entry summaries. ~200 tokens.",
+      description: '[DEPRECATED \u2014 use paradigm_lore_search with tag:"arc:{id}"] List assessment arcs or entries within a specific arc. ~200 tokens.',
       inputSchema: {
         type: "object",
         properties: {
@@ -10341,7 +10614,7 @@ function getAssessmentToolsList() {
     },
     {
       name: "paradigm_assessment_get",
-      description: "Get a specific assessment entry or arc detail. Pass an entry ID (A-*) or arc ID (arc-*). Returns full entry or arc with entry list. ~200 tokens.",
+      description: "[DEPRECATED \u2014 use paradigm_lore_get] Get a specific assessment entry or arc detail. ~200 tokens.",
       inputSchema: {
         type: "object",
         properties: {
@@ -10353,7 +10626,7 @@ function getAssessmentToolsList() {
     },
     {
       name: "paradigm_assessment_search",
-      description: "Search across all assessment arcs by symbol, tag, date range, or type. Returns matching entries with arc context. ~200 tokens.",
+      description: "[DEPRECATED \u2014 use paradigm_lore_search with tag/type filters] Search across assessment entries by symbol, tag, type, or date. ~200 tokens.",
       inputSchema: {
         type: "object",
         properties: {
@@ -10369,13 +10642,13 @@ function getAssessmentToolsList() {
     },
     {
       name: "paradigm_assessment_arc_create",
-      description: "Explicitly create an assessment arc (without adding an entry). Returns arc ID. ~100 tokens.",
+      description: "[DEPRECATED \u2014 arcs are now tag prefixes] No-op. Arcs are just arc:* tags on lore entries. No explicit creation needed. ~100 tokens.",
       inputSchema: {
         type: "object",
         properties: {
-          id: { type: "string", description: 'Arc ID (e.g., "arc-telemetry"). Kebab-case, prefixed with "arc-".' },
-          name: { type: "string", description: "Human-readable arc name" },
-          description: { type: "string", description: "What this arc tracks" },
+          id: { type: "string", description: "Arc ID (no longer needed \u2014 just use arc:{id} tag on lore entries)" },
+          name: { type: "string", description: "Arc name (ignored)" },
+          description: { type: "string", description: "Arc description (ignored)" },
           tags: { type: "array", items: { type: "string" } }
         },
         required: ["id", "name"]
@@ -10384,7 +10657,7 @@ function getAssessmentToolsList() {
     },
     {
       name: "paradigm_assessment_arc_close",
-      description: "Mark an assessment arc as complete or archived. Returns confirmation. ~100 tokens.",
+      description: "[DEPRECATED \u2014 use paradigm_lore_search + paradigm_lore_update] Adds arc-closed tag to all entries in the arc. ~100 tokens.",
       inputSchema: {
         type: "object",
         properties: {
@@ -10400,27 +10673,38 @@ function getAssessmentToolsList() {
 async function handleAssessmentTool(name, args, ctx) {
   switch (name) {
     case "paradigm_assessment_record": {
+      const arcId = args.arc_id;
+      const entryType = args.type || "retro";
+      const userTags = args.tags || [];
+      const tags = [
+        `arc:${arcId}`,
+        `assessment:${entryType}`,
+        ...userTags
+      ];
+      const entry = {
+        id: "",
+        type: entryType,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        author: resolveAuthor(),
+        agent: { provider: "anthropic", model: "claude-opus-4-6" },
+        title: args.title,
+        summary: args.summary,
+        body: args.body,
+        symbols_touched: args.symbols || [],
+        tags,
+        linked_lore: args.linked_lore,
+        linked_tasks: args.linked_tasks,
+        linked_commits: args.linked_commits
+      };
       try {
-        const id = await recordEntry(
-          ctx.rootDir,
-          {
-            arc_id: args.arc_id,
-            title: args.title,
-            summary: args.summary,
-            body: args.body,
-            symbols: args.symbols,
-            tags: args.tags,
-            type: args.type,
-            linked_lore: args.linked_lore,
-            linked_tasks: args.linked_tasks,
-            linked_commits: args.linked_commits
-          },
-          args.arc_name,
-          args.arc_description
-        );
+        const id = await recordLoreEntry(ctx.rootDir, entry);
         return {
           handled: true,
-          text: JSON.stringify({ recorded: id, arc_id: args.arc_id }, null, 2)
+          text: JSON.stringify({
+            recorded: id,
+            arc_id: arcId,
+            deprecated: 'Use paradigm_lore_record with tags: ["arc:' + arcId + '"] instead'
+          }, null, 2)
         };
       } catch (err2) {
         return {
@@ -10432,88 +10716,160 @@ async function handleAssessmentTool(name, args, ctx) {
     case "paradigm_assessment_list": {
       const arcId = args.arc_id;
       if (arcId) {
-        const entries = await loadEntries(ctx.rootDir, arcId);
-        const limited2 = entries.slice(0, args.limit || 20);
-        const arc = await loadArc(ctx.rootDir, arcId);
-        const arcName = arc ? arc.name : arcId;
-        const lines2 = [`${limited2.length} entries in "${arcName}" (${arcId}):`];
-        for (const e of limited2) {
-          lines2.push(`  [${e.type}] ${e.id}: ${e.title} (${e.date.slice(0, 10)})`);
-        }
-        return { handled: true, text: lines2.join("\n") };
-      }
-      const status = args.status || "active";
-      const arcs = await loadArcs(ctx.rootDir, status);
-      const limited = arcs.slice(0, args.limit || 20);
-      const lines = [`${limited.length} ${status} arc(s):`];
-      for (const a of limited) {
-        const symbols = a.symbols.length > 0 ? ` [${a.symbols.slice(0, 3).join(", ")}]` : "";
-        lines.push(`  ${a.id}: ${a.name} (${a.entry_count} entries)${symbols}`);
+        const entries = await loadLoreEntries(ctx.rootDir, {
+          tag: `arc:${arcId}`,
+          limit: args.limit || 20
+        });
+        const lines = [`${entries.length} entries with arc:${arcId} tag:`];
+        for (const e of entries) {
+          lines.push(`  [${e.type || "unknown"}] ${e.id}: ${e.title} (${e.timestamp.slice(0, 10)})`);
+        }
+        lines.push("", 'Deprecated: Use paradigm_lore_search with tag: "arc:' + arcId + '"');
+        return { handled: true, text: lines.join("\n") };
+      }
+      try {
+        const status = args.status || "active";
+        const arcs = await loadArcs(ctx.rootDir, status);
+        const limited = arcs.slice(0, args.limit || 20);
+        const lines = [`${limited.length} ${status} arc(s):`];
+        for (const a of limited) {
+          const symbols = a.symbols.length > 0 ? ` [${a.symbols.slice(0, 3).join(", ")}]` : "";
+          lines.push(`  ${a.id}: ${a.name} (${a.entry_count} entries)${symbols}`);
+        }
+        lines.push("", 'Deprecated: Run "paradigm lore migrate-assessments" then use paradigm_lore_search');
+        return { handled: true, text: lines.join("\n") };
+      } catch {
+        return { handled: true, text: "No assessment arcs found. Assessments are now unified with lore." };
       }
-      return { handled: true, text: lines.join("\n") };
     }
     case "paradigm_assessment_get": {
       const id = args.id;
+      if (id.startsWith("L-")) {
+        const entry = await loadLoreEntry(ctx.rootDir, id);
+        if (entry) {
+          return {
+            handled: true,
+            text: JSON.stringify({
+              entry,
+              deprecated: "Use paradigm_lore_get instead"
+            }, null, 2)
+          };
+        }
+      }
       if (id.startsWith("arc-")) {
-        const arc = await loadArc(ctx.rootDir, id);
-        if (!arc) {
+        try {
+          const arc = await loadArc(ctx.rootDir, id);
+          if (!arc) {
+            return { handled: true, text: JSON.stringify({ error: `Arc ${id} not found` }) };
+          }
+          const entries = await loadEntries(ctx.rootDir, id);
+          return {
+            handled: true,
+            text: JSON.stringify({
+              arc,
+              entries: entries.map((e) => ({ id: e.id, type: e.type, title: e.title, date: e.date.slice(0, 10), summary: e.summary })),
+              deprecated: 'Run "paradigm lore migrate-assessments" then use paradigm_lore_search with tag: "arc:' + id + '"'
+            }, null, 2)
+          };
+        } catch {
           return { handled: true, text: JSON.stringify({ error: `Arc ${id} not found` }) };
         }
-        const entries = await loadEntries(ctx.rootDir, id);
+      }
+      try {
+        const result = await loadEntry(ctx.rootDir, id);
+        if (!result) {
+          return { handled: true, text: JSON.stringify({ error: `Entry ${id} not found` }) };
+        }
         return {
           handled: true,
           text: JSON.stringify({
-            arc,
-            entries: entries.map((e) => ({ id: e.id, type: e.type, title: e.title, date: e.date.slice(0, 10), summary: e.summary }))
+            entry: result.entry,
+            arc: { id: result.arc.id, name: result.arc.name, status: result.arc.status },
+            deprecated: 'Run "paradigm lore migrate-assessments" then use paradigm_lore_get'
           }, null, 2)
         };
-      }
-      const result = await loadEntry(ctx.rootDir, id);
-      if (!result) {
+      } catch {
         return { handled: true, text: JSON.stringify({ error: `Entry ${id} not found` }) };
       }
-      return {
-        handled: true,
-        text: JSON.stringify({ entry: result.entry, arc: { id: result.arc.id, name: result.arc.name, status: result.arc.status } }, null, 2)
-      };
     }
     case "paradigm_assessment_search": {
-      const entries = await searchEntries(ctx.rootDir, {
-        symbol: args.symbol,
-        tag: args.tag,
-        type: args.type,
-        dateFrom: args.dateFrom,
-        dateTo: args.dateTo,
+      const filter = {
         limit: args.limit || 20
-      });
-      const lines = [`${entries.length} matching entries:`];
-      for (const e of entries) {
-        const symbols = (e.symbols || []).slice(0, 3).join(", ");
-        lines.push(`  [${e.type}] ${e.id} (${e.arc_id}): ${e.title} \u2014 ${symbols}`);
+      };
+      if (args.symbol) filter.symbol = args.symbol;
+      if (args.tag) filter.tag = args.tag;
+      if (args.type) filter.tag = `assessment:${args.type}`;
+      if (args.dateFrom) filter.dateFrom = args.dateFrom;
+      if (args.dateTo) filter.dateTo = args.dateTo;
+      const loreEntries = await loadLoreEntries(ctx.rootDir, filter);
+      const arcEntries = loreEntries.filter((e) => e.tags?.some((t) => t.startsWith("arc:")));
+      if (arcEntries.length > 0) {
+        const lines = [`${arcEntries.length} matching lore entries (with arc tags):`];
+        for (const e of arcEntries) {
+          const arcTag = e.tags?.find((t) => t.startsWith("arc:")) || "";
+          const symbols = (e.symbols_touched || []).slice(0, 3).join(", ");
+          lines.push(`  [${e.type || "unknown"}] ${e.id} (${arcTag}): ${e.title} \u2014 ${symbols}`);
+        }
+        lines.push("", "Deprecated: Use paradigm_lore_search with tag filter");
+        return { handled: true, text: lines.join("\n") };
       }
-      return { handled: true, text: lines.join("\n") };
-    }
-    case "paradigm_assessment_arc_create": {
       try {
-        const arcId = await createArc(ctx.rootDir, {
-          id: args.id,
-          name: args.name,
-          description: args.description,
-          tags: args.tags
+        const entries = await searchEntries(ctx.rootDir, {
+          symbol: args.symbol,
+          tag: args.tag,
+          type: args.type,
+          dateFrom: args.dateFrom,
+          dateTo: args.dateTo,
+          limit: args.limit || 20
         });
-        return { handled: true, text: JSON.stringify({ created: arcId }, null, 2) };
-      } catch (err2) {
-        return { handled: true, text: JSON.stringify({ error: err2.message }) };
+        const lines = [`${entries.length} matching entries:`];
+        for (const e of entries) {
+          const symbols = (e.symbols || []).slice(0, 3).join(", ");
+          lines.push(`  [${e.type}] ${e.id} (${e.arc_id}): ${e.title} \u2014 ${symbols}`);
+        }
+        lines.push("", 'Deprecated: Run "paradigm lore migrate-assessments" then use paradigm_lore_search');
+        return { handled: true, text: lines.join("\n") };
+      } catch {
+        return { handled: true, text: "0 matching entries." };
       }
     }
+    case "paradigm_assessment_arc_create": {
+      return {
+        handled: true,
+        text: JSON.stringify({
+          message: "Arcs are now tag prefixes on lore entries. No explicit creation needed.",
+          guidance: `To create entries in this arc, use paradigm_lore_record with tags: ["arc:${args.id}"]`,
+          deprecated: true
+        }, null, 2)
+      };
+    }
     case "paradigm_assessment_arc_close": {
       const arcId = args.arc_id;
       const status = args.status || "complete";
-      const ok2 = await closeArc(ctx.rootDir, arcId, status);
-      if (!ok2) {
-        return { handled: true, text: JSON.stringify({ error: `Arc ${arcId} not found` }) };
+      const entries = await loadLoreEntries(ctx.rootDir, { tag: `arc:${arcId}` });
+      let updated = 0;
+      for (const entry of entries) {
+        const currentTags = entry.tags || [];
+        if (!currentTags.includes("arc-closed")) {
+          await updateLoreEntry(ctx.rootDir, entry.id, {
+            tags: [...currentTags, "arc-closed", `arc-status:${status}`]
+          });
+          updated++;
+        }
       }
-      return { handled: true, text: JSON.stringify({ closed: arcId, status }, null, 2) };
+      try {
+        await closeArc(ctx.rootDir, arcId, status);
+      } catch {
+      }
+      return {
+        handled: true,
+        text: JSON.stringify({
+          closed: arcId,
+          status,
+          lore_entries_tagged: updated,
+          deprecated: "Use paradigm_lore_search + paradigm_lore_update to manage arc lifecycle via tags"
+        }, null, 2)
+      };
     }
     default:
       return { handled: false, text: "" };
@@ -10530,8 +10886,8 @@ function generateRunId() {
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function interpolate(value, scope) {
   if (typeof value === "string") {
-    return value.replace(TEMPLATE_REGEX, (_match, path25) => {
-      const resolved = resolvePath(path25.trim(), scope);
+    return value.replace(TEMPLATE_REGEX, (_match, path26) => {
+      const resolved = resolvePath(path26.trim(), scope);
       return resolved !== void 0 ? String(resolved) : _match;
     });
   }
@@ -10564,8 +10920,8 @@ function resolvePath(dotPath, scope) {
       return void 0;
   }
 }
-function deepGet(obj, path25) {
-  const parts = path25.split(/[.\[\]]+/).filter(Boolean);
+function deepGet(obj, path26) {
+  const parts = path26.split(/[.\[\]]+/).filter(Boolean);
   let current = obj;
   for (const part of parts) {
     if (current == null || typeof current !== "object") return void 0;
@@ -10801,11 +11157,11 @@ async function runPersonaObject(rootDir, persona, options) {
 }
 async function runChain(rootDir, chainId, options) {
   const start = Date.now();
-  const fs21 = await import("fs");
-  const path25 = await import("path");
-  const yaml12 = await import("js-yaml");
-  const chainPath = path25.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
-  if (!fs21.existsSync(chainPath)) {
+  const fs22 = await import("fs");
+  const path26 = await import("path");
+  const yaml13 = await import("js-yaml");
+  const chainPath = path26.join(rootDir, ".paradigm", "personas", "chains", `${chainId}.yaml`);
+  if (!fs22.existsSync(chainPath)) {
     return {
       chain_id: chainId,
       status: "error",
@@ -10814,7 +11170,7 @@ async function runChain(rootDir, chainId, options) {
       duration_ms: Date.now() - start
     };
   }
-  const chain = yaml12.load(fs21.readFileSync(chainPath, "utf8"));
+  const chain = yaml13.load(fs22.readFileSync(chainPath, "utf8"));
   let permutation;
   if (options.permutation && chain.permutations) {
     permutation = chain.permutations.find((p) => p.id === options.permutation);
@@ -10918,8 +11274,8 @@ function validateInterpolation(persona) {
     const serialized = JSON.stringify(step);
     const templates = serialized.match(TEMPLATE_REGEX) || [];
     for (const template of templates) {
-      const path25 = template.replace("{{", "").replace("}}", "").trim();
-      const [namespace, ...rest] = path25.split(".");
+      const path26 = template.replace("{{", "").replace("}}", "").trim();
+      const [namespace, ...rest] = path26.split(".");
       const key = rest.join(".");
       switch (namespace) {
         case "fixtures":
@@ -10980,7 +11336,7 @@ var PERSONA_SCHEMA = {
 var sentinelSchemaRegistered = false;
 async function emitPersonaEvents(result) {
   try {
-    const { SentinelStorage: SentinelStorage2 } = await import("./dist-YHDSIZQD.js");
+    const { SentinelStorage: SentinelStorage2 } = await import("./dist-IKBGY7FQ.js");
     const storage2 = new SentinelStorage2();
     if (!sentinelSchemaRegistered) {
       try {
@@ -11932,8 +12288,8 @@ function summarizeStep(step) {
 }
 
 // ../paradigm-mcp/src/tools/fallback-grep.ts
-import * as path23 from "path";
-import { execSync as execSync3 } from "child_process";
+import * as path24 from "path";
+import { execSync as execSync5 } from "child_process";
 function grepForReferences(rootDir, symbol, options = {}) {
   const { maxResults = 20 } = options;
   const results = [];
@@ -11947,7 +12303,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
   let output = "";
   for (const cmd of grepCommands) {
     try {
-      output = execSync3(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
+      output = execSync5(cmd, { encoding: "utf8", maxBuffer: 1024 * 1024 });
       if (output.trim()) break;
     } catch {
       continue;
@@ -11961,7 +12317,7 @@ function grepForReferences(rootDir, symbol, options = {}) {
     const match = line.match(/^(.+?):(\d+):(.*)$/);
     if (match) {
       const [, filePath, lineNum, content] = match;
-      const relativePath = path23.relative(rootDir, filePath);
+      const relativePath = path24.relative(rootDir, filePath);
       let context2 = "unknown";
       if (relativePath.includes(".purpose") || relativePath.includes("portal.yaml")) {
         context2 = "purpose";
@@ -12614,7 +12970,7 @@ function registerTools(server, getContext2, reloadContext2) {
                 const symbols = getSymbolsByType(ctx.index, type);
                 examples[type] = symbols.slice(0, 3).map((s) => s.symbol);
               }
-              const platform2 = os.platform();
+              const platform2 = os3.platform();
               const isWindows = platform2 === "win32";
               const shell = isWindows ? "PowerShell/CMD" : platform2 === "darwin" ? "zsh/bash" : "bash";
               let protocols;
@@ -12854,10 +13210,10 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-T4N3NG73.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-CMZARW5K.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
-              const memberAbsPath = path24.resolve(path24.dirname(ctx.workspace.workspacePath), member.path);
+              const memberAbsPath = path25.resolve(path25.dirname(ctx.workspace.workspacePath), member.path);
               try {
                 const result = await rebuildStaticFiles2(memberAbsPath);
                 memberResults.push({