@elixium.ai/mcp-server 0.4.0 → 0.5.0

package/README.md

@@ -125,6 +125,30 @@ If you're using multiple MCP servers, combine them in the same config:
 > If you set `ELIXIUM_BOARD_SLUG`, the MCP server will only read/write stories for that board.
 > The server resolves the board slug to a boardId on startup, so the slug must match an existing board.
 
+## Required Scopes (for Scoped API Keys)
+
+If you generate a **scoped** API key (via the Command Center → Integrations → *Advanced: Key Scopes*), the key must include the scopes below to use the corresponding MCP tools. An **unscoped** key (all scopes picker collapsed when generating) has full access and works with every tool.
+
+| Tool category | Tools | Required scopes |
+|---|---|---|
+| **Read stories** | `list_stories`, `get_story`, `get_iteration_context`, `prepare_implementation`, `estimate_cost` | `stories:read` |
+| **Write stories** | `create_story`, `update_story`, `start_story`, `propose_test_plan`, `submit_for_review`, `record_learning`, `create_hypothesis` | `stories:read` + `stories:write` |
+| **Read epics** | `list_epics`, `get_epic_cost_rollup` | `epics:read` |
+| **Write epics** | `create_epic`, `update_epic`, `prioritize_epic` | `epics:read` + `epics:write` |
+| **Read boards** | `list_boards`, `select_board` | `boards:read` |
+| **Write boards** | `create_board` | `boards:read` + `boards:write` |
+| **Read workspace config** | `get_feature_config`, `get_infrastructure_profile` | `workspace:read` |
+| **Team decisions** | `list_decisions`, `search_decisions` | `stories:read` |
+| **Team decisions (write)** | `record_decision` | `stories:read` + `stories:write` |
+| **Objectives** | `list_objectives` | `stories:read` |
+
+**Recommended baseline for full MCP functionality:**
+```
+stories:read, stories:write, epics:read, epics:write, boards:read, workspace:read
+```
+
+If a scoped key is missing a scope, the MCP server surfaces an actionable error message naming the missing scope and directing you to regenerate the key with the required scope. You do NOT need to restart the MCP server after regenerating — just update `ELIXIUM_API_KEY` in your config and reload the server.
+
 ## Usage
 Once configured, your AI agent will have access to tools like:
 - `list_stories` - View all stories on the board

package/dist/constants/workflowModelLabels.js

@@ -0,0 +1,59 @@
+/**
+ * Canonical workflow model labels for MCP tool responses.
+ *
+ * Story 69c3a615 — surfaces the active workflow model in `start_story` and
+ * `submit_for_review` responses so agents (and through them, users) know
+ * what state transitions to expect. Story 79f641d5 (Team Profile UI) will
+ * import the same constants to keep terminology aligned across layers.
+ *
+ * AC: "model name matches the Team Profile UI's label exactly (no
+ * terminology drift between layers)" — this module is the single source.
+ */
+export const WORKFLOW_MODEL_NAMES = {
+    /** Pivotal-style 4-state model with explicit `delivered` step. */
+    pivotal4State: "4-state (Pivotal)",
+    /** Trunk-based 3-state model — no delivered step, finished → accepted. */
+    trunk3State: "3-state (simple)",
+};
+/** Per-state parenthetical explanations under each model. */
+export const WORKFLOW_MODEL_STATE_EXPLANATION = {
+    pivotal4State: {
+        delivered: "work is on main, awaiting acceptance",
+        finished: "PR pending merge, advances to delivered when merged",
+    },
+    trunk3State: {
+        finished: "story moves directly to accepted on human review",
+    },
+};
+/** At-start (no state yet) explanations — used by `start_story`. */
+export const WORKFLOW_MODEL_START_EXPLANATION = {
+    pivotal4State: "submit will set delivered (auto-merge) or finished (PR pending)",
+    trunk3State: "submit advances to finished, accept moves to accepted",
+};
+/**
+ * Formats the canonical "Workflow Model:" line for MCP tool responses.
+ *
+ * Examples:
+ *   { useDeliveredState: true, state: "delivered" }
+ *     → "4-state (Pivotal — work is on main, awaiting acceptance)"
+ *   { useDeliveredState: false, state: "finished" }
+ *     → "3-state (simple — story moves directly to accepted on human review)"
+ *   { useDeliveredState: true } (no state — start_story case)
+ *     → "4-state (Pivotal — submit will set delivered (auto-merge) or finished (PR pending))"
+ *
+ * Single-line output guarantee: the returned string never contains a newline
+ * — callers can safely interpolate it as one row in a markdown response.
+ */
+export function formatWorkflowModelLine(args) {
+    const modelKey = args.useDeliveredState ? "pivotal4State" : "trunk3State";
+    const baseName = args.useDeliveredState ? "4-state" : "3-state";
+    const typeLabel = args.useDeliveredState ? "Pivotal" : "simple";
+    let explanation = WORKFLOW_MODEL_START_EXPLANATION[modelKey];
+    if (args.state) {
+        const stateExplanations = WORKFLOW_MODEL_STATE_EXPLANATION[modelKey];
+        const found = stateExplanations[args.state];
+        if (found)
+            explanation = found;
+    }
+    return `${baseName} (${typeLabel} — ${explanation})`;
+}

package/dist/index.js

@@ -5,6 +5,9 @@ import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import * as http from "node:http";
+import { CREATE_STORY_INPUT_SCHEMA, UPDATE_STORY_INPUT_SCHEMA, GET_STAKEHOLDERS_INPUT_SCHEMA, PROPOSE_FIELD_DRAFT_INPUT_SCHEMA, ENDORSE_PROPOSAL_INPUT_SCHEMA, REJECT_PROPOSAL_INPUT_SCHEMA, DRAFT_HYPOTHESIS_INPUT_SCHEMA, GET_TRUST_LEAKAGE_INPUT_SCHEMA, } from "./toolSchemas.js";
+import { deriveStakeholders } from "./stakeholders.js";
+import { formatWorkflowModelLine } from "./constants/workflowModelLabels.js";
 const API_KEY = process.env.ELIXIUM_API_KEY;
 const API_URL = process.env.ELIXIUM_API_URL || "https://elixium.ai/api";
 const BOARD_SLUG = process.env.ELIXIUM_BOARD_SLUG;
