Importer overhaul: two-pathway Codex parser, HF auth, timestamps, Greatest Hits

- ingest.py: Replace parse_codex() with parse_codex_submission() implementing
Pathway Alpha (3:2:1 standard baseline, input = output × 2.0) and
Pathway Beta (Claude 1:9 closed-loop, input = output / 9.0).
Returns calibrated_user_input + structural_context_debt.

- app.py: Rename tab to 'Clock Your Signal'. Fix CLI instructions to show
all ccusage providers (claude/codex/combined). Fix paste format and examples.
Add HF LoginButton (Space-only, graceful local fallback). Wire HF auth
into run_ingest — only authenticated users get persisted board entries.
Add Greatest Hits section showing top sessions by Υ.

- db.py: Add submitted_at timestamp to save_operator(). Gate saves on
hf_user (no HF login = no persistence). Add sigrank_sessions table
for session history. Add load_session_history() for Greatest Hits.

- theme.py: CSS for parsing mode badge, estimation asterisk, Greatest
Hits table, HF login button.

- sigrank.py: Use parse_codex_submission with operator_profile detection
(Claude profile → Beta pathway, else Alpha).

- requirements.txt: gradio[oauth] for HF LoginButton.

metrics.py and SEED numbers are untouched.

Co-Authored-By: Deric J. McHenry <deric.mchenry@gmail.com>

app.py

@@ -7,6 +7,7 @@ import gradio as gr
 import html as _html
 import math as _math
 import re as _re
+from datetime import datetime, timezone
 from metrics import compute, SEED
 from ingest import ingest_meta
 from theme import CSS
@@ -68,7 +69,7 @@ def board_html(extra=None):
         else:
             cls = f"mb-row rarity-{rkey}"
         ne = _html.escape(n)
-        est_mark = " <span class='mb-est' title='estimated (Codex anchor)'>~</span>" if m.get("cost_estimated") else ""
+        est_mark = " <span class='mb-est' title='* structural estimation'>*</span>" if m.get("cost_estimated") else ""
         out.append(f'<div class="{cls}">'
             f'<span class="mb-rank {rank_cls}">{i}</span>'
             f'<span class="mb-op"><b>{ne}{est_mark}</b><br><span class="mb-raw">R {_fmt_int(m["raw"]["cache_read"])} \u00b7 C {_fmt_int(m["raw"]["cache_create"])} \u00b7 I {_fmt_int(m["raw"]["input"])} \u00b7 O {_fmt_int(m["raw"]["output"])}</span></span>'
@@ -81,7 +82,7 @@ def board_html(extra=None):
             f'<span class="mb-yval">{y:,.0f}</span></span>'
             f'</div>')
     out.append('</div>')
-    out.append('<div class="mb-foot">\u03a5 bar is log-scaled \u00b7 MO\u00a7ES leads the field by ~4 orders of magnitude \u00b7 $/1M blended cost (~ = list-price estimate) \u00b7 volume can\'t buy rank</div>')
+    out.append('<div class="mb-foot">\u03a5 bar is log-scaled \u00b7 MO\u00a7ES leads the field by ~4 orders of magnitude \u00b7 $/1M blended cost (~ = list-price estimate) \u00b7 * = structural estimation \u00b7 volume can\'t buy rank</div>')
     return "".join(out)
 
 # ---------- profile ----------
@@ -142,6 +143,9 @@ def card_html(name, m, rank, total_ops, narration_text):
     archetype = classify(m).split("\u00b7")[0].strip()
     rkey, rlabel, passive, effect = rarity_class(m)
     c = m["composition"]
