@elixium.ai/mcp-server 0.3.3 → 0.4.0

package/dist/index.js

@@ -44,6 +44,7 @@ const SSE_PATH = ensurePath(getArgValue("--sse-path") ?? process.env.ELIXIUM_MCP
 const MESSAGE_PATH = ensurePath(getArgValue("--message-path") ??
     process.env.ELIXIUM_MCP_MESSAGE_PATH ??
     "/message", "/message");
+import { listBoards, createBoard, selectBoard, getActiveBoardSlug, getRuntimeBoardId, } from "./board-context.js";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
@@ -98,6 +99,119 @@ const client = axios.create({
         ...(BOARD_SLUG ? { "x-board-slug": BOARD_SLUG } : {}),
     },
 });
+// ── Contract Scanning for prepare_implementation ──
+const CONTRACT_STOP_WORDS = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "for", "and", "nor", "but",
+    "or", "yet", "so", "in", "on", "at", "to", "of", "by", "with", "from",
+    "up", "about", "into", "through", "during", "before", "after", "above",
+    "below", "between", "out", "off", "over", "under", "again", "further",
+    "then", "once", "here", "there", "when", "where", "why", "how", "all",
+    "each", "every", "both", "few", "more", "most", "other", "some", "such",
+    "no", "not", "only", "own", "same", "than", "too", "very", "just",
+    "because", "as", "until", "while", "that", "this", "these", "those",
+    "it", "its", "we", "they", "add", "update", "fix", "implement", "create",
+    "new", "remove", "change", "make", "use", "set", "get", "check", "ensure",
+    "story", "feature", "bug", "chore", "task",
+]);
+function extractKeywords(title, description = "") {
+    const text = `${title} ${description}`.toLowerCase();
+    const words = text
+        .replace(/[^a-z0-9\s-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !CONTRACT_STOP_WORDS.has(w));
+    return [...new Set(words)];
+}
+function categorizeMatch(content) {
+    if (/\b(create|generate|produce|emit|publish|write|return|send|build|insert)\b/i.test(content))
+        return "producer";
+    if (/\b(consume|read|validate|verify|import|parse|receive|fetch|load|decode|check)\b/i.test(content))
+        return "consumer";
+    return "reference";
+}
+function scanCodebaseForContracts(keywords, cwd) {
+    if (keywords.length === 0)
+        return [];
+    const matches = [];
+    const searchDirs = ["app", "backend/api/src", "mcp-server/src", "components"].map(d => path.join(cwd, d));
+    const extensions = new Set([".ts", ".tsx", ".js", ".jsx"]);
+    const maxMatches = 50;
+    function searchDir(dir) {
+        if (matches.length >= maxMatches)
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (matches.length >= maxMatches)
+                    return;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist")
+                        continue;
+                    searchDir(fullPath);
+                }
+                else if (extensions.has(path.extname(entry.name))) {
+                    try {
+                        const content = fs.readFileSync(fullPath, "utf-8");
+                        const lines = content.split("\n");
+                        for (let i = 0; i < lines.length && matches.length < maxMatches; i++) {
+                            const line = lines[i];
+                            const lineLower = line.toLowerCase();
+                            if (keywords.some((kw) => lineLower.includes(kw))) {
+                                const trimmed = line.trim();
+                                if (trimmed.length > 0 && !trimmed.startsWith("//") && !trimmed.startsWith("*")) {
+                                    matches.push({
+                                        file: path.relative(cwd, fullPath),
+                                        line: i + 1,
+                                        content: trimmed.substring(0, 200),
+                                        role: categorizeMatch(trimmed),
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch { /* skip unreadable files */ }
+                }
+            }
+        }
+        catch { /* skip inaccessible dirs */ }
+    }
+    for (const dir of searchDirs) {
+        if (fs.existsSync(dir))
+            searchDir(dir);
+    }
+    return matches;
+}
+function formatContractsSection(matches) {
+    if (matches.length === 0) {
+        return "\n## Integration Contracts\nNo downstream consumers detected.\n";
+    }
+    const producers = matches.filter((m) => m.role === "producer");
+    const consumers = matches.filter((m) => m.role === "consumer");
+    const references = matches.filter((m) => m.role === "reference");
+    let section = "\n## Integration Contracts\n\nThis story touches systems with upstream/downstream dependencies:\n";
+    if (producers.length > 0) {
+        section += "\n**Produces (writes/creates/returns):**\n";
+        for (const p of producers.slice(0, 10)) {
+            section += `- \`${p.file}:${p.line}\` — ${p.content}\n`;
+        }
+    }
+    if (consumers.length > 0) {
+        section += "\n**Consumed by (reads/validates/imports):**\n";
+        for (const c of consumers.slice(0, 10)) {
+            section += `- \`${c.file}:${c.line}\` — ${c.content}\n`;
+        }
+    }
+    if (references.length > 0 && producers.length + consumers.length < 5) {
+        section += "\n**Other references:**\n";
+        for (const r of references.slice(0, 5)) {
+            section += `- \`${r.file}:${r.line}\` — ${r.content}\n`;
+        }
+    }
+    section += "\n> **Note:** This section is informational. Review these contracts before writing your test plan.\n";
+    return section;
+}
 const LANE_TITLE = {
     backlog: "Backlog",
     icebox: "Icebox",
@@ -153,6 +267,10 @@ const normalizeBoardSlug = (value) => {
 let cachedBoardId = null;
 let cachedBoardSlug = null;
 const resolveBoardId = async () => {
+    // Prefer runtime selection from select_board tool
+    const runtimeId = getRuntimeBoardId();
+    if (runtimeId)
+        return runtimeId;
     const slug = normalizeBoardSlug(BOARD_SLUG);
     if (!slug)
         return null;
@@ -200,12 +318,16 @@ const fetchFeatureConfig = async () => {
                 learningLoop: true,
                 tddWorkflow: true,
                 aiTools: true,
+                teamDecisions: false,
+                ragKnowledgeBase: false,
             },
             source: {
                 balancedTeam: "error-fallback",
                 learningLoop: "error-fallback",
                 tddWorkflow: "error-fallback",
                 aiTools: "error-fallback",
+                teamDecisions: "error-fallback",
+                ragKnowledgeBase: "error-fallback",
             },
         };
     }
@@ -219,6 +341,10 @@ const isLearningLoopEnabled = async () => {
     const config = await fetchFeatureConfig();
     return config.features.learningLoop;
 };
+const isTeamDecisionsEnabled = async () => {
+    const config = await fetchFeatureConfig();
+    return config.features.teamDecisions;
+};
 const isAiToolsEnabled = async () => {
     const config = await fetchFeatureConfig();
     return config.features.aiTools;
@@ -328,7 +454,7 @@ const formatDorWarnings = (boardSettings, dorChecklist) => {
 };
 const fetchStories = async () => {
     const boardId = await resolveBoardId();
-    const slug = normalizeBoardSlug(BOARD_SLUG);
+    const slug = getActiveBoardSlug(BOARD_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
@@ -346,7 +472,7 @@ const fetchStories = async () => {
 };
 const fetchEpics = async () => {
     const boardId = await resolveBoardId();
-    const slug = normalizeBoardSlug(BOARD_SLUG);
+    const slug = getActiveBoardSlug(BOARD_SLUG) ?? normalizeBoardSlug(BOARD_SLUG);
     const isMainBoard = slug === "main";
     const response = await client.get("/epics", {
         params: boardId && !isMainBoard ? { boardId } : undefined,
@@ -423,7 +549,58 @@ const createServer = () => {
         const featureConfig = await fetchFeatureConfig();
         const tddEnabled = featureConfig.features.tddWorkflow;
         const learningLoopEnabled = featureConfig.features.learningLoop;
+        const teamDecisionsEnabled = featureConfig.features.teamDecisions;
+        const ragKnowledgeBaseEnabled = featureConfig.features.ragKnowledgeBase;
         const baseTools = [
+            {
+                name: "list_boards",
+                description: "List all boards in the workspace. Returns id, name, slug, and story count for each board. Marks the currently selected board.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        includeArchived: {
+                            type: "boolean",
+                            description: "Include archived boards (default false)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "create_board",
+                description: "Create a new board in the workspace. Auto-generates slug from name if not provided. Max 3 active boards per tenant.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Name for the new board",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Optional description",
+                        },
+                        slug: {
+                            type: "string",
+                            description: "Optional custom slug (auto-generated from name if omitted)",
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+            {
+                name: "select_board",
+                description: "Switch the active board context. All subsequent tool calls (list_stories, create_story, list_epics, etc.) will operate against the selected board. Overrides ELIXIUM_BOARD_SLUG env var for this session.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        slug: {
+                            type: "string",
+                            description: "Slug of the board to select (case-insensitive)",
+                        },
+                    },
+                    required: ["slug"],
+                },
+            },
             {
                 name: "get_feature_config",
                 description: "Get the feature configuration for this board/workspace. Returns enabled features, team profile, and smart defaults context.",
@@ -434,10 +611,34 @@ const createServer = () => {
             },
             {
                 name: "list_stories",
-                description: "List all stories on the Elixium board",
+                description: "List stories on the Elixium board. Returns compact summaries (id, title, lane, points, owners, epic, state). Use lane filter to reduce results. Defaults to 25 stories max.",
                 inputSchema: {
                     type: "object",
-                    properties: {},
+                    properties: {
+                        lane: {
+                            type: "string",
+                            description: "Filter by lane (case-insensitive). Omit to list all lanes.",
+                            enum: ["Current", "Backlog", "Icebox", "Done"],
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Max stories to return (default 25, max 100)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_story",
+                description: "Get full details for a single story by UUID. Returns all fields including description, acceptance criteria, tasks, labels, metrics, and workflow state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "The full UUID of the story (from list_stories output)",
+                        },
+                    },
+                    required: ["id"],
                 },
             },
             {
@@ -477,6 +678,14 @@ const createServer = () => {
                             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"],
                 },
@@ -595,6 +804,18 @@ const createServer = () => {
                             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"],
                 },
@@ -658,6 +879,25 @@ const createServer = () => {
                     required: ["epicId"],
                 },
             },
+            {
+                name: "prioritize_epic",
+                description: "AI-powered dependency analysis and story prioritization for an epic. Analyzes stories, proposes optimal execution order based on dependencies, and optionally applies the reorder. Uses the same server-side endpoint as the UI.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        epicId: {
+                            type: "string",
+                            description: "ID of the epic to prioritize",
+                        },
+                        mode: {
+                            type: "string",
+                            description: "analyze (preview proposed order) or apply (commit the reorder)",
+                            enum: ["analyze", "apply"],
+                        },
+                    },
+                    required: ["epicId"],
+                },
+            },
         ];
         const tddTools = tddEnabled ? [
             // TDD Workflow Tools
@@ -684,6 +924,14 @@ const createServer = () => {
                             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.",
                         },
+                        skipGates: {
+                            type: "boolean",
+                            description: "If true, bypasses the test plan approval gate. For hotfixes/emergencies only. Bypass is recorded in the story audit trail.",
+                        },
+                        skipReason: {
+                            type: "string",
+                            description: "Reason for bypassing gates (e.g., 'hotfix for production outage'). Recorded in the audit trail.",
+                        },
                     },
                     required: ["storyId"],
                 },
@@ -725,6 +973,20 @@ const createServer = () => {
                     required: ["storyId"],
                 },
             },
+            {
+                name: "get_test_plan",
+                description: "Retrieve and display the full TDD test plan for a story. Shows the plan text, workflow stage, approval status, and test file paths.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        storyId: {
+                            type: "string",
+                            description: "ID of the story whose test plan to display",
+                        },
+                    },
+                    required: ["storyId"],
+                },
+            },
             {
                 name: "submit_for_review",
                 description: "Submit implementation for human review. Only works if tests are approved. Sets state to finished.",
@@ -802,14 +1064,92 @@ const createServer = () => {
                 },
             },
         ] : [];
-        return { tools: [...baseTools, ...tddTools, ...learningLoopTools] };
+        // Team Decisions tools (conditional on feature flag)
+        const teamDecisionsTools = teamDecisionsEnabled ? [
+            {
+                name: "record_decision",
+                description: "Record a team decision, meeting outcome, or architectural choice. These are shared across all team members' AI sessions.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Short title for the decision" },
+                        content: { type: "string", description: "Full description of the decision, context, and rationale" },
+                        category: {
+                            type: "string",
+                            description: "Category (e.g., architecture, meeting-note, convention, tooling, decision, general)",
+                        },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Tags for filtering (e.g., ['auth', 'self-hosted', 'phase-2'])",
+                        },
+                        storyId: { type: "string", description: "Optional story UUID to link this decision to" },
+                        epicId: { type: "string", description: "Optional epic UUID to link this decision to" },
+                    },
+                    required: ["title", "content"],
+                },
+            },
+            {
+                name: "list_decisions",
+                description: "List recent team decisions. Filter by category, tag, or date. Use this to check what the team has decided recently.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        category: { type: "string", description: "Filter by category" },
+                        tag: { type: "string", description: "Filter by tag" },
+                        since: { type: "string", description: "ISO date string — only return decisions after this date" },
+                        limit: { type: "number", description: "Max results to return (default 20)" },
+                    },
+                },
+            },
+            {
+                name: "search_decisions",
+                description: "Full-text search across all team decisions. Use this when looking for decisions related to a specific topic or keyword.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query (keywords)" },
+                        category: { type: "string", description: "Optional category filter" },
+                        limit: { type: "number", description: "Max results to return (default 10)" },
+                    },
+                    required: ["query"],
+                },
+            },
+        ] : [];
+        // RAG Knowledge Base tools (conditional on feature flag)
+        const ragTools = ragKnowledgeBaseEnabled ? [
+            {
+                name: "search_knowledge",
+                description: "Semantic search across team knowledge base (documents, wikis, runbooks, etc). Returns relevant chunks with source attribution.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query (natural language)" },
+                        category: { type: "string", description: "Optional source type filter (e.g., wiki, runbook, adr, confluence)" },
+                        limit: { type: "number", description: "Max results to return (default 10)" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "list_knowledge_sources",
+                description: "List all knowledge sources indexed in the RAG knowledge base, grouped by source type.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        source_type: { type: "string", description: "Optional filter by source type" },
+                    },
+                },
+            },
+        ] : [];
+        return { tools: [...baseTools, ...tddTools, ...learningLoopTools, ...teamDecisionsTools, ...ragTools] };
     });
     // Handle Requests
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         try {
             const toolName = request.params.name;
             // Check TDD workflow tools
-            const tddWorkflowTools = ["start_story", "propose_test_plan", "submit_for_review", "review_pr"];
+            const tddWorkflowTools = ["start_story", "propose_test_plan", "get_test_plan", "submit_for_review", "review_pr"];
             if (tddWorkflowTools.includes(toolName)) {
                 const enabled = await isTddWorkflowEnabled();
                 if (!enabled) {
@@ -844,7 +1184,87 @@ const createServer = () => {
                     };
                 }
             }
+            // Check Team Decisions tools
+            const teamDecisionsToolNames = ["record_decision", "list_decisions", "search_decisions"];
+            if (teamDecisionsToolNames.includes(toolName)) {
+                const enabled = await isTeamDecisionsEnabled();
+                if (!enabled) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Team Decisions is disabled",
+                                    message: "The Team Decisions feature is currently disabled for this board. This feature enables shared institutional memory across all team members' AI sessions.",
+                                    help: "Team Decisions can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
+            // Check RAG Knowledge Base tools
+            const ragToolNames = ["search_knowledge", "list_knowledge_sources"];
+            if (ragToolNames.includes(toolName)) {
+                const config = await fetchFeatureConfig();
+                if (!config.features.ragKnowledgeBase) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "RAG Knowledge Base is disabled",
+                                    message: "The RAG Knowledge Base feature is currently disabled for this board. This feature enables semantic search across team knowledge sources.",
+                                    help: "RAG Knowledge Base can be enabled in workspace settings or per-board settings."
+                                }, null, 2)
+                            }],
+                        isError: true,
+                    };
+                }
+            }
             switch (toolName) {
+                case "list_boards": {
+                    const args = request.params.arguments;
+                    const result = await listBoards(client, {
+                        includeArchived: args?.includeArchived,
+                    });
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "create_board": {
+                    const args = request.params.arguments;
+                    const board = await createBoard(client, {
+                        name: args.name,
+                        description: args.description,
+                        slug: args.slug,
+                    });
+                    // Invalidate feature config cache since board list changed
+                    cachedFeatureConfig = null;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `# Board Created\n\n- **Name:** ${board.name}\n- **Slug:** ${board.slug}\n- **ID:** ${board.id}\n\n> Use \`select_board\` with slug "${board.slug}" to switch to this board.`,
+                            },
+                        ],
+                    };
+                }
+                case "select_board": {
+                    const args = request.params.arguments;
+                    const board = await selectBoard(client, args.slug);
+                    // Invalidate caches so subsequent calls use new board context
+                    cachedFeatureConfig = null;
+                    cachedBoardId = null;
+                    cachedBoardSlug = null;
+                    cachedLaneStyle = null;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `# Board Selected\n\n- **Name:** ${board.name}\n- **Slug:** ${board.slug}\n- **ID:** ${board.id}\n\nAll subsequent tool calls will operate against this board.`,
+                            },
+                        ],
+                    };
+                }
                 case "get_feature_config": {
                     const config = await fetchFeatureConfig();
                     const formattedConfig = `
@@ -855,6 +1275,8 @@ ${config.features.balancedTeam ? "✅" : "❌"} **Balanced Team** - Design URLs,
 ${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
+${config.features.teamDecisions ? "✅" : "❌"} **Team Decisions** - Shared institutional memory across AI sessions
+${config.features.ragKnowledgeBase ? "✅" : "❌"} **RAG Knowledge Base** - Semantic search across team knowledge sources
 
 ## Team Profile
 ${config.teamProfile ? `
@@ -870,6 +1292,8 @@ ${config.teamProfile ? `
 - Learning Loop: ${config.source.learningLoop}
 - TDD Workflow: ${config.source.tddWorkflow}
 - AI Tools: ${config.source.aiTools}
+- Team Decisions: ${config.source.teamDecisions}
+- RAG Knowledge Base: ${config.source.ragKnowledgeBase}
 
 ## Branching Strategy Defaults
 ${config.branchingDefaults ? `- Trunk-Based: ${config.branchingDefaults.trunkBased ? "Yes" : "No"}
@@ -890,10 +1314,49 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                     };
                 }
                 case "list_stories": {
-                    const stories = await fetchStories();
+                    const args = request.params.arguments;
+                    let stories = await fetchStories();
+                    // Filter by lane if specified
+                    if (args?.lane) {
+                        const targetLane = args.lane.toLowerCase();
+                        stories = stories.filter((s) => (s.lane || "").toLowerCase() === targetLane);
+                    }
+                    // Apply limit (default 25, max 100)
+                    const limit = Math.min(Math.max(args?.limit || 25, 1), 100);
+                    const total = stories.length;
+                    stories = stories.slice(0, limit);
+                    // Return compact summaries to fit LLM context
+                    const compact = stories.map((s) => ({
+                        id: s.id,
+                        title: s.title,
+                        lane: s.lane,
+                        state: s.state,
+                        points: s.points,
+                        owners: s.owners,
+                        labels: s.labels,
+                        epicId: s.epicId,
+                        storyType: s.storyType || s.story_type,
+                        createdAt: s.createdAt || s.created_at,
+                    }));
+                    const result = {
+                        total,
+                        showing: compact.length,
+                        ...(args?.lane ? { lane: args.lane } : {}),
+                        stories: compact,
+                    };
                     return {
                         content: [
-                            { type: "text", text: JSON.stringify(stories, null, 2) },
+                            { type: "text", text: JSON.stringify(result, null, 2) },
+                        ],
+                    };
+                }
+                case "get_story": {
+                    const args = request.params.arguments;
+                    assertUUID(args.id, "story id");
+                    const response = await client.get(`/stories/${args.id}`);
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(response.data, null, 2) },
                         ],
                     };
                 }
