wyrm-mcp 3.2.1 → 3.3.0

package/dist/index.js

@@ -28,11 +28,19 @@ import { initializeOrchestrator, getDefaultConfig } from "./auto-orchestrator.js
 import { sanitizeFtsQuery, sanitizeString, validateBatchSize } from "./security.js";
 import { getCrypto, initializeCrypto } from "./crypto.js";
 import { createVectorStore } from "./vectors.js";
+import { IndexingPipeline } from "./indexer.js";
+import { KnowledgeGraph } from "./knowledge-graph.js";
+import { MemoryArtifacts } from "./memory-artifacts.js";
+import { GroundTruths, ReasoningScaffolds } from "./intelligence.js";
 import { initializeLicense, getLicenseInfo, hasFeature, getTier, activateLicense } from "./license.js";
 import { WyrmAnalytics } from "./analytics.js";
 import { WyrmCloudBackup } from "./cloud-backup.js";
 const db = new WyrmDB();
 const sync = new WyrmSync(db);
+const graph = new KnowledgeGraph(db.getDatabase());
+const memory = new MemoryArtifacts(db.getDatabase());
+const groundTruths = new GroundTruths(db.getDatabase());
+const scaffoldLib = new ReasoningScaffolds(db.getDatabase());
 // ==================== OPTIONAL ENCRYPTION ====================
 if (process.env.WYRM_ENCRYPTION_KEY) {
     try {
@@ -45,10 +53,46 @@ if (process.env.WYRM_ENCRYPTION_KEY) {
 const wyrmCrypto = getCrypto();
 // ==================== OPTIONAL VECTOR SEARCH ====================
 let vectorStore = null;
+let indexingPipeline = null;
 try {
     const provider = (process.env.WYRM_VECTOR_PROVIDER || 'none');
     if (provider !== 'none') {
-        vectorStore = createVectorStore({ provider });
+        vectorStore = createVectorStore({ provider }, db.getDatabase());
+        // Content resolver for the indexing pipeline
+        const resolveContent = (type, id) => {
+            try {
+                switch (type) {
+                    case 'session': {
+                        const s = db.getSession(id);
+                        if (!s)
+                            return null;
+                        const parts = [s.objectives, s.completed, s.notes, s.summary].filter(Boolean);
+                        return parts.join(' ') || null;
+                    }
+                    case 'quest': {
+                        const q = db.getDatabase().prepare('SELECT * FROM quests WHERE id = ?').get(id);
+                        if (!q)
+                            return null;
+                        return [q.title, q.description].filter(Boolean).join(' ') || null;
+                    }
+                    case 'note':
+                    case 'context': {
+                        const rows = db.getDatabase().prepare('SELECT value FROM data_lake WHERE id = ?').all(id);
+                        if (!rows.length)
+                            return null;
+                        const val = wyrmCrypto.maybeDecrypt(rows[0].value);
+                        return val.startsWith('ENCRYPTED:') ? null : val; // skip encrypted content
+                    }
+                    default:
+                        return null;
+                }
+            }
+            catch {
+                return null;
+            }
+        };
+        indexingPipeline = new IndexingPipeline(db.getDatabase(), vectorStore, resolveContent, { batchSize: 20, maxRetries: 3, intervalMs: 10000 });
+        indexingPipeline.start();
     }
 }
 catch (e) {
@@ -172,6 +216,13 @@ const READ_ONLY_TOOLS = new Set([
     "wyrm_license",
     "wyrm_analytics_dashboard",
     "wyrm_cost_report",
+    "wyrm_entity_search",
+    "wyrm_entity_graph",
+    "wyrm_entity_path",
+    "wyrm_recall",
+    "wyrm_context_build",
+    "wyrm_truth_get",
+    "wyrm_scaffold_get",
 ]);
 /** Tools that mutate data — invalidate relevant caches */
 const WRITE_TOOLS = new Set([
@@ -192,6 +243,15 @@ const WRITE_TOOLS = new Set([
     "wyrm_activate",
     "wyrm_cloud_backup",
     "wyrm_encrypt_setup",
+    "wyrm_entity_add",
+    "wyrm_entity_link",
+    "wyrm_entity_merge",
+    "wyrm_remember",
+    "wyrm_feedback",
+    "wyrm_truth_set",
+    "wyrm_scaffold_save",
+    "wyrm_distill",
+    "wyrm_review",
 ]);
 const server = new Server({
     name: "wyrm",
@@ -493,12 +553,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         // Search
         {
             name: "wyrm_search",
-            description: "Search across all projects, sessions, quests, and data",
+            description: "Search across all projects, sessions, quests, data, and entities. Supports lexical (FTS), semantic (vector), and hybrid (RRF fusion) search modes.",
             inputSchema: {
                 type: "object",
                 properties: {
                     query: { type: "string", description: "Search query" },
-                    type: { type: "string", enum: ["all", "sessions", "quests", "data"], description: "What to search" },
+                    type: { type: "string", enum: ["all", "sessions", "quests", "data", "entities"], description: "What to search" },
+                    mode: { type: "string", enum: ["lexical", "semantic", "hybrid"], description: "Search mode: lexical (FTS), semantic (vector similarity), or hybrid (RRF fusion). Default: hybrid if vectors available, lexical otherwise." },
                     projectPath: { type: "string", description: "Limit to specific project" },
                 },
                 required: ["query"],
@@ -660,6 +721,268 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["action"],
             },
         },
+        // Knowledge Graph
+        {
+            name: "wyrm_entity_add",
+            description: "Add an entity to the knowledge graph (person, concept, tool, etc.)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project to add entity to" },
+                    name: { type: "string", description: "Entity name" },
+                    type: { type: "string", description: "Entity type (e.g., person, concept, tool, framework, service)" },
+                    metadata: { type: "string", description: "JSON metadata about the entity" },
+                    aliases: { type: "array", items: { type: "string" }, description: "Alternative names for the entity" },
+                },
+                required: ["projectPath", "name", "type"],
+            },
+        },
+        {
+            name: "wyrm_entity_link",
+            description: "Create a relationship between two entities in the knowledge graph",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project containing the entities" },
+                    source: { type: "string", description: "Source entity name" },
+                    target: { type: "string", description: "Target entity name" },
+                    relationship: { type: "string", description: "Relationship type (e.g., uses, depends_on, created_by, extends)" },
+                    weight: { type: "number", description: "Relationship weight 0-1 (default: 1.0)" },
+                    confidence: { type: "number", description: "Confidence score 0-1 (default: 1.0)" },
+                    sourceMemory: { type: "string", description: "Source of this knowledge (e.g., session:42, quest:7)" },
+                },
+                required: ["projectPath", "source", "target", "relationship"],
+            },
+        },
+        {
+            name: "wyrm_entity_search",
+            description: "Search for entities in the knowledge graph",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project to search in" },
+                    query: { type: "string", description: "Search query for entity names" },
+                    type: { type: "string", description: "Filter by entity type" },
+                    limit: { type: "number", description: "Max results (default: 20)" },
+                },
+                required: ["projectPath", "query"],
+            },
+        },
+        {
+            name: "wyrm_entity_graph",
+            description: "Get the neighborhood graph around an entity — all connected nodes within N hops",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project containing the entity" },
+                    entity: { type: "string", description: "Entity name to center on" },
+                    depth: { type: "number", description: "Max hops from center (1-5, default: 2)" },
+                },
+                required: ["projectPath", "entity"],
+            },
+        },
+        {
+            name: "wyrm_entity_path",
+            description: "Find the shortest path between two entities in the knowledge graph",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project containing the entities" },
+                    source: { type: "string", description: "Source entity name" },
+                    target: { type: "string", description: "Target entity name" },
+                    maxDepth: { type: "number", description: "Max path length (1-5, default: 5)" },
+                },
+                required: ["projectPath", "source", "target"],
+            },
+        },
+        {
+            name: "wyrm_entity_merge",
+            description: "Merge two entities — combines aliases, redirects relationships, deletes the source",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project containing the entities" },
+                    source: { type: "string", description: "Entity name to merge FROM (will be deleted)" },
+                    target: { type: "string", description: "Entity name to merge INTO (will be kept)" },
+                },
+                required: ["projectPath", "source", "target"],
+            },
+        },
+        // ==================== INTELLIGENCE AMPLIFICATION ====================
+        {
+            name: "wyrm_remember",
+            description: "Store a distilled knowledge artifact — proven patterns, lessons learned, anti-patterns, and reasoning traces. These are recalled automatically by wyrm_context_build to help AI models apply past knowledge to new tasks.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project this knowledge belongs to" },
+                    kind: {
+                        type: "string",
+                        enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"],
+                        description: "reasoning_trace: a solved problem with steps; lesson: a general insight; pattern: a proven approach; anti_pattern: what NOT to do; heuristic: a rule of thumb",
+                    },
+                    problem: { type: "string", description: "What was being solved or observed (be specific and searchable)" },
+                    constraints: { type: "string", description: "What conditions or constraints applied" },
+                    validatedFix: { type: "string", description: "What actually worked — the validated solution or approach" },
+                    whyItWorked: { type: "string", description: "The insight behind WHY this worked (key for transfer learning)" },
+                    outcome: { type: "string", enum: ["positive", "negative", "neutral"], description: "Was this approach successful?" },
+                    tags: { type: "array", items: { type: "string" }, description: "Searchable tags (e.g. ['auth', 'rate-limit', 'typescript'])" },
+                    confidence: { type: "number", description: "Confidence level 0.0–1.0 (default: 1.0)" },
+                    sourceSessionId: { type: "number", description: "Session ID where this was discovered (optional)" },
+                },
+                required: ["projectPath", "kind", "problem"],
+            },
+        },
+        {
+            name: "wyrm_recall",
+            description: "Retrieve relevant knowledge artifacts for a given task or problem. Uses 2-stage retrieval (FTS + tag matching) with freshness and confidence weighting. Returns distilled knowledge from past sessions.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project to search within" },
+                    query: { type: "string", description: "Describe the current task or problem" },
+                    kind: {
+                        type: "string",
+                        enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"],
+                        description: "Filter by artifact kind (optional — searches all kinds if omitted)",
+                    },
+                    limit: { type: "number", description: "Max results (default: 10)" },
+                    minConfidence: { type: "number", description: "Minimum confidence threshold 0.0–1.0 (default: 0.0)" },
+                },
+                required: ["projectPath", "query"],
+            },
+        },
+        {
+            name: "wyrm_feedback",
+            description: "Record whether a recalled knowledge artifact was useful. Adjusts confidence over time — successful reuse boosts it, failure lowers it. Call after applying a recalled pattern or lesson.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    artifactId: { type: "number", description: "ID of the memory artifact (from wyrm_recall results)" },
+                    success: { type: "boolean", description: "Was this artifact helpful for the task?" },
+                },
+                required: ["artifactId", "success"],
+            },
+        },
+        {
+            name: "wyrm_context_build",
+            description: "Assemble an optimized memory brief for the current task — a formatted block of relevant patterns, lessons, reasoning traces, and anti-patterns from past sessions. Inject this at the start of complex tasks to give AI models the right context without bloating the whole conversation.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project to build context from" },
+                    task: { type: "string", description: "Describe the current task in detail — the more specific, the better the recall" },
+                    maxItems: { type: "number", description: "Max knowledge items to include (default: 10, max: 20)" },
+                    kinds: {
+                        type: "array",
+                        items: { type: "string", enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"] },
+                        description: "Limit to specific artifact kinds (default: all)",
+                    },
+                    minConfidence: { type: "number", description: "Minimum confidence threshold (default: 0.3)" },
+                },
+                required: ["projectPath", "task"],
+            },
+        },
+        {
+            name: "wyrm_truth_set",
+            description: "Store a ground truth for the project — validated facts about architecture, constraints, conventions, or key decisions. Ground truths are injected first into every wyrm_context_build response so the AI always works from a foundation of confirmed facts.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project root path" },
+                    category: { type: "string", description: "Category grouping (e.g. 'architecture', 'conventions', 'constraints', 'decisions')" },
+                    key: { type: "string", description: "Short unique key within the category (snake_case)" },
+                    value: { type: "string", description: "The ground truth statement" },
+                    rationale: { type: "string", description: "Why this is true / how it was determined" },
+                    source: { type: "string", description: "Origin: 'user', 'derived', 'observed', 'confirmed'" },
+                    confidence: { type: "number", description: "Confidence 0-1 (default: 1.0 for user-asserted truths)" },
+                },
+                required: ["projectPath", "category", "key", "value"],
+            },
+        },
+        {
+            name: "wyrm_truth_get",
+            description: "Retrieve current ground truths for a project. Returns validated facts the AI should treat as baseline. Optionally filter by category.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project root path" },
+                    category: { type: "string", description: "Filter to specific category (optional)" },
+                },
+                required: ["projectPath"],
+            },
+        },
+        {
+            name: "wyrm_scaffold_save",
+            description: "Save a reasoning scaffold — a structured checklist that guides step-by-step thinking for a specific problem type. Scaffolds are automatically surfaced by wyrm_context_build when the task matches, helping AI models apply proven reasoning patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project path (optional, null for global scaffolds)" },
+                    problemType: { type: "string", description: "Short slug for the problem type (e.g. 'api-design', 'security-review', 'db-migration')" },
+                    description: { type: "string", description: "What kind of task this scaffold helps with" },
+                    whenToUse: { type: "string", description: "Conditions that indicate this scaffold should be applied" },
+                    steps: { type: "array", items: { type: "string" }, description: "Ordered checklist steps to follow" },
+                    verificationSteps: { type: "array", items: { type: "string" }, description: "Steps to verify the work is correct" },
+                    doNotApplyIf: { type: "string", description: "Conditions where this scaffold does NOT apply" },
+                    tags: { type: "array", items: { type: "string" }, description: "Searchable tags" },
+                },
+                required: ["problemType", "description", "whenToUse", "steps"],
+            },
+        },
+        {
+            name: "wyrm_scaffold_get",
+            description: "Find the best reasoning scaffold for a task description. Returns the most relevant structured checklist, or null if no match meets the confidence threshold.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project path (searches project + global)" },
+                    task: { type: "string", description: "Task description to match against scaffolds" },
+                    minConfidence: { type: "number", description: "Minimum match confidence 0-1 (default: 0.3)" },
+                },
+                required: ["task"],
+            },
+        },
+        {
+            name: "wyrm_distill",
+            description: "Distill a work session into candidate memory artifacts for review. Parses the session's objectives, decisions, and outcomes into structured artifacts (lessons, patterns, anti-patterns) and queues them for approval via wyrm_review. Use at session end to extract institutional knowledge.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    projectPath: { type: "string", description: "Project root path" },
+                    sessionId: { type: "string", description: "Session ID to distill" },
+                    candidates: {
+                        type: "array",
+                        description: "Pre-parsed candidate artifacts to store for review",
+                        items: {
+                            type: "object",
+                            properties: {
+                                kind: { type: "string", enum: ["lesson", "pattern", "anti_pattern", "heuristic", "reasoning_trace"] },
+                                title: { type: "string" },
+                                content: { type: "string" },
+                                tags: { type: "array", items: { type: "string" } },
+                                confidence: { type: "number" },
+                            },
+                            required: ["kind", "title", "content"],
+                        },
+                    },
+                },
+                required: ["projectPath", "candidates"],
+            },
+        },
+        {
+            name: "wyrm_review",
+            description: "Approve or reject a pending memory artifact from the distillation queue. Approved artifacts enter the active recall pool; rejected artifacts are permanently discarded.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    artifactId: { type: "number", description: "ID of the artifact to review" },
+                    approved: { type: "boolean", description: "true to approve (activate), false to reject (delete)" },
+                    notes: { type: "string", description: "Optional reviewer notes" },
+                },
+                required: ["artifactId", "approved"],
+            },
+        },
     ],
 }));
 // Tool implementations
