agent-enderun 0.6.1 → 0.6.6

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

@@ -29,13 +29,18 @@ 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];
                     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) {
+                    while ((colMatch = colRegex.exec(tableBlockText)) !== null) {
                         mermaid += `    ${colMatch[2].replace(/[^a-zA-Z0-9]/g, '_')} ${colMatch[1]}\n`;
                     }
                     mermaid += `  }\n`;
@@ -45,7 +50,7 @@ export const databaseHandlers = {
                 return { content: [{ type: "text", text: "No database tables detected." }] };
             return { content: [{ type: "text", text: `### DATABASE SCHEMA MAP\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`\n\n**Total Tables Detected:** ${tablesFound}` }] };
         }
-        catch (error) {
+        catch {
             return { content: [{ type: "text", text: "Database schema analysis failed." }] };
         }
     },

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

@@ -2,7 +2,6 @@ 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",
@@ -70,8 +69,6 @@ export const frameworkHandlers = {
                 if (detected.length > 0)
                     techStack = detected.join(", ");
             }
-            const rootDirs = fs.readdirSync(projectRoot).filter(f => fs.lstatSync(path.join(projectRoot, f)).isDirectory() && !f.startsWith("."));
-            const isMonorepo = rootDirs.includes("apps") || rootDirs.includes("packages");
             const date = new Date().toISOString().split("T")[0];
             const bootstrapContent = `# PROJECT MEMORY — Legacy Onboarding\n\n## CURRENT STATUS\n\n| Active Phase | Profile | Last Update | Active Trace ID | Blockers |\n| PHASE_1 | Full | ${date} | — | Legacy Onboarding |`;
             if (fs.existsSync(memoryPath))
@@ -79,7 +76,7 @@ export const frameworkHandlers = {
             fs.writeFileSync(memoryPath, bootstrapContent);
             return { content: [{ type: "text", text: `Legacy Codebase Bootstrap complete. Detected Stack: ${techStack}.` }] };
         }
-        catch (error) {
+        catch {
             return { content: [{ type: "text", text: "Failed to bootstrap legacy memory." }] };
         }
     },
@@ -95,8 +92,8 @@ export const frameworkHandlers = {
                 content: [{ type: "text", text: `Framework active (v${FRAMEWORK_VERSION}). Phase: ${phase}. Profile: ${profile}.` }],
             };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "Framework active. Memory unreadable." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to get framework status." }] };
         }
     },
     get_project_gaps: async (args, projectRoot) => {
@@ -150,8 +147,8 @@ 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 (error) {
-            return { content: [{ type: "text", text: "Failed to gather memory insights." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to get memory insights." }] };
         }
     },
     codebase_context: async (args, projectRoot) => {
@@ -164,15 +161,14 @@ 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 (error) {
-            return { content: [{ type: "text", text: "Context discovery failed." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to gather codebase context." }] };
         }
     },
     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

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

@@ -44,8 +44,8 @@ export const gitHandlers = {
             const summary = files.length === 1 ? `update ${path.basename(files[0])}` : `update ${files.length} files`;
             return { content: [{ type: "text", text: `### SUGGESTED SEMANTIC COMMIT MESSAGE\n\n\`[${parsed.data.traceId}] ${type}(${scope}): ${summary}\`\n\n**Files Analyzed:**\n${files.map(f => `- ${f}`).join("\n")}` }] };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "Failed to generate commit message." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to generate semantic commit message." }] };
         }
     },
 };

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

@@ -76,7 +76,7 @@ export const knowledgeHandlers = {
             }).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 (error) {
+        catch {
             return { content: [{ type: "text", text: "Knowledge base search failed." }] };
         }
     },
@@ -90,7 +90,7 @@ export const knowledgeHandlers = {
             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("---")) {
                 const frontmatter = `---\ntitle: ${parsed.data.topic}\ntags: [${tags.join(", ")}]\nlast_updated: ${new Date().toISOString()}\n---\n\n`;
@@ -99,7 +99,7 @@ export const knowledgeHandlers = {
             fs.writeFileSync(path.join(kbDir, fileName), finalContent);
             return { content: [{ type: "text", text: `Obsidian Wiki updated: ${parsed.data.topic}` }] };
         }
-        catch (error) {
+        catch {
             return { content: [{ type: "text", text: "Failed to update knowledge base." }] };
         }
     },
@@ -126,8 +126,8 @@ export const knowledgeHandlers = {
             });
             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." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to get knowledge graph." }] };
         }
     }
 };

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

