@r1z4x/tezgah 1.4.0 → 1.5.0

package/bin/tezgah-taste

@@ -39,9 +39,11 @@ design T1P). Each prompt after a writing turn - from the capture rows in the
 from this repository's omp and Claude transcripts - becomes one structured signal
 built by code: the prompt, the files written, the agent's edits and the user's
 own edit between two agent writes. One typed decision per signal, required from
-TypeSafe (`only=("typesafe",)`): preference, defect or none; the category; the
-scope; and how it relates to each learning held. A decision any other provider
-gave is recorded `unverified` and never applied. A defect goes to the `defects`
+the Jev model (`only=("jev",)`: TypeSafe, OpenRouter System One, Cloudflare
+Workers AI or a compatible endpoint - whichever carrier the judge seam resolves):
+preference, defect or none; the category; the scope; and how it relates to each
+learning held. A decision any other provider gave is recorded `unverified` and
+never applied. A defect goes to the `defects`
 table, never into the ledger. The ledger itself is `hooks/tezgah_taste_ledger.py`. A
 learning that becomes active gets one readable line from a generative provider
 (a `text` question; the user's own words when none answers).
@@ -320,7 +322,7 @@ def classify(texts, model, only=None):
 
     The rule rides the state, so each request pays for it once and the
     questions carry only their own prompt."""
-    labels, tokens_in, tokens_out, used = [], 0, 0, model
+    labels, tokens_in, tokens_out, used, spent = [], 0, 0, model, 0.0
     for start in range(0, len(texts), BATCH):
         chunk = texts[start:start + BATCH]
         questions = {"p%d" % i: {"type": "choice", "criteria": CRITERIA,
@@ -332,24 +334,36 @@ def classify(texts, model, only=None):
             tokens_in += result["usage"]["input_tokens"]
             tokens_out += result["usage"]["output_tokens"]
             used = result.get("model", used)
+            one = result_cost(result)
+            spent = None if spent is None or one is None else spent + one
         for i in range(len(chunk)):
             label = tezgah_judge.choice(result, "p%d" % i)
             labels.append(label if label in CLASSES else None)
     return labels, {"model": used, "input_tokens": tokens_in,
-                    "output_tokens": tokens_out, "cost_usd": cost(used, tokens_in,
-                                                                  tokens_out)}
-
-
-def cost(model, tokens_in, tokens_out):
-    """Dollars at the model's listed price per 1M tokens, None when unlisted."""
-    price = JEV_PRICE if model == tezgah_judge.MODEL else (
-        tezgah_models.overlay().get("prices", {}).get(model)
-        or tezgah_models.SNAPSHOT.get(model))
+                    "output_tokens": tokens_out,
+                    "cost_usd": None if spent is None else round(spent, 6)}
+
+
+def cost(model, tokens_in, tokens_out, provider=None):
+    """Dollars at the model's listed price per 1M tokens, None when unlisted. A
+    typed carrier (`tezgah_judge.input_price`) is priced by the carrier that
+    answered: Clef's price is not Jev's."""
+    typed = tezgah_judge.input_price(provider)
+    price = (typed, 0.0) if typed is not None else JEV_PRICE \
+        if model == tezgah_judge.MODEL else (
+            tezgah_models.overlay().get("prices", {}).get(model)
+            or tezgah_models.SNAPSHOT.get(model))
     if not (isinstance(price, (list, tuple)) and len(price) == 2):
         return None
     return round((tokens_in * price[0] + tokens_out * price[1]) / 1e6, 6)
 
 
+def result_cost(result):
+    """One judge result's cost, priced by the provider that answered it."""
+    return cost(result.get("model"), result["usage"]["input_tokens"],
+                result["usage"]["output_tokens"], result.get("provider"))
+
+
 def usage_line(usage):
     money = ("$%.6f" % usage["cost_usd"] if usage["cost_usd"] is not None
              else "cost unknown (no listed price)")
@@ -370,7 +384,7 @@ def cmd_measure(args):
     if not tezgah_judge.available():
         return misuse("no judge: no credential resolves or judge-off is set; nothing sent")
     got, usage = classify([text for text, _gold in pairs], args.model,
-                          only=("typesafe",) if args.typed else None)
+                          only=("jev",) if args.typed else None)
     confusion = {g: {p: 0 for p in CLASSES} for g in CLASSES}
     unjudged = 0
     for (_text, gold), pred in zip(pairs, got):
@@ -628,12 +642,12 @@ def picked(result, qid, default):
 
 
 def decide(sig, learnings, fallback=True):