@@ -1088,6 +1551,32 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                         fetchBoardSettings(),
                     ]);
                     const story = storyResponse.data;
+                    // Auto-search team decisions if feature flag is enabled (graceful degradation)
+                    let relevantDecisions = [];
+                    if (teamConfig.features.teamDecisions) {
+                        try {
+                            const decisionsResponse = await client.get("/decisions/search", {
+                                params: { q: story.title, limit: 5 },
+                            });
+                            relevantDecisions = decisionsResponse.data?.decisions || [];
+                        }
+                        catch {
+                            // Silently omit — decisions search failure should not break the brief
+                        }
+                    }
+                    // Auto-search knowledge base if feature flag is enabled (graceful degradation)
+                    let relatedKnowledge = [];
+                    if (teamConfig.features.ragKnowledgeBase) {
+                        try {
+                            const knowledgeResponse = await client.get("/knowledge/search", {
+                                params: { q: story.title, limit: 5 },
+                            });
+                            relatedKnowledge = knowledgeResponse.data?.results || [];
+                        }
+                        catch {
+                            // Silently omit — knowledge search failure should not break the brief
+                        }
+                    }
                     // Validation & Guardrails
                     const storyLane = typeof story.lane === "string" ? story.lane.trim().toLowerCase() : "";
                     const statusWarning = storyLane !== "current"
