agent-enderun 0.7.2 → 0.7.5

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

@@ -0,0 +1,368 @@
+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) }] };
+    },
+};

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

@@ -0,0 +1,267 @@
+import { promises as fs } from "fs";
+import path from "path";
+// ─── Tool Definitions ─────────────────────────────────────────────────────────
+export const pipelineTools = [
+    {
+        name: "create_execution_pipeline",
+        description: "Creates a multi-stage execution pipeline for complex workflows (e.g., build → test → security audit → deploy). Each stage is assigned to a specific agent and has defined dependencies. The pipeline is persisted and can be advanced or rolled back.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                traceId: { type: "string", description: "Active Trace ID from @manager briefing" },
+                name: { type: "string", description: "Pipeline name (e.g. 'Production Deploy v1.2.0')" },
+                description: { type: "string", description: "What this pipeline accomplishes" },
+                stages: {
+                    type: "array",
+                    description: "Ordered pipeline stages",
+                    items: {
+                        type: "object",
+                        required: ["id", "name", "agent"],
+                        properties: {
+                            id: { type: "string" },
+                            name: { type: "string" },
+                            agent: { type: "string" },
+                            dependsOn: { type: "array", items: { type: "string" } },
+                        },
+                    },
+                },
+                rollbackStages: {
+                    type: "array",
+                    description: "Optional rollback stages executed in reverse order on pipeline failure",
+                    items: {
+                        type: "object",
+                        required: ["id", "name", "agent"],
+                        properties: {
+                            id: { type: "string" },
+                            name: { type: "string" },
+                            agent: { type: "string" },
+                            dependsOn: { type: "array", items: { type: "string" } },
+                        },
+                    },
+                },
+            },
+            required: ["traceId", "name", "stages"],
+        },
+    },
+    {
+        name: "advance_pipeline_stage",
+        description: "Advances a pipeline to the next eligible stage. Marks the current stage as COMPLETED and activates all dependent stages that now have their dependencies satisfied. Returns the new pipeline state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pipelineId: { type: "string", description: "Pipeline ID" },
+                completedStageId: { type: "string", description: "The stage that just completed successfully" },
+                stageOutput: { type: "string", description: "Optional output/result from the completed stage" },
+            },
+            required: ["pipelineId", "completedStageId"],
+        },
+    },
+    {
+        name: "rollback_pipeline",
+        description: "Rolls back a pipeline to the last stable state by executing the defined rollback stages in reverse order. Updates the pipeline status to ROLLED_BACK.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pipelineId: { type: "string", description: "Pipeline ID to roll back" },
+                reason: { type: "string", description: "Reason for the rollback (mandatory for audit)" },
+            },
+            required: ["pipelineId", "reason"],
+        },
+    },
+    {
+        name: "get_pipeline_status",
+        description: "Returns the full current status of a pipeline including all stage states, progress percentage, blocking stages, and estimated completion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pipelineId: { type: "string", description: "Pipeline ID" },
+            },
+            required: ["pipelineId"],
+        },
+    },
+];
+// ─── Handlers ─────────────────────────────────────────────────────────────────
+export const pipelineHandlers = {
+    async create_execution_pipeline(args, projectRoot) {
+        const { traceId, name, description, stages, rollbackStages } = args;
+        const pipelineId = `PIPE-${traceId}-${Date.now()}`;
+        const now = new Date().toISOString();
+        const pipeline = {
+            id: pipelineId,
+            traceId,
+            name,
+            description: description ?? "",
+            createdAt: now,
+            updatedAt: now,
+            status: "PENDING",
+            stages: stages.map((s) => ({
+                ...s,
+                dependsOn: s.dependsOn ?? [],
+                status: "PENDING",
+            })),
+            rollbackStages: rollbackStages?.map((s) => ({
+                ...s,
+                dependsOn: s.dependsOn ?? [],
+                status: "PENDING",
+            })),
+        };
+        // Activate stages with no dependencies
+        for (const stage of pipeline.stages) {
+            if (stage.dependsOn.length === 0) {
+                stage.status = "RUNNING";
+                stage.startedAt = now;
+            }
+        }
+        pipeline.status = "RUNNING";
+        // Persist pipeline
+        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+        await fs.mkdir(pipelineDir, { recursive: true });
+        await fs.writeFile(path.join(pipelineDir, `${pipelineId}.json`), JSON.stringify(pipeline, null, 2), "utf-8");
+        return { content: [{ type: "text", text: JSON.stringify(pipeline, null, 2) }] };
+    },
+    async advance_pipeline_stage(args, projectRoot) {
+        const { pipelineId, completedStageId, stageOutput } = args;
+        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+        const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
+        let pipeline;
+        try {
+            const content = await fs.readFile(pipelinePath, "utf-8");
+            pipeline = JSON.parse(content);
+        }
+        catch {
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+                ],
+            };
+        }
+        const now = new Date().toISOString();
+        // Mark completed stage
+        const completedStage = pipeline.stages.find((s) => s.id === completedStageId);
+        if (!completedStage) {
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify({ error: "STAGE_NOT_FOUND", completedStageId }) },
+                ],
+            };
+        }
+        completedStage.status = "COMPLETED";
+        completedStage.completedAt = now;
+        if (stageOutput)
+            completedStage.output = stageOutput;
+        // Activate newly unblocked stages
+        const completedIds = new Set(pipeline.stages.filter((s) => s.status === "COMPLETED").map((s) => s.id));
+        const newlyActivated = [];
+        for (const stage of pipeline.stages) {
+            if (stage.status === "PENDING" && stage.dependsOn.every((dep) => completedIds.has(dep))) {
+                stage.status = "RUNNING";
+                stage.startedAt = now;
+                newlyActivated.push(stage.id);
+            }
+        }
+        // Check if pipeline is complete
+        const allDone = pipeline.stages.every((s) => s.status === "COMPLETED");
+        if (allDone) {
+            pipeline.status = "COMPLETED";
+        }
+        pipeline.updatedAt = now;
+        await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ pipeline, newlyActivatedStages: newlyActivated }, null, 2),
+                },
+            ],
+        };
+    },
+    async rollback_pipeline(args, projectRoot) {
+        const { pipelineId, reason } = args;
+        const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
+        const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
+        let pipeline;
+        try {
+            const content = await fs.readFile(pipelinePath, "utf-8");
+            pipeline = JSON.parse(content);
+        }
+        catch {
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+                ],
+            };
+        }
+        const now = new Date().toISOString();
+        pipeline.status = "ROLLED_BACK";
+        pipeline.updatedAt = now;
+        // Mark all non-completed stages as SKIPPED
+        for (const stage of pipeline.stages) {
+            if (stage.status === "RUNNING" || stage.status === "PENDING") {
+                stage.status = "SKIPPED";
+            }
+        }
+        // Activate rollback stages if defined
+        if (pipeline.rollbackStages) {
+            for (const stage of pipeline.rollbackStages) {
+                stage.status = "RUNNING";
+                stage.startedAt = now;
+            }
+        }
+        await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
+        // Write rollback event to devops log
+        const devopsLogPath = path.join(projectRoot, ".enderun", "logs", "devops.json");
+        let devopsLog = { rollbacks: [] };
+        try {
+            const existing = await fs.readFile(devopsLogPath, "utf-8");
+            devopsLog = JSON.parse(existing);
+            if (!devopsLog.rollbacks)
+                devopsLog.rollbacks = [];
+        }
+        catch {
+            // Start fresh
+        }
+        devopsLog.rollbacks.push({ pipelineId, reason, timestamp: now });
+        await fs.mkdir(path.dirname(devopsLogPath), { recursive: true });
+        await fs.writeFile(devopsLogPath, JSON.stringify(devopsLog, null, 2), "utf-8");
+        return { content: [{ type: "text", text: JSON.stringify({ pipeline, rollbackReason: reason }, null, 2) }] };
+    },
+    async get_pipeline_status(args, projectRoot) {
+        const { pipelineId } = args;
+        const pipelinePath = path.join(projectRoot, ".enderun", "queue", "pipelines", `${pipelineId}.json`);
+        try {
+            const content = await fs.readFile(pipelinePath, "utf-8");
+            const pipeline = JSON.parse(content);
+            const total = pipeline.stages.length;
+            const completed = pipeline.stages.filter((s) => s.status === "COMPLETED").length;
+            const running = pipeline.stages.filter((s) => s.status === "RUNNING").map((s) => s.id);
+            const blocked = pipeline.stages.filter((s) => s.status === "PENDING" && s.dependsOn.some((dep) => {
+                const depStage = pipeline.stages.find((st) => st.id === dep);
+                return depStage && depStage.status !== "COMPLETED";
+            })).map((s) => s.id);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            pipelineId,
+                            name: pipeline.name,
+                            status: pipeline.status,
+                            progress: `${completed}/${total} stages (${Math.round((completed / total) * 100)}%)`,
+                            currentlyRunning: running,
+                            waitingOn: blocked,
+                            createdAt: pipeline.createdAt,
+                            updatedAt: pipeline.updatedAt,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch {
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
+                ],
+            };
+        }
+    },
+};

