fix Codex parser + sharpen instructions + add ./sigrank --all

- Codex parser: unify Alpha/Beta into one _codex_input_estimate helper
(removes the two divergent hardcoded /9.0 copies). Beta now uses the
operator's REAL Claude input/output ratio; Alpha uses the AA 2:1 baseline.
- ./sigrank --all: run every provider in turn (claude, then codex); Codex
reuses Claude's measured ratio for the Beta pathway; one failing provider
doesn't stop the others.
- Instructions (app.py Clock Your Signal tab + README How-to-measure):
measure each provider separately, never bare `ccusage --json`; what data /
where to get it / where to input it; accurate two-pathway Codex description.
- Drop duplicate claudetodolist.md (content lives in SUPABASE_MIGRATION.md).

Supabase migration (submitted_at, hf_user, sigrank_sessions + RLS) applied
live via MCP and verified end-to-end. Canonical MO§ES Υ 18436.98 unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

README.md

@@ -47,12 +47,45 @@ is the token-domain expression of the same conservation law.
 - *[Word-based operator ranking — link placeholder]*
 
 ## What it does
-Paste `npx ccusage@latest --json` (Claude Code), `ccusage codex --json` (Codex),
+Paste `ccusage claude --json` (Claude Code), `ccusage codex --json` (Codex),
 or four numbers →
 - **operator profile** — a 0.5B MiniCPM model narrates your architecture, plus
   raw ledger, composition, full metrics, cascade breakdown
 - **leaderboard placement** vs real operators, ranked by Υ, with blended **$/1M cost**
 