@@ -1169,74 +1492,539 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 // ==================== SEARCH ====================
                 case "wyrm_search": {
-                    const { query, type, projectPath } = args;
+                    const { query, type, mode, projectPath } = args;
                     const sanitizedQuery = sanitizeFtsQuery(query);
                     const project = projectPath ? db.getProject(projectPath) : undefined;
                     const projectId = project?.id;
                     const searchType = type || 'all';
-                    let text = `🐉 **Search Results for "${query}"**\n\n`;
+                    const searchMode = mode || (vectorStore ? 'hybrid' : 'lexical');
+                    let text = `🐉 **Search Results for "${query}"** _(mode: ${searchMode})_\n\n`;
+                    const ftsResultsByType = {};
                     if (searchType === 'all' || searchType === 'sessions') {
-                        const sessions = db.searchSessions(sanitizedQuery, projectId);
-                        if (sessions.length > 0) {
-                            text += `## Sessions (${sessions.length})\n`;
-                            for (const s of sessions.slice(0, 10)) {
-                                text += `- ${s.date}: ${s.objectives?.slice(0, 80) || s.completed?.slice(0, 80) || 'No info'}...\n`;
-                            }
-                            text += '\n';
+                        if (searchMode !== 'semantic') {
+                            const sessions = db.searchSessions(sanitizedQuery, projectId);
+                            ftsResultsByType['session'] = sessions.map((s, i) => ({
+                                id: s.id,
+                                snippet: `${s.date}: ${(s.objectives || s.completed || 'No info').slice(0, 80)}`,
+                                rank: i + 1,
+                            }));
                         }
                     }
                     if (searchType === 'all' || searchType === 'quests') {
-                        const quests = db.searchQuests(sanitizedQuery);
-                        if (quests.length > 0) {
-                            text += `## Quests (${quests.length})\n`;
-                            for (const q of quests.slice(0, 10)) {
-                                text += `- #${q.id}: ${q.title}\n`;
-                            }
-                            text += '\n';
+                        if (searchMode !== 'semantic') {
+                            const quests = db.searchQuests(sanitizedQuery);
+                            ftsResultsByType['quest'] = quests.map((q, i) => ({
+                                id: q.id,
+                                snippet: `#${q.id}: ${q.title}`,
+                                rank: i + 1,
+                            }));
                         }
                     }
                     if (searchType === 'all' || searchType === 'data') {
-                        const data = db.searchData(sanitizedQuery, projectId);
-                        if (data.length > 0) {
-                            text += `## Data (${data.length})\n`;
-                            for (const d of data.slice(0, 10)) {
-                                const val = wyrmCrypto.maybeDecrypt(d.value);
-                                text += `- ${d.category}/${d.key}: ${val.slice(0, 60)}${val.length > 60 ? '...' : ''}\n`;
+                        if (searchMode !== 'semantic') {
+                            const data = db.searchData(sanitizedQuery, projectId);
+                            ftsResultsByType['note'] = data.map((d, i) => ({
+                                id: d.id,
+                                snippet: `${d.category}/${d.key}: ${wyrmCrypto.maybeDecrypt(d.value).slice(0, 60)}`,
+                                rank: i + 1,
+                            }));
+                        }
+                    }
+                    let vectorResults = [];
+                    if (vectorStore && searchMode !== 'lexical' && (searchType === 'all' || searchType === 'data' || searchType === 'sessions' || searchType === 'quests')) {
+                        try {
+                            vectorResults = await vectorStore.search(query, 20, projectId);
+                        }
+                        catch {
+                            // Vector search failed gracefully — continue with FTS
+                        }
+                    }
+                    // ── Reciprocal Rank Fusion (RRF) ──────────────────────────────────────
+                    // Score formula: Σ 1/(k + rank) where k=60
+                    const RRF_K = 60;
+                    const rrfScores = new Map();
+                    const addFtsToRrf = (contentType, results) => {
+                        results.forEach((r, idx) => {
+                            const key = `${contentType}:${r.id}`;
+                            const existing = rrfScores.get(key);
+                            const score = 1 / (RRF_K + (idx + 1));
+                            if (existing) {
+                                existing.score += score;
+                            }
+                            else {
+                                rrfScores.set(key, { score, snippet: r.snippet, type: contentType, id: r.id });
+                            }
+                        });
+                    };
+                    for (const [contentType, results] of Object.entries(ftsResultsByType)) {
+                        addFtsToRrf(contentType, results);
+                    }
+                    // Add vector results to RRF (sorted by similarity desc → rank 1=most similar)
+                    const vecByType = {};
+                    for (const vr of vectorResults) {
+                        if (!vecByType[vr.content_type])
+                            vecByType[vr.content_type] = [];
+                        vecByType[vr.content_type].push(vr);
+                    }
+                    for (const [contentType, results] of Object.entries(vecByType)) {
+                        results.forEach((vr, idx) => {
+                            const key = `${contentType}:${vr.content_id}`;
+                            const existing = rrfScores.get(key);
+                            const score = 1 / (RRF_K + (idx + 1));
+                            if (existing) {
+                                existing.score += score;
+                                existing.snippet += ` (semantic: ${(vr.similarity * 100).toFixed(0)}%)`;
+                            }
+                            else {
+                                rrfScores.set(key, { score, snippet: `${contentType} #${vr.content_id} (semantic: ${(vr.similarity * 100).toFixed(0)}%)`, type: contentType, id: vr.content_id });
+                            }
+                        });
+                    }
+                    // Sort by RRF score and render fused results
+                    const fused = Array.from(rrfScores.values()).sort((a, b) => b.score - a.score);
+                    if (fused.length > 0) {
+                        const byType = {};
+                        for (const r of fused) {
+                            if (!byType[r.type])
+                                byType[r.type] = [];
+                            byType[r.type].push(r);
+                        }
+                        for (const [contentType, results] of Object.entries(byType)) {
+                            const label = contentType === 'note' ? 'Data' : contentType.charAt(0).toUpperCase() + contentType.slice(1) + 's';
+                            text += `## ${label} (${results.length})\n`;
+                            for (const r of results.slice(0, 10)) {
+                                text += `- ${r.snippet}\n`;
                             }
                             text += '\n';
                         }
                     }
+                    // Skills search (FTS only — no vector indexing for skills)
                     if (searchType === 'all' || searchType === 'skills') {
                         const skills = db.searchSkills(sanitizedQuery, 10);
                         if (skills.length > 0) {
                             text += `## Skills (${skills.length})\n`;
                             for (const s of skills) {
-                                text += `- **${s.name}** (${s.category || 'uncategorized'}) ${s.is_active ? '\u2705' : '\u274c'}\n`;
+                                text += `- **${s.name}** (${s.category || 'uncategorized'}) ${s.is_active ? '✅' : '❌'}\n`;
                                 text += `  ${s.description}\n`;
                             }
+                            text += '\n';
                         }
                     }
-                    // Optional vector search enhancement
-                    if (vectorStore && (searchType === 'all' || searchType === 'data')) {
-                        try {
-                            const vectorResults = await vectorStore.search(query, 5, projectId);
-                            if (vectorResults.length > 0) {
-                                text += `\n## Semantic Matches (${vectorResults.length})\n`;
-                                for (const v of vectorResults) {
-                                    text += `- ${v.content_type} #${v.content_id} (similarity: ${(v.similarity * 100).toFixed(1)}%)\n`;
-                                }
+                    // Entity graph search
+                    if ((searchType === 'all' || searchType === 'entities') && projectId !== undefined) {
+                        const entities = graph.searchEntities(projectId, query, 10);
+                        if (entities.length > 0) {
+                            text += `## Entities (${entities.length})\n`;
+                            for (const e of entities) {
+                                const rels = graph.getRelationships(e.id, 'both');
+                                text += `- **${e.name}** _(${e.type})_ — ${rels.length} relationship${rels.length !== 1 ? 's' : ''}\n`;
                             }
-                        }
-                        catch {
-                            // Vector search failed gracefully — FTS results still returned
+                            text += '\n';
                         }
                     }
+                    if (fused.length === 0 && !text.includes('##')) {
+                        text += '_No results found._\n';
+                    }
                     const response = cachedResponse(text);
                     if (cacheKey)
                         cache.set(cacheKey, response, 20000);
                     return response;
                 }
-                // ==================== SYNC & MAINTENANCE ====================
+                // ==================== KNOWLEDGE GRAPH ====================
+                case "wyrm_entity_add": {
+                    const { projectPath: ePath, name: eName, type: eType, metadata: eMeta, aliases: eAliases } = args;
+                    const eProject = db.getProject(ePath);
+                    if (!eProject)
+                        return { content: [{ type: "text", text: `Project not found: ${ePath}` }], isError: true };
+                    const existingEntity = graph.findEntity(eProject.id, eName, eType);
+                    if (existingEntity) {
+                        return { content: [{ type: "text", text: `🐉 Entity already exists: **${eName}** (${eType}) — id ${existingEntity.id}` }] };
+                    }
+                    const entity = graph.addEntity(eProject.id, eName, eType, eMeta);
+                    if (eAliases?.length) {
+                        for (const alias of eAliases)
+                            graph.addAlias(entity.id, alias);
+                    }
+                    cache.invalidate('wyrm_entity_search');
+                    cache.invalidate('wyrm_entity_graph');
+                    cache.invalidate('wyrm_stats');
+                    let text = `🐉 **Entity Added**\n\n- **${entity.name}** _(${entity.type})_\n- ID: ${entity.id}\n`;
+                    if (eAliases?.length)
+                        text += `- Aliases: ${eAliases.join(', ')}\n`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "wyrm_entity_link": {
+                    const { projectPath: lPath, source, target, relationship, weight, confidence, sourceMemory } = args;
+                    const lProject = db.getProject(lPath);
+                    if (!lProject)
+                        return { content: [{ type: "text", text: `Project not found: ${lPath}` }], isError: true };
+                    const srcEntity = graph.findEntity(lProject.id, source) ?? graph.findByAlias(lProject.id, source);
+                    const tgtEntity = graph.findEntity(lProject.id, target) ?? graph.findByAlias(lProject.id, target);
+                    if (!srcEntity)
+                        return { content: [{ type: "text", text: `Entity not found: "${source}". Use wyrm_entity_add first.` }], isError: true };
+                    if (!tgtEntity)
+                        return { content: [{ type: "text", text: `Entity not found: "${target}". Use wyrm_entity_add first.` }], isError: true };
+                    const rel = graph.addRelationship(lProject.id, srcEntity.id, tgtEntity.id, relationship, {
+                        weight: weight ?? 1.0,
+                        confidence: confidence ?? 1.0,
+                        sourceMemory,
+                    });
+                    cache.invalidate('wyrm_entity_search');
+                    cache.invalidate('wyrm_entity_graph');
+                    cache.invalidate('wyrm_stats');
+                    return { content: [{ type: "text", text: `🐉 **Relationship Created**\n\n**${source}** —[${relationship}]→ **${target}**\n- ID: ${rel.id}${sourceMemory ? `\n- Source: ${sourceMemory}` : ''}` }] };
+                }
+                case "wyrm_entity_search": {
+                    const { projectPath: sePath, query: seQuery, type: seType, limit: seLimit } = args;
+                    const seProject = db.getProject(sePath);
+                    if (!seProject)
+                        return { content: [{ type: "text", text: `Project not found: ${sePath}` }], isError: true };
+                    const entities = graph.searchEntities(seProject.id, seQuery, seLimit ?? 20);
+                    const filtered = seType ? entities.filter(e => e.type === seType) : entities;
+                    if (filtered.length === 0) {
+                        return { content: [{ type: "text", text: `🐉 No entities found matching "${seQuery}"` }] };
+                    }
+                    let text = `🐉 **Entities matching "${seQuery}"** (${filtered.length})\n\n`;
+                    for (const e of filtered) {
+                        const rels = graph.getRelationships(e.id, 'both');
+                        const aliases = graph.getAliases(e.id);
+                        text += `- **${e.name}** _(${e.type})_ — ${rels.length} connection${rels.length !== 1 ? 's' : ''}`;
+                        if (aliases.length)
+                            text += ` | also: ${aliases.join(', ')}`;
+                        text += '\n';
+                    }
+                    const response = cachedResponse(text);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 15000);
+                    return response;
+                }
+                case "wyrm_entity_graph": {
+                    const { projectPath: gPath, entity: gEntity, depth: gDepth } = args;
+                    const gProject = db.getProject(gPath);
+                    if (!gProject)
+                        return { content: [{ type: "text", text: `Project not found: ${gPath}` }], isError: true };
+                    const centerEntity = graph.findEntity(gProject.id, gEntity) ?? graph.findByAlias(gProject.id, gEntity);
+                    if (!centerEntity)
+                        return { content: [{ type: "text", text: `Entity not found: "${gEntity}". Use wyrm_entity_search to find entities.` }], isError: true };
+                    const hood = graph.getNeighborhood(centerEntity.id, Math.min(gDepth ?? 2, 5));
+                    let text = `🐉 **Graph: ${centerEntity.name}** _(depth: ${gDepth ?? 2})_\n\n`;
+                    text += `**${hood.nodes.length} nodes, ${hood.edges.length} edges**\n\n`;
+                    // Group nodes by depth
+                    const byDepth = {};
+                    for (const n of hood.nodes) {
+                        if (!byDepth[n.depth])
+                            byDepth[n.depth] = [];
+                        byDepth[n.depth].push(n);
+                    }
+                    for (const [depth, nodes] of Object.entries(byDepth).sort((a, b) => Number(a[0]) - Number(b[0]))) {
+                        const label = depth === '0' ? '🎯 Center' : `Hop ${depth}`;
+                        text += `**${label}:** ${nodes.map(n => `${n.name} (${n.type})`).join(', ')}\n`;
+                    }
+                    if (hood.edges.length > 0) {
+                        text += '\n**Connections:**\n';
+                        for (const e of hood.edges.slice(0, 20)) {
+                            text += `- ${e.source_name} —[${e.relationship_type}]→ ${e.target_name}\n`;
+                        }
+                    }
+                    const response = cachedResponse(text);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 15000);
+                    return response;
+                }
+                case "wyrm_entity_path": {
+                    const { projectPath: pPath, source: pSource, target: pTarget, maxDepth: pDepth } = args;
+                    const pProject = db.getProject(pPath);
+                    if (!pProject)
+                        return { content: [{ type: "text", text: `Project not found: ${pPath}` }], isError: true };
+                    const pSrc = graph.findEntity(pProject.id, pSource) ?? graph.findByAlias(pProject.id, pSource);
+                    const pTgt = graph.findEntity(pProject.id, pTarget) ?? graph.findByAlias(pProject.id, pTarget);
+                    if (!pSrc)
+                        return { content: [{ type: "text", text: `Entity not found: "${pSource}"` }], isError: true };
+                    if (!pTgt)
+                        return { content: [{ type: "text", text: `Entity not found: "${pTarget}"` }], isError: true };
+                    const path = graph.findPath(pSrc.id, pTgt.id, Math.min(pDepth ?? 5, 5));
+                    if (!path) {
+                        return { content: [{ type: "text", text: `🐉 No path found between **${pSource}** and **${pTarget}** within ${pDepth ?? 5} hops.` }] };
+                    }
+                    // Resolve entity names for path display
+                    const pathEntities = path.map(id => graph.getEntity(id)).filter(Boolean);
+                    const pathStr = pathEntities.map(e => e.name).join(' → ');
+                    return { content: [{ type: "text", text: `🐉 **Path Found** (${path.length - 1} hops)\n\n${pathStr}` }] };
+                }
+                case "wyrm_entity_merge": {
+                    const { projectPath: mPath, source: mSource, target: mTarget } = args;
+                    const mProject = db.getProject(mPath);
+                    if (!mProject)
+                        return { content: [{ type: "text", text: `Project not found: ${mPath}` }], isError: true };
+                    const mSrc = graph.findEntity(mProject.id, mSource) ?? graph.findByAlias(mProject.id, mSource);
+                    const mTgt = graph.findEntity(mProject.id, mTarget) ?? graph.findByAlias(mProject.id, mTarget);
+                    if (!mSrc)
+                        return { content: [{ type: "text", text: `Entity not found: "${mSource}"` }], isError: true };
+                    if (!mTgt)
+                        return { content: [{ type: "text", text: `Entity not found: "${mTarget}"` }], isError: true };
+                    if (mSrc.id === mTgt.id)
+                        return { content: [{ type: "text", text: `Cannot merge entity with itself.` }], isError: true };
+                    graph.mergeEntities(mSrc.id, mTgt.id);
+                    cache.invalidate('wyrm_entity_search');
+                    cache.invalidate('wyrm_entity_graph');
+                    cache.invalidate('wyrm_stats');
+                    return { content: [{ type: "text", text: `🐉 **Merged** "${mSource}" → "${mTarget}"\n\n"${mSource}" is now an alias of "${mTarget}". All relationships redirected.` }] };
+                }
+                // ==================== INTELLIGENCE AMPLIFICATION ====================
+                case "wyrm_remember": {
+                    const { projectPath: rPath, kind: rKind, problem: rProblem, constraints: rConst, validatedFix: rFix, whyItWorked: rWhy, outcome: rOutcome, tags: rTags, confidence: rConf, sourceSessionId: rSessId } = args;
+                    const rProject = db.getProject(rPath);
+                    if (!rProject)
+                        return { content: [{ type: "text", text: `Project not found: ${rPath}` }], isError: true };
+                    const artifact = memory.add(rProject.id, {
+                        kind: rKind,
+                        problem: rProblem,
+                        constraints: rConst,
+                        validatedFix: rFix,
+                        whyItWorked: rWhy,
+                        outcome: rOutcome,
+                        tags: rTags,
+                        confidence: rConf,
+                        sourceSessionId: rSessId,
+                    });
+                    const kindEmoji = {
+                        pattern: '✅', lesson: '📚', reasoning_trace: '🧠', anti_pattern: '⚠️', heuristic: '💡',
+                    };
+                    const emoji = kindEmoji[artifact.kind] ?? '🐉';
+                    let text = `🐉 **Memory Stored** ${emoji}\n\n`;
+                    text += `- **Kind:** ${artifact.kind}\n`;
+                    text += `- **ID:** ${artifact.id}\n`;
+                    text += `- **Problem:** ${artifact.problem}\n`;
+                    if (artifact.validated_fix)
+                        text += `- **Solution:** ${artifact.validated_fix}\n`;
+                    if (artifact.why_it_worked)
+                        text += `- **Why it worked:** ${artifact.why_it_worked}\n`;
+                    text += `- **Confidence:** ${(artifact.confidence * 100).toFixed(0)}%\n`;
+                    if (artifact.tags)
+                        text += `- **Tags:** ${artifact.tags}\n`;
+                    text += `\n_Use \`wyrm_recall\` to retrieve similar memories, or \`wyrm_context_build\` to assemble a task brief._`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "wyrm_recall": {
+                    const { projectPath: rcPath, query: rcQuery, kind: rcKind, limit: rcLimit, minConfidence: rcMinConf } = args;
+                    const rcProject = db.getProject(rcPath);
+                    if (!rcProject)
+                        return { content: [{ type: "text", text: `Project not found: ${rcPath}` }], isError: true };
+                    const results = memory.recall(rcProject.id, rcQuery, {
+                        kind: rcKind,
+                        limit: rcLimit ?? 10,
+                        minConfidence: rcMinConf,
+                    });
+                    if (results.length === 0) {
+                        return { content: [{ type: "text", text: `🐉 No relevant memory found for: "${rcQuery}"\n\nUse \`wyrm_remember\` to store knowledge as you work.` }] };
+                    }
+                    const kindEmoji = {
+                        pattern: '✅', lesson: '📚', reasoning_trace: '🧠', anti_pattern: '⚠️', heuristic: '💡',
+                    };
+                    let text = `🐉 **Memory Recall** — "${rcQuery}" (${results.length} found)\n\n`;
+                    for (const r of results) {
+                        const a = r.artifact;
+                        const emoji = kindEmoji[a.kind] ?? '📌';
+                        text += `### ${emoji} ${a.kind} (ID: ${a.id}) — relevance ${(r.relevance_score * 100).toFixed(0)}%\n`;
+                        text += `**Problem:** ${a.problem}\n`;
+                        if (a.constraints)
+                            text += `**Constraints:** ${a.constraints}\n`;
+                        if (a.validated_fix)
+                            text += `**Solution:** ${a.validated_fix}\n`;
+                        if (a.why_it_worked)
+                            text += `**Why:** ${a.why_it_worked}\n`;
+                        if (a.outcome === 'negative')
+                            text += `⚠️ _This approach failed — see solution for what to do instead_\n`;
+                        text += `_Confidence: ${(a.confidence * 100).toFixed(0)}% | Used ${a.reuse_count}× | Success rate: ${a.reuse_count > 0 ? ((a.reuse_success_count / a.reuse_count) * 100).toFixed(0) + '%' : 'not yet used'}_\n\n`;
+                    }
+                    text += `_Use \`wyrm_feedback\` to record whether these were helpful._`;
+                    const response = cachedResponse(text);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 15000);
+                    return response;
+                }
+                case "wyrm_feedback": {
+                    const { artifactId, success } = args;
+                    const artifact = memory.get(artifactId);
+                    if (!artifact)
+                        return { content: [{ type: "text", text: `Artifact #${artifactId} not found.` }], isError: true };
+                    memory.recordFeedback(artifactId, success);
+                    const updated = memory.get(artifactId);
+                    const icon = success ? '✅' : '❌';
+                    return { content: [{ type: "text", text: `🐉 Feedback recorded ${icon}\n\n- Artifact #${artifactId}: "${artifact.problem.slice(0, 60)}"\n- New confidence: ${(updated.confidence * 100).toFixed(0)}%\n- Total uses: ${updated.reuse_count} (✅ ${updated.reuse_success_count} / ❌ ${updated.reuse_failure_count})` }] };
+                }
+                case "wyrm_context_build": {
+                    const { projectPath: cbPath, task: cbTask, maxItems: cbMax, kinds: cbKinds, minConfidence: cbMinConf } = args;
+                    const cbProject = db.getProject(cbPath);
+                    if (!cbProject)
+                        return { content: [{ type: "text", text: `Project not found: ${cbPath}` }], isError: true };
+                    const sections = [];
+                    // Section 1: Ground truths (~1200 char budget)
+                    const truthsText = groundTruths.formatForContext(cbProject.id);
+                    if (truthsText) {
+                        sections.push(truthsText.slice(0, 1200));
+                    }
+                    // Section 2: Best reasoning scaffold (~1500 char budget)
+                    const scaffoldMatch = scaffoldLib.findBest(cbTask, cbProject.id);
+                    if (scaffoldMatch) {
+                        const scaffoldText = scaffoldLib.formatForContext(scaffoldMatch);
+                        sections.push(scaffoldText.slice(0, 1500));
+                    }
+                    // Section 3: Memory artifacts brief (~2000 char budget)
+                    const brief = memory.buildContextBrief(cbProject.id, cbTask, {
+                        maxItems: Math.min(cbMax ?? 10, 20),
+                        kinds: cbKinds,
+                        minConfidence: cbMinConf,
+                    });
+                    if (brief.sections.length > 0) {
+                        const truncated = brief.text.slice(0, 2000);
+                        sections.push(truncated);
+                    }
+                    if (sections.length === 0) {
+                        return { content: [{ type: "text", text: `🐉 **Context Brief**\n\nNo relevant memory found for this task yet.\n\nAs you work, use \`wyrm_remember\` to store:\n- ✅ Patterns that work\n- ⚠️ Anti-patterns to avoid\n- 💡 Heuristics and shortcuts\n- 🧠 Reasoning traces from complex problems\n\nFuture context briefs will become richer over time.` }] };
+                    }
+                    const stats = memory.getStats(cbProject.id);
+                    const truthStats = groundTruths.getStats(cbProject.id);
+                    let text = `🐉 **Context Brief** — "${cbTask}"\n\n`;
+                    text += sections.join('\n\n---\n\n');
+                    text += `\n\n_Brief: ${truthStats.current} ground truth${truthStats.current !== 1 ? 's' : ''}, scaffold: ${scaffoldMatch ? scaffoldMatch.scaffold.problem_type : 'none'}, ${stats.total} memory artifact${stats.total !== 1 ? 's' : ''}.`;
+                    if (brief.sourceIds.length > 0) {
+                        text += ` Memory IDs: [${brief.sourceIds.join(', ')}] — use \`wyrm_feedback\` to rate._`;
+                    }
+                    else {
+                        text += `_`;
+                    }
+                    const response = cachedResponse(text);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 10000);
+                    return response;
+                }
+                case "wyrm_truth_set": {
+                    const { projectPath: tPath, category: tCat, key: tKey, value: tVal, rationale: tRat, source: tSrc, confidence: tConf } = args;
+                    const tProject = db.getProject(tPath);
+                    if (!tProject)
+                        return { content: [{ type: "text", text: `Project not found: ${tPath}` }], isError: true };
+                    const truth = groundTruths.set(tProject.id, {
+                        category: tCat,
+                        key: tKey,
+                        value: tVal,
+                        rationale: tRat,
+                        source: tSrc,
+                        confidence: tConf ?? 1.0,
+                    });
+                    cache.invalidate('wyrm_truth_get');
+                    cache.invalidate('wyrm_context_build');
+                    return { content: [{ type: "text", text: `🐉 **Ground Truth Set** ✅\n\n- **Category:** ${tCat}\n- **Key:** ${tKey}\n- **Value:** ${tVal}${tRat ? `\n- **Rationale:** ${tRat}` : ''}\n- **ID:** ${truth.id}\n\nThis truth will be injected at the top of every \`wyrm_context_build\` response for this project.` }] };
+                }
+                case "wyrm_truth_get": {
+                    const { projectPath: tgPath, category: tgCat } = args;
+                    const tgProject = db.getProject(tgPath);
+                    if (!tgProject)
+                        return { content: [{ type: "text", text: `Project not found: ${tgPath}` }], isError: true };
+                    const truths = groundTruths.getCurrent(tgProject.id, tgCat);
+                    if (truths.length === 0) {
+                        const msg = tgCat
+                            ? `No ground truths in category "${tgCat}" for this project.`
+                            : `No ground truths stored yet. Use \`wyrm_truth_set\` to add validated facts.`;
+                        return { content: [{ type: "text", text: `🐉 **Ground Truths**\n\n${msg}` }] };
+                    }
+                    const byCategory = new Map();
+                    for (const t of truths) {
+                        if (!byCategory.has(t.category))
+                            byCategory.set(t.category, []);
+                        byCategory.get(t.category).push(t);
+                    }
+                    let text = `🐉 **Ground Truths** — ${truths.length} active\n\n`;
+                    for (const [cat, items] of byCategory) {
+                        text += `### ${cat}\n`;
+                        for (const t of items) {
+                            text += `- **${t.key}:** ${t.value}`;
+                            if (t.confidence < 1)
+                                text += ` _(confidence: ${(t.confidence * 100).toFixed(0)}%)_`;
+                            if (t.rationale)
+                                text += `\n  _${t.rationale}_`;
+                            text += '\n';
+                        }
+                        text += '\n';
+                    }
+                    const response = cachedResponse(text);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 15000);
+                    return response;
+                }
+                case "wyrm_scaffold_save": {
+                    const { projectPath: spPath, problemType, description: spDesc, whenToUse, steps, verificationSteps, doNotApplyIf, tags: spTags } = args;
+                    const spProjectId = spPath ? db.getProject(spPath)?.id ?? undefined : undefined;
+                    const scaffold = scaffoldLib.save({
+                        projectId: spProjectId,
+                        problemType: problemType,
+                        description: spDesc,
+                        whenToUse: whenToUse,
+                        steps,
+                        verificationSteps: verificationSteps ?? undefined,
+                        doNotApplyIf: doNotApplyIf ? [doNotApplyIf] : undefined,
+                        tags: spTags ?? [],
+                    });
+                    cache.invalidate('wyrm_scaffold_get');
+                    cache.invalidate('wyrm_context_build');
+                    return { content: [{ type: "text", text: `🐉 **Reasoning Scaffold Saved** ✅\n\n- **Problem Type:** ${problemType}\n- **Description:** ${spDesc}\n- **Steps:** ${steps.length} checklist items\n- **ID:** ${scaffold.id}\n\nThis scaffold will be surfaced by \`wyrm_context_build\` when tasks match "${problemType}".` }] };
+                }
+                case "wyrm_scaffold_get": {
+                    const { projectPath: sgPath, task: sgTask, minConfidence: sgConf } = args;
+                    const sgProjectId = sgPath ? db.getProject(sgPath)?.id ?? undefined : undefined;
+                    const match = scaffoldLib.findBest(sgTask, sgProjectId, sgConf);
+                    if (!match) {
+                        return { content: [{ type: "text", text: `🐉 **Reasoning Scaffold**\n\nNo scaffold matched for: "${sgTask}"\n\nUse \`wyrm_scaffold_save\` to add scaffolds for this problem type.` }] };
+                    }
+                    const text = scaffoldLib.formatForContext(match);
+                    const response = cachedResponse(`🐉 **Reasoning Scaffold Match** (${(match.matchScore * 100).toFixed(0)}% confidence)\n\n${text}`);
+                    if (cacheKey)
+                        cache.set(cacheKey, response, 15000);
+                    return response;
+                }
+                case "wyrm_distill": {
+                    const { projectPath: dPath, candidates } = args;
+                    const dProject = db.getProject(dPath);
+                    if (!dProject)
+                        return { content: [{ type: "text", text: `Project not found: ${dPath}` }], isError: true };
+                    if (!candidates || candidates.length === 0) {
+                        return { content: [{ type: "text", text: `🐉 **Distill**\n\nNo candidates provided. Provide an array of candidate artifacts to distill.` }], isError: true };
+                    }
+                    const ids = [];
+                    for (const c of candidates) {
+                        const artifact = memory.add(dProject.id, {
+                            kind: c.kind,
+                            problem: c.title,
+                            validatedFix: c.content,
+                            tags: c.tags ?? [],
+                            confidence: c.confidence ?? 0.7,
+                            needsReview: 1,
+                        });
+                        ids.push(artifact.id);
+                    }
+                    let text = `🐉 **Distillation Complete** — ${ids.length} artifact${ids.length !== 1 ? 's' : ''} queued for review\n\n`;
+                    candidates.forEach((c, i) => {
+                        text += `- [#${ids[i]}] **${c.kind}**: ${c.title}\n`;
+                    });
+                    text += `\nUse \`wyrm_review\` with each ID to approve or reject.`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "wyrm_review": {
+                    const { artifactId: rvId, approved, notes: rvNotes } = args;
+                    const artifact = memory.get(rvId);
+                    if (!artifact)
+                        return { content: [{ type: "text", text: `Artifact #${rvId} not found.` }], isError: true };
+                    if (approved) {
+                        memory.update(rvId, { needs_review: 0 });
+                        const icon = '✅';
+                        return { content: [{ type: "text", text: `🐉 ${icon} **Approved** — Artifact #${rvId} is now active.\n\n"${artifact.problem.slice(0, 80)}"\n\nIt will appear in future \`wyrm_recall\` and \`wyrm_context_build\` results.${rvNotes ? `\n\nNotes: ${rvNotes}` : ''}` }] };
+                    }
+                    else {
+                        const rawDb = db.getDatabase();
+                        rawDb.prepare('DELETE FROM memory_artifacts WHERE id = ?').run(rvId);
+                        return { content: [{ type: "text", text: `🐉 ❌ **Rejected** — Artifact #${rvId} permanently deleted.\n\n"${artifact.problem.slice(0, 80)}"${rvNotes ? `\n\nNotes: ${rvNotes}` : ''}` }] };
+                    }
+                }
                 case "wyrm_sync": {
                     const { projectPath, direction } = args;
                     const dir = direction || 'both';