agent-enderun 0.6.5 → 0.6.6

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

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { getFrameworkDir } from "../utils.js";
-import { SEND_AGENT_MESSAGE_ARGS_SCHEMA, READ_AGENT_MESSAGES_ARGS_SCHEMA, GET_AGENT_INBOX_STATS_ARGS_SCHEMA } from "../schemas.js";
+import { SEND_AGENT_MESSAGE_ARGS_SCHEMA, READ_AGENT_MESSAGES_ARGS_SCHEMA, GET_AGENT_INBOX_STATS_ARGS_SCHEMA, UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA } from "../schemas.js";
 export const messageTools = [
     {
         name: "send_agent_message",
@@ -9,13 +9,14 @@ export const messageTools = [
         inputSchema: {
             type: "object",
             properties: {
+                from: { type: "string", description: "Sender agent name (e.g. @manager, @backend)" },
                 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"],
+            required: ["from", "to", "message", "traceId"],
         },
     },
     {
@@ -41,6 +42,19 @@ export const messageTools = [
             required: ["agent"],
         },
     },
+    {
+        name: "update_agent_message_status",
+        description: "Allows an agent to acknowledge, complete, or reject a Hermes message by Trace ID (advances the orchestration lifecycle).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "The agent performing the status update" },
+                traceId: { type: "string", description: "Trace ID of the message to update" },
+                newStatus: { type: "string", enum: ["ACKNOWLEDGED", "COMPLETED", "REJECTED"], description: "New lifecycle status" },
+            },
+            required: ["agent", "traceId", "newStatus"],
+        },
+    },
 ];
 function normalizeAgentName(agent) {
     const normalized = agent.replace(/^@/, "").trim();
@@ -61,20 +75,22 @@ export const messageHandlers = {
                 fs.mkdirSync(messagesDir, { recursive: true });
             const messagePath = path.join(messagesDir, `${recipient}.json`);
             const messages = (fs.existsSync(messagePath) ? JSON.parse(fs.readFileSync(messagePath, "utf-8")) : []);
+            const sender = normalizeAgentName(parsed.data.from) || "unknown";
             messages.push({
                 timestamp: new Date().toISOString(),
-                from: "manager",
+                from: sender,
+                to: recipient,
                 traceId: parsed.data.traceId,
                 category: parsed.data.category,
                 priority: parsed.data.priority,
                 content: parsed.data.message,
-                read: false
+                status: "PENDING"
             });
             fs.writeFileSync(messagePath, JSON.stringify(messages, null, 2));
             return { content: [{ type: "text", text: `Hermes: Message sent to @${recipient} [${parsed.data.category} | ${parsed.data.priority}].` }] };
         }
         catch {
-            return { content: [{ type: "text", text: "Failed to get message statistics." }] };
+            return { content: [{ type: "text", text: "Failed to send agent message." }] };
         }
     },
     read_agent_messages: async (args, projectRoot) => {
@@ -90,11 +106,20 @@ export const messageHandlers = {
             if (!fs.existsSync(messagePath))
                 return { content: [{ type: "text", text: "No messages found." }] };
             const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8"));
-            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)
+            const pending = messages.filter((m) => (m.status === "PENDING" || m.status === "ACKNOWLEDGED") &&
+                (!parsed.data.traceId || m.traceId === parsed.data.traceId));
+            // Transition PENDING → READ (Do not regress ACKNOWLEDGED messages back to READ)
+            const updated = messages.map((m) => {
+                if (m.status === "PENDING" &&
+                    (!parsed.data.traceId || m.traceId === parsed.data.traceId)) {
+                    return { ...m, status: "READ" };
+                }
+                return m;
+            });
+            fs.writeFileSync(messagePath, JSON.stringify(updated, null, 2));
+            if (pending.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");
+            const formatted = pending.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 {
@@ -114,20 +139,55 @@ export const messageHandlers = {
             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 pendingOrRead = messages.filter(m => m.status === "PENDING" || m.status === "READ");
             const priorityDist = messages.reduce((acc, m) => {
                 acc[m.priority] = (acc[m.priority] || 0) + 1;
                 return acc;
             }, {});
+            const statusDist = messages.reduce((acc, m) => {
+                acc[m.status] = (acc[m.status] || 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)}`
+                        text: `### INBOX STATS: @${agentName}\n- Total: ${messages.length}\n- Pending/Read: ${pendingOrRead.length}\n- By Priority: ${JSON.stringify(priorityDist)}\n- By Status: ${JSON.stringify(statusDist)}`
                     }]
             };
         }
         catch {
             return { content: [{ type: "text", text: "Failed to read agent messages." }] };
         }
+    },
+    update_agent_message_status: async (args, projectRoot) => {
+        const parsed = UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA.safeParse(args ?? {});
+        if (!parsed.success)
+            return { content: [{ type: "text", text: "Invalid arguments for status update." }] };
+        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: "No messages for this agent." }] };
+            const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8"));
+            let updated = false;
+            const newMessages = messages.map((m) => {
+                if (m.traceId === parsed.data.traceId) {
+                    updated = true;
+                    return { ...m, status: parsed.data.newStatus };
+                }
+                return m;
+            });
+            if (!updated) {
+                return { content: [{ type: "text", text: `No message found with Trace ID ${parsed.data.traceId}.` }] };
+            }
+            fs.writeFileSync(messagePath, JSON.stringify(newMessages, null, 2));
+            return { content: [{ type: "text", text: `Hermes: Message ${parsed.data.traceId} marked as ${parsed.data.newStatus}.` }] };
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to update message status." }] };
+        }
     }
 };