+    parsing_mode = m.get("_parsing_mode", "")
+    mode_badge = (f'<div class="sig-card-mode">* {_html.escape(parsing_mode)}</div>'
+                  if parsing_mode else "")
     if m["transmission"] is not None:
         cascade = (
             f'<div class="sig-card-cascade-box">{m["transmission"]:.1f}\u00d7<small>trans</small></div>'
@@ -163,6 +167,7 @@ def card_html(name, m, rank, total_ops, narration_text):
         f'<div class="sig-card-archetype">{archetype}</div>'
         f'<div class="sig-card-passive">Passive: {passive}</div>'
         f'<div class="sig-card-effect">{effect}</div>'
+        f'{mode_badge}'
         f'<div class="sig-card-yield">{m["yield"]:,.0f}</div>'
         '<div class="sig-card-yield-label">net volumetric yield</div>'
         f'<div class="sig-card-rank">#<span>{rank}</span> of {total_ops} operators</div>'
@@ -181,8 +186,10 @@ def profile_md(name, m, rank, total_ops, read=None):
     cav = m.get("_caveat")
     cav_line = f"\n\n`\u26a0 {cav}`" if cav else ""
     cost_note = " (list-price estimate)" if m.get("cost_estimated") else " (from ccusage)"
+    mode = m.get("_parsing_mode")
+    mode_line = f"\n\n`* {mode}`" if mode else ""
     return f"""## OPERATOR \u00b7 {name}
-ranked **#{rank}** of {total_ops} by \u03a5{cav_line}
+ranked **#{rank}** of {total_ops} by \u03a5{cav_line}{mode_line}
 
 > {read}
 
@@ -207,97 +214,172 @@ ranked **#{rank}** of {total_ops} by \u03a5{cav_line}
 | Avg $/1M | ${m['avg_cost_1m']:.3f} |{cost_note} |
 | **\u03a5 Yield** | **{m['yield']:,.2f}** | un-gameable rank |
 
-**cascade** — {m['cascade_str']} (transmission \u00d7 commitment \u00d7 reuse)
-**scale V** — {m['V']:.2f}
+**cascade** \u2014 {m['cascade_str']} (transmission \u00d7 commitment \u00d7 reuse)
+**scale V** \u2014 {m['V']:.2f}
 """
 
+def _greatest_hits_html(name):
+    """Render top sessions for this operator from session history."""
+    history = db.load_session_history(name, limit=5)
+    if not history:
+        return ""
+    rows = []
+    for h in history:
+        i = int(h.get("input", 0) or 0)
+        o = int(h.get("output", 0) or 0)
+        cw = int(h.get("cache_create", 0) or 0)
+        cr = int(h.get("cache_read", 0) or 0)
+        m = compute(i, o, cw, cr)
+        ts = h.get("submitted_at", "")
+        if ts:
+            try:
+                dt = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                ts = dt.strftime("%Y-%m-%d %H:%M UTC")
+            except (ValueError, TypeError):
+                pass
+        src = h.get("source", "")
+        rows.append(
+            f'<tr><td>{ts}</td><td>{_fmt_int(m["yield"])}</td>'
+            f'<td>{m["velocity"]:.2f}\u00d7</td><td>{m["leverage"]:,.0f}\u00d7</td>'
+            f'<td>{src}</td></tr>'
+        )
+    return (
+        '<div class="greatest-hits">'
+        '<h4>Greatest Hits</h4>'
+        '<table><thead><tr><th>when</th><th>\u03a5</th><th>vel</th><th>lev</th><th>source</th></tr></thead>'
+        '<tbody>' + "".join(rows) + '</tbody></table>'
+        '</div>'
+    )
+
 # ---------- ingestion handler ----------
-def run_ingest(blob, name):
+def run_ingest(blob, name, request: gr.Request):
+    hf_user = None
+    if request:
+        hf_user = getattr(request, "username", None)
     name=(name or "you").strip()[:24] or "you"
     try:
         i,o,cw,cr,meta = ingest_meta(blob or "")
     except Exception as e:
-        return ("Paste your `npx ccusage@latest --json` output, your "
-                "`ccusage codex --json` output, or four numbers: "
+        return ("Paste your `ccusage claude --json` output, your "
+                "`ccusage codex --json` output, or `ccusage --json` "
+                "for all providers. You can also paste four numbers: "
                 "input output cache_create cache_read.\n\n"
-                f"_parser said: {e}_"), "", "", board_html()
+                f"_parser said: {e}_"), "", "", "", board_html()
     if i+o+cw+cr==0:
-        return "Got zeros — check your paste.", "", "", board_html()
+        return "Got zeros \u2014 check your paste.", "", "", "", board_html()
     m=compute(i,o,cw,cr, cost_usd=meta.get("cost"))
     if meta.get("estimated"):
         m["_caveat"]=meta.get("caveat")
-    # persist only if writes are configured (curated demo leaves them off -> transient)
+    if meta.get("parsing_mode"):
+        m["_parsing_mode"] = meta["parsing_mode"]
+    # persist only if HF-authenticated + writes configured
     saved=False
-    if db.writes_enabled():
+    if hf_user and db.writes_enabled():
         saved=db.save_operator(name,i,o,cw,cr, cost=meta.get("cost"),
                                source=meta.get("source","manual"),
                                estimated=bool(meta.get("estimated")),
-                               caveat=meta.get("caveat"))
-    base=operators(force=saved)   # refresh cache only if a row was actually written
+                               caveat=meta.get("caveat"),
+                               hf_user=hf_user)
+    base=operators(force=saved)
     rows=[(nn,compute(*vv)) for nn,vv in base.items() if nn!=name]+[(name,m)]
     rows.sort(key=lambda r:r[1]['yield'],reverse=True)
     rank=next(idx for idx,(nn,_) in enumerate(rows,1) if nn==name)
     read = narrate(name, m, classify(m))
