@kylewadegrove/cutline-mcp-cli 0.6.1 → 0.6.2

package/dist/servers/chunk-DE7R7WKY.js

@@ -0,0 +1,331 @@
+// ../mcp/dist/mcp/src/schemas.js
+import { z } from "zod";
+var PMJsonSchema = z.object({
+  project: z.object({
+    name: z.string(),
+    brief: z.string(),
+    constraints: z.object({
+      team: z.string().optional(),
+      budget_usd: z.number().optional(),
+      deadline_days: z.number().int().optional(),
+      must_ship_scope: z.string().optional()
+    }).optional(),
+    reference_classes: z.array(z.string()).optional().default([])
+  }),
+  personas: z.object({
+    user_personas: z.array(z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      segment: z.string().optional(),
+      is_buyer: z.boolean().optional(),
+      description: z.string(),
+      motivations: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional(),
+      objections: z.array(z.string()).optional()
+    })).optional(),
+    buyer_personas: z.array(z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      segment: z.string().optional(),
+      is_buyer: z.boolean().optional(),
+      description: z.string(),
+      motivations: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional(),
+      objections: z.array(z.string()).optional()
+    })).optional()
+  }).optional(),
+  outside_view: z.object({
+    base_rates: z.array(z.object({
+      statement: z.string(),
+      p50: z.number().optional(),
+      p90: z.number().optional(),
+      source_hint: z.string().optional()
+    })).optional(),
+    failed_analogs: z.array(z.string()).optional(),
+    success_analogs: z.array(z.string()).optional()
+  }).optional(),
+  pricing: z.object({
+    monthly: z.number().optional(),
+    annual: z.number().optional(),
+    tiers: z.array(z.object({
+      name: z.string(),
+      price_month_usd: z.number(),
+      features: z.array(z.string()).optional()
+    })).optional(),
+    freemium: z.object({
+      enabled: z.boolean(),
+      features: z.array(z.string()).optional()
+    }).optional(),
+    trialDays: z.number().optional(),
+    adTier: z.object({
+      enabled: z.boolean(),
+      notes: z.string().optional()
+    }).optional(),
+    strategy: z.string().optional()
+  }).optional(),
+  kill_criteria: z.array(z.object({
+    name: z.string(),
+    threshold: z.string(),
+    status: z.enum(["unknown", "pass", "fail"]).optional(),
+    evidence: z.string().optional()
+  })).optional(),
+  decision: z.object({
+    recommendation: z.enum(["No-Go", "Revise", "Go (guarded)"]),
+    rationale: z.string(),
+    what_would_change_my_mind: z.string().optional(),
+    market_feasibility: z.object({
+      score: z.enum(["strong", "moderate", "weak"]),
+      rationale: z.string(),
+      nfr_coverage_pct: z.number().optional()
+    }).optional(),
+    productionalization_feasibility: z.object({
+      score: z.enum(["strong", "moderate", "weak"]),
+      rationale: z.string(),
+      nfr_coverage_pct: z.number().optional()
+    }).optional(),
+    engineering_time_reduction: z.object({
+      unassisted_hours: z.number(),
+      assisted_hours: z.number(),
+      speedup_factor: z.number()
+    }).optional()
+  }).optional(),
+  confidence: z.object({
+    p50: z.number(),
+    p75: z.number().optional(),
+    p90: z.number()
+  }).optional(),
+  risks: z.array(z.object({
+    area: z.enum(["Demand", "Channel", "UnitEcon", "Ops", "Legal", "Competition", "Tech"]).optional(),
+    description: z.string(),
+    likelihood: z.enum(["Low", "Med", "High"]).optional(),
+    impact: z.enum(["Low", "Med", "High", "Severe"]).optional(),
+    mitigation: z.string().optional(),
+    owner: z.string().optional()
+  })).optional(),
+  assumptions: z.array(z.object({
+    statement: z.string(),
+    falsifiable: z.boolean(),
+    owner: z.string(),
+    due_by: z.string()
+  })).optional(),
+  experiments: z.array(z.object({
+    name: z.string(),
+    cost_usd: z.number(),
+    days: z.number().int(),
+    reduces_uncertainty_on: z.array(z.string()),
+    success_criterion: z.string()
+  })).optional(),
+  competitors: z.array(z.object({
+    name: z.string(),
+    notes: z.string().optional()
+  })).optional(),
+  market: z.object({
+    tam_usd: z.number().optional(),
+    sam_usd: z.number().optional(),
+    som_3yr_usd: z.number().optional(),
+    method: z.string().optional(),
+    notes: z.string().optional(),
+    tam_rationale: z.array(z.string()).optional(),
+    sam_rationale: z.array(z.string()).optional(),
+    som_rationale: z.array(z.string()).optional(),
+    growth_cagr: z.number().optional(),
+    geo_scope: z.string().optional(),
+    segments: z.array(z.string()).optional(),
+    pricing_model: z.string().optional(),
+    arpa_usd: z.number().optional(),
+    adoption_notes: z.string().optional(),
+    icp: z.array(z.string()).optional(),
+    ease_of_spend: z.enum(["Low", "Med", "High"]).optional(),
+    ease_of_reach: z.enum(["Low", "Med", "High"]).optional(),
+    how_to_reach: z.array(z.string()).optional(),
+    channels: z.array(z.string()).optional(),
+    decision_makers: z.array(z.string()).optional(),
+    adoption_ramp: z.array(z.object({
+      month: z.number().int(),
+      adoption_pct: z.number().optional(),
+      revenue_usd: z.number().optional(),
+      notes: z.string().optional()
+    })).optional(),
+    sources: z.array(z.object({
+      title: z.string(),
+      url: z.string().optional(),
+      as_of: z.string().optional()
+    })).optional(),
+    confidence: z.object({
+      p50: z.number().optional(),
+      p90: z.number().optional()
+    }).optional()
+  }).optional(),
+  icp: z.object({
+    primary_icp: z.object({
+      title: z.string(),
+      description: z.string(),
+      demographics: z.object({
+        company_size: z.string(),
+        industry: z.string(),
+        geography: z.string(),
+        budget_range: z.string(),
+        job_titles: z.array(z.string()).optional(),
+        tech_stack: z.array(z.string()).optional()
+      }),
+      psychographics: z.object({
+        pain_points: z.array(z.string()),
+        goals: z.array(z.string()),
+        values: z.array(z.string()),
+        frustrations: z.array(z.string()).optional()
+      }),
+      buying_behavior: z.object({
+        decision_makers: z.array(z.string()),
+        buying_triggers: z.array(z.string()),
+        objections: z.array(z.string()),
+        sales_cycle_days: z.number().optional(),
+        preferred_channels: z.array(z.string()).optional()
+      }),
+      fit_score: z.number(),
+      rationale: z.string()
+    }),
+    secondary_icps: z.array(z.object({
+      title: z.string(),
+      description: z.string(),
+      key_differences: z.array(z.string()),
+      fit_score: z.number()
+    })).optional(),
+    anti_personas: z.array(z.object({
+      title: z.string(),
+      description: z.string(),
+      why_poor_fit: z.array(z.string())
+    })),
+    consulting_fit: z.object({
+      ideal_client_profile: z.string(),
+      engagement_signals: z.array(z.string()),
+      disqualifiers: z.array(z.string()),
+      stakeholder_map: z.array(z.string()).optional()
+    }).optional(),
+    sources: z.array(z.object({
+      title: z.string(),
+      url: z.string().optional(),
+      as_of: z.string().optional()
+    })).optional()
+  }).optional(),
+  metrics: z.object({
+    north_star: z.string().optional(),
+    leading: z.array(z.string()).optional(),
+    unit_econ: z.object({
+      target_cac: z.number().optional(),
+      target_gpm: z.number().optional(),
+      payback_months: z.number().optional()
+    }).optional()
+  }).optional(),
+  plan: z.object({
+    tasks: z.array(z.object({
+      id: z.string().optional(),
+      name: z.string(),
+      owner: z.enum(["Eng", "Design", "PM", "Compliance"]).optional(),
+      days: z.number().int(),
+      deps: z.array(z.string()).optional()
+    })).optional()
+  }).optional(),
+  notes: z.object({
+    pre_mortem: z.string().optional(),
+    evidence_gaps: z.array(z.string()).optional()
+  }).optional(),
+  role_summaries: z.array(z.object({
+    role: z.string(),
+    summary: z.string()
+  })).optional()
+}).passthrough();
+var RunInputSchema = z.object({
+  mode: z.enum(["product", "consulting"]).optional().default("product"),
+  project: z.object({
+    name: z.string(),
+    brief: z.string(),
+    constraints: z.object({
+      team: z.string().optional(),
+      budget_usd: z.number().optional(),
+      deadline_days: z.number().int().optional(),
+      must_ship_scope: z.string().optional()
+    }).optional(),
+    reference_classes: z.array(z.string()).optional().default([]),
+    tech_stack: z.array(z.string()).optional()
+  }),
+  client: z.object({
+    name: z.string().optional(),
+    industry: z.string().optional(),
+    size: z.enum(["startup", "smb", "enterprise"]).optional(),
+    stakeholders: z.array(z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      influence: z.enum(["decision_maker", "influencer", "blocker", "champion"]).optional()
+    })).optional()
+  }).optional(),
+  kill_criteria: z.array(z.object({ name: z.string(), threshold: z.string() })).optional(),
+  pessimism: z.number().min(0).max(1).optional(),
+  organizationId: z.string().optional(),
+  productId: z.string().optional(),
+  seed_personas: z.object({
+    user_personas: z.array(z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      segment: z.string().optional(),
+      is_buyer: z.boolean().optional(),
+      description: z.string(),
+      motivations: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional(),
+      objections: z.array(z.string()).optional()
+    })).optional(),
+    buyer_personas: z.array(z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      segment: z.string().optional(),
+      is_buyer: z.boolean().optional(),
+      description: z.string(),
+      motivations: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional(),
+      objections: z.array(z.string()).optional()
+    })).optional()
+  }).optional(),
+  conversational_artifacts: z.object({
+    risks: z.array(z.object({
+      title: z.string(),
+      description: z.string().optional(),
+      category: z.string().optional(),
+      severity: z.enum(["low", "medium", "high", "critical"]).optional(),
+      likelihood: z.number().min(0).max(1).optional(),
+      impact: z.number().min(0).max(1).optional()
+    })).optional(),
+    assumptions: z.array(z.object({
+      statement: z.string(),
+      category: z.string().optional(),
+      confidence: z.number().min(0).max(1).optional(),
+      importance: z.number().min(0).max(1).optional()
+    })).optional(),
+    market_context: z.string().optional(),
+    competitors: z.array(z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      threat_level: z.enum(["low", "medium", "high"]).optional()
+    })).optional(),
+    conversation_summary: z.string().optional(),
+    target_users: z.string().optional()
+  }).optional(),
+  code_context: z.object({
+    files_audited: z.array(z.string()).optional(),
+    ecosystem: z.object({
+      languages: z.array(z.string()).optional(),
+      frameworks: z.array(z.string()).optional(),
+      orms: z.array(z.string()).optional()
+    }).optional(),
+    binding_health: z.object({
+      healthy: z.number().optional(),
+      total: z.number().optional(),
+      coverage_pct: z.number().optional()
+    }).optional(),
+    sensitive_data_count: z.number().optional(),
+    security_gaps: z.array(z.string()).optional()
+  }).optional()
+});
+
+export {
+  PMJsonSchema,
+  RunInputSchema
+};

