@elixium.ai/mcp-server 0.1.8 → 0.2.0

package/dist/index.js

@@ -113,16 +113,9 @@ const parseLaneStyle = (value) => {
     return null;
 };
 const inferLaneStyleFromUrl = (apiUrl) => {
-    try {
-        const host = new URL(apiUrl).hostname.toLowerCase();
-        if (host === "localhost" || host === "127.0.0.1" || host.endsWith(".local")) {
-            return "title";
-        }
-    }
-    catch {
-        // Fall through to default.
-    }
-    return "upper";
+    // Default to title case as that's what the frontend LaneType enum expects
+    // (e.g., "Backlog", "Current", "Done", "Icebox")
+    return "title";
 };
 const normalizeLaneForComparison = (lane) => {
     if (typeof lane !== "string")
@@ -171,19 +164,91 @@ const resolveBoardId = async () => {
     cachedBoardId = match.id;
     return cachedBoardId;
 };
+// Feature flag caching
+let cachedFeatureConfig = null;
+const FEATURE_FLAG_CACHE_TTL = 60000; // 1 minute
+const fetchFeatureConfig = async () => {
+    const now = Date.now();
+    if (cachedFeatureConfig && now - cachedFeatureConfig.fetchedAt < FEATURE_FLAG_CACHE_TTL) {
+        const { fetchedAt, ...config } = cachedFeatureConfig;
+        return config;
+    }
+    try {
+        const boardId = await resolveBoardId();
+        const response = await client.get("/config/features", {
+            params: boardId ? { boardId } : undefined,
+        });
+        cachedFeatureConfig = {
+            ...response.data,
+            fetchedAt: now,
+        };
+        return response.data;
+    }
+    catch (error) {
+        console.error("Failed to fetch feature config, defaulting to all enabled:", error);
+        return {
+            features: {
+                balancedTeam: true,
+                learningLoop: true,
+                tddWorkflow: true,
+                aiTools: true,
+            },
+            source: {
+                balancedTeam: "error-fallback",
+                learningLoop: "error-fallback",
+                tddWorkflow: "error-fallback",
+                aiTools: "error-fallback",
+            },
+        };
+    }
+};
+// Helper functions to check individual features
+const isTddWorkflowEnabled = async () => {
+    const config = await fetchFeatureConfig();
+    return config.features.tddWorkflow;
+};
+const isLearningLoopEnabled = async () => {
+    const config = await fetchFeatureConfig();
+    return config.features.learningLoop;
+};
+const isAiToolsEnabled = async () => {
+    const config = await fetchFeatureConfig();
+    return config.features.aiTools;
+};
+const getTeamProfile = async () => {
+    const config = await fetchFeatureConfig();
+    return config.teamProfile;
+};
 const fetchStories = async () => {
     const boardId = await resolveBoardId();
+    const slug = normalizeBoardSlug(BOARD_SLUG);
+    const isMainBoard = slug === "main";
+    // For the "main" board, fetch ALL stories (no boardId filter) then filter
+    // client-side. This matches the frontend behavior: legacy stories have
+    // boardId: null and must be included on the main board.
     const response = await client.get("/stories", {
-        params: boardId ? { boardId } : undefined,
+        params: boardId && !isMainBoard ? { boardId } : undefined,
     });
-    return extractStories(response.data);
+    let stories = extractStories(response.data);
+    // Client-side filter for main board: include stories matching boardId OR
+    // with no boardId (legacy stories created before multi-board support)
+    if (boardId && isMainBoard) {
+        stories = stories.filter((s) => s.boardId === boardId || !s.boardId);
+    }
+    return stories;
 };
 const fetchEpics = async () => {
     const boardId = await resolveBoardId();
+    const slug = normalizeBoardSlug(BOARD_SLUG);
+    const isMainBoard = slug === "main";
     const response = await client.get("/epics", {
-        params: boardId ? { boardId } : undefined,
+        params: boardId && !isMainBoard ? { boardId } : undefined,
     });
-    return extractEpics(response.data);
+    let epics = extractEpics(response.data);
+    if (boardId && isMainBoard) {
+        epics = epics.filter((e) => e.boardId === boardId || !e.boardId);
+    }
+    return epics;
 };
 let cachedLaneStyle = null;
 const detectLaneStyle = async () => {
@@ -221,7 +286,15 @@ const normalizeLane = async (lane) => {
 const buildIterationContext = (stories, user = null) => {
     const currentIteration = stories.filter((story) => normalizeLaneForComparison(story?.lane) === "current");
     const backlog = stories.filter((story) => normalizeLaneForComparison(story?.lane) === "backlog");
-    return { currentIteration, backlog, user };
+    // Cost summary across current iteration
+    const iterationStories = [...currentIteration, ...backlog];
+    const withEstimates = iterationStories.filter((s) => s.costEstimate);
+    const costSummary = {
+        totalMonthlyCost: withEstimates.reduce((sum, s) => sum + (s.costEstimate?.totalMonthlyCost || 0), 0),
+        estimatedCount: withEstimates.length,
+        unestimatedCount: iterationStories.length - withEstimates.length,
+    };
+    return { currentIteration, backlog, user, costSummary };
 };
 const createServer = () => {
     const server = new Server({
@@ -234,302 +307,432 @@ const createServer = () => {
     });
     // Define Tools
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        return {
-            tools: [
-                {
-                    name: "list_stories",
-                    description: "List all stories on the Elixium board",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
+        const featureConfig = await fetchFeatureConfig();
+        const tddEnabled = featureConfig.features.tddWorkflow;
+        const learningLoopEnabled = featureConfig.features.learningLoop;
+        const baseTools = [
+            {
+                name: "get_feature_config",
+                description: "Get the feature configuration for this board/workspace. Returns enabled features, team profile, and smart defaults context.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
                 },
-                {
-                    name: "create_story",
-                    description: "Create a new story on the Elixium board",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            title: { type: "string", description: "Title of the story" },
-                            description: {
-                                type: "string",
-                                description: "Description of the story",
-                            },
-                            acceptanceCriteria: {
-                                type: "string",
-                                description: "Acceptance criteria in Given/When/Then format",
-                            },
-                            lane: {
-                                type: "string",
-                                description: "Lane to add the story to (case-insensitive)",
-                                enum: [
-                                    "Backlog",
-                                    "Icebox",
-                                    "Current",
-                                    "Done",
-                                    "BACKLOG",
-                                    "ICEBOX",
-                                    "CURRENT",
-                                    "DONE",
-                                ],
-                            },
-                            points: {
-                                type: "number",
-                                description: "Points (0, 1, 2, 3, 5, 8)",
-                            },
-                            requester: {
-                                type: "string",
-                                description: "Email of the person requesting this story. Defaults to ELIXIUM_USER_EMAIL env var or API key owner.",
-                            },
-                        },
-                        required: ["title"],
-                    },
+            },
+            {
+                name: "list_stories",
+                description: "List all stories on the Elixium board",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
                 },
-                {
-                    name: "get_iteration_context",
-                    description: "Get the current iteration context (Current + Backlog) for AI planning",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
+            },
+            {
+                name: "create_story",
+                description: "Create a new story on the Elixium board",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Title of the story" },
+                        description: {
+                            type: "string",
+                            description: "Description of the story",
+                        },
+                        acceptanceCriteria: {
+                            type: "string",
+                            description: "Acceptance criteria in Given/When/Then format",
+                        },
+                        lane: {
+                            type: "string",
+                            description: "Lane to add the story to (case-insensitive)",
+                            enum: [
+                                "Backlog",
+                                "Icebox",
+                                "Current",
+                                "Done",
+                                "BACKLOG",
+                                "ICEBOX",
+                                "CURRENT",
+                                "DONE",
+                            ],
+                        },
+                        points: {
+                            type: "number",
+                            description: "Points (0, 1, 2, 3, 5, 8)",
+                        },
+                        requester: {
+                            type: "string",
+                            description: "Email of the person requesting this story. Defaults to ELIXIUM_USER_EMAIL env var or API key owner.",
+                        },
                     },
+                    required: ["title"],
+                },
+            },
+            {
+                name: "get_iteration_context",
+                description: "Get the current iteration context (Current + Backlog) for AI planning",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "list_objectives",
+                description: "List objectives for the current workspace",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "list_epics",
+                description: "List epics for the current board",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
                 },
-                {
-                    name: "create_hypothesis",
-                    description: "Create a new assumption/hypothesis in the Icebox",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            title: { type: "string", description: "The assumption statement" },
-                            hypothesis: { type: "string", description: "Detailed hypothesis" },
-                            confidence_score: {
-                                type: "number",
-                                description: "Initial confidence (1-5)",
-                                minimum: 1,
-                                maximum: 5,
-                            },
-                        },
-                        required: ["title", "hypothesis", "confidence_score"],
+            },
+            {
+                name: "create_epic",
+                description: "Create a new epic for the current board",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Epic title" },
+                        description: { type: "string", description: "Epic description" },
+                        stage: {
+                            type: "string",
+                            description: "Roadmap stage",
+                            enum: ["in_progress", "next", "soon", "someday", "archived"],
+                        },
+                        hypothesis: { type: "string", description: "We believe that... (outcome hypothesis)" },
+                        successMetrics: { type: "string", description: "We'll know it works when... (success criteria)" },
+                        targetDate: { type: "number", description: "Unix timestamp - when to evaluate outcome (not ship date)" },
+                        outcomeStatus: {
+                            type: "string",
+                            description: "Outcome validation status",
+                            enum: ["exploring", "validating", "achieved", "abandoned"],
+                        },
                     },
+                    required: ["title"],
                 },
-                {
-                    name: "list_objectives",
-                    description: "List objectives for the current workspace",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
+            },
+            {
+                name: "update_epic",
+                description: "Update an epic (title, description, stage, or outcome fields)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        epicId: { type: "string", description: "ID of the epic" },
+                        title: { type: "string", description: "Epic title" },
+                        description: { type: "string", description: "Epic description" },
+                        stage: {
+                            type: "string",
+                            description: "Roadmap stage",
+                            enum: ["in_progress", "next", "soon", "someday", "archived"],
+                        },
+                        hypothesis: { type: "string", description: "We believe that... (outcome hypothesis)" },
+                        successMetrics: { type: "string", description: "We'll know it works when... (success criteria)" },
+                        targetDate: { type: "number", description: "Unix timestamp - when to evaluate outcome (not ship date)" },
+                        outcomeStatus: {
+                            type: "string",
+                            description: "Outcome validation status",
+                            enum: ["exploring", "validating", "achieved", "abandoned"],
+                        },
                     },
+                    required: ["epicId"],
                 },
-                {
-                    name: "record_learning",
-                    description: "Record a learning outcome for a completed story",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: { type: "string", description: "ID of the story" },
-                            outcome_summary: {
-                                type: "string",
-                                description: "What was learned?",
-                            },
-                        },
-                        required: ["storyId", "outcome_summary"],
+            },
+            {
+                name: "update_story",
+                description: "Update fields on an existing story",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: { type: "string", description: "ID of the story" },
+                        title: { type: "string", description: "Updated title" },
+                        description: { type: "string", description: "Updated description" },
+                        lane: {
+                            type: "string",
+                            description: "Lane to move the story to (case-insensitive)",
+                            enum: [
+                                "Backlog",
+                                "Icebox",
+                                "Current",
+                                "Done",
+                                "BACKLOG",
+                                "ICEBOX",
+                                "CURRENT",
+                                "DONE",
+                            ],
+                        },
+                        points: {
+                            type: "number",
+                            description: "Updated points (0, 1, 2, 3, 5, 8)",
+                        },
+                        state: {
+                            type: "string",
+                            description: "Story state (unstarted, started, finished, delivered, accepted, rejected)",
+                        },
+                        outcome_summary: {
+                            type: "string",
+                            description: "Learning outcome summary",
+                        },
+                        acceptanceCriteria: {
+                            type: "string",
+                            description: "Acceptance criteria in Given/When/Then format",
+                        },
                     },
+                    required: ["storyId"],
                 },