@@ -57,7 +57,7 @@ export const memoryHandlers = {
                         updated = true;
                         break;
                     }
-                    catch (e) {
+                    catch {
                         // Ignore section not found
                     }
                 }
@@ -75,10 +75,8 @@ export const memoryHandlers = {
                 fs.unlinkSync(lockPath);
             return { content: [{ type: "text", text: `Section ${section} updated successfully.` }] };
         }
-        catch (error) {
-            if (fs.existsSync(lockPath) && fs.readFileSync(lockPath, "utf-8").includes(lockOwner))
-                fs.unlinkSync(lockPath);
-            return { content: [{ type: "text", text: `Memory update failed: ${error instanceof Error ? error.message : "Unknown error"}` }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to update project memory." }] };
         }
     },
     read_project_memory: async (args, projectRoot) => {
@@ -89,8 +87,8 @@ export const memoryHandlers = {
                 return { content: [{ type: "text", text: `ERROR: ${frameworkDir}/PROJECT_MEMORY.md not found.` }] };
             return { content: [{ type: "text", text: fs.readFileSync(memoryPath, "utf-8") }] };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "ERROR: Failed to read PROJECT_MEMORY.md" }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to read project memory." }] };
         }
     },
 };

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 (error) {
-            return { content: [{ type: "text", text: "Failed to send message via Hermes." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to send agent message." }] };
         }
     },
     read_agent_messages: async (args, projectRoot) => {
@@ -90,15 +106,24 @@ 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 (error) {
-            return { content: [{ type: "text", text: "Failed to read messages." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to send agent message." }] };
         }
     },
     get_agent_inbox_stats: async (args, projectRoot) => {
@@ -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 (error) {
-            return { content: [{ type: "text", text: "Failed to get inbox stats." }] };
+        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/tools/repository.js

@@ -66,8 +66,8 @@ export const repositoryHandlers = {
                 results.push(runScript("build"));
             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." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to analyze repository health." }] };
         }
     },
     analyze_documentation_debt: async (args, projectRoot) => {
@@ -94,8 +94,8 @@ export const repositoryHandlers = {
             const majorDirs = ["apps/backend", "apps/web", "framework-mcp"], missingREADME = majorDirs.filter(dir => fs.existsSync(path.join(projectRoot, dir)) && !fs.existsSync(path.join(projectRoot, dir, "README.md")));
             return { content: [{ type: "text", text: `### DOCUMENTATION DEBT REPORT\n\n**Missing JSDoc:**\n${missingJSDoc.slice(0, 10).join("\n")}\n\n**Missing README.md:**\n${missingREADME.join("\n")}` }] };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "Documentation debt scan failed." }] };
+        catch {
+            return { content: [{ type: "text", text: "Failed to analyze documentation debt." }] };
         }
     },
 };

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

@@ -60,7 +60,8 @@ export const scaffoldHandlers = {
             return { content: [{ type: "text", text: `Successfully instantiated blueprint '${blueprintPath}' into '${targetPath}'` }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Scaffold failed: ${error.message}` }] };
+            const message = error instanceof Error ? error.message : "Unknown error";
+            return { content: [{ type: "text", text: `Scaffold failed: ${message}` }] };
         }
     },
     save_as_blueprint: async (args, projectRoot) => {
@@ -83,7 +84,8 @@ export const scaffoldHandlers = {
             return { content: [{ type: "text", text: `Successfully saved blueprint to '${blueprintPath}'` }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Failed to save blueprint: ${error.message}` }] };
