CognitiveHire -- Divergent Rail Execution Plan

CognitiveHire -- Divergent Rail Execution Plan

> Generated: 2026-03-27
> Protocol: Divergent Rail (EW-governed parallel execution)
> Project: `[home]/Desktop/cognitive-hire/`
> North Star: Mohamed Diomande -- 112K+ AI turns, KARL adapter, RAG++ 332K rows

---

Architecture Overview

                    Supabase (aaqbofotpchgpyuohmmz)
                    141 tables | 112K+ turns | 332K embedded rows
                           |
         +-----------------+-----------------+
         |                 |                 |
  claude_prompts    claude_sessions   claude_assistant_turns
  claude_tool_calls claude_file_diffs claude_daily_summaries
         |                 |                 |
         +--------+--------+--------+--------+
                  |                  |
          Extraction Pipeline    RAG++ :8000
          (normalize + strip)    (vector search)
                  |                  |
          Cognitive Graph        KARL Adapter
          (per-user metrics)     (twin responses)
                  |                  |
         +--------+------------------+--------+
         |                 |                  |
  Personal Dashboard   Twin Interface   Grand Diomande
  (proof of concept)   (hiring chat)    (sales demo)

---

Data Sources (Verified)

---

Phase 1: Foundation -- Data Extraction + Metric Prototyping

> Gate: Raw cognitive metrics computed for Mohamed. At least 3 metric types producing non-trivial output from real data. Dashboard skeleton renders locally.
> EW Check: Invariant 1 (Minimum Entropy). Risk: metrics produce flat/meaningless output from real data. Corrective: swap metric algorithm, not data source.

Critical: Cognitive Metric Extraction

Build Python scripts that query Supabase directly and compute 6 cognitive metrics from Mohamed's real data.

Directory: `Desktop/cognitive-hire/extraction/metrics/`

Metrics to implement:

1. Divergence Rate (`divergence_rate.py`)
- Definition: How often the user's prompt topic changes vs. stays in the same domain within a session
- Source: `claude_prompts.cwd` + `claude_prompts.git_repo` + `claude_prompts.tags` grouped by `session_id`
- Algorithm: For each session, compute topic transitions / total prompts. Cluster by `cwd` or `git_repo` for domain. High divergence = context-switching mind, low = deep-focus mind.
- Output: `{session_id, divergence_score, transitions[], domains_touched}`

2. Thought Diet (`thought_diet.py`)
- Definition: Distribution of what the user thinks about, weighted by time and depth
- Source: `claude_prompts.tags` + `claude_prompts.intent_classification` + `claude_prompts.total_tokens` + `claude_daily_summaries.projects`
- Algorithm: Aggregate all prompts by intent/tag, weight by token count (proxy for depth). Produce a pie/treemap of cognitive allocation.
- Output: `{category, weight_pct, total_tokens, prompt_count, avg_complexity}`

3. Depth of Death (`depth_of_death.py`)
- Definition: At what point does the user give up on a thread? Where do conversation chains terminate?
- Source: `claude_prompts.turn_count` + `claude_assistant_turns.turn_index` per session
- Algorithm: For each session, find the max turn depth. Plot distribution. Sessions that end at turn 1-2 = shallow. Sessions that go 20+ = deep dives. The "death" point is where the user stops engaging.
- Output: `{session_id, max_depth, terminal_topic, depth_histogram[]}`

4. Prompt Entropy (`prompt_entropy.py`)
- Definition: Information-theoretic measure of prompt unpredictability
- Source: `claude_prompts.prompt_text` + `claude_prompts.prompt_text_length`
- Algorithm: Shannon entropy of token distribution across prompts. Compare user's entropy to a baseline (uniform). High entropy = diverse vocabulary/thinking. Also compute temporal entropy (how entropy changes over weeks).
- Output: `{period, entropy_score, baseline_entropy, vocabulary_richness, temporal_trend[]}`

