switchboard-cli 0.1.0-alpha.1 → 0.1.0-alpha.3

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

@@ -0,0 +1,1114 @@
+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 };