+            const message = error instanceof Error ? error.message : "Unknown error";
+            return { content: [{ type: "text", text: `Failed to save blueprint: ${message}` }] };
         }
     },
     list_blueprints: async (args, projectRoot) => {
@@ -123,7 +125,8 @@ export const scaffoldHandlers = {
             return { content: [{ type: "text", text: `### AVAILABLE BLUEPRINTS\n\n` + available.map(b => `- ${b}`).join("\n") }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Listing blueprints failed: ${error.message}` }] };
+            const message = error instanceof Error ? error.message : "Unknown error";
+            return { content: [{ type: "text", text: `Listing blueprints failed: ${message}` }] };
         }
     },
 };

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

@@ -77,8 +77,8 @@ export const securityHandlers = {
             }
             return { content: [{ type: "text", text: vulnerabilities.length > 0 ? `### ADVANCED SECURITY AUDIT RESULTS\n\n${Array.from(new Set(vulnerabilities)).join("\n\n")}` : "No security patterns or rule violations detected (Regex & AST verified)." }] };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "Security scan failed." }] };
+        catch {
+            return { content: [{ type: "text", text: "Security audit failed." }] };
         }
     },
     analyze_constitution_compliance: async (args, projectRoot) => {
@@ -130,8 +130,8 @@ export const securityHandlers = {
             }
             return { content: [{ type: "text", text: `### CONSTITUTION COMPLIANCE REPORT\n\n` + (violations.length > 0 ? `⚠️ **VIOLATIONS FOUND:**\n${violations.map(v => `- ${v}`).join("\n")}` : "✅ **ALL SYSTEMS COMPLIANT:** AST and Regex scans passed. No rule violations detected.") }] };
         }
-        catch (error) {
-            return { content: [{ type: "text", text: "Compliance analysis failed." }] };
+        catch {
+            return { content: [{ type: "text", text: "Constitution compliance check failed." }] };
         }
     },
 };

package/framework-mcp/dist/utils.js

@@ -1,8 +1,8 @@
 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 = [".gemini", ".claude", ".cursor", ".enderun", ".codex"];
+    const adapters = [".antigravitycli", ".claude", ".cursor", ".enderun", ".codex"];
     for (const adp of adapters) {
         const fullPath = path.join(projectRoot, adp);
         if (fs.existsSync(fullPath) && fs.lstatSync(fullPath).isDirectory()) {

package/framework-mcp/package.json

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

package/framework-mcp/src/schemas.ts

@@ -32,6 +32,7 @@ export const LOG_AGENT_ACTION_ARGS_SCHEMA = z.object({
 });
 
 export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
+    from: z.string().min(1),
     to: z.string().min(1),
     message: z.string().min(1),
     traceId: z.string().min(1),
@@ -39,6 +40,12 @@ export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
     priority: z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]).default("MEDIUM"),
 });
 
+export const UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA = z.object({
+    agent: z.string().min(1),
+    traceId: z.string().min(1),
+    newStatus: z.enum(["ACKNOWLEDGED", "COMPLETED", "REJECTED"]),
+});
+
 export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
     query: z.string().min(1),
 });

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

@@ -3,8 +3,6 @@ import path from "path";
 import { getFrameworkDir } from "../utils.js";
 import { 
     GET_ACADEMY_PERFORMANCE_ARGS_SCHEMA, 
-    GENERATE_STRATEGIC_BRIEFING_ARGS_SCHEMA,
-    GENERATE_ACADEMY_PROGRESS_REPORT_ARGS_SCHEMA,
     GET_AGENT_AUDIT_REPORT_ARGS_SCHEMA,
     LOG_AGENT_ACTION_ARGS_SCHEMA
 } from "../schemas.js";
@@ -112,7 +110,7 @@ export const academyHandlers = {
                 return { agent: file.replace(".json", ""), actions: logs.length, successRate: (success / (logs.length || 1)) * 100 };
             }).filter(s => s.actions > 0);
             return { content: [{ type: "text", text: `### GLOBAL ACADEMY PERFORMANCE REPORT\n\n- **Analysis Period:** Last ${days} days\n- **Global Success Rate:** ${((totalSuccess / (totalActions || 1)) * 100).toFixed(1)}%\n\n**Agent Breakdown:**\n` + agentStats.map(s => `- **@${s.agent}:** ${s.actions} actions (${s.successRate.toFixed(1)}% success)`).join("\n") }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Failed to generate global performance report." }] };
         }
     },
