Smoke Signal v1: integrated pipeline wizard tab

app.py

@@ -26,6 +26,7 @@ from src.totem_workbook import (
 )
 
 from src.codex_extractor import process_upload, format_fingerprint_report
+from smoke_signal_tab import smoke_signal_tab, SS_CSS
 
 ORIGINAL_WORKBOOK_PATH = "data/order69_macmillan_totem_rebuilt.xlsx"
 CODEX_CATALOGUE_PATH = Path("data/codex_catalogue.xlsx")
@@ -1175,7 +1176,7 @@ def single_score(active_path, sequence, stanza_id, draft_pass, clarity, rhythm,
 
 # ── GRADIO INTERFACE ──────────────────────────────────────────────────────────
 
-with gr.Blocks(title="TOTEM Studio", css=CSS, head=HEAD) as demo:
+with gr.Blocks(title="TOTEM Studio", css=CSS + SS_CSS, head=HEAD) as demo:
     active_path = gr.State(str(DEFAULT_WORKBOOK))
     log_state = gr.State(pd.DataFrame(columns=LOG_COLUMNS))
 
@@ -1341,6 +1342,9 @@ with gr.Blocks(title="TOTEM Studio", css=CSS, head=HEAD) as demo:
             </div>
             """)
 
+        # ── SMOKE SIGNAL TAB ─────────────────────────────────────────────────
+        smoke_signal_tab()
+
     # ── EVENT WIRING ─────────────────────────────────────────────────────────
 
     # Dashboard tab

smoke_signal_tab.py

@@ -0,0 +1,1325 @@
+"""
+Smoke Signal v1 — Gradio Tab Module
+=====================================
+Drop this file into your Codex_Extractor Space root.
+Then add to app.py:
+
+    from smoke_signal_tab import smoke_signal_tab, SS_CSS
+
+    # Add SS_CSS to your existing CSS string
+    # Add smoke_signal_tab() call inside your gr.Blocks() tabs
+
+Architecture:
+    Step 1: INGEST   — upload PDFs, register + hash
+    Step 2: PROFILE  — detect text vs image pages
+    Step 3: OCR      — Surya extraction + confidence scoring
+    Step 4: REVIEW   — human correction workbench (feeds training data)
+    Step 5: EXPORT   — clean JSONL to Codex + downloadable gold set
+
+Self-improvement loop:
+    Every correction → recalibrates confidence thresholds in real time
+    Every correction → appended to gold_corrections.jsonl for fine-tuning
+"""
+
+import csv
+import hashlib
+import json
+import os
+import tempfile
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+import pandas as pd
+
+# ── Paths ──────────────────────────────────────────────────────────────────────
+SS_ROOT      = Path(__file__).parent / "smoke_signal"
+SOURCE_DIR   = SS_ROOT / "source_pdfs"
+MANIFEST_CSV = SS_ROOT / "manifest" / "source_manifest.csv"
+PROFILES_DIR = SS_ROOT / "manifest" / "page_profiles"
+OCR_RAW_DIR  = SS_ROOT / "ocr_raw"
+RENDERS_DIR  = SS_ROOT / "renders"
+REGIONS_DIR  = SS_ROOT / "regions"
+REVIEW_DIR   = SS_ROOT / "review"
+EXPORTS_DIR  = SS_ROOT / "exports"
+GOLD_DIR     = SS_ROOT / "gold"
+LOGS_DIR     = SS_ROOT / "logs"
+
+for d in [SOURCE_DIR, MANIFEST_CSV.parent, PROFILES_DIR, OCR_RAW_DIR,
+          RENDERS_DIR, REGIONS_DIR, REVIEW_DIR, EXPORTS_DIR, GOLD_DIR, LOGS_DIR]:
+    d.mkdir(parents=True, exist_ok=True)
+
+GOLD_FILE    = GOLD_DIR / "gold_corrections.jsonl"
+DECISIONS_CSV = REVIEW_DIR / "review_decisions.csv"
+QUEUE_CSV    = REVIEW_DIR / "review_queue.csv"
+
+# ── Confidence calibration state (in-memory, persisted to disk) ────────────────
+CALIBRATION_FILE = SS_ROOT / "manifest" / "confidence_calibration.json"
+
+DEFAULT_CALIBRATION = {
+    "narration":               {"auto_accept": 0.85, "review": 0.60, "quarantine": 0.35, "corrections": 0},
+    "dialogue-speech-bubble":  {"auto_accept": 0.80, "review": 0.55, "quarantine": 0.30, "corrections": 0},
+    "caption":                 {"auto_accept": 0.82, "review": 0.58, "quarantine": 0.32, "corrections": 0},
+    "title":                   {"auto_accept": 0.88, "review": 0.65, "quarantine": 0.40, "corrections": 0},
+    "sign-label":              {"auto_accept": 0.75, "review": 0.50, "quarantine": 0.25, "corrections": 0},
+    "_default":                {"auto_accept": 0.85, "review": 0.60, "quarantine": 0.35, "corrections": 0},
+}
+
+def load_calibration() -> dict:
+    if CALIBRATION_FILE.exists():
+        try:
+            return json.load(open(CALIBRATION_FILE))
+        except Exception:
+            pass
+    return DEFAULT_CALIBRATION.copy()
+
+def save_calibration(cal: dict) -> None:
+    with open(CALIBRATION_FILE, "w") as f:
+        json.dump(cal, f, indent=2)
+
+def recalibrate(region_class: str, was_correct: bool, confidence: float) -> None:
+    """Tighten thresholds when corrections happen frequently for a region class."""
+    cal = load_calibration()
+    key = region_class if region_class in cal else "_default"
+    entry = cal[key]
+
+    if not was_correct:
+        entry["corrections"] = entry.get("corrections", 0) + 1
+        corrections = entry["corrections"]
+        # Every 5 corrections on same class: tighten auto-accept by 2%
+        if corrections % 5 == 0:
+            entry["auto_accept"] = min(0.98, entry["auto_accept"] + 0.02)
+            entry["review"]      = min(0.90, entry["review"] + 0.01)
+
+    cal[key] = entry
+    save_calibration(cal)
+
+
+# ── CSS ────────────────────────────────────────────────────────────────────────
+SS_CSS = """
+/* ── Smoke Signal palette ── */
+:root {
+    --ss-bg:       #0d1117;
+    --ss-surface:  #161b22;
+    --ss-border:   #30363d;
+    --ss-smoke:    #8b949e;
+    --ss-signal:   #f0883e;
+    --ss-glow:     #58a6ff;
+    --ss-green:    #3fb950;
+    --ss-red:      #f85149;
+    --ss-gold:     #e3b341;
+    --ss-text:     #e6edf3;
+    --ss-muted:    #7d8590;
+}
+
+/* Wizard step bar */
+.ss-wizard {
+    display: flex;
+    align-items: center;
+    gap: 0;
+    padding: 20px 28px 0;
+    background: var(--ss-bg);
+    border-bottom: 1px solid var(--ss-border);
+    overflow-x: auto;
+}
+
+.ss-step {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 14px 20px;
+    cursor: pointer;
+    border-bottom: 3px solid transparent;
+    transition: all 0.2s;
+    white-space: nowrap;
+    font-family: 'Source Code Pro', 'Courier New', monospace;
+    font-size: 12px;
+    font-weight: 600;
+    color: var(--ss-muted);
+    letter-spacing: 1px;
+    text-transform: uppercase;
+}
+
+.ss-step.active {
+    color: var(--ss-signal);
+    border-bottom-color: var(--ss-signal);
+}
+
+.ss-step.complete {
+    color: var(--ss-green);
+    border-bottom-color: var(--ss-green);
+}
+
+.ss-step.locked {
+    color: var(--ss-border);
+    cursor: not-allowed;
+}
+
+.ss-num {
+    width: 26px;
+    height: 26px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 11px;
+    font-weight: 900;
+    background: var(--ss-surface);
+    border: 2px solid currentColor;
+    flex-shrink: 0;
+}
+
+.ss-step.complete .ss-num {
+    background: var(--ss-green);
+    color: var(--ss-bg);
+    border-color: var(--ss-green);
+}
+
+.ss-connector {
+    width: 40px;
+    height: 2px;
+    background: var(--ss-border);
+    flex-shrink: 0;
+}
+
+/* Main panel */
+.ss-panel {
+    background: var(--ss-bg);
+    min-height: 600px;
+    padding: 28px;
+    font-family: 'Lato', sans-serif;
+    color: var(--ss-text);
+}
+
+.ss-panel-header {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 28px;
+    padding-bottom: 20px;
+    border-bottom: 1px solid var(--ss-border);
+}
+
+.ss-panel-icon {
+    font-size: 32px;
+    width: 56px;
+    height: 56px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--ss-surface);
+    border: 1px solid var(--ss-border);
+    border-radius: 10px;
+}
+
+.ss-panel-title {
+    font-family: 'Playfair Display', Georgia, serif;
+    font-size: 22px;
+    font-weight: 700;
+    color: var(--ss-text);
+    margin: 0;
+}
+
+.ss-panel-sub {
+    font-family: 'Source Code Pro', monospace;
+    font-size: 11px;
+    color: var(--ss-muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin: 4px 0 0;
+}
+
+/* Status pills */
+.ss-pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 12px;
+    border-radius: 999px;
+    font-size: 11px;
+    font-weight: 700;
+    font-family: 'Source Code Pro', monospace;
+    letter-spacing: 1px;
+    text-transform: uppercase;
+}
+
+.ss-pill-waiting  { background: #21262d; color: var(--ss-muted); border: 1px solid var(--ss-border); }
+.ss-pill-running  { background: #1c2a1e; color: var(--ss-gold); border: 1px solid var(--ss-gold); }
+.ss-pill-done     { background: #1a2f1a; color: var(--ss-green); border: 1px solid var(--ss-green); }
+.ss-pill-error    { background: #2d1a1a; color: var(--ss-red); border: 1px solid var(--ss-red); }
+.ss-pill-review   { background: #2a1f0e; color: var(--ss-signal); border: 1px solid var(--ss-signal); }
+
+/* Cards */
+.ss-card {
+    background: var(--ss-surface);
+    border: 1px solid var(--ss-border);
+    border-radius: 10px;
+    padding: 20px;
+    margin-bottom: 16px;
+}
+
+.ss-card-title {
+    font-size: 13px;
+    font-weight: 700;
+    color: var(--ss-smoke);
+    text-transform: uppercase;
+    letter-spacing: 2px;
+    margin-bottom: 12px;
+    font-family: 'Source Code Pro', monospace;
+}
+
+/* Metric row */
+.ss-metrics {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 12px;
+    margin-bottom: 20px;
+}
+
+.ss-metric {
+    background: var(--ss-surface);
+    border: 1px solid var(--ss-border);
+    border-radius: 8px;
+    padding: 16px;
+    text-align: center;
+}
+
+.ss-metric-val {
+    font-size: 28px;
+    font-weight: 900;
+    font-family: 'Source Code Pro', monospace;
+    color: var(--ss-text);
+    line-height: 1;
+}
+
+.ss-metric-label {
+    font-size: 10px;
+    color: var(--ss-muted);
+    text-transform: uppercase;
+    letter-spacing: 2px;
+    margin-top: 6px;
+}
+
+/* Progress bar */
+.ss-progress-wrap {
+    background: var(--ss-border);
+    border-radius: 4px;
+    height: 6px;
+    margin: 8px 0;
+    overflow: hidden;
+}
+
+.ss-progress-bar {
+    height: 6px;
+    border-radius: 4px;
+    background: linear-gradient(90deg, var(--ss-signal), var(--ss-gold));
+    transition: width 0.4s ease;
+}
+
+/* Review workbench */
+.ss-review-grid {
+    display: grid;
+    grid-template-columns: 240px 1fr 320px;
+    gap: 16px;
+    height: 580px;
+}
+
+.ss-queue-list {
+    background: var(--ss-surface);
+    border: 1px solid var(--ss-border);
+    border-radius: 8px;
+    overflow-y: auto;
+    padding: 8px;
+}
+
+.ss-queue-item {
+    padding: 10px 12px;
+    border-radius: 6px;
+    margin-bottom: 6px;
+    cursor: pointer;
+    border-left: 3px solid var(--ss-border);
+    font-size: 12px;
+    transition: all 0.15s;
+}
+
+.ss-queue-item:hover { background: #21262d; }
+.ss-queue-item.active { background: #1c2028; border-left-color: var(--ss-signal); }
+.ss-queue-item.done   { border-left-color: var(--ss-green); opacity: 0.7; }
+.ss-queue-item.quar   { border-left-color: var(--ss-red); }
+
+.ss-image-panel {
+    background: #010409;
+    border: 1px solid var(--ss-border);
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+}
+
+.ss-action-panel {
+    background: var(--ss-surface);
+    border: 1px solid var(--ss-border);
+    border-radius: 8px;
+    padding: 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    overflow-y: auto;
+}
+
+/* Buttons */
+.ss-btn-accept { background: var(--ss-green) !important; color: #010409 !important; font-weight: 800 !important; border-radius: 6px !important; }
+.ss-btn-edit   { background: var(--ss-signal) !important; color: #010409 !important; font-weight: 800 !important; border-radius: 6px !important; }
+.ss-btn-reject { background: var(--ss-red) !important; color: white !important; font-weight: 800 !important; border-radius: 6px !important; }
+.ss-btn-quar   { background: #21262d !important; color: var(--ss-gold) !important; font-weight: 800 !important; border-radius: 6px !important; border: 1px solid var(--ss-gold) !important; }
+.ss-btn-next   { background: var(--ss-glow) !important; color: #010409 !important; font-weight: 800 !important; border-radius: 6px !important; }
+.ss-btn-run    { background: linear-gradient(135deg, var(--ss-signal), var(--ss-gold)) !important; color: #010409 !important; font-weight: 900 !important; border-radius: 8px !important; font-size: 15px !important; min-height: 52px !important; }
+
+/* Training signal */
+.ss-training-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 6px 12px;
+    background: #1a2535;
+    border: 1px solid var(--ss-glow);
+    border-radius: 6px;
+    font-size: 11px;
+    color: var(--ss-glow);
+    font-family: 'Source Code Pro', monospace;
+}
+
+.ss-pulse {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--ss-glow);
+    animation: ss-pulse 1.5s infinite;
+}
+
+@keyframes ss-pulse {
+    0%, 100% { opacity: 1; transform: scale(1); }
+    50%       { opacity: 0.4; transform: scale(0.8); }
+}
+
+/* Log terminal */
+.ss-log {
+    background: #010409;
+    border: 1px solid var(--ss-border);
+    border-radius: 8px;
+    padding: 14px;
+    font-family: 'Source Code Pro', 'Courier New', monospace;
+    font-size: 12px;
+    color: #7ee787;
+    min-height: 120px;
+    max-height: 200px;
+    overflow-y: auto;
+    white-space: pre-wrap;
+}
+
+/* Gradio overrides for dark theme inside SS */
+#ss-tab .gradio-container { background: var(--ss-bg) !important; }
+#ss-tab textarea, #ss-tab input[type=text] {
+    background: var(--ss-surface) !important;
+    border: 1px solid var(--ss-border) !important;
+    color: var(--ss-text) !important;
+    border-radius: 6px !important;
+    font-family: 'Source Code Pro', monospace !important;
+    font-size: 13px !important;
+}
+#ss-tab .label-wrap span { color: var(--ss-smoke) !important; font-size: 11px !important; text-transform: uppercase !important; letter-spacing: 1px !important; }
+"""
+
+
+# ── Utility functions ──────────────────────────────────────────────────────────
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def load_manifest_df() -> pd.DataFrame:
+    if not MANIFEST_CSV.exists():
+        return pd.DataFrame(columns=[
+            "book_id","filename","sha256","page_count","rights_class",
+            "status","acquisition_date","notes"
+        ])
+    return pd.read_csv(MANIFEST_CSV)
+
+
+def save_manifest_df(df: pd.DataFrame) -> None:
+    df.to_csv(MANIFEST_CSV, index=False)
+
+
+def next_book_id(df: pd.DataFrame) -> str:
+    existing = set(df["book_id"].tolist()) if not df.empty else set()
+    for i in range(1, 10000):
+        bid = f"SS-BOOK-{i:04d}"
+        if bid not in existing:
+            return bid
+    return "SS-BOOK-9999"
+
+
+def load_queue_df() -> pd.DataFrame:
+    if not QUEUE_CSV.exists():
+        return pd.DataFrame()
+    return pd.read_csv(QUEUE_CSV)
+
+
+def load_decisions_df() -> pd.DataFrame:
+    if not DECISIONS_CSV.exists():
+        return pd.DataFrame()
+    return pd.read_csv(DECISIONS_CSV)
+
+
+def ts() -> str:
+    return datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+
+
+def log_line(msg: str) -> str:
+    return f"[{datetime.utcnow().strftime('%H:%M:%S')}] {msg}"
+
+
+# ── Step 1: INGEST ─────────────────────────────────────────────────────────────
+def ingest_pdfs(files, rights_class: str, notes: str) -> tuple:
+    """Register uploaded PDFs into the source manifest."""
+    if not files:
+        return _ingest_status_html("idle"), pd.DataFrame(), "No files uploaded."
+
+    df = load_manifest_df()
+    log  = []
+    new_count = 0
+    dup_count = 0
+
+    for file in files:
+        path = Path(file.name) if hasattr(file, "name") else Path(file)
+        if not path.exists():
+            log.append(log_line(f"⚠ File not found: {path.name}"))
+            continue
+
+        file_hash = sha256_file(path)
+
+        # Check duplicate
+        if not df.empty and file_hash in df["sha256"].values:
+            log.append(log_line(f"↩ Duplicate: {path.name}"))
+            dup_count += 1
+            continue
+
+        # Copy to source_pdfs
+        dest = SOURCE_DIR / path.name
+        import shutil
+        shutil.copy2(path, dest)
+
+        # Page count
+        page_count = None
+        try:
+            import fitz
+            doc = fitz.open(str(dest))
+            page_count = doc.page_count
+            doc.close()
+        except Exception:
+            pass
+
+        book_id = next_book_id(df)
+        new_row = pd.DataFrame([{
+            "book_id":          book_id,
+            "filename":         path.name,
+            "sha256":           file_hash,
+            "page_count":       page_count or "",
+            "rights_class":     rights_class,
+            "status":           "pending",
+            "acquisition_date": datetime.utcnow().date().isoformat(),
+            "notes":            notes,
+        }])
+        df = pd.concat([df, new_row], ignore_index=True)
+        log.append(log_line(f"✓ Registered {book_id} — {path.name} ({page_count or '?'} pages)"))
+        new_count += 1
+
+    save_manifest_df(df)
+
+    summary = f"Registered {new_count} new | {dup_count} duplicates skipped"
+    log.append(log_line(summary))
+
+    return _ingest_status_html("done", new_count, dup_count), df, "\n".join(log)
+
+
+def _ingest_status_html(state: str, new=0, dups=0) -> str:
+    df = load_manifest_df()
+    total = len(df)
+    pending = len(df[df["status"] == "pending"]) if not df.empty else 0
+    unknown = len(df[df["rights_class"] == "unknown"]) if not df.empty else 0
+
+    alert = ""
+    if unknown > 0:
+        alert = f'<div style="background:#2a1f0e;border:1px solid var(--ss-signal);border-radius:6px;padding:10px 14px;margin-top:12px;font-size:12px;color:var(--ss-signal)">⚠ {unknown} sources have unknown rights class — set before extraction</div>'
+
+    return f"""
+    <div class="ss-metrics">
+        <div class="ss-metric"><div class="ss-metric-val">{total}</div><div class="ss-metric-label">Total Sources</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-signal)">{pending}</div><div class="ss-metric-label">Pending</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-green)">{total - pending}</div><div class="ss-metric-label">Processed</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:{'var(--ss-red)' if unknown else 'var(--ss-green)'}">{unknown}</div><div class="ss-metric-label">Unknown Rights</div></div>
+    </div>{alert}"""
+
+
+# ── Step 2: PROFILE ────────────────────────────────────────────────────────────
+def run_profile() -> tuple:
+    """Profile all pending PDFs."""
+    df = load_manifest_df()
+    if df.empty:
+        return _profile_status_html(), "No sources registered. Complete Step 1 first."
+
+    pending = df[df["status"] == "pending"]
+    if pending.empty:
+        return _profile_status_html(), "No pending PDFs to profile."
+
+    log = []
+    try:
+        import fitz
+    except ImportError:
+        return _profile_status_html(), "PyMuPDF not installed. Run: pip install pymupdf"
+
+    for _, row in pending.iterrows():
+        book_id  = row["book_id"]
+        filename = row["filename"]
+        pdf_path = SOURCE_DIR / filename
+
+        if not pdf_path.exists():
+            log.append(log_line(f"✗ {book_id}: file not found"))
+            continue
+        if row.get("rights_class") in ("unknown", "excluded"):
+            log.append(log_line(f"↩ {book_id}: skipped — rights={row['rights_class']}"))
+            continue
+
+        try:
+            doc     = fitz.open(str(pdf_path))
+            pages   = []
+            routes  = {"embedded_text": 0, "ocr": 0, "hybrid": 0}
+
+            for i in range(doc.page_count):
+                page      = doc[i]
+                text      = page.get_text("text").strip()
+                has_text  = len(text) >= 20
+                has_imgs  = len(page.get_images(full=True)) > 0
+                route     = "embedded_text" if has_text and not has_imgs else \
+                            "hybrid" if has_text and has_imgs else "ocr"
+                routes[route] += 1
+                pages.append({
+                    "page_number": i + 1,
+                    "route": route,
+                    "char_count": len(text),
+                    "has_images": has_imgs,
+                    "width_pt": round(page.rect.width, 1),
+                    "height_pt": round(page.rect.height, 1),
+                    "rotation_deg": page.rotation,
+                    "is_spread": (page.rect.width / max(page.rect.height, 1)) >= 1.6,
+                    "warnings": [],
+                    "render_path": None,
+                    "render_dpi": None,
+                })
+            doc.close()
+
+            profile = {
+                "book_id": book_id, "filename": filename,
+                "source_hash": row["sha256"],
+                "page_count": len(pages),
+                "config_version": "ss_profiler_v0.1",
+                "profiled_at": datetime.utcnow().isoformat() + "Z",
+                "route_summary": routes,
+                "render_errors": [],
+                "pages": pages,
+            }
+            profile_path = PROFILES_DIR / f"{book_id}_page_profile.json"
+            with open(profile_path, "w") as f:
+                json.dump(profile, f, indent=2)
+
+            df.loc[df["book_id"] == book_id, "status"] = "profiled"
+            df.loc[df["book_id"] == book_id, "page_count"] = len(pages)
+            log.append(log_line(f"✓ {book_id}: {len(pages)}pp — embed={routes['embedded_text']} ocr={routes['ocr']} hybrid={routes['hybrid']}"))
+
+        except Exception as e:
+            log.append(log_line(f"✗ {book_id}: {e}"))
+
+    save_manifest_df(df)
+    return _profile_status_html(), "\n".join(log)
+
+
+def _profile_status_html() -> str:
+    df = load_manifest_df()
+    profiled = len(df[df["status"].isin(["profiled","rendered","ocred","reviewed","exported"])]) if not df.empty else 0
+    total    = len(df)
+    pct      = int(profiled / max(total, 1) * 100)
+
+    # Aggregate route stats from all profiles
+    embed = ocr = hybrid = 0
+    for p in PROFILES_DIR.glob("*_page_profile.json"):
+        try:
+            data = json.load(open(p))
+            rs   = data.get("route_summary", {})
+            embed  += rs.get("embedded_text", 0)
+            ocr    += rs.get("ocr", 0)
+            hybrid += rs.get("hybrid", 0)
+        except Exception:
+            pass
+
+    return f"""
+    <div class="ss-metrics">
+        <div class="ss-metric"><div class="ss-metric-val">{profiled}/{total}</div><div class="ss-metric-label">Profiled</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-green)">{embed}</div><div class="ss-metric-label">Embedded Text</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-signal)">{ocr}</div><div class="ss-metric-label">→ OCR</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-gold)">{hybrid}</div><div class="ss-metric-label">Hybrid</div></div>
+    </div>
+    <div class="ss-progress-wrap"><div class="ss-progress-bar" style="width:{pct}%"></div></div>
+    <div style="font-size:11px;color:var(--ss-muted);text-align:right;font-family:monospace">{pct}% profiled</div>"""
+
+
+# ── Step 3: OCR ────────────────────────────────────────────────────────────────
+def run_ocr() -> tuple:
+    """Run Surya OCR on all profiled PDFs."""
+    df = load_manifest_df()
+    if df.empty:
+        return _ocr_status_html(), "No sources. Complete Steps 1-2 first."
+
+    eligible = df[df["status"] == "profiled"]
+    if eligible.empty:
+        return _ocr_status_html(), "No profiled PDFs. Complete Step 2 first."
+
+    log = []
+
+    # Try to import Surya
+    surya = None
+    try:
+        from surya.ocr import run_ocr as surya_run
+        from surya.model.detection.model import load_model as load_det
+        from surya.model.detection.processor import load_processor as load_det_proc
+        from surya.model.recognition.model import load_model as load_rec
+        from surya.model.recognition.processor import load_processor as load_rec_proc
+        log.append(log_line("Loading Surya models (may take a moment)..."))
+        surya = {
+            "run": surya_run,
+            "det_model": load_det(), "det_proc": load_det_proc(),
+            "rec_model": load_rec(), "rec_proc": load_rec_proc(),
+        }
+        log.append(log_line("✓ Surya models loaded"))
+    except ImportError:
+        log.append(log_line("⚠ Surya not installed — falling back to text extraction only"))
+
+    queue_rows = []
+
+    for _, row in eligible.iterrows():
+        book_id  = row["book_id"]
+        profile_path = PROFILES_DIR / f"{book_id}_page_profile.json"
+        if not profile_path.exists():
+            log.append(log_line(f"✗ {book_id}: no profile"))
+            continue
+
+        profile  = json.load(open(profile_path))
+        ocr_pages = []
+        review_pages = []
+        quarantine_pages = []
+        cal = load_calibration()
+
+        for page_data in profile["pages"]:
+            page_num = page_data["page_number"]
+            route    = page_data["route"]
+
+            if route == "embedded_text":
+                # Extract directly via fitz
+                try:
+                    import fitz
+                    pdf_path = SOURCE_DIR / row["filename"]
+                    doc  = fitz.open(str(pdf_path))
+                    page = doc[page_num - 1]
+                    text = page.get_text("text").strip()
+                    doc.close()
+                    regions = [{"text": text, "confidence": 0.99, "bbox": [0,0,100,100], "word_count": len(text.split())}]
+                    conf    = 0.99
+                    method  = "embedded-text"
+                except Exception:
+                    regions = []
+                    conf    = 0.0
+                    method  = "error"
+            elif surya:
+                try:
+                    from PIL import Image
+                    import fitz
+                    pdf_path = SOURCE_DIR / row["filename"]
+                    doc  = fitz.open(str(pdf_path))
+                    page = doc[page_num - 1]
+                    mat  = fitz.Matrix(300/72, 300/72)
+                    pix  = page.get_pixmap(matrix=mat, alpha=False)
+
+                    # Save render
+                    render_dir = RENDERS_DIR / book_id
+                    render_dir.mkdir(exist_ok=True)
+                    render_path = render_dir / f"{book_id}_page_{page_num:04d}_300dpi.png"
+                    pix.save(str(render_path))
+                    doc.close()
+
+                    img = Image.open(render_path).convert("RGB")
+                    result = surya["run"]([img], [["en"]], surya["det_model"], surya["det_proc"], surya["rec_model"], surya["rec_proc"])
+                    page_result = result[0]
+
+                    regions = []
+                    for line in page_result.text_lines:
+                        txt = line.text.strip()
+                        if txt:
+                            c = float(line.confidence) if hasattr(line, "confidence") else 1.0
+                            regions.append({"text": txt, "confidence": round(c,4), "bbox": line.bbox, "word_count": len(txt.split())})
+
+                    conf = sum(r["confidence"]*r["word_count"] for r in regions) / max(sum(r["word_count"] for r in regions), 1) if regions else 0.0
+                    conf = round(conf, 4)
+                    method = "surya"
+
+                    # Update profile with render path
+                    page_data["render_path"] = str(render_path.relative_to(SS_ROOT))
+                    page_data["render_dpi"]  = 300
+
+                except Exception as e:
+                    log.append(log_line(f"  ⚠ Page {page_num}: {e}"))
+                    regions = []
+                    conf    = 0.0
+                    method  = "error"
+            else:
+                # No surya — skip OCR pages
+                regions = []
+                conf    = 0.0
+                method  = "skipped-no-surya"
+
+            # Classify confidence
+            default_cal = cal.get("_default", DEFAULT_CALIBRATION["_default"])
+            if conf >= default_cal["auto_accept"]:
+                conf_class = "auto-accept"
+            elif conf >= default_cal["review"]:
+                conf_class = "review-required"
+                review_pages.append(page_num)
+            elif conf >= default_cal["quarantine"]:
+                conf_class = "low-confidence"
+                review_pages.append(page_num)
+            else:
+                conf_class = "quarantine"
+                quarantine_pages.append(page_num)
+
+            ocr_pages.append({
+                "page_number": page_num,
+                "route": route,
+                "regions": regions,
+                "page_confidence": conf,
+                "confidence_class": conf_class,
+                "extraction_method": method,
+                "render_path": page_data.get("render_path"),
+                "ocred_at": datetime.utcnow().isoformat() + "Z",
+            })
+
+            # Add to review queue
+            if conf_class in ("review-required", "low-confidence", "quarantine"):
+                raw_text = " ".join(r["text"] for r in regions)[:500]
+                region_id = f"{book_id}_p{page_num:04d}"
+                queue_rows.append({
+                    "book_id": book_id, "filename": row["filename"],
+                    "page": page_num, "region_id": region_id,
+                    "region_class": "narration",
+                    "crop_path": page_data.get("render_path",""),
+                    "raw_ocr": raw_text,
+                    "confidence": conf, "confidence_class": conf_class,
+                    "status": "quarantine" if conf_class == "quarantine" else "pending",
+                    "reviewer": "", "correction": "", "reason_code": "",
+                })
+
+        # Save OCR raw
+        ocr_dir = OCR_RAW_DIR / book_id
+        ocr_dir.mkdir(exist_ok=True)
+        with open(ocr_dir / f"{book_id}_ocr_raw.json", "w") as f:
+            json.dump({
+                "book_id": book_id, "filename": row["filename"],
+                "source_hash": row["sha256"],
+                "page_count": len(ocr_pages),
+                "review_queue": review_pages,
+                "quarantine_list": quarantine_pages,
+                "pages": ocr_pages,
+            }, f, indent=2)
+
+        # Save updated profile (with render paths)
+        with open(profile_path, "w") as f:
+            json.dump(profile, f, indent=2)
+
+        df.loc[df["book_id"] == book_id, "status"] = "ocred"
+        total_review = len(review_pages) + len(quarantine_pages)
+        log.append(log_line(f"✓ {book_id}: {len(ocr_pages)}pp — review queue: {total_review}"))
+
+    # Write review queue
+    if queue_rows:
+        qdf = pd.DataFrame(queue_rows)
+        if QUEUE_CSV.exists():
+            existing = pd.read_csv(QUEUE_CSV)
+            qdf = pd.concat([existing, qdf], ignore_index=True).drop_duplicates(subset=["region_id"])
+        qdf.to_csv(QUEUE_CSV, index=False)
+
+    save_manifest_df(df)
+    return _ocr_status_html(), "\n".join(log)
+
+
+def _ocr_status_html() -> str:
+    q_df = load_queue_df()
+    d_df = load_decisions_df()
+    total_queue = len(q_df)
+    decided     = len(d_df)
+    pending     = total_queue - decided
+    auto        = len(q_df[q_df["confidence_class"] == "auto-accept"]) if not q_df.empty and "confidence_class" in q_df.columns else 0
+    quar        = len(q_df[q_df["confidence_class"] == "quarantine"]) if not q_df.empty and "confidence_class" in q_df.columns else 0
+
+    cal = load_calibration()
+    default = cal.get("_default", DEFAULT_CALIBRATION["_default"])
+    corrections = sum(v.get("corrections",0) for v in cal.values() if isinstance(v, dict))
+
+    training_badge = f'<div class="ss-training-badge"><div class="ss-pulse"></div>{corrections} corrections logged · thresholds auto={default["auto_accept"]:.0%} review={default["review"]:.0%}</div>'
+
+    return f"""
+    <div class="ss-metrics">
+        <div class="ss-metric"><div class="ss-metric-val">{total_queue}</div><div class="ss-metric-label">Review Queue</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-signal)">{pending}</div><div class="ss-metric-label">Pending</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-red)">{quar}</div><div class="ss-metric-label">Quarantined</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-green)">{decided}</div><div class="ss-metric-label">Decided</div></div>
+    </div>
+    <div style="margin-top:8px">{training_badge}</div>"""
+
+
+# ── Step 4: REVIEW ─────────────────────────────────────────────────────────────
+def get_review_item(idx: int) -> tuple:
+    q_df = load_queue_df()
+    d_df = load_decisions_df()
+    if q_df.empty:
+        return None, "", "", 0, 0
+
+    decided_ids = set(d_df["region_id"].tolist()) if not d_df.empty else set()
+    pending     = q_df[~q_df["region_id"].isin(decided_ids)]
+    if pending.empty:
+        return None, "All items reviewed!", "", len(q_df), len(q_df)
+
+    idx  = idx % len(pending)
+    item = pending.iloc[idx]
+
+    img_path = None
+    crop_path = item.get("crop_path","")
+    if crop_path:
+        candidate = SS_ROOT / crop_path
+        if candidate.exists():
+            img_path = str(candidate)
+
+    info = (f"<div style='font-family:monospace;font-size:11px;color:var(--ss-muted)'>"
+            f"{item['book_id']} · page {item['page']} · "
+            f"conf: <b style='color:{'var(--ss-red)' if float(item.get('confidence',0)) < 0.6 else 'var(--ss-gold)'}'>"
+            f"{float(item.get('confidence',0)):.0%}</b></div>")
+
+    return img_path, item.get("raw_ocr",""), info, len(q_df) - len(pending), len(q_df)
+
+
+def save_review_decision(idx: int, final_text: str, action: str, reviewer: str, reason: str) -> tuple:
+    q_df = load_queue_df()
+    d_df = load_decisions_df()
+    if q_df.empty:
+        return "No queue.", *get_review_item(idx)[1:]
+
+    decided_ids = set(d_df["region_id"].tolist()) if not d_df.empty else set()
+    pending     = q_df[~q_df["region_id"].isin(decided_ids)]
+    if pending.empty:
+        return "All done!", *get_review_item(0)[1:]
+
+    idx  = idx % len(pending)
+    item = pending.iloc[idx]
+
+    raw_text    = item.get("raw_ocr","")
+    was_correct = (final_text.strip() == raw_text.strip())
+    region_class = item.get("region_class","narration")
+
+    # Recalibrate confidence thresholds
+    recalibrate(region_class, was_correct, float(item.get("confidence",0)))
+
+    # Save decision
+    decision = {
+        "region_id":   item["region_id"],
+        "book_id":     item["book_id"],
+        "page":        item["page"],
+        "status":      action,
+        "final_text":  final_text,
+        "raw_text":    raw_text,
+        "reason_code": reason,
+        "reviewer":    reviewer or "reviewer",
+        "was_correct": was_correct,
+        "decided_at":  datetime.utcnow().isoformat() + "Z",
+    }
+
+    # Append to decisions CSV
+    new_row = pd.DataFrame([decision])
+    if DECISIONS_CSV.exists():
+        d_df = pd.concat([d_df, new_row], ignore_index=True)
+    else:
+        d_df = new_row
+    d_df.to_csv(DECISIONS_CSV, index=False)
+
+    # Append to gold training set
+    with open(GOLD_FILE, "a", encoding="utf-8") as f:
+        f.write(json.dumps({
+            **decision,
+            "region_class":  region_class,
+            "confidence":    float(item.get("confidence", 0)),
+            "conf_class":    item.get("confidence_class",""),
+        }) + "\n")
+
+    cal         = load_calibration()
+    default     = cal.get("_default", DEFAULT_CALIBRATION["_default"])
+    corrections = sum(v.get("corrections",0) for v in cal.values() if isinstance(v,dict))
+    gold_count  = sum(1 for _ in open(GOLD_FILE)) if GOLD_FILE.exists() else 0
+
+    feedback = (f"<div class='ss-training-badge'><div class='ss-pulse'></div>"
+                f"Gold set: {gold_count} examples · {corrections} corrections · "
+                f"auto-accept threshold: {default['auto_accept']:.0%}</div>")
+
+    return feedback, *get_review_item(0)
+
+
+def _review_status_html() -> str:
+    q_df = load_queue_df()
+    d_df = load_decisions_df()
+    total    = len(q_df)
+    decided  = len(d_df)
+    pending  = total - decided
+    accepted = len(d_df[d_df["status"] == "accepted"]) if not d_df.empty else 0
+    edited   = len(d_df[d_df["status"] == "edited"]) if not d_df.empty else 0
+    rejected = len(d_df[d_df["status"] == "rejected"]) if not d_df.empty else 0
+    gold_count = sum(1 for _ in open(GOLD_FILE)) if GOLD_FILE.exists() else 0
+    pct = int(decided / max(total, 1) * 100)
+
+    return f"""
+    <div class="ss-metrics">
+        <div class="ss-metric"><div class="ss-metric-val">{pending}</div><div class="ss-metric-label">Pending</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-green)">{accepted + edited}</div><div class="ss-metric-label">Approved</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-red)">{rejected}</div><div class="ss-metric-label">Rejected</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-glow)">{gold_count}</div><div class="ss-metric-label">Gold Examples</div></div>
+    </div>
+    <div class="ss-progress-wrap"><div class="ss-progress-bar" style="width:{pct}%"></div></div>"""
+
+
+# ── Step 5: EXPORT ─────────────────────────────────────────────────────────────
+def run_export() -> tuple:
+    """Export approved decisions to Codex JSONL + gold set."""
+    d_df = load_decisions_df()
+    q_df = load_queue_df()
+    df   = load_manifest_df()
+
+    if d_df.empty:
+        return _export_status_html(), "No review decisions. Complete Step 4 first.", None, None
+
+    approved = d_df[d_df["status"].isin(["accepted","edited"])]
+    if approved.empty:
+        return _export_status_html(), "No approved items to export.", None, None
+
+    log = []
+    records = []
+    batch   = ts()
+
+    for _, dec in approved.iterrows():
+        book_id = dec["book_id"]
+        manifest_row = df[df["book_id"] == book_id].iloc[0] if not df[df["book_id"] == book_id].empty else {}
+
+        records.append({
+            "book_id":          book_id,
+            "source_hash":      manifest_row.get("sha256","") if isinstance(manifest_row, pd.Series) else "",
+            "page_number":      dec["page"],
+            "region_id":        dec["region_id"],
+            "text_final":       dec["final_text"],
+            "text_raw":         dec.get("raw_text",""),
+            "review_status":    dec["status"],
+            "reviewer":         dec.get("reviewer",""),
+            "extraction_method": "ocr",
+            "export_batch":     batch,
+            "exported_at":      datetime.utcnow().isoformat() + "Z",
+        })
+
+    # Write Codex JSONL
+    jsonl_path = EXPORTS_DIR / f"codex_export_{batch}.jsonl"
+    with open(jsonl_path, "w", encoding="utf-8") as f:
+        for r in records:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    # Write gold set copy
+    gold_export = EXPORTS_DIR / f"gold_set_{batch}.jsonl"
+    if GOLD_FILE.exists():
+        import shutil
+        shutil.copy2(GOLD_FILE, gold_export)
+
+    log.append(log_line(f"✓ Exported {len(records)} approved records → {jsonl_path.name}"))
+    log.append(log_line(f"✓ Gold training set → {gold_export.name}"))
+    log.append(log_line(f"✓ Ready for Codex ingestion"))
+
+    return _export_status_html(len(records)), "\n".join(log), str(jsonl_path), str(gold_export)
+
+
+def _export_status_html(last_export=0) -> str:
+    exports = list(EXPORTS_DIR.glob("codex_export_*.jsonl"))
+    total_exports = len(exports)
+    gold_count = sum(1 for _ in open(GOLD_FILE)) if GOLD_FILE.exists() else 0
+    d_df = load_decisions_df()
+    approved = len(d_df[d_df["status"].isin(["accepted","edited"])]) if not d_df.empty else 0
+
+    return f"""
+    <div class="ss-metrics">
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-green)">{approved}</div><div class="ss-metric-label">Approved</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-signal)">{last_export or '—'}</div><div class="ss-metric-label">Last Export</div></div>
+        <div class="ss-metric"><div class="ss-metric-val">{total_exports}</div><div class="ss-metric-label">Export Batches</div></div>
+        <div class="ss-metric"><div class="ss-metric-val" style="color:var(--ss-glow)">{gold_count}</div><div class="ss-metric-label">Gold Examples</div></div>
+    </div>"""
+
+
+# ── Main tab builder ───────────────────────────────────────────────────────────
+def smoke_signal_tab():
+    """Call this inside your gr.Blocks() Tabs to add the Smoke Signal tab."""
+
+    with gr.TabItem("◈ Smoke Signal", elem_id="ss-tab"):
+
+        # ── Wizard header ────────────────────────────────────────────────────
+        gr.HTML("""
+        <div style="background:linear-gradient(135deg,#0d1117,#161b22);padding:24px 28px 0;border-bottom:1px solid #30363d">
+            <div style="display:flex;align-items:center;gap:16px;margin-bottom:20px">
+                <div style="font-size:38px;line-height:1">◈</div>
+                <div>
+                    <div style="font-family:'Playfair Display',Georgia,serif;font-size:26px;font-weight:900;color:#e6edf3;line-height:1">Smoke Signal</div>
+                    <div style="font-family:'Source Code Pro',monospace;font-size:10px;color:#7d8590;letter-spacing:3px;text-transform:uppercase;margin-top:4px">Picture-Book OCR · Extraction Pipeline · v1</div>
+                </div>
+            </div>
+            <div class="ss-wizard">
+                <div class="ss-step active"><span class="ss-num">1</span>INGEST</div>
+                <div class="ss-connector"></div>
+                <div class="ss-step"><span class="ss-num">2</span>PROFILE</div>
+                <div class="ss-connector"></div>
+                <div class="ss-step"><span class="ss-num">3</span>OCR</div>
+                <div class="ss-connector"></div>
+                <div class="ss-step"><span class="ss-num">4</span>REVIEW</div>
+                <div class="ss-connector"></div>
+                <div class="ss-step"><span class="ss-num">5</span>EXPORT</div>
+            </div>
+        </div>
+        """)
+
+        with gr.Tabs() as wizard:
+
+            # ── STEP 1: INGEST ────────────────────────────────────────────────
+            with gr.TabItem("① Ingest", id="ss-ingest"):
+                gr.HTML("""<div class="ss-panel-header" style="padding:20px 0 0 0">
+                    <div class="ss-panel-icon">📥</div>
+                    <div><p class="ss-panel-title">Source Registry</p>
+                    <p class="ss-panel-sub">Upload PDFs · Register · Hash · Rights class</p></div>
+                </div>""")
+
+                ingest_status = gr.HTML(_ingest_status_html("idle"))
+
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        pdf_upload = gr.File(
+                            label="Drop picture-book PDFs here",
+                            file_types=[".pdf"],
+                            file_count="multiple",
+                            type="filepath",
+                        )
+                    with gr.Column(scale=1):
+                        rights_dd = gr.Dropdown(
+                            label="Rights Class",
+                            choices=["public-domain","licensed-owned","controlled-internal","unknown"],
+                            value="unknown",
+                        )
+                        ingest_notes = gr.Textbox(label="Notes", placeholder="Source, edition, etc.", lines=2)
+                        ingest_btn = gr.Button("Register Sources →", elem_classes=["ss-btn-run"])
+
+                manifest_table = gr.DataFrame(
+                    label="Source Manifest",
+                    interactive=False,
+                    wrap=True,
+                )
+                ingest_log = gr.Textbox(label="Log", lines=6, interactive=False, elem_classes=["ss-log"])
+
+                ingest_btn.click(
+                    ingest_pdfs,
+                    inputs=[pdf_upload, rights_dd, ingest_notes],
+                    outputs=[ingest_status, manifest_table, ingest_log],
+                )
+                gr.HTML('<div style="height:16px"></div>')
+                wizard.load(lambda: (load_manifest_df(),), outputs=[manifest_table])
+
+            # ── STEP 2: PROFILE ───────────────────────────────────────────────
+            with gr.TabItem("② Profile", id="ss-profile"):
+                gr.HTML("""<div class="ss-panel-header" style="padding:20px 0 0 0">
+                    <div class="ss-panel-icon">🔍</div>
+                    <div><p class="ss-panel-title">PDF Profiler</p>
+                    <p class="ss-panel-sub">Detect embedded text vs image pages · Route to extraction path</p></div>
+                </div>""")
+
+                profile_status = gr.HTML(_profile_status_html())
+                profile_btn    = gr.Button("Run Profiler →", elem_classes=["ss-btn-run"])
+                profile_log    = gr.Textbox(label="Log", lines=10, interactive=False, elem_classes=["ss-log"])
+
+                profile_btn.click(run_profile, outputs=[profile_status, profile_log])
+
+            # ── STEP 3: OCR ───────────────────────────────────────────────────
+            with gr.TabItem("③ OCR", id="ss-ocr"):
+                gr.HTML("""<div class="ss-panel-header" style="padding:20px 0 0 0">
+                    <div class="ss-panel-icon">👁</div>
+                    <div><p class="ss-panel-title">OCR Engine</p>
+                    <p class="ss-panel-sub">Surya layout + recognition · Confidence scoring · Review queue</p></div>
+                </div>""")
+
+                ocr_status = gr.HTML(_ocr_status_html())
+
+                gr.HTML("""<div class="ss-card">
+                    <div class="ss-card-title">Self-Improvement Loop</div>
+                    <div style="font-size:13px;color:#8b949e;line-height:1.6">
+                    Every correction you make in Step 4 is logged to the gold training set and recalibrates
+                    the confidence thresholds for that region class in real time. The more you review,
+                    the smarter the pipeline gets — without retraining.
+                    </div>
+                </div>""")
+
+                ocr_btn = gr.Button("Run OCR →", elem_classes=["ss-btn-run"])
+                ocr_log = gr.Textbox(label="Log", lines=10, interactive=False, elem_classes=["ss-log"])
+
+                ocr_btn.click(run_ocr, outputs=[ocr_status, ocr_log])
+
+            # ── STEP 4: REVIEW ────────────────────────────────────────────────
+            with gr.TabItem("④ Review", id="ss-review"):
+                gr.HTML("""<div class="ss-panel-header" style="padding:20px 0 0 0">
+                    <div class="ss-panel-icon">✎</div>
+                    <div><p class="ss-panel-title">Review Workbench</p>
+                    <p class="ss-panel-sub">Correct · Accept · Reject · Build gold training set</p></div>
+                </div>""")
+
+                review_status = gr.HTML(_review_status_html())
+                training_feedback = gr.HTML()
+
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        review_image = gr.Image(
+                            label="Page Render",
+                            type="filepath",
+                            height=420,
+                            show_download_button=False,
+                        )
+                        item_info = gr.HTML()
+
+                    with gr.Column(scale=2):
+                        raw_text_box = gr.Textbox(
+                            label="Raw OCR",
+                            lines=6,
+                            interactive=False,
+                        )
+                        final_text_box = gr.Textbox(
+                            label="Final Text (edit to correct)",
+                            lines=8,
+                            interactive=True,
+                        )
+                        reviewer_name = gr.Textbox(label="Your name", placeholder="e.g. jamal", scale=1)
+                        reason_code   = gr.Dropdown(
+                            label="Reason code",
+                            choices=["","OCR_MISS","OCR_WRONG_WORD","DECORATIVE_FONT",
+                                     "SPEECH_BUBBLE_ERROR","LOW_CONTRAST","SCAN_SKEW_BLUR",
+                                     "NON_STORY_TEXT","LLM_OVER_CORRECTION","OTHER"],
+                            value="",
+                        )
+
+                        with gr.Row():
+                            accept_btn = gr.Button("✓ Accept", elem_classes=["ss-btn-accept"])
+                            edit_btn   = gr.Button("✎ Save Edit", elem_classes=["ss-btn-edit"])
+                        with gr.Row():
+                            reject_btn = gr.Button("✗ Reject", elem_classes=["ss-btn-reject"])
+                            quar_btn   = gr.Button("⚑ Quarantine", elem_classes=["ss-btn-quar"])
+                        next_btn = gr.Button("Next Item →", elem_classes=["ss-btn-next"])
+
+                current_idx = gr.State(0)
+
+                review_outputs = [training_feedback, review_image, raw_text_box, item_info,
+                                  gr.State(), gr.State()]
+
+                def load_review():
+                    img, raw, info, done, total = get_review_item(0)
+                    status = _review_status_html()
+                    return status, img, raw, raw, info
+
+                def next_item(idx):
+                    new_idx = idx + 1
+                    img, raw, info, done, total = get_review_item(new_idx)
+                    return new_idx, img, raw, raw, info
+
+                def do_accept(idx, final, reviewer, reason):
+                    action = "edited" if final.strip() != "" else "accepted"
+                    fb, img, raw, info, _, _ = save_review_decision(idx, final, action, reviewer, reason)
+                    status = _review_status_html()
+                    new_idx = idx + 1
+                    img2, raw2, info2, _, _ = get_review_item(new_idx)
+                    return fb, status, new_idx, img2, raw2, raw2, info2
+
+                def do_reject(idx, final, reviewer, reason):
+                    fb, img, raw, info, _, _ = save_review_decision(idx, final, "rejected", reviewer, reason)
+                    status = _review_status_html()
+                    new_idx = idx + 1
+                    img2, raw2, info2, _, _ = get_review_item(new_idx)
+                    return fb, status, new_idx, img2, raw2, raw2, info2
+
+                def do_quarantine(idx, final, reviewer, reason):
+                    fb, img, raw, info, _, _ = save_review_decision(idx, final, "quarantined", reviewer, reason)
+                    status = _review_status_html()
+                    new_idx = idx + 1
+                    img2, raw2, info2, _, _ = get_review_item(new_idx)
+                    return fb, status, new_idx, img2, raw2, raw2, info2
+
+                action_outputs = [training_feedback, review_status, current_idx,
+                                  review_image, raw_text_box, final_text_box, item_info]
+
+                accept_btn.click(do_accept, inputs=[current_idx, final_text_box, reviewer_name, reason_code], outputs=action_outputs)
+                edit_btn.click(do_accept, inputs=[current_idx, final_text_box, reviewer_name, reason_code], outputs=action_outputs)
+                reject_btn.click(do_reject, inputs=[current_idx, final_text_box, reviewer_name, reason_code], outputs=action_outputs)
+                quar_btn.click(do_quarantine, inputs=[current_idx, final_text_box, reviewer_name, reason_code], outputs=action_outputs)
+
+                def _next(idx):
+                    new_idx = idx + 1
+                    img, raw, info, _, _ = get_review_item(new_idx)
+                    return new_idx, img, raw, raw, info
+
+                next_btn.click(_next, inputs=[current_idx],
+                               outputs=[current_idx, review_image, raw_text_box, final_text_box, item_info])
+
+                wizard.load(load_review, outputs=[review_status, review_image, raw_text_box, final_text_box, item_info])
+
+            # ── STEP 5: EXPORT ────────────────────────────────────────────────
+            with gr.TabItem("⑤ Export", id="ss-export"):
+                gr.HTML("""<div class="ss-panel-header" style="padding:20px 0 0 0">
+                    <div class="ss-panel-icon">⬇</div>
+                    <div><p class="ss-panel-title">Codex Export</p>
+                    <p class="ss-panel-sub">Clean JSONL · Gold training set · Auto-feed Codex</p></div>
+                </div>""")
+
+                export_status = gr.HTML(_export_status_html())
+
+                gr.HTML("""<div class="ss-card">
+                    <div class="ss-card-title">What gets exported</div>
+                    <div style="font-size:13px;color:#8b949e;line-height:1.8">
+                    <b style="color:#e6edf3">codex_export_[batch].jsonl</b> — all accepted/edited text with full provenance,
+                    ready for Codex fingerprint analysis.<br>
+                    <b style="color:#e6edf3">gold_set_[batch].jsonl</b> — your labelled corrections for future Surya fine-tuning.
+                    The more you correct, the better your next training run will be.
+                    </div>
+                </div>""")
+
+                export_btn  = gr.Button("Export to Codex →", elem_classes=["ss-btn-run"])
+                export_log  = gr.Textbox(label="Export log", lines=6, interactive=False, elem_classes=["ss-log"])
+
+                with gr.Row():
+                    codex_download = gr.File(label="Codex JSONL", interactive=False)
+                    gold_download  = gr.File(label="Gold Training Set", interactive=False)
+
+                export_btn.click(
+                    run_export,
+                    outputs=[export_status, export_log, codex_download, gold_download],
+                )