@@ -320,6 +323,7 @@ const fetchFeatureConfig = async () => {
                 aiTools: true,
                 teamDecisions: false,
                 ragKnowledgeBase: false,
+                useDeliveredState: true,
             },
             source: {
                 balancedTeam: "error-fallback",
@@ -328,6 +332,7 @@ const fetchFeatureConfig = async () => {
                 aiTools: "error-fallback",
                 teamDecisions: "error-fallback",
                 ragKnowledgeBase: "error-fallback",
+                useDeliveredState: "error-fallback",
             },
         };
     }
@@ -643,52 +648,8 @@ const createServer = () => {
             },
             {
                 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.",
-                        },
-                        epicId: {
-                            type: "string",
-                            description: "Epic ID to link this story to (optional). Use list_epics to find epic IDs.",
-                        },
-                        testPlan: {
-                            type: "string",
-                            description: "Markdown test plan describing test strategy (optional). Sets the test_plan field without changing workflow_stage.",
-                        },
-                    },
-                    required: ["title"],
-                },
+                description: "Create a new story on the Elixium board. Accepts storyType (feature/bug/chore/platform) at create time.",
+                inputSchema: CREATE_STORY_INPUT_SCHEMA,
             },
             {
                 name: "get_iteration_context",
@@ -767,58 +728,38 @@ const createServer = () => {
             },
             {
                 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",
-                        },
-                        sortOrder: {
-                            type: "number",
-                            description: "Sort order within the lane (lower = higher priority)",
-                        },
-                        epicId: {
-                            type: "string",
-                            description: "Epic ID to link this story to. Set to empty string to unlink.",
-                        },
-                        testPlan: {
-                            type: "string",
-                            description: "Markdown test plan. Updates test_plan field without changing workflow_stage.",
-                        },
-                    },
-                    required: ["storyId"],
-                },
+                description: "Update fields on an existing story. Accepts Learning Loop fields (hypothesis, confidence_score, hidden_unknowns, risk_profile) and storyType in addition to the basics.",
+                inputSchema: UPDATE_STORY_INPUT_SCHEMA,
+            },
+            {
+                name: "get_stakeholders",
+                description: "Derive the set of trust audiences this story needs to earn trust with. Returns an array of {audience, reason} entries based on the story's risk_profile, its linked epic's hypothesis/successMetrics, and the workspace's compliance frameworks. Pure derivation — no mutations, no AI calls.",
+                inputSchema: GET_STAKEHOLDERS_INPUT_SCHEMA,
+            },
+            {
+                name: "propose_field_draft",
+                description: "Submit an AI-drafted value for a Learning Loop field as a pending proposal. The draft does NOT change the story until a human endorses via endorse_proposal. Caller should disclose `provider` (LLM model) and `agent` (client+version) for trust attribution.",
+                inputSchema: PROPOSE_FIELD_DRAFT_INPUT_SCHEMA,
+            },
+            {
+                name: "endorse_proposal",
+                description: "Endorse a pending field proposal. Updates the underlying story field with the proposal's draft_value and emits a proposal.endorsed audit event. Only humans should endorse — the agent should never call this on its own draft.",
+                inputSchema: ENDORSE_PROPOSAL_INPUT_SCHEMA,
+            },
+            {
+                name: "reject_proposal",
+                description: "Reject a pending field proposal with a required reason. Story field is unchanged; reason is captured for agent learning + audit.",
+                inputSchema: REJECT_PROPOSAL_INPUT_SCHEMA,
+            },
+            {
+                name: "draft_hypothesis",
+                description: "Reference consumer of the proposal primitive: backend calls AI_PROVIDER to generate a hypothesis draft for the given story, then submits it as a pending proposal. Pattern for §4 outcome-from-evidence and §6 v2 missing-field drafter to follow.",
+                inputSchema: DRAFT_HYPOTHESIS_INPUT_SCHEMA,
+            },
+            {
+                name: "get_trust_leakage",
+                description: "Return the tenant's off-system decision report: commits authored since `since` on the workspace's configured Git provider (GitHub, GitHub Enterprise, GitLab, or Gitea) whose messages do NOT reference any story on the board. Nudge signal, not a gate. Requires workspace_git_provider to be configured via POST /workspace/git-provider first.",
+                inputSchema: GET_TRUST_LEAKAGE_INPUT_SCHEMA,
             },
             {
                 name: "prepare_implementation",
@@ -959,6 +900,20 @@ const createServer = () => {
                     required: ["storyId", "testPlan"],
                 },
             },
