atabey 0.0.16 → 0.0.18

package/framework-mcp/dist/src/shared/storage.js

@@ -1,325 +0,0 @@
-import Database from "better-sqlite3";
-import fs from "fs";
-import path from "path";
-import crypto from "crypto";
-import { getFrameworkDir } from "../cli/utils/memory.js";
-import { logger } from "./logger.js";
-import { maskText } from "./pii.js";
-import { asAgentID, asLogID, asMessageID, asTaskID } from "./types.js";
-/**
- * [DB] Atabey Storage Engine
- * Central SQLite database for enterprise-scale agent state management.
- */
-export class AtabeyStorage {
-    static db = null;
-    static getDB() {
-        if (!this.db) {
-            const frameworkDir = getFrameworkDir();
-            if (!fs.existsSync(frameworkDir)) {
-                fs.mkdirSync(frameworkDir, { recursive: true });
-            }
-            const dbPath = path.join(frameworkDir, "atabey.db");
-            this.db = new Database(dbPath, { timeout: 5000 });
-            this.db.pragma("journal_mode = WAL");
-            this.initializeSchema();
-        }
-        return this.db;
-    }
-    static initializeSchema() {
-        const db = this.db;
-        // Agents Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS agents (
-                name TEXT PRIMARY KEY,
-                state TEXT DEFAULT 'READY',
-                task TEXT DEFAULT 'Idle',
-                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
-            )
-        `);
-        // Messages (Hermes) Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS messages (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                sender TEXT,
-                receiver TEXT,
-                category TEXT,
-                content TEXT,
-                trace_id TEXT,
-                parent_id TEXT,
-                status TEXT DEFAULT 'PENDING',
-                priority TEXT DEFAULT 'NORMAL',
-                requires_approval BOOLEAN DEFAULT 0
-            )
-        `);
-        // Tasks Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS tasks (
-                id TEXT PRIMARY KEY,
-                trace_id TEXT,
-                description TEXT,
-                agent TEXT,
-                status TEXT DEFAULT 'PENDING',
-                priority TEXT DEFAULT 'NORMAL',
-                dependencies TEXT, -- JSON Array
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-            )
-        `);
-        // Logs Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS logs (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                agent TEXT,
-                action TEXT,
-                trace_id TEXT,
-                status TEXT,
-                summary TEXT,
-                findings TEXT,
-                prev_hash TEXT,
-                hash TEXT
-            )
-        `);
-        // self-healing schema check/migration for older logs table
-        try {
-            const tableInfo = db.prepare("PRAGMA table_info(logs)").all();
-            const columnNames = tableInfo.map(c => c.name);
-            if (!columnNames.includes("prev_hash")) {
-                db.exec("ALTER TABLE logs ADD COLUMN prev_hash TEXT");
-            }
-            if (!columnNames.includes("hash")) {
-                db.exec("ALTER TABLE logs ADD COLUMN hash TEXT");
-            }
-        }
-        catch (err) {
-            logger.error(`Failed to migrate logs table schema: ${err.message}`);
-        }
-        // Metadata (State) Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS metadata (
-                key TEXT PRIMARY KEY,
-                value TEXT
-            )
-        `);
-        // Costs Table
-        db.exec(`
-            CREATE TABLE IF NOT EXISTS costs (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                provider TEXT,
-                model TEXT,
-                input_tokens INTEGER,
-                output_tokens INTEGER,
-                cost REAL,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                trace_id TEXT
-            )
-        `);
-    }
-    static saveLog(log) {
-        const db = this.getDB();
-        const timestamp = new Date().toISOString();
-        const agent = log.agent.replace("@", "");
-        const maskedSummary = maskText(log.summary);
-        const maskedFindings = log.findings ? maskText(log.findings) : null;
-        // Get last log's hash
-        let prevHash = "GENESIS";
-        try {
-            const lastRow = db.prepare("SELECT hash FROM logs ORDER BY id DESC LIMIT 1").get();
-            if (lastRow && lastRow.hash) {
-                prevHash = lastRow.hash;
-            }
-        }
-        catch { /* use default */ }
-        // Compute hash
-        const dataToHash = `${prevHash}|${agent}|${log.action}|${log.trace_id || ""}|${log.status}|${maskedSummary}|${timestamp}`;
-        const hash = crypto.createHash("sha256").update(dataToHash).digest("hex");
-        const result = db.prepare(`
-            INSERT INTO logs (timestamp, agent, action, trace_id, status, summary, findings, prev_hash, hash)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(timestamp, agent, log.action, log.trace_id || null, log.status, maskedSummary, maskedFindings, prevHash, hash);
-        return result.lastInsertRowid;
-    }
-    static verifyLogIntegrity() {
-        const db = this.getDB();
-        try {
-            const rows = db.prepare("SELECT * FROM logs ORDER BY id ASC").all();
-            let expectedPrevHash = "GENESIS";
-            for (const row of rows) {
-                if (row.prev_hash !== expectedPrevHash) {
-                    return {
-                        valid: false,
-                        failedLogId: row.id,
-                        reason: `Hash mismatch at row ${row.id}: expected prev_hash to be '${expectedPrevHash}', but got '${row.prev_hash}'`
-                    };
-                }
-                // Recalculate hash
-                const dataToHash = `${row.prev_hash}|${row.agent}|${row.action}|${row.trace_id || ""}|${row.status}|${row.summary}|${row.timestamp}`;
-                const calculatedHash = crypto.createHash("sha256").update(dataToHash).digest("hex");
-                if (row.hash !== calculatedHash) {
-                    return {
-                        valid: false,
-                        failedLogId: row.id,
-                        reason: `Hash corruption at row ${row.id}: calculated hash '${calculatedHash}' does not match database hash '${row.hash}'`
-                    };
-                }
-                expectedPrevHash = row.hash || "";
-            }
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, reason: `Verification error: ${err.message}` };
-        }
-    }
-    // --- Cost Operations ---
-    static saveCost(cost) {
-        const db = this.getDB();
-        db.prepare(`
-            INSERT INTO costs (provider, model, input_tokens, output_tokens, cost, timestamp, trace_id)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        `).run(cost.provider, cost.model, cost.inputTokens, cost.outputTokens, cost.cost, cost.timestamp, cost.traceId || null);
-    }
-    static getAllCosts() {
-        const rows = this.getDB().prepare("SELECT * FROM costs ORDER BY timestamp ASC").all();
-        return rows.map(r => ({
-            provider: r.provider,
-            model: r.model,
-            inputTokens: r.input_tokens,
-            outputTokens: r.output_tokens,
-            cost: r.cost,
-            timestamp: r.timestamp,
-            traceId: r.trace_id || undefined
-        }));
-    }
-    // --- Agent Operations ---
-    static updateAgentStatus(name, state, task, lastUpdated) {
-        const db = this.getDB();
-        const cleanName = name.replace("@", "");
-        const timestamp = lastUpdated || new Date().toISOString();
-        // [KVKK/GDPR] Mask PII in task description before storing
-        const maskedTask = maskText(task);
-        db.prepare(`
-            INSERT INTO agents (name, state, task, last_updated)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(name) DO UPDATE SET
-                state = excluded.state,
-                task = excluded.task,
-                last_updated = excluded.last_updated
-        `).run(cleanName, state, maskedTask, timestamp);
-    }
-    static getAllAgents() {
-        return this.getDB().prepare("SELECT * FROM agents").all();
-    }
-    // --- Message Operations ---
-    static saveMessage(msg) {
-        const db = this.getDB();
-        // [KVKK/GDPR] Mask PII in message content before storing
-        const maskedContent = maskText(msg.content);
-        db.prepare(`
-            INSERT INTO messages (sender, receiver, category, content, trace_id, parent_id, status, priority, requires_approval)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(msg.from, msg.to, msg.category, maskedContent, msg.traceId, msg.parentId || null, msg.status || "PENDING", msg.priority || "NORMAL", msg.requiresApproval ? 1 : 0);
-    }
-    static getPendingMessages() {
-        const rows = this.getDB().prepare("SELECT * FROM messages WHERE status IN ('PENDING', 'APPROVED') ORDER BY priority DESC, timestamp ASC").all();
-        return rows.map(r => ({
-            id: asMessageID(r.id),
-            timestamp: r.timestamp,
-            from: asAgentID(r.sender),
-            to: asAgentID(r.receiver),
-            category: r.category,
-            content: r.content,
-            traceId: r.trace_id,
-            parentId: r.parent_id ? asTaskID(r.parent_id) : undefined,
-            status: r.status,
-            priority: r.priority,
-            requiresApproval: r.requires_approval === 1
-        }));
-    }
-    static updateMessageStatus(id, status) {
-        this.getDB().prepare("UPDATE messages SET status = ? WHERE id = ?").run(status, id);
-    }
-    // --- Task Operations ---
-    static saveTask(task) {
-        const db = this.getDB();
-        db.prepare(`
-            INSERT INTO tasks (id, trace_id, description, agent, status, priority, dependencies)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(id) DO UPDATE SET
-                status = excluded.status,
-                description = excluded.description
-        `).run(task.id, task.traceId, task.description, task.agent, task.status, task.priority, JSON.stringify(task.dependencies || []));
-    }
-    static getTasks(traceId) {
-        const db = this.getDB();
-        let rows;
-        if (traceId) {
-            rows = db.prepare("SELECT * FROM tasks WHERE trace_id = ?").all(traceId);
-        }
-        else {
-            rows = db.prepare("SELECT * FROM tasks").all();
-        }
-        return rows.map(r => {
-            let deps = [];
-            try {
-                const parsed = JSON.parse(r.dependencies || "[]");
-                deps = Array.isArray(parsed) ? parsed : JSON.parse(parsed);
-            }
-            catch (err) {
-                logger.warn("Failed to parse task dependencies, using empty array", err);
-            }
-            return {
-                id: asTaskID(r.id),
-                traceId: r.trace_id,
-                description: r.description,
-                agent: asAgentID(r.agent),
-                status: r.status,
-                priority: r.priority,
-                dependencies: deps,
-                createdAt: r.created_at
-            };
-        });
-    }
-    static getLogs(agentName) {
-        const db = this.getDB();
-        let rows;
-        const cleanName = agentName ? agentName.replace("@", "") : undefined;
-        if (cleanName) {
-            rows = db.prepare("SELECT * FROM logs WHERE agent = ? ORDER BY timestamp DESC").all(cleanName);
-        }
-        else {
-            rows = db.prepare("SELECT * FROM logs ORDER BY timestamp DESC").all();
-        }
-        return rows.map(r => ({
-            id: asLogID(r.id),
-            timestamp: r.timestamp,
-            agent: asAgentID(r.agent),
-            action: r.action,
-            trace_id: r.trace_id || undefined,
-            status: r.status,
-            // [KVKK/GDPR] Mask PII in log summaries before returning
-            summary: maskText(r.summary),
-            findings: r.findings ? maskText(r.findings) : undefined,
-            prev_hash: r.prev_hash || undefined,
-            hash: r.hash || undefined
-        }));
-    }
-    // --- Metadata Operations ---
-    static setMetadata(key, value) {
-        this.getDB().prepare(`
-            INSERT INTO metadata (key, value) VALUES (?, ?)
-            ON CONFLICT(key) DO UPDATE SET value = excluded.value
-        `).run(key, value);
-    }
-    static getMetadata(key) {
-        const row = this.getDB().prepare("SELECT value FROM metadata WHERE key = ?").get(key);
-        return row ? row.value : null;
-    }
-    static reset() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-}
-/** @deprecated Use AtabeyStorage instead. Kept for backward compatibility. */
-export const Storage = AtabeyStorage;

package/framework-mcp/dist/src/shared/string.js

@@ -1,29 +0,0 @@
-export function stripMarkdownCodeBlocks(text) {
-    // Regex to find markdown code blocks (```lang ... ```) and extract their content.
-    // Handles cases where LLMs might wrap JSON in such blocks.
-    const markdownCodeBlockRegex = /```(?:\w+)?\s*([\s\S]*?)\s*```/g;
-    // Attempt to extract content from a single markdown code block.
-    const cleanedText = text.replace(markdownCodeBlockRegex, "$1").trim();
-    // If after stripping, it looks like JSON, return it.
-    if ((cleanedText.startsWith("{") && cleanedText.endsWith("}")) || (cleanedText.startsWith("[") && cleanedText.endsWith("]"))) {
-        return cleanedText;
-    }
-    // Fallback: If the original text itself was valid JSON (without being in a code block)
-    // or if the stripping made it valid, this check helps.
-    try {
-        JSON.parse(text.trim());
-        return text.trim(); // Original text was valid JSON
-    }
-    catch {
-        // Continue if original text wasn't valid JSON
-    }
-    // Try a more specific JSON code block extraction if the generic one didn't yield valid JSON
-    const specificJsonCodeBlockRegex = /```json\s*(\{[\s\S]*?\}|\[[\s\S]*?\])\s*```/g;
-    const specificMatch = text.match(specificJsonCodeBlockRegex);
-    if (specificMatch && specificMatch[1]) {
-        return specificMatch[1].trim();
-    }
-    // If all else fails, return the most aggressively stripped version.
-    // JSON.parse will fail if it's not valid, which is the expected behavior.
-    return cleanedText;
-}

package/framework-mcp/dist/src/shared/types.js

@@ -1,16 +0,0 @@
-/**
- * Agent Atabey Framework — Internal Branded Types
- * Used to enforce absolute type safety within the core orchestration logic.
- */
-/**
- * Casts a raw string to a Branded Type.
- * Use this only at the boundaries of the system.
- */
-export function asTraceID(val) { return val; }
-export function asAgentID(val) { return val; }
-export function asPhaseID(val) { return val; }
-export function asProjectPath(val) { return val; }
-export function asMessageID(val) { return val; }
-export function asTaskID(val) { return val; }
-export function asLogID(val) { return val; }
-export function asPlanID(val) { return val; }

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

@@ -1,82 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-/**
- * Handles acquiring a stateful lock on a resource.
- */
-export async function handleAcquireLock(projectRoot, args) {
-    const { resource, agent, ttl = 60 } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockDir = path.join(projectRoot, frameworkDir, "locks");
-    const lockPath = path.join(lockDir, `${resource}.lock`);
-    try {
-        if (!fs.existsSync(lockDir))
-            fs.mkdirSync(lockDir, { recursive: true });
-        // Check for stale lock first
-        if (fs.existsSync(lockPath)) {
-            const stat = fs.statSync(lockPath);
-            const now = new Date().getTime();
-            const age = (now - stat.mtimeMs) / 1000;
-            if (age < ttl) {
-                return {
-                    isError: true,
-                    content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
-                };
-            }
-            // Lock expired, safe to override by renaming first (POSIX atomic operation)
-            const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
-            try {
-                fs.renameSync(lockPath, tempLockPath);
-                fs.unlinkSync(tempLockPath);
-            }
-            catch {
-                // If rename failed, it means another agent already evicting/deleting it.
-                // Do not delete anything else; proceed and let writeFileSync (wx flag) fail if a new lock exists.
-            }
-        }
-        // Use 'wx' flag for atomic file creation
-        const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
-        fs.writeFileSync(lockPath, lockData, { flag: "wx" });
-        return {
-            content: [{ type: "text", text: `[OK] Lock acquired for resource '${resource}' by ${agent}.` }]
-        };
-    }
-    catch (e) {
-        const error = e;
-        if (error.code === "EEXIST") {
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Resource '${resource}' was just acquired by another agent.` }]
-            };
-        }
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]
-        };
-    }
-}
-/**
- * Handles releasing a lock.
- */
-export async function handleReleaseLock(projectRoot, args) {
-    const { resource, agent } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const lockPath = path.join(projectRoot, frameworkDir, "locks", `${resource}.lock`);
-    try {
-        if (!fs.existsSync(lockPath)) {
-            return { content: [{ type: "text", text: `ℹ️ No lock found for resource '${resource}'.` }] };
-        }
-        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-        if (lockData.agent !== agent) {
-            return {
-                isError: true,
-                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: `[OK] Lock released for resource '${resource}' by ${agent}.` }] };
-    }
-    catch (e) {
-        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
-    }
-}

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

