agent-enderun 0.4.7 → 0.5.1

package/codex.md

@@ -4,4 +4,7 @@ This file is the entry point for Codex. The project's "Supreme Law" and all inst
 
 👉 **[{{FRAMEWORK_DIR}}/ENDERUN.md]({{FRAMEWORK_DIR}}/ENDERUN.md)**
 
-Please read that file thoroughly before taking any action.
+### 🤖 AGENT DIRECTIVE
+You are ALWAYS operating as `@manager` (Team-Lead) by default — on every message, every turn. The user does NOT need to type `@manager`. Typing a specific agent (e.g. `@backend`) explicitly will override this and activate that specialist role directly. You are responsible for analysis and delegation.
+
+Please read the Supreme Law thoroughly before taking any action.

package/cursor.md

@@ -4,4 +4,7 @@ This file is the entry point for Cursor. The project's "Supreme Law" and all ins
 
 👉 **[{{FRAMEWORK_DIR}}/ENDERUN.md]({{FRAMEWORK_DIR}}/ENDERUN.md)**
 
-Please read that file thoroughly before taking any action.
+### 🤖 AGENT DIRECTIVE
+You are ALWAYS operating as `@manager` (Team-Lead) by default — on every message, every turn. The user does NOT need to type `@manager`. Typing a specific agent (e.g. `@backend`) explicitly will override this and activate that specialist role directly. You are responsible for analysis and delegation.
+
+Please read the Supreme Law thoroughly before taking any action.

package/gemini.md

@@ -4,4 +4,7 @@ This file is the entry point for Gemini. The project's "Supreme Law" and all ins
 
 👉 **[{{FRAMEWORK_DIR}}/ENDERUN.md]({{FRAMEWORK_DIR}}/ENDERUN.md)**
 
-Please read that file thoroughly before taking any action.
+### 🤖 AGENT DIRECTIVE
+You are ALWAYS operating as `@manager` (Team-Lead) by default — on every message, every turn. The user does NOT need to type `@manager`. Typing a specific agent (e.g. `@backend`) explicitly will override this and activate that specialist role directly. You are responsible for analysis and delegation.
+
+Please read the Supreme Law thoroughly before taking any action.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "0.4.7",
+  "version": "0.5.1",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -61,22 +61,24 @@
     "enderun:trace": "agent-enderun trace:new",
     "enderun:verify": "agent-enderun verify-contract",
     "enderun:check": "agent-enderun check",
+    "lint": "eslint .",
     "clean": "rm -rf node_modules packages/*/node_modules apps/*/node_modules packages/*/dist apps/*/dist"
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {},
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^22.13.4",
-    "typescript": "^5.9.3",
-    "tsx": "^4.19.4",
-    "vitest": "^3.0.5",
+    "concurrently": "^9.1.2",
     "eslint": "^9.20.1",
-    "concurrently": "^9.1.2"
+    "tsx": "^4.19.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^3.0.5"
   },
   "enderun": {
-    "version": "0.4.7",
+    "version": "0.5.1",
     "initializedAt": "2026-05-09T13:24:27.472Z"
   }
-}
+}

package/packages/framework-mcp/dist/index.js

@@ -2,9 +2,10 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { allTools, allHandlers } from "./tools/index.js";
+import { FRAMEWORK_VERSION } from "./utils.js";
 const server = new Server({
     name: "ai-enderun-mcp",
-    version: "0.3.4",
+    version: FRAMEWORK_VERSION,
 }, {
     capabilities: {
         tools: {},

package/packages/framework-mcp/dist/schemas.js

@@ -29,6 +29,8 @@ export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
     to: z.string().min(1),
     message: z.string().min(1),
     traceId: z.string().min(1),
+    category: z.enum(["ACTION", "DELEGATION", "INFO", "ALERT"]).default("INFO"),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]).default("MEDIUM"),
 });
 export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
     query: z.string().min(1),
@@ -82,3 +84,15 @@ export const GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA = z.object({
     agent: z.string().min(1),
     days: z.number().default(7),
 });
+export const GET_AGENT_INBOX_STATS_ARGS_SCHEMA = z.object({
+    agent: z.string().min(1),
+});
+export const GET_KNOWLEDGE_GRAPH_ARGS_SCHEMA = z.object({
+    tag: z.string().optional(),
+});
+export const SYNC_CONTRACT_HASH_ARGS_SCHEMA = z.object({
+    force: z.boolean().default(false),
+});
+export const VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA = z.object({
+    detailed: z.boolean().default(false),
+});