+            {
+                name: "draft_test_plan",
+                description: "Return a starter test plan scaffold seeded from the story's hidden_unknowns and hypothesis. The agent edits this scaffold and calls propose_test_plan with the final version. Makes Icebox premortem assumptions load-bearing at test authoring time.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story to draft a test plan for",
+                        },
+                    },
+                    required: ["storyId"],
+                },
+            },
             {
                 name: "approve_tests",
                 description: "Approve a proposed test plan so implementation can proceed. Transitions workflow from tests_proposed to tests_approved. This is the human approval gate in the TDD workflow.",
@@ -1149,7 +1104,7 @@ const createServer = () => {
         try {
             const toolName = request.params.name;
             // Check TDD workflow tools
-            const tddWorkflowTools = ["start_story", "propose_test_plan", "get_test_plan", "submit_for_review", "review_pr"];
+            const tddWorkflowTools = ["start_story", "propose_test_plan", "draft_test_plan", "get_test_plan", "submit_for_review", "review_pr"];
             if (tddWorkflowTools.includes(toolName)) {
                 const enabled = await isTddWorkflowEnabled();
                 if (!enabled) {
@@ -1540,6 +1495,134 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                         ],
                     };
                 }
+                case "get_stakeholders": {
+                    const args = request.params.arguments;
+                    const { storyId } = args;
+                    assertUUID(storyId, "storyId");
+                    // Fetch story + feature config in parallel; the story tells us
+                    // whether to fetch a linked epic.
+                    const [storyResponse, featureConfig] = await Promise.all([
+                        client.get(`/stories/${storyId}`),
+                        fetchFeatureConfig(),
+                    ]);
+                    const story = storyResponse.data;
+                    // If the story is linked to an epic, fetch the epic too.
+                    let epic = null;
+                    if (story.epic_id) {
+                        try {
+                            const epicResponse = await client.get(`/epics/${story.epic_id}`);
+                            epic = epicResponse.data;
+                        }
+                        catch {
+                            // Epic fetch failure is non-fatal — derivation simply won't
+                            // add the `execs` audience in this case.
+                            epic = null;
+                        }
+                    }
+                    // Read from canonical field name `complianceFrameworks` (per
+                    // types.ts InfrastructureProfile); fall back to `compliance` for
+                    // any shipped callers that use the older name. Values are
+                    // normalized case-insensitively in deriveStakeholders.
+                    const infra = featureConfig.infrastructureProfile ?? {};
+                    const workspaceCompliance = Array.isArray(infra.complianceFrameworks)
+                        ? infra.complianceFrameworks
+                        : Array.isArray(infra.compliance)
+                            ? infra.compliance
+                            : [];
+                    const stakeholders = deriveStakeholders({
+                        story: {
+                            story_type: story.story_type ?? null,
+                            title: story.title ?? null,
+                            risk_profile: story.risk_profile ?? null,
+                            epic_id: story.epic_id ?? null,
+                        },
+                        epic: epic
+                            ? {
+                                hypothesis: epic.hypothesis ?? null,
+                                successMetrics: epic.successMetrics ?? null,
+                            }
+                            : null,
+                        workspaceCompliance,
+                    });
+                    const payload = {
+                        storyId: story.id,
+                        stakeholders,
+                        derived_from: {
+                            story_type: story.story_type ?? null,
+                            risk_profile: story.risk_profile ?? null,
+                            epic_id: story.epic_id ?? null,
+                            compliance_frameworks: workspaceCompliance,
+                        },
+                    };
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(payload, null, 2) },
+                        ],
+                    };
+                }
+                case "propose_field_draft": {
+                    const args = request.params.arguments;
+                    const { storyId, fieldName, draftValue, provider, agent } = args;
+                    assertUUID(storyId, "storyId");
+                    const response = await client.post(`/stories/${storyId}/proposals`, {
+                        field_name: fieldName,
+                        draft_value: draftValue,
+                        ...(provider ? { provider } : {}),
+                        ...(agent ? { agent } : {}),
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
+                        ],
+                    };
+                }
+                case "endorse_proposal": {
+                    const args = request.params.arguments;
+                    const { proposalId } = args;
+                    assertUUID(proposalId, "proposalId");
+                    const response = await client.post(`/proposals/${proposalId}/endorse`, {});
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
+                        ],
+                    };
+                }
+                case "reject_proposal": {
+                    const args = request.params.arguments;
+                    const { proposalId, reason } = args;
+                    assertUUID(proposalId, "proposalId");
+                    const response = await client.post(`/proposals/${proposalId}/reject`, { reason });
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
+                        ],
+                    };
+                }
+                case "draft_hypothesis": {
+                    const args = request.params.arguments;
+                    const { storyId, context } = args;
+                    assertUUID(storyId, "storyId");
+                    const response = await client.post(`/stories/${storyId}/proposals/draft`, { field_name: "hypothesis", ...(context ? { context } : {}) });
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
+                        ],
+                    };
+                }
+                case "get_trust_leakage": {
+                    const args = (request.params.arguments ?? {});
+                    const query = {};
+                    if (args.since)
+                        query.since = String(args.since);
+                    if (args.repo)
+                        query.repo = String(args.repo);
+                    const response = await client.get(`/trust-leakage`, { params: query });
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
+                        ],
+                    };
+                }
                 case "prepare_implementation": {
                     const args = request.params.arguments;
                     const { storyId } = args;
@@ -1680,6 +1763,9 @@ Here’s the smallest change that will validate it:
                     const dorWarnings = formatDorWarnings(boardSettings, result.dorChecklist);
                     const isTrunk = result.trunkBased;
                     const isAutoMerge = result.autoMerge;
+                    const workflowModelLine = formatWorkflowModelLine({
+                        useDeliveredState: teamConfig.features.useDeliveredState,
+                    });
                     let formattedResult;
                     if (isTrunk && !isAutoMerge) {
                         formattedResult = `
@@ -1688,6 +1774,7 @@ Here’s the smallest change that will validate it:
 **Mode:** Direct to main (trunk-based development)
 **Feature Flag:** \`${result.featureFlagName || "none"}\`
 **Workflow Stage:** ${result.workflow_stage}
+**Workflow Model:** ${workflowModelLine}
 
 ## Acceptance Criteria
 ${result.acceptance_criteria || "No specific AC provided."}
@@ -1714,6 +1801,7 @@ ${dorWarnings}`;
 **Branch:** \`${result.branch}\`
 **Feature Flag:** \`${result.featureFlagName || "none"}\`
 **Workflow Stage:** ${result.workflow_stage}
+**Workflow Model:** ${workflowModelLine}
 
 ## Acceptance Criteria
 ${result.acceptance_criteria || "No specific AC provided."}
@@ -1738,6 +1826,7 @@ ${dorWarnings}`;
 
 **Branch:** \`${result.branch}\`
 **Workflow Stage:** ${result.workflow_stage}
+**Workflow Model:** ${workflowModelLine}
 
 ## Acceptance Criteria
 ${result.acceptance_criteria || "No specific AC provided."}
@@ -1844,6 +1933,30 @@ ${(result.test_file_paths || []).map((p) => `- \`${p}\``).join("\n") || "No test
 ${result.message}
 
 > 🛑 **BLOCKED:** Implementation cannot proceed until a human approves this test plan.
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
+                case "draft_test_plan": {
+                    const args = request.params.arguments;
+                    const { storyId } = args;
+                    if (!storyId) {
+                        throw new Error("storyId is required");
+                    }
+                    assertUUID(storyId, "storyId");
+                    const response = await client.get(`/stories/${storyId}/draft-test-plan`);
+                    const result = response.data;
+                    const formattedResult = `
+# Drafted Test Plan
+
+**Story ID:** ${storyId}
+
+> This is a scaffold seeded from the story's \`hidden_unknowns\` and \`hypothesis\`. Edit freely, then call \`propose_test_plan\` with the final version.
+
+---
+
+${result.testPlan}
 `;
                     return {
                         content: [{ type: "text", text: formattedResult.trim() }],
@@ -1880,13 +1993,20 @@ ${result.message}
                         throw new Error("storyId is required");
                     }
                     assertUUID(storyId, "storyId");
-                    const response = await client.post(`/stories/${storyId}/submit-review`, {
-                        commitHash,
-                        testResults,
-                        implementationNotes,
-                    });
+                    const [response, submitFeatureConfig] = await Promise.all([
+                        client.post(`/stories/${storyId}/submit-review`, {
+                            commitHash,
+                            testResults,
+                            implementationNotes,
+                        }),
+                        fetchFeatureConfig(),
+                    ]);
                     const result = response.data;
                     const isAutoMerge = result.autoMerge;
+                    const submitWorkflowModelLine = formatWorkflowModelLine({
+                        useDeliveredState: submitFeatureConfig.features.useDeliveredState,
+                        state: result.state,
+                    });
                     let autoMergeSection = "";
                     if (isAutoMerge && result.autoMergeInstructions) {
                         const instr = result.autoMergeInstructions;
@@ -1920,6 +2040,7 @@ git branch -d ${instr.sourceBranch}
 **Status:** ${result.status}
 **Workflow Stage:** ${result.workflow_stage}
 **State:** ${result.state}
+**Workflow Model:** ${submitWorkflowModelLine}
 ${result.trunkBased ? `**Mode:** Trunk-based${isAutoMerge ? " + Auto-merge" : ""}` : ""}
 ${result.featureFlagName ? `**Feature Flag:** \`${result.featureFlagName}\`` : ""}
 
@@ -2335,7 +2456,17 @@ ${depList || "No dependencies detected."}
             if (error.response?.status) {
                 errorText += ` (HTTP ${error.response.status})`;
             }
-            if (error.response?.data) {
+            // Enhanced 403 handling for RBAC and API key scope errors
+            if (error.response?.status === 403 && error.response?.data) {
+                const data = error.response.data;
+                if (data.required && data.currentScopes) {
+                    errorText = `🔑 API key missing scope: ${data.required}\n\nYour key has scopes: [${data.currentScopes.join(", ")}]\nRegenerate your API key with the required scope to use this tool.\n\nIn Elixium → Integrations → Generate API Key (with scopes)`;
+                }
+                else if (data.required && data.currentLevel) {
+                    errorText = `🔒 Insufficient permissions: ${data.required}\n\nYour access level is "${data.currentLevel}". This operation requires a higher access level.\nContact your workspace owner to update your role.`;
+                }
+            }
+            else if (error.response?.data) {
                 const data = error.response.data;
                 const detail = typeof data === "string" ? data : JSON.stringify(data);
                 errorText += `\nDetails: ${detail}`;

package/dist/stakeholders.js

@@ -0,0 +1,72 @@
+/**
+ * Stakeholder derivation — mcp-server local mirror of the logic in
+ * `lib/trust-audiences.ts` (story 72d27a2a / §7).
+ *
+ * Why duplicated: mcp-server is a separately-published npm package with
+ * its own `tsconfig.json` (rootDir = `./src`). It can't import from the
+ * parent repo's `lib/` without a workspace-level refactor. For now, the
+ * derivation logic lives independently here.
+ *
+ * **Drift guard:** `tests/stakeholder-detection-mcp-parity.spec.ts`
+ * imports both this module and `lib/trust-audiences.ts` and asserts they
+ * produce identical output on a fixture matrix. If either copy is
+ * updated without the other, that test fails.
+ *
+ * If/when a shared workspace package is introduced, consolidate.
+ */
+export const AUDIENCE_KEYS = [
+    "peers",
+    "institutional_memory",
+    "onboarders",
+    "risk_committee",
+    "governance",
+    "execs",
+];
+// Case-insensitive: accepts uppercase forms historically used in test
+// fixtures AND the lowercase enum values from types.ts.
+const REGULATED_FRAMEWORKS_NORMALIZED = new Set([
+    "hipaa",
+    "soc2",
+    "fedramp-moderate",
+    "fedramp-high",
+    "fedramp",
+]);
+function isRegulatedFramework(framework) {
+    return REGULATED_FRAMEWORKS_NORMALIZED.has(framework.toLowerCase());
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function deriveStakeholders(input) {
+    const result = [];
+    const seen = new Set();
+    function add(audience, reason) {
+        if (seen.has(audience))
+            return;
+        seen.add(audience);
+        result.push({ audience, reason });
+    }
+    add("peers", "always needed");
+    add("institutional_memory", "always needed");
+    add("onboarders", "always needed");
+    if (nonEmpty(input.story.risk_profile)) {
+        add("risk_committee", `risk_profile = "${input.story.risk_profile}"`);
+    }
+    if (input.story.risk_profile === "Compliance") {
+        add("governance", "risk_profile flags Compliance");
+    }
+    const regulated = (input.workspaceCompliance ?? []).find((f) => isRegulatedFramework(f));
+    if (regulated) {
+        add("governance", `workspace compliance: ${regulated}`);
+    }
+    const epic = input.epic;
+    if (epic) {
+        if (nonEmpty(epic.hypothesis)) {
+            add("execs", "epic has hypothesis");
+        }
+        else if (nonEmpty(epic.successMetrics)) {
+            add("execs", "epic has successMetrics");
+        }
+    }
+    return result;
+}

package/dist/toolSchemas.js

@@ -0,0 +1,235 @@
+/**
+ * MCP tool input schemas — extracted from `index.ts` so they can be imported
+ * directly by behavior tests instead of grepped from source (Tier 5.7).
+ *
+ * Pattern for new MCP tools in this package: define the inputSchema here as
+ * an exported `as const` literal, then reference it from the tool definition
+ * in `index.ts`. Story 50e536ca will eventually migrate the remaining inline
+ * schemas to this module.
+ *
+ * Keep enums and field shapes locked to the backend Zod validators
+ * (`backend/api/src/validators/storySchemas.ts`). Drift between the MCP
+ * schema and the backend validator means LLMs can send fields that get
+ * silently stripped (or be told to send valid fields the backend rejects).
+ * Cross-spec drift guards live in the test specs.
+ */
+const STORY_TYPE_ENUM = ["feature", "bug", "chore", "platform"];
+const RISK_PROFILE_ENUM = [
+    "User",
+    "Tech",
+    "Market",
+    "Compliance",
+    "Model_Drift",
+];
+const LANE_ENUM = [
+    "Backlog",
+    "Icebox",
+    "Current",
+    "Done",
+    "BACKLOG",
+    "ICEBOX",
+    "CURRENT",
+    "DONE",
+];
+export const CREATE_STORY_INPUT_SCHEMA = {
+    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: LANE_ENUM,
+        },
+        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.",
+        },
+        epicId: {
+            type: "string",
+            description: "Epic ID to link this story to (optional). Use list_epics to find epic IDs.",
+        },
+        testPlan: {
+            type: "string",
+            description: "Markdown test plan describing test strategy (optional). Sets the test_plan field without changing workflow_stage.",
+        },
+        storyType: {
+            type: "string",
+            description: "Categorizes the story for filtering and Learning Loop signals (feature, bug, chore, platform).",
+            enum: STORY_TYPE_ENUM,
+        },
+    },
+    required: ["title"],
+};
+// ─── Story 0ad8e319 (§2): Agent-proposal primitive ──────────────────────
+const PROPOSABLE_FIELD_NAMES_FOR_MCP = [
+    "hypothesis",
+    "hidden_unknowns",
+    "confidence_score",
+    "risk_profile",
+    "outcome_summary",
+];
+export const PROPOSE_FIELD_DRAFT_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        storyId: {
+            type: "string",
+            description: "UUID of the story this proposal is for",
+        },
+        fieldName: {
+            type: "string",
+            description: "Which Learning Loop field this proposal targets. Must be one of the proposable fields.",
+            enum: PROPOSABLE_FIELD_NAMES_FOR_MCP,
+        },
+        draftValue: {
+            type: ["string", "number", "null"],
+            description: "The proposed value for the field. Type matches the field: string for hypothesis/hidden_unknowns/risk_profile/outcome_summary, number for confidence_score, null to propose clearing the field.",
+        },
+        provider: {
+            type: "string",
+            description: "Optional: the LLM provider+model that generated this draft (e.g., 'anthropic.claude-sonnet-4.5', 'google.gemini-2.0-flash'). Strongly encouraged — disclosed on the proposal badge so humans see which model drafted it.",
+        },
+        agent: {
+            type: "string",
+            description: "Optional: the agent client+version that submitted the proposal (e.g., 'claude-code/1.2.3', 'cursor/0.40.0'). Used for per-agent calibration signatures.",
+        },
+    },
+    required: ["storyId", "fieldName", "draftValue"],
+};
+export const ENDORSE_PROPOSAL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        proposalId: {
+            type: "string",
+            description: "UUID of the pending proposal to endorse. Endorsement updates the underlying story field with the proposal's draft_value and emits a proposal.endorsed audit event.",
+        },
+    },
+    required: ["proposalId"],
+};
+export const REJECT_PROPOSAL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        proposalId: {
+            type: "string",
+            description: "UUID of the pending proposal to reject.",
+        },
+        reason: {
+            type: "string",
+            description: "Required reason the proposal was rejected. Captured for agent learning + audit.",
+        },
+    },
+    required: ["proposalId", "reason"],
+};
+export const DRAFT_HYPOTHESIS_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        storyId: {
+            type: "string",
+            description: "UUID of the story to draft a hypothesis for. Reference consumer of the proposal primitive — calls the configured AI_PROVIDER on the backend to generate a draft hypothesis, then submits it as a pending proposal. Pattern for §4 outcome-from-evidence and §6 v2 missing-field drafter to follow.",
+        },
+        context: {
+            type: "string",
+            description: "Optional additional context to seed the AI draft (e.g., domain notes, prior hypotheses).",
+        },
+    },
+    required: ["storyId"],
+};
+export const GET_STAKEHOLDERS_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        storyId: {
+            type: "string",
+            description: "UUID of the story to derive stakeholders for. Returns which audiences (peers, execs, governance, risk_committee, institutional_memory, onboarders) this card needs to earn trust with, based on story metadata + linked epic + workspace compliance frameworks.",
+        },
+    },
+    required: ["storyId"],
+};
+export const GET_TRUST_LEAKAGE_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        since: {
+            type: "string",
+            description: "Optional ISO-8601 timestamp. Return only commits authored on or after this instant. Defaults to 30 days ago.",
+        },
+        repo: {
+            type: "string",
+            description: "Optional repo override in 'owner/repo' form. Defaults to the workspace's configured default_repo for the tenant's provider.",
+        },
+    },
+    required: [],
+};
+export const UPDATE_STORY_INPUT_SCHEMA = {
+    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: LANE_ENUM,
+        },
+        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",
+        },
+        sortOrder: {
+            type: "number",
+            description: "Sort order within the lane (lower = higher priority)",
+        },
+        epicId: {
+            type: "string",
+            description: "Epic ID to link this story to. Set to empty string to unlink.",
+        },
+        testPlan: {
+            type: "string",
+            description: "Markdown test plan. Updates test_plan field without changing workflow_stage.",
+        },
+        storyType: {
+            type: "string",
+            description: "Categorizes the story for filtering and Learning Loop signals (feature, bug, chore, platform).",
+            enum: STORY_TYPE_ENUM,
+        },
+        hypothesis: {
+            type: "string",
+            description: "We believe that... — drives Learning Loop AI prompts and earns trust with execs/board.",
+        },
+        confidence_score: {
+            type: "number",
+            description: "How confident we are this delivers value (0-100). Earns trust with peers and calibration-minded leaders.",
+        },
+        hidden_unknowns: {
+            type: "string",
+            description: "Assumptions or open questions that could invalidate the hypothesis. Earns trust with risk committee / staff engineering.",
+        },
+        risk_profile: {
+            type: "string",
+            description: "Categorizes risk (User, Tech, Market, Compliance, Model_Drift). Earns trust with governance and compliance audiences.",
+            enum: RISK_PROFILE_ENUM,
+        },
+    },
+    required: ["storyId"],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elixium.ai/mcp-server",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "MCP Server for Elixium.ai",
   "mcpName": "io.github.IndirectTek/mcp-server",