-    """(decision, result): the typed decision, TypeSafe required; when it cannot
+    """(decision, result): the typed decision, the Jev model required; when it cannot
     answer, the seam's own providers, recorded unverified - only on a signal's
     first try, since an unverified answer is never applied and a rerun would pay
     for it again."""
     state, questions = decision_request(sig, learnings)
-    result = tezgah_judge.ask(state, questions, only=("typesafe",), timeout=60)
+    result = tezgah_judge.ask(state, questions, only=("jev",), timeout=60)
     if result is None and fallback:
         result = tezgah_judge.ask(state, questions, timeout=120)
     if result is None:
@@ -643,7 +657,7 @@ def decide(sig, learnings, fallback=True):
            "scope": picked(result, "scope", "repository"),
            "relations": {lr["id"]: picked(result, "rel_" + lr["id"], "unrelated")
                          for lr in learnings},
-           "verified": result.get("provider") == "typesafe"}
+           "verified": tezgah_judge.is_jev(result.get("provider"))}
     return dec, result
 
 
@@ -678,7 +692,7 @@ def learn_refusal(repo):
     """Why `learn` sends and writes nothing here, or None - read before the
     store lock, so a refused run leaves no lock file behind."""
     if tezgah_judge.tp.off("judge-off") or not (
-            tezgah_judge.available() or tezgah_judge.named(("typesafe",))):
+            tezgah_judge.available() or tezgah_judge.named(("jev",))):
         return "no judge: no credential resolves or judge-off is set; nothing sent"
     import tezgah_context
     if ".no-taste" in tezgah_context.repo_marks(repo)[1]:
@@ -692,16 +706,16 @@ def cmd_learn(args):
                else capture_signals(repo))
     decided = {}
     for r in tl.rows(repo, "decisions"):
-        decided[r.get("id")] = decided.get(r.get("id")) or r.get("provider") == "typesafe"
-    # a typed decision is final; an unverified one is retried, TypeSafe only
+        decided[r.get("id")] = decided.get(r.get("id")) or tezgah_judge.is_jev(r.get("provider"))
+    # a typed decision is final; an unverified one is retried, the Jev model only
     todo = [s for s in signals if not decided.get(s["id"])]
     if args.limit is not None:
         todo = todo[:args.limit]
     ledgers = tl.load(repo)
     before = {k for k, v in tl.every(ledgers).items() if v["state"] == "active"}
-    counts = {"signals": len(todo), "typesafe": 0, "unverified": 0, "unanswered": 0,
+    counts = {"signals": len(todo), "jev": 0, "unverified": 0, "unanswered": 0,
               "preference": 0, "defect": 0, "none": 0}
-    tokens = [0, 0]
+    tokens, spent = [0, 0], 0.0
     for sig in todo:
         dec, result = decide(sig, held(ledgers),
                              fallback=not args.no_fallback and sig["id"] not in decided)
@@ -710,6 +724,8 @@ def cmd_learn(args):
             continue
         tokens[0] += result["usage"]["input_tokens"]
         tokens[1] += result["usage"]["output_tokens"]
+        one = result_cost(result)
+        spent = None if spent is None or one is None else spent + one
         day = tl.now_day()
         tl.append(repo, "decisions", {
             "id": sig["id"], "day": day, "at": sig.get("at"), "session": sig["session"],
@@ -721,7 +737,7 @@ def cmd_learn(args):
         if not dec["verified"]:
             counts["unverified"] += 1
             continue
-        counts["typesafe"] += 1
+        counts["jev"] += 1
         counts[dec["kind"][0] if dec["kind"][0] in CLASSES else "none"] += 1
         if dec["kind"][0] == "defect":
             tl.append(repo, "defects",
@@ -743,16 +759,18 @@ def cmd_learn(args):
     for learning in tl.every(ledgers).values():
         states[learning["state"]] = states.get(learning["state"], 0) + 1
     report = dict(counts, states=states, input_tokens=tokens[0], output_tokens=tokens[1],
-                  cost_usd=cost(tezgah_judge.MODEL, tokens[0], tokens[1]))
+                  cost_usd=None if spent is None else round(spent, 6))
     if args.json:
         print(json.dumps(report, indent=2))
         return 0
-    print("signals %d: typesafe %d, unverified %d, unanswered %d" % (
-        counts["signals"], counts["typesafe"], counts["unverified"], counts["unanswered"]))
+    print("signals %d: jev %d, unverified %d, unanswered %d" % (
+        counts["signals"], counts["jev"], counts["unverified"], counts["unanswered"]))
     print("decided: preference %d, defect %d, none %d" % (
         counts["preference"], counts["defect"], counts["none"]))
     print("ledger: " + (", ".join("%s %d" % kv for kv in sorted(states.items())) or "empty"))
-    print("typed decisions: %d input tokens, $%s" % (tokens[0], report["cost_usd"]))
+    money = report["cost_usd"]
+    print("typed decisions: %d input tokens, %s" % (
+        tokens[0], "$%s" % money if money is not None else "cost unknown (no listed price)"))
     return 0
 
 
@@ -808,8 +826,8 @@ def cmd_label(args):
     sample of unlabelled typed decisions - drawn without regard to what was
     injected, so the calibration bound rests on an unselected sample."""
     repo = store_or_exit(args)
-    decided = {r["id"]: r for r in tl.rows(repo, "decisions", "WHERE provider = ?",
-                                            ("typesafe",)) if r.get("id")}
+    decided = {r["id"]: r for r in tl.rows(repo, "decisions", *tl.jev_rows())
+               if r.get("id")}
     labelled = {r.get("id") for r in tl.rows(repo, "labels")}
     if args.id:
         if args.label not in CLASSES:
@@ -873,7 +891,7 @@ def main(argv):
     measure.add_argument("--model", default=tezgah_judge.MODEL)
     measure.add_argument("--json", action="store_true")
     measure.add_argument("--typed", action="store_true",
-                         help="require TypeSafe (the decision T1P's ledger trusts)")
+                         help="require the Jev model (the decision T1P's ledger trusts)")
     rate = sub.add_parser("rate")
     rate.add_argument("--in", dest="inp", required=True)
     rate.add_argument("--limit", type=int)
