atabey 0.0.6 → 0.0.8

package/framework-mcp/{src/tools/file_system/read_file.ts → dist/framework-mcp/src/tools/file_system/read_file.js}

@@ -1,29 +1,23 @@
 import fs from "fs";
 import { safePath } from "../../utils/security.js";
-import { ReadFileArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
-
-export function handleReadFile(projectRoot: string, args: ReadFileArgs): ToolResult {
+export function handleReadFile(projectRoot, args) {
     if (!args.path) {
         const err = "Missing 'path' argument.";
         Metrics.logError(projectRoot, "@mcp", "read_file", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
-
     try {
         const filePath = safePath(projectRoot, args.path);
         if (!fs.existsSync(filePath)) {
             const err = `File not found: ${args.path}`;
             Metrics.logError(projectRoot, "@mcp", "read_file", err);
-            return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+            return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
         }
-
         const startLine = args.startLine;
         const endLine = args.endLine;
-
         const content = fs.readFileSync(filePath, "utf8");
         const lines = content.split(/\r?\n/);
-        
         if (startLine !== undefined || endLine !== undefined) {
             const start = startLine !== undefined ? Math.max(1, startLine) - 1 : 0;
             const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
@@ -32,7 +26,6 @@ export function handleReadFile(projectRoot: string, args: ReadFileArgs): ToolRes
             Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
             return { content: [{ type: "text", text: sliced }] };
         }
-
         // Default protection limit: 1000 lines
         const DEFAULT_MAX_LINES = 1000;
         if (lines.length > DEFAULT_MAX_LINES) {
@@ -41,18 +34,18 @@ export function handleReadFile(projectRoot: string, args: ReadFileArgs): ToolRes
             Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path} (truncated)`, tokens);
             return {
                 content: [{
-                    type: "text",
-                    text: `${sliced}\n\n... [TRUNCATED - File is too long (${lines.length} lines). Only the first ${DEFAULT_MAX_LINES} lines are shown. Use startLine and endLine parameters to read other parts of the file.]`
-                }]
+                        type: "text",
+                        text: `${sliced}\n\n... [TRUNCATED - File is too long (${lines.length} lines). Only the first ${DEFAULT_MAX_LINES} lines are shown. Use startLine and endLine parameters to read other parts of the file.]`
+                    }]
             };
         }
-
         const tokens = Metrics.estimateTokens(content);
         Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
         return { content: [{ type: "text", text: content }] };
-    } catch (e) {
+    }
+    catch (e) {
         const err = `Failed to read file: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", `read_file:${args.path}`, err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
 }

package/framework-mcp/{src/tools/file_system/replace_text.ts → dist/framework-mcp/src/tools/file_system/replace_text.js}

@@ -1,24 +1,22 @@
 import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { writeTextFileAtomic } from "../../utils/fs.js";
-import { ReplaceTextArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
-
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-
-export function handleReplaceText(projectRoot: string, args: ReplaceTextArgs): ToolResult {
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handleReplaceText(projectRoot, args) {
     const filePath = safePath(projectRoot, args.path);
+    // ENFORCE PERMISSION MATRIX
+    verifyWritePermission(projectRoot, args.path);
     const content = fs.readFileSync(filePath, "utf8");
     const oldText = args.oldText;
     const newText = args.newText;
     const allowMultiple = args.allowMultiple || false; // Default to false
-
     if (!content.includes(oldText)) {
         const err = `Text not found in file: ${oldText.slice(0, 100)}...`;
         Metrics.logError(projectRoot, "@mcp", `replace_text:${args.path}`, err);
         throw new Error(err);
     }
-
     // Surgical precision guard: reject ambiguous replacements unless allowMultiple is true.
     if (!allowMultiple) {
         const firstIndex = content.indexOf(oldText);
@@ -26,29 +24,27 @@ export function handleReplaceText(projectRoot: string, args: ReplaceTextArgs): T
         if (firstIndex !== lastIndex) {
             const count = (content.match(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
             const err = `Ambiguous replacement: "${oldText.slice(0, 80)}..." found ${count} times in ${args.path}. ` +
-                        "Provide a longer, unique context string or set 'allow_multiple' to true.";
+                "Provide a longer, unique context string or set 'allow_multiple' to true.";
             Metrics.logError(projectRoot, "@mcp", `replace_text:${args.path}`, err);
             throw new Error(err);
         }
     }
-
     // Perform replacement(s).
     // Use a function replacer so special patterns ($&, $1, $$) inside newText
     // are treated literally and never reinterpreted as regex backreferences.
-    let newContent: string;
+    let newContent;
     if (allowMultiple) {
         newContent = content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), () => newText);
-    } else {
+    }
+    else {
         newContent = content.replace(oldText, () => newText);
     }
-
     // ENFORCE CORPORATE COMPLIANCE
-    verifyCorporateCompliance(newContent, args.path as string);
-    
+    verifyCorporateCompliance(newContent, args.path);
+    // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+    await verifyRiskAndAwaitApproval(projectRoot, newContent, args.path);
     writeTextFileAtomic(filePath, newContent);
-
     const tokens = Metrics.estimateTokens(newText);
     Metrics.logUsage(projectRoot, "@mcp", `replace_text: ${args.path}`, tokens);
-
-    return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args.path}` }] };
+    return { content: [{ type: "text", text: `[OK] Surgical edit successful in ${args.path}` }] };
 }

package/framework-mcp/{src/tools/file_system/write_file.ts → dist/framework-mcp/src/tools/file_system/write_file.js}

@@ -3,30 +3,27 @@ import path from "path";
 import { safePath, resolveFrameworkDir } from "../../utils/security.js";
 import { writeTextFileAtomic, appendFileSafe } from "../../utils/fs.js";
 import { Metrics } from "../../utils/metrics.js";
-import { WriteFileArgs, ToolResult } from "../types.js";
-
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-
-export function handleWriteFile(projectRoot: string, args: WriteFileArgs): ToolResult {
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handleWriteFile(projectRoot, args) {
     if (!args.path || args.content === undefined) {
         const err = "Missing 'path' or 'content' argument.";
         Metrics.logError(projectRoot, "@mcp", "write_file", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
-
     try {
         const filePath = safePath(projectRoot, args.path);
         const content = args.content;
-        
+        // ENFORCE PERMISSION MATRIX
+        verifyWritePermission(projectRoot, args.path);
         // ENFORCE CORPORATE COMPLIANCE
         verifyCorporateCompliance(content, args.path);
-
+        // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+        await verifyRiskAndAwaitApproval(projectRoot, content, args.path);
         writeTextFileAtomic(filePath, content);
-        
         // AUTO-LOGGING & METRICS
         const tokens = Metrics.estimateTokens(content);
         Metrics.logUsage(projectRoot, "@mcp", `write_file: ${args.path}`, tokens);
-
         try {
             const frameworkDir = resolveFrameworkDir(projectRoot);
             const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
@@ -34,12 +31,13 @@ export function handleWriteFile(projectRoot: string, args: WriteFileArgs): ToolR
                 const entry = `\n### ${new Date().toISOString().split("T")[0]} — Auto-Update\n- **Action:** wrote file \`${args.path}\` (${tokens} tokens estimated).\n`;
                 appendFileSafe(memoryPath, entry);
             }
-        } catch { /* ignore memory logging errors */ }
-
-        return { content: [{ type: "text", text: `✅ File written: ${args.path}` }] };
-    } catch (e) {
+        }
+        catch { /* ignore memory logging errors */ }
+        return { content: [{ type: "text", text: `[OK] File written: ${args.path}` }] };
+    }
+    catch (e) {
         const err = `Failed to write file: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", `write_file:${args.path}`, err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
 }

package/framework-mcp/{src/tools/framework/audit_deps.ts → dist/framework-mcp/src/tools/framework/audit_deps.js}

@@ -1,49 +1,41 @@
 import fs from "fs";
 import path from "path";
-import { ToolArgs, ToolResult } from "../types.js";
-
 /**
  * Audits package.json for unused or duplicate-like packages.
  * Focuses on project health and cleanup.
  */
-export function handleAuditDependencies(projectRoot: string, _args: ToolArgs): ToolResult {
+export function handleAuditDependencies(projectRoot, _args) {
     const pkgPath = path.join(projectRoot, "package.json");
     if (!fs.existsSync(pkgPath)) {
         throw new Error("package.json not found.");
     }
-
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     const depNames = Object.keys(deps);
-    
-    const results: string[] = [];
-
+    const results = [];
     // 1. Look for similar packages (potential duplicates)
-    const similarityGroups: Record<string, string[]> = {
+    const similarityGroups = {
         "CSS/Styling": ["tailwind", "panda", "styled-components", "emotion", "sass"],
         "Testing": ["vitest", "jest", "mocha", "jasmine"],
         "Fetching": ["axios", "ky", "fetch"]
     };
-
     for (const [group, patterns] of Object.entries(similarityGroups)) {
         const found = depNames.filter(d => patterns.some(p => d.includes(p)));
         if (found.length > 1) {
-            results.push(`⚠️  Potential redundancy in [${group}]: Found ${found.join(", ")}`);
+            results.push(`[WARN]  Potential redundancy in [${group}]: Found ${found.join(", ")}`);
         }
     }
-
     // 2. Scan for "any" usage in package names (bad practice markers)
     const legacyDeps = depNames.filter(d => d.includes("legacy") || d.includes("compat"));
     if (legacyDeps.length > 0) {
         results.push(`ℹ️  Legacy compatibility packages detected: ${legacyDeps.join(", ")}`);
     }
-
     return {
         content: [{
-            type: "text",
-            text: results.length > 0 
-                ? `Dependency Audit Results:\n\n${results.join("\n")}`
-                : "✅ Dependencies look clean and consolidated."
-        }]
+                type: "text",
+                text: results.length > 0
+                    ? `Dependency Audit Results:\n\n${results.join("\n")}`
+                    : "[OK] Dependencies look clean and consolidated."
+            }]
     };
 }

package/framework-mcp/{src/tools/framework/get_status.ts → dist/framework-mcp/src/tools/framework/get_status.js}

@@ -1,7 +1,5 @@
 import { safeExec } from "../../utils/cli.js";
-import { GetStatusArgs, ToolResult } from "../types.js";
-
-export function handleGetFrameworkStatus(projectRoot: string, args: GetStatusArgs): ToolResult {
+export function handleGetFrameworkStatus(projectRoot, args) {
     const output = safeExec("npx", ["atabey", "status"], projectRoot, args.timeout);
     return { content: [{ type: "text", text: output }] };
 }

package/framework-mcp/{src/tools/framework/orchestrate.ts → dist/framework-mcp/src/tools/framework/orchestrate.js}

@@ -1,7 +1,5 @@
 import { safeExec } from "../../utils/cli.js";
-import { OrchestrateArgs, ToolResult } from "../types.js";
-
-export function handleOrchestrateLoop(projectRoot: string, args: OrchestrateArgs): ToolResult {
+export function handleOrchestrateLoop(projectRoot, args) {
     const output = safeExec("npx", ["atabey", "orchestrate"], projectRoot, args.timeout);
     return { content: [{ type: "text", text: output }] };
 }

package/framework-mcp/{src/tools/framework/run_tests.ts → dist/framework-mcp/src/tools/framework/run_tests.js}

@@ -1,30 +1,27 @@
 import { execSync } from "child_process";
-import { RunTestsArgs, ToolResult } from "../types.js";
 import { getBackendLanguage, getDefaultTestCommand } from "../../utils/cli.js";
-
 /**
  * Executes project tests and returns results for agent analysis.
  */
-export function handleRunTests(projectRoot: string, args: RunTestsArgs): ToolResult {
+export function handleRunTests(projectRoot, args) {
     const language = getBackendLanguage(projectRoot);
     const testCommand = args.command || getDefaultTestCommand(language);
-    
     try {
         const output = execSync(testCommand, { cwd: projectRoot, encoding: "utf8", stdio: "pipe" });
         return {
-            content: [{ type: "text", text: `✅ Tests passed successfully for ${language}!\n\n${output}` }]
+            content: [{ type: "text", text: `[OK] Tests passed successfully for ${language}!\n\n${output}` }]
         };
-    } catch (error: unknown) {
-        const err = error as { stderr?: Buffer; stdout?: Buffer };
+    }
+    catch (error) {
+        const err = error;
         const stderr = err.stderr?.toString() || "";
         const stdout = err.stdout?.toString() || "";
-        
         return {
             isError: true,
-            content: [{ 
-                type: "text", 
-                text: `❌ Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}` 
-            }]
+            content: [{
+                    type: "text",
+                    text: `[ERROR] Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}`
+                }]
         };
     }
 }

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

@@ -0,0 +1,13 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleSubmitPlan(projectRoot, args) {
+    if (!args.tasks || !Array.isArray(args.tasks)) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: "[ERROR] Error: 'tasks' array is required for submit_plan." }]
+        };
+    }
+    const planJson = JSON.stringify(args.tasks);
+    // Escape for shell if necessary, but safeExec handles arguments as an array
+    const output = safeExec("npx", ["atabey", "plan:submit", planJson], projectRoot);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/{src/tools/framework/update_contract_hash.ts → dist/framework-mcp/src/tools/framework/update_contract_hash.js}

@@ -1,7 +1,5 @@
 import { safeExec } from "../../utils/cli.js";
-import { UpdateContractHashArgs, ToolResult } from "../types.js";
-
-export function handleUpdateContractHash(projectRoot: string, args: UpdateContractHashArgs): ToolResult {
+export function handleUpdateContractHash(projectRoot, args) {
     const output = safeExec("npx", ["atabey", "update-contract"], projectRoot, args.timeout);
     return { content: [{ type: "text", text: output }] };
 }

package/framework-mcp/{src/tools/framework/update_memory.ts → dist/framework-mcp/src/tools/framework/update_memory.js}

@@ -1,10 +1,8 @@
 import { safeExec } from "../../utils/cli.js";
-import { UpdateProjectMemoryArgs, ToolResult } from "../types.js";
-
-export function handleUpdateProjectMemory(projectRoot: string, args: UpdateProjectMemoryArgs): ToolResult {
+export function handleUpdateProjectMemory(projectRoot, args) {
     const section = args.section;
     const content = args.content;
     // Using execFileSync with array args prevents command injection
     safeExec("npx", ["atabey", "update_project_memory", section, content], projectRoot);
-    return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
+    return { content: [{ type: "text", text: `[OK] Section ${section} updated.` }] };
 }

package/framework-mcp/{src/tools/index.ts → dist/framework-mcp/src/tools/index.js}

@@ -15,6 +15,7 @@ import { handleRunTests } from "./framework/run_tests.js";
 import { handleGetSystemHealth } from "./observability/get_health.js";
 import { handleCheckPorts } from "./observability/check_ports.js";
 import { handleOrchestrateLoop } from "./framework/orchestrate.js";
+import { handleSubmitPlan } from "./framework/submit_plan.js";
 import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
 import { handleReadProjectMemory } from "./memory/read_memory.js";
 import { handleGetMemoryInsights } from "./memory/get_insights.js";
@@ -24,14 +25,11 @@ import { handleAcquireLock, handleReleaseLock } from "./control_plane/locking.js
 import { handleRegisterAgent } from "./control_plane/registry.js";
 import { handleRunCommand } from "./shell/run_command.js";
 import { handleCheckLint } from "./quality/check_lint.js";
-import { ToolHandler, ToolResult } from "./types.js";
-
 // Map of tool names to their handler functions
-const bind = <T>(fn: (root: string, args: T) => ToolResult | Promise<ToolResult>): ToolHandler => {
-    return (root: string, args: unknown) => fn(root, args as T);
+const bind = (fn) => {
+    return (root, args) => fn(root, args);
 };
-
-export const toolHandlers: Record<string, ToolHandler> = {
+export const toolHandlers = {
     read_file: bind(handleReadFile),
     view_file: bind(handleReadFile), // Alias
     list_dir: bind(handleListDir),
@@ -51,6 +49,7 @@ export const toolHandlers: Record<string, ToolHandler> = {
     get_system_health: bind(handleGetSystemHealth),
     check_active_ports: bind(handleCheckPorts),
     orchestrate_loop: bind(handleOrchestrateLoop),
+    submit_plan: bind(handleSubmitPlan),
     send_agent_message: bind(handleSendAgentMessage),
     log_agent_action: bind(handleLogAgentAction),
     update_contract_hash: bind(handleUpdateContractHash),
@@ -60,5 +59,4 @@ export const toolHandlers: Record<string, ToolHandler> = {
     run_shell_command: bind(handleRunCommand),
     check_lint: bind(handleCheckLint),
 };
-
 export { TOOLS };

package/framework-mcp/{src/tools/memory/get_insights.ts → dist/framework-mcp/src/tools/memory/get_insights.js}

@@ -1,27 +1,21 @@
 import fs from "fs";
 import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
 /**
  * Extracts key insights from the project memory to minimize token usage.
  * Returns only the active phase, trace, and the last 5 decisions/tasks.
  */
-export function handleGetMemoryInsights(projectRoot: string, _args: ToolArgs): ToolResult {
+export function handleGetMemoryInsights(projectRoot, _args) {
     try {
         const frameworkDir = resolveFrameworkDir(projectRoot);
         const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-
         if (!fs.existsSync(memoryPath)) {
             return { content: [{ type: "text", text: "New project: No history available." }] };
         }
-
         const content = fs.readFileSync(memoryPath, "utf8");
         const lines = content.split("\n");
-        
         const activePhase = lines.find(l => l.includes("**Phase:**"))?.split("**Phase:**")[1]?.trim() || "Unknown";
         const activeTrace = lines.find(l => l.includes("**Trace ID:**"))?.split("**Trace ID:**")[1]?.trim() || "None";
-        
         // Find the last 5 history items (heuristic)
         const historyStartIndex = lines.findIndex(l => l.toUpperCase().includes("HISTORY"));
         let recentHistory = "No history found.";
@@ -31,11 +25,10 @@ export function handleGetMemoryInsights(projectRoot: string, _args: ToolArgs): T
                 .slice(-5)
                 .join("\n");
         }
-
-        const insights = `🧠 **Memory Insights**\n- **Phase:** ${activePhase}\n- **Trace:** ${activeTrace}\n\n**Recent Actions:**\n${recentHistory}`;
-        
+        const insights = `[MEMORY] **Memory Insights**\n- **Phase:** ${activePhase}\n- **Trace:** ${activeTrace}\n\n**Recent Actions:**\n${recentHistory}`;
         return { content: [{ type: "text", text: insights }] };
-    } catch (e) {
+    }
+    catch (e) {
         return { isError: true, content: [{ type: "text", text: `Failed to extract insights: ${String(e)}` }] };
     }
 }

package/framework-mcp/{src/tools/memory/read_memory.ts → dist/framework-mcp/src/tools/memory/read_memory.js}

@@ -1,28 +1,25 @@
 import fs from "fs";
 import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
 /**
  * Reads the project's central memory (PROJECT_MEMORY.md).
  * This is the "brain" of the project.
  */
-export function handleReadProjectMemory(projectRoot: string, _args: ToolArgs): ToolResult {
+export function handleReadProjectMemory(projectRoot, _args) {
     try {
         const frameworkDir = resolveFrameworkDir(projectRoot);
         const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-
         if (!fs.existsSync(memoryPath)) {
             return {
                 content: [{ type: "text", text: "ℹ️ Project memory file not found. It might be a new project." }]
             };
         }
-
         const content = fs.readFileSync(memoryPath, "utf8");
         return {
             content: [{ type: "text", text: content }]
         };
-    } catch (e) {
+    }
+    catch (e) {
         return {
             isError: true,
             content: [{ type: "text", text: `Failed to read project memory: ${String(e)}` }]

package/framework-mcp/{src/tools/messaging/log_action.ts → dist/framework-mcp/src/tools/messaging/log_action.js}

@@ -1,16 +1,12 @@
 import fs from "fs";
 import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
-import { LogAgentActionArgs, ToolResult } from "../types.js";
-
-export function handleLogAgentAction(projectRoot: string, args: LogAgentActionArgs): ToolResult {
+export function handleLogAgentAction(projectRoot, args) {
     const { agent, action, traceId, status, summary } = args;
     const findings = args.findings ? args.findings.split(",").map(f => f.trim()) : [];
-
     const frameworkDir = resolveFrameworkDir(projectRoot);
     const agentName = agent.replace("@", "");
     const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
-
     const logEntry = {
         timestamp: new Date().toISOString(),
         agent,
@@ -20,9 +16,7 @@ export function handleLogAgentAction(projectRoot: string, args: LogAgentActionAr
         summary,
         findings
     };
-
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
     fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
-
-    return { content: [{ type: "text", text: `✅ Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
+    return { content: [{ type: "text", text: `[OK] Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
 }

package/framework-mcp/{src/tools/messaging/send_message.ts → dist/framework-mcp/src/tools/messaging/send_message.js}

@@ -1,25 +1,20 @@
 import fs from "fs";
 import path from "path";
 import { resolveFrameworkDir } from "../../utils/security.js";
-import { SendAgentMessageArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
-
-export async function handleSendAgentMessage(projectRoot: string, args: SendAgentMessageArgs): Promise<ToolResult> {
+export async function handleSendAgentMessage(projectRoot, args) {
     const { to, category, content, traceId, parentId, requiresApproval } = args;
     const from = args.from || "@mcp";
-
     if (!to || !category || !content || !traceId) {
         const err = "Missing required messaging arguments (to, category, content, or traceId).";
         Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
-
     const frameworkDir = resolveFrameworkDir(projectRoot);
     const messagesDir = path.join(projectRoot, frameworkDir, "messages");
     const agentName = to.replace("@", "");
     const messagePath = path.join(messagesDir, `${agentName}.json`);
     const lockPath = path.join(messagesDir, `${agentName}.lock`);
-
     // Hermes Lock Protocol: Retry 20 times with 500ms delay
     let retries = 20;
     let acquired = false;
@@ -33,7 +28,8 @@ export async function handleSendAgentMessage(projectRoot: string, args: SendAgen
                         fs.renameSync(lockPath, tempLockPath);
                         fs.unlinkSync(tempLockPath);
                     }
-                } catch {
+                }
+                catch {
                     // ignore if concurrently unlinked or renamed
                 }
             }
@@ -41,31 +37,30 @@ export async function handleSendAgentMessage(projectRoot: string, args: SendAgen
             fs.writeFileSync(lockPath, `Locked by ${from} at ${new Date().toISOString()}`, { flag: "wx" });
             acquired = true;
             break;
-        } catch (err: unknown) {
-            const error = err as { code?: string; message?: string };
+        }
+        catch (err) {
+            const error = err;
             if (error.code === "EEXIST") {
                 retries--;
                 if (retries > 0) {
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
-            } else {
-                return { content: [{ type: "text", text: `❌ Unexpected lock acquisition error: ${error.message || String(err)}` }], isError: true };
+            }
+            else {
+                return { content: [{ type: "text", text: `[ERROR] Unexpected lock acquisition error: ${error.message || String(err)}` }], isError: true };
             }
         }
     }
-
     if (!acquired) {
         const err = `Could not send message to ${to}: Hermes lock is busy.`;
         Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { content: [{ type: "text", text: `❌ ${err}` }], isError: true };
+        return { content: [{ type: "text", text: `[ERROR] ${err}` }], isError: true };
     }
-
     try {
         const defaultPriority = (category === "ALERT" || category === "ACTION") ? "HIGH" : "NORMAL";
         const finalRequiresApproval = requiresApproval !== undefined
             ? requiresApproval
             : category === "ALERT";
-
         const message = {
             timestamp: new Date().toISOString(),
             from,
@@ -78,18 +73,20 @@ export async function handleSendAgentMessage(projectRoot: string, args: SendAgen
             status: "PENDING",
             requiresApproval: finalRequiresApproval
         };
-
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-        return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
-    } catch (e) {
+        return { content: [{ type: "text", text: `[OK] Message sent to ${to} (from: ${from})` }] };
+    }
+    catch (e) {
         const err = `Failed to write message: ${String(e)}`;
         Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
-    } finally {
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+    }
+    finally {
         if (acquired && fs.existsSync(lockPath)) {
             try {
                 fs.unlinkSync(lockPath);
-            } catch {
+            }
+            catch {
                 // ignore
             }
         }

package/framework-mcp/{src/tools/observability/check_ports.ts → dist/framework-mcp/src/tools/observability/check_ports.js}

@@ -1,28 +1,24 @@
 import { execSync } from "child_process";
-import { CheckActivePortsArgs, ToolResult } from "../types.js";
-
 /**
  * Checks for active network ports and their status.
  */
-export function handleCheckPorts(projectRoot: string, args: CheckActivePortsArgs): ToolResult {
+export function handleCheckPorts(projectRoot, args) {
     const filter = args.filter || ""; // Optional filter (e.g., ":3000")
-
     try {
         // Using 'lsof -i -P -n' to list open files and network connections
         // Note: may require permissions or behave differently on non-Unix systems
         const command = process.platform === "win32"
             ? `netstat -ano | findstr LISTENING ${filter ? `| findstr ${filter}` : ""}`
             : `lsof -i -P -n | grep LISTEN ${filter ? `| grep ${filter}` : ""}`;
-
         const output = execSync(command, { encoding: "utf8" });
-
         return {
             content: [{
-                type: "text",
-                text: `📡 **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
-            }]
+                    type: "text",
+                    text: `[SIGNAL] **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
+                }]
         };
-    } catch (_e) {
+    }
+    catch (_e) {
         return {
             content: [{ type: "text", text: "ℹ️ No active ports found or command failed (this is normal if nothing is listening)." }]
         };