@@ -19,20 +19,17 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^0.6.0",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "axios": "^1.6.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "ts-node": "^10.9.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.1"
+    "typescript": "^5.3.0"
   }
 }

package/dist/__tests__/board-isolation.test.js

@@ -1,83 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { selectBoard, resetBoardContext, getRuntimeBoardId, } from "../board-context.js";
-import { ALL_BOARDS, BOARD_ALPHA, BOARD_BETA, ALPHA_STORIES, BETA_STORIES, ALL_STORIES, ALPHA_EPICS, BETA_EPICS, } from "./fixtures/boards.js";
-const mockClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    resetBoardContext();
-});
-/**
- * Simulates how fetchStories filters by boardId in the MCP server.
- * This mirrors the logic in index.ts that will use getRuntimeBoardId().
- */
-const fetchStoriesForBoard = (boardId, allStories) => {
-    if (!boardId)
-        return allStories;
-    return allStories.filter((s) => s.boardId === boardId || !s.boardId);
-};
-const fetchEpicsForBoard = (boardId, allEpics) => {
-    if (!boardId)
-        return allEpics;
-    return allEpics.filter((e) => e.boardId === boardId || !e.boardId);
-};
-describe("board isolation", () => {
-    it("4.1 stories are scoped to selected board", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        const boardId = getRuntimeBoardId();
-        const stories = fetchStoriesForBoard(boardId, ALL_STORIES);
-        expect(stories).toHaveLength(ALPHA_STORIES.length);
-        expect(stories.every((s) => s.boardId === BOARD_ALPHA.id)).toBe(true);
-    });
-    it("4.1b beta board returns only beta stories", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "beta");
-        const boardId = getRuntimeBoardId();
-        const stories = fetchStoriesForBoard(boardId, ALL_STORIES);
-        expect(stories).toHaveLength(BETA_STORIES.length);
-        expect(stories.every((s) => s.boardId === BOARD_BETA.id)).toBe(true);
-    });
-    it("4.2 creating a story assigns it to selected board", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        const boardId = getRuntimeBoardId();
-        // Simulate what create_story handler does
-        const payload = {
-            title: "New Story",
-            lane: "Current",
-            ...(boardId ? { boardId } : {}),
-        };
-        expect(payload.boardId).toBe(BOARD_ALPHA.id);
-    });
-    it("4.3 epics respect board context", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        const boardId = getRuntimeBoardId();
-        const allEpics = [...ALPHA_EPICS, ...BETA_EPICS];
-        const epics = fetchEpicsForBoard(boardId, allEpics);
-        expect(epics).toHaveLength(1);
-        expect(epics[0].boardId).toBe(BOARD_ALPHA.id);
-    });
-    it("4.5 no board selected falls back to all stories", async () => {
-        // No select_board called, no env var
-        const boardId = getRuntimeBoardId();
-        expect(boardId).toBeNull();
-        const stories = fetchStoriesForBoard(boardId, ALL_STORIES);
-        expect(stories).toHaveLength(ALL_STORIES.length);
-    });
-    it("switching boards changes story scope", async () => {
-        // Select alpha
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        let stories = fetchStoriesForBoard(getRuntimeBoardId(), ALL_STORIES);
-        expect(stories).toHaveLength(ALPHA_STORIES.length);
-        // Switch to beta
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "beta");
-        stories = fetchStoriesForBoard(getRuntimeBoardId(), ALL_STORIES);
-        expect(stories).toHaveLength(BETA_STORIES.length);
-    });
-});

