agent-enderun 0.8.8 → 0.9.0

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

@@ -1,47 +0,0 @@
-import { codebaseTools, codebaseHandlers } from "./codebase.js";
-import { frameworkTools, frameworkHandlers } from "./framework.js";
-import { securityTools, securityHandlers } from "./security.js";
-import { memoryTools, memoryHandlers } from "./memory.js";
-import { contractTools, contractHandlers } from "./contract.js";
-import { messageTools, messageHandlers } from "./messages.js";
-import { gitTools, gitHandlers } from "./git.js";
-import { knowledgeTools, knowledgeHandlers } from "./knowledge.js";
-import { governanceTools, governanceHandlers } from "./governance.js";
-import { orchestrationTools, orchestrationHandlers } from "./orchestration.js";
-import { monitoringTools, monitoringHandlers } from "./monitoring.js";
-import { pipelineTools, pipelineHandlers } from "./pipeline.js";
-export const allTools = [
-    ...codebaseTools,
-    ...frameworkTools,
-    ...securityTools,
-    ...memoryTools,
-    ...contractTools,
-    ...messageTools,
-    ...gitTools,
-    ...knowledgeTools,
-    ...governanceTools,
-    // v1.0 Army Core
-    ...orchestrationTools,
-    ...monitoringTools,
-    ...pipelineTools,
-];
-export const allHandlers = {
-    ...codebaseHandlers,
-    ...frameworkHandlers,
-    ...securityHandlers,
-    ...memoryHandlers,
-    ...contractHandlers,
-    ...messageHandlers,
-    ...gitHandlers,
-    ...knowledgeHandlers,
-    ...governanceHandlers,
-    // v1.0 Army Core
-    ...orchestrationHandlers,
-    ...monitoringHandlers,
-    ...pipelineHandlers,
-};
-// Add compatibility aliases
-allHandlers.codebase_search = allHandlers.search_codebase;
-allHandlers.codebase_graph_query = allHandlers.analyze_dependencies;
-allHandlers.codebase_status = allHandlers.get_framework_status;
-allHandlers.codebase_context_search = allHandlers.search_codebase; // Modified in original but search_codebase handles extension

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

@@ -1,133 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getFrameworkDir } from "../utils.js";
-import { SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA, UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA } from "../schemas.js";
-export const knowledgeTools = [
-    {
-        name: "search_knowledge_base",
-        description: "Searches the Academy's Obsidian-style knowledge base using keywords or tags.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Search query, topic, or tag (e.g. #security)" },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "update_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" },
-                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 ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid search query." }] };
-        try {
-            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");
-                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 entries found." }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Knowledge base search failed." }] };
-        }
-    },
-    update_knowledge_base: async (args, projectRoot) => {
-        const parsed = UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA.safeParse(args ?? {});
-        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 });
-            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 {
-            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 {
-            return { content: [{ type: "text", text: "Failed to get knowledge graph." }] };
-        }
-    }
-};

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