5. Cadence Fingerprint (`cadence_fingerprint.py`)
- Definition: When and how the user works. Temporal signature.
- Source: `claude_prompts.prompt_received_at` + `claude_sessions.started_at` + `claude_daily_summaries`
- Algorithm: Heatmap of activity by hour-of-day x day-of-week. Session duration distribution. Burst detection (rapid prompt sequences vs. gaps). Sleep cycle inference.
- Output: `{heatmap[24][7], burst_pattern, avg_session_gap_minutes, peak_hours[], circadian_type}`

6. Recovery Topology (`recovery_topology.py`)
- Definition: How the user recovers from failures. Error response patterns.
- Source: `claude_tool_calls.success` (where success=false) + subsequent prompts + `claude_file_diffs` (rollbacks)
- Algorithm: Find failed tool calls. Track what happens next: immediate retry, different approach, escalation, abandon. Build a state machine of recovery strategies.
- Output: `{failure_type, recovery_strategy, avg_recovery_time_ms, success_after_recovery_pct}`

Pre-Conditions:

# Verify Supabase connectivity
python3 -c "
import os, urllib.request, json
url = 'https://aaqbofotpchgpyuohmmz.supabase.co/rest/v1/claude_prompts?select=count&limit=1'
headers = {
    'apikey': os.environ.get('SUPABASE_ANON_KEY', ''),
    'Authorization': f\"Bearer {os.environ.get('SUPABASE_ANON_KEY', '')}\",
    'Prefer': 'count=exact'
}
req = urllib.request.Request(url, headers=headers)
resp = urllib.request.urlopen(req)
print(f'Status: {resp.status}, Count header: {resp.headers.get(\"content-range\")}')"

# Verify directories exist
mkdir -p Desktop/cognitive-hire/extraction/metrics
mkdir -p Desktop/cognitive-hire/data/processed

Shared utilities (`extraction/metrics/supabase_client.py`):

# Thin client wrapping urllib.request for Supabase REST API
# - paginated_fetch(table, select, filters, order, limit)
# - Uses SUPABASE_URL + SUPABASE_ANON_KEY from env
# - Handles pagination via Range headers (1000 rows per page)
# - Returns generator of dicts

Deliverables:
- `extraction/metrics/supabase_client.py` -- shared Supabase REST client
- `extraction/metrics/{divergence_rate,thought_diet,depth_of_death,prompt_entropy,cadence_fingerprint,recovery_topology}.py`
- `data/processed/mohamed_metrics.json` -- computed metrics for Mohamed (JSON, ~1-5MB)
- Each script runnable standalone: `python3 divergence_rate.py --output ../../../data/processed/`

Invariant Risks: Inv 1 -- if Supabase data is sparser than expected (e.g., tags are mostly null), metrics will be flat. Corrective: fall back to prompt_text NLP (spaCy or simple regex) for classification.

---

Track A: Dashboard Scaffold

Directory: `Desktop/cognitive-hire/dashboard/`

Tech stack:
- Next.js 16 (matches granddiomande.com stack, React 19)
- Tailwind v4
- D3.js for custom visualizations (topology, entropy, cadence heatmap)
- Recharts for standard charts (thought diet treemap, depth histogram)
- No auth in Phase 1 -- static data rendering only

Scaffold:

cd Desktop/cognitive-hire/dashboard
npx create-next-app@latest . --typescript --tailwind --app --no-src-dir --import-alias "@/*"
npm install d3 @types/d3 recharts

Page structure:

dashboard/
  app/
    layout.tsx          -- dark theme, custom font (Space Grotesk + JetBrains Mono)
    page.tsx            -- landing: summary cards + mini-charts
    globals.css         -- CSS variables, grain overlay, mesh gradient bg
    metrics/
      divergence/page.tsx
      thought-diet/page.tsx
      depth/page.tsx
      entropy/page.tsx
      cadence/page.tsx
      recovery/page.tsx
    api/
      metrics/route.ts  -- serves data/processed/*.json (Phase 1: static file read)
  components/
    CognitiveCard.tsx   -- metric summary card with sparkline
    HeatmapGrid.tsx     -- D3 hour x day heatmap (cadence)
    TopologyGraph.tsx    -- D3 force-directed recovery topology
    DepthHistogram.tsx  -- Recharts histogram
    ThoughtDietTree.tsx -- Recharts treemap
    EntropyTimeline.tsx -- D3 temporal entropy line
    DivergenceFlow.tsx  -- D3 Sankey or alluvial diagram
  lib/
    metrics.ts          -- fetch + transform metric JSON
    theme.ts            -- design tokens

Design direction (per CLAUDE.md anti-slop rules):
- Font: Space Grotesk (headings) + JetBrains Mono (data) via Google Fonts
- Palette: Deep navy (#0a0e1a) base, electric cyan (#00f0ff) accent, warm amber (#ff9f1c) secondary
- Background: layered noise texture + subtle gradient mesh
- Layout: asymmetric grid, metric cards with generous negative space, overlap elements
- Motion: staggered reveal on page load (CSS @keyframes), D3 transitions on data changes

Deliverables:
- Working Next.js app at `dashboard/` that renders placeholder data
- 6 visualization components (can use mock data until Critical track delivers real data)
- `npm run dev` serves locally on :3000

---

Track B: Export Parsers

Directory: `Desktop/cognitive-hire/extraction/pipeline/`

ChatGPT parser (`chatgpt_parser.py`):
- Input: ChatGPT export ZIP (Settings > Data Controls > Export Data)
- ZIP contains `conversations.json` with structure: `[{title, create_time, mapping: {uuid: {message: {content, author, create_time}}}}]`
- Extract: prompt text, response text, timestamps, conversation depth, model used
- Output: normalized `{turns: [{role, content, timestamp, tokens_est}], metadata: {source: "chatgpt", ...}}`

Gemini parser (`gemini_parser.py`):
- Input: Google Takeout > Gemini Apps (JSON or HTML)
- Extract: conversation turns, timestamps, attachments
- Output: same normalized format

Claude parser (`claude_parser.py`):
- Input: Direct from Supabase `claude_prompts` + `claude_assistant_turns`
- This is the primary path for Mohamed's data
- Output: same normalized format, but enriched with tool calls, diffs, git context

Privacy layer (`privacy_strip.py`):
- Strip emails, phone numbers, API keys, file paths, IP addresses
- Regex-based + spaCy NER for names/orgs (optional, heavy)
- Retain: cognitive structure (topic transitions, depth, timing, tool patterns)
- Configurable: `--strip-level minimal|moderate|aggressive`
- `minimal`: emails, keys, phone numbers only
- `moderate`: + names, org names, specific file paths
- `aggressive`: + all proper nouns, all paths, all URLs

Normalized output format (`cognitive_graph.py`):

CognitiveGraph = {
    "user_id": str,          # anonymized hash
    "source": str,           # "chatgpt" | "claude" | "gemini"
    "period": {"start": iso, "end": iso},
    "sessions": [{
        "id": str,
        "turns": [{"role": str, "content_hash": str, "timestamp": iso, "tokens_est": int}],
        "depth": int,
        "topic_tags": [str],
        "tool_usage": {"tool_name": count},
        "duration_ms": int
    }],
    "metrics": {}  # computed by Phase 1 Critical scripts
}

Deliverables:
- `extraction/pipeline/chatgpt_parser.py`
- `extraction/pipeline/gemini_parser.py`
- `extraction/pipeline/claude_parser.py`
- `extraction/pipeline/privacy_strip.py`
- `extraction/pipeline/cognitive_graph.py` -- normalized output builder
- Unit tests: `extraction/pipeline/test_parsers.py` (mock data for each format)

---

Track C: Content -- "Today vs Tomorrow" Script

Directory: `Desktop/cognitive-hire/content/scripts/`

Deliverable: `today_vs_tomorrow_v1.md` -- 90-second video script

Concept: Split-screen. Left: "Today" (resume, interview, whiteboard). Right: "Tomorrow" (cognitive twin, real interaction data, pattern analysis). The script should land the thesis: your AI interaction history IS your resume.

Structure:
1. Cold open (5s): Two hiring managers. One reads a resume. One talks to a cognitive twin.
2. Problem (15s): Resumes are performance. Interviews are performance. Neither shows how someone actually thinks.
3. Insight (15s): But every day, millions of people show exactly how they think -- to AI. Their prompts, their follow-ups, their recovery from errors, their depth on hard problems.
4. Product (30s): CognitiveHire captures this. Not what you say you can do. What your thinking patterns prove you do.
5. Demo flash (15s): Quick cuts of the dashboard -- cadence heatmap, divergence flow, depth chart, thought diet.
6. Close (10s): "Your prompts are your portfolio. CognitiveHire reads them."

Deliverables:
- `content/scripts/today_vs_tomorrow_v1.md`
- `content/scripts/shot_list.md` -- camera/screen recording shot list for the demo cuts

---

Phase 1 Invariant Verification:

Inv 1 (Entropy):    len(deliverables) > 0? YES if any metric script produces output.
                    Corrective: if Supabase tags are null, use prompt_text regex for classification.
Inv 2 (Bounded):    4 tracks <= 4. PASS.
Inv 3 (Forcing):    If Critical (metrics) stalls on Supabase schema, Track B (parsers)
                    can provide local JSONL data as fallback. Cross-layer coupling present.
Inv 4 (No absorb):  If dashboard scaffold fails (npm/Next.js), fallback to static HTML + CDN D3.
                    If Supabase is unreachable, use local prompt-logs JSONL (3.4GB).
                    2+ viable paths exist for every track.

---

Phase 2: Core Integration -- Dashboard Alive + Twin Prototype

> Gate: Dashboard renders real Mohamed data with all 6 metrics. Twin interface responds to at least one question using RAG++ retrieval. Deploy dashboard to Vercel (preview URL).
> EW Check: Invariant 3 (Cross-Layer Forcing). Risk: dashboard and twin evolve independently without sharing the cognitive graph format. Corrective: lock the CognitiveGraph schema in Phase 1, both consume it.

Critical: Dashboard Data Integration + Vercel Deploy

Actions:

1. Replace mock data in dashboard with real metric JSON
- `dashboard/app/api/metrics/route.ts` reads from `data/processed/mohamed_metrics.json`
- Each visualization component consumes its metric slice
- Add loading states and error boundaries

2. Polish visualizations with real data
- Tune D3 scales, color ranges, and layouts to actual data distributions
- Cadence heatmap: ensure hour x day grid maps correctly to Mohamed's timezone
- Entropy timeline: set axis bounds from actual entropy range
- Recovery topology: adjust force simulation parameters for real node count

3. Deploy to Vercel

   cd Desktop/cognitive-hire/dashboard
   npx vercel --prod

• Configure: `NEXT_PUBLIC_DATA_MODE=static` (no live Supabase queries in Phase 2)
• Custom domain: `cognitivehire.com` or subdomain of `granddiomande.com`

Deliverables:
- Dashboard live on Vercel with real Mohamed data
- All 6 metric pages rendering correctly
- Landing page with summary cards showing headline numbers
- Mobile-responsive (container queries or media queries)

---

Track A: Twin Interface MVP

Directory: `Desktop/cognitive-hire/twin-interface/`

Tech: Next.js app (can be same repo as dashboard, or separate -- same repo preferred for shared types)

Architecture:

twin-interface/
  ui/
    ChatPanel.tsx       -- conversation UI (user messages + twin responses)
    ProvenancePanel.tsx -- sidebar showing source interactions that informed response
    TopologyAnchor.tsx  -- mini cognitive topology map (always visible)
  api/
    chat/route.ts       -- POST handler, calls RAG++ then LLM

Chat flow:
1. Hiring manager types question: "How does Mohamed handle debugging complex systems?"
2. Backend calls RAG++ at `:8000/api/rag/search` with the question
3. RAG++ returns top-K relevant memory_turns (with embeddings, similarity scores)
4. Build prompt: system message (you are Mohamed's cognitive twin) + retrieved context + question
5. Call Claude API (or local MLX on Mac5) to generate response
6. Response includes provenance: which real interactions informed this answer (IDs, timestamps, similarity scores)

Provenance panel:
- For each twin response, show the source interactions that contributed
- Display: timestamp, project context, snippet of the original prompt, similarity score
- Clicking a source expands the full interaction context
- Visual: highlighted segments in the response linked to source interactions

RAG++ integration:

# RAG++ API (running on Mac1 :8000)
# POST /api/rag/search
# Body: {"query": "...", "top_k": 10, "source_type": "claude"}
# Returns: [{"content": "...", "similarity": 0.65, "metadata": {...}}]

KARL integration (stretch for Phase 2, required by Phase 3):
- KARL adapter provides skill-weighted responses
- Config at `[home-path]` shows embedding via RAG++ :8000
- 72 skill-labeled trajectories across 11 domains = the twin's "expertise map"

Deliverables:
- Chat page at `/twin` route (or separate app)
- Working RAG++ retrieval with real data
- Basic provenance panel (shows source interaction IDs + similarity scores)
- Cognitive topology mini-map placeholder

---

Track B: Cognitive Graph Builder (Heavy Compute)

Machine: Mac4 (Ollama available for local LLM classification)

Purpose: Take raw Supabase data + export parser output and build the full cognitive graph JSON.

Steps:
1. Pull all claude_prompts (112K+) via Supabase REST API with pagination
2. Run all 6 metric scripts against the full dataset (not just samples)
3. Use Ollama on Mac4 for batch intent classification if `intent_classification` column is sparse

   # Mac4 has Ollama running
   # Use qwen2.5:7b for classification (fast, good enough)
   curl http://localhost:11434/api/generate -d '{
     "model": "qwen2.5:7b",
     "prompt": "Classify this AI prompt intent into one of: debugging, architecture, deployment, writing, research, data-analysis, automation, learning, creative. Prompt: ...",
     "stream": false
   }'

4. Build the complete CognitiveGraph JSON for Mohamed
5. rsync result back to Mac1

Transfer:

# Mac4 -> Mac1
rsync -avz --checksum mac4:[home-path] \
  Desktop/cognitive-hire/data/processed/

Deliverables:
- `data/processed/mohamed_cognitive_graph.json` -- complete cognitive graph
- `data/processed/mohamed_intent_classified.json` -- LLM-classified intents for sparse data
- `extraction/metrics/batch_runner.py` -- runs all 6 metrics in sequence with progress bars

---

Track C: LinkedIn Series Drafts

Directory: `Desktop/cognitive-hire/content/tracks/linkedin/`

3 posts (following CLAUDE.md writing voice rules -- no AI-isms, casual, direct):

1. "Your prompts are your portfolio" (`post_1_prompts_portfolio.md`)
- Thesis: Every prompt you write reveals how you think. Not what you claim to know, but how you actually approach problems.
- Hook: "I have 112,000 conversations with AI. That's not a flex. That's a cognitive fingerprint."
- CTA: Interest form / waitlist

2. "Input > Output" (`post_2_input_over_output.md`)
- Thesis: The questions you ask matter more than the answers you produce. Traditional hiring optimizes for output. CognitiveHire optimizes for input.
- Hook: "A resume tells me what you built. Your prompts tell me how you think."
- CTA: Link to dashboard demo

3. "The interview is dead" (`post_3_interview_dead.md`)
- Thesis: Behavioral interviews measure performance under stress, not competence. AI interaction history measures competence under real conditions.
- Hook: "What if the best interview already happened? Every day. With your AI."
- CTA: Link to twin demo

Deliverables:
- 3 LinkedIn post drafts (800-1200 words each)
- Each with a visual concept note for accompanying image/graphic

---

Phase 2 Invariant Verification:

Inv 1 (Entropy):    Dashboard must render real data, not mock. Twin must return real RAG results.
                    If either shows only placeholder, phase is not complete.
Inv 3 (Forcing):    Dashboard (Critical) and Twin (Track A) share CognitiveGraph format.
                    If dashboard discovers data shape issues, twin must adapt immediately.
                    If twin's RAG queries reveal metric gaps, Critical must fix them.
Inv 4 (No absorb):  If Vercel deploy fails, serve from Mac1 :3000 via Tailscale.
                    If RAG++ is down, twin falls back to KARL trajectories only.

---

Phase 3: Polish -- Public Demo + Multi-Source + Sales

> Gate: Public URL with working dashboard + working twin. At least 2 data sources supported (Claude + ChatGPT). Grand Diomande integration live.
> EW Check: Invariant 2 (Bounded Divergence). Risk: scope creep into features not needed for launch. Cap at: dashboard, twin, 2 parsers, sales page. Nothing else.

Critical: Production Hardening

Actions:
1. Error boundaries on every visualization component
2. Loading skeletons (not spinners -- animated placeholders matching layout)
3. Mobile responsive: stack cards vertically, heatmap scrollable, twin chat fullscreen
4. Performance: lazy-load D3 visualizations, split metric pages into dynamic imports
5. SEO: OpenGraph meta tags, structured data, `cognitivehire.com` canonical
6. Analytics: Vercel Analytics or Plausible (no Google Analytics)

Deliverables:
- Zero JavaScript errors in production
- Lighthouse score > 90 on all pages
- Mobile layout tested on iPhone SE through iPad Pro

---

Track A: Multi-Source Testing

Actions:
1. Get a real ChatGPT export (Mohamed's own, or generate test data)
2. Run `chatgpt_parser.py` on real export
3. Run `privacy_strip.py` on output
4. Compute cognitive metrics on ChatGPT data
5. Display both Claude and ChatGPT data in dashboard (source selector/filter)

Deliverables:
- ChatGPT parser validated against real export data
- Dashboard supports source filtering (Claude / ChatGPT / All)
- Side-by-side comparison view: "How does the same person think differently with Claude vs ChatGPT?"

---

Track B: Grand Diomande Integration

Existing site: `Desktop/granddiomande.com/` (Next.js 16, Tailwind v4, Vercel)

Actions:
1. Add `/intelligence` page (directory already exists: `src/app/intelligence/`)
2. Embed cognitive dashboard as iframe or shared components
3. Add "See My Cognitive Profile" CTA on homepage
4. Create consulting pitch deck content:
- "Hire the mind, not the resume" positioning
- Pricing: $X per cognitive assessment
- Case study: Mohamed's own profile as proof

Deliverables:
- `granddiomande.com/intelligence` page live
- Twin demo accessible from Grand Diomande site
- Pitch content in `content/tracks/sales/pitch_deck.md`

---

Track C: Twin Interface Polish

Actions:
1. Provenance panel: clickable source interactions with full context expansion
2. Cognitive topology mini-map: D3 force-directed graph showing:
- Nodes = skill domains (from KARL's 11 domains)
- Edges = cross-domain connections (prompts that span domains)
- Node size = prompt volume in that domain
- Current conversation topic highlighted
3. Response quality: ensure twin responses cite specific interactions, not generic summaries
4. Typing indicator, streaming responses (if using Claude API)

Deliverables:
- Provenance panel with click-to-expand source interactions
- Cognitive topology visualization in twin sidebar
- Streaming response support

---

Phase 3 Invariant Verification:

Inv 2 (Bounded):    4 tracks. No new tracks added. If Twin polish (Track C) spawns sub-work
                    (e.g., "we need a whole graph database"), it does NOT become a new track.
                    It either fits in Track C's scope or defers to Phase 4.
Inv 3 (Forcing):    If ChatGPT parser (Track A) reveals the normalized format needs changes,
                    Dashboard (Critical) and Twin (Track C) must adapt in-phase. No deferral.
Inv 4 (No absorb):  If granddiomande.com deploy breaks, demo from cognitivehire.com directly.
                    If ChatGPT export format has changed, skip ChatGPT and ship with Claude-only.

---

Phase 4: Launch -- Content, Outreach, Case Study

> Gate: CognitiveHire is publicly demo-able. Mohamed can show it in a sales call. Content published. Case study written.
> EW Check: Invariant 4 (No Absorbing States). The launch is not the end. Plan must include post-launch iteration path.

Critical: Case Study

File: `Desktop/cognitive-hire/content/tracks/sales/case_study_mohamed.md`

Structure:
1. Who: Mohamed Diomande, AI architect, 112K+ interaction turns
2. Data: Claude prompts (primary), multi-machine distributed development
3. Cognitive profile: the 6 metrics with actual numbers and visualizations
4. What it reveals: deep systems thinker, high divergence (11 domains), fast recovery topology, night-owl cadence, heavy tool usage
5. Hiring signal: "If you saw this profile without a name attached, would you hire this person?"
6. Screenshots of dashboard + twin conversation

---

Track A: Technical Blog

File: `Desktop/cognitive-hire/content/tracks/blog/cognitive_metrics_technical.md`

Audience: Technical hiring managers, AI engineers
Content: How the 6 metrics work, what they measure, why prompt data is a better signal than interviews, the extraction pipeline architecture

---

Track B: Demo Walkthrough Script

File: `Desktop/cognitive-hire/content/scripts/demo_walkthrough.md`

Format: Screen recording script with voiceover notes
- Walk through dashboard metrics
- Show twin conversation
- Show provenance (how twin's answer traces back to real interactions)
- 3-5 minutes total

---

Track C: Waitlist + Automation

Machine: cloud-vm

Actions:
1. Simple waitlist form (Supabase table `cognitive_hire_waitlist`)
2. Prefect flow: when new ChatGPT export uploaded, run parser -> privacy strip -> metric extraction -> graph build
3. Email notification on completion (or Telegram via existing infra)

Deliverables:
- `cognitive_hire_waitlist` table in Supabase
- Prefect flow `cognitive-hire-ingest` registered
- Upload endpoint (Supabase storage bucket + edge function trigger)

---

Phase 4 Invariant Verification:

Inv 1 (Entropy):    Case study must include real numbers, not placeholders.
                    Blog must include real code snippets, not pseudocode.
Inv 4 (No absorb):  Post-launch path defined:
                    - Path A: Onboard 5 beta users (collect ChatGPT exports, build their profiles)
                    - Path B: Add Gemini parser, expand to 3 sources
                    - Path C: Build employer-side dashboard (view multiple candidate profiles)
                    Launch is NOT the final state.

---

Plan Metadata

Total Phases:           4
Total Tracks:           16 (4 critical + 12 divergent)
Machines:               Mac1 (primary), Mac4 (compute), cloud-vm (automation)
Mac5:                   Reserved for KARL fine-tuning if twin needs adapter updates

Estimated Wall Time:
  Phase 1:  3-4 days (metrics + scaffold are independent)
  Phase 2:  3-4 days (data integration + twin MVP)
  Phase 3:  2-3 days (polish + multi-source)
  Phase 4:  2-3 days (content + automation)
  Total:    10-14 days

Invariant Configuration:
  epsilon:                0.01 (min progress per phase)
  max_divergence:         4 (max tracks per phase)
  stall_threshold:        2 (phases without progress before forcing)
  min_viable_transitions: 2 (next-phase options per gate)

---

Compact Notation

P1[C:metric_extraction | A:dashboard_scaffold | B:export_parsers | C:video_script] -> GATE(3+ metrics computed, dashboard renders)
P2[C:dashboard_data_deploy | A:twin_interface_mvp | B:cognitive_graph_build | C:linkedin_drafts] -> GATE(vercel live, twin responds, graph complete)
P3[C:production_hardening | A:multi_source_test | B:granddiomande_integration | C:twin_polish] -> GATE(public URL, 2 sources, sales ready)
P4[C:case_study | A:technical_blog | B:demo_video_script | C:waitlist_automation] -> GATE(launch ready, post-launch paths defined)

---

Machine Assignment Summary

---

Key Dependencies (Verified)

---

Post-Launch Evolution Paths (Invariant 4 Compliance)

Path A -- User Onboarding: Accept ChatGPT exports, process automatically, build comparative analytics across users.

Path B -- Source Expansion: Gemini parser, Cursor/Copilot parser, IDE telemetry ingestion.

Path C -- Employer Dashboard: Multi-candidate view, role-fit scoring, team composition analysis.

Path D -- API: Cognitive metrics as a service. Third-party integrations. Webhook on profile update.

None of these paths are in scope for the 4-phase plan. They exist to satisfy Invariant 4: the launch is not an absorbing state.