package/dist/__tests__/create-board.test.js

@@ -1,97 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createBoard, resetBoardContext } from "../board-context.js";
-const mockClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    resetBoardContext();
-});
-describe("create_board", () => {
-    it("2.1 creates board with name and description", async () => {
-        const created = {
-            id: "new-board-id",
-            slug: "sprint-board",
-            name: "Sprint Board",
-            description: "For sprints",
-            is_archived: false,
-            created_at: "2026-03-23T00:00:00.000Z",
-        };
-        mockClient.post.mockResolvedValue({ data: created });
-        const result = await createBoard(mockClient, {
-            name: "Sprint Board",
-            description: "For sprints",
-        });
-        expect(mockClient.post).toHaveBeenCalledWith("/boards", {
-            name: "Sprint Board",
-            slug: "sprint-board",
-            description: "For sprints",
-        });
-        expect(result.id).toBe("new-board-id");
-        expect(result.slug).toBe("sprint-board");
-        expect(result.name).toBe("Sprint Board");
-    });
-    it("2.2 auto-generates slug from name", async () => {
-        mockClient.post.mockResolvedValue({
-            data: {
-                id: "gen-id",
-                slug: "my-sprint-board",
-                name: "My Sprint Board",
-                is_archived: false,
-                created_at: "2026-03-23T00:00:00.000Z",
-            },
-        });
-        await createBoard(mockClient, { name: "My Sprint Board" });
-        expect(mockClient.post).toHaveBeenCalledWith("/boards", {
-            name: "My Sprint Board",
-            slug: "my-sprint-board",
-            description: "",
-        });
-    });
-    it("2.3 creates board with only required name field", async () => {
-        mockClient.post.mockResolvedValue({
-            data: {
-                id: "min-id",
-                slug: "backlog",
-                name: "Backlog",
-                description: "",
-                is_archived: false,
-                created_at: "2026-03-23T00:00:00.000Z",
-            },
-        });
-        const result = await createBoard(mockClient, { name: "Backlog" });
-        expect(result.name).toBe("Backlog");
-        expect(result.description).toBe("");
-    });
-    it("2.4 rejects creation when board limit reached", async () => {
-        mockClient.post.mockRejectedValue({
-            response: {
-                status: 422,
-                data: { error: "Maximum 3 active boards per tenant" },
-            },
-            message: "Request failed with status code 422",
-        });
-        await expect(createBoard(mockClient, { name: "Fourth Board" })).rejects.toMatchObject({
-            response: { status: 422 },
-        });
-    });
-    it("2.5 rejects duplicate slug within tenant", async () => {
-        mockClient.post.mockRejectedValue({
-            response: {
-                status: 409,
-                data: { error: "Board slug already exists" },
-            },
-            message: "Request failed with status code 409",
-        });
-        await expect(createBoard(mockClient, { name: "Alpha Board" })).rejects.toMatchObject({
-            response: { status: 409 },
-        });
-    });
-    it("2.6 validates name is non-empty", async () => {
-        await expect(createBoard(mockClient, { name: "" })).rejects.toThrow("Board name cannot be empty");
-        await expect(createBoard(mockClient, { name: "   " })).rejects.toThrow("Board name cannot be empty");
-        // Should not call API
-        expect(mockClient.post).not.toHaveBeenCalled();
-    });
-});