-                {
-                    name: "list_epics",
-                    description: "List epics for the current board",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
+            },
+            {
+                name: "prepare_implementation",
+                description: "Fetch all context for a story and format an implementation brief",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story to prepare",
+                        },
                     },
+                    required: ["storyId"],
                 },
-                {
-                    name: "create_epic",
-                    description: "Create a new epic for the current board",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            title: { type: "string", description: "Epic title" },
-                            description: { type: "string", description: "Epic description" },
-                            stage: {
-                                type: "string",
-                                description: "Roadmap stage",
-                                enum: ["in_progress", "next", "soon", "someday", "archived"],
-                            },
-                            hypothesis: { type: "string", description: "We believe that... (outcome hypothesis)" },
-                            successMetrics: { type: "string", description: "We'll know it works when... (success criteria)" },
-                            targetDate: { type: "number", description: "Unix timestamp - when to evaluate outcome (not ship date)" },
-                            outcomeStatus: {
-                                type: "string",
-                                description: "Outcome validation status",
-                                enum: ["exploring", "validating", "achieved", "abandoned"],
-                            },
-                        },
-                        required: ["title"],
+            },
+            {
+                name: "estimate_cost",
+                description: "Generate AI-assisted infrastructure cost estimate for a story. Uses live cloud pricing data when available.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story to estimate cost for",
+                        },
+                        provider: {
+                            type: "string",
+                            description: "Cloud provider for the estimate",
+                            enum: ["gcp", "aws", "azure", "self-hosted"],
+                        },
+                        constraints: {
+                            type: "string",
+                            description: "Optional constraints (e.g., budget limit, region, instance types)",
+                        },
                     },
