@vibekiln/cutline-mcp-cli 0.1.0

package/dist/servers/premortem-server.js

@@ -0,0 +1,971 @@
+#!/usr/bin/env node
+import {
+  RunInputSchema
+} from "./chunk-DE7R7WKY.js";
+import {
+  isWriteTool
+} from "./chunk-KMUSQOTJ.js";
+import {
+  guardBoundary,
+  guardOutput,
+  withPerfTracking
+} from "./chunk-OP4EO6FV.js";
+import {
+  cfPremortemChatAgent,
+  cfPremortemKick,
+  cfRegenAssumptions,
+  cfRegenExperiments,
+  createPremortem,
+  getChat,
+  getPremortem,
+  listPremortems,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  resolveAuthContext,
+  saveChat,
+  updateChat,
+  updatePremortem,
+  validateAuth,
+  validateRequestSize
+} from "./chunk-ZVWDXO6M.js";
+
+// ../mcp/dist/mcp/src/premortem-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";
+
+// ../mcp/dist/mcp/src/premortem-handoff.js
+function buildBrief(ctx) {
+  if (!ctx)
+    return "";
+  const parts = [];
+  if (ctx.brief)
+    parts.push(ctx.brief);
+  if (ctx.problemSolved && !ctx.brief?.toLowerCase().includes(ctx.problemSolved.toLowerCase().slice(0, 20)))
+    parts.push(`Problem: ${ctx.problemSolved}`);
+  if (ctx.uniqueValue && !ctx.brief?.toLowerCase().includes(ctx.uniqueValue.toLowerCase().slice(0, 20)))
+    parts.push(`Unique value: ${ctx.uniqueValue}`);
+  if (ctx.targetUser && !ctx.brief?.toLowerCase().includes(ctx.targetUser.toLowerCase().slice(0, 15)))
+    parts.push(`Target users: ${ctx.targetUser}`);
+  if (ctx.businessModel && !ctx.brief?.toLowerCase().includes(ctx.businessModel.toLowerCase().slice(0, 15)))
+    parts.push(`Business model: ${ctx.businessModel}`);
+  return parts.join(". ").trim() || "No description provided.";
+}
+function buildReferenceClasses(competitors) {
+  if (competitors && competitors.length > 0) {
+    return competitors.filter((c) => c.name && c.name.length > 0).map((c) => c.name).slice(0, 5);
+  }
+  return ["General market alternatives"];
+}
+function buildSeedPersonas(ctx) {
+  if (!ctx.productContext?.targetUser)
+    return void 0;
+  return {
+    user_personas: [{ name: "Primary User", description: ctx.productContext.targetUser }]
+  };
+}
+function buildRunInput(request) {
+  const { projectName, conversationalContext: ctx, mode = "product", clientContext } = request;
+  let brief = buildBrief(ctx.productContext);
+  if (ctx.risks.length > 0) {
+    const topRisks = ctx.risks.filter((r) => r.severity === "critical" || r.severity === "high").slice(0, 2).map((r) => r.title);
+    if (topRisks.length > 0)
+      brief += ` Key concerns to investigate: ${topRisks.join(", ")}.`;
+  }
+  if (ctx.verdict?.summary)
+    brief += ` Initial assessment: ${ctx.verdict.summary}`;
+  const runInput = {
+    mode,
+    project: { name: projectName, brief, reference_classes: buildReferenceClasses(ctx.competitors) }
+  };
+  if (mode === "consulting" && clientContext) {
+    runInput.client = {
+      name: clientContext.name,
+      industry: clientContext.industry,
+      size: clientContext.size,
+      stakeholders: clientContext.stakeholders
+    };
+  }
+  const seedPersonas = buildSeedPersonas(ctx);
+  if (seedPersonas)
+    runInput.seed_personas = seedPersonas;
+  if (ctx.risks.length > 0 || ctx.assumptions.length > 0 || ctx.competitors.length > 0) {
+    runInput.conversational_artifacts = {
+      risks: ctx.risks.length > 0 ? ctx.risks.map((r) => ({
+        title: r.title,
+        description: r.description,
+        category: r.category,
+        severity: r.severity,
+        likelihood: r.likelihood,
+        impact: r.impact
+      })) : void 0,
+      assumptions: ctx.assumptions.length > 0 ? ctx.assumptions.map((a) => ({
+        statement: a.statement,
+        category: a.category,
+        confidence: a.confidence,
+        importance: a.importance
+      })) : void 0,
+      competitors: ctx.competitors.length > 0 ? ctx.competitors.map((c) => ({
+        name: c.name,
+        description: c.description,
+        threat_level: c.threatLevel
+      })) : void 0,
+      conversation_summary: ctx.verdict?.summary
+    };
+  }
+  return runInput;
+}
+function validateForGraduation(ctx) {
+  const errors = [];
+  const warnings = [];
+  if (!ctx.productContext?.brief && !ctx.productContext?.problemSolved)
+    errors.push("No product description found. Please describe what you're building first.");
+  if (ctx.assumptions.length === 0)
+    warnings.push("No assumptions were surfaced. The full analysis will discover them.");
+  if (ctx.risks.length === 0)
+    warnings.push("No risks were identified. The full analysis will analyze risks in depth.");
+  if (ctx.competitors.length === 0)
+    warnings.push("No competitors were discussed. Provide reference companies for better analysis.");
+  return { valid: errors.length === 0, errors, warnings };
+}
+function buildGraduationMetadata(sessionId, ctx, currentAct) {
+  return {
+    sourceType: "conversational_premortem",
+    sourceSessionId: sessionId,
+    graduatedAt: Date.now(),
+    conversationSummary: {
+      actsCompleted: currentAct,
+      assumptionsCount: ctx.assumptions.length,
+      risksCount: ctx.risks.length,
+      competitorsCount: ctx.competitors.length,
+      hasVerdict: !!ctx.verdict
+    }
+  };
+}
+
+// ../mcp/dist/mcp/src/premortem-server.js
+var ACT_NAMES = {
+  1: "Product Understanding",
+  2: "Assumption Surfacing",
+  3: "Risk Discovery",
+  4: "Competitive Landscape",
+  5: "Verdict & Next Steps"
+};
+var chatSessionCache = /* @__PURE__ */ new Map();
+function generateChatSessionId() {
+  return `pmc_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function saveChatSession(session) {
+  session.updatedAt = Date.now();
+  chatSessionCache.set(session.id, session);
+  if (session.uid) {
+    try {
+      await saveChat(session.id, { ...session });
+    } catch (e) {
+      console.error("[PremortemChat] Failed to persist session:", e);
+    }
+  }
+}
+async function getChatSession(sessionId) {
+  if (chatSessionCache.has(sessionId)) {
+    return chatSessionCache.get(sessionId);
+  }
+  try {
+    const data = await getChat(sessionId);
+    if (data) {
+      chatSessionCache.set(sessionId, data);
+      return data;
+    }
+  } catch (e) {
+    console.error("[PremortemChat] Failed to load session:", e);
+  }
+  return null;
+}
+async function createChatSession(initialInput, uid) {
+  const session = {
+    id: generateChatSessionId(),
+    uid,
+    currentAct: 1,
+    initialInput,
+    assumptions: [],
+    risks: [],
+    competitors: [],
+    conversationHistory: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+  await saveChatSession(session);
+  return session;
+}
+function sessionToContext(session) {
+  return {
+    currentAct: session.currentAct,
+    initialInput: session.initialInput,
+    productContext: session.productContext,
+    assumptions: session.assumptions,
+    risks: session.risks,
+    competitors: session.competitors,
+    conversationHistory: session.conversationHistory
+  };
+}
+function canGraduateSession(session) {
+  if (session.verdict) {
+    return { canGraduate: true };
+  }
+  if (session.currentAct < 3) {
+    return { canGraduate: false, reason: "Need to complete at least Act 3 (Risk Discovery)" };
+  }
+  const hasProductContext = session.productContext?.brief;
+  const hasMinimumContent = session.assumptions.length >= 2 || session.risks.length >= 2;
+  if (!hasProductContext) {
+    return { canGraduate: false, reason: "Need product context before graduation" };
+  }
+  if (!hasMinimumContent) {
+    return { canGraduate: false, reason: "Need at least 2 assumptions or risks before graduation" };
+  }
+  return { canGraduate: true };
+}
+var server = new Server({
+  name: "cutline-premortem",
+  version: "0.1.0"
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "premortem_run",
+        description: "Run a synchronous pre-mortem generation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: { type: "object", description: "RunInput object" },
+            auth_token: { type: "string", description: "Optional Firebase ID token" }
+          },
+          required: ["input"]
+        }
+      },
+      {
+        name: "premortem_queue",
+        description: "Enqueue an async pre-mortem job",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: { type: "object", description: "RunInput object" },
+            auth_token: { type: "string" }
+          },
+          required: ["input"]
+        }
+      },
+      {
+        name: "premortem_status",
+        description: "Get status of a pre-mortem job",
+        inputSchema: {
+          type: "object",
+          properties: {
+            jobId: { type: "string" },
+            auth_token: { type: "string" }
+          },
+          required: ["jobId"]
+        }
+      },
+      {
+        name: "premortem_kick",
+        description: "Trigger job execution or resume",
+        inputSchema: {
+          type: "object",
+          properties: {
+            jobId: { type: "string" },
+            auth_token: { type: "string" }
+          },
+          required: ["jobId"]
+        }
+      },
+      {
+        name: "premortem_regen_assumptions",
+        description: "Regenerate assumptions section",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: { type: "object" },
+            doc: { type: "object" },
+            auth_token: { type: "string" }
+          },
+          required: ["input", "doc"]
+        }
+      },
+      {
+        name: "premortem_regen_experiments",
+        description: "Regenerate experiments section",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: { type: "object" },
+            doc: { type: "object" },
+            auth_token: { type: "string" }
+          },
+          required: ["input", "doc"]
+        }
+      },
+      {
+        name: "premortem_list",
+        description: "List user's premortems",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "number", description: "Max number of items to return" },
+            auth_token: { type: "string" }
+          }
+        }
+      },
+      {
+        name: "premortem_graduate",
+        description: "Graduate a conversational premortem to full analysis. Takes context from a chat session and runs the full 9-agent pipeline. Requires premium subscription.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "ID of the conversational premortem session" },
+            project_name: { type: "string", description: "Name for the project (required)" },
+            conversational_context: {
+              type: "object",
+              description: "Context gathered from conversational premortem",
+              properties: {
+                productContext: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    brief: { type: "string" },
+                    targetUser: { type: "string" },
+                    problemSolved: { type: "string" },
+                    uniqueValue: { type: "string" },
+                    businessModel: { type: "string" }
+                  }
+                },
+                assumptions: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      statement: { type: "string" },
+                      category: { type: "string" },
+                      confidence: { type: "number" },
+                      importance: { type: "number" }
+                    }
+                  }
+                },
+                risks: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      title: { type: "string" },
+                      description: { type: "string" },
+                      category: { type: "string" },
+                      severity: { type: "string" },
+                      likelihood: { type: "number" },
+                      impact: { type: "number" }
+                    }
+                  }
+                },
+                competitors: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      name: { type: "string" },
+                      description: { type: "string" },
+                      threatLevel: { type: "string" }
+                    }
+                  }
+                },
+                verdict: {
+                  type: "object",
+                  properties: {
+                    recommendation: { type: "string" },
+                    confidence: { type: "number" },
+                    summary: { type: "string" }
+                  }
+                }
+              }
+            },
+            auth_token: { type: "string" }
+          },
+          required: ["session_id", "project_name", "conversational_context"]
+        }
+      },
+      // ==========================================
+      // Conversational Premortem Chat Tools
+      // ==========================================
+      {
+        name: "premortem_chat_start",
+        description: "Start a conversational premortem session. Guides you through a 5-act stress test of your product idea: Product Understanding \u2192 Assumptions \u2192 Risks \u2192 Competition \u2192 Verdict. FREE to use, graduation to full analysis requires premium.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            product_brief: {
+              type: "string",
+              description: "Brief description of your product or idea to stress-test"
+            },
+            auth_token: { type: "string", description: "Optional Firebase ID token" }
+          },
+          required: ["product_brief"]
+        }
+      },
+      {
+        name: "premortem_chat",
+        description: "Continue a conversational premortem session. Send messages to the AI strategist who will probe your assumptions, identify risks, and help you stress-test your idea.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "Session ID from premortem_chat_start" },
+            message: { type: "string", description: "Your response or question" },
+            advance_act: {
+              type: "boolean",
+              description: "If true, advance to the next act when ready"
+            },
+            auth_token: { type: "string" }
+          },
+          required: ["session_id", "message"]
+        }
+      },
+      {
+        name: "premortem_chat_status",
+        description: "Get the current status of a conversational premortem session, including gathered artifacts and graduation readiness.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "Session ID to check" },
+            auth_token: { type: "string" }
+          },
+          required: ["session_id"]
+        }
+      },
+      {
+        name: "premortem_chat_graduate",
+        description: "Graduate a conversational premortem session to full analysis. Uses the gathered context to run the complete 9-agent pipeline. Requires premium subscription.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session_id: { type: "string", description: "Session ID to graduate" },
+            auth_token: { type: "string" }
+          },
+          required: ["session_id"]
+        }
+      }
+    ]
+  };
+});
+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 () => {
+      if (isWriteTool(name)) {
+        const peekToken = args.auth_token;
+        if (peekToken) {
+          const peekDecoded = await validateAuth(peekToken).catch(() => null);
+          if (peekDecoded && peekDecoded.accountType === "agent") {
+            throw new McpError(ErrorCode.InvalidRequest, "This is a read-only agent account. Write operations require the owner account.");
+          }
+        }
+      }
+      switch (name) {
+        case "premortem_run": {
+          console.error(`[Premortem DEBUG] Starting premortem_run...`);
+          const { input, auth_token } = args;
+          console.error(`[Premortem DEBUG] Step 1: Authenticating...`);
+          const decoded = await requirePremiumWithAutoAuth(auth_token);
+          console.error(`[Premortem DEBUG] Step 1 done: UID=${decoded?.uid}`);
+          console.error(`[Premortem DEBUG] Step 2: Parsing input...`);
+          const parsedInput = RunInputSchema.parse(input);
+          console.error(`[Premortem DEBUG] Step 2 done: project=${parsedInput.project.name}`);
+          console.error(`[Premortem] Queuing analysis for: ${parsedInput.project.name}`);
+          const startTime = Date.now();
+          console.error(`[Premortem DEBUG] Step 4: Creating job document...`);
+          const { id: jobId } = await createPremortem({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null,
+            source: "mcp_sync"
+          });
+          console.error(`[Premortem DEBUG] Step 4 done: jobId=${jobId}`);
+          console.error(`[Premortem] Job queued: ${jobId}, polling for completion...`);
+          const maxWaitMs = 10 * 60 * 1e3;
+          const pollIntervalMs = 3e3;
+          let lastStage = "";
+          let kickedFallback = false;
+          while (Date.now() - startTime < maxWaitMs) {
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            const data = await getPremortem(jobId) || {};
+            if (!kickedFallback && data.status === "queued" && Date.now() - startTime > 1e4) {
+              console.error(`[Premortem] Job still queued after 10s, kicking via Cloud Function...`);
+              kickedFallback = true;
+              cfPremortemKick(jobId).catch((e) => console.error(`[Premortem] Kick fallback error:`, e?.message));
+            }
+            const stage = data.stage_label || data.stage;
+            const progress = data.progress;
+            if (stage && stage !== lastStage) {
+              lastStage = stage;
+              const pct = progress ? ` (${Math.round(progress * 100)}%)` : "";
+              console.error(`[Premortem] ${stage}${pct}`);
+            }
+            if (data.status === "completed") {
+              const elapsed2 = ((Date.now() - startTime) / 1e3).toFixed(1);
+              console.error(`[Premortem] Complete in ${elapsed2}s`);
+              const result = data.result || {};
+              result._jobId = jobId;
+              return {
+                content: [{ type: "text", text: JSON.stringify(result) }]
+              };
+            }
+            if (data.status === "failed" || data.status === "error") {
+              throw new McpError(ErrorCode.InternalError, `Job failed: ${data.error || "Unknown error"}`);
+            }
+          }
+          const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+          console.error(`[Premortem] Timed out after ${elapsed}s, job still running`);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              status: "running",
+              jobId,
+              message: `Job is still running after ${elapsed}s. Use premortem_status to check progress.`
+            }) }]
+          };
+        }
+        case "premortem_queue": {
+          const { input, auth_token } = args;
+          const decoded = await requirePremiumWithAutoAuth(auth_token);
+          const parsedInput = RunInputSchema.parse(input);
+          const { id: queuedJobId } = await createPremortem({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ jobId: queuedJobId }) }]
+          };
+        }
+        case "premortem_status": {
+          const { jobId, auth_token } = args;
+          const { effectiveUid } = await resolveAuthContext(auth_token);
+          const data = await getPremortem(jobId);
+          if (!data)
+            throw new McpError(ErrorCode.InvalidRequest, "Job not found");
+          const allowPublic = process.env.ALLOW_PUBLIC_PREMORTEM === "true";
+          if (!allowPublic && effectiveUid && data.uid && data.uid !== effectiveUid) {
+            throw new McpError(ErrorCode.InvalidRequest, "You do not have permission to access this job");
+          }
+          const status = {
+            status: data.status,
+            result: data.result || null,
+            error: data.error || null,
+            progress: data.progress,
+            stage: data.stage,
+            stage_label: data.stage_label,
+            updatedAt: data.updatedAt
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(status) }]
+          };
+        }
+        case "premortem_kick": {
+          console.error(`[Premortem Kick] Starting kick for job...`);
+          const { jobId, auth_token } = args;
+          const decoded = await requirePremiumWithAutoAuth(auth_token);
+          console.error(`[Premortem Kick] Authenticated: UID=${decoded?.uid}`);
+          console.error(`[Premortem Kick] Calling Cloud Function for job ${jobId}...`);
+          try {
+            const result = await cfPremortemKick(jobId);
+            console.error(`[Premortem Kick] Cloud Function returned:`, result);
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                kicked: result.kicked,
+                status: result.status,
+                jobId,
+                message: result.status === "completed" ? "\u2615 Full analysis complete! Use premortem_status to view results." : "Job processed. Use premortem_status to check results."
+              }) }]
+            };
+          } catch (e) {
+            console.error(`[Premortem Kick] Cloud Function error:`, e?.message || e);
+            throw new McpError(ErrorCode.InternalError, `Failed to process job: ${e?.message || "Unknown error"}`);
+          }
+        }
+        case "premortem_regen_assumptions": {
+          const { input, doc, auth_token } = args;
+          await requirePremiumWithAutoAuth(auth_token);
+          const out = await cfRegenAssumptions(input, doc);
+          return {
+            content: [{ type: "text", text: JSON.stringify(out) }]
+          };
+        }
+        case "premortem_regen_experiments": {
+          const { input, doc, auth_token } = args;
+          await requirePremiumWithAutoAuth(auth_token);
+          const out = await cfRegenExperiments(input, doc);
+          return {
+            content: [{ type: "text", text: JSON.stringify(out) }]
+          };
+        }
+        case "premortem_list": {
+          const { limit = 10, auth_token } = args;
+          const { effectiveUid } = await resolveAuthContext(auth_token);
+          const premortems = await listPremortems({ limit });
+          return {
+            content: [{ type: "text", text: JSON.stringify(premortems, null, 2) }]
+          };
+        }
+        case "premortem_graduate": {
+          const { session_id, project_name, conversational_context, auth_token } = args;
+          if (!session_id || typeof session_id !== "string") {
+            throw new McpError(ErrorCode.InvalidParams, "session_id is required");
+          }
+          if (!project_name || typeof project_name !== "string" || project_name.trim().length === 0) {
+            throw new McpError(ErrorCode.InvalidParams, "project_name is required and cannot be empty");
+          }
+          if (!conversational_context || typeof conversational_context !== "object") {
+            throw new McpError(ErrorCode.InvalidParams, "conversational_context is required");
+          }
+          const decoded = await requirePremiumWithAutoAuth(auth_token);
+          const validation = validateForGraduation(conversational_context);
+          if (!validation.valid) {
+            throw new McpError(ErrorCode.InvalidParams, `Cannot graduate: ${validation.errors.join(", ")}`);
+          }
+          const runInput = buildRunInput({
+            sessionId: session_id,
+            projectName: project_name.trim(),
+            conversationalContext: conversational_context
+          });
+          const parsedInput = RunInputSchema.parse(runInput);
+          const graduationMetadata = buildGraduationMetadata(
+            session_id,
+            conversational_context,
+            conversational_context.verdict ? 5 : 4
+            // Estimate current act
+          );
+          const { id: gradJobId } = await createPremortem({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null,
+            source: "mcp_graduate",
+            graduation: graduationMetadata
+          });
+          console.error(`[Premortem Graduate] Created job ${gradJobId} from session ${session_id}`);
+          try {
+            const sessionData = await getPremortem(session_id);
+            if (sessionData) {
+              await updatePremortem(session_id, {
+                linkedJobId: gradJobId,
+                graduatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              console.error(`[Premortem Graduate] Linked session ${session_id} to job ${gradJobId}`);
+            }
+          } catch (linkError) {
+            console.error(`[Premortem Graduate] Failed to link session:`, linkError);
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              success: true,
+              jobId: gradJobId,
+              sourceSessionId: session_id,
+              projectName: project_name,
+              warnings: validation.warnings,
+              message: `\u2615 Full analysis queued! This will take a minute\u2014go grab a cup of coffee. Use premortem_status with jobId "${gradJobId}" to check progress.`
+            }, null, 2) }]
+          };
+        }
+        // ==========================================
+        // Conversational Premortem Chat Handlers
+        // ==========================================
+        case "premortem_chat_start": {
+          const { product_brief, auth_token } = args;
+          if (!product_brief || typeof product_brief !== "string" || product_brief.trim().length < 10) {
+            throw new McpError(ErrorCode.InvalidParams, "product_brief is required (min 10 characters)");
+          }
+          let uid;
+          try {
+            const decoded = await requirePremiumWithAutoAuth(auth_token).catch(() => null);
+            uid = decoded?.uid;
+          } catch {
+          }
+          const session = await createChatSession(product_brief.trim(), uid);
+          const welcomeMessage = `Let's stress-test **"${session.initialInput.slice(0, 100)}${session.initialInput.length > 100 ? "..." : ""}"**.
+
+I'm going to play devil's advocate and help you find the blind spots, risky assumptions, and potential failure modes in your idea\u2014**before** you invest significant resources.
+
+We'll go through 5 phases:
+1. **Product Understanding** - What exactly are you building?
+2. **Assumption Surfacing** - What must be true for this to work?
+3. **Risk Discovery** - What could go wrong?
+4. **Competitive Landscape** - Who else is here?
+5. **Verdict & Next Steps** - What should you do?
+
+\u{1F4A1} **Tip**: I have access to real-time web research. At any point, ask me to look up competitors, market data, regulations, or industry trends\u2014I'll share what I find.
+
+---
+
+**Act 1: Product Understanding**
+
+Let's start with the basics. Tell me more about what you're building:
+
+- **Who is this for?** (Be specific\u2014role, company size, industry)
+- **What problem does it solve?** How painful is that problem today?
+- **How is it different** from what's already out there?`;
+          session.conversationHistory.push({
+            role: "assistant",
+            content: welcomeMessage
+          });
+          await saveChatSession(session);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              session_id: session.id,
+              current_act: session.currentAct,
+              act_name: ACT_NAMES[session.currentAct],
+              message: welcomeMessage,
+              can_graduate: false
+            }, null, 2) }]
+          };
+        }
+        case "premortem_chat": {
+          const { session_id, message, advance_act, auth_token } = args;
+          if (!session_id) {
+            throw new McpError(ErrorCode.InvalidParams, "session_id is required");
+          }
+          if (!message || typeof message !== "string") {
+            throw new McpError(ErrorCode.InvalidParams, "message is required");
+          }
+          try {
+            const decoded = await requirePremiumWithAutoAuth(auth_token).catch(() => null);
+          } catch {
+          }
+          const session = await getChatSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          session.conversationHistory.push({
+            role: "user",
+            content: message
+          });
+          if (advance_act && session.currentAct < 5) {
+            session.currentAct = session.currentAct + 1;
+          }
+          let response;
+          try {
+            const context = sessionToContext(session);
+            console.error("[PremortemChat] Calling Cloud Function...");
+            response = await cfPremortemChatAgent(message, context);
+            console.error("[PremortemChat] Cloud Function response received");
+          } catch (e) {
+            console.error("[PremortemChat] Cloud Function error:", e?.message || e);
+            throw new McpError(ErrorCode.InternalError, `Failed to generate response: ${e.message}`);
+          }
+          if (response.artifacts) {
+            for (const artifact of response.artifacts) {
+              switch (artifact.type) {
+                case "product_context":
+                  session.productContext = artifact.data;
+                  break;
+                case "assumption":
+                  const existingAssumption = session.assumptions.find((a) => a.statement.toLowerCase() === artifact.data.statement?.toLowerCase());
+                  if (!existingAssumption && artifact.data.statement) {
+                    session.assumptions.push({
+                      id: `asm_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+                      ...artifact.data
+                    });
+                  }
+                  break;
+                case "risk":
+                  const existingRisk = session.risks.find((r) => r.title?.toLowerCase() === artifact.data.title?.toLowerCase());
+                  if (!existingRisk && artifact.data.title) {
+                    session.risks.push({
+                      id: `risk_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+                      ...artifact.data
+                    });
+                  }
+                  break;
+                case "competitor":
+                  const existingCompetitor = session.competitors.find((c) => c.name?.toLowerCase() === artifact.data.name?.toLowerCase());
+                  if (!existingCompetitor && artifact.data.name) {
+                    session.competitors.push({
+                      id: `comp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+                      ...artifact.data
+                    });
+                  }
+                  break;
+                case "verdict":
+                  session.verdict = artifact.data;
+                  break;
+              }
+            }
+          }
+          if (response.suggestedAct && response.suggestedAct !== session.currentAct) {
+            session.currentAct = response.suggestedAct;
+          }
+          session.conversationHistory.push({
+            role: "assistant",
+            content: response.content
+          });
+          await saveChatSession(session);
+          const graduationStatus = canGraduateSession(session);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              session_id: session.id,
+              current_act: session.currentAct,
+              act_name: ACT_NAMES[session.currentAct],
+              message: response.content,
+              artifacts_count: {
+                assumptions: session.assumptions.length,
+                risks: session.risks.length,
+                competitors: session.competitors.length,
+                has_verdict: !!session.verdict
+              },
+              can_graduate: graduationStatus.canGraduate,
+              graduation_hint: graduationStatus.canGraduate ? "Ready to graduate! Use premortem_chat_graduate to run full analysis." : graduationStatus.reason
+            }, null, 2) }]
+          };
+        }
+        case "premortem_chat_status": {
+          const { session_id, auth_token } = args;
+          if (!session_id) {
+            throw new McpError(ErrorCode.InvalidParams, "session_id is required");
+          }
+          try {
+            await requirePremiumWithAutoAuth(auth_token).catch(() => null);
+          } catch {
+          }
+          const session = await getChatSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          const graduationStatus = canGraduateSession(session);
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              session_id: session.id,
+              current_act: session.currentAct,
+              act_name: ACT_NAMES[session.currentAct],
+              initial_input: session.initialInput,
+              product_context: session.productContext || null,
+              artifacts: {
+                assumptions: session.assumptions,
+                risks: session.risks,
+                competitors: session.competitors,
+                verdict: session.verdict || null
+              },
+              conversation_turns: session.conversationHistory.length,
+              can_graduate: graduationStatus.canGraduate,
+              graduation_hint: graduationStatus.canGraduate ? "Ready! Use premortem_chat_graduate to run full analysis." : graduationStatus.reason,
+              created_at: new Date(session.createdAt).toISOString(),
+              updated_at: new Date(session.updatedAt).toISOString()
+            }, null, 2) }]
+          };
+        }
+        case "premortem_chat_graduate": {
+          const { session_id, auth_token } = args;
+          if (!session_id) {
+            throw new McpError(ErrorCode.InvalidParams, "session_id is required");
+          }
+          const decoded = await requirePremiumWithAutoAuth(auth_token);
+          const session = await getChatSession(session_id);
+          if (!session) {
+            throw new McpError(ErrorCode.InvalidRequest, `Session not found: ${session_id}`);
+          }
+          const graduationStatus = canGraduateSession(session);
+          if (!graduationStatus.canGraduate) {
+            throw new McpError(ErrorCode.InvalidRequest, `Cannot graduate: ${graduationStatus.reason}`);
+          }
+          let productContext = session.productContext;
+          if (!productContext?.brief) {
+            console.error("[PremortemGraduate] Building fallback product context from initialInput");
+            productContext = {
+              name: session.initialInput.slice(0, 50),
+              brief: session.initialInput,
+              targetUser: "",
+              problemSolved: "",
+              uniqueValue: ""
+            };
+          }
+          const conversational_context = {
+            productContext,
+            assumptions: session.assumptions,
+            risks: session.risks,
+            competitors: session.competitors,
+            verdict: session.verdict
+          };
+          const validation = validateForGraduation(conversational_context);
+          if (!validation.valid) {
+            throw new McpError(ErrorCode.InvalidParams, `Cannot graduate: ${validation.errors.join(", ")}`);
+          }
+          const project_name = productContext?.name || session.initialInput.slice(0, 50);
+          const runInput = buildRunInput({
+            sessionId: session_id,
+            projectName: project_name,
+            conversationalContext: conversational_context
+          });
+          const parsedInput = RunInputSchema.parse(runInput);
+          const { id: chatGradJobId } = await createPremortem({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null,
+            source: "mcp_chat_graduate",
+            metadata: buildGraduationMetadata(session_id, conversational_context, conversational_context.verdict ? 5 : 4)
+          });
+          session.conversationHistory.push({
+            role: "assistant",
+            content: `\u{1F393} **Graduated to Full Analysis!**
+
+\u2615 This will take a minute\u2014go grab a cup of coffee while our 9 AI agents stress-test your idea.
+
+Job ID: \`${chatGradJobId}\`
+
+The full pipeline includes deeper competitor research, market sizing, financial modeling, and more.`
+          });
+          await saveChatSession(session);
+          try {
+            await updateChat(session_id, {
+              linkedJobId: chatGradJobId,
+              graduatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              success: true,
+              jobId: chatGradJobId,
+              sourceSessionId: session_id,
+              projectName: project_name,
+              warnings: validation.warnings,
+              artifacts_used: {
+                assumptions: session.assumptions.length,
+                risks: session.risks.length,
+                competitors: session.competitors.length,
+                has_verdict: !!session.verdict
+              },
+              message: `\u2615 Full analysis queued! This will take a minute\u2014go grab a cup of coffee. Use premortem_status with jobId "${chatGradJobId}" to check progress.`
+            }, 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 Premortem MCP Server running on stdio");
+  console.error("Tools: premortem_run, premortem_queue, premortem_status, premortem_kick, premortem_list, premortem_graduate");
+  console.error("Chat Tools: premortem_chat_start, premortem_chat, premortem_chat_status, premortem_chat_graduate");
+}
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});