package/dist/__tests__/fixtures/boards.js

@@ -1,117 +0,0 @@
-/**
- * Test fixtures for multi-board MCP tools.
- */
-export const BOARD_ALPHA = {
-    id: "aaaaaaaa-1111-2222-3333-444444444444",
-    slug: "alpha",
-    name: "Alpha Board",
-    description: "First test board",
-    is_archived: false,
-    created_at: "2026-03-01T00:00:00.000Z",
-    settings: {},
-};
-export const BOARD_BETA = {
-    id: "bbbbbbbb-1111-2222-3333-444444444444",
-    slug: "beta",
-    name: "Beta Board",
-    description: "Second test board",
-    is_archived: false,
-    created_at: "2026-03-02T00:00:00.000Z",
-    settings: {},
-};
-export const BOARD_ARCHIVED = {
-    id: "cccccccc-1111-2222-3333-444444444444",
-    slug: "archived-board",
-    name: "Archived Board",
-    description: "An archived board",
-    is_archived: true,
-    created_at: "2026-02-15T00:00:00.000Z",
-    settings: {},
-};
-export const ALL_BOARDS = [BOARD_ALPHA, BOARD_BETA, BOARD_ARCHIVED];
-export const ACTIVE_BOARDS = [BOARD_ALPHA, BOARD_BETA];
-// Stories assigned to specific boards
-export const ALPHA_STORIES = [
-    {
-        id: "s1111111-1111-1111-1111-111111111111",
-        title: "Alpha Story 1",
-        lane: "Current",
-        state: "started",
-        points: 3,
-        owners: ["user-1"],
-        labels: [],
-        epicId: null,
-        boardId: BOARD_ALPHA.id,
-        storyType: "feature",
-        createdAt: "2026-03-10T00:00:00.000Z",
-    },
-    {
-        id: "s2222222-2222-2222-2222-222222222222",
-        title: "Alpha Story 2",
-        lane: "Backlog",
-        state: "unstarted",
-        points: 2,
-        owners: [],
-        labels: [],
-        epicId: null,
-        boardId: BOARD_ALPHA.id,
-        storyType: "bug",
-        createdAt: "2026-03-11T00:00:00.000Z",
-    },
-];
-export const BETA_STORIES = [
-    {
-        id: "s3333333-3333-3333-3333-333333333333",
-        title: "Beta Story 1",
-        lane: "Current",
-        state: "unstarted",
-        points: 5,
-        owners: ["user-2"],
-        labels: [],
-        epicId: null,
-        boardId: BOARD_BETA.id,
-        storyType: "feature",
-        createdAt: "2026-03-12T00:00:00.000Z",
-    },
-    {
-        id: "s4444444-4444-4444-4444-444444444444",
-        title: "Beta Story 2",
-        lane: "Current",
-        state: "started",
-        points: 1,
-        owners: [],
-        labels: [],
-        epicId: null,
-        boardId: BOARD_BETA.id,
-        storyType: "chore",
-        createdAt: "2026-03-13T00:00:00.000Z",
-    },
-    {
-        id: "s5555555-5555-5555-5555-555555555555",
-        title: "Beta Story 3",
-        lane: "Backlog",
-        state: "unstarted",
-        points: 8,
-        owners: [],
-        labels: [],
-        epicId: null,
-        boardId: BOARD_BETA.id,
-        storyType: "feature",
-        createdAt: "2026-03-14T00:00:00.000Z",
-    },
-];
-export const ALL_STORIES = [...ALPHA_STORIES, ...BETA_STORIES];
-export const ALPHA_EPICS = [
-    {
-        id: "e1111111-1111-1111-1111-111111111111",
-        name: "Alpha Epic",
-        boardId: BOARD_ALPHA.id,
-    },
-];
-export const BETA_EPICS = [
-    {
-        id: "e2222222-2222-2222-2222-222222222222",
-        name: "Beta Epic",
-        boardId: BOARD_BETA.id,
-    },
-];