@@ -1,35 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-/**
- * Handles agent registration with the Control Plane.
- * This can be used to validate permissions and active status.
- */
-export async function handleRegisterAgent(projectRoot, 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`);
-    try {
-        if (!fs.existsSync(registryDir))
-            fs.mkdirSync(registryDir, { recursive: true });
-        const agentData = {
-            agent,
-            role,
-            capability,
-            specialties,
-            last_seen: new Date().toISOString(),
-            status: "ACTIVE"
-        };
-        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
-        return {
-            content: [{ type: "text", text: `[ATABEY] Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
-        };
-    }
-    catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]
-        };
-    }
-}

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

@@ -1,154 +0,0 @@
-import * as schemas from "./schemas.js";
-import { zodToMcpSchema } from "../utils/zod-to-mcp.js";
-/**
- * ─── SUPREME TOOL REGISTRY ─────────────────────────────────────────
- * Every tool is dynamically generated from its Zod schema.
- * ZERO manual JSON schema maintenance permitted.
- */
-export const TOOLS = [
-    // File System
-    {
-        name: "read_file",
-        description: "Read the content of a file within the project. Supports optional line range reading to prevent stream overload.",
-        inputSchema: zodToMcpSchema(schemas.ReadFileSchema),
-    },
-    {
-        name: "view_file",
-        description: "Alias for read_file. Reads the content of a file within the project.",
-        inputSchema: zodToMcpSchema(schemas.ReadFileSchema),
-    },
-    {
-        name: "write_file",
-        description: "Write content to a file. Creates directories if missing.",
-        inputSchema: zodToMcpSchema(schemas.WriteFileSchema),
-    },
-    {
-        name: "replace_text",
-        description: "Surgically replace a string in a file with another string.",
-        inputSchema: zodToMcpSchema(schemas.ReplaceTextSchema),
-    },
-    {
-        name: "batch_surgical_edit",
-        description: "Perform multiple surgical text replacements across multiple files in a single batch request.",
-        inputSchema: zodToMcpSchema(schemas.BatchSurgicalEditSchema),
-    },
-    {
-        name: "patch_file",
-        description: "Safely update a file by replacing a specific line range with new content.",
-        inputSchema: zodToMcpSchema(schemas.PatchFileSchema),
-    },
-    // Search & Exploration
-    {
-        name: "list_dir",
-        description: "List the contents of a directory. Essential for codebase exploration.",
-        inputSchema: zodToMcpSchema(schemas.ListDirSchema),
-    },
-    {
-        name: "grep_search",
-        description: "Perform a recursive regex search across the codebase.",
-        inputSchema: zodToMcpSchema(schemas.GrepSearchSchema),
-    },
-    {
-        name: "get_project_map",
-        description: "Generate a tree-view map of the project structure.",
-        inputSchema: zodToMcpSchema(schemas.GetProjectMapSchema),
-    },
-    {
-        name: "get_project_gaps",
-        description: "Scans the codebase for TODOs, FIXMEs, and empty function bodies.",
-        inputSchema: zodToMcpSchema(schemas.GetProjectGapsSchema),
-    },
-    // Framework & System
-    {
-        name: "run_shell_command",
-        description: "Execute a shell command. Restricted for security.",
-        inputSchema: zodToMcpSchema(schemas.RunShellCommandSchema),
-    },
-    {
-        name: "run_tests",
-        description: "Execute project test suites and capture pass/fail reports.",
-        inputSchema: zodToMcpSchema(schemas.RunTestsSchema),
-    },
-    {
-        name: "get_system_health",
-        description: "Retrieve real-time system metrics (CPU, RAM).",
-        inputSchema: zodToMcpSchema(schemas.GetSystemHealthSchema),
-    },
-    {
-        name: "check_active_ports",
-        description: "Identify which network ports are currently active.",
-        inputSchema: zodToMcpSchema(schemas.CheckPortsSchema),
-    },
-    {
-        name: "get_framework_status",
-        description: "Get the current project phase, active traces, and agent states.",
-        inputSchema: zodToMcpSchema(schemas.GetFrameworkStatusSchema),
-    },
-    {
-        name: "read_project_memory",
-        description: "Read the full project central memory (PROJECT_MEMORY.md).",
-        inputSchema: zodToMcpSchema(schemas.ReadProjectMemorySchema),
-    },
-    {
-        name: "get_memory_insights",
-        description: "Retrieve a summarized version of the project memory.",
-        inputSchema: zodToMcpSchema(schemas.GetMemoryInsightsSchema),
-    },
-    {
-        name: "update_project_memory",
-        description: "Update a specific section in PROJECT_MEMORY.md.",
-        inputSchema: zodToMcpSchema(schemas.UpdateProjectMemorySchema),
-    },
-    {
-        name: "orchestrate_loop",
-        description: "Process pending Hermes messages and trigger transitions.",
-        inputSchema: zodToMcpSchema(schemas.OrchestrateLoopSchema),
-    },
-    {
-        name: "submit_plan",
-        description: "Submit a structured DAG plan of tasks for the project.",
-        inputSchema: zodToMcpSchema(schemas.SubmitPlanSchema),
-    },
-    {
-        name: "update_contract_hash",
-        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
-        inputSchema: zodToMcpSchema(schemas.UpdateContractHashSchema),
-    },
-    {
-        name: "audit_dependencies",
-        description: "Audits package.json for unused or redundant packages.",
-        inputSchema: zodToMcpSchema(schemas.AuditDependenciesSchema),
-    },
-    {
-        name: "check_lint",
-        description: "Run the project's linter (e.g., ESLint).",
-        inputSchema: zodToMcpSchema(schemas.CheckLintSchema),
-    },
-    // Control Plane
-    {
-        name: "acquire_lock",
-        description: "Acquire a stateful lock on a shared resource.",
-        inputSchema: zodToMcpSchema(schemas.AcquireLockSchema),
-    },
-    {
-        name: "release_lock",
-        description: "Release a previously acquired lock.",
-        inputSchema: zodToMcpSchema(schemas.ReleaseLockSchema),
-    },
-    {
-        name: "register_agent",
-        description: "Register an agent instance with the Control Plane.",
-        inputSchema: zodToMcpSchema(schemas.RegisterAgentSchema),
-    },
-    // Messaging (Hermes)
-    {
-        name: "send_agent_message",
-        description: "Send a Hermes protocol message to another agent.",
-        inputSchema: zodToMcpSchema(schemas.SendAgentMessageSchema),
-    },
-    {
-        name: "log_agent_action",
-        description: "Log an agent action to the framework logs.",
-        inputSchema: zodToMcpSchema(schemas.LogAgentActionSchema),
-    },
-];