@@ -1,217 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getFrameworkDir, prependToSection, replaceSectionContent } from "../utils.js";
-import { UPDATE_MEMORY_ARGS_SCHEMA } from "../schemas.js";
-export const memoryTools = [
-    {
-        name: "update_project_memory",
-        description: "Update a specific section of PROJECT_MEMORY.md (CURRENT STATUS, HISTORY, or ACTIVE TASKS) with new content.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                section: {
-                    type: "string",
-                    enum: ["CURRENT STATUS", "HISTORY", "ACTIVE TASKS"],
-                    description: "The section to update.",
-                },
-                content: {
-                    type: "string",
-                    description: "The new content to append or replace in that section.",
-                },
-            },
-            required: ["section", "content"],
-        },
-    },
-    {
-        name: "read_project_memory",
-        description: "Read the entire content of PROJECT_MEMORY.md safely. Use this instead of direct ReadFile tools to ensure framework compatibility.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_army_graph",
-        description: "Read the current Agent Army interaction graph (memory-graph/graph.json). Useful for @orchestrator and @manager to see relationships and health.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_agent_context",
-        description: "Read the private persistent context for a specific agent from memory-graph/agent-contexts/{agent}.json (without the @ prefix).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "Agent name without @ (e.g. manager, orchestrator, backend)" }
-            },
-            required: ["agent"]
-        },
-    },
-    {
-        name: "update_shared_facts",
-        description: "Update the shared facts file used by the entire Agent Army (memory-graph/shared-facts.json).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                facts: { type: "object", description: "Partial or full facts object to merge into shared-facts.json" }
-            },
-            required: ["facts"]
-        },
-    },
-    {
-        name: "update_agent_context",
-        description: "Update the private context for a specific agent in memory-graph/agent-contexts/.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: { type: "string", description: "Agent name without @" },
-                context: { type: "object", description: "Data to write/merge for this agent" }
-            },
-            required: ["agent", "context"]
-        },
-    },
-];
-export const memoryHandlers = {
-    update_project_memory: async (args, projectRoot) => {
-        const parsed = UPDATE_MEMORY_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid section or content." }] };
-        const { section, content } = parsed.data;
-        const frameworkDir = getFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-        const lockPath = memoryPath + ".lock";
-        const lockOwner = `lock-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-        try {
-            try {
-                // Atomic write using 'wx' flag to prevent TOCTOU race conditions
-                fs.writeFileSync(lockPath, JSON.stringify({ owner: lockOwner, createdAt: new Date().toISOString() }), { flag: "wx" });
-            }
-            catch (error) {
-                if (error.code === "EEXIST") {
-                    const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 120000) {
-                        try {
-                            fs.unlinkSync(lockPath);
-                            // Retry atomic write once after unlinking stale lock
-                            fs.writeFileSync(lockPath, JSON.stringify({ owner: lockOwner, createdAt: new Date().toISOString() }), { flag: "wx" });
-                        }
-                        catch {
-                            return { content: [{ type: "text", text: "Memory is locked. Try again later." }] };
-                        }
-                    }
-                    else {
-                        return { content: [{ type: "text", text: "Memory is locked. Try again later." }] };
-                    }
-                }
-                else {
-                    throw error;
-                }
-            }
-            let memoryContent = fs.readFileSync(memoryPath, "utf-8");
-            if (section === "HISTORY") {
-                let updated = false;
-                const headers = ["HISTORY (Persistent Memory)", "HISTORY"];
-                for (const h of headers) {
-                    try {
-                        memoryContent = prependToSection(memoryContent, h, content);
-                        updated = true;
-                        break;
-                    }
-                    catch {
-                        // Ignore section not found
-                    }
-                }
-                if (!updated)
-                    throw new Error("HISTORY section not found.");
-            }
-            else if (section === "CURRENT STATUS") {
-                memoryContent = replaceSectionContent(memoryContent, "CURRENT STATUS", content);
-            }
-            else if (section === "ACTIVE TASKS") {
-                memoryContent = replaceSectionContent(memoryContent, "ACTIVE TASKS", content);
-            }
-            fs.writeFileSync(memoryPath, memoryContent);
-            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 update project memory." }] };
-        }
-    },
-    read_project_memory: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            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 read project memory." }] };
-        }
-    },
-    get_army_graph: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const graphPath = path.join(projectRoot, frameworkDir, "memory-graph", "graph.json");
-            if (!fs.existsSync(graphPath))
-                return { content: [{ type: "text", text: "Army graph not found. Run army initialization first." }] };
-            const graph = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
-            return { content: [{ type: "text", text: JSON.stringify(graph, null, 2) }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to read army graph." }] };
-        }
-    },
-    get_agent_context: async (args, projectRoot) => {
-        try {
-            const { agent } = args;
-            if (!agent)
-                return { content: [{ type: "text", text: "Agent name required." }] };
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const contextPath = path.join(projectRoot, frameworkDir, "memory-graph", "agent-contexts", `${agent.replace(/^@/, "")}.json`);
-            if (!fs.existsSync(contextPath))
-                return { content: [{ type: "text", text: `No private context found for @${agent}.` }] };
-            const ctx = JSON.parse(fs.readFileSync(contextPath, "utf-8"));
-            return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to read agent context." }] };
-        }
-    },
-    update_shared_facts: async (args, projectRoot) => {
-        try {
-            const { facts } = args;
-            if (!facts)
-                return { content: [{ type: "text", text: "facts object required." }] };
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const factsPath = path.join(projectRoot, frameworkDir, "memory-graph", "shared-facts.json");
-            let existing = {};
-            if (fs.existsSync(factsPath)) {
-                existing = JSON.parse(fs.readFileSync(factsPath, "utf-8"));
-            }
-            const merged = { ...existing, ...facts, updatedAt: new Date().toISOString() };
-            fs.writeFileSync(factsPath, JSON.stringify(merged, null, 2));
-            return { content: [{ type: "text", text: "Shared facts updated successfully." }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to update shared facts." }] };
-        }
-    },
-    update_agent_context: async (args, projectRoot) => {
-        try {
-            const { agent, context } = args;
-            if (!agent || !context)
-                return { content: [{ type: "text", text: "agent and context required." }] };
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const ctxPath = path.join(projectRoot, frameworkDir, "memory-graph", "agent-contexts", `${agent.replace(/^@/, "")}.json`);
-            let existing = {};
-            if (fs.existsSync(ctxPath)) {
-                existing = JSON.parse(fs.readFileSync(ctxPath, "utf-8"));
-            }
-            const merged = { ...existing, ...context, updatedAt: new Date().toISOString() };
-            fs.writeFileSync(ctxPath, JSON.stringify(merged, null, 2));
-            return { content: [{ type: "text", text: `Context for @${agent} updated successfully.` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to update agent context." }] };
-        }
-    },
-};

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

@@ -1,193 +0,0 @@
-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, UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA } from "../schemas.js";
-export const messageTools = [
-    {
-        name: "send_agent_message",
-        description: "Sends a message to another specialized agent following the Hermes Protocol.",
-        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: ["from", "to", "message", "traceId"],
-        },
-    },
-    {
-        name: "read_agent_messages",
-        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"],
-        },
-    },
-    {
-        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();
-    return /^[a-z0-9_-]+$/i.test(normalized) ? normalized : null;
-}
-export const messageHandlers = {
-    send_agent_message: async (args, projectRoot) => {
-        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 = 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")) : []);
-            const sender = normalizeAgentName(parsed.data.from) || "unknown";
-            messages.push({
-                timestamp: new Date().toISOString(),
-                from: sender,
-                to: recipient,
-                traceId: parsed.data.traceId,
-                category: parsed.data.category,
-                priority: parsed.data.priority,
-                content: parsed.data.message,
-                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 send agent message." }] };
-        }
-    },
-    read_agent_messages: async (args, projectRoot) => {
-        const parsed = READ_AGENT_MESSAGES_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: "No messages found." }] };
-            const messages = JSON.parse(fs.readFileSync(messagePath, "utf-8"));
-            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 = 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 {
-            return { content: [{ type: "text", text: "Failed to read agent 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 = 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"));
-            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- 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." }] };
-        }
-    }
-};