Deploy mailbox-automation Next.js app

.gitattributes

@@ -1,37 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-sources/needful_things/needful_things.duckdb filter=lfs diff=lfs merge=lfs -text
-.netlify/functions-internal/___netlify-server-handler/.next/server/app/api/gmail/auth/route.js filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -3,11 +3,15 @@ node_modules/
 out/
 build/
 dist/
+data/
 exports/
 app-config.json
 *.log
 .DS_Store
 .env
 .env.local
-.env.*.local
+.env*.local
 .vercel
+.netlify
+.netlify/
+scripts/__pycache__/

.npmrc

@@ -0,0 +1 @@
+legacy-peer-deps=true

Dockerfile

@@ -1,16 +1,41 @@
-FROM node:20
+FROM node:20-alpine AS base
 
-# Install http-server to serve the static site
-RUN npm install -g http-server
+# Stage 1: Install dependencies
+FROM base AS deps
+WORKDIR /app
+COPY package.json package-lock.json* .npmrc ./
+RUN npm ci --legacy-peer-deps
 
-# Build the app
-WORKDIR /usr/app
-COPY ./ /usr/app
-RUN npm install 
-RUN npm run sources && npm run build
+# Stage 2: Build the app
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+ENV NEXT_PUBLIC_DEMO=true
+RUN npm run build
 
-# Expose port 7860
+# Stage 3: Production runner
+# Works on Hugging Face Spaces (port 7860), Fly.io (port 7860), and any Docker host.
+# PORT is set by the platform; default to 7860 for HF Spaces compatibility.
+FROM base AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+ENV NEXT_PUBLIC_DEMO=true
+ENV PORT=7860
+ENV HOSTNAME=0.0.0.0
+
+# Hugging Face Spaces runs containers as UID 1000.
+# node:20-alpine already has a 'node' user with UID 1000 / GID 1000.
+# Use that existing user instead of creating a new one.
+RUN mkdir -p /app && chown -R node:node /app
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=node:node /app/.next/standalone ./
+COPY --from=builder --chown=node:node /app/.next/static ./.next/static
+
+USER node
+
+# Expose 7860 (HF Spaces default)
 EXPOSE 7860
 
-# Serve the static site from the /usr/app/build directory on host 0.0.0.0 and port 7860
-CMD ["http-server", "/usr/app/build", "-a", "0.0.0.0", "-p", "7860"]
+CMD ["node", "server.js"]

README.md

@@ -1,12 +1,100 @@
 ---
-title: Over
-emoji: 📦
-colorFrom: blue
-colorTo: green
+title: Mailbox Automation — Scientific Data Extraction
+emoji: 📬
+colorFrom: indigo
+colorTo: purple
 sdk: docker
-pinned: false
-license: mit
-short_description: over
+app_port: 7860
+short_description: AI-powered mailbox analysis with scientific data extraction
+startup_duration_timeout: 10m
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Mailbox Automation — Scientific Data Extraction
+
+A production-ready Next.js app for analyzing Gmail / Microsoft 365 mailboxes, extracting structured scientific data, and exporting it to spreadsheets. Deployed on Hugging Face Spaces (Docker SDK), Netlify, and Vercel from a single codebase.
+
+## Deploy
+
+### Hugging Face Spaces (Docker SDK)
+
+This Space runs the Next.js standalone build inside a Docker container on port 7860. The Dockerfile handles the full build — no manual build step needed.
+
+```bash
+# The Space auto-builds on push. To deploy manually:
+hf spaces restart luguog/mailbox-automation
+```
+
+### Netlify
+
+[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start)
+
+Uses `@netlify/plugin-nextjs` with serverless functions. Build command and publish dir are in `netlify.toml`.
+
+### Vercel
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Foverandor%2Fburchi&env=NEXT_PUBLIC_DEMO,NEXT_PUBLIC_OAUTH_REDIRECT_BASE&project-name=mailbox-automation)
+
+Uses native Next.js support. Configuration in `vercel.json`.
+
+## Environment variables
+
+All platforms support the same env vars. Set them in the platform dashboard (HF Spaces Settings → Variables and secrets, Netlify Site Settings → Environment, Vercel Project Settings → Environment Variables).
+
+```bash
+# For a public demo with no real mailbox, set NEXT_PUBLIC_DEMO=true
+NEXT_PUBLIC_DEMO=true
+
+# LLM provider (optional — app falls back to free LLM7 if not set)
+OPENAI_API_KEY=sk-...
+LLM_MODEL=gpt-4o-mini
+LLM_ENDPOINT=https://api.openai.com/v1
+
+# For live Microsoft 365 sync
+AZURE_CLIENT_ID=
+AZURE_TENANT_ID=common
+AZURE_CLIENT_SECRET=
+MAILBOX_EMAIL=
+
+# For live Gmail sync
+GMAIL_CLIENT_ID=
+GMAIL_CLIENT_SECRET=
+
+# Public URL of the deployed app (for OAuth redirect URIs)
+# HF Spaces:  https://luguog-mailbox-automation.hf.space
+# Netlify:    https://your-site.netlify.app
+# Vercel:     https://your-project.vercel.app
+NEXT_PUBLIC_OAUTH_REDIRECT_BASE=https://luguog-mailbox-automation.hf.space
+```
+
+## What works without any credentials
+
+- **Public demo mode** — pre-generated sample emails with analyses, mindmaps, and execution plans
+- **LLM inference** — automatic fallback to free LLM7 API (no key needed) when the configured endpoint is unavailable
+- **Dark mode** — toggle in the header
+- **Health check** — `GET /api/health` returns system status
+
+## Run locally
+
+```bash
+npm install
+npm run dev
+```
+
+Then open `http://localhost:3000`.
+
+## Architecture
+
+- **Framework**: Next.js 14 (App Router, standalone output)
+- **Styling**: Tailwind CSS with dark mode support
+- **Deployment**: Single codebase → HF Spaces (Docker), Netlify (serverless), Vercel (serverless)
+- **LLM**: OpenAI-compatible endpoints with multi-provider fallback chain (configured → LLM7 → Pollinations)
+- **Storage**: Client-side localStorage (serverless-friendly); filesystem on Docker
+- **Tests**: Node built-in test runner (`npm test`)
+- **Health**: `GET /api/health` checks config, telemetry, analysis, and utils modules
+
+## Notes
+
+- `next.config.js` uses `output: 'standalone'` for Docker/Node hosts (HF Spaces, Fly.io)
+- On Netlify/Vercel, the Next.js plugin handles serverless adaptation automatically
+- Server-side config is env-first; file-based config falls back safely on serverless
+- The Dockerfile exposes port 7860 (HF Spaces default) and 3000 (generic Docker)

fly.toml

@@ -0,0 +1,16 @@
+app = "mailbox-sci-data"
+primary_region = "iad"
+
+[build]
+
+[http_service]
+  internal_port = 7860
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  memory = "1024mb"
+  cpu_kind = "shared"
+  cpus = 1

netlify.toml

@@ -0,0 +1,14 @@
+[build]
+  command = "NEXT_PUBLIC_DEMO=true npm run build"
+  publish = ".next"
+
+[build.environment]
+  NEXT_PUBLIC_DEMO = "true"
+  NODE_VERSION = "20"
+
+[[plugins]]
+  package = "@netlify/plugin-nextjs"
+
+[functions]
+  # Allow up to 120s for LLM inference and sync operations
+  max_duration = 120

next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

next.config.js

@@ -0,0 +1,12 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+  experimental: {
+    serverComponentsExternalPackages: ['exceljs', 'pdf-parse', '@azure/msal-node', 'imapflow']
+  },
+  env: {
+    NEXT_PUBLIC_DEMO: process.env.NEXT_PUBLIC_DEMO,
+  },
+};
+
+module.exports = nextConfig;

package.json

@@ -1,37 +1,51 @@
 {
-  "name": "my-evidence-project",
-  "version": "0.0.1",
+  "name": "microsoft-mailbox-automation",
+  "version": "1.0.0",
+  "private": true,
   "scripts": {
-    "build": "evidence build",
-    "build:strict": "evidence build:strict",
-    "dev": "evidence dev --open /",
-    "test": "evidence build",
-    "sources": "evidence sources",
-    "preview": "evidence preview"
+    "dev": "next dev -p 3000",
+    "build": "next build",
+    "start": "next start -p 3000",
+    "lint": "next lint",
+    "test": "node --test --import tsx src/lib/__tests__/*.test.ts",
+    "pages:build": "npx @cloudflare/next-on-pages"
   },
-  "engines": {
-    "npm": ">=7.0.0",
-    "node": ">=18.0.0"
-  },
-  "type": "module",
   "dependencies": {
-    "@evidence-dev/bigquery": "^2.0.7",
-    "@evidence-dev/core-components": "^4.8.10",
-    "@evidence-dev/csv": "^1.0.12",
-    "@evidence-dev/databricks": "^1.0.7",
-    "@evidence-dev/duckdb": "^1.0.11",
-    "@evidence-dev/evidence": "^39.1.13",
-    "@evidence-dev/motherduck": "^1.0.2",
-    "@evidence-dev/mssql": "^1.0.9",
-    "@evidence-dev/mysql": "^1.1.3",
-    "@evidence-dev/postgres": "^1.0.6",
-    "@evidence-dev/snowflake": "^1.1.0",
-    "@evidence-dev/sqlite": "^2.0.6",
-    "@evidence-dev/trino": "^1.0.8"
+    "@azure/msal-browser": "^5.17.3",
+    "@azure/msal-node": "^2.9.2",
+    "@azure/msal-react": "^5.5.4",
+    "@google-cloud/local-auth": "^3.0.1",
+    "@microsoft/microsoft-graph-client": "^3.0.5",
+    "clsx": "^2.1.1",
+    "date-fns": "^3.6.0",
+    "exceljs": "^4.4.0",
+    "googleapis": "^173.0.0",
+    "imapflow": "^1.6.5",
+    "isomorphic-fetch": "^3.0.0",
+    "lucide-react": "^0.408.0",
+    "mermaid": "^11.16.0",
+    "nanoid": "^5.0.7",
+    "next": "14.2.5",
+    "openai": "^4.52.0",
+    "papaparse": "^5.4.1",
+    "pdf-parse": "^1.1.2",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "tailwind-merge": "^2.4.0",
+    "zustand": "^4.5.4"
   },
-  "overrides": {
-    "jsonwebtoken": "9.0.0",
-    "trim@<0.0.3": ">0.0.3",
-    "sqlite3": "5.1.5"
+  "devDependencies": {
+    "@cloudflare/next-on-pages": "^1.13.16",
+    "@netlify/plugin-nextjs": "^5.8.1",
+    "@types/node": "^20.14.10",
+    "@types/papaparse": "^5.3.14",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "autoprefixer": "^10.4.19",
+    "eslint": "^8.57.0",
+    "postcss": "^8.4.39",
+    "tailwindcss": "^3.4.6",
+    "tsx": "^4.23.5",
+    "typescript": "^5.5.3"
   }
-}
+}

postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};

