feat: initial commit - core multi-agent compiler engine and frontend UI

.gitignore

@@ -0,0 +1,42 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Environments & Secret credentials
+.env
+.env.local
+.env*.local
+backend/.env
+frontend/.env
+
+# Local database files
+*.db
+*.sqlite
+*.sqlite3
+*.sqlite-journal
+backend/db/local_brain.db
+
+# Node dependencies & Next.js cache
+node_modules/
+.next/
+out/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# Unit test & Coverage reports
+.pytest_cache/
+.coverage
+htmlcov/
+.cache/
+
+# User data sources (ignore uploaded dynamic sources, keep demo ones if needed)
+# For the hackathon, we keep the static demo rivanly-inc files, but ignore other companies if uploaded
+data/sources/*/
+!data/sources/rivanly-inc/

CLAUDE.md

@@ -0,0 +1,444 @@
+# Company Brain — CLAUDE.md
+## Project context for AI coding assistants
+
+---
+
+## What This Project Is
+
+Company Brain is a multi-agent compilation pipeline that extracts operational decision knowledge from company data sources (Slack, Notion SOPs, support tickets) and compiles it into a versioned, evidence-linked, executable skills file. A downstream brain agent uses this skills file to handle operational scenarios correctly — acting like the company's best employee.
+
+**The core thesis:** Agents are compilers, not assistants. We don't search raw documents. We compile tribal knowledge into structured, executable logic once. Then we read the compiled output forever.
+
+---
+
+## Monorepo Structure
+
+```
+company-brain/
+├── backend/              ← FastAPI + LangGraph pipeline (Python)
+│   ├── main.py           ← FastAPI app entry point
+│   ├── graph/
+│   │   ├── state.py      ← BrainState TypedDict
+│   │   ├── nodes/        ← one file per LangGraph node
+│   │   │   ├── ingest_slack.py
+│   │   │   ├── ingest_notion.py
+│   │   │   ├── ingest_tickets.py
+│   │   │   ├── ingest_join.py
+│   │   │   ├── extract_decisions.py
+│   │   │   ├── extract_workflows.py
+│   │   │   ├── extract_exceptions.py
+│   │   │   ├── detect_contradictions.py
+│   │   │   ├── synthesize_skills.py
+│   │   │   ├── link_evidence.py
+│   │   │   ├── score_confidence.py
+│   │   │   └── write_brain.py
+│   │   └── graph.py      ← graph assembly + compile
+│   ├── agents/
+│   │   └── brain_agent.py ← query-time brain agent
+│   ├── db/
+│   │   └── supabase.py   ← Supabase client + queries
+│   ├── models/
+│   │   └── schemas.py    ← Pydantic models for API
+│   └── requirements.txt
+├── frontend/             ← Next.js 14 + Tailwind (Harshit)
+├── data/
+│   └── sources/          ← 8 synthetic source files
+│       ├── notion_refund_sop.md
+│       ├── notion_pricing_policy.md
+│       ├── notion_eng_runbook.md
+│       ├── notion_hr_playbook.md
+│       ├── notion_cs_playbook.md
+│       ├── slack_export_support.json
+│       ├── slack_export_ops.json
+│       └── zendesk_tickets.json
+└── CLAUDE.md             ← this file
+```
+
+---
+
+## Tech Stack
+
+| Layer | Technology |
+|---|---|
+| LLM inference | vLLM serving `RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic` on AMD MI300X, port 8000 |
+| LLM client | `openai` Python SDK pointed at `http://localhost:8000/v1` |
+| Agent orchestration | `langgraph` with async nodes + `Send` API for parallel fan-out |
+| State checkpointing | `MemorySaver` (in-memory for v0) |
+| Embedding (skill matching) | `sentence-transformers` `all-MiniLM-L6-v2` in-memory, CPU |
+| Web framework | `FastAPI` with `uvicorn` |
+| Real-time streaming | FastAPI `StreamingResponse` with `text/event-stream` |
+| Database | Supabase (Postgres) via `supabase-py` |
+| File storage | Supabase Storage |
+
+---
+
+## LLM Client Setup
+
+```python
+from openai import AsyncOpenAI
+
+llm = AsyncOpenAI(
+    base_url="http://localhost:8000/v1",
+    api_key="not-needed"
+)
+
+# All LLM calls use this pattern:
+response = await llm.chat.completions.create(
+    model="RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic",
+    messages=[
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_content}
+    ],
+    temperature=0.1,
+    max_tokens=4096
+)
+result = response.choices[0].message.content
+```
+
+**Never use `openai.OpenAI()` — always use `AsyncOpenAI`. All nodes are async.**
+
+---
+
+## BrainState — The Central Data Structure
+
+```python
+from typing import TypedDict, Annotated
+import operator
+
+class BrainState(TypedDict):
+    company_id: str
+    source_files: list[dict]          # [{filename, content, sha256, type}]
+    
+    # Ingestion outputs (parallel, accumulated with operator.add)
+    normalized_events: Annotated[list[dict], operator.add]    # from Slack
+    structured_sops: Annotated[list[dict], operator.add]      # from Notion
+    resolved_cases: Annotated[list[dict], operator.add]       # from tickets
+    
+    # Extraction outputs (parallel, accumulated with operator.add)
+    raw_decisions: Annotated[list[dict], operator.add]
+    workflow_steps: Annotated[list[dict], operator.add]
+    exception_rules: Annotated[list[dict], operator.add]
+    contradictions: Annotated[list[dict], operator.add]
+    
+    # Compilation outputs (sequential)
+    draft_skills: list[dict]
+    skills_with_evidence: list[dict]
+    final_skills: list[dict]
+    
+    # Metadata
+    job_id: str
+    brain_version: str
+    errors: Annotated[list[str], operator.add]
+```
+
+**The `Annotated[list, operator.add]` pattern is critical.** It allows multiple parallel nodes to write to the same list field without overwriting each other. Do not change this.
+
+---
+
+## LangGraph Architecture — Fan-Out Pattern
+
+```python
+from langgraph.graph import StateGraph
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.types import Send
+
+def route_to_ingestion(state: BrainState) -> list[Send]:
+    """Fan out to 3 parallel ingestion nodes based on source file types."""
+    sends = []
+    for file in state["source_files"]:
+        if file["type"] == "slack_json":
+            sends.append(Send("ingest_slack", {"source_files": [file], ...}))
+        elif file["type"] == "notion_md":
+            sends.append(Send("ingest_notion", {"source_files": [file], ...}))
+        elif file["type"] == "tickets_json":
+            sends.append(Send("ingest_tickets", {"source_files": [file], ...}))
+    return sends
+
+def route_to_extraction(state: BrainState) -> list[Send]:
+    """Fan out to 4 parallel extraction nodes after ingestion join."""
+    return [
+        Send("extract_decisions", state),
+        Send("extract_workflows", state),
+        Send("extract_exceptions", state),
+        Send("detect_contradictions", state),
+    ]
+
+# Graph assembly:
+# START → route_to_ingestion (conditional) → [ingest_slack, ingest_notion, ingest_tickets]
+#       → ingest_join (barrier, waits for all) → route_to_extraction (conditional)
+#       → [extract_decisions, extract_workflows, extract_exceptions, detect_contradictions]
+#       → synthesize_skills → link_evidence → score_confidence → write_brain → END
+```
+
+**Never use `graph.add_edge("extractor", "synthesize_skills")` for parallel nodes — this causes synthesize_skills to fire multiple times. Always use the `Send` API + barrier join node.**
+
+---
+
+## Extraction Prompt Pattern
+
+Every extraction node uses this prompt structure:
+
+```python
+SYSTEM = """You are a policy analyst. Your ONLY job is to extract {type} from company communications.
+Output ONLY a JSON array. No preamble. No explanation. No markdown.
+Each item must have exactly these fields: {schema}
+If you find nothing, output: []
+Example output: {example}"""
+
+USER = """Extract all {type} from this company data:
+{content}"""
+```
+
+- Temperature: always `0.1`
+- Max tokens: `4096`
+- Always wrap LLM call in try/except — on JSON parse failure, retry once with stricter prompt, then return `[]`
+
+---
+
+## Skills File Schema (per skill)
+
+```python
+{
+    "id": "handle_refund_request",          # snake_case
+    "name": "Handle Refund Request",         # human readable
+    "domain": "support",                     # support|revenue|product_eng|customer_success|hr|finance_ops
+    "version": "1.0",
+    "confidence": 0.91,                      # 0.0 - 1.0
+    "stale": False,
+    "review_required": False,                # True if confidence < 0.6
+    "last_updated": "2026-05-04T09:30:00Z",
+    "trigger": {
+        "phrases": ["refund", "money back"],
+        "conditions": ["customer mentions payment dissatisfaction"]
+    },
+    "decision_logic": [
+        {
+            "condition": "plan == 'annual' AND days_since_purchase <= 14",
+            "action": "approve_full_refund",
+            "note": "No-questions policy within 14 days.",
+            "evidence_sources": [
+                {
+                    "source": "notion_refund_sop.md",
+                    "excerpt": "Annual plan customers within 14 days...",
+                    "confidence": 0.95
+                }
+            ]
+        }
+    ],
+    "forbidden_actions": [
+        "Never process refunds for lifetime deal accounts"
+    ],
+    "escalation_chain": ["support_agent", "support_lead", "account_manager", "founder"],
+    "sla": "respond_within_2h, resolve_within_24h"
+}
+```
+
+---
+
+## Confidence Scoring Formula
+
+```python
+def score_confidence(skill: dict, all_sources: list[dict]) -> float:
+    base = 0.5
+    
+    # More sources = higher confidence
+    source_count = len(skill["decision_logic"][0].get("evidence_sources", []))
+    if source_count >= 3:
+        base += 0.25
+    elif source_count == 2:
+        base += 0.15
+    elif source_count == 1:
+        base += 0.05
+    
+    # Recent sources = higher confidence
+    # (check source file last_modified if available)
+    base += 0.15  # assume recent for v0
+    
+    # No contradictions for this skill = higher confidence
+    # (passed in from contradiction detector)
+    has_contradiction = False  # check contradictions list
+    if not has_contradiction:
+        base += 0.10
+    
+    return min(base, 1.0)
+```
+
+---
+
+## Brain Agent Pattern
+
+```python
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+# Load once at startup
+embedder = SentenceTransformer('all-MiniLM-L6-v2')
+
+# Pre-compute skill embeddings (call after compile)
+skill_embeddings = {}  # {skill_id: np.array}
+
+def compute_skill_embeddings(skills: list[dict]):
+    global skill_embeddings
+    for skill in skills:
+        text = f"{skill['name']} {' '.join(skill['trigger']['phrases'])}"
+        skill_embeddings[skill['id']] = embedder.encode(text)
+
+def match_skill(query: str) -> tuple[str, float]:
+    query_emb = embedder.encode(query)
+    scores = {}
+    for skill_id, emb in skill_embeddings.items():
+        score = float(np.dot(query_emb, emb) / 
+                     (np.linalg.norm(query_emb) * np.linalg.norm(emb)))
+        scores[skill_id] = score
+    best_id = max(scores, key=scores.get)
+    return best_id, scores[best_id]
+
+def skill_to_markdown(skill: dict) -> str:
+    """Convert skill JSON to markdown for prompt injection."""
+    lines = [f"## {skill['name']}", ""]
+    for logic in skill['decision_logic']:
+        lines.append(f"- IF {logic['condition']}: {logic['action']}")
+        if logic.get('note'):
+            lines.append(f"  Note: {logic['note']}")
+    lines.append("")
+    lines.append("FORBIDDEN: " + "; ".join(skill['forbidden_actions']))
+    lines.append("ESCALATE: " + " → ".join(skill['escalation_chain']))
+    return "\n".join(lines)
+```
+
+---
+
+## FastAPI SSE Pattern
+
+```python
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+import asyncio
+import json
+
+async def event_generator(job_id: str):
+    """Yields SSE events during compilation."""
+    async for event in compilation_events[job_id]:
+        yield f"event: {event['type']}\ndata: {json.dumps(event['data'])}\n\n"
+
+@app.get("/compile/stream")
+async def stream_compile(job_id: str):
+    return StreamingResponse(
+        event_generator(job_id),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Access-Control-Allow-Origin": "*"  # CORS for frontend
+        }
+    )
+```
+
+---
+
+## Supabase Tables
+
+```sql
+-- Run these in Supabase SQL editor before starting
+
+CREATE TABLE companies (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now()
+);
+
+INSERT INTO companies VALUES ('rivanly-inc', 'Rivanly Inc.', now());
+
+CREATE TABLE skills_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  version TEXT NOT NULL,
+  brain_json JSONB NOT NULL,
+  source_hashes JSONB NOT NULL,
+  compiled_at TIMESTAMPTZ DEFAULT now(),
+  is_current BOOLEAN DEFAULT false
+);
+
+CREATE UNIQUE INDEX idx_one_current_per_company 
+  ON skills_files(company_id) WHERE is_current = true;
+
+CREATE TABLE compile_runs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  status TEXT CHECK (status IN ('started','running','complete','error')),
+  started_at TIMESTAMPTZ DEFAULT now(),
+  completed_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  result_version TEXT,
+  error_detail TEXT
+);
+
+CREATE TABLE source_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  filename TEXT NOT NULL,
+  sha256 TEXT NOT NULL,
+  content TEXT NOT NULL,
+  source_type TEXT CHECK (source_type IN ('slack_json','notion_md','tickets_json')),
+  uploaded_at TIMESTAMPTZ DEFAULT now()
+);
+```
+
+---
+
+## Environment Variables
+
+```bash
+# backend/.env
+VLLM_BASE_URL=http://localhost:8000/v1
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_KEY=your_supabase_anon_key
+COMPANY_ID=rivanly-inc
+```
+
+---
+
+## API Endpoints — Full List
+
+```
+POST /compile              → trigger pipeline, returns {job_id, stream_url}
+GET  /compile/stream       → SSE stream for job_id
+GET  /brain/status         → current brain version + stats
+GET  /skills               → all skills (lightweight)
+GET  /skills/{id}          → full skill detail
+POST /agent/handle         → brain agent query
+GET  /diff/{v1}/{v2}       → version diff
+POST /sources/upload       → upload source files
+```
+
+---
+
+## Critical Rules — Do Not Violate
+
+1. **All LangGraph nodes must be `async def`** — sync nodes break parallelism
+2. **Use `Send` API for fan-out, never direct edges between parallel nodes and their join**
+3. **Never read raw source files at query time** — brain agent reads skills file only
+4. **All LLM calls wrapped in try/except** — retry once on JSON parse failure, return `[]` if still failing
+5. **`skills_files.is_current` enforced by partial unique index** — only one current per company
+6. **`compile_runs` table is append-only** — never update rows, only insert
+7. **CORS headers on all endpoints** — frontend is on different domain
+8. **Temperature 0.1 on all extraction calls** — deterministic is better than creative here
+
+---
+
+## Demo Company — Rivanly Inc.
+
+The demo uses Rivanly Inc. — a fictional 15-person B2B SaaS company.
+
+6 departments, 12 skills:
+
+| Department | Skills |
+|---|---|
+| Support | handle_refund_request, respond_to_outage |
+| Revenue | handle_pricing_exception, evaluate_discount_request |
+| Product/Eng | prioritize_bug_report, handle_sla_breach |
+| Customer Success | evaluate_churn_risk, enterprise_onboarding_steps |
+| HR | hiring_process_engineering, performance_pip_trigger |
+| Finance | approve_vendor_payment, expense_policy_exception |
+
+The 8 synthetic source files in `data/sources/` are authored to produce these 12 skills when processed by the pipeline.

backend/.env.example

@@ -0,0 +1,4 @@
+VLLM_BASE_URL=http://<MI300X_IP>:8000/v1
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_KEY=your_supabase_anon_key
+COMPANY_ID=rivanly-inc

backend/agent/brain_agent.py

@@ -0,0 +1,144 @@
+import json
+from backend.db.supabase import get_client
+from backend.llm import llm_call, get_embedding, cosine_similarity
+
+
+async def handle_agent_query(company_id: str, scenario: str, context: dict = None, with_brain: bool = True) -> dict:
+    """
+    Real agent query handler.  No keyword routing, no hardcoded actions.
+    Everything flows through: retrieve skills -> build prompt -> call vLLM -> return raw result.
+    """
+    if not with_brain:
+        return await _baseline_query(scenario, context)
+
+    # --- WITH BRAIN ---
+    db = get_client()
+    if not db:
+        return _error_response("Database connection failed.")
+
+    # 1. Fetch latest compiled skills
+    res = db.table("skills_files").select("brain_json").eq(
+        "company_id", company_id
+    ).order("compiled_at", desc=True).limit(1).execute()
+
+    if not res.data:
+        return _error_response("No compiled brain found. Please compile first.")
+
+    skills = res.data[0]["brain_json"].get("skills", [])
+    if not skills:
+        return _error_response("Brain is empty — no skills compiled.")
+
+    # 2. Embed the query and score every skill
+    query_text = f"{scenario} {json.dumps(context or {})}"
+    query_emb = get_embedding(query_text)
+
+    scored = []
+    for i, skill in enumerate(skills):
+        skill_text = f"{skill.get('category', '')} {skill.get('rule', '')} {skill.get('rationale', '')}"
+        skill_emb = get_embedding(skill_text)
+        score = cosine_similarity(query_emb, skill_emb)
+        scored.append({"skill": skill, "score": round(score, 4), "index": i})
+
+    scored.sort(key=lambda x: x["score"], reverse=True)
+    top_results = scored[:5]
+    retrieval_scores = [s["score"] for s in top_results]
+
+    # 3. Build skills context for the LLM
+    skills_context = ""
+    for rank, s in enumerate(top_results):
+        sk = s["skill"]
+        skills_context += f"\n--- Skill #{rank+1} (retrieval_score: {s['score']}) ---\n"
+        skills_context += f"Category: {sk.get('category', 'Unknown')}\n"
+        skills_context += f"Rule: {sk.get('rule', '')}\n"
+        skills_context += f"Rationale: {sk.get('rationale', '')}\n"
+        skills_context += f"Evidence: {json.dumps(sk.get('evidence', []))}\n"
+        skills_context += f"Compiled Confidence: {sk.get('confidence', 'unknown')}\n"
+
+    # 4. Prompt the LLM - no example confidence values to bias it
+    prompt = """You are the Kernl Brain Agent. You have access to this company's compiled operational skills (retrieved below, ranked by relevance).
+
+Your task:
+1. Read the scenario and optional JSON context carefully.
+2. Examine the retrieved skills and their retrieval_scores.
+3. Determine whether any skill clearly applies to this scenario.
+4. If a skill applies, state the specific recommended action from that skill's rule.
+5. If NO skill applies, or if the input is nonsensical/gibberish, say so honestly.
+
+CONFIDENCE SCORING - base it on real signals:
+- retrieval_score < 0.3 -> scenario is likely unrelated to any skill -> confidence < 0.2
+- retrieval_score 0.3-0.5 -> weak match -> confidence 0.2-0.5
+- retrieval_score 0.5-0.7 -> moderate match -> confidence 0.5-0.75
+- retrieval_score > 0.7 AND rule clearly addresses the scenario -> confidence 0.75-0.95
+- Never exceed 0.95 unless the match is exact and unambiguous.
+- Gibberish or nonsensical input -> confidence 0.0, recommended_action = "unable to determine"
+
+Respond with ONLY a JSON object (no markdown fences, no text outside the JSON):
+{
+  "recommended_action": "the specific action to take",
+  "rule_applied": "exact rule text from the best matching skill",
+  "evidence": ["evidence items from the skill"],
+  "skill_matched": "the category of the matched skill",
+  "confidence": 0.0,
+  "reasoning": "explain why this skill applies and how you chose the confidence level"
+}"""
+
+    user_content = f"--- Scenario ---\n{scenario}\n\n--- Additional Context ---\n{json.dumps(context or {})}\n\n--- Retrieved Skills (ranked by relevance) ---\n{skills_context}"
+
+    response_str = await llm_call(prompt, user_content)
+    result = _parse_json(response_str)
+    result["retrieval_scores"] = retrieval_scores
+    return result
+
+
+async def _baseline_query(scenario: str, context: dict = None) -> dict:
+    """Without-brain baseline: LLM answers with zero company context."""
+    prompt = """You are a generic AI assistant. You have NO company-specific knowledge or policies.
+Answer based only on general industry standards. Be honest about your lack of specific context.
+Respond with ONLY a JSON object:
+{
+  "recommended_action": "your general recommendation",
+  "rule_applied": "general industry standard you referenced",
+  "evidence": [],
+  "skill_matched": "none",
+  "confidence": 0.3,
+  "retrieval_scores": [],
+  "reasoning": "explain your reasoning, noting you lack company-specific context"
+}"""
+    user_content = f"Scenario: {scenario}\nContext: {json.dumps(context or {})}"
+    response_str = await llm_call(prompt, user_content)
+    return _parse_json(response_str)
+
+
+def _parse_json(raw: str) -> dict:
+    """Parse LLM response as JSON, stripping markdown fences."""
+    try:
+        clean = raw.strip()
+        if clean.startswith("```json"):
+            clean = clean[7:]
+        if clean.startswith("```"):
+            clean = clean[3:]
+        if clean.endswith("```"):
+            clean = clean[:-3]
+        return json.loads(clean.strip())
+    except Exception as e:
+        return {
+            "recommended_action": "Failed to parse LLM response",
+            "rule_applied": "none",
+            "evidence": [],
+            "skill_matched": "none",
+            "confidence": 0.0,
+            "retrieval_scores": [],
+            "reasoning": f"JSON parse error: {e}. Raw: {raw[:500]}"
+        }
+
+
+def _error_response(msg: str) -> dict:
+    return {
+        "recommended_action": msg,
+        "rule_applied": "none",
+        "evidence": [],
+        "skill_matched": "none",
+        "confidence": 0.0,
+        "retrieval_scores": [],
+        "reasoning": msg
+    }

backend/db/schema.sql

@@ -0,0 +1,58 @@
+-- Run these in Supabase SQL editor before starting
+
+CREATE TABLE companies (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now()
+);
+
+INSERT INTO companies VALUES ('rivanly-inc', 'Rivanly Inc.', now());
+
+CREATE TABLE skills_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  version TEXT NOT NULL,
+  brain_json JSONB NOT NULL,
+  source_hashes JSONB NOT NULL,
+  compiled_at TIMESTAMPTZ DEFAULT now(),
+  is_current BOOLEAN DEFAULT false
+);
+
+CREATE UNIQUE INDEX idx_skills_files_current ON skills_files(company_id) WHERE is_current = true;
+
+CREATE TABLE skills (
+  id TEXT NOT NULL,
+  company_id TEXT REFERENCES companies(id),
+  skills_file_id UUID REFERENCES skills_files(id),
+  name TEXT NOT NULL,
+  domain TEXT NOT NULL,
+  version TEXT NOT NULL,
+  confidence FLOAT NOT NULL,
+  stale BOOLEAN DEFAULT false,
+  review_required BOOLEAN DEFAULT false,
+  skill_json JSONB NOT NULL,
+  PRIMARY KEY (id, company_id, skills_file_id)
+);
+
+CREATE TABLE source_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  filename TEXT NOT NULL,
+  sha256 TEXT NOT NULL,
+  storage_path TEXT NOT NULL,
+  uploaded_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE TABLE compile_runs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  status TEXT NOT NULL CHECK (status IN ('started','running','complete','error')),
+  started_at TIMESTAMPTZ DEFAULT now(),
+  completed_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  result_version TEXT,
+  error_detail TEXT
+);
+
+CREATE INDEX idx_skills_files_company ON skills_files(company_id, compiled_at DESC);
+CREATE INDEX idx_skills_company ON skills(company_id);

backend/db/supabase.py

@@ -0,0 +1,63 @@
+import os
+from supabase import create_client, Client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if SUPABASE_URL and SUPABASE_KEY:
+    supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+else:
+    # We allow the app to start without Supabase for local testing if needed,
+    # but actual DB calls will fail if not provided.
+    supabase = None
+
+def get_client():
+    return supabase
+
+def get_current_brain(company_id: str):
+    if not supabase: return None
+    res = supabase.table("skills_files").select("*").eq("company_id", company_id).eq("is_current", True).execute()
+    if res.data:
+        return res.data[0]
+    return None
+
+def save_skills_file(data: dict):
+    if not supabase: return None
+    res = supabase.table("skills_files").insert(data).execute()
+    return res.data
+
+def save_compile_run(data: dict):
+    if not supabase: return None
+    res = supabase.table("compile_runs").insert(data).execute()
+    return res.data
+
+def update_compile_run(run_id: str, data: dict):
+    if not supabase: return None
+    res = supabase.table("compile_runs").update(data).eq("id", run_id).execute()
+    return res.data
+
+def get_source_hashes(company_id: str):
+    if not supabase: return {}
+    # Get the latest current brain
+    brain = get_current_brain(company_id)
+    if brain:
+        return brain.get("source_hashes", {})
+    return {}
+
+def save_source_file(data: dict):
+    if not supabase: return None
+    res = supabase.table("source_files").insert(data).execute()
+    return res.data
+
+def get_skills_by_brain_id(brain_id: str):
+    if not supabase: return []
+    res = supabase.table("skills").select("*").eq("skills_file_id", brain_id).execute()
+    return res.data
+
+def insert_skills(data: list):
+    if not supabase: return None
+    res = supabase.table("skills").insert(data).execute()
+    return res.data

backend/graph/graph.py

@@ -0,0 +1,30 @@
+from langgraph.graph import StateGraph, END
+from backend.graph.state import BrainState
+from backend.graph.nodes.load_and_chunk import load_and_chunk
+from backend.graph.nodes.cluster_evidence import cluster_evidence
+from backend.graph.nodes.synthesize_skills import synthesize_skills
+from backend.graph.nodes.quality_normalize import quality_normalize
+from backend.graph.nodes.write_brain import write_brain
+
+
+def build_compilation_graph() -> StateGraph:
+    """
+    Linear 5-node pipeline:
+      load_and_chunk → cluster_evidence → synthesize_skills → quality_normalize → write_brain
+    """
+    workflow = StateGraph(BrainState)
+
+    workflow.add_node("load_and_chunk", load_and_chunk)
+    workflow.add_node("cluster_evidence", cluster_evidence)
+    workflow.add_node("synthesize_skills", synthesize_skills)
+    workflow.add_node("quality_normalize", quality_normalize)
+    workflow.add_node("write_brain", write_brain)
+
+    workflow.set_entry_point("load_and_chunk")
+    workflow.add_edge("load_and_chunk", "cluster_evidence")
+    workflow.add_edge("cluster_evidence", "synthesize_skills")
+    workflow.add_edge("synthesize_skills", "quality_normalize")
+    workflow.add_edge("quality_normalize", "write_brain")
+    workflow.add_edge("write_brain", END)
+
+    return workflow.compile()

backend/graph/nodes/cluster_evidence.py

@@ -0,0 +1,64 @@
+"""
+Node 2: Embed all chunks and cluster them by domain using the LLM.
+Emits SSE stage: EMBEDDING
+"""
+import json
+from backend.graph.state import BrainState
+from backend.llm import llm_call, get_embeddings
+from backend.sse import emit
+
+
+async def cluster_evidence(state: BrainState) -> dict:
+    job_id = state["job_id"]
+    chunks = state.get("chunks", [])
+
+    print(f"[{job_id}] Node cluster_evidence started with {len(chunks)} chunks")
+
+    if not chunks:
+        await emit(job_id, "stage", {"name": "EMBEDDING", "detail": "No chunks to embed"})
+        return {"clusters": {"domains": {}}}
+
+    await emit(job_id, "stage", {"name": "EMBEDDING", "detail": f"Embedding {len(chunks)} chunks"})
+
+    # Build a numbered summary of each chunk for the LLM
+    summaries = []
+    for i, c in enumerate(chunks):
+        # Truncate long chunks for the categorization prompt
+        preview = c["text"][:300].replace("\n", " ")
+        summaries.append(f"[{i}] ({c['source_file']}) {preview}")
+
+    chunk_list_text = "\n".join(summaries)
+
+    prompt = """You are an operations analyst. Below is a numbered list of text chunks extracted from a company's internal documents (SOPs, Slack messages, support tickets).
+
+Categorize each chunk into an operational domain. Use clear domain names like:
+"Customer Support", "Engineering", "Sales", "Human Resources", "Finance", "Operations", etc.
+
+Return ONLY a valid JSON object mapping domain names to arrays of chunk indices.
+Example: {"Customer Support": [0, 3, 5], "Engineering": [1, 2], "Sales": [4]}
+
+Every chunk index must appear exactly once. Do not skip any."""
+
+    response_str = await llm_call(prompt, chunk_list_text)
+
+    try:
+        clean = response_str.strip()
+        if clean.startswith("```json"):
+            clean = clean[7:]
+        if clean.startswith("```"):
+            clean = clean[3:]
+        if clean.endswith("```"):
+            clean = clean[:-3]
+        domains = json.loads(clean.strip())
+    except Exception as e:
+        print(f"[cluster_evidence] Failed to parse LLM clustering: {e}")
+        # Fallback: put all chunks in one cluster
+        domains = {"General": list(range(len(chunks)))}
+
+    await emit(job_id, "stage", {
+        "name": "EMBEDDING_DONE",
+        "detail": f"Clustered into {len(domains)} domains: {list(domains.keys())}",
+    })
+
+    print(f"[{job_id}] Node cluster_evidence finished with {len(domains)} domains")
+    return {"clusters": {"domains": domains}}

backend/graph/nodes/load_and_chunk.py

@@ -0,0 +1,174 @@
+"""
+Node 1: Load source files from disk and chunk them.
+Emits SSE stages: LOADING_DOCS, CHUNKING
+"""
+import os
+import json
+import hashlib
+import time
+from backend.graph.state import BrainState
+from backend.sse import emit
+
+
+async def load_and_chunk(state: BrainState) -> dict:
+    company_id = state["company_id"]
+    job_id = state["job_id"]
+
+    print(f"[{job_id}] Node load_and_chunk started")
+    await emit(job_id, "stage", {"name": "LOADING_DOCS", "detail": f"Reading sources for {company_id}"})
+
+    # Read files from the company-specific directory
+    # __file__ is backend/graph/nodes/load_and_chunk.py
+    base = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    sources_dir = os.path.join(base, "data", "sources", company_id)
+
+    if not os.path.isdir(sources_dir):
+        await emit(job_id, "pipeline_error", {"error": f"No source directory found: data/sources/{company_id}/"})
+        print(f"[{job_id}] Node load_and_chunk failed (Missing dir: {sources_dir})")
+        return {"errors": [f"Missing directory: {sources_dir}"], "source_files": [], "chunks": []}
+
+    source_files = []
+    for filename in sorted(os.listdir(sources_dir)):
+        filepath = os.path.join(sources_dir, filename)
+        if not os.path.isfile(filepath):
+            continue
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read()
+        doc_type = _detect_type(filename)
+        source_files.append({
+            "filename": filename,
+            "content": content,
+            "sha256": hashlib.sha256(content.encode("utf-8")).hexdigest(),
+            "doc_type": doc_type,
+        })
+
+    await emit(job_id, "stage", {
+        "name": "CHUNKING",
+        "detail": f"Splitting {len(source_files)} files into chunks",
+    })
+
+    chunks = []
+    for sf in source_files:
+        if sf["doc_type"] == "notion_md":
+            chunks.extend(_chunk_markdown(sf))
+        elif sf["doc_type"] == "slack_json":
+            chunks.extend(_chunk_slack(sf))
+        elif sf["doc_type"] == "tickets_json":
+            chunks.extend(_chunk_tickets(sf))
+        else:
+            # Treat unknown as plain text
+            chunks.append({
+                "text": sf["content"],
+                "source_file": sf["filename"],
+                "chunk_index": 0,
+                "doc_type": sf["doc_type"],
+            })
+
+    await emit(job_id, "stage", {
+        "name": "CHUNKING_DONE",
+        "detail": f"Produced {len(chunks)} chunks from {len(source_files)} files",
+    })
+
+    print(f"[{job_id}] Node load_and_chunk finished (chunks: {len(chunks)})")
+    return {"source_files": source_files, "chunks": chunks}
+
+
+# --- Helpers ---
+
+def _detect_type(filename: str) -> str:
+    fn = filename.lower()
+    if fn.endswith(".json"):
+        if "slack" in fn:
+            return "slack_json"
+        if "ticket" in fn or "zendesk" in fn:
+            return "tickets_json"
+        return "json"
+    if fn.endswith(".md"):
+        return "notion_md"
+    return "unknown"
+
+
+def _chunk_markdown(sf: dict) -> list:
+    """Split a markdown file by ## headers. Each section is a chunk."""
+    content = sf["content"]
+    sections = []
+    current_header = "Introduction"
+    current_body = []
+
+    for line in content.split("\n"):
+        if line.startswith("## "):
+            if current_body:
+                sections.append((current_header, "\n".join(current_body).strip()))
+            current_header = line.lstrip("# ").strip()
+            current_body = []
+        else:
+            current_body.append(line)
+
+    if current_body:
+        sections.append((current_header, "\n".join(current_body).strip()))
+
+    chunks = []
+    for i, (header, body) in enumerate(sections):
+        if not body:
+            continue
+        chunks.append({
+            "text": f"[{header}] {body}",
+            "source_file": sf["filename"],
+            "chunk_index": i,
+            "doc_type": "notion_md",
+            "section_header": header,
+        })
+    return chunks
+
+
+def _chunk_slack(sf: dict) -> list:
+    """Each Slack message is one chunk."""
+    try:
+        messages = json.loads(sf["content"])
+    except json.JSONDecodeError:
+        return []
+    chunks = []
+    for i, msg in enumerate(messages):
+        text = msg.get("text", "")
+        if not text:
+            continue
+        user = msg.get("user", "unknown")
+        channel = msg.get("channel", "unknown")
+        chunks.append({
+            "text": f"[Slack #{channel} @{user}] {text}",
+            "source_file": sf["filename"],
+            "chunk_index": i,
+            "doc_type": "slack_json",
+        })
+    return chunks
+
+
+def _chunk_tickets(sf: dict) -> list:
+    """Each ticket is one chunk."""
+    try:
+        tickets = json.loads(sf["content"])
+    except json.JSONDecodeError:
+        return []
+    chunks = []
+    for i, tkt in enumerate(tickets):
+        parts = []
+        if tkt.get("subject"):
+            parts.append(f"Subject: {tkt['subject']}")
+        if tkt.get("description"):
+            parts.append(f"Description: {tkt['description']}")
+        if tkt.get("resolution"):
+            parts.append(f"Resolution: {tkt['resolution']}")
+        if tkt.get("priority"):
+            parts.append(f"Priority: {tkt['priority']}")
+        if tkt.get("customer_plan"):
+            parts.append(f"Plan: {tkt['customer_plan']}")
+        text = " | ".join(parts)
+        if not text:
+            continue
+        chunks.append({
+            "text": f"[Zendesk Ticket] {text}",
+            "source_file": sf["filename"],
+            "chunk_index": i,
+            "doc_type": "tickets_json",
+        })
+    return chunks

backend/graph/nodes/quality_normalize.py

@@ -0,0 +1,83 @@
+"""
+Node 4: De-duplicate skills, resolve conflicts, score confidence, enforce schema.
+Emits SSE stage: QUALITY_CHECK
+"""
+import json
+from backend.graph.state import BrainState
+from backend.llm import llm_call
+from backend.sse import emit
+
+
+async def quality_normalize(state: BrainState) -> dict:
+    job_id = state["job_id"]
+    raw_skills = state.get("raw_skills", [])
+
+    print(f"[{job_id}] Node quality_normalize started with {len(raw_skills)} raw skills")
+
+    if not raw_skills:
+        await emit(job_id, "stage", {"name": "QUALITY_CHECK", "detail": "No skills to normalize"})
+        print(f"[{job_id}] Node quality_normalize finished (0 skills)")
+        return {"skills_file": {"skills": []}}
+
+    await emit(job_id, "stage", {
+        "name": "QUALITY_CHECK",
+        "detail": f"Normalizing {len(raw_skills)} raw skills",
+    })
+
+    prompt = """You are a quality assurance agent for an operational skills file.
+
+Below is a raw list of skills extracted from company documents. Your job:
+
+1. DEDUPLICATE: merge skills that describe the same rule (keep the most complete version).
+2. RESOLVE CONFLICTS: if two skills contradict, keep both but note the conflict in the rationale. Prefer observed behavior (from Slack/tickets) over stated policy (from SOPs) when they conflict.
+3. SCORE CONFIDENCE (0.0 to 1.0) for each skill based on:
+   - 0.9–1.0: multiple confirming sources, clear unambiguous rule
+   - 0.7–0.89: single strong source or multiple weak sources
+   - 0.5–0.69: only one source, or some ambiguity
+   - 0.3–0.49: weak evidence or significant ambiguity
+   - < 0.3: speculative or poorly supported
+4. ENFORCE SCHEMA: every skill must have: id, category, rule, rationale, evidence (array), confidence (float).
+
+Return ONLY a JSON object:
+{
+  "skills": [
+    {
+      "id": "skill_slug",
+      "category": "Domain Name",
+      "rule": "The specific rule text",
+      "rationale": "Why this rule exists",
+      "evidence": ["source reference 1", "source reference 2"],
+      "confidence": 0.85
+    }
+  ]
+}"""
+
+    skills_text = json.dumps(raw_skills, indent=2)
+    print(f"[{job_id}] Requesting quality normalization...")
+    response_str = await llm_call(prompt, skills_text, max_tokens=8192)
+    print(f"[{job_id}] Received quality normalization response")
+
+    try:
+        clean = response_str.strip()
+        if clean.startswith("```json"):
+            clean = clean[7:]
+        if clean.startswith("```"):
+            clean = clean[3:]
+        if clean.endswith("```"):
+            clean = clean[:-3]
+        data = json.loads(clean.strip())
+        final_skills = data.get("skills", raw_skills)
+    except Exception as e:
+        print(f"[{job_id}] [quality_normalize] Parse error: {e}")
+        # Fallback: use raw skills with default confidence
+        final_skills = raw_skills
+        for sk in final_skills:
+            sk.setdefault("confidence", 0.5)
+
+    await emit(job_id, "stage", {
+        "name": "QUALITY_CHECK_DONE",
+        "detail": f"Final skills count: {len(final_skills)} (from {len(raw_skills)} raw)",
+    })
+
+    print(f"[{job_id}] Node quality_normalize finished (final skills: {len(final_skills)})")
+    return {"skills_file": {"skills": final_skills}}

backend/graph/nodes/synthesize_skills.py

@@ -0,0 +1,111 @@
+"""
+Node 3: For each domain cluster, call vLLM to synthesize structured skills.
+Emits SSE stage: SYNTHESIZING_SKILLS
+"""
+import json
+import uuid
+from backend.graph.state import BrainState
+from backend.llm import llm_call
+from backend.sse import emit
+
+
+async def synthesize_skills(state: BrainState) -> dict:
+    job_id = state["job_id"]
+    chunks = state.get("chunks", [])
+    clusters = state.get("clusters", {})
+    domains = clusters.get("domains", {})
+
+    print(f"[{job_id}] Node synthesize_skills started with {len(domains)} domains")
+
+    if not domains:
+        await emit(job_id, "stage", {"name": "SYNTHESIZING_SKILLS", "detail": "No clusters to synthesize"})
+        print(f"[{job_id}] Node synthesize_skills finished (0 domains)")
+        return {"raw_skills": []}
+
+    await emit(job_id, "stage", {
+        "name": "SYNTHESIZING_SKILLS",
+        "detail": f"Synthesizing skills for {len(domains)} domains",
+    })
+
+    all_skills = []
+
+    for domain_name, chunk_indices in domains.items():
+        # Gather the actual chunk texts for this domain
+        domain_chunks = []
+        for idx in chunk_indices:
+            if 0 <= idx < len(chunks):
+                domain_chunks.append(chunks[idx])
+
+        if not domain_chunks:
+            continue
+
+        chunk_text = "\n\n".join([c["text"] for c in domain_chunks])
+        source_files = list(set(c["source_file"] for c in domain_chunks))
+
+        prompt = f"""You are a Principal Operations Architect analyzing the "{domain_name}" domain.
+
+Below are real excerpts from a company's internal documents (SOPs, Slack messages, support tickets) related to {domain_name}.
+
+Your job: extract every distinct operational rule, policy, process, or decision pattern you can find.
+
+For EACH skill, provide:
+- id: a unique identifier (use a short slug like "refund_loyal_customer")
+- category: "{domain_name}"
+- rule: the specific, actionable rule or process (be precise — include thresholds, timeframes, approvals)
+- rationale: why this rule exists (based on the evidence)
+- evidence: array of specific quotes or references from the source chunks that support this rule
+- source_files: which files this came from
+
+Rules for quality:
+- Extract what the documents ACTUALLY say, not what you assume.
+- If there are contradictions (e.g., SOP says X but Slack shows Y), note BOTH and state which takes precedence in practice.
+- Do NOT invent rules that aren't supported by the text below.
+- Each rule should be specific enough that a human could follow it without additional context.
+
+Respond with ONLY a JSON object:
+{{
+  "skills": [
+    {{
+      "id": "refund_loyal_customer",
+      "category": "{domain_name}",
+      "rule": "Approve refunds up to 45 days for customers with >2 years tenure",
+      "rationale": "Exception applied over standard 30-day limit for loyal customers",
+      "evidence": ["slack_export_support.json: Mike approved 45-day refund for Acme Corp"],
+      "source_files": ["slack_export_support.json", "notion_refund_sop.md"]
+    }}
+  ]
+}}"""
+
+        print(f"[{job_id}] Requesting skills for domain '{domain_name}'...")
+        response_str = await llm_call(prompt, chunk_text)
+        print(f"[{job_id}] Received skills response for domain '{domain_name}'")
+
+        try:
+            clean = response_str.strip()
+            if clean.startswith("```json"):
+                clean = clean[7:]
+            if clean.startswith("```"):
+                clean = clean[3:]
+            if clean.endswith("```"):
+                clean = clean[:-3]
+            data = json.loads(clean.strip())
+            domain_skills = data.get("skills", [])
+        except Exception as e:
+            print(f"[{job_id}] [synthesize_skills] Parse error for {domain_name}: {e}")
+            domain_skills = []
+
+        # Ensure every skill has an id
+        for sk in domain_skills:
+            if not sk.get("id"):
+                sk["id"] = str(uuid.uuid4())[:8]
+            sk["category"] = domain_name  # ensure consistency
+
+        all_skills.extend(domain_skills)
+
+        await emit(job_id, "stage", {
+            "name": "SYNTHESIZING_SKILLS",
+            "detail": f"{domain_name}: extracted {len(domain_skills)} skills",
+        })
+
+    print(f"[{job_id}] Node synthesize_skills finished (extracted {len(all_skills)} skills overall)")
+    return {"raw_skills": all_skills}

backend/graph/nodes/write_brain.py

@@ -0,0 +1,96 @@
+"""
+Node 5: Write the final skills file to the database.
+Emits SSE stage: WRITING_DB, then pipeline_complete.
+"""
+import time
+import json
+import uuid
+import datetime
+from backend.graph.state import BrainState
+from backend.db.supabase import get_client
+from backend.sse import emit
+
+
+async def write_brain(state: BrainState) -> dict:
+    job_id = state.get("job_id")
+    company_id = state.get("company_id")
+    skills_file = state.get("skills_file", {})
+    skills = skills_file.get("skills", [])
+    start_time = state.get("start_time", time.time())
+    duration_ms = int((time.time() - start_time) * 1000)
+
+    print(f"[{job_id}] Node write_brain started for {company_id}")
+
+    await emit(job_id, "stage", {"name": "WRITING_DB", "detail": f"Persisting {len(skills)} skills"})
+
+    db = get_client()
+    if not db:
+        await emit(job_id, "pipeline_error", {"error": "Database connection failed"})
+        print(f"[{job_id}] Node write_brain failed (no DB client)")
+        return {"errors": ["DB connection failed in write_brain"]}
+
+    try:
+        now_iso = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        version_str = f"v_{int(time.time())}"
+
+        source_hashes = {}
+        for f in state.get("source_files", []):
+            if "filename" in f and "sha256" in f:
+                source_hashes[f["filename"]] = f["sha256"]
+
+        # Mark previous brain as not current
+        db.table("skills_files").update(
+            {"is_current": False}
+        ).eq("company_id", company_id).eq("is_current", True).execute()
+
+        # Insert new brain
+        sf_res = db.table("skills_files").insert({
+            "company_id": company_id,
+            "version": version_str,
+            "brain_json": skills_file,
+            "source_hashes": source_hashes,
+            "is_current": True,
+        }).execute()
+
+        sf_id = sf_res.data[0]["id"]
+
+        # Insert individual skills
+        for skill in skills:
+            db.table("skills").insert({
+                "id": skill.get("id", str(uuid.uuid4())[:8]),
+                "company_id": company_id,
+                "skills_file_id": sf_id,
+                "name": skill.get("rule", "Unknown")[:200],
+                "domain": skill.get("category", "general"),
+                "version": version_str,
+                "confidence": float(skill.get("confidence", 0.5)),
+                "skill_json": skill,
+            }).execute()
+
+        # Update compile run
+        db.table("compile_runs").update({
+            "status": "complete",
+            "completed_at": now_iso,
+            "duration_ms": duration_ms,
+            "result_version": version_str,
+        }).eq("id", job_id).execute()
+
+    except Exception as e:
+        print(f"[{job_id}] [write_brain] DB Error: {e}")
+        await emit(job_id, "pipeline_error", {"error": str(e)})
+        return {"errors": [f"write_brain DB error: {e}"]}
+
+    await emit(job_id, "stage", {
+        "name": "DONE",
+        "detail": f"Brain {version_str} written: {len(skills)} skills, {len(source_hashes)} sources, {duration_ms}ms",
+    })
+    await emit(job_id, "pipeline_complete", {
+        "status": "success",
+        "version": version_str,
+        "skills_count": len(skills),
+        "source_count": len(source_hashes),
+        "duration_ms": duration_ms,
+    })
+
+    print(f"[{job_id}] Node write_brain finished successfully (version: {version_str})")
+    return {}

backend/graph/state.py

@@ -0,0 +1,14 @@
+from typing import TypedDict, Annotated, List, Dict, Any
+import operator
+
+class BrainState(TypedDict):
+    company_id: str
+    job_id: str
+    source_files: List[Dict[str, Any]]   # [{filename, content, sha256, doc_type}]
+    chunks: List[Dict[str, Any]]         # [{text, source_file, chunk_index, doc_type}]
+    clusters: Dict[str, Any]             # {domains: {domain_name: [chunk_indices]}}
+    raw_skills: List[Dict[str, Any]]     # skills before quality pass
+    skills_file: Dict[str, Any]          # final {skills: [...]}
+    brain_version: str
+    start_time: float
+    errors: Annotated[List[str], operator.add]

backend/llm.py

@@ -0,0 +1,65 @@
+import os
+import json
+import numpy as np
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+VLLM_BASE_URL = os.getenv("VLLM_BASE_URL", "http://localhost:8000/v1")
+MODEL_NAME = "RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic"
+
+llm = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key="not-needed", timeout=120.0)
+
+# --- Embedding model (local, fast, centralized here) ---
+_embedding_model = None
+
+def _get_embedding_model():
+    global _embedding_model
+    if _embedding_model is None:
+        from sentence_transformers import SentenceTransformer
+        _embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
+    return _embedding_model
+
+def get_embedding(text: str) -> list:
+    """Return a single embedding vector as a Python list."""
+    model = _get_embedding_model()
+    return model.encode(text).tolist()
+
+def get_embeddings(texts: list) -> list:
+    """Return a list of embedding vectors."""
+    model = _get_embedding_model()
+    return [v.tolist() for v in model.encode(texts)]
+
+def cosine_similarity(v1, v2) -> float:
+    """Cosine similarity between two vectors."""
+    a, b = np.array(v1), np.array(v2)
+    denom = np.linalg.norm(a) * np.linalg.norm(b)
+    if denom == 0:
+        return 0.0
+    return float(np.dot(a, b) / denom)
+
+async def check_vllm_health() -> dict:
+    """Ping the vLLM /v1/models endpoint. Returns status dict."""
+    try:
+        response = await llm.models.list()
+        models = [m.id for m in response.data]
+        return {"healthy": True, "models": models, "url": VLLM_BASE_URL}
+    except Exception as e:
+        return {"healthy": False, "error": str(e), "url": VLLM_BASE_URL}
+
+async def llm_call(system_prompt: str, user_content: str, temperature: float = 0.1, max_tokens: int = 4096) -> str:
+    """Single centralized LLM call through vLLM. Raises on failure."""
+    try:
+        response = await llm.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_content}
+            ],
+            temperature=temperature,
+            max_tokens=max_tokens
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        raise RuntimeError(f"vLLM call failed ({VLLM_BASE_URL}): {e}")

backend/main.py

@@ -0,0 +1,310 @@
+from fastapi import FastAPI, BackgroundTasks, HTTPException, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+import os
+import uuid
+import time
+import json
+import hashlib
+import shutil
+
+from backend.graph.graph import build_compilation_graph
+from backend.sse import event_bus, emit
+from backend.agent.brain_agent import handle_agent_query
+from backend.db.supabase import get_client
+from backend.llm import check_vllm_health
+from backend.models.schemas import CompileRequest, AgentHandleRequest, AgentQueryRequest
+
+app = FastAPI(title="Kernl API", version="2.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SOURCES_ROOT = os.path.join(BASE_DIR, "data", "sources")
+
+
+# ─────────────────────────────────────────────
+# Health
+# ─────────────────────────────────────────────
+@app.get("/health")
+async def health_check():
+    vllm = await check_vllm_health()
+    db = get_client()
+    return {
+        "status": "ok",
+        "vllm": vllm,
+        "database": "connected" if db else "not configured",
+    }
+
+
+# ─────────────────────────────────────────────
+# Source file management
+# ─────────────────────────────────────────────
+def _company_sources_dir(company_id: str) -> str:
+    return os.path.join(SOURCES_ROOT, company_id)
+
+
+@app.post("/sources/upload")
+async def upload_source(company_id: str = Form(...), file: UploadFile = File(...)):
+    """Upload a source file for a company."""
+    dest_dir = _company_sources_dir(company_id)
+    os.makedirs(dest_dir, exist_ok=True)
+
+    content = await file.read()
+    filepath = os.path.join(dest_dir, file.filename)
+    with open(filepath, "wb") as f:
+        f.write(content)
+
+    file_hash = hashlib.sha256(content).hexdigest()
+
+    # Record in DB
+    db = get_client()
+    if db:
+        try:
+            db.table("source_files").insert({
+                "company_id": company_id,
+                "filename": file.filename,
+                "sha256": file_hash,
+                "storage_path": f"data/sources/{company_id}/{file.filename}",
+            }).execute()
+        except Exception as e:
+            print(f"[upload] DB record error: {e}")
+
+    return {"filename": file.filename, "sha256": file_hash, "status": "uploaded"}
+
+
+@app.get("/sources/{company_id}")
+async def list_sources(company_id: str):
+    """List all source files for a company."""
+    src_dir = _company_sources_dir(company_id)
+    if not os.path.isdir(src_dir):
+        return {"files": []}
+    files = []
+    for fn in sorted(os.listdir(src_dir)):
+        fp = os.path.join(src_dir, fn)
+        if os.path.isfile(fp):
+            with open(fp, "rb") as f:
+                content = f.read()
+            files.append({
+                "filename": fn,
+                "size_bytes": len(content),
+                "sha256": hashlib.sha256(content).hexdigest(),
+            })
+    return {"files": files, "company_id": company_id}
+
+
+@app.delete("/sources/{company_id}/{filename}")
+async def delete_source(company_id: str, filename: str):
+    """Delete a source file."""
+    filepath = os.path.join(_company_sources_dir(company_id), filename)
+    if not os.path.isfile(filepath):
+        raise HTTPException(status_code=404, detail=f"File not found: {filename}")
+    os.remove(filepath)
+
+    db = get_client()
+    if db:
+        try:
+            db.table("source_files").delete().eq(
+                "company_id", company_id
+            ).eq("filename", filename).execute()
+        except Exception as e:
+            print(f"[delete] DB cleanup error: {e}")
+
+    return {"status": "deleted", "filename": filename}
+
+
+# ─────────────────────────────────────────────
+# Compilation pipeline
+# ─────────────────────────────────────────────
+import asyncio
+import traceback
+import datetime
+
+async def run_compilation_graph(job_id: str, company_id: str):
+    initial_state = {
+        "job_id": job_id,
+        "company_id": company_id,
+        "source_files": [],
+        "chunks": [],
+        "clusters": {},
+        "raw_skills": [],
+        "skills_file": {},
+        "brain_version": "",
+        "start_time": time.time(),
+        "errors": [],
+    }
+
+    graph = build_compilation_graph()
+
+    await emit(job_id, "pipeline_start", {"company_id": company_id})
+    try:
+        # Prevent indefinite hanging
+        await asyncio.wait_for(graph.ainvoke(initial_state), timeout=600.0)
+    except Exception as e:
+        err_msg = str(e)
+        if isinstance(e, asyncio.TimeoutError):
+            err_msg = "Pipeline execution timed out after 600 seconds."
+        
+        trace = traceback.format_exc()
+        print(f"Graph execution failed for {job_id}:\n{trace}")
+        
+        await emit(job_id, "pipeline_error", {"error": err_msg, "traceback": trace})
+        # Update compile run status
+        db = get_client()
+        if db:
+            try:
+                db.table("compile_runs").update({
+                    "status": "error",
+                    "completed_at": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                    "error_detail": err_msg,
+                }).eq("id", job_id).execute()
+            except Exception as db_e:
+                print(f"Failed to update compile_runs with error status: {db_e}")
+
+
+@app.post("/compile")
+@app.post("/compile/run")
+async def compile_brain(req: CompileRequest, background_tasks: BackgroundTasks):
+    # Verify source directory exists
+    src_dir = _company_sources_dir(req.company_id)
+    if not os.path.isdir(src_dir) or not os.listdir(src_dir):
+        raise HTTPException(
+            status_code=400,
+            detail=f"No source files found at data/sources/{req.company_id}/. Upload files first.",
+        )
+
+    job_id = str(uuid.uuid4())
+    db = get_client()
+
+    if db:
+        try:
+            db.table("compile_runs").insert({
+                "id": job_id,
+                "company_id": req.company_id,
+                "status": "running",
+            }).execute()
+        except Exception as e:
+            print(f"Error creating run: {e}")
+
+    background_tasks.add_task(run_compilation_graph, job_id, req.company_id)
+    return {"job_id": job_id, "status": "started"}
+
+
+@app.get("/compile/{job_id}/stream")
+async def compile_stream(job_id: str):
+    return StreamingResponse(
+        event_bus.event_generator(job_id),
+        media_type="text/event-stream",
+    )
+
+
+@app.get("/compile/{job_id}/status")
+async def compile_status(job_id: str):
+    db = get_client()
+    if not db:
+        return {"status": "unknown", "error_detail": "No DB"}
+    res = db.table("compile_runs").select("*").eq("id", job_id).execute()
+    if not res.data:
+        return {"status": "not_found"}
+    return res.data[0]
+
+
+# ─────────────────────────────────────────────
+# Agent query
+# ─────────────────────────────────────────────
+@app.post("/agent/handle")
+async def agent_handle_endpoint(req: AgentHandleRequest):
+    """Legacy endpoint — kept for frontend compat."""
+    result = await handle_agent_query(req.company_id, req.scenario, req.context, req.with_brain)
+    return result
+
+
+@app.post("/agent/query")
+async def agent_query_endpoint(req: AgentQueryRequest):
+    """New canonical endpoint."""
+    result = await handle_agent_query(
+        req.company_id,
+        req.scenario_text,
+        req.json_context,
+        req.with_brain,
+    )
+    return result
+
+
+# ─────────────────────────────────────────────
+# Skills & brain versions
+# ─────────────────────────────────────────────
+@app.get("/skills")
+async def get_skills_legacy(company_id: str):
+    """Legacy endpoint: returns raw brain_json."""
+    db = get_client()
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not connected")
+    res = db.table("skills_files").select("brain_json").eq(
+        "company_id", company_id
+    ).order("compiled_at", desc=True).limit(1).execute()
+    if not res.data:
+        return {"skills": []}
+    return res.data[0]["brain_json"]
+
+
+@app.get("/skills/{company_id}")
+async def get_skills(company_id: str):
+    """Returns detailed skills with metadata."""
+    db = get_client()
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not connected")
+
+    res = db.table("skills_files").select("*").eq(
+        "company_id", company_id
+    ).eq("is_current", True).execute()
+
+    if not res.data:
+        return {"skills": [], "version": None, "compiled_at": None}
+
+    brain = res.data[0]
+    skills = brain["brain_json"].get("skills", [])
+    return {
+        "skills": skills,
+        "version": brain["version"],
+        "compiled_at": brain["compiled_at"],
+        "source_hashes": brain.get("source_hashes", {}),
+        "brain_id": brain["id"],
+    }
+
+
+@app.get("/brain/versions/{company_id}")
+async def list_brain_versions(company_id: str):
+    """Lists all brain versions for a company."""
+    db = get_client()
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not connected")
+
+    res = db.table("skills_files").select(
+        "id, version, compiled_at, is_current, source_hashes"
+    ).eq("company_id", company_id).order("compiled_at", desc=True).execute()
+
+    versions = []
+    for row in res.data:
+        brain_json = None
+        # Get skill count from the full row
+        full = db.table("skills_files").select("brain_json").eq("id", row["id"]).execute()
+        skill_count = 0
+        if full.data:
+            skill_count = len(full.data[0]["brain_json"].get("skills", []))
+        versions.append({
+            "id": row["id"],
+            "version": row["version"],
+            "compiled_at": row["compiled_at"],
+            "is_current": row["is_current"],
+            "source_count": len(row.get("source_hashes", {})),
+            "skill_count": skill_count,
+        })
+
+    return {"versions": versions, "company_id": company_id}

backend/models/schemas.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+class CompileRequest(BaseModel):
+    company_id: str
+    force_recompile: bool = False
+
+class AgentHandleRequest(BaseModel):
+    """Legacy schema — kept for frontend compatibility."""
+    company_id: str
+    scenario: str
+    context: Optional[Dict[str, Any]] = None
+    with_brain: bool = True
+
+class AgentQueryRequest(BaseModel):
+    """New canonical schema for agent queries."""
+    company_id: str
+    scenario_text: str
+    json_context: Optional[Dict[str, Any]] = None
+    with_brain: bool = True

backend/requirements.txt

@@ -0,0 +1,10 @@
+fastapi>=0.115
+uvicorn[standard]
+openai
+langgraph>=0.4
+sentence-transformers
+numpy
+supabase
+python-dotenv
+python-multipart
+pydantic

backend/sse.py

@@ -0,0 +1,40 @@
+import asyncio
+import json
+from typing import Dict, AsyncGenerator
+
+class CompilationEventBus:
+    def __init__(self):
+        self.queues: Dict[str, asyncio.Queue] = {}
+
+    def get_queue(self, job_id: str) -> asyncio.Queue:
+        if job_id not in self.queues:
+            self.queues[job_id] = asyncio.Queue()
+        return self.queues[job_id]
+
+    async def emit_event(self, job_id: str, event_type: str, data: dict):
+        queue = self.get_queue(job_id)
+        await queue.put({"type": event_type, "data": data})
+
+    async def event_generator(self, job_id: str) -> AsyncGenerator[str, None]:
+        """Yields SSE-formatted strings. Uses unnamed events so the
+        frontend's EventSource.onmessage handler fires correctly.
+        Payload: data: {"event": "<type>", "data": {<payload>}}\n\n
+        """
+        queue = self.get_queue(job_id)
+        try:
+            while True:
+                event = await asyncio.wait_for(queue.get(), timeout=300)
+                payload = json.dumps({"event": event["type"], "data": event["data"]})
+                yield f"data: {payload}\n\n"
+                if event["type"] in ["pipeline_complete", "pipeline_error"]:
+                    break
+        except asyncio.TimeoutError:
+            yield f'data: {json.dumps({"event": "timeout", "data": {}})}\n\n'
+        finally:
+            if job_id in self.queues:
+                del self.queues[job_id]
+
+event_bus = CompilationEventBus()
+
+async def emit(job_id: str, event_type: str, data: dict):
+    await event_bus.emit_event(job_id, event_type, data)

backend/test_compile.py

@@ -0,0 +1,89 @@
+import asyncio
+import os
+import json
+import uuid
+import sys
+from dotenv import load_dotenv
+
+# Set backend in path
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+from backend.graph.graph import build_compilation_graph
+
+async def run_compilation_test():
+    load_dotenv()
+    
+    # Check vLLM
+    vllm_url = os.getenv("VLLM_BASE_URL")
+    if not vllm_url:
+        print("VLLM_BASE_URL not set in .env. LLM calls will fail.")
+    else:
+        print(f"Using VLLM_BASE_URL: {vllm_url}")
+
+    company_id = "rivanly-inc"
+    job_id = str(uuid.uuid4())
+    
+    # Read files
+    source_files = []
+    sources_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "sources")
+    if os.path.exists(sources_dir):
+        import hashlib
+        for filename in os.listdir(sources_dir):
+            filepath = os.path.join(sources_dir, filename)
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read()
+            
+            ftype = "unknown"
+            if filename.endswith(".json"):
+                if "slack" in filename: ftype = "slack_json"
+                elif "tickets" in filename: ftype = "tickets_json"
+            elif filename.endswith(".md"):
+                ftype = "notion_md"
+                
+            source_files.append({
+                "filename": filename,
+                "content": content,
+                "type": ftype,
+                "sha256": hashlib.sha256(content.encode('utf-8')).hexdigest()
+            })
+    else:
+        print(f"No sources dir found at {sources_dir}")
+        return
+
+    print(f"Found {len(source_files)} source files. Starting graph...")
+    
+    initial_state = {
+        "job_id": job_id,
+        "company_id": company_id,
+        "source_files": source_files,
+        "structured_sops": [],
+        "normalized_events": [],
+        "resolved_cases": [],
+        "extracted_decisions": [],
+        "extracted_workflows": [],
+        "extracted_exceptions": [],
+        "detected_contradictions": [],
+        "skills_file": {}
+    }
+    
+    graph = build_compilation_graph()
+    
+    try:
+        final_state = await graph.ainvoke(initial_state)
+        print("\n=== COMPILATION COMPLETE ===")
+        print(f"Extracted Decisions: {len(final_state.get('extracted_decisions', []))}")
+        print(f"Detected Contradictions: {len(final_state.get('detected_contradictions', []))}")
+        for c in final_state.get('detected_contradictions', []):
+            print(f"  - Contradiction: {c}")
+            
+        skills_file = final_state.get('skills_file', {})
+        skills = skills_file.get('skills', [])
+        print(f"Generated Skills: {len(skills)}")
+        for s in skills:
+            print(f"  - {s.get('id')} ({s.get('confidence')} conf)")
+            
+    except Exception as e:
+        print(f"Graph execution failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(run_compilation_test())

brand_alchemy_company_brain.html

@@ -0,0 +1,254 @@
+
+<style>
+  .ba-root { font-family: var(--font-sans); padding: 1.5rem 0; }
+  .section-label { font-size: 11px; font-weight: 500; letter-spacing: 0.08em; text-transform: uppercase; color: var(--color-text-tertiary); margin-bottom: 0.75rem; }
+  .pov-block { border-left: 2px solid var(--color-border-secondary); padding: 0.75rem 1rem; margin-bottom: 1.5rem; }
+  .pov-block p { margin: 0; font-size: 15px; color: var(--color-text-primary); line-height: 1.6; }
+  .pov-block .pov-sub { font-size: 13px; color: var(--color-text-secondary); margin-top: 0.4rem; }
+  .meta-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; margin-bottom: 2rem; }
+  .meta-card { background: var(--color-background-secondary); border-radius: var(--border-radius-md); padding: 0.75rem 1rem; }
+  .meta-card .mk { font-size: 11px; color: var(--color-text-tertiary); margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.06em; }
+  .meta-card .mv { font-size: 13px; font-weight: 500; color: var(--color-text-primary); }
+  .name-card { background: var(--color-background-primary); border: 0.5px solid var(--color-border-tertiary); border-radius: var(--border-radius-lg); padding: 1.25rem; margin-bottom: 0.75rem; }
+  .name-card.winner { border: 1.5px solid #1D9E75; }
+  .name-header { display: flex; align-items: center; gap: 12px; margin-bottom: 0.75rem; }
+  .name-title { font-size: 22px; font-weight: 500; color: var(--color-text-primary); letter-spacing: -0.02em; }
+  .name-score { display: flex; gap: 6px; margin-left: auto; align-items: center; }
+  .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--color-border-tertiary); }
+  .dot.filled { background: #1D9E75; }
+  .winner-badge { font-size: 11px; font-weight: 500; background: #E1F5EE; color: #0F6E56; padding: 3px 10px; border-radius: 20px; }
+  .name-tagline { font-size: 14px; color: var(--color-text-secondary); margin-bottom: 0.75rem; font-style: italic; }
+  .phono-row { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 0.75rem; }
+  .phono-pill { font-size: 11px; background: var(--color-background-secondary); border: 0.5px solid var(--color-border-tertiary); color: var(--color-text-secondary); padding: 3px 10px; border-radius: 20px; }
+  .phono-pill.p { background: #EEEDFE; color: #3C3489; border-color: #AFA9EC; }
+  .phono-pill.l { background: #E1F5EE; color: #0F6E56; border-color: #5DCAA5; }
+  .phono-pill.f { background: #FAEEDA; color: #633806; border-color: #EF9F27; }
+  .name-reasoning { font-size: 13px; color: var(--color-text-secondary); line-height: 1.6; margin-bottom: 0.75rem; }
+  .domain-row { display: flex; gap: 8px; flex-wrap: wrap; }
+  .domain-tag { font-size: 12px; font-weight: 500; padding: 3px 10px; border-radius: 20px; display: flex; align-items: center; gap: 5px; }
+  .domain-tag.available { background: #E1F5EE; color: #085041; }
+  .domain-tag.taken { background: #FCEBEB; color: #791F1F; }
+  .diamond-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; margin-bottom: 2rem; }
+  .diamond-item { background: var(--color-background-secondary); border-radius: var(--border-radius-md); padding: 0.6rem; text-align: center; }
+  .diamond-label { font-size: 11px; color: var(--color-text-tertiary); margin-bottom: 4px; }
+  .diamond-bar-bg { height: 4px; background: var(--color-border-tertiary); border-radius: 2px; overflow: hidden; }
+  .diamond-bar-fill { height: 4px; border-radius: 2px; background: #1D9E75; }
+  .diamond-score { font-size: 12px; font-weight: 500; color: var(--color-text-primary); margin-top: 4px; }
+  .divider { border: none; border-top: 0.5px solid var(--color-border-tertiary); margin: 1.5rem 0; }
+  .rec-block { background: #E1F5EE; border-radius: var(--border-radius-lg); padding: 1.25rem; margin-top: 1rem; }
+  .rec-title { font-size: 14px; font-weight: 500; color: #085041; margin-bottom: 0.5rem; }
+  .rec-text { font-size: 13px; color: #0F6E56; line-height: 1.6; }
+  .positioning-table { width: 100%; border-collapse: collapse; font-size: 13px; margin-bottom: 1.5rem; }
+  .positioning-table td { padding: 8px 12px; border-bottom: 0.5px solid var(--color-border-tertiary); color: var(--color-text-secondary); vertical-align: top; }
+  .positioning-table td:first-child { font-weight: 500; color: var(--color-text-primary); width: 40%; }
+</style>
+
+<div class="ba-root">
+  <h2 style="sr-only">Brand Alchemy Report — Company Brain</h2>
+
+  <div class="section-label">Product DNA — what was learned</div>
+  <div class="pov-block">
+    <p>A compiler layer that extracts the operational judgment scattered across Slack, SOPs, tickets and people's heads — and produces a versioned, evidence-linked, executable skills file any AI agent can consume.</p>
+    <p class="pov-sub">Not RAG. Not a chatbot. Not search. A compiler of how a company actually decides things — living, stale-aware, and infrastructure-grade.</p>
+  </div>
+
+  <div class="meta-grid">
+    <div class="meta-card">
+      <div class="mk">Category</div>
+      <div class="mv">AI Infrastructure</div>
+    </div>
+    <div class="meta-card">
+      <div class="mk">Audience</div>
+      <div class="mv">B2B SaaS Ops + AI Builders</div>
+    </div>
+    <div class="meta-card">
+      <div class="mk">Brand vibe</div>
+      <div class="mv">Authoritative + Precise</div>
+    </div>
+    <div class="meta-card">
+      <div class="mk">Core metaphor</div>
+      <div class="mv">Compiler, not assistant</div>
+    </div>
+    <div class="meta-card">
+      <div class="mk">Alternative today</div>
+      <div class="mv">Long system prompts, Notion docs</div>
+    </div>
+    <div class="meta-card">
+      <div class="mk">The moat</div>
+      <div class="mv">Stale detection + evidence trail</div>
+    </div>
+  </div>
+
+  <hr class="divider">
+
+  <div class="section-label">Category point of view (POV)</div>
+  <div class="pov-block" style="margin-bottom: 2rem;">
+    <p>The old category — "knowledge management" — is about humans finding information. The new category is <strong style="color:var(--color-text-primary)">operational memory infrastructure</strong>: the persistent, executable layer that lets AI agents inherit a company's judgment. The race isn't between AI models. It's between companies that give their agents operational memory and those that don't.</p>
+  </div>
+
+  <hr class="divider">
+
+  <div class="section-label">Phonosemantics key — sound symbolism used</div>
+  <div style="display:flex; gap:8px; flex-wrap:wrap; margin-bottom: 1.5rem;">
+    <span class="phono-pill p">P — plosive → authority, precision</span>
+    <span class="phono-pill l">L — liquid → intelligence, flow</span>
+    <span class="phono-pill f">F — fricative → speed, edge</span>
+    <span class="phono-pill" style="background:#FAECE7;color:#712B13;border-color:#F0997B;">N — nasal → warmth, connection</span>
+    <span class="phono-pill" style="background:#E6F1FB;color:#0C447C;border-color:#85B7EB;">K — hard plosive → technical force</span>
+  </div>
+
+  <div class="section-label">5 name candidates — linguistic breakdown + domain verification</div>
+
+  <!-- KERNL -->
+  <div class="name-card winner">
+    <div class="name-header">
+      <div class="name-title">Kernl</div>
+      <span class="winner-badge">★ top pick</span>
+      <div class="name-score">
+        <div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div>
+      </div>
+    </div>
+    <div class="name-tagline">"The operational kernel your AI agents run on."</div>
+    <div class="phono-row">
+      <span class="phono-pill p">K plosive — technical force</span>
+      <span class="phono-pill l">R liquid — intelligence</span>
+      <span class="phono-pill" style="background:#FAECE7;color:#712B13;border-color:#F0997B;">N nasal — familiar</span>
+      <span class="phono-pill" style="background:#E6F1FB;color:#0C447C;border-color:#85B7EB;">dropped 'e' — modern tech register</span>
+    </div>
+    <div class="name-reasoning">A kernel is the essential core of an operating system — the layer that mediates between hardware and everything above it. Kernl <em>is</em> that layer for AI agents: between raw company data and reliable automation. The dropped final 'e' (à la Tumblr, Flickr) signals a distinctly technical register. Infrastructure-grade naming — belongs alongside Redis, Kafka, Postgres.</div>
+    <div class="domain-row">
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> kernl.com</span>
+      <span class="domain-tag taken"><i class="ti ti-x" aria-hidden="true"></i> kernl.ai</span>
+      <span class="domain-tag taken"><i class="ti ti-x" aria-hidden="true"></i> kernl.io</span>
+    </div>
+  </div>
+
+  <!-- MELD -->
+  <div class="name-card">
+    <div class="name-header">
+      <div class="name-title">Meld</div>
+      <div class="name-score">
+        <div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot"></div>
+      </div>
+    </div>
+    <div class="name-tagline">"Melds scattered knowledge into a single executable mind."</div>
+    <div class="phono-row">
+      <span class="phono-pill" style="background:#FAECE7;color:#712B13;border-color:#F0997B;">M nasal — warmth, familiarity</span>
+      <span class="phono-pill l">L liquid — intelligence</span>
+      <span class="phono-pill p">D plosive — decisive, final</span>
+      <span class="phono-pill" style="background:#E6F1FB;color:#0C447C;border-color:#85B7EB;">1 syllable — maximum compression</span>
+    </div>
+    <div class="name-reasoning">To meld is to blend disparate elements into a unified whole. In card games, it means to lay down your hidden hand — revealing what was implicit. Both meanings map perfectly: Meld takes scattered, implicit operational knowledge and merges it into explicit, executable form. One syllable, pure infrastructure energy, zero ambiguity.</div>
+    <div class="domain-row">
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> meld.com</span>
+      <span class="domain-tag taken"><i class="ti ti-x" aria-hidden="true"></i> meld.ai</span>
+      <span class="domain-tag taken"><i class="ti ti-x" aria-hidden="true"></i> meld.io</span>
+    </div>
+  </div>
+
+  <!-- OPSLORE -->
+  <div class="name-card">
+    <div class="name-header">
+      <div class="name-title">Opslore</div>
+      <div class="name-score">
+        <div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot"></div>
+      </div>
+    </div>
+    <div class="name-tagline">"The living operational lore of your company, made executable."</div>
+    <div class="phono-row">
+      <span class="phono-pill p">P plosive — operational precision</span>
+      <span class="phono-pill f">S fricative — speed</span>
+      <span class="phono-pill l">L+R liquids — intelligence, depth</span>
+    </div>
+    <div class="name-reasoning">Lore is the body of accumulated, traditional knowledge belonging to a group — the unwritten rules, the cultural wisdom. "Opslore" is the operational lore of a company: how refunds get handled, why escalation chains exist, what the pricing exception rule actually is. The word has warmth and depth while remaining precise. Best domain position of any candidate — .com, .ai, and .io all clear.</div>
+    <div class="domain-row">
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> opslore.com</span>
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> opslore.ai</span>
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> opslore.io</span>
+    </div>
+  </div>
+
+  <!-- OPSCODEX -->
+  <div class="name-card">
+    <div class="name-header">
+      <div class="name-title">Opscodex</div>
+      <div class="name-score">
+        <div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot"></div>
+      </div>
+    </div>
+    <div class="name-tagline">"The compiled operational codex your agents execute from."</div>
+    <div class="phono-row">
+      <span class="phono-pill p">K+P plosives — double authority</span>
+      <span class="phono-pill" style="background:#EEEDFE;color:#3C3489;border-color:#AFA9EC;">X terminal — distinct, rare</span>
+      <span class="phono-pill" style="background:#E6F1FB;color:#0C447C;border-color:#85B7EB;">Codex etymology — compiled law</span>
+    </div>
+    <div class="name-reasoning">A codex was the ancient form of the book — sheets compiled and bound, replacing scrolls. Historically, codices preserved legal codes, canonical texts, laws. Opscodex is the compiled operational code of a company: the canonical, authoritative record of how things are decided. The terminal X adds sonic distinctiveness and technical sharpness. Carries scholarly gravitas — infrastructure, not a feature.</div>
+    <div class="domain-row">
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> opscodex.com</span>
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> opscodex.ai</span>
+    </div>
+  </div>
+
+  <!-- LOREKERN -->
+  <div class="name-card">
+    <div class="name-header">
+      <div class="name-title">Lorekern</div>
+      <div class="name-score">
+        <div class="dot filled"></div><div class="dot filled"></div><div class="dot filled"></div><div class="dot"></div><div class="dot"></div>
+      </div>
+    </div>
+    <div class="name-tagline">"The kernel of operational lore, distilled and executable."</div>
+    <div class="phono-row">
+      <span class="phono-pill l">L+R liquids — intelligence, flow</span>
+      <span class="phono-pill p">K plosive — technical core</span>
+      <span class="phono-pill" style="background:#FAECE7;color:#712B13;border-color:#F0997B;">N nasal — grounding</span>
+    </div>
+    <div class="name-reasoning">Morpheme blend of Lore (accumulated operational wisdom) and Kern (kernel/core). Reads as two concepts merged — like the product itself: taking the living lore of an organization and distilling it into an executable core. More descriptive and compound than the other candidates; works well if a human-warmth brand angle is preferred over pure infrastructure framing.</div>
+    <div class="domain-row">
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> lorekern.com</span>
+      <span class="domain-tag available"><i class="ti ti-check" aria-hidden="true"></i> lorekern.ai</span>
+    </div>
+  </div>
+
+  <hr class="divider">
+
+  <div class="section-label">Diamond test — top pick: Kernl</div>
+  <div class="diamond-grid">
+    <div class="diamond-item">
+      <div class="diamond-label">Distinctiveness</div>
+      <div class="diamond-bar-bg"><div class="diamond-bar-fill" style="width:96%"></div></div>
+      <div class="diamond-score">96</div>
+    </div>
+    <div class="diamond-item">
+      <div class="diamond-label">Processing fluency</div>
+      <div class="diamond-bar-bg"><div class="diamond-bar-fill" style="width:95%"></div></div>
+      <div class="diamond-score">95</div>
+    </div>
+    <div class="diamond-item">
+      <div class="diamond-label">Relevance</div>
+      <div class="diamond-bar-bg"><div class="diamond-bar-fill" style="width:97%"></div></div>
+      <div class="diamond-score">97</div>
+    </div>
+    <div class="diamond-item">
+      <div class="diamond-label">Energy</div>
+      <div class="diamond-bar-bg"><div class="diamond-bar-fill" style="width:88%"></div></div>
+      <div class="diamond-score">88</div>
+    </div>
+  </div>
+
+  <div class="rec-block">
+    <div class="rec-title">Final recommendation: Kernl</div>
+    <div class="rec-text">Register <strong>kernl.com</strong> immediately. The kernel metaphor is structurally perfect — it is the deepest, most precise analogy in the OS/infra vocabulary for what this product does. The hard K plosive delivers maximum technical authority. The dropped 'e' places it firmly in infrastructure naming tradition. It scales: "your company's Kernl", "deploy Kernl", "the Kernl API". It competes with Redis and Kafka on naming gravity, which is exactly the positioning the PRD demands.</div>
+  </div>
+
+  <hr class="divider">
+
+  <div class="section-label">Visual system direction</div>
+  <table class="positioning-table">
+    <tr><td>Mark style</td><td>Wordmark only. No icon. Infrastructure products don't need icons — they are the icon. Monospace or geometric sans. Think Stripe, Linear, Vercel.</td></tr>
+    <tr><td>Color</td><td>Single accent on near-black ground. Deep teal (#0F6E56) or electric indigo — evokes precision and living systems without the generic "AI blue" trap.</td></tr>
+    <tr><td>Voice</td><td>Declarative. Short sentences. Never explain — demonstrate. "12 skills. 58 seconds. Evidence-linked." — not "our platform leverages AI to..."</td></tr>
+    <tr><td>Tagline direction</td><td>"Operational memory for AI agents." — or — "Your AI knows how your company works."</td></tr>
+    <tr><td>Pitch one-liner</td><td>"Kernl compiles how your company decides into an executable skills file. Any agent. Any task. Correct every time."</td></tr>
+  </table>
+</div>

company_brain_PRD_v4.md

@@ -0,0 +1,1061 @@
+# Company Brain — Product Requirements Document
+**Version:** 4.0 — Final (Pre-Build, All Issues Resolved)
+**Date:** May 4, 2026
+**Authors:** Abhijith Pingali, Harshit Anand
+**Status:** Final — Build starts post-kickoff
+
+> **v4 changes over v3:**
+> 1. Ground truth table completed — all 12 Rivanly scenarios with expected action + skill
+> 2. `with_brain: false` behaviour fully documented in Section 9
+> 3. Section 10 user flow added — screen-to-screen navigation with decision points
+> 4. Competitive landscape updated with 8 real companies identified in LinkedIn thread
+> 5. Risk table updated: "knowledge never captured" risk added from Paul Breuler's comment
+> 6. Section 2.5 added: "The Stale Knowledge Problem" — validates drift detection as core feature
+> 7. Section 15 updated: execution boundary insight from Horizon Labs added to v2 roadmap
+
+---
+
+## 1. Executive Summary
+
+**Problem:** AI agents deployed by B2B companies behave like a new hire on day one — they lack the operational judgment embedded in how the company actually decides things. This knowledge lives in Slack threads, SOPs, support tickets, and people's heads, invisible to any model.
+
+**Solution:** Company Brain is a compilation layer that extracts this operational judgment and produces a versioned, evidence-linked, executable skills file any AI agent can consume to act like the company's best employee.
+
+**Success Criteria (Hackathon v0):**
+
+| KPI | Target |
+|---|---|
+| Full compilation pipeline: sources → 12 skills | Completes without error, every run |
+| Skills with confidence ≥ 0.7 | ≥ 10 of 12 |
+| Brain agent: correct action on all Rivanly scenarios | 12 / 12 correct |
+| Compilation time on AMD MI300X | < 90s (target 60s) |
+| Brain agent response latency | < 8s per query |
+
+---
+
+## 2. Problem Statement & Solution
+
+### 2.1 The Problem
+
+Every company trying to deploy AI automation hits the same wall. The models are good enough. The infrastructure is available. But the AI behaves like a new hire on day one — it doesn't know how the company actually operates.
+
+Refund policies live in Priya's head. Pricing exceptions get decided in Slack threads nobody archived. Escalation chains exist because three incidents taught the team the hard way. This operational knowledge — how the company actually decides things — is invisible to AI agents.
+
+Existing solutions miss this entirely. RAG retrieves document chunks. Chatbots answer questions. Neither gives an AI agent the operational judgment to do real work correctly and consistently.
+
+### 2.2 The Solution
+
+Company Brain is the missing compilation layer. It extracts the operational judgment embedded in how a company behaves — not what it documents, but how it actually decides — and compiles it into an executable, versioned, living skills file that any AI agent can use.
+
+**Agents are compilers, not assistants.** Company Brain's extraction agents do not summarize or search. They convert messy human behavior into structured, executable logic. The downstream brain agent that does real work is a consumer of that compiled output — it never reasons from scratch.
+
+### 2.3 One-Line Pitch
+
+> "We turn how your company actually operates into an executable Company Brain. Any agent can use it to do real work without guessing."
+
+### 2.4 Product Positioning
+
+Company Brain is **infrastructure, not a feature.**
+
+| What it is NOT | What it IS |
+|---|---|
+| RAG over documents | Compiler of operational judgment |
+| Chatbot over your data | Executable skills file for AI agents |
+| A search engine | A living map of how your company works |
+| One-time snapshot | Versioned, updatable, drift-aware |
+
+### 2.5 The Stale Knowledge Problem (Why "Living" Matters)
+
+*Validated by multiple practitioners in the YC RFS LinkedIn thread.*
+
+The hardest part of any knowledge system is not building it — it is keeping it alive. Most companies will document their workflows once, ship the AI agent, and within six weeks the map diverges from reality. A new pricing exception gets approved in a Slack DM. An escalation chain changes when someone leaves. The AI keeps following the old rules.
+
+Company Brain's stale detection — SHA-256 hashing of source files, `stale: true` badges on affected skills, and recompile triggers — directly solves this. The skills file is not a document. It is a living artifact that stays current with how the company actually evolves.
+
+This is not a minor feature. It is the moat.
+
+### 2.6 What Company Brain Does NOT Solve (v0)
+
+*Acknowledged risk from Paul Breuler (BaseState founder), LinkedIn thread:*
+
+> "The decisions that matter happen in context, on the ground, and were never captured in a ticket or Slack thread."
+
+Company Brain compiles knowledge that was captured somewhere — Slack, SOPs, tickets, call transcripts. Knowledge that exists only in someone's head and was never written down or discussed in any recorded channel cannot be extracted. This is a known limitation. The pitch should never claim to capture all company knowledge — only the knowledge that was communicated in any digital form.
+
+For v1, voice call transcription addresses a portion of this gap. For v2, an active knowledge capture interface (where employees record decisions as they happen) closes it further.
+
+---
+
+## 3. Target Customer & User Personas
+
+### 3.1 Primary Wedge — v1
+
+**B2B SaaS companies, 10–50 employees, actively deploying AI automation for the first time.**
+
+These companies have:
+- Enough operational complexity that AI agents fail without context
+- Enough technical sophistication to understand why RAG isn't solving their problem
+- Enough urgency to pay for a solution (they are actively trying and failing to deploy AI)
+- Not enough resources to build this infrastructure themselves
+
+### 3.2 User Personas
+
+| Persona | Role | Primary Goal | Pain Point |
+|---|---|---|---|
+| **Ops Owner** | Head of Operations / Founder | Get AI agents to handle work consistently | Agents hallucinate edge cases; policies go stale |
+| **AI Builder** | Developer / Automation Lead | Consume company knowledge in agent prompts | No structured source of truth to inject into prompts |
+| **Agent Consumer** | Support agent, AM, anyone using the AI | Get correct, policy-backed responses instantly | Generic AI responses that don't match company policy |
+| **Demo Viewer / Judge** | Hackathon judge, investor, prospect | Understand what the product does in 5 minutes | Can't distinguish this from "just another RAG tool" |
+
+### 3.3 Fictional Reference Customer — Rivanly Inc.
+
+Rivanly is a 15-person B2B SaaS company used throughout this document and the demo. 6 departments, 12 operational skills. Enough complexity to make the product real, small enough to demo in 5 minutes.
+
+### 3.4 Expanded Customer Universe — v2+
+
+- E-commerce operators (refund, shipping, returns automation)
+- Agencies (client approval, scope change, billing exception workflows)
+- Healthcare admin (referral routing, prior authorization, scheduling exceptions)
+- Legal operations (intake, escalation, matter routing)
+
+---
+
+## 4. Jobs To Be Done
+
+| Job | Current Solution | Problem |
+|---|---|---|
+| "I want an AI agent to handle customer refunds correctly" | Write a long system prompt with refund rules | Rules go stale, edge cases missed, no evidence trail |
+| "I need to onboard a new AI tool to how we operate" | Document everything manually in Notion | Takes weeks, immediately outdated, agent still hallucinates |
+| "I want to know if my AI agent is following company policy" | Read agent logs manually | No structured audit trail linking actions to rules |
+| "We updated our pricing policy — the AI needs to know" | Edit the system prompt manually | No systematic way to detect or propagate policy changes |
+| "Why did the agent make that decision?" | Cannot answer | No evidence chain from agent action back to source |
+
+---
+
+## 5. User Stories
+
+### Source Ingestion & File Handling
+
+1. As an Ops Owner, I want to upload `.md` Notion SOPs so that my written policies are ingested without manual reformatting.
+2. As an Ops Owner, I want to upload Slack JSON exports so that informal decision patterns from real conversations are captured.
+3. As an Ops Owner, I want to upload Zendesk ticket JSON exports so that resolved case reasoning is extracted as evidence.
+4. As an Ops Owner, I want the system to detect unchanged files by SHA-256 hash so that re-uploading a file doesn't trigger unnecessary re-extraction.
+5. As an Ops Owner, I want a clear parse error message when a file is malformed so that I know exactly which file to fix.
+6. As an Ops Owner, I want unsupported file types to be rejected with a helpful error so that I don't wait for a compilation that will fail.
+7. As an Ops Owner, I want source files stored in Supabase so that I don't need to re-upload them on every compile.
+
+### Compilation Pipeline
+
+8. As an Ops Owner, I want 4 extraction agents to run in parallel on AMD MI300X so that compilation completes under 90 seconds instead of 8+ minutes.
+9. As an Ops Owner, I want IF-THEN-EXCEPT decision rules extracted from Slack threads so that informal decisions become structured, executable policies.
+10. As an Ops Owner, I want sequential process steps extracted from SOPs and runbooks so that workflow sequences are captured correctly.
+11. As an Ops Owner, I want edge cases, overrides, and "unless..." patterns extracted specifically so that exception logic isn't lost in summarization.
+12. As an Ops Owner, I want contradictions between SOPs and actual Slack/ticket behavior flagged so that I can identify and resolve policy drift.
+13. As an Ops Owner, I want skills with confidence below 0.6 to be flagged for human review rather than auto-published so that only verified rules go live.
+14. As an Ops Owner, I want each decision rule backlinked to its source file and excerpt so that every policy is auditable, not asserted.
+15. As an Ops Owner, I want the system to retry once if the LLM returns malformed JSON so that a single bad LLM response doesn't abort the whole compile.
+16. As an Ops Owner, I want a clear compile error message if vLLM becomes unreachable so that I know the issue is infrastructure, not my data.
+17. As a Developer, I want LangGraph checkpointing via MemorySaver so that a crashed compile can be inspected and does not silently lose data.
+
+### Skills File & Schema
+
+18. As an Ops Owner, I want each skill stored as a versioned JSON object with id, name, domain, confidence, decision_logic, forbidden_actions, escalation_chain, and evidence_sources so that the schema is complete and consistent.
+19. As an Ops Owner, I want skills converted to markdown at query time so that they are injected into LLM prompts efficiently.
+20. As an Ops Owner, I want the meta block of the skills file to store source hashes so that stale skills can be detected when source files change.
+21. As an Ops Owner, I want the skills file versioned with semver so that every compile produces a traceable snapshot.
+
+### Version Management & Drift Detection
+
+22. As an Ops Owner, I want to compare any two historical brain versions in a diff view so that I can see exactly what changed after a policy update.
+23. As an Ops Owner, I want changed rules highlighted in the diff (added green, removed red, modified yellow) so that I don't have to read everything to spot changes.
+24. As an Ops Owner, I want stale skills badged in the Skills Viewer so that I know which skills need recompilation after a source file changed.
+25. As an Ops Owner, I want at least 2 pre-seeded historical versions in the demo so that the diff view is usable on day one.
+
+### Brain Dashboard (Frontend)
+
+26. As an Ops Owner, I want a "Build Company Brain" button on the dashboard so that I can trigger recompilation from the UI without touching a terminal.
+27. As an Ops Owner, I want the button to be disabled with a spinner during an active compile so that I can't trigger duplicate jobs.
+28. As an Ops Owner, I want a real-time SSE feed showing each pipeline node completing with timestamps so that I trust the system is working.
+29. As an Ops Owner, I want the compilation time displayed to the second so that I can use this as a live AMD MI300X proof point.
+30. As an Ops Owner, I want the current brain version and last-compiled timestamp visible at a glance so that I know which brain is active.
+
+### Skills Viewer (Frontend)
+
+31. As an Ops Owner, I want skills grouped by department so that I can navigate to the right area quickly.
+32. As an Ops Owner, I want a visual confidence bar per skill so that I can immediately see which skills are strong vs. uncertain without reading numbers.
+33. As an Ops Owner, I want to expand any skill and see all its decision conditions and forbidden actions so that I can verify the rules are correct.
+34. As an Ops Owner, I want the evidence panel per skill to show source file names and excerpts so that I can trace every policy back to where it came from.
+
+### Brain Agent (Demo)
+
+35. As an AI Builder, I want to submit a natural language scenario to the brain agent so that I get a structured action recommendation with evidence, not a guess.
+36. As an AI Builder, I want the response to include the exact rule condition that matched so that I can verify the logic is correct.
+37. As an AI Builder, I want the agent to gracefully handle scenarios with no matching skill so that low-confidence situations escalate to a human rather than produce a wrong answer.
+38. As a Demo Viewer / Judge, I want to see the agent without the brain respond generically to the same scenario so that the value of the compilation layer is immediately obvious.
+39. As a Demo Viewer / Judge, I want to see the "Change a SOP rule → Rebuild → same scenario → different outcome" flow so that I understand this is a living map, not a static snapshot.
+
+---
+
+## 6. Product Scope
+
+### 6.1 Three-Ring Model
+
+| Ring | Name | Timeline | What Ships |
+|---|---|---|---|
+| **Ring 1** | Hackathon v0 | May 4–10, 2026 | Offline compiler, Rivanly demo, file upload inputs, brain agent demo |
+| **Ring 2** | Product v1 | 4–6 weeks post-hackathon | Live connectors, multi-tenant, real company data, auth |
+| **Ring 3** | Scale | 2–6 months | Agent SDK, skills marketplace, audit trails, RBAC |
+
+### 6.2 Hackathon v0 — In Scope
+
+- Multi-agent compilation pipeline (LangGraph, 4 parallel async extraction agents)
+- 6-department, 12-skill coverage of Rivanly Inc.
+- Synthetic dataset (8 source files authored before kickoff)
+- Skills file: JSON storage, markdown runtime, evidence-linked, confidence-scored, versioned
+- Brain agent: scenario input → in-memory skill match → structured response with rule trace
+- Frontend: Brain Dashboard + Skills Viewer + Demo Agent panel
+- Real-time SSE compilation progress feed
+- Brain version diffing (v1.2 → v1.3 what changed)
+- AMD MI300X deployment via vLLM (`RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic`)
+- Side-by-side "with brain vs. without brain" comparison panel — **P0, the money shot**
+- Build in Public: 2 posts on X/LinkedIn during build
+
+### 6.3 Out of Scope for v0
+
+- Real Slack, Notion, Zendesk OAuth connectors — file upload only
+- Multi-tenant isolation — single company demo
+- Auth / login — none required for demo
+- Redis job queue — direct `graph.ainvoke()` only
+- pgvector — in-memory sentence-transformers for v0 skill matching
+- Webhook-triggered recompilation
+- Human skill review queue UI
+
+### 6.4 Team Ownership
+
+| Owner | Scope |
+|---|---|
+| **Abhijith** | F-01, F-02, F-03, F-04, F-05, F-06, F-07, F-12 (pipeline + API) |
+| **Harshit** | F-08, F-09, F-10, F-11 (all frontend) |
+| **Both** | Synthetic dataset — 4 files each, done before May 4 kickoff |
+
+---
+
+## 7. Feature Requirements
+
+Priority: **[P0]** = demo breaks without it · **[P1]** = must ship · **[P2]** = ship if time allows
+
+---
+
+### F-01: Source Ingestion [P0]
+
+**Functional Requirements:**
+- Accept `.md`, `.json`, `.txt` file uploads
+- Parse Notion SOP markdown → `structured_sops[]`
+- Parse Slack export JSON → `normalized_events[]`
+- Parse ticket JSON → `resolved_cases[]`
+- Compute SHA-256 hash per file; compare to previous run; skip unchanged files
+- No LLM calls at this stage — pure Python parsing only
+
+**Acceptance Criteria:**
+
+*AC-01-1:*
+- **Given** a valid Notion SOP `.md` file is uploaded
+- **When** the ingest node runs
+- **Then** `structured_sops` contains at least one entry with `source`, `content`, and `type` fields
+
+*AC-01-2:*
+- **Given** a file was uploaded in a previous compile with hash `H`
+- **When** the same file is uploaded again unchanged
+- **Then** the ingestion node skips extraction for that file and logs "hash match, skipping"
+
+*AC-01-3:*
+- **Given** a malformed JSON file is uploaded
+- **When** the ingest node attempts to parse it
+- **Then** the SSE stream emits `node_error` with `file`, `error: "parse_error"`, and `detail` — and the compile continues with remaining files
+
+*AC-01-4:*
+- **Given** an unsupported file type (e.g. `.xlsx`) is uploaded
+- **When** `POST /sources/upload` is called
+- **Then** the API returns `400` with `{"error": "unsupported_file_type", "accepted": [".md", ".json", ".txt"]}`
+
+---
+
+### F-02: Parallel Extraction [P0]
+
+**Functional Requirements:**
+- Four async LangGraph nodes run simultaneously via `Send` API + `await llm.ainvoke()`
+- Decision Extractor: IF-THEN-EXCEPT judgment patterns from Slack + tickets
+- Workflow Extractor: sequential process steps from SOPs and runbooks
+- Exception Extractor: edge cases, overrides, "unless..." patterns
+- Contradiction Detector: divergence between SOPs and actual behavior
+- All four target `RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic` on AMD MI300X via vLLM
+
+**Acceptance Criteria:**
+
+*AC-02-1:*
+- **Given** all three ingest nodes have completed
+- **When** `route_to_extractors` is called
+- **Then** all four extraction nodes start within 2 seconds of each other
+
+*AC-02-2:*
+- **Given** the Rivanly synthetic dataset
+- **When** extraction completes
+- **Then** each extractor returns a non-empty list; `contradictions[]` contains ≥ 1 entry
+
+*AC-02-3:*
+- **Given** the LLM returns malformed JSON for one extractor
+- **When** the node catches the error
+- **Then** it retries once with a stricter JSON-only prompt; if still malformed, returns empty list and emits `node_error` without aborting other extractors
+
+*AC-02-4:*
+- **Given** all four async extractors complete
+- **When** wall clock is checked
+- **Then** total extraction time is under 45 seconds on MI300X
+
+---
+
+### F-03: Skill Compilation [P0]
+
+**Functional Requirements:**
+- Synthesize extractor outputs into 12 canonical skill objects
+- Evidence linker: backfill `evidence_sources[]` for every `decision_logic` entry
+- Confidence scorer: `f(source_count, source_recency, internal_consistency)`
+- Skills below 0.6 confidence: present with `"review_required": true`, not auto-published
+- Write `skills_file.json` to Supabase `skills_files` table with incremented semver
+
+**Acceptance Criteria:**
+
+*AC-03-1:*
+- **Given** all extraction nodes have produced output
+- **When** `synthesize_skills` runs
+- **Then** output contains exactly 12 skill objects, each with all required schema fields
+
+*AC-03-2:*
+- **Given** a skill has been synthesized
+- **When** `link_evidence` runs
+- **Then** every `decision_logic` entry has at least one `evidence_sources` entry with non-empty `source` and `excerpt`
+
+*AC-03-3:*
+- **Given** a skill has only one supporting source
+- **When** `score_confidence` runs
+- **Then** that skill's `confidence` is below 0.7 and `review_required` is `true` if below 0.6
+
+*AC-03-4:*
+- **Given** compilation succeeds
+- **When** `write_brain` runs
+- **Then** `skills_files` table gains a new row with semver one minor bump higher, `is_current: true`, and all previous rows `is_current: false`
+
+---
+
+### F-04: Skills File Format [P0]
+
+**Schema (per skill):**
+```json
+{
+  "id": "handle_refund_request",
+  "name": "Handle Refund Request",
+  "domain": "support",
+  "version": "1.2",
+  "confidence": 0.91,
+  "stale": false,
+  "review_required": false,
+  "last_updated": "2026-05-04T09:30:00Z",
+  "trigger": {
+    "phrases": ["refund", "money back"],
+    "conditions": ["customer mentions payment dissatisfaction"]
+  },
+  "decision_logic": [
+    {
+      "condition": "plan == 'annual' AND days_since_purchase <= 14",
+      "action": "approve_full_refund",
+      "note": "No-questions policy within 14 days.",
+      "evidence_sources": [
+        { "source": "notion_refund_sop.md", "excerpt": "...", "confidence": 0.95 }
+      ]
+    }
+  ],
+  "forbidden_actions": ["Never process refunds for lifetime deal accounts"],
+  "escalation_chain": ["support_agent", "support_lead", "account_manager", "founder"],
+  "sla": "respond_within_2h, resolve_within_24h"
+}
+```
+
+**Acceptance Criteria:**
+
+*AC-04-1:*
+- **Given** the compiled skills file
+- **When** validated against JSON schema
+- **Then** zero validation errors
+
+*AC-04-2:*
+- **Given** a skill selected for prompt injection
+- **When** converted to markdown
+- **Then** output is plain English, contains all conditions and forbidden actions, under 800 tokens
+
+---
+
+### F-05: Brain Version Management [P1]
+
+**Acceptance Criteria:**
+
+*AC-05-1:*
+- **Given** one source file changed and recompilation triggered
+- **When** compile finishes
+- **Then** new brain version is a minor bump (`1.2.0 → 1.3.0`) and diff endpoint returns that file's dependent skills as `modified_skills`
+
+*AC-05-2:*
+- **Given** two brain versions exist
+- **When** `GET /diff/1.2.0/1.3.0` is called
+- **Then** response contains `added_skills`, `removed_skills`, and `modified_skills` with per-skill field-level changes
+
+*AC-05-3:*
+- **Given** a source file changes
+- **When** the new compile runs
+- **Then** skills whose `evidence_sources` reference that file have `stale: true`
+
+---
+
+### F-06: Scenario Handling — Brain Agent [P0]
+
+**Functional Requirements:**
+- Accept natural language scenario input + optional structured context
+- Embed query via `all-MiniLM-L6-v2` (in-memory, CPU); pre-compute skill embeddings once at startup
+- Cosine similarity match → select top skill
+- Convert skill JSON → markdown snippet
+- Single LLM call: company context + skill rules + scenario
+- Return structured response (F-07)
+
+**Acceptance Criteria:**
+
+*AC-06-1:*
+- **Given** an enterprise refund scenario
+- **When** `POST /agent/handle` is called
+- **Then** matched skill is `handle_refund_request` (cosine similarity > 0.6)
+
+*AC-06-2:*
+- **Given** all 12 Rivanly demo scenarios submitted in sequence
+- **When** each response reviewed
+- **Then** all 12 return correct action (verified against ground truth table in Section 12)
+
+*AC-06-3:*
+- **Given** a scenario matching no skill above cosine 0.4
+- **When** match function runs
+- **Then** response is `{"action": "escalate_to_human", "reason": "no_skill_match", "confidence": <score>}` — not an error, not a hallucination
+
+*AC-06-4:*
+- **Given** a valid scenario submitted
+- **When** response returned
+- **Then** wall-clock latency under 8 seconds
+
+---
+
+### F-07: Response Structure [P0]
+
+Every `POST /agent/handle` response:
+
+```json
+{
+  "action": "escalate_to_am_within_1hr",
+  "message_to_customer": "...",
+  "rule_applied": "plan == 'enterprise' AND any_amount",
+  "evidence": {
+    "source": "slack_thread_2024-03-12",
+    "excerpt": "enterprise = always AM"
+  },
+  "skill_matched": "handle_refund_request",
+  "confidence": 0.91
+}
+```
+
+**Acceptance Criteria:**
+
+*AC-07-1:*
+- **Given** any valid scenario input
+- **When** brain agent responds
+- **Then** all six top-level fields present and non-null
+
+*AC-07-2:*
+- **Given** the response `rule_applied` field
+- **When** compared to matched skill's `decision_logic`
+- **Then** string matches an exact `condition` field — never paraphrased
+
+---
+
+### F-08: Brain Dashboard [P0]
+
+**Acceptance Criteria:**
+
+*AC-08-1:*
+- **Given** the dashboard is loaded
+- **When** user clicks "Build Company Brain"
+- **Then** button becomes disabled with spinner and SSE feed begins showing node events within 2 seconds
+
+*AC-08-2:*
+- **Given** SSE stream is active
+- **When** each pipeline node completes
+- **Then** feed shows node name, completion checkmark, and elapsed time in real time without page refresh
+
+*AC-08-3:*
+- **Given** compilation completes
+- **When** dashboard updates
+- **Then** brain version, last-compiled timestamp, and total compilation time displayed with correct values
+
+---
+
+### F-09: Skills Viewer [P0]
+
+**Acceptance Criteria:**
+
+*AC-09-1:*
+- **Given** a compiled brain with 12 skills
+- **When** Skills Viewer loaded
+- **Then** all 12 skills visible, grouped under 6 correct department headings
+
+*AC-09-2:*
+- **Given** a skill with `stale: true`
+- **When** it appears in the viewer
+- **Then** it has a visible "Stale" badge and confidence bar is visually de-emphasized
+
+*AC-09-3:*
+- **Given** user clicks any skill
+- **When** detail panel expands
+- **Then** all `decision_logic` conditions, all `forbidden_actions`, `escalation_chain`, and at least one `evidence_sources` entry visible
+
+---
+
+### F-10: Demo Agent Panel [P0] — Side-by-Side Required
+
+**Functional Requirements:**
+- Free-text scenario input + optional structured context fields
+- Two response panels rendered simultaneously:
+  - **Without Brain:** Same LLM, same scenario, system prompt contains only the raw scenario — no company name, no skills context, no Rivanly-specific information. Goal: produce a demonstrably generic response.
+  - **With Brain:** Full skill context + rule trace + evidence
+- Visual trace showing matched skill and cosine similarity score
+
+**Acceptance Criteria:**
+
+*AC-10-1:*
+- **Given** a scenario submitted
+- **When** both panels render
+- **Then** both responses appear within 10 seconds
+
+*AC-10-2:*
+- **Given** the enterprise refund demo scenario
+- **When** both panels render
+- **Then** "Without Brain" response is generic (no company-specific rule, no evidence); "With Brain" response includes `rule_applied` and `evidence` visually highlighted
+
+*AC-10-3:*
+- **Given** a judge views the demo panel for the first time
+- **When** they read both responses
+- **Then** the value of the brain is legible without any verbal explanation
+
+---
+
+### F-11: Version Diff View [P1]
+
+**Acceptance Criteria:**
+
+*AC-11-1:*
+- **Given** two pre-seeded brain versions (v1.1.0 and v1.2.0)
+- **When** diff view opened and both selected
+- **Then** modified skills highlighted yellow with field-level changes inline
+
+*AC-11-2:*
+- **Given** the "change a rule → rebuild → diff" demo flow
+- **When** performed end-to-end
+- **Then** diff correctly shows changed rule in under 30 seconds of demo time
+
+---
+
+### F-12: API Layer [P0]
+
+**`POST /compile`**
+```
+Request:  { "company_id": "rivanly-inc", "force_recompile": false }
+Response: { "job_id": "uuid", "status": "started", "stream_url": "/compile/stream?job_id=uuid" }
+```
+
+**`GET /brain/status`**
+```
+Response: {
+  "company_id": "rivanly-inc",
+  "brain_version": "1.3.0",
+  "last_compiled_at": "2026-05-04T09:30:00Z",
+  "total_skills": 12,
+  "stale_skills": 2,
+  "coverage_areas": ["support", "revenue", "product_eng", "customer_success", "hr", "finance_ops"]
+}
+```
+
+**`GET /skills`**
+```
+Response: {
+  "skills": [
+    { "id": "handle_refund_request", "name": "Handle Refund Request",
+      "domain": "support", "confidence": 0.91, "stale": false, "version": "1.2" }
+  ]
+}
+```
+
+**`GET /skills/:id`** → full skill object (schema per F-04)
+
+**`POST /agent/handle`**
+```
+Request: {
+  "scenario": "Enterprise customer, 18 months tenure, wants $1,200 refund",
+  "context": { "plan": "enterprise", "tenure_months": 18, "refund_amount": 1200 },
+  "with_brain": true
+}
+```
+
+**`with_brain` flag behaviour (fully specified):**
+- `with_brain: true` → system prompt includes: company name (Rivanly), active brain version, relevant skill in markdown, all decision conditions, forbidden actions, escalation chain
+- `with_brain: false` → system prompt contains ONLY the raw scenario text. No company name. No skills context. No Rivanly-specific information. No hint that a brain exists. The goal is to produce a generic response from the base model that demonstrates what agents do WITHOUT the compilation layer. This is the "before" panel in the side-by-side comparison.
+
+**`GET /compile/stream?job_id=uuid`** — SSE event schema:
+```
+event: node_start
+data: {"node": "ingest_slack", "timestamp": "2026-05-04T09:30:01Z"}
+
+event: node_complete
+data: {"node": "ingest_slack", "duration_ms": 312, "output_count": 47}
+
+event: node_error
+data: {"node": "extract_decisions", "error": "llm_malformed_json", "retrying": true}
+
+event: compile_complete
+data: {
+  "brain_version": "1.3.0",
+  "total_skills": 12,
+  "stale_skills": 0,
+  "duration_ms": 54200,
+  "skills_below_threshold": 1
+}
+
+event: compile_error
+data: {"error": "llm_unavailable", "checkpoint_saved": true, "resume_job_id": "uuid"}
+```
+
+**`GET /diff/:v1/:v2`**
+```
+Response: {
+  "from_version": "1.2.0", "to_version": "1.3.0",
+  "added_skills": [], "removed_skills": [],
+  "modified_skills": [
+    { "id": "handle_refund_request",
+      "changes": [{"field": "decision_logic[1].action",
+                   "from": "approve_prorated_refund", "to": "escalate_to_am"}] }
+  ]
+}
+```
+
+**`POST /sources/upload`**
+```
+Request:  multipart/form-data: files[], company_id
+Response: { "uploaded": ["notion_refund_sop.md"], "hashes": {"notion_refund_sop.md": "sha256:a1b2c3..."} }
+```
+
+---
+
+## 8. AI System Requirements
+
+### 8.1 Tool & Model Requirements
+
+| Component | Tool / Model | Reason |
+|---|---|---|
+| All LLM extraction calls | `RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic` via vLLM | Best instruction following; FP8 = 1.5× throughput, ~72GB VRAM |
+| Skill matching (v0) | `all-MiniLM-L6-v2` via `sentence-transformers` (in-memory, CPU) | Zero infra overhead; sufficient for 12 skills |
+| Skill matching (v1) | pgvector on Supabase | Multi-tenant, persistent, scalable |
+| LLM fallback | `Llama-3.3-70B BF16` | If Qwen2.5 unavailable on MI300X |
+| Serving | vLLM on AMD MI300X (192GB VRAM) | Parallel batch inference, OpenAI-compatible API |
+
+### 8.2 Extraction Prompts — Requirements
+
+- All extractors demand: "Output ONLY structured JSON. Do not summarize. Do not generalize beyond what the text explicitly supports."
+- All extractors include: output schema definition + 1-shot example in system prompt
+- Temperature: 0.1 (deterministic extraction)
+- Max tokens: 4096 per call
+
+### 8.3 Evaluation Strategy
+
+| Eval | Target | How to test |
+|---|---|---|
+| Brain agent correct action | 12 / 12 (100%) | Run all 12 scenarios against ground truth table |
+| Evidence coverage | 100% of `decision_logic` entries have ≥ 1 `evidence_sources` | JSON schema validation post-compile |
+| Contradiction recall | ≥ 2 contradictions flagged | Plant 2 deliberate contradictions in synthetic dataset |
+| Confidence calibration | Well-sourced skills ≥ 0.7, single-source skills < 0.75 | Inspect post-compile |
+| LLM JSON validity | 0 uncaught malformed responses in 10-run stress test | Run compile 10× on same dataset |
+| "Without brain" failure rate | ≥ 8 of 12 scenarios produce generic/wrong response | Verify demo panel contrast is meaningful |
+
+---
+
+## 9. Implementation Decisions
+
+**`with_brain: false` — Full Specification**
+
+When `POST /agent/handle` is called with `"with_brain": false`, the system prompt sent to Qwen2.5-72B contains ONLY this:
+
+```
+You are a helpful customer support assistant.
+The customer says: {scenario}
+{context if provided}
+Respond appropriately.
+```
+
+No company name. No skills. No Rivanly. No hint that any compiled knowledge exists. The base model responds from its training data alone. This produces a generic, policy-free response — which is the "before" state that makes the "with brain" response look like magic.
+
+**Other key architectural decisions:**
+
+- `ingest_join` + `Send` API pattern required for correct LangGraph fan-in. Direct edges ingest→extract cause synthesis to fire before all extractors complete.
+- `Annotated[List, operator.add]` on all extraction output fields required for parallel writes to merge correctly rather than overwrite.
+- `await compiled_graph.ainvoke(initial_state)` — not `.invoke()` — in FastAPI background task. Without async, nodes block the event loop and parallelism is lost.
+- Skills file is the only source of truth. The agent never reads raw source files at query time.
+- `skills_files.is_current` enforced via partial unique index — only one row per company can be `true` at a time.
+- `compile_runs` table is append-only. No updates.
+
+---
+
+## 10. Technical Specifications
+
+### 10.1 Architecture Overview
+
+```
+FILE UPLOAD (Next.js)
+       │
+       ▼ POST /sources/upload
+FASTAPI API LAYER
+       │
+       ▼ POST /compile → ainvoke
+LANGGRAPH ENGINE (BrainState)
+  │
+  ├── INGESTION (parallel, CPU)
+  │   ├── ingest_slack → normalized_events[]
+  │   ├── ingest_notion → structured_sops[]
+  │   └── ingest_tickets → resolved_cases[]
+  │   └── ingest_join (barrier)
+  │
+  ├── EXTRACTION (parallel, async, AMD MI300X)
+  │   ├── extract_decisions → raw_decisions[]
+  │   ├── extract_workflows → workflow_steps[]
+  │   ├── extract_exceptions → exception_rules[]
+  │   └── detect_contradictions → contradictions[]
+  │
+  └── COMPILATION + VALIDATION (sequential)
+      ├── synthesize_skills → draft_skills[]
+      ├── link_evidence → skills_with_evidence[]
+      ├── score_confidence → confidence per skill
+      └── write_brain → skills_file.json → Supabase
+
+BRAIN AGENT (query time)
+  POST /agent/handle
+  → sentence-transformers match → skill JSON → markdown
+  → single vLLM call → structured response JSON
+```
+
+### 10.2 Screen-to-Screen User Flow
+
+**Primary flow (Ops Owner compiling and testing for the first time):**
+
+```
+[Upload Sources page]
+  → Upload 3–8 files (drag + drop or file picker)
+  → See file list with SHA-256 hash status (new / unchanged / changed)
+  → Click "Done — Go to Dashboard"
+       ↓
+[Brain Dashboard]
+  → See: company name, current brain version (or "No brain yet"), last compiled timestamp
+  → See: source files uploaded (count)
+  → Click "Build Company Brain" button
+       ↓
+[SSE Progress overlay — renders in-place on Dashboard]
+  → Real-time: each node appears as it starts, gets checkmark when complete
+  → ingest_slack ✓ → ingest_notion ✓ → ingest_tickets ✓ → [join]
+  → extract_decisions ✓ (parallel) extract_workflows ✓ extract_exceptions ✓ detect_contradictions ✓
+  → synthesize_skills ✓ → link_evidence ✓ → score_confidence ✓ → write_brain ✓
+  → "Brain compiled: v1.3.0 in 58 seconds"
+       ↓
+[Brain Dashboard — updated state]
+  → Version badge updated: v1.3.0
+  → Last compiled: just now
+  → 12 skills / 6 departments / 0 stale
+  → Click "View Skills" (or nav to Skills in sidebar)
+       ↓
+[Skills Viewer]
+  → 6 department groups, 12 skill cards
+  → Each card: name, confidence bar, stale badge (if applicable)
+  → Click any skill card → detail panel expands right
+  → Detail: all conditions, forbidden actions, escalation chain, evidence panel (source + excerpt)
+  → Click "Try a scenario" button (appears in detail panel)
+       ↓
+[Demo Agent Panel]
+  → Left panel: "Without Brain" — base model response (generic)
+  → Right panel: "With Brain" — rule trace + evidence + action
+  → Scenario input pre-filled from skill that was clicked (optional convenience)
+  → Submit → both panels render simultaneously
+  → Judge reads both — value is self-evident
+  → Click "What changed?" link (appears in top nav after ≥ 2 brain versions exist)
+       ↓
+[Version Diff View]
+  → Select v1 and v2 from dropdowns (pre-seeded with v1.1.0 and v1.2.0)
+  → See: modified skills (yellow), new skills (green), removed (red)
+  → Click modified skill → see field-level diff of changed conditions
+  → Click "← Back to Dashboard" (always accessible from nav)
+       ↓
+[Brain Dashboard]
+  → Modify a source file → re-upload → stale badge appears on affected skills
+  → Click "Build Company Brain" → recompile cycle repeats
+```
+
+**Critical path for demo (8-step script):**
+Upload Sources → Dashboard → Build → SSE feed → Skills Viewer → Evidence panel → Demo Agent (side-by-side) → Change + Rebuild → Diff view
+
+**Navigation rules:**
+- Sidebar always visible: Dashboard | Skills | Agent | Diff
+- "Try a scenario" shortcut from Skills Viewer pre-fills the Agent panel's skill context
+- "What changed?" link only appears when ≥ 2 brain versions exist (prevents confusion when first compiled)
+- All pages accessible from nav at any time — no forced linear flow outside the demo script
+
+### 10.3 Integration Points
+
+| Integration | v0 | v1 |
+|---|---|---|
+| LLM | vLLM on AMD MI300X (private IP:8000) | Same + failover |
+| Database | Supabase Postgres | Same + RLS per company |
+| File storage | Supabase Storage | Same |
+| Auth | None | Clerk |
+| Queue | None (direct ainvoke) | Redis/Upstash |
+| Connectors | File upload only | Slack OAuth, Notion API, Zendesk |
+| Checkpointing | MemorySaver (in-memory) | PostgresSaver |
+
+### 10.4 Security & Privacy
+
+**v0 (hackathon):** All data is synthetic (Rivanly is fictional). No PII. vLLM on private AMD cloud IP. No RLS needed.
+
+**v1 (required before real customer data):**
+- Clerk auth on all endpoints
+- Supabase RLS: `company_id` row-level isolation
+- vLLM behind VPC — not publicly accessible
+- No customer message content stored permanently — only extracted rules and evidence excerpts
+
+---
+
+## 11. Data Model (Supabase)
+
+```sql
+CREATE TABLE companies (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE TABLE skills_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  version TEXT NOT NULL,
+  brain_json JSONB NOT NULL,
+  source_hashes JSONB NOT NULL,
+  compiled_at TIMESTAMPTZ DEFAULT now(),
+  is_current BOOLEAN DEFAULT false
+);
+CREATE UNIQUE INDEX idx_skills_files_current ON skills_files(company_id) WHERE is_current = true;
+
+CREATE TABLE skills (
+  id TEXT NOT NULL,
+  company_id TEXT REFERENCES companies(id),
+  skills_file_id UUID REFERENCES skills_files(id),
+  name TEXT NOT NULL,
+  domain TEXT NOT NULL,
+  version TEXT NOT NULL,
+  confidence FLOAT NOT NULL,
+  stale BOOLEAN DEFAULT false,
+  review_required BOOLEAN DEFAULT false,
+  skill_json JSONB NOT NULL,
+  PRIMARY KEY (id, company_id, skills_file_id)
+);
+
+CREATE TABLE source_files (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  filename TEXT NOT NULL,
+  sha256 TEXT NOT NULL,
+  storage_path TEXT NOT NULL,
+  uploaded_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE TABLE compile_runs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  company_id TEXT REFERENCES companies(id),
+  status TEXT NOT NULL CHECK (status IN ('started','running','complete','error')),
+  started_at TIMESTAMPTZ DEFAULT now(),
+  completed_at TIMESTAMPTZ,
+  duration_ms INTEGER,
+  result_version TEXT,
+  error_detail TEXT
+);
+
+CREATE INDEX idx_skills_files_company ON skills_files(company_id, compiled_at DESC);
+CREATE INDEX idx_skills_company ON skills(company_id);
+```
+
+---
+
+## 12. Testing Decisions
+
+### Ground Truth Test Suite — All 12 Scenarios (COMPLETE)
+
+**Owner: Abhijith. Must be run and passing before demo day. All 12 must return correct `action`.**
+
+| # | Scenario | Key Context | Expected `action` | Expected `skill_matched` |
+|---|---|---|---|---|
+| 1 | Enterprise customer, 18 months tenure, $1,200 refund requested | plan=enterprise, tenure=18mo, amount=1200 | `escalate_to_am_within_1hr` | `handle_refund_request` |
+| 2 | Annual plan customer, day 10 of subscription, $300 refund requested | plan=annual, days_since_purchase=10, amount=300 | `approve_full_refund` | `handle_refund_request` |
+| 3 | New customer, 2 months tenure, $600 refund requested | plan=monthly, tenure=2mo, amount=600 | `escalate_to_founder` | `handle_refund_request` |
+| 4 | Loyal annual customer, 14 months tenure, $150 refund outside window | plan=annual, tenure=14mo, amount=150 | `approve_prorated_refund` | `handle_refund_request` |
+| 5 | Lifetime deal customer requesting any refund | plan=lifetime, amount=any | `deny_refund_ltd_terms` | `handle_refund_request` |
+| 6 | Customer contact during active platform outage | context=outage_active | `send_incident_response_template` | `respond_to_outage` |
+| 7 | Startup customer requesting 40% discount | customer_type=startup, discount_requested=40% | `escalate_to_ae` | `evaluate_discount_request` |
+| 8 | P0 bug reported on dashboard module by enterprise customer | bug_severity=P0, customer_plan=enterprise | `page_oncall_engineer_immediately` | `prioritize_bug_report` |
+| 9 | Customer SLA breached by 2 hours, enterprise plan | sla_breach_hours=2, plan=enterprise | `notify_am_and_eng_lead` | `handle_sla_breach` |
+| 10 | Customer showing 3 churn signals in last 30 days (no login, support ticket, downgrade inquiry) | signals=3, timeframe=30days | `schedule_am_call_within_24h` | `evaluate_churn_risk` |
+| 11 | Engineering candidate — completed 2 rounds, needs offer approval | stage=offer, role=engineer | `get_founder_approval_before_sending` | `hiring_process_engineering` |
+| 12 | Vendor invoice for $3,500 needs payment approval | amount=3500, vendor_type=software | `route_to_ops_lead_approval` | `approve_vendor_payment` |
+
+**How to run:**
+```python
+# Run before demo. All 12 must pass.
+for scenario in GROUND_TRUTH_SCENARIOS:
+    response = client.post("/agent/handle", json=scenario["input"])
+    assert response.json()["action"] == scenario["expected_action"]
+    assert response.json()["skill_matched"] == scenario["expected_skill"]
+```
+
+### Module Test Matrix
+
+| Module | Test Type | What to Test |
+|---|---|---|
+| Source parsers | Unit | Given raw fixture file → correct normalized output shape |
+| SHA-256 hasher | Unit | Same content → same hash; changed content → different hash |
+| Skill matcher | Unit | Given 12 known queries → each returns correct `skill_id` |
+| JSON→Markdown converter | Unit | Given skill object → output contains all conditions and forbidden actions, under 800 tokens |
+| `POST /compile` | Integration | Returns `job_id` and `stream_url`; sets compile_run status to "started" |
+| `GET /skills` | Integration | Returns exactly 12 skills for Rivanly |
+| `POST /agent/handle` | Integration | All 12 ground-truth scenarios return correct `action` |
+| `GET /diff/:v1/:v2` | Integration | Pre-seeded v1.1.0 and v1.2.0 → returns expected `modified_skills` |
+| Full pipeline | End-to-end | 8 source files → 12 skills in Supabase, `is_current: true`, all with evidence |
+| LLM output | Eval | 10-run stress test → zero uncaught malformed JSON |
+
+---
+
+## 13. Non-Functional Requirements
+
+- Full compilation: under 90 seconds (target: 60s)
+- Brain agent response: under 8 seconds
+- SSE feed: real-time node events, no polling
+- Skill matching: under 200ms (in-memory cosine similarity)
+- LangGraph MemorySaver checkpointing: compile state survives crash
+- Fallback model: Llama-3.3-70B BF16 if Qwen2.5 unavailable
+- vLLM health check queried before accepting `/compile` requests
+
+---
+
+## 14. Success Metrics
+
+### Hackathon v0 — Measurable Targets
+
+| Metric | Target | Verification |
+|---|---|---|
+| End-to-end pipeline | Completes without error | Run 3× in final 2 hours |
+| Skills produced | Exactly 12 | Check `skills_file.json` |
+| Skills with confidence ≥ 0.7 | ≥ 10 of 12 | Check confidence field |
+| Agent correct action | 12 / 12 | Run ground truth suite |
+| Agent latency | < 8 seconds | Time on demo day |
+| Compilation time | < 90 seconds | Dashboard display |
+| Live URL accessible | Yes | Test on fresh device before submission |
+| Demo video submitted | Yes | Render early, keep backup |
+| Public posts | 2 minimum | During hours 8–16 and 16–28 |
+
+### The 8-Step Demo — Ring 1 Acceptance Test
+
+1. Show source files — "Rivanly's scattered knowledge."
+2. Click "Build Company Brain" — watch SSE feed in real time.
+3. Show compilation time — "12 skills in 58 seconds on AMD MI300X."
+4. Open Skills Viewer — 6 departments, 12 skills, confidence bars.
+5. Click `handle_refund_request` — show evidence panel.
+6. Submit enterprise refund scenario to agent panel.
+7. Show side-by-side: without brain (generic) vs. with brain (rule trace + evidence).
+8. Change one SOP rule → Rebuild → same scenario → different outcome. **This is the moment.**
+
+### Post-Hackathon Business Metrics (v1)
+
+- 3 paying pilot customers within 60 days of v1 launch
+- Activation: first brain compiled + agent handles 1 scenario correctly
+- Retention: brain recompiled at least once within 30 days
+- Revenue: $200/month Starter, $500/month Growth
+
+---
+
+## 15. Competitive Landscape
+
+*Updated with companies identified in YC/LinkedIn Company Brain thread.*
+
+| Company | What they do | Differentiation |
+|---|---|---|
+| **Notion AI** | Q&A over documents | Retrieves chunks, doesn't compile operational judgment |
+| **Guru / Confluence** | Knowledge base search | Human-maintained, not executable by AI agents |
+| **Glean** | Enterprise search | Search-first, not compilation; no executable output |
+| **Sugarwork** (sugarwork.com) | Surfaces tacit knowledge for AI | Adjacent; watch closely |
+| **BrandOS** (getbrandos.site) | Company brain for marketing teams | Vertical-specific; not full company coverage |
+| **Context AI** | Operational knowledge for agents | Direct competitor — monitor |
+| **LineageOne** (NEXT'26) | Fragmented operations → live operational model | Direct competitor |
+| **AutoBase** | Building this for 7 months | Direct competitor |
+| **Company Brain** | Full compilation layer, all departments, versioned, evidence-linked | Evidence trail, stale detection, parallel AMD compilation |
+
+**Observation:** Multiple teams are building in this space. This validates the market. The race is to who ships the most complete, demo-able, production-credible version. Company Brain's differentiator is the combination of: evidence-linked rules (not just structured outputs), stale detection, version diffing, and the clean "compiler not assistant" framing that competitors haven't articulated.
+
+---
+
+## 16. Risks & Mitigation
+
+| Risk | Likelihood | Mitigation |
+|---|---|---|
+| Knowledge that was never captured cannot be extracted | **High — acknowledged** | Scope v0 to knowledge that exists in digital form; call out in pitch as known limitation; v1 adds call transcription |
+| Extraction agents produce low-quality skills | Medium | Dataset authored backward from desired output; eval suite catches failures before demo |
+| vLLM setup on AMD cloud takes too long | Low | Kubernetes on AMD course completed; fallback to Fireworks API |
+| LangGraph parallel fan-in bug | Low | Fixed using `Send` API + `ingest_join` barrier node |
+| Demo breaks during judging | Medium | Pre-recorded fallback video; deploy to stable URL 24h before submission |
+| Qwen2.5-72B FP8 unavailable | Low | `RedHatAI/Qwen2.5-72B-Instruct-FP8-dynamic` confirmed on HuggingFace |
+| Frontend/backend API contract mismatch | Medium | Both parties agree on F-12 schemas before writing frontend code |
+| Synthetic dataset too shallow | Medium | Each file: ≥ 4 edge cases, ≥ 1 planted contradiction; reviewed together before kickoff |
+| Competitors ship demo before May 11 | Low | Multiple are building but none have shipped a demo yet; Company Brain's AMD + parallel compile angle is unique |
+
+---
+
+## 17. v2 Roadmap — Insights from LinkedIn Thread
+
+*Insights from practitioners who responded to Tom Blomfield's YC RFS post that should inform v2 product decisions.*
+
+**Execution boundaries (Horizon Labs insight):** The skills file is currently advisory — the agent reads it and acts. In v2, the skills file should become constraining — the agent should not be able to take actions not in the admissible action set. This is the difference between a knowledge map and an execution boundary. Add to v2: `forbidden_actions` enforced at the runtime level, not just injected as prompt guidance.
+
+**The stale knowledge divergence problem (Matan Elmalam insight):** Teams build the map once, ship the agent, and within six weeks reality diverges. Our stale detection addresses this for captured knowledge. For v2: active monitoring — compare agent actions against skills file weekly and surface divergences as "possible new skills" for human review.
+
+**Call transcription (Paul Breuler gap):** Knowledge that exists only in spoken conversations will never be in Slack or Notion. In v2: integrate with Fireflies/Otter/Grain to pull meeting transcripts as a first-class source type. This closes the most common knowledge capture gap.
+
+**Audit trail (Josh Jefferd insight):** Every agent action should be logged with which skill rule was applied and which evidence excerpt justified it. This is the compliance and trust layer. Add to v2 roadmap as a first-class feature, not an afterthought.
+
+---
+
+## 18. Open Questions — All Resolved
+
+| Question | Resolution |
+|---|---|
+| Who owns frontend vs. pipeline? | Abhijith = pipeline + API. Harshit = all frontend. |
+| Supabase schema? | Defined in Section 11. |
+| SSE disconnect/reconnect handling? | Frontend: exponential backoff (1s, 2s, 4s). Fallback: `GET /brain/status` for final state. |
+| Synthetic dataset ownership? | Both — 4 files each, authored before May 4 kickoff. |
+| Ground truth table complete? | Yes — all 12 scenarios in Section 12. Run before demo. |
+| `with_brain: false` behaviour? | Fully specified in F-10 and Section 9. |
+| Screen-to-screen user flow? | Defined in Section 10.2. |
+
+---
+
+*This document supersedes company_brain_PRD_v3.md. All three audit issues resolved. Competitive landscape updated with real companies from LinkedIn thread. No scope changes after May 4 kickoff.*

data/sources/rivanly-inc/notion_cs_playbook.md

@@ -0,0 +1,10 @@
+# Customer Success Playbook
+**Department:** Customer Success
+**Last Updated:** May 2026
+
+## 1. Churn Risk Evaluation
+It is critical to identify and intervene when accounts show signs of churning.
+- **Rule:** If a customer exhibits 3 or more churn signals (e.g., no logins, support ticket escalations, downgrade inquiries) within a 30-day timeframe, you must schedule an AM call within 24 hours.
+
+## 2. Enterprise Onboarding
+- **Rule:** For all new Enterprise customers, the onboarding process must include a dedicated kickoff call, a customized training session, and a 30-day check-in.

data/sources/rivanly-inc/notion_eng_runbook.md

@@ -0,0 +1,17 @@
+# Engineering Runbook & SLAs
+**Department:** Product & Engineering
+**Last Updated:** February 2026
+
+## 1. Bug Triage
+- **P0 (Critical):** System down, data loss, or core workflow broken. 
+  - **Rule:** If a P0 bug is reported by an Enterprise customer, page the on-call engineer immediately.
+- **P1 (High):** Major feature broken but workaround exists.
+  - **Rule:** P1 bugs must be resolved within 4 hours.
+- **P2 (Medium/Low):** UI glitches, minor inconveniences. Add to the backlog.
+
+## 2. SLA Breach Handling
+- **Standard Process:** If a customer SLA is breached by more than 1 hour, notify the support lead.
+- **Enterprise Exceptions:** If an Enterprise plan customer SLA is breached by 2 hours or more, you must notify both the Account Manager and the Engineering Lead immediately.
+
+## 3. Outage Response
+- If a customer contacts support during an active platform outage, do not troubleshoot. Send the standard incident response template and link to the status page.

data/sources/rivanly-inc/notion_hr_playbook.md

@@ -0,0 +1,17 @@
+# HR & Hiring Playbook
+**Department:** HR
+**Last Updated:** January 2026
+
+## 1. Engineering Hiring Process
+The standard hiring process for Engineering roles:
+1. Recruiter Screen
+2. Technical Interview (Pair Programming)
+3. Systems Design Interview
+4. Culture Fit with Founders
+5. Offer Stage
+
+**Critical Rule:** For any engineering candidate at the offer stage, you must get Founder approval before sending the final offer letter.
+
+## 2. Performance & PIPs
+- A Performance Improvement Plan (PIP) is triggered if an employee misses their core KPIs for two consecutive quarters.
+- If an employee is placed on a PIP, HR must schedule a formal review with the department head within 5 business days.

data/sources/rivanly-inc/notion_pricing_policy.md

@@ -0,0 +1,14 @@
+# Pricing & Discount Policy
+**Department:** Revenue
+**Last Updated:** April 2026
+
+## 1. Overview
+This document outlines standard pricing exceptions and discount approval chains.
+
+## 2. Discount Authority
+- **Standard Discount:** Support and CS can apply up to a 10% discount to save a churning customer.
+- **Startup Discount:** If a customer identifies as an early-stage startup (pre-seed or seed), you may approve up to a 20% discount on the Annual plan for the first year.
+- **Large Discounts:** If a customer requests a discount greater than 30%, it must be escalated to an Account Executive (AE) for approval. Support cannot approve this.
+
+## 3. Custom Pricing
+- **Enterprise Custom Pricing:** Enterprise customers requesting custom feature bundles or volume-based pricing must be routed to the VP of Sales.

data/sources/rivanly-inc/notion_refund_sop.md

@@ -0,0 +1,16 @@
+# Refund Standard Operating Procedure (SOP)
+**Department:** Support
+**Last Updated:** March 2026
+
+## 1. Core Policy
+Our refund policy is designed to balance customer satisfaction with revenue retention. Always aim to understand the root cause before processing a refund.
+
+## 2. Refund Eligibility & Rules
+- **Annual Plans (First 14 days):** If a customer on an annual plan requests a refund within the first 14 days of purchase, approve a full refund immediately. No questions asked.
+- **Annual Plans (After 14 days):** If a customer on an annual plan requests a refund after 14 days, approve a prorated refund for the remaining unused months.
+- **Enterprise Customers:** If any Enterprise customer requests a refund of any amount, DO NOT process it immediately. You must escalate to the Account Manager (AM) within 1 hour.
+- **Lifetime Deals (LTD):** Under no circumstances do we process refunds for lifetime deal accounts. Deny the request citing LTD terms.
+- **Monthly Plans (New Customers):** If a customer on a monthly plan with a tenure of less than 3 months requests a refund over $500, escalate to the Founder.
+
+## 3. Strict Time Limits
+**CRITICAL:** We offer absolutely no refunds after 30 days of purchase for any customer tier. If the purchase was more than 30 days ago, deny the refund.

data/sources/rivanly-inc/slack_export_ops.json

@@ -0,0 +1,20 @@
+[
+  {
+    "channel": "finance-ops",
+    "user": "jessica_fin",
+    "text": "I have an incoming vendor invoice for $3,500 from Datadog (software vendor). Who needs to approve this?",
+    "timestamp": "2026-02-15T09:30:00Z"
+  },
+  {
+    "channel": "finance-ops",
+    "user": "david_ops_lead",
+    "text": "Any software vendor invoice of $3,500 or more needs to be routed to the ops lead for approval before finance pays it. Send it my way.",
+    "timestamp": "2026-02-15T09:45:00Z"
+  },
+  {
+    "channel": "finance-ops",
+    "user": "jessica_fin",
+    "text": "Got it, routing it to you.",
+    "timestamp": "2026-02-15T09:46:00Z"
+  }
+]

data/sources/rivanly-inc/slack_export_support.json

@@ -0,0 +1,26 @@
+[
+  {
+    "channel": "support-triage",
+    "user": "sarah_am",
+    "text": "Hey team, Acme Corp (been with us 4 years) is asking for a refund for last month's invoice due to the billing mixup. It's been 45 days since that charge, I know SOP says 30 days max.",
+    "timestamp": "2026-03-12T10:00:00Z"
+  },
+  {
+    "channel": "support-triage",
+    "user": "mike_lead",
+    "text": "For loyal customers over 2 years tenure, we can bypass the 30-day rule. Go ahead and approve the refund for Acme Corp.",
+    "timestamp": "2026-03-12T10:05:00Z"
+  },
+  {
+    "channel": "support-triage",
+    "user": "alex_support",
+    "text": "We have an active platform outage affecting all EU servers. Customers are opening tickets left and right.",
+    "timestamp": "2026-04-01T14:20:00Z"
+  },
+  {
+    "channel": "support-triage",
+    "user": "mike_lead",
+    "text": "Do not try to troubleshoot individual EU tickets right now. Just send the incident response template and close the tickets.",
+    "timestamp": "2026-04-01T14:22:00Z"
+  }
+]

data/sources/rivanly-inc/zendesk_tickets.json

@@ -0,0 +1,23 @@
+[
+  {
+    "id": "TICKET-1042",
+    "subject": "Dashboard not loading",
+    "description": "I cannot access the main dashboard. It just spins forever.",
+    "resolution": "P0 bug confirmed. Paged on-call engineer immediately as this is an Enterprise customer.",
+    "tags": ["bug", "P0", "enterprise"]
+  },
+  {
+    "id": "TICKET-1045",
+    "subject": "Export feature failing",
+    "description": "When I try to export reports to CSV, it fails.",
+    "resolution": "Confirmed P1 bug for Enterprise customer GlobalCorp. Escalated to Eng and resolved same-day (within 12 hours), outside the normal 4-hour SLA but acceptable for this specific complex issue for Enterprise.",
+    "tags": ["bug", "P1", "enterprise"]
+  },
+  {
+    "id": "TICKET-1088",
+    "subject": "SLA breached on ticket 1087",
+    "description": "We have been waiting 6 hours for a response.",
+    "resolution": "SLA breached by 2 hours for Enterprise customer. Notified AM and Eng Lead immediately.",
+    "tags": ["sla_breach", "enterprise"]
+  }
+]

frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

frontend/AGENTS.md

@@ -0,0 +1,5 @@
+<!-- BEGIN:nextjs-agent-rules -->
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` before writing any code. Heed deprecation notices.
+<!-- END:nextjs-agent-rules -->

frontend/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

frontend/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

frontend/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

frontend/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

frontend/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "next": "16.2.5",
+    "react": "19.2.4",
+    "react-dom": "19.2.4"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.5",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

frontend/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

frontend/src/app/compile/[jobId]/page.tsx

@@ -0,0 +1,115 @@
+"use client";
+
+import { useEffect, useState, use } from "react";
+import { useRouter } from "next/navigation";
+
+interface LogEvent {
+  timestamp: string;
+  type: string;
+  data: any;
+}
+
+const STAGE_LABELS: Record<string, string> = {
+  pipeline_start: "🚀 Pipeline Started",
+  LOADING_DOCS: "📂 Loading Documents",
+  CHUNKING: "✂️ Chunking Documents",
+  CHUNKING_DONE: "✅ Chunking Complete",
+  EMBEDDING: "🧠 Embedding & Clustering",
+  EMBEDDING_DONE: "✅ Clustering Complete",
+  SYNTHESIZING_SKILLS: "⚡ Synthesizing Skills",
+  QUALITY_CHECK: "🔍 Quality & Confidence Scoring",
+  QUALITY_CHECK_DONE: "✅ Quality Check Complete",
+  WRITING_DB: "💾 Writing to Database",
+  DONE: "✅ Pipeline Complete",
+  pipeline_complete: "🎉 Compilation Finished",
+  pipeline_error: "❌ Pipeline Error",
+};
+
+export default function CompileViewer({ params }: { params: Promise<{ jobId: string }> }) {
+  const resolvedParams = use(params);
+  const jobId = resolvedParams.jobId;
+  const [logs, setLogs] = useState<LogEvent[]>([]);
+  const [status, setStatus] = useState("Connecting...");
+  const router = useRouter();
+
+  useEffect(() => {
+    if (!jobId) return;
+
+    const eventSource = new EventSource(`http://localhost:8080/compile/${jobId}/stream`);
+
+    eventSource.onmessage = (event) => {
+      const parsed = JSON.parse(event.data);
+      const eventType = parsed.event;
+      const eventData = parsed.data;
+
+      setLogs((prev) => [
+        ...prev,
+        { timestamp: new Date().toLocaleTimeString(), type: eventType, data: eventData },
+      ]);
+
+      // Update the status bar based on event type
+      if (eventType === "stage") {
+        const stageName = eventData.name || "";
+        const label = STAGE_LABELS[stageName] || stageName;
+        const detail = eventData.detail || "";
+        setStatus(`${label}${detail ? ` — ${detail}` : ""}`);
+      } else if (eventType === "pipeline_start") {
+        setStatus(STAGE_LABELS.pipeline_start);
+      } else if (eventType === "pipeline_complete") {
+        setStatus(STAGE_LABELS.pipeline_complete);
+        eventSource.close();
+      } else if (eventType === "pipeline_error") {
+        setStatus(`❌ Error: ${eventData.error || "Unknown"}`);
+        eventSource.close();
+      }
+    };
+
+    eventSource.onerror = () => {
+      eventSource.close();
+    };
+
+    return () => eventSource.close();
+  }, [jobId]);
+
+  return (
+    <div className="min-h-screen p-8 flex flex-col">
+      <div className="flex justify-between items-center mb-6 border-b border-gray-800 pb-4">
+        <h1 className="text-2xl font-bold text-primary">Pipeline Stream</h1>
+        <div className="flex items-center gap-4">
+          <span
+            className={`px-3 py-1 font-mono text-sm border ${
+              status.includes("Finished") || status.includes("Complete")
+                ? "border-green-500 text-green-500"
+                : status.includes("Error")
+                ? "border-red-500 text-red-500"
+                : "border-primary text-primary animate-pulse"
+            }`}
+          >
+            {status}
+          </span>
+          <button onClick={() => router.push("/")} className="text-text-secondary hover:text-foreground">
+            Back
+          </button>
+        </div>
+      </div>
+
+      <div className="flex-1 bg-surface border border-gray-800 p-4 font-mono text-sm overflow-y-auto">
+        {logs.map((log, i) => {
+          const isStage = log.type === "stage";
+          const stageName = isStage ? log.data?.name : log.type;
+          const label = STAGE_LABELS[stageName] || stageName;
+          const detail = isStage ? log.data?.detail || "" : JSON.stringify(log.data);
+          const isError = stageName?.includes("error") || stageName?.includes("Error");
+
+          return (
+            <div key={i} className="mb-2">
+              <span className="text-text-secondary">[{log.timestamp}]</span>{" "}
+              <span className={isError ? "text-red-500" : "text-primary"}>{label}</span>{" "}
+              <span className="text-foreground">{detail}</span>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

frontend/src/app/demo/[companyId]/page.tsx

@@ -0,0 +1,269 @@
+"use client";
+
+import { useState, use } from "react";
+import { useRouter } from "next/navigation";
+
+type AgentResponse = {
+  recommended_action?: string;
+  rule_applied?: string;
+  evidence?: string[];
+  skill_matched?: string;
+  confidence?: number;
+  retrieval_scores?: number[];
+  reasoning?: string;
+  error?: string;
+};
+
+export default function QueryDemo({ params }: { params: Promise<{ companyId: string }> }) {
+  const resolvedParams = use(params);
+  const companyId = resolvedParams.companyId;
+  const [scenario, setScenario] = useState("");
+  const [contextJson, setContextJson] = useState("{}");
+  const [loading, setLoading] = useState(false);
+
+  const [withBrainResponse, setWithBrainResponse] = useState<AgentResponse | null>(null);
+  const [withoutBrainResponse, setWithoutBrainResponse] = useState<AgentResponse | null>(null);
+
+  const router = useRouter();
+
+  const handleQuery = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!scenario) return;
+    setLoading(true);
+    setWithBrainResponse(null);
+    setWithoutBrainResponse(null);
+
+    let parsedContext = {};
+    try {
+      if (contextJson.trim()) {
+        parsedContext = JSON.parse(contextJson);
+      }
+    } catch {
+      alert("Invalid JSON in context field");
+      setLoading(false);
+      return;
+    }
+
+    try {
+      const [resWithBrain, resWithoutBrain] = await Promise.all([
+        fetch("http://localhost:8080/agent/handle", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ company_id: companyId, scenario, context: parsedContext, with_brain: true }),
+        }),
+        fetch("http://localhost:8080/agent/handle", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ company_id: companyId, scenario, context: parsedContext, with_brain: false }),
+        }),
+      ]);
+
+      setWithBrainResponse(await resWithBrain.json());
+      setWithoutBrainResponse(await resWithoutBrain.json());
+    } catch (err) {
+      console.error(err);
+      alert("Query failed — is the backend running?");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const confidenceColor = (c: number) => {
+    if (c >= 0.75) return "bg-green-500";
+    if (c >= 0.5) return "bg-yellow-500";
+    if (c >= 0.25) return "bg-orange-500";
+    return "bg-red-500";
+  };
+
+  return (
+    <div className="min-h-screen p-8 flex flex-col items-center">
+      <div className="w-full max-w-5xl">
+        <div className="flex justify-between items-center mb-6 border-b border-gray-800 pb-4">
+          <h1 className="text-2xl font-bold text-primary">Brain Query Demo</h1>
+          <button onClick={() => router.push("/")} className="text-text-secondary hover:text-foreground">
+            Back to Dashboard
+          </button>
+        </div>
+
+        <form onSubmit={handleQuery} className="mb-8 bg-surface p-6 border border-gray-800">
+          <div className="flex flex-col gap-4">
+            <div>
+              <label className="block text-text-secondary text-sm font-bold mb-2">Scenario</label>
+              <textarea
+                className="w-full px-4 py-3 bg-background border border-gray-700 text-foreground focus:outline-none focus:border-primary min-h-[100px]"
+                placeholder="Enterprise customer, 18 months tenure, wants $1,200 refund"
+                value={scenario}
+                onChange={(e) => setScenario(e.target.value)}
+              />
+            </div>
+            <div>
+              <label className="block text-text-secondary text-sm font-bold mb-2">Context (JSON)</label>
+              <textarea
+                className="w-full px-4 py-3 bg-background border border-gray-700 text-foreground focus:outline-none focus:border-primary font-mono text-sm min-h-[80px]"
+                placeholder='{"plan": "enterprise", "tenure_months": 18, "refund_amount": 1200}'
+                value={contextJson}
+                onChange={(e) => setContextJson(e.target.value)}
+              />
+            </div>
+            <button
+              type="submit"
+              disabled={loading || !scenario}
+              className="bg-primary text-background font-bold py-3 px-6 hover:opacity-90 disabled:opacity-50 self-end"
+            >
+              {loading ? "Thinking..." : "Compare Models"}
+            </button>
+          </div>
+        </form>
+
+        {(withBrainResponse || withoutBrainResponse) && (
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
+            {/* WITHOUT BRAIN */}
+            <div className="bg-surface border border-gray-800 p-6 opacity-75">
+              <h2 className="text-xl font-bold text-gray-400 mb-4 flex items-center gap-2">
+                <span className="w-2 h-2 rounded-full bg-gray-500"></span>
+                Without Brain (Generic AI)
+              </h2>
+
+              {withoutBrainResponse ? (
+                <div className="space-y-4 text-gray-300">
+                  <div>
+                    <h3 className="text-gray-500 text-sm font-bold uppercase tracking-wider mb-1">Response</h3>
+                    <p className="text-lg bg-background p-4 border border-gray-800 rounded">
+                      {withoutBrainResponse.recommended_action || "No action"}
+                    </p>
+                  </div>
+                  <div>
+                    <h3 className="text-gray-500 text-sm font-bold uppercase tracking-wider mb-1">Rule Applied</h3>
+                    <p className="italic">{withoutBrainResponse.rule_applied || "General knowledge"}</p>
+                  </div>
+                  {withoutBrainResponse.reasoning && (
+                    <div>
+                      <h3 className="text-gray-500 text-sm font-bold uppercase tracking-wider mb-1">Reasoning</h3>
+                      <p className="text-sm">{withoutBrainResponse.reasoning}</p>
+                    </div>
+                  )}
+                </div>
+              ) : (
+                <p>Loading...</p>
+              )}
+            </div>
+
+            {/* WITH BRAIN */}
+            <div className="bg-surface border-2 border-primary p-6 relative shadow-[0_0_15px_rgba(45,212,191,0.1)]">
+              <div className="absolute -top-3 -right-3 bg-primary text-background text-xs font-bold px-3 py-1 uppercase tracking-wider rounded-full">
+                Company Brain
+              </div>
+              <h2 className="text-xl font-bold text-primary mb-4 flex items-center gap-2">
+                <span className="w-2 h-2 rounded-full bg-primary animate-pulse"></span>
+                With Brain (Compiled Agent)
+              </h2>
+
+              {withBrainResponse ? (
+                <div className="space-y-4">
+                  {withBrainResponse.error ? (
+                    <p className="text-red-400">{withBrainResponse.error}</p>
+                  ) : (
+                    <>
+                      <div>
+                        <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                          Recommended Action
+                        </h3>
+                        <p className="text-xl font-semibold text-white bg-primary/10 p-4 border border-primary/30 rounded">
+                          {withBrainResponse.recommended_action}
+                        </p>
+                      </div>
+
+                      <div className="grid grid-cols-2 gap-4">
+                        <div>
+                          <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                            Skill Matched
+                          </h3>
+                          <p className="font-mono text-sm bg-background p-2 rounded">
+                            {withBrainResponse.skill_matched || "N/A"}
+                          </p>
+                        </div>
+                        <div>
+                          <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                            Confidence
+                          </h3>
+                          <div className="flex items-center gap-2 mt-2">
+                            <div className="flex-1 bg-background h-2 rounded-full overflow-hidden">
+                              <div
+                                className={`h-full ${confidenceColor(withBrainResponse.confidence || 0)}`}
+                                style={{ width: `${(withBrainResponse.confidence || 0) * 100}%` }}
+                              ></div>
+                            </div>
+                            <span className="text-xs font-mono">
+                              {((withBrainResponse.confidence || 0) * 100).toFixed(0)}%
+                            </span>
+                          </div>
+                        </div>
+                      </div>
+
+                      {/* Retrieval Scores */}
+                      {withBrainResponse.retrieval_scores && withBrainResponse.retrieval_scores.length > 0 && (
+                        <div>
+                          <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                            Retrieval Scores (Top {withBrainResponse.retrieval_scores.length} Skills)
+                          </h3>
+                          <div className="flex gap-2 flex-wrap">
+                            {withBrainResponse.retrieval_scores.map((score, i) => (
+                              <span
+                                key={i}
+                                className="bg-background border border-gray-700 px-2 py-1 rounded text-xs font-mono"
+                              >
+                                #{i + 1}: {(score * 100).toFixed(1)}%
+                              </span>
+                            ))}
+                          </div>
+                        </div>
+                      )}
+
+                      <div>
+                        <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                          Rule Applied
+                        </h3>
+                        <p className="text-white border-l-2 border-primary pl-3 py-1 font-medium">
+                          {withBrainResponse.rule_applied}
+                        </p>
+                      </div>
+
+                      {/* Reasoning */}
+                      {withBrainResponse.reasoning && (
+                        <div>
+                          <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-1">
+                            LLM Reasoning
+                          </h3>
+                          <p className="text-sm text-gray-300 bg-background p-3 rounded border border-gray-800">
+                            {withBrainResponse.reasoning}
+                          </p>
+                        </div>
+                      )}
+
+                      {withBrainResponse.evidence && withBrainResponse.evidence.length > 0 && (
+                        <div>
+                          <h3 className="text-primary/70 text-sm font-bold uppercase tracking-wider mb-2">
+                            Evidence Trail
+                          </h3>
+                          <ul className="space-y-2">
+                            {withBrainResponse.evidence.map((src, i) => (
+                              <li key={i} className="text-gray-300 text-sm bg-background p-3 rounded border border-gray-800">
+                                {src}
+                              </li>
+                            ))}
+                          </ul>
+                        </div>
+                      )}
+                    </>
+                  )}
+                </div>
+              ) : (
+                <p>Loading...</p>
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/app/globals.css

@@ -0,0 +1,24 @@
+@import "tailwindcss";
+
+:root {
+  --background: #0A0F14;
+  --foreground: #E2E8F0;
+  --surface: #131B23;
+  --primary: #00D2B4;
+  --text-secondary: #94A3B8;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-surface: var(--surface);
+  --color-primary: var(--primary);
+  --color-text-secondary: var(--text-secondary);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+}

frontend/src/app/layout.tsx

@@ -0,0 +1,33 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html
+      lang="en"
+      className={`${geistSans.variable} ${geistMono.variable} h-full antialiased`}
+    >
+      <body className="min-h-full flex flex-col">{children}</body>
+    </html>
+  );
+}

