idea-gauntlet 0.1.0

package/dist/chunk-P4FDULQC.js

@@ -0,0 +1,703 @@
+import {
+  skeptic
+} from "./chunk-VQHEJYTS.js";
+
+// src/core/scoring.ts
+function calculateScores(params) {
+  const { hasEvidence, evidenceStrength, overrides } = params;
+  const defaults = {
+    clarity: 6,
+    pain: 5,
+    differentiation: 5,
+    buildability: 6,
+    distribution: 3,
+    monetization: 3,
+    evidence: evidenceScore(hasEvidence, evidenceStrength)
+  };
+  return { ...defaults, ...overrides };
+}
+function evidenceScore(hasEvidence, strength) {
+  if (!hasEvidence) return 1;
+  switch (strength) {
+    case "strong":
+      return 8;
+    case "medium":
+      return 5;
+    case "weak":
+      return 3;
+    default:
+      return 2;
+  }
+}
+function medianScore(scores) {
+  const values = [
+    scores.clarity,
+    scores.pain,
+    scores.differentiation,
+    scores.buildability,
+    scores.distribution,
+    scores.monetization,
+    scores.evidence
+  ].sort((a, b) => a - b);
+  return values[3];
+}
+
+// src/engines/immuneEngine.ts
+async function runImmuneEngine(idea, provider) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const skepticPrompt = skeptic(idea);
+  let parsed = {};
+  try {
+    const response = await provider.complete(skepticPrompt.userMessage, {
+      system: skepticPrompt.system,
+      temperature: 0.4,
+      maxTokens: 2048
+    });
+    parsed = JSON.parse(response);
+  } catch {
+    parsed = {};
+  }
+  const risks = (parsed.risks ?? []).map((r) => ({
+    title: r.title ?? "Unknown risk",
+    severity: r.severity ?? "medium",
+    explanation: r.explanation ?? "",
+    mitigation: r.mitigation
+  }));
+  const assumptions = (parsed.assumptions ?? []).map((a) => ({
+    title: a.title ?? "Unknown assumption",
+    whyItMatters: a.whyItMatters ?? "",
+    howToTest: a.howToTest ?? "",
+    confidence: a.confidence ?? "medium"
+  }));
+  const killTests = (parsed.killTests ?? []).map((k) => ({
+    title: k.title ?? "Unknown test",
+    method: k.method ?? "",
+    timeframe: k.timeframe ?? "",
+    successSignal: k.successSignal ?? "",
+    killSignal: k.killSignal ?? ""
+  }));
+  const scoreOverrides = parsed.scores ?? {};
+  const scores = calculateScores({ hasEvidence: false, overrides: scoreOverrides });
+  const verdict = determineVerdict(scores);
+  return {
+    id,
+    createdAt: now,
+    mode: "quick",
+    input: idea,
+    verdict,
+    scores,
+    coreInsight: parsed.coreInsight ?? "Analysis complete.",
+    strongestCase: parsed.strongestCase ?? "",
+    weakestAssumption: parsed.weakestAssumption ?? "",
+    risks,
+    assumptions,
+    killTests,
+    nextActions: parsed.nextActions ?? [],
+    markdown: ""
+  };
+}
+function determineVerdict(scores) {
+  const median = medianScore(scores);
+  if (median >= 8 && scores.evidence >= 5) return "strong";
+  if (median >= 6) return "promising_but_risky";
+  if (median >= 4) return "unclear";
+  if (scores.evidence <= 1 && scores.clarity <= 3) return "pivot_recommended";
+  if (scores.evidence <= 2 && median < 5) return "needs_real_evidence";
+  return "weak";
+}
+
+// src/core/report.ts
+function buildReport(report) {
+  const lines = [];
+  lines.push("# IdeaGauntlet Report\n");
+  if (report.mode === "quick") {
+    lines.push(`**Generated:** ${report.createdAt}`);
+    lines.push(`**Mode:** ${report.mode}`);
+    lines.push(`**Idea:** ${report.input.idea}
+`);
+  }
+  lines.push(`## Verdict
+
+${report.verdict}
+`);
+  if (report.coreInsight) {
+    lines.push(`## Core Insight
+
+${report.coreInsight}
+`);
+  }
+  if (report.strongestCase) {
+    lines.push(`## Strongest Case
+
+${report.strongestCase}
+`);
+  }
+  if (report.weakestAssumption) {
+    lines.push(`## Weakest Assumption
+
+${report.weakestAssumption}
+`);
+  }
+  if (report.scores) {
+    lines.push(`## Scorecard
+
+${buildScorecardTable(report.scores)}
+`);
+  }
+  if (report.risks && report.risks.length > 0) {
+    lines.push(`## Top Failure Modes
+
+${buildRiskList(report.risks)}
+`);
+  }
+  if (report.assumptions && report.assumptions.length > 0) {
+    lines.push(`## Dangerous Assumptions
+
+${buildAssumptionList(report.assumptions)}
+`);
+  }
+  if (report.killTests && report.killTests.length > 0) {
+    lines.push(`## Kill Tests
+
+${buildKillTestList(report.killTests)}
+`);
+  }
+  if (report.syntheticUsers && report.syntheticUsers.length > 0) {
+    lines.push(`## Synthetic Users
+
+${buildSyntheticUserList(report.syntheticUsers)}
+`);
+    lines.push("> **Disclaimer:** Synthetic users are fictional archetypes generated by AI. They are not a substitute for real user interviews. Use them to prepare for real research, not to replace it.\n");
+  }
+  if (report.court) {
+    lines.push(`## Court Debate
+
+${buildCourtSession(report.court)}
+`);
+  }
+  if (report.mvpPlan) {
+    lines.push(`## MVP Validation Plan
+
+${buildMvpPlan(report.mvpPlan)}
+`);
+  }
+  if (report.comparison) {
+    lines.push(`## Idea Comparison
+
+${buildComparison(report.comparison)}
+`);
+  }
+  if (report.nextActions && report.nextActions.length > 0) {
+    lines.push(`## Next Actions
+
+${buildActionList(report.nextActions)}
+`);
+  }
+  lines.push("---\n");
+  lines.push("*Report generated by IdeaGauntlet. Scores are diagnostic signals, not predictions. Synthetic analysis is not a substitute for real user research.*\n");
+  return lines.join("\n");
+}
+function buildScorecardTable(scores) {
+  const rows = ["| Dimension | Score |", "|-----------|-------|"];
+  const labels = {
+    clarity: "Clarity",
+    pain: "Pain",
+    differentiation: "Differentiation",
+    buildability: "Buildability",
+    distribution: "Distribution",
+    monetization: "Monetization",
+    evidence: "Evidence"
+  };
+  for (const [key, label] of Object.entries(labels)) {
+    const val = scores[key];
+    rows.push(`| ${label} | ${val}/10 |`);
+  }
+  rows.push(`| **Overall** | **${medianScore(scores)}/10** |`);
+  return rows.join("\n");
+}
+function buildRiskList(risks) {
+  return risks.map(
+    (r, i) => `${i + 1}. **${r.title}** (${r.severity}) \u2014 ${r.explanation}${r.mitigation ? `
+   - Mitigation: ${r.mitigation}` : ""}`
+  ).join("\n");
+}
+function buildAssumptionList(assumptions) {
+  return assumptions.map(
+    (a, i) => `${i + 1}. **${a.title}** (confidence: ${a.confidence})
+   - Why it matters: ${a.whyItMatters}
+   - How to test: ${a.howToTest}`
+  ).join("\n\n");
+}
+function buildKillTestList(tests) {
+  return tests.map(
+    (t) => `### ${t.title}
+- **Method:** ${t.method}
+- **Timeframe:** ${t.timeframe}
+- **Success signal:** ${t.successSignal}
+- **Kill signal:** ${t.killSignal}`
+  ).join("\n\n");
+}
+function buildSyntheticUserList(users) {
+  return users.map(
+    (u) => `### ${u.name} (${u.archetype})
+- **Goal:** ${u.goal}
+- **Current workaround:** ${u.currentWorkaround}
+- **Trigger to try:** ${u.triggerToTry}
+- **Primary objection:** ${u.primaryObjection}
+- **Willingness to pay:** ${u.willingnessToPay}
+- **Likely churn reason:** ${u.likelyChurnReason}
+- **Quote:** "${u.quote}"
+- **Interview question:** ${u.interviewQuestion}`
+  ).join("\n\n");
+}
+function buildCourtSession(court) {
+  const turns = court.transcript.map((t) => `### ${t.role}
+
+${t.argument}`).join("\n\n");
+  return `${turns}
+
+**Verdict:** ${court.verdict}
+
+**Unresolved Questions:**
+${court.unresolvedQuestions.map((q) => `- ${q}`).join("\n")}`;
+}
+function buildActionList(actions) {
+  return actions.map((a, i) => `${i + 1}. ${a}`).join("\n");
+}
+function buildMvpPlan(plan) {
+  const parts = [];
+  parts.push(`**Goal:** ${plan.goal}
+`);
+  parts.push(`**Timeline:** ${plan.timeline}
+`);
+  parts.push("**Scope:**\n" + plan.scope.map((s, i) => `${i + 1}. ${s}`).join("\n"));
+  parts.push("**Non-goals:**\n" + plan.nonGoals.map((s, i) => `${i + 1}. ${s}`).join("\n"));
+  parts.push("**Metrics:**\n" + plan.metrics.map((s, i) => `${i + 1}. ${s}`).join("\n"));
+  return parts.join("\n");
+}
+function buildComparison(comparison) {
+  const parts = [];
+  parts.push(`**Recommended pick:** ${comparison.recommendedPick}
+`);
+  parts.push(`**Fastest to validate:** ${comparison.fastestToValidate}
+`);
+  parts.push(`**Highest upside:** ${comparison.highestUpside}
+`);
+  parts.push("### Ranking\n");
+  parts.push(comparison.ranking.map((r, i) => `${i + 1}. ${r}`).join("\n"));
+  parts.push("\n### Detailed Scores\n");
+  parts.push("| Idea | Verdict | Score | Riskiest Assumption | Evidence |");
+  parts.push("|------|---------|-------|---------------------|----------|");
+  for (const idea of comparison.ideas) {
+    parts.push(`| ${idea.title} | ${idea.verdict} | ${idea.score}/10 | ${idea.riskiestAssumption} | ${idea.evidenceScore}/10 |`);
+  }
+  return parts.join("\n");
+}
+
+// src/providers/mockProvider.ts
+var MockProvider = class {
+  kind = "mock";
+  async complete(prompt, options) {
+    const combined = options?.system ? `${options.system} ${prompt}` : prompt;
+    if (combined.includes("Skeptic") || combined.includes("immune")) {
+      return JSON.stringify({
+        coreInsight: "The idea targets a real pain point but assumes behavior change without sufficient incentive.",
+        strongestCase: "Users who already use existing workarounds may adopt if friction is low enough.",
+        weakestAssumption: "Users will pay for this before experiencing the full value.",
+        scores: { clarity: 6, pain: 5, differentiation: 5, buildability: 6, distribution: 3, monetization: 3, evidence: 2 },
+        risks: [
+          { title: "Low retention after novelty wears off", severity: "high", explanation: "Users may try once and never return.", mitigation: "Build a single-session MVP first and measure Day 7 return rate." },
+          { title: "Hard to reach target users without paid acquisition", severity: "medium", explanation: "No organic distribution channel.", mitigation: "Focus on one community (e.g., indie hackers on Twitter)." },
+          { title: "Substitute solutions are free and habit-forming", severity: "critical", explanation: "Existing free tools already solve part of the problem.", mitigation: "Differentiate on synthetic companion angle, not features." }
+        ],
+        assumptions: [
+          { title: "Users want synthetic social presence", whyItMatters: "Core value prop depends on this", howToTest: "Fake door test with 100 visitors", confidence: "low" },
+          { title: "Users will complete more work with companions", whyItMatters: "Retention depends on measurable productivity gain", howToTest: "A/B test with 20 users", confidence: "medium" }
+        ],
+        killTests: [
+          { title: "Fake room test", method: "Static page with timer + companion avatars", timeframe: "2 days", successSignal: "40%+ complete a session", killSignal: "<20% engagement" }
+        ],
+        nextActions: ["Build static prototype this week", "Run manual sessions with 10 users"]
+      });
+    }
+    return JSON.stringify({
+      verdict: "promising_but_risky",
+      summary: "Mock verdict. The idea has a plausible wedge if positioned carefully."
+    });
+  }
+};
+
+// src/providers/openaiCompatibleProvider.ts
+var OpenAICompatibleProvider = class {
+  kind = "openai";
+  config;
+  constructor(config) {
+    if (!config.apiKey) throw new Error("API key is required for OpenAICompatibleProvider");
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl ?? "https://api.openai.com/v1",
+      model: config.model ?? "gpt-4o-mini"
+    };
+  }
+  async complete(prompt, options) {
+    const url = `${this.config.baseUrl}/chat/completions`;
+    const messages = [];
+    if (options?.system) messages.push({ role: "system", content: options.system });
+    messages.push({ role: "user", content: prompt });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        temperature: options?.temperature ?? 0.4,
+        max_tokens: options?.maxTokens ?? 2048
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Provider returned ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    return data.choices[0].message.content ?? "";
+  }
+};
+
+// src/utils/env.ts
+function getEnv(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+function getApiKey() {
+  return getEnv("IDEAGAUNTLET_API_KEY");
+}
+function getBaseUrl() {
+  return getEnv("IDEAGAUNTLET_BASE_URL") ?? "https://api.openai.com/v1";
+}
+function getModel() {
+  return getEnv("IDEAGAUNTLET_MODEL") ?? "gpt-4o-mini";
+}
+function hasApiKey() {
+  return !!getApiKey();
+}
+function isNodeGte(minMajor) {
+  const match = process.version.match(/^v(\d+)/);
+  if (!match) return false;
+  return parseInt(match[1], 10) >= minMajor;
+}
+
+// src/providers/providerUtils.ts
+function resolveProvider(options) {
+  if (options?.mock) return { provider: new MockProvider(), source: "mock" };
+  if (options?.apiKey) return { provider: new OpenAICompatibleProvider({ apiKey: options.apiKey, baseUrl: options.baseUrl, model: options.model }), source: "flags" };
+  if (hasApiKey()) return { provider: new OpenAICompatibleProvider({ apiKey: getApiKey(), baseUrl: options?.baseUrl ?? getBaseUrl(), model: options?.model ?? getModel() }), source: "env" };
+  return null;
+}
+function getProvider(options) {
+  const resolved = resolveProvider(options);
+  if (!resolved) throw new NoProviderError();
+  return resolved.provider;
+}
+var NoProviderError = class extends Error {
+  constructor() {
+    super("No LLM provider configured");
+    this.name = "NoProviderError";
+  }
+};
+
+// src/prompts/courtPrompt.ts
+var COURT_ROLES = [
+  {
+    name: "Prosecutor",
+    system: "You are the Prosecutor in IdeaGauntlet. Attack the product idea aggressively. Focus on weak assumptions, user apathy, substitutes, distribution, and monetization. Be specific."
+  },
+  {
+    name: "Defender",
+    system: "You are the Defender in IdeaGauntlet. Make the strongest honest case for the idea. Identify the wedge, early adopters, the narrow version most likely to work."
+  },
+  {
+    name: "User Advocate",
+    system: "You are the User Advocate in IdeaGauntlet. Protect the real user from founder fantasy. Ask whether the user has a painful problem, a trigger, a current workaround, and a reason to switch."
+  },
+  {
+    name: "Investor",
+    system: "You are the Investor in IdeaGauntlet. Examine market size, distribution, monetization, defensibility, and scale. Be conservative."
+  },
+  {
+    name: "Competitor",
+    system: "You are the Competitor in IdeaGauntlet. Explain how an existing player could attack this idea. Identify weak moats and easy-to-copy features."
+  }
+];
+
+// src/engines/courtEngine.ts
+async function runCourtEngine(idea, provider) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transcript = [];
+  const userMessage = `Product idea: ${idea.idea}
+
+Provide your argument in 2-3 paragraphs. Be specific and direct.`;
+  if (provider.kind === "mock") {
+    transcript.push(
+      {
+        role: "Prosecutor",
+        argument: "Mock: The idea assumes behavior change without sufficient incentive."
+      },
+      {
+        role: "Defender",
+        argument: "Mock: The synthetic companion angle is novel for early adopters."
+      },
+      {
+        role: "User Advocate",
+        argument: "Mock: Users want better focus but may not want AI companionship."
+      },
+      {
+        role: "Investor",
+        argument: "Mock: Niche market with unclear defensibility."
+      },
+      {
+        role: "Competitor",
+        argument: "Mock: Existing focus apps could add companion features."
+      }
+    );
+  } else {
+    for (const role of COURT_ROLES) {
+      const response = await provider.complete(userMessage, {
+        system: role.system,
+        temperature: 0.4,
+        maxTokens: 512
+      });
+      transcript.push({ role: role.name, argument: response.trim() });
+    }
+  }
+  let verdictText = "Court debate completed. See transcript for details.";
+  let unresolvedQuestions = [];
+  let reportVerdict = "unclear";
+  if (provider.kind === "mock") {
+    verdictText = "Mock verdict: Promising but risky. Core assumption needs real-world testing.";
+    unresolvedQuestions = [
+      "Do users feel motivated after one week?",
+      "Will users pay?"
+    ];
+    reportVerdict = "promising_but_risky";
+  } else {
+    try {
+      const judgeResponse = await provider.complete(
+        `Court transcript:
+${transcript.map((t) => `${t.role}: ${t.argument}`).join("\n\n")}
+
+Synthesize a verdict as JSON with verdict and unresolvedQuestions.`,
+        {
+          system: "You are the Judge in IdeaGauntlet. Synthesize arguments into a conservative verdict.",
+          temperature: 0.3,
+          maxTokens: 512
+        }
+      );
+      const parsed = JSON.parse(judgeResponse);
+      verdictText = parsed.verdict ?? verdictText;
+      unresolvedQuestions = parsed.unresolvedQuestions ?? [];
+    } catch {
+    }
+  }
+  const report = {
+    id,
+    createdAt: now,
+    mode: "court",
+    input: idea,
+    verdict: reportVerdict,
+    court: {
+      transcript,
+      verdict: verdictText,
+      unresolvedQuestions
+    },
+    markdown: ""
+  };
+  report.markdown = buildReport(report);
+  return report;
+}
+
+// src/engines/syntheticUserLab.ts
+async function runUserLab(idea, provider, count = 6) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const systemPrompt = `You are a Synthetic User Generator. Generate ${count} fictional user archetypes. Each includes: name, archetype, goal, currentWorkaround, triggerToTry, primaryObjection, willingnessToPay (none/low/medium/high), likelyChurnReason, quote, interviewQuestion. Return a JSON object with a "users" array. Only valid JSON. IMPORTANT: These are fictional archetypes for hypothesis generation.`;
+  const userMessage = `Product idea: ${idea.idea}${idea.targetUsers ? `
+Target users: ${idea.targetUsers.join(", ")}` : ""}
+
+Generate ${count} fictional user archetypes as JSON.`;
+  let users = [];
+  if (provider.kind === "mock") {
+    users = [
+      {
+        name: "Alex Chen",
+        archetype: "Busy Student",
+        goal: "Focus on exam prep",
+        currentWorkaround: "YouTube study-with-me videos",
+        triggerToTry: "Exam week stress",
+        primaryObjection: "Might feel childish",
+        willingnessToPay: "low",
+        likelyChurnReason: "Novelty fades after one week",
+        quote: "I'll try anything during finals.",
+        interviewQuestion: "What do you do when you can't focus?"
+      },
+      {
+        name: "Maya Rodriguez",
+        archetype: "Remote Designer",
+        goal: "Deep work without isolation",
+        currentWorkaround: "Coworking cafes",
+        triggerToTry: "Bad weather days",
+        primaryObjection: "AI companions can't replace real presence",
+        willingnessToPay: "medium",
+        likelyChurnReason: "Not enough social feedback",
+        quote: "A fake coworker might feel worse than silence.",
+        interviewQuestion: "What aspect of coworking is hardest to replicate alone?"
+      }
+    ];
+  } else {
+    try {
+      const response = await provider.complete(userMessage, {
+        system: systemPrompt,
+        temperature: 0.5,
+        maxTokens: 2048
+      });
+      const parsed = JSON.parse(response);
+      users = (parsed.users ?? []).slice(0, count);
+    } catch {
+      users = [];
+    }
+  }
+  const report = {
+    id,
+    createdAt: now,
+    mode: "users",
+    input: idea,
+    verdict: "unclear",
+    syntheticUsers: users,
+    nextActions: users.map(
+      (u) => `Interview a real user like "${u.name}": ${u.interviewQuestion}`
+    ),
+    markdown: ""
+  };
+  report.markdown = buildReport(report);
+  return report;
+}
+
+// src/prompts/mvpPrompt.ts
+var MVP_SYSTEM_PROMPT = `You are the MVP Planner in IdeaGauntlet.
+Your job is to turn a product critique into an aggressive, minimal validation plan.
+Be ruthless about reducing scope. A 14-day plan should test only the riskiest assumption.
+Do not plan features that require auth, payments, or complex onboarding.
+Output a JSON object with: goal, scope (string[]), nonGoals (string[]), timeline (string), metrics (string[]).
+Only valid JSON.`;
+
+// src/engines/mvpPlanner.ts
+async function runMvpPlanner(idea, provider) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let riskiestAssumption = "Users will adopt this product";
+  try {
+    const skepticPrompt = skeptic(idea);
+    const skepticResponse = await provider.complete(skepticPrompt.userMessage, { system: skepticPrompt.system, temperature: 0.4, maxTokens: 1024 });
+    const parsed = JSON.parse(skepticResponse);
+    const assumptions = parsed.assumptions ?? [];
+    if (assumptions.length > 0) {
+      riskiestAssumption = assumptions[0].title ?? riskiestAssumption;
+    }
+  } catch {
+  }
+  let plan = {
+    goal: `Test the riskiest assumption: ${riskiestAssumption}`,
+    scope: ["Fake-door landing page"],
+    nonGoals: ["Auth", "Payments", "Mobile apps"],
+    timeline: "14 days",
+    metrics: ["Signup conversion > 10%", "5+ user interviews"]
+  };
+  try {
+    const response = await provider.complete(
+      `Product idea: ${idea.idea}
+Riskiest assumption: ${riskiestAssumption}
+
+Design a 14-day MVP validation plan as JSON.`,
+      { system: MVP_SYSTEM_PROMPT, temperature: 0.4, maxTokens: 1024 }
+    );
+    const parsed = JSON.parse(response);
+    plan = {
+      goal: parsed.goal ?? plan.goal,
+      scope: parsed.scope ?? plan.scope,
+      nonGoals: parsed.nonGoals ?? plan.nonGoals,
+      timeline: parsed.timeline ?? plan.timeline,
+      metrics: parsed.metrics ?? plan.metrics
+    };
+  } catch {
+  }
+  const report = {
+    id,
+    createdAt: now,
+    mode: "mvp",
+    input: idea,
+    verdict: `MVP plan: ${plan.goal}`,
+    mvpPlan: plan,
+    nextActions: plan.scope,
+    markdown: ""
+  };
+  report.markdown = buildReport(report);
+  return report;
+}
+
+// src/engines/compareEngine.ts
+async function runCompareEngine(ideas, provider) {
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const results = [];
+  for (const idea of ideas) {
+    const report2 = await runImmuneEngine(idea, provider);
+    results.push({
+      title: idea.title ?? idea.idea.slice(0, 40),
+      verdict: report2.verdict,
+      score: report2.scores ? Math.round((report2.scores.clarity + report2.scores.pain + report2.scores.differentiation) / 3) : 5,
+      riskiestAssumption: report2.weakestAssumption || "Unknown",
+      evidenceScore: report2.scores?.evidence ?? 1
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  const comparison = {
+    ideas: results,
+    ranking: results.map((r) => r.title),
+    fastestToValidate: results[0]?.title ?? "",
+    highestUpside: results[0]?.title ?? "",
+    recommendedPick: results[0]?.title ?? ""
+  };
+  const report = {
+    id,
+    createdAt: now,
+    mode: "compare",
+    input: ideas[0],
+    verdict: `Compared ${ideas.length} ideas. Top pick: ${comparison.recommendedPick}`,
+    comparison,
+    nextActions: [`Validate "${comparison.recommendedPick}" first`],
+    markdown: ""
+  };
+  report.markdown = buildReport(report);
+  return report;
+}
+
+export {
+  calculateScores,
+  medianScore,
+  runImmuneEngine,
+  buildReport,
+  runCourtEngine,
+  runUserLab,
+  runMvpPlanner,
+  runCompareEngine,
+  MockProvider,
+  OpenAICompatibleProvider,
+  getApiKey,
+  isNodeGte,
+  resolveProvider,
+  getProvider,
+  NoProviderError
+};