agent-enderun 0.8.7 → 0.9.0

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

@@ -1,294 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-import { getFrameworkDir } from "../utils.js";
-// ─── Tool Definitions ─────────────────────────────────────────────────────────
-export const monitoringTools = [
-    {
-        name: "get_army_health_dashboard",
-        description: "Returns a comprehensive health dashboard for the entire Agent Enderun Army. Includes agent states, active tasks, health scores, queue depth, and recent blockages. Single call for full army situational awareness.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectRoot: { type: "string", description: "Root directory of the project" },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "calculate_agent_performance_score",
-        description: "Calculates a dynamic performance score for a specific agent based on their last N actions from the audit log. Returns success rate, average execution time, and blockage frequency.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agentName: { type: "string", description: "Agent identifier (e.g. @backend)" },
-                lastN: { type: "number", description: "Number of recent actions to analyze", default: 20 },
-            },
-            required: ["agentName"],
-        },
-    },
-    {
-        name: "detect_bottleneck_agents",
-        description: "Scans all agent logs and STATUS.md to identify agents that are causing delays — either by being BLOCKED, exceeding execution timeout, or having a high blockage frequency. Returns a prioritized list of bottlenecks.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                thresholdMinutes: {
-                    type: "number",
-                    description: "Minutes after which an EXECUTING agent is considered a bottleneck",
-                    default: 30,
-                },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "generate_war_room_report",
-        description: "Generates a crisis-mode summary report for @manager. Includes: all BLOCKED/ERROR agents, unresolved dependencies, critical path analysis, and recommended immediate actions. Designed for high-urgency situations.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: { type: "string", description: "Active Trace ID for the crisis" },
-                crisisDescription: { type: "string", description: "Brief description of the crisis or incident" },
-            },
-            required: ["traceId", "crisisDescription"],
-        },
-    },
-];
-// ─── Handlers ─────────────────────────────────────────────────────────────────
-export const monitoringHandlers = {
-    async get_army_health_dashboard(_args, projectRoot) {
-        const results = {
-            generatedAt: new Date().toISOString(),
-            agents: [],
-            queueDepth: { pending: 0, processing: 0, completed: 0, failed: 0 },
-            recentBlockages: [],
-            recentBroadcasts: [],
-            overallHealth: "GREEN",
-        };
-        // Read STATUS.md
-        const frameworkDir = getFrameworkDir(projectRoot);
-        const statusPath = path.join(projectRoot, frameworkDir, "STATUS.md");
-        try {
-            const statusContent = await fs.readFile(statusPath, "utf-8");
-            const lines = statusContent
-                .split("\n")
-                .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-            results.agents = lines
-                .map((line) => {
-                const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-                return cells.length >= 4
-                    ? {
-                        agent: cells[0],
-                        state: cells[1],
-                        currentTask: cells[2],
-                        blockedBy: cells[3],
-                        healthScore: cells[4] ?? "—",
-                        lastAction: cells[5] ?? "—",
-                    }
-                    : null;
-            })
-                .filter(Boolean);
-        }
-        catch {
-            results.agents = [{ error: "STATUS.md not found or unreadable" }];
-        }
-        // Read queue depths
-        const queueBase = path.join(projectRoot, ".enderun", "queue");
-        for (const subdir of ["pending", "processing", "completed", "failed"]) {
-            try {
-                const files = await fs.readdir(path.join(queueBase, subdir));
-                results.queueDepth[subdir] = files.filter((f) => f.endsWith(".json")).length;
-            }
-            catch {
-                results.queueDepth[subdir] = 0;
-            }
-        }
-        // Read orchestrator log for recent blockages and broadcasts
-        const logPath = path.join(projectRoot, ".enderun", "logs", "orchestrator.json");
-        try {
-            const logContent = await fs.readFile(logPath, "utf-8");
-            const log = JSON.parse(logContent);
-            results.recentBlockages = (log.blockages ?? []).slice(-5);
-            results.recentBroadcasts = (log.broadcasts ?? []).slice(-3);
-        }
-        catch {
-            // No log yet
-        }
-        // Calculate overall health
-        const blockedCount = results.agents.filter((a) => a?.state?.includes("BLOCKED") || a?.state?.includes("ERROR")).length;
-        if (blockedCount >= 3)
-            results.overallHealth = "RED";
-        else if (blockedCount >= 1)
-            results.overallHealth = "YELLOW";
-        else
-            results.overallHealth = "GREEN";
-        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
-    },
-    async calculate_agent_performance_score(args, projectRoot) {
-        const { agentName, lastN } = args;
-        const n = lastN ?? 20;
-        const logName = agentName.replace("@", "") + ".json";
-        const logPath = path.join(projectRoot, ".enderun", "logs", logName);
-        try {
-            const content = await fs.readFile(logPath, "utf-8");
-            const log = JSON.parse(content);
-            const actions = (log.actions ?? []).slice(-n);
-            const total = actions.length;
-            const successful = actions.filter((a) => a.status === "SUCCESS" || a.status === "DONE").length;
-            const successRate = total > 0 ? ((successful / total) * 100).toFixed(1) + "%" : "N/A";
-            const avgDuration = total > 0
-                ? (actions.reduce((sum, a) => sum + (a.durationMs ?? 0), 0) / total).toFixed(0) + "ms"
-                : "N/A";
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            agent: agentName,
-                            analyzedActions: total,
-                            successRate,
-                            averageExecutionTime: avgDuration,
-                            generatedAt: new Date().toISOString(),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            agent: agentName,
-                            error: "No log found or log is empty",
-                            analyzedActions: 0,
-                        }),
-                    },
-                ],
-            };
-        }
-    },
-    async detect_bottleneck_agents(args, projectRoot) {
-        const { thresholdMinutes } = args;
-        const threshold = thresholdMinutes ?? 30;
-        const statusPath = path.join(projectRoot, ".enderun", "STATUS.md");
-        const bottlenecks = [];
-        try {
-            const content = await fs.readFile(statusPath, "utf-8");
-            const lines = content
-                .split("\n")
-                .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-            for (const line of lines) {
-                const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-                if (cells.length < 2)
-                    continue;
-                const [agent, state] = cells;
-                if (state.includes("BLOCKED")) {
-                    bottlenecks.push({ agent, state, reason: "Agent is in BLOCKED state", severity: "CRITICAL" });
-                }
-                else if (state.includes("ERROR")) {
-                    bottlenecks.push({ agent, state, reason: "Agent is in ERROR state", severity: "CRITICAL" });
-                }
-                else if (state.includes("EXECUTING")) {
-                    bottlenecks.push({
-                        agent,
-                        state,
-                        reason: `Agent has been EXECUTING for more than ${threshold} minutes (verify manually)`,
-                        severity: "HIGH",
-                    });
-                }
-            }
-        }
-        catch {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ error: "Could not read STATUS.md" }),
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        bottlenecks,
-                        total: bottlenecks.length,
-                        analysisThresholdMinutes: threshold,
-                        generatedAt: new Date().toISOString(),
-                    }, null, 2),
-                },
-            ],
-        };
-    },
-    async generate_war_room_report(args, projectRoot) {
-        const { traceId, crisisDescription } = args;
-        // Gather all data for the war room report
-        const report = {
-            warRoomReport: true,
-            traceId,
-            crisisDescription,
-            generatedAt: new Date().toISOString(),
-            agentStatuses: [],
-            queueSnapshot: {},
-            recentBlockages: [],
-            immediateActions: [],
-        };
-        // Agent statuses
-        const frameworkDir = getFrameworkDir(projectRoot);
-        const statusPath = path.join(projectRoot, frameworkDir, "STATUS.md");
-        try {
-            const content = await fs.readFile(statusPath, "utf-8");
-            const lines = content
-                .split("\n")
-                .filter((l) => l.includes("|") && !l.includes("---") && !l.includes("Agent"));
-            report.agentStatuses = lines
-                .map((l) => {
-                const cells = l.split("|").map((c) => c.trim()).filter(Boolean);
-                return cells.length >= 2 ? { agent: cells[0], state: cells[1] } : null;
-            })
-                .filter(Boolean);
-        }
-        catch {
-            report.agentStatuses = [];
-        }
-        // Queue snapshot
-        const queueBase = path.join(projectRoot, ".enderun", "queue");
-        const snapshot = {};
-        for (const dir of ["pending", "processing", "completed", "failed"]) {
-            try {
-                const files = await fs.readdir(path.join(queueBase, dir));
-                snapshot[dir] = files.length;
-            }
-            catch {
-                snapshot[dir] = 0;
-            }
-        }
-        report.queueSnapshot = snapshot;
-        // Recent blockages
-        const logPath = path.join(projectRoot, ".enderun", "logs", "orchestrator.json");
-        try {
-            const logContent = await fs.readFile(logPath, "utf-8");
-            const log = JSON.parse(logContent);
-            report.recentBlockages = (log.blockages ?? []).slice(-10);
-        }
-        catch {
-            report.recentBlockages = [];
-        }
-        // Generate recommended immediate actions
-        const blockedAgents = report.agentStatuses.filter((a) => a.state.includes("BLOCKED") || a.state.includes("ERROR"));
-        if (blockedAgents.length > 0) {
-            report.immediateActions.push(`IMMEDIATE: Resolve ${blockedAgents.map((a) => a.agent).join(", ")} blockages — these are on the critical path`);
-        }
-        if ((snapshot["pending"] ?? 0) > 5) {
-            report.immediateActions.push("HIGH: Queue has excessive pending tasks — consider deploying additional agents");
-        }
-        if (report.immediateActions.length === 0) {
-            report.immediateActions.push("No critical immediate actions required — monitor agent states");
-        }
-        return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
-    },
-};

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