scripts/cicd_research.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+CI/CD Research Generator — 24/7 continuous prior art research.
+
+Loops through all 8 research categories, generates a draft for each,
+then starts over. Runs forever. Saves everything to disk.
+
+Each cycle:
+  1. Search GitHub + arXiv + HuggingFace for prior art
+  2. Generate 5-section research draft
+  3. Save to output dir with timestamp
+  4. Move to next category
+  5. After all 8, start over
+
+Usage:
+  python3 cicd_research.py --output ./research_output
+  python3 cicd_research.py --output ./research_output --interval 3600  # wait 1h between cycles
+"""
+
+import sys, os, time, json, argparse, traceback
+from datetime import datetime
+from pathlib import Path
+
+# Add parent to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from prior_art_generator import (
+    PriorArtResearcher, ResearchDraftGenerator, RESEARCH_CATEGORIES,
+    llm_chat, llm_generate_long
+)
+
+def run_cycle(cycle_num, output_dir):
+    """Run one full cycle through all categories."""
+    researcher = PriorArtResearcher()
+    cycle_dir = output_dir / f"cycle_{cycle_num:04d}"
+    cycle_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"\n{'#'*70}", flush=True)
+    print(f"#  CYCLE {cycle_num} — {datetime.now().isoformat()}", flush=True)
+    print(f"#  Output: {cycle_dir}", flush=True)
+    print(f"{'#'*70}", flush=True)
+
+    results_summary = []
+
+    for i, category in enumerate(RESEARCH_CATEGORIES):
+        print(f"\n{'='*60}", flush=True)
+        print(f"  [{i+1}/8] {category['name']}", flush=True)
+        print(f"  Gap: {category['gap'][:80]}...", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        try:
+            # Search for prior art
+            prior_art = researcher.research(category)
+
+            # Generate draft
+            generator = ResearchDraftGenerator(output_dir=str(cycle_dir))
+            filepath, tokens = generator.generate_draft(category, prior_art)
+
+            results_summary.append({
+                "category": category["name"],
+                "prior_art_count": len(prior_art),
+                "tokens_generated": tokens,
+                "file": str(filepath),
+                "status": "success",
+            })
+
+            print(f"\n  ✅ {category['name']}: {tokens} tokens, {len(prior_art)} sources", flush=True)
+
+        except Exception as e:
+            print(f"\n  ❌ {category['name']}: {e}", flush=True)
+            traceback.print_exc()
+            results_summary.append({
+                "category": category["name"],
+                "status": "failed",
+                "error": str(e),
+            })
+            continue
+
+    # Save cycle summary
+    summary_path = cycle_dir / "cycle_summary.json"
+    summary_path.write_text(json.dumps({
+        "cycle": cycle_num,
+        "timestamp": datetime.now().isoformat(),
+        "categories": results_summary,
+        "total_tokens": sum(r.get("tokens_generated", 0) for r in results_summary),
+    }, indent=2))
+
+    print(f"\n{'#'*70}", flush=True)
+    print(f"#  CYCLE {cycle_num} COMPLETE", flush=True)
+    print(f"#  Categories: {len(results_summary)}", flush=True)
+    print(f"#  Success: {sum(1 for r in results_summary if r['status']=='success')}", flush=True)
+    print(f"#  Failed: {sum(1 for r in results_summary if r['status']=='failed')}", flush=True)
+    print(f"{'#'*70}", flush=True)
+
+    return results_summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="CI/CD 24/7 Research Generator")
+    parser.add_argument("--output", type=str, default="./research_output",
+                        help="Output directory")
+    parser.add_argument("--interval", type=int, default=0,
+                        help="Seconds to wait between cycles (0 = no wait)")
+    parser.add_argument("--max-cycles", type=int, default=0,
+                        help="Max cycles (0 = infinite)")
+    args = parser.parse_args()
+
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write master index
+    index_path = output_dir / "INDEX.md"
+    index_path.write_text(f"# Research Output Index\n\n*Started: {datetime.now().isoformat()}*\n\n")
+
+    cycle = 1
+    all_summaries = []
+
+    while True:
+        try:
+            summary = run_cycle(cycle, output_dir)
+            all_summaries.append({"cycle": cycle, "results": summary})
+
+            # Update index
+            index_lines = [f"# Research Output Index",
+                          f"*Last updated: {datetime.now().isoformat()}*",
+                          f"*Cycles completed: {cycle}*",
+                          f"*Total drafts: {sum(len(s['results']) for s in all_summaries)}*",
+                          ""]
+            for s in all_summaries[-10:]:  # last 10 cycles
+                index_lines.append(f"## Cycle {s['cycle']}")
+                for r in s["results"]:
+                    status = "✅" if r["status"] == "success" else "❌"
+                    tokens = r.get("tokens_generated", 0)
+                    index_lines.append(f"  {status} {r['category']} — {tokens} tokens")
+                index_lines.append("")
+            index_path.write_text("\n".join(index_lines))
+
+        except KeyboardInterrupt:
+            print(f"\n\nStopped by user after {cycle} cycles.", flush=True)
+            break
+        except Exception as e:
+            print(f"\n⚠ Cycle {cycle} crashed: {e}", flush=True)
+            traceback.print_exc()
+
+        if args.max_cycles and cycle >= args.max_cycles:
+            print(f"\nReached max cycles ({args.max_cycles}). Stopping.", flush=True)
+            break
+
+        cycle += 1
+
+        if args.interval > 0:
+            print(f"\n⏳ Waiting {args.interval}s before next cycle...", flush=True)
+            time.sleep(args.interval)
+
+
+if __name__ == "__main__":
+    main()

scripts/fractal_book.py

@@ -0,0 +1,566 @@
+#!/usr/bin/env python3
+"""
+Fractal Book Generator — 6 Tomes, Endless Generation
+
+Architecture:
+  Tome (6 total)
+    └── Chapter (each chapter = book-length, fractal)
+          └── Section (generated via rotation)
+                └── Chunk (1024 tokens per request)
+
+Speed decay: generation slows over time to preserve novelty.
+  - First chapter: fast (18 tok/s, raw creative flow)
+  - Later chapters: slower (down to 2 tok/s), more deliberate
+  - This mimics how a real author slows down as the story deepens
+
+Crawler: runs between chapters, compresses previous content:
+  - Removes redundancy
+  - Paraphrases verbose passages
+  - Compresses to ~30% of original token count
+  - Frees up context window for new generation
+
+LGBTQ+ themed — love stories, chosen family, identity journeys.
+
+Usage:
+  python3 fractal_book.py [--tomes 6] [--chapters-per-tome 20] [--output ./book]
+"""
+
+import requests
+import json
+import time
+import os
+import re
+import argparse
+import random
+from datetime import datetime
+from pathlib import Path
+
+# ─── CONFIG ───────────────────────────────────────────────────────────────────
+
+ENDPOINTS = [
+    {"url": "https://gguf-serverless-poc.vercel.app/v1", "model": "/models/model.gguf"},
+    # Add more nodes for parallelism:
+    # {"url": "https://gguf-node-2.vercel.app/v1", "model": "/models/model.gguf"},
+]
+
+MAX_TOKENS_PER_REQUEST = 512  # smaller chunks = faster response within timeout
+REQUEST_TIMEOUT = 120  # seconds — Vercel container may need to reload model
+COLD_START_WAIT = 20  # seconds to wait on 503
+
+# Speed decay — slows generation to preserve novelty
+INITIAL_SPEED_FACTOR = 1.0   # full speed at start
+MIN_SPEED_FACTOR = 0.15      # slow down to 15% by the end
+SPEED_DECAY_PER_CHAPTER = 0.92  # multiply by this each chapter
+
+# Crawler — compresses content to save tokens
+CRAWLER_COMPRESSION_TARGET = 0.35  # compress to 35% of original
+CRAWLER_ENABLED = True
+
+# Fractal — each chapter is book-length
+TOKENS_PER_SECTION = 8000       # each section within a chapter
+SECTIONS_PER_CHAPTER = 5        # sections per chapter (fractal: chapter = book)
+CHAPTERS_PER_TOME = 20          # chapters per tome
+
+# ─── TOMES ────────────────────────────────────────────────────────────────────
+
+TOMES = [
+    {
+        "title": "Tome I: The Awakening",
+        "theme": "A young man discovers his identity in a vibrant coastal city. First love, chosen family, and the courage to be seen. Queer awakening story with joy and heartbreak.",
+        "characters": ["Milo (protagonist, 24, artist)", "Jules (love interest, 26, musician)", "Sasha (best friend, 25, drag performer)", "Elena (mentor, 40, gallery owner)"],
+        "setting": "A seaside art district with queer bars, galleries, and found-family dinners",
+    },
+    {
+        "title": "Tome II: The Currents",
+        "theme": "Relationships deepen and fracture. Polyamory, long-distance love, and the tension between freedom and commitment. The chosen family faces its first real test.",
+        "characters": ["Milo and Jules (now 3 years in)", "Kai (new love, 23, surfer)", "Sasha (navigating sobriety)", "Diego (Jules's ex, returns)"],
+        "setting": "The same city, now through the lens of familiarity — the bars feel smaller, the ocean feels deeper",
+    },
+    {
+        "title": "Tome III: The Depths",
+        "theme": "Loss, grief, and rebirth. A pandemic, a death, a breakup. How queer community holds each other through the worst. Dark but ultimately hopeful.",
+        "characters": ["Milo (grieving)", "Elena (illness)", "Sasha (relapse and recovery)", "New: Tomás (hospice nurse, 30)"],
+        "setting": "Empty streets, hospital rooms, memorial gatherings, the ocean at dawn",
+    },
+    {
+        "title": "Tome IV: The Return",
+        "theme": "Healing and second chances. Milo returns to the city after years away. Rebuilding, forgiveness, and the discovery that home is people, not places.",
+        "characters": ["Milo (returning, 32)", "Jules (reunion)", "Sasha (sober, running a community center)", "New: Aria (16, queer youth Milo mentors)"],
+        "setting": "The city, changed and unchanged. Gentrified queerness, new bars, old ghosts",
+    },
+    {
+        "title": "Tome V: The Legacy",
+        "theme": "Milo builds something lasting — a queer art space, a community, a family. Intergenerational queer stories. What we leave behind.",
+        "characters": ["Milo (35, building)", "Aria (now 19, finding her path)", "Sasha (elder statesman of the scene)", "New: Cole (Milo's adopted son, 8)"],
+        "setting": "A queer community center, an art collective, a home that's always open",
+    },
+    {
+        "title": "Tome VI: The Eternal",
+        "theme": "Time becomes fluid. The book loops back on itself. Characters from all tomes appear at different ages. The story never ends — it just changes form. Queer eternity.",
+        "characters": ["All characters, across time", "The city itself as character", "The ocean as witness"],
+        "setting": "Everywhere and every-when. The coastal city across decades. Dream-logic spaces.",
+    },
+]
+
+# ─── INFERENCE ────────────────────────────────────────────────────────────────
+
+class InferenceNode:
+    def __init__(self, url, model):
+        self.url = url
+        self.model = model
+        self.healthy = True
+        self.request_count = 0
+        self.last_used = 0
+
+    def chat(self, messages, max_tokens=1024, temperature=0.7):
+        """Send a chat completion request. Retries on 503."""
+        endpoint = self.url.rstrip("/") + "/chat/completions"
+
+        for attempt in range(3):
+            try:
+                r = requests.post(endpoint, json={
+                    "model": self.model,
+                    "messages": messages,
+                    "max_tokens": max_tokens,
+                    "temperature": temperature,
+                    "stream": False,
+                }, timeout=REQUEST_TIMEOUT)
+
+                if r.status_code == 503:
+                    print(f"  [cold start] waiting {COLD_START_WAIT}s...")
+                    time.sleep(COLD_START_WAIT)
+                    continue
+
+                r.raise_for_status()
+                data = r.json()
+                self.healthy = True
+                self.request_count += 1
+                self.last_used = time.time()
+
+                content = data["choices"][0]["message"]["content"]
+                tokens = data.get("usage", {}).get("completion_tokens", len(content) // 4)
+                finish = data["choices"][0].get("finish_reason", "stop")
+                return content, tokens, finish
+
+            except Exception as e:
+                print(f"  [error] {e}")
+                self.healthy = False
+                if attempt < 2:
+                    time.sleep(COLD_START_WAIT)
+                else:
+                    raise
+
+        return "", 0, "error"
+
+    def health(self):
+        try:
+            url = self.url.replace("/v1", "/health").rstrip("/")
+            r = requests.get(url, timeout=10)
+            self.healthy = r.ok
+            return r.ok
+        except:
+            self.healthy = False
+            return False
+
+
+# ─── CRAWLER (compression/paraphrasing) ───────────────────────────────────────
+
+class Crawler:
+    """Runs between chapters to compress and refine content.
+    Reduces token count by ~65% while preserving narrative essence."""
+
+    def __init__(self, node):
+        self.node = node
+
+    def compress(self, content, target_ratio=0.35):
+        """Compress content to target_ratio of its original length."""
+        if not content.strip():
+            return content
+
+        original_tokens = len(content) // 4
+        target_tokens = int(original_tokens * target_ratio)
+
+        if target_tokens < 100:
+            return content  # too short to compress
+
+        # Split into chunks of ~2000 tokens for compression
+        chunks = self._split_content(content, max_chars=8000)
+        compressed = []
+
+        for chunk in chunks:
+            messages = [
+                {"role": "system", "content": "You are an editor. Compress the following text to 35% of its length. Remove redundancy, paraphrase verbosely, keep all plot points, character moments, and emotional beats. Preserve the prose style. Output only the compressed text."},
+                {"role": "user", "content": f"Compress this passage:\n\n{chunk}"},
+            ]
+
+            try:
+                result, tokens, _ = self.node.chat(messages, max_tokens=512, temperature=0.3)
+                compressed.append(result)
+                print(f"  [crawler] compressed {len(chunk)//4}→{tokens} tokens ({tokens/(len(chunk)//4)*100:.0f}%)")
+            except:
+                # If compression fails, keep original
+                compressed.append(chunk)
+
+        return "\n\n".join(compressed)
+
+    def _split_content(self, content, max_chars=8000):
+        """Split content at paragraph boundaries."""
+        paragraphs = content.split("\n\n")
+        chunks = []
+        current = ""
+
+        for p in paragraphs:
+            if len(current) + len(p) > max_chars and current:
+                chunks.append(current)
+                current = p
+            else:
+                current = current + "\n\n" + p if current else p
+
+        if current:
+            chunks.append(current)
+
+        return chunks
+
+
+# ─── FRACTAL BOOK GENERATOR ────────────────────────────────────────────���──────
+
+class FractalBookGenerator:
+    def __init__(self, nodes, output_dir="./book"):
+        self.nodes = nodes
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.crawler = Crawler(nodes[0])
+        self.speed_factor = INITIAL_SPEED_FACTOR
+        self.chapter_count = 0
+        self.total_tokens = 0
+        self.compressed_tokens = 0
+
+    def _get_speed_delay(self):
+        """Returns delay (seconds) to wait before generating, based on speed factor.
+        Slower speed = longer delay = more 'deliberate' generation."""
+        base_delay = 0.5  # minimum delay
+        max_delay = 8.0   # maximum delay at slowest speed
+        delay = base_delay + (1.0 - self.speed_factor) * (max_delay - base_delay)
+        # Add randomness for organic feel
+        delay *= random.uniform(0.7, 1.3)
+        return delay
+
+    def _get_temperature(self):
+        """Temperature increases slightly as speed decreases (more creative when slow)."""
+        return 0.7 + (1.0 - self.speed_factor) * 0.3  # 0.7 → 1.0
+
+    def _decay_speed(self):
+        """Slow down generation to preserve novelty."""
+        self.speed_factor = max(MIN_SPEED_FACTOR, self.speed_factor * SPEED_DECAY_PER_CHAPTER)
+        self.chapter_count += 1
+
+    def _get_node(self):
+        """Round-robin to next healthy node."""
+        for node in self.nodes:
+            if node.healthy:
+                return node
+        # All unhealthy — reset and try first
+        for node in self.nodes:
+            node.healthy = True
+        return self.nodes[0]
+
+    def generate_section(self, system_prompt, user_prompt, target_tokens, context=None):
+        """Generate a section via sequential requests within one node."""
+        node = self._get_node()
+        messages = [{"role": "system", "content": system_prompt}]
+
+        if context:
+            # Include compressed context for continuity
+            messages.append({"role": "user", "content": f"Previous context (compressed):\n{context[:4000]}"})
+            messages.append({"role": "assistant", "content": "Understood. I'll continue from this context."})
+
+        messages.append({"role": "user", "content": user_prompt})
+
+        section_content = ""
+        section_tokens = 0
+        rotations = 0
+
+        while section_tokens < target_tokens and rotations < 50:
+            current_msgs = list(messages)
+
+            if rotations > 0:
+                current_msgs.append({
+                    "role": "user",
+                    "content": "Continue exactly where you left off. Do not repeat. Write the next part of this section."
+                })
+
+            # Apply speed delay for novelty preservation
+            delay = self._get_speed_delay()
+            if delay > 0.1:
+                time.sleep(delay)
+
+            temp = self._get_temperature()
+
+            try:
+                content, tokens, finish = node.chat(
+                    current_msgs, max_tokens=MAX_TOKENS_PER_REQUEST, temperature=temp
+                )
+
+                if not content.strip():
+                    break
+
+                section_content += content
+                section_tokens += tokens
+                self.total_tokens += tokens
+                rotations += 1
+
+                # Add to context for continuity
+                messages.append({"role": "assistant", "content": content})
+
+                # Prune context to prevent KV cache bloat
+                if len(messages) > 8:
+                    # Keep system + first user + last 4 exchanges
+                    messages = messages[:2] + messages[-4:]
+
+                print(f"    [{rotations}] {section_tokens}/{target_tokens} tok | "
+                      f"speed={self.speed_factor:.2f} | delay={delay:.1f}s | temp={temp:.1f}")
+
+                # Natural stop
+                if finish == "stop" and tokens < MAX_TOKENS_PER_REQUEST * 0.5:
+                    break
+
+            except Exception as e:
+                print(f"    [error] {e}")
+                time.sleep(5)
+                continue
+
+        return section_content, section_tokens
+
+    def generate_chapter(self, tome, chapter_num, total_chapters, compressed_context=""):
+        """Generate one chapter (fractal: each chapter is book-length with sections)."""
+        chapter_title = f"Chapter {chapter_num}: {self._chapter_title(tome, chapter_num)}"
+
+        print(f"\n  📖 {chapter_title}")
+        print(f"     Speed factor: {self.speed_factor:.3f} | "
+              f"Delay: {self._get_speed_delay():.1f}s | "
+              f"Temp: {self._get_temperature():.1f}")
+
+        system = (
+            f"You are a celebrated queer novelist writing {tome['title']}. "
+            f"Theme: {tome['theme']}\n"
+            f"Characters: {', '.join(tome['characters'])}\n"
+            f"Setting: {tome['setting']}\n\n"
+            f"Write vivid, immersive prose. Include dialogue, sensory details, "
+            f"emotional depth, and queer joy. This is literary fiction — not a summary. "
+            f"Write the actual narrative prose."
+        )
+
+        chapter_content = ""
+        chapter_tokens = 0
+
+        # Each chapter has multiple sections (fractal: chapter = book)
+        for section_num in range(1, SECTIONS_PER_CHAPTER + 1):
+            section_prompt = (
+                f"Write Section {section_num} of {SECTIONS_PER_CHAPTER} of {chapter_title}.\n"
+                f"This is chapter {chapter_num} of {total_chapters} in {tome['title']}.\n\n"
+                f"Section focus: {self._section_focus(tome, chapter_num, section_num)}\n\n"
+                f"Write full narrative prose — at least 1500 words. Include dialogue, "
+                f"description, internal monologue, and sensory detail. Do not summarize."
+            )
+
+            print(f"\n    ─── Section {section_num}/{SECTIONS_PER_CHAPTER} ───")
+            content, tokens = self.generate_section(
+                system, section_prompt, TOKENS_PER_SECTION,
+                context=compressed_context if section_num == 1 else None
+            )
+
+            chapter_content += f"\n\n## Section {section_num}\n\n{content}"
+            chapter_tokens += tokens
+
+            # Save section incrementally
+            self._save_chapter(tome, chapter_num, chapter_title, chapter_content, chapter_tokens)
+
+        # Crawler: compress this chapter for future context
+        compressed = ""
+        if CRAWLER_ENABLED:
+            print(f"\n  🕷️  Crawler compressing chapter {chapter_num}...")
+            compressed = self.crawler.compress(chapter_content, CRAWLER_COMPRESSION_TARGET)
+            comp_tokens = len(compressed) // 4
+            self.compressed_tokens += comp_tokens
+            print(f"     {chapter_tokens}→{comp_tokens} tokens "
+                  f"({comp_tokens/max(chapter_tokens,1)*100:.0f}%)")
+
+        # Decay speed for next chapter (novelty preservation)
+        self._decay_speed()
+
+        return chapter_content, chapter_tokens, compressed
+
+    def generate_tome(self, tome, tome_num):
+        """Generate one full tome (20 chapters)."""
+        print(f"\n{'='*70}")
+        print(f"  📕 {tome['title']}")
+        print(f"     {tome['theme'][:100]}...")
+        print(f"{'='*70}")
+
+        tome_content = ""
+        tome_tokens = 0
+        compressed_context = ""  # Accumulates compressed chapters
+
+        for chapter_num in range(1, CHAPTERS_PER_TOME + 1):
+            chapter_content, chapter_tokens, compressed = self.generate_chapter(
+                tome, chapter_num, CHAPTERS_PER_TOME, compressed_context
+            )
+
+            tome_content += f"\n\n# {tome['title']} — Chapter {chapter_num}\n\n{chapter_content}"
+            tome_tokens += chapter_tokens
+
+            # Add compressed chapter to running context
+            if compressed:
+                compressed_context = self._merge_context(compressed_context, compressed)
+
+            # Save tome incrementally
+            self._save_tome(tome, tome_num, tome_content, tome_tokens)
+
+            # Stats
+            self._print_stats()
+
+        return tome_content, tome_tokens
+
+    def generate_all(self, num_tomes=6):
+        """Generate all tomes. Continuous, endless generation."""
+        print(f"\n{'#'*70}")
+        print(f"#  FRACTAL BOOK GENERATOR")
+        print(f"#  {num_tomes} tomes × {CHAPTERS_PER_TOME} chapters × {SECTIONS_PER_CHAPTER} sections")
+        print(f"#  Speed decay: {INITIAL_SPEED_FACTOR}→{MIN_SPEED_FACTOR} (novelty preservation)")
+        print(f"#  Crawler: {'ON' if CRAWLER_ENABLED else 'OFF'} (compresses to {CRAWLER_COMPRESSION_TARGET*100:.0f}%)")
+        print(f"#  LGBTQ+ themed: love, chosen family, identity, queer joy")
+        print(f"{'#'*70}")
+
+        start_time = time.time()
+
+        # Health check all nodes
+        print("\nHealth checking nodes...")
+        for node in self.nodes:
+            healthy = node.health()
+            print(f"  {node.url}: {'✓' if healthy else '✗'}")
+
+        all_content = ""
+        all_tokens = 0
+
+        for tome_num, tome in enumerate(TOMES[:num_tomes], 1):
+            tome_content, tome_tokens = self.generate_tome(tome, tome_num)
+            all_content += tome_content
+            all_tokens += tome_tokens
+
+            # Save complete book so far
+            self._save_book(all_content, all_tokens, start_time)
+
+        elapsed = time.time() - start_time
+        print(f"\n{'#'*70}")
+        print(f"#  COMPLETE: {num_tomes} tomes, {all_tokens} tokens")
+        print(f"#  Time: {elapsed/3600:.1f} hours")
+        print(f"#  Compressed: {self.compressed_tokens} tokens saved by crawler")
+        print(f"#  Words: ~{all_tokens * 4 // 1}")
+        print(f"#  Pages: ~{all_tokens * 4 // 250}")
+        print(f"{'#'*70}")
+
+    # ─── HELPERS ──────────────────────────────────────────────────────────────
+
+    def _chapter_title(self, tome, chapter_num):
+        titles = [
+            "The First Light", "Salt and Skin", "The Bar at the End of the Pier",
+            "What the Ocean Knows", "Chosen", "The Art of Being Seen",
+            "Ebb", "Flood", "The Dinner Party", "Midnight Swims",
+            "The Gallery", "What We Carry", "The Long Walk Home",
+            "Letters Never Sent", "The Return", "Saudade",
+            "The Lighthouse", "Becoming", "The Eternal Now", "Full Circle",
+        ]
+        return titles[(chapter_num - 1) % len(titles)]
+
+    def _section_focus(self, tome, chapter_num, section_num):
+        focuses = [
+            "Open with a vivid scene. Introduce the emotional landscape. Who is present? What do they want?",
+            "Deepen the scene. Add dialogue — let characters reveal themselves through speech.",
+            "A shift or complication. Something changes. Internal monologue, doubt, desire.",
+            "The emotional peak of this chapter. The most vulnerable moment. Sensory immersion.",
+            "Resolution and transition. A closing image that lingers. Set up the next chapter.",
+        ]
+        return focuses[(section_num - 1) % len(focuses)]
+
+    def _merge_context(self, existing, new):
+        """Merge compressed contexts, keeping total under ~6000 tokens."""
+        merged = existing + "\n\n" + new if existing else new
+        max_chars = 24000  # ~6000 tokens
+        if len(merged) > max_chars:
+            # Keep the most recent (end of the context)
+            merged = merged[-max_chars:]
+        return merged
+
+    def _save_chapter(self, tome, chapter_num, title, content, tokens):
+        """Save chapter incrementally."""
+        tome_dir = self.output_dir / f"tome_{tome['title'].split(':')[0].split()[-1]}"
+        tome_dir.mkdir(parents=True, exist_ok=True)
+        filepath = tome_dir / f"chapter_{chapter_num:02d}.md"
+        with open(filepath, "w") as f:
+            f.write(f"# {title}\n\n*{tokens} tokens*\n\n{content}")
+
+    def _save_tome(self, tome, tome_num, content, tokens):
+        """Save complete tome."""
+        filepath = self.output_dir / f"tome_{tome_num:02d}_{tome['title'].split(':')[1].strip().lower().replace(' ', '_')}.md"
+        with open(filepath, "w") as f:
+            f.write(f"# {tome['title']}\n\n*{tokens} tokens, ~{tokens*4//250} pages*\n\n{content}")
+
+    def _save_book(self, content, tokens, start_time):
+        """Save the complete book."""
+        filepath = self.output_dir / "fractal_book_complete.md"
+        elapsed = time.time() - start_time
+        words = tokens * 4
+        pages = words // 250
+
+        with open(filepath, "w") as f:
+            f.write(f"# The Eternal Book: Six Tomes\n\n")
+            f.write(f"*Generated: {datetime.now().isoformat()}*\n")
+            f.write(f"*Tokens: {tokens} | Words: ~{words} | Pages: ~{pages}*\n")
+            f.write(f"*Time: {elapsed/3600:.1f} hours*\n")
+            f.write(f"*Crawler saved: {self.compressed_tokens} tokens*\n\n")
+            f.write(f"---\n\n{content}")
+
+    def _print_stats(self):
+        """Print running stats."""
+        print(f"\n  📊 Stats: {self.total_tokens} tokens | "
+              f"Speed: {self.speed_factor:.3f} | "
+              f"Crawler saved: {self.compressed_tokens} tokens | "
+              f"Chapters: {self.chapter_count}")
+
+
+# ─── MAIN ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Fractal Book Generator — 6 Tomes")
+    parser.add_argument("--tomes", type=int, default=6, help="Number of tomes (default: 6)")
+    parser.add_argument("--chapters", type=int, default=20, help="Chapters per tome (default: 20)")
+    parser.add_argument("--sections", type=int, default=5, help="Sections per chapter (default: 5)")
+    parser.add_argument("--output", type=str, default="./book", help="Output directory")
+    parser.add_argument("--no-crawler", action="store_true", help="Disable crawler compression")
+    parser.add_argument("--no-decay", action="store_true", help="Disable speed decay")
+    args = parser.parse_args()
+
+    global CHAPTERS_PER_TOME, SECTIONS_PER_CHAPTER, CRAWLER_ENABLED
+    CHAPTERS_PER_TOME = args.chapters
+    SECTIONS_PER_CHAPTER = args.sections
+    if args.no_crawler:
+        global CRAWLER_ENABLED
+        CRAWLER_ENABLED = False
+
+    # Build nodes
+    nodes = [InferenceNode(ep["url"], ep["model"]) for ep in ENDPOINTS]
+
+    # Create generator
+    gen = FractalBookGenerator(nodes, output_dir=args.output)
+
+    if args.no_decay:
+        gen.speed_factor = 1.0
+        global SPEED_DECAY_PER_CHAPTER
+        SPEED_DECAY_PER_CHAPTER = 1.0
+
+    # Generate!
+    gen.generate_all(num_tomes=args.tomes)
+
+
+if __name__ == "__main__":
+    main()

scripts/prior_art_generator.py

@@ -0,0 +1,624 @@
+#!/usr/bin/env python3
+"""
+Prior Art Research Generator
+
+Identifies the most needed category of LLM research by searching:
+  1. GitHub — existing systems, repos, implementations
+  2. arXiv — published papers
+  3. Hugging Face — deployed models, spaces, demos
+
+Then drafts what DOESN'T exist yet — novel system proposals backed
+by real prior art, with defensible novelty claims.
+
+This is NOT creative writing. This is research synthesis.
+
+Usage:
+  python3 prior_art_generator.py [--topic "LLM inference scaling"] [--output ./research]
+  python3 prior_art_generator.py --auto  # auto-discover hottest underexplored topic
+"""
+
+import requests
+import json
+import time
+import re
+import os
+import argparse
+import random
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import quote
+
+# ─── CONFIG ───────────────────────────────────────────────────────────────────
+
+LLM_URL = "https://gguf-serverless-poc.vercel.app/v1/chat/completions"
+LLM_MODEL = "/models/model.gguf"
+REQUEST_TIMEOUT = 120
+COLD_START_WAIT = 15
+MAX_TOKENS_PER_REQUEST = 512
+
+# ─── SEARCH BACKENDS ──────────────────────────────────────────────────────────
+
+class GitHubSearch:
+    """Search GitHub repositories for prior art."""
+    BASE = "https://api.github.com/search/repositories"
+
+    def search(self, query, per_page=10):
+        params = {"q": query, "sort": "stars", "order": "desc", "per_page": per_page}
+        r = requests.get(self.BASE, params=params, timeout=15,
+                         headers={"Accept": "application/vnd.github.v3+json"})
+        if not r.ok:
+            return []
+        data = r.json()
+        results = []
+        for item in data.get("items", []):
+            results.append({
+                "source": "github",
+                "name": item["full_name"],
+                "url": item["html_url"],
+                "stars": item["stargazers_count"],
+                "description": item.get("description", ""),
+                "language": item.get("language", ""),
+                "topics": item.get("topics", []),
+                "updated": item.get("updated_at", ""),
+                "license": item.get("license", {}).get("name", "") if item.get("license") else "",
+            })
+        return results
+
+    def search_code(self, query, per_page=5):
+        """Search code for implementation patterns."""
+        params = {"q": query, "per_page": per_page}
+        r = requests.get("https://api.github.com/search/code", params=params, timeout=15,
+                         headers={"Accept": "application/vnd.github.v3+json"})
+        if not r.ok:
+            return []
+        data = r.json()
+        return [{"source": "github_code", "repo": item["repository"]["full_name"],
+                 "path": item["path"], "url": item["html_url"]}
+                for item in data.get("items", [])]
+
+
+class ArxivSearch:
+    """Search arXiv for published papers."""
+    BASE = "http://export.arxiv.org/api/query"
+
+    def search(self, query, max_results=10):
+        params = {"search_query": f"all:{query}", "max_results": max_results,
+                  "sortBy": "relevance", "sortOrder": "descending"}
+        r = requests.get(self.BASE, params=params, timeout=15)
+        if not r.ok:
+            return []
+        text = r.text
+        entries = []
+        # Parse Atom feed
+        entry_blocks = re.findall(r'<entry>(.*?)</entry>', text, re.DOTALL)
+        for block in entry_blocks:
+            title = re.search(r'<title>(.*?)</title>', block, re.DOTALL)
+            summary = re.search(r'<summary>(.*?)</summary>', block, re.DOTALL)
+            link = re.search(r'<id>(.*?)</id>', block, re.DOTALL)
+            published = re.search(r'<published>(.*?)</published>', block, re.DOTALL)
+            authors = re.findall(r'<name>(.*?)</name>', block, re.DOTALL)
+            entries.append({
+                "source": "arxiv",
+                "title": title.group(1).strip().replace("\n", " ") if title else "",
+                "summary": summary.group(1).strip()[:500] if summary else "",
+                "url": link.group(1).strip() if link else "",
+                "published": published.group(1).strip() if published else "",
+                "authors": authors[:5],
+            })
+        return entries
+
+
+class HuggingFaceSearch:
+    """Search Hugging Face for models, spaces, and datasets."""
+    def search_models(self, query, limit=10):
+        r = requests.get(f"https://huggingface.co/api/models",
+                         params={"search": query, "limit": limit}, timeout=15)
+        if not r.ok:
+            return []
+        data = r.json()
+        return [{
+            "source": "hf_model",
+            "name": m["id"],
+            "url": f"https://huggingface.co/{m['id']}",
+            "downloads": m.get("downloads", 0),
+            "likes": m.get("likes", 0),
+            "tags": m.get("tags", [])[:5],
+        } for m in data]
+
+    def search_spaces(self, query, limit=5):
+        r = requests.get(f"https://huggingface.co/api/spaces",
+                         params={"search": query, "limit": limit}, timeout=15)
+        if not r.ok:
+            return []
+        data = r.json()
+        return [{
+            "source": "hf_space",
+            "name": s["id"],
+            "url": f"https://huggingface.co/spaces/{s['id']}",
+            "tags": s.get("tags", [])[:5],
+        } for s in data]
+
+
+# ─── LLM INFERENCE ────────────────────────────────────────────────────────────
+
+def llm_chat(messages, max_tokens=512, temp=0.7):
+    """Send a chat completion request with retry on cold start."""
+    for attempt in range(3):
+        try:
+            r = requests.post(LLM_URL, json={
+                "model": LLM_MODEL, "messages": messages,
+                "max_tokens": max_tokens, "temperature": temp, "stream": False,
+            }, timeout=REQUEST_TIMEOUT)
+            if r.status_code == 503:
+                print(f"  ❄ cold start, waiting...", flush=True)
+                time.sleep(COLD_START_WAIT)
+                continue
+            r.raise_for_status()
+            d = r.json()
+            return d["choices"][0]["message"]["content"], d["usage"]["completion_tokens"]
+        except Exception as e:
+            print(f"  ⚠ {e}", flush=True)
+            time.sleep(10)
+    return "", 0
+
+
+def llm_generate_long(system_prompt, user_prompt, target_tokens=2000):
+    """Generate long-form text via sequential requests with context pruning."""
+    context = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+    full_text = ""
+    total_tokens = 0
+    rotation = 0
+
+    while total_tokens < target_tokens and rotation < 30:
+        msgs = list(context)
+        if rotation > 0:
+            msgs.append({"role": "user", "content": "Continue. Do not repeat. Write the next section."})
+
+        content, tokens = llm_chat(msgs, max_tokens=MAX_TOKENS_PER_REQUEST, temp=0.7)
+        if not content.strip():
+            break
+
+        full_text += content
+        total_tokens += tokens
+        rotation += 1
+        context.append({"role": "assistant", "content": content})
+
+        # Prune context to prevent KV cache bloat
+        if len(context) > 6:
+            context = context[:2] + context[-4:]
+
+        print(f"    [{rotation}] {total_tokens}/{target_tokens} tok", flush=True)
+
+        if tokens < MAX_TOKENS_PER_REQUEST * 0.3:
+            break  # natural stop
+
+    return full_text, total_tokens
+
+
+# ─── RESEARCH CATEGORIES ──────────────────────────────────────────────────────
+
+# Hot LLM research areas — ranked by "what's most needed but doesn't fully exist yet"
+RESEARCH_CATEGORIES = [
+    {
+        "name": "Serverless LLM Inference Rotation",
+        "description": "Multi-node rotation of serverless inference endpoints to bypass per-container timeout limits",
+        "gap": "No existing system chains serverless inference nodes for continuous generation beyond platform timeout limits",
+        "search_terms": ["llm inference serverless", "llama.cpp serverless", "inference rotation scaling", "serverless model serving"],
+    },
+    {
+        "name": "KV Cache Externalization for Serverless LLMs",
+        "description": "Extracting and persisting KV cache across serverless invocations to avoid recomputation",
+        "gap": "KV cache is ephemeral in serverless — no system persists it externally for reuse across cold starts",
+        "search_terms": ["kv cache persistence", "llm cache external", "kv cache serverless", "transformer cache reuse"],
+    },
+    {
+        "name": "Fractal Token Compression via Self-Editing",
+        "description": "LLM that compresses its own output mid-generation to preserve context window for novel content",
+        "gap": "No system has the model edit/compress its own prior output during generation to free context",
+        "search_terms": ["llm context compression", "token reduction inference", "self-editing generation", "context window optimization"],
+    },
+    {
+        "name": "P2P GGUF Distribution with Chunk-Level Provenance",
+        "description": "BitTorrent-style distribution of GGUF model files with cryptographic chunk provenance",
+        "gap": "Existing model distribution is centralized (HF Hub) — no P2P system with chunk-level integrity verification",
+        "search_terms": ["gguf p2p distribution", "model file sharing", "torrent model distribution", "decentralized llm"],
+    },
+    {
+        "name": "Competitive Inference Racing for Quality Selection",
+        "description": "Multiple models race on the same prompt; preference signals select the best output without human review",
+        "gap": "Arena-style human preference exists, but no autonomous racing system selects outputs without human voting",
+        "search_terms": ["llm arena competitive", "model racing inference", "preference learning llm", "constitutional ai selection"],
+    },
+    {
+        "name": "Email-to-Execution Pipeline with LLM-Generated DAGs",
+        "description": "Parse email content into executable DAGs (directed acyclic graphs) that run ETL operations autonomously",
+        "gap": "Email parsing exists, but no system generates executable workflow DAGs from unstructured email content",
+        "search_terms": ["email etl pipeline", "llm workflow generation", "dag generation from text", "automated email processing"],
+    },
+    {
+        "name": "MCP (Model Context Protocol) for Cross-Model Tool Routing",
+        "description": "Standardized protocol for routing tool calls across heterogeneous LLM endpoints",
+        "gap": "MCP exists as a spec, but no production system routes tool calls across multiple model backends dynamically",
+        "search_terms": ["model context protocol", "mcp llm tools", "cross-model routing", "llm tool orchestration"],
+    },
+    {
+        "name": "WebRTC-Based Peer-to-Peer LLM Inference",
+        "description": "Browser-to-browser LLM inference using WebRTC for direct peer chunk transfer",
+        "gap": "WebRTC exists for media, but no system uses it for LLM model weight or inference distribution",
+        "search_terms": ["webrtc inference", "browser llm", "peer-to-peer model", "webgpu inference"],
+    },
+]
+
+
+# ─── PRIOR ART RESEARCHER ─────────────────────────────────────────────────────
+
+class PriorArtResearcher:
+    """Searches GitHub, arXiv, and Hugging Face for prior art on a topic."""
+
+    def __init__(self):
+        self.github = GitHubSearch()
+        self.arxiv = ArxivSearch()
+        self.hf = HuggingFaceSearch()
+
+    def research(self, category):
+        """Search all sources for prior art on a research category."""
+        print(f"\n{'─'*60}", flush=True)
+        print(f"  RESEARCHING: {category['name']}", flush=True)
+        print(f"  Gap: {category['gap']}", flush=True)
+        print(f"{'─'*60}", flush=True)
+
+        all_results = []
+        for term in category["search_terms"]:
+            print(f"\n  Searching: \"{term}\"", flush=True)
+
+            # GitHub
+            print(f"    GitHub...", flush=True)
+            gh = self.github.search(term, per_page=5)
+            all_results.extend(gh)
+            for r in gh[:3]:
+                print(f"      ★{r['stars']:>5} {r['name']} — {(r['description'] or '')[:60]}", flush=True)
+
+            # arXiv
+            print(f"    arXiv...", flush=True)
+            ax = self.arxiv.search(term, max_results=5)
+            all_results.extend(ax)
+            for r in ax[:2]:
+                print(f"      📄 {r['title'][:80]}", flush=True)
+
+            # HuggingFace
+            print(f"    HuggingFace...", flush=True)
+            hf_models = self.hf.search_models(term, limit=3)
+            all_results.extend(hf_models)
+            for r in hf_models[:2]:
+                print(f"      🤗 {r['name']} ({r['downloads']} downloads)", flush=True)
+
+            time.sleep(1)  # rate limit courtesy
+
+        return all_results
+
+    def auto_discover(self):
+        """Search all categories and rank by 'most needed but least explored'."""
+        print(f"\n{'='*60}", flush=True)
+        print(f"  AUTO-DISCOVERING HOTTEST UNDEREXPLORED TOPIC", flush=True)
+        print(f"  Searching {len(RESEARCH_CATEGORIES)} research categories...", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        scored = []
+        for cat in RESEARCH_CATEGORIES:
+            results = self.research(cat)
+            github_count = len([r for r in results if r["source"] == "github"])
+            arxiv_count = len([r for r in results if r["source"] == "arxiv"])
+            hf_count = len([r for r in results if r["source"] in ("hf_model", "hf_space")])
+            total = len(results)
+
+            # Score: lower existing work = higher novelty potential
+            # But need SOME existing work to build on
+            if total == 0:
+                novelty_score = 0  # too novel — nothing to build on
+            else:
+                novelty_score = max(0, 100 - total * 3)  # fewer results = more novel
+
+            scored.append({
+                "category": cat,
+                "results": results,
+                "github_count": github_count,
+                "arxiv_count": arxiv_count,
+                "hf_count": hf_count,
+                "total": total,
+                "novelty_score": novelty_score,
+            })
+
+            print(f"\n  📊 {cat['name']}: {total} results "
+                  f"(GH:{github_count} arXiv:{arxiv_count} HF:{hf_count}) "
+                  f"— Novelty: {novelty_score}/100", flush=True)
+
+        # Sort by novelty score (highest = most needed, least explored)
+        scored.sort(key=lambda x: x["novelty_score"], reverse=True)
+
+        print(f"\n{'='*60}", flush=True)
+        print(f"  RANKING (most needed → least needed):", flush=True)
+        for i, s in enumerate(scored):
+            marker = " ◀ SELECTED" if i == 0 else ""
+            print(f"  {i+1}. {s['category']['name']} "
+                  f"— {s['total']} prior art, novelty={s['novelty_score']}{marker}", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        return scored[0]
+
+
+# ─── RESEARCH DRAFT GENERATOR ─────────────────────────────────────────────────
+
+class ResearchDraftGenerator:
+    """Generates a research draft claiming novelty backed by prior art."""
+
+    def __init__(self, output_dir="./research"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_draft(self, category, prior_art):
+        """Generate a full research draft with defensible novelty claims."""
+        print(f"\n{'='*60}", flush=True)
+        print(f"  GENERATING RESEARCH DRAFT", flush=True)
+        print(f"  Topic: {category['name']}", flush=True)
+        print(f"  Prior art: {len(prior_art)} sources", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        # Format prior art for the LLM context
+        prior_art_text = self._format_prior_art(prior_art)
+
+        # ─── SECTION 1: ABSTRACT & PROBLEM STATEMENT ───────────
+        print(f"\n  📝 Section 1: Abstract & Problem Statement", flush=True)
+        s1_system = (
+            "You are a senior ML systems researcher writing a technical paper. "
+            "You write precise, academic prose with citations. "
+            "You identify gaps in existing systems and propose novel solutions backed by prior art. "
+            "Do not write fiction. Write research."
+        )
+        s1_prompt = (
+            f"Write the Abstract and Problem Statement for a research paper on: {category['name']}.\n\n"
+            f"Description: {category['description']}\n"
+            f"Identified gap: {category['gap']}\n\n"
+            f"Prior art (existing systems this builds on):\n{prior_art_text[:3000]}\n\n"
+            f"Write a rigorous abstract (200 words) and problem statement (500 words) "
+            f"that positions this work against the prior art. Cite specific systems by name. "
+            f"Clearly state what does NOT exist yet and why it matters."
+        )
+        s1_text, s1_tokens = llm_generate_long(s1_system, s1_prompt, target_tokens=1500)
+
+        # ─── SECTION 2: RELATED WORK ────────────────────────────
+        print(f"\n  📝 Section 2: Related Work (Prior Art Analysis)", flush=True)
+        s2_system = s1_system
+        s2_prompt = (
+            f"Write the Related Work section for a paper on {category['name']}.\n\n"
+            f"Analyze these existing systems and papers:\n{prior_art_text[:4000]}\n\n"
+            f"For each category of prior art:\n"
+            f"1. Summarize what exists\n"
+            f"2. Identify limitations\n"
+            f"3. State what gap remains\n\n"
+            f"Be specific — cite repo names, paper titles, and model names. "
+            f"This is a literature review, not a summary."
+        )
+        s2_text, s2_tokens = llm_generate_long(s2_system, s2_prompt, target_tokens=2000)
+
+        # ─── SECTION 3: PROPOSED SYSTEM ─────────────────────────
+        print(f"\n  📝 Section 3: Proposed System Architecture", flush=True)
+        s3_system = s1_system
+        s3_prompt = (
+            f"Write the Proposed System section for a paper on {category['name']}.\n\n"
+            f"Gap being addressed: {category['gap']}\n\n"
+            f"Design a novel system that fills this gap. Include:\n"
+            f"1. System architecture (components, data flow)\n"
+            f"2. Novel contributions (what doesn't exist in prior art)\n"
+            f"3. Technical approach (algorithms, protocols, data structures)\n"
+            f"4. Why this is defensibly novel (cite what exists vs what's new)\n\n"
+            f"Prior art for context:\n{prior_art_text[:2000]}\n\n"
+            f"Write technical specifications, not vague descriptions."
+        )
+        s3_text, s3_tokens = llm_generate_long(s3_system, s3_prompt, target_tokens=2000)
+
+        # Save partial draft after section 3
+        self._save_partial(category, prior_art, s1_text, s2_text, s3_text, "", "")
+
+        # ─── SECTION 4: NOVELTY DEFENSE ─────────────────────────
+        print(f"\n  📝 Section 4: Novelty Defense (Claim Analysis)", flush=True)
+        s4_system = s1_system
+        s4_prompt = (
+            f"Write the Novelty Analysis section for a paper on {category['name']}.\n\n"
+            f"Defend the novelty claims against this prior art:\n{prior_art_text[:3000]}\n\n"
+            f"For each novel claim:\n"
+            f"1. State the claim\n"
+            f"2. List the closest existing system\n"
+            f"3. Explain the specific difference\n"
+            f"4. Rate novelty strength (incremental/moderate/fundamental)\n\n"
+            f"Be honest — if something is incremental, say so. "
+            f"Only claim fundamental novelty where the prior art genuinely lacks it."
+        )
+        s4_text, s4_tokens = llm_generate_long(s4_system, s4_prompt, target_tokens=1500)
+
+        # Save partial after section 4
+        self._save_partial(category, prior_art, s1_text, s2_text, s3_text, s4_text, "")
+
+        # ─── SECTION 5: IMPLEMENTATION ROADMAP ──────────────────
+        print(f"\n  📝 Section 5: Implementation Roadmap", flush=True)
+        s5_system = s1_system
+        s5_prompt = (
+            f"Write the Implementation Roadmap for the proposed system: {category['name']}.\n\n"
+            f"Gap: {category['gap']}\n\n"
+            f"Include:\n"
+            f"1. MVP scope (what to build first)\n"
+            f"2. Dependencies (existing tools, libraries, models to use)\n"
+            f"3. Evaluation metrics (how to measure success)\n"
+            f"4. Risk assessment (what could fail)\n"
+            f"5. Timeline (phased approach)\n\n"
+            f"Reference specific tools from prior art where applicable:\n{prior_art_text[:1500]}"
+        )
+        s5_text, s5_tokens = llm_generate_long(s5_system, s5_prompt, target_tokens=1500)
+
+        # ─── ASSEMBLE ───────────────────────────────────────────
+        total_tokens = s1_tokens + s2_tokens + s3_tokens + s4_tokens + s5_tokens
+        timestamp = datetime.now().isoformat()
+
+        draft = f"""# {category['name']}
+## A Novel System Proposal Backed by Prior Art Analysis
+
+*Generated: {timestamp}*
+*Prior art sources: {len(prior_art)} (GitHub, arXiv, Hugging Face)*
+*Total tokens generated: {total_tokens}*
+
+---
+
+## Prior Art Sources
+
+{self._format_prior_art_table(prior_art)}
+
+---
+
+## Section 1: Abstract & Problem Statement
+
+{s1_text}
+
+---
+
+## Section 2: Related Work
+
+{s2_text}
+
+---
+
+## Section 3: Proposed System Architecture
+
+{s3_text}
+
+---
+
+## Section 4: Novelty Defense
+
+{s4_text}
+
+---
+
+## Section 5: Implementation Roadmap
+
+{s5_text}
+
+---
+
+## Appendix: Raw Prior Art Data
+
+{json.dumps(prior_art, indent=2)[:5000]}
+"""
+
+        # Save
+        filename = f"{category['name'].lower().replace(' ', '_').replace('/', '_')}.md"
+        filepath = self.output_dir / filename
+        filepath.write_text(draft)
+
+        print(f"\n{'='*60}", flush=True)
+        print(f"  DRAFT COMPLETE", flush=True)
+        print(f"  Sections: 5", flush=True)
+        print(f"  Total tokens: {total_tokens}", flush=True)
+        print(f"  Prior art cited: {len(prior_art)}", flush=True)
+        print(f"  Saved to: {filepath}", flush=True)
+        print(f"{'='*60}", flush=True)
+
+        return filepath, total_tokens
+
+    def _save_partial(self, category, prior_art, s1, s2, s3, s4, s5):
+        """Save partial draft incrementally."""
+        filename = f"{category['name'].lower().replace(' ', '_').replace('/', '_')}.md"
+        filepath = self.output_dir / filename
+        sections = []
+        if s1: sections.append(f"## Section 1: Abstract & Problem Statement\n\n{s1}")
+        if s2: sections.append(f"## Section 2: Related Work\n\n{s2}")
+        if s3: sections.append(f"## Section 3: Proposed System Architecture\n\n{s3}")
+        if s4: sections.append(f"## Section 4: Novelty Defense\n\n{s4}")
+        if s5: sections.append(f"## Section 5: Implementation Roadmap\n\n{s5}")
+
+        content = f"# {category['name']}\n## Novel System Proposal (PARTIAL)\n\n---\n\n" + "\n\n---\n\n".join(sections)
+        filepath.write_text(content)
+
+    def _format_prior_art(self, results):
+        """Format prior art results as text for LLM context."""
+        lines = []
+        for r in results:
+            if r["source"] == "github":
+                lines.append(f"- [GitHub] {r['name']} (★{r['stars']}) — {r['description'][:100] if r['description'] else 'no description'} | {r['url']}")
+            elif r["source"] == "arxiv":
+                lines.append(f"- [arXiv] \"{r['title']}\" by {', '.join(r['authors'][:2])} — {r['summary'][:100]} | {r['url']}")
+            elif r["source"] == "hf_model":
+                lines.append(f"- [HF Model] {r['name']} ({r['downloads']} downloads) — tags: {', '.join(r['tags'][:3])} | {r['url']}")
+            elif r["source"] == "hf_space":
+                lines.append(f"- [HF Space] {r['name']} — {r['url']}")
+        return "\n".join(lines[:30])  # cap at 30 sources
+
+    def _format_prior_art_table(self, results):
+        """Format prior art as a markdown table."""
+        lines = ["| Source | Name | Details | URL |", "|--------|------|---------|-----|"]
+        for r in results[:20]:
+            if r["source"] == "github":
+                lines.append(f"| GitHub | {r['name']} | ★{r['stars']} — {r['description'][:50] if r['description'] else ''} | {r['url']} |")
+            elif r["source"] == "arxiv":
+                lines.append(f"| arXiv | {r['title'][:40]} | {r['published'][:10]} | {r['url']} |")
+            elif r["source"] == "hf_model":
+                lines.append(f"| HF | {r['name']} | {r['downloads']} downloads | {r['url']} |")
+        return "\n".join(lines)
+
+
+# ─── MAIN ─────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Prior Art Research Generator")
+    parser.add_argument("--topic", type=str, default=None,
+                        help="Specific research topic (default: auto-discover)")
+    parser.add_argument("--auto", action="store_true",
+                        help="Auto-discover the most needed underexplored topic")
+    parser.add_argument("--output", type=str, default="./research",
+                        help="Output directory")
+    parser.add_argument("--list", action="store_true",
+                        help="List all research categories and exit")
+    args = parser.parse_args()
+
+    if args.list:
+        print("\nResearch Categories:")
+        for i, cat in enumerate(RESEARCH_CATEGORIES, 1):
+            print(f"\n  {i}. {cat['name']}")
+            print(f"     {cat['description']}")
+            print(f"     Gap: {cat['gap']}")
+        return
+
+    researcher = PriorArtResearcher()
+    generator = ResearchDraftGenerator(output_dir=args.output)
+
+    if args.topic:
+        # Find matching category or create one
+        category = None
+        for cat in RESEARCH_CATEGORIES:
+            if args.topic.lower() in cat["name"].lower():
+                category = cat
+                break
+        if not category:
+            category = {
+                "name": args.topic,
+                "description": args.topic,
+                "gap": f"No comprehensive system exists for {args.topic}",
+                "search_terms": [args.topic.lower()],
+            }
+        prior_art = researcher.research(category)
+    else:
+        # Auto-discover
+        best = researcher.auto_discover()
+        category = best["category"]
+        prior_art = best["results"]
+
+    # Generate the research draft
+    filepath, tokens = generator.generate_draft(category, prior_art)
+
+    print(f"\n✅ Research draft saved to: {filepath}", flush=True)
+    print(f"   Open it to review the novel system proposal.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

src/app/(app)/discovery-ledger/page.tsx

@@ -0,0 +1,97 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+
+interface FairnessAudit { totalHighUpside: number; builderMissions: number; goldenNodeCredit: number; hoardingDetected: boolean; perEmployee: { employeeId: string; highUpside: number; builder: number; replications: number; usefulFailures: number; goldenNodeCredit: number; }[]; }
+interface ResearchReliability { employeeId: string; level: string; metrics: { executionQuality: number; evidenceQuality: number; completionRate: number; confounderControl: number; derivativeRate: number; }; }
+interface CompetitionRanking { employeeId: string; totalScore: number; categoryWins: Record<string, number>; }
+
+export default function DiscoveryLedgerPage() {
+  const [audit, setAudit] = useState<FairnessAudit | null>(null);
+  const [reliability, setReliability] = useState<ResearchReliability[]>([]);
+  const [rankings, setRankings] = useState<CompetitionRanking[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    try {
+      const [aRes, rRes, cRes] = await Promise.all([
+        fetch("/api/golden/discovery-ledger?audit=true"),
+        fetch("/api/golden/research-reliability"),
+        fetch("/api/golden/competition?rank=true"),
+      ]);
+      const aData = await aRes.json();
+      const rData = await rRes.json();
+      const cData = await cRes.json();
+      setAudit(aData.audit || null);
+      setReliability(rData.reliability || []);
+      setRankings(cData.rankings || []);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading discovery ledger…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">History</h1>
+      <p className="mt-2 text-muted-foreground">Discovery ledger, fairness audit, research reliability, and competition rankings.</p>
+      {audit && (
+        <div className="card mt-6 p-5">
+          <p className="done-section-label">Fairness audit</p>
+          <div className="mt-3 grid grid-cols-2 gap-4 text-sm md:grid-cols-4">
+            <div><p className="text-muted-foreground">High-upside total</p><p className="text-lg font-bold text-foreground">{audit.totalHighUpside}</p></div>
+            <div><p className="text-muted-foreground">Builder missions</p><p className="text-lg font-bold text-foreground">{audit.builderMissions}</p></div>
+            <div><p className="text-muted-foreground">Golden node credit</p><p className="text-lg font-bold text-foreground">{audit.goldenNodeCredit}</p></div>
+            <div><p className="text-muted-foreground">Hoarding</p><p className={`text-lg font-bold ${audit.hoardingDetected ? "text-status-blocked" : "text-status-completed"}`}>{audit.hoardingDetected ? "Detected" : "None"}</p></div>
+          </div>
+          {audit.perEmployee.length > 0 && (
+            <table className="mt-4 w-full text-sm">
+              <thead><tr className="text-left text-xs text-muted-foreground"><th className="pb-2">Employee</th><th className="pb-2">High-upside</th><th className="pb-2">Builder</th><th className="pb-2">Replications</th><th className="pb-2">Useful failures</th><th className="pb-2">GN credit</th></tr></thead>
+              <tbody>
+                {audit.perEmployee.map((e) => (<tr key={e.employeeId} className="border-t border-border"><td className="py-2 text-foreground">{e.employeeId}</td><td className="py-2 text-foreground/90">{e.highUpside}</td><td className="py-2 text-foreground/90">{e.builder}</td><td className="py-2 text-foreground/90">{e.replications}</td><td className="py-2 text-foreground/90">{e.usefulFailures}</td><td className="py-2 text-foreground/90">{e.goldenNodeCredit}</td></tr>))}
+              </tbody>
+            </table>
+          )}
+        </div>
+      )}
+      <div className="card mt-4 p-5">
+        <p className="done-section-label">Research reliability</p>
+        {reliability.length === 0 ? (<p className="mt-3 text-sm text-muted-foreground">No reliability data yet.</p>) : (
+          <div className="mt-3 space-y-3">
+            {reliability.map((r) => (
+              <div key={r.employeeId} className="rounded-lg border border-border p-3">
+                <div className="flex items-center justify-between"><p className="font-medium text-foreground">{r.employeeId}</p><span className="rounded-full bg-foreground/10 px-2.5 py-0.5 text-xs font-medium text-foreground">{r.level}</span></div>
+                <div className="mt-2 grid grid-cols-2 gap-2 text-xs md:grid-cols-5">
+                  {Object.entries(r.metrics).map(([k, v]) => (<div key={k}><p className="text-muted-foreground">{k.replace(/([A-Z])/g, " $1").trim()}</p><p className="font-medium text-foreground">{(v * 100).toFixed(0)}%</p></div>))}
+                </div>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+      <div className="card mt-4 p-5">
+        <p className="done-section-label">Research competition</p>
+        {rankings.length === 0 ? (<p className="mt-3 text-sm text-muted-foreground">No rankings yet.</p>) : (
+          <div className="mt-3 space-y-2">
+            {rankings.map((r, i) => (
+              <div key={r.employeeId} className="flex items-center justify-between rounded-lg border border-border p-3">
+                <div className="flex items-center gap-3">
+                  <span className="flex h-7 w-7 items-center justify-center rounded-full bg-foreground/10 text-sm font-bold text-foreground">{i + 1}</span>
+                  <div><p className="font-medium text-foreground">{r.employeeId}</p><div className="mt-0.5 flex flex-wrap gap-1">{Object.entries(r.categoryWins).filter(([, v]) => v > 0).map(([k, v]) => (<span key={k} className="rounded-full border border-border px-2 py-0.5 text-[10px] text-muted-foreground">{k.replace(/_/g, " ")}: {v}</span>))}</div></div>
+                </div>
+                <p className="text-lg font-bold text-foreground">{r.totalScore.toFixed(1)}</p>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

src/app/(app)/experiment/page.tsx

@@ -0,0 +1,2 @@
+import { redirect } from "next/navigation";
+export default function ExperimentPage() { redirect("/experiments"); }

src/app/(app)/experiments/page.tsx

@@ -0,0 +1,140 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+import type { HypothesisAnatomy, HypothesisAssignment, SuccessKind } from "@/types";
+
+const EMPLOYEE_ID = "emp-001";
+
+export default function ExperimentsPage() {
+  const [assignments, setAssignments] = useState<HypothesisAssignment[]>([]);
+  const [hypotheses, setHypotheses] = useState<Map<string, HypothesisAnatomy>>(new Map());
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [recordingFor, setRecordingFor] = useState<string | null>(null);
+  const [form, setForm] = useState({
+    successKind: "performance" as SuccessKind,
+    outcomeDescription: "",
+    falsified: false,
+    falsificationEvidence: "",
+    metricName: "",
+    metricValue: 0,
+    metricBaseline: 0,
+    metricUnit: "",
+    higherIsBetter: true,
+  });
+  const [submitting, setSubmitting] = useState(false);
+  const [lastResult, setLastResult] = useState<string | null>(null);
+  const [useLLM, setUseLLM] = useState(true);
+
+  const load = useCallback(async () => {
+    try {
+      const [aRes, hRes] = await Promise.all([
+        fetch(`/api/golden/assignments?employeeId=${EMPLOYEE_ID}`),
+        fetch("/api/golden/hypotheses"),
+      ]);
+      const aData = await aRes.json();
+      const hData = await hRes.json();
+      setAssignments(aData.assignments || []);
+      setHypotheses(new Map((hData.hypotheses || []).map((h: HypothesisAnatomy) => [h.id, h])));
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  async function submitOutcome(assignmentId: string) {
+    setSubmitting(true);
+    setLastResult(null);
+    try {
+      const metrics = form.metricName
+        ? [{ metric: form.metricName, value: Number(form.metricValue), unit: form.metricUnit, baseline: Number(form.metricBaseline), higherIsBetter: form.higherIsBetter }]
+        : [];
+      const res = await fetch("/api/golden/outcomes", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          assignmentId, successKind: form.successKind, outcomeDescription: form.outcomeDescription,
+          metrics, falsified: form.falsified, falsificationEvidence: form.falsificationEvidence || undefined, useLLM,
+        }),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      const llmTag = data.llmUsed ? " [LLM]" : " [deterministic]";
+      setLastResult(
+        `Recorded${llmTag}. Attribution: ${data.attribution ? data.attribution.responsibleFactor.replace(/_/g, " ") + ` (confidence ${(data.attribution.attributionConfidence * 100).toFixed(0)}%)` : "pending"}. Derivatives generated: ${data.derivatives?.length || 0}.`
+      );
+      setRecordingFor(null);
+      setForm({ successKind: "performance", outcomeDescription: "", falsified: false, falsificationEvidence: "", metricName: "", metricValue: 0, metricBaseline: 0, metricUnit: "", higherIsBetter: true });
+      await load();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Recording failed");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading experiments…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+
+  const active = assignments.filter((a) => !["falsified", "validated", "scaled", "productized", "channel", "rejected", "completed"].includes(a.state));
+
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Experiments</h1>
+      <p className="mt-2 text-muted-foreground">Record outcomes from your active hypothesis missions.</p>
+
+      {lastResult && (
+        <div className="mt-4 rounded-lg border border-status-completed/30 bg-status-completed/10 p-4 text-sm text-foreground/90">{lastResult}</div>
+      )}
+
+      {active.length === 0 ? (
+        <div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No active experiments. Accept a hypothesis from Today's Research.</p></div>
+      ) : (
+        <div className="mt-6 space-y-4">
+          {active.map((a) => {
+            const h = hypotheses.get(a.hypothesisId);
+            return (
+              <div key={a.id} className="card p-5">
+                <div className="flex items-start justify-between">
+                  <div>
+                    <p className="font-medium text-foreground">{h?.claim || a.hypothesisId}</p>
+                    <p className="mt-1 text-xs text-muted-foreground">{a.kind} · {a.state} · Trial {a.trialNumber} · {a.evaluationPeriodDays}d window · {a.eligibleAccountIds.length} accounts</p>
+                  </div>
+                  <button onClick={() => { setRecordingFor(recordingFor === a.id ? null : a.id); setLastResult(null); }} className="btn btn-primary">{recordingFor === a.id ? "Cancel" : "Record outcome"}</button>
+                </div>
+                {recordingFor === a.id && (
+                  <div className="mt-4 space-y-3 border-t border-border pt-4">
+                    <label className="block">
+                      <span className="done-section-label">Success kind</span>
+                      <select className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" value={form.successKind} onChange={(e) => setForm({ ...form, successKind: e.target.value as SuccessKind })}>
+                        {["performance", "efficiency", "discovery", "boundary", "system", "channel", "falsification"].map((k) => (<option key={k} value={k}>{k}</option>))}
+                      </select>
+                    </label>
+                    <label className="block">
+                      <span className="done-section-label">Outcome description</span>
+                      <textarea className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" rows={3} placeholder="What happened? What did you observe?" value={form.outcomeDescription} onChange={(e) => setForm({ ...form, outcomeDescription: e.target.value })} />
+                    </label>
+                    <div className="grid grid-cols-2 gap-3">
+                      <label className="block"><span className="done-section-label">Metric name</span><input className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" placeholder="e.g. completion_rate" value={form.metricName} onChange={(e) => setForm({ ...form, metricName: e.target.value })} /></label>
+                      <label className="block"><span className="done-section-label">Unit</span><input className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" placeholder="e.g. pct" value={form.metricUnit} onChange={(e) => setForm({ ...form, metricUnit: e.target.value })} /></label>
+                      <label className="block"><span className="done-section-label">Value</span><input type="number" className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" value={form.metricValue} onChange={(e) => setForm({ ...form, metricValue: Number(e.target.value) })} /></label>
+                      <label className="block"><span className="done-section-label">Baseline</span><input type="number" className="mt-1 w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" value={form.metricBaseline} onChange={(e) => setForm({ ...form, metricBaseline: Number(e.target.value) })} /></label>
+                    </div>
+                    <label className="flex items-center gap-2 text-sm text-muted-foreground"><input type="checkbox" checked={form.higherIsBetter} onChange={(e) => setForm({ ...form, higherIsBetter: e.target.checked })} />Higher is better</label>
+                    <label className="flex items-center gap-2 text-sm text-muted-foreground"><input type="checkbox" checked={form.falsified} onChange={(e) => setForm({ ...form, falsified: e.target.checked })} />This falsifies the hypothesis (useful failure)</label>
+                    {form.falsified && (<input className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" placeholder="Falsification evidence" value={form.falsificationEvidence} onChange={(e) => setForm({ ...form, falsificationEvidence: e.target.value })} />)}
+                    <label className="flex items-center gap-2 text-sm text-muted-foreground"><input type="checkbox" checked={useLLM} onChange={(e) => setUseLLM(e.target.checked)} />Use LLM for attribution & derivatives (falls back to deterministic if unavailable)</label>
+                    <button onClick={() => submitOutcome(a.id)} disabled={submitting || !form.outcomeDescription} className="btn btn-primary disabled:opacity-50">{submitting ? "Recording…" : "Submit & attribute"}</button>
+                  </div>
+                )}
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}

src/app/(app)/foundry/page.tsx

@@ -0,0 +1,279 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type {
+  SpinorOrganism,
+  SpinorOrganismNode,
+  SpinorSignatureAction,
+  SpinorMaturityStage,
+  SpinorEvidenceBadge,
+} from "@/types";
+import {
+  STAGE_LABEL,
+  STAGE_GLYPH,
+  EVIDENCE_LABEL,
+  ACTION_LABEL,
+} from "@/lib/spinor/scoring";
+
+const EMPLOYEE_ID = "emp-001";
+
+const COLOR_HEX: Record<SpinorOrganismNode["color"], string> = {
+  blue: "#38bdf8", violet: "#a78bfa", green: "#34d399", gold: "#fbbf24", red: "#f87171", gray: "#94a3b8",
+};
+
+const STAGE_COLOR: Record<SpinorMaturityStage, string> = {
+  seed: "#94a3b8", sprout: "#34d399", branch: "#a78bfa", grove: "#38bdf8", golden_node: "#fbbf24", infrastructure: "#f59e0b", spinout: "#fb923c",
+};
+
+const ROLE_LABEL: Record<SpinorOrganismNode["role"], string> = {
+  core: "Core hypothesis", supporting_research: "Supporting research", contradicting: "Contradicting evidence",
+  previous_attempt: "Previous attempt", derivative: "Derivative", replication: "Replication (root)",
+  risk_signal: "Risk signal", expected_value: "Expected value (fruit)", golden_node: "Golden Node", compost: "Compost",
+};
+
+const ACTION_ENDPOINT: Record<SpinorSignatureAction, "accept" | "reject" | "modify"> = {
+  plant: "accept", observe: "accept", record: "accept", challenge: "reject",
+  replicate: "accept", derive: "modify", integrate: "accept", spin_out: "accept",
+};
+
+export default function FoundryPage() {
+  const [organism, setOrganism] = useState<SpinorOrganism | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [acting, setActing] = useState<SpinorSignatureAction | null>(null);
+  const [flash, setFlash] = useState<string | null>(null);
+  const [selectedNode, setSelectedNode] = useState<SpinorOrganismNode | null>(null);
+  const [priorArt, setPriorArt] = useState<{ id: string; hypothesisClaim: string; status: string; evidenceState: string; adjacentSupportSummary: string; sourceDomains: string[]; researchConfidence: number } | null>(null);
+  const [derivatives, setDerivatives] = useState<{ id: string; claim: string; modifiedDimension: string; rationale: string; status: string; origin: string }[]>([]);
+
+  const load = useCallback(async () => {
+    try {
+      const [res, paRes, derRes] = await Promise.all([
+        fetch(`/api/spinor/organism?employeeId=${EMPLOYEE_ID}`, { cache: "no-store" }),
+        fetch("/api/golden/prior-art", { cache: "no-store" }),
+        fetch("/api/golden/derivatives", { cache: "no-store" }),
+      ]);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      if (!data.organism) throw new Error("No organism available.");
+      setOrganism(data.organism as SpinorOrganism);
+      setSelectedNode(null);
+      const paData = await paRes.json();
+      const paList: { id: string; hypothesisClaim: string; status: string; evidenceState: string; adjacentSupportSummary: string; sourceDomains: string[]; researchConfidence: number }[] = paData.priorArt || [];
+      const paRefId = (data.organism.nodes as SpinorOrganismNode[]).find((n: SpinorOrganismNode) => n.role === "supporting_research")?.refId;
+      setPriorArt(paList.find((p) => p.id === paRefId) ?? paList[0] ?? null);
+      const derData = await derRes.json();
+      const derList: { id: string; claim: string; modifiedDimension: string; rationale: string; status: string; origin: string }[] = derData.derivatives || [];
+      setDerivatives(derList);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load organism.");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  async function performAction(action: SpinorSignatureAction) {
+    if (!organism) return;
+    setActing(action);
+    setFlash(null);
+    try {
+      const endpoint = ACTION_ENDPOINT[action];
+      const body: Record<string, unknown> = { action: endpoint, assignmentId: organism.assignmentId };
+      if (action === "derive") { body.dimension = "content_sequence"; body.rationale = `Derivative proposed from ${organism.hypothesisId} via SPINOR Derive action.`; }
+      if (action === "challenge") { body.note = `Challenged via SPINOR: ${organism.falsificationCondition}`; }
+      const res = await fetch("/api/golden/assignments", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      setFlash(`${ACTION_LABEL[action]} recorded. The organism is evolving.`);
+      await load();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : `${ACTION_LABEL[action]} failed.`);
+    } finally {
+      setActing(null);
+    }
+  }
+
+  const canvas = useMemo(() => {
+    if (!organism) return null;
+    const W = 640, H = 640, cx = W / 2, cy = H / 2, ringScale = 110;
+    const placed = organism.nodes.map((n) => { const r = n.radius * ringScale; return { ...n, x: cx + Math.cos(n.angle) * r, y: cy + Math.sin(n.angle) * r }; });
+    return { W, H, cx, cy, placed };
+  }, [organism]);
+
+  if (loading) return <div className="mx-auto flex max-w-6xl flex-col items-center justify-center px-8 py-20"><div className="animate-pulse text-muted-foreground">Building your Hypothesis Organism…</div></div>;
+  if (error || !organism) return <div className="mx-auto max-w-6xl px-8 py-20 text-center"><p className="text-status-blocked">{error || "No organism available."}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div>;
+
+  const coreColor = STAGE_COLOR[organism.maturity];
+
+  return (
+    <div className="mx-auto max-w-6xl px-6 py-8">
+      <div className="grid grid-cols-1 gap-4 md:grid-cols-3">
+        <div className="card p-5">
+          <h2 className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Today's Hypothesis</h2>
+          <p className="mt-2 text-sm font-medium leading-snug text-foreground">{organism.claim}</p>
+          <div className="mt-3 flex items-center gap-2">
+            <span className="rounded-full px-2.5 py-0.5 text-xs font-semibold text-white" style={{ backgroundColor: coreColor }}>{STAGE_LABEL[organism.maturity]}</span>
+            <span className="rounded-full px-2.5 py-0.5 text-xs font-medium" style={{ backgroundColor: COLOR_HEX.blue + "20" }}>{EVIDENCE_LABEL[organism.evidence]}</span>
+          </div>
+        </div>
+        <div className="card p-5">
+          <h2 className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Evidence Required</h2>
+          <p className="mt-2 text-sm text-foreground/90">{organism.trialsCompleted} / {organism.requiredTrials} trials completed</p>
+          <div className="evidence-bar mt-2"><div className="evidence-bar-fill" style={{ width: `${Math.min(100, (organism.trialsCompleted / organism.requiredTrials) * 100)}%`, background: COLOR_HEX.green }} /></div>
+          <p className="mt-2 text-xs text-muted-foreground">Falsification: {organism.falsificationCondition}</p>
+        </div>
+        <div className="card p-5">
+          <h2 className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Evolutionary Paths</h2>
+          <div className="mt-2 space-y-1.5">
+            {organism.actions.map((a) => (<div key={a} className="flex items-center gap-2 text-xs text-foreground/90"><span className="h-1.5 w-1.5 rounded-full" style={{ background: coreColor }} />{ACTION_LABEL[a]}</div>))}
+          </div>
+        </div>
+      </div>
+
+      <div className="mt-8 grid grid-cols-1 gap-6 lg:grid-cols-[1fr_320px]">
+        <section className="card p-5">
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Organism Canvas</h2>
+          {canvas && (
+            <svg viewBox={`0 0 ${canvas.W} ${canvas.H}`} className="mt-4 w-full" style={{ maxHeight: "640px" }}>
+              <defs>
+                <radialGradient id="coreGlow"><stop offset="0%" stopColor={coreColor} stopOpacity="0.3" /><stop offset="100%" stopColor={coreColor} stopOpacity="0" /></radialGradient>
+                <filter id="soft"><feGaussianBlur stdDeviation="1" /></filter>
+              </defs>
+              {[1, 2, 3].map((ring) => (<circle key={ring} cx={canvas.cx} cy={canvas.cy} r={ring * 110} fill="none" stroke="currentColor" strokeWidth="0.5" className="text-border" opacity="0.2" />))}
+              {canvas.placed.filter((n) => n.role !== "core").map((n) => {
+                const color = COLOR_HEX[n.color]; const isRoot = n.role === "replication"; const isCompost = n.role === "compost";
+                const mx = (canvas.cx + n.x) / 2 + (isRoot ? -40 : 20) * Math.sin(n.angle);
+                const my = (canvas.cy + n.y) / 2 + (isRoot ? -40 : 20) * Math.cos(n.angle);
+                const d = `M ${canvas.cx} ${canvas.cy} Q ${mx} ${my} ${n.x} ${n.y}`;
+                return <path key={`stem-${n.id}`} d={d} fill="none" stroke={color} strokeWidth={isRoot ? 2.5 : 1.5} strokeOpacity={isCompost ? 0.25 : 0.5} strokeDasharray={isRoot ? "2 5" : isCompost ? "1 6" : undefined} className={isRoot ? "spinor-root" : "spinor-stem"} />;
+              })}
+              <circle cx={canvas.cx} cy={canvas.cy} r="90" fill="url(#coreGlow)" />
+              {canvas.placed.map((n) => {
+                const color = COLOR_HEX[n.color]; const isGold = n.role === "golden_node"; const r = isGold ? 16 : n.role === "core" ? 0 : 10;
+                return (
+                  <g key={n.id} className="spinor-node" style={{ cursor: "pointer" }} onClick={() => setSelectedNode(n)}>
+                    {isGold && <circle cx={n.x} cy={n.y} r={r + 8} fill={color} opacity="0.18" className="spinor-node-pulse" />}
+                    {n.pulse && <circle cx={n.x} cy={n.y} r={r + 6} fill="none" stroke={color} strokeWidth="1.5" opacity="0.5" className="spinor-node-pulse" />}
+                    <circle cx={n.x} cy={n.y} r={r} fill={color} fillOpacity={selectedNode?.id === n.id ? 0.95 : 0.7} stroke={color} strokeWidth="2" filter="url(#soft)" />
+                    <circle cx={n.x} cy={n.y} r={r} fill={color} />
+                    <text x={n.x} y={n.y + r + 16} textAnchor="middle" className="spinor-node-label" fill="hsl(var(--muted-foreground))">{ROLE_LABEL[n.role]}</text>
+                  </g>
+                );
+              })}
+              <g>
+                <circle cx={canvas.cx} cy={canvas.cy} r="34" fill={coreColor} fillOpacity="0.18" stroke={coreColor} strokeWidth="2" />
+                <circle cx={canvas.cx} cy={canvas.cy} r="22" fill={coreColor} fillOpacity="0.3" className="spinor-core-pulse" />
+                <text x={canvas.cx} y={canvas.cy + 5} textAnchor="middle" fontSize="20" fill={coreColor} fontWeight="700">{STAGE_GLYPH[organism.maturity]}</text>
+              </g>
+            </svg>
+          )}
+          <div className="mt-4 px-4">
+            <p className="text-base font-semibold leading-snug text-foreground">{organism.claim}</p>
+            <p className="mt-2 text-sm text-muted-foreground"><span className="font-medium text-foreground/80">Why this reached you: </span>{organism.allocationReason}</p>
+          </div>
+          {selectedNode && (
+            <div className="mt-4 animate-fade-in-up rounded-xl border border-border bg-muted/30 p-4 text-sm">
+              <div className="flex items-center justify-between">
+                <p className="font-semibold" style={{ color: COLOR_HEX[selectedNode.color] }}>{ROLE_LABEL[selectedNode.role]}</p>
+                <button className="text-xs text-muted-foreground hover:text-foreground" onClick={() => setSelectedNode(null)}>close</button>
+              </div>
+              <p className="mt-1 text-foreground/90">{selectedNode.detail}</p>
+              <p className="mt-2 text-xs text-muted-foreground">Evidence: {EVIDENCE_LABEL[selectedNode.evidence]} · Maturity: {STAGE_LABEL[selectedNode.maturity]}</p>
+            </div>
+          )}
+        </section>
+
+        <aside className="space-y-5">
+          <div className="card p-5">
+            <div className="flex items-baseline justify-between">
+              <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Discovery Contribution Score</h2>
+              {organism.dcs.provisional && <span className="text-[10px] font-semibold uppercase tracking-wider text-violet-400">provisional</span>}
+            </div>
+            <div className="mt-3 flex items-end gap-2"><span className="text-5xl font-bold tabular-nums text-foreground">{organism.dcs.score}</span><span className="mb-1 text-sm text-muted-foreground">/ 100</span></div>
+            <div className="mt-1 text-xs text-muted-foreground">DCS = (I × C × R × V × T) ÷ H · confidence {Math.round(organism.dcs.scoreConfidence * 100)}%</div>
+            <div className="mt-4 space-y-2">
+              {organism.dcs.components.map((c) => (
+                <div key={c.symbol}>
+                  <div className="flex items-center justify-between text-xs"><span className="font-medium text-foreground/80"><span className="text-foreground">{c.symbol}</span> · {c.name}</span><span className="tabular-nums text-muted-foreground">{Math.round(c.value * 100)}</span></div>
+                  <div className="evidence-bar mt-1"><div className="evidence-bar-fill" style={{ width: `${Math.round(c.value * 100)}%`, background: c.symbol === "H" ? COLOR_HEX.red : COLOR_HEX.blue }} /></div>
+                  <p className="mt-0.5 text-[11px] text-muted-foreground">{c.rationale}</p>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          <div className="card p-5">
+            <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Experiment design</h2>
+            <dl className="mt-3 space-y-2 text-sm">
+              <div className="flex justify-between"><dt className="text-muted-foreground">Trials completed</dt><dd className="font-medium tabular-nums text-foreground">{organism.trialsCompleted} / {organism.requiredTrials}</dd></div>
+              <div className="evidence-bar"><div className="evidence-bar-fill" style={{ width: `${Math.min(100, (organism.trialsCompleted / organism.requiredTrials) * 100)}%`, background: COLOR_HEX.green }} /></div>
+              <div className="flex justify-between pt-1"><dt className="text-muted-foreground">Time window</dt><dd className="font-medium text-foreground">{organism.timeWindowDays} days</dd></div>
+            </dl>
+            <div className="mt-3 rounded-lg border border-border bg-muted/30 p-3 text-xs"><p className="font-semibold text-red-400/90">Compliance boundary</p><p className="mt-1 text-foreground/80">{organism.complianceBoundary}</p></div>
+            <div className="mt-2 rounded-lg border border-border bg-muted/30 p-3 text-xs"><p className="font-semibold text-violet-400/90">Falsification condition</p><p className="mt-1 text-foreground/80">{organism.falsificationCondition}</p></div>
+          </div>
+
+          <div className="card p-5">
+            <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Signature actions</h2>
+            <p className="mt-1 text-xs text-muted-foreground">You do not complete tasks. You cultivate evidence.</p>
+            <div className="mt-3 grid grid-cols-2 gap-2">
+              {organism.actions.map((a) => (<button key={a} disabled={acting !== null} onClick={() => performAction(a)} className="btn btn-outline h-9 px-3 text-xs disabled:opacity-40">{acting === a ? "…" : ACTION_LABEL[a]}</button>))}
+            </div>
+            {flash && <p className="mt-3 animate-fade-in-up text-xs font-medium text-green-400">{flash}</p>}
+            {error && <p className="mt-3 text-xs text-red-400">{error}</p>}
+          </div>
+        </aside>
+      </div>
+
+      <section className="mt-8 grid grid-cols-1 gap-6 md:grid-cols-2">
+        <div className="card p-5">
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Prior art</h2>
+          {priorArt ? (
+            <div className="mt-3 space-y-2 text-sm">
+              <p className="text-foreground/90">{priorArt.hypothesisClaim}</p>
+              <div className="flex flex-wrap gap-2 text-xs">
+                <span className="badge border-border text-muted-foreground">{priorArt.status.replace(/_/g, " ")}</span>
+                <span className="badge border-border text-muted-foreground">evidence: {priorArt.evidenceState}</span>
+                <span className="badge border-border text-muted-foreground">confidence {Math.round(priorArt.researchConfidence * 100)}%</span>
+              </div>
+              <p className="text-xs text-muted-foreground">{priorArt.adjacentSupportSummary}</p>
+              <p className="text-[11px] text-muted-foreground">Sources: {priorArt.sourceDomains.join(", ")}</p>
+            </div>
+          ) : <p className="mt-3 text-sm text-muted-foreground">No prior-art record linked to this hypothesis.</p>}
+        </div>
+
+        <div className="card p-5">
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Novelty</h2>
+          <p className="mt-3 text-sm text-foreground/90">The genuinely new element: <span className="font-medium text-violet-400">{organism.nodes.find((n) => n.role === "expected_value")?.detail ?? "to be isolated by Dissect → Novelty Magnify"}</span></p>
+          <p className="mt-2 text-xs text-muted-foreground">DCS Novelty (V) = {Math.round((organism.dcs.components.find((c) => c.symbol === "V")?.value ?? 0) * 100)}%. Duplicates and near-duplicates receive reduced credit.</p>
+        </div>
+
+        <div className="card p-5">
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Variations</h2>
+          {derivatives.length > 0 ? (
+            <ul className="mt-3 space-y-2 text-sm">
+              {derivatives.slice(0, 5).map((d) => (<li key={d.id} className="rounded-lg border border-border bg-muted/20 p-3"><p className="text-foreground/90">{d.claim}</p><p className="mt-1 text-[11px] text-muted-foreground">dimension: {d.modifiedDimension.replace(/_/g, " ")} · origin: {d.origin.replace(/_/g, " ")} · status: {d.status}</p></li>))}
+            </ul>
+          ) : <p className="mt-3 text-sm text-muted-foreground">No derivatives yet. Use <span className="font-medium text-foreground">Derive</span> to branch this hypothesis.</p>}
+        </div>
+
+        <div className="card p-5">
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground">Mutation controls</h2>
+          <p className="mt-3 text-xs text-muted-foreground">Dimensions an employee may modify within their innovation window.</p>
+          <div className="mt-3 flex flex-wrap gap-2">
+            {["stakeholder", "timing", "channel", "content_sequence", "automation_step", "followup_interval"].map((dim) => (<span key={dim} className="badge border-violet-500/30 bg-violet-500/10 text-violet-300">{dim.replace(/_/g, " ")}</span>))}
+          </div>
+          <p className="mt-3 text-[11px] text-muted-foreground">Fixed constraints and compliance boundaries cannot be mutated. Mutations are versioned — the parent hypothesis is preserved.</p>
+        </div>
+      </section>
+
+      <footer className="mt-6 flex flex-wrap items-center gap-4 text-xs text-muted-foreground">
+        <span className="font-semibold uppercase tracking-wider">Color system:</span>
+        {[["blue", "Supported"], ["violet", "Novelty"], ["green", "Replicated"], ["gold", "Golden Node"], ["red", "Risk / contradiction"], ["gray", "Unresolved"]].map(([c, label]) => (
+          <span key={c} className="inline-flex items-center gap-1.5"><span className="inline-block h-2.5 w-2.5 rounded-full" style={{ background: COLOR_HEX[c as SpinorOrganismNode["color"]] }} />{label}</span>
+        ))}
+      </footer>
+    </div>
+  );
+}

src/app/(app)/golden-nodes/page.tsx

@@ -0,0 +1,41 @@
+"use client";
+import { useState, useEffect, useCallback } from "react";
+import type { GoldenNode } from "@/types";
+const STAGES = ["hypothesis", "local_success", "rep_owned_process", "replicated_method", "organizational_capability", "productized_service", "independent_channel"];
+export default function GoldenNodesPage() {
+  const [nodes, setNodes] = useState<GoldenNode[]>([]);
+  const [ledger, setLedger] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [promoting, setPromoting] = useState<string | null>(null);
+  const [channelName, setChannelName] = useState("");
+  const load = useCallback(async () => { try { const res = await fetch("/api/golden/golden-nodes?ledger=true"); const data = await res.json(); setNodes(data.goldenNodes || []); setLedger(data.ledger || []); } catch (e) { setError(e instanceof Error ? e.message : "Failed to load"); } finally { setLoading(false); } }, []);
+  useEffect(() => { load(); }, [load]);
+  async function promote(id: string, toStage: string) { setPromoting(id); try { const body: Record<string, unknown> = { id, toStage }; if (toStage === "independent_channel" && channelName) body.channelName = channelName; const res = await fetch("/api/golden/golden-nodes", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }); if (!res.ok) throw new Error(`HTTP ${res.status}`); setChannelName(""); await load(); } catch (e) { setError(e instanceof Error ? e.message : "Promotion failed"); } finally { setPromoting(null); } }
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading Golden Nodes…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Golden Nodes</h1>
+      <p className="mt-2 text-muted-foreground">Validated strategy lineages — methods that have been replicated and promoted into reusable systems.</p>
+      {nodes.length === 0 ? <div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No Golden Nodes yet. Record outcomes and replicate successful hypotheses to earn promotion.</p></div> : (
+        <div className="mt-6 space-y-4">
+          {nodes.map((gn) => { const stageIdx = STAGES.indexOf(gn.stage); const ledgerEntry = ledger.find((l) => l.goldenNodeId === gn.id); return (
+            <div key={gn.id} className="card p-5">
+              <div className="flex items-start justify-between"><div className="flex-1"><p className="font-medium text-foreground">{gn.claim}</p><p className="mt-1 text-xs text-muted-foreground">{gn.id} · {gn.stage.replace(/_/g, " ")}</p></div><div className="text-right"><p className="text-lg font-bold text-status-completed">${gn.economicValue.toLocaleString()}</p><p className="text-xs text-muted-foreground">economic value</p></div></div>
+              <p className="mt-3 text-sm text-muted-foreground">{gn.observedResult}</p>
+              <div className="mt-4 flex items-center gap-1">{STAGES.map((s, i) => (<div key={s} className="flex items-center"><div className={`h-2.5 w-2.5 rounded-full ${i <= stageIdx ? "bg-status-completed" : "bg-muted"}`} />{i < STAGES.length - 1 && <div className={`h-0.5 w-6 ${i < stageIdx ? "bg-status-completed" : "bg-muted"}`} />}</div>))}</div>
+              <div className="mt-4 grid grid-cols-2 gap-2 text-xs md:grid-cols-3">
+                {[["Measurable effect", gn.measurableEffect],["Repeatability", gn.repeatability],["Portability", gn.portability],["Defensible mechanism", gn.defensibleMechanism],["Reusable process", gn.reusableProcess],["Economic value", gn.economicValue > 0]].map(([label, ok]) => (<div key={label as string} className={`rounded-lg border px-2 py-1 ${ok ? "border-status-completed/30 text-status-completed" : "border-border text-muted-foreground"}`}>{ok ? "✓" : "·"} {label}</div>))}
+              </div>
+              <div className="mt-3 text-sm"><p className="done-section-label">Primary mechanism</p><p className="mt-0.5 text-foreground/90">{gn.primaryMechanism}</p></div>
+              <div className="mt-2 text-sm"><p className="done-section-label">Replication</p><p className="mt-0.5 text-foreground/90">{gn.replicationCount} replications across {gn.replicationTerritories.length} territories</p></div>
+              {ledgerEntry && <div className="mt-3 rounded-lg border border-border bg-muted/20 p-3 text-xs"><p className="done-section-label">Attribution ledger</p><p className="mt-1 text-muted-foreground">Origin: {ledgerEntry.originalHypothesisSource} · Confidence: {(ledgerEntry.attributionConfidence * 100).toFixed(0)}% · Value created: ${ledgerEntry.economicValueCreated.toLocaleString()}</p>{ledgerEntry.recognition && <p className="mt-1 text-muted-foreground">Recognition: {ledgerEntry.recognition.join(", ")}</p>}</div>}
+              {stageIdx < STAGES.length - 1 && <div className="mt-4 flex items-center gap-2"><button onClick={() => promote(gn.id, STAGES[stageIdx + 1])} disabled={promoting === gn.id} className="btn btn-primary disabled:opacity-50">{promoting === gn.id ? "Promoting…" : `Promote to ${STAGES[stageIdx + 1].replace(/_/g, " ")}`}</button>{STAGES[stageIdx + 1] === "independent_channel" && <input className="rounded-lg border border-border bg-background px-3 py-2 text-sm" placeholder="Channel name" value={channelName} onChange={(e) => setChannelName(e.target.value)} />}</div>}
+            </div>
+          ); })}
+        </div>
+      )}
+    </div>
+  );
+}

src/app/(app)/history/page.tsx

@@ -0,0 +1,2 @@
+import { redirect } from "next/navigation";
+export default function HistoryPage() { redirect("/discovery-ledger"); }

src/app/(app)/inbox/page.tsx

@@ -0,0 +1,16 @@
+"use client";
+import { useState, useEffect, useCallback } from "react";
+export default function InboxPage() {
+  const [loading, setLoading] = useState(true);
+  const [emails, setEmails] = useState<any[]>([]);
+  const [error, setError] = useState<string | null>(null);
+  const load = useCallback(async () => { try { const res = await fetch("/api/mailbox/status"); const data = await res.json(); setEmails(data.recentEmails || []); } catch (e) { setError(e instanceof Error ? e.message : "Failed to load inbox"); } finally { setLoading(false); } }, []);
+  useEffect(() => { load(); }, [load]);
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Inbox Intelligence</h1>
+      <p className="mt-2 text-muted-foreground">Mailbox Scientific Data — evidence substrate for the Advantage Foundry.</p>
+      {loading ? <p className="mt-6 text-muted-foreground">Loading inbox…</p> : error ? <div className="card mt-6 p-6"><p className="text-status-blocked">{error}</p></div> : emails.length === 0 ? <div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No emails processed yet. Connect a mailbox from the control plane to begin evidence intake.</p><a href="/settings" className="btn btn-primary mt-4 inline-block">Configure mailbox</a></div> : <div className="mt-6 space-y-3">{emails.map((e) => (<div key={e.id} className="card p-4"><p className="font-medium text-foreground">{e.subject || "(no subject)"}</p><p className="mt-1 text-xs text-muted-foreground">From: {e.from} · {e.date}</p><p className="mt-2 text-sm text-muted-foreground">{e.preview?.slice(0, 200)}</p></div>))}</div>}
+    </div>
+  );
+}

src/app/(app)/layout.tsx

@@ -0,0 +1,10 @@
+/**
+ * (app) route group layout — pass-through.
+ *
+ * The unified Advantage Foundry shell (GameNav) is rendered by the root
+ * layout via AppShell. This file exists only so the route group resolves;
+ * it must NOT render a second nav or header.
+ */
+export default function AppLayout({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}

src/app/(app)/learnings/page.tsx

@@ -0,0 +1,112 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+import type { HypothesisDerivative } from "@/types";
+
+const FILTERS = ["all", "proposed", "testing", "supported", "falsified"] as const;
+type Filter = typeof FILTERS[number];
+
+export default function LearningsPage() {
+  const [derivatives, setDerivatives] = useState<HypothesisDerivative[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [filter, setFilter] = useState<Filter>("all");
+  const [generating, setGenerating] = useState(false);
+
+  const load = useCallback(async () => {
+    try {
+      const res = await fetch("/api/golden/derivatives");
+      const data = await res.json();
+      setDerivatives(data.derivatives || []);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  async function generateLlm(hypothesisId: string, useLLM = false) {
+    setGenerating(true);
+    try {
+      await fetch("/api/golden/derivatives", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "llm_permutations", hypothesisId, useLLM }),
+      });
+      await load();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Generate failed");
+    } finally {
+      setGenerating(false);
+    }
+  }
+
+  async function promote(id: string) {
+    try {
+      await fetch("/api/golden/derivatives", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id, action: "promote" }) });
+      await load();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Promote failed");
+    }
+  }
+
+  const parentIds = [...new Set(derivatives.map((d) => d.parentHypothesisId))];
+
+  const filtered = filter === "all" ? derivatives : derivatives.filter((d) => d.status === filter);
+
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading derivatives…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Derivatives</h1>
+      <p className="mt-2 text-muted-foreground">Hypothesis mutations — branched experiments adapted to new contexts.</p>
+
+      <div className="mt-6 flex flex-wrap items-center gap-2">
+        {FILTERS.map((f) => (
+          <button key={f} onClick={() => setFilter(f)}
+            className={`rounded-lg border px-3 py-1.5 text-xs font-medium transition-all ${filter === f ? "border-foreground bg-foreground/10 text-foreground" : "border-border text-muted-foreground hover:text-foreground"}`}>
+            {f}
+          </button>
+        ))}
+        {parentIds.length > 0 && (
+          <div className="ml-auto flex gap-2">
+            <button onClick={() => generateLlm(parentIds[0], false)} disabled={generating}
+              className="rounded-lg border border-border px-3 py-1.5 text-xs font-medium text-muted-foreground hover:text-foreground disabled:opacity-50">
+              {generating ? "Generating…" : "Generate permutations"}
+            </button>
+            <button onClick={() => generateLlm(parentIds[0], true)} disabled={generating}
+              className="rounded-lg border border-foreground/40 px-3 py-1.5 text-xs font-medium text-foreground hover:bg-foreground/10 disabled:opacity-50">
+              Generate with LLM
+            </button>
+          </div>
+        )}
+      </div>
+
+      {filtered.length === 0 ? (
+        <div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No derivatives yet. Use Generate to create permutations from your hypotheses.</p></div>
+      ) : (
+        <div className="mt-6 space-y-4">
+          {filtered.map((d) => (
+            <div key={d.id} className="card p-5">
+              <div className="flex items-start justify-between">
+                <div className="flex-1">
+                  <p className="font-medium text-foreground">{d.claim}</p>
+                  <p className="mt-1 text-xs text-muted-foreground">
+                    dimension: {d.modifiedDimension.replace(/_/g, " ")} · origin: {d.origin.replace(/_/g, " ")} · status: {d.status}
+                  </p>
+                  {d.rationale && <p className="mt-2 text-sm text-muted-foreground">{d.rationale}</p>}
+                </div>
+                {d.status === "proposed" && (
+                  <button onClick={() => promote(d.id)} className="btn btn-outline text-xs">Promote to hypothesis</button>
+                )}
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

src/app/(app)/process-lab/page.tsx

@@ -0,0 +1,119 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+import type { ProcessDefinition } from "@/types";
+
+const EMPLOYEE_ID = "emp-001";
+const STEP_TYPES = ["trigger", "condition", "action", "wait", "measurement", "stop"] as const;
+interface StepForm { type: typeof STEP_TYPES[number]; label: string; waitHours?: number; }
+
+export default function ProcessLabPage() {
+  const [processes, setProcesses] = useState<ProcessDefinition[]>([]);
+  const [hypotheses, setHypotheses] = useState<{ id: string; claim: string }[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+  const [form, setForm] = useState({ name: "", hypothesisId: "", objective: "", eligibilityRules: "", complianceBoundary: "" });
+  const [steps, setSteps] = useState<StepForm[]>([{ type: "trigger", label: "" }]);
+
+  const load = useCallback(async () => {
+    try {
+      const [pRes, hRes] = await Promise.all([fetch(`/api/golden/process-lab?employeeId=${EMPLOYEE_ID}`), fetch("/api/golden/hypotheses")]);
+      const pData = await pRes.json();
+      const hData = await hRes.json();
+      setProcesses(pData.processes || []);
+      setHypotheses((hData.hypotheses || []).map((h: any) => ({ id: h.id, claim: h.claim })));
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  function addStep() { setSteps([...steps, { type: "action", label: "" }]); }
+  function removeStep(i: number) { setSteps(steps.filter((_, idx) => idx !== i)); }
+  function updateStep(i: number, patch: Partial<StepForm>) { setSteps(steps.map((s, idx) => idx === i ? { ...s, ...patch } : s)); }
+
+  async function submit() {
+    setSubmitting(true);
+    setError(null);
+    try {
+      const res = await fetch("/api/golden/process-lab", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name: form.name, hypothesisId: form.hypothesisId || undefined, objective: form.objective,
+          eligibilityRules: form.eligibilityRules.split("\n").filter(Boolean), complianceBoundary: form.complianceBoundary,
+          steps: steps.filter((s) => s.label.trim()).map((s, i) => ({ id: `step_${i + 1}`, type: s.type, label: s.label, ...(s.type === "wait" ? { waitHours: s.waitHours || 24 } : {}) })),
+          authorEmployeeId: EMPLOYEE_ID,
+        }),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      setForm({ name: "", hypothesisId: "", objective: "", eligibilityRules: "", complianceBoundary: "" });
+      setSteps([{ type: "trigger", label: "" }]);
+      await load();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to create process");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading process lab…</p></div>;
+
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Process Lab</h1>
+      <p className="mt-2 text-muted-foreground">Turn validated hypotheses into reusable, executable processes.</p>
+      {error && <div className="mt-4 rounded-lg border border-status-blocked/30 bg-status-blocked/10 p-3 text-sm text-status-blocked">{error}</div>}
+      <div className="card mt-6 p-5">
+        <p className="done-section-label">Process builder</p>
+        <div className="mt-3 space-y-3">
+          <input className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" placeholder="Process name" value={form.name} onChange={(e) => setForm({ ...form, name: e.target.value })} />
+          <select className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" value={form.hypothesisId} onChange={(e) => setForm({ ...form, hypothesisId: e.target.value })}>
+            <option value="">Link to hypothesis (optional)</option>
+            {hypotheses.map((h) => (<option key={h.id} value={h.id}>{h.claim.slice(0, 80)}</option>))}
+          </select>
+          <textarea className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" rows={2} placeholder="Objective" value={form.objective} onChange={(e) => setForm({ ...form, objective: e.target.value })} />
+          <textarea className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" rows={3} placeholder="Eligibility rules (one per line)" value={form.eligibilityRules} onChange={(e) => setForm({ ...form, eligibilityRules: e.target.value })} />
+          <textarea className="w-full rounded-lg border border-border bg-background px-3 py-2 text-sm" rows={2} placeholder="Compliance boundary" value={form.complianceBoundary} onChange={(e) => setForm({ ...form, complianceBoundary: e.target.value })} />
+          <div>
+            <p className="done-section-label">Steps</p>
+            <div className="mt-2 space-y-2">
+              {steps.map((s, i) => (
+                <div key={i} className="flex items-center gap-2">
+                  <span className="text-xs text-muted-foreground w-6">{i + 1}.</span>
+                  <select className="rounded-lg border border-border bg-background px-2 py-1.5 text-xs" value={s.type} onChange={(e) => updateStep(i, { type: e.target.value as StepForm["type"] })}>
+                    {STEP_TYPES.map((t) => (<option key={t} value={t}>{t}</option>))}
+                  </select>
+                  <input className="flex-1 rounded-lg border border-border bg-background px-3 py-1.5 text-sm" placeholder="Step description" value={s.label} onChange={(e) => updateStep(i, { label: e.target.value })} />
+                  {s.type === "wait" && <input type="number" className="w-20 rounded-lg border border-border bg-background px-2 py-1.5 text-sm" placeholder="hrs" value={s.waitHours || ""} onChange={(e) => updateStep(i, { waitHours: Number(e.target.value) })} />}
+                  {steps.length > 1 && <button onClick={() => removeStep(i)} className="text-xs text-muted-foreground hover:text-status-blocked">✕</button>}
+                </div>
+              ))}
+            </div>
+            <button onClick={addStep} className="mt-2 text-xs font-medium text-muted-foreground hover:text-foreground">+ Add step</button>
+          </div>
+          <button onClick={submit} disabled={submitting || !form.name || !form.objective} className="btn btn-primary disabled:opacity-50">{submitting ? "Creating…" : "Create process"}</button>
+        </div>
+      </div>
+      <div className="mt-6 space-y-4">
+        <p className="done-section-label">Existing processes</p>
+        {processes.length === 0 ? (<p className="text-sm text-muted-foreground">No processes defined yet.</p>) : (
+          processes.map((p) => (
+            <div key={p.id} className="card p-5">
+              <p className="font-medium text-foreground">{p.name}</p>
+              <p className="mt-1 text-xs text-muted-foreground">{p.id} · {p.hypothesisId || "unlinked"}</p>
+              <p className="mt-2 text-sm text-foreground/90">{p.objective}</p>
+              {p.eligibilityRules.length > 0 && (<div className="mt-2"><p className="text-xs text-muted-foreground">Eligibility:</p><ul className="ml-4 text-xs text-muted-foreground">{p.eligibilityRules.map((r, i) => (<li key={i}>· {r}</li>))}</ul></div>)}
+              <div className="mt-3"><p className="text-xs text-muted-foreground">Steps:</p><ol className="ml-4 mt-1 space-y-1 text-sm text-foreground/90">{p.steps.map((s, i) => (<li key={s.id}><span className="text-muted-foreground">{i + 1}.</span> [{s.type}] {s.label}{s.type === "wait" && s.waitHours ? ` (${s.waitHours}h)` : ""}</li>))}</ol></div>
+              {p.complianceBoundary && <p className="mt-2 text-xs text-status-needs">Compliance: {p.complianceBoundary}</p>}
+            </div>
+          ))
+        )}
+      </div>
+    </div>
+  );
+}

src/app/(app)/results/page.tsx

@@ -0,0 +1,38 @@
+"use client";
+import { useState, useEffect, useCallback } from "react";
+import type { HypothesisAttribution, HypothesisOutcome } from "@/types";
+export default function ResultsPage() {
+  const [attributions, setAttributions] = useState<HypothesisAttribution[]>([]);
+  const [outcomes, setOutcomes] = useState<HypothesisOutcome[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const load = useCallback(async () => {
+    try { const [aRes, oRes] = await Promise.all([fetch("/api/golden/attributions"), fetch("/api/golden/outcomes")]); const aData = await aRes.json(); const oData = await oRes.json(); setAttributions(aData.attributions || []); setOutcomes(oData.outcomes || []); } catch (e) { setError(e instanceof Error ? e.message : "Failed to load"); } finally { setLoading(false); }
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading results…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+  const outcomeMap = new Map(outcomes.map((o) => [o.id, o]));
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Why It Worked</h1>
+      <p className="mt-2 text-muted-foreground">Causal attribution for every recorded outcome.</p>
+      {attributions.length === 0 ? <div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No attributions yet. Record outcomes from experiments to generate attribution analysis.</p></div> : (
+        <div className="mt-6 space-y-4">
+          {attributions.map((a) => {
+            const outcome = outcomeMap.get(a.outcomeId); const highVariance = a.unexplainedVariance >= 0.15;
+            return (
+              <div key={a.id} className="card p-5">
+                <div className="flex items-start justify-between"><div><p className="font-medium text-foreground">{a.responsibleFactor.replace(/_/g, " ")}</p><p className="mt-1 text-xs text-muted-foreground">Method: {a.method.replace(/_/g, " ")} · Employee: {a.employeeId}</p></div><div className="text-right"><p className="text-lg font-bold text-foreground">{(a.estimatedEffect * 100).toFixed(0)}%</p><p className="text-xs text-muted-foreground">estimated effect</p></div></div>
+                {outcome && <p className="mt-3 text-sm text-muted-foreground">{outcome.outcomeDescription}</p>}
+                <div className="mt-3 grid grid-cols-2 gap-3 text-sm md:grid-cols-4"><div><p className="done-section-label">Confidence</p><p className="mt-0.5 text-foreground/90">{(a.attributionConfidence * 100).toFixed(0)}%</p></div><div><p className="done-section-label">Unexplained</p><p className={`mt-0.5 ${highVariance ? "text-status-blocked font-medium" : "text-foreground/90"}`}>{(a.unexplainedVariance * 100).toFixed(0)}%</p></div><div><p className="done-section-label">Counterfactual</p><p className="mt-0.5 text-foreground/90">{a.counterfactualEstimate}</p></div><div><p className="done-section-label">Success kind</p><p className="mt-0.5 text-foreground/90">{outcome?.successKind || "—"}</p></div></div>
+                <p className="mt-3 text-sm text-muted-foreground">{a.reasoning}</p>
+                {highVariance && <div className="mt-3 rounded-lg border border-status-blocked/30 bg-status-blocked/10 p-3 text-xs text-status-blocked">High unexplained variance ({(a.unexplainedVariance * 100).toFixed(0)}%). This attribution is not yet defensible — collect more replications.</div>}
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}

src/app/(app)/spinor/page.tsx

@@ -0,0 +1,260 @@
+"use client";
+
+import { useState, useEffect, useCallback } from "react";
+import type { SpinorOrganism, SpinorOrganismNode, SpinorSignatureAction, SpinorMaturityStage, SpinorEvidenceBadge } from "@/types";
+
+const EMPLOYEE_ID = "emp-001";
+
+const STAGE_COLOR: Record<SpinorMaturityStage, string> = {
+  seed: "#6b7280", sprout: "#8b5cf6", branch: "#a78bfa", grove: "#22c55e",
+  golden_node: "#fbbf24", infrastructure: "#f59e0b", spinout: "#ef4444",
+};
+
+const EVIDENCE_COLOR: Record<SpinorEvidenceBadge, string> = {
+  established: "#22c55e", supported: "#3b82f6", transferred: "#06b6d4",
+  plausible: "#a78bfa", untested: "#6b7280", contradicted: "#ef4444", internal_signal: "#fbbf24",
+};
+
+const NODE_COLOR_HEX: Record<string, string> = {
+  blue: "#3b82f6", violet: "#8b5cf6", green: "#22c55e", gold: "#fbbf24", red: "#ef4444", gray: "#6b7280",
+};
+
+const ACTION_LABEL: Record<SpinorSignatureAction, string> = {
+  plant: "Plant — begin the experiment",
+  observe: "Observe — record an interim measurement",
+  record: "Record — log a final outcome",
+  challenge: "Challenge — dispute the hypothesis or its evidence",
+  replicate: "Replicate — verify or falsify another's finding",
+  derive: "Derive — propose a derivative",
+  integrate: "Integrate — promote into infrastructure",
+  spin_out: "Spin out — propose as a separate channel/business",
+};
+
+const ROLE_LABEL: Record<string, string> = {
+  core: "Today's Hypothesis", supporting_research: "Supporting Research", contradicting: "Contradicting Evidence",
+  previous_attempt: "Previous Attempt", derivative: "Derivative", replication: "Replication",
+  risk_signal: "Risk Signal", expected_value: "Expected Value", golden_node: "Golden Node", compost: "Compost (Falsified)",
+};
+
+export default function SpinorPage() {
+  const [organism, setOrganism] = useState<SpinorOrganism | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [selectedNode, setSelectedNode] = useState<SpinorOrganismNode | null>(null);
+  const [leaderboard, setLeaderboard] = useState<{ employeeId: string; score: number; roles: string[]; breakdown: Record<string, number> }[]>([]);
+  const [profile, setProfile] = useState<{ dimensions: Record<string, number>; researchStreak: number } | null>(null);
+  const [roles, setRoles] = useState<string[]>([]);
+  const [tab, setTab] = useState<"organism" | "leaderboard" | "profile">("organism");
+
+  const load = useCallback(async () => {
+    try {
+      await fetch("/api/golden", { method: "POST" });
+      const [orgRes, lbRes, profRes] = await Promise.all([
+        fetch(`/api/golden/spinor?action=organism&employeeId=${EMPLOYEE_ID}`),
+        fetch("/api/golden/spinor?action=leaderboard"),
+        fetch(`/api/golden/spinor?action=profile&employeeId=${EMPLOYEE_ID}`),
+      ]);
+      if (orgRes.ok) { const d = await orgRes.json(); setOrganism(d.organism || null); }
+      if (lbRes.ok) { const d = await lbRes.json(); setLeaderboard(d.rankings || []); }
+      if (profRes.ok) { const d = await profRes.json(); setProfile(d.profile || null); setRoles(d.roles || []); }
+    } catch (e) { setError(e instanceof Error ? e.message : "Failed to load"); }
+    finally { setLoading(false); }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  if (loading) return <div className="mx-auto max-w-5xl px-8 py-10"><p className="text-muted-foreground">Building your Hypothesis Organism…</p></div>;
+  if (error) return <div className="mx-auto max-w-5xl px-8 py-10"><div className="card border-status-blocked/30 p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+
+  return (
+    <div className="mx-auto max-w-5xl px-8 py-10">
+      <div className="mb-6">
+        <h1 className="text-3xl font-bold tracking-tight text-foreground">Hypothesis Organism</h1>
+        <p className="mt-2 text-muted-foreground">Your daily mission is a living experimental ecosystem.</p>
+      </div>
+
+      <div className="mb-6 flex gap-2">
+        {(["organism", "leaderboard", "profile"] as const).map((t) => (
+          <button key={t} onClick={() => setTab(t)}
+            className={`rounded-lg border px-4 py-2 text-sm font-medium transition-all ${tab === t ? "border-foreground bg-foreground/10 text-foreground" : "border-border text-muted-foreground hover:text-foreground"}`}>
+            {t === "organism" ? "Today's Organism" : t === "leaderboard" ? "Leaderboard" : "My Profile"}
+          </button>
+        ))}
+      </div>
+
+      {tab === "organism" && organism && (
+        <div className="space-y-6">
+          <div className="grid grid-cols-1 gap-4 md:grid-cols-3">
+            <div className="card p-5">
+              <p className="done-section-label">Today's Hypothesis</p>
+              <p className="mt-2 text-sm font-medium text-foreground">{organism.claim}</p>
+              <div className="mt-3 flex items-center gap-2">
+                <span className="rounded-full px-2.5 py-0.5 text-xs font-semibold text-white" style={{ backgroundColor: STAGE_COLOR[organism.maturity] }}>{organism.maturity.replace(/_/g, " ")}</span>
+                <span className="rounded-full px-2.5 py-0.5 text-xs font-medium" style={{ backgroundColor: EVIDENCE_COLOR[organism.evidence] + "30", color: EVIDENCE_COLOR[organism.evidence] }}>{organism.evidence.replace(/_/g, " ")}</span>
+              </div>
+            </div>
+            <div className="card p-5">
+              <p className="done-section-label">Evidence Required</p>
+              <p className="mt-2 text-sm text-foreground/90">{organism.trialsCompleted} / {organism.requiredTrials} trials completed</p>
+              <div className="mt-2 h-2 overflow-hidden rounded-full bg-muted">
+                <div className="h-full rounded-full bg-foreground transition-all" style={{ width: `${Math.min(100, (organism.trialsCompleted / organism.requiredTrials) * 100)}%` }} />
+              </div>
+              <p className="mt-2 text-xs text-muted-foreground">Falsification: {organism.falsificationCondition}</p>
+            </div>
+            <div className="card p-5">
+              <p className="done-section-label">Evolutionary Paths</p>
+              <div className="mt-2 space-y-1.5">
+                {organism.actions.map((a) => (<div key={a} className="flex items-center gap-2 text-sm text-foreground/90"><span className="h-1.5 w-1.5 rounded-full bg-foreground" />{ACTION_LABEL[a]}</div>))}
+              </div>
+            </div>
+          </div>
+
+          <div className="card p-5">
+            <div className="flex items-center justify-between">
+              <p className="done-section-label">Discovery Contribution Score</p>
+              <span className="text-2xl font-bold text-foreground">{organism.dcs.score}</span>
+            </div>
+            <p className="mt-1 text-xs text-muted-foreground">DCS = (I × C × R × V × T) / H · {organism.dcs.provisional ? "Provisional" : "Settled"}</p>
+            <div className="mt-3 grid grid-cols-3 gap-3 md:grid-cols-6">
+              {organism.dcs.components.map((c) => (
+                <div key={c.symbol} className="rounded-lg border border-border p-2 text-center">
+                  <p className="text-xs font-bold text-foreground">{c.symbol}</p>
+                  <p className="text-xs text-muted-foreground">{c.name}</p>
+                  <p className="mt-1 text-sm font-semibold text-foreground">{(c.value * 100).toFixed(0)}%</p>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          <div className="card p-5">
+            <p className="done-section-label mb-4">Organism Canvas</p>
+            <div className="relative mx-auto" style={{ width: "500px", height: "500px", maxWidth: "100%" }}>
+              <svg viewBox="-250 -250 500 500" className="w-full h-full">
+                {[60, 120, 180, 220].map((r) => (<circle key={r} cx="0" cy="0" r={r} fill="none" stroke="currentColor" strokeWidth="0.5" className="text-border" opacity="0.3" />))}
+                {organism.nodes.filter((n) => n.role !== "core").map((n) => {
+                  const x = Math.cos(n.angle) * n.radius * 100;
+                  const y = Math.sin(n.angle) * n.radius * 100;
+                  return <line key={`line-${n.id}`} x1="0" y1="0" x2={x} y2={y} stroke={NODE_COLOR_HEX[n.color] || "#6b7280"} strokeWidth="1" opacity="0.2" />;
+                })}
+                <circle cx="0" cy="0" r="45" fill={STAGE_COLOR[organism.maturity]} opacity="0.15" />
+                <circle cx="0" cy="0" r="30" fill={STAGE_COLOR[organism.maturity]} opacity="0.3" />
+                <circle cx="0" cy="0" r="18" fill={STAGE_COLOR[organism.maturity]} className="cursor-pointer" onClick={() => setSelectedNode(organism.nodes.find(n => n.role === "core") || null)}>
+                  <animate attributeName="r" values="18;22;18" dur="3s" repeatCount="indefinite" />
+                </circle>
+                <text x="0" y="4" textAnchor="middle" fill="white" fontSize="9" fontWeight="bold">CORE</text>
+                {organism.nodes.filter((n) => n.role !== "core").map((n) => {
+                  const x = Math.cos(n.angle) * n.radius * 100;
+                  const y = Math.sin(n.angle) * n.radius * 100;
+                  const color = NODE_COLOR_HEX[n.color] || "#6b7280";
+                  const r = n.role === "golden_node" ? 16 : n.role === "compost" ? 10 : 12;
+                  return (
+                    <g key={n.id} className="cursor-pointer" onClick={() => setSelectedNode(n)}>
+                      {n.pulse && (
+                        <circle cx={x} cy={y} r={r + 4} fill={color} opacity="0.2">
+                          <animate attributeName="r" values={`${r + 2};${r + 8};${r + 2}`} dur="2s" repeatCount="indefinite" />
+                          <animate attributeName="opacity" values="0.2;0.05;0.2" dur="2s" repeatCount="indefinite" />
+                        </circle>
+                      )}
+                      <circle cx={x} cy={y} r={r} fill={color} opacity="0.8" stroke={color} strokeWidth="1.5" />
+                      <text x={x} y={y + 3} textAnchor="middle" fill="white" fontSize="7" fontWeight="bold">
+                        {n.role === "golden_node" ? "GN" : n.role === "derivative" ? "D" : n.role === "replication" ? "R" : n.role === "previous_attempt" ? "T" : n.role === "supporting_research" ? "S" : n.role === "contradicting" ? "X" : n.role === "risk_signal" ? "!" : n.role === "expected_value" ? "$" : n.role === "compost" ? "C" : "•"}
+                      </text>
+                    </g>
+                  );
+                })}
+              </svg>
+            </div>
+            <div className="mt-4 flex flex-wrap gap-3 text-xs text-muted-foreground">
+              {Object.entries(ROLE_LABEL).filter(([k]) => k !== "core").map(([k, v]) => (
+                <div key={k} className="flex items-center gap-1.5">
+                  <span className="h-2.5 w-2.5 rounded-full" style={{ backgroundColor: NODE_COLOR_HEX[
+                    k === "supporting_research" ? "blue" : k === "contradicting" ? "red" : k === "previous_attempt" ? "violet" :
+                    k === "derivative" ? "violet" : k === "replication" ? "green" : k === "risk_signal" ? "red" :
+                    k === "expected_value" ? "gold" : k === "golden_node" ? "gold" : k === "compost" ? "gray" : "gray"
+                  ] }} />
+                  {v}
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {selectedNode && (
+            <div className="card p-5">
+              <div className="flex items-center gap-2">
+                <span className="rounded-full px-2.5 py-0.5 text-xs font-semibold text-white" style={{ backgroundColor: NODE_COLOR_HEX[selectedNode.color] }}>{ROLE_LABEL[selectedNode.role]}</span>
+                <span className="rounded-full px-2.5 py-0.5 text-xs" style={{ backgroundColor: EVIDENCE_COLOR[selectedNode.evidence] + "20", color: EVIDENCE_COLOR[selectedNode.evidence] }}>{selectedNode.evidence.replace(/_/g, " ")}</span>
+              </div>
+              <p className="mt-3 text-sm font-medium text-foreground">{selectedNode.label}</p>
+              <p className="mt-1 text-sm text-muted-foreground">{selectedNode.detail}</p>
+            </div>
+          )}
+
+          <div className="card border-status-needs/30 p-4">
+            <p className="text-xs text-muted-foreground"><span className="font-medium text-foreground">Compliance boundary: </span>{organism.complianceBoundary}</p>
+          </div>
+        </div>
+      )}
+
+      {tab === "leaderboard" && (
+        <div className="card p-5">
+          <p className="done-section-label mb-2">Node Score Leaderboard</p>
+          <p className="text-sm text-muted-foreground mb-4">Ranks the human–LLM–hypothesis combination, not raw sales.</p>
+          <div className="space-y-2">
+            {leaderboard.map((r, i) => (
+              <div key={r.employeeId} className={`flex items-center justify-between rounded-lg border p-4 ${r.employeeId === EMPLOYEE_ID ? "border-foreground/40 bg-foreground/5" : "border-border"}`}>
+                <div className="flex items-center gap-4">
+                  <span className="flex h-8 w-8 items-center justify-center rounded-full bg-foreground/10 text-sm font-bold text-foreground">{i + 1}</span>
+                  <div>
+                    <p className="font-medium text-foreground">{r.employeeId}</p>
+                    <div className="mt-0.5 flex flex-wrap gap-1">
+                      {r.roles.map((role) => (<span key={role} className="rounded-full border border-border px-2 py-0.5 text-[10px] text-muted-foreground">{role}</span>))}
+                    </div>
+                  </div>
+                </div>
+                <div className="text-right">
+                  <p className="text-xl font-bold text-foreground">{r.score.toFixed(1)}</p>
+                  <p className="text-xs text-muted-foreground">lift {r.breakdown.causalLift} + info {r.breakdown.informationGained} + mut {r.breakdown.mutationValue}</p>
+                </div>
+              </div>
+            ))}
+            {leaderboard.length === 0 && <p className="text-center text-muted-foreground py-8">No scores yet.</p>}
+          </div>
+        </div>
+      )}
+
+      {tab === "profile" && profile && (
+        <div className="space-y-4">
+          <div className="card p-5">
+            <div className="flex items-center justify-between">
+              <div><p className="done-section-label">Participant Profile</p><p className="mt-1 text-sm text-foreground">{EMPLOYEE_ID}</p></div>
+              <div className="flex flex-wrap gap-1.5">
+                {roles.map((role) => (<span key={role} className="rounded-full bg-foreground/10 px-3 py-1 text-xs font-semibold text-foreground">{role}</span>))}
+              </div>
+            </div>
+            <p className="mt-3 text-xs text-muted-foreground">Research streak: {profile.researchStreak}</p>
+          </div>
+          <div className="card p-5">
+            <p className="done-section-label mb-3">Contribution Dimensions</p>
+            <div className="space-y-3">
+              {Object.entries(profile.dimensions).map(([key, value]) => (
+                <div key={key}>
+                  <div className="flex items-center justify-between text-sm">
+                    <span className="text-muted-foreground capitalize">{key.replace(/([A-Z])/g, " $1").trim()}</span>
+                    <span className="font-medium text-foreground">{(value * 100).toFixed(0)}%</span>
+                  </div>
+                  <div className="mt-1 h-1.5 overflow-hidden rounded-full bg-muted">
+                    <div className="h-full rounded-full bg-foreground transition-all" style={{ width: `${value * 100}%` }} />
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+      )}
+
+      {tab === "organism" && !organism && (
+        <div className="card p-8 text-center"><p className="text-muted-foreground">No active hypothesis. Allocate one from Today's Research.</p></div>
+      )}
+    </div>
+  );
+}

src/app/(app)/today/page.tsx

@@ -0,0 +1,56 @@
+"use client";
+import { useState, useEffect, useCallback } from "react";
+import type { HypothesisAnatomy, PriorArtRecord, HypothesisAssignment } from "@/types";
+const EMPLOYEE_ID = "emp-001";
+export default function TodayPage() {
+  const [assignments, setAssignments] = useState<HypothesisAssignment[]>([]);
+  const [hypotheses, setHypotheses] = useState<Map<string, HypothesisAnatomy>>(new Map());
+  const [priorArt, setPriorArt] = useState<Map<string, PriorArtRecord>>(new Map());
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [acting, setActing] = useState(false);
+  const [llmResearch, setLlmResearch] = useState<{ summary: string; used: boolean; error?: string } | null>(null);
+  const [researching, setResearching] = useState(false);
+  const load = useCallback(async () => {
+    try {
+      const [aRes, hRes, paRes] = await Promise.all([fetch(`/api/golden/assignments?employeeId=${EMPLOYEE_ID}&active=true`), fetch("/api/golden/hypotheses"), fetch("/api/golden/prior-art")]);
+      const aData = await aRes.json(); const hData = await hRes.json(); const paData = await paRes.json();
+      setAssignments(aData.assignments || []);
+      setHypotheses(new Map((hData.hypotheses || []).map((h: HypothesisAnatomy) => [h.id, h])));
+      setPriorArt(new Map((paData.priorArt || []).map((p: PriorArtRecord) => [p.id, p])));
+    } catch (e) { setError(e instanceof Error ? e.message : "Failed to load"); } finally { setLoading(false); }
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  const current = assignments[0];
+  const hypothesis = current ? hypotheses.get(current.hypothesisId) : undefined;
+  const pa = hypothesis ? priorArt.get(hypothesis.priorArtId) : undefined;
+  async function patchAssignment(action: "accept" | "reject" | "modify", extra?: Record<string, unknown>) {
+    if (!current) return; setActing(true);
+    try { const res = await fetch("/api/golden/assignments", { method: "PATCH", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action, assignmentId: current.id, ...extra }) }); if (!res.ok) throw new Error(`HTTP ${res.status}`); await load(); } catch (e) { setError(e instanceof Error ? e.message : "Action failed"); } finally { setActing(false); }
+  }
+  async function runLLMResearch() {
+    if (!hypothesis) return; setResearching(true); setLlmResearch(null);
+    try { const res = await fetch("/api/golden/llm", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action: "research", claim: hypothesis.claim }) }); if (!res.ok) throw new Error(`HTTP ${res.status}`); const data = await res.json(); setLlmResearch({ summary: data.record?.adjacentSupportSummary || "No summary returned.", used: data.llmUsed, error: data.llmError }); } catch (e) { setLlmResearch({ summary: "", used: false, error: e instanceof Error ? e.message : "Research failed" }); } finally { setResearching(false); }
+  }
+  if (loading) return <div className="mx-auto max-w-4xl px-8 py-10"><p className="text-muted-foreground">Loading today's hypothesis…</p></div>;
+  if (error) return <div className="mx-auto max-w-4xl px-8 py-10"><div className="card p-6"><p className="text-status-blocked">{error}</p><button className="btn btn-primary mt-4" onClick={load}>Retry</button></div></div>;
+  if (!current || !hypothesis) return (<div className="mx-auto max-w-4xl px-8 py-10"><h1 className="text-3xl font-bold tracking-tight text-foreground">Today's Hypothesis</h1><div className="card mt-6 p-8 text-center"><p className="text-muted-foreground">No active hypothesis mission. Allocate one to begin.</p><button className="btn btn-primary mt-4" onClick={async () => { await fetch("/api/golden/allocate", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ employeeId: EMPLOYEE_ID }) }); load(); }}>Allocate hypothesis</button></div></div>);
+  return (
+    <div className="mx-auto max-w-4xl px-8 py-10">
+      <h1 className="text-3xl font-bold tracking-tight text-foreground">Today's Hypothesis</h1>
+      <p className="mt-2 text-muted-foreground">Trial {current.trialNumber} · {current.kind} · {current.state}</p>
+      <div className="card mt-6 p-6">
+        <p className="text-lg font-medium text-foreground">{hypothesis.claim}</p>
+        <p className="mt-2 text-sm text-muted-foreground"><span className="font-medium text-foreground/80">Why this reached you: </span>{current.allocationReason}</p>
+        {pa && (<div className="mt-4 rounded-lg border border-border bg-muted/20 p-4"><p className="done-section-label">Prior art</p><p className="mt-1 text-sm text-muted-foreground">Status: {pa.status.replace(/_/g, " ")} · Evidence: {pa.evidenceState} · Confidence: {(pa.researchConfidence * 100).toFixed(0)}%</p><p className="mt-1 text-muted-foreground">{pa.adjacentSupportSummary}</p><p className="mt-2 text-xs text-muted-foreground">Source domains: {pa.sourceDomains.join(", ")}</p></div>)}
+        <div className="mt-4 rounded-lg border border-border bg-muted/20 p-4"><div className="flex items-center justify-between"><p className="done-section-label">LLM prior-art research</p><button onClick={runLLMResearch} disabled={researching} className="rounded-lg border border-border px-3 py-1 text-xs font-medium text-muted-foreground transition-all hover:border-foreground hover:text-foreground disabled:opacity-50">{researching ? "Researching…" : "Run LLM research"}</button></div>{llmResearch && (<div className="mt-2 text-sm">{llmResearch.used ? <p className="text-foreground/90">{llmResearch.summary}</p> : <p className="text-muted-foreground">LLM unavailable{llmResearch.error ? `: ${llmResearch.error}` : ""}. Deterministic prior-art used instead.</p>}</div>)}</div>
+        <div className="mt-5 grid grid-cols-1 gap-4 md:grid-cols-2"><div><p className="done-section-label">Intervention</p><p className="mt-1 text-sm text-foreground/90">{hypothesis.intervention}</p></div><div><p className="done-section-label">Control</p><p className="mt-1 text-sm text-foreground/90">{hypothesis.control}</p></div><div><p className="done-section-label">Primary outcome</p><p className="mt-1 text-sm text-foreground/90">{hypothesis.primaryOutcome}</p></div><div><p className="done-section-label">Primary uncertainty</p><p className="mt-1 text-sm text-foreground/90">{hypothesis.primaryUncertainty}</p></div></div>
+        <div className="mt-5"><p className="done-section-label">Fixed constraints</p><ul className="mt-1 space-y-1 text-sm text-muted-foreground">{hypothesis.fixedConstraints.map((c, i) => (<li key={i}>· {c}</li>))}</ul></div>
+        <div className="mt-5"><p className="done-section-label">Innovation window (modifiable dimensions)</p><div className="mt-2 flex flex-wrap gap-2">{(hypothesis.modifiableDimensions || []).map((d) => (<span key={d} className="rounded-lg border border-violet-500/30 bg-violet-500/10 px-3 py-1 text-xs font-medium text-violet-300">{d.replace(/_/g, " ")}</span>))}</div></div>
+        <div className="mt-5 grid grid-cols-1 gap-4 md:grid-cols-2"><div><p className="done-section-label">Expected value</p><p className="mt-1 text-sm text-foreground/90">{hypothesis.expectedValue}</p></div><div><p className="done-section-label">Eligible accounts</p><p className="mt-1 text-sm text-foreground/90">{current.eligibleAccountIds.length} accounts · {current.evaluationPeriodDays} day window</p></div></div>
+        <div className="mt-5 rounded-lg border border-status-needs/30 bg-status-needs/5 p-4"><p className="done-section-label text-status-needs">Compliance boundary</p><p className="mt-1 text-sm text-foreground/80">{hypothesis.complianceBoundary}</p></div>
+        <div className="mt-6 flex gap-3"><button onClick={() => patchAssignment("accept")} disabled={acting} className="btn btn-primary disabled:opacity-50">{acting ? "…" : "Accept mission"}</button><button onClick={() => patchAssignment("reject")} disabled={acting} className="btn btn-outline disabled:opacity-50">Reject</button></div>
+      </div>
+    </div>
+  );
+}

src/app/api/azure/config/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse } from "next/server";
+import { loadConfig } from "@/lib/config";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Returns whether Azure AD / Microsoft Graph OAuth is configured server-side.
+ * Exposes the clientId (not secret) so the client knows it can initiate auth.
+ */
+export async function GET() {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (e) {
+    console.error("[azure/config] loadConfig error:", e);
+    config = { graph: {} };
+  }
+
+  const clientId =
+    process.env.AZURE_AD_CLIENT_ID ||
+    process.env.AZURE_CLIENT_ID ||
+    process.env.MICROSOFT_CLIENT_ID ||
+    config.graph?.clientId ||
+    "";
+  const tenantId =
+    process.env.AZURE_AD_TENANT_ID ||
+    process.env.AZURE_TENANT_ID ||
+    process.env.MICROSOFT_TENANT_ID ||
+    config.graph?.tenantId ||
+    "";
+  const clientSecret =
+    process.env.AZURE_AD_CLIENT_SECRET ||
+    process.env.AZURE_CLIENT_SECRET ||
+    process.env.MICROSOFT_CLIENT_SECRET ||
+    config.graph?.clientSecret ||
+    "";
+  const mailbox =
+    process.env.MAILBOX_EMAIL ||
+    config.graph?.mailbox ||
+    "";
+
+  return NextResponse.json({
+    configured: !!(clientId && tenantId && clientSecret),
+    clientId,
+    tenantId,
+    hasSecret: !!clientSecret,
+    mailbox,
+  });
+}

src/app/api/commitments/detect/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server";
+import { detectCommitments } from "@/lib/commitment/detector";
+import { loadProcessedEmails } from "@/lib/config";
+import { upsertCommitmentByEmailId, listCommitments, loadMetrics } from "@/lib/commitment/store";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 60;
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const records = Array.isArray(body.records) ? body.records : loadProcessedEmails();
+
+    const detected = detectCommitments(records);
+
+    for (const c of detected) {
+      try {
+        upsertCommitmentByEmailId(c);
+      } catch (e: any) {
+        console.error("[commitments/detect] upsert error:", e);
+      }
+    }
+
+    const commitments = listCommitments();
+    const metrics = loadMetrics();
+
+    return NextResponse.json({
+      success: true,
+      detected: detected.length,
+      count: commitments.length,
+      commitments,
+      metrics,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (e: any) {
+    console.error("[commitments/detect] error:", e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/commitments/execute/route.ts

@@ -0,0 +1,70 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getCommitmentById,
+  listCommitments,
+  loadMetrics,
+  upsertCommitment,
+  addCommitmentAuditEvent,
+} from "@/lib/commitment/store";
+import { executeCommitment } from "@/lib/commitment/executor";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 120;
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+
+    const executeAll = !!body.executeAll;
+    const id = typeof body.id === "string" ? body.id : "";
+
+    if (!executeAll && !id) {
+      return NextResponse.json({ error: "id is required (or executeAll=true)" }, { status: 400 });
+    }
+
+    let targets = [];
+    if (executeAll) {
+      targets = listCommitments().filter((c) => c.status === "detected");
+    } else {
+      const found = getCommitmentById(id);
+      if (!found) {
+        return NextResponse.json({ error: `Commitment not found: ${id}` }, { status: 404 });
+      }
+      targets = [found];
+    }
+
+    let metrics = loadMetrics();
+    const executed: any[] = [];
+
+    for (const c of targets) {
+      try {
+        addCommitmentAuditEvent(c.id, "execute_requested", executeAll ? "Bulk execution requested" : "Execution requested");
+      } catch (e) {
+        console.error("[commitments/execute] audit error:", e);
+      }
+
+      const result = executeCommitment(c, metrics);
+      metrics = result.metrics;
+
+      const saved = upsertCommitment(result.contract);
+      executed.push({
+        id: saved.id,
+        emailId: saved.emailId,
+        status: saved.status,
+        staged: result.staged,
+        deliverableCount: saved.deliverables?.length ?? 0,
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      executedCount: executed.length,
+      executed,
+      metrics,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (e: any) {
+    console.error("[commitments/execute] error:", e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/commitments/outcome/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  getCommitmentById,
+  upsertCommitment,
+  addCommitmentAuditEvent,
+  updateCommitmentStatus,
+  recordAcceptanceOutcome,
+} from "@/lib/commitment/store";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 30;
+
+const OutcomeSchema = z.object({
+  id: z.string().min(1),
+  eventId: z.string().min(6),
+  accepted: z.boolean(),
+  revisionRequested: z.boolean().optional().default(false),
+  notes: z.string().max(2000).optional().default(""),
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const parsed = OutcomeSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: "Invalid request", details: parsed.error.flatten() },
+        { status: 400 },
+      );
+    }
+
+    const { id, eventId, accepted, revisionRequested, notes } = parsed.data;
+
+    const existing = getCommitmentById(id);
+    if (!existing) {
+      return NextResponse.json({ error: `Commitment not found: ${id}` }, { status: 404 });
+    }
+
+    const already = (existing.auditEvents || []).some(
+      (e) => e.event === "outcome" && (e.detail || "").includes(`eventId=${eventId}`),
+    );
+
+    if (already) {
+      return NextResponse.json({
+        success: true,
+        alreadyRecorded: true,
+        id,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    const acceptedWithoutRevision = accepted && !revisionRequested;
+
+    recordAcceptanceOutcome({ acceptedWithoutRevision });
+
+    const detail = [
+      `eventId=${eventId}`,
+      `accepted=${accepted}`,
+      `revisionRequested=${revisionRequested}`,
+      notes ? `notes=${notes}` : "",
+    ]
+      .filter(Boolean)
+      .join(" ");
+
+    try {
+      addCommitmentAuditEvent(id, "outcome", detail);
+    } catch (e) {
+      console.error("[commitments/outcome] audit error:", e);
+    }
+
+    // Update the contract status based on outcome feedback.
+    try {
+      if (accepted) {
+        updateCommitmentStatus(id, "completed", "Outcome recorded: accepted");
+      } else if (revisionRequested) {
+        updateCommitmentStatus(id, "executing", "Outcome recorded: revision requested");
+      } else {
+        updateCommitmentStatus(id, "escalated", "Outcome recorded: rejected");
+      }
+    } catch (e) {
+      console.error("[commitments/outcome] status update error:", e);
+    }
+
+    // Ensure latest contract is persisted
+    const updated = getCommitmentById(id);
+    if (updated) {
+      upsertCommitment(updated);
+    }
+
+    return NextResponse.json({
+      success: true,
+      alreadyRecorded: false,
+      id,
+      acceptedWithoutRevision,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (e: any) {
+    console.error("[commitments/outcome] error:", e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/commitments/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listCommitments, loadMetrics } from "@/lib/commitment/store";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 30;
+
+export async function GET(request: NextRequest) {
+  try {
+    const commitments = listCommitments();
+    const metrics = loadMetrics();
+
+    const limitRaw = request.nextUrl.searchParams.get("limit");
+    const limit = limitRaw ? Math.max(1, Math.min(500, parseInt(limitRaw))) : 200;
+
+    return NextResponse.json({
+      success: true,
+      count: commitments.length,
+      commitments: commitments.slice(0, limit),
+      metrics,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (e: any) {
+    console.error("[commitments] error:", e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/competitive/actions/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  generateCompetitivePlan,
+  updateActionStatus,
+  recordActionOutcome,
+} from "@/lib/competitive/engine";
+import { ActionStatus, ActionOutcome } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId") || "emp-001";
+
+  try {
+    const plan = generateCompetitivePlan(employeeId);
+    if (!plan) {
+      return NextResponse.json(
+        { error: `Employee not found: ${employeeId}` },
+        { status: 404 },
+      );
+    }
+    return NextResponse.json(plan.portfolio);
+  } catch (e) {
+    console.error("[api/competitive/actions] GET error:", e);
+    return NextResponse.json(
+      { error: "Failed to get actions" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { actionId, operation, feedback, outcome, context } = body;
+
+    if (!actionId || !operation) {
+      return NextResponse.json(
+        { error: "actionId and operation are required" },
+        { status: 400 },
+      );
+    }
+
+    const validOperations = ["accept", "modify", "replace", "decline", "complete", "explain"];
+    if (!validOperations.includes(operation)) {
+      return NextResponse.json(
+        { error: `Invalid operation: ${operation}. Must be one of: ${validOperations.join(", ")}` },
+        { status: 400 },
+      );
+    }
+
+    const statusMap: Record<string, ActionStatus> = {
+      accept: "accepted",
+      modify: "modified",
+      replace: "replaced",
+      decline: "declined",
+      complete: "completed",
+      explain: "accepted",
+    };
+
+    const updated = updateActionStatus(actionId, statusMap[operation], feedback);
+
+    if (operation === "complete" && outcome) {
+      const outcomeRecord = recordActionOutcome({
+        actionId,
+        employeeId: body.employeeId || "emp-001",
+        experimentId: body.experimentId,
+        variant: body.variant,
+        actionTaken: body.actionTaken || updated?.title || "Action completed",
+        outcome: outcome as ActionOutcome["outcome"],
+        timeToOutcomeHours: body.timeToOutcomeHours || 0,
+        context: context || {},
+      });
+      return NextResponse.json({ action: updated, outcome: outcomeRecord });
+    }
+
+    return NextResponse.json({ action: updated });
+  } catch (e) {
+    console.error("[api/competitive/actions] POST error:", e);
+    return NextResponse.json(
+      { error: "Failed to update action" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/experiments/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getEngineState } from "@/lib/competitive/engine";
+import { getActiveExperiments, getCompletedExperiments } from "@/lib/competitive/experiment";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId");
+  const status = req.nextUrl.searchParams.get("status") || "all";
+
+  try {
+    const state = getEngineState();
+    let experiments = state.experiments;
+
+    if (status === "active") {
+      experiments = getActiveExperiments(state.experiments);
+    } else if (status === "completed") {
+      experiments = getCompletedExperiments(state.experiments);
+    }
+
+    if (employeeId) {
+      const empOutcomes = state.outcomes.filter((o) => o.employeeId === employeeId);
+      const empExperimentIds = new Set(empOutcomes.map((o) => o.experimentId).filter(Boolean));
+      experiments = experiments.filter(
+        (e) => empExperimentIds.has(e.id) || e.status === "running",
+      );
+    }
+
+    return NextResponse.json({ experiments, total: experiments.length });
+  } catch (e) {
+    console.error("[api/competitive/experiments] error:", e);
+    return NextResponse.json(
+      { error: "Failed to get experiments" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/learnings/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getEngineState } from "@/lib/competitive/engine";
+import {
+  getValidatedStrategies,
+  getExperimentalStrategies,
+} from "@/lib/competitive/learning";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const filter = req.nextUrl.searchParams.get("filter") || "all";
+
+  try {
+    const state = getEngineState();
+    let strategies = state.strategies;
+
+    if (filter === "validated") {
+      strategies = getValidatedStrategies(state.strategies);
+    } else if (filter === "experimental") {
+      strategies = getExperimentalStrategies(state.strategies);
+    }
+
+    strategies = [...strategies].sort((a, b) => b.confidence - a.confidence);
+
+    return NextResponse.json({ strategies, total: strategies.length });
+  } catch (e) {
+    console.error("[api/competitive/learnings] error:", e);
+    return NextResponse.json(
+      { error: "Failed to get learnings" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/manager/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getManagerLabView } from "@/lib/competitive/engine";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const managerId = req.nextUrl.searchParams.get("managerId") || "emp-007";
+
+  try {
+    const view = getManagerLabView(managerId);
+    if (!view) {
+      return NextResponse.json(
+        { error: `Manager not found or not a manager role: ${managerId}` },
+        { status: 404 },
+      );
+    }
+    return NextResponse.json(view);
+  } catch (e) {
+    console.error("[api/competitive/manager] error:", e);
+    return NextResponse.json(
+      { error: "Failed to get manager lab view" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/plan/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { generateCompetitivePlan } from "@/lib/competitive/engine";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId") || "emp-001";
+
+  try {
+    const plan = generateCompetitivePlan(employeeId);
+    if (!plan) {
+      return NextResponse.json(
+        { error: `Employee not found: ${employeeId}` },
+        { status: 404 },
+      );
+    }
+    return NextResponse.json(plan);
+  } catch (e) {
+    console.error("[api/competitive/plan] error:", e);
+    return NextResponse.json(
+      { error: "Failed to generate competitive plan" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/results/route.ts

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getEngineState } from "@/lib/competitive/engine";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId");
+
+  try {
+    const state = getEngineState();
+    let outcomes = state.outcomes;
+
+    if (employeeId) {
+      outcomes = outcomes.filter((o) => o.employeeId === employeeId);
+    }
+
+    outcomes = [...outcomes].sort(
+      (a, b) => new Date(b.capturedAt).getTime() - new Date(a.capturedAt).getTime(),
+    );
+
+    return NextResponse.json({ outcomes, total: outcomes.length });
+  } catch (e) {
+    console.error("[api/competitive/results] error:", e);
+    return NextResponse.json(
+      { error: "Failed to get results" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/score/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { generateCompetitivePlan } from "@/lib/competitive/engine";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId") || "emp-001";
+
+  try {
+    const plan = generateCompetitivePlan(employeeId);
+    if (!plan) {
+      return NextResponse.json(
+        { error: `Employee not found: ${employeeId}` },
+        { status: 404 },
+      );
+    }
+    return NextResponse.json(plan.score);
+  } catch (e) {
+    console.error("[api/competitive/score] error:", e);
+    return NextResponse.json(
+      { error: "Failed to compute score" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/competitive/trajectory/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { generateCompetitivePlan } from "@/lib/competitive/engine";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const employeeId = req.nextUrl.searchParams.get("employeeId") || "emp-001";
+
+  try {
+    const plan = generateCompetitivePlan(employeeId);
+    if (!plan) {
+      return NextResponse.json(
+        { error: `Employee not found: ${employeeId}` },
+        { status: 404 },
+      );
+    }
+    return NextResponse.json(plan.trajectory);
+  } catch (e) {
+    console.error("[api/competitive/trajectory] error:", e);
+    return NextResponse.json(
+      { error: "Failed to generate trajectory" },
+      { status: 500 },
+    );
+  }
+}

src/app/api/config/route.ts

@@ -0,0 +1,68 @@
+import { NextRequest, NextResponse } from "next/server";
+import { loadConfig, saveConfig } from "@/lib/config";
+import { AppConfig } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const config = loadConfig();
+  const safeConfig = {
+    ...config,
+    graph: {
+      ...config.graph,
+      clientSecret: config.graph.clientSecret ? "***" : "",
+    },
+    llm: {
+      ...config.llm,
+      apiKey: config.llm.apiKey ? "***" : "",
+    },
+  };
+  return NextResponse.json(safeConfig);
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json() as Partial<AppConfig>;
+
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      return NextResponse.json({ error: "Request body must be a valid configuration object" }, { status: 400 });
+    }
+
+    const current = loadConfig();
+
+    const updated: AppConfig = {
+      graph: {
+        clientId: body.graph?.clientId ?? current.graph.clientId,
+        clientSecret: body.graph?.clientSecret && body.graph.clientSecret !== "***"
+          ? body.graph.clientSecret
+          : current.graph.clientSecret,
+        tenantId: body.graph?.tenantId ?? current.graph.tenantId,
+        mailbox: body.graph?.mailbox ?? current.graph.mailbox,
+      },
+      llm: {
+        provider: body.llm?.provider ?? current.llm.provider,
+        apiKey: body.llm?.apiKey && body.llm.apiKey !== "***"
+          ? body.llm.apiKey
+          : current.llm.apiKey,
+        model: body.llm?.model ?? current.llm.model,
+        endpoint: body.llm?.endpoint ?? current.llm.endpoint,
+      },
+      processing: {
+        autoProcess: body.processing?.autoProcess ?? current.processing.autoProcess,
+        pollInterval: body.processing?.pollInterval ?? current.processing.pollInterval,
+        maxEmailsPerSync: body.processing?.maxEmailsPerSync ?? current.processing.maxEmailsPerSync,
+        categories: body.processing?.categories ?? current.processing.categories,
+        extractionPrompt: body.processing?.extractionPrompt ?? current.processing.extractionPrompt,
+      },
+      export: {
+        format: body.export?.format ?? current.export.format,
+        outputPath: body.export?.outputPath ?? current.export.outputPath,
+      },
+    };
+
+    saveConfig(updated);
+    return NextResponse.json({ success: true });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/demo/seed/route.ts

@@ -0,0 +1,350 @@
+import { NextResponse } from "next/server";
+import { ProcessedEmailRecord, ParsedAttachmentData } from "@/types";
+import { generateAnalysis } from "@/lib/analysis/generator";
+import { saveProcessedEmails, loadProcessedEmails, saveSyncStatus } from "@/lib/config";
+import { generateSampleCommitments } from "@/lib/commitment/detector";
+import { listCommitments, upsertCommitment } from "@/lib/commitment/store";
+import { nanoid } from "nanoid";
+
+export const dynamic = "force-dynamic";
+
+interface SampleEmail {
+  subject: string;
+  sender: string;
+  receivedDate: string;
+  body: string;
+  attachments: { name: string; type: string; parsedData: ParsedAttachmentData }[];
+}
+
+const SAMPLE_EMAILS: SampleEmail[] = [
+  {
+    subject: "Q3 Environmental Field Study Results — Lake Ontario Basin",
+    sender: "Dr. Sarah Chen",
+    receivedDate: "2026-07-28T14:30:00Z",
+    body: `Hi team,
+
+Please find attached the Q3 environmental monitoring results for the Lake Ontario basin. The field study covered 12 sampling sites across the shoreline.
+
+Key findings:
+- pH levels averaged 7.8 (within normal range)
+- Dissolved oxygen: 8.2 mg/L (improved from Q2's 7.1 mg/L)
+- Phosphorus concentration: 0.045 mg/L (exceeds EPA threshold of 0.025 mg/L)
+- Water temperature: 22.4°C average (2.1°C above historical mean)
+
+The elevated phosphorus levels near site 7 require immediate attention. I've included the full CSV dataset and a PDF summary report.
+
+Please review and let me know if you need any clarification.
+
+Best regards,
+Dr. Sarah Chen
+Environmental Science Division`,
+    attachments: [
+      {
+        name: "field_data_q3.csv",
+        type: "csv",
+        parsedData: {
+          type: "csv",
+          rows: [
+            { site: "S1", ph: 7.6, dissolved_oxygen_mgL: 8.5, phosphorus_mgL: 0.021, temperature_C: 21.2, turbidity_NTU: 3.2 },
+            { site: "S2", ph: 7.9, dissolved_oxygen_mgL: 8.3, phosphorus_mgL: 0.028, temperature_C: 21.8, turbidity_NTU: 2.8 },
+            { site: "S3", ph: 7.7, dissolved_oxygen_mgL: 8.1, phosphorus_mgL: 0.033, temperature_C: 22.0, turbidity_NTU: 4.1 },
+            { site: "S4", ph: 7.8, dissolved_oxygen_mgL: 8.4, phosphorus_mgL: 0.019, temperature_C: 21.5, turbidity_NTU: 2.5 },
+            { site: "S5", ph: 8.0, dissolved_oxygen_mgL: 7.9, phosphorus_mgL: 0.041, temperature_C: 22.3, turbidity_NTU: 5.6 },
+            { site: "S6", ph: 7.5, dissolved_oxygen_mgL: 8.6, phosphorus_mgL: 0.024, temperature_C: 21.0, turbidity_NTU: 3.0 },
+            { site: "S7", ph: 7.3, dissolved_oxygen_mgL: 7.2, phosphorus_mgL: 0.067, temperature_C: 23.1, turbidity_NTU: 8.9 },
+            { site: "S8", ph: 7.8, dissolved_oxygen_mgL: 8.2, phosphorus_mgL: 0.030, temperature_C: 22.1, turbidity_NTU: 3.5 },
+          ],
+          metadata: { rowCount: 8, headers: ["site", "ph", "dissolved_oxygen_mgL", "phosphorus_mgL", "temperature_C", "turbidity_NTU"] },
+        },
+      },
+      {
+        name: "summary_report.pdf",
+        type: "pdf",
+        parsedData: {
+          type: "pdf",
+          text: `Environmental Field Study Summary — Q3 2026\nLake Ontario Basin Monitoring Program\n\nExecutive Summary:\nThis report presents water quality data from 8 sampling sites along the Lake Ontario shoreline. The study was conducted between July 1-15, 2026.\n\nKey Findings:\n1. Overall water quality is acceptable with pH within normal range (7.3-8.0)\n2. Dissolved oxygen levels improved 15% compared to Q2 2026\n3. Site S7 shows critical phosphorus levels (0.067 mg/L) — 2.7x EPA threshold\n4. Water temperatures are 2.1°C above historical mean, consistent with climate trends\n\nRecommendations:\n- Immediate investigation of phosphorus source near Site S7\n- Continued monthly monitoring at all sites\n- Expansion to include nitrogen compounds in Q4\n\nPrepared by: Dr. Sarah Chen, Environmental Science Division`,
+          metadata: { pages: 3 },
+        },
+      },
+    ],
+  },
+  {
+    subject: "Clinical Trial Phase II — Patient Response Data Batch 14",
+    sender: "Dr. Michael Rodriguez",
+    receivedDate: "2026-07-26T09:15:00Z",
+    body: `Team,
+
+Batch 14 patient response data is attached. This batch covers patients 201-240 in the Phase II trial for compound NRX-417.
+
+Summary:
+- 40 patients evaluated
+- 28 showed positive response (70%)
+- 8 showed no significant change (20%)
+- 4 showed adverse reactions (10%) — all mild, none severe
+- Average response time: 6.3 days
+
+The CSV contains per-patient metrics. Please analyze for statistical significance and prepare for the safety board review next week.
+
+Dr. Rodriguez
+Clinical Research Unit`,
+    attachments: [
+      {
+        name: "patient_batch14.csv",
+        type: "csv",
+        parsedData: {
+          type: "csv",
+          rows: [
+            { patient_id: "P201", age: 54, sex: "F", dose_mg: 50, response: "positive", response_days: 5, side_effects: "none" },
+            { patient_id: "P202", age: 61, sex: "M", dose_mg: 50, response: "positive", response_days: 7, side_effects: "mild_nausea" },
+            { patient_id: "P203", age: 47, sex: "F", dose_mg: 75, response: "positive", response_days: 4, side_effects: "none" },
+            { patient_id: "P204", age: 58, sex: "M", dose_mg: 50, response: "none", response_days: 14, side_effects: "none" },
+            { patient_id: "P205", age: 63, sex: "F", dose_mg: 75, response: "positive", response_days: 6, side_effects: "mild_headache" },
+            { patient_id: "P206", age: 52, sex: "M", dose_mg: 50, response: "positive", response_days: 8, side_effects: "none" },
+            { patient_id: "P207", age: 49, sex: "F", dose_mg: 100, response: "adverse", response_days: 3, side_effects: "mild_rash" },
+            { patient_id: "P208", age: 67, sex: "M", dose_mg: 75, response: "positive", response_days: 5, side_effects: "none" },
+          ],
+          metadata: { rowCount: 8, headers: ["patient_id", "age", "sex", "dose_mg", "response", "response_days", "side_effects"] },
+        },
+      },
+    ],
+  },
+  {
+    subject: "Lab Results — Spectroscopy Analysis of Compound XJ-22",
+    sender: "Lab Technician James Park",
+    receivedDate: "2026-07-25T16:45:00Z",
+    body: `Dr. Chen,
+
+The spectroscopy analysis for compound XJ-22 is complete. Here are the key results:
+
+- Molecular weight: 342.4 g/mol
+- Melting point: 187°C
+- Purity: 98.7% (HPLC)
+- UV-Vis peak: 278 nm
+- IR peaks: 3400, 2920, 1720, 1650, 1540 cm⁻¹
+
+The full spectral data is in the attached text file. The compound appears to match the expected structure with high confidence.
+
+James
+Analytical Chemistry Lab`,
+    attachments: [
+      {
+        name: "spectral_data.txt",
+        type: "text",
+        parsedData: {
+          type: "text",
+          text: `SPECTROSCOPY REPORT — Compound XJ-22\nDate: 2026-07-25\nOperator: James Park\n\nMolecular Formula: C18H22O5N2\nMolecular Weight: 342.37 g/mol\nMelting Point: 187.2°C\nPurity (HPLC): 98.7%\n\nUV-Vis Spectroscopy:\n  Peak 1: 278 nm (absorbance 0.847)\n  Peak 2: 215 nm (absorbance 1.234)\n\nIR Spectroscopy (cm⁻¹):\n  3400 — O-H stretch\n  2920 — C-H stretch\n  1720 — C=O stretch (ester)\n  1650 — C=O stretch (amide)\n  1540 — N-H bend\n\nNMR (1H, 400MHz, DMSO-d6):\n  δ 9.2 (s, 1H, NH)\n  δ 7.3 (d, 2H, ArH)\n  δ 6.8 (d, 2H, ArH)\n  δ 4.1 (q, 2H, OCH2)\n  δ 3.5 (s, 2H, CH2)\n  δ 1.2 (t, 3H, CH3)\n\nConclusion: Structure confirmed with 98.7% confidence.`,
+          metadata: {},
+        },
+      },
+    ],
+  },
+  {
+    subject: "Research Collaboration Proposal — Marine Biodiversity Survey",
+    sender: "Prof. Elena Volkov",
+    receivedDate: "2026-07-24T11:00:00Z",
+    body: `Dear Colleagues,
+
+I'm writing to propose a collaborative marine biodiversity survey in the Gulf of Maine, scheduled for September 2026.
+
+Project scope:
+- 15-day expedition covering 30 sampling stations
+- Multi-depth trawl and eDNA sampling
+- Target species: Atlantic cod, haddock, lobster, and 20+ indicator species
+- Budget: $285,000 (shared between 3 institutions)
+- Team: 12 researchers + 4 crew
+
+The attached proposal document contains the full methodology, timeline, and budget breakdown. We'd need your institution's commitment by August 10th.
+
+Looking forward to your response.
+
+Prof. Elena Volkov
+Marine Biology Department`,
+    attachments: [
+      {
+        name: "proposal_summary.txt",
+        type: "text",
+        parsedData: {
+          type: "text",
+          text: `MARINE BIODIVERSITY SURVEY — GULF OF MAINE\nProposal Date: July 24, 2026\nPrincipal Investigator: Prof. Elena Volkov\n\nDuration: 15 days (September 5-19, 2026)\nSampling Stations: 30\nBudget: $285,000\nTeam Size: 16 (12 researchers + 4 crew)\n\nObjectives:\n1. Assess population health of key commercial species\n2. Document biodiversity changes since 2024 survey\n3. Collect eDNA samples for metagenomic analysis\n4. Monitor ocean acidification impacts on shellfish\n\nMethodology:\n- Multi-depth trawl surveys (0-200m)\n- Environmental DNA sampling at each station\n- Benthic sediment core sampling\n- CTD profiler casts for water chemistry\n\nDeliverables:\n- Comprehensive biodiversity report\n- Species distribution maps\n- eDNA reference database\n- Policy recommendations for fisheries management`,
+          metadata: {},
+        },
+      },
+    ],
+  },
+];
+
+export async function POST() {
+  try {
+  let existing: ProcessedEmailRecord[] = [];
+  try {
+    existing = loadProcessedEmails();
+  } catch (e) {
+    console.error("[demo/seed] loadProcessedEmails error:", e);
+  }
+  const records: ProcessedEmailRecord[] = [...existing];
+
+  for (const email of SAMPLE_EMAILS) {
+    if (records.some((r) => r.subject === email.subject)) continue;
+
+    const analysis = generateAnalysis({
+      subject: email.subject,
+      sender: email.sender,
+      body: email.body,
+      attachments: email.attachments,
+    });
+
+    // Demo data uses pre-built analysis (wikitree, mindmap, execution)
+    // LLM extraction is skipped — it's available via the /api/llm/infer endpoint
+    const llmSummary = "";
+    const llmCategory = categorizeEmail(email);
+    const llmConfidence = 0.85;
+
+    const fields: any[] = [];
+    const tables: any[] = [];
+
+    for (const att of email.attachments) {
+      if (att.parsedData?.rows && att.parsedData.rows.length > 0) {
+        const firstRow = att.parsedData.rows[0];
+        for (const [key, value] of Object.entries(firstRow)) {
+          fields.push({
+            key,
+            value: String(value || ""),
+            type: typeof value === "number" ? "number" : "string",
+            confidence: 0.9,
+          });
+        }
+        const headers = Object.keys(firstRow);
+        tables.push({
+          name: att.name,
+          headers,
+          rows: att.parsedData.rows.slice(0, 100),
+          source: att.name,
+        });
+      }
+      if (att.parsedData?.text) {
+        const lines = att.parsedData.text.split("\n").slice(0, 20);
+        for (const line of lines) {
+          const match = line.match(/^([A-Za-z][A-Za-z0-9\s]+):\s*(.+)$/);
+          if (match) {
+            fields.push({
+              key: match[1].trim(),
+              value: match[2].trim(),
+              type: "string",
+              confidence: 0.7,
+            });
+          }
+        }
+      }
+    }
+
+    const category = llmCategory;
+
+    records.push({
+      id: nanoid(),
+      emailId: `demo-${nanoid(8)}`,
+      subject: email.subject,
+      sender: email.sender,
+      receivedDate: email.receivedDate,
+      processedAt: new Date().toISOString(),
+      category,
+      confidence: llmConfidence,
+      fieldCount: fields.length,
+      tableCount: tables.length,
+      extractedData: {
+        emailId: `demo-${nanoid(8)}`,
+        extractedAt: new Date().toISOString(),
+        fields: fields.slice(0, 50),
+        tables,
+        summary: llmSummary || analysis.execution.summary,
+        category,
+        confidence: llmConfidence,
+        source: email.attachments.length > 0 ? "attachment" : "email_body",
+      },
+      analysis,
+    });
+  }
+
+  // Try to persist to filesystem (works locally, silently fails on serverless)
+  try {
+    saveProcessedEmails(records);
+    saveSyncStatus({
+      lastSync: new Date().toISOString(),
+      totalEmails: records.length,
+      processedEmails: records.length,
+      pendingEmails: 0,
+      isSyncing: false,
+      errors: [],
+    });
+  } catch (e) {
+    console.error("[demo/seed] persist error:", e);
+  }
+
+  let commitments: any[] = [];
+  let commitmentsSeeded = 0;
+  try {
+    const existingCommitments = listCommitments();
+    if (existingCommitments.length === 0) {
+      const samples = generateSampleCommitments();
+      for (const c of samples) {
+        try {
+          upsertCommitment(c);
+          commitmentsSeeded++;
+        } catch (e: any) {
+          console.error("[demo/seed] commitment seed error:", e.message);
+        }
+      }
+      commitments = samples;
+    } else {
+      commitments = existingCommitments;
+    }
+  } catch (e: any) {
+    console.error("[demo/seed] commitments error:", e.message);
+  }
+
+  return NextResponse.json({
+    seeded: records.length - existing.length,
+    total: records.length,
+    message: `Loaded ${records.length - existing.length} real processed emails through the analysis pipeline`,
+    records, // Include records so frontend can store them in localStorage
+    commitments,
+    commitmentsSeeded,
+    status: {
+      lastSync: new Date().toISOString(),
+      totalEmails: records.length,
+      processedEmails: records.length,
+      pendingEmails: 0,
+      isSyncing: false,
+      errors: [],
+    },
+  });
+  } catch (e: any) {
+    console.error("[demo/seed] error:", e);
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+function categorizeEmail(email: SampleEmail): string {
+  const subject = email.subject.toLowerCase();
+  if (subject.includes("field study") || subject.includes("environmental")) return "Environmental Data";
+  if (subject.includes("clinical") || subject.includes("trial")) return "Clinical Trial";
+  if (subject.includes("lab") || subject.includes("spectroscopy")) return "Lab Results";
+  if (subject.includes("research") || subject.includes("proposal")) return "Research Data";
+  return "Other";
+}
+
+export async function DELETE() {
+  try {
+    saveProcessedEmails([]);
+    saveSyncStatus({
+      lastSync: null,
+      totalEmails: 0,
+      processedEmails: 0,
+      pendingEmails: 0,
+      isSyncing: false,
+      errors: [],
+    });
+  } catch (e) {
+    console.error("[demo/seed] delete error:", e);
+  }
+  return NextResponse.json({ cleared: true });
+}

src/app/api/gmail/action/route.ts

@@ -0,0 +1,83 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  markAsReadREST,
+  markAsUnreadREST,
+  starEmailREST,
+  archiveEmailREST,
+  trashEmailREST,
+  snoozeEmailREST,
+  modifyLabelsREST,
+} from "@/lib/gmail/rest-client";
+import { normalizeOrigin, getRequestOrigin } from "@/lib/utils";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 30;
+
+/**
+ * Generic email action endpoint.
+ * POST /api/gmail/action
+ * Body: { action: "read"|"unread"|"star"|"archive"|"trash"|"snooze"|"modify", messageId, ... }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const clientId = process.env.GMAIL_CLIENT_ID || "";
+    const clientSecret = process.env.GMAIL_CLIENT_SECRET || "";
+    const refreshToken = body.refreshToken || request.cookies.get("gmail-refresh-token")?.value || "";
+
+    if (!clientId || !refreshToken) {
+      return NextResponse.json({ error: "Gmail not connected" }, { status: 401 });
+    }
+
+    if (!body.messageId) {
+      return NextResponse.json({ error: "messageId is required" }, { status: 400 });
+    }
+
+    const redirectUri = `${normalizeOrigin(getRequestOrigin(request))}/api/gmail/callback`;
+    const config = { clientId, clientSecret, redirectUri, refreshToken, emailAddress: "" };
+
+    switch (body.action) {
+      case "read":
+        await markAsReadREST(config, body.messageId);
+        return NextResponse.json({ success: true, action: "read" });
+
+      case "unread":
+        await markAsUnreadREST(config, body.messageId);
+        return NextResponse.json({ success: true, action: "unread" });
+
+      case "star":
+        await starEmailREST(config, body.messageId);
+        return NextResponse.json({ success: true, action: "star" });
+
+      case "archive":
+        await archiveEmailREST(config, body.messageId);
+        return NextResponse.json({ success: true, action: "archive" });
+
+      case "trash":
+        await trashEmailREST(config, body.messageId);
+        return NextResponse.json({ success: true, action: "trash" });
+
+      case "snooze":
+        if (!body.snoozeUntil) {
+          return NextResponse.json({ error: "snoozeUntil is required for snooze action" }, { status: 400 });
+        }
+        await snoozeEmailREST(config, body.messageId, body.snoozeUntil);
+        return NextResponse.json({ success: true, action: "snooze", snoozeUntil: body.snoozeUntil });
+
+      case "modify":
+        await modifyLabelsREST(config, body.messageId, {
+          addLabelIds: body.addLabelIds,
+          removeLabelIds: body.removeLabelIds,
+        });
+        return NextResponse.json({ success: true, action: "modify" });
+
+      default:
+        return NextResponse.json({
+          error: `Unknown action: ${body.action}`,
+          availableActions: ["read", "unread", "star", "archive", "trash", "snooze", "modify"],
+        }, { status: 400 });
+    }
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/gmail/auth/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuthUrl } from "@/lib/gmail/client";
+import { loadConfig } from "@/lib/config";
+import { normalizeOrigin, getRequestOrigin } from "@/lib/utils";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Returns the Google OAuth authorization URL.
+ * Credentials are read exclusively from server environment variables —
+ * the client never sees or handles the client secret.
+ */
+export async function GET(request: NextRequest) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (e) {
+    console.error("[gmail/auth] loadConfig error:", e);
+    config = { graph: {} };
+  }
+
+  // Only use server-side env vars or config file — never accept credentials from query params
+  const clientId =
+    process.env.GMAIL_CLIENT_ID ||
+    config.graph?.clientId ||
+    "";
+  const clientSecret =
+    process.env.GMAIL_CLIENT_SECRET ||
+    config.graph?.clientSecret ||
+    "";
+
+  if (!clientId || !clientSecret) {
+    return NextResponse.json({
+      error: "Gmail OAuth is not configured on the server. Ask your administrator to set GMAIL_CLIENT_ID and GMAIL_CLIENT_SECRET environment variables.",
+    }, { status: 500 });
+  }
+
+  const redirectUri = `${normalizeOrigin(getRequestOrigin(request))}/api/gmail/callback`;
+
+  const authUrl = getAuthUrl({
+    clientId,
+    clientSecret,
+    redirectUri,
+    refreshToken: "",
+    emailAddress: "",
+  });
+
+  return NextResponse.json({ authUrl });
+}

src/app/api/gmail/body/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fetchEmailBodyREST } from "@/lib/gmail/rest-client";
+import { normalizeOrigin, getRequestOrigin } from "@/lib/utils";
+
+export const dynamic = "force-dynamic";
+export const maxDuration = 30;
+
+/**
+ * POST /api/gmail/body
+ * Fetches the full body of a single email on demand.
+ * Body: { messageId, refreshToken? }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const clientId = process.env.GMAIL_CLIENT_ID || "";
+    const clientSecret = process.env.GMAIL_CLIENT_SECRET || "";
+    const refreshToken = body.refreshToken || request.cookies.get("gmail-refresh-token")?.value || "";
+
+    if (!clientId || !refreshToken) {
+      return NextResponse.json({ error: "Gmail not connected" }, { status: 401 });
+    }
+
+    if (!body.messageId) {
+      return NextResponse.json({ error: "messageId required" }, { status: 400 });
+    }
+
+    const redirectUri = `${normalizeOrigin(getRequestOrigin(request))}/api/gmail/callback`;
+    const rawBody = await fetchEmailBodyREST(
+      { clientId, clientSecret, redirectUri, refreshToken, emailAddress: "" },
+      body.messageId
+    );
+
+    // Strip HTML tags if the body is HTML
+    const cleanBody = rawBody.includes("<") && rawBody.includes(">")
+      ? rawBody
+          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+          .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+          .replace(/<[^>]+>/g, "")
+          .replace(/&nbsp;/g, " ")
+          .replace(/&amp;/g, "&")
+          .replace(/&lt;/g, "<")
+          .replace(/&gt;/g, ">")
+          .replace(/&#39;/g, "'")
+          .replace(/&quot;/g, '"')
+          .replace(/\n{3,}/g, "\n\n")
+          .trim()
+      : rawBody;
+
+    return NextResponse.json({ body: cleanBody || "(no body)" });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

src/app/api/gmail/callback/route.ts

@@ -0,0 +1,21 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRequestOrigin } from "@/lib/utils";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  const code = request.nextUrl.searchParams.get("code");
+  const error = request.nextUrl.searchParams.get("error");
+  const origin = getRequestOrigin(request);
+
+  if (error) {
+    return NextResponse.redirect(`${origin}/?gmail_error=${error}`);
+  }
+
+  if (!code) {
+    return NextResponse.redirect(`${origin}/?gmail_error=no_code`);
+  }
+
+  // Redirect to client-side page that will exchange the code using localStorage credentials
+  return NextResponse.redirect(`${origin}/gmail/connect?code=${encodeURIComponent(code)}`);
+}

src/app/api/gmail/config/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { loadConfig } from "@/lib/config";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Returns whether Gmail OAuth is configured server-side (env vars or config file).
+ * Exposes the clientId (not secret) so the client can build auth URLs without
+ * requiring the user to enter credentials manually.
+ */
+export async function GET() {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (e) {
+    console.error("[gmail/config] loadConfig error:", e);
+    config = { graph: {} };
+  }
+
+  const clientId =
+    process.env.GMAIL_CLIENT_ID ||
+    config.graph?.clientId ||
+    "";
+  const clientSecret =
+    process.env.GMAIL_CLIENT_SECRET ||
+    config.graph?.clientSecret ||
+    "";
+
+  return NextResponse.json({
+    configured: !!(clientId && clientSecret),
+    clientId, // not secret — needed to build auth URL client-side
+    hasSecret: !!clientSecret,
+  });
+}