package/dist/servers/cutline-server.js

@@ -1,30 +1,11 @@
 #!/usr/bin/env node
 import {
-  GraphTraverser,
-  computeGenericGraphMetrics,
-  computeMetricsFromGraph,
-  detectConstraintConflicts
-} from "./chunk-UBBAYTW3.js";
+  PMJsonSchema,
+  RunInputSchema
+} from "./chunk-DE7R7WKY.js";
 import {
   isWriteTool
 } from "./chunk-KMUSQOTJ.js";
-import {
-  applyEditsLogic,
-  buildPdfBuffer,
-  chatWithPersona,
-  createLinearIssues,
-  generateAnswer,
-  generateChatSuggestion,
-  generateExplorationResponse,
-  generateTemplateResponse,
-  generateTrialRun,
-  getPersona,
-  getWikiMarkdown,
-  listPersonas,
-  saveWikiMarkdown,
-  uploadAndSign
-} from "./chunk-M37M2UA4.js";
-import "./chunk-JBJYSV4P.js";
 import {
   guardBoundary,
   guardOutput,
@@ -36,6 +17,20 @@ import {
   addEntity,
   addNodes,
   addTestCases,
+  cfApplyEdits,
+  cfBuildAndUploadPdf,
+  cfChatWithPersona,
+  cfCreateLinearIssues,
+  cfGenerateAnswer,
+  cfGenerateChatSuggestion,
+  cfGenerateExplorationResponse,
+  cfGenerateTemplateResponse,
+  cfGenerateTrialRun,
+  cfGetWikiMarkdown,
+  cfPremortemRun,
+  cfRegenAssumptions,
+  cfRegenExperiments,
+  cfSaveWikiMarkdown,
   createPremortem,
   createTemplate,
   generateReadinessReportViaProxy,
@@ -50,14 +45,20 @@ import {
   getNodesByCategories,
   getNodesMissingEmbeddings,
   getNodesWithEmbeddings,
+  getPersona,
   getPremortem,
   getScanRateLimit,
   getTemplate,
   getTestCasesForEntity,
   hasConstraints,
+  listPersonas,
   listPremortems,
   listTemplates,
+  mapErrorToMcp,
   recordScoreSnapshot,
+  requirePremiumWithAutoAuth,
+  resolveAuthContext,
+  resolveAuthContextFree,
   saveScanReport,
   updateEntityEmbedding,
   updateGraphMetadata,
@@ -68,23 +69,15 @@ import {
   upsertBindings,
   upsertEdges,
   upsertEntities,
-  upsertNodes
-} from "./chunk-PQUAX5YW.js";
-import {
-  mapErrorToMcp,
-  requirePremiumWithAutoAuth,
-  resolveAuthContext,
-  resolveAuthContextFree,
+  upsertNodes,
   validateRequestSize
-} from "./chunk-NUBIEJTU.js";
+} from "./chunk-7N4HJ3KR.js";
 import {
-  PMJsonSchema,
-  RunInputSchema,
-  regenerateAssumptions,
-  regenerateExperiments,
-  runRolesAndSummarize,
-  runRolesAndSummarizeIncremental
-} from "./chunk-7FHM2GD3.js";
+  GraphTraverser,
+  computeGenericGraphMetrics,
+  computeMetricsFromGraph,
+  detectConstraintConflicts
+} from "./chunk-UBBAYTW3.js";
 
 // ../mcp/dist/mcp/src/cutline-server.js
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -2828,7 +2821,7 @@ async function propagateConstraints(productId, sourceEntityId, targetEntityId, s
 // ../mcp/dist/src/orchestrator/agents/shared/vertex.js
 import { VertexAI } from "@google-cloud/vertexai";
 import { GoogleAuth as GoogleAuth2 } from "google-auth-library";
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer } from "node:buffer";
 
 // ../mcp/dist/src/shared/circuit-breaker.js
 var DEFAULT_OPTIONS = {
@@ -3195,7 +3188,7 @@ ${options.system || ""}`.trim();
     }
     if (p?.inlineData?.data) {
       try {
-        const decoded = Buffer2.from(p.inlineData.data, "base64").toString("utf8");
+        const decoded = Buffer.from(p.inlineData.data, "base64").toString("utf8");
         inlineSegments.push(decoded);
       } catch {
       }
@@ -8587,7 +8580,7 @@ What's your connection to this space? Are you an insider who knows the pain, or
           ideas: session.ideas,
           conversationHistory: session.conversationHistory
         };
-        const response = await generateExplorationResponse(message, context);
+        const response = await cfGenerateExplorationResponse(message, context);
         session.conversationHistory.push({ role: "assistant", content: response.content });
         if (response.artifacts) {
           for (const artifact of response.artifacts) {
@@ -8789,7 +8782,7 @@ Why AI: ${idea.whyAI}`
       }
       if (name2 === "trial_generate") {
         const { prompt } = args;
-        const text = await generateTrialRun(prompt);
+        const text = await cfGenerateTrialRun(prompt);
         return { content: [{ type: "text", text: JSON.stringify({ text }) }] };
       }
       if (name2 === "engineering_audit") {
@@ -8881,7 +8874,7 @@ Why AI: ${idea.whyAI}`
           const { id: runDocId } = await createPremortem({ status: "running", payload: parsedInput }, jobId);
           const timeoutMs = 10 * 60 * 1e3;
           const result = await Promise.race([
-            runRolesAndSummarize(parsedInput, { includeDiagnostics: true }),
+            cfPremortemRun(parsedInput),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs))
           ]);
           await updatePremortem(runDocId, { status: "completed", result });
@@ -8931,7 +8924,7 @@ Competitive threats: ${competitors}` : ""
           ftInput.productId = ftDocId;
           const ftTimeoutMs = 10 * 60 * 1e3;
           const ftResult = await Promise.race([
-            runRolesAndSummarize(ftInput, { includeDiagnostics: true }),
+            cfPremortemRun(ftInput),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), ftTimeoutMs))
           ]);
           await updatePremortem(ftDocId, { status: "completed", result: ftResult });