@@ -1114,6 +1603,35 @@ ${config.infrastructureProfile?.provider ? `- Provider: ${config.infrastructureP
                                 r.concerns.map((c) => `- **${c.severity}:** ${c.description}`).join("\n") + "\n";
                         }
                     }
+                    // Format relevant team decisions section (only if matches exist)
+                    let decisionsSection = "";
+                    if (relevantDecisions.length > 0) {
+                        const formatted = relevantDecisions.map((d) => {
+                            const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                            return `- [${date}] **${d.title}** (${d.category || "general"})\n  ${d.content}`;
+                        }).join("\n");
+                        decisionsSection = `\n## Relevant Team Decisions\n${formatted}\n`;
+                    }
+                    // Format related knowledge section (only if matches exist)
+                    let knowledgeSection = "";
+                    if (relatedKnowledge.length > 0) {
+                        const formatted = relatedKnowledge.map((k) => {
+                            const relevance = k.relevance ? ` (${(k.relevance * 100).toFixed(0)}% match)` : "";
+                            return `- **${k.source_title}** [${k.source_type}]${relevance}\n  ${k.content}`;
+                        }).join("\n");
+                        knowledgeSection = `\n## Related Knowledge\n${formatted}\n`;
+                    }
+                    // Scan codebase for integration contracts (non-blocking)
+                    let contractsSection = "";
+                    try {
+                        const keywords = extractKeywords(story.title, story.description || "");
+                        const cwd = process.cwd();
+                        const contractMatches = scanCodebaseForContracts(keywords, cwd);
+                        contractsSection = formatContractsSection(contractMatches);
+                    }
+                    catch {
+                        contractsSection = "\n## Integration Contracts\nContract scanning unavailable.\n";
+                    }
                     const formattedBrief = `
 # Implementation Brief: ${story.title}
 
@@ -1126,7 +1644,7 @@ ${acceptanceCriteria}
 ## Assumptions
 Here are the assumptions I think we’re testing:
 ${assumptions}
-
+${decisionsSection}${knowledgeSection}${contractsSection}
 ${formatTeamContext(teamConfig)}
 ${formatDorDodSection(boardSettings, story.dorChecklist, story.dodChecklist)}
 ## Proposal
@@ -1140,7 +1658,7 @@ Here’s the smallest change that will validate it:
                 // TDD Workflow Handlers
                 case "start_story": {
                     const args = request.params.arguments;
-                    const { storyId, branchPrefix, trunkBased, autoMerge } = args;
+                    const { storyId, branchPrefix, trunkBased, autoMerge, skipGates, skipReason } = args;
                     if (!storyId) {
                         throw new Error("storyId is required");
                     }
@@ -1151,6 +1669,8 @@ Here’s the smallest change that will validate it:
                             branchPrefix: branchPrefix || "feat",
                             trunkBased,
                             autoMerge,
+                            ...(skipGates && { skipGates: true }),
+                            ...(skipReason && { skipReason }),
                         }),
                         fetchFeatureConfig(),
                         fetchBoardSettings(),
@@ -1234,6 +1754,56 @@ ${dorWarnings}`;
                         content: [{ type: "text", text: formattedResult.trim() }],
                     };
                 }