package/packages/framework-mcp/dist/tools/framework.js

@@ -1,6 +1,8 @@
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 import { getFrameworkDir, collectMarkdownArtifacts, FRAMEWORK_VERSION } from "../utils.js";
+import { VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA } from "../schemas.js";
 export const frameworkTools = [
     {
         name: "get_framework_status",
@@ -37,6 +39,16 @@ export const frameworkTools = [
         description: "Analyzes a pre-existing codebase to automatically generate the initial project memory, learning its tech stack and architecture.",
         inputSchema: { type: "object", properties: {} },
     },
+    {
+        name: "verify_framework_health",
+        description: "Runs the framework's internal 'check' command and reports system health status via MCP.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                detailed: { type: "boolean", default: false, description: "Include detailed issues if any." },
+            },
+        },
+    },
 ];
 export const frameworkHandlers = {
     bootstrap_legacy_memory: async (args, projectRoot) => {
@@ -158,4 +170,17 @@ export const frameworkHandlers = {
     get_system_time: async () => {
         return { content: [{ type: "text", text: new Date().toISOString() }] };
     },
+    verify_framework_health: async (args, projectRoot) => {
+        const parsed = VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA.safeParse(args ?? {});
+        try {
+            // Run the internal CLI check command via tsx to ensure we test current state
+            // If the CLI is not yet linked, we might need a relative path
+            const cliPath = path.join(projectRoot, "bin/cli.js");
+            const output = execSync(`node ${cliPath} check`, { cwd: projectRoot, encoding: "utf-8", stdio: "pipe" });
+            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK\n\n${output}` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (FAILED)\n\n${error.stdout || error.message}` }] };
+        }
+    }
 };

package/packages/framework-mcp/dist/tools/knowledge.js