+                    required: ["storyId", "provider"],
                 },
-                {
-                    name: "update_epic",
-                    description: "Update an epic (title, description, stage, or outcome fields)",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            epicId: { type: "string", description: "ID of the epic" },
-                            title: { type: "string", description: "Epic title" },
-                            description: { type: "string", description: "Epic description" },
-                            stage: {
-                                type: "string",
-                                description: "Roadmap stage",
-                                enum: ["in_progress", "next", "soon", "someday", "archived"],
-                            },
-                            hypothesis: { type: "string", description: "We believe that... (outcome hypothesis)" },
-                            successMetrics: { type: "string", description: "We'll know it works when... (success criteria)" },
-                            targetDate: { type: "number", description: "Unix timestamp - when to evaluate outcome (not ship date)" },
-                            outcomeStatus: {
-                                type: "string",
-                                description: "Outcome validation status",
-                                enum: ["exploring", "validating", "achieved", "abandoned"],
-                            },
-                        },
-                        required: ["epicId"],
+            },
+            {
+                name: "get_epic_cost_rollup",
+                description: "Get aggregated infrastructure cost for all stories in an epic. Shows total monthly cost, category breakdown, and estimation coverage.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        epicId: {
+                            type: "string",
+                            description: "ID of the epic",
+                        },
                     },
