agent-enderun 0.5.0 → 0.5.2

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

@@ -1,8 +1,8 @@
 import path from "path";
 import fs from "fs";
-export const FRAMEWORK_VERSION = "0.5.0";
+export const FRAMEWORK_VERSION = "0.5.2";
 export function getFrameworkDir(projectRoot) {
-    const adapters = [".gemini", ".claude", ".cursor", ".codex", ".enderun"];
+    const adapters = [".gemini", ".claude", ".cursor", ".enderun", ".codex"];
     for (const adp of adapters) {
         const fullPath = path.join(projectRoot, adp);
         if (fs.existsSync(fullPath) && fs.lstatSync(fullPath).isDirectory()) {

package/packages/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-enderun-mcp",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Enterprise-grade MCP Server for AI Agent Framework",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "npx tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts"
   },

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({
@@ -44,6 +46,7 @@ export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
 export const UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
     topic: z.string().min(1),
     content: z.string().min(1),
+    tags: z.array(z.string().min(1)).default([]),
 });
 
 export const ANALYZE_DATABASE_SCHEMA_ARGS_SCHEMA = z.object({
@@ -77,6 +80,7 @@ export const VALIDATE_REPOSITORY_HEALTH_ARGS_SCHEMA = z.object({
 
 export const READ_AGENT_MESSAGES_ARGS_SCHEMA = z.object({
     agent: z.string().min(1),
+    traceId: z.string().min(1).optional(),
 });
 
 export const VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA = z.object({
@@ -104,3 +108,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/contract.ts

@@ -8,6 +8,18 @@ import {
 } from "../utils.js";
 import { VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA } from "../schemas.js";
 
+function calculateContractHash(sharedTypesDir: string, projectRoot: string): string {
+    const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
+    const hash = crypto.createHash("sha256");
+    files.forEach((filePath) => {
+        hash.update(path.relative(projectRoot, filePath));
+        hash.update("\0");
+        hash.update(fs.readFileSync(filePath));
+        hash.update("\0");
+    });
+    return hash.digest("hex");
+}
+
 export const contractTools = [
     {
         name: "verify_api_contract",
@@ -41,10 +53,7 @@ export const contractHandlers = {
             const sharedTypesDir = path.join(projectRoot, "packages/shared-types/src");
             const contractJsonPath = path.join(projectRoot, "packages/shared-types/contract.version.json");
             if (!fs.existsSync(sharedTypesDir) || !fs.existsSync(contractJsonPath)) return { content: [{ type: "text", text: "Missing shared-types directory or contract.version.json" }] };
-            const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
-            const hash = crypto.createHash("sha256");
-            files.forEach(f => hash.update(fs.readFileSync(f)));
-            const currentHash = hash.digest("hex");
+            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
             const storedHash = JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")).contract_hash;
             return { content: [{ type: "text", text: currentHash === storedHash ? "✅ MATCH: Contract is valid and synchronized." : `❌ MISMATCH: Current hash (${currentHash.slice(0, 8)}...) does not match stored hash (${storedHash.slice(0, 8)}...).` }] };
         } catch (error) {
@@ -58,9 +67,7 @@ export const contractHandlers = {
             if (!fs.existsSync(sharedTypesDir)) return { content: [{ type: "text", text: "Missing shared-types directory" }] };
             const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
             if (files.length === 0) return { content: [{ type: "text", text: "⚠️ WARNING: No TypeScript files found in shared-types/src. Hash not updated." }] };
-            const hash = crypto.createHash("sha256");
-            files.forEach(f => hash.update(fs.readFileSync(f)));
-            const currentHash = hash.digest("hex");
+            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
             const contractJson = fs.existsSync(contractJsonPath) ? JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")) : {};
             contractJson.contract_hash = currentHash;
             contractJson.last_updated = new Date().toISOString();

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

@@ -1,10 +1,12 @@
 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 = [
     {
@@ -42,6 +44,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 = {
@@ -154,4 +166,16 @@ export const frameworkHandlers = {
     get_system_time: async () => {
         return { content: [{ type: "text", text: new Date().toISOString() }] };
     },
+    verify_framework_health: async (args: unknown, projectRoot: string) => {
+        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: any) {
+            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (FAILED)\n\n${error.stdout || error.message}` }] };
+        }
+    }
 };

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

@@ -3,35 +3,59 @@ import path from "path";
 import { getFrameworkDir } from "../utils.js";
 import { 
     SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA, 
-    UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA 
+    UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA,
+    GET_KNOWLEDGE_GRAPH_ARGS_SCHEMA
 } from "../schemas.js";
 
 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: string) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return { metadata: {}, body: content };
+    const yaml = match[1];
+    const metadata: Record<string, any> = {};
+    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: unknown, projectRoot: string) => {
         const parsed = SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
@@ -40,29 +64,79 @@ export const knowledgeHandlers = {
             const frameworkDir = getFrameworkDir(projectRoot);
             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." }] };
         }
     },
     update_knowledge_base: async (args: unknown, projectRoot: string) => {
         const parsed = UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success) return { content: [{ type: "text", text: "Invalid topic or content." }] };
+        if (!parsed.success) 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: unknown, projectRoot: string) => {
+        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: string) => {
+                        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/src/tools/messages.ts

@@ -3,30 +3,45 @@ import path from "path";
 import { getFrameworkDir } from "../utils.js";
 import { 
     SEND_AGENT_MESSAGE_ARGS_SCHEMA, 
-    READ_AGENT_MESSAGES_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"],
         },
@@ -37,26 +52,42 @@ interface Message {
     timestamp: string;
     from: string;
     traceId: string;
+    category: "ACTION" | "DELEGATION" | "INFO" | "ALERT";
+    priority: "LOW" | "MEDIUM" | "HIGH" | "URGENT";
     content: string;
     read: boolean;
 }
 
+function normalizeAgentName(agent: string): string | null {
+    const normalized = agent.replace(/^@/, "").trim();
+    return /^[a-z0-9_-]+$/i.test(normalized) ? normalized : null;
+}
+
 export const messageHandlers = {
     send_agent_message: async (args: unknown, projectRoot: string) => {
         const parsed = SEND_AGENT_MESSAGE_ARGS_SCHEMA.safeParse(args ?? {});
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid message arguments." }] };
         try {
             const frameworkDir = getFrameworkDir(projectRoot);
-            const recipient = parsed.data.to.replace(/^@/, "");
+            const recipient = normalizeAgentName(parsed.data.to);
+            if (!recipient) return { content: [{ type: "text", text: "Invalid recipient agent name." }] };
             const messagesDir = path.join(projectRoot, frameworkDir, "messages");
             if (!fs.existsSync(messagesDir)) fs.mkdirSync(messagesDir, { recursive: true });
             const messagePath = path.join(messagesDir, `${recipient}.json`);
             const messages = (fs.existsSync(messagePath) ? JSON.parse(fs.readFileSync(messagePath, "utf-8")) : []) as Message[];
-            messages.push({ timestamp: new Date().toISOString(), from: "manager", traceId: parsed.data.traceId, content: parsed.data.message, read: false });
+            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: unknown, projectRoot: string) => {
@@ -64,15 +95,53 @@ export const messageHandlers = {
         if (!parsed.success) return { content: [{ type: "text", text: "Invalid agent name." }] };
         try {
             const frameworkDir = getFrameworkDir(projectRoot);
-            const agentName = parsed.data.agent.replace(/^@/, "");
+            const agentName = normalizeAgentName(parsed.data.agent);
+            if (!agentName) return { content: [{ type: "text", text: "Invalid agent name." }] };
             const messagePath = path.join(projectRoot, frameworkDir, "messages", `${agentName}.json`);
             if (!fs.existsSync(messagePath)) return { content: [{ type: "text", text: "No messages found." }] };
             const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8")) as Message[];
-            const unread = messages.filter((m) => !m.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") }] };
+            const unread = messages.filter((m) => !m.read && (!parsed.data.traceId || m.traceId === parsed.data.traceId));
+            
+            fs.writeFileSync(messagePath, JSON.stringify(messages.map((m) => (
+                !m.read && (!parsed.data.traceId || m.traceId === parsed.data.traceId) ? { ...m, read: true } : m
+            )), null, 2));
+            
+            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: unknown, projectRoot: string) => {
+        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 = normalizeAgentName(parsed.data.agent);
+            if (!agentName) return { content: [{ type: "text", text: "Invalid agent name." }] };
+            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")) as Message[];
+            const unread = messages.filter(m => !m.read);
+            
+            const priorityDist = messages.reduce((acc, m) => {
+                acc[m.priority] = (acc[m.priority] || 0) + 1;
+                return acc;
+            }, {} as Record<string, number>);
+
+            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/src/tools/repository.ts

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { execSync } from "child_process";
+import { spawnSync } from "child_process";
 import { Project } from "ts-morph";
 import { 
     resolveSafePath, 
@@ -42,12 +42,33 @@ export const repositoryHandlers = {
             const pkgPath = path.join(projectRoot, "package.json");
             if (!fs.existsSync(pkgPath)) return { content: [{ type: "text", text: "package.json not found." }] };
             const scripts = JSON.parse(fs.readFileSync(pkgPath, "utf-8")).scripts || {};
-            const runScript = (name: string) => scripts[name] ? { name, status: (execSync(`npm run ${name}`, { stdio: "pipe", cwd: projectRoot }) ? "PASSED" : "FAILED") } : { name, status: "SKIPPED" };
+            const scriptCandidates: Record<string, string[]> = {
+                lint: ["lint", "enderun:lint"],
+                test: ["test", "enderun:test"],
+                build: ["build", "enderun:build"],
+            };
+            const runScript = (name: string) => {
+                const scriptName = scriptCandidates[name].find((candidate) => scripts[candidate]);
+                if (!scriptName) return { name, script: "-", status: "SKIPPED", details: "No matching script found." };
+
+                const result = spawnSync("npm", ["run", scriptName], {
+                    cwd: projectRoot,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                const output = `${result.stdout || ""}${result.stderr || ""}`.trim();
+                return {
+                    name,
+                    script: scriptName,
+                    status: result.status === 0 ? "PASSED" : "FAILED",
+                    details: output.split("\n").slice(-5).join("\n"),
+                };
+            };
             const results = [];
             if (scope === "full" || scope === "lint") results.push(runScript("lint"));
             if (scope === "full" || scope === "test") results.push(runScript("test"));
             if (scope === "full" || scope === "build") results.push(runScript("build"));
-            return { content: [{ type: "text", text: `### REPOSITORY HEALTH REPORT\n\n` + results.map(r => `- **${r.name.toUpperCase()}:** ${r.status}`).join("\n") }] };
+            return { content: [{ type: "text", text: `### REPOSITORY HEALTH REPORT\n\n` + results.map(r => `- **${r.name.toUpperCase()}** (${r.script}): ${r.status}${r.status === "FAILED" && r.details ? `\n  ${r.details}` : ""}`).join("\n") }] };
         } catch (error) {
             return { content: [{ type: "text", text: "Health validation failed." }] };
         }

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

@@ -1,10 +1,10 @@
 import path from "path";
 import fs from "fs";
 
-export const FRAMEWORK_VERSION = "0.5.0";
+export const FRAMEWORK_VERSION = "0.5.2";
 
 export function getFrameworkDir(projectRoot: string): string {
-    const adapters = [".gemini", ".claude", ".cursor", ".codex", ".enderun"];
+    const adapters = [".gemini", ".claude", ".cursor", ".enderun", ".codex"];
     for (const adp of adapters) {
         const fullPath = path.join(projectRoot, adp);
         if (fs.existsSync(fullPath) && fs.lstatSync(fullPath).isDirectory()) {

package/packages/shared-types/contract.version.json

@@ -1,9 +1,12 @@
 {
   "version": "0.1.11",
-  "last_updated": "2026-05-11T13:45:00Z",
-  "contract_hash": "a8ff433521ce2d7e249d67e84ae8ef0e54082260195b672789ef7a48a9a1e35a",
+  "last_updated": "2026-05-16T16:47:16.000Z",
+  "contract_hash": "8574144a23e68351f48365f5ccb3d69dc11629af54ec9c1ed0fffd57f967b777",
   "breaking_changes": [
-    { "version": "0.1.11", "description": "Extended shared types for Enderun Brain Dashboard" }
+    {
+      "version": "0.1.11",
+      "description": "Extended shared types for Enderun Brain Dashboard"
+    }
   ],
   "deprecated_versions": []
 }

package/packages/shared-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-enderun/shared-types",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Shared TypeScript types for AI-Enderun Framework. Ensures Contract-First synchronization between agents.",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -23,9 +23,9 @@
     "README.md"
   ],
   "scripts": {
-    "build": "npx tsc -p tsconfig.json",
-    "build:watch": "npx tsc -p tsconfig.json --watch",
-    "typecheck": "npx tsc -p tsconfig.json --noEmit"
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "license": "MIT",
   "devDependencies": {

package/panda.config.ts

@@ -5,7 +5,11 @@ export default defineConfig({
   preflight: true,
   
   // Where to look for your css declarations
-  include: ["./src/**/*.{js,jsx,ts,tsx}", "./pages/**/*.{js,jsx,ts,tsx}"],
+  include: [
+    "./src/**/*.{js,jsx,ts,tsx}",
+    "./pages/**/*.{js,jsx,ts,tsx}",
+    "./apps/**/*.{js,jsx,ts,tsx}",
+  ],
 
   // Files to exclude
   exclude: [],