@hiveforge/hivemind-mcp 2.0.0 → 2.1.1

package/README.md

@@ -4,7 +4,13 @@
 
 # Hivemind MCP Server
 
-[![npm version](https://img.shields.io/npm/v/@hiveforge/hivemind-mcp.svg)](https://www.npmjs.com/package/@hiveforge/hivemind-mcp)
+[![NPM Version](https://img.shields.io/npm/v/@hiveforge/hivemind-mcp.svg)](https://www.npmjs.com/package/@hiveforge/hivemind-mcp)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/hiveforge-io/hivemind/test.yml?branch=master&label=tests)](https://github.com/hiveforge-io/hivemind/actions/workflows/test.yml)
+[![Release](https://img.shields.io/github/actions/workflow/status/hiveforge-io/hivemind/release.yml?branch=master&label=release)](https://github.com/hiveforge-io/hivemind/actions/workflows/release.yml)
+[![codecov](https://codecov.io/gh/hiveforge-io/hivemind/branch/master/graph/badge.svg)](https://codecov.io/gh/hiveforge-io/hivemind)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub issues](https://img.shields.io/github/issues/hiveforge-io/hivemind)](https://github.com/hiveforge-io/hivemind/issues)
+[![GitHub stars](https://img.shields.io/github/stars/hiveforge-io/hivemind)](https://github.com/hiveforge-io/hivemind/stargazers)
 
 An MCP (Model Context Protocol) server for Obsidian worldbuilding vaults that provides AI tools with consistent, canonical context from your fictional worlds.
 
@@ -134,39 +140,65 @@ Obsidian Vault → File Watcher → Markdown Parser → Knowledge Graph
 
 ## Development Status
 
-**Current Phase**: Phase 1 - MVP Complete ✅
+**Current Phase**: Milestone 1.0 Complete ✅
 
-### Roadmap
+### What's Included
 
-See [.planning/PROJECT.md](.planning/PROJECT.md) for the active requirements and progress tracking.
-
-**Recently Completed:**
-- [x] Project setup and dependencies
-- [x] Vault reading and file watching (VaultReader, VaultWatcher)
-- [x] Markdown parsing with wikilinks (MarkdownParser)
-- [x] Knowledge graph construction (GraphBuilder, HivemindDatabase)
-- [x] HybridRAG search implementation (SearchEngine)
-- [x] MCP tools (query_character, query_location, search_vault, rebuild_index)
-- [x] CLI vault override flag (--vault)
-- [x] Automatic stale index detection on startup
+- [x] MCP server with hybrid search (vector, graph, keyword)
+- [x] Vault templates for all entity types (Character, Location, Event, Faction, Lore, Asset)
+- [x] Canon workflow tools (status management, consistency validation)
+- [x] Asset management with full provenance tracking
 - [x] ComfyUI integration with workflow management
-- [x] Obsidian plugin with image generation and frontmatter tools
-- [x] GitHub release automation for plugin distribution
-- [x] Test coverage improvement (37% → 45%)
-- [x] CodeQL security scanning integration
+- [x] Obsidian plugin with image generation
+- [x] CI/CD with semantic-release and CodeQL scanning
 
 **Up Next:**
-- [ ] Obsidian plugin community submission (automated release ready)
-- [ ] Testing and validation
-- [ ] Vault templates standardization
-- [ ] Canon workflow implementation
+- [ ] Obsidian community plugin submission
+- [ ] Template System (make Hivemind domain-agnostic)
+
+## MCP Tools
+
+### Query Tools
+| Tool | Description |
+|------|-------------|
+| `query_character` | Get character with relationships and content |
+| `query_location` | Get location with hierarchy and connected entities |
+| `search_vault` | Hybrid search across all content with filters |
+
+### Asset Management
+| Tool | Description |
+|------|-------------|
+| `store_asset` | Store generated image with provenance metadata |
+| `query_asset` | Get asset with generation settings |
+| `list_assets` | Filter assets by entity, type, status, workflow |
+
+### Canon Workflow
+| Tool | Description |
+|------|-------------|
+| `get_canon_status` | List entities grouped by status (draft/pending/canon) |
+| `submit_for_review` | Move entity from draft to pending review |
+| `validate_consistency` | Check for broken links, duplicates, conflicts |
+
+### ComfyUI Integration (when enabled)
+| Tool | Description |
+|------|-------------|
+| `store_workflow` | Save ComfyUI workflow to vault |
+| `list_workflows` | Browse saved workflows |
+| `get_workflow` | Retrieve workflow by ID |
+| `generate_image` | Generate image with vault context injection |
+
+### Utility
+| Tool | Description |
+|------|-------------|
+| `rebuild_index` | Force complete re-index of vault |
+| `get_vault_stats` | Vault statistics and token savings metrics |
 
 ## Documentation
 
-- [Project Requirements & Roadmap](.planning/PROJECT.md)
-- [Architecture Research](.planning/research/ARCHITECTURE.md)
-- [Technology Stack](.planning/research/STACK.md)
-- [Features Specification](.planning/research/FEATURES.md)
+- [Setup Guide](docs/SETUP_GUIDE.md)
+- [ComfyUI Integration](docs/COMFYUI_INTEGRATION.md)
+- [Obsidian Plugin Workflow](docs/OBSIDIAN_PLUGIN_WORKFLOW.md)
+- [Vault Templates](sample-vault/Templates/README.md)
 
 ## License
 

package/dist/server.d.ts

@@ -28,6 +28,11 @@ export declare class HivemindServer {
     private handleGetWorkflow;
     private handleGenerateImage;
     private handleStoreAsset;
+    private handleQueryAsset;
+    private handleListAssets;
+    private handleGetCanonStatus;
+    private handleSubmitForReview;
+    private handleValidateConsistency;
     start(): Promise<void>;
     private printReadyBanner;
 }

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAQA,OAAO,EAOL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAY1B,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,YAAY,CAIlB;gBAEU,MAAM,EAAE,cAAc;IA+ClC,OAAO,CAAC,aAAa;YA8XP,oBAAoB;YA+CpB,mBAAmB;YA+CnB,iBAAiB;YA2CjB,kBAAkB;YAiClB,mBAAmB;IA6FjC,OAAO,CAAC,iBAAiB;YAcX,aAAa;IAwC3B,OAAO,CAAC,gCAAgC;IAwExC,OAAO,CAAC,+BAA+B;IA8CvC,OAAO,CAAC,mBAAmB;YA2Bb,mBAAmB;YAkBnB,mBAAmB;YA8BnB,iBAAiB;YA0BjB,mBAAmB;YAwInB,gBAAgB;IAkCxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAkCd,gBAAgB;CA2B/B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AASA,OAAO,EAYL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAY1B,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,YAAY,CAIlB;gBAEU,MAAM,EAAE,cAAc;IA+ClC,OAAO,CAAC,aAAa;YA0fP,oBAAoB;YA+CpB,mBAAmB;YA+CnB,iBAAiB;YA2CjB,kBAAkB;YAiClB,mBAAmB;IA6FjC,OAAO,CAAC,iBAAiB;YAcX,aAAa;IAwC3B,OAAO,CAAC,gCAAgC;IAwExC,OAAO,CAAC,+BAA+B;IA8CvC,OAAO,CAAC,mBAAmB;YA2Bb,mBAAmB;YAkBnB,mBAAmB;YA8BnB,iBAAiB;YA0BjB,mBAAmB;YAwInB,gBAAgB;YAkChB,gBAAgB;YAkDhB,gBAAgB;YA4DhB,oBAAoB;YAqEpB,qBAAqB;YAsDrB,yBAAyB;IA4GjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAkCd,gBAAgB;CA2B/B"}

package/dist/server.js

@@ -1,7 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { QueryCharacterArgsSchema, QueryLocationArgsSchema, SearchVaultArgsSchema, StoreWorkflowArgsSchema, GenerateImageArgsSchema, StoreAssetArgsSchema, } from './types/index.js';
+import { QueryCharacterArgsSchema, QueryLocationArgsSchema, SearchVaultArgsSchema, StoreWorkflowArgsSchema, GenerateImageArgsSchema, StoreAssetArgsSchema, QueryAssetArgsSchema, ListAssetsArgsSchema, GetCanonStatusArgsSchema, SubmitForReviewArgsSchema, ValidateConsistencyArgsSchema, } from './types/index.js';
 import { VaultReader } from './vault/reader.js';
 import { VaultWatcher } from './vault/watcher.js';
 import { HivemindDatabase } from './graph/database.js';
@@ -188,6 +188,110 @@ export class HivemindServer {
                             required: [],
                         },
                     },
+                    {
+                        name: 'query_asset',
+                        description: 'Get a specific asset by ID with its generation settings and metadata',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    description: 'Asset ID to query',
+                                },
+                            },
+                            required: ['id'],
+                        },
+                    },
+                    {
+                        name: 'list_assets',
+                        description: 'List assets with optional filters by entity, type, status, or workflow',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                depicts: {
+                                    type: 'string',
+                                    description: 'Filter by entity ID depicted in asset',
+                                },
+                                assetType: {
+                                    type: 'string',
+                                    enum: ['image', 'audio', 'video', 'document'],
+                                    description: 'Filter by asset type',
+                                },
+                                status: {
+                                    type: 'string',
+                                    enum: ['draft', 'pending', 'canon', 'non-canon', 'archived'],
+                                    description: 'Filter by approval status',
+                                },
+                                workflowId: {
+                                    type: 'string',
+                                    description: 'Filter by workflow used',
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum results to return (1-100, default 20)',
+                                    default: 20,
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: 'get_canon_status',
+                        description: 'Get entities grouped by their canon status (draft, pending, canon, non-canon, archived)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                status: {
+                                    type: 'string',
+                                    enum: ['draft', 'pending', 'canon', 'non-canon', 'archived'],
+                                    description: 'Filter to specific status',
+                                },
+                                type: {
+                                    type: 'string',
+                                    enum: ['character', 'location', 'event', 'faction', 'lore', 'asset'],
+                                    description: 'Filter by entity type',
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: 'submit_for_review',
+                        description: 'Submit an entity for review, changing its status from draft to pending',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    description: 'Entity ID to submit for review',
+                                },
+                                notes: {
+                                    type: 'string',
+                                    description: 'Optional notes for reviewers',
+                                },
+                            },
+                            required: ['id'],
+                        },
+                    },
+                    {
+                        name: 'validate_consistency',
+                        description: 'Check for consistency issues in the vault (duplicate names, broken links, conflicting data)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    description: 'Specific entity ID to validate, or omit for full vault check',
+                                },
+                                type: {
+                                    type: 'string',
+                                    enum: ['character', 'location', 'event', 'faction', 'lore', 'asset'],
+                                    description: 'Filter validation to specific type',
+                                },
+                            },
+                            required: [],
+                        },
+                    },
                     ...(this.config.comfyui?.enabled ? [
                         {
                             name: 'store_workflow',
@@ -372,6 +476,26 @@ export class HivemindServer {
                         const parsed = StoreAssetArgsSchema.parse(args);
                         return await this.handleStoreAsset(parsed);
                     }
+                    case 'query_asset': {
+                        const parsed = QueryAssetArgsSchema.parse(args);
+                        return await this.handleQueryAsset(parsed);
+                    }
+                    case 'list_assets': {
+                        const parsed = ListAssetsArgsSchema.parse(args);
+                        return await this.handleListAssets(parsed);
+                    }
+                    case 'get_canon_status': {
+                        const parsed = GetCanonStatusArgsSchema.parse(args);
+                        return await this.handleGetCanonStatus(parsed);
+                    }
+                    case 'submit_for_review': {
+                        const parsed = SubmitForReviewArgsSchema.parse(args);
+                        return await this.handleSubmitForReview(parsed);
+                    }
+                    case 'validate_consistency': {
+                        const parsed = ValidateConsistencyArgsSchema.parse(args);
+                        return await this.handleValidateConsistency(parsed);
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -1034,6 +1158,302 @@ File watcher keeps index updated automatically.
                 }],
         };
     }
+    async handleQueryAsset(args) {
+        const asset = this.database.db.prepare(`
+      SELECT * FROM assets WHERE id = ?
+    `).get(args.id);
+        if (!asset) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Asset not found: "${args.id}"`,
+                    }],
+            };
+        }
+        const depicts = asset.depicts ? JSON.parse(asset.depicts) : [];
+        const parameters = asset.parameters ? JSON.parse(asset.parameters) : {};
+        let response = `# Asset: ${asset.id}\n\n`;
+        response += `**Type**: ${asset.asset_type} | **Status**: ${asset.status}\n\n`;
+        response += `## File\n\`${asset.file_path}\`\n\n`;
+        if (depicts.length > 0) {
+            response += `## Depicts\n${depicts.map((d) => `- ${d}`).join('\n')}\n\n`;
+        }
+        if (asset.workflow_id) {
+            response += `## Generation\n`;
+            response += `- **Workflow**: ${asset.workflow_id}\n`;
+            if (asset.prompt)
+                response += `- **Prompt**: ${asset.prompt}\n`;
+            if (Object.keys(parameters).length > 0) {
+                response += `- **Parameters**:\n`;
+                for (const [key, value] of Object.entries(parameters)) {
+                    response += `  - ${key}: ${value}\n`;
+                }
+            }
+            response += `\n`;
+        }
+        response += `## Metadata\n`;
+        response += `- **Created**: ${asset.created}\n`;
+        response += `- **Status**: ${asset.status}\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
+    async handleListAssets(args) {
+        let query = 'SELECT * FROM assets WHERE 1=1';
+        const params = [];
+        if (args.depicts) {
+            query += ` AND depicts LIKE ?`;
+            params.push(`%${args.depicts}%`);
+        }
+        if (args.assetType) {
+            query += ` AND asset_type = ?`;
+            params.push(args.assetType);
+        }
+        if (args.status) {
+            query += ` AND status = ?`;
+            params.push(args.status);
+        }
+        if (args.workflowId) {
+            query += ` AND workflow_id = ?`;
+            params.push(args.workflowId);
+        }
+        query += ` ORDER BY created DESC LIMIT ?`;
+        params.push(args.limit || 20);
+        const assets = this.database.db.prepare(query).all(...params);
+        if (assets.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No assets found matching the specified filters.',
+                    }],
+            };
+        }
+        let response = `# Assets\n\nFound ${assets.length} asset(s):\n\n`;
+        for (const asset of assets) {
+            const depicts = asset.depicts ? JSON.parse(asset.depicts) : [];
+            response += `## ${asset.id}\n`;
+            response += `- **Type**: ${asset.asset_type} | **Status**: ${asset.status}\n`;
+            response += `- **Path**: \`${asset.file_path}\`\n`;
+            if (depicts.length > 0) {
+                response += `- **Depicts**: ${depicts.join(', ')}\n`;
+            }
+            if (asset.workflow_id) {
+                response += `- **Workflow**: ${asset.workflow_id}\n`;
+            }
+            response += `- **Created**: ${asset.created}\n`;
+            response += `\n`;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
+    async handleGetCanonStatus(args) {
+        await this.ensureIndexed();
+        const allNotes = this.vaultReader.getAllNotes();
+        // Group notes by status
+        const byStatus = {
+            draft: [],
+            pending: [],
+            canon: [],
+            'non-canon': [],
+            archived: [],
+        };
+        for (const note of allNotes) {
+            const status = note.frontmatter.status || 'draft';
+            const type = note.frontmatter.type;
+            // Apply filters
+            if (args.status && status !== args.status)
+                continue;
+            if (args.type && type !== args.type)
+                continue;
+            if (byStatus[status]) {
+                byStatus[status].push({
+                    id: note.id,
+                    title: note.frontmatter.title || note.fileName,
+                    type: type,
+                    path: note.filePath,
+                });
+            }
+        }
+        let response = `# Canon Status Overview\n\n`;
+        const statusLabels = {
+            draft: 'Draft (Work in Progress)',
+            pending: 'Pending Review',
+            canon: 'Canon (Approved)',
+            'non-canon': 'Non-Canon',
+            archived: 'Archived',
+        };
+        for (const [status, notes] of Object.entries(byStatus)) {
+            if (args.status && status !== args.status)
+                continue;
+            response += `## ${statusLabels[status]} (${notes.length})\n\n`;
+            if (notes.length === 0) {
+                response += `*No entities*\n\n`;
+            }
+            else {
+                for (const note of notes) {
+                    response += `- **${note.title}** (${note.type}) — \`${note.id}\`\n`;
+                }
+                response += `\n`;
+            }
+        }
+        // Summary
+        const total = Object.values(byStatus).reduce((sum, arr) => sum + arr.length, 0);
+        response += `---\n**Total**: ${total} entities\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
+    async handleSubmitForReview(args) {
+        await this.ensureIndexed();
+        // Find the note
+        const note = this.vaultReader.getAllNotes().find(n => n.id === args.id);
+        if (!note) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Entity not found: "${args.id}"`,
+                    }],
+                isError: true,
+            };
+        }
+        const currentStatus = note.frontmatter.status || 'draft';
+        if (currentStatus !== 'draft') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Cannot submit for review: Entity "${args.id}" is currently "${currentStatus}", not "draft".\n\nOnly draft entities can be submitted for review.`,
+                    }],
+                isError: true,
+            };
+        }
+        // Note: This tool reports what needs to change but doesn't modify files directly.
+        // The user should update the frontmatter manually or use Obsidian.
+        let response = `# Submit for Review: ${note.frontmatter.title || note.fileName}\n\n`;
+        response += `**Entity**: ${args.id}\n`;
+        response += `**Current Status**: ${currentStatus}\n`;
+        response += `**New Status**: pending\n\n`;
+        if (args.notes) {
+            response += `**Review Notes**: ${args.notes}\n\n`;
+        }
+        response += `## Action Required\n\n`;
+        response += `Update the frontmatter in \`${note.filePath}\`:\n\n`;
+        response += `\`\`\`yaml\n`;
+        response += `status: pending\n`;
+        response += `\`\`\`\n\n`;
+        response += `The MCP server will detect the change automatically.\n`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
+    async handleValidateConsistency(args) {
+        await this.ensureIndexed();
+        const allNotes = this.vaultReader.getAllNotes();
+        const issues = [];
+        // Filter notes if specific ID or type requested
+        let notesToCheck = allNotes;
+        if (args.id) {
+            notesToCheck = allNotes.filter(n => n.id === args.id);
+            if (notesToCheck.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Entity not found: "${args.id}"`,
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        if (args.type) {
+            notesToCheck = notesToCheck.filter(n => n.frontmatter.type === args.type);
+        }
+        // Check 1: Duplicate IDs
+        const idCounts = new Map();
+        for (const note of allNotes) {
+            const paths = idCounts.get(note.id) || [];
+            paths.push(note.filePath);
+            idCounts.set(note.id, paths);
+        }
+        for (const [id, paths] of idCounts) {
+            if (paths.length > 1) {
+                issues.push(`**Duplicate ID** \`${id}\` found in:\n${paths.map(p => `  - ${p}`).join('\n')}`);
+            }
+        }
+        // Check 2: Broken wikilinks
+        for (const note of notesToCheck) {
+            for (const link of note.links) {
+                const linkLower = link.toLowerCase();
+                // Check if link resolves to any note
+                const found = allNotes.some(n => n.id === link ||
+                    (n.frontmatter.title || n.fileName).toLowerCase() === linkLower ||
+                    n.fileName.toLowerCase() === linkLower ||
+                    n.fileName.toLowerCase() === linkLower + '.md');
+                if (!found) {
+                    issues.push(`**Broken link** in \`${note.filePath}\`: [[${link}]]`);
+                }
+            }
+        }
+        // Check 3: Missing required fields
+        for (const note of notesToCheck) {
+            if (!note.frontmatter.type) {
+                issues.push(`**Missing type** in \`${note.filePath}\``);
+            }
+            if (!note.frontmatter.id && !note.id) {
+                issues.push(`**Missing ID** in \`${note.filePath}\``);
+            }
+        }
+        // Check 4: Canon entities referencing non-canon
+        const canonNotes = allNotes.filter(n => n.frontmatter.status === 'canon');
+        for (const note of canonNotes) {
+            if (!notesToCheck.includes(note) && !args.id)
+                continue;
+            for (const link of note.links) {
+                const linkedNote = allNotes.find(n => n.id === link ||
+                    (n.frontmatter.title || n.fileName).toLowerCase() === link.toLowerCase());
+                if (linkedNote && linkedNote.frontmatter.status === 'draft') {
+                    issues.push(`**Canon → Draft reference**: \`${note.filePath}\` links to draft entity [[${link}]]`);
+                }
+            }
+        }
+        // Format response
+        let response = `# Consistency Validation\n\n`;
+        if (args.id) {
+            response += `**Checking**: ${args.id}\n\n`;
+        }
+        else if (args.type) {
+            response += `**Checking**: All ${args.type} entities\n\n`;
+        }
+        else {
+            response += `**Checking**: Full vault (${allNotes.length} entities)\n\n`;
+        }
+        if (issues.length === 0) {
+            response += `✅ **No issues found!**\n\nAll checked entities are consistent.`;
+        }
+        else {
+            response += `⚠️ **Found ${issues.length} issue(s)**:\n\n`;
+            for (const issue of issues) {
+                response += `${issue}\n\n`;
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
     async start() {
         // Initial vault scan
         console.error('Performing initial vault scan...');