@@ -5,28 +5,52 @@ import { SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA, UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA }
 export const knowledgeTools = [
     {
         name: "search_knowledge_base",
-        description: "Searches the Academy's internal knowledge base for architectural patterns, troubleshooting guides, and FAQs.",
+        description: "Searches the Academy's Obsidian-style knowledge base using keywords or tags.",
         inputSchema: {
             type: "object",
             properties: {
-                query: { type: "string", description: "Search query or topic" },
+                query: { type: "string", description: "Search query, topic, or tag (e.g. #security)" },
             },
             required: ["query"],
         },
     },
     {
         name: "update_knowledge_base",
-        description: "Adds or updates an entry in the Academy's internal knowledge base.",
+        description: "Adds or updates an entry with mandatory YAML frontmatter for Obsidian compatibility.",
         inputSchema: {
             type: "object",
             properties: {
-                topic: { type: "string", description: "The topic or title of the entry" },
-                content: { type: "string", description: "The technical content or guide" },
+                topic: { type: "string", description: "The topic or title" },
+                content: { type: "string", description: "Content (YAML frontmatter will be auto-generated if missing)" },
+                tags: { type: "array", items: { type: "string" }, description: "Tags for the entry" },
             },
             required: ["topic", "content"],
         },
     },
+    {
+        name: "get_knowledge_graph",
+        description: "Generates a Mermaid diagram showing relationships between knowledge entries based on 'related' metadata.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tag: { type: "string", description: "Filter by tag" },
+            },
+        },
+    },
 ];
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return { metadata: {}, body: content };
+    const yaml = match[1];
+    const metadata = {};
+    yaml.split("\n").forEach(line => {
+        const [key, ...val] = line.split(":");
+        if (key && val.length > 0)
+            metadata[key.trim()] = val.join(":").trim();
+    });
+    return { metadata, body: content.replace(match[0], "").trim() };
+}
 export const knowledgeHandlers = {
     search_knowledge_base: async (args, projectRoot) => {
         const parsed = SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
@@ -37,14 +61,20 @@ export const knowledgeHandlers = {
             const kbDir = path.join(projectRoot, frameworkDir, "knowledge");
             if (!fs.existsSync(kbDir))
                 return { content: [{ type: "text", text: "Knowledge base is empty." }] };
+            const query = parsed.data.query.toLowerCase();
             const results = fs.readdirSync(kbDir).filter(f => f.endsWith(".md")).map(file => {
                 const content = fs.readFileSync(path.join(kbDir, file), "utf-8");
-                if (content.toLowerCase().includes(parsed.data.query.toLowerCase()) || file.toLowerCase().includes(parsed.data.query.toLowerCase())) {
-                    return `### ${file.replace(".md", "")}\n\n${content.slice(0, 300)}...`;
+                const { metadata, body } = parseFrontmatter(content);
+                const matchesQuery = body.toLowerCase().includes(query) ||
+                    file.toLowerCase().includes(query) ||
+                    (metadata.tags && metadata.tags.toLowerCase().includes(query)) ||
+                    (metadata.title && metadata.title.toLowerCase().includes(query));
+                if (matchesQuery) {
+                    return `### ${metadata.title || file.replace(".md", "")}\n**Tags:** ${metadata.tags || "None"}\n\n${body.slice(0, 300)}...`;
                 }
                 return null;
             }).filter(Boolean);
-            return { content: [{ type: "text", text: results.length > 0 ? `### KNOWLEDGE BASE SEARCH RESULTS\n\n${results.join("\n\n---\n\n")}` : "No matching knowledge base entries found." }] };
+            return { content: [{ type: "text", text: results.length > 0 ? `### KNOWLEDGE BASE SEARCH RESULTS\n\n${results.join("\n\n---\n\n")}` : "No matching knowledge entries found." }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: "Knowledge base search failed." }] };
@@ -53,17 +83,51 @@ export const knowledgeHandlers = {
     update_knowledge_base: async (args, projectRoot) => {
         const parsed = UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
         if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid topic or content." }] };
+            return { content: [{ type: "text", text: "Invalid arguments." }] };
         try {
             const frameworkDir = getFrameworkDir(projectRoot);
             const kbDir = path.join(projectRoot, frameworkDir, "knowledge");
             if (!fs.existsSync(kbDir))
                 fs.mkdirSync(kbDir, { recursive: true });
-            fs.writeFileSync(path.join(kbDir, parsed.data.topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md"), parsed.data.content);
-            return { content: [{ type: "text", text: `Knowledge base updated: ${parsed.data.topic}` }] };
+            const fileName = parsed.data.topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md";
+            const tags = parsed.data.tags || [];
+            let finalContent = parsed.data.content;
+            if (!finalContent.startsWith("---")) {
+                const frontmatter = `---\ntitle: ${parsed.data.topic}\ntags: [${tags.join(", ")}]\nlast_updated: ${new Date().toISOString()}\n---\n\n`;
+                finalContent = frontmatter + finalContent;
+            }
+            fs.writeFileSync(path.join(kbDir, fileName), finalContent);
+            return { content: [{ type: "text", text: `Obsidian Wiki updated: ${parsed.data.topic}` }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: "Failed to update knowledge base." }] };
         }
     },
+    get_knowledge_graph: async (args, projectRoot) => {
+        try {
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const kbDir = path.join(projectRoot, frameworkDir, "knowledge");
+            if (!fs.existsSync(kbDir))
+                return { content: [{ type: "text", text: "Knowledge base empty." }] };
+            const files = fs.readdirSync(kbDir).filter(f => f.endsWith(".md"));
+            let mermaid = "graph TD\n";
+            files.forEach(file => {
+                const content = fs.readFileSync(path.join(kbDir, file), "utf-8");
+                const { metadata } = parseFrontmatter(content);
+                const id = file.replace(".md", "");
+                const label = metadata.title || id;
+                mermaid += `  ${id}["${label}"]\n`;
+                if (metadata.related) {
+                    const related = metadata.related.replace(/[\[\]]/g, "").split(",");
+                    related.forEach((r) => {
+                        mermaid += `  ${id} --> ${r.trim().replace(".md", "")}\n`;
+                    });
+                }
+            });
+            return { content: [{ type: "text", text: `### KNOWLEDGE GRAPH (Mermaid)\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: "Failed to generate knowledge graph." }] };
+        }
+    }
 };

package/packages/framework-mcp/dist/tools/memory.js

@@ -57,7 +57,9 @@ export const memoryHandlers = {
                         updated = true;
                         break;
                     }
-                    catch (e) { }
+                    catch (e) {
+                        // Ignore section not found
+                    }
                 }
                 if (!updated)
                     throw new Error("HISTORY section not found.");

package/packages/framework-mcp/dist/tools/messages.js

@@ -1,28 +1,42 @@
 import fs from "fs";
 import path from "path";
 import { getFrameworkDir } from "../utils.js";
-import { SEND_AGENT_MESSAGE_ARGS_SCHEMA, READ_AGENT_MESSAGES_ARGS_SCHEMA } from "../schemas.js";
+import { SEND_AGENT_MESSAGE_ARGS_SCHEMA, READ_AGENT_MESSAGES_ARGS_SCHEMA, GET_AGENT_INBOX_STATS_ARGS_SCHEMA } from "../schemas.js";
 export const messageTools = [
     {
         name: "send_agent_message",
-        description: "Sends a message to another specialized agent. Useful for collaboration and delegation.",
+        description: "Sends a message to another specialized agent following the Hermes Protocol.",
         inputSchema: {
             type: "object",
             properties: {
                 to: { type: "string", description: "Recipient agent name" },
                 message: { type: "string", description: "The message content" },
                 traceId: { type: "string", description: "The active Trace ID" },
+                category: { type: "string", enum: ["ACTION", "DELEGATION", "INFO", "ALERT"], default: "INFO" },
+                priority: { type: "string", enum: ["LOW", "MEDIUM", "HIGH", "URGENT"], default: "MEDIUM" },
             },
             required: ["to", "message", "traceId"],
         },
     },
     {
         name: "read_agent_messages",
-        description: "Reads messages sent to the current agent.",
+        description: "Reads messages sent to the current agent. Filters by Trace ID if provided.",
         inputSchema: {
             type: "object",
             properties: {
                 agent: { type: "string", description: "Current agent name reading their messages" },
+                traceId: { type: "string", description: "Optional Trace ID to filter messages" },
+            },
+            required: ["agent"],
+        },
+    },
+    {
+        name: "get_agent_inbox_stats",
+        description: "Returns statistics about the agent's inbox (total, unread, priority distribution).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "Agent name" },
             },
             required: ["agent"],
         },
@@ -40,13 +54,21 @@ export const messageHandlers = {
             if (!fs.existsSync(messagesDir))
                 fs.mkdirSync(messagesDir, { recursive: true });
             const messagePath = path.join(messagesDir, `${recipient}.json`);
-            let messages = fs.existsSync(messagePath) ? JSON.parse(fs.readFileSync(messagePath, "utf-8")) : [];
-            messages.push({ timestamp: new Date().toISOString(), from: "manager", traceId: parsed.data.traceId, content: parsed.data.message, read: false });
+            const messages = (fs.existsSync(messagePath) ? JSON.parse(fs.readFileSync(messagePath, "utf-8")) : []);
+            messages.push({
+                timestamp: new Date().toISOString(),
+                from: "manager",
+                traceId: parsed.data.traceId,
+                category: parsed.data.category,
+                priority: parsed.data.priority,
+                content: parsed.data.message,
+                read: false
+            });
             fs.writeFileSync(messagePath, JSON.stringify(messages, null, 2));
-            return { content: [{ type: "text", text: `Message sent to @${recipient}.` }] };
+            return { content: [{ type: "text", text: `Hermes: Message sent to @${recipient} [${parsed.data.category} | ${parsed.data.priority}].` }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: "Failed to send message." }] };
+            return { content: [{ type: "text", text: "Failed to send message via Hermes." }] };
         }
     },
     read_agent_messages: async (args, projectRoot) => {
@@ -61,11 +83,42 @@ export const messageHandlers = {
                 return { content: [{ type: "text", text: "No messages found." }] };
             const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8"));
             const unread = messages.filter((m) => !m.read);
+            // Mark as read
             fs.writeFileSync(messagePath, JSON.stringify(messages.map((m) => ({ ...m, read: true })), null, 2));
-            return { content: [{ type: "text", text: unread.length === 0 ? "No new messages." : `### INBOX: @${agentName}\n\n` + unread.map((m) => `- **From:** ${m.from}\n  **Message:** ${m.content}`).join("\n\n") }] };
+            if (unread.length === 0)
+                return { content: [{ type: "text", text: "No new messages." }] };
+            const formatted = unread.map((m) => `- [${m.priority}] **${m.from}** (${m.category}): ${m.content} *(Trace: ${m.traceId})*`).join("\n");
+            return { content: [{ type: "text", text: `### HERMES INBOX: @${agentName}\n\n${formatted}` }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: "Failed to read messages." }] };
         }
     },
+    get_agent_inbox_stats: async (args, projectRoot) => {
+        const parsed = GET_AGENT_INBOX_STATS_ARGS_SCHEMA.safeParse(args ?? {});
+        if (!parsed.success)
+            return { content: [{ type: "text", text: "Invalid agent name." }] };
+        try {
+            const frameworkDir = getFrameworkDir(projectRoot);
+            const agentName = parsed.data.agent.replace(/^@/, "");
+            const messagePath = path.join(projectRoot, frameworkDir, "messages", `${agentName}.json`);
+            if (!fs.existsSync(messagePath))
+                return { content: [{ type: "text", text: "Inbox empty." }] };
+            const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8"));
+            const unread = messages.filter(m => !m.read);
+            const priorityDist = messages.reduce((acc, m) => {
+                acc[m.priority] = (acc[m.priority] || 0) + 1;
+                return acc;
+            }, {});
+            return {
+                content: [{
+                        type: "text",
+                        text: `### INBOX STATS: @${agentName}\n- Total: ${messages.length}\n- Unread: ${unread.length}\n- Priority Distribution: ${JSON.stringify(priorityDist)}`
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: "Failed to get inbox stats." }] };
+        }
+    }
 };

package/packages/framework-mcp/dist/tools/repository.js

@@ -62,8 +62,12 @@ export const repositoryHandlers = {
                 if (relativePath.includes("node_modules") || relativePath.includes("dist"))
                     continue;
                 sourceFile.getExportedDeclarations().forEach((declarations, name) => {
-                    declarations.forEach(decl => { if (typeof decl.getJsDocs === "function" && decl.getJsDocs().length === 0)
-                        missingJSDoc.push(`${relativePath} -> ${name}`); });
+                    declarations.forEach(decl => {
+                        const d = decl;
+                        if (typeof d.getJsDocs === "function" && d.getJsDocs().length === 0) {
+                            missingJSDoc.push(`${relativePath} -> ${name}`);
+                        }
+                    });
                 });
             }
             const majorDirs = ["apps/backend", "apps/web", "packages/shared-types", "packages/framework-mcp"], missingREADME = majorDirs.filter(dir => fs.existsSync(path.join(projectRoot, dir)) && !fs.existsSync(path.join(projectRoot, dir, "README.md")));

package/packages/framework-mcp/dist/utils.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-export const FRAMEWORK_VERSION = "0.3.4";
+export const FRAMEWORK_VERSION = "0.5.1";
 export function getFrameworkDir(projectRoot) {
     const adapters = [".gemini", ".claude", ".cursor", ".codex", ".enderun"];
     for (const adp of adapters) {
@@ -71,7 +71,7 @@ export function collectMarkdownArtifacts(projectRoot) {
 }
 export function replaceSectionContent(markdown, sectionTitle, newBody) {
     const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`, "m");
+    const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`);
     if (!sectionRegex.test(markdown)) {
         throw new Error(`Section not found: ${sectionTitle}`);
     }
@@ -79,7 +79,7 @@ export function replaceSectionContent(markdown, sectionTitle, newBody) {
 }
 export function prependToSection(markdown, sectionTitle, contentToPrepend) {
     const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`(## ${escaped}\\n)([\\s\\S]*?)(?=\\n## |$)`, "m");
+    const sectionRegex = new RegExp(`(## ${escaped}\\n)([\\s\\S]*?)(?=\\n## |$)`);
     const match = markdown.match(sectionRegex);
     if (!match) {
         throw new Error(`Section not found: ${sectionTitle}`);

package/packages/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-enderun-mcp",
-  "version": "0.4.7",
+  "version": "0.5.1",
   "description": "Enterprise-grade MCP Server for AI Agent Framework",
   "author": "Yusuf BEKAR",
   "license": "MIT",

package/packages/framework-mcp/src/index.ts

@@ -2,10 +2,11 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { allTools, allHandlers } from "./tools/index.js";
+import { FRAMEWORK_VERSION } from "./utils.js";
 
 const server = new Server({
     name: "ai-enderun-mcp",
-    version: "0.3.4",
+    version: FRAMEWORK_VERSION,
 }, {
     capabilities: {
         tools: {},

package/packages/framework-mcp/src/schemas.ts

@@ -35,6 +35,8 @@ export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
     to: z.string().min(1),
     message: z.string().min(1),
     traceId: z.string().min(1),
+    category: z.enum(["ACTION", "DELEGATION", "INFO", "ALERT"]).default("INFO"),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]).default("MEDIUM"),
 });
 
 export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
@@ -104,3 +106,19 @@ export const GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA = z.object({
     agent: z.string().min(1),
     days: z.number().default(7),
 });
+
+export const GET_AGENT_INBOX_STATS_ARGS_SCHEMA = z.object({
+    agent: z.string().min(1),
+});
+
+export const GET_KNOWLEDGE_GRAPH_ARGS_SCHEMA = z.object({
+    tag: z.string().optional(),
+});
+
+export const SYNC_CONTRACT_HASH_ARGS_SCHEMA = z.object({
+    force: z.boolean().default(false),
+});
+
+export const VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA = z.object({
+    detailed: z.boolean().default(false),
+});

package/packages/framework-mcp/src/tools/academy.ts

@@ -89,8 +89,14 @@ export const academyTools = [
     },
 ];
 
+interface AgentLog {
+    timestamp: string;
+    status: string;
+    [key: string]: unknown;
+}
+
 export const academyHandlers = {
-    get_academy_performance: async (args: any, projectRoot: string) => {
+    get_academy_performance: async (args: unknown, projectRoot: string) => {
         const parsed = GET_ACADEMY_PERFORMANCE_ARGS_SCHEMA.safeParse(args ?? {});
         const days = parsed.success ? parsed.data.periodDays : 30;
         try {
@@ -100,8 +106,8 @@ export const academyHandlers = {
             const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
             let totalActions = 0, totalSuccess = 0;
             const agentStats = fs.readdirSync(logsDir).filter(f => f.endsWith(".json")).map(file => {
-                const logs = JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8")).filter((l: any) => new Date(l.timestamp) >= cutoff);
-                const success = logs.filter((l: any) => l.status === "SUCCESS").length;
+                const logs = (JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8")) as AgentLog[]).filter((l) => new Date(l.timestamp) >= cutoff);
+                const success = logs.filter((l) => l.status === "SUCCESS").length;
                 totalActions += logs.length; totalSuccess += success;
                 return { agent: file.replace(".json", ""), actions: logs.length, successRate: (success / (logs.length || 1)) * 100 };
             }).filter(s => s.actions > 0);
@@ -110,15 +116,15 @@ export const academyHandlers = {
             return { content: [{ type: "text", text: "Failed to generate global performance report." }] };
         }
     },
-    generate_strategic_briefing: async (args: any, projectRoot: string) => {
+    generate_strategic_briefing: async (args: unknown, projectRoot: string) => {
         try {
             const frameworkDir = getFrameworkDir(projectRoot);
             const logsDir = path.join(projectRoot, frameworkDir, "logs");
             let totalActions = 0, successCount = 0;
             if (fs.existsSync(logsDir)) {
                 fs.readdirSync(logsDir).filter(f => f.endsWith(".json")).forEach(file => {
-                    const logs = JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8"));
-                    totalActions += logs.length; successCount += logs.filter((l: any) => l.status === "SUCCESS").length;
+                    const logs = JSON.parse(fs.readFileSync(path.join(logsDir, file), "utf-8")) as AgentLog[];
+                    totalActions += logs.length; successCount += logs.filter((l) => l.status === "SUCCESS").length;
                 });
             }
             const successRate = (successCount / (totalActions || 1)) * 100;
@@ -127,7 +133,7 @@ export const academyHandlers = {
             return { content: [{ type: "text", text: "Strategic briefing generation failed." }] };
         }
     },
-    generate_academy_progress_report: async (args: any, projectRoot: string) => {
+    generate_academy_progress_report: async (args: unknown, projectRoot: string) => {
         const parsed = GENERATE_ACADEMY_PROGRESS_REPORT_ARGS_SCHEMA.safeParse(args ?? {});
         const days = parsed.success ? parsed.data.days : 7;
         try {
@@ -141,7 +147,7 @@ export const academyHandlers = {
             return { content: [{ type: "text", text: "Failed to generate progress report." }] };
         }
     },
-    get_agent_audit_report: async (args: any, projectRoot: string) => {
+    get_agent_audit_report: async (args: unknown, projectRoot: string) => {
         const parsed = GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA.safeParse(args ?? {});
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid agent or days argument." }] };
         try {
@@ -149,14 +155,14 @@ export const academyHandlers = {
             const logPath = path.join(projectRoot, frameworkDir, "logs", `${parsed.data.agent}.json`);
             if (!fs.existsSync(logPath)) return { content: [{ type: "text", text: `No logs found for agent: ${parsed.data.agent}` }] };
             const cutoff = new Date(Date.now() - parsed.data.days * 24 * 60 * 60 * 1000);
-            const logs = JSON.parse(fs.readFileSync(logPath, "utf-8")).filter((l: any) => new Date(l.timestamp) >= cutoff);
-            const successCount = logs.filter((l: any) => l.status === "SUCCESS").length;
+            const logs = (JSON.parse(fs.readFileSync(logPath, "utf-8")) as AgentLog[]).filter((l) => new Date(l.timestamp) >= cutoff);
+            const successCount = logs.filter((l) => l.status === "SUCCESS").length;
             return { content: [{ type: "text", text: `### AGENT AUDIT REPORT: ${parsed.data.agent.toUpperCase()}\n\n- **Total Actions:** ${logs.length}\n- **Success Rate:** ${((successCount / (logs.length || 1)) * 100).toFixed(1)}%` }] };
         } catch (error) {
             return { content: [{ type: "text", text: "Failed to generate audit report." }] };
         }
     },
-    log_agent_action: async (args: any, projectRoot: string) => {
+    log_agent_action: async (args: unknown, projectRoot: string) => {
         const parsed = LOG_AGENT_ACTION_ARGS_SCHEMA.safeParse(args ?? {});
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid arguments for log_agent_action." }] };
         try {

package/packages/framework-mcp/src/tools/codebase.ts

@@ -134,7 +134,7 @@ export const codebaseTools = [
 ];
 
 export const codebaseHandlers = {
-    search_codebase: async (args: any, projectRoot: string) => {
+    search_codebase: async (args: unknown, projectRoot: string) => {
         const parsed = SEARCH_CODEBASE_ARGS_SCHEMA.safeParse(args);
         if (!parsed.success) {
             return { content: [{ type: "text", text: "Invalid query/extension argument." }] };
@@ -168,7 +168,7 @@ export const codebaseHandlers = {
             return { content: [{ type: "text", text: "Search failed." }] };
         }
     },
-    analyze_dependencies: async (args: any, projectRoot: string) => {
+    analyze_dependencies: async (args: unknown, projectRoot: string) => {
         const parsed = ANALYZE_DEPENDENCIES_ARGS_SCHEMA.safeParse(args);
         if (!parsed.success) {
             return { content: [{ type: "text", text: "Invalid path argument." }] };
@@ -198,7 +198,7 @@ export const codebaseHandlers = {
             return { content: [{ type: "text", text: "Analysis failed: " + (error instanceof Error ? error.message : String(error)) }] };
         }
     },
-    analyze_codebase_intelligence: async (args: any, projectRoot: string) => {
+    analyze_codebase_intelligence: async (args: unknown, projectRoot: string) => {
         const parsed = ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA.safeParse(args);
         const targetPath = parsed.success ? parsed.data.path : ".";
         try {
@@ -227,7 +227,7 @@ export const codebaseHandlers = {
             return { content: [{ type: "text", text: "Intelligence scan failed." }] };
         }
     },
-    analyze_procedural_continuity: async (args: any, projectRoot: string) => {
+    analyze_procedural_continuity: async (args: unknown, projectRoot: string) => {
         const parsed = ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA.safeParse(args);
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid targetPath or referencePath." }] };
         try {
@@ -251,7 +251,7 @@ export const codebaseHandlers = {
             return { content: [{ type: "text", text: "Continuity analysis failed." }] };
         }
     },
-    generate_dependency_graph: async (args: any, projectRoot: string) => {
+    generate_dependency_graph: async (args: unknown, projectRoot: string) => {
         const parsed = GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA.safeParse(args);
         const targetPath = parsed.success ? parsed.data.path : "src";
         const format = parsed.success ? parsed.data.format : "mermaid";