atabey-mcp 0.0.6 → 0.0.7

package/dist/{constants.js → framework-mcp/src/constants.js}

@@ -46,7 +46,7 @@ export const NATIVE_AGENT_PATHS = {
     cursor: ".cursor/rules",
     codex: ".agents/instructions",
     grok: ".grok",
-    "antigravity-cli": ".antigravity/agents",
+    "antigravity-cli": ".agents/agents",
 };
 // ─── Backward-compatible aliases ──────────────────────────────────────────
 export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;

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

@@ -4,8 +4,9 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { TOOLS, toolHandlers } from "./tools/index.js";
+import { RESOURCES, handleReadResource } from "./resources/index.js";
 // ─── Server Setup ─────────────────────────────────────────────────
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Robustly find package.json by walking up from __dirname
@@ -28,6 +29,7 @@ const server = new Server({
 }, {
     capabilities: {
         tools: {},
+        resources: {},
     },
 });
 // Basic Schema Validator for Required Fields
@@ -51,6 +53,28 @@ server.setRequestHandler(ListToolsRequestSchema, async (request) => {
     }
     return { tools: TOOLS };
 });
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources: RESOURCES };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    try {
+        const content = await handleReadResource(uri);
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "text/markdown",
+                    text: content,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read resource: ${message}`, { cause: error });
+    }
+});
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const req = request;
     const { name, arguments: args } = req.params;
@@ -65,15 +89,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (!handler) {
             return {
                 isError: true,
-                content: [{ type: "text", text: `❌ Unknown tool: ${name}` }],
+                content: [{ type: "text", text: `[ERROR] Unknown tool: ${name}` }],
             };
         }
-        // 🛡️ Runtime Validation
+        // [SECURITY] Runtime Validation
         const validationError = validateArgs(name, args || {});
         if (validationError) {
             return {
                 isError: true,
-                content: [{ type: "text", text: `❌ Validation Error: ${validationError}` }],
+                content: [{ type: "text", text: `[ERROR] Validation Error: ${validationError}` }],
             };
         }
         return await handler(projectRoot, args || {});
@@ -82,7 +106,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const message = error instanceof Error ? error.message : "Unknown error occurred";
         return {
             isError: true,
-            content: [{ type: "text", text: `❌ Execution failed: ${message}` }],
+            content: [{ type: "text", text: `[ERROR] Execution failed: ${message}` }],
         };
     }
 });

package/dist/framework-mcp/src/resources/index.js

@@ -0,0 +1,58 @@
+import { Storage } from "../../../src/shared/storage.js";
+/**
+ * [DATA] MCP Resource Definitions
+ */
+export const RESOURCES = [
+    {
+        uri: "atabey://army/status",
+        name: "Agent Army Status",
+        description: "Real-time state and active tasks of all specialized agents.",
+        mimeType: "text/markdown"
+    },
+    {
+        uri: "atabey://plan/active",
+        name: "Active Execution Plan",
+        description: "The current DAG of tasks and their completion status.",
+        mimeType: "text/markdown"
+    },
+    {
+        uri: "atabey://memory/project",
+        name: "Project Memory",
+        description: "The central source of truth for project context (PROJECT_MEMORY.md).",
+        mimeType: "text/markdown"
+    }
+];
+export async function handleReadResource(uri) {
+    if (uri === "atabey://army/status") {
+        const agents = Storage.getAllAgents();
+        let md = "# [AI] Agent Army Status\n\n| Agent | State | Active Task | Last Updated |\n| :--- | :--- | :--- | :--- |\n";
+        agents.forEach((a) => {
+            md += `| @${a.name} | ${a.state} | ${a.task} | ${a.last_updated} |\n`;
+        });
+        return md;
+    }
+    if (uri === "atabey://plan/active") {
+        const tasks = Storage.getTasks();
+        let md = "# 📋 Active Execution Plan\n\n| ID | Task | Agent | Status | Dependencies |\n| :--- | :--- | :--- | :--- | :--- |\n";
+        tasks.forEach((t) => {
+            const deps = t.dependencies.join(", ") || "-";
+            md += `| ${t.id} | ${t.description} | ${t.agent} | ${t.status} | ${deps} |\n`;
+        });
+        return md;
+    }
+    if (uri === "atabey://memory/project") {
+        const fs = await import("fs");
+        const path = await import("path");
+        const { getFrameworkDir } = await import("../../../src/cli/utils/memory.js");
+        const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
+        const fwDir = getFrameworkDir();
+        const p = path.isAbsolute(fwDir)
+            ? path.join(fwDir, "memory", "PROJECT_MEMORY.md")
+            : path.join(projectRoot, fwDir, "memory", "PROJECT_MEMORY.md");
+        if (fs.existsSync(p)) {
+            return fs.readFileSync(p, "utf8");
+        }
+        return "Project memory not found. Run 'atabey init' first.";
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+}

package/dist/{tools → framework-mcp/src/tools}/control_plane/locking.js

@@ -38,7 +38,7 @@ export async function handleAcquireLock(projectRoot, args) {
         const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
         fs.writeFileSync(lockPath, lockData, { flag: "wx" });
         return {
-            content: [{ type: "text", text: `✅ Lock acquired for resource '${resource}' by ${agent}.` }]
+            content: [{ type: "text", text: `[OK] Lock acquired for resource '${resource}' by ${agent}.` }]
         };
     }
     catch (e) {
@@ -70,11 +70,11 @@ export async function handleReleaseLock(projectRoot, args) {
         if (lockData.agent !== agent) {
             return {
                 isError: true,
-                content: [{ type: "text", text: `❌ Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
+                content: [{ type: "text", text: `[ERROR] Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
             };
         }
         fs.unlinkSync(lockPath);
-        return { content: [{ type: "text", text: `✅ Lock released for resource '${resource}' by ${agent}.` }] };
+        return { content: [{ type: "text", text: `[OK] Lock released for resource '${resource}' by ${agent}.` }] };
     }
     catch (e) {
         return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };

package/dist/{tools → framework-mcp/src/tools}/control_plane/registry.js

@@ -6,7 +6,7 @@ import { resolveFrameworkDir } from "../../utils/security.js";
  * This can be used to validate permissions and active status.
  */
 export async function handleRegisterAgent(projectRoot, args) {
-    const { agent, role, capability = 5 } = args;
+    const { agent, role, capability = 5, specialties } = args;
     const frameworkDir = resolveFrameworkDir(projectRoot);
     const registryDir = path.join(projectRoot, frameworkDir, "registry");
     const agentFile = path.join(registryDir, `${agent.replace("@", "")}_active.json`);
@@ -17,12 +17,13 @@ export async function handleRegisterAgent(projectRoot, args) {
             agent,
             role,
             capability,
+            specialties,
             last_seen: new Date().toISOString(),
             status: "ACTIVE"
         };
         fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
         return {
-            content: [{ type: "text", text: `🎖️ Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
+            content: [{ type: "text", text: `[ATABEY] Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
         };
     }
     catch (e) {

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

@@ -232,7 +232,12 @@ export const TOOLS = [
             properties: {
                 agent: { type: "string", description: "The agent name (e.g., '@backend')." },
                 role: { type: "string", description: "The role of the agent." },
-                capability: { type: "number", description: "The capability score (1-10)." }
+                capability: { type: "number", description: "The capability score (1-10)." },
+                specialties: {
+                    type: "object",
+                    additionalProperties: { type: "number" },
+                    description: "Sub-specialty weights mapping (e.g. {\"postgres\": 10, \"redis\": 8})"
+                }
             },
             required: ["agent", "role"]
         }
@@ -274,6 +279,33 @@ export const TOOLS = [
         description: "Run the project's linter (e.g., ESLint) to check for code quality and style issues.",
         inputSchema: { type: "object", properties: {} },
     },
+    {
+        name: "submit_plan",
+        description: "Submit a structured DAG plan of tasks for the project. This will be decomposed and queued for execution.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string", description: "Unique task ID (e.g. TASK_01)" },
+                            agent: { type: "string", description: "The agent responsible for the task (e.g. @backend)" },
+                            task: { type: "string", description: "The task description" },
+                            dependencies: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "List of task IDs that must be completed before this task."
+                            }
+                        },
+                        required: ["id", "agent", "task"]
+                    }
+                }
+            },
+            required: ["tasks"],
+        },
+    },
     {
         name: "view_file",
         description: "Alias for read_file. Reads the content of a file within the project.",

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

@@ -2,11 +2,12 @@ import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { writeTextFileAtomic } from "../../utils/fs.js";
 import { Metrics } from "../../utils/metrics.js";
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
 /**
  * Performs multiple surgical text replacements across multiple files in a single batch.
  */
-export function handleBatchSurgicalEdit(projectRoot, args) {
+export async function handleBatchSurgicalEdit(projectRoot, args) {
     const edits = args.edits;
     if (!Array.isArray(edits) || edits.length === 0) {
         const err = "No edits provided in the batch request.";
@@ -17,6 +18,8 @@ export function handleBatchSurgicalEdit(projectRoot, args) {
     let totalTokens = 0;
     for (const edit of edits) {
         const filePath = safePath(projectRoot, edit.path);
+        // ENFORCE PERMISSION MATRIX
+        verifyWritePermission(projectRoot, edit.path);
         if (!fs.existsSync(filePath)) {
             const err = `File not found: ${edit.path}`;
             Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
@@ -44,10 +47,12 @@ export function handleBatchSurgicalEdit(projectRoot, args) {
             : content.replace(oldText, newText);
         // ENFORCE CORPORATE COMPLIANCE
         verifyCorporateCompliance(newContent, edit.path);
+        // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+        await verifyRiskAndAwaitApproval(projectRoot, newContent, edit.path);
         writeTextFileAtomic(filePath, newContent);
         const tokens = Metrics.estimateTokens(newText);
         totalTokens += tokens;
-        results.push(`✅ Edited ${edit.path}`);
+        results.push(`[OK] Edited ${edit.path}`);
     }
     Metrics.logUsage(projectRoot, "@mcp", `batch_surgical_edit: ${edits.length} files`, totalTokens);
     return {

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

@@ -1,9 +1,12 @@
 import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { Metrics } from "../../utils/metrics.js";
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-export function handlePatchFile(projectRoot, args) {
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handlePatchFile(projectRoot, args) {
     const filePath = safePath(projectRoot, args.path);
+    // ENFORCE PERMISSION MATRIX
+    verifyWritePermission(projectRoot, args.path);
     const lines = fs.readFileSync(filePath, "utf8").split("\n");
     const start = args.startLine - 1;
     const end = args.endLine;
@@ -22,8 +25,10 @@ export function handlePatchFile(projectRoot, args) {
     const patchedContent = lines.join("\n");
     // ENFORCE CORPORATE COMPLIANCE
     verifyCorporateCompliance(patchedContent, args.path);
+    // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+    await verifyRiskAndAwaitApproval(projectRoot, patchedContent, args.path);
     fs.writeFileSync(filePath, patchedContent);
     const tokens = Metrics.estimateTokens(args.newContent);
     Metrics.logUsage(projectRoot, "@mcp", `patch_file: ${args.path}`, tokens);
-    return { content: [{ type: "text", text: `✅ File patched successfully: ${args.path}` }] };
+    return { content: [{ type: "text", text: `[OK] File patched successfully: ${args.path}` }] };
 }

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

@@ -5,14 +5,14 @@ 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;
@@ -46,6 +46,6 @@ export function handleReadFile(projectRoot, args) {
     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/dist/{tools → framework-mcp/src/tools}/file_system/replace_text.js

@@ -2,9 +2,12 @@ import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { writeTextFileAtomic } from "../../utils/fs.js";
 import { Metrics } from "../../utils/metrics.js";
-import { verifyCorporateCompliance } from "../../utils/compliance.js";
-export function handleReplaceText(projectRoot, args) {
+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;
@@ -38,8 +41,10 @@ export function handleReplaceText(projectRoot, args) {
     }
     // ENFORCE CORPORATE COMPLIANCE
     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/dist/{tools → framework-mcp/src/tools}/file_system/write_file.js

@@ -3,18 +3,23 @@ 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 { verifyCorporateCompliance } from "../../utils/compliance.js";
-export function handleWriteFile(projectRoot, args) {
+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);
@@ -28,11 +33,11 @@ export function handleWriteFile(projectRoot, args) {
             }
         }
         catch { /* ignore memory logging errors */ }
-        return { content: [{ type: "text", text: `✅ File written: ${args.path}` }] };
+        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/dist/{tools → framework-mcp/src/tools}/framework/audit_deps.js

@@ -22,7 +22,7 @@ export function handleAuditDependencies(projectRoot, _args) {
     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)
@@ -35,7 +35,7 @@ export function handleAuditDependencies(projectRoot, _args) {
                 type: "text",
                 text: results.length > 0
                     ? `Dependency Audit Results:\n\n${results.join("\n")}`
-                    : "✅ Dependencies look clean and consolidated."
+                    : "[OK] Dependencies look clean and consolidated."
             }]
     };
 }

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

@@ -9,7 +9,7 @@ export function handleRunTests(projectRoot, args) {
     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) {
@@ -20,7 +20,7 @@ export function handleRunTests(projectRoot, args) {
             isError: true,
             content: [{
                     type: "text",
-                    text: `❌ Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}`
+                    text: `[ERROR] Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}`
                 }]
         };
     }

package/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/dist/{tools → framework-mcp/src/tools}/framework/update_memory.js

@@ -4,5 +4,5 @@ export function handleUpdateProjectMemory(projectRoot, args) {
     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/dist/{tools → 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";
@@ -48,6 +49,7 @@ export const toolHandlers = {
     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),

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

@@ -25,7 +25,7 @@ export function handleGetMemoryInsights(projectRoot, _args) {
                 .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) {

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

@@ -18,5 +18,5 @@ export function handleLogAgentAction(projectRoot, args) {
     };
     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/dist/{tools → framework-mcp/src/tools}/messaging/send_message.js

@@ -8,7 +8,7 @@ export async function handleSendAgentMessage(projectRoot, args) {
     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");
@@ -47,14 +47,14 @@ export async function handleSendAgentMessage(projectRoot, args) {
                 }
             }
             else {
-                return { content: [{ type: "text", text: `❌ Unexpected lock acquisition error: ${error.message || String(err)}` }], isError: true };
+                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";
@@ -74,12 +74,12 @@ export async function handleSendAgentMessage(projectRoot, args) {
             requiresApproval: finalRequiresApproval
         };
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-        return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
+        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}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
     finally {
         if (acquired && fs.existsSync(lockPath)) {

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

@@ -14,7 +14,7 @@ export function handleCheckPorts(projectRoot, args) {
         return {
             content: [{
                     type: "text",
-                    text: `📡 **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
+                    text: `[SIGNAL] **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
                 }]
         };
     }

package/dist/{tools → framework-mcp/src/tools}/quality/check_lint.js

@@ -17,13 +17,13 @@ export function handleCheckLint(projectRoot, _args) {
                 Metrics.logError(projectRoot, "@mcp", "check_lint", err);
                 resolve({
                     isError: true,
-                    content: [{ type: "text", text: `❌ Lint Errors Found (${language}):\n\n${output}` }]
+                    content: [{ type: "text", text: `[ERROR] Lint Errors Found (${language}):\n\n${output}` }]
                 });
                 return;
             }
             Metrics.logUsage(projectRoot, "@mcp", "check_lint", tokens);
             resolve({
-                content: [{ type: "text", text: `✅ Lint check passed successfully for ${language}:\n\n${output}` }]
+                content: [{ type: "text", text: `[OK] Lint check passed successfully for ${language}:\n\n${output}` }]
             });
         });
     });

package/dist/{tools → framework-mcp/src/tools}/search/get_gaps.js

@@ -42,7 +42,7 @@ export function handleGetProjectGaps(projectRoot, args) {
                 type: "text",
                 text: results.length > 0
                     ? `Found ${results.length} gaps/todos:\n\n${results.join("\n")}`
-                    : "✅ No major gaps or TODOs found in the scanned directory."
+                    : "[OK] No major gaps or TODOs found in the scanned directory."
             }]
     };
 }

package/dist/{tools → framework-mcp/src/tools}/search/grep_search.js

@@ -11,7 +11,7 @@ export function handleGrepSearch(projectRoot, args) {
     if (!pattern) {
         const err = "Search pattern is required.";
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
     const results = [];
     try {
@@ -20,7 +20,7 @@ export function handleGrepSearch(projectRoot, args) {
     catch (e) {
         const err = `Invalid regex pattern: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
     const walk = (dir) => {
         if (results.length > 100)
@@ -62,7 +62,7 @@ export function handleGrepSearch(projectRoot, args) {
     catch (e) {
         const err = `Search failed: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
     return {
         content: [{