switchboard-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/node_modules/@switchboard/core/src/synthesis-provider.ts

@@ -1,1114 +0,0 @@
-import type {
-  ActivationInput,
-  FollowUpQuestion,
-  InferredChip,
-  IntakeAnalysis,
-  ResearchAngle,
-  ResearchClassification,
-  RoutingResult,
-  SynthesizedSeed,
-} from "./types";
-import {
-  intakeAnalysisSchema,
-  researchClassificationSchema,
-  synthesizedSeedSchema,
-} from "./types";
-
-// ---------------------------------------------------------------------------
-// Interface — exactly 3 methods, no more.
-// ---------------------------------------------------------------------------
-
-export interface SynthesisProvider {
-  extractSeed(input: ActivationInput): SynthesizedSeed;
-  classifyResearchAngles(seed: SynthesizedSeed): ResearchClassification;
-  generateBrief(
-    input: ActivationInput,
-    seed: SynthesizedSeed,
-    route: RoutingResult,
-  ): string;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function compact(text: string) {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-function truncate(text: string, limit = 180) {
-  const c = compact(text);
-  return c.length <= limit ? c : `${c.slice(0, limit - 1).trimEnd()}…`;
-}
-
-function sentence(text: string) {
-  return (
-    text
-      .split(/[\n.!?]/)
-      .map((p) => compact(p))
-      .find(Boolean) ?? truncate(text, 120)
-  );
-}
-
-function titleCase(text: string) {
-  return text
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(" ");
-}
-
-function slugify(value: string) {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 50);
-}
-
-// ---------------------------------------------------------------------------
-// Problem / solution split
-// ---------------------------------------------------------------------------
-
-const SOLUTION_MARKERS_FOR_SPLIT = [
-  " that helps ", " that turns ", " that converts ", " that takes ",
-  " which helps ", " which turns ",
-  " it turns ", " it helps ", " it takes ", " it converts ",
-  " to help ", " designed to ", " built to ", " meant to ",
-];
-
-function splitProblemSolution(raw: string): { problem: string; solution: string } {
-  const normalized = compact(raw);
-  const lowerNorm = normalized.toLowerCase();
-
-  // Strategy 1: Find explicit pain sentences in the full text
-  // Look for "Right now..." or "The problem is..." deeper in the input
-  const sentences = raw.split(/(?<=[.!?\n])\s+/).map((s) => compact(s)).filter((s) => s.length > 15);
-  const painSentences: string[] = [];
-  const solutionSentences: string[] = [];
-
-  for (const s of sentences) {
-    const lower = s.toLowerCase();
-    const isPain =
-      /^right now\b/i.test(s) ||
-      /\bhard to\b/i.test(lower) ||
-      /\beverywhere\b/i.test(lower) ||
-      /\bforgetting\b/i.test(lower) ||
-      /\bpain\b/i.test(lower) ||
-      /\bstruggle\b/i.test(lower) ||
-      /\bmanually\b/i.test(lower) ||
-      /\bproblem isn'?t\b/i.test(lower) ||
-      /\bthe problem\b/i.test(lower) ||
-      // Feature-extension markers
-      /\bcurrently only\b/i.test(lower) ||
-      /\bcurrently supports?\b/i.test(lower) ||
-      /\bwe have a\b.*\bthat\b/i.test(lower) ||
-      /\bdoesn'?t (?:support|have|include)\b/i.test(lower) ||
-      // Narrative pain markers
-      /\bkeep getting\b/i.test(lower) ||
-      /\bover and over\b/i.test(lower) ||
-      /\binstead of\b/i.test(lower) ||
-      /\bchasing\b/i.test(lower) ||
-      /\bwasting time\b/i.test(lower) ||
-      /\bfrustrat/i.test(lower) ||
-      /\btoo much time\b/i.test(lower) ||
-      /\bkeep having to\b/i.test(lower) ||
-      /\bscattered\b/i.test(lower) ||
-      /\bno single\b/i.test(lower) ||
-      /\bno way to\b/i.test(lower);
-
-    const isSolution =
-      /\bshould\b/i.test(lower) ||
-      /\bthe product\b/i.test(lower) ||
-      /\bi think\b/i.test(lower) ||
-      /\bif i had to imagine\b/i.test(lower) ||
-      /\bthe core outcome\b/i.test(lower) ||
-      // Feature-extension solution markers
-      /\bi need to add\b/i.test(lower) ||
-      /\badd a\b/i.test(lower) ||
-      /\bthe .+ should\b/i.test(lower) ||
-      /\bpreferences?\s+should\b/i.test(lower) ||
-      // Narrative solution markers
-      /\bi want to build\b/i.test(lower) ||
-      /\bi need a tool\b/i.test(lower) ||
-      /\bi want (?:a|something)\b/i.test(lower) ||
-      /\bshould feel\b/i.test(lower) ||
-      /\bmy team gets\b/i.test(lower) ||
-      /\bclients? (?:fill|complete|submit|answer)\b/i.test(lower) ||
-      /\bsystem (?:generates?|creates?|produces?)\b/i.test(lower);
-
-    // "I want to build..." is always solution, even if it also contains pain markers
-    if (isSolution && /\bi want to build\b/i.test(lower)) {
-      solutionSentences.push(s);
-    } else if (isPain) {
-      painSentences.push(s);
-    } else if (isSolution) {
-      solutionSentences.push(s);
-    }
-  }
-
-  if (painSentences.length > 0) {
-    const problem = painSentences.slice(0, 2).join(" ");
-    const solution = solutionSentences.length > 0
-      ? solutionSentences.slice(0, 2).join(" ")
-      : extractCoreSolution(normalized);
-    return {
-      problem: truncate(problem, 300),
-      solution: truncate(solution, 300),
-    };
-  }
-
-  // Strategy 2: Structural split on "that helps/turns..." in the first sentence
-  for (const marker of SOLUTION_MARKERS_FOR_SPLIT) {
-    const idx = lowerNorm.indexOf(marker);
-    if (idx > 15) {
-      const problem = normalized.slice(0, idx).trim();
-      const solution = normalized.slice(idx).trim();
-      if (problem.length > 10 && solution.length > 10) {
-        return { problem, solution };
-      }
-    }
-  }
-
-  return { problem: normalized, solution: "Needs further shaping." };
-}
-
-function extractCoreSolution(text: string): string {
-  // Look for "The product should..." or "The core outcome..."
-  const match = text.match(
-    /(?:the product should|the core outcome[^:]*:|if i had to imagine v1[^:]*:)\s*(.{20,250})/i,
-  );
-  if (match?.[1]) return compact(match[1]);
-
-  // Look for narrative solution: "I want to build a [thing] where [flow]"
-  const narrativeMatch = text.match(
-    /i want to build\s+(.{15,250}?)(?:\.\s|$)/i,
-  );
-  if (narrativeMatch?.[1]) return compact(narrativeMatch[1]);
-
-  // Look for feature-extension: "I need to add [feature]"
-  const addMatch = text.match(
-    /i need to add\s+(.{15,250}?)(?:\.\s|$)/i,
-  );
-  if (addMatch?.[1]) return compact(addMatch[1]);
-
-  // Look for "I need a tool that..."
-  const needMatch = text.match(
-    /i need\s+(.{15,200}?)(?:\.\s|$)/i,
-  );
-  if (needMatch?.[1]) return compact(needMatch[1]);
-
-  // Look for declarative tool/feature descriptions: "A [tool/app/system] that/for..."
-  const declarativeMatch = text.match(
-    /\ba\s+(?:cli\s+)?(?:tool|app|system|feature|page|component|service|module|script)\s+(?:that|for|which)\s+(.{15,250}?)(?:\.\s|$)/i,
-  );
-  if (declarativeMatch?.[1]) return compact(declarativeMatch[1]);
-
-  // Fall back to the first sentence's solution clause
-  const solutionMatch = text.match(/(?:that helps?|that turns?|which helps?)\s+(.{20,200})/i);
-  if (solutionMatch?.[1]) return compact(solutionMatch[1]);
-
-  // Fall back: if what_do_you_want_next starts with "implement" or "build", use it
-  const implMatch = text.match(/\b(?:implement|build)\s+(.{15,200}?)(?:\.\s|$)/i);
-  if (implMatch?.[1]) return compact(implMatch[1]);
-
-  return "Needs further shaping.";
-}
-
-// ---------------------------------------------------------------------------
-// Target user extraction
-// ---------------------------------------------------------------------------
-
-const USER_PATTERNS = [
-  /\btarget\s+user(?:\s+is)?[:\s]+([^.,;!?\n]{4,80})/i,
-  /\bfor\s+([^.,;!?\n]{4,60}?)(?:\s+(?:that|who|which|shipping|building|working|using|running))/i,
-  /\btargeting\s+([^.,;!?\n]{4,60})/i,
-  /\baimed at\s+([^.,;!?\n]{4,60})/i,
-  /\bfor\s+([^.,;!?\n]{4,60})/i,
-];
-
-// Words that indicate the match is an action/purpose, not a user segment
-const NON_USER_MARKERS = [
-  "managing", "building", "creating", "making", "doing", "getting",
-  "tracking", "handling", "processing", "running", "stuff", "things",
-  "better", "faster", "easier", "more",
-];
-
-export const GENERIC_USER_FALLBACK = "Solo builders shipping software.";
-
-function extractTargetUser(raw: string): { user: string; explicit: boolean } {
-  for (const pattern of USER_PATTERNS) {
-    const match = raw.match(pattern);
-    if (match?.[1]) {
-      const candidate = compact(match[1]);
-      const candidateWords = candidate.toLowerCase().split(/\s+/);
-
-      // Reject if the first word looks like a verb/action, not a user type
-      if (candidateWords[0] && NON_USER_MARKERS.includes(candidateWords[0])) continue;
-
-      if (candidateWords.length >= 2 && candidate.length > 5) {
-        return { user: candidate, explicit: true };
-      }
-    }
-  }
-  return { user: GENERIC_USER_FALLBACK, explicit: false };
-}
-
-// ---------------------------------------------------------------------------
-// Non-goal inference
-// ---------------------------------------------------------------------------
-
-const ADJACENCY_MAP: Record<string, string> = {
-  route: "Not a general-purpose workflow engine or DAG builder.",
-  compil: "Not a code generation or transpilation tool.",
-  handoff: "Not a project management or ticketing system.",
-  return: "Not an observability or logging platform.",
-  brief: "Not a document or wiki editor.",
-  dispatch: "Not a task queue or job scheduler.",
-  autonom: "Not an autonomous agent platform or LLM gateway.",
-  chat: "Not a chat wrapper or conversational interface.",
-  deploy: "Not a CI/CD pipeline or deployment platform.",
-  team: "Not a team collaboration or communication tool.",
-  analytic: "Not an analytics dashboard or reporting tool.",
-  plugin: "Not a plugin marketplace or extension system.",
-  review: "Not a code review tool or pull request manager.",
-  pipeline: "Not a data pipeline or ETL framework.",
-  manage: "Not a generic management console or admin panel.",
-  marketplace: "Not a marketplace or commerce platform.",
-  collaborat: "Not a real-time collaboration tool.",
-};
-
-const PRODUCT_GUARDRAIL_LINE_SET = new Set<string>(Object.values(ADJACENCY_MAP));
-const GENERIC_MINIMUM_NON_GOALS = [
-  "Not a generic chat wrapper or prompt management product.",
-  "Not an autonomous agent platform.",
-] as const;
-
-/** True when a boundary line is a product-level guardrail (keyword map or generic minimum), not user-authored scope. */
-export function isProductLevelGuardrailBoundary(line: string): boolean {
-  const t = compact(line);
-  if (!t) return false;
-  if ((GENERIC_MINIMUM_NON_GOALS as readonly string[]).includes(t)) return true;
-  return PRODUCT_GUARDRAIL_LINE_SET.has(t);
-}
-
-const EXPLICIT_NON_GOAL_PATTERNS = [
-  /i do (?:NOT|not) want (?:this to become |it to be |to build )?([^.]+?)(?:\.|$)/gim,
-  /i (?:also )?do (?:NOT|not) want ([^.]+?)(?:\.|$)/gim,
-  /(?:^|\.\s+)no\s+([^.]{6,60}?)\s+in v1\b/gi,
-  /should (?:NOT|not) (?:be|become|feel) ([^.]+?)(?:\.|$)/gim,
-];
-
-function extractExplicitNonGoals(text: string): string[] {
-  const goals: string[] = [];
-  const combined = `${text}`;
-
-  for (const pattern of EXPLICIT_NON_GOAL_PATTERNS) {
-    pattern.lastIndex = 0;
-    let match: RegExpExecArray | null;
-    while ((match = pattern.exec(combined)) !== null) {
-      if (!match[1]) continue;
-      const candidate = compact(match[1]);
-      if (candidate.length > 5 && candidate.length < 120) {
-        // Normalize to "Not..." phrasing
-        const normalized = candidate.startsWith("not ")
-          ? candidate.charAt(0).toUpperCase() + candidate.slice(1)
-          : `Not ${candidate.charAt(0).toLowerCase()}${candidate.slice(1)}`;
-        // Remove trailing "in V1" if present
-        const cleaned = normalized.replace(/\s+in v1$/i, "").trim();
-        const final = cleaned.endsWith(".") ? cleaned : `${cleaned}.`;
-
-        // Deduplicate: skip if any existing goal shares 60%+ keywords
-        const finalWords = new Set(compact(final).toLowerCase().split(/\s+/).filter((w) => w.length > 3));
-        const isDupe = goals.some((existing) => {
-          const existingWords = new Set(compact(existing).toLowerCase().split(/\s+/).filter((w) => w.length > 3));
-          let overlap = 0;
-          for (const w of finalWords) { if (existingWords.has(w)) overlap++; }
-          return finalWords.size > 0 && overlap / finalWords.size >= 0.6;
-        });
-
-        if (!isDupe) {
-          goals.push(final);
-        }
-      }
-    }
-  }
-
-  return goals;
-}
-
-function inferNonGoals(raw: string, solution: string, constraints: string): string[] {
-  // Step 1: Extract explicit non-goals from user's own words
-  const explicit = extractExplicitNonGoals(`${raw}\n${constraints}`);
-
-  // Step 2: Supplement with inferred non-goals from adjacency map (only if explicit list is thin)
-  const combined = `${raw} ${solution} ${constraints}`.toLowerCase();
-  const inferred: string[] = [];
-
-  // Only add keyword guardrails when the idea has not already supplied competing boundaries.
-  if (explicit.length < 2) {
-    for (const [keyword, nonGoal] of Object.entries(ADJACENCY_MAP)) {
-      if (combined.includes(keyword) && !explicit.some((e) => e.toLowerCase().includes(keyword))) {
-        inferred.push(nonGoal);
-        if (explicit.length + inferred.length >= 5) break;
-      }
-    }
-  }
-
-  const all = [...explicit, ...inferred];
-
-  if (all.length < 2) {
-    all.push("Not a generic chat wrapper or prompt management product.");
-    all.push("Not an autonomous agent platform.");
-  }
-
-  return all.slice(0, 7);
-}
-
-// ---------------------------------------------------------------------------
-// Missing inputs detection — split into lock-blocking vs cautions
-// ---------------------------------------------------------------------------
-
-export type IntakeGapBuckets = {
-  /** Must be resolved before the record can be locked (activation blocked in UI). */
-  blocking: string[];
-  /** Important but non-blocking until lock. */
-  cautions: string[];
-  /** Combined list (blocking first) for seed confidence scoring. */
-  combined: string[];
-};
-
-function collectIntakeGaps(input: ActivationInput, seed: Partial<SynthesizedSeed>): IntakeGapBuckets {
-  const blocking: string[] = [];
-  const cautions: string[] = [];
-
-  if (!seed.target_user || seed.target_user === GENERIC_USER_FALLBACK) {
-    blocking.push("Target user is not on record — name who this is for before locking.");
-  }
-
-  if (seed.proposed_solution === "Needs further shaping.") {
-    blocking.push("No clear change or solution approach — describe what actually ships in this slice.");
-  }
-
-  if (!compact(input.constraints)) {
-    cautions.push("No extra constraints stated — add boundaries if V1 should refuse certain directions.");
-  }
-
-  if (compact(input.what_do_you_want_next).split(/\s+/).length < 4) {
-    cautions.push("First outcome is vague — tighten “what should happen first” when you can.");
-  }
-
-  const wordCount = compact(input.raw_idea).split(/\s+/).length;
-  if (wordCount < 8) {
-    blocking.push("The idea is too thin to compile — add enough detail to define the problem and slice.");
-  }
-
-  const affirmativeText = input.raw_idea
-    .replace(/I do (?:NOT|not) want[^.]*\./g, "")
-    .replace(/I (?:also )?do (?:NOT|not) want[^.]*\./g, "")
-    .replace(/I care[^.]*\./g, "");
-  const segments = affirmativeText.split(/,\s*|\band\b/i).map((s) => compact(s));
-  const capabilitySegments = segments.filter(
-    (s) => s.length > 10 && /\b(management|collaboration|review|pipeline|dashboard|marketplace|analytics|deploy|monitor|tracking|automation)\b/i.test(s),
-  );
-  if (capabilitySegments.length >= 3) {
-    cautions.push(
-      "The idea lists many features — pick one wedge capability so the record is not a wishlist.",
-    );
-  }
-
-  const combined = [...blocking, ...cautions];
-  return { blocking, cautions, combined };
-}
-
-// ---------------------------------------------------------------------------
-// Confidence scoring
-// ---------------------------------------------------------------------------
-
-function scoreConfidence(blocking: string[], cautions: string[] = []): SynthesizedSeed["confidence"] {
-  const total = blocking.length + cautions.length;
-  if (blocking.length >= 2) return "low";
-  if (blocking.length >= 1) return "medium";
-  if (total === 0) return "high";
-  if (total === 1) return "high";
-  if (total <= 2) return "medium";
-  return "low";
-}
-
-// ---------------------------------------------------------------------------
-// Title derivation (improved from original)
-// ---------------------------------------------------------------------------
-
-function deriveTitle(raw: string): string {
-  const normalized = compact(raw);
-
-  // Strategy 1: Look for "turn X into Y" — the product's core transformation
-  const transformMatch = normalized.match(
-    /(?:helps?\s+)?turn\w*\s+(.{5,40}?)\s+into\s+(.{5,40}?)(?:\.|,|\s+fast|\s+quick|$)/i,
-  );
-  if (transformMatch?.[1] && transformMatch[2]) {
-    const x = compact(transformMatch[1]).replace(/^messy\s+/i, "").replace(/[^\w\s-]/g, " ");
-    const y = compact(transformMatch[2]).replace(/^a\s+/i, "").replace(/[^\w\s-]/g, " ");
-    const combined = `${x} To ${y}`;
-    const w = combined.split(/\s+/).filter(Boolean).slice(0, 5);
-    if (w.length >= 3) return titleCase(w.join(" "));
-  }
-
-  // Strategy 1b: Look for "that helps/turns [concept]" without "into"
-  const conceptMatch = normalized.match(
-    /(?:that|which)\s+(?:helps?\s+)?(?:turn|convert|transform|ingest|cluster|compile|route|dispatch|generate|validate|manage|track|organize|build|create)\w*\s+(.{8,50}?)(?:\s+into\b|\s+from\b|\s+across\b|\.|,|$)/i,
-  );
-  if (conceptMatch?.[1]) {
-    const concept = conceptMatch[1].replace(/[^\w\s-]/g, " ").trim();
-    const w = concept.split(/\s+/).filter(Boolean).slice(0, 5);
-    if (w.length >= 2) return titleCase(w.join(" "));
-  }
-
-  // Strategy 2: Narrative-style — "I want to build a [adj] [noun] where [purpose]"
-  // Extract the purpose/action, not just the noun
-  const narrativeBuildMatch = normalized.match(
-    /(?:build|create|make)\s+(?:a\s+)?(?:\w+\s+){0,3}(?:tool|app|system|platform|product)\s+(?:where|that|so|for)\s+(.{10,60}?)(?:\s*,|\s+and\s+the|\s+the system|\.|$)/i,
-  );
-  if (narrativeBuildMatch?.[1]) {
-    const purpose = compact(narrativeBuildMatch[1])
-      .replace(/^(?:new\s+)?(?:clients?|users?|people)\s+/i, "")
-      .replace(/[^\w\s-]/g, " ");
-    const w = purpose.split(/\s+/).filter(Boolean).slice(0, 5);
-    if (w.length >= 2) return titleCase(w.join(" "));
-  }
-
-  // Strategy 2b: Look for "a [noun] for [user] that..." — declarative style
-  const nounMatch = normalized.match(
-    /\ba\s+([\w-]+(?:\s+[\w-]+){0,3})\s+(?:for|that|which)\b/i,
-  );
-  if (nounMatch?.[1]) {
-    const noun = nounMatch[1].trim();
-    const GENERIC = ["tool", "app", "thing", "product", "platform", "system"];
-    if (!GENERIC.includes(noun.toLowerCase())) {
-      return titleCase(noun);
-    }
-  }
-
-  // Strategy 3: Look for the core outcome phrase — "turn X into Y"
-  const outcomeMatch = normalized.match(
-    /turn\w*\s+(.{5,30}?)\s+into\s+(.{5,40}?)(?:\.|,|$)/i,
-  );
-  if (outcomeMatch) {
-    const w = compact(`${outcomeMatch[1]} to ${outcomeMatch[2]}`)
-      .replace(/[^\w\s-]/g, " ")
-      .split(/\s+/)
-      .filter(Boolean)
-      .slice(0, 6);
-    if (w.length >= 3) return titleCase(w.join(" "));
-  }
-
-  // Strategy 4: Fall back to stripping boilerplate and taking what's left
-  const cleaned = sentence(normalized)
-    .replace(/^(i want to build|build|create|make)\s+/i, "")
-    .replace(/^(an?\s+(?:tool|app|platform|product|system)\s+(?:for|that)\s+)/i, "")
-    .replace(/[^\w\s-]/g, " ");
-
-  const w = cleaned.split(/\s+/).filter(Boolean).slice(0, 6);
-  return titleCase(w.join(" ")) || "New Project";
-}
-
-// ---------------------------------------------------------------------------
-// V1 outcome derivation — extract from raw idea, not from operator intent
-// ---------------------------------------------------------------------------
-
-const V1_OUTCOME_PATTERNS = [
-  /the core outcome I want is[:\s]*(.{15,200})/i,
-  /if I had to imagine V1[^:]*:[:\s]*(.{15,250})/i,
-  /V1[,:]?\s*(?:should|would|could|maybe)\s+(.{15,200})/i,
-  /the real (?:win|value|outcome) (?:is|would be)[:\s]*(.{15,200})/i,
-  /I want (?:something|a product|it) (?:that|to)\s+(.{15,150})/i,
-  // Feature-extension: "I need to add [feature]"
-  /I need to add\s+(.{15,200})/i,
-  // Narrative outcome: "my team gets [good thing] instead of [bad thing]"
-  /(?:my team|we|I)\s+(?:get|gets|receive|receives)\s+(.{15,150})/i,
-  // Narrative outcome: "instead of [bad], [good]"
-  /instead of\s+.{10,60}?,\s*(.{15,150})/i,
-  // Narrative outcome: "so that [outcome]" or "so [someone] can [outcome]"
-  /so (?:that |I |we |my team )(?:can )?(.{15,150})/i,
-];
-
-function deriveV1Outcome(raw: string, solution: string): string {
-  // Strategy 1: Find explicit outcome statements in the raw idea
-  for (const pattern of V1_OUTCOME_PATTERNS) {
-    const match = raw.match(pattern);
-    if (match?.[1]) {
-      const candidate = compact(match[1]);
-      // Take up to first period or newline
-      const trimmed = candidate.split(/[.\n]/).map((p) => compact(p)).find((p) => p.length > 10);
-      if (trimmed && trimmed.length > 15) {
-        return truncate(trimmed, 220);
-      }
-    }
-  }
-
-  // Strategy 2: Use the first sentence of the proposed solution
-  if (solution && solution !== "Needs further shaping.") {
-    const firstSol = solution.split(/[.\n]/).map((p) => compact(p)).find((p) => p.length > 15);
-    if (firstSol) return truncate(firstSol, 220);
-  }
-
-  // Strategy 3: Fall back to the one-liner
-  return truncate(deriveOneLiner(raw), 220);
-}
-
-// ---------------------------------------------------------------------------
-// First build slice derivation — the product's actual first slice
-// ---------------------------------------------------------------------------
-
-function deriveFirstBuildSlice(raw: string, solution: string): string {
-  // Look for "If I had to imagine V1" sections with bullet lists
-  const v1Match = raw.match(/if I had to imagine V1[^:]*:[\s\n]*((?:[-•]\s*.+[\n]?)+)/i);
-  if (v1Match?.[1]) {
-    const bullets = v1Match[1]
-      .split("\n")
-      .map((l) => l.replace(/^[-•]\s*/, "").trim())
-      .filter((l) => l.length > 5);
-    if (bullets.length >= 2) {
-      return bullets.join(". ") + ".";
-    }
-  }
-
-  // Fall back to the core solution description
-  if (solution && solution !== "Needs further shaping.") {
-    return truncate(solution, 300);
-  }
-
-  return "Define and implement the narrowest slice that proves the core value proposition.";
-}
-
-// ---------------------------------------------------------------------------
-// Open questions extraction — preserve the user's explicit uncertainties
-// ---------------------------------------------------------------------------
-
-const UNCERTAINTY_PATTERNS = [
-  /I'?m not sure (?:yet|about|whether|if)[:\s]*\n?((?:[-•]\s*.+[\n]?)+)/i,
-  /I don'?t know (?:yet|whether|if)[:\s]*\n?((?:[-•]\s*.+[\n]?)+)/i,
-  /open questions?[:\s]*\n?((?:[-•]\s*.+[\n]?)+)/i,
-  /not sure[:\s]*\n?((?:[-•]\s*.+[\n]?)+)/i,
-];
-
-function extractOpenQuestions(raw: string): string[] {
-  for (const pattern of UNCERTAINTY_PATTERNS) {
-    const match = raw.match(pattern);
-    if (match?.[1]) {
-      const bullets = match[1]
-        .split("\n")
-        .map((l) => l.replace(/^[-•]\s*/, "").trim())
-        .filter((l) => l.length > 8);
-      if (bullets.length >= 1) {
-        return bullets.slice(0, 5);
-      }
-    }
-  }
-  return [];
-}
-
-// ---------------------------------------------------------------------------
-// One-liner derivation
-// ---------------------------------------------------------------------------
-
-function deriveOneLiner(raw: string): string {
-  const normalized = compact(raw);
-
-  // Strip "I want to build" prefix and clean up
-  const stripped = normalized
-    .replace(/^i want to build\s+/i, "")
-    .replace(/^i('?m| am) building\s+/i, "")
-    .replace(/^build\s+/i, "");
-
-  // Take the first sentence of the stripped version
-  const first = stripped.split(/[.\n!?]/).map((p) => compact(p)).find((p) => p.length > 10);
-  return truncate(first ?? stripped, 160);
-}
-
-// ---------------------------------------------------------------------------
-// Task-type detection — product idea vs implementation request
-// ---------------------------------------------------------------------------
-
-import type { TaskType } from "./types";
-
-function detectTaskType(raw: string, repoExists: boolean): TaskType {
-  const lower = compact(raw);
-
-  // Strong implementation signals
-  const implSignals = [
-    /\bwe have a\b.*\bapp\b/i,
-    /\bexisting\b.*\b(?:repo|codebase|app|project|page|component)\b/i,
-    /\bcurrently (?:only )?supports?\b/i,
-    /\bi need to add\b/i,
-    /\badd a\b.*\b(?:layout|panel|page|section|feature|endpoint|route)\b/i,
-    /\brefactor\b/i,
-    /\bmigrate\b/i,
-    /\bthe current\b.*\b(?:page|component|module|file|code)\b/i,
-    /\bsrc\/\b/i,
-    /\b\.tsx?\b/i,
-    /\bpackage\.json\b/i,
-  ];
-
-  // Strong product-idea signals
-  const productSignals = [
-    /\bi want to build a (?:tool|product|app|platform)\b/i,
-    /\bthe product should\b/i,
-    /\bif i had to imagine v1\b/i,
-    /\bthe core outcome i want\b/i,
-    /\bwho it is for\b/i,
-    /\btarget user\b/i,
-    /\bv1 promise\b/i,
-  ];
-
-  const implCount = implSignals.filter((p) => p.test(lower)).length;
-  const productCount = productSignals.filter((p) => p.test(lower)).length;
-
-  // Repo exists is a strong implementation signal — repo-bound work is implementation
-  // unless there are truly NO implementation signals AND strong product signals
-  if (repoExists && implCount >= 1) return "implementation-request";
-  if (implCount >= 2) return "implementation-request";
-
-  // Product-idea only wins when repo is NOT present, or when impl signals are zero
-  if (productCount >= 2 && !repoExists) return "product-idea";
-  if (productCount >= 2 && implCount === 0 && repoExists) return "product-idea";
-
-  // Repo tie-breaker: any impl signal with repo → implementation
-  if (repoExists && implCount > 0) return "implementation-request";
-  if (productCount > implCount) return "product-idea";
-
-  // Repo-present with no other signals defaults to implementation
-  if (repoExists) return "implementation-request";
-
-  return "unknown";
-}
-
-// ---------------------------------------------------------------------------
-// LocalSynthesisProvider
-// ---------------------------------------------------------------------------
-
-export class LocalSynthesisProvider implements SynthesisProvider {
-  extractSeed(input: ActivationInput): SynthesizedSeed {
-    let { problem, solution } = splitProblemSolution(input.raw_idea);
-
-    // If raw_idea didn't yield a solution, try what_do_you_want_next
-    if (solution === "Needs further shaping." && input.what_do_you_want_next) {
-      const fromNext = extractCoreSolution(`${input.raw_idea} ${input.what_do_you_want_next}`);
-      if (fromNext !== "Needs further shaping.") {
-        solution = fromNext;
-      }
-    }
-
-    const { user } = extractTargetUser(`${input.raw_idea} ${input.what_do_you_want_next ?? ""} ${input.constraints ?? ""}`);
-    const title = deriveTitle(input.raw_idea);
-    const nonGoals = inferNonGoals(input.raw_idea, solution, input.constraints);
-    const oneLiner = deriveOneLiner(input.raw_idea);
-    const v1Outcome = deriveV1Outcome(input.raw_idea, solution);
-    const openQuestions = extractOpenQuestions(input.raw_idea);
-    const firstBuildSlice = deriveFirstBuildSlice(input.raw_idea, solution);
-
-    const partial = {
-      title,
-      one_liner: oneLiner,
-      problem: truncate(problem, 240),
-      proposed_solution: truncate(solution, 240),
-      target_user: user,
-      v1_outcome: v1Outcome,
-      non_goals: nonGoals,
-    };
-
-    const gaps = collectIntakeGaps(input, partial);
-    const missingInputs = gaps.blocking;
-    const confidence = scoreConfidence(gaps.blocking, gaps.cautions);
-
-    const taskType = detectTaskType(input.raw_idea, input.repo_exists);
-
-    return synthesizedSeedSchema.parse({
-      ...partial,
-      missing_inputs: missingInputs,
-      open_questions: openQuestions,
-      first_build_slice: firstBuildSlice,
-      confidence,
-      task_type: taskType,
-    });
-  }
-
-  classifyResearchAngles(seed: SynthesizedSeed): ResearchClassification {
-    if (seed.confidence === "high" && seed.missing_inputs.length === 0) {
-      return researchClassificationSchema.parse({
-        angles: [],
-        research_needed: false,
-        summary: "Seed is strong enough to proceed without additional research.",
-      });
-    }
-
-    const angles: ResearchAngle[] = [];
-
-    if (seed.target_user === GENERIC_USER_FALLBACK) {
-      angles.push({
-        category: "user-validation",
-        question: "Who exactly will use this and what is their current workflow?",
-        why_it_matters: "A generic target user leads to generic solutions that serve no one well.",
-        priority: "blocking",
-      });
-    }
-
-    if (seed.proposed_solution === "Needs further shaping.") {
-      angles.push({
-        category: "technical-feasibility",
-        question: "What is the simplest technical approach that solves the core problem?",
-        why_it_matters: "Without a clear solution approach, the build brief cannot be execution-ready.",
-        priority: "blocking",
-      });
-    }
-
-    // Check for domain-specific terms that might need research
-    const domainTerms = seed.problem.match(
-      /\b(compliance|regulatory|medical|financial|legal|security|encryption|protocol)\b/i,
-    );
-    if (domainTerms) {
-      angles.push({
-        category: "domain-knowledge",
-        question: `What domain constraints apply to ${domainTerms[0].toLowerCase()} in this context?`,
-        why_it_matters: "Domain-specific requirements can fundamentally reshape the solution.",
-        priority: "strengthening",
-      });
-    }
-
-    // Check if the idea mentions patterns that could benefit from competitive research
-    const hasCompetitiveSignal = seed.missing_inputs.some(
-      (m) => m.includes("many features") || m.includes("single capability"),
-    );
-    if (hasCompetitiveSignal && angles.length < 3) {
-      angles.push({
-        category: "competitive-landscape",
-        question: "What existing tools partially solve this and where do they fall short?",
-        why_it_matters: "Understanding the landscape prevents building what already exists.",
-        priority: "strengthening",
-      });
-    }
-
-    return researchClassificationSchema.parse({
-      angles: angles.slice(0, 3),
-      research_needed: angles.length > 0,
-      summary:
-        angles.length === 0
-          ? "Seed is strong enough to proceed without additional research."
-          : `${angles.length} research angle${angles.length > 1 ? "s" : ""} identified before proceeding.`,
-    });
-  }
-
-  generateBrief(
-    input: ActivationInput,
-    seed: SynthesizedSeed,
-    route: RoutingResult,
-  ): string {
-    const constraintsLine = compact(input.constraints)
-      ? `Constraints to respect: ${truncate(input.constraints, 180)}.`
-      : "No extra constraints were supplied beyond keeping V1 narrow and coherent.";
-
-    // Combine missing inputs (structural gaps) with open questions (user's explicit uncertainties)
-    const allQuestions = [...seed.missing_inputs, ...seed.open_questions];
-    const openQuestions =
-      allQuestions.length > 0
-        ? allQuestions.map((q) => `- ${q}`).join("\n")
-        : "- None identified.";
-
-    const nonGoals = seed.non_goals.map((g) => `- ${g}`).join("\n");
-    const firstSlice = deriveFirstBuildSlice(input.raw_idea, seed.proposed_solution);
-
-    return `# SB_SPEC
-
-## What this product is
-
-${seed.one_liner}
-
-## Who it is for
-
-${seed.target_user}
-
-## The problem
-
-${seed.problem}
-
-## The proposed solution
-
-${seed.proposed_solution}
-
-## V1 promise
-
-${seed.v1_outcome}
-
-## Scope in
-
-- ${firstSlice}
-- Keep the primary artifact aligned with the current product definition.
-- Touch only files and artifacts that directly support the first build slice.
-
-## Scope out
-
-${nonGoals}
-
-## First build slice
-
-${firstSlice}
-
-${constraintsLine}
-
-## Acceptance criteria
-
-- The product seed is valid and reflects the user's actual problem, target user, and desired outcome.
-- The primary artifact is execution-ready for the first build slice.
-- The next recommended surface is explicit, deterministic, and accompanied by a return condition.
-- The first handoff can be launched as one SBX bundle.
-
-## Open questions
-
-${openQuestions}
-
-## What must not change
-
-These boundaries anchor original intent and must survive every handoff:
-${nonGoals}
-
-## Key risks / unknowns
-
-- Is the seed strong enough to drive execution without further shaping? (confidence: ${seed.confidence})
-- ${route.return_condition}
-`;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Intake analysis — infer chips + follow-ups from raw input
-// ---------------------------------------------------------------------------
-
-const BOUNDARY_PATTERNS: { pattern: RegExp; id: string; label: string }[] = [
-  { pattern: /\bno\s+billing\b/i, id: "no-billing", label: "No billing" },
-  { pattern: /\bno\s+subscriptions?\b/i, id: "no-subscriptions", label: "No subscriptions" },
-  { pattern: /\bno\s+admin\b/i, id: "no-admin", label: "No admin panel" },
-  { pattern: /\bno\s+team\b/i, id: "no-team", label: "No team features" },
-  { pattern: /\bno\s+(?:multi-?)?workspace\b/i, id: "no-workspace", label: "No multi-workspace" },
-  { pattern: /\bno\s+(?:CRM|crm)\b/i, id: "no-crm", label: "No CRM" },
-  { pattern: /\bno\s+project management\b/i, id: "no-pm", label: "No project management" },
-  { pattern: /\bpersonal\s+(?:settings|account)\s+only\b/i, id: "personal-only", label: "Personal settings only" },
-  { pattern: /\bno\s+(?:deep\s+)?(?:jira|slack|hubspot)\s+integrations?\b/i, id: "no-integrations", label: "No deep integrations" },
-  { pattern: /\bno\s+(?:client|user)\s+(?:accounts?|login)\b/i, id: "no-client-accounts", label: "No client accounts" },
-  { pattern: /\bno\s+(?:meeting\s+)?transcription\b/i, id: "no-transcription", label: "No transcription" },
-  { pattern: /\bno\s+(?:client|team)\s+permissions?\b/i, id: "no-permissions", label: "No permissions system" },
-  { pattern: /\bkeep\s+(?:it\s+)?(?:simple|lightweight|minimal)\b/i, id: "keep-simple", label: "Keep it simple" },
-  { pattern: /\bmanual\s+curation\b/i, id: "manual-curation", label: "Manual curation in the loop" },
-  { pattern: /\bpreserve\s+(?:user\s+)?(?:voice|language)\b/i, id: "preserve-voice", label: "Preserve user voice" },
-  { pattern: /\bnot\s+(?:a\s+)?(?:giant\s+)?enterprise\b|\bno\s+enterprise\b/i, id: "no-enterprise", label: "No enterprise features" },
-  { pattern: /\bno(?:t want)?\s+(?:a\s+)?(?:generic\s+)?dashboard\b/i, id: "no-dashboard", label: "No generic dashboard" },
-  { pattern: /\bno\s+analytics\b/i, id: "no-analytics", label: "No analytics" },
-  { pattern: /\bsingle.?page\b/i, id: "single-page", label: "Single-page app" },
-];
-
-const SYSTEM_PATTERNS: { pattern: RegExp; id: string; label: string }[] = [
-  { pattern: /\bsupabase\b/i, id: "supabase", label: "Supabase" },
-  { pattern: /\bauth\s+context\b|\bexisting\s+auth\b/i, id: "auth-context", label: "Auth context" },
-  { pattern: /\bnew\s+\w+(?:_\w+)*\s+table\b|\bnew\s+(?:table|schema)\b/i, id: "new-db-table", label: "New database table" },
-  { pattern: /\bexisting\s+(?:\w+\s+)?table\b/i, id: "existing-db", label: "Existing database" },
-  { pattern: /\bavatar\s+upload\b|\bfile\s+upload\b|\bimage\s+upload\b/i, id: "upload", label: "File/image upload" },
-  { pattern: /\bAPI\s+route\b|\bendpoint\b/i, id: "api-route", label: "API route" },
-  { pattern: /\b\/\w+\b.*page\b|\bpage\s+at\s+\//i, id: "ui-page", label: "UI page/route" },
-  { pattern: /\bserver\s+(?:actions?|components?)\b/i, id: "server-actions", label: "Server actions" },
-  { pattern: /\bmiddleware\b/i, id: "middleware", label: "Middleware" },
-  { pattern: /\bnotion\b/i, id: "notion", label: "Notion" },
-  { pattern: /\bCSV\b/i, id: "csv", label: "CSV import/export" },
-  { pattern: /\bNext\.?js\b/i, id: "nextjs", label: "Next.js" },
-  { pattern: /\btailwind\b/i, id: "tailwind", label: "Tailwind CSS" },
-  { pattern: /\bclaude\b|\bai\s+(?:api|call|prompt)\b|\bllm\b/i, id: "ai-api", label: "AI/LLM API" },
-];
-
-const SOURCE_PATTERNS: { pattern: RegExp; id: string; label: string }[] = [
-  { pattern: /\bcall\s+(?:notes?|transcripts?)\b/i, id: "call-notes", label: "Call notes" },
-  { pattern: /\bsupport\s+tickets?\b/i, id: "tickets", label: "Support tickets" },
-  { pattern: /\bscreenshots?\b/i, id: "screenshots", label: "Screenshots" },
-  { pattern: /\bvoice\s+(?:notes?|memos?)\b/i, id: "voice-notes", label: "Voice notes" },
-  { pattern: /\bnotion\s+docs?\b/i, id: "notion-docs", label: "Notion docs" },
-  { pattern: /\bslack\s+messages?\b/i, id: "slack-msgs", label: "Slack messages" },
-  { pattern: /\bexisting\s+(?:code|repo)\b/i, id: "existing-code", label: "Existing codebase" },
-  { pattern: /\bfigma\b/i, id: "figma", label: "Figma designs" },
-  { pattern: /\bbrief\b|\bPRD\b|\bspec\b/i, id: "brief", label: "Existing brief/spec" },
-];
-
-function inferChips(raw: string, constraints: string): InferredChip[] {
-  const combined = `${raw}\n${constraints}`;
-  const chips: InferredChip[] = [];
-
-  for (const { pattern, id, label } of BOUNDARY_PATTERNS) {
-    if (pattern.test(combined)) {
-      chips.push({ id, label, category: "boundary", selected: true, inferred_from: pattern.source });
-    }
-  }
-
-  for (const { pattern, id, label } of SYSTEM_PATTERNS) {
-    if (pattern.test(combined)) {
-      chips.push({ id, label, category: "system", selected: true, inferred_from: pattern.source });
-    }
-  }
-
-  for (const { pattern, id, label } of SOURCE_PATTERNS) {
-    if (pattern.test(combined)) {
-      chips.push({ id, label, category: "source", selected: true, inferred_from: pattern.source });
-    }
-  }
-
-  return chips;
-}
-
-function inferFollowUps(
-  seed: SynthesizedSeed,
-  chips: InferredChip[],
-): FollowUpQuestion[] {
-  const questions: FollowUpQuestion[] = [];
-
-  // Budget: 0 for high confidence, 1 for medium, 1-2 for low
-  const budget = seed.confidence === "high" ? 0 : seed.confidence === "medium" ? 1 : 2;
-  if (budget === 0) return [];
-
-  // Check for new DB table without confirmation
-  const hasNewTable = chips.some((c) => c.id === "new-db-table");
-  const hasUpload = chips.some((c) => c.id === "upload");
-
-  if (hasNewTable && seed.confidence !== "high" && questions.length < budget) {
-    questions.push({
-      question: "Should creating the new database table be part of this scope?",
-      why: "Database changes affect migration and deployment.",
-      options: ["Yes, include migration", "No, assume table exists", "Not sure yet"],
-    });
-  }
-
-  if (hasUpload && seed.confidence !== "high" && questions.length < budget) {
-    questions.push({
-      question: "Should file upload use existing storage infrastructure?",
-      why: "Storage setup affects scope and complexity.",
-      options: ["Yes, reuse existing", "No, needs new setup", "Not sure yet"],
-    });
-  }
-
-  // Generic fallback for low confidence
-  if (seed.confidence === "low" && questions.length === 0 && budget > 0) {
-    if (seed.task_type === "implementation-request") {
-      questions.push({
-        question: "What is the single most important thing this change should accomplish?",
-        why: "Helps Switchboard choose the right scope and execution boundaries.",
-      });
-    } else {
-      questions.push({
-        question: "Who will use this first — and what will they do in the first session?",
-        why: "Helps Switchboard determine the right V1 slice.",
-      });
-    }
-  }
-
-  return questions.slice(0, budget);
-}
-
-function normRough(s: string): string {
-  return compact(s)
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function isSubstantiveDuplicate(candidate: string, refs: string[]): boolean {
-  const c = normRough(candidate);
-  if (c.length < 16) return false;
-  for (const r of refs) {
-    const br = normRough(r);
-    if (!br) continue;
-    if (c === br) return true;
-    if (c.length >= 28 && br.length >= 28 && (c.includes(br) || br.includes(c))) return true;
-  }
-  return false;
-}
-
-/** Drop preview fields that repeat the same substantive text as direction / problem / one-liner. */
-function buildDistinctActivationPreview(seed: SynthesizedSeed): IntakeAnalysis["activation_preview"] {
-  const problem = seed.problem;
-  const proposed_solution = seed.proposed_solution;
-  let v1_outcome = seed.v1_outcome;
-  let first_build_slice = seed.first_build_slice;
-
-  const refsForV1 = [proposed_solution, problem, seed.one_liner];
-  if (isSubstantiveDuplicate(v1_outcome, refsForV1)) {
-    v1_outcome = "";
-  }
-
-  const refsForSlice = [proposed_solution, v1_outcome || seed.v1_outcome, problem, seed.one_liner];
-  if (isSubstantiveDuplicate(first_build_slice, refsForSlice)) {
-    first_build_slice = "";
-  }
-
-  return {
-    title: seed.title,
-    one_liner: seed.one_liner,
-    problem,
-    proposed_solution,
-    target_user: seed.target_user,
-    v1_outcome,
-    non_goals: seed.non_goals,
-    first_build_slice,
-    open_questions: seed.open_questions,
-    missing_inputs: [],
-    confidence: seed.confidence,
-    task_type: seed.task_type,
-  };
-}
-
-export function analyzeIntake(
-  rawIdea: string,
-  constraints: string,
-  repoExists: boolean,
-  whatDoYouWantNext: string = "",
-  operatorTargetUser?: string,
-): IntakeAnalysis {
-  const taskType = detectTaskType(rawIdea, repoExists);
-  const chips = inferChips(rawIdea, constraints);
-
-  const provider = new LocalSynthesisProvider();
-  const activationInput: ActivationInput = {
-    raw_idea: rawIdea,
-    repo_exists: repoExists,
-    what_do_you_want_next: whatDoYouWantNext.trim() || "—",
-    constraints,
-  };
-  const seed = provider.extractSeed(activationInput);
-
-  const targetMeta = operatorTargetUser?.trim()
-    ? { user: operatorTargetUser.trim(), explicit: true }
-    : extractTargetUser(rawIdea);
-  const gaps = collectIntakeGaps(activationInput, seed);
-
-  const followUps = inferFollowUps(seed, chips);
-
-  const blocked = gaps.blocking.length > 0;
-  const confidenceNote = blocked
-    ? "Lock blocked — the draft record is missing required fields."
-    : seed.confidence === "high"
-      ? "Minimum lock criteria met — review the charter, then write the opening record."
-      : seed.confidence === "medium"
-        ? "Shaped enough to lock if you accept the cautions below."
-        : "Thin signal — cautions and open items are explicit; lock only if you accept the risk.";
-
-  const activation_preview = buildDistinctActivationPreview(seed);
-
-  return intakeAnalysisSchema.parse({
-    task_type: taskType,
-    chips,
-    follow_ups: followUps,
-    confidence_note: confidenceNote,
-    activation_preview,
-    target_user_on_record: targetMeta.explicit,
-    activation_state: blocked ? "blocked_by_missing_evidence" : "ready_to_lock",
-    lock_blocking_requirements: gaps.blocking,
-    lock_cautions: gaps.cautions,
-    lock_tracked_open: seed.open_questions,
-  });
-}
-
-export { slugify };