@@ -1,368 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-// ─── Tool Definitions ─────────────────────────────────────────────────────────
-export const orchestrationTools = [
-    {
-        name: "create_task_dag",
-        description: "Creates a Directed Acyclic Graph (DAG) of tasks with dependencies. Used by @orchestrator to plan parallel execution. Returns both a JSON structure and a Mermaid diagram for visualization.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: {
-                    type: "string",
-                    description: "Trace ID inherited from @manager briefing. Required.",
-                },
-                tasks: {
-                    type: "array",
-                    description: "Array of task definitions to build the DAG from.",
-                    items: {
-                        type: "object",
-                        required: ["id", "agent", "briefing"],
-                        properties: {
-                            id: { type: "string", description: "Unique task ID (e.g. T001)" },
-                            agent: { type: "string", description: "Assigned agent (e.g. @backend)" },
-                            briefing: { type: "string", description: "Task description" },
-                            dependsOn: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Task IDs that must complete before this task starts",
-                            },
-                            priority: {
-                                type: "string",
-                                enum: ["CRITICAL", "HIGH", "MEDIUM", "LOW"],
-                                default: "MEDIUM",
-                            },
-                        },
-                    },
-                },
-            },
-            required: ["traceId", "tasks"],
-        },
-    },
-    {
-        name: "assign_agent_to_task",
-        description: "Assigns the most capable available agent to a task based on domain and capability score. Checks STATUS.md for agent availability before assigning.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: { type: "string", description: "Active Trace ID" },
-                taskId: { type: "string", description: "Task ID to assign" },
-                domain: {
-                    type: "string",
-                    enum: ["backend", "frontend", "security", "qa", "devops", "mobile", "native", "analysis", "git", "exploration"],
-                    description: "Domain of the task — used to filter eligible agents",
-                },
-                preferredAgent: {
-                    type: "string",
-                    description: "Optional preferred agent. If not available, falls back to capability-based selection.",
-                },
-            },
-            required: ["traceId", "taskId", "domain"],
-        },
-    },
-    {
-        name: "get_agent_workload",
-        description: "Returns the current workload for all agents: active task count, state, current task description, and health score. Used by @orchestrator to make load-aware assignment decisions.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectRoot: { type: "string", description: "Root directory of the project." },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "resolve_agent_blockage",
-        description: "Handles a BLOCKED agent by documenting the blockage, escalating to @manager, and optionally reassigning the task to another eligible agent.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                blockedAgent: { type: "string", description: "The agent identifier that is BLOCKED, e.g. @frontend" },
-                traceId: { type: "string", description: "Active Trace ID" },
-                blockReason: { type: "string", description: "Mandatory description of why the agent is blocked" },
-                reassign: {
-                    type: "boolean",
-                    description: "If true, attempt to find and assign an alternative agent",
-                    default: false,
-                },
-            },
-            required: ["blockedAgent", "traceId", "blockReason"],
-        },
-    },
-    {
-        name: "broadcast_army_directive",
-        description: "Broadcasts a directive message to all agents simultaneously via the Hermes messaging system. Used for war-room mode, policy changes, or global state transitions.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: { type: "string", description: "Active Trace ID" },
-                directiveType: {
-                    type: "string",
-                    enum: [
-                        "WAR_ROOM_ACTIVATE",
-                        "WAR_ROOM_DEACTIVATE",
-                        "CONTRACT_CHANGED",
-                        "PHASE_ROLLBACK",
-                        "POLICY_UPDATE",
-                        "ARMY_PAUSE",
-                        "ARMY_RESUME",
-                    ],
-                    description: "Type of directive being broadcast",
-                },
-                message: { type: "string", description: "Human-readable directive message" },
-                urgency: {
-                    type: "string",
-                    enum: ["IMMEDIATE", "HIGH", "NORMAL"],
-                    default: "NORMAL",
-                },
-            },
-            required: ["traceId", "directiveType", "message"],
-        },
-    },
-];
-// ─── Handlers ─────────────────────────────────────────────────────────────────
-export const orchestrationHandlers = {
-    async create_task_dag(args, projectRoot) {
-        const { traceId, tasks } = args;
-        // Build adjacency structure
-        const dagNodes = tasks.map((t) => ({
-            id: t.id,
-            agent: t.agent,
-            briefing: t.briefing,
-            status: "PENDING",
-            priority: t.priority ?? "MEDIUM",
-            dependsOn: t.dependsOn ?? [],
-        }));
-        // Topological sort to find execution order
-        const executionWaves = [];
-        const resolved = new Set();
-        const remaining = [...dagNodes];
-        while (remaining.length > 0) {
-            const wave = remaining.filter((n) => n.dependsOn.every((dep) => resolved.has(dep)));
-            if (wave.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: "CIRCULAR_DEPENDENCY",
-                                message: "Circular dependency detected in task DAG. Check dependsOn fields.",
-                            }),
-                        },
-                    ],
-                };
-            }
-            executionWaves.push(wave.map((n) => n.id));
-            wave.forEach((n) => {
-                resolved.add(n.id);
-                remaining.splice(remaining.indexOf(n), 1);
-            });
-        }
-        // Generate Mermaid diagram
-        const mermaidLines = ["graph TD"];
-        for (const node of dagNodes) {
-            const label = `${node.id}["${node.agent}: ${node.briefing.slice(0, 40)}..."]`;
-            mermaidLines.push(`  ${node.id}${label}`);
-        }
-        for (const node of dagNodes) {
-            for (const dep of node.dependsOn) {
-                mermaidLines.push(`  ${dep} --> ${node.id}`);
-            }
-        }
-        const dag = {
-            traceId,
-            createdAt: new Date().toISOString(),
-            nodes: dagNodes,
-            executionWaves,
-            mermaid: mermaidLines.join("\n"),
-            parallelOpportunities: executionWaves.filter((w) => w.length > 1).length,
-        };
-        // Persist to queue
-        const queueDir = path.join(projectRoot, ".enderun", "queue", "pending");
-        await fs.mkdir(queueDir, { recursive: true });
-        await fs.writeFile(path.join(queueDir, `${traceId}-dag.json`), JSON.stringify(dag, null, 2), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify(dag, null, 2) }] };
-    },
-    async assign_agent_to_task(args, projectRoot) {
-        const { traceId, taskId, domain, preferredAgent } = args;
-        // Try to load capability roster from shared-facts.json (dynamic — fixes KRITIK-3)
-        let agentCapabilityRoster = [];
-        try {
-            const sharedFactsPath = path.join(projectRoot, ".enderun", "memory-graph", "shared-facts.json");
-            const content = await fs.readFile(sharedFactsPath, "utf-8");
-            const facts = JSON.parse(content);
-            agentCapabilityRoster = facts.agentCapabilityRoster ?? [];
-        }
-        catch {
-            // Fallback to hardcoded map if shared-facts not available
-        }
-        // Build domain → agents map from shared-facts roster
-        // Exclude @manager — @manager does NOT execute specialist tasks
-        const domainMap = {};
-        for (const entry of agentCapabilityRoster) {
-            if (entry.agent === "@manager" || entry.agent === "@orchestrator")
-                continue;
-            const d = entry.primaryDomain;
-            if (!domainMap[d])
-                domainMap[d] = [];
-            domainMap[d].push({ agent: entry.agent, capability: entry.capability });
-        }
-        // Hardcoded fallback (used only if shared-facts unavailable)
-        const fallbackDomainMap = {
-            backend: [{ agent: "@backend", capability: 9.2 }],
-            frontend: [{ agent: "@frontend", capability: 9.0 }],
-            security: [{ agent: "@security", capability: 9.3 }],
-            qa: [{ agent: "@qa", capability: 9.1 }],
-            devops: [{ agent: "@devops", capability: 9.0 }],
-            mobile: [{ agent: "@mobile", capability: 8.8 }],
-            native: [{ agent: "@native", capability: 8.9 }],
-            analysis: [{ agent: "@analyst", capability: 9.6 }],
-            git: [{ agent: "@git", capability: 9.1 }],
-            exploration: [{ agent: "@explorer", capability: 9.4 }],
-        };
-        const effectiveMap = Object.keys(domainMap).length > 0 ? domainMap : fallbackDomainMap;
-        const candidates = effectiveMap[domain] ?? [];
-        let assigned = [...candidates].sort((a, b) => b.capability - a.capability)[0];
-        if (preferredAgent && preferredAgent !== "@manager" && preferredAgent !== "@orchestrator") {
-            const preferred = candidates.find((c) => c.agent === preferredAgent);
-            if (preferred)
-                assigned = preferred;
-        }
-        if (!assigned) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ error: "NO_ELIGIBLE_AGENT", domain, taskId,
-                            note: "@manager and @orchestrator are excluded from task assignment" }),
-                    },
-                ],
-            };
-        }
-        const assignment = {
-            traceId,
-            taskId,
-            assignedAgent: assigned.agent,
-            capabilityScore: assigned.capability,
-            assignedAt: new Date().toISOString(),
-            domain,
-            sourceMap: Object.keys(domainMap).length > 0 ? "shared-facts" : "fallback",
-        };
-        // Write assignment log
-        const logPath = path.join(projectRoot, ".enderun", "logs", "orchestrator.json");
-        let log = { assignments: [] };
-        try {
-            const existing = await fs.readFile(logPath, "utf-8");
-            log = JSON.parse(existing);
-        }
-        catch {
-            // File doesn't exist yet — start fresh
-        }
-        log.assignments.push(assignment);
-        await fs.mkdir(path.dirname(logPath), { recursive: true });
-        await fs.writeFile(logPath, JSON.stringify(log, null, 2), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify(assignment, null, 2) }] };
-    },
-    async get_agent_workload(_args, projectRoot) {
-        const statusPath = path.join(projectRoot, ".enderun", "STATUS.md");
-        let statusContent;
-        try {
-            statusContent = await fs.readFile(statusPath, "utf-8");
-        }
-        catch {
-            statusContent = "";
-        }
-        // Parse the markdown table
-        const lines = statusContent.length > 0
-            ? statusContent.split("\n").filter((l) => l.includes("|") && !l.includes("---"))
-            : [];
-        const agents = lines.length > 1
-            ? lines
-                .slice(1) // skip header
-                .map((line) => {
-                const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-                return cells.length >= 4
-                    ? { agent: cells[0], state: cells[1], currentTask: cells[2], healthScore: cells[4] }
-                    : null;
-            })
-                .filter(Boolean)
-            : [];
-        return { content: [{ type: "text", text: JSON.stringify({ agents, generatedAt: new Date().toISOString() }, null, 2) }] };
-    },
-    async resolve_agent_blockage(args, projectRoot) {
-        const { blockedAgent, traceId, blockReason, reassign } = args;
-        const resolution = {
-            traceId,
-            blockedAgent,
-            blockReason,
-            detectedAt: new Date().toISOString(),
-            escalatedToManager: true,
-            reassignAttempted: reassign ?? false,
-            status: "ESCALATED_TO_MANAGER",
-        };
-        // Log blockage
-        const logPath = path.join(projectRoot, ".enderun", "logs", "orchestrator.json");
-        let log = { assignments: [], blockages: [] };
-        try {
-            const existing = await fs.readFile(logPath, "utf-8");
-            log = JSON.parse(existing);
-            if (!log.blockages)
-                log.blockages = [];
-        }
-        catch {
-            // Start fresh
-        }
-        log.blockages.push(resolution);
-        await fs.mkdir(path.dirname(logPath), { recursive: true });
-        await fs.writeFile(logPath, JSON.stringify(log, null, 2), "utf-8");
-        // Write a message to @manager's inbox via messages folder
-        const messagesDir = path.join(projectRoot, ".enderun", "messages");
-        await fs.mkdir(messagesDir, { recursive: true });
-        const messageFile = path.join(messagesDir, `BLOCKAGE-${traceId}-${Date.now()}.json`);
-        await fs.writeFile(messageFile, JSON.stringify({
-            from: "@orchestrator",
-            to: "@manager",
-            type: "AGENT_BLOCKED",
-            traceId,
-            payload: { blockedAgent, blockReason, resolution },
-            timestamp: new Date().toISOString(),
-        }), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify(resolution, null, 2) }] };
-    },
-    async broadcast_army_directive(args, projectRoot) {
-        const { traceId, directiveType, message, urgency } = args;
-        const broadcast = {
-            id: `BROADCAST-${traceId}-${Date.now()}`,
-            from: "@orchestrator",
-            to: "*",
-            traceId,
-            directiveType,
-            message,
-            urgency: urgency ?? "NORMAL",
-            timestamp: new Date().toISOString(),
-        };
-        // Write to messages folder for all agents
-        const messagesDir = path.join(projectRoot, ".enderun", "messages");
-        await fs.mkdir(messagesDir, { recursive: true });
-        await fs.writeFile(path.join(messagesDir, `${broadcast.id}.json`), JSON.stringify(broadcast, null, 2), "utf-8");
-        // Log broadcast
-        const logPath = path.join(projectRoot, ".enderun", "logs", "orchestrator.json");
-        let log = {
-            assignments: [],
-            blockages: [],
-            broadcasts: [],
-        };
-        try {
-            const existing = await fs.readFile(logPath, "utf-8");
-            log = JSON.parse(existing);
-            if (!log.broadcasts)
-                log.broadcasts = [];
-        }
-        catch {
-            // Start fresh
-        }
-        log.broadcasts.push(broadcast);
-        await fs.writeFile(logPath, JSON.stringify(log, null, 2), "utf-8");
-        return { content: [{ type: "text", text: JSON.stringify(broadcast, null, 2) }] };
-    },
-};