frontend/src/app/page.tsx

@@ -0,0 +1,90 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+
+export default function Dashboard() {
+  const [companyId, setCompanyId] = useState("");
+  const [loading, setLoading] = useState(false);
+  const router = useRouter();
+
+  const handleCompile = async () => {
+    if (!companyId) return;
+    setLoading(true);
+    try {
+      const res = await fetch("http://localhost:8080/compile", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ company_id: companyId }),
+      });
+      const data = await res.json();
+      if (data.job_id) {
+        router.push(`/compile/${data.job_id}`);
+      }
+    } catch (err) {
+      console.error(err);
+      alert("Failed to start compilation");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleQuery = () => {
+    if (companyId) {
+      router.push(`/demo/${companyId}`);
+    }
+  };
+
+  const handleViewSkills = () => {
+    if (companyId) {
+      router.push(`/skills/${companyId}`);
+    }
+  };
+
+  return (
+    <div className="min-h-screen p-8 flex flex-col items-center justify-center">
+      <div className="max-w-md w-full bg-surface p-8 border border-gray-800 shadow-2xl">
+        <h1 className="text-3xl font-bold text-primary mb-6">Kernl Compilation</h1>
+        
+        <div className="mb-6">
+          <label className="block text-text-secondary text-sm font-bold mb-2">
+            Company ID
+          </label>
+          <input
+            type="text"
+            className="w-full px-3 py-2 bg-background border border-gray-700 text-foreground focus:outline-none focus:border-primary"
+            placeholder="e.g. comp_123"
+            value={companyId}
+            onChange={(e) => setCompanyId(e.target.value)}
+          />
+        </div>
+
+        <div className="flex flex-col gap-3">
+          <button
+            onClick={handleCompile}
+            disabled={loading || !companyId}
+            className="w-full bg-primary text-background font-bold py-2 px-4 hover:opacity-90 disabled:opacity-50"
+          >
+            {loading ? "Starting..." : "Compile Brain"}
+          </button>
+          
+          <button
+            onClick={handleViewSkills}
+            disabled={!companyId}
+            className="w-full border border-primary text-primary font-bold py-2 px-4 hover:bg-primary/10 disabled:opacity-50"
+          >
+            View Skills File
+          </button>
+          
+          <button
+            onClick={handleQuery}
+            disabled={!companyId}
+            className="w-full border border-gray-600 text-foreground font-bold py-2 px-4 hover:bg-gray-800 disabled:opacity-50"
+          >
+            Query Agent Demo
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/app/skills/[companyId]/page.tsx

@@ -0,0 +1,162 @@
+"use client";
+
+import { useEffect, useState, use } from "react";
+import { useRouter } from "next/navigation";
+
+type Skill = {
+  id?: string;
+  category?: string;
+  rule?: string;
+  rationale?: string;
+  evidence?: string[];
+  confidence?: number;
+};
+
+type SkillsData = {
+  skills: Skill[];
+  version?: string;
+  compiled_at?: string;
+  brain_id?: string;
+};
+
+export default function SkillsViewer({ params }: { params: Promise<{ companyId: string }> }) {
+  const resolvedParams = use(params);
+  const companyId = resolvedParams.companyId;
+  const [data, setData] = useState<SkillsData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [filter, setFilter] = useState("");
+  const [sortBy, setSortBy] = useState<"category" | "confidence">("category");
+  const router = useRouter();
+
+  useEffect(() => {
+    fetch(`http://localhost:8080/skills/${companyId}`)
+      .then((res) => res.json())
+      .then((d) => {
+        setData(d);
+        setLoading(false);
+      })
+      .catch((err) => {
+        console.error(err);
+        setLoading(false);
+      });
+  }, [companyId]);
+
+  const skills = data?.skills || [];
+  const categories = [...new Set(skills.map((s) => s.category || "Unknown"))];
+
+  const filtered = skills
+    .filter((s) => {
+      if (!filter) return true;
+      return (s.category || "").toLowerCase().includes(filter.toLowerCase());
+    })
+    .sort((a, b) => {
+      if (sortBy === "confidence") return (b.confidence || 0) - (a.confidence || 0);
+      return (a.category || "").localeCompare(b.category || "");
+    });
+
+  const confidenceColor = (c: number) => {
+    if (c >= 0.8) return "text-green-400 border-green-400/30";
+    if (c >= 0.6) return "text-yellow-400 border-yellow-400/30";
+    if (c >= 0.4) return "text-orange-400 border-orange-400/30";
+    return "text-red-400 border-red-400/30";
+  };
+
+  return (
+    <div className="min-h-screen p-8 flex flex-col">
+      <div className="flex justify-between items-center mb-6 border-b border-gray-800 pb-4">
+        <div>
+          <h1 className="text-2xl font-bold text-primary">Skills File Viewer</h1>
+          {data?.version && (
+            <p className="text-text-secondary text-sm mt-1">
+              Version: <span className="font-mono text-primary">{data.version}</span>
+              {data.compiled_at && (
+                <> · Compiled: {new Date(data.compiled_at).toLocaleString()}</>
+              )}
+              {" · "}{skills.length} skills
+            </p>
+          )}
+        </div>
+        <button onClick={() => router.push("/")} className="text-text-secondary hover:text-foreground">
+          Back
+        </button>
+      </div>
+
+      {/* Filter + Sort Controls */}
+      <div className="flex gap-4 mb-4">
+        <select
+          value={filter}
+          onChange={(e) => setFilter(e.target.value)}
+          className="bg-surface border border-gray-700 text-foreground px-3 py-2 text-sm"
+        >
+          <option value="">All Categories</option>
+          {categories.map((c) => (
+            <option key={c} value={c}>{c}</option>
+          ))}
+        </select>
+        <select
+          value={sortBy}
+          onChange={(e) => setSortBy(e.target.value as "category" | "confidence")}
+          className="bg-surface border border-gray-700 text-foreground px-3 py-2 text-sm"
+        >
+          <option value="category">Sort by Category</option>
+          <option value="confidence">Sort by Confidence</option>
+        </select>
+      </div>
+
+      {/* Skills Grid */}
+      <div className="flex-1 overflow-y-auto">
+        {loading ? (
+          <div className="text-text-secondary">Loading skills...</div>
+        ) : filtered.length === 0 ? (
+          <div className="text-center py-12">
+            <p className="text-text-secondary text-lg">No skills compiled yet.</p>
+            <p className="text-text-secondary text-sm mt-2">
+              Go to Dashboard → Compile Brain to generate skills from your source documents.
+            </p>
+          </div>
+        ) : (
+          <div className="grid grid-cols-1 lg:grid-cols-2 gap-4">
+            {filtered.map((skill, i) => (
+              <div
+                key={skill.id || i}
+                className="bg-surface border border-gray-800 p-5 hover:border-primary/30 transition-colors"
+              >
+                <div className="flex justify-between items-start mb-3">
+                  <span className="text-xs font-mono bg-primary/10 text-primary px-2 py-1 rounded">
+                    {skill.category || "Unknown"}
+                  </span>
+                  <span
+                    className={`text-xs font-mono px-2 py-1 border rounded ${confidenceColor(
+                      skill.confidence || 0
+                    )}`}
+                  >
+                    {((skill.confidence || 0) * 100).toFixed(0)}%
+                  </span>
+                </div>
+
+                <p className="text-white font-medium mb-2">{skill.rule}</p>
+
+                {skill.rationale && (
+                  <p className="text-text-secondary text-sm mb-3 italic">{skill.rationale}</p>
+                )}
+
+                {skill.evidence && skill.evidence.length > 0 && (
+                  <div className="border-t border-gray-800 pt-3 mt-3">
+                    <h4 className="text-xs text-text-secondary uppercase tracking-wider mb-2">
+                      Evidence ({skill.evidence.length})
+                    </h4>
+                    {skill.evidence.map((e, j) => (
+                      <p key={j} className="text-xs text-gray-400 mb-1 pl-2 border-l border-gray-700">
+                        {e}
+                      </p>
+                    ))}
+                  </div>
+                )}
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}