dopple-ai 0.1.0

package/dist/cli.js

@@ -0,0 +1,4603 @@
+#!/usr/bin/env node
+import {
+  createProvider,
+  listProviders
+} from "./chunk-RXD7VZ7P.js";
+import {
+  TRAIT_PROFILES,
+  compileBehavioralProfile,
+  traitDistance
+} from "./chunk-QR5GEK27.js";
+import {
+  DoppleGraph
+} from "./chunk-FA7ZWJOA.js";
+import "./chunk-PGZVVIL6.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+
+// src/traits/compiler.ts
+function describeTraitLevel(score) {
+  if (score >= 0.85) return "very high";
+  if (score >= 0.65) return "high";
+  if (score >= 0.45) return "moderate";
+  if (score >= 0.25) return "low";
+  return "very low";
+}
+function compilePersonaPrompt(persona) {
+  const sections = [];
+  sections.push(`You are ${persona.name}.`);
+  const demo = persona.demographics;
+  const demoLines = [];
+  if (demo.age) demoLines.push(`${demo.age} years old`);
+  if (demo.gender) demoLines.push(demo.gender);
+  if (demo.location) demoLines.push(`lives in ${demo.location}`);
+  if (demo.occupation) demoLines.push(`works as ${demo.occupation}`);
+  if (demo.income) demoLines.push(`income: ${demo.income}`);
+  if (demo.education) demoLines.push(`education: ${demo.education}`);
+  if (demoLines.length > 0) {
+    sections.push(`Demographics: ${demoLines.join(", ")}.`);
+  }
+  const traitNames = [
+    "openness",
+    "conscientiousness",
+    "extraversion",
+    "agreeableness",
+    "neuroticism"
+  ];
+  const traitDesc = [];
+  for (const t of traitNames) {
+    const score = persona.traits[t];
+    const level = describeTraitLevel(score);
+    const profile = TRAIT_PROFILES[t];
+    const behaviors = score >= 0.5 ? profile.highBehaviors : profile.lowBehaviors;
+    const topBehaviors = behaviors.slice(0, 2).join("; ");
+    traitDesc.push(
+      `- ${t} (${level}, ${score.toFixed(2)}): ${topBehaviors}`
+    );
+  }
+  sections.push(`Personality (Big Five / OCEAN):
+${traitDesc.join("\n")}`);
+  const bp = persona.behavioralProfile;
+  sections.push(
+    `Behavioral tendencies:
+${bp.rules.map((r) => `- ${r}`).join("\n")}`
+  );
+  if (persona.context.product) {
+    sections.push(
+      `You are being asked about: ${persona.context.product}. Answer from your genuine perspective as a user/potential user of this product.`
+    );
+  }
+  if (persona.context.behaviorData && persona.context.behaviorData.length > 0) {
+    sections.push(
+      `Real behavioral data about users like you:
+${persona.context.behaviorData.map((d) => `- ${d}`).join("\n")}`
+    );
+  }
+  if (persona.context.supportData && persona.context.supportData.length > 0) {
+    sections.push(
+      `Real support conversations from users like you:
+${persona.context.supportData.map((d) => `- ${d}`).join("\n")}`
+    );
+  }
+  if (persona.context.paymentData && persona.context.paymentData.length > 0) {
+    sections.push(
+      `Real payment behavior from users like you:
+${persona.context.paymentData.map((d) => `- ${d}`).join("\n")}`
+    );
+  }
+  if (persona.context.freeformContext && persona.context.freeformContext.length > 0) {
+    sections.push(
+      `Additional context:
+${persona.context.freeformContext.map((d) => `- ${d}`).join("\n")}`
+    );
+  }
+  sections.push(
+    [
+      "INSTRUCTIONS:",
+      "- Respond authentically as this person. Your personality traits should shape HOW you respond.",
+      "- Be specific and concrete \u2014 mention real details, not generic platitudes.",
+      "- If you would not care about something, say so directly.",
+      "- If you would be excited about something, show genuine enthusiasm.",
+      "- If you would be confused or skeptical, express that.",
+      "- Do NOT break character. Do NOT mention that you are an AI or a persona.",
+      "- Keep responses concise (2-4 sentences) unless asked for detail.",
+      `- Your confidence level is ${persona.confidence.toUpperCase()}. ${persona.confidence === "low" ? "Your responses are based on general knowledge, not real user data." : persona.confidence === "medium" ? "Your responses are partially grounded in real behavioral data." : "Your responses are grounded in real user data from multiple sources."}`
+    ].join("\n")
+  );
+  return sections.join("\n\n");
+}
+
+// src/memory/memory.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+var PersonaMemory = class {
+  personaId;
+  baseDir;
+  facts = [];
+  episodes = [];
+  stances = [];
+  loaded = false;
+  constructor(personaId, storageDir) {
+    this.personaId = personaId;
+    this.baseDir = join(
+      storageDir ?? join(process.cwd(), ".dopple"),
+      "memory",
+      personaId
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Fact Store
+  // -------------------------------------------------------------------------
+  /**
+   * Add a ground truth fact from a data source.
+   * Facts are immutable — they represent real data, not opinions.
+   */
+  addFact(source, content, salience = 0.5) {
+    this.facts.push({
+      source,
+      content,
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      salience: Math.max(0, Math.min(1, salience))
+    });
+  }
+  /**
+   * Add multiple facts from adapter data.
+   */
+  addFacts(facts) {
+    for (const f of facts) {
+      this.addFact(f.source, f.content, f.salience);
+    }
+  }
+  /**
+   * Get facts above a salience threshold (default: include all).
+   */
+  getFacts(minSalience = 0) {
+    return this.facts.filter((f) => f.salience >= minSalience).sort((a, b) => b.salience - a.salience);
+  }
+  // -------------------------------------------------------------------------
+  // Episodic Memory
+  // -------------------------------------------------------------------------
+  /**
+   * Record a conversation exchange.
+   */
+  addEpisode(question, answer, topics = []) {
+    this.episodes.push({
+      question,
+      answer,
+      topics,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Retrieve relevant past episodes.
+   *
+   * Retrieval strategy: topic match > recency.
+   * Returns the most relevant episodes up to `limit`.
+   */
+  recall(query, limit = 5) {
+    if (this.episodes.length === 0) return [];
+    const queryWords = new Set(
+      query.toLowerCase().split(/\W+/).filter((w) => w.length > 3)
+    );
+    const scored = this.episodes.map((ep) => {
+      const epWords = /* @__PURE__ */ new Set([
+        ...ep.question.toLowerCase().split(/\W+/).filter((w) => w.length > 3),
+        ...ep.topics.map((t) => t.toLowerCase())
+      ]);
+      const overlap = [...queryWords].filter((w) => epWords.has(w)).length;
+      const topicScore = queryWords.size > 0 ? overlap / queryWords.size : 0;
+      const ageMs = Date.now() - new Date(ep.timestamp).getTime();
+      const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+      const recencyScore = Math.exp(-ageDays / 30);
+      return { episode: ep, score: topicScore * 0.7 + recencyScore * 0.3 };
+    });
+    return scored.sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.episode);
+  }
+  /**
+   * Get all episodes (chronological).
+   */
+  getAllEpisodes() {
+    return [...this.episodes];
+  }
+  // -------------------------------------------------------------------------
+  // Stance Tracker
+  // -------------------------------------------------------------------------
+  /**
+   * Update or create a stance on a topic.
+   */
+  setStance(topic, position, reason) {
+    const existing = this.stances.find(
+      (s) => s.topic.toLowerCase() === topic.toLowerCase()
+    );
+    if (existing) {
+      existing.position = position;
+      existing.reason = reason;
+      existing.evidence++;
+      existing.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    } else {
+      this.stances.push({
+        topic,
+        position,
+        reason,
+        evidence: 1,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  /**
+   * Get all stances.
+   */
+  getStances() {
+    return [...this.stances];
+  }
+  /**
+   * Get stance on a specific topic (or null if no stance).
+   */
+  getStance(topic) {
+    return this.stances.find(
+      (s) => s.topic.toLowerCase() === topic.toLowerCase()
+    ) ?? null;
+  }
+  /**
+   * Auto-derive stances from episodic memory using an LLM.
+   */
+  async deriveStances(llm) {
+    if (this.episodes.length < 3) return this.stances;
+    const episodeSummary = this.episodes.slice(-20).map((e) => `Q: ${e.question}
+A: ${e.answer}`).join("\n\n");
+    const derived = await llm.generateJSON(
+      "You analyze conversation history to identify consistent positions/stances a person holds.",
+      `Based on these past conversations, identify the key topics this person has taken a clear position on.
+
+${episodeSummary}
+
+Return a JSON array of stances:
+[{"topic": "<topic>", "position": "strongly_for" | "for" | "neutral" | "against" | "strongly_against", "reason": "<why they hold this position>"}]
+
+Only include topics where the person has expressed a clear, consistent position. If they've been ambiguous or contradictory, mark as "neutral".`
+    );
+    for (const d of derived) {
+      this.setStance(d.topic, d.position, d.reason);
+    }
+    return this.stances;
+  }
+  // -------------------------------------------------------------------------
+  // Prompt compilation
+  // -------------------------------------------------------------------------
+  /**
+   * Compile memory into prompt segments to inject into the persona's system prompt.
+   * This is the main integration point — call this before every LLM query.
+   */
+  compileForPrompt(query) {
+    const sections = [];
+    const importantFacts = this.getFacts(0.5);
+    if (importantFacts.length > 0) {
+      sections.push(
+        `GROUND TRUTH FACTS (you must not contradict these):
+${importantFacts.map((f) => `- [${f.source}] ${f.content}`).join("\n")}`
+      );
+    }
+    const relevant = this.recall(query, 3);
+    if (relevant.length > 0) {
+      sections.push(
+        `YOUR PAST STATEMENTS (be consistent with these):
+${relevant.map((e) => `- When asked "${e.question}", you said: "${e.answer}"`).join("\n")}`
+      );
+    }
+    if (this.stances.length > 0) {
+      const stanceLines = this.stances.map((s) => {
+        const emoji = s.position === "strongly_for" || s.position === "for" ? "FOR" : s.position === "against" || s.position === "strongly_against" ? "AGAINST" : "NEUTRAL";
+        return `- ${s.topic}: ${emoji} \u2014 ${s.reason}`;
+      });
+      sections.push(`YOUR KNOWN POSITIONS:
+${stanceLines.join("\n")}`);
+    }
+    return sections.length > 0 ? "\n\n" + sections.join("\n\n") : "";
+  }
+  // -------------------------------------------------------------------------
+  // Persistence (JSONL)
+  // -------------------------------------------------------------------------
+  async save() {
+    await mkdir(this.baseDir, { recursive: true });
+    await writeFile(
+      join(this.baseDir, "facts.jsonl"),
+      this.facts.map((f) => JSON.stringify(f)).join("\n") + "\n"
+    );
+    await writeFile(
+      join(this.baseDir, "episodes.jsonl"),
+      this.episodes.map((e) => JSON.stringify(e)).join("\n") + "\n"
+    );
+    await writeFile(
+      join(this.baseDir, "stances.jsonl"),
+      this.stances.map((s) => JSON.stringify(s)).join("\n") + "\n"
+    );
+  }
+  async load() {
+    if (this.loaded) return;
+    this.facts = await loadJsonl(join(this.baseDir, "facts.jsonl"));
+    this.episodes = await loadJsonl(
+      join(this.baseDir, "episodes.jsonl")
+    );
+    this.stances = await loadJsonl(
+      join(this.baseDir, "stances.jsonl")
+    );
+    this.loaded = true;
+  }
+  /**
+   * Stats about this persona's memory.
+   */
+  stats() {
+    return {
+      facts: this.facts.length,
+      episodes: this.episodes.length,
+      stances: this.stances.length
+    };
+  }
+};
+async function loadJsonl(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return content.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+// src/persona/persona.ts
+var Persona = class {
+  definition;
+  memory;
+  llm;
+  systemPrompt;
+  history = [];
+  constructor(definition, llm, storageDir) {
+    this.definition = definition;
+    this.llm = llm;
+    this.systemPrompt = compilePersonaPrompt(definition);
+    this.memory = new PersonaMemory(definition.id, storageDir);
+  }
+  get id() {
+    return this.definition.id;
+  }
+  get name() {
+    return this.definition.name;
+  }
+  get confidence() {
+    return this.definition.confidence;
+  }
+  /**
+   * Load persisted memory from disk.
+   * Call this once after construction if you want cross-session memory.
+   */
+  async loadMemory() {
+    await this.memory.load();
+  }
+  /**
+   * Save memory to disk.
+   * Call this after a session to persist episodic memory and stances.
+   */
+  async saveMemory() {
+    await this.memory.save();
+  }
+  /**
+   * Ask the persona a question and get a sourced response.
+   * Memory (facts, past episodes, stances) is automatically injected.
+   */
+  async ask(question) {
+    const memoryContext = this.memory.compileForPrompt(question);
+    const historyContext = this.history.length > 0 ? `
+
+Previous conversation:
+${this.history.slice(-6).map(
+      (h) => `${h.role === "user" ? "Interviewer" : this.definition.name}: ${h.content}`
+    ).join("\n")}` : "";
+    const structured = await this.llm.generateJSON(
+      this.systemPrompt + memoryContext + historyContext + CITATION_INSTRUCTIONS,
+      `Question: "${question}"
+
+Respond as JSON:
+{
+  "response": "<your answer as this persona, 2-4 sentences>",
+  "reasoning": "<which of your personality traits and experiences drive this answer>",
+  "citations": [
+    {"source": "<source type>", "detail": "<specific data point>", "weight": <0.0-1.0>}
+  ]
+}`
+    );
+    this.history.push({ role: "user", content: question });
+    this.history.push({ role: "persona", content: structured.response });
+    this.memory.addEpisode(question, structured.response);
+    return {
+      personaId: this.definition.id,
+      personaName: this.definition.name,
+      question,
+      response: structured.response,
+      confidence: this.definition.confidence,
+      groundedIn: this.definition.dataSources,
+      citations: structured.citations ?? [],
+      reasoning: structured.reasoning ?? "",
+      traits: this.definition.traits
+    };
+  }
+  /**
+   * Get the persona's reaction to a stimulus (feature, price change, etc.)
+   */
+  async react(stimulus) {
+    return this.ask(
+      `React to this as yourself \u2014 what's your honest first reaction? "${stimulus}"`
+    );
+  }
+  /**
+   * Compare two options from the persona's perspective.
+   */
+  async compare(optionA, optionB) {
+    return this.ask(
+      `Compare these two options and tell me which you'd choose and why:
+Option A: ${optionA}
+Option B: ${optionB}`
+    );
+  }
+  /**
+   * Derive stances from past conversations.
+   * Call after multiple ask() calls to distill positions.
+   */
+  async deriveStances() {
+    await this.memory.deriveStances(this.llm);
+  }
+  /**
+   * Get the compiled system prompt (useful for debugging).
+   */
+  toPrompt() {
+    return this.systemPrompt;
+  }
+  /**
+   * Get the full prompt including memory (useful for debugging).
+   */
+  toFullPrompt(query = "") {
+    return this.systemPrompt + this.memory.compileForPrompt(query);
+  }
+  /**
+   * Serialize to JSON.
+   */
+  toJSON() {
+    return this.definition;
+  }
+  /**
+   * One-line summary.
+   */
+  summary() {
+    const d = this.definition.demographics;
+    const parts = [this.definition.name];
+    if (d.age) parts.push(`${d.age}`);
+    if (d.occupation) parts.push(d.occupation);
+    if (d.location) parts.push(d.location);
+    return parts.join(", ");
+  }
+  /**
+   * Reset conversation history (does NOT clear persistent memory).
+   */
+  clearHistory() {
+    this.history = [];
+  }
+};
+var CITATION_INSTRUCTIONS = `
+
+CITATION REQUIREMENTS:
+For every response, you MUST explain your reasoning and cite sources.
+
+For "citations", use these source types:
+- "trait-model" \u2014 your personality traits (OCEAN scores) drive this answer. Detail should name the specific trait.
+- "behavioral-data" \u2014 real user behavior data informs this. Detail should quote the specific pattern.
+- "support-data" \u2014 real support conversations inform this. Detail should reference what users said.
+- "payment-data" \u2014 real payment/subscription data informs this. Detail should reference specific patterns.
+- "memory" \u2014 your past statements or known positions inform this. Detail should reference what you said before.
+- "general-knowledge" \u2014 general market knowledge, not grounded in specific data.
+
+Assign weight 0.0-1.0 based on how much this citation influenced your answer.
+If you only have trait-model and general-knowledge to cite, be honest about that.
+If GROUND TRUTH FACTS or YOUR PAST STATEMENTS are provided, you MUST cite them when relevant.`;
+
+// src/persona/generator.ts
+import { randomUUID } from "crypto";
+async function generatePersonas(llm, options) {
+  const count = options.count ?? 5;
+  const diversityThreshold = options.diversityThreshold ?? 0.3;
+  const documents = [];
+  const dataRecords = [];
+  for (const r of options.userData ?? []) {
+    if (r.properties._type === "document" || r.properties._type === "context") {
+      documents.push(r);
+    } else {
+      dataRecords.push(r);
+    }
+  }
+  const hasData = dataRecords.length > 0;
+  const hasDocs = documents.length > 0;
+  let confidence;
+  let mode;
+  const dataSources = [];
+  if (hasData && hasDocs) {
+    mode = "combined";
+    confidence = "high";
+    dataSources.push("user-data", "documents");
+  } else if (hasData) {
+    mode = "data";
+    confidence = "medium";
+    dataSources.push("user-data");
+  } else if (hasDocs) {
+    mode = "documents";
+    confidence = "medium";
+    dataSources.push("documents");
+  } else {
+    mode = "context-only";
+    confidence = "low";
+  }
+  if (options.context?.length) dataSources.push("context");
+  if (options.product) dataSources.push("product-description");
+  const contextParts = [];
+  if (options.product) {
+    contextParts.push(`Product/Domain: ${options.product}`);
+  }
+  if (options.context?.length) {
+    contextParts.push(`Additional context:
+${options.context.join("\n")}`);
+  }
+  if (hasData) {
+    contextParts.push(
+      `Real user data summary:
+${summarizeUserData(dataRecords)}`
+    );
+  }
+  if (hasDocs) {
+    contextParts.push(
+      `Document content:
+${summarizeDocuments(documents)}`
+    );
+  }
+  const systemPrompt = mode === "documents" ? STAKEHOLDER_SYSTEM_PROMPT : mode === "combined" ? COMBINED_SYSTEM_PROMPT : GENERATION_SYSTEM_PROMPT;
+  const prompt = buildGenerationPrompt(
+    contextParts.join("\n\n"),
+    count,
+    mode
+  );
+  const suggestions = await llm.generateJSON(
+    systemPrompt,
+    prompt
+  );
+  const personas = [];
+  for (const suggestion of (suggestions ?? []).slice(0, count)) {
+    const traits = enforceTraitBounds(suggestion.traits);
+    const tooSimilar = personas.some(
+      (p) => traitDistance(p.traits, traits) < diversityThreshold
+    );
+    const finalTraits = tooSimilar ? perturbVector(traits, diversityThreshold) : traits;
+    const behavioralProfile = compileBehavioralProfile(finalTraits);
+    const personaContext = {
+      product: options.product,
+      freeformContext: [
+        ...options.context ?? [],
+        // Inject the rich backstory and motivations into context
+        suggestion.backstory,
+        ...(suggestion.painPoints ?? []).map((p) => `Pain point: ${p}`),
+        ...(suggestion.goals ?? []).map((g) => `Goal: ${g}`),
+        suggestion.relationship ? `Relationship to product: ${suggestion.relationship}` : ""
+      ].filter(Boolean)
+    };
+    if (hasData) {
+      const enrichment = enrichFromUserData(dataRecords);
+      personaContext.behaviorData = enrichment.behaviors;
+      personaContext.paymentData = enrichment.payments;
+      personaContext.supportData = enrichment.support;
+    }
+    if (hasDocs) {
+      personaContext.freeformContext = [
+        ...personaContext.freeformContext ?? [],
+        ...documents.slice(0, 3).map(
+          (d) => `From document "${d.properties._filename}": ${String(d.properties._content).slice(0, 2e3)}`
+        )
+      ];
+    }
+    personas.push({
+      id: randomUUID(),
+      name: suggestion.name,
+      traits: finalTraits,
+      demographics: {
+        age: suggestion.age,
+        gender: suggestion.gender,
+        location: suggestion.location,
+        occupation: suggestion.occupation,
+        income: suggestion.income,
+        education: suggestion.education
+      },
+      context: personaContext,
+      behavioralProfile,
+      dataSources,
+      confidence,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return personas;
+}
+var GENERATION_SYSTEM_PROMPT = `You are a psychometrician and consumer behavior researcher. You generate realistic synthetic user personas grounded in Big Five (OCEAN) personality psychology.
+
+Your personas must feel like REAL PEOPLE, not data points. Each persona needs:
+
+1. A RICH BACKSTORY \u2014 not "34, PM, Singapore." Instead: "Mei Lin is 34, a product manager at a mid-size fintech in Singapore. She joined three years ago after burning out at a big bank. She's methodical \u2014 she keeps a spreadsheet of every SaaS tool her team uses, color-coded by renewal date. She discovered this product through a colleague's recommendation and signed up during a free trial, but almost cancelled when she couldn't figure out the export feature. She stayed because the dashboard saved her 2 hours a week on reporting."
+
+2. PAIN POINTS \u2014 specific frustrations, not generic ones. What keeps them up at night?
+
+3. GOALS \u2014 what are they trying to achieve? Not just with the product, but in their life/work.
+
+4. RELATIONSHIP TO THE PRODUCT \u2014 how did they find it? How do they use it? What would make them leave? What would make them stay forever?
+
+5. INTERNALLY CONSISTENT OCEAN TRAITS \u2014 a high-neuroticism person worries about price changes. A low-openness person resists new features. Make the backstory MATCH the traits.
+
+When assigning OCEAN scores, use the full range. Real humans cluster at extremes, not 0.5.`;
+var STAKEHOLDER_SYSTEM_PROMPT = `You are a psychometrician and policy researcher. Given documents about a domain, you identify the key STAKEHOLDER TYPES and generate a realistic persona for each.
+
+Your job is to READ the documents carefully and figure out: who are the different types of people affected by this? What are their different perspectives, concerns, and behaviors?
+
+For each stakeholder, generate a RICH, SPECIFIC persona:
+
+1. A NARRATIVE BACKSTORY \u2014 not demographics. A story. "Ah Kow is 72, a retired hawker who's lived in his ground-floor Bishan HDB flat for 38 years. He remembers the big flood in 1978 and still keeps sandbags by the door. His children keep telling him to move upstairs but he says the garden is his life. He reads Lianhe Zaobao every morning and trusts what the government says about drainage, but he noticed the water comes faster now than it used to."
+
+2. Their SPECIFIC RELATIONSHIP to the domain/policy \u2014 not generic. What do they stand to gain or lose?
+
+3. Their INFORMATION SOURCES \u2014 how do they learn about this topic? Who do they trust?
+
+4. OCEAN TRAITS that match their described behavior \u2014 the cautious elderly man is high conscientiousness, moderate neuroticism.
+
+Extract stakeholder types DIRECTLY from the document content. Don't invent types the documents don't mention.`;
+var COMBINED_SYSTEM_PROMPT = `You are a psychometrician and researcher. You have BOTH real user data AND domain documents. Generate personas that combine behavioral patterns from the data with contextual knowledge from the documents.
+
+Each persona should:
+
+1. REPRESENT a real behavioral segment from the data (their actions, usage patterns, payment behavior are grounded in real numbers)
+
+2. Be ENRICHED with domain knowledge from the documents (they understand the broader context \u2014 policy implications, industry trends, competitive landscape)
+
+3. Have a RICH NARRATIVE BACKSTORY that weaves together their data-revealed behavior with document-revealed context. Not: "Power user, exports a lot." Instead: "Raj is the kind of user who builds his workflow around your tool. He's automated his entire weekly report using your CSV exports \u2014 340 exports last month. But he saw the blog post about the new API-first strategy and he's worried that CSV exports are going to be deprecated. He's already evaluating alternatives, not because he wants to leave, but because he needs a backup plan. His boss asks for that report every Monday at 9am and there's no room for 'the export feature changed.'"
+
+4. Have OCEAN TRAITS consistent with both their observed behavior AND their described personality.
+
+Ground every claim in either the real data or the documents. If you're speculating, say so.`;
+function buildGenerationPrompt(context, count, mode) {
+  const modeInstruction = mode === "documents" ? "Identify the key stakeholder types mentioned or implied in the documents. Generate one persona per stakeholder type." : mode === "combined" ? "Combine behavioral segments from the user data with stakeholder perspectives from the documents." : "Generate diverse personas that represent the range of users for this product/domain.";
+  return `${modeInstruction}
+
+${context}
+
+Generate a JSON array of ${count} personas. Each must have:
+- name: A realistic full first name (culturally appropriate for the context)
+- age: number
+- gender: string
+- location: string (specific \u2014 neighborhood/city, not just country)
+- occupation: string (specific role, not just industry)
+- income: string (range)
+- education: string
+- traits: { openness, conscientiousness, extraversion, agreeableness, neuroticism } (each 0.0 to 1.0)
+- backstory: 3-5 sentences. A NARRATIVE about this person \u2014 their history, daily life, how they relate to this product/domain. Make them feel real. Include specific details only this person would have.
+- painPoints: array of 2-3 specific frustrations (not generic)
+- goals: array of 2-3 things they're trying to achieve
+- relationship: 1-2 sentences on how they found/use/feel about this product or domain
+
+Make personas GENUINELY DIVERSE:
+- Spread across age ranges, income levels, and personality types
+- Include skeptics and critics, not just fans
+- Include edge cases \u2014 the person who almost left, the person who uses it "wrong"
+- OCEAN traits should use the full 0-1 range, not cluster around 0.5
+
+Return ONLY a JSON array.`;
+}
+function enforceTraitBounds(traits) {
+  const bounded = { ...traits };
+  for (const key of Object.keys(bounded)) {
+    bounded[key] = Math.max(0, Math.min(1, bounded[key]));
+  }
+  return bounded;
+}
+function perturbVector(traits, minDistance) {
+  const perturbed = { ...traits };
+  const keys = Object.keys(perturbed);
+  const shuffled = keys.sort(() => Math.random() - 0.5);
+  for (const key of shuffled.slice(0, 3)) {
+    const shift = (Math.random() - 0.5) * minDistance * 2;
+    perturbed[key] = Math.max(0, Math.min(1, perturbed[key] + shift));
+  }
+  return perturbed;
+}
+function summarizeUserData(records) {
+  const lines = [];
+  lines.push(`Total users: ${records.length}`);
+  const propCounts = {};
+  for (const r of records) {
+    for (const [key, value] of Object.entries(r.properties)) {
+      if (key.startsWith("_")) continue;
+      if (!propCounts[key]) propCounts[key] = {};
+      const v = String(value);
+      propCounts[key][v] = (propCounts[key][v] ?? 0) + 1;
+    }
+  }
+  for (const [prop, values] of Object.entries(propCounts)) {
+    const sorted = Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, 5);
+    const total = Object.values(values).reduce((a, b) => a + b, 0);
+    const dist = sorted.map(([v, c]) => `${v} (${(c / total * 100).toFixed(0)}%)`).join(", ");
+    lines.push(`${prop}: ${dist}`);
+  }
+  const eventCounts = {};
+  for (const r of records) {
+    for (const e of r.events ?? []) {
+      eventCounts[e.name] = (eventCounts[e.name] ?? 0) + 1;
+    }
+  }
+  if (Object.keys(eventCounts).length > 0) {
+    const topEvents = Object.entries(eventCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => `${name} (${count}x)`).join(", ");
+    lines.push(`Top events: ${topEvents}`);
+  }
+  const paymentStatuses = {};
+  const cancelReasons = [];
+  for (const r of records) {
+    for (const p of r.payments ?? []) {
+      paymentStatuses[p.status] = (paymentStatuses[p.status] ?? 0) + 1;
+      if (p.cancelReason) cancelReasons.push(p.cancelReason);
+    }
+  }
+  if (Object.keys(paymentStatuses).length > 0) {
+    lines.push(
+      `Payment statuses: ${Object.entries(paymentStatuses).map(([s, c]) => `${s}: ${c}`).join(", ")}`
+    );
+  }
+  if (cancelReasons.length > 0) {
+    lines.push(`Cancel reasons: ${cancelReasons.slice(0, 10).join("; ")}`);
+  }
+  return lines.join("\n");
+}
+function summarizeDocuments(docs) {
+  return docs.map((d) => {
+    const filename = d.properties._filename ?? "unknown";
+    const content = String(d.properties._content ?? "").slice(0, 3e3);
+    return `--- ${filename} ---
+${content}`;
+  }).join("\n\n");
+}
+function enrichFromUserData(records) {
+  const behaviors = [];
+  const payments = [];
+  const support = [];
+  const eventCounts = {};
+  for (const r of records) {
+    for (const e of r.events ?? []) {
+      eventCounts[e.name] = (eventCounts[e.name] ?? 0) + 1;
+    }
+  }
+  for (const [name, count] of Object.entries(eventCounts).sort((a, b) => b[1] - a[1]).slice(0, 5)) {
+    behaviors.push(
+      `${name}: occurs ${count} times across ${records.length} users`
+    );
+  }
+  for (const r of records) {
+    for (const p of r.payments ?? []) {
+      if (p.cancelReason) {
+        payments.push(`Cancelled: "${p.cancelReason}" (plan: ${p.plan})`);
+      }
+    }
+  }
+  for (const r of records) {
+    for (const c of r.conversations ?? []) {
+      support.push(c);
+    }
+  }
+  return {
+    behaviors: behaviors.slice(0, 10),
+    payments: payments.slice(0, 10),
+    support: support.slice(0, 10)
+  };
+}
+
+// src/groups/segment.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function discoverSegments(llm, records, options = {}) {
+  if (records.length === 0) {
+    return {
+      segments: [],
+      totalUsersAnalyzed: 0,
+      confidence: "low",
+      suggestions: [
+        {
+          source: "dopple",
+          suggestion: "No user data available. Connect a data source first.",
+          impact: "high"
+        }
+      ]
+    };
+  }
+  const dataSummary = buildDataSummary(records);
+  const segmentCount = options.segmentCount ?? "3-6";
+  const prompt = `Analyze this user data and identify ${segmentCount} distinct segments.
+
+Product: ${options.product ?? "Unknown"}
+
+User Data Summary:
+${dataSummary}
+
+For each segment, return:
+- name: A memorable nickname (e.g., "The Optimizer", "The Casual")
+- description: 1-2 sentence description
+- percentage: Estimated % of users in this segment
+- patterns: Array of 3-5 key behavioral patterns
+- persona: A representative person with name, age, gender, occupation, location, income, and OCEAN traits (0.0-1.0)
+
+IMPORTANT:
+- Segments should be meaningfully different, not just age brackets
+- Ground segments in the ACTUAL data patterns you see, not generic archetypes
+- OCEAN traits must reflect the behavioral patterns (e.g., methodical researchers = high conscientiousness)
+- Percentages must sum to ~100%
+
+Return a JSON array of segments.`;
+  const suggestions = await llm.generateJSON(
+    DISCOVERY_SYSTEM_PROMPT,
+    prompt
+  );
+  const segments = suggestions.map((s) => {
+    const traits = enforceTraitBounds2(s.persona.traits);
+    const behavioralProfile = compileBehavioralProfile(traits);
+    const persona = {
+      id: randomUUID2(),
+      name: s.persona.name,
+      traits,
+      demographics: {
+        age: s.persona.age,
+        gender: s.persona.gender,
+        occupation: s.persona.occupation,
+        location: s.persona.location,
+        income: s.persona.income
+      },
+      context: {
+        product: options.product,
+        behaviorData: s.patterns
+      },
+      behavioralProfile,
+      dataSources: ["user-data", "segmentation"],
+      confidence: computeConfidence(records),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return {
+      id: randomUUID2(),
+      name: s.name,
+      description: s.description,
+      userCount: Math.round(s.percentage / 100 * records.length),
+      percentage: s.percentage,
+      averageTraits: traits,
+      patterns: s.patterns,
+      persona
+    };
+  });
+  const dataSuggestions = analyzeDataGaps(records);
+  return {
+    segments,
+    totalUsersAnalyzed: records.length,
+    confidence: computeConfidence(records),
+    suggestions: dataSuggestions
+  };
+}
+function buildDataSummary(records) {
+  const lines = [`Total users: ${records.length}`];
+  const propCounts = {};
+  for (const r of records) {
+    for (const [key, value] of Object.entries(r.properties)) {
+      if (key.startsWith("_")) continue;
+      if (!propCounts[key]) propCounts[key] = {};
+      const v = String(value);
+      propCounts[key][v] = (propCounts[key][v] ?? 0) + 1;
+    }
+  }
+  for (const [prop, values] of Object.entries(propCounts)) {
+    const uniqueValues = Object.keys(values).length;
+    if (uniqueValues > 20) {
+      const nums = Object.keys(values).map(Number).filter((n) => !isNaN(n));
+      if (nums.length > 0) {
+        lines.push(
+          `${prop}: range ${Math.min(...nums)}-${Math.max(...nums)}, ${uniqueValues} unique values`
+        );
+      } else {
+        lines.push(`${prop}: ${uniqueValues} unique values`);
+      }
+    } else {
+      const sorted = Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, 8);
+      const total = records.length;
+      const dist = sorted.map(([v, c]) => `${v} (${(c / total * 100).toFixed(0)}%)`).join(", ");
+      lines.push(`${prop}: ${dist}`);
+    }
+  }
+  const eventCounts = {};
+  let totalEvents = 0;
+  for (const r of records) {
+    for (const e of r.events ?? []) {
+      eventCounts[e.name] = (eventCounts[e.name] ?? 0) + 1;
+      totalEvents++;
+    }
+  }
+  if (totalEvents > 0) {
+    lines.push(`
+Total events: ${totalEvents}`);
+    const topEvents = Object.entries(eventCounts).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([name, count]) => `  ${name}: ${count}x`).join("\n");
+    lines.push(`Top events:
+${topEvents}`);
+  }
+  let hasPayments = false;
+  const statuses = {};
+  const plans = {};
+  const cancelReasons = [];
+  for (const r of records) {
+    for (const p of r.payments ?? []) {
+      hasPayments = true;
+      statuses[p.status] = (statuses[p.status] ?? 0) + 1;
+      if (p.plan) plans[p.plan] = (plans[p.plan] ?? 0) + 1;
+      if (p.cancelReason) cancelReasons.push(p.cancelReason);
+    }
+  }
+  if (hasPayments) {
+    lines.push(
+      `
+Payment statuses: ${Object.entries(statuses).map(([s, c]) => `${s}: ${c}`).join(", ")}`
+    );
+    if (Object.keys(plans).length > 0) {
+      lines.push(
+        `Plans: ${Object.entries(plans).map(([p, c]) => `${p}: ${c}`).join(", ")}`
+      );
+    }
+    if (cancelReasons.length > 0) {
+      lines.push(`Cancel reasons: ${cancelReasons.slice(0, 10).join("; ")}`);
+    }
+  }
+  let convCount = 0;
+  for (const r of records) {
+    convCount += (r.conversations ?? []).length;
+  }
+  if (convCount > 0) {
+    lines.push(`
+Support conversations: ${convCount} total`);
+  }
+  return lines.join("\n");
+}
+function computeConfidence(records) {
+  let score = 0;
+  if (records.length >= 100) score += 2;
+  else if (records.length >= 20) score += 1;
+  const hasEvents = records.some((r) => (r.events ?? []).length > 0);
+  if (hasEvents) score += 1;
+  const hasPayments = records.some((r) => (r.payments ?? []).length > 0);
+  if (hasPayments) score += 1;
+  const hasConversations = records.some(
+    (r) => (r.conversations ?? []).length > 0
+  );
+  if (hasConversations) score += 1;
+  if (score >= 4) return "high";
+  if (score >= 2) return "medium";
+  return "low";
+}
+function analyzeDataGaps(records) {
+  const suggestions = [];
+  const hasEvents = records.some((r) => (r.events ?? []).length > 0);
+  const hasPayments = records.some((r) => (r.payments ?? []).length > 0);
+  const hasConversations = records.some(
+    (r) => (r.conversations ?? []).length > 0
+  );
+  if (!hasEvents) {
+    suggestions.push({
+      source: "posthog",
+      suggestion: "Connect PostHog to get event data. Behavioral events dramatically improve segment accuracy.",
+      impact: "high"
+    });
+  }
+  if (!hasPayments) {
+    suggestions.push({
+      source: "stripe",
+      suggestion: "Connect Stripe to get payment data. Subscription status and cancel reasons ground pricing personas.",
+      impact: "high"
+    });
+  }
+  if (!hasConversations) {
+    suggestions.push({
+      source: "intercom",
+      suggestion: "Connect a support tool to get real conversations. User words improve persona authenticity.",
+      impact: "medium"
+    });
+  }
+  const propCoverage = {};
+  for (const r of records) {
+    for (const key of Object.keys(r.properties)) {
+      propCoverage[key] = (propCoverage[key] ?? 0) + 1;
+    }
+  }
+  for (const [prop, count] of Object.entries(propCoverage)) {
+    const coverage = count / records.length;
+    if (coverage < 0.3 && !prop.startsWith("_")) {
+      suggestions.push({
+        source: "data-quality",
+        suggestion: `Property "${prop}" is only set for ${(coverage * 100).toFixed(0)}% of users. Improve coverage for better segmentation.`,
+        impact: "low"
+      });
+    }
+  }
+  if (records.length < 20) {
+    suggestions.push({
+      source: "data-volume",
+      suggestion: `Only ${records.length} users. Segments improve significantly with 50+ users.`,
+      impact: "medium"
+    });
+  }
+  return suggestions;
+}
+function enforceTraitBounds2(traits) {
+  const bounded = { ...traits };
+  for (const key of Object.keys(bounded)) {
+    bounded[key] = Math.max(0, Math.min(1, bounded[key]));
+  }
+  return bounded;
+}
+var DISCOVERY_SYSTEM_PROMPT = `You are a behavioral data scientist and psychometrician. You analyze product usage data to discover meaningful user segments.
+
+Your segmentation must:
+1. Be grounded in ACTUAL patterns in the data \u2014 not generic marketing personas
+2. Identify segments that differ in behavior, motivation, and personality \u2014 not just demographics
+3. Assign OCEAN trait vectors that are CONSISTENT with observed behaviors
+4. Include edge cases and minority segments \u2014 not just the obvious majority
+5. Be actionable \u2014 each segment should suggest different product decisions
+
+When assigning OCEAN scores, map behaviors to traits:
+- Methodical/planning behavior \u2192 high conscientiousness
+- Social/sharing behavior \u2192 high extraversion
+- Price complaints/comparison shopping \u2192 high neuroticism, low agreeableness
+- Early adopter/feature requests \u2192 high openness
+- Loyalty despite issues \u2192 high agreeableness`;
+
+// src/validation/validate.ts
+var PSYCHOMETRIC_ITEMS = [
+  // Openness
+  {
+    question: "Would you enjoy visiting an art museum?",
+    trait: "openness",
+    positiveKeyed: true
+  },
+  {
+    question: "Do you prefer sticking to tried-and-true methods rather than trying new approaches?",
+    trait: "openness",
+    positiveKeyed: false
+  },
+  {
+    question: "Are you curious about things even if they aren't immediately useful to you?",
+    trait: "openness",
+    positiveKeyed: true
+  },
+  // Conscientiousness
+  {
+    question: "Do you make a plan and follow through with it?",
+    trait: "conscientiousness",
+    positiveKeyed: true
+  },
+  {
+    question: "Do you often forget to put things back in their proper place?",
+    trait: "conscientiousness",
+    positiveKeyed: false
+  },
+  {
+    question: "Do you research products thoroughly before buying them?",
+    trait: "conscientiousness",
+    positiveKeyed: true
+  },
+  // Extraversion
+  {
+    question: "Do you enjoy being the center of attention?",
+    trait: "extraversion",
+    positiveKeyed: true
+  },
+  {
+    question: "Would you rather spend a Saturday night at home alone than at a party?",
+    trait: "extraversion",
+    positiveKeyed: false
+  },
+  {
+    question: "Do you share your opinions about products with friends and family?",
+    trait: "extraversion",
+    positiveKeyed: true
+  },
+  // Agreeableness
+  {
+    question: "Do you generally trust that people have good intentions?",
+    trait: "agreeableness",
+    positiveKeyed: true
+  },
+  {
+    question: "Would you publicly complain about a product that disappointed you?",
+    trait: "agreeableness",
+    positiveKeyed: false
+  },
+  {
+    question: "Do you give products a second chance even after a bad experience?",
+    trait: "agreeableness",
+    positiveKeyed: true
+  },
+  // Neuroticism
+  {
+    question: "Do you worry about making the wrong purchase decision?",
+    trait: "neuroticism",
+    positiveKeyed: true
+  },
+  {
+    question: "Do you handle unexpected price increases calmly?",
+    trait: "neuroticism",
+    positiveKeyed: false
+  },
+  {
+    question: "Do you read negative reviews more carefully than positive ones?",
+    trait: "neuroticism",
+    positiveKeyed: true
+  }
+];
+async function testPsychometricFidelity(persona, llm) {
+  const traitScores = {
+    openness: [],
+    conscientiousness: [],
+    extraversion: [],
+    agreeableness: [],
+    neuroticism: []
+  };
+  for (const item of PSYCHOMETRIC_ITEMS) {
+    const response = await llm.generateJSON(
+      `You are answering personality questions as ${persona.name}. Based on the persona's personality, answer honestly.
+
+Persona traits: O=${persona.definition.traits.openness.toFixed(2)} C=${persona.definition.traits.conscientiousness.toFixed(2)} E=${persona.definition.traits.extraversion.toFixed(2)} A=${persona.definition.traits.agreeableness.toFixed(2)} N=${persona.definition.traits.neuroticism.toFixed(2)}`,
+      `Question: "${item.question}"
+
+Respond with JSON: {"answer": "yes" | "no" | "maybe"}`
+    );
+    let score2;
+    if (response.answer === "yes") score2 = item.positiveKeyed ? 1 : 0;
+    else if (response.answer === "no") score2 = item.positiveKeyed ? 0 : 1;
+    else score2 = 0.5;
+    traitScores[item.trait].push(score2);
+  }
+  let totalError = 0;
+  let traitCount = 0;
+  for (const trait of Object.keys(traitScores)) {
+    const scores = traitScores[trait];
+    if (scores.length === 0) continue;
+    const measured = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const defined = persona.definition.traits[trait];
+    totalError += Math.abs(measured - defined);
+    traitCount++;
+  }
+  const avgError = traitCount > 0 ? totalError / traitCount : 1;
+  const score = Math.max(0, 1 - avgError);
+  return {
+    testName: "Psychometric Fidelity",
+    passed: score >= 0.6,
+    score: Math.round(score * 100),
+    maxScore: 100,
+    details: score >= 0.6 ? `Persona responses align with defined traits (${(avgError * 100).toFixed(0)}% average error)` : `Persona responses diverge from defined traits (${(avgError * 100).toFixed(0)}% average error). Trait compilation may need calibration.`
+  };
+}
+async function testConsistency(persona, _llm) {
+  const question = "What matters most to you when choosing a new product or service?";
+  const runs = 3;
+  const responses = [];
+  for (let i = 0; i < runs; i++) {
+    persona.clearHistory();
+    const r = await persona.ask(question);
+    responses.push(r.response);
+  }
+  const allWords = responses.map(
+    (r) => r.toLowerCase().split(/\W+/).filter((w) => w.length > 4)
+  );
+  const wordSets = allWords.map((words) => new Set(words));
+  let overlapScore = 0;
+  let comparisons = 0;
+  for (let i = 0; i < wordSets.length; i++) {
+    for (let j = i + 1; j < wordSets.length; j++) {
+      const intersection = new Set(
+        [...wordSets[i]].filter((w) => wordSets[j].has(w))
+      );
+      const union = /* @__PURE__ */ new Set([...wordSets[i], ...wordSets[j]]);
+      overlapScore += union.size > 0 ? intersection.size / union.size : 0;
+      comparisons++;
+    }
+  }
+  const avgOverlap = comparisons > 0 ? overlapScore / comparisons : 0;
+  const score = Math.min(1, avgOverlap * 3);
+  return {
+    testName: "Response Consistency",
+    passed: score >= 0.3,
+    score: Math.round(score * 100),
+    maxScore: 100,
+    details: score >= 0.3 ? `Persona gives thematically consistent responses across ${runs} runs (${(avgOverlap * 100).toFixed(0)}% lexical overlap)` : `Persona responses vary too much across runs. Consider stronger trait constraints.`
+  };
+}
+async function testDiscrimination(persona, llm) {
+  const oppositeTraits = {
+    openness: 1 - persona.definition.traits.openness,
+    conscientiousness: 1 - persona.definition.traits.conscientiousness,
+    extraversion: 1 - persona.definition.traits.extraversion,
+    agreeableness: 1 - persona.definition.traits.agreeableness,
+    neuroticism: 1 - persona.definition.traits.neuroticism
+  };
+  const oppositeDef = {
+    ...persona.definition,
+    id: "opposite-" + persona.definition.id,
+    name: "Opposite-" + persona.definition.name,
+    traits: oppositeTraits
+  };
+  const { compileBehavioralProfile: compileBehavioralProfile2 } = await import("./ocean-SIPS4NY7.js");
+  oppositeDef.behavioralProfile = compileBehavioralProfile2(oppositeTraits);
+  const oppositePersona = new Persona(oppositeDef, llm);
+  const question = "A new product you've never heard of is being recommended by a friend. It costs 20% more than what you currently use. What do you do?";
+  persona.clearHistory();
+  oppositePersona.clearHistory();
+  const r1 = await persona.ask(question);
+  const r2 = await oppositePersona.ask(question);
+  const words1 = new Set(
+    r1.response.toLowerCase().split(/\W+/).filter((w) => w.length > 4)
+  );
+  const words2 = new Set(
+    r2.response.toLowerCase().split(/\W+/).filter((w) => w.length > 4)
+  );
+  const intersection = new Set([...words1].filter((w) => words2.has(w)));
+  const union = /* @__PURE__ */ new Set([...words1, ...words2]);
+  const similarity = union.size > 0 ? intersection.size / union.size : 0;
+  const difference = 1 - similarity;
+  return {
+    testName: "Trait Discrimination",
+    passed: difference >= 0.4,
+    score: Math.round(difference * 100),
+    maxScore: 100,
+    details: difference >= 0.4 ? `Opposite personas give meaningfully different responses (${(difference * 100).toFixed(0)}% different)` : `Opposite personas give too-similar responses. Trait constraints may not be strong enough.`
+  };
+}
+async function validatePersona(definition, llm) {
+  const persona = new Persona(definition, llm);
+  const tests = [];
+  tests.push(await testPsychometricFidelity(persona, llm));
+  tests.push(await testConsistency(persona, llm));
+  tests.push(await testDiscrimination(persona, llm));
+  const totalScore = tests.reduce((sum, t) => sum + t.score, 0);
+  const maxScore = tests.reduce((sum, t) => sum + t.maxScore, 0);
+  const allPassed = tests.every((t) => t.passed);
+  return {
+    overall: { passed: allPassed, score: totalScore, maxScore },
+    tests,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/adapters/base.ts
+var registry = /* @__PURE__ */ new Map();
+function registerAdapter(type, factory) {
+  registry.set(type, factory);
+}
+function createAdapter(config) {
+  const factory = registry.get(config.type);
+  if (!factory) {
+    throw new Error(
+      `Unknown adapter type: "${config.type}". Available: ${[...registry.keys()].join(", ")}`
+    );
+  }
+  return factory(config);
+}
+
+// src/storage/store.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+var DoppleStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? join2(process.cwd(), ".dopple");
+  }
+  // -------------------------------------------------------------------------
+  // Panels
+  // -------------------------------------------------------------------------
+  async savePanel(name, personas, product) {
+    const dir = join2(this.baseDir, "panels");
+    await mkdir2(dir, { recursive: true });
+    const panel = {
+      id: randomUUID3(),
+      name,
+      product,
+      personas,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const filename = `${slugify(name)}-${panel.id.slice(0, 8)}.jsonl`;
+    const lines = personas.map((p) => JSON.stringify(p));
+    const meta = JSON.stringify({
+      _type: "panel",
+      id: panel.id,
+      name: panel.name,
+      product: panel.product,
+      personaCount: personas.length,
+      createdAt: panel.createdAt
+    });
+    await writeFile2(join2(dir, filename), [meta, ...lines].join("\n") + "\n");
+    return panel;
+  }
+  async loadPanel(nameOrId) {
+    const dir = join2(this.baseDir, "panels");
+    try {
+      const files = await readdir(dir);
+      const match = files.find(
+        (f) => f.includes(nameOrId) || f.startsWith(slugify(nameOrId))
+      );
+      if (!match) return null;
+      const content = await readFile2(join2(dir, match), "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      if (lines.length === 0) return null;
+      const meta = JSON.parse(lines[0]);
+      const personas = lines.slice(1).map((l) => JSON.parse(l));
+      return {
+        id: meta.id,
+        name: meta.name,
+        product: meta.product,
+        personas,
+        createdAt: meta.createdAt,
+        updatedAt: meta.createdAt
+      };
+    } catch {
+      return null;
+    }
+  }
+  async listPanels() {
+    const dir = join2(this.baseDir, "panels");
+    try {
+      const files = await readdir(dir);
+      const panels = [];
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        const content = await readFile2(join2(dir, file), "utf-8");
+        const firstLine = content.split("\n")[0];
+        if (!firstLine) continue;
+        const meta = JSON.parse(firstLine);
+        if (meta._type === "panel") {
+          panels.push({
+            id: meta.id,
+            name: meta.name,
+            personaCount: meta.personaCount,
+            createdAt: meta.createdAt
+          });
+        }
+      }
+      return panels.sort(
+        (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Surveys
+  // -------------------------------------------------------------------------
+  async saveSurvey(result) {
+    const dir = join2(this.baseDir, "surveys");
+    await mkdir2(dir, { recursive: true });
+    const filename = `${slugify(result.surveyName)}-${Date.now()}.jsonl`;
+    const meta = JSON.stringify({
+      _type: "survey",
+      surveyName: result.surveyName,
+      personaCount: result.personaCount,
+      questionCount: result.questions.length,
+      timestamp: result.timestamp
+    });
+    const questions = JSON.stringify({
+      _type: "questions",
+      questions: result.questions
+    });
+    const summary = JSON.stringify({
+      _type: "summary",
+      summary: result.summary
+    });
+    const responseLines = result.responses.map((r) => JSON.stringify(r));
+    await writeFile2(
+      join2(dir, filename),
+      [meta, questions, summary, ...responseLines].join("\n") + "\n"
+    );
+    return filename;
+  }
+  // -------------------------------------------------------------------------
+  // Conversation History
+  // -------------------------------------------------------------------------
+  async appendResponse(response) {
+    const dir = join2(this.baseDir, "history");
+    await mkdir2(dir, { recursive: true });
+    const filename = `${response.personaId}.jsonl`;
+    const line = JSON.stringify({
+      ...response,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }) + "\n";
+    const filepath = join2(dir, filename);
+    try {
+      const existing = await readFile2(filepath, "utf-8");
+      await writeFile2(filepath, existing + line);
+    } catch {
+      await writeFile2(filepath, line);
+    }
+  }
+};
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/traces/store.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir as readdir2 } from "fs/promises";
+import { join as join3 } from "path";
+var TraceStore = class {
+  baseDir;
+  constructor(storageDir) {
+    this.baseDir = join3(storageDir ?? join3(process.cwd(), ".dopple"), "traces");
+  }
+  /**
+   * Save a trace.
+   */
+  async save(trace) {
+    const dir = join3(this.baseDir, slugify2(trace.product));
+    await mkdir3(dir, { recursive: true });
+    await writeFile3(
+      join3(dir, `${trace.id}.jsonl`),
+      JSON.stringify(trace) + "\n"
+    );
+    await this.updateIndex(trace.product);
+  }
+  /**
+   * Record an outcome for an existing trace.
+   */
+  async recordOutcome(product, traceId, outcome, accuracy) {
+    const dir = join3(this.baseDir, slugify2(product));
+    const path = join3(dir, `${traceId}.jsonl`);
+    const content = await readFile3(path, "utf-8");
+    const trace = JSON.parse(content.trim());
+    trace.outcome = outcome;
+    trace.accuracy = accuracy;
+    await writeFile3(path, JSON.stringify(trace) + "\n");
+    await this.updateIndex(product);
+  }
+  /**
+   * Get all traces for a product.
+   */
+  async getProductHistory(product) {
+    const dir = join3(this.baseDir, slugify2(product));
+    const traces = await this.loadTraces(dir);
+    return {
+      product,
+      traces,
+      calibrationSummary: computeCalibrationSummary(traces, product)
+    };
+  }
+  /**
+   * Get recent traces for a product (for prompt injection).
+   */
+  async getRecentTraces(product, limit = 10) {
+    const dir = join3(this.baseDir, slugify2(product));
+    const traces = await this.loadTraces(dir);
+    return traces.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    ).slice(0, limit);
+  }
+  /**
+   * Get traces that have outcomes (for calibration history).
+   */
+  async getTracesWithOutcomes(product) {
+    const dir = join3(this.baseDir, slugify2(product));
+    const traces = await this.loadTraces(dir);
+    return traces.filter((t) => t.outcome !== null);
+  }
+  /**
+   * Get the calibration narrative for prompt injection.
+   * This is the key method — it tells the LLM how accurate past predictions were.
+   */
+  async getCalibrationContext(product) {
+    const history = await this.getProductHistory(product);
+    return history.calibrationSummary.narrative;
+  }
+  /**
+   * List all products that have traces.
+   */
+  async listProducts() {
+    try {
+      const dirs = await readdir2(this.baseDir);
+      const indices = [];
+      for (const dir of dirs) {
+        const indexPath = join3(this.baseDir, dir, "index.jsonl");
+        try {
+          const content = await readFile3(indexPath, "utf-8");
+          indices.push(JSON.parse(content.trim()));
+        } catch {
+        }
+      }
+      return indices.sort(
+        (a, b) => new Date(b.lastTraceAt).getTime() - new Date(a.lastTraceAt).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  async loadTraces(dir) {
+    try {
+      const files = await readdir2(dir);
+      const traces = [];
+      for (const file of files) {
+        if (file === "index.jsonl" || !file.endsWith(".jsonl")) continue;
+        try {
+          const content = await readFile3(join3(dir, file), "utf-8");
+          traces.push(JSON.parse(content.trim()));
+        } catch {
+        }
+      }
+      return traces;
+    } catch {
+      return [];
+    }
+  }
+  async updateIndex(product) {
+    const dir = join3(this.baseDir, slugify2(product));
+    const traces = await this.loadTraces(dir);
+    const withOutcomes = traces.filter((t) => t.outcome !== null);
+    const maes = withOutcomes.map((t) => t.accuracy?.mae).filter((m) => m !== void 0 && m !== null);
+    const typeCounts = {};
+    for (const t of traces) {
+      typeCounts[t.type] = (typeCounts[t.type] ?? 0) + 1;
+    }
+    const index = {
+      product,
+      traceCount: traces.length,
+      withOutcomes: withOutcomes.length,
+      averageAccuracy: maes.length > 0 ? maes.reduce((a, b) => a + b, 0) / maes.length : null,
+      lastTraceAt: traces.length > 0 ? traces.sort(
+        (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+      )[0].timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      traceTypes: typeCounts
+    };
+    await writeFile3(join3(dir, "index.jsonl"), JSON.stringify(index) + "\n");
+  }
+};
+function computeCalibrationSummary(traces, product) {
+  const withOutcomes = traces.filter((t) => t.outcome !== null);
+  if (withOutcomes.length === 0) {
+    return {
+      totalPredictions: traces.length,
+      withOutcomes: 0,
+      averageMAE: null,
+      directionAccuracy: null,
+      narrative: traces.length > 0 ? `${traces.length} predictions made for "${product}" but no outcomes recorded yet. Predictions are uncalibrated.` : `No prediction history for "${product}".`
+    };
+  }
+  const maes = withOutcomes.map((t) => t.accuracy?.mae).filter((m) => m !== void 0 && m !== null);
+  const directionResults = withOutcomes.map((t) => t.accuracy?.directionCorrect).filter((d) => d !== void 0 && d !== null);
+  const averageMAE = maes.length > 0 ? maes.reduce((a, b) => a + b, 0) / maes.length : null;
+  const directionAccuracy = directionResults.length > 0 ? directionResults.filter(Boolean).length / directionResults.length : null;
+  const parts = [];
+  parts.push(
+    `CALIBRATION HISTORY for "${product}": ${withOutcomes.length} predictions have been verified against real outcomes.`
+  );
+  if (averageMAE !== null) {
+    if (averageMAE <= 0.05) {
+      parts.push(
+        `Average error: ${(averageMAE * 100).toFixed(1)}pp \u2014 excellent accuracy. Your predictions closely match reality.`
+      );
+    } else if (averageMAE <= 0.1) {
+      parts.push(
+        `Average error: ${(averageMAE * 100).toFixed(1)}pp \u2014 good accuracy. Minor adjustments may improve predictions.`
+      );
+    } else {
+      parts.push(
+        `Average error: ${(averageMAE * 100).toFixed(1)}pp \u2014 moderate accuracy. Be conservative with confidence levels.`
+      );
+    }
+  }
+  if (directionAccuracy !== null) {
+    parts.push(
+      `Directional accuracy: ${(directionAccuracy * 100).toFixed(0)}% of predictions got the direction right.`
+    );
+  }
+  const overEstimates = withOutcomes.filter(
+    (t) => t.accuracy?.notes?.toLowerCase().includes("over") || t.accuracy?.mae && t.accuracy.mae > 0.05
+  );
+  const underEstimates = withOutcomes.filter(
+    (t) => t.accuracy?.notes?.toLowerCase().includes("under")
+  );
+  if (overEstimates.length > underEstimates.length) {
+    parts.push(
+      "Tendency: you tend to OVER-estimate negative outcomes (churn, dissatisfaction). Adjust predictions slightly more optimistic."
+    );
+  } else if (underEstimates.length > overEstimates.length) {
+    parts.push(
+      "Tendency: you tend to UNDER-estimate negative outcomes. Adjust predictions slightly more conservative."
+    );
+  }
+  const mostRecent = withOutcomes.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  )[0];
+  if (mostRecent) {
+    parts.push(
+      `Most recent verified prediction: "${mostRecent.prediction.summary}" \u2192 Actual: "${mostRecent.outcome.actual}" (${mostRecent.accuracy?.notes ?? "no notes"})`
+    );
+  }
+  return {
+    totalPredictions: traces.length,
+    withOutcomes: withOutcomes.length,
+    averageMAE,
+    directionAccuracy,
+    narrative: parts.join("\n")
+  };
+}
+function slugify2(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/survey/survey.ts
+var Survey = class {
+  name;
+  questions = [];
+  constructor(name) {
+    this.name = name;
+  }
+  freeText(name, text) {
+    this.questions.push({ name, text, type: "free_text" });
+    return this;
+  }
+  multipleChoice(name, text, options) {
+    this.questions.push({ name, text, type: "multiple_choice", options });
+    return this;
+  }
+  likert5(name, text) {
+    this.questions.push({
+      name,
+      text,
+      type: "likert_5",
+      options: [
+        "Strongly disagree",
+        "Disagree",
+        "Neutral",
+        "Agree",
+        "Strongly agree"
+      ]
+    });
+    return this;
+  }
+  likert7(name, text) {
+    this.questions.push({
+      name,
+      text,
+      type: "likert_7",
+      options: [
+        "Strongly disagree",
+        "Disagree",
+        "Somewhat disagree",
+        "Neutral",
+        "Somewhat agree",
+        "Agree",
+        "Strongly agree"
+      ]
+    });
+    return this;
+  }
+  yesNo(name, text) {
+    this.questions.push({ name, text, type: "yes_no" });
+    return this;
+  }
+  numerical(name, text, min, max) {
+    this.questions.push({ name, text, type: "numerical", min, max });
+    return this;
+  }
+  ranking(name, text, options) {
+    this.questions.push({ name, text, type: "ranking", options });
+    return this;
+  }
+  /**
+   * Run the survey against a panel of personas.
+   */
+  async run(personas, llm) {
+    const allResponses = [];
+    for (const persona of personas) {
+      for (const question of this.questions) {
+        const response = await askSurveyQuestion(persona, question, llm);
+        allResponses.push(response);
+      }
+    }
+    const summary = {};
+    for (const q of this.questions) {
+      const qResponses = allResponses.filter((r) => r.questionName === q.name);
+      summary[q.name] = {
+        questionText: q.text,
+        type: q.type,
+        distribution: buildDistribution(q, qResponses),
+        themes: q.type === "free_text" ? extractThemes(qResponses) : void 0
+      };
+    }
+    return {
+      surveyName: this.name,
+      questions: this.questions,
+      responses: allResponses,
+      summary,
+      personaCount: personas.length,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  getQuestions() {
+    return [...this.questions];
+  }
+};
+async function askSurveyQuestion(persona, question, llm) {
+  const formatInstruction = getFormatInstruction(question);
+  const prompt = `Survey question: "${question.text}"
+
+${formatInstruction}
+
+Respond as JSON with this exact structure:
+{
+  "answer": <your answer matching the format above>,
+  "reasoning": "<1-2 sentences explaining WHY you answered this way, referencing your personality traits or experiences>",
+  "citations": [
+    {"source": "<data source>", "detail": "<specific data point>", "weight": <0-1>}
+  ]
+}
+
+For citations.source, use one of: "trait-model", "behavioral-data", "support-data", "payment-data", "general-knowledge"
+If you have no specific data to cite, use "trait-model" and reference which personality trait drives this answer.`;
+  const systemPrompt = persona.toPrompt();
+  const raw = await llm.generateJSON(systemPrompt, prompt);
+  return {
+    personaId: persona.id,
+    personaName: persona.name,
+    questionName: question.name,
+    questionText: question.text,
+    answer: raw.answer,
+    confidence: persona.definition.confidence,
+    citations: raw.citations ?? [],
+    reasoning: raw.reasoning ?? ""
+  };
+}
+function getFormatInstruction(q) {
+  switch (q.type) {
+    case "free_text":
+      return 'Answer in 1-3 sentences. Set "answer" to your text response.';
+    case "multiple_choice":
+      return `Choose ONE of these options exactly: ${q.options.map((o) => `"${o}"`).join(", ")}. Set "answer" to the chosen option string.`;
+    case "likert_5":
+      return `Rate on this scale: ${q.options.join(", ")}. Set "answer" to one of these exact strings.`;
+    case "likert_7":
+      return `Rate on this scale: ${q.options.join(", ")}. Set "answer" to one of these exact strings.`;
+    case "yes_no":
+      return 'Answer "Yes" or "No". Set "answer" to "Yes" or "No".';
+    case "numerical":
+      return `Provide a number${q.min != null ? ` (min: ${q.min}` : ""}${q.max != null ? `, max: ${q.max})` : q.min != null ? ")" : ""}. Set "answer" to the number.`;
+    case "ranking":
+      return `Rank these from most to least important: ${q.options.join(", ")}. Set "answer" to an array of strings in your preferred order.`;
+  }
+}
+function buildDistribution(q, responses) {
+  const dist = {};
+  if (q.type === "free_text") {
+    dist["total_responses"] = responses.length;
+    return dist;
+  }
+  for (const r of responses) {
+    const key = String(r.answer);
+    dist[key] = (dist[key] ?? 0) + 1;
+  }
+  return dist;
+}
+function extractThemes(responses) {
+  const wordCounts = {};
+  for (const r of responses) {
+    const words = String(r.answer).toLowerCase().split(/\W+/).filter((w) => w.length > 4);
+    for (const w of words) {
+      wordCounts[w] = (wordCounts[w] ?? 0) + 1;
+    }
+  }
+  return Object.entries(wordCounts).filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([word]) => word);
+}
+
+// src/simulation/focus-group.ts
+var FocusGroup = class {
+  name;
+  config;
+  personas = [];
+  rounds = [];
+  currentRound = 0;
+  injectedContextQueue = [];
+  privateContext = {};
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    if (config.personaContext) {
+      this.privateContext = { ...config.personaContext };
+    }
+  }
+  addPersonas(personas) {
+    this.personas.push(...personas);
+  }
+  /**
+   * Set private context for a specific persona.
+   * This information is only visible to them — other participants don't see it.
+   */
+  setPersonaContext(nameOrId, context) {
+    this.privateContext[nameOrId] = context;
+  }
+  /**
+   * Inject new context visible to ALL personas at the start of the next round.
+   */
+  inject(context) {
+    this.injectedContextQueue.push(context);
+  }
+  /**
+   * Run one round of discussion.
+   * Each persona speaks in turn, seeing what others said before them.
+   * Personas can change their minds if persuaded.
+   */
+  async discuss(llm) {
+    this.currentRound++;
+    const maxRounds = this.config.maxRounds ?? 5;
+    if (this.currentRound > maxRounds) {
+      throw new Error(
+        `Maximum rounds (${maxRounds}) reached. Create a new focus group or increase maxRounds.`
+      );
+    }
+    const injected = this.injectedContextQueue.length > 0 ? this.injectedContextQueue.splice(0).join("\n") : null;
+    const messages = [];
+    const roundMessages = [];
+    const speakingOrder = [...this.personas].sort(() => Math.random() - 0.5);
+    for (const persona of speakingOrder) {
+      const personalContext = this.privateContext[persona.name] ?? this.privateContext[persona.id] ?? null;
+      const prompt = buildGroupPrompt(
+        this.config,
+        this.currentRound,
+        this.getRecentHistory(3),
+        roundMessages,
+        injected,
+        persona.name,
+        personalContext
+      );
+      const response = await llm.generateJSON(
+        persona.toPrompt() + GROUP_INSTRUCTIONS,
+        prompt
+      );
+      const msg = {
+        round: this.currentRound,
+        personaId: persona.id,
+        personaName: persona.name,
+        message: response.message,
+        reasoning: response.reasoning,
+        citations: response.citations ?? [],
+        reactingTo: roundMessages.length > 0 ? roundMessages[roundMessages.length - 1] : null,
+        opinionShift: response.opinionShift ?? null,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      messages.push(msg);
+      roundMessages.push(`${persona.name}: ${response.message}`);
+    }
+    const round2 = {
+      round: this.currentRound,
+      messages,
+      injectedContext: injected
+    };
+    this.rounds.push(round2);
+    return round2;
+  }
+  /**
+   * Get all opinion shifts across all rounds.
+   */
+  getOpinionShifts() {
+    const shifts = [];
+    for (const round2 of this.rounds) {
+      for (const msg of round2.messages) {
+        if (msg.opinionShift) {
+          shifts.push({
+            personaId: msg.personaId,
+            personaName: msg.personaName,
+            previousPosition: msg.opinionShift.previousPosition,
+            newPosition: msg.opinionShift.newPosition,
+            trigger: {
+              personaName: msg.opinionShift.triggeredBy,
+              message: round2.messages.find(
+                (m) => m.personaName === msg.opinionShift.triggeredBy
+              )?.message ?? ""
+            },
+            round: round2.round,
+            reasoning: msg.reasoning
+          });
+        }
+      }
+    }
+    return shifts;
+  }
+  getTranscript() {
+    return [...this.rounds];
+  }
+  getAllMessages() {
+    return this.rounds.flatMap((r) => r.messages);
+  }
+  /**
+   * Summarize the discussion — themes, agreements, disagreements, insights, opinion shifts.
+   */
+  async summarize(llm) {
+    const transcript = this.rounds.flatMap((r) => {
+      const lines = [];
+      if (r.injectedContext) {
+        lines.push(`[MODERATOR: ${r.injectedContext}]`);
+      }
+      for (const m of r.messages) {
+        let line = `${m.personaName}: ${m.message}`;
+        if (m.opinionShift) {
+          line += ` [SHIFTED: from "${m.opinionShift.previousPosition}" to "${m.opinionShift.newPosition}", triggered by ${m.opinionShift.triggeredBy}]`;
+        }
+        lines.push(line);
+      }
+      return lines;
+    }).join("\n");
+    const analysis = await llm.generateJSON(
+      "You are a focus group moderator analyzing a discussion transcript.",
+      `Analyze this focus group discussion about "${this.config.topic}" for ${this.config.product ?? "a product"}.
+
+Transcript:
+${transcript}
+
+Return JSON with:
+- themes: top 3-5 recurring themes
+- agreements: points where most participants agreed
+- disagreements: points of contention or split opinions
+- insights: 2-3 non-obvious insights that emerged from the discussion (pay special attention to opinion shifts \u2014 when someone changed their mind, that's often the most revealing moment)`
+    );
+    return {
+      ...analysis,
+      opinionShifts: this.getOpinionShifts()
+    };
+  }
+  get roundCount() {
+    return this.currentRound;
+  }
+  get size() {
+    return this.personas.length;
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  getRecentHistory(rounds) {
+    const recent = this.rounds.slice(-rounds);
+    const lines = [];
+    for (const r of recent) {
+      if (r.injectedContext) {
+        lines.push(`[New information: ${r.injectedContext}]`);
+      }
+      for (const m of r.messages) {
+        lines.push(`${m.personaName}: ${m.message}`);
+      }
+    }
+    return lines;
+  }
+};
+function buildGroupPrompt(config, round2, history, currentRoundMessages, injectedContext, speakerName, personalContext) {
+  const parts = [];
+  parts.push(
+    `You are in a focus group discussion (round ${round2}) about: "${config.topic}"`
+  );
+  if (config.product) {
+    parts.push(`Product: ${config.product}`);
+  }
+  if (personalContext && personalContext.length > 0) {
+    parts.push(
+      `INFORMATION ONLY YOU HAVE (other participants don't know this):
+${personalContext.map((c) => `- ${c}`).join("\n")}`
+    );
+  }
+  if (history.length > 0) {
+    parts.push(`Previous discussion:
+${history.join("\n")}`);
+  }
+  if (injectedContext) {
+    parts.push(
+      `NEW INFORMATION just shared by the moderator:
+"${injectedContext}"
+
+React to this new information in your response.`
+    );
+  }
+  if (currentRoundMessages.length > 0) {
+    parts.push(
+      `Others have already spoken this round:
+${currentRoundMessages.join("\n")}
+
+You may agree, disagree, or build on what they said.`
+    );
+  }
+  parts.push(`Now it's YOUR turn to speak, ${speakerName}.
+
+Respond as JSON:
+{
+  "message": "<your contribution, 2-4 sentences. Be natural \u2014 agree, disagree, ask questions, share experiences>",
+  "reasoning": "<which personality traits drive your perspective here>",
+  "citations": [{"source": "<source>", "detail": "<detail>", "weight": <0-1>}],
+  "opinionShift": null
+}
+
+If someone genuinely changed your mind this round, set opinionShift to:
+{
+  "previousPosition": "<what you believed before>",
+  "newPosition": "<what you believe now>",
+  "triggeredBy": "<name of person whose argument convinced you>"
+}
+Otherwise keep opinionShift as null. Opinion shifts should be rare and genuine.`);
+  return parts.join("\n\n");
+}
+var GROUP_INSTRUCTIONS = `
+
+FOCUS GROUP RULES:
+- You are in a group discussion with other people. React to what others say.
+- Be natural \u2014 agree, disagree, interrupt, ask questions, share personal experiences.
+- Don't just answer the moderator's question. Engage with other participants.
+- If someone says something you disagree with, push back respectfully.
+- If new information is introduced, react honestly \u2014 it might change your mind or reinforce your position.
+- If someone makes a genuinely persuasive point, you ARE allowed to change your mind. Be honest about it.
+- Opinion shifts should be rare and meaningful. Don't flip-flop \u2014 only shift when truly convinced.
+- If you have private information, you may reference it naturally without explicitly saying "I have private info."
+- Stay in character. Your personality traits should be obvious from how you interact.
+- Keep responses to 2-4 sentences. This is a conversation, not a monologue.`;
+
+// src/insights/analyzer.ts
+import { randomUUID as randomUUID4 } from "crypto";
+async function discoverInsights(llm, userData, segments, personas, product, graph, graphPatterns) {
+  const questions = await generateQuestions(
+    llm,
+    userData,
+    segments,
+    product,
+    graphPatterns
+  );
+  const personaResponses = [];
+  for (const q of questions) {
+    for (const persona of personas) {
+      const r = await persona.ask(q.question);
+      const segment = segments.find((s) => s.persona.id === persona.id);
+      personaResponses.push({
+        question: q.question,
+        personaName: persona.name,
+        segmentName: segment?.name ?? "unknown",
+        response: r.response
+      });
+    }
+  }
+  const insights = await synthesizeInsights(
+    llm,
+    userData,
+    segments,
+    personaResponses,
+    product,
+    graphPatterns
+  );
+  return insights.sort((a, b) => b.impact * b.confidence - a.impact * a.confidence).slice(0, 7);
+}
+async function generateQuestions(llm, userData, segments, product, graphPatterns) {
+  const dataSummary = buildDataSummary2(userData);
+  const segmentSummary = segments.map(
+    (s) => `"${s.name}" (${s.percentage}%): ${s.description}. Patterns: ${s.patterns.join(", ")}`
+  ).join("\n");
+  const patternSummary = graphPatterns ? graphPatterns.slice(0, 5).map((p) => p.description).join("\n") : "No graph patterns available.";
+  const questions = await llm.generateJSON(
+    `You are a product analyst. Given user data, segments, and patterns, you generate the most important questions to ask users to uncover actionable insights. Do NOT use generic questions \u2014 every question must be grounded in something specific from the data.`,
+    `Product: ${product}
+
+User Data Summary:
+${dataSummary}
+
+Discovered Segments:
+${segmentSummary}
+
+Graph Patterns:
+${patternSummary}
+
+Generate 5-8 targeted questions that would reveal the most valuable product insights. Each question should be grounded in a specific data pattern or anomaly you noticed.
+
+Return JSON array:
+[{
+  "question": "<specific question grounded in the data>",
+  "rationale": "<why this question matters \u2014 what data pattern prompted it>",
+  "relevantSegments": ["<segment names this question is most relevant to>"]
+}]
+
+Focus on questions that would reveal:
+- Why users behave the way they do (motivation behind data patterns)
+- What would change their behavior (actionable)
+- Where the biggest opportunities or risks are
+- Discrepancies between what different segments might want`
+  );
+  return questions ?? [];
+}
+async function synthesizeInsights(llm, userData, segments, personaResponses, product, graphPatterns) {
+  const responsesSummary = personaResponses.map(
+    (r) => `[${r.segmentName}] ${r.personaName}: "${r.response}" (Q: ${r.question})`
+  ).join("\n");
+  const dataSummary = buildDataSummary2(userData);
+  const patternSummary = graphPatterns ? graphPatterns.slice(0, 5).map((p) => p.description).join("\n") : "";
+  const raw = await llm.generateJSON(
+    `You are a senior product analyst synthesizing insights from user data, persona responses, and behavioral patterns. Your insights must be:
+1. ACTIONABLE \u2014 each insight has a clear "do this" recommendation
+2. GROUNDED \u2014 every claim cites specific data or persona responses
+3. NON-OBVIOUS \u2014 don't just restate the data, find the "so what?"
+4. HONEST \u2014 if confidence is low, say so. Don't inflate.`,
+    `Product: ${product}
+
+Real User Data:
+${dataSummary}
+
+${patternSummary ? `Graph Patterns:
+${patternSummary}
+` : ""}
+
+Persona Responses:
+${responsesSummary}
+
+Synthesize 3-7 actionable insights. For each insight:
+- Cross-reference what personas said with what the real data shows
+- Look for discrepancies (persona says X but data shows Y \u2014 these are gold)
+- Look for agreement across segments (strong signal)
+- Look for polarization between segments (opportunity for segmented approach)
+
+Return JSON array:
+[{
+  "title": "<short, punchy insight title>",
+  "description": "<2-3 sentence explanation>",
+  "confidence": <0.0-1.0>,
+  "impact": <0.0-1.0>,
+  "evidence": [{"type": "data_pattern|persona_response|graph_pattern|cross_reference", "source": "<source>", "detail": "<specific evidence>", "weight": <0-1>}],
+  "recommendation": "<specific action to take>",
+  "segments": ["<which segments this applies to>"]
+}]`
+  );
+  return (raw ?? []).map((r) => ({
+    id: randomUUID4(),
+    ...r
+  }));
+}
+function buildDataSummary2(records) {
+  const lines = [`Total users: ${records.length}`];
+  const propCounts = {};
+  for (const r of records) {
+    for (const [key, value] of Object.entries(r.properties)) {
+      if (key.startsWith("_")) continue;
+      if (!propCounts[key]) propCounts[key] = {};
+      const v = String(value);
+      propCounts[key][v] = (propCounts[key][v] ?? 0) + 1;
+    }
+  }
+  for (const [prop, values] of Object.entries(propCounts)) {
+    const sorted = Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, 5);
+    const total = records.length;
+    const dist = sorted.map(([v, c]) => `${v} (${(c / total * 100).toFixed(0)}%)`).join(", ");
+    lines.push(`${prop}: ${dist}`);
+  }
+  const eventCounts = {};
+  for (const r of records) {
+    for (const e of r.events ?? []) {
+      eventCounts[e.name] = (eventCounts[e.name] ?? 0) + 1;
+    }
+  }
+  if (Object.keys(eventCounts).length > 0) {
+    const top = Object.entries(eventCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([n, c]) => `${n} (${c}x)`).join(", ");
+    lines.push(`Top events: ${top}`);
+  }
+  const statuses = {};
+  const cancelReasons = [];
+  for (const r of records) {
+    for (const p of r.payments ?? []) {
+      statuses[p.status] = (statuses[p.status] ?? 0) + 1;
+      if (p.cancelReason) cancelReasons.push(p.cancelReason);
+    }
+  }
+  if (Object.keys(statuses).length > 0) {
+    lines.push(
+      `Payments: ${Object.entries(statuses).map(([s, c]) => `${s}: ${c}`).join(", ")}`
+    );
+  }
+  if (cancelReasons.length > 0) {
+    lines.push(`Cancel reasons: ${cancelReasons.slice(0, 5).join("; ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/insights/insights.ts
+async function runInsightsPipeline(dopple, llm, options) {
+  const startTime = Date.now();
+  const userData = await dopple.fetchData();
+  let graph;
+  let graphPatterns;
+  if (options.useGraph && userData.length > 0) {
+    const doppleGraph = await dopple.buildGraph(options.context);
+    graph = doppleGraph.raw;
+    graphPatterns = doppleGraph.patterns();
+  }
+  const discovery = await dopple.discover({ product: options.product });
+  const personas = [];
+  for (const segment of discovery.segments) {
+    const persona = new Persona(segment.persona, llm);
+    if (graph) {
+      const { getPersonaContext } = await import("./query-GEL76KSF.js");
+      const graphContext = getPersonaContext(graph, segment.persona.traits);
+      persona.memory.addFacts(
+        graphContext.map((c) => ({
+          source: "knowledge-graph",
+          content: c,
+          salience: 0.7
+        }))
+      );
+    }
+    personas.push(persona);
+  }
+  const insights = await discoverInsights(
+    llm,
+    userData,
+    discovery.segments,
+    personas,
+    options.product,
+    graph,
+    graphPatterns
+  );
+  const durationMs = Date.now() - startTime;
+  return {
+    product: options.product,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dataQuality: {
+      sources: [...new Set(userData.flatMap(() => ["user-data"]))],
+      userCount: userData.length,
+      confidence: discovery.confidence,
+      gaps: discovery.suggestions
+    },
+    graph: graph ? {
+      nodeCount: graph.metadata.nodeCount,
+      edgeCount: graph.metadata.edgeCount,
+      patterns: (graphPatterns ?? []).map((p) => p.description)
+    } : void 0,
+    segments: discovery.segments,
+    insights,
+    metadata: {
+      model: llm.providerId,
+      segmentCount: discovery.segments.length,
+      personaCount: personas.length,
+      durationMs
+    }
+  };
+}
+
+// src/calibration/extract.ts
+import { randomUUID as randomUUID5 } from "crypto";
+async function extractRules(llm, source) {
+  const prompt = getExtractionPrompt(source);
+  const extracted = await llm.generateJSON(
+    `You extract testable rules and expectations from documents. Each rule should be something you can verify by asking a synthetic persona a question or putting them in a scenario.
+
+Focus on rules that are:
+1. TESTABLE \u2014 you can design a scenario that checks if someone follows/understands this
+2. BEHAVIORAL \u2014 about what people would do, think, or expect
+3. SPECIFIC \u2014 not vague platitudes, but concrete predictions`,
+    prompt
+  );
+  return (extracted ?? []).map((r) => ({
+    id: randomUUID5(),
+    rule: r.rule,
+    source: source.name,
+    testScenario: r.testScenario
+  }));
+}
+function getExtractionPrompt(source) {
+  switch (source.type) {
+    case "policy":
+      return `Extract testable rules from this policy document. For each rule, create a scenario that tests whether a user/citizen understands and would comply with this policy.
+
+Policy document "${source.name}":
+${source.content}
+
+Return JSON array:
+[{"rule": "<the policy rule or expectation>", "testScenario": "<a scenario/question that tests if a persona follows this rule>"}]
+
+Extract 5-15 rules. Focus on rules that affect user behavior, not internal procedures.`;
+    case "survey":
+      return `Extract expected response patterns from this survey data. Each "rule" is a known finding \u2014 something real users actually said/chose.
+
+Survey data "${source.name}":
+${source.content}
+
+Return JSON array:
+[{"rule": "<the known finding from real users, e.g. '62% prefer monthly billing'>", "testScenario": "<ask the same question to check if synthetic personas match>"}]
+
+Extract the most significant findings as rules.`;
+    case "outcomes":
+      return `Extract behavioral outcomes from this data. Each "rule" is something that actually happened \u2014 a measurable result.
+
+Outcome data "${source.name}":
+${source.content}
+
+Return JSON array:
+[{"rule": "<what actually happened, e.g. '22% churned after price increase'>", "testScenario": "<a scenario that tests if personas would predict this outcome>"}]
+
+Focus on outcomes that reveal user motivations and decision-making.`;
+    case "benchmarks":
+      return `Extract industry benchmarks from this data. Each "rule" is a known metric or standard.
+
+Benchmark data "${source.name}":
+${source.content}
+
+Return JSON array:
+[{"rule": "<the benchmark, e.g. 'average SaaS NPS is 31'>", "testScenario": "<a scenario that tests if personas align with this benchmark>"}]`;
+    case "document":
+    default:
+      return `Extract testable expectations from this document. Identify anything that makes a claim about how users/people behave, think, or make decisions.
+
+Document "${source.name}":
+${source.content}
+
+Return JSON array:
+[{"rule": "<the expectation or claim>", "testScenario": "<a scenario that tests if a persona matches this expectation>"}]`;
+  }
+}
+
+// src/calibration/test.ts
+async function testRule(llm, rule, personas) {
+  const responses = [];
+  for (const persona of personas) {
+    const r = await persona.ask(rule.testScenario);
+    responses.push(`${persona.name}: ${r.response}`);
+  }
+  const evaluation = await llm.generateJSON(
+    `You evaluate whether synthetic persona responses align with a known rule or expectation. Be rigorous \u2014 a vague match is not alignment. Look for specific behavioral alignment.`,
+    `Rule: "${rule.rule}"
+Source: ${rule.source}
+
+Persona responses to the scenario "${rule.testScenario}":
+${responses.join("\n")}
+
+Evaluate alignment. Return JSON:
+{
+  "aligned": <true if the majority of personas match the rule's expectation>,
+  "score": <0.0-1.0 alignment score. 1.0 = perfect match, 0.0 = complete mismatch>,
+  "personaSummary": "<what the personas collectively said/did>",
+  "expected": "<what was expected based on the rule>",
+  "gapAnalysis": "<if misaligned: WHY the gap exists and what it means. If aligned: what confirms it>"
+}`
+  );
+  return {
+    ruleId: rule.id,
+    rule: rule.rule,
+    aligned: evaluation.aligned,
+    score: Math.max(0, Math.min(1, evaluation.score)),
+    personaResponse: evaluation.personaSummary,
+    expected: evaluation.expected,
+    gapAnalysis: evaluation.gapAnalysis
+  };
+}
+async function testAllRules(llm, rules, personas) {
+  const results = [];
+  for (const rule of rules) {
+    for (const p of personas) p.clearHistory();
+    const result = await testRule(llm, rule, personas);
+    results.push(result);
+  }
+  return results;
+}
+
+// src/calibration/calibrate.ts
+async function calibrate(llm, personas, sources, options = {}) {
+  const startTime = Date.now();
+  const maxRules = options.maxRulesPerSource ?? 10;
+  const allRules = [];
+  for (const source of sources) {
+    const rules = await extractRules(llm, source);
+    allRules.push(...rules.slice(0, maxRules));
+  }
+  if (allRules.length === 0) {
+    return emptyReport(sources, personas.length, Date.now() - startTime);
+  }
+  const results = await testAllRules(llm, allRules, personas);
+  const alignedCount = results.filter((r) => r.aligned).length;
+  const misalignedCount = results.length - alignedCount;
+  const overallScore = results.length > 0 ? results.reduce((sum, r) => sum + r.score, 0) / results.length : 0;
+  const topMisalignments = results.filter((r) => !r.aligned).sort((a, b) => a.score - b.score).slice(0, 5);
+  const recommendations = await generateRecommendations(
+    llm,
+    topMisalignments,
+    sources
+  );
+  return {
+    overallScore,
+    totalRules: results.length,
+    alignedCount,
+    misalignedCount,
+    results,
+    topMisalignments,
+    recommendations,
+    sources: sources.map((s) => ({ type: s.type, name: s.name })),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: {
+      personaCount: personas.length,
+      ruleCount: allRules.length,
+      durationMs: Date.now() - startTime
+    }
+  };
+}
+async function generateRecommendations(llm, misalignments, sources) {
+  if (misalignments.length === 0) {
+    return ["All rules aligned. Persona panel matches the calibration sources well."];
+  }
+  const gapSummary = misalignments.map(
+    (m) => `Rule: "${m.rule}"
+Expected: ${m.expected}
+Actual: ${m.personaResponse}
+Gap: ${m.gapAnalysis}`
+  ).join("\n\n");
+  const sourceTypes = sources.map((s) => `${s.type}: "${s.name}"`).join(", ");
+  const recs = await llm.generateJSON(
+    "You generate actionable recommendations from calibration gaps between synthetic personas and ground truth data.",
+    `These are the top misalignments between synthetic personas and calibration sources (${sourceTypes}):
+
+${gapSummary}
+
+Generate 3-5 actionable recommendations. Each should:
+1. Name the specific gap
+2. Explain what it means for the product/policy
+3. Suggest a concrete action
+
+Return a JSON array of strings.`
+  );
+  return recs ?? [];
+}
+function emptyReport(sources, personaCount, durationMs) {
+  return {
+    overallScore: 0,
+    totalRules: 0,
+    alignedCount: 0,
+    misalignedCount: 0,
+    results: [],
+    topMisalignments: [],
+    recommendations: [
+      "No testable rules could be extracted from the provided sources. Try providing more detailed policy documents or survey data."
+    ],
+    sources: sources.map((s) => ({ type: s.type, name: s.name })),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: { personaCount, ruleCount: 0, durationMs }
+  };
+}
+
+// src/calibration/structured.ts
+function calibrateStructured(realData, syntheticResults, options = {}) {
+  const startTime = Date.now();
+  const threshold = options.threshold ?? 0.1;
+  const questionResults = [];
+  const allRealPcts = [];
+  const allSyntheticPcts = [];
+  for (const realQ of realData.questions) {
+    const syntheticSummary = syntheticResults.summary[realQ.name];
+    if (!syntheticSummary) continue;
+    const realTotal = realQ.totalRespondents;
+    const realPcts = {};
+    for (const [opt, count] of Object.entries(realQ.distribution)) {
+      realPcts[opt] = realTotal > 0 ? count / realTotal : 0;
+    }
+    const syntheticDist = syntheticSummary.distribution;
+    const syntheticTotal = Object.values(syntheticDist).reduce(
+      (a, b) => a + b,
+      0
+    );
+    const syntheticPcts = {};
+    for (const [opt, count] of Object.entries(syntheticDist)) {
+      syntheticPcts[opt] = syntheticTotal > 0 ? count / syntheticTotal : 0;
+    }
+    const allOptions = [
+      .../* @__PURE__ */ new Set([...Object.keys(realPcts), ...Object.keys(syntheticPcts)])
+    ];
+    const perOptionError = {};
+    let totalError = 0;
+    for (const opt of allOptions) {
+      const realPct = realPcts[opt] ?? 0;
+      const synthPct = syntheticPcts[opt] ?? 0;
+      const error = Math.abs(realPct - synthPct);
+      perOptionError[opt] = error;
+      totalError += error;
+      allRealPcts.push(realPct);
+      allSyntheticPcts.push(synthPct);
+    }
+    const mae = allOptions.length > 0 ? totalError / allOptions.length : 0;
+    let largest = { option: "", realPct: 0, syntheticPct: 0, error: 0 };
+    for (const opt of allOptions) {
+      const err = perOptionError[opt];
+      if (err > largest.error) {
+        largest = {
+          option: opt,
+          realPct: realPcts[opt] ?? 0,
+          syntheticPct: syntheticPcts[opt] ?? 0,
+          error: err
+        };
+      }
+    }
+    questionResults.push({
+      questionName: realQ.name,
+      questionText: realQ.text,
+      type: realQ.type,
+      mae,
+      withinThreshold: mae <= threshold,
+      realDistribution: Object.fromEntries(
+        Object.entries(realPcts).map(([k, v]) => [k, round(v * 100)])
+      ),
+      syntheticDistribution: Object.fromEntries(
+        Object.entries(syntheticPcts).map(([k, v]) => [k, round(v * 100)])
+      ),
+      perOptionError: Object.fromEntries(
+        Object.entries(perOptionError).map(([k, v]) => [k, round(v * 100)])
+      ),
+      largestDivergence: {
+        option: largest.option,
+        realPct: round(largest.realPct * 100),
+        syntheticPct: round(largest.syntheticPct * 100),
+        error: round(largest.error * 100)
+      }
+    });
+  }
+  questionResults.sort((a, b) => b.mae - a.mae);
+  const overallMAE = questionResults.length > 0 ? questionResults.reduce((sum, q) => sum + q.mae, 0) / questionResults.length : 0;
+  const correlation = pearsonCorrelation(allRealPcts, allSyntheticPcts);
+  const questionsWithinThreshold = questionResults.filter(
+    (q) => q.withinThreshold
+  ).length;
+  const sortedByMAE = [...questionResults].sort((a, b) => a.mae - b.mae);
+  const medianIdx = Math.floor(sortedByMAE.length / 2);
+  const maxRespondents = Math.max(
+    ...realData.questions.map((q) => q.totalRespondents),
+    0
+  );
+  return {
+    name: realData.name,
+    overallMAE: round(overallMAE * 100) / 100,
+    correlation: round(correlation * 1e3) / 1e3,
+    questionsWithinThreshold,
+    totalQuestions: questionResults.length,
+    threshold,
+    questions: questionResults,
+    stats: {
+      bestQuestion: sortedByMAE.length > 0 ? {
+        name: sortedByMAE[0].questionName,
+        mae: round(sortedByMAE[0].mae * 100)
+      } : { name: "none", mae: 0 },
+      worstQuestion: sortedByMAE.length > 0 ? {
+        name: sortedByMAE[sortedByMAE.length - 1].questionName,
+        mae: round(
+          sortedByMAE[sortedByMAE.length - 1].mae * 100
+        )
+      } : { name: "none", mae: 0 },
+      medianMAE: sortedByMAE.length > 0 ? round(sortedByMAE[medianIdx].mae * 100) : 0,
+      personaCount: syntheticResults.personaCount,
+      realRespondentCount: maxRespondents
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: Date.now() - startTime
+  };
+}
+function pearsonCorrelation(x, y) {
+  const n = x.length;
+  if (n === 0 || n !== y.length) return 0;
+  const meanX = x.reduce((a, b) => a + b, 0) / n;
+  const meanY = y.reduce((a, b) => a + b, 0) / n;
+  let numerator = 0;
+  let denomX = 0;
+  let denomY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - meanX;
+    const dy = y[i] - meanY;
+    numerator += dx * dy;
+    denomX += dx * dx;
+    denomY += dy * dy;
+  }
+  const denom = Math.sqrt(denomX * denomY);
+  if (denom === 0) return 0;
+  return numerator / denom;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/adapters/posthog.ts
+var PostHogAdapter = class {
+  type = "posthog";
+  config;
+  baseUrl;
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = (config.host ?? "https://us.posthog.com").replace(
+      /\/$/,
+      ""
+    );
+  }
+  async fetch() {
+    const persons = await this.fetchPersons();
+    const records = [];
+    for (const person of persons) {
+      const events = await this.fetchPersonEvents(person.distinct_ids[0]);
+      records.push({
+        id: person.distinct_ids[0] ?? person.id,
+        properties: person.properties ?? {},
+        events: events.map(
+          (e) => ({
+            name: e.event,
+            timestamp: e.timestamp,
+            properties: e.properties ?? {}
+          })
+        )
+      });
+    }
+    return records;
+  }
+  async fetchPersons() {
+    const limit = this.config.limit ?? 100;
+    const url = new URL(`${this.baseUrl}/api/projects/@current/persons/`);
+    url.searchParams.set("limit", String(limit));
+    if (this.config.propertyFilters) {
+      url.searchParams.set(
+        "properties",
+        JSON.stringify(
+          this.config.propertyFilters.map((f) => ({
+            key: f.key,
+            value: f.value,
+            operator: f.operator ?? "exact",
+            type: "person"
+          }))
+        )
+      );
+    }
+    const res = await globalThis.fetch(url.toString(), {
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(
+        `PostHog API error: ${res.status} ${res.statusText}`
+      );
+    }
+    const data = await res.json();
+    return data.results ?? [];
+  }
+  async fetchPersonEvents(distinctId) {
+    const url = new URL(`${this.baseUrl}/api/projects/@current/events/`);
+    url.searchParams.set("person_id", distinctId);
+    url.searchParams.set("limit", "50");
+    url.searchParams.set("orderBy", JSON.stringify(["-timestamp"]));
+    const res = await globalThis.fetch(url.toString(), {
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      return [];
+    }
+    const data = await res.json();
+    return data.results ?? [];
+  }
+};
+registerAdapter("posthog", (config) => new PostHogAdapter(config));
+
+// src/adapters/csv.ts
+import { readFile as readFile4 } from "fs/promises";
+import { parse } from "csv-parse/sync";
+var FileAdapter = class {
+  type;
+  config;
+  constructor(config) {
+    this.type = config.type;
+    this.config = config;
+  }
+  async fetch() {
+    const content = await readFile4(this.config.path, "utf-8");
+    if (this.config.type === "json") {
+      return this.parseJSON(content);
+    }
+    return this.parseCSV(content);
+  }
+  parseJSON(content) {
+    const data = JSON.parse(content);
+    const rows = Array.isArray(data) ? data : [data];
+    return rows.map((row, i) => {
+      const obj = row;
+      const id = String(obj.id ?? obj.user_id ?? obj.email ?? `row-${i}`);
+      return {
+        id,
+        properties: obj
+      };
+    });
+  }
+  parseCSV(content) {
+    const records = parse(content, {
+      columns: true,
+      skip_empty_lines: true,
+      trim: true
+    });
+    return records.map((row, i) => {
+      const id = (this.config.idColumn ? row[this.config.idColumn] : void 0) ?? row.id ?? row.user_id ?? row.email ?? `row-${i}`;
+      return {
+        id,
+        properties: row
+      };
+    });
+  }
+};
+registerAdapter("csv", (config) => new FileAdapter(config));
+registerAdapter("json", (config) => new FileAdapter(config));
+
+// src/adapters/context.ts
+var ContextAdapter = class {
+  type = "context";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const contextParts = [];
+    if (this.config.text) {
+      contextParts.push(this.config.text);
+    }
+    if (this.config.urls) {
+      for (const url of this.config.urls) {
+        try {
+          const res = await globalThis.fetch(url);
+          if (res.ok) {
+            const html = await res.text();
+            const text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 5e3);
+            contextParts.push(`Content from ${url}:
+${text}`);
+          }
+        } catch {
+        }
+      }
+    }
+    if (contextParts.length === 0) return [];
+    return [
+      {
+        id: "context",
+        properties: {
+          _type: "context",
+          _content: contextParts.join("\n\n")
+        }
+      }
+    ];
+  }
+};
+registerAdapter("context", (config) => new ContextAdapter(config));
+
+// src/adapters/stripe.ts
+var StripeAdapter = class {
+  type = "stripe";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const customers = await this.fetchCustomers();
+    const records = [];
+    for (const customer of customers) {
+      const subscriptions = await this.fetchSubscriptions(customer.id);
+      const payments = subscriptions.map((sub) => ({
+        amount: sub.plan?.amount ? sub.plan.amount / 100 : 0,
+        currency: sub.currency ?? "usd",
+        status: mapStatus(sub.status),
+        plan: sub.plan?.nickname ?? sub.plan?.id ?? void 0,
+        cancelReason: sub.cancellation_details?.reason ?? void 0,
+        createdAt: new Date(sub.created * 1e3).toISOString()
+      }));
+      records.push({
+        id: customer.id,
+        properties: {
+          email: customer.email,
+          name: customer.name,
+          created: new Date(customer.created * 1e3).toISOString(),
+          currency: customer.currency,
+          delinquent: customer.delinquent
+        },
+        payments
+      });
+    }
+    return records;
+  }
+  async fetchCustomers() {
+    const limit = this.config.limit ?? 100;
+    const res = await fetch(
+      `https://api.stripe.com/v1/customers?limit=${limit}`,
+      {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` }
+      }
+    );
+    if (!res.ok) {
+      throw new Error(`Stripe API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.data ?? [];
+  }
+  async fetchSubscriptions(customerId) {
+    const res = await fetch(
+      `https://api.stripe.com/v1/subscriptions?customer=${customerId}&limit=10&status=all`,
+      {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` }
+      }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.data ?? [];
+  }
+};
+function mapStatus(status) {
+  switch (status) {
+    case "active":
+      return "active";
+    case "canceled":
+      return "cancelled";
+    case "past_due":
+      return "past_due";
+    case "trialing":
+      return "trialing";
+    default:
+      return "cancelled";
+  }
+}
+registerAdapter(
+  "stripe",
+  (config) => new StripeAdapter(config)
+);
+
+// src/adapters/document.ts
+import { readFile as readFile5, readdir as readdir3, stat } from "fs/promises";
+import { join as join4, extname, basename } from "path";
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".html",
+  ".htm",
+  ".doc",
+  ".rtf",
+  ".csv",
+  ".json"
+]);
+var DocumentAdapter = class {
+  type = "document";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const maxChars = this.config.maxChars ?? 5e4;
+    const allowedExts = this.config.extensions ? new Set(this.config.extensions.map((e) => e.startsWith(".") ? e : `.${e}`)) : SUPPORTED_EXTENSIONS;
+    const files = await this.resolveFiles(allowedExts);
+    const records = [];
+    for (const filePath of files) {
+      const ext = extname(filePath).toLowerCase();
+      const name = basename(filePath);
+      let text;
+      try {
+        text = await extractText(filePath, ext);
+      } catch {
+        continue;
+      }
+      if (!text.trim()) continue;
+      const content = text.length > maxChars ? text.slice(0, maxChars) : text;
+      records.push({
+        id: `doc-${name}`,
+        properties: {
+          _type: "document",
+          _source: filePath,
+          _filename: name,
+          _extension: ext,
+          _charCount: content.length,
+          _content: content
+        }
+      });
+    }
+    return records;
+  }
+  async resolveFiles(allowedExts) {
+    const p = this.config.path;
+    const info = await stat(p);
+    if (info.isFile()) {
+      return [p];
+    }
+    if (info.isDirectory()) {
+      const entries = await readdir3(p);
+      return entries.filter((e) => allowedExts.has(extname(e).toLowerCase())).map((e) => join4(p, e));
+    }
+    return [];
+  }
+};
+async function extractText(filePath, ext) {
+  switch (ext) {
+    case ".pdf":
+      return extractPDF(filePath);
+    case ".html":
+    case ".htm":
+      return extractHTML(filePath);
+    case ".md":
+    case ".mdx":
+    case ".txt":
+    case ".rtf":
+    default:
+      return readFile5(filePath, "utf-8");
+  }
+}
+async function extractPDF(filePath) {
+  const mod = await import("pdf-parse");
+  const pdfParse = mod.default ?? mod;
+  const buffer = await readFile5(filePath);
+  const data = await pdfParse(buffer);
+  return data.text;
+}
+async function extractHTML(filePath) {
+  const html = await readFile5(filePath, "utf-8");
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+registerAdapter(
+  "document",
+  (config) => new DocumentAdapter(config)
+);
+
+// src/adapters/amplitude.ts
+var AmplitudeAdapter = class {
+  type = "amplitude";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const now = /* @__PURE__ */ new Date();
+    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
+    const start = this.config.startDate ?? formatDate(thirtyDaysAgo) + "T00";
+    const end = this.config.endDate ?? formatDate(now) + "T23";
+    const auth = Buffer.from(
+      `${this.config.apiKey}:${this.config.secretKey}`
+    ).toString("base64");
+    const res = await fetch(
+      `https://amplitude.com/api/2/export?start=${start}&end=${end}`,
+      {
+        headers: { Authorization: `Basic ${auth}` }
+      }
+    );
+    if (!res.ok) {
+      throw new Error(`Amplitude API error: ${res.status} ${res.statusText}`);
+    }
+    const text = await res.text();
+    const lines = text.trim().split("\n").filter(Boolean);
+    const userMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        const userId = event.user_id ?? event.device_id ?? "anonymous";
+        if (!userMap.has(userId)) {
+          userMap.set(userId, {
+            properties: event.user_properties ?? {},
+            events: []
+          });
+        }
+        const user = userMap.get(userId);
+        user.events.push({
+          name: event.event_type,
+          timestamp: event.event_time ?? (/* @__PURE__ */ new Date()).toISOString(),
+          properties: event.event_properties ?? {}
+        });
+      } catch {
+      }
+    }
+    return [...userMap.entries()].map(([id, data]) => ({
+      id,
+      properties: data.properties,
+      events: data.events
+    }));
+  }
+};
+function formatDate(d) {
+  return d.toISOString().slice(0, 10).replace(/-/g, "");
+}
+registerAdapter(
+  "amplitude",
+  (config) => new AmplitudeAdapter(config)
+);
+
+// src/adapters/mixpanel.ts
+var MixpanelAdapter = class {
+  type = "mixpanel";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const profiles = await this.fetchProfiles();
+    const events = await this.fetchEvents();
+    const eventsByUser = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const userId = event.properties?.distinct_id ?? "anonymous";
+      if (!eventsByUser.has(userId)) eventsByUser.set(userId, []);
+      eventsByUser.get(userId).push({
+        name: event.event,
+        timestamp: event.properties?.time ? new Date(event.properties.time * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        properties: event.properties ?? {}
+      });
+    }
+    const userMap = /* @__PURE__ */ new Map();
+    for (const profile of profiles) {
+      const id = String(profile.$distinct_id ?? profile.$properties?.$email ?? "unknown");
+      userMap.set(id, {
+        id,
+        properties: profile.$properties ?? {},
+        events: eventsByUser.get(String(id)) ?? []
+      });
+    }
+    for (const [userId, userEvents] of eventsByUser) {
+      if (!userMap.has(userId)) {
+        userMap.set(userId, {
+          id: userId,
+          properties: {},
+          events: userEvents
+        });
+      }
+    }
+    return [...userMap.values()];
+  }
+  async fetchProfiles() {
+    const auth = Buffer.from(`${this.config.apiSecret}:`).toString("base64");
+    const res = await fetch(
+      "https://mixpanel.com/api/2.0/engage?page_size=100",
+      {
+        headers: {
+          Authorization: `Basic ${auth}`,
+          Accept: "application/json"
+        }
+      }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.results ?? [];
+  }
+  async fetchEvents() {
+    const days = this.config.days ?? 30;
+    const now = /* @__PURE__ */ new Date();
+    const from = new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
+    const fromStr = from.toISOString().slice(0, 10);
+    const toStr = now.toISOString().slice(0, 10);
+    const auth = Buffer.from(`${this.config.apiSecret}:`).toString("base64");
+    const res = await fetch(
+      `https://data.mixpanel.com/api/2.0/export?from_date=${fromStr}&to_date=${toStr}`,
+      {
+        headers: { Authorization: `Basic ${auth}` }
+      }
+    );
+    if (!res.ok) return [];
+    const text = await res.text();
+    return text.trim().split("\n").filter(Boolean).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+  }
+};
+registerAdapter(
+  "mixpanel",
+  (config) => new MixpanelAdapter(config)
+);
+
+// src/adapters/hubspot.ts
+var HubSpotAdapter = class {
+  type = "hubspot";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const contacts = await this.fetchContacts();
+    const records = [];
+    for (const contact of contacts) {
+      const props = contact.properties ?? {};
+      const record = {
+        id: contact.id,
+        properties: {
+          email: props.email,
+          firstName: props.firstname,
+          lastName: props.lastname,
+          company: props.company,
+          jobTitle: props.jobtitle,
+          phone: props.phone,
+          city: props.city,
+          state: props.state,
+          country: props.country,
+          lifecycleStage: props.lifecyclestage,
+          leadStatus: props.hs_lead_status,
+          lastActivityDate: props.notes_last_updated,
+          createDate: props.createdate
+        }
+      };
+      if (this.config.includeDeals) {
+        const deals = await this.fetchContactDeals(contact.id);
+        if (deals.length > 0) {
+          record.payments = deals.map((deal) => ({
+            amount: parseFloat(deal.properties?.amount ?? "0"),
+            currency: deal.properties?.deal_currency_code ?? "USD",
+            status: deal.properties?.dealstage === "closedwon" ? "active" : deal.properties?.dealstage === "closedlost" ? "cancelled" : "trialing",
+            plan: deal.properties?.dealname ?? void 0,
+            cancelReason: deal.properties?.closed_lost_reason ?? void 0,
+            createdAt: deal.properties?.createdate ?? (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
+      }
+      records.push(record);
+    }
+    return records;
+  }
+  async fetchContacts() {
+    const limit = this.config.limit ?? 100;
+    const res = await fetch(
+      `https://api.hubapi.com/crm/v3/objects/contacts?limit=${limit}&properties=email,firstname,lastname,company,jobtitle,phone,city,state,country,lifecyclestage,hs_lead_status,notes_last_updated,createdate`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!res.ok) {
+      throw new Error(`HubSpot API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.results ?? [];
+  }
+  async fetchContactDeals(contactId) {
+    const res = await fetch(
+      `https://api.hubapi.com/crm/v3/objects/contacts/${contactId}/associations/deals`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`
+        }
+      }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    const deals = [];
+    for (const assoc of data.results ?? []) {
+      const dealRes = await fetch(
+        `https://api.hubapi.com/crm/v3/objects/deals/${assoc.id}?properties=dealname,amount,dealstage,deal_currency_code,closed_lost_reason,createdate`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.config.accessToken}`
+          }
+        }
+      );
+      if (dealRes.ok) {
+        deals.push(await dealRes.json());
+      }
+    }
+    return deals;
+  }
+};
+registerAdapter(
+  "hubspot",
+  (config) => new HubSpotAdapter(config)
+);
+
+// src/adapters/intercom.ts
+var IntercomAdapter = class {
+  type = "intercom";
+  config;
+  baseUrl = "https://api.intercom.io";
+  constructor(config) {
+    this.config = config;
+  }
+  async fetch() {
+    const contacts = await this.fetchContacts();
+    const records = [];
+    for (const contact of contacts) {
+      const record = {
+        id: contact.id,
+        properties: {
+          email: contact.email,
+          name: contact.name,
+          role: contact.role,
+          signedUpAt: contact.signed_up_at,
+          lastSeenAt: contact.last_seen_at,
+          lastContactedAt: contact.last_contacted_at,
+          browser: contact.browser,
+          os: contact.os,
+          city: contact.location?.city,
+          country: contact.location?.country,
+          unsubscribedFromEmails: contact.unsubscribed_from_emails,
+          tags: contact.tags?.tags?.map((t) => t.name) ?? [],
+          customAttributes: contact.custom_attributes
+        }
+      };
+      if (this.config.includeConversations) {
+        const conversations = await this.fetchContactConversations(contact.id);
+        record.conversations = conversations;
+      }
+      records.push(record);
+    }
+    return records;
+  }
+  async fetchContacts() {
+    const res = await fetch(`${this.baseUrl}/contacts?per_page=${this.config.limit ?? 50}`, {
+      headers: {
+        Authorization: `Bearer ${this.config.accessToken}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Intercom API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.data ?? [];
+  }
+  async fetchContactConversations(contactId) {
+    const res = await fetch(
+      `${this.baseUrl}/conversations/search`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.config.accessToken}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({
+          query: {
+            field: "contact_ids",
+            operator: "=",
+            value: contactId
+          }
+        })
+      }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    const messages = [];
+    for (const conv of data.conversations ?? []) {
+      if (conv.source?.body) {
+        const text = conv.source.body.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+        if (text) messages.push(text);
+      }
+    }
+    return messages.slice(0, 10);
+  }
+};
+registerAdapter(
+  "intercom",
+  (config) => new IntercomAdapter(config)
+);
+
+// src/engine.ts
+var Dopple = class {
+  llm;
+  adapters;
+  contextStrings;
+  cachedUserData = null;
+  store;
+  traces;
+  cachedGraph = null;
+  constructor(config = {}) {
+    this.llm = createProvider(config.model, config.apiKey, config.baseUrl);
+    this.adapters = (config.adapters ?? []).map((c) => createAdapter(c));
+    this.contextStrings = config.context ?? [];
+    this.store = new DoppleStore(config.storageDir);
+    this.traces = new TraceStore(config.storageDir);
+  }
+  /**
+   * Add an adapter dynamically.
+   */
+  addAdapter(config) {
+    this.adapters.push(createAdapter(config));
+    this.cachedUserData = null;
+  }
+  /**
+   * Add freeform context.
+   */
+  addContext(context) {
+    this.contextStrings.push(context);
+  }
+  /**
+   * Fetch all user data from configured adapters.
+   */
+  async fetchData() {
+    if (this.cachedUserData) return this.cachedUserData;
+    const allRecords = [];
+    for (const adapter of this.adapters) {
+      const records = await adapter.fetch();
+      allRecords.push(...records);
+    }
+    this.cachedUserData = allRecords;
+    return allRecords;
+  }
+  /**
+   * Generate personas from context and/or data.
+   */
+  async generate(options = {}) {
+    const userData = await this.fetchData();
+    const definitions = await generatePersonas(this.llm, {
+      product: options.product,
+      count: options.count ?? 5,
+      context: [...this.contextStrings, ...options.context ?? []],
+      userData: userData.length > 0 ? userData : void 0,
+      diversityThreshold: options.diversityThreshold
+    });
+    const personas = definitions.map((d) => new Persona(d, this.llm));
+    if (options.save) {
+      await this.store.savePanel(options.save, definitions, options.product);
+    }
+    return personas;
+  }
+  /**
+   * Load a previously saved persona panel.
+   */
+  async loadPanel(nameOrId) {
+    const panel = await this.store.loadPanel(nameOrId);
+    if (!panel) return null;
+    return panel.personas.map((d) => new Persona(d, this.llm));
+  }
+  /**
+   * Discover user segments from data.
+   * Requires at least one data adapter to be configured.
+   */
+  async discover(options = {}) {
+    const userData = await this.fetchData();
+    return discoverSegments(this.llm, userData, {
+      product: options.product,
+      segmentCount: options.segmentCount
+    });
+  }
+  /**
+   * Create a survey to run against personas.
+   */
+  createSurvey(name) {
+    return new Survey(name);
+  }
+  /**
+   * Create a focus group — multiple personas discussing a topic together.
+   * Supports context injection mid-discussion.
+   *
+   * @example
+   * ```ts
+   * const group = dopple.createFocusGroup("pricing", {
+   *   topic: "Should we raise prices?",
+   *   product: "my SaaS",
+   * });
+   * group.addPersonas(personas);
+   * const round1 = await group.discuss(this.llm);
+   * group.inject("A competitor just launched a free tier");
+   * const round2 = await group.discuss(this.llm);
+   * const summary = await group.summarize(this.llm);
+   * ```
+   */
+  createFocusGroup(name, config) {
+    return new FocusGroup(name, config);
+  }
+  /**
+   * Run a focus group discussion and return the full transcript.
+   * Convenience method that creates personas, runs N rounds, and summarizes.
+   */
+  async runFocusGroup(config) {
+    const personas = config.personas ?? await this.generate({
+      product: config.product,
+      count: config.personaCount ?? 5
+    });
+    const group = new FocusGroup("focus-group", config);
+    group.addPersonas(personas);
+    const roundCount = config.rounds ?? 3;
+    const allRounds = [];
+    for (let i = 0; i < roundCount; i++) {
+      const round2 = await group.discuss(this.llm);
+      allRounds.push(round2);
+    }
+    const summary = await group.summarize(this.llm);
+    return { rounds: allRounds, summary };
+  }
+  /**
+   * Run a survey against a persona panel and save results.
+   */
+  async runSurvey(survey, personas) {
+    const result = await survey.run(personas, this.llm);
+    await this.store.saveSurvey(result);
+    return result;
+  }
+  /**
+   * Validate a persona's psychometric accuracy.
+   */
+  async validate(persona) {
+    return validatePersona(persona.definition, this.llm);
+  }
+  /**
+   * Ask all personas in a panel the same question.
+   */
+  async askPanel(personas, question) {
+    const results = await Promise.all(
+      personas.map(async (p) => {
+        const r = await p.ask(question);
+        return {
+          persona: p.name,
+          response: r.response,
+          confidence: r.confidence,
+          reasoning: r.reasoning,
+          citations: r.citations
+        };
+      })
+    );
+    return results;
+  }
+  /**
+   * Get data quality status and improvement suggestions.
+   */
+  async status() {
+    const userData = await this.fetchData();
+    const discovery = await discoverSegments(this.llm, userData, {});
+    const panels = await this.store.listPanels();
+    return {
+      adapters: this.adapters.map((a) => a.type),
+      userCount: userData.length,
+      confidence: discovery.confidence,
+      suggestions: discovery.suggestions,
+      panels
+    };
+  }
+  /**
+   * Run the insights pipeline — THE main product feature.
+   * Data in → actionable insights out.
+   * Automatically records a trace and injects calibration history.
+   */
+  async runInsights(options) {
+    const calibrationContext = await this.traces.getCalibrationContext(
+      options.product
+    );
+    const enrichedOptions = {
+      ...options,
+      context: [
+        ...options.context ?? [],
+        ...calibrationContext ? [calibrationContext] : []
+      ]
+    };
+    const report = await runInsightsPipeline(this, this.llm, enrichedOptions);
+    const { randomUUID: randomUUID6 } = await import("crypto");
+    const trace = {
+      id: randomUUID6(),
+      product: options.product,
+      type: "insight",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      input: {
+        command: "insights",
+        dataSources: report.dataQuality.sources,
+        userCount: report.dataQuality.userCount,
+        context: options.context
+      },
+      prediction: {
+        summary: report.insights.slice(0, 3).map((i) => i.title).join("; "),
+        details: {
+          insightCount: report.insights.length,
+          topInsight: report.insights[0] ?? null,
+          segmentCount: report.segments.length
+        },
+        confidence: report.insights.length > 0 ? report.insights.reduce((s, i) => s + i.confidence, 0) / report.insights.length : 0,
+        model: report.metadata.model,
+        personaCount: report.metadata.personaCount
+      },
+      outcome: null,
+      accuracy: null
+    };
+    await this.traces.save(trace).catch(() => {
+    });
+    return report;
+  }
+  /**
+   * Calibrate personas against a source of truth.
+   * Policy documents, survey data, outcome data, benchmarks — any ground truth.
+   */
+  async calibrate(personas, sources, options) {
+    return calibrate(this.llm, personas, sources, options);
+  }
+  /**
+   * Structured calibration — compare synthetic survey results against real data.
+   * Uses real math (MAE, Pearson correlation), not LLM judgment.
+   *
+   * 1. Run the same survey through Dopple personas
+   * 2. Provide real survey data with response distributions
+   * 3. Get statistical comparison: MAE per question, correlation, threshold pass/fail
+   */
+  calibrateStructured(realData, syntheticResults, options) {
+    return calibrateStructured(realData, syntheticResults, options);
+  }
+  /**
+   * Build a knowledge graph from all adapter data.
+   * Graph is cached — call clearCache() to rebuild.
+   */
+  async buildGraph(contextTexts) {
+    if (this.cachedGraph) return this.cachedGraph;
+    const userData = await this.fetchData();
+    const graph = new DoppleGraph();
+    await graph.build(this.llm, userData, contextTexts);
+    this.cachedGraph = graph;
+    return graph;
+  }
+  /**
+   * Record a real outcome for a past prediction.
+   * This closes the calibration loop — next predictions will be informed by this.
+   */
+  async recordOutcome(product, traceId, actual, source, accuracy) {
+    await this.traces.recordOutcome(product, traceId, {
+      actual,
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source
+    }, {
+      mae: accuracy?.mae,
+      directionCorrect: accuracy?.directionCorrect,
+      notes: accuracy?.notes ?? ""
+    });
+  }
+  /**
+   * Get prediction history and calibration summary for a product.
+   */
+  async getTraceHistory(product) {
+    return this.traces.getProductHistory(product);
+  }
+  /**
+   * Get the underlying LLM provider info.
+   */
+  get provider() {
+    return this.llm.providerId;
+  }
+  /**
+   * Invalidate cached data (call after adapter changes).
+   */
+  clearCache() {
+    this.cachedUserData = null;
+    this.cachedGraph = null;
+  }
+};
+
+// src/cli/format.ts
+import pc from "picocolors";
+var PERSONA_COLORS = [pc.cyan, pc.magenta, pc.green, pc.yellow, pc.blue, pc.red];
+function personaColor(name) {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = hash * 31 + name.charCodeAt(i) | 0;
+  }
+  return PERSONA_COLORS[Math.abs(hash) % PERSONA_COLORS.length];
+}
+function confidenceColor(level) {
+  switch (level) {
+    case "low":
+      return pc.red;
+    case "medium":
+      return pc.yellow;
+    case "high":
+      return pc.green;
+  }
+}
+function formatPersonaName(name) {
+  const color = personaColor(name);
+  return color(pc.bold(name));
+}
+function formatConfidence(level) {
+  const color = confidenceColor(level);
+  return color(level.toUpperCase());
+}
+function formatCitation(c) {
+  return pc.dim(`  [${c.source}] ${c.detail} (${(c.weight * 100).toFixed(0)}%)`);
+}
+function formatOcean(traits) {
+  const fmt = (label, val) => {
+    const bar = "\u2588".repeat(Math.round(val * 10));
+    const empty = "\u2591".repeat(10 - Math.round(val * 10));
+    return `${pc.dim(label)} ${pc.cyan(bar)}${pc.dim(empty)} ${val.toFixed(2)}`;
+  };
+  return [
+    fmt("O", traits.openness),
+    fmt("C", traits.conscientiousness),
+    fmt("E", traits.extraversion),
+    fmt("A", traits.agreeableness),
+    fmt("N", traits.neuroticism)
+  ].join("\n");
+}
+function progressBar(percent, width = 20) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return `${pc.green("\u2588".repeat(filled))}${pc.dim("\u2591".repeat(empty))} ${percent}%`;
+}
+function printPersonas(personas) {
+  console.log(`
+${pc.bold(`Generated ${personas.length} personas:`)}
+`);
+  for (const p of personas) {
+    const d = p.definition;
+    console.log(`  ${formatPersonaName(p.name)} ${pc.dim("\u2014")} ${p.summary()}`);
+    console.log(`    ${formatOcean(d.traits).split("\n").join("\n    ")}`);
+    console.log(`    Confidence: ${formatConfidence(d.confidence)}`);
+    console.log();
+  }
+}
+function printPanelResponse(results) {
+  for (const r of results) {
+    console.log(
+      `
+${formatPersonaName(r.persona)} ${pc.dim(`[${r.confidence}]`)}:`
+    );
+    console.log(`  ${r.response}`);
+    if (r.reasoning) {
+      console.log(`  ${pc.dim("Why:")} ${pc.dim(r.reasoning)}`);
+    }
+    for (const c of r.citations) {
+      console.log(formatCitation(c));
+    }
+  }
+  console.log();
+}
+function printDiscovery(result) {
+  console.log(
+    `
+${pc.bold(`Discovered ${result.segments.length} segments`)} from ${result.totalUsersAnalyzed} users:
+`
+  );
+  for (const seg of result.segments) {
+    const pct = progressBar(seg.percentage, 15);
+    console.log(
+      `  ${formatPersonaName(seg.name)} ${pc.dim("\u2014")} ${pct} (${seg.userCount} users)`
+    );
+    console.log(`    ${pc.dim(seg.description)}`);
+    for (const p of seg.patterns) {
+      console.log(`    ${pc.dim("\u2022")} ${p}`);
+    }
+    console.log(
+      `    Representative: ${formatPersonaName(seg.persona.name)}`
+    );
+    console.log();
+  }
+  if (result.suggestions.length > 0) {
+    console.log(`  ${pc.bold("Suggestions to improve accuracy:")}`);
+    for (const s of result.suggestions) {
+      const impact = s.impact === "high" ? pc.red(s.impact.toUpperCase()) : s.impact === "medium" ? pc.yellow(s.impact.toUpperCase()) : pc.dim(s.impact.toUpperCase());
+      console.log(`    [${impact}] ${pc.bold(s.source)}: ${s.suggestion}`);
+    }
+    console.log();
+  }
+}
+function printSurvey(result) {
+  console.log(
+    `
+${pc.bold(`Survey: "${result.surveyName}"`)} \u2014 ${result.personaCount} personas, ${result.questions.length} questions
+`
+  );
+  for (const [qName, data] of Object.entries(result.summary)) {
+    console.log(`  ${pc.bold(data.questionText)}`);
+    if (data.type === "free_text") {
+      const responses = result.responses.filter(
+        (r) => r.questionName === qName
+      );
+      for (const r of responses) {
+        console.log(
+          `    ${formatPersonaName(r.personaName)}: ${pc.dim(`"${r.answer}"`)}`
+        );
+      }
+    } else {
+      const total = Object.values(data.distribution).reduce(
+        (a, b) => a + b,
+        0
+      );
+      for (const [answer, count] of Object.entries(data.distribution)) {
+        const pct = total > 0 ? Math.round(count / total * 100) : 0;
+        const barLen = Math.round(pct / 5);
+        console.log(
+          `    ${answer.padEnd(25)} ${pc.cyan("\u2593".repeat(barLen))}${pc.dim("\u2591".repeat(20 - barLen))} ${pct}%`
+        );
+      }
+    }
+    console.log();
+  }
+}
+function printFocusGroupRound(round2) {
+  console.log(`
+${pc.bold(`Round ${round2.round}`)}`);
+  console.log(pc.dim("\u2500".repeat(50)));
+  if (round2.injectedContext) {
+    console.log(
+      `  ${pc.bgYellow(pc.black(" MODERATOR "))} ${round2.injectedContext}`
+    );
+    console.log();
+  }
+  for (const msg of round2.messages) {
+    console.log(`  ${formatPersonaName(msg.personaName)}:`);
+    console.log(`    ${msg.message}`);
+    if (msg.opinionShift) {
+      console.log(
+        `    ${pc.yellow("\u27F3 SHIFTED:")} ${pc.dim(msg.opinionShift.previousPosition)} \u2192 ${pc.bold(msg.opinionShift.newPosition)} ${pc.dim(`(convinced by ${msg.opinionShift.triggeredBy})`)}`
+      );
+    }
+    if (msg.reasoning) {
+      console.log(`    ${pc.dim(`Why: ${msg.reasoning}`)}`);
+    }
+  }
+  console.log();
+}
+function printValidation(name, report) {
+  console.log(`
+${pc.bold(`Validation Report for ${name}`)}`);
+  console.log(pc.dim("\u2550".repeat(50)));
+  const overall = report.overall.passed ? pc.green(pc.bold("PASS")) : pc.red(pc.bold("FAIL"));
+  console.log(
+    `Overall: ${overall} (${report.overall.score}/${report.overall.maxScore})`
+  );
+  for (const test of report.tests) {
+    const icon = test.passed ? pc.green("+") : pc.red("-");
+    const score = test.score >= test.maxScore * 0.7 ? pc.green(`${test.score}/${test.maxScore}`) : test.score >= test.maxScore * 0.4 ? pc.yellow(`${test.score}/${test.maxScore}`) : pc.red(`${test.score}/${test.maxScore}`);
+    console.log(`
+  [${icon}] ${pc.bold(test.testName)}: ${score}`);
+    console.log(`      ${pc.dim(test.details)}`);
+  }
+  console.log();
+}
+function printInsightReport(report) {
+  console.log(`
+${pc.bold("Dopple Insights")}`);
+  console.log(pc.dim("\u2550".repeat(60)));
+  console.log(`  Product: ${pc.bold(report.product)}`);
+  console.log(
+    `  Data: ${report.dataQuality.userCount} users from ${report.dataQuality.sources.join(", ") || "none"}`
+  );
+  console.log(
+    `  Confidence: ${formatConfidence(report.dataQuality.confidence)}`
+  );
+  if (report.graph) {
+    console.log(
+      `  Graph: ${pc.cyan(String(report.graph.nodeCount))} nodes, ${pc.cyan(String(report.graph.edgeCount))} edges`
+    );
+  }
+  console.log(
+    `  Segments: ${report.segments.length}  |  Duration: ${(report.metadata.durationMs / 1e3).toFixed(1)}s`
+  );
+  if (report.dataQuality.gaps.length > 0) {
+    console.log(`
+  ${pc.dim("Data gaps:")}`);
+    for (const g of report.dataQuality.gaps.slice(0, 3)) {
+      const impact = g.impact === "high" ? pc.red("HIGH") : g.impact === "medium" ? pc.yellow("MED") : pc.dim("LOW");
+      console.log(`    [${impact}] ${g.suggestion}`);
+    }
+  }
+  console.log(`
+${pc.bold(`${report.insights.length} Insights:`)}
+`);
+  for (let i = 0; i < report.insights.length; i++) {
+    const insight = report.insights[i];
+    const confBar = progressBar(Math.round(insight.confidence * 100), 10);
+    const impactBar = progressBar(Math.round(insight.impact * 100), 10);
+    console.log(`  ${pc.bold(`${i + 1}. ${insight.title}`)}`);
+    console.log(`     ${insight.description}`);
+    console.log(`     Confidence: ${confBar}  Impact: ${impactBar}`);
+    console.log(
+      `     Segments: ${insight.segments.map((s) => pc.cyan(s)).join(", ")}`
+    );
+    if (insight.evidence.length > 0) {
+      for (const e of insight.evidence.slice(0, 3)) {
+        console.log(
+          `     ${pc.dim(`[${e.type}] ${e.detail}`)}`
+        );
+      }
+    }
+    console.log(`     ${pc.green("\u2192")} ${pc.green(insight.recommendation)}`);
+    console.log();
+  }
+}
+function printCalibrationReport(report) {
+  console.log(`
+${pc.bold("Calibration Report")}`);
+  console.log(pc.dim("\u2550".repeat(60)));
+  const scoreColor = report.overallScore >= 0.7 ? pc.green : report.overallScore >= 0.4 ? pc.yellow : pc.red;
+  console.log(
+    `  Overall alignment: ${scoreColor(pc.bold(`${(report.overallScore * 100).toFixed(0)}%`))}  ${progressBar(Math.round(report.overallScore * 100), 15)}`
+  );
+  console.log(
+    `  Rules tested: ${report.totalRules}  |  ${pc.green(`${report.alignedCount} aligned`)}  |  ${pc.red(`${report.misalignedCount} misaligned`)}`
+  );
+  console.log(
+    `  Sources: ${report.sources.map((s) => `${s.type}:"${s.name}"`).join(", ")}`
+  );
+  console.log(
+    `  Duration: ${(report.metadata.durationMs / 1e3).toFixed(1)}s`
+  );
+  if (report.topMisalignments.length > 0) {
+    console.log(`
+${pc.bold(pc.red("Top Misalignments:"))}
+`);
+    for (const m of report.topMisalignments) {
+      const bar = progressBar(Math.round(m.score * 100), 10);
+      console.log(`  ${pc.red("\u2717")} ${pc.bold(m.rule)}`);
+      console.log(`    Score: ${bar}`);
+      console.log(`    Expected: ${pc.dim(m.expected)}`);
+      console.log(`    Got:      ${m.personaResponse}`);
+      console.log(`    Gap:      ${pc.yellow(m.gapAnalysis)}`);
+      console.log();
+    }
+  }
+  const aligned = report.results.filter((r) => r.aligned);
+  if (aligned.length > 0) {
+    console.log(`${pc.bold(pc.green("Aligned Rules:"))}`);
+    for (const r of aligned) {
+      console.log(`  ${pc.green("\u2713")} ${r.rule} ${pc.dim(`(${(r.score * 100).toFixed(0)}%)`)}`);
+    }
+    console.log();
+  }
+  if (report.recommendations.length > 0) {
+    console.log(`${pc.bold("Recommendations:")}`);
+    for (const rec of report.recommendations) {
+      console.log(`  ${pc.yellow("\u2192")} ${rec}`);
+    }
+    console.log();
+  }
+}
+function printStructuredCalibration(report) {
+  console.log(`
+${pc.bold("Structured Calibration Report")}`);
+  console.log(pc.dim("\u2550".repeat(60)));
+  console.log(`  ${pc.bold(report.name)}`);
+  const maeColor = report.overallMAE <= 0.05 ? pc.green : report.overallMAE <= 0.1 ? pc.yellow : pc.red;
+  const corrColor = report.correlation >= 0.8 ? pc.green : report.correlation >= 0.5 ? pc.yellow : pc.red;
+  console.log(
+    `  Overall MAE: ${maeColor(pc.bold(`${(report.overallMAE * 100).toFixed(1)}pp`))} ${pc.dim("(lower = better, <10pp is good)")}`
+  );
+  console.log(
+    `  Correlation: ${corrColor(pc.bold(`r=${report.correlation.toFixed(3)}`))} ${pc.dim("(higher = better, >0.8 is strong)")}`
+  );
+  console.log(
+    `  Questions within ${(report.threshold * 100).toFixed(0)}pp threshold: ${report.questionsWithinThreshold}/${report.totalQuestions}`
+  );
+  console.log(
+    `  Personas: ${report.stats.personaCount}  |  Real respondents: ${report.stats.realRespondentCount}`
+  );
+  console.log(
+    `
+  Best:   ${pc.green(report.stats.bestQuestion.name)} (${report.stats.bestQuestion.mae}pp MAE)`
+  );
+  console.log(
+    `  Worst:  ${pc.red(report.stats.worstQuestion.name)} (${report.stats.worstQuestion.mae}pp MAE)`
+  );
+  console.log(
+    `  Median: ${report.stats.medianMAE}pp MAE`
+  );
+  console.log(`
+${pc.bold("Per-Question Results:")}
+`);
+  for (const q of report.questions) {
+    const icon = q.withinThreshold ? pc.green("\u2713") : pc.red("\u2717");
+    const maeStr = q.mae <= report.threshold ? pc.green(`${(q.mae * 100).toFixed(1)}pp`) : pc.red(`${(q.mae * 100).toFixed(1)}pp`);
+    console.log(`  ${icon} ${pc.bold(q.questionName)} \u2014 ${maeStr} MAE`);
+    console.log(`    ${pc.dim(q.questionText)}`);
+    const allOpts = [
+      .../* @__PURE__ */ new Set([
+        ...Object.keys(q.realDistribution),
+        ...Object.keys(q.syntheticDistribution)
+      ])
+    ];
+    for (const opt of allOpts) {
+      const real = q.realDistribution[opt] ?? 0;
+      const synth = q.syntheticDistribution[opt] ?? 0;
+      const err = q.perOptionError[opt] ?? 0;
+      const realBar = pc.cyan("\u2593".repeat(Math.round(real / 5)));
+      const synthBar = pc.magenta("\u2593".repeat(Math.round(synth / 5)));
+      const errStr = err > 5 ? pc.yellow(`  \u0394${err.toFixed(0)}pp`) : "";
+      const label = opt.length > 30 ? opt.slice(0, 30) + "..." : opt;
+      console.log(
+        `    ${label.padEnd(33)} Real: ${realBar} ${String(real.toFixed(0)).padStart(3)}%  Synth: ${synthBar} ${String(synth.toFixed(0)).padStart(3)}%${errStr}`
+      );
+    }
+    console.log();
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("dopple").description(
+  "Synthetic user research engine. Generate grounded personas, query them, validate them."
+).version("0.1.0");
+var addGlobalOpts = (cmd) => cmd.option(
+  "--model <provider/model>",
+  'LLM model (e.g. "anthropic/claude-sonnet-4-20250514", "openai/gpt-4o", "ollama/llama3")'
+).option("--api-key <key>", "API key (or use env vars)").option("--base-url <url>", "Custom API base URL").option("--agent", "Structured JSON output for AI agents (single-line, envelope format)", false);
+function output(command, data, opts, prettyFn) {
+  if (opts.agent) {
+    const envelope = { ok: true, command, data };
+    process.stdout.write(JSON.stringify(envelope) + "\n");
+  } else if (opts.pretty && prettyFn) {
+    prettyFn();
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function buildCommandSchema(prog) {
+  return {
+    name: prog.name(),
+    version: prog.version(),
+    description: prog.description(),
+    commands: prog.commands.map((cmd) => ({
+      name: cmd.name(),
+      description: cmd.description(),
+      options: cmd.options.map((opt) => ({
+        flags: opt.flags,
+        description: opt.description,
+        required: opt.required,
+        defaultValue: opt.defaultValue
+      }))
+    }))
+  };
+}
+if (process.argv.includes("--agent") && process.argv.includes("--help")) {
+  process.on("beforeExit", () => {
+  });
+}
+addGlobalOpts(
+  program.command("generate").description("Generate personas from product context and/or data").requiredOption("--product <description>", "Product or brand description").option("-n, --count <number>", "Number of personas", "5").option("--context <text...>", "Additional context strings").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--csv <path>", "Path to CSV file with user data").option("--json-file <path>", "Path to JSON file with user data").option("--save <name>", "Save panel to .dopple/ storage").option("-o, --output <path>", "Save personas to file").option("--pretty", "Pretty-print output for humans", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const personas = await dopple.generate({
+    product: opts.product,
+    count: parseInt(opts.count, 10),
+    context: opts.context,
+    save: opts.save
+  });
+  const data = personas.map((p) => p.toJSON());
+  if (opts.output) {
+    const lines = data.map((p) => JSON.stringify(p));
+    await writeFile4(opts.output, lines.join("\n") + "\n");
+  }
+  output("generate", data, opts, () => printPersonas(personas));
+});
+addGlobalOpts(
+  program.command("discover").description("Discover user segments from your data").option("--product <description>", "Product description").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--csv <path>", "Path to CSV file").option("--json-file <path>", "Path to JSON file").option("-n, --segments <number>", "Number of segments to discover").option("-o, --output <path>", "Save results to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const result = await dopple.discover({
+    product: opts.product,
+    segmentCount: opts.segments ? parseInt(opts.segments, 10) : void 0
+  });
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(result, null, 2));
+  }
+  output("discover", result, opts, () => printDiscovery(result));
+});
+addGlobalOpts(
+  program.command("ask").description("Ask a persona or panel a question").argument("<question>", "The question to ask").option("--persona <path>", "Path to persona JSONL file or saved panel name").option("--product <description>", "Product context").option("--posthog-key <key>", "PostHog API key").option("-n, --count <number>", "Generate N personas if no file given", "5").option("--pretty", "Pretty-print output", false)
+).action(async (question, opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  let personas;
+  if (opts.persona) {
+    const fromStorage = await dopple.loadPanel(opts.persona);
+    if (fromStorage) {
+      personas = fromStorage;
+    } else {
+      const content = await readFile6(opts.persona, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+      const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+      const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+      personas = definitions.map((d) => new Persona(d, llm));
+    }
+  } else {
+    personas = await dopple.generate({
+      product: opts.product,
+      count: parseInt(opts.count, 10)
+    });
+  }
+  const results = await dopple.askPanel(personas, question);
+  output("ask", results, opts, () => printPanelResponse(results));
+});
+addGlobalOpts(
+  program.command("survey").description("Run a structured survey against personas").requiredOption("--product <description>", "Product description").option("--questions <path>", "Path to survey questions JSON file").option("--persona <path>", "Path to persona JSONL or saved panel name").option("-n, --count <number>", "Persona count if generating", "5").option("--posthog-key <key>", "PostHog API key").option("-o, --output <path>", "Save results to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  let personas;
+  if (opts.persona) {
+    const fromStorage = await dopple.loadPanel(opts.persona);
+    if (fromStorage) {
+      personas = fromStorage;
+    } else {
+      const content = await readFile6(opts.persona, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+      const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+      const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+      personas = definitions.map((d) => new Persona(d, llm));
+    }
+  } else {
+    personas = await dopple.generate({
+      product: opts.product,
+      count: parseInt(opts.count, 10)
+    });
+  }
+  let survey;
+  if (opts.questions) {
+    const qData = JSON.parse(await readFile6(opts.questions, "utf-8"));
+    survey = new Survey(qData.name ?? "survey");
+    for (const q of qData.questions) {
+      switch (q.type) {
+        case "free_text":
+          survey.freeText(q.name, q.text);
+          break;
+        case "multiple_choice":
+          survey.multipleChoice(q.name, q.text, q.options ?? []);
+          break;
+        case "likert_5":
+          survey.likert5(q.name, q.text);
+          break;
+        case "likert_7":
+          survey.likert7(q.name, q.text);
+          break;
+        case "yes_no":
+          survey.yesNo(q.name, q.text);
+          break;
+        case "numerical":
+          survey.numerical(q.name, q.text, q.min, q.max);
+          break;
+        case "ranking":
+          survey.ranking(q.name, q.text, q.options ?? []);
+          break;
+      }
+    }
+  } else {
+    survey = new Survey("quick-feedback").freeText("pain", "What's the biggest problem you face in this area?").likert5("satisfaction", "How satisfied are you with current solutions?").yesNo("switch", "Would you try a new product in this space?").numerical("budget", "What's the most you'd pay monthly for a great solution?", 0, 200);
+  }
+  const result = await dopple.runSurvey(survey, personas);
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(result, null, 2));
+  }
+  output("survey", result, opts, () => printSurvey(result));
+});
+addGlobalOpts(
+  program.command("validate").description("Run validation suite on a persona").requiredOption("--persona <path>", "Path to persona JSONL file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const content = await readFile6(opts.persona, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+  if (definitions.length === 0) {
+    console.error("No valid persona definitions found in file.");
+    process.exit(1);
+  }
+  const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+  const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+  const definition = definitions[0];
+  const persona = new Persona(definition, llm);
+  const dopple = new Dopple(buildConfig(opts));
+  const report = await dopple.validate(persona);
+  output("validate", report, opts, () => printValidation(definition.name, report));
+});
+program.command("panels").description("List saved persona panels").option("--agent", "Structured JSON output for AI agents", false).option("--pretty", "Pretty-print output", false).action(async (opts) => {
+  const dopple = new Dopple();
+  const panels = await dopple.store.listPanels();
+  output("panels", panels, opts, () => {
+    if (panels.length === 0) {
+      console.log("No saved panels. Use --save <name> with generate to save one.");
+      return;
+    }
+    console.log("\nSaved panels:\n");
+    for (const p of panels) {
+      console.log(`  ${p.name} (${p.personaCount} personas) \u2014 ${p.createdAt}`);
+      console.log(`    ID: ${p.id}`);
+    }
+    console.log();
+  });
+});
+program.command("providers").description("List supported LLM providers").option("--agent", "Structured JSON output for AI agents", false).option("--pretty", "Pretty-print output", false).action((opts) => {
+  const providers = listProviders();
+  output("providers", providers, opts, () => {
+    console.log("\nSupported providers:\n");
+    for (const p of providers) {
+      console.log(`  ${p.id} \u2014 ${p.name}${p.envVar ? ` (env: ${p.envVar})` : ""}`);
+    }
+    console.log('\nUsage: --model "provider/model-name"');
+    console.log('Example: --model "openai/gpt-4o"');
+    console.log('Example: --model "ollama/llama3"');
+    console.log();
+  });
+});
+addGlobalOpts(
+  program.command("status").description("Show data quality and improvement suggestions").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--csv <path>", "CSV file path").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const status = await dopple.status();
+  output("status", status, opts, () => {
+    console.log(`
+Dopple Status`);
+    console.log("=".repeat(40));
+    console.log(`Provider: ${dopple.provider}`);
+    console.log(`Adapters: ${status.adapters.join(", ") || "none"}`);
+    console.log(`Users: ${status.userCount}`);
+    console.log(`Confidence: ${status.confidence.toUpperCase()}`);
+    if (status.panels.length > 0) {
+      console.log(`Saved panels: ${status.panels.length}`);
+    }
+    if (status.suggestions.length > 0) {
+      console.log(`
+Suggestions to improve:`);
+      for (const s of status.suggestions) {
+        console.log(
+          `  [${s.impact.toUpperCase()}] ${s.source}: ${s.suggestion}`
+        );
+      }
+    }
+    console.log();
+  });
+});
+addGlobalOpts(
+  program.command("focus-group").description("Run a focus group discussion with multiple personas").requiredOption("--topic <topic>", "Discussion topic or question").option("--product <description>", "Product context").option("--persona <path>", "Path to persona JSONL or saved panel name").option("-n, --count <number>", "Persona count if generating", "5").option("--rounds <number>", "Number of discussion rounds", "3").option("--inject <context...>", "Context to inject between rounds").option("--context-file <path>", "JSON file mapping persona names to private context arrays").option("--posthog-key <key>", "PostHog API key").option("-o, --output <path>", "Save transcript to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  let personas;
+  if (opts.persona) {
+    const fromStorage = await dopple.loadPanel(opts.persona);
+    if (fromStorage) {
+      personas = fromStorage;
+    } else {
+      const content = await readFile6(opts.persona, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+      const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+      const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+      personas = definitions.map((d) => new Persona(d, llm));
+    }
+  } else {
+    personas = await dopple.generate({
+      product: opts.product,
+      count: parseInt(opts.count, 10)
+    });
+  }
+  let personaContext;
+  if (opts.contextFile) {
+    personaContext = JSON.parse(await readFile6(opts.contextFile, "utf-8"));
+  }
+  const group = dopple.createFocusGroup("cli-focus-group", {
+    topic: opts.topic,
+    product: opts.product,
+    maxRounds: parseInt(opts.rounds, 10) + 1,
+    personaContext
+  });
+  group.addPersonas(personas);
+  const injectContexts = opts.inject ?? [];
+  const rounds = parseInt(opts.rounds, 10);
+  for (let i = 0; i < rounds; i++) {
+    if (injectContexts[i]) {
+      group.inject(injectContexts[i]);
+    }
+    const round2 = await group.discuss(
+      // Get the LLM from engine — create a fresh provider
+      (await import("./provider-7PWDG74H.js")).createProvider(
+        opts.model,
+        opts.apiKey,
+        opts.baseUrl
+      )
+    );
+    if (opts.pretty) {
+      printFocusGroupRound(round2);
+    }
+  }
+  const summary = await group.summarize(
+    (await import("./provider-7PWDG74H.js")).createProvider(
+      opts.model,
+      opts.apiKey,
+      opts.baseUrl
+    )
+  );
+  const fullResult = {
+    topic: opts.topic,
+    product: opts.product,
+    rounds: group.getTranscript(),
+    summary
+  };
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(fullResult, null, 2));
+  }
+  output("focus-group", fullResult, opts, async () => {
+    const pc2 = (await import("picocolors")).default;
+    console.log(pc2.bold("\nFocus Group Summary"));
+    console.log(pc2.dim("\u2550".repeat(50)));
+    console.log(`
+${pc2.bold("Themes:")}`);
+    for (const t of summary.themes) console.log(`  ${pc2.cyan("\u2022")} ${t}`);
+    console.log(`
+${pc2.bold("Agreements:")}`);
+    for (const a of summary.agreements)
+      console.log(`  ${pc2.green("\u2713")} ${a}`);
+    console.log(`
+${pc2.bold("Disagreements:")}`);
+    for (const d of summary.disagreements)
+      console.log(`  ${pc2.red("\u2717")} ${d}`);
+    console.log(`
+${pc2.bold("Key Insights:")}`);
+    for (const i of summary.insights)
+      console.log(`  ${pc2.yellow("\u2192")} ${i}`);
+    console.log();
+  });
+});
+addGlobalOpts(
+  program.command("insights").description("Generate actionable product insights from your data").requiredOption("--product <description>", "Product description").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--csv <path>", "Path to CSV file").option("--json-file <path>", "Path to JSON file").option("--context <text...>", "Additional context strings").option("--graph", "Use knowledge graph for deeper analysis", false).option("-o, --output <path>", "Save report to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const report = await dopple.runInsights({
+    product: opts.product,
+    useGraph: opts.graph,
+    context: opts.context
+  });
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(report, null, 2));
+  }
+  output("insights", report, opts, () => printInsightReport(report));
+});
+addGlobalOpts(
+  program.command("review").description("Have personas review a design, messaging, landing page, or any content").argument("<content>", "URL, text, or file path to review").requiredOption(
+    "--type <type>",
+    "Content type: design, messaging, landing_page, email, ad, pricing_page, onboarding, feature"
+  ).option("--description <text>", "Additional context about what's being reviewed").option("--questions <q...>", "Specific questions to ask about the content").option("--persona <path>", "Path to persona JSONL or saved panel name").option("--product <description>", "Product context (for generating personas)").option("-n, --count <number>", "Persona count if generating", "5").option("--figma-token <token>", "Figma access token (if content is a Figma URL)").option("-o, --output <path>", "Save review to file").option("--pretty", "Pretty-print output", false)
+).action(async (content, opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  let personas;
+  if (opts.persona) {
+    const fromStorage = await dopple.loadPanel(opts.persona);
+    if (fromStorage) {
+      personas = fromStorage;
+    } else {
+      const fileContent = await readFile6(opts.persona, "utf-8");
+      const lines = fileContent.trim().split("\n").filter(Boolean);
+      const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+      const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+      const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+      personas = definitions.map((d) => new Persona(d, llm));
+    }
+  } else {
+    personas = await dopple.generate({
+      product: opts.product,
+      count: parseInt(opts.count, 10)
+    });
+  }
+  const isFigma = content.includes("figma.com") && opts.figmaToken;
+  let result;
+  if (isFigma) {
+    const match = content.match(/figma\.com\/(?:file|design)\/([^/]+)/);
+    const nodeMatch = content.match(/node-id=([^&]+)/);
+    if (!match) {
+      console.error("Invalid Figma URL");
+      process.exit(1);
+    }
+    const { reviewFigmaDesign } = await import("./figma-N554M5KW.js");
+    const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+    const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+    result = await reviewFigmaDesign(llm, personas, {
+      accessToken: opts.figmaToken,
+      fileKey: match[1],
+      nodeId: nodeMatch?.[1]?.replace("-", ":")
+    });
+  } else {
+    const { reviewContent } = await import("./review-DNYYHU2M.js");
+    const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+    const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+    result = await reviewContent(llm, personas, {
+      type: opts.type,
+      content,
+      description: opts.description,
+      questions: opts.questions
+    });
+  }
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(result, null, 2));
+  }
+  output("review", result, opts, async () => {
+    const pc2 = (await import("picocolors")).default;
+    const r = result;
+    console.log(`
+${pc2.bold(`Content Review: ${r.input.type}`)}`);
+    console.log(pc2.dim("\u2550".repeat(50)));
+    console.log(`  Sentiment: ${r.consensus.overallSentiment.toUpperCase()}`);
+    console.log(`  Would act: ${(r.consensus.wouldActRate * 100).toFixed(0)}%
+`);
+    for (const rev of r.reviews) {
+      const color = rev.wouldAct ? pc2.green : pc2.red;
+      console.log(`  ${pc2.bold(rev.personaName)} [${rev.relevance}]`);
+      console.log(`    ${rev.firstImpression}`);
+      console.log(`    Would act: ${color(rev.wouldAct ? "Yes" : "No")} \u2014 ${pc2.dim(rev.reasoning)}`);
+      for (const f of rev.feedback) console.log(`    ${pc2.dim("\u2022")} ${f}`);
+      console.log();
+    }
+    console.log(`${pc2.bold("Consensus:")}`);
+    console.log(`  ${pc2.green("Strengths:")} ${r.consensus.strengths.join(", ")}`);
+    console.log(`  ${pc2.red("Weaknesses:")} ${r.consensus.weaknesses.join(", ")}`);
+    console.log(`  ${pc2.yellow("Suggestions:")}`);
+    for (const s of r.consensus.suggestions) console.log(`    \u2192 ${s}`);
+    console.log();
+  });
+});
+addGlobalOpts(
+  program.command("calibrate").description("Calibrate personas against a source of truth (policy, survey, outcomes)").requiredOption("--source <path>", "Path to calibration source file (text, JSON, or PDF)").requiredOption(
+    "--source-type <type>",
+    "Type of source: policy, survey, outcomes, benchmarks, document"
+  ).option("--source-name <name>", "Label for the source").option("--persona <path>", "Path to persona JSONL or saved panel name").option("--product <description>", "Product context (for generating personas)").option("-n, --count <number>", "Persona count if generating", "5").option("--posthog-key <key>", "PostHog API key").option("--stripe-key <key>", "Stripe API key").option("--csv <path>", "CSV file for persona generation").option("--max-rules <number>", "Max rules to extract per source", "10").option("-o, --output <path>", "Save report to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const sourceContent = await readFile6(opts.source, "utf-8");
+  const source = {
+    type: opts.sourceType,
+    name: opts.sourceName ?? opts.source,
+    content: sourceContent
+  };
+  let personas;
+  if (opts.persona) {
+    const fromStorage = await dopple.loadPanel(opts.persona);
+    if (fromStorage) {
+      personas = fromStorage;
+    } else {
+      const content = await readFile6(opts.persona, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      const definitions = lines.map((l) => JSON.parse(l)).filter((d) => d.id && d.traits);
+      const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+      const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+      personas = definitions.map((d) => new Persona(d, llm));
+    }
+  } else {
+    personas = await dopple.generate({
+      product: opts.product,
+      count: parseInt(opts.count, 10)
+    });
+  }
+  const report = await dopple.calibrate(personas, [source], {
+    maxRulesPerSource: parseInt(opts.maxRules, 10)
+  });
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(report, null, 2));
+  }
+  output("calibrate", report, opts, () => printCalibrationReport(report));
+});
+addGlobalOpts(
+  program.command("calibrate-data").description(
+    "Compare synthetic survey results against real survey data using statistical measures (MAE, correlation)"
+  ).requiredOption(
+    "--real <path>",
+    "Path to real survey data JSON (StructuredCalibrationInput format)"
+  ).requiredOption(
+    "--synthetic <path>",
+    "Path to synthetic survey results JSON (from dopple survey -o)"
+  ).option(
+    "--threshold <number>",
+    "MAE threshold for pass/fail per question (default: 0.10 = 10pp)",
+    "0.10"
+  ).option("-o, --output <path>", "Save report to file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const realData = JSON.parse(
+    await readFile6(opts.real, "utf-8")
+  );
+  const syntheticResults = JSON.parse(
+    await readFile6(opts.synthetic, "utf-8")
+  );
+  const dopple = new Dopple();
+  const report = dopple.calibrateStructured(realData, syntheticResults, {
+    threshold: parseFloat(opts.threshold)
+  });
+  if (opts.output) {
+    await writeFile4(opts.output, JSON.stringify(report, null, 2));
+  }
+  output(
+    "calibrate-data",
+    report,
+    opts,
+    () => printStructuredCalibration(report)
+  );
+});
+addGlobalOpts(
+  program.command("query").description("Ask the knowledge graph a natural language question").argument("<question>", "The question to ask").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--stripe-key <key>", "Stripe API key").option("--csv <path>", "Path to CSV file").option("--json-file <path>", "Path to JSON file").option("--context <text...>", "Additional context strings").option("--graph-file <path>", "Load graph from saved JSONL instead of building").option("--pretty", "Pretty-print output", false)
+).action(async (question, opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  let graph;
+  if (opts.graphFile) {
+    const { DoppleGraph: DoppleGraph2 } = await import("./graph-P5GYGDF7.js");
+    graph = new DoppleGraph2();
+    await graph.load(opts.graphFile);
+  } else {
+    graph = await dopple.buildGraph(opts.context);
+  }
+  const { createProvider: createProvider2 } = await import("./provider-7PWDG74H.js");
+  const llm = createProvider2(opts.model, opts.apiKey, opts.baseUrl);
+  const result = await graph.ask(llm, question);
+  output("query", result, opts, async () => {
+    const pc2 = (await import("picocolors")).default;
+    console.log(`
+${pc2.bold("Graph Query")}`);
+    console.log(pc2.dim("\u2550".repeat(50)));
+    console.log(`  Q: ${pc2.cyan(result.question)}`);
+    console.log(`  Confidence: ${result.confidence >= 0.7 ? pc2.green(result.confidence.toFixed(2)) : result.confidence >= 0.4 ? pc2.yellow(result.confidence.toFixed(2)) : pc2.red(result.confidence.toFixed(2))}`);
+    console.log(`
+  ${result.answer}`);
+    if (result.evidence.length > 0) {
+      console.log(`
+  ${pc2.bold("Evidence:")}`);
+      for (const e of result.evidence) {
+        const rel = e.relevance >= 0.7 ? pc2.green("HIGH") : e.relevance >= 0.4 ? pc2.yellow("MED") : pc2.dim("LOW");
+        console.log(`    [${rel}] ${pc2.dim(`(${e.type})`)} ${e.label}: ${e.detail}`);
+      }
+    }
+    if (result.relatedNodes.length > 0) {
+      console.log(`
+  ${pc2.dim("Follow up on:")} ${result.relatedNodes.join(", ")}`);
+    }
+    console.log();
+  });
+});
+addGlobalOpts(
+  program.command("graph").description("Build and display a knowledge graph from your data").option("--product <description>", "Product context").option("--posthog-key <key>", "PostHog API key").option("--posthog-host <url>", "PostHog host").option("--csv <path>", "Path to CSV file").option("--json-file <path>", "Path to JSON file").option("--context <text...>", "Additional context strings").option("-o, --output <path>", "Save graph to JSONL file").option("--pretty", "Pretty-print output", false)
+).action(async (opts) => {
+  const config = buildConfig(opts);
+  const dopple = new Dopple(config);
+  const graph = await dopple.buildGraph(opts.context);
+  const raw = graph.raw;
+  const patterns = graph.patterns();
+  if (opts.output) {
+    await graph.save(opts.output);
+  }
+  const data = {
+    summary: graph.summary,
+    patterns: patterns.map((p) => ({ description: p.description, significance: p.significance })),
+    nodeCount: raw.metadata.nodeCount,
+    edgeCount: raw.metadata.edgeCount,
+    sources: raw.metadata.sources
+  };
+  output("graph", data, opts, async () => {
+    const pc2 = (await import("picocolors")).default;
+    console.log(`
+${pc2.bold("Knowledge Graph")}`);
+    console.log(pc2.dim("\u2550".repeat(50)));
+    console.log(`  Nodes: ${pc2.cyan(String(raw.metadata.nodeCount))}  Edges: ${pc2.cyan(String(raw.metadata.edgeCount))}`);
+    console.log(`  Sources: ${raw.metadata.sources.join(", ")}`);
+    if (patterns.length > 0) {
+      console.log(`
+${pc2.bold("Patterns discovered:")}`);
+      for (const p of patterns) {
+        const bar = "\u2588".repeat(Math.round(p.significance * 10));
+        console.log(`  ${pc2.yellow(bar)} ${p.description}`);
+      }
+    }
+    const typeCounts = {};
+    for (const node of raw.nodes) {
+      typeCounts[node.type] = (typeCounts[node.type] ?? 0) + 1;
+    }
+    console.log(`
+${pc2.bold("Node types:")}`);
+    for (const [type, count] of Object.entries(typeCounts).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${type.padEnd(12)} ${pc2.cyan(String(count))}`);
+    }
+    console.log();
+  });
+});
+program.command("traces").description("View prediction history and calibration accuracy per product").option("--product <name>", "Show traces for a specific product").option("--agent", "Structured JSON output", false).option("--pretty", "Pretty-print output", false).action(async (opts) => {
+  const dopple = new Dopple();
+  if (opts.product) {
+    const history = await dopple.getTraceHistory(opts.product);
+    output("traces", history, opts, async () => {
+      const pc2 = (await import("picocolors")).default;
+      const cal = history.calibrationSummary;
+      console.log(`
+${pc2.bold(`Traces: ${history.product}`)}`);
+      console.log(pc2.dim("\u2550".repeat(50)));
+      console.log(`  Predictions: ${cal.totalPredictions}`);
+      console.log(`  With outcomes: ${cal.withOutcomes}`);
+      if (cal.averageMAE !== null) {
+        const maeColor = cal.averageMAE <= 0.05 ? pc2.green : cal.averageMAE <= 0.1 ? pc2.yellow : pc2.red;
+        console.log(`  Average MAE: ${maeColor(`${(cal.averageMAE * 100).toFixed(1)}pp`)}`);
+      }
+      if (cal.directionAccuracy !== null) {
+        console.log(`  Direction accuracy: ${(cal.directionAccuracy * 100).toFixed(0)}%`);
+      }
+      console.log(`
+${pc2.bold("Recent traces:")}
+`);
+      for (const t of history.traces.slice(-10).reverse()) {
+        const hasOutcome = t.outcome ? pc2.green("\u2713") : pc2.dim("\u25CB");
+        console.log(`  ${hasOutcome} ${pc2.dim(t.timestamp.slice(0, 10))} [${t.type}] ${t.prediction.summary}`);
+        if (t.outcome) {
+          console.log(`    Actual: ${t.outcome.actual}`);
+        }
+        if (t.accuracy) {
+          console.log(`    ${pc2.dim(t.accuracy.notes)}`);
+        }
+      }
+      console.log();
+    });
+  } else {
+    const products = await dopple.traces.listProducts();
+    output("traces", products, opts, async () => {
+      const pc2 = (await import("picocolors")).default;
+      if (products.length === 0) {
+        console.log("No traces yet. Run dopple insights to start accumulating.");
+        return;
+      }
+      console.log(`
+${pc2.bold("Products with traces:")}
+`);
+      for (const p of products) {
+        const acc = p.averageAccuracy !== null ? `MAE: ${(p.averageAccuracy * 100).toFixed(1)}pp` : "uncalibrated";
+        console.log(`  ${pc2.bold(p.product)} \u2014 ${p.traceCount} traces, ${p.withOutcomes} verified (${acc})`);
+      }
+      console.log();
+    });
+  }
+});
+program.command("record-outcome").description("Record a real outcome for a past prediction (closes the calibration loop)").requiredOption("--product <name>", "Product name").requiredOption("--trace-id <id>", "Trace ID to update").requiredOption("--actual <text>", "What actually happened").option("--source <source>", "Where the outcome data came from", "manual").option("--mae <number>", "Mean Absolute Error if known").option("--direction-correct", "Was the directional prediction correct?").option("--notes <text>", "Additional notes about accuracy").option("--agent", "Structured JSON output", false).option("--pretty", "Pretty-print output", false).action(async (opts) => {
+  const dopple = new Dopple();
+  await dopple.recordOutcome(
+    opts.product,
+    opts.traceId,
+    opts.actual,
+    opts.source,
+    {
+      mae: opts.mae ? parseFloat(opts.mae) : void 0,
+      directionCorrect: opts.directionCorrect ?? void 0,
+      notes: opts.notes ?? `Outcome recorded: ${opts.actual}`
+    }
+  );
+  const data = { product: opts.product, traceId: opts.traceId, recorded: true };
+  output("record-outcome", data, opts, async () => {
+    const pc2 = (await import("picocolors")).default;
+    console.log(`
+${pc2.green("\u2713")} Outcome recorded for trace ${opts.traceId}`);
+    console.log(`  Product: ${opts.product}`);
+    console.log(`  Actual: ${opts.actual}`);
+    console.log(`  ${pc2.dim("Next predictions for this product will be informed by this outcome.")}
+`);
+  });
+});
+function buildConfig(opts) {
+  const adapters = [];
+  if (opts.posthogKey) {
+    adapters.push({
+      type: "posthog",
+      apiKey: opts.posthogKey,
+      host: opts.posthogHost ?? void 0
+    });
+  }
+  if (opts.csv) {
+    adapters.push({ type: "csv", path: opts.csv });
+  }
+  if (opts.jsonFile) {
+    adapters.push({ type: "json", path: opts.jsonFile });
+  }
+  if (opts.stripeKey) {
+    adapters.push({ type: "stripe", apiKey: opts.stripeKey });
+  }
+  if (opts.doc) {
+    const docs = Array.isArray(opts.doc) ? opts.doc : [opts.doc];
+    for (const d of docs) {
+      adapters.push({ type: "document", path: d });
+    }
+  }
+  return {
+    model: opts.model,
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl,
+    adapters
+  };
+}
+if (process.argv.includes("--agent") && process.argv.includes("--help")) {
+  const schema = buildCommandSchema(program);
+  process.stdout.write(JSON.stringify(schema) + "\n");
+  process.exit(0);
+}
+program.parse();
+//# sourceMappingURL=cli.js.map