@kylewadegrove/cutline-mcp-cli 0.4.2 → 0.5.0

package/dist/servers/premortem-server.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+import {
+  firestoreRetry
+} from "./chunk-PU7TL6S3.js";
+import {
+  isWriteTool
+} from "./chunk-KMUSQOTJ.js";
+import "./chunk-IVWF7VYZ.js";
+import {
+  guardBoundary,
+  guardOutput,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  resolveAuthContext,
+  validateAuth,
+  validateRequestSize,
+  withPerfTracking
+} from "./chunk-PD2HN2R5.js";
+import {
+  RunInputSchema,
+  regenerateAssumptions,
+  regenerateExperiments
+} from "./chunk-7FHM2GD3.js";
+import "./chunk-JBJYSV4P.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";
+import admin from "firebase-admin";
+import { getApps, getApp } from "firebase-admin/app";
+import { getFirestore } from "firebase-admin/firestore";
+import { GoogleAuth } from "google-auth-library";
+var PREMORTEM_CHAT_FUNCTION_URL = process.env.PREMORTEM_CHAT_AGENT_FUNCTION_URL || "https://us-central1-cutline-prod.cloudfunctions.net/premortemChatAgent";
+var PREMORTEM_KICK_FUNCTION_URL = process.env.PREMORTEM_KICK_FUNCTION_URL || "https://us-central1-cutline-prod.cloudfunctions.net/premortemKick";
+async function callPremortemChatAgent(message, context) {
+  const auth = new GoogleAuth();
+  const client = await auth.getIdTokenClient(PREMORTEM_CHAT_FUNCTION_URL);
+  const response = await client.request({
+    url: PREMORTEM_CHAT_FUNCTION_URL,
+    method: "POST",
+    data: { message, context }
+  });
+  return response.data;
+}
+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)}`;
+}
+function getDb() {
+  const app = getApps().length > 0 ? getApp() : void 0;
+  if (!app)
+    return null;
+  return getFirestore(app);
+}
+async function saveChatSession(session) {
+  session.updatedAt = Date.now();
+  chatSessionCache.set(session.id, session);
+  const db = getDb();
+  if (db && session.uid) {
+    try {
+      await firestoreRetry(() => db.collection("premortem_chats").doc(session.id).set({
+        ...session,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp()
+      }, { merge: true }), { operationName: "premortem_chat_persist" });
+    } catch (e) {
+      console.error("[PremortemChat] Failed to persist session:", e);
+    }
+  }
+}
+async function getChatSession(sessionId) {
+  if (chatSessionCache.has(sessionId)) {
+    return chatSessionCache.get(sessionId);
+  }
+  const db = getDb();
+  if (db) {
+    try {
+      const doc = await db.collection("premortem_chats").doc(sessionId).get();
+      if (doc.exists) {
+        const data = doc.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 DEBUG] Step 3: Getting Firebase app...`);
+          const app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const db = getFirestore(app);
+          console.error(`[Premortem DEBUG] Step 3 done: Firebase ready`);
+          console.error(`[Premortem] Queuing analysis for: ${parsedInput.project.name}`);
+          const startTime = Date.now();
+          console.error(`[Premortem DEBUG] Step 4: Creating job document...`);
+          const docRef = await firestoreRetry(() => db.collection("premortem_jobs").add({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null,
+            source: "mcp_sync",
+            createdAt: admin.firestore.FieldValue.serverTimestamp()
+          }), { operationName: "premortem_job_create" });
+          const jobId = docRef.id;
+          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 snap = await docRef.get();
+            const data = snap.data() || {};
+            if (!kickedFallback && data.status === "queued" && Date.now() - startTime > 1e4) {
+              console.error(`[Premortem] Job still queued after 10s, kicking via Cloud Function...`);
+              kickedFallback = true;
+              try {
+                const auth = new GoogleAuth();
+                const client = await auth.getIdTokenClient(PREMORTEM_KICK_FUNCTION_URL);
+                client.request({
+                  url: PREMORTEM_KICK_FUNCTION_URL,
+                  method: "POST",
+                  data: { id: jobId },
+                  timeout: 6e5
+                }).catch((e) => console.error(`[Premortem] Kick fallback error:`, e?.message));
+              } catch (e) {
+                console.error(`[Premortem] Kick fallback failed:`, 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 app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const db = getFirestore(app);
+          const docRef = await firestoreRetry(() => db.collection("premortem_jobs").add({
+            status: "queued",
+            payload: parsedInput,
+            createdAt: admin.firestore.FieldValue.serverTimestamp(),
+            uid: decoded?.uid || null
+          }), { operationName: "premortem_queue_create" });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ jobId: docRef.id }) }]
+          };
+        }
+        case "premortem_status": {
+          const { jobId, auth_token } = args;
+          const { effectiveUid } = await resolveAuthContext(auth_token);
+          const app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const firestore = getFirestore(app);
+          const snap = await firestore.collection("premortem_jobs").doc(jobId).get();
+          if (!snap.exists)
+            throw new McpError(ErrorCode.InvalidRequest, "Job not found");
+          const data = snap.data() || {};
+          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 auth = new GoogleAuth();
+            const client = await auth.getIdTokenClient(PREMORTEM_KICK_FUNCTION_URL);
+            const response = await client.request({
+              url: PREMORTEM_KICK_FUNCTION_URL,
+              method: "POST",
+              data: { id: jobId },
+              timeout: 6e5
+              // 10 minute timeout for full analysis
+            });
+            console.error(`[Premortem Kick] Cloud Function returned:`, response.data);
+            return {
+              content: [{ type: "text", text: JSON.stringify({
+                kicked: response.data.kicked,
+                status: response.data.status,
+                jobId,
+                message: response.data.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 regenerateAssumptions(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 regenerateExperiments(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 app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const firestore = getFirestore(app);
+          const snapshot = await firestore.collection("premortem_jobs").where("uid", "==", effectiveUid).orderBy("createdAt", "desc").limit(limit).get();
+          const premortems = snapshot.docs.map((doc) => {
+            const data = doc.data();
+            return {
+              id: doc.id,
+              uid: data.uid,
+              status: data.status,
+              stage: data.stage,
+              stage_label: data.stage_label,
+              progress: data.progress,
+              createdAt: data.createdAt?.toDate()?.toISOString(),
+              startedAt: data.startedAt?.toDate()?.toISOString(),
+              updatedAt: data.updatedAt?.toDate()?.toISOString(),
+              productName: data.payload?.project?.name || data.result?.project?.name || "Untitled",
+              productDescription: data.payload?.project?.brief || data.result?.project?.brief || ""
+            };
+          });
+          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 app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const db = getFirestore(app);
+          const { buildRunInput, validateForGraduation, buildGraduationMetadata } = await import("./premortem-handoff-XT4K3YDJ.js");
+          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 docRef = await firestoreRetry(() => db.collection("premortem_jobs").add({
+            status: "queued",
+            payload: parsedInput,
+            createdAt: admin.firestore.FieldValue.serverTimestamp(),
+            uid: decoded?.uid || null,
+            source: "mcp_graduate",
+            graduation: graduationMetadata
+          }), { operationName: "premortem_graduate_create" });
+          console.error(`[Premortem Graduate] Created job ${docRef.id} from session ${session_id}`);
+          try {
+            const sessionRef = db.collection("premortem_jobs").doc(session_id);
+            const sessionSnap = await sessionRef.get();
+            if (sessionSnap.exists) {
+              await firestoreRetry(() => sessionRef.update({
+                linkedJobId: docRef.id,
+                graduatedAt: admin.firestore.FieldValue.serverTimestamp()
+              }), { operationName: "premortem_session_link" });
+              console.error(`[Premortem Graduate] Linked session ${session_id} to job ${docRef.id}`);
+            }
+          } catch (linkError) {
+            console.error(`[Premortem Graduate] Failed to link session:`, linkError);
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              success: true,
+              jobId: docRef.id,
+              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 "${docRef.id}" 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 callPremortemChatAgent(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}`);
+          }
+          const app = getApps().length > 0 ? getApp() : void 0;
+          if (!app)
+            throw new McpError(ErrorCode.InternalError, "Firebase Admin not initialized");
+          const db = getFirestore(app);
+          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 { buildRunInput, validateForGraduation, buildGraduationMetadata } = await import("./premortem-handoff-XT4K3YDJ.js");
+          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 docRef = await firestoreRetry(() => db.collection("premortem_jobs").add({
+            status: "queued",
+            payload: parsedInput,
+            uid: decoded?.uid || null,
+            source: "mcp_chat_graduate",
+            metadata: buildGraduationMetadata({
+              sessionId: session_id,
+              conversationalContext: conversational_context
+            }),
+            createdAt: admin.firestore.FieldValue.serverTimestamp()
+          }), { operationName: "premortem_chat_graduate" });
+          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: \`${docRef.id}\`
+
+The full pipeline includes deeper competitor research, market sizing, financial modeling, and more.`
+          });
+          await saveChatSession(session);
+          try {
+            await firestoreRetry(() => db.collection("premortem_chats").doc(session_id).update({
+              linkedJobId: docRef.id,
+              graduatedAt: admin.firestore.FieldValue.serverTimestamp()
+            }), { operationName: "premortem_chat_link" });
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              success: true,
+              jobId: docRef.id,
+              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 "${docRef.id}" 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);
+});