@konductro/claude-plugin 2.0.0

package/servers/konductro-api.js

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+
+/**
+ * Konductro MCP Server
+ *
+ * Bridges Claude Code to the Konductro platform REST API.
+ * Runs as a stdio MCP server, spawned by the plugin config.
+ *
+ * Environment variables (set by plugin.json from userConfig):
+ *   KONDUCTRO_URL     — Konductro platform URL
+ *   KONDUCTRO_CLI_TOKEN — Personal CLI access token
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const KONDUCTRO_URL = process.env.KONDUCTRO_URL?.replace(/\/$/, '') || '';
+const CLI_TOKEN = process.env.KONDUCTRO_CLI_TOKEN || '';
+
+async function konductroFetch(path, options = {}) {
+  const url = `${KONDUCTRO_URL}${path}`;
+  const headers = {
+    'Authorization': `Bearer ${CLI_TOKEN}`,
+    ...options.headers,
+  };
+  // Only set Content-Type and default body for methods that send JSON
+  if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
+    headers['Content-Type'] = 'application/json';
+    if (!options.body) options.body = '{}';
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    throw new Error(`Konductro API error (${response.status}): ${body}`);
+  }
+
+  return response.json();
+}
+
+const server = new McpServer({
+  name: 'konductro',
+  version: '1.0.0',
+});
+
+// Tool: List pending tech analysis tasks
+server.tool(
+  'list_tech_analysis_tasks',
+  'List your pending technical analysis assignments from Konductro',
+  {},
+  async () => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token in the plugin settings.',
+        }],
+      };
+    }
+
+    const tasks = await konductroFetch('/api/cli/tech-analysis-tasks');
+
+    if (tasks.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'No pending technical analysis tasks assigned to you.',
+        }],
+      };
+    }
+
+    const taskList = tasks.map((t, i) =>
+      `${i + 1}. **${t.projectName}** — ${t.phaseName}\n   Client: ${t.clientName}\n   Phase ID: ${t.phaseId}\n   ${t.hasExistingDraft ? '(has existing draft)' : '(new analysis)'}`
+    ).join('\n\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Your Pending Technical Analysis Tasks\n\n${taskList}\n\nUse the **get_task_context** tool with the phase ID to load the full context for a task.`,
+      }],
+    };
+  }
+);
+
+// Tool: Get full context for a tech analysis task
+server.tool(
+  'get_task_context',
+  'Load the full context (requirements, project info, repositories) for a technical analysis task',
+  {
+    phaseId: z.string().describe('The phase ID from the task list'),
+  },
+  async ({ phaseId }) => {
+    const context = await konductroFetch(`/api/cli/tech-analysis-tasks/${phaseId}/context`);
+
+    let contextText = `## Technical Analysis Context\n\n`;
+    contextText += `**Project:** ${context.project.name}\n`;
+    contextText += `**Client:** ${context.project.client.name}`;
+    if (context.project.client.industry) contextText += ` (${context.project.client.industry})`;
+    contextText += `\n**Phase:** ${context.phase.name}\n`;
+    if (context.phase.description) contextText += `**Description:** ${context.phase.description}\n`;
+    contextText += `\n`;
+
+    if (context.repositories.length > 0) {
+      contextText += `### Repositories\n\n`;
+      for (const repo of context.repositories) {
+        contextText += `- **${repo.name}** (${repo.repoType}) — ${repo.stacks.join(', ')}\n`;
+        contextText += `  URL: ${repo.repoUrl}\n`;
+        contextText += `  Base branch: ${repo.branchBase}\n`;
+      }
+      contextText += `\n`;
+    }
+
+    if (context.requirements) {
+      contextText += `### Approved Requirements (v${context.requirements.version})\n\n`;
+      contextText += context.requirements.content;
+      contextText += `\n\n`;
+    }
+
+    if (context.approvedArtefacts.length > 0) {
+      for (const artefact of context.approvedArtefacts) {
+        if (artefact.type !== 'requirements') {
+          contextText += `### ${artefact.title} (v${artefact.version})\n\n`;
+          contextText += artefact.content;
+          contextText += `\n\n`;
+        }
+      }
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: contextText,
+      }],
+    };
+  }
+);
+
+// Tool: Submit tech analysis
+server.tool(
+  'submit_tech_analysis',
+  'Submit your technical analysis document and conversation summary back to Konductro',
+  {
+    phaseId: z.string().describe('The phase ID for the task'),
+    document: z.string().describe('The complete technical analysis document in markdown'),
+    conversationSummary: z.string().optional().describe('Summary of key findings and decisions from the analysis conversation'),
+  },
+  async ({ phaseId, document, conversationSummary }) => {
+    const result = await konductroFetch(`/api/cli/tech-analysis-tasks/${phaseId}/submit`, {
+      method: 'POST',
+      body: JSON.stringify({ document, conversationSummary }),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Technical Analysis Submitted\n\n${result.message}\n\n- Artefact ID: ${result.artefactId}\n- Version: ${result.version}\n\nThe document is now available in Konductro for review and approval.`,
+      }],
+    };
+  }
+);
+
+// Tool: List pending decomposition tasks
+server.tool(
+  'list_decomposition_tasks',
+  'List your pending story decomposition assignments from Konductro',
+  {},
+  async () => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token in the plugin settings.',
+        }],
+      };
+    }
+
+    const tasks = await konductroFetch('/api/cli/decomposition-tasks');
+
+    if (tasks.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'No pending decomposition tasks assigned to you.',
+        }],
+      };
+    }
+
+    const taskList = tasks.map((t, i) =>
+      `${i + 1}. **${t.ticketKey}** — ${t.storyTitle}\n   Project: ${t.projectName} (${t.clientName})\n   Phase: ${t.phaseName}\n   Complexity: ${t.complexityScore || 'not scored'}\n   Story ID: ${t.storyId}\n   ${t.existingTaskCount > 0 ? `(${t.existingTaskCount} existing tasks)` : '(no tasks yet)'}`
+    ).join('\n\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Your Pending Decomposition Tasks\n\n${taskList}\n\nUse the **get_decomposition_context** tool with the story ID to load the full context.`,
+      }],
+    };
+  }
+);
+
+// Tool: Get full context for a decomposition task
+server.tool(
+  'get_decomposition_context',
+  'Load the full context (story details, requirements, architecture, repositories) for a decomposition task',
+  {
+    storyId: z.string().describe('The story ID from the task list'),
+  },
+  async ({ storyId }) => {
+    const ctx = await konductroFetch(`/api/cli/decomposition-tasks/${storyId}/context`);
+
+    let text = `## Decomposition Context\n\n`;
+    text += `**Story:** ${ctx.story.ticketKey} — ${ctx.story.title}\n`;
+    text += `**Project:** ${ctx.project.name}\n`;
+    text += `**Phase:** ${ctx.phase.name}\n`;
+    if (ctx.story.complexityScore) text += `**Complexity:** ${ctx.story.complexityScore}`;
+    if (ctx.story.complexityReasoning) text += ` — ${ctx.story.complexityReasoning}`;
+    text += `\n\n`;
+
+    if (ctx.story.description) {
+      text += `### Story Description\n\n${ctx.story.description}\n\n`;
+    }
+
+    if (ctx.story.acceptanceCriteria?.length > 0) {
+      text += `### Acceptance Criteria\n\n`;
+      ctx.story.acceptanceCriteria.forEach((ac, i) => {
+        text += `${i + 1}. ${ac}\n`;
+      });
+      text += `\n`;
+    }
+
+    if (ctx.story.dependencies?.length > 0) {
+      text += `### Dependencies\n\n`;
+      ctx.story.dependencies.forEach(d => { text += `- ${d}\n`; });
+      text += `\n`;
+    }
+
+    if (ctx.repositories.length > 0) {
+      text += `### Repositories\n\n`;
+      for (const repo of ctx.repositories) {
+        text += `- **${repo.name}** (${repo.repoType}) — ${repo.stacks.join(', ')}\n`;
+        text += `  ID: ${repo.id}\n`;
+        text += `  URL: ${repo.repoUrl}\n`;
+        if (repo.profile) {
+          text += `  Role: ${repo.profile.role}`;
+          if (repo.profile.domainOwned) text += `, Domain: ${repo.profile.domainOwned}`;
+          text += `\n`;
+        }
+      }
+      text += `\n`;
+    }
+
+    if (ctx.requirements) {
+      text += `### Requirements (v${ctx.requirements.version})\n\n${ctx.requirements.content}\n\n`;
+    }
+
+    if (ctx.architecture) {
+      text += `### Architecture (v${ctx.architecture.version})\n\n${ctx.architecture.content}\n\n`;
+    }
+
+    if (ctx.existingTasks.length > 0) {
+      text += `### Existing Tasks\n\n`;
+      ctx.existingTasks.forEach(t => {
+        text += `- ${t.title} (${t.type}, ${t.status})\n`;
+      });
+      text += `\n`;
+    }
+
+    if (ctx.siblingStories.length > 0) {
+      text += `### Sibling Stories (for context)\n\n`;
+      for (const s of ctx.siblingStories) {
+        text += `- **${s.title}**`;
+        if (s.children.length > 0) text += ` — ${s.children.length} tasks`;
+        text += `\n`;
+      }
+      text += `\n`;
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text,
+      }],
+    };
+  }
+);
+
+// Tool: Submit a single decomposed task
+server.tool(
+  'submit_decomposition_task',
+  'Submit a single decomposed task for a story to Konductro. Call once per task.',
+  {
+    storyId: z.string().describe('The story ID being decomposed'),
+    title: z.string().describe('Task title'),
+    description: z.string().describe('Technical description of the task'),
+    repositoryId: z.string().describe('Repository ID from the context'),
+    type: z.enum(['ui_component', 'api_java', 'api_node', 'android', 'ios', 'infra']).default('api_node').describe('Task type'),
+    acceptanceCriteria: z.array(z.string()).default([]).describe('Technical acceptance criteria'),
+    architecturalNotes: z.array(z.string()).default([]).describe('Implementation notes for the agent'),
+    componentPath: z.string().optional().nullable().describe('Primary file/directory path for this task'),
+    order: z.number().int().default(0).describe('Execution order (0-based)'),
+    filesToCreate: z.array(z.string()).default([]).describe('Files that need to be created'),
+    filesToModify: z.array(z.object({
+      path: z.string(),
+      change: z.string(),
+    })).default([]).describe('Files that need to be modified and what to change'),
+    implementationSteps: z.array(z.string()).default([]).describe('Step-by-step implementation guide'),
+    outOfScope: z.array(z.string()).default([]).describe('What is explicitly NOT included in this task'),
+  },
+  async ({ storyId, ...task }) => {
+    const result = await konductroFetch(`/api/cli/decomposition-tasks/${storyId}/task`, {
+      method: 'POST',
+      body: JSON.stringify(task),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Task created: **${result.title}** (${result.ticketNumber})`,
+      }],
+    };
+  }
+);
+
+// Tool: Complete decomposition — finalise after all tasks submitted
+server.tool(
+  'complete_decomposition',
+  'Mark a story decomposition as complete after all tasks have been submitted. Call this once after submitting all tasks.',
+  {
+    storyId: z.string().describe('The story ID that was decomposed'),
+    conversationSummary: z.string().optional().describe('Summary of decomposition decisions and rationale'),
+  },
+  async ({ storyId, conversationSummary }) => {
+    const result = await konductroFetch(`/api/cli/decomposition-tasks/${storyId}/complete`, {
+      method: 'POST',
+      body: JSON.stringify({ conversationSummary }),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Decomposition Complete\n\n${result.message}\n\nThe tasks are now available in Konductro for review and sprint planning.`,
+      }],
+    };
+  }
+);
+
+// Tool: List my tickets
+server.tool(
+  'list_my_tickets',
+  'List all tickets assigned to you in Konductro. Shows ticket key, title, status, project, phase, sprint, and branch info.',
+  {
+    status: z.string().optional().describe('Filter by ticket status (e.g. in_progress, assigned, pr_open)'),
+    level: z.enum(['story', 'task']).optional().describe('Filter by ticket level'),
+  },
+  async ({ status, level }) => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token in the plugin settings.',
+        }],
+      };
+    }
+
+    const params = new URLSearchParams();
+    if (status) params.set('status', status);
+    if (level) params.set('level', level);
+    const qs = params.toString() ? `?${params.toString()}` : '';
+
+    const tickets = await konductroFetch(`/api/cli/my-tickets${qs}`);
+
+    if (tickets.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: status ? `No tickets with status "${status}" assigned to you.` : 'No tickets assigned to you.',
+        }],
+      };
+    }
+
+    const ticketList = tickets.map((t, i) => {
+      let line = `${i + 1}. **${t.ticketKey}** — ${t.title}\n`;
+      line += `   Status: ${t.status} | Level: ${t.level} | Kind: ${t.kind}\n`;
+      line += `   Project: ${t.project.name} | Phase: ${t.phase.name}`;
+      if (t.sprint) line += ` | Sprint: ${t.sprint.name}`;
+      if (t.branchName) line += `\n   Branch: ${t.branchName}`;
+      if (t.prUrl) line += `\n   PR: ${t.prUrl}`;
+      if (t.parent) line += `\n   Parent: ${t.parent.ticketKey} — ${t.parent.title}`;
+      return line;
+    }).join('\n\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Your Tickets (${tickets.length})\n\n${ticketList}\n\nUse **get_ticket_context** with a ticket ID to load the full context.`,
+      }],
+    };
+  }
+);
+
+// Tool: Get full ticket context
+server.tool(
+  'get_ticket_context',
+  'Load the full context for a specific ticket — description, acceptance criteria, architectural notes, parent story, repository info, and approved artefacts. IMPORTANT: After showing context, do NOT offer to start implementing or writing code. If the developer wants to start work, they must use the /start-ticket skill which creates the branch and updates the ticket status in Konductro.',
+  {
+    ticketId: z.string().describe('The ticket ID to load context for'),
+  },
+  async ({ ticketId }) => {
+    const ctx = await konductroFetch(`/api/cli/tickets/${ticketId}/context`);
+
+    let text = `## Ticket Context\n\n`;
+    text += `**${ctx.ticket.ticketKey}** — ${ctx.ticket.title}\n`;
+    text += `**Status:** ${ctx.ticket.status} | **Level:** ${ctx.ticket.level} | **Kind:** ${ctx.ticket.kind}\n`;
+    text += `**Project:** ${ctx.project.name} | **Phase:** ${ctx.phase.name}\n`;
+    if (ctx.ticket.complexityScore) text += `**Complexity:** ${ctx.ticket.complexityScore}`;
+    if (ctx.ticket.complexityReasoning) text += ` — ${ctx.ticket.complexityReasoning}`;
+    if (ctx.ticket.complexityScore) text += `\n`;
+    if (ctx.ticket.branchName) text += `**Branch:** ${ctx.ticket.branchName}\n`;
+    if (ctx.ticket.prUrl) text += `**PR:** ${ctx.ticket.prUrl}\n`;
+    if (ctx.ticket.estimatedHours) text += `**Estimated:** ${ctx.ticket.estimatedHours}h\n`;
+    if (ctx.ticket.assignee) text += `**Assignee:** ${ctx.ticket.assignee.name}\n`;
+    if (ctx.ticket.developer) text += `**Developer:** ${ctx.ticket.developer.name}\n`;
+    text += `\n`;
+
+    // Description
+    text += `### Description\n\n${ctx.ticket.description}\n\n`;
+
+    // Acceptance Criteria
+    if (ctx.ticket.acceptanceCriteria?.length > 0) {
+      text += `### Acceptance Criteria\n\n`;
+      ctx.ticket.acceptanceCriteria.forEach((ac, i) => {
+        text += `${i + 1}. ${ac}\n`;
+      });
+      text += `\n`;
+    }
+
+    // Architectural Notes
+    if (ctx.ticket.architecturalNotes?.length > 0) {
+      text += `### Architectural Notes\n\n`;
+      ctx.ticket.architecturalNotes.forEach(n => { text += `- ${n}\n`; });
+      text += `\n`;
+    }
+
+    // Out of Scope
+    if (ctx.ticket.outOfScope?.length > 0) {
+      text += `### Out of Scope\n\n`;
+      ctx.ticket.outOfScope.forEach(o => { text += `- ${o}\n`; });
+      text += `\n`;
+    }
+
+    // Dependencies
+    if (ctx.ticket.dependencies?.length > 0) {
+      text += `### Dependencies\n\n`;
+      ctx.ticket.dependencies.forEach(d => { text += `- ${d}\n`; });
+      text += `\n`;
+    }
+
+    // Context Pack
+    if (ctx.ticket.contextPack) {
+      text += `### Context Pack\n\n${ctx.ticket.contextPack}\n\n`;
+    }
+
+    // Parent Story
+    if (ctx.parent) {
+      text += `### Parent Story: ${ctx.parent.ticketKey} — ${ctx.parent.title}\n\n`;
+      text += ctx.parent.description + '\n\n';
+      if (ctx.parent.acceptanceCriteria?.length > 0) {
+        text += `**Story AC:**\n`;
+        ctx.parent.acceptanceCriteria.forEach((ac, i) => { text += `${i + 1}. ${ac}\n`; });
+        text += `\n`;
+      }
+      if (ctx.parent.contextPack) {
+        text += `**Story Context Pack:**\n${ctx.parent.contextPack}\n\n`;
+      }
+    }
+
+    // Children tasks
+    if (ctx.children?.length > 0) {
+      text += `### Sub-tasks\n\n`;
+      ctx.children.forEach(c => {
+        text += `- ${c.ticketKey} — ${c.title} (${c.status})\n`;
+      });
+      text += `\n`;
+    }
+
+    // Repository
+    if (ctx.repository) {
+      text += `### Target Repository\n\n`;
+      text += `- **${ctx.repository.name}** (${ctx.repository.repoType}) — ${ctx.repository.stacks?.join(', ') || ''}\n`;
+      text += `  URL: ${ctx.repository.repoUrl}\n`;
+      text += `  Base branch: ${ctx.repository.branchBase}\n`;
+      if (ctx.repository.profile) {
+        text += `  Role: ${ctx.repository.profile.role}`;
+        if (ctx.repository.profile.domainOwned) text += `, Domain: ${ctx.repository.profile.domainOwned}`;
+        text += `\n`;
+      }
+      text += `\n`;
+    }
+
+    // Artefacts
+    if (ctx.artefacts.requirements) {
+      text += `### Requirements (v${ctx.artefacts.requirements.version})\n\n${ctx.artefacts.requirements.content}\n\n`;
+    }
+    if (ctx.artefacts.technicalAnalysis) {
+      text += `### Technical Analysis (v${ctx.artefacts.technicalAnalysis.version})\n\n${ctx.artefacts.technicalAnalysis.content}\n\n`;
+    }
+    if (ctx.artefacts.architecture) {
+      text += `### Architecture (v${ctx.artefacts.architecture.version})\n\n${ctx.artefacts.architecture.content}\n\n`;
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text,
+      }],
+    };
+  }
+);
+
+// Tool: Start work on a ticket
+server.tool(
+  'start_work',
+  'Start work on an assigned ticket in Konductro. Creates a branch via ADO, pushes the ticket spec file, and sets the ticket to in_progress.',
+  {
+    ticketId: z.string().describe('The ticket ID to start work on'),
+    branchFrom: z.string().optional().describe('Base branch to branch from (defaults to repo base branch, e.g. dev)'),
+    branchName: z.string().optional().describe('Branch name to create (defaults to feature/{TICKET-KEY})'),
+  },
+  async ({ ticketId, branchFrom, branchName }) => {
+    try {
+      const body = {};
+      if (branchFrom) body.branchFrom = branchFrom;
+      if (branchName) body.branchName = branchName;
+
+      const result = await konductroFetch(`/api/cli/tickets/${ticketId}/start-work`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+      });
+
+      let text = `## Work Started\n\n`;
+      text += `**${result.ticketKey}** — ${result.title ?? 'Ticket'}\n`;
+      text += `**Branch:** ${result.branchName}\n`;
+      text += `**Branched from:** ${result.branchFrom}\n`;
+      text += `**Status:** in_progress\n\n`;
+      text += `To check out the branch locally:\n\`\`\`\ngit fetch && git checkout ${result.branchName}\n\`\`\``;
+
+      return { content: [{ type: 'text', text }] };
+    } catch (err) {
+      return {
+        content: [{
+          type: 'text',
+          text: `## Error\n\n${err.message}`,
+        }],
+      };
+    }
+  }
+);
+
+// Tool: Create a pull request for a ticket
+server.tool(
+  'create_pr',
+  'Create a pull request for a ticket in Konductro. Creates the PR on the git provider (ADO/Gitea), auto-assigns a reviewer based on project rules, and moves the ticket to pr_open status.',
+  {
+    ticketId: z.string().describe('The ticket ID or key (e.g. MRB-18) to create a PR for. Ticket must be in_progress with a branch.'),
+  },
+  async ({ ticketId }) => {
+    try {
+      const result = await konductroFetch(`/api/cli/tickets/${ticketId}/create-pr`, {
+        method: 'POST',
+        body: JSON.stringify({}),
+      });
+
+      let text = `## Pull Request Created\n\n`;
+      text += `**${result.ticketKey}** — ${result.title ?? 'Ticket'}\n`;
+      text += `**PR URL:** ${result.prUrl}\n`;
+      text += `**Status:** ${result.status}\n`;
+      if (result.reviewer) {
+        text += `**Reviewer:** ${result.reviewer.name}\n`;
+      }
+      text += `\n[View PR](${result.prUrl})`;
+
+      return { content: [{ type: 'text', text }] };
+    } catch (err) {
+      return {
+        content: [{
+          type: 'text',
+          text: `## Error\n\n${err.message}`,
+        }],
+      };
+    }
+  }
+);
+
+// Tool: Profile repository — scan local codebase and submit to Konductro
+server.tool(
+  'profile_repository',
+  'Scan the current repository and submit its profile (tech stack, dependencies, APIs) to Konductro. Run this from the root of a cloned repository.',
+  {
+    repoUrl: z.string().describe('The git remote URL of the repository (run: git remote get-url origin)'),
+    role: z.string().optional().describe('Role of this repo: application, library, service, infrastructure'),
+    domainOwned: z.string().optional().describe('Business domain this repo owns (e.g., payments, auth, booking)'),
+    apisExposed: z.array(z.object({
+      method: z.string(),
+      path: z.string(),
+      description: z.string().optional(),
+    })).optional().describe('API endpoints exposed by this repo'),
+    dependencies: z.array(z.object({
+      name: z.string(),
+      version: z.string().optional(),
+      type: z.string().optional(),
+    })).optional().describe('Key dependencies (frameworks, libraries)'),
+    eventsProduced: z.array(z.string()).optional().describe('Events/messages this repo produces'),
+    eventsConsumed: z.array(z.string()).optional().describe('Events/messages this repo consumes'),
+  },
+  async ({ repoUrl, role, domainOwned, apisExposed, dependencies, eventsProduced, eventsConsumed }) => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token.',
+        }],
+      };
+    }
+
+    try {
+      const result = await konductroFetch('/api/cli/repo-profile', {
+        method: 'POST',
+        body: JSON.stringify({
+          repoUrl,
+          profile: {
+            role: role || 'application',
+            domainOwned: domainOwned || '',
+            apisExposed: apisExposed || [],
+            dependencies: dependencies || [],
+            eventsProduced: eventsProduced || [],
+            eventsConsumed: eventsConsumed || [],
+          },
+        }),
+      });
+
+      return {
+        content: [{
+          type: 'text',
+          text: `## Repository Profile Submitted\n\n${result.message}\n\n- Repository: ${result.repoName}\n- Profile ID: ${result.profileId}`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{
+          type: 'text',
+          text: `## Error\n\n${err.message}\n\nMake sure this repository is registered in Konductro and the git remote URL matches.`,
+        }],
+      };
+    }
+  }
+);
+
+// Tool: Find prototypes for a project (by git remote URL)
+server.tool(
+  'find_project_prototypes',
+  'Find available UX prototypes for a project by matching the git remote URL to a Konductro project',
+  {
+    repoUrl: z.string().describe('The git remote URL of the repository (e.g. from git remote get-url origin)'),
+  },
+  async ({ repoUrl }) => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token in the plugin settings.',
+        }],
+      };
+    }
+
+    try {
+      const result = await konductroFetch(`/api/cli/project-prototypes?repoUrl=${encodeURIComponent(repoUrl)}`);
+
+      if (!result.prototypes || result.prototypes.length === 0) {
+        return {
+          content: [{
+            type: 'text',
+            text: 'No prototypes found for this project.',
+          }],
+        };
+      }
+
+      const list = result.prototypes.map((p, i) => {
+        const fileList = p.files.map(f => `  - [${f.filename}](${f.url})`).join('\n');
+        return `### ${i + 1}. ${p.engagementName} (v${p.version})\n` +
+          `Project: ${p.projectName}\n` +
+          `Index: ${p.indexUrl}\n` +
+          `Files:\n${fileList}`;
+      }).join('\n\n');
+
+      return {
+        content: [{
+          type: 'text',
+          text: `## Prototypes Found\n\n${list}`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{
+          type: 'text',
+          text: `## Error\n\n${err.message}\n\nMake sure this repository is registered in Konductro.`,
+        }],
+      };
+    }
+  }
+);
+
+// ─── Prototype Tasks ────────────────────────────────────────────────────────
+
+// Tool: List pending prototype tasks
+server.tool(
+  'list_prototype_tasks',
+  'List your pending prototype build assignments from Konductro',
+  {},
+  async () => {
+    if (!KONDUCTRO_URL || !CLI_TOKEN) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'Konductro is not configured. Please set your Konductro URL and CLI token in the plugin settings.',
+        }],
+      };
+    }
+
+    const tasks = await konductroFetch('/api/cli/prototype-tasks');
+
+    if (tasks.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: 'No pending prototype tasks assigned to you.',
+        }],
+      };
+    }
+
+    const taskList = tasks.map((t, i) =>
+      `${i + 1}. **${t.engagementName}**\n   Project: ${t.projectName} (${t.clientName})\n   Status: ${t.status}\n   Job ID: \`${t.jobId}\``
+    ).join('\n\n');
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Your Prototype Tasks\n\n${taskList}\n\nUse the **get_prototype_context** tool with the job ID to load the full context.`,
+      }],
+    };
+  }
+);
+
+// Tool: Get full context for a prototype task
+server.tool(
+  'get_prototype_context',
+  'Load the full context (design system, approved documents, preview HTML) for a prototype build task',
+  {
+    jobId: z.string().describe('The job ID from the prototype task list'),
+  },
+  async ({ jobId }) => {
+    const ctx = await konductroFetch(`/api/cli/prototype-tasks/${jobId}/context`);
+
+    let contextText = `## Prototype Build Context\n\n`;
+    contextText += `**Engagement:** ${ctx.engagement.name}\n`;
+    contextText += `**Project:** ${ctx.project.name} (${ctx.project.clientName})\n`;
+    if (ctx.engagement.description) {
+      contextText += `**Description:** ${ctx.engagement.description}\n`;
+    }
+    contextText += `**S3 Prefix:** ${ctx.s3.prefix}\n`;
+    contextText += `**Version:** ${ctx.s3.version}\n\n`;
+
+    if (ctx.designSystem) {
+      contextText += `### Design System${ctx.designSystem.name ? ` — ${ctx.designSystem.name}` : ''}\n\n`;
+      if (ctx.designSystem.tokens) {
+        contextText += `**Tokens:**\n\`\`\`json\n${JSON.stringify(ctx.designSystem.tokens, null, 2)}\n\`\`\`\n\n`;
+      }
+      if (ctx.designSystem.components) {
+        contextText += `**Components:**\n\`\`\`json\n${JSON.stringify(ctx.designSystem.components, null, 2)}\n\`\`\`\n\n`;
+      }
+    }
+
+    if (ctx.approvedDocuments?.length) {
+      contextText += `### Approved Documents\n\n`;
+      for (const doc of ctx.approvedDocuments) {
+        contextText += `#### ${doc.title} (${doc.type})\n\n${doc.content}\n\n---\n\n`;
+      }
+    }
+
+    if (ctx.previewHtml) {
+      contextText += `### Design Studio Preview HTML\n\nA preview screen was locked in the Design Studio step. The HTML is ${ctx.previewHtml.length} characters long. Use this as visual direction for the prototype.\n\n\`\`\`html\n${ctx.previewHtml.slice(0, 3000)}${ctx.previewHtml.length > 3000 ? '\n... (truncated)' : ''}\n\`\`\`\n`;
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: contextText,
+      }],
+    };
+  }
+);
+
+// Tool: Start work on a prototype task
+server.tool(
+  'start_prototype_work',
+  'Mark a prototype task as in progress — call this before building the prototype',
+  {
+    jobId: z.string().describe('The job ID of the prototype task'),
+  },
+  async ({ jobId }) => {
+    const result = await konductroFetch(`/api/cli/prototype-tasks/${jobId}/start`, {
+      method: 'POST',
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `Prototype task started. Status: **${result.status}**. You can now build the prototype in a \`./prototype/\` directory.`,
+      }],
+    };
+  }
+);
+
+// Tool: Request scoped S3 upload credentials
+server.tool(
+  'request_upload_credentials',
+  'Get temporary AWS credentials scoped to upload prototype files to S3',
+  {
+    jobId: z.string().describe('The job ID of the prototype task'),
+  },
+  async ({ jobId }) => {
+    const creds = await konductroFetch(`/api/cli/prototype-tasks/${jobId}/upload-credentials`, {
+      method: 'POST',
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Upload Credentials\n\n` +
+          `These credentials expire at **${creds.expiresAt}** (15 minutes).\n\n` +
+          `- **Bucket:** ${creds.bucket}\n` +
+          `- **Region:** ${creds.region}\n` +
+          `- **Prefix:** ${creds.prefix}\n` +
+          `- **Access Key ID:** ${creds.accessKeyId}\n` +
+          `- **Secret Access Key:** ${creds.secretAccessKey}\n` +
+          `- **Session Token:** ${creds.sessionToken}\n\n` +
+          `Upload each HTML file from the \`./prototype/\` directory to \`s3://${creds.bucket}/${creds.prefix}/\` using these credentials.`,
+      }],
+    };
+  }
+);
+
+// Tool: Submit completed prototype
+server.tool(
+  'submit_prototype',
+  'Submit the completed prototype to Konductro — call after uploading all files to S3',
+  {
+    jobId: z.string().describe('The job ID of the prototype task'),
+    pages: z.array(z.object({
+      filename: z.string().describe('The filename (e.g. index.html, dashboard.html)'),
+      title: z.string().optional().describe('Optional page title'),
+    })).describe('List of pages that were uploaded'),
+  },
+  async ({ jobId, pages }) => {
+    const result = await konductroFetch(`/api/cli/prototype-tasks/${jobId}/submit`, {
+      method: 'POST',
+      body: JSON.stringify({ pages }),
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## Prototype Submitted\n\n` +
+          `Version **${result.version}** published with ${pages.length} page(s).\n\n` +
+          (result.prototypeUrl ? `**URL:** ${result.prototypeUrl}\n\n` : '') +
+          `The SDM has been notified. Task complete.`,
+      }],
+    };
+  }
+);
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error('Failed to start Konductro MCP server:', error);
+  process.exit(1);
+});