@@ -129,13 +127,11 @@ export const academyHandlers = {
             }
             const successRate = (successCount / (totalActions || 1)) * 100;
             return { content: [{ type: "text", text: `# 🏛️ ACADEMY STRATEGIC BRIEFING\n\n- **Academy Health:** ${successRate.toFixed(1)}% Success Rate over ${totalActions} actions.\n**Status:** READY FOR PHASE_1 COMPLETION.` }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Strategic briefing generation failed." }] };
         }
     },
     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 {
             const frameworkDir = getFrameworkDir(projectRoot);
             const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
@@ -143,7 +139,7 @@ export const academyHandlers = {
             const historySection = memoryContent.match(/## HISTORY[\s\S]*$/m)?.[0] ?? "";
             const milestones = Array.from(historySection.matchAll(/### (.*)\n\n- \*\*Agent:\*\* (.*)\n- \*\*Trace ID:\*\* (.*)\n- \*\*Action:\*\* (.*)/g)).slice(0, 5).map(m => `- [${m[1]}] **${m[2]}:** ${m[4]}`).join("\n");
             return { content: [{ type: "text", text: `# 🎓 AGENT ACADEMY PROGRESS REPORT\n\n## 🏆 Key Milestones Achieved\n${milestones}` }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Failed to generate progress report." }] };
         }
     },
@@ -158,7 +154,7 @@ export const academyHandlers = {
             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) {
+        } catch {
             return { content: [{ type: "text", text: "Failed to generate audit report." }] };
         }
     },
@@ -177,7 +173,7 @@ export const academyHandlers = {
             logs.push({ timestamp: new Date().toISOString(), ...parsed.data });
             fs.writeFileSync(logPath, JSON.stringify(logs, null, 2));
             return { content: [{ type: "text", text: `SUCCESS: Logged action to ${parsed.data.agent}.json` }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Failed to log action." }] };
         }
     },

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

@@ -145,7 +145,7 @@ export const codebaseHandlers = {
             let queryRegex: RegExp;
             try {
                 queryRegex = new RegExp(query, "i");
-            } catch (error) {
+            } catch {
                 return { content: [{ type: "text", text: "Invalid regex pattern in query." }] };
             }
             const matches: string[] = [];
@@ -164,7 +164,7 @@ export const codebaseHandlers = {
                 }
             }
             return { content: [{ type: "text", text: matches.join("\n") || "No matches found." }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Search failed." }] };
         }
     },
@@ -223,7 +223,7 @@ export const codebaseHandlers = {
                 });
             }
             return { content: [{ type: "text", text: `### CODEBASE INTELLIGENCE REPORT\n\n**Complexity Spikes (>300 lines):**\n${complexitySpikes.length > 0 ? complexitySpikes.map(s => `- ${s}`).join("\n") : "- None detected"}\n\n**Potential Dead Code (Unused Exports):**\n${potentialDeadCode.length > 0 ? potentialDeadCode.map(d => `- ${d}`).join("\n") : "- None detected (within scanned scope)"}` }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Intelligence scan failed." }] };
         }
     },
@@ -247,8 +247,8 @@ export const codebaseHandlers = {
             const referenceFunctions = referenceFile.getFunctions().map(f => f.getName());
             if (referenceFunctions.some(f => f?.startsWith("get")) && !targetFunctions.some(f => f?.startsWith("get"))) deviations.push("Reference uses 'get' prefix for functions, target does not.");
             return { content: [{ type: "text", text: deviations.length > 0 ? `### PROCEDURAL CONTINUITY DEVIATIONS\n\n${deviations.map(d => `- ${d}`).join("\n")}` : "No major structural or stylistic deviations detected based on reference." }] };
-        } catch (error) {
-            return { content: [{ type: "text", text: "Continuity analysis failed." }] };
+        } catch {
+            return { content: [{ type: "text", text: "Dependency analysis failed." }] };
         }
     },
     generate_dependency_graph: async (args: unknown, projectRoot: string) => {
@@ -277,7 +277,7 @@ export const codebaseHandlers = {
             if (uniqueEdges.length === 0) return { content: [{ type: "text", text: "No internal dependencies found in the scanned path." }] };
             mermaid += uniqueEdges.join("\n");
             return { content: [{ type: "text", text: `### VISUAL ARCHITECTURE MAP: ${targetPath}\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`\n\n**Total Nodes:** ${new Set(edges.flatMap(e => [e.from, e.to])).size} | **Total Edges:** ${uniqueEdges.length}` }] };
-        } catch (error) {
+        } catch {
             return { content: [{ type: "text", text: "Dependency graph generation failed." }] };
         }
     },