+                case "get_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}`);
+                    const story = response.data;
+                    const testPlan = story.test_plan || story.testPlan;
+                    const workflowStage = story.workflow_stage || story.workflowStage;
+                    const testFilePaths = story.test_file_paths || story.testFilePaths || [];
+                    const feedback = story.test_plan_feedback || story.testPlanFeedback;
+                    const title = story.title || "Untitled Story";
+                    if (!testPlan) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `# No Test Plan\n\n**Story:** ${title}\n**Story ID:** ${storyId}\n**Workflow Stage:** ${workflowStage || "none"}\n\nThis story does not have a test plan yet. Use \`propose_test_plan\` to submit one.`,
+                                },
+                            ],
+                        };
+                    }
+                    const stageLabel = workflowStage === "tests_approved"
+                        ? "Approved"
+                        : workflowStage === "tests_proposed"
+                            ? "Proposed — Awaiting Approval"
+                            : workflowStage === "tests_revision_requested"
+                                ? "Revision Requested"
+                                : workflowStage || "unknown";
+                    const feedbackSection = feedback
+                        ? `\n## Revision Feedback\n> ${feedback.split("\n").join("\n> ")}\n`
+                        : "";
+                    const formattedResult = `# Test Plan: ${title}
+
+**Story ID:** ${storyId}
+**Workflow Stage:** ${workflowStage}
+**Status:** ${stageLabel}
+
+## Test Plan
+${testPlan}
+${feedbackSection}
+## Test Files
+${testFilePaths.length > 0 ? testFilePaths.map((p) => `- \`${p}\``).join("\n") : "No test files specified"}
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
                 case "propose_test_plan": {
                     const args = request.params.arguments;
                     const { storyId, testPlan, testFilePaths } = args;
@@ -1540,6 +2110,49 @@ ${categoryBreakdown}
 ${unestimated.length === 0
                         ? "All stories have been estimated!"
                         : unestimated.map((s) => `- ${s.title} (${s.id})`).join("\n")}
+`;
+                    return {
+                        content: [{ type: "text", text: formattedResult.trim() }],
+                    };
+                }
+                case "prioritize_epic": {
+                    const args = request.params.arguments;
+                    const { epicId, mode = "analyze" } = args;
+                    if (!epicId)
+                        throw new Error("epicId is required");
+                    assertUUID(epicId, "epicId");
+                    const res = await client.post(`/prioritize-epic/${epicId}`, { mode });
+                    if (mode === "apply") {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Prioritization applied to epic. ${res.data.updatedCount} stories reordered.`,
+                                }],
+                        };
+                    }
+                    // Analyze mode — format the preview
+                    const data = res.data;
+                    const orderList = (data.proposedOrder || [])
+                        .map((item, i) => `${i + 1}. **${item.storyTitle}** — ${item.reason}`)
+                        .join("\n");
+                    const depList = (data.dependencies || [])
+                        .map((dep) => `- ${dep.storyTitle} is blocked by ${dep.blockedByStoryTitle}: ${dep.reason}`)
+                        .join("\n");
+                    const circularWarning = data.circularDependencies?.length > 0
+                        ? `\n## Circular Dependencies Detected\n${data.circularDependencies.map((cd) => `- ${cd.description}`).join("\n")}\n`
+                        : "";
+                    const formattedResult = `
+# AI Prioritization Preview
+
+${data.summary}
+${circularWarning}
+## Proposed Order (do first → do last)
+${orderList}
+
+## Dependencies
+${depList || "No dependencies detected."}
+
+> To apply this order, call \`prioritize_epic\` with mode: "apply"
 `;
                     return {
                         content: [{ type: "text", text: formattedResult.trim() }],
@@ -1580,6 +2193,135 @@ ${unestimated.length === 0
                         content: [{ type: "text", text: sections.join("\n") }],
                     };
                 }