+                    required: ["epicId"],
                 },
-                {
-                    name: "update_story",
-                    description: "Update fields on an existing story",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: { type: "string", description: "ID of the story" },
-                            title: { type: "string", description: "Updated title" },
-                            description: { type: "string", description: "Updated description" },
-                            lane: {
-                                type: "string",
-                                description: "Lane to move the story to (case-insensitive)",
-                                enum: [
-                                    "Backlog",
-                                    "Icebox",
-                                    "Current",
-                                    "Done",
-                                    "BACKLOG",
-                                    "ICEBOX",
-                                    "CURRENT",
-                                    "DONE",
-                                ],
-                            },
-                            points: {
-                                type: "number",
-                                description: "Updated points (0, 1, 2, 3, 5, 8)",
-                            },
-                            state: {
-                                type: "string",
-                                description: "Story state (unstarted, started, finished, delivered, accepted, rejected)",
-                            },
-                            outcome_summary: {
-                                type: "string",
-                                description: "Learning outcome summary",
-                            },
-                            acceptanceCriteria: {
-                                type: "string",
-                                description: "Acceptance criteria in Given/When/Then format",
-                            },
-                        },
-                        required: ["storyId"],
+            },
+        ];
+        const tddTools = tddEnabled ? [
+            // TDD Workflow Tools
+            {
+                name: "start_story",
+                description: "Start TDD workflow for a story. By default creates a feature branch. Set trunkBased=true to work directly on main (recommended for small changes). Set autoMerge=true with trunkBased for short-lived branches that auto-merge on submit.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story to start",
+                        },
+                        branchPrefix: {
+                            type: "string",
+                            description: "Branch prefix (feat, fix, chore) - ignored if trunkBased=true without autoMerge",
+                            enum: ["feat", "fix", "chore"],
+                        },
+                        trunkBased: {
+                            type: "boolean",
+                            description: "If true, use trunk-based development. Without autoMerge, commits directly to main with feature flag. With autoMerge, creates a short-lived branch. Board/workspace defaults apply if not set.",
+                        },
+                        autoMerge: {
+                            type: "boolean",
+                            description: "If true with trunkBased, creates a short-lived branch that auto-merges to main on submit_for_review. Branch is deleted after merge.",
+                        },
                     },
+                    required: ["storyId"],
                 },
-                {
-                    name: "prepare_implementation",
-                    description: "Fetch all context for a story and format an implementation brief",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: {
-                                type: "string",
-                                description: "ID of the story to prepare",
-                            },
-                        },
-                        required: ["storyId"],
+            },
+            {
+                name: "propose_test_plan",
+                description: "Submit a test plan for human review. Sets workflow_stage to tests_proposed. Implementation is BLOCKED until human approves.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story",
+                        },
+                        testPlan: {
+                            type: "string",
+                            description: "Markdown test plan describing test strategy",
+                        },
+                        testFilePaths: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Paths to created test files",
+                        },
                     },
+                    required: ["storyId", "testPlan"],
                 },