package/dist/__tests__/list-boards.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { listBoards, resetBoardContext, selectBoard } from "../board-context.js";
-import { ALL_BOARDS, ACTIVE_BOARDS, } from "./fixtures/boards.js";
-const mockClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    resetBoardContext();
-});
-describe("list_boards", () => {
-    it("1.1 returns all boards with required fields", async () => {
-        mockClient.get.mockResolvedValue({ data: ACTIVE_BOARDS });
-        const result = await listBoards(mockClient);
-        expect(result.boards).toHaveLength(2);
-        for (const board of result.boards) {
-            expect(board).toHaveProperty("id");
-            expect(board).toHaveProperty("name");
-            expect(board).toHaveProperty("slug");
-            expect(board).toHaveProperty("createdAt");
-        }
-    });
-    it("1.2 returns empty array when no boards exist", async () => {
-        mockClient.get.mockResolvedValue({ data: [] });
-        const result = await listBoards(mockClient);
-        expect(result.boards).toEqual([]);
-    });
-    it("1.3 excludes archived boards by default", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result = await listBoards(mockClient);
-        expect(result.boards).toHaveLength(2);
-        expect(result.boards.every((b) => !b.isArchived)).toBe(true);
-    });
-    it("1.4 includes archived boards when requested", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result = await listBoards(mockClient, { includeArchived: true });
-        expect(result.boards).toHaveLength(3);
-        const archived = result.boards.find((b) => b.slug === "archived-board");
-        expect(archived?.isArchived).toBe(true);
-    });
-    it("1.5 indicates currently selected board", async () => {
-        // First select alpha
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        // Then list
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result = await listBoards(mockClient);
-        const alpha = result.boards.find((b) => b.slug === "alpha");
-        const beta = result.boards.find((b) => b.slug === "beta");
-        expect(alpha?.selected).toBe(true);
-        expect(beta?.selected).toBeUndefined();
-    });
-});