package/framework-mcp/dist/utils.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-export const FRAMEWORK_VERSION = "0.6.1";
+export const FRAMEWORK_VERSION = "0.6.5";
 export function getFrameworkDir(projectRoot) {
     const adapters = [".antigravitycli", ".claude", ".cursor", ".enderun", ".codex"];
     for (const adp of adapters) {

package/framework-mcp/package.json

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

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

@@ -30,11 +30,16 @@ export const databaseHandlers = {
             for (const sourceFile of tsProject.getSourceFiles()) {
                 const text = sourceFile.getFullText();
                 const tableMatches = Array.from(text.matchAll(/\.createTable\(['"]([^'"]+)['"]\)/g));
-                for (const match of tableMatches) {
+                for (let i = 0; i < tableMatches.length; i++) {
+                    const match = tableMatches[i] as any;
                     const tableName = match[1]; tablesFound++;
                     mermaid += `  ${tableName} {\n`;
+                    const startIndex = match.index ?? 0;
+                    const nextMatch = tableMatches[i + 1];
+                    const endIndex = nextMatch ? (nextMatch.index ?? text.length) : text.length;
+                    const tableBlockText = text.substring(startIndex, endIndex);
                     const colRegex = /\.addColumn\(['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/g;
-                    let colMatch; while ((colMatch = colRegex.exec(text)) !== null) {
+                    let colMatch; while ((colMatch = colRegex.exec(tableBlockText)) !== null) {
                         mermaid += `    ${colMatch[2].replace(/[^a-zA-Z0-9]/g, '_')} ${colMatch[1]}\n`;
                     }
                     mermaid += `  }\n`;

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

@@ -78,7 +78,7 @@ export const frameworkHandlers = {
             fs.writeFileSync(memoryPath, bootstrapContent);
             return { content: [{ type: "text", text: `Legacy Codebase Bootstrap complete. Detected Stack: ${techStack}.` }] };
         } catch {
-            return { content: [{ type: "text", text: "Failed to get project gaps." }] };
+            return { content: [{ type: "text", text: "Failed to bootstrap legacy memory." }] };
         }
     },
     get_framework_status: async (args: unknown, projectRoot: string) => {
@@ -93,7 +93,7 @@ export const frameworkHandlers = {
                 content: [{ type: "text", text: `Framework active (v${FRAMEWORK_VERSION}). Phase: ${phase}. Profile: ${profile}.` }],
             };
         } catch {
-            return { content: [{ type: "text", text: "Failed to get memory insights." }] };
+            return { content: [{ type: "text", text: "Failed to get framework status." }] };
         }
     },
     get_project_gaps: async (args: unknown, projectRoot: string) => {
@@ -146,7 +146,7 @@ export const frameworkHandlers = {
                 content: [{ type: "text", text: `### LIVE MEMORY INSIGHTS\n\n**Active Tasks:**\n${activeTasks.trim()}\n\n**Recent History:**\n${history.trim().substring(0, 1000)}...\n\n**Brain Snapshot:**\n${dashboardAgents.trim().substring(0, 500)}...` }],
             };
         } catch {
-            return { content: [{ type: "text", text: "Failed to get framework status." }] };
+            return { content: [{ type: "text", text: "Failed to get memory insights." }] };
         }
     },
     codebase_context: async (args: unknown, projectRoot: string) => {
@@ -159,7 +159,7 @@ export const frameworkHandlers = {
                 content: [{ type: "text", text: "### CONTEXT ARTIFACTS\n\n" + `PROJECT_MEMORY: ${fs.existsSync(memoryPath) ? "present" : "missing"}\n` + `BRAIN_DASHBOARD: ${fs.existsSync(dashboardPath) ? "present" : "missing"}\n` + `Docs:\n${artifacts.length > 0 ? artifacts.join("\n") : "No markdown artifacts found."}` }],
             };
         } catch {
-            return { content: [{ type: "text", text: "Failed to bootstrap legacy memory." }] };
+            return { content: [{ type: "text", text: "Failed to gather codebase context." }] };
         }
     },
     get_system_time: async () => {

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

@@ -94,7 +94,7 @@ function parseFrontmatter(content: string) {
             if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
             
             const fileName = parsed.data.topic.replace(/[^a-z0-9]/gi, "_").toLowerCase() + ".md";
-            const tags = parsed.data.tags;
+            const tags = parsed.data.tags || [];
             
             let finalContent = parsed.data.content;
             if (!finalContent.startsWith("---")) {

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

@@ -73,7 +73,7 @@ export const memoryHandlers = {
             if (fs.existsSync(lockPath) && fs.readFileSync(lockPath, "utf-8").includes(lockOwner)) fs.unlinkSync(lockPath);
             return { content: [{ type: "text", text: `Section ${section} updated successfully.` }] };
         } catch {
-            return { content: [{ type: "text", text: "Failed to read project memory." }] };
+            return { content: [{ type: "text", text: "Failed to update project memory." }] };
         }
     },
     read_project_memory: async (args: unknown, projectRoot: string) => {
@@ -83,7 +83,7 @@ export const memoryHandlers = {
             if (!fs.existsSync(memoryPath)) return { content: [{ type: "text", text: `ERROR: ${frameworkDir}/PROJECT_MEMORY.md not found.` }] };
             return { content: [{ type: "text", text: fs.readFileSync(memoryPath, "utf-8") }] };
         } catch {
-            return { content: [{ type: "text", text: "Failed to update project memory." }] };
+            return { content: [{ type: "text", text: "Failed to read project memory." }] };
         }
     },
 };

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

@@ -123,9 +123,9 @@ export const messageHandlers = {
                 (!parsed.data.traceId || m.traceId === parsed.data.traceId)
             );
             
-            // Transition PENDING → READ
+            // Transition PENDING → READ (Do not regress ACKNOWLEDGED messages back to READ)
             const updated = messages.map((m) => {
-                if ((m.status === "PENDING" || m.status === "ACKNOWLEDGED") && 
+                if (m.status === "PENDING" && 
                     (!parsed.data.traceId || m.traceId === parsed.data.traceId)) {
                     return { ...m, status: "READ" as const };
                 }
@@ -140,8 +140,8 @@ export const messageHandlers = {
             ).join("\n");
             
             return { content: [{ type: "text", text: `### HERMES INBOX: @${agentName}\n\n${formatted}` }] };
-        } catch {
-            return { content: [{ type: "text", text: "Failed to send agent message." }] };
+                } catch {
+            return { content: [{ type: "text", text: "Failed to read agent messages." }] };
         }
     },
     get_agent_inbox_stats: async (args: unknown, projectRoot: string) => {

package/framework-mcp/src/utils.ts

@@ -1,7 +1,24 @@
 import path from "path";
 import fs from "fs";
+import { fileURLToPath } from "url";
 
-export const FRAMEWORK_VERSION = "0.6.5";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const getPackageVersion = (): string => {
+    try {
+        const pkgPath = path.join(__dirname, "../package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            return pkg.version || "0.6.6";
+        }
+    } catch {
+        // fallback
+    }
+    return "0.6.6";
+};
+
+export const FRAMEWORK_VERSION = getPackageVersion();
 
 export function getFrameworkDir(projectRoot: string): string {
     const adapters = [".antigravitycli", ".claude", ".cursor", ".enderun", ".codex"];

package/framework-mcp/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "outDir": "./dist",
-    "strict": false,
+    "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-enderun",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "The Supreme AI Governance & Orchestration Framework for Enterprise Development",
   "author": "Yusuf BEKAR",
   "license": "MIT",
@@ -69,7 +69,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@pandacss/dev": "^0.53.0",
     "@types/node": "^22.13.4",
-    "agent-enderun": "^0.6.5",
+    "agent-enderun": "^0.6.6",
     "concurrently": "^9.1.2",
     "eslint": "^9.20.1",
     "ts-morph": "^28.0.0",
@@ -80,7 +80,7 @@
     "zod": "^3.24.2"
   },
   "enderun": {
-    "version": "0.6.5",
+    "version": "0.6.6",
     "initializedAt": "2026-05-23T13:00:32.411Z"
   },
   "dependencies": {}

package/.enderun/messages/2026-05-23-backend-to-manager-auth-errors-reply.json

@@ -1,23 +0,0 @@
-{
-  "id": "msg_01H7K9P2Q3R4S5T6U7V8W9X0Y2",
-  "timestamp": "2026-05-23T18:22:00.000Z",
-  "from": "@backend",
-  "to": "@manager",
-  "traceId": "01H7K9P2Q3R4S5T6U7V8W9X0Y1",
-  "category": "INFO",
-  "priority": "MEDIUM",
-  "status": "COMPLETED",
-  "subject": "Re: Implement User Authentication DomainError hierarchy",
-  "content": {
-    "status": "COMPLETED",
-    "filesCreated": [
-      "apps/backend/src/errors/domain-error.ts",
-      "apps/backend/src/errors/index.ts"
-    ],
-    "notes": "Followed the gold standard blueprint exactly. All 6 error classes implemented with proper branded error codes.",
-    "nextStep": "Ready for review by @analyst"
-  },
-  "metadata": {
-    "inReplyTo": "msg_01H7K9P2Q3R4S5T6U7V8W9X0Y1"
-  }
-}

package/.enderun/messages/2026-05-23-manager-to-backend-auth-errors.json

@@ -1,26 +0,0 @@
-{
-  "id": "msg_01H7K9P2Q3R4S5T6U7V8W9X0Y1",
-  "timestamp": "2026-05-23T18:15:00.000Z",
-  "from": "@manager",
-  "to": "@backend",
-  "traceId": "01H7K9P2Q3R4S5T6U7V8W9X0Y1",
-  "category": "DELEGATION",
-  "priority": "HIGH",
-  "status": "ACKNOWLEDGED",
-  "subject": "Implement User Authentication DomainError hierarchy",
-  "content": {
-    "task": "Create the standard DomainError base class and all required subclasses (NotFoundError, ValidationError, UnauthorizedError, etc.) in apps/backend/src/errors/",
-    "reference": "Blueprint: backend/errors/domain-error.ts",
-    "deadline": "End of current phase",
-    "constraints": [
-      "Must follow Branded Types pattern",
-      "No direct throw new Error() allowed",
-      "Must be exported from index.ts"
-    ]
-  },
-  "metadata": {
-    "relatedTo": "trace_01H7K9P2Q3R4S5T6U7V8W9X0Y1",
-    "requiresResponse": true,
-    "estimatedEffort": "2 hours"
-  }
-}