-                // TDD Workflow Tools
-                {
-                    name: "start_story",
-                    description: "Start TDD workflow for a story. By default creates a feature branch. Set trunkBased=true to work directly on main (recommended for small changes).",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: {
-                                type: "string",
-                                description: "ID of the story to start",
-                            },
-                            branchPrefix: {
-                                type: "string",
-                                description: "Branch prefix (feat, fix, chore) - ignored if trunkBased=true",
-                                enum: ["feat", "fix", "chore"],
-                            },
-                            trunkBased: {
-                                type: "boolean",
-                                description: "If true, skip branch creation and commit directly to main. Recommended for small, well-tested changes.",
-                            },
-                        },
-                        required: ["storyId"],
+            },
+            {
+                name: "submit_for_review",
+                description: "Submit implementation for human review. Only works if tests are approved. Sets state to finished.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story",
+                        },
+                        commitHash: {
+                            type: "string",
+                            description: "Latest commit SHA",
+                        },
+                        testResults: {
+                            type: "string",
+                            description: "Test output summary",
+                        },
+                        implementationNotes: {
+                            type: "string",
+                            description: "What was implemented",
+                        },
                     },
+                    required: ["storyId"],
                 },
-                {
-                    name: "propose_test_plan",
-                    description: "Submit a test plan for human review. Sets workflow_stage to tests_proposed. Implementation is BLOCKED until human approves.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: {
-                                type: "string",
-                                description: "ID of the story",
-                            },
-                            testPlan: {
-                                type: "string",
-                                description: "Markdown test plan describing test strategy",
-                            },
-                            testFilePaths: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Paths to created test files",
-                            },
-                        },
-                        required: ["storyId", "testPlan"],
+            },
+        ] : [];
+        // Learning Loop tools (conditional on feature flag)
+        const learningLoopTools = learningLoopEnabled ? [
+            {
+                name: "create_hypothesis",
+                description: "Create a new assumption/hypothesis in the Icebox for validation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "The assumption statement" },
+                        hypothesis: { type: "string", description: "Detailed hypothesis" },
+                        confidence_score: {
+                            type: "number",
+                            description: "Initial confidence (1-5)",
+                            minimum: 1,
+                            maximum: 5,
+                        },
                     },
+                    required: ["title", "hypothesis", "confidence_score"],
                 },
-                {
-                    name: "submit_for_review",
-                    description: "Submit implementation for human review. Only works if tests are approved. Sets state to finished.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            storyId: {
-                                type: "string",
-                                description: "ID of the story",
-                            },
-                            commitHash: {
-                                type: "string",
-                                description: "Latest commit SHA",
-                            },
-                            testResults: {
-                                type: "string",
-                                description: "Test output summary",
-                            },
-                            implementationNotes: {
-                                type: "string",
-                                description: "What was implemented",
-                            },
-                        },
-                        required: ["storyId"],
+            },
+            {
+                name: "record_learning",
+                description: "Record a learning outcome for a completed story",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: { type: "string", description: "ID of the story" },
+                        outcome_summary: {
+                            type: "string",
+                            description: "What was learned?",
+                        },
                     },
+                    required: ["storyId", "outcome_summary"],
                 },