package/dist/__tests__/select-board.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { selectBoard, resetBoardContext, getActiveBoardSlug, getRuntimeBoardId, } from "../board-context.js";
-import { ALL_BOARDS, BOARD_ALPHA, BOARD_BETA } from "./fixtures/boards.js";
-const mockClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    resetBoardContext();
-});
-describe("select_board", () => {
-    it("3.1 selects board by slug and confirms selection", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result = await selectBoard(mockClient, "alpha");
-        expect(result.id).toBe(BOARD_ALPHA.id);
-        expect(result.name).toBe("Alpha Board");
-        expect(result.slug).toBe("alpha");
-        expect(getActiveBoardSlug()).toBe("alpha");
-        expect(getRuntimeBoardId()).toBe(BOARD_ALPHA.id);
-    });
-    it("3.2 case-insensitive slug matching", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result1 = await selectBoard(mockClient, "Alpha");
-        expect(result1.id).toBe(BOARD_ALPHA.id);
-        resetBoardContext();
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        const result2 = await selectBoard(mockClient, "ALPHA");
-        expect(result2.id).toBe(BOARD_ALPHA.id);
-    });
-    it("3.3 returns error for invalid slug", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await expect(selectBoard(mockClient, "nonexistent")).rejects.toThrow('Board "nonexistent" not found');
-        // Board context should remain unset
-        expect(getActiveBoardSlug()).toBeNull();
-        expect(getRuntimeBoardId()).toBeNull();
-    });
-    it("3.3b preserves previous selection on error", async () => {
-        // Select alpha first
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        expect(getActiveBoardSlug()).toBe("alpha");
-        // Try to select nonexistent — should fail
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await expect(selectBoard(mockClient, "nonexistent")).rejects.toThrow();
-        // Alpha should still be selected
-        expect(getActiveBoardSlug()).toBe("alpha");
-        expect(getRuntimeBoardId()).toBe(BOARD_ALPHA.id);
-    });
-    it("3.4 subsequent calls use selected board", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        // getActiveBoardSlug should return "alpha" for downstream tools
-        expect(getActiveBoardSlug()).toBe("alpha");
-        expect(getRuntimeBoardId()).toBe(BOARD_ALPHA.id);
-    });
-    it("3.5 switching boards updates context", async () => {
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "alpha");
-        expect(getActiveBoardSlug()).toBe("alpha");
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "beta");
-        expect(getActiveBoardSlug()).toBe("beta");
-        expect(getRuntimeBoardId()).toBe(BOARD_BETA.id);
-    });
-    it("3.6 overrides ELIXIUM_BOARD_SLUG env var", async () => {
-        // Before runtime selection, env var is used
-        expect(getActiveBoardSlug("alpha")).toBe("alpha");
-        // After runtime selection, runtime wins
-        mockClient.get.mockResolvedValue({ data: ALL_BOARDS });
-        await selectBoard(mockClient, "beta");
-        expect(getActiveBoardSlug("alpha")).toBe("beta");
-    });
-});