+## How to measure yourself
+Three things: **what data, where to get it, where to put it.**
+
+**1 — What / where to get it.** SigRank needs four integers — `input`, `output`,
+`cache_create`, `cache_read`. [`ccusage`](https://github.com/ryoppippi/ccusage) reads
+them from your local logs. Run **one command per provider** — Claude and Codex are
+different operators, so measure them **separately**:
+
+```
+ccusage claude --json       # Claude Code
+ccusage codex --json        # Codex
+```
+
+> ⚠️ Don't use bare `ccusage --json` (no subcommand): it merges every agent into one
+> total, which inflates input and distorts the architecture read.
+
+**2 — Where to put it.** Either:
+
+- **Local importer (no paste):** `./sigrank` (Claude), `./sigrank --codex` (Codex),
+  or `./sigrank --all` (each provider in turn). Reads your usage on your machine and
+  prints your profile + board rank. Nothing leaves your computer.
+- **Hosted Space:** paste one provider's JSON into the **Clock Your Signal** box, or type
+  the four numbers `input output cache_create cache_read`.
+
+**3 — Saving (optional).** On the Space, sign in with HuggingFace to earn one persistent
+board entry + session history (Greatest Hits). Without login, your read is a live
+snapshot only — scored against the field but not saved.
+
+**Codex note.** Codex doesn't report a fresh-vs-cache input split, so its input is
+*estimated*: on its own it uses the AA-backed **2:1** baseline; if you also have a Claude
+profile (e.g. `./sigrank --codex`, which reads your Claude ratio first) it calibrates with
+**your own Claude input:output ratio**. Estimated rows are flagged with `*`.
+
 ## The model (Tiny Titan / MiniCPM)
 `openbmb/MiniCPM4-0.5B` (0.5B params, well under the 4B cap) runs on ZeroGPU and
 narrates the operator read. It is **non-blocking**: if unavailable, a deterministic
@@ -152,11 +185,17 @@ benchmarks on one side, real user token ledgers on the other — landing on the
 same architecture is the validation.
 
 ## Codex support
-Codex reports a *combined* input figure (fresh + cached) and never itemizes cache
-writes. SigRank splits it with the measured field anchor **input:output ≈ 2:1**
-(estimated fresh input = 2×output; remainder → cache_create, clamped ≥0). Every
-Codex-derived row is flagged with its directional caveat (↑ input-heavy /
-↓ output-rich). The anchor is provisional and being refined (see CODEX.md).
+Codex never itemizes cache writes, so SigRank estimates the high-signal user input
+from output via two pathways (`_codex_input_estimate` in `ingest.py`):
+
+- **Alpha — Codex alone:** the AA-backed **2:1** baseline — `est_input = 2 × output`.
+- **Beta — Codex + a Claude profile:** the operator's **own** measured Claude
+  `input:output` ratio — `est_input = output × (claude_input / claude_output)`. The
+  CLI builds this automatically (`./sigrank --codex` reads your Claude usage first).
+
+`cache_create` is the remainder (`raw_input − est_input`, clamped ≥0); `cache_read` is
+measured directly. Every Codex-derived row is **flagged with `*`** and names the exact
+pathway used in its caveat.
 
 ## Cost
 For Claude Code, ccusage supplies real cost → exact $/1M. For manual/wild rows

app.py

@@ -327,25 +327,34 @@ def _build_demo():
             gr.HTML(board_html())
 
         with gr.Tab("Clock Your Signal"):
-            gr.Markdown("""**Get your operator profile \u2014 every provider, one command.**
+            gr.Markdown("""**Get your operator profile \u2014 measure each provider separately.**
 
-**\u2460 Run ccusage** (reads your local usage \u2014 one command per provider):
+**\u2460 Get your numbers.** Run one command per provider in your terminal:
 ```
-ccusage claude --json       # Claude Code stats
-ccusage codex --json        # Codex stats (estimated *)
-ccusage --json              # ALL providers combined
+ccusage claude --json       # Claude Code
+ccusage codex --json        # Codex (estimated *)
 ```
-Or use the local importer:
+\u26a0\ufe0f **Run each provider on its own \u2014 never bare `ccusage --json`.** With no
+subcommand it merges every agent into one total, inflating input and distorting your
+architecture. Claude and Codex are different operators \u2014 measure them separately.
+
+Prefer zero copy-paste? Use the local importer (reads your usage on your machine):
 ```
-./sigrank                   # Claude Code (measured)
-./sigrank --codex           # Codex (applies field anchor *)
+./sigrank            # Claude Code (measured)
+./sigrank --codex    # Codex (calibrated *)
+./sigrank --all      # each provider, one after another
 ```
 
-**\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`.
+**\u2461 Paste it below.** Drop one provider's `ccusage` JSON in the box \u2014 we route it
+automatically. No JSON handy? Type four numbers in order:
+`input  output  cache_create  cache_read`.
 
-*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 \\*.*
+*Codex reports no fresh-vs-cache input split, so its input is **estimated**: on its own it
+uses the AA-backed **2:1** baseline; if you also have a Claude profile it uses **your own
+Claude input:output ratio**. Estimated rows are flagged with \\*.*
 
-**\u2462 Sign in to save.** HuggingFace users get one persistent board entry + session history. Paste without login = snapshot only.""")
+**\u2462 Sign in to save.** A HuggingFace login earns one persistent board entry + session
+history (Greatest Hits). Pasting without login is a live snapshot only.""")
             if _ON_SPACE:
                 gr.LoginButton(elem_id="hf-login-btn")
             else:

claudetodolist.md

@@ -1,147 +0,0 @@
-2 items... i had devin build the instructions for the following... 
-
-
-1) i dont feel like we covered enough on instructions and detailing what information we need, where to get it... and where to imput it 
-
-
-
-2) # Supabase Migration — SigRank Importer Overhaul
-
-Run these in the Supabase SQL Editor (Dashboard → SQL Editor → New Query).
-
----
-
-## 1. Add columns to `sigrank_operators`
-
-```sql
--- Timestamp for when the entry was last submitted/updated
-ALTER TABLE sigrank_operators
-  ADD COLUMN IF NOT EXISTS submitted_at TIMESTAMPTZ DEFAULT now();
-
--- HuggingFace username — only authenticated users can persist
-ALTER TABLE sigrank_operators
-  ADD COLUMN IF NOT EXISTS hf_user TEXT;
-
--- Index for fast lookups by HF user
-CREATE INDEX IF NOT EXISTS idx_sigrank_operators_hf_user
-  ON sigrank_operators (hf_user);
-```
-
----
-
-## 2. Create `sigrank_sessions` table (session history / Greatest Hits)
-
-```sql
-CREATE TABLE IF NOT EXISTS sigrank_sessions (
-  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
-  name TEXT NOT NULL,
-  input BIGINT NOT NULL DEFAULT 0,
-  output BIGINT NOT NULL DEFAULT 0,
-  cache_create BIGINT NOT NULL DEFAULT 0,
-  cache_read BIGINT NOT NULL DEFAULT 0,
-  cost_usd DOUBLE PRECISION,
-  source TEXT DEFAULT 'manual',
-  estimated BOOLEAN DEFAULT FALSE,
-  caveat TEXT,
-  hf_user TEXT,
-  submitted_at TIMESTAMPTZ DEFAULT now()
-);
-
--- Index for loading a user's session history
-CREATE INDEX IF NOT EXISTS idx_sigrank_sessions_name
-  ON sigrank_sessions (name, submitted_at DESC);
-```
-
----
-
-## 3. RLS policies (keep anon read-only, service key for writes)
-
-```sql
--- Enable RLS on the new table
-ALTER TABLE sigrank_sessions ENABLE ROW LEVEL SECURITY;
-
--- Anon can read session history
-CREATE POLICY "anon_read_sessions" ON sigrank_sessions
-  FOR SELECT USING (true);
-
--- Service role can insert (writes come from the app backend)
-CREATE POLICY "service_insert_sessions" ON sigrank_sessions
-  FOR INSERT WITH CHECK (true);
-
--- Same pattern for the new columns on sigrank_operators
--- (existing policies should already cover SELECT/INSERT;
---  verify the existing INSERT policy allows the new columns)
-```
-
----
-
-## 4. Verify
-
-After running the above, check:
-
-```sql
--- Should show submitted_at and hf_user columns
-SELECT column_name, data_type
-FROM information_schema.columns
-WHERE table_name = 'sigrank_operators'
-ORDER BY ordinal_position;
-
--- Should exist with all columns
-SELECT column_name, data_type
-FROM information_schema.columns
-WHERE table_name = 'sigrank_sessions'
-ORDER BY ordinal_position;
-```
-
----
-
-## Notes
-
-- `sigrank_operators` still upserts on `name` (one board entry per operator)
-- `sigrank_sessions` is append-only — every submission creates a new row
-- The app reads sessions via `load_session_history(name, limit=5)` for the Greatest Hits display
-- `hf_user` is populated only when the user is authenticated via HuggingFace OAuth on the Space
-- Without the `SUPABASE_SERVICE_KEY` env var, all writes are no-ops (safe for public demo)
-
-
-
-3)Here's the spec for ./sigrank --all that Claude Code can implement:
-Goal: ./sigrank --all runs each ccusage provider sequentially and loads results into the user's profile one at a time.
-In sigrank.py:
-
-# Add to argparser:
-p.add_argument("--all", action="store_true",
-               help="run all providers (claude + codex) sequentially")
- 
-# In main(), before the existing try block:
-if args.all:
-    for provider, is_codex in [("claude", False), ("codex", True)]:
-        sub_args = type("a", (), {
-            "file": None, "stdin": False, "codex": is_codex,
-            "name": args.name, "no_color": args.no_color,
-            "stdin_dash": None
-        })()
-        try:
-            raw, how = _grab_usage(sub_args)
-            # Build operator_profile from Claude data if running Codex
-            op_profile = None
-            if is_codex:
-                # Try to get Claude's I/O ratio for Beta pathway
-                try:
-                    claude_args = type("a", (), {"file": None, "stdin": False, "codex": False})()
-                    c_raw, _ = _grab_usage(claude_args)
-                    ci, co, _, _, _ = parse_ccusage(c_raw)
-                    if co > 0:
-                        op_profile = {"model_type": "claude", "io_ratio": ci / co}
-                except Exception:
-                    pass
-            i, o, cw, cr, meta = ingest_meta(raw, operator_profile=op_profile)
-            m = compute(i, o, cw, cr, cost_usd=meta.get("cost"))
-            if meta.get("estimated"):
-                m["_caveat"] = meta.get("caveat")
-            print(render(args.name, m, how, color=not args.no_color))
-        except Exception as e:
-            print(f"  [{provider}] skipped: {e}")
-    sys.exit(0)
-Flow: ./sigrank --all → runs ccusage claude --json, prints profile → runs ccusage codex --json, prints profile with Alpha or Beta pathway applied. Each provider is independent — if one fails, the other still runs. find the users model via ccusage --help
-That should be everything! PRs #5 and #6 cover the full importer overhaul. Let me know if you need anything else.

ingest.py

@@ -182,18 +182,37 @@ def _extract_codex_totals(d):
     return tot
 
 
+def _codex_input_estimate(raw_out, operator_profile):
+    """Estimate Codex high-signal user input from output. Single source of truth
+    for both the JSON and named-field Codex paths (no duplicated magic numbers).
+
+    Codex never reports a fresh-vs-cache input split, so we estimate the
+    high-signal user input from the output (the real work product) via a ratio:
+
+      Beta  (Codex + Claude present): use the operator's REAL Claude operating
+        ratio io_ratio = claude_input/claude_output ->  est_input = output * io_ratio
+        (dynamic, never a constant — it's the operator's own measured behaviour).
+
+      Alpha (Codex alone, no Claude):  AA-backed 2:1 baseline (input:output = 2),
+        supported by the wild corpus ->  est_input = output * 2.0
+
+    Returns (est_input:int, parsing_mode:str).
+    """
+    if (operator_profile and operator_profile.get("model_type") == "claude"
+            and operator_profile.get("io_ratio")):
+        ratio = operator_profile["io_ratio"]            # claude input / output
+        return int(raw_out * ratio), f"Claude operating-ratio {ratio:.3f}:1 (input:output)"
+    return int(raw_out * 2.0), "AA 2:1 baseline (wild-corpus backed)"
+
+
 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
+    Two pathways depending on operator telemetry (see _codex_input_estimate):
 
-    Pathway Beta (Claude Engine): Operator has verified Claude profile ->
-      dynamic 1:9 transmission velocity extraction.
-      estimated_user_input = outputTokens / 9.0
+    Pathway Beta (Codex + Claude): est_input = output * (claude_input/claude_output)
+    Pathway Alpha (Codex alone):   est_input = output * 2.0   (AA 2:1 baseline)
 
     Returns (i, o, cw, cr, meta) mapped to the four pillars:
       i  = calibrated_user_input (high-signal core)
@@ -209,16 +228,8 @@ def parse_codex_submission(payload, operator_profile=None):
     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:
-        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))
+    estimated_user_input, parsing_mode = _codex_input_estimate(raw_out, operator_profile)
+    context_debt = max(0, raw_in - estimated_user_input)
 
     meta = {
         "source": "codex",
@@ -240,10 +251,10 @@ def ingest_meta(text, operator_profile=None):
       - Text with named fields (extracts by field name, not position)
       - Four bare numbers: input output cache_create cache_read
 
-    operator_profile: optional dict with at least {"model_type": "claude"}
+    operator_profile: optional dict {"model_type": "claude", "io_ratio": float}
     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.
+    switches the Codex parser from the Alpha 2:1 baseline to the Beta pathway
+    that uses the operator's own Claude input/output ratio.
     """
     text=text.strip()
     if not text: raise ValueError("empty")
@@ -284,13 +295,8 @@ def ingest_meta(text, operator_profile=None):
                         raw_in = int(float(m.group(1).replace(",", "")))
                         break
                 raw_out = o  # already includes reasoning from _extract_by_name
-                if operator_profile and operator_profile.get("model_type") == "claude":
-                    est_input = raw_out / 9.0
-                    parsing_mode = "Claude Closed-Loop Calibration (1:9)"
-                else:
-                    est_input = raw_out * 2.0
-                    parsing_mode = "Standard Open-Loop Baseline (3:2:1)"
-                context_debt = max(0, raw_in - int(est_input))
+                est_input, parsing_mode = _codex_input_estimate(raw_out, operator_profile)
+                context_debt = max(0, raw_in - est_input)
                 meta = {
                     "source": "codex", "estimated": True,
                     "parsing_mode": parsing_mode,

sigrank.py

@@ -6,8 +6,9 @@ Her-style: reads YOUR usage on YOUR machine and prints your operator read. No
 paste, no token, no upload. The hosted Space's paste box is the backup; this is
 the real-app path.
 
-  python sigrank.py                 # auto-run `ccusage --json` (Claude Code)
+  python sigrank.py                 # auto-run `ccusage claude --json` (Claude Code)
   python sigrank.py --codex         # auto-run `ccusage codex --json`
+  python sigrank.py --all           # every provider in turn (claude, then codex)
   python sigrank.py --file u.json   # read a saved ccusage/codex json
   python sigrank.py --name "you"    # label your row
   cat u.json | python sigrank.py -  # read from stdin (backup)
@@ -137,6 +138,8 @@ def main(argv=None):
     p.add_argument("stdin_dash", nargs="?", default=None, help="pass '-' to read JSON from stdin")
     p.add_argument("--file", help="read a saved ccusage/codex json file")
     p.add_argument("--codex", action="store_true", help="run `ccusage codex --json`")
+    p.add_argument("--all", action="store_true",
+                   help="run every provider in turn (claude, then codex)")
     p.add_argument("--name", default="you", help="label for your row")
     p.add_argument("--no-color", action="store_true", help="plain output")
     args = p.parse_args(argv)
@@ -144,7 +147,34 @@ def main(argv=None):
 
     color = sys.stdout.isatty() and not args.no_color
 
-    # For Codex: detect Claude profile so the parser uses 1:9 pathway.
+    # --all: run each provider sequentially and independently. Claude runs first;
+    # its measured input/output ratio is captured and handed to the Codex pass so
+    # Codex uses the Beta (operator-ratio) pathway. One provider failing (e.g. no
+    # Codex usage) never stops the others.
+    if args.all:
+        name = (args.name or "you").strip()[:24] or "you"
+        claude_profile = None
+        for provider, is_codex in (("claude", False), ("codex", True)):
+            try:
+                prov_args = type("a", (), {"file": None, "stdin": False, "codex": is_codex})()
+                raw, how = _grab_usage(prov_args)
+                prof = claude_profile if is_codex else None
+                i, o, cw, cr, meta = ingest_meta(raw, operator_profile=prof)
+                if i + o + cw + cr == 0:
+                    print(f"  [{provider}] no usage data — skipped")
+                    continue
+                m = compute(i, o, cw, cr, cost_usd=meta.get("cost"))
+                if meta.get("estimated"):
+                    m["_caveat"] = meta.get("caveat")
+                print(render(name, m, how, color))
+                if not is_codex and o > 0:        # capture Claude ratio for the Codex pass
+                    claude_profile = {"model_type": "claude", "io_ratio": i / o}
+            except Exception as e:
+                print(f"  [{provider}] skipped: {e}")
+        return 0
+
+    # For Codex: detect the operator's real Claude I/O ratio so the parser uses
+    # the Beta pathway (output * claude_input/claude_output) instead of Alpha 2:1.
     operator_profile = None
     if args.codex:
         try:
@@ -154,7 +184,7 @@ def main(argv=None):
             if _co > 0:
                 operator_profile = {"model_type": "claude", "io_ratio": _ci / _co}
         except Exception:
-            pass  # no Claude data — Alpha pathway (3:2:1)
+            pass  # no Claude data — Alpha pathway (AA 2:1 baseline)
 
     try:
         raw, how = _grab_usage(args)