-    return (profile_md(name,m,rank,len(rows),read),
+
+    save_note = ""
+    if not hf_user:
+        save_note = "\n\n*\u26a0 Sign in with HuggingFace to save your entry to the board. Paste-only results are a snapshot \u2014 not persisted.*"
+    elif saved:
+        save_note = f"\n\n*Saved to the board as **{_html.escape(name)}** at {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')}.*"
+
+    hits_html = _greatest_hits_html(name) if hf_user else ""
+    profile = profile_md(name,m,rank,len(rows),read) + save_note
+
+    return (profile,
             comp_bar_html(m["composition"]),
             card_html(name,m,rank,len(rows),read),
+            hits_html,
             board_html((name,m)))
 
 # ---------- UI ----------
-_blocks_kw = {"title": "MO\u00a7ES SigRank"}
-try:
-    _b = gr.Blocks(css=CSS, theme=gr.themes.Base(), **_blocks_kw)
-except TypeError:
-    _b = gr.Blocks(**_blocks_kw)
-with _b as demo:
-    with gr.Column(elem_id="moses-hero"):
-        gr.HTML("<h1>MO§ES\u2122 SigRank</h1>"
-                "<p>the diagnostic x-ray of the token economy \u00b7 ranked by \u03a5 (Net Volumetric Yield) \u00b7 volume can't buy rank</p>")
-        gr.HTML('<div id="moses-stat-strip">'
-                '<div>operators ranked <span>7</span></div>'
-                '<div>MO§ES leads by <span>3,141\u00d7</span></div>'
-                '<div>architecture beats budget</div>'
-                '</div>')
+import os as _os
+_ON_SPACE = bool(_os.environ.get("SPACE_ID"))
 
-    with gr.Tab("Leaderboard"):
-        gr.Markdown("Ranked by **Υ = (Cache·Output)/Input²**. Raw Read·Create·In·Out stacked under each operator. $/1M is blended cost — efficient architecture is also the cheapest.")
-        gr.Markdown("*Corpus is curated — pasting your usage scores you live against the field but doesn't add you to the persisted board. $/1M is a list-price recompute (~); real cost shows when you paste your own ccusage.*", elem_id="moses-foot")
-        lb = gr.HTML(board_html())
+def _build_demo():
+    _blocks_kw = {"title": "MO\u00a7ES SigRank"}
+    try:
+        _b = gr.Blocks(css=CSS, theme=gr.themes.Base(), **_blocks_kw)
+    except TypeError:
+        _b = gr.Blocks(**_blocks_kw)
+    with _b:
+        with gr.Column(elem_id="moses-hero"):
+            gr.HTML("<h1>MO\u00a7ES\u2122 SigRank</h1>"
+                    "<p>the diagnostic x-ray of the token economy \u00b7 ranked by \u03a5 (Net Volumetric Yield) \u00b7 volume can't buy rank</p>")
+            gr.HTML('<div id="moses-stat-strip">'
+                    '<div>operators ranked <span>7</span></div>'
+                    '<div>MO\u00a7ES leads by <span>3,141\u00d7</span></div>'
+                    '<div>architecture beats budget</div>'
+                    '</div>')
 
-    with gr.Tab("Measure yourself"):
-        gr.Markdown("""**Get your operator profile — automatic, no paste.**
+        with gr.Tab("Leaderboard"):
+            gr.Markdown("Ranked by **\u03a5 = (Cache\u00b7Output)/Input\u00b2**. Raw Read\u00b7Create\u00b7In\u00b7Out stacked under each operator. $/1M is blended cost \u2014 efficient architecture is also the cheapest.")
+            gr.Markdown("*Corpus is curated \u2014 pasting your usage scores you live against the field but doesn't add you to the persisted board unless you're signed in via HuggingFace. $/1M is a list-price recompute (~); real cost shows when you paste your own ccusage. * = structural estimation.*", elem_id="moses-foot")
+            gr.HTML(board_html())
 
-**① Run the local importer** (reads your usage on your machine, 100% local):
+        with gr.Tab("Clock Your Signal"):
+            gr.Markdown("""**Get your operator profile \u2014 every provider, one command.**
+
+**\u2460 Run ccusage** (reads your local usage \u2014 one command per provider):
+```
+ccusage claude --json       # Claude Code stats
+ccusage codex --json        # Codex stats (estimated *)
+ccusage --json              # ALL providers combined
 ```
-./sigrank
+Or use the local importer:
 ```
-(or `python3 sigrank.py`). It auto-runs `ccusage`, computes your profile + Υ, and prints your board rank. No paste, no upload, no token.
+./sigrank                   # Claude Code (measured)
+./sigrank --codex           # Codex (applies field anchor *)
+```
+
+**\u2461 Paste the JSON below.** Drop your `ccusage` output \u2014 Claude, Codex, or combined \u2014 and we'll route it automatically. Or paste four numbers: `input output cache_create cache_read`.
 
-**② Paste — the backup.** No importer handy? Run `npx ccusage@latest --json` (Claude Code) or `ccusage codex --json` (Codex) and drop it below, or just four numbers (input, output, cache_create, cache_read).
-*Codex note: combined input is split via the 2:1 field anchor; estimated rows are flagged.*""")
-        nm = gr.Textbox(label="operator name", placeholder="your handle", max_lines=1)
-        blob = gr.Textbox(label="ccusage / codex JSON  —or—  four numbers", lines=6,
-                          placeholder='{"totals":{"inputTokens":...}}   or   1251211 11296121 128196310 2555179769')
-        go = gr.Button("Compute my SigRank", variant="primary", elem_id="compute-btn")
-        prof = gr.Markdown(elem_id="moses-profile")
-        prof_bar = gr.HTML()
-        gr.Markdown("### share card")
-        card = gr.HTML()
-        gr.Markdown("*Screenshot to share \u00b7 right-click \u2192 Save image*", elem_id="moses-foot")
-        gr.Markdown("### your placement")
-        gr.Markdown("*Live placement against the curated field — your row is transient (not saved to the board).*", elem_id="moses-foot")
-        ob = gr.HTML(board_html())
-        go.click(run_ingest, [blob, nm], [prof, prof_bar, card, ob])
-        gr.Examples(
-            examples=[
-                ['{"totals":{"inputTokens":1251211,"outputTokens":11296121,"cacheCreationTokens":128196310,"cacheReadTokens":2555179769}}','MO§ES'],
-                ['{"data":[{"input_tokens":145809,"cached_input_tokens":112512,"output_tokens":2094,"reasoning_output_tokens":710}]}','codex-operator'],
-            ],
-            inputs=[blob, nm])
+*Codex / non-Claude providers: input is calibrated via the 3:2:1 field anchor (or 1:9 if you have a Claude profile). Estimated rows are flagged with \\*.*
 
-    gr.Markdown(elem_id="moses-foot", value="""Four integers in, full ledger out. 
+**\u2462 Sign in to save.** HuggingFace users get one persistent board entry + session history. Paste without login = snapshot only.""")
+            if _ON_SPACE:
+                gr.LoginButton(elem_id="hf-login-btn")
+            else:
+                gr.Markdown("*HuggingFace login available on the hosted Space \u2014 local mode is transient.*", elem_id="moses-foot")
+            nm = gr.Textbox(label="operator name", placeholder="your handle", max_lines=1)
+            blob = gr.Textbox(label="ccusage JSON (any provider) \u2014or\u2014 four numbers (I O C R)", lines=6,
+                              placeholder='Paste ccusage claude/codex/combined --json output here\n\nor four numbers: input output cache_create cache_read\n\nExample: 1251211 11296121 128196310 2555179769')
+            go = gr.Button("Clock My Signal", variant="primary", elem_id="compute-btn")
+            prof = gr.Markdown(elem_id="moses-profile")
+            prof_bar = gr.HTML()
+            gr.Markdown("### share card")
+            card = gr.HTML()
+            gr.Markdown("*Screenshot to share \u00b7 right-click \u2192 Save image*", elem_id="moses-foot")
+            gr.Markdown("### greatest hits")
+            hits = gr.HTML()
+            gr.Markdown("*Top sessions by \u03a5 \u2014 sign in with HuggingFace to track your history.*", elem_id="moses-foot")
+            gr.Markdown("### your placement")
+            gr.Markdown("*Live placement against the curated field \u2014 sign in to persist your entry.*", elem_id="moses-foot")
+            ob = gr.HTML(board_html())
+            go.click(run_ingest, [blob, nm], [prof, prof_bar, card, hits, ob])
+            gr.Examples(
+                examples=[
+                    ['{"totals":{"inputTokens":1251211,"outputTokens":11296121,"cacheCreationTokens":128196310,"cacheReadTokens":2555179769}}','MO\u00a7ES'],
+                    ['{"data":[{"inputTokens":58920000,"cachedInputTokens":707300000,"outputTokens":3500000,"reasoningOutputTokens":510000}]}','codex-operator'],
+                    ['1251211 11296121 128196310 2555179769', 'manual-paste'],
+                ],
+                inputs=[blob, nm])
+
+        gr.Markdown(elem_id="moses-foot", value="""Four integers in, full ledger out. 
 Architecture is the only variable that matters. 
-Wild-corpus values provisional · MO§ES row verified ccusage · [How it works ↗](#)""")
+Wild-corpus values provisional \u00b7 MO\u00a7ES row verified ccusage \u00b7 * = structural estimation \u00b7 [How it works \u2197](#)""")
+    return _b
+
+demo = _build_demo()
 
 if __name__ == "__main__":
     try:

db.py

@@ -15,11 +15,13 @@ Curated mode (A):
 cleanly even where requests isn't installed (it just falls back to SEED).
 """
 import os
+from datetime import datetime, timezone
 
 _URL     = os.environ.get("SUPABASE_URL", "").rstrip("/")
 _ANON    = os.environ.get("SUPABASE_ANON_KEY", "")
 _SERVICE = os.environ.get("SUPABASE_SERVICE_KEY", "")
 _TABLE   = "sigrank_operators"
+_HIST_TABLE = "sigrank_sessions"
 _TIMEOUT = 6
 
 
@@ -69,12 +71,16 @@ def load_operators():
 
 
 def save_operator(name, i, o, cw, cr, cost=None, source="manual",
-                  estimated=False, caveat=None):
+                  estimated=False, caveat=None, hf_user=None):
     """Upsert one operator via the service key (PostgREST merge-duplicates on
     `name`). No-op returning False unless SUPABASE_SERVICE_KEY is set. Never
-    raises — failures are swallowed and logged so ingestion can't crash."""
+    raises — failures are swallowed and logged so ingestion can't crash.
+    hf_user: HuggingFace username — only authenticated users get persisted."""
     if not writes_enabled():
         return False
+    if not hf_user:
+        return False
+    now = datetime.now(timezone.utc).isoformat()
     try:
         import requests
         payload = {
@@ -83,6 +89,8 @@ def save_operator(name, i, o, cw, cr, cost=None, source="manual",
             "cache_create": int(cw), "cache_read": int(cr),
             "cost_usd": cost, "source": source,
             "estimated": bool(estimated), "caveat": caveat,
+            "hf_user": str(hf_user)[:64],
+            "submitted_at": now,
         }
         r = requests.post(
             f"{_URL}/rest/v1/{_TABLE}",
@@ -93,7 +101,65 @@ def save_operator(name, i, o, cw, cr, cost=None, source="manual",
             json=payload, timeout=_TIMEOUT,
         )
         r.raise_for_status()
+        # also log to session history (best-effort)
+        _save_session(name, i, o, cw, cr, cost, source, estimated, caveat,
+                      hf_user, now)
         return True
     except Exception as e:
         print(f"[db] save_operator failed (non-fatal): {e}")
         return False
+
+
+def _save_session(name, i, o, cw, cr, cost, source, estimated, caveat,
+                  hf_user, timestamp):
+    """Append a session record (never upserts — one row per submission).
+    Best-effort; failures are swallowed."""
+    if not writes_enabled():
+        return
+    try:
+        import requests
+        payload = {
+            "name": str(name)[:64],
+            "input": int(i), "output": int(o),
+            "cache_create": int(cw), "cache_read": int(cr),
+            "cost_usd": cost, "source": source,
+            "estimated": bool(estimated), "caveat": caveat,
+            "hf_user": str(hf_user)[:64],
+            "submitted_at": timestamp,
+        }
+        r = requests.post(
+            f"{_URL}/rest/v1/{_HIST_TABLE}",
+            headers={"apikey": _SERVICE, "Authorization": f"Bearer {_SERVICE}",
+                     "Content-Type": "application/json",
+                     "Prefer": "return=minimal"},
+            json=payload, timeout=_TIMEOUT,
+        )
+        r.raise_for_status()
+    except Exception as e:
+        print(f"[db] _save_session failed (non-fatal): {e}")
+
+
+def load_session_history(name, limit=5):
+    """Load top N sessions for an operator by Υ (yield = cr/i * o/i).
+    Returns list of dicts with keys: input, output, cache_create, cache_read,
+    submitted_at. Falls back to empty list on any failure."""
+    if not enabled():
+        return []
+    try:
+        import requests
+        r = requests.get(
+            f"{_URL}/rest/v1/{_HIST_TABLE}",
+            params={
+                "select": "input,output,cache_create,cache_read,submitted_at,source",
+                "name": f"eq.{name}",
+                "order": "submitted_at.desc",
+                "limit": str(limit),
+            },
+            headers={"apikey": _ANON, "Authorization": f"Bearer {_ANON}"},
+            timeout=_TIMEOUT,
+        )
+        r.raise_for_status()
+        return r.json()
+    except Exception as e:
+        print(f"[db] load_session_history failed (non-fatal): {e}")
+        return []

ingest.py

@@ -1,8 +1,14 @@
 """
 Ingestion — turn whatever the user pastes into four integers (+cost).
 Survives ccusage version differences and routes Codex shape separately.
+
+System Flag / Disclaimer *: All parsed values generated via the Codex pathway
+are calculated structural estimations designed to isolate high-signal user
+direction from background open-loop context noise. These values are optimized
+for architectural modeling and are distinct from raw provider API payload logs.
 """
 import json
+import re
 
 def parse_ccusage(text):
     """Accept raw `ccusage --json` output (any known shape). Returns (i,o,cw,cr,cost)."""
@@ -34,13 +40,12 @@ def parse_ccusage(text):
     return tot["input"],tot["output"],tot["cache_create"],tot["cache_read"],cost
 
 def parse_four(text):
-    """Accept four numbers in any delimiter."""
-    import re
+    """Accept four numbers in any delimiter: input output cache_create cache_read."""
     nums=[int(float(x)) for x in re.findall(r"[\d,.]+", text.replace(",",""))]
     if len(nums)<4: raise ValueError("need 4 numbers: input output cache_create cache_read")
     return nums[0],nums[1],nums[2],nums[3]
 
-# ---------- Codex parse (combined-input split via 2:1 field anchor) ----------
+# ---------- Codex shape detection ----------
 def is_codex_shape(d):
     keys = set()
     def scan(o):
@@ -53,96 +58,97 @@ def is_codex_shape(d):
     return ("cached_input_tokens" in keys or "cachedInputTokens" in keys or
             "reasoning_output_tokens" in keys or "reasoningOutputTokens" in keys)
 
-def parse_codex(text, io_ratio=None):
-    """
-    Codex reports combined input_tokens (incl. cached) + cached_input_tokens +
-    output + reasoning. cache_create is never reported by OpenAI.
-
-    Anchor strategy (turn-delta-first, ratio fallback):
-    - If daily/session granularity is present, estimate cache_create from
-      per-day context deltas (turn-delta method): each day's input growth above
-      the previous day's total \u2248 new cache writes.
-    - Else, fall back to io_ratio anchor: est_fresh = io_ratio * output.
-    - io_ratio defaults to 2.0 (provisional); pass Claude's measured I/O ratio
-      for better accuracy.
-
-    cache_read = cachedInputTokens (measured directly).
-    """
-    d = json.loads(text) if isinstance(text, str) else text
+# ---------- Codex two-pathway parser ----------
+def _extract_codex_totals(d):
+    """Walk a Codex JSON payload and sum the raw token fields."""
     tot = {"in":0, "cached":0, "out":0, "reason":0, "cost":0.0}
-    days = []  # for turn-delta
-    def add(e, track=False):
+    def add(e):
         if not isinstance(e, dict): return
-        i   = e.get("input_tokens", e.get("inputTokens",0)) or 0
-        ca  = e.get("cached_input_tokens", e.get("cachedInputTokens",0)) or 0
-        o   = e.get("output_tokens", e.get("outputTokens",0)) or 0
-        r   = e.get("reasoning_output_tokens", e.get("reasoningOutputTokens",0)) or 0
-        c   = e.get("costUSD", e.get("cost",0)) or 0.0
-        tot["in"] += i; tot["cached"] += ca
-        tot["out"] += o; tot["reason"] += r; tot["cost"] += c
-        if track and i > 0:
-            days.append({"date": e.get("date",""), "in": i, "cached": ca})
+        tot["in"]     += e.get("input_tokens", e.get("inputTokens",0)) or 0
+        tot["cached"] += e.get("cached_input_tokens", e.get("cachedInputTokens",0)) or 0
+        tot["out"]    += e.get("output_tokens", e.get("outputTokens",0)) or 0
+        tot["reason"] += e.get("reasoning_output_tokens", e.get("reasoningOutputTokens",0)) or 0
+        tot["cost"]   += e.get("costUSD", e.get("cost",0)) or 0.0
     if isinstance(d, list):
         for e in d: add(e)
-    else:
-        for key in ("daily","session","sessions","data","entries","events"):
-            v = d.get(key) if isinstance(d, dict) else None
+    elif isinstance(d, dict):
+        for key in ("totals", "daily", "session", "sessions", "data", "entries", "events"):
+            v = d.get(key)
+            if key == "totals" and isinstance(v, dict):
+                add(v); return tot
             if isinstance(v, list):
-                for e in v: add(e, track=True)
-                break
+                for e in v: add(e)
+                return tot
             if isinstance(v, dict):
                 for e in v.values(): add(e)
-                break
-        else:
-            add(d)
-
-    combined_in = tot["in"]; read = tot["cached"]; O = tot["out"] + tot["reason"]
-    anchor_used = "2:1 fixed"
-
-    # --- turn-delta method (when we have daily granularity) ---
-    if len(days) >= 2:
-        days.sort(key=lambda x: x["date"])
-        # Each day's fresh input above the previous day's floor \u2248 new cache writes.
-        # Heuristic: new context added each day = max(0, today.in - prev.in)
-        create = 0
-        prev = days[0]["in"]
-        for day in days[1:]:
-            delta = max(0, day["in"] - prev)
-            create += delta
-            prev = day["in"]
-        create += days[0]["in"]  # first day's full input is new cache
-        I = combined_in  # fresh input IS inputTokens (not combined with reads)
-        anchor_used = "turn-delta"
-        caveat = "estimated via turn-delta (cache_create from daily context growth)"
+                return tot
+        add(d)
+    return tot
+
+
+def parse_codex_submission(payload, operator_profile=None):
+    """
+    Parses Codex token payloads to estimate true high-signal user input.
+
+    Two pathways depending on operator telemetry:
+
+    Pathway Alpha (Standard): No Claude footprint → 3:2:1 baseline.
+      estimated_user_input = outputTokens × 2.0
+
+    Pathway Beta (Claude Engine): Operator has verified Claude profile →
+      dynamic 1:9 transmission velocity extraction.
+      estimated_user_input = outputTokens / 9.0
+
+    Returns (i, o, cw, cr, meta) mapped to the four pillars:
+      i  = calibrated_user_input (high-signal core)
+      o  = raw output (unchanged)
+      cw = structural_context_debt (non-essential friction tokens)
+      cr = retained_cache_read (measured directly)
+    """
+    d = json.loads(payload) if isinstance(payload, str) else payload
+    tot = _extract_codex_totals(d)
+
+    raw_out   = tot["out"] + tot["reason"]
+    raw_in    = tot["in"]
+    raw_cache = tot["cached"]
+    cost      = tot["cost"] if tot["cost"] > 0 else None
+
+    # Pathway Beta: Dynamic User Profile Match (Claude Engine)
+    if operator_profile and operator_profile.get("model_type") == "claude":
+        estimated_user_input = raw_out / 9.0
+        parsing_mode = "Claude Closed-Loop Calibration (1:9)"
+    # Pathway Alpha: Fallback Standard (The Top 10 Wild Field Baseline)
     else:
-        # --- ratio anchor fallback ---
-        ratio = io_ratio if io_ratio and io_ratio > 0 else 2.0
-        est_fresh = ratio * O
-        create = combined_in - est_fresh
-        if create >= 0:
-            I = est_fresh
-            label = f"{ratio:.2f}:1 anchor (Claude-measured)" if io_ratio else "2:1 anchor (fixed)"
-            anchor_used = label
-            caveat = f"estimated via {label}"
-        else:
-            create = 0
-            I = max(combined_in - read, 0) or combined_in
-            anchor_used = "fallback (anchor inverted)"
-            caveat = "estimated \u2193 output-rich (anchor inverted)"
-
-    meta = {"source":"codex", "estimated":True, "caveat":caveat,
-            "anchor": anchor_used,
-            "cost": tot["cost"] if tot["cost"] > 0 else None}
-    return I, O, int(create), read, meta
-
-def ingest_meta(text, io_ratio=None):
-    """Returns (i,o,cw,cr,meta) with estimated/caveat/cost."""
+        estimated_user_input = raw_out * 2.0
+        parsing_mode = "Standard Open-Loop Baseline (3:2:1)"
+
+    context_debt = max(0, raw_in - int(estimated_user_input))
+
+    meta = {
+        "source": "codex",
+        "estimated": True,
+        "parsing_mode": parsing_mode,
+        "caveat": f"* {parsing_mode}",
+        "anchor": parsing_mode,
+        "cost": cost,
+    }
+    return int(estimated_user_input), raw_out, context_debt, raw_cache, meta
+
+
+def ingest_meta(text, operator_profile=None):
+    """Returns (i,o,cw,cr,meta) with estimated/caveat/cost.
+
+    operator_profile: optional dict with at least {"model_type": "claude"}
+    when the submitting user has a verified Claude session profile. This
+    switches the Codex parser from the 3:2:1 baseline to the 1:9 closed-loop
+    calibration pathway.
+    """
     text=text.strip()
     if not text: raise ValueError("empty")
     if text[0] in "{[":
         d=json.loads(text)
         if is_codex_shape(d):
-            return parse_codex(d, io_ratio=io_ratio)
+            return parse_codex_submission(d, operator_profile=operator_profile)
         i,o,cw,cr,cost = parse_ccusage(text)
         return i,o,cw,cr,{"source":"ccusage","estimated":False,"caveat":None,"cost":cost}
     i,o,cw,cr = parse_four(text)

requirements.txt

@@ -1,4 +1,4 @@
-gradio>=4.44.0
+gradio[oauth]>=4.44.0
 spaces
 requests
 torch

sigrank.py

@@ -24,7 +24,7 @@ import shutil
 import subprocess
 import sys
 
-from ingest import ingest_meta
+from ingest import ingest_meta, parse_ccusage
 from metrics import compute
 import db
 
@@ -144,22 +144,21 @@ def main(argv=None):
 
     color = sys.stdout.isatty() and not args.no_color
 
-    # For Codex: compute Claude's real I/O ratio first and use it as anchor.
-    io_ratio = None
+    # For Codex: detect Claude profile so the parser uses 1:9 pathway.
+    operator_profile = None
     if args.codex:
         try:
-            from ingest import parse_ccusage as _pcc
             _c_args = type("a", (), {"file": None, "stdin": False, "codex": False})()
             _c_raw, _ = _grab_usage(_c_args)
-            _ci, _co, _, _, _ = _pcc(_c_raw)
+            _ci, _co, _, _, _ = parse_ccusage(_c_raw)
             if _co > 0:
-                io_ratio = _ci / _co
+                operator_profile = {"model_type": "claude", "io_ratio": _ci / _co}
         except Exception:
-            pass  # fall back to 2:1
+            pass  # no Claude data — Alpha pathway (3:2:1)
 
     try:
         raw, how = _grab_usage(args)
-        i, o, cw, cr, meta = ingest_meta(raw, io_ratio=io_ratio)
+        i, o, cw, cr, meta = ingest_meta(raw, operator_profile=operator_profile)
     except Exception as e:
         print(f"sigrank: {e}", file=sys.stderr)
         return 1

theme.py

@@ -171,6 +171,35 @@ button.primary:hover, #compute-btn:hover { background: #d8a449 !important; }
   display: flex; justify-content: space-between;
 }
 
+/* parsing mode badge on trading card */
+.sig-card-mode {
+  font-size: 8px; color: var(--moses-dim); letter-spacing: 0.06em;
+  margin-bottom: 10px; padding: 2px 6px;
+  border: 1px dashed var(--moses-line); border-radius: 2px;
+  display: inline-block;
+}
+
+/* estimation asterisk on board rows */
+.mb-est { color: var(--moses-gold); font-weight: 700; font-size: 10px; cursor: help; }
+
+/* greatest hits table */
+.greatest-hits { margin: 16px 0; }
+.greatest-hits h4 { color: var(--moses-gold); font-size: 13px; letter-spacing: 0.08em; margin-bottom: 8px; }
+.greatest-hits table { width: 100%; border-collapse: collapse; font-size: 11px; }
+.greatest-hits th {
+  color: var(--moses-gold); font-size: 9px; letter-spacing: 0.06em;
+  text-transform: uppercase; text-align: left; padding: 6px 8px;
+  border-bottom: 1px solid var(--moses-gold);
+}
+.greatest-hits td {
+  color: var(--moses-dim); padding: 6px 8px;
+  border-bottom: 1px solid var(--moses-line);
+}
+.greatest-hits tr:first-child td { color: var(--moses-ink); }
+
+/* HF login button styling */
+#hf-login-btn { margin-bottom: 8px; }
+
 footer { display: none !important; }
 
 @media (max-width: 700px) {