@vibekiln/cutline-mcp-cli 0.1.0

package/dist/servers/exploration-server.js

@@ -0,0 +1,930 @@
+#!/usr/bin/env node
+import {
+  guardBoundary,
+  guardOutput,
+  withPerfTracking
+} from "./chunk-OP4EO6FV.js";
+import {
+  cfConsultingDiscoveryAgent,
+  cfExplorationAgent,
+  createExplorationSession,
+  getExplorationSession,
+  listExplorationSessions,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  updateExplorationSession,
+  validateRequestSize
+} from "./chunk-ZVWDXO6M.js";
+
+// ../mcp/dist/mcp/src/exploration-server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+var sessionCache = /* @__PURE__ */ new Map();
+function generateId(mode = "product") {
+  const prefix = mode === "consulting" ? "cdisc" : "exp";
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function createSession(initialInput, mode = "product", uid) {
+  const session = {
+    id: generateId(mode),
+    uid,
+    mode,
+    currentAct: 1,
+    initialInput,
+    painPoints: [],
+    ideas: [],
+    challenges: [],
+    scopeItems: [],
+    approachOptions: [],
+    conversationHistory: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+  const collectionName = mode === "consulting" ? "consulting_discovery_sessions" : "exploration_sessions";
+  try {
+    await createExplorationSession(session.id, { ...session }, collectionName);
+    console.error(`[Discovery] Session created (${mode}): ${session.id}`);
+  } catch (err) {
+    console.error(`[Discovery] Failed to persist session:`, err);
+  }
+  sessionCache.set(session.id, session);
+  return session;
+}
+async function getSession(id) {
+  const isConsulting = id.startsWith("cdisc_");
+  const collectionName = isConsulting ? "consulting_discovery_sessions" : "exploration_sessions";
+  try {
+    const data = await getExplorationSession(id, collectionName);
+    if (data) {
+      const session = {
+        id: data.id || id,
+        uid: data.uid,
+        mode: data.mode || (isConsulting ? "consulting" : "product"),
+        currentAct: data.currentAct,
+        initialInput: data.initialInput,
+        domainContext: data.domainContext,
+        painPoints: data.painPoints || [],
+        ideas: data.ideas || [],
+        clientContext: data.clientContext,
+        challenges: data.challenges || [],
+        scopeItems: data.scopeItems || [],
+        approachOptions: data.approachOptions || [],
+        fitAssessment: data.fitAssessment,
+        conversationHistory: data.conversationHistory || [],
+        createdAt: data.createdAt?.toMillis?.() || data.createdAt || Date.now(),
+        updatedAt: data.updatedAt?.toMillis?.() || data.updatedAt || Date.now()
+      };
+      sessionCache.set(id, session);
+      return session;
+    }
+  } catch (err) {
+    console.error(`[Discovery] Failed to load session:`, err);
+  }
+  return sessionCache.get(id) || null;
+}
+async function updateSession(session) {
+  session.updatedAt = Date.now();
+  const collectionName = session.mode === "consulting" ? "consulting_discovery_sessions" : "exploration_sessions";
+  try {
+    await updateExplorationSession(session.id, { ...session }, collectionName);
+  } catch (err) {
+    console.error(`[Discovery] Failed to update session:`, err);
+  }
+  sessionCache.set(session.id, session);
+}
+async function listUserSessions(uid, mode) {
+  try {
+    const collections = mode ? [mode === "consulting" ? "consulting_discovery_sessions" : "exploration_sessions"] : ["exploration_sessions", "consulting_discovery_sessions"];
+    const allSessions = [];
+    for (const collectionName of collections) {
+      const docs = await listExplorationSessions(collectionName, 20);
+      const isConsulting = collectionName === "consulting_discovery_sessions";
+      const sessions = docs.map((data) => ({
+        id: data.id,
+        uid: data.uid,
+        mode: data.mode || (isConsulting ? "consulting" : "product"),
+        currentAct: data.currentAct,
+        initialInput: data.initialInput,
+        domainContext: data.domainContext,
+        painPoints: data.painPoints || [],
+        ideas: data.ideas || [],
+        clientContext: data.clientContext,
+        challenges: data.challenges || [],
+        scopeItems: data.scopeItems || [],
+        approachOptions: data.approachOptions || [],
+        fitAssessment: data.fitAssessment,
+        conversationHistory: data.conversationHistory || [],
+        createdAt: data.createdAt?.toMillis?.() || data.createdAt || Date.now(),
+        updatedAt: data.updatedAt?.toMillis?.() || data.updatedAt || Date.now()
+      }));
+      allSessions.push(...sessions);
+    }
+    return allSessions.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, 20);
+  } catch (err) {
+    console.error(`[Discovery] Failed to list sessions:`, err);
+    const sessions = Array.from(sessionCache.values());
+    return mode ? sessions.filter((s) => s.mode === mode) : sessions;
+  }
+}
+var server = new Server({
+  name: "cutline-exploration",
+  version: "0.1.0"
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "discovery_start",
+        description: "Start a new discovery session. FREE - no premium required. Supports both product exploration and consulting client discovery modes.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: {
+              type: "string",
+              description: "Initial input - for product mode: domain/idea (e.g., 'AI tools for real estate agents'); for consulting mode: client/engagement context (e.g., 'Acme Corp - AI strategy assessment')"
+            },
+            mode: {
+              type: "string",
+              enum: ["product", "consulting"],
+              description: "Discovery mode: 'product' for product/idea exploration (default), 'consulting' for client engagement discovery"
+            }
+          },
+          required: ["input"]
+        }
+      },
+      // Backwards compatibility alias
+      {
+        name: "exploration_start",
+        description: "Start a new product exploration session. FREE - no premium required. (Alias for discovery_start with mode=product)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: {
+              type: "string",
+              description: "Initial domain, problem space, or idea to explore"
+            }
+          },
+          required: ["input"]
+        }
+      },
+      {
+        name: "discovery_chat",
+        description: "Continue a discovery conversation. FREE - no premium required. Works for both product exploration and consulting discovery sessions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "Session ID from discovery_start or exploration_start" },
+            message: { type: "string", description: "Your message or response" },
+            advance_act: { type: "boolean", description: "If true, advance to the next act when suggested" }
+          },
+          required: ["session_id", "message"]
+        }
+      },
+      // Backwards compatibility alias
+      {
+        name: "exploration_chat",
+        description: "Continue an exploration conversation. (Alias for discovery_chat)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "Session ID from exploration_start" },
+            message: { type: "string", description: "Your message or response" },
+            advance_act: { type: "boolean", description: "If true, advance to the next act when suggested" }
+          },
+          required: ["session_id", "message"]
+        }
+      },
+      {
+        name: "discovery_status",
+        description: "Get current status of a discovery session including progress and collected artifacts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string" }
+          },
+          required: ["session_id"]
+        }
+      },
+      // Backwards compatibility alias
+      {
+        name: "exploration_status",
+        description: "Get current status of an exploration session. (Alias for discovery_status)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string" }
+          },
+          required: ["session_id"]
+        }
+      },
+      {
+        name: "discovery_list",
+        description: "List all discovery sessions (both product exploration and consulting discovery).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              enum: ["product", "consulting"],
+              description: "Optional filter by mode"
+            }
+          }
+        }
+      },
+      // Backwards compatibility alias
+      {
+        name: "exploration_list",
+        description: "List all exploration sessions. (Alias for discovery_list with mode=product)",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "discovery_graduate",
+        description: "Graduate from discovery to refinement (premortem). REQUIRES PREMIUM - shows teaser if not subscribed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string" },
+            idea_index: { type: "number", description: "For product mode: index of the idea to graduate (0-based). Defaults to top-ranked." },
+            approach_index: { type: "number", description: "For consulting mode: index of the approach to graduate (0-based). Defaults to highest fit score." },
+            auth_token: { type: "string", description: "Optional Firebase ID token for premium check" }
+          },
+          required: ["session_id"]
+        }
+      },
+      // Backwards compatibility alias
+      {
+        name: "exploration_graduate",
+        description: "Graduate the top idea from exploration to pre-mortem. (Alias for discovery_graduate)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string" },
+            idea_index: { type: "number", description: "Index of the idea to graduate (0-based). Defaults to top-ranked idea." },
+            auth_token: { type: "string", description: "Optional Firebase ID token for premium check" }
+          },
+          required: ["session_id"]
+        }
+      }
+    ]
+  };
+});
+var PRODUCT_ACT_NAMES = {
+  1: "Domain Framing",
+  2: "Pain Discovery",
+  3: "AI Fit Analysis",
+  4: "Idea Crystallization",
+  5: "Value Ranking",
+  6: "Graduation"
+};
+var CONSULTING_ACT_NAMES = {
+  1: "Client Context",
+  2: "Problem Discovery",
+  3: "Scope Framing",
+  4: "Approach Options",
+  5: "Fit Assessment",
+  6: "Graduation"
+};
+function getActNames(mode) {
+  return mode === "consulting" ? CONSULTING_ACT_NAMES : PRODUCT_ACT_NAMES;
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: rawArgs } = request.params;
+    if (!rawArgs)
+      throw new McpError(ErrorCode.InvalidParams, "Missing arguments");
+    validateRequestSize(rawArgs);
+    const { args } = guardBoundary(name, rawArgs);
+    const rawResponse = await withPerfTracking(name, async () => {
+      switch (name) {
+        case "discovery_start":
+        case "exploration_start": {
+          const { input, mode: requestedMode } = args;
+          if (!input || typeof input !== "string") {
+            throw new McpError(ErrorCode.InvalidParams, "Input is required");
+          }
+          const mode = name === "exploration_start" ? "product" : requestedMode || "product";
+          let uid;
+          const session = await createSession(input.trim(), mode, uid);
+          const actNames = getActNames(mode);
+          let welcomeMessage;
+          if (mode === "consulting") {
+            welcomeMessage = `Let's explore this consulting engagement: **"${session.initialInput}"**
+
+I'll help you understand the client, identify their challenges, define scope, and develop engagement approaches. We'll go through this systematically:
+
+1. **Client Context** - Understand the client and stakeholders
+2. **Problem Discovery** - Identify their core challenges
+3. **Scope Framing** - Define what's in and out of scope
+4. **Approach Options** - Generate engagement approaches
+5. **Fit Assessment** - Evaluate mutual fit and risks
+6. **Graduation** - Prepare for deeper analysis
+
+\u{1F4A1} **Tip**: I can research the client's company, industry trends, and typical consulting rates. Just ask!
+
+Let's start with **Client Context**:
+
+Tell me about this potential client. What do you know about:
+- Their company (size, industry, growth stage)?
+- Who you've been talking to (role, influence)?
+- What prompted them to reach out?`;
+          } else {
+            welcomeMessage = `Let's explore **"${session.initialInput}"** together.
+
+I'll help you map out this space, identify pain points, and crystallize concrete product ideas. We'll go through this systematically:
+
+1. **Domain Framing** - Understand the landscape
+2. **Pain Discovery** - Find the problems worth solving  
+3. **AI Fit Analysis** - Score opportunities for AI leverage
+4. **Idea Crystallization** - Generate product concepts
+5. **Value Ranking** - Prioritize by potential
+6. **Graduation** - Pick a winner to stress-test
+
+\u{1F4A1} **Tip**: I have access to real-time web research. At any point, ask me to look up market trends, existing solutions, or industry data\u2014I'll share what I find.
+
+Let's start with **Domain Framing**:
+
+What's your current connection to this space? Are you:
+- An insider who knows the pain firsthand?
+- An outsider who's observed opportunities?
+- Somewhere in between?
+
+And what draws you to explore this area?`;
+          }
+          session.conversationHistory.push({
+            role: "assistant",
+            content: welcomeMessage
+          });
+          await updateSession(session);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                session_id: session.id,
+                mode: session.mode,
+                current_act: session.currentAct,
+                act_name: actNames[session.currentAct],
+                message: welcomeMessage,
+                hint: `Reply with ${mode === "consulting" ? "discovery_chat" : "exploration_chat"} to continue the conversation`
+              }, null, 2)
+            }]
+          };
+        }
+        case "discovery_chat":
+        case "exploration_chat": {
+          const { session_id, message, advance_act } = args;
+          const session = await getSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          const actNames = getActNames(session.mode);
+          session.conversationHistory.push({
+            role: "user",
+            content: message
+          });
+          let response;
+          if (session.mode === "consulting") {
+            const context = {
+              currentAct: session.currentAct,
+              initialInput: session.initialInput,
+              clientContext: session.clientContext,
+              challenges: session.challenges,
+              scopeItems: session.scopeItems,
+              approachOptions: session.approachOptions,
+              conversationHistory: session.conversationHistory,
+              fallbackCount: session.fallbackCount || 0
+            };
+            console.error("[Discovery] Calling Consulting Discovery Cloud Function...");
+            response = await cfConsultingDiscoveryAgent(message, context);
+          } else {
+            const context = {
+              currentAct: session.currentAct,
+              initialInput: session.initialInput,
+              domainContext: session.domainContext,
+              painPoints: session.painPoints,
+              ideas: session.ideas,
+              conversationHistory: session.conversationHistory,
+              fallbackCount: session.fallbackCount || 0
+            };
+            console.error("[Discovery] Calling Exploration Cloud Function...");
+            response = await cfExplorationAgent(message, context);
+          }
+          console.error("[Discovery] Cloud Function response received");
+          if (response.wasFallback) {
+            session.fallbackCount = (session.fallbackCount || 0) + 1;
+            console.error(`[Discovery] Fallback count: ${session.fallbackCount}`);
+          } else {
+            session.fallbackCount = 0;
+          }
+          session.conversationHistory.push({
+            role: "assistant",
+            content: response.content
+          });
+          if (response.artifacts) {
+            for (const artifact of response.artifacts) {
+              if (session.mode === "consulting") {
+                if (artifact.type === "client_context" && artifact.data) {
+                  session.clientContext = {
+                    ...session.clientContext,
+                    ...artifact.data
+                  };
+                }
+                if (artifact.type === "challenge" && artifact.data?.description) {
+                  session.challenges.push({
+                    id: generateId(session.mode),
+                    ...artifact.data
+                  });
+                }
+                if (artifact.type === "scope_item" && artifact.data?.item) {
+                  session.scopeItems.push({
+                    id: generateId(session.mode),
+                    ...artifact.data
+                  });
+                }
+                if (artifact.type === "approach_option" && artifact.data?.title) {
+                  session.approachOptions.push({
+                    id: generateId(session.mode),
+                    ...artifact.data
+                  });
+                }
+                if (artifact.type === "fit_assessment" && artifact.data?.overallFit) {
+                  session.fitAssessment = artifact.data;
+                }
+              } else {
+                if (artifact.type === "domain_context" && artifact.data) {
+                  session.domainContext = {
+                    ...session.domainContext,
+                    ...artifact.data
+                  };
+                }
+                if (artifact.type === "pain_point" && artifact.data) {
+                  if (artifact.data.description) {
+                    session.painPoints.push({
+                      id: generateId(session.mode),
+                      ...artifact.data
+                    });
+                  }
+                  if (artifact.data.scores) {
+                    for (const score of artifact.data.scores) {
+                      if (session.painPoints[score.painPointIndex]) {
+                        session.painPoints[score.painPointIndex].aiLeverage = score.aiLeverage;
+                      }
+                    }
+                  }
+                }
+                if (artifact.type === "idea_card" && artifact.data?.title) {
+                  session.ideas.push({
+                    id: generateId(session.mode),
+                    ...artifact.data
+                  });
+                }
+              }
+            }
+          }
+          let actAdvanced = false;
+          if (response.autoAdvanced && response.suggestedAct) {
+            session.currentAct = response.suggestedAct;
+            session.fallbackCount = 0;
+            actAdvanced = true;
+            console.error(`[Discovery] Auto-advanced to act ${session.currentAct} due to fallback loop`);
+          } else if (advance_act && response.suggestedAct && response.suggestedAct !== session.currentAct) {
+            session.currentAct = response.suggestedAct;
+            session.fallbackCount = 0;
+            actAdvanced = true;
+          }
+          await updateSession(session);
+          const result = {
+            session_id: session.id,
+            mode: session.mode,
+            current_act: session.currentAct,
+            act_name: actNames[session.currentAct],
+            message: response.content
+          };
+          if (response.suggestedAct && response.suggestedAct !== session.currentAct) {
+            result.suggested_next_act = response.suggestedAct;
+            result.suggested_act_name = actNames[response.suggestedAct];
+            result.hint = `To advance to ${actNames[response.suggestedAct]}, add advance_act: true to your next message`;
+          }
+          if (actAdvanced) {
+            result.act_advanced = true;
+            result.hint = `Now in ${actNames[session.currentAct]} phase`;
+          }
+          if (session.mode === "consulting") {
+            result.stats = {
+              challenges: session.challenges.length,
+              scope_items: session.scopeItems.length,
+              approaches: session.approachOptions.length,
+              messages: session.conversationHistory.length
+            };
+          } else {
+            result.stats = {
+              pain_points: session.painPoints.length,
+              ideas: session.ideas.length,
+              messages: session.conversationHistory.length
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }]
+          };
+        }
+        case "discovery_status":
+        case "exploration_status": {
+          const { session_id } = args;
+          const session = await getSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          const actNames = getActNames(session.mode);
+          if (session.mode === "consulting") {
+            const topApproach = session.approachOptions.length > 0 ? session.approachOptions.reduce((best, approach) => approach.fitScore > best.fitScore ? approach : best) : null;
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  session_id: session.id,
+                  mode: session.mode,
+                  current_act: session.currentAct,
+                  act_name: actNames[session.currentAct],
+                  progress: `${session.currentAct}/6 acts`,
+                  initial_input: session.initialInput,
+                  client_context: session.clientContext,
+                  challenges: session.challenges.map((c, i) => ({
+                    index: i,
+                    description: c.description,
+                    urgency: c.urgency,
+                    feasibility: c.feasibility
+                  })),
+                  scope_items: session.scopeItems.map((s, i) => ({
+                    index: i,
+                    item: s.item,
+                    in_scope: s.inScope
+                  })),
+                  approaches: session.approachOptions.map((a, i) => ({
+                    index: i,
+                    title: a.title,
+                    fit_score: a.fitScore,
+                    pricing: a.pricing
+                  })),
+                  top_approach: topApproach ? {
+                    title: topApproach.title,
+                    fit_score: topApproach.fitScore
+                  } : null,
+                  fit_assessment: session.fitAssessment,
+                  can_graduate: session.currentAct >= 5 && session.approachOptions.length > 0,
+                  created_at: new Date(session.createdAt).toISOString(),
+                  updated_at: new Date(session.updatedAt).toISOString()
+                }, null, 2)
+              }]
+            };
+          } else {
+            const topIdea = session.ideas.length > 0 ? session.ideas.reduce((best, idea) => {
+              const score = idea.painIntensity * idea.aiLeverage * idea.marketAccessibility / 10;
+              const bestScore = best.painIntensity * best.aiLeverage * best.marketAccessibility / 10;
+              return score > bestScore ? idea : best;
+            }) : null;
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  session_id: session.id,
+                  mode: session.mode,
+                  current_act: session.currentAct,
+                  act_name: actNames[session.currentAct],
+                  progress: `${session.currentAct}/6 acts`,
+                  initial_input: session.initialInput,
+                  domain_context: session.domainContext,
+                  pain_points: session.painPoints.map((p, i) => ({
+                    index: i,
+                    description: p.description,
+                    who_feels_it: p.whoFeelsIt,
+                    ai_leverage: p.aiLeverage
+                  })),
+                  ideas: session.ideas.map((idea, i) => ({
+                    index: i,
+                    title: idea.title,
+                    problem: idea.problem,
+                    solution: idea.solution,
+                    value_score: Math.round(idea.painIntensity * idea.aiLeverage * idea.marketAccessibility / 10)
+                  })),
+                  top_idea: topIdea ? {
+                    title: topIdea.title,
+                    value_score: Math.round(topIdea.painIntensity * topIdea.aiLeverage * topIdea.marketAccessibility / 10)
+                  } : null,
+                  can_graduate: session.currentAct >= 5 && session.ideas.length > 0,
+                  created_at: new Date(session.createdAt).toISOString(),
+                  updated_at: new Date(session.updatedAt).toISOString()
+                }, null, 2)
+              }]
+            };
+          }
+        }
+        case "discovery_list":
+        case "exploration_list": {
+          const { mode: filterMode } = args;
+          const effectiveMode = name === "exploration_list" ? "product" : filterMode;
+          const sessions = await listUserSessions(void 0, effectiveMode);
+          const sessionList = sessions.map((s) => {
+            const actNames = getActNames(s.mode);
+            const base = {
+              session_id: s.id,
+              mode: s.mode,
+              current_act: s.currentAct,
+              act_name: actNames[s.currentAct],
+              initial_input: s.initialInput.slice(0, 50) + (s.initialInput.length > 50 ? "..." : ""),
+              updated_at: new Date(s.updatedAt).toISOString()
+            };
+            if (s.mode === "consulting") {
+              return {
+                ...base,
+                client_name: s.clientContext?.companyName,
+                challenges: s.challenges.length,
+                approaches: s.approachOptions.length
+              };
+            } else {
+              return {
+                ...base,
+                pain_points: s.painPoints.length,
+                ideas: s.ideas.length
+              };
+            }
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                sessions: sessionList,
+                count: sessionList.length,
+                filter: effectiveMode || "all"
+              }, null, 2)
+            }]
+          };
+        }
+        case "discovery_graduate":
+        case "exploration_graduate": {
+          const { session_id, idea_index, approach_index, auth_token } = args;
+          const session = await getSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          let isPremium = false;
+          try {
+            await requirePremiumWithAutoAuth(auth_token);
+            isPremium = true;
+          } catch (e) {
+            console.error("[Discovery] Auth check failed:", e?.message);
+            isPremium = false;
+          }
+          if (session.mode === "consulting") {
+            if (session.approachOptions.length === 0) {
+              throw new McpError(ErrorCode.InvalidRequest, "No approaches to graduate. Complete discovery first.");
+            }
+            let approachToGraduate;
+            const idx = approach_index ?? idea_index;
+            if (typeof idx === "number") {
+              if (idx < 0 || idx >= session.approachOptions.length) {
+                throw new McpError(ErrorCode.InvalidRequest, `Invalid approach_index: ${idx}. Valid range: 0-${session.approachOptions.length - 1}`);
+              }
+              approachToGraduate = session.approachOptions[idx];
+            } else {
+              approachToGraduate = session.approachOptions.reduce((best, approach) => approach.fitScore > best.fitScore ? approach : best);
+            }
+            const generateConsultingTeaser = () => {
+              let riskCount = session.challenges.filter((c) => c.urgency === "critical" || c.urgency === "high").length;
+              riskCount = Math.max(riskCount, 2);
+              const fit = session.fitAssessment?.overallFit || "unknown";
+              const signal = fit === "strong" ? "\u2705 STRONG FIT" : fit === "good" ? "\u{1F44D} GOOD FIT" : fit === "cautious" ? "\u26A0\uFE0F PROCEED WITH CAUTION" : "\u{1F6A8} CONCERNS";
+              return {
+                signal,
+                risks_found: riskCount,
+                scope_items: session.scopeItems.length,
+                fit_assessment: fit
+              };
+            };
+            if (!isPremium) {
+              const teaser = generateConsultingTeaser();
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "gate",
+                    mode: "consulting",
+                    message: "Full analysis requires Cutline Premium",
+                    approach: {
+                      title: approachToGraduate.title,
+                      fit_score: approachToGraduate.fitScore
+                    },
+                    teaser: {
+                      preliminary_signal: teaser.signal,
+                      risks_found: teaser.risks_found,
+                      scope_items: teaser.scope_items,
+                      message: `Engagement "${approachToGraduate.title}" has ${teaser.risks_found} identified risks.`
+                    },
+                    locked: [
+                      "Full engagement risk analysis",
+                      "Pricing strategy recommendations",
+                      "SOW and proposal generation",
+                      "Go/no-go recommendation with evidence"
+                    ],
+                    upgrade: {
+                      url: "https://thecutline.ai/upgrade",
+                      message: "Upgrade to unlock full consulting analysis"
+                    }
+                  }, null, 2)
+                }]
+              };
+            }
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  status: "ready",
+                  mode: "consulting",
+                  message: "Ready to graduate to consulting analysis!",
+                  approach: {
+                    title: approachToGraduate.title,
+                    description: approachToGraduate.description,
+                    deliverables: approachToGraduate.deliverables,
+                    pricing: approachToGraduate.pricing,
+                    fit_score: approachToGraduate.fitScore
+                  },
+                  context: {
+                    client: session.clientContext,
+                    challenges: session.challenges,
+                    scope_items: session.scopeItems,
+                    fit_assessment: session.fitAssessment,
+                    discovery_id: session.id
+                  },
+                  next_step: {
+                    tool: "premortem_chat_start",
+                    hint: "Use premortem_chat_start with mode='consulting' to start the refinement conversation.",
+                    input_template: {
+                      input: `Consulting engagement for ${session.clientContext?.companyName || "client"}: ${approachToGraduate.title}`,
+                      mode: "consulting"
+                    }
+                  }
+                }, null, 2)
+              }]
+            };
+          } else {
+            if (session.ideas.length === 0) {
+              throw new McpError(ErrorCode.InvalidRequest, "No ideas to graduate. Complete exploration first.");
+            }
+            let ideaToGraduate;
+            if (typeof idea_index === "number") {
+              if (idea_index < 0 || idea_index >= session.ideas.length) {
+                throw new McpError(ErrorCode.InvalidRequest, `Invalid idea_index: ${idea_index}. Valid range: 0-${session.ideas.length - 1}`);
+              }
+              ideaToGraduate = session.ideas[idea_index];
+            } else {
+              ideaToGraduate = session.ideas.reduce((best, idea) => {
+                const score = idea.painIntensity * idea.aiLeverage * idea.marketAccessibility / 10;
+                const bestScore = best.painIntensity * best.aiLeverage * best.marketAccessibility / 10;
+                return score > bestScore ? idea : best;
+              });
+            }
+            const valueScore = Math.round(ideaToGraduate.painIntensity * ideaToGraduate.aiLeverage * ideaToGraduate.marketAccessibility / 10);
+            const generateTeaser = () => {
+              let riskCount = 2;
+              if (ideaToGraduate.aiLeverage < 6)
+                riskCount++;
+              if (ideaToGraduate.marketAccessibility < 5)
+                riskCount++;
+              if (ideaToGraduate.painIntensity < 6)
+                riskCount++;
+              if (session.domainContext?.assumptions && session.domainContext.assumptions.length > 3) {
+                riskCount++;
+              }
+              riskCount = Math.min(riskCount, 6);
+              const assumptionCount = (session.domainContext?.assumptions?.length || 3) + 2;
+              const competitorHints = ideaToGraduate.marketAccessibility >= 7 ? 3 : ideaToGraduate.marketAccessibility >= 5 ? 2 : 1;
+              let signal;
+              if (valueScore >= 60 && riskCount <= 3) {
+                signal = "proceed";
+              } else if (valueScore >= 40 || riskCount <= 4) {
+                signal = "caution";
+              } else {
+                signal = "concern";
+              }
+              const signalEmoji = {
+                proceed: "\u2705 PROMISING",
+                caution: "\u26A0\uFE0F CAUTION",
+                concern: "\u{1F6A8} CONCERNS"
+              };
+              return {
+                signal: signalEmoji[signal],
+                risks_found: riskCount,
+                assumptions_to_validate: assumptionCount,
+                competitive_threats: competitorHints
+              };
+            };
+            if (!isPremium) {
+              const teaser = generateTeaser();
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "gate",
+                    mode: "product",
+                    message: "Pre-mortem requires Cutline Premium",
+                    idea: {
+                      title: ideaToGraduate.title,
+                      value_score: valueScore
+                    },
+                    teaser: {
+                      preliminary_signal: teaser.signal,
+                      risks_found: teaser.risks_found,
+                      assumptions_to_validate: teaser.assumptions_to_validate,
+                      competitive_threats: teaser.competitive_threats,
+                      message: `Your idea "${ideaToGraduate.title}" has ${teaser.risks_found} critical risks and ${teaser.assumptions_to_validate} assumptions to validate.`
+                    },
+                    locked: [
+                      "Full risk analysis with mitigations",
+                      "Assumption prioritization and test plans",
+                      "Competitive landscape deep dive",
+                      "Final verdict with clear reasoning",
+                      "What to validate first"
+                    ],
+                    upgrade: {
+                      url: "https://thecutline.ai/upgrade",
+                      message: "Upgrade to unlock full pre-mortem analysis"
+                    },
+                    hint: "Run 'cutline-mcp login' to authenticate, or visit https://thecutline.ai/upgrade"
+                  }, null, 2)
+                }]
+              };
+            }
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  status: "ready",
+                  mode: "product",
+                  message: "Ready to graduate to pre-mortem!",
+                  idea: {
+                    title: ideaToGraduate.title,
+                    problem: ideaToGraduate.problem,
+                    solution: ideaToGraduate.solution,
+                    why_ai: ideaToGraduate.whyAI,
+                    value_score: valueScore,
+                    scores: {
+                      pain_intensity: ideaToGraduate.painIntensity,
+                      ai_leverage: ideaToGraduate.aiLeverage,
+                      market_accessibility: ideaToGraduate.marketAccessibility
+                    }
+                  },
+                  context: {
+                    domain: session.domainContext,
+                    pain_points: session.painPoints,
+                    exploration_id: session.id
+                  },
+                  next_step: {
+                    tool: "premortem_run",
+                    hint: "\u2615 Use premortem_run with this idea to start the full analysis. It'll take a minute\u2014grab a coffee while our AI agents stress-test your idea!",
+                    input_template: {
+                      project: {
+                        name: ideaToGraduate.title,
+                        brief: `${ideaToGraduate.problem}
+
+Solution: ${ideaToGraduate.solution}
+
+Why AI: ${ideaToGraduate.whyAI}`
+                      }
+                    }
+                  }
+                }, null, 2)
+              }]
+            };
+          }
+        }
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+    });
+    return guardOutput(name, rawResponse);
+  } catch (error) {
+    throw mapErrorToMcp(error, { tool: request.params.name });
+  }
+});
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Cutline Discovery MCP Server (Stage II-a) running on stdio");
+  console.error("Modes: product (exploration) | consulting (client discovery)");
+  console.error("Tools: discovery_start, discovery_chat, discovery_status, discovery_list, discovery_graduate");
+  console.error("       (plus exploration_* aliases for backwards compatibility)");
+  console.error("Discovery is FREE. Graduation to refinement requires premium.");
+}
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});