@@ -8987,11 +8980,8 @@ Competitive threats: ${competitors}` : ""
           if (!kickInput.productId)
             kickInput.productId = jobId;
           await updatePremortem(jobId, { status: "running", payload: kickInput });
-          const update = async (patch) => {
-            await updatePremortem(jobId, patch);
-          };
           const result = await Promise.race([
-            runRolesAndSummarizeIncremental(kickInput, update),
+            cfPremortemRun(kickInput),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 10 * 60 * 1e3))
           ]);
           const doc = PMJsonSchema.parse(result);
@@ -9011,74 +9001,67 @@ Competitive threats: ${competitors}` : ""
           return { content: [{ type: "text", text: JSON.stringify(premortems, null, 2) }] };
         }
         case "premortem_render_pdf": {
-          const { doc, store = true } = args;
+          const { doc } = args;
           const parsedDoc = PMJsonSchema.parse(doc);
-          const bytes = await buildPdfBuffer(parsedDoc);
-          if (store) {
-            const uploaded = await uploadAndSign(bytes, parsedDoc?.project?.name || "premortem");
-            if (uploaded?.url) {
-              return { content: [{ type: "text", text: JSON.stringify({ url: uploaded.url }) }] };
-            }
-          }
-          const base64 = Buffer.from(bytes).toString("base64");
-          return { content: [{ type: "text", text: JSON.stringify({ dataUrl: `data:application/pdf;base64,${base64}` }) }] };
+          const result = await cfBuildAndUploadPdf(parsedDoc);
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         case "premortem_qa": {
           const { question, doc } = args;
-          const result = await generateAnswer(question, doc);
+          const result = await cfGenerateAnswer(question, doc);
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         case "premortem_regen_assumptions": {
           const { input, doc } = args;
-          const out = await regenerateAssumptions(input, doc);
+          const out = await cfRegenAssumptions(input, doc);
           return { content: [{ type: "text", text: JSON.stringify(out) }] };
         }
         case "premortem_regen_experiments": {
           const { input, doc } = args;
-          const out = await regenerateExperiments(input, doc);
+          const out = await cfRegenExperiments(input, doc);
           return { content: [{ type: "text", text: JSON.stringify(out) }] };
         }
         // Personas tools
         case "personas_list": {
           const { productId } = args;
-          const personas = await listPersonas(effectiveUid, productId);
+          const personas = await listPersonas(productId);
           return { content: [{ type: "text", text: JSON.stringify({ personas }) }] };
         }
         case "personas_get": {
           const { personaId } = args;
-          const persona = await getPersona(effectiveUid, personaId);
+          const persona = await getPersona(personaId);
           return { content: [{ type: "text", text: JSON.stringify({ persona }) }] };
         }
         case "personas_chat": {
           const { persona, userMessage, product, conversationHistory } = args;
-          const result = await chatWithPersona(persona, userMessage, product, conversationHistory);
+          const result = await cfChatWithPersona(persona, userMessage, product, conversationHistory);
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         // Wiki tools
         case "wiki_load": {
           const { projectId } = args;
-          const markdown = await getWikiMarkdown(projectId);
+          const markdown = await cfGetWikiMarkdown(projectId);
           return { content: [{ type: "text", text: JSON.stringify({ markdown }) }] };
         }
         case "wiki_save": {
           const { projectId, markdown } = args;
-          await saveWikiMarkdown(projectId, markdown, effectiveUid);
+          await cfSaveWikiMarkdown(projectId, markdown);
           return { content: [{ type: "text", text: JSON.stringify({ ok: true }) }] };
         }
         case "wiki_apply_edits": {
           const { edits } = args;
-          const result = await applyEditsLogic(edits);
+          const result = await cfApplyEdits(edits);
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         case "agent_chat": {
           const { prompt, wikiMarkdown } = args;
-          const text = await generateChatSuggestion(prompt, wikiMarkdown);
+          const text = await cfGenerateChatSuggestion(prompt, wikiMarkdown);
           return { content: [{ type: "text", text: JSON.stringify({ text }) }] };
         }
         // Integrations
         case "integrations_create_issues": {
           const { schema_json, limit } = args;
-          const result = await createLinearIssues(schema_json, limit);
+          const result = await cfCreateLinearIssues(schema_json, limit);
           return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
         // ─────────────────────────────────────────────────────────────────
@@ -9195,7 +9178,7 @@ Meta: ${JSON.stringify(output.meta)}` }
           if (!persona_id || !product_id) {
             throw new McpError(ErrorCode.InvalidParams, "persona_id and product_id are required");
           }
-          const persona = await getPersona(effectiveUid, persona_id);
+          const persona = await getPersona(persona_id);
           if (!persona) {
             throw new McpError(ErrorCode.InvalidRequest, "Persona not found");
           }
@@ -9220,7 +9203,7 @@ Meta: ${JSON.stringify(output.meta)}` }
           if (!wiki_id || !product_id) {
             throw new McpError(ErrorCode.InvalidParams, "wiki_id and product_id are required");
           }
-          const markdown = await getWikiMarkdown(wiki_id);
+          const markdown = await cfGetWikiMarkdown(wiki_id);
           if (!markdown) {
             throw new McpError(ErrorCode.InvalidRequest, "Wiki not found or empty");
           }
@@ -9885,7 +9868,7 @@ Meta: ${JSON.stringify(output.meta)}` }
               deepDiveData = ddData.result;
             }
           }
-          const response = await generateTemplateResponse(message, {
+          const response = await cfGenerateTemplateResponse(message, {
             templateType: templateData.type,
             currentAct: templateData.discoverySession?.currentAct || 1,
             deepDiveData,

package/dist/servers/{data-client-2IQIMRIS.js → data-client-PF2AI2MX.js}

@@ -3,6 +3,21 @@ import {
   addEntity,
   addNodes,
   addTestCases,
+  cfApplyEdits,
+  cfBuildAndUploadPdf,
+  cfChatWithPersona,
+  cfCreateLinearIssues,
+  cfGenerateAnswer,
+  cfGenerateChatSuggestion,
+  cfGenerateExplorationResponse,
+  cfGenerateTemplateResponse,
+  cfGenerateTrialRun,
+  cfGetWikiMarkdown,
+  cfPremortemRun,
+  cfPremortemStart,
+  cfRegenAssumptions,
+  cfRegenExperiments,
+  cfSaveWikiMarkdown,
   createExplorationSession,
   createPremortem,
   createTemplate,
@@ -27,6 +42,7 @@ import {
   getNodesMissingEmbeddings,
   getNodesWithEmbeddings,
   getPersona,
+  getPodcastIntroductions,
   getPremortem,
   getReadinessReport,
   getScanRateLimit,
@@ -55,13 +71,27 @@ import {
   upsertEdges,
   upsertEntities,
   upsertNodes
-} from "./chunk-PQUAX5YW.js";
-import "./chunk-NUBIEJTU.js";
+} from "./chunk-7N4HJ3KR.js";
 export {
   addEdges,
   addEntity,
   addNodes,
   addTestCases,
+  cfApplyEdits,
+  cfBuildAndUploadPdf,
+  cfChatWithPersona,
+  cfCreateLinearIssues,
+  cfGenerateAnswer,
+  cfGenerateChatSuggestion,
+  cfGenerateExplorationResponse,
+  cfGenerateTemplateResponse,
+  cfGenerateTrialRun,
+  cfGetWikiMarkdown,
+  cfPremortemRun,
+  cfPremortemStart,
+  cfRegenAssumptions,
+  cfRegenExperiments,
+  cfSaveWikiMarkdown,
   createExplorationSession,
   createPremortem,
   createTemplate,
@@ -86,6 +116,7 @@ export {
   getNodesMissingEmbeddings,
   getNodesWithEmbeddings,
   getPersona,
+  getPodcastIntroductions,
   getPremortem,
   getReadinessReport,
   getScanRateLimit,

package/dist/servers/exploration-server.js

@@ -8,13 +8,11 @@ import {
   createExplorationSession,
   getExplorationSession,
   listExplorationSessions,
-  updateExplorationSession
-} from "./chunk-PQUAX5YW.js";
-import {
   mapErrorToMcp,
   requirePremiumWithAutoAuth,
+  updateExplorationSession,
   validateRequestSize
-} from "./chunk-NUBIEJTU.js";
+} from "./chunk-7N4HJ3KR.js";
 
 // ../mcp/dist/mcp/src/exploration-server.js
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";