package/framework-mcp/dist/utils.js

@@ -8,7 +8,7 @@ const getPackageVersion = () => {
         const pkgPath = path.join(__dirname, "../package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.7.1";
+            return pkg.version || "0.7.5";
         }
     }
     catch {
@@ -17,8 +17,30 @@ const getPackageVersion = () => {
     return "0.6.6";
 };
 export const FRAMEWORK_VERSION = getPackageVersion();
-export function getFrameworkDir(_projectRoot) {
-    return ".agents"; // Antigravity-only runtime folder
+/**
+ * Dynamically detects the framework directory for the current project.
+ * Checks in priority order: .enderun → .gemini → .cursor → fallback .gemini
+ * This resolves the adapter mismatch bug (KRITIK-1 in v0.7.5 analysis).
+ */
+export function getFrameworkDir(projectRoot) {
+    const candidates = [".enderun", ".gemini", ".cursor"];
+    for (const dir of candidates) {
+        const dirPath = path.join(projectRoot, dir);
+        if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+            // Verify it looks like a framework dir (has PROJECT_MEMORY.md or agents/ dir)
+            const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md"));
+            const hasAgents = fs.existsSync(path.join(dirPath, "agents"));
+            if (hasMemory || hasAgents) {
+                return dir;
+            }
+        }
+    }
+    // Ultimate fallback — return first existing dir or .gemini
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(projectRoot, dir)))
+            return dir;
+    }
+    return ".gemini";
 }
 export function resolveSafePath(projectRoot, targetPath) {
     const resolved = path.resolve(projectRoot, targetPath);