+                // Team Decisions Handlers
+                case "record_decision": {
+                    const args = request.params.arguments;
+                    const { title, content, category, tags, storyId, epicId } = args;
+                    if (!title || !content) {
+                        throw new Error("title and content are required");
+                    }
+                    if (storyId)
+                        assertUUID(storyId, "storyId");
+                    if (epicId)
+                        assertUUID(epicId, "epicId");
+                    const response = await client.post("/decisions", {
+                        title,
+                        content,
+                        category,
+                        tags,
+                        storyId,
+                        epicId,
+                    });
+                    const decision = response.data;
+                    const confirmText = `✅ Decision recorded: "${decision.title || title}"
+- **Category:** ${decision.category || category || "general"}
+- **Tags:** ${(decision.tags || tags || []).join(", ") || "none"}
+- **ID:** ${decision.id}`;
+                    return {
+                        content: [{ type: "text", text: confirmText }],
+                    };
+                }
+                case "list_decisions": {
+                    const args = request.params.arguments;
+                    const { category, tag, since, limit } = args || {};
+                    const params = {};
+                    if (category)
+                        params.category = category;
+                    if (tag)
+                        params.tag = tag;
+                    if (since)
+                        params.since = since;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/decisions", { params });
+                    const { decisions, total } = response.data;
+                    if (!decisions || decisions.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No team decisions found matching the filters." }],
+                        };
+                    }
+                    const formatted = decisions.map((d) => {
+                        const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                        const tagStr = d.tags?.length ? ` [${d.tags.join(", ")}]` : "";
+                        return `### [${date}] ${d.title} (${d.category || "general"})${tagStr}\n${d.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Team Decisions (${decisions.length} of ${total})\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "search_decisions": {
+                    const args = request.params.arguments;
+                    const { query, category, limit } = args || {};
+                    if (!query) {
+                        throw new Error("query is required");
+                    }
+                    const params = { q: query };
+                    if (category)
+                        params.category = category;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/decisions/search", { params });
+                    const { decisions } = response.data;
+                    if (!decisions || decisions.length === 0) {
+                        return {
+                            content: [{ type: "text", text: `No team decisions found matching "${query}".` }],
+                        };
+                    }
+                    const formatted = decisions.map((d) => {
+                        const date = d.created_at ? new Date(d.created_at).toISOString().split("T")[0] : "unknown";
+                        const tagStr = d.tags?.length ? ` [${d.tags.join(", ")}]` : "";
+                        return `### [${date}] ${d.title} (${d.category || "general"})${tagStr}\n${d.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Search Results for "${query}" (${decisions.length} matches)\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "search_knowledge": {
+                    const args = request.params.arguments;
+                    const { query, category, limit } = args || {};
+                    if (!query) {
+                        throw new Error("query is required");
+                    }
+                    const params = { q: query };
+                    if (category)
+                        params.category = category;
+                    if (limit)
+                        params.limit = String(limit);
+                    const response = await client.get("/knowledge/search", { params });
+                    const { results } = response.data;
+                    if (!results || results.length === 0) {
+                        return {
+                            content: [{ type: "text", text: `No knowledge results found matching "${query}".` }],
+                        };
+                    }
+                    const formatted = results.map((r) => {
+                        const relevance = r.relevance ? `(${(r.relevance * 100).toFixed(1)}% relevant)` : "";
+                        return `### ${r.source_title} [${r.source_type}] ${relevance}\n${r.content}`;
+                    }).join("\n\n---\n\n");
+                    const header = `# Knowledge Search Results for "${query}" (${results.length} matches)\n\n`;
+                    return {
+                        content: [{ type: "text", text: header + formatted }],
+                    };
+                }
+                case "list_knowledge_sources": {
+                    const args = request.params.arguments;
+                    const params = {};
+                    if (args?.source_type)
+                        params.source_type = args.source_type;
+                    const response = await client.get("/knowledge/sources", { params });
+                    const { sources } = response.data;
+                    if (!sources || sources.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No knowledge sources are currently indexed." }],
+                        };
+                    }
+                    const formatted = sources.map((s) => `- **${s.source_title}** (${s.source_type}) — ${s.chunk_count || 0} chunks`).join("\n");
+                    return {
+                        content: [{ type: "text", text: `# Knowledge Sources\n\n${formatted}` }],
+                    };
+                }
                 default:
                     throw new Error("Unknown tool");
             }