-            ],
-        };
+            },
+        ] : [];
+        return { tools: [...baseTools, ...tddTools, ...learningLoopTools] };
     });
     // Handle Requests
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         try {
-            switch (request.params.name) {
+            const toolName = request.params.name;
+            // Check TDD workflow tools
+            const tddWorkflowTools = ["start_story", "propose_test_plan", "submit_for_review"];
+            if (tddWorkflowTools.includes(toolName)) {
+                const enabled = await isTddWorkflowEnabled();
+                if (!enabled) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "TDD workflow is disabled",
+                                    message: "The TDD workflow feature is currently disabled for this board. Contact your workspace administrator to enable it.",
+                                    help: "TDD workflow can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
+            // Check Learning Loop tools
+            const learningLoopTools = ["create_hypothesis", "record_learning"];
+            if (learningLoopTools.includes(toolName)) {
+                const enabled = await isLearningLoopEnabled();
+                if (!enabled) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Learning Loop is disabled",
+                                    message: "The Learning Loop feature is currently disabled for this board. This feature includes hypothesis tracking and confidence scoring.",
+                                    help: "Learning Loop can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
+            switch (toolName) {
+                case "get_feature_config": {
+                    const config = await fetchFeatureConfig();
+                    const formattedConfig = `
+# Workspace Feature Configuration
+
+## Enabled Features
+${config.features.balancedTeam ? "✅" : "❌"} **Balanced Team** - Design URLs, Three Amigos checks, OKR linking
+${config.features.learningLoop ? "✅" : "❌"} **Learning Loop** - Hypothesis tracking, risk profiles, confidence scores
+${config.features.tddWorkflow ? "✅" : "❌"} **TDD Workflow** - Test-driven development enforcement
+${config.features.aiTools ? "✅" : "❌"} **AI Tools** - AI-powered suggestions and analysis
+
+## Team Profile
+${config.teamProfile ? `
+- Team Size: ${config.teamProfile.teamSize || "Not set"}
+- Has Designer: ${config.teamProfile.hasDesigner ? "Yes" : "No"}
+- Has Product Manager: ${config.teamProfile.hasProductManager ? "Yes" : "No"}
+- Has QA: ${config.teamProfile.hasQA ? "Yes" : "No"}
+- Development Approach: ${config.teamProfile.developmentApproach || "Not set"}
+` : "Team profile not configured"}
+
+## Feature Sources
+- Balanced Team: ${config.source.balancedTeam}
+- Learning Loop: ${config.source.learningLoop}
+- TDD Workflow: ${config.source.tddWorkflow}
+- AI Tools: ${config.source.aiTools}
+
+## Branching Strategy Defaults
+${config.branchingDefaults ? `- Trunk-Based: ${config.branchingDefaults.trunkBased ? "Yes" : "No"}
+- Auto-Merge: ${config.branchingDefaults.autoMerge ? "Yes" : "No"}
+- Source: ${config.branchingDefaults.source}` : "Not configured (branch-based default)"}
+
+> **Tip:** Features can be configured at workspace or board level. Board settings override workspace defaults.
+`;
+                    return {
+                        content: [{ type: "text", text: formattedConfig.trim() }],
+                    };
+                }
                 case "list_stories": {
                     const stories = await fetchStories();
                     return {
@@ -542,6 +745,12 @@ const createServer = () => {
                     const args = request.params.arguments;
                     const normalizedLane = await normalizeLane(args.lane);
                     const boardId = await resolveBoardId();
+                    // Warn if no boardId - stories may not appear on board UI
+                    if (!boardId) {
+                        console.warn("Warning: ELIXIUM_BOARD_SLUG is not set or board not found. " +
+                            "Stories created without boardId may not appear on the board UI. " +
+                            "Set ELIXIUM_BOARD_SLUG in your MCP configuration.");
+                    }
                     // Use requester from args, fall back to env var, then let backend use API key owner
                     const requester = args.requester || USER_EMAIL;
                     const response = await client.post("/stories", {
@@ -724,35 +933,68 @@ Here’s the smallest change that will validate it:
                 // TDD Workflow Handlers
                 case "start_story": {
                     const args = request.params.arguments;
-                    const { storyId, branchPrefix, trunkBased } = args;
+                    const { storyId, branchPrefix, trunkBased, autoMerge } = args;
                     if (!storyId) {
                         throw new Error("storyId is required");
                     }
                     const response = await client.post(`/stories/${storyId}/start`, {
                         branchPrefix: branchPrefix || "feat",
-                        trunkBased: trunkBased || false,
+                        trunkBased,
+                        autoMerge,
                     });
                     const result = response.data;
-                    const isTrunk = trunkBased || result.branch === "main";
-                    const formattedResult = isTrunk ? `
+                    const isTrunk = result.trunkBased;
+                    const isAutoMerge = result.autoMerge;
+                    let formattedResult;
+                    if (isTrunk && !isAutoMerge) {
+                        formattedResult = `
 # Story Started (Trunk-Based): ${storyId}
 
-**Mode:** 🚀 Direct to main (trunk-based development)
+**Mode:** Direct to main (trunk-based development)
+**Feature Flag:** \`${result.featureFlagName || "none"}\`
 **Workflow Stage:** ${result.workflow_stage}
 
 ## Acceptance Criteria
 ${result.acceptance_criteria || "No specific AC provided."}
 
 ## Trunk-Based Workflow
-1. ✅ Write tests first
-2. ✅ Call \`propose_test_plan\` and wait for approval
-3. ✅ Implement (make tests pass)
-4. ✅ Run \`npm run build\` to verify
-5. ✅ Commit directly to main
-6. 🚀 Auto-deploy on green CI
-
-> ⚠️ **TDD Workflow:** Write tests first, then call \`propose_test_plan\` before implementing.
-` : `
+1. Write tests first
+2. Call \`propose_test_plan\` and wait for approval
+3. Implement (make tests pass)
+4. Run \`npm run build\` to verify
+5. Commit directly to main behind feature flag \`${result.featureFlagName}\`
+6. Auto-deploy on green CI
+
+> **Feature Flag:** Wrap new behavior with \`${result.featureFlagName}\` for safe isolation.
+> **TDD Workflow:** Write tests first, then call \`propose_test_plan\` before implementing.
+`;
+                    }
+                    else if (isTrunk && isAutoMerge) {
+                        formattedResult = `
+# Story Started (Trunk-Based + Auto-Merge): ${storyId}
+
+**Mode:** Short-lived branch with auto-merge to main
+**Branch:** \`${result.branch}\`
+**Feature Flag:** \`${result.featureFlagName || "none"}\`
+**Workflow Stage:** ${result.workflow_stage}
+
+## Acceptance Criteria
+${result.acceptance_criteria || "No specific AC provided."}
+
+## Auto-Merge Workflow
+1. Write tests first on branch \`${result.branch}\`
+2. Call \`propose_test_plan\` and wait for approval
+3. Implement (make tests pass)
+4. Run \`npm run build\` to verify
+5. Call \`submit_for_review\` — branch auto-merges to main if tests pass
+6. Branch is deleted after merge
+
+> **Feature Flag:** Wrap new behavior with \`${result.featureFlagName}\` for safe isolation.
+> **TDD Workflow:** Write tests first, then call \`propose_test_plan\` before implementing.
+`;
+                    }
+                    else {
+                        formattedResult = `
 # Story Started: ${storyId}
 
 **Branch:** \`${result.branch}\`
@@ -764,8 +1006,9 @@ ${result.acceptance_criteria || "No specific AC provided."}
 ## Next Steps
 ${result.workflow_reminder}
 
-> ⚠️ **TDD Workflow:** Write tests first, then call \`propose_test_plan\` before implementing.
+> **TDD Workflow:** Write tests first, then call \`propose_test_plan\` before implementing.
 `;
+                    }
                     return {
                         content: [{ type: "text", text: formattedResult.trim() }],
                     };
@@ -814,6 +1057,25 @@ ${result.message}
                         implementationNotes,
                     });
                     const result = response.data;
+                    const isAutoMerge = result.autoMerge;
+                    let autoMergeSection = "";
+                    if (isAutoMerge && result.autoMergeInstructions) {
+                        const instr = result.autoMergeInstructions;
+                        autoMergeSection = `
+## Auto-Merge Instructions
+**Action:** Merge \`${instr.sourceBranch}\` into \`${instr.targetBranch}\`
+**Delete branch after merge:** Yes
+
+Run these git commands:
+\`\`\`bash
+git checkout main && git pull
+git merge ${instr.sourceBranch}
+git push origin main
+git push origin --delete ${instr.sourceBranch}
+git branch -d ${instr.sourceBranch}
+\`\`\`
+`;
+                    }
                     const formattedResult = `
 # Implementation Submitted for Review
 
@@ -821,17 +1083,141 @@ ${result.message}
 **Status:** ${result.status}
 **Workflow Stage:** ${result.workflow_stage}
 **State:** ${result.state}
+${result.trunkBased ? `**Mode:** Trunk-based${isAutoMerge ? " + Auto-merge" : ""}` : ""}
+${result.featureFlagName ? `**Feature Flag:** \`${result.featureFlagName}\`` : ""}
 
 ## Branch
-\`${result.branch || "No branch recorded"}\`
+\`${result.branch || "main (trunk-based)"}\`
 
 ## Commits
 ${(result.commit_hashes || []).map((h) => `- \`${h}\``).join("\n") || "No commits recorded"}
-
+${autoMergeSection}
 ## Next Step
 ${result.next_step}
 
-> ✅ **Ready for Review:** Human should review diff and move story to Done lane.
+> ${isAutoMerge
+                        ? "**Auto-Merge:** Execute the git commands above to merge and clean up the branch."
+                        : "**Ready for Review:** Human should review diff and move story to Done lane."}
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
+                case "estimate_cost": {
+                    const args = request.params.arguments;
+                    const { storyId, provider, constraints } = args;
+                    if (!storyId)
+                        throw new Error("storyId is required");
+                    if (!provider)
+                        throw new Error("provider is required");
+                    if (!["gcp", "aws", "azure", "self-hosted"].includes(provider)) {
+                        throw new Error("provider must be one of: gcp, aws, azure, self-hosted");
+                    }
+                    // Fetch the story to get title and description
+                    const storyRes = await client.get(`/stories/${storyId}`);
+                    const storyData = storyRes.data;
+                    if (!storyData.description) {
+                        throw new Error("Story needs a description before cost estimation");
+                    }
+                    // Call the AI estimate-cost endpoint
+                    const estimateRes = await client.post("/ai/estimate-cost", {
+                        storyTitle: storyData.title,
+                        description: storyData.description,
+                        provider,
+                        ...(constraints ? { constraints } : {}),
+                    });
+                    const estimate = estimateRes.data;
+                    // Save the estimate to the story
+                    await client.patch(`/stories/${storyId}`, {
+                        costEstimate: estimate,
+                    });
+                    // Format result as markdown
+                    const componentTable = estimate.components
+                        .map((c) => provider === "self-hosted"
+                        ? `| ${c.name} | ${c.category} | ${c.resourceUnits || "-"} |`
+                        : `| ${c.name} | ${c.category} | $${c.monthlyCost?.toFixed(2)} | ${c.resourceUnits || "-"} |`)
+                        .join("\n");
+                    const tableHeader = provider === "self-hosted"
+                        ? "| Component | Category | Resources |\n|-----------|----------|-----------|\n"
+                        : "| Component | Category | Monthly Cost | Resources |\n|-----------|----------|-------------|------------|\n";
+                    const formattedResult = `
+# Cost Estimate: ${storyData.title}
+
+**Provider:** ${provider.toUpperCase()}
+**Confidence:** ${estimate.confidence}
+**Pricing Source:** ${estimate.pricingSource === "live" ? "Live API data" : "AI-estimated"}
+${provider !== "self-hosted" ? `**Total Monthly Cost:** $${estimate.totalMonthlyCost?.toLocaleString()}/mo` : "**Mode:** Self-hosted (resource units only)"}
+
+## Components
+${tableHeader}${componentTable}
+
+## Assumptions
+${(estimate.assumptions || []).map((a) => `- ${a}`).join("\n")}
+
+> Estimate saved to story ${storyId}.
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
+                case "get_epic_cost_rollup": {
+                    const args = request.params.arguments;
+                    const { epicId } = args;
+                    if (!epicId)
+                        throw new Error("epicId is required");
+                    // Fetch all stories and filter by epicId
+                    const allStories = await fetchStories();
+                    const epicStories = allStories.filter((s) => s.epicId === epicId);
+                    // Fetch epic info
+                    const epicsRes = await client.get("/epics");
+                    const epicsData = Array.isArray(epicsRes.data) ? epicsRes.data : [];
+                    const epic = epicsData.find((e) => e.id === epicId);
+                    const epicTitle = epic?.title || epicId;
+                    const estimated = epicStories.filter((s) => s.costEstimate);
+                    const unestimated = epicStories.filter((s) => !s.costEstimate);
+                    if (estimated.length === 0) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `# Cost Rollup: ${epicTitle}\n\nNo stories have cost estimates yet. Use \`estimate_cost\` to estimate individual stories first.\n\n**Stories without estimates:** ${unestimated.length}`,
+                                }],
+                        };
+                    }
+                    let totalMonthlyCost = 0;
+                    const byCategory = {};
+                    const providerCounts = {};
+                    estimated.forEach((s) => {
+                        const est = s.costEstimate;
+                        totalMonthlyCost += est.totalMonthlyCost || 0;
+                        providerCounts[est.provider] = (providerCounts[est.provider] || 0) + 1;
+                        (est.components || []).forEach((comp) => {
+                            byCategory[comp.category] = (byCategory[comp.category] || 0) + (comp.monthlyCost || 0);
+                        });
+                    });
+                    const providers = Object.keys(providerCounts);
+                    const providerSummary = providers.length === 1
+                        ? providers[0].toUpperCase()
+                        : providers.map((p) => `${p.toUpperCase()} (${providerCounts[p]})`).join(", ");
+                    const categoryBreakdown = Object.entries(byCategory)
+                        .sort(([, a], [, b]) => b - a)
+                        .map(([cat, cost]) => `| ${cat} | $${cost.toFixed(2)} |`)
+                        .join("\n");
+                    const formattedResult = `
+# Cost Rollup: ${epicTitle}
+
+**Total Monthly Cost:** $${totalMonthlyCost.toLocaleString(undefined, { minimumFractionDigits: 2 })}/mo
+**Coverage:** ${estimated.length} of ${epicStories.length} stories estimated
+**Provider(s):** ${providerSummary}
+
+## Cost by Category
+| Category | Monthly Cost |
+|----------|-------------|
+${categoryBreakdown}
+
+## Stories Without Estimates
+${unestimated.length === 0
+                        ? "All stories have been estimated!"
+                        : unestimated.map((s) => `- ${s.title} (${s.id})`).join("\n")}
 `;
                     return {
                         content: [{ type: "text", text: formattedResult.trim() }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elixium.ai/mcp-server",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "type": "module",
   "description": "MCP Server for Elixium.ai",
   "publishConfig": {