@@ -883,7 +901,7 @@ def main(argv):
     learn.add_argument("--host", choices=("omp", "claude", "all"), default="all")
     learn.add_argument("--limit", type=int)
     learn.add_argument("--no-fallback", action="store_true",
-                       help="TypeSafe only: never pay another provider for a decision")
+                       help="the Jev model only: never pay another provider for a decision")
     listing = sub.add_parser("list")
     listing.add_argument("--all", action="store_true")
     for name in ("show", "accept", "reject", "edit"):

package/bin/tezgah-triage

@@ -4,7 +4,8 @@
 A `browser_snapshot` / `mobile_list_elements_on_screen` result is the whole screen
 as text - one measured 40-row work-order table came back as 13,045 characters in
 356 lines - and the analyze-app loop pays for all of it to find the dozen lines
-that carry the controls. This flattens the snapshot, asks TypeSafe about the
+that carry the controls. This flattens the snapshot, asks the judge seam (the
+session's own CLI or the Jev model through any carrier) about the
 units of the tree (a row, a table cell, a control on its own) in ONE batched
 request, and prints the line ids under the selected units with their original
 element refs.
@@ -90,10 +91,13 @@ MEASURED = ("100% of the control lines at a 94% read on a reproduced 356-line "
             "screen")
 CUT = 96
 USAGE = "tezgah-triage --select FILE --task TEXT | --states FILE [--component TEXT]"
-NO_CREDENTIAL = ("no judge: no session CLI (omp or claude, from OMPCODE/CLAUDECODE), "
-                 "and no third party the `fallback` setting allows (TYPESAFE_API_KEY "
-                 "or ~/.config/typesafe/key, or the OpenRouter fallback's "
-                 "OPENROUTER_API_KEY or ~/.config/openrouter/key), or the judge-off "
+NO_CREDENTIAL = ("no judge: no session CLI (omp, claude, opencode, cursor or codex, "
+                 "the one this session runs under), and no third party the `fallback` "
+                 "setting allows - the Jev model through TypeSafe (TYPESAFE_API_KEY or "
+                 "~/.config/typesafe/key), OpenRouter System One or the OpenRouter chat "
+                 "fallback (OPENROUTER_API_KEY or ~/.config/openrouter/key), Cloudflare "
+                 "Workers AI, or a compatible endpoint (JEV_API_BASE_URL), the carrier "
+                 "picked by TEZGAH_JEV_PROVIDER or config `jev` - or the judge-off "
                  "switch is on")
 TRIAGE_OFF = "the triage-off switch is on"
 FAILED = ("the call failed - a timeout, a refusal, or a reply that is not the "
@@ -197,10 +201,11 @@ def trim(line):
 
 def judge_line(result):
     usage = result["usage"]
+    # the carrier's own price (Clef's is not Jev's); Jev's for a chat stand-in
+    price = tezgah_judge.input_price(result.get("provider")) or PRICE_PER_MILLION
     print("judge: %d input tokens, %d output, %d ms; $%.6f at $%.3f/1M input"
           % (usage["input_tokens"], usage["output_tokens"], result["latency_ms"],
-             usage["input_tokens"] * PRICE_PER_MILLION / 1000000,
-             PRICE_PER_MILLION))
+             usage["input_tokens"] * price / 1000000, price))
 
 
 def units(numbered):

package/docs/clarity-baseline.json

@@ -18,10 +18,10 @@
     "semicolons": 9
   },
   "docs/contract.md": {
-    "long_sentences": 43,
-    "passive": 26,
+    "long_sentences": 42,
+    "passive": 25,
     "replace_words": 0,
-    "semicolons": 31
+    "semicolons": 30
   },
   "docs/environment.md": {
     "long_sentences": 3,
@@ -61,9 +61,9 @@
   },
   "docs/judge.md": {
     "long_sentences": 22,
-    "passive": 15,
+    "passive": 14,
     "replace_words": 0,
-    "semicolons": 14
+    "semicolons": 13
   },
   "docs/layers.md": {
     "long_sentences": 20,
@@ -78,7 +78,7 @@
     "semicolons": 9
   },
   "docs/operations.md": {
-    "long_sentences": 67,
+    "long_sentences": 66,
     "passive": 21,
     "replace_words": 3,
     "semicolons": 42

package/docs/contract.md

@@ -38,7 +38,9 @@ rules and all.
 The skill suggestion is the one surface a judgement writes rather than a constant.
 The roster reaches a session as an index of host-truncated one-liners, so which
 entry to look at first is the turn's own weak spot; one batched judgement request
-answers it - TypeSafe, or the OpenRouter fallback when no TypeSafe key resolves
+answers it - the session's own CLI, else the Jev model through whichever carrier
+resolves (TypeSafe, OpenRouter System One, Cloudflare Workers AI, a compatible
+endpoint), else the OpenRouter chat fallback
 (`credential()`, `hooks/tezgah_judge.py::credential`) - a Choice across the installed
 skill names plus `none`, and one Noul
 asking whether the turn wants a skill at all - and the winner is appended after
@@ -158,11 +160,14 @@ never told this; and a ledger with no such row costs no bytes. `verify-off` drop
 it with the integrity rule it restates.
 
 The on-demand contract also carries detail the core has no budget for. One is
-the review rule: a change with an executable oracle - a checker, a gate rule, a
-parser - is reviewed by four direction-led reviewers whose every claim is built
-as a fixture and run before it counts, a tentative default measured on two
-research lines with a written flip; everything else keeps one fresh reviewer
-(`skills/tezgah-contract/SKILL.md:503-527`).
+the review rule. A plan gets one review over its whole diff, in at most two
+rounds. Round one fans out one reviewer per dimension. Only a confirmed critical
+or major finding opens round two, and `tezgah-task review` refuses a third. A
+change with an executable oracle - a checker, a gate rule, a parser - spends the
+same budget. Its round one is four direction-led reviewers, and each claim
+becomes a fixture that runs before it counts. That population is a tentative
+default, measured on two research lines with a written flip
+(`skills/tezgah-contract/SKILL.md:519-550`).
 
 ## Composition order of the always-on core
 
@@ -272,12 +277,17 @@ sentence of the rule.
 `PROMPT_HINTS` (`hooks/tezgah_context.py::PROMPT_HINTS`) is one compiled pattern per key
 — `spec`, `consult`, `research`, `product`, `graph`, `fanout` — and `classify_prompt()` returns the keys
 a prompt matches (`hooks/tezgah_context.py::classify_prompt`). `fanout` arms on the
-shape of the request, not a word. Two or more list entries on their own lines
-arm it, and so does an explicit subagent, parallel or worktree ask. The owner
-no longer has to say "do it with subagents, in parallel". On that turn only, the
-matching paragraphs are appended after the reminder
+shape of the request, not a word. Two list entries on their own lines arm it.
+An entry starts with `1.`, `1)`, `1 -`, `1:`, `a)` or a bullet. An inline
+`1. ... 2. ...` arms it too. So do three files named as one list, "First, ...
+Second, ..." and three imperative clauses in one sentence. An explicit
+subagent, parallel or worktree ask arms it as well. The owner no longer has to
+say "do it with subagents, in parallel". On that turn only, the matching
+paragraphs are appended after the reminder
 (`hooks/tezgah_context.py::context_for`); a session that never asks such a question
-pays the one-line pointer instead. The patterns carry Turkish stems because the
+pays the one-line pointer instead. A later match in the same session pays one
+line. The fan-out line still names the action
+(`hooks/tezgah_context.py::armed_again`). The patterns carry Turkish stems because the
 user writes Turkish, and a plain prompt arms nothing. The same prompt arms the
 same rules on every host (`tests/test_context.py::ArmingConformance.test_all_hosts_arm_the_same_rules`) and each advisory
 rule keeps a pointer line in the always-on text (`tests/test_context.py::ArmingConformance.test_every_advisory_rule_has_an_always_on_pointer`).

package/docs/environment.md

@@ -56,6 +56,7 @@ the kill switches are files, not variables, and live in
 | `TEZGAH_ORCA_BIN` | `hooks/tezgah_orca.py::cli` | `ORCA_CLI_COMMAND`, then `$ORCA_CLI_BIN_DIR/orca`, then `orca` on PATH (`orca-ide` on Linux outside Orca), then the macOS app's CLI | The Orca CLI `tezgah-status --orca` and `tezgah-setup --status` ask. A missing path is no CLI, never a fallback: the test suite points it at one. |
 | `TEZGAH_OMP_BIN` | `hooks/tezgah_paths.py::omp_bin` | `omp` on PATH | The omp binary the installer, the model table, consult's session-model lookup and the judgement seam's session call run; tests point it at a stand-in. |
 | `TEZGAH_CLAUDE_BIN` | `claude_bin`, `hooks/tezgah_paths.py::claude_bin` | `claude` on PATH | The Claude Code CLI `--install` registers the plugin with (`claude plugin`) and the judgement seam asks in a Claude Code session; the test suite points it at a path that does not exist, or at a stand-in. |
+| `TEZGAH_OPENCODE_BIN`, `TEZGAH_CURSOR_BIN`, `TEZGAH_CODEX_BIN` | `hooks/tezgah_paths.py::opencode_bin`, `hooks/tezgah_paths.py::cursor_bin`, `hooks/tezgah_paths.py::codex_bin` | `opencode`, `cursor-agent`, `codex` on PATH or a per-user bin dir | The CLI the judgement seam asks in that host's session; tests point them at stand-ins. |
 | `TEZGAH_DSH_BIN` | `bin/tezgah-setup::reconcile_json_servers` | the profile-local entry, then `bin/tezgah-dsh`, then npx | How the installer invokes the dsh CLI. |
 | `TEZGAH_INDEX_BIN` | `bin/tezgah-dsh:19`, `bin/tezgah-dsh.cmd` | `~/.config/tezgah/bin/tezgah-index` | The index worker `tezgah-dsh` warms before it starts dsh. |
 | `TEZGAH_STATUS_BIN` | `hosts/dsh/statusline/lib/index.js:24`, `hosts/opencode/tui/tezgah-tui.tsx` | `~/.config/tezgah/bin/tezgah-status` | The status renderer the dsh status line and the opencode TUI call. |
@@ -73,7 +74,7 @@ the kill switches are files, not variables, and live in
 
 | Variable | Read by | Default | Effect |
 |---|---|---|---|
-| `OMPCODE`, `CLAUDECODE` | `hooks/tezgah_paths.py::session_cli`, `bin/consult`, `hooks/tezgah_models.py::worker_model` | set by the host | Name the host session: the judgement seam asks that host's CLI first (`OMPCODE` wins, omp sets both). The test suite unsets both. |
+| `OMPCODE`, `CLAUDECODE`, `OPENCODE`, `CURSOR_AGENT`, `CURSOR_VERSION`, `CODEX_THREAD_ID` | `hooks/tezgah_paths.py::session_cli` (all), `bin/consult`, `hooks/tezgah_models.py::worker_model` (the first two) | set by the host | Name the host session: the judgement seam asks that host's CLI first, in the order listed (omp sets both of the first two, so `OMPCODE` wins; Cursor sets `CURSOR_AGENT` in its shell tool and `CURSOR_VERSION` in its hooks; Codex sets `CODEX_THREAD_ID` in its shell tool only). The test suite unsets all of them. |
 | `TYPESAFE_API_KEY` | `hooks/tezgah_judge.py::key`, `hooks/tezgah_paths.py` | `~/.config/typesafe/key` | The judgement seam's first third-party credential, used as `fallback` in `config.json` allows ([judge](judge.md)); omp also reads it for its own judge. |
 | `OPENROUTER_API_KEY` | `hooks/tezgah_judge.py::openrouter_key`, `bin/consult`, `bin/codegen`, `hooks/tezgah_models.py` | `~/.config/openrouter/key` | The seam's chat fallback, consult's and codegen's `openrouter` provider, and omp's `any` family. |
 | `DEEPSEEK_API_KEY`, `INCEPTION_API_KEY` | `bin/consult`, `bin/codegen`, `hooks/tezgah_replay.py::label_model` | `~/.config/deepseek/key`, `~/.config/inception/key` | The `deepseek` and `inception` providers of consult and codegen; `DEEPSEEK_API_KEY` alone is also the replay sheet's `--provider deepseek` rater. |
@@ -82,6 +83,7 @@ the kill switches are files, not variables, and live in
 | `TEZGAH_OPENROUTER_URL` | `hooks/tezgah_judge.py::openrouter_url` | OpenRouter's chat-completions URL | Repoints the seam's chat fallback (tests). Plain `http` is refused unless the host is this machine. |
 | `TEZGAH_DEEPSEEK_URL` | `hooks/tezgah_replay.py::_deepseek` | `https://api.deepseek.com/chat/completions` | Repoints the replay sheet's `--provider deepseek` rater (tests). Plain `http` is refused unless the host is this machine. |
 | `TEZGAH_JUDGE_MODEL` | `hooks/tezgah_judge.py::fallback_model` | the cheap `any` row of the models table | The model the seam's chat fallback asks. |
+| `TEZGAH_JUDGE_CLI` | `hooks/tezgah_paths.py::session_cli` | `judge_cli` in `config.json`, else `auto` | The session CLI the judgement seam asks: `omp`, `claude`, `opencode`, `cursor` or `codex`, or `auto` to read the host's marker. A named CLI that is not installed means no session CLI, never another one. |
 
 ## consult and codegen
 

package/docs/evidence.md

@@ -785,11 +785,12 @@ one rater's totals would show the other rater those labels.
 
 `replay --label-model --prompt <file>` is rater 2 when that rater is a model. It sends each sheet
 row to the judge seam (`hooks/tezgah_judge.py`) as one `choice` question and writes
-`labels-model.jsonl` beside the sheet. It redacts the row's text first (`ti.redact`), and it runs
-only when TypeSafe answers. The prompt file holds each set's instructions and criteria. A reply
+`labels-model.jsonl` beside the sheet. It redacts the row's text first (`ti.redact`). It runs
+only when a Jev carrier answers: TypeSafe, OpenRouter System One, Cloudflare Workers AI or a
+compatible endpoint. `--provider jev` names it, and the old name `typesafe` still works. The prompt file holds each set's instructions and criteria. A reply
 with no label from those criteria leaves its row unlabelled. The command writes each label as it
 arrives, so a run that stops early keeps what it paid for. A second run asks only the unlabelled rows. Every run prints the input tokens and their cost. The sheet rows leave the machine for
-`api.typesafe.ai`. The key and the corpus stay on it. Kappa against a model rater
+the Jev carrier's endpoint. The key and the corpus stay on it. Kappa against a model rater
 measures human-model agreement, not inter-rater reliability.
 
 `--provider deepseek --model deepseek-v4-pro` asks the same questions from the same prompt file

package/docs/glossary.md

@@ -98,7 +98,7 @@ A mark consumed by its own first use, so the thing it protects happens once: the
 An opt-out file in the repo tree - `.no-ponytail`, `.no-adhd`, `.no-graph`, `.no-lessons`, `.no-taste` - collected by `repo_marks()` walking up to the enclosing root (`hooks/tezgah_context.py::repo_marks`). Not a [kill switch](#kill-switch): a mark travels with the repo, a switch with the machine.
 
 ### plan
-A piece of work spanning sessions, one markdown file with frontmatter under `<repo root>/.tezgah/plans/open/`, moved to `.tezgah/plans/done/` when closed, up to three of them injected by `open_plans()` (`hooks/tezgah_context.py::open_plans`) and its work happening on a `plan/NNN-slug` branch. Not a TODO in code.
+A piece of work spanning sessions, one markdown file with frontmatter under `<repo root>/.tezgah/plans/open/`, moved to `.tezgah/plans/done/` when closed, up to three of them injected by `open_plans()` (`hooks/tezgah_context.py::open_plans`) and its work happening on a `plan/NNN-slug` branch. An optional `after:` names the plans it waits on, and `tezgah-task status` reads it with the ticked Acceptance boxes (`hooks/tezgah_task.py::queue`). Not a TODO in code, and not the host's session todo list, which no reader syncs with it.
 
 ### plan table
 The status table in `.tezgah/plans/README.md` (`.tezgah/plans/README.md:9`), owned by the `plan-status` skill (`skills/plan-status/SKILL.md:1`) and among the first blocks the [budget](#budget) gives up because it lives on disk (`hooks/tezgah_context.py::DROP_ORDER`). Not the injected list of open plans.

package/docs/judge.md

@@ -14,9 +14,10 @@ the kill-switch paragraph and nothing else (`CORE`,
 One seam, five callers, one provider order, one egress boundary, one price, one
 redirect guard. The module is stdlib only and total - a failure is a `None`, never
 an exception, because a hook imports it and a hook that raises takes a session
-down (`_request`, `hooks/tezgah_judge.py::_request`). One endpoint and one key path
-are module constants (`URL`, `hooks/tezgah_judge.py::URL`; `KEY_FILE`,
-`hooks/tezgah_judge.py::KEY_FILE`), one opener is shared by every call (`OPENER`,
+down (`_request`, `hooks/tezgah_judge.py::_request`). The carriers' endpoints are
+module constants: `URL` (`hooks/tezgah_judge.py::URL`), `JEV_OPENROUTER_URL`
+(`hooks/tezgah_judge.py::JEV_OPENROUTER_URL`) and `CLOUDFLARE_URL`
+(`hooks/tezgah_judge.py::CLOUDFLARE_URL`). One opener serves every call (`OPENER`,
 `hooks/tezgah_judge.py::OPENER`), and it refuses a redirect that leaves the
 endpoint's host, so a `Location` cannot carry the bearer (`guarded_opener`,
 `hooks/tezgah_paths.py`, the one copy `bin/consult` and `bin/codegen` use too). A
@@ -25,15 +26,18 @@ attempt. A 4xx, a session CLI's non-zero exit and a malformed reply never do
 (`_transient`, `hooks/tezgah_judge.py::_transient`). A hook caller asks for one
 attempt and a wall-clock `deadline` instead (`ask`, `hooks/tezgah_judge.py::ask`).
 A session CLI answers in 4-10 s (measured 2026-10-07), so the skill hint's
-4 s deadline usually ends first. `TEZGAH_TYPESAFE_URL`, `TEZGAH_OPENROUTER_URL`
-and `TEZGAH_OMP_BIN`/`TEZGAH_CLAUDE_BIN` are the test seams.
+4 s deadline usually ends first. `TEZGAH_TYPESAFE_URL`, `TEZGAH_JEV_OPENROUTER_URL`,
+`TEZGAH_CLOUDFLARE_URL`, `TEZGAH_OPENROUTER_URL` and
+`TEZGAH_OMP_BIN`/`TEZGAH_CLAUDE_BIN` are the test seams. Each URL override goes
+through `override` (`hooks/tezgah_judge.py::override`), which refuses plain http
+off this machine.
 
 Every caller reads an answer through the same accessors rather than reaching
 into the raw reply, so a Choice and a Noul are read one way for all five
 (`choice`, `hooks/tezgah_judge.py::choice`; `noul`,
 `hooks/tezgah_judge.py::noul`). A `text` question is the one shape that asks
 for prose. `bin/tezgah-taste` asks it for a learning's readable line, and only
-a generative provider answers one. TypeSafe is never sent one (`text`,
+a generative provider answers one. No Jev carrier is sent one (`text`,
 `hooks/tezgah_judge.py::text`). All three are total: a missing or
 wrongly-typed answer is a `None`, never an exception.
 
@@ -44,9 +48,11 @@ are untouched, so a model answer can never license a "done" (`STEP_KINDS`,
 
 The state leaves the machine. By default it goes to the session's own vendor,
 through the session's own CLI and credential ([below](#the-providers-and-their-order)).
-A third party - `api.typesafe.ai` or `openrouter.ai` (`OPENROUTER_URL`,
-`hooks/tezgah_judge.py::OPENROUTER_URL`) - reads it only as the `fallback`
-setting allows. For the triage the state is the screen's own text, so whoever
+A third party reads it only as the `fallback` setting allows. The third parties
+are the Jev carriers' hosts - `api.typesafe.ai`, `openrouter.ai`,
+`api.cloudflare.com` or a user's `JEV_API_BASE_URL` - and the chat endpoint
+(`OPENROUTER_URL`, `hooks/tezgah_judge.py::OPENROUTER_URL`).
+For the triage the state is the screen's own text, so whoever
 answers reads any personal data on it. For the docs fallback it is the query.
 Nothing else goes: no session id, no
 workspace path, no environment. The seam does not rewrite the state, because
@@ -89,18 +95,74 @@ background `learn` that armed taste starts.
 
 `providers()` (`hooks/tezgah_judge.py::providers`) is the order `ask()` tries.
 The next one is asked only when the previous failed. First comes the session's own
-CLI (`tp.session_cli`, `hooks/tezgah_paths.py::session_cli`): `omp` when
-`OMPCODE` is set, else `claude` when `CLAUDECODE` is. It runs headless with no
-tools, rules, skills, extensions, MCP servers or settings (`SESSION_ARGV`,
-`hooks/tezgah_judge.py::SESSION_ARGV`). Measured 2026-10-07, a call cost $0.007
-on claude and $0.015 on omp. The session's own credential pays, OAuth subscription
-included. The model and usage are read from the CLI's JSON output
-(`_session_request`, `hooks/tezgah_judge.py::_session_request`). Then come the
-third parties. TypeSafe reads `TYPESAFE_API_KEY`, else `~/.config/typesafe/key`
-(`key`, `hooks/tezgah_judge.py::key`). OpenRouter reads `OPENROUTER_API_KEY`, else
-`~/.config/openrouter/key` (`openrouter_key`, `hooks/tezgah_judge.py::openrouter_key`).
+CLI (`tp.session_cli`, `hooks/tezgah_paths.py::session_cli`). The host's marker
+names it, in this order:
+
+| CLI | Marker | Set by |
+|---|---|---|
+| `omp` | `OMPCODE` | omp, which sets `CLAUDECODE` too |
+| `claude` | `CLAUDECODE` | Claude Code |
+| `opencode` | `OPENCODE` | opencode, in its own process |
+| `cursor` (runs `cursor-agent`) | `CURSOR_AGENT`, `CURSOR_VERSION` | Cursor: the first in its shell tool, the second in its hooks |
+| `codex` | `CODEX_THREAD_ID` | Codex in its shell tool; tezgah's Codex hook sets it from the session id |
+
+A marked host whose binary is missing has no session CLI. No other CLI stands
+in. `TEZGAH_JUDGE_CLI`, else `judge_cli` in `~/.config/tezgah/config.json`,
+names one of the five instead. `auto`, the default, reads the marker. A named CLI
+that is not installed is no session CLI either.
+
+The CLI runs headless in an empty temp dir. Its flags are `SESSION_ARGV`
+(`hooks/tezgah_judge.py::SESSION_ARGV`). The omp and claude runs drop tools,
+rules, skills, extensions, MCP servers and settings. The other three have no flag
+that drops their tools or takes a system prompt. They run with the least their
+`--help` offers: opencode `--pure`, cursor-agent `--mode ask`, codex
+`-s read-only --ephemeral`. Their prompt starts with the system prompt.
+`opencode run` ran a shell command its prompt asked for in a probe on
+2026-10-09. So it also gets an inline config that denies every tool
+(`SESSION_ENV`, `hooks/tezgah_judge.py::SESSION_ENV`). With it, the same probe
+wrote nothing. cursor-agent in ask mode refused the same shell call.
+Measured 2026-10-07, a call cost $0.007 on claude and $0.015 on omp. Measured
+2026-10-09 on one choice question, opencode read 28,646 input tokens ($0.004 by
+its own report), cursor-agent 17,095 and codex 20,919. The session's own
+credential pays, OAuth subscription included. The answer and usage come from the
+CLI's JSON output (`_session_request`, `hooks/tezgah_judge.py::_session_request`).
+`_cli_answer` (`hooks/tezgah_judge.py::_cli_answer`) reads the last three. Only
+omp and claude name the model. Then come the
+third parties: first the chosen Jev carriers, each a real System One transport
+(`_jev_call`, `hooks/tezgah_judge.py::_jev_call`), then the OpenRouter chat
+fallback. `JEV_CARRIERS` (`hooks/tezgah_judge.py::JEV_CARRIERS`) names the six.
+Two of them are not Jev. Clef and Clef-flash are Cloudflare's own decision
+models. They take the same System One request. They answer in the same typed
+shape, so a caller that needs a typed answer takes them like Jev.
+
+| Carrier | Endpoint | Credential (env, else file, stripped) | Body |
+|---|---|---|---|
+| `typesafe` | `https://api.typesafe.ai/v1/systemone` | `TYPESAFE_API_KEY`, else `~/.config/typesafe/key`, else the active omp login (`~/.omp/agent/agent.db`, read-only; `typesafe_key`, `hooks/tezgah_paths.py::typesafe_key`) | `{state, model, questions}` |
+| `jev-openrouter` | `https://openrouter.ai/api/v1/systemone` | `OPENROUTER_API_KEY`, else `~/.config/openrouter/key` | the same, a bare `jev-*` id sent as `typesafe/<id>` |
+| `jev-cloudflare` | `https://api.cloudflare.com/client/v4/accounts/<id>/ai/run` | `JEV_CLOUDFLARE_API_TOKEN`, else `CLOUDFLARE_API_TOKEN`, else `~/.config/cloudflare/token`; the account id from `CLOUDFLARE_ACCOUNT_ID`, else `~/.config/cloudflare/account_id` | `{model: "typesafe/jev", input: {state, questions}}`; the reply is read bare or inside `result` |
+| `jev-compatible` | `JEV_API_BASE_URL`, used verbatim | `JEV_API_KEY` | TypeSafe's, the model from `TEZGAH_JEV_MODEL` if set |
+| `clef`, `clef-flash` | `https://api.cloudflare.com/client/v4/accounts/<id>/ai/run/@cf/cloudflare/<name>` | the Cloudflare token and account id above | `{model: "<name>", state, questions}`; the reply read like Cloudflare's above |
+
+`JEV_API_BASE_URL` and `JEV_API_KEY` are the names the public jev-mcp server
+reads, so one export serves both. `TEZGAH_JEV_PROVIDER` chooses the carrier,
+else `JEV_PROVIDER`, else `jev` in `~/.config/tezgah/config.json`, else `auto`
+(`jev_choice`, `hooks/tezgah_paths.py::jev_choice`). The values are `auto`,
+`typesafe`, `openrouter`, `cloudflare`, `compatible`, `clef` and `clef-flash`.
+`tezgah-setup --jev <value>` writes the config key
+(`set_jev`, `bin/tezgah-setup::set_jev`). `auto`
+asks every carrier that resolves, in the table's order (`jev_carriers`,
+`hooks/tezgah_paths.py::jev_carriers`). The seam asks a named carrier without
+its credential nothing, and nothing stands in for it: the call records
+`no credential (jev=<value>)` as a failure. `tezgah-status --judge` prints the
+choice and the carriers it resolves to (`jev_summary`,
+`hooks/tezgah_judge.py::jev_summary`). A cost row prices the carrier that
+answered (`input_price`, `hooks/tezgah_judge.py::input_price`). Per 1M input
+tokens: $0.042 for Jev, $0.24 for Clef, $0.09 for Clef-flash. Output is free.
+
+OpenRouter's chat fallback reads the OpenRouter key (`openrouter_key`,
+`hooks/tezgah_judge.py::openrouter_key`).
 It asks the table's cheap row unless `TEZGAH_JUDGE_MODEL` names another
-(`fallback_model`, `hooks/tezgah_judge.py::fallback_model`). The key file is
+(`fallback_model`, `hooks/tezgah_judge.py::fallback_model`). The key files are
 read because a hook runs where `~/.zshenv` never did. A chat answer is asked for in prose
 (`CHAT_SYSTEM`, `hooks/tezgah_judge.py::CHAT_SYSTEM`) and filtered to the ids
 asked, a wrongly typed answer dropped (`_chat_answers`,
@@ -111,8 +173,8 @@ asked, a wrongly typed answer dropped (`_chat_answers`,
 
 | `fallback` | Session CLI present | No session CLI |
 |---|---|---|
-| `vendor` (default) | the session CLI only; when it fails, no judgement | TypeSafe, then OpenRouter |
-| `any` | the session CLI, then TypeSafe, then OpenRouter | TypeSafe, then OpenRouter |
+| `vendor` (default) | the session CLI only; when it fails, no judgement | the Jev carriers, then the chat fallback |
+| `any` | the session CLI, then the Jev carriers, then the chat fallback | the Jev carriers, then the chat fallback |
 | `none` | the session CLI only | nobody: `available()` is false |
 
 Nothing that stands in is silent. A result carries `provider`, the `model`
@@ -124,7 +186,7 @@ hint's cost row and the router's `route` row also carry `judge=<provider>/<model
 
 A caller that needs one provider in particular passes `only` (`named`,
 `hooks/tezgah_judge.py::named`). `learn`'s decision has to come from a typed
-model, so it passes `only=("typesafe",)`. It gets `None` rather than another
+model, so it passes `only=("jev",)`, every Jev carrier that resolves. It gets `None` rather than another
 provider's answer. The caller named the provider, so the `vendor` order does not
 apply. `none` still keeps every third party out.
 
@@ -173,8 +235,9 @@ known (`note`, `hooks/tezgah_integrity.py::note`), counted by the row's kind
    costs a fraction of a cent, so a cache is not worth its state file, and a naive
    one would make two runs of the same command disagree. Beside the last-use
    record, the seam keeps a failure marker (`DOWN_FOR`, 300 s, in `hooks/tezgah_judge.py`). A
-   call that ends on a 401, 402, 5xx or a session CLI's non-zero exit marks that
-   provider, endpoint and credential down for five minutes. Until the marker
+   401, 402, 403, 5xx or a session CLI's non-zero exit marks that
+   provider, endpoint and credential down for five minutes. A 403 is OpenRouter's
+   answer to a key past its limit. Until the marker
    expires, that provider is skipped and sent no request. A dead key or an empty account then costs
    one refusal per five minutes, not one per prompt. A rotated key gets a new
    marker, so the seam asks it at once.
@@ -193,8 +256,11 @@ known (`note`, `hooks/tezgah_integrity.py::note`), counted by the row's kind
 
 ## Source of truth
 
-- `hooks/tezgah_judge.py` — the seam: endpoint, key path, `available()`, `ask()`,
-  the answer accessors, the retry class and the provider-down marker.
+- `hooks/tezgah_judge.py` — the seam: the carriers' endpoints and bodies,
+  `available()`, `ask()`, the answer accessors, the retry class and the
+  provider-down marker.
+- `hooks/tezgah_paths.py` — the key channels (`typesafe_key`, `jev_carriers`)
+  and the carrier choice (`jev_choice`).
 - `bin/tezgah-triage` — the snapshot triage and the per-state matrix; prints the
   unit it selected, the characters it saved and the cost it paid.
 - `bin/tezgah-docs` — the page router; its index match, then its one fallback