feat(persona-quiz): branching decision tree + sub-personas, reveal fidelity

The v2 quiz branched only twice per path, so ~91% of answers couldn't
change the revealed persona and the questionnaire read as repetitive. Each
domain is now a depth-3 decision tree (a branch in ~every phase) resolving
to one of 8 sub-personas (32 total); paths drop from ~15 templated
questions to 8 high-signal ones. The reveal now tracks the user's answers,
seeds tags from the persona's keyTags, raises tagConfidenceFloor to 2, and
backfills with domain-aware tags instead of generic javascript/webdev.

The graph + archetypes are emitted and validated by generatePersonaQuiz.mjs
(no dead pointers, all reachable, >=4 branch points/path, no repeated
concept on a path, tags constrained to the system vocabulary), with a jest
gate over the committed artifact.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: davidercruz

packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/FunnelPersonaQuiz.spec.tsx

@@ -168,7 +168,9 @@ const parameters: FunnelStepPersonaQuiz['parameters'] = {
       name: 'Frontend Dev',
       headline: 'TypeScript frontend dev',
       description: 'Heavy TS + React feed coming up.',
-      keyTags: ['react', 'typescript', 'tailwind'],
+      // `design-systems` isn't produced by any answer below — it can only end
+      // up in the final tags if the archetype's keyTags seed the list.
+      keyTags: ['design-systems', 'react', 'typescript', 'tailwind'],
     },
     {
       id: 'backend_dev',
@@ -260,6 +262,26 @@ describe('FunnelPersonaQuiz', () => {
     });
   });
 
+  it('seeds the final tag list with the resolved archetype keyTags', async () => {
+    const { onTransition } = renderStep();
+    fireEvent.click(await screen.findByText('Frontend'));
+    fireEvent.click(await screen.findByText('Yes'));
+    expect(
+      await screen.findByText('TypeScript frontend dev'),
+    ).toBeInTheDocument();
+    fireEvent.click(screen.getByText('Looks good'));
+    await waitFor(() => {
+      expect(onTransition).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: FunnelStepTransitionType.Complete,
+          details: expect.objectContaining({
+            tags: expect.arrayContaining(['design-systems']),
+          }),
+        }),
+      );
+    });
+  });
+
   it('falls back to a tag-based headline when no archetype is resolved', async () => {
     renderStep({
       parameters: {

packages/shared/src/features/onboarding/steps/FunnelPersonaQuiz/index.tsx

@@ -140,9 +140,21 @@ function FunnelPersonaQuizComponent({
         archetypes.find((a) => a.id === terminalQuestion?.archetypeId) ?? null;
       setRevealArchetype(archetype);
 
+      // Backfill with tags relevant to the chosen domain (the opener answer)
+      // rather than a generic list, falling back to the generic one.
+      const domainAnswer = committedAnswers[0]?.optionId;
+      const fallback =
+        (domainAnswer && selection.fallbackTagsByDomain?.[domainAnswer]) ||
+        selection.fallbackTags ||
+        [];
+
+      // Seed the persona's canonical tags first so the reveal headline and the
+      // followed tags stay coherent, then the user's strongest answer-derived
+      // tags, then domain backfill. Cap at the target.
       const merged = dedupePreserveOrder([
+        ...(archetype?.keyTags ?? []).slice(0, 4),
         ...accumulatedTags,
-        ...(selection.fallbackTags ?? []),
+        ...fallback,
       ]).slice(0, selection.targetTotalTags);
 
       // Most tags are already followed (we stream them incrementally above);
@@ -163,6 +175,7 @@ function FunnelPersonaQuizComponent({
       accumulatedTags,
       selection.targetTotalTags,
       selection.fallbackTags,
+      selection.fallbackTagsByDomain,
       enrichmentComplete,
       followTags,
       refetchPreview,

packages/shared/src/features/onboarding/types/funnel.ts

@@ -418,7 +418,14 @@ export interface FunnelStepPersonaQuizParameters {
     maxQuestions: number;
     targetTotalTags: number;
     tagConfidenceFloor: number;
+    /** Generic backfill used when no domain-specific list applies. */
     fallbackTags?: string[];
+    /**
+     * Domain-specific backfill keyed by the Q1 (opener) option id. Preferred
+     * over `fallbackTags` so a sparse result is topped up with tags relevant
+     * to the user's chosen domain rather than generic ones.
+     */
+    fallbackTagsByDomain?: Record<string, string[]>;
   };
   /**
    * Finite set of persona archetypes the quiz can resolve to. The user's path