@r1z4x/tezgah 1.4.0 → 1.5.1

package/hooks/tezgah_paths.py

@@ -499,32 +499,144 @@ def have_typesafe_key():
 def have_judge_key():
     """True when tezgah's own judgement seam can ask anyone: the session's own
     CLI (`session_cli()`), else - when the `fallback` setting lets a third party
-    answer - the TypeSafe env var or key file, then the OpenRouter fallback's own
-    two channels (`OPENROUTER_API_KEY`, `~/.config/openrouter/key`), which are
-    the channels `hooks/tezgah_judge.py`'s `providers()` picks between. This is
-    what `bin/tezgah-triage`, `bin/tezgah-docs` and the skill picker spend. Never
-    omp's login store: the seam does not open it.
+    answer - a chosen Jev carrier's credential (`jev_carriers()`) or the
+    OpenRouter chat fallback's own two channels (`OPENROUTER_API_KEY`,
+    `~/.config/openrouter/key`), which are the channels `hooks/tezgah_judge.py`'s
+    `providers()` picks between. This is what `bin/tezgah-triage`,
+    `bin/tezgah-docs` and the skill picker spend.
 
     Kept next to `have_typesafe_key()` because the two are asked together and a
     report that showed one answer under both questions was wrong in both
-    directions - a key file alone (seam works, omp does not) and a login-store
-    record alone (omp works, seam does not). A blank file is not a credential
-    here either, so this stays in step with the seam's own `strip() or None`."""
+    directions - a key file alone serves the seam and not omp. A blank file is
+    not a credential here either, so this stays in step with the seam's own
+    `strip() or None`."""
     if session_cli():
         return True
     if fallback_policy() == "none":
         return False
-    for env, home in (("TYPESAFE_API_KEY", ".config/typesafe/key"),
-                      ("OPENROUTER_API_KEY", ".config/openrouter/key")):
-        if os.environ.get(env, "").strip():
-            return True
+    return bool(openrouter_key() or any(s for _, s in jev_carriers()))
+
+
+def key_from(envs, path):
+    """The first non-blank env var of `envs`, else the file at `path` (`~`
+    expanded), else None - stripped either way, because a newline inside an
+    Authorization header is an injection, not a typo. The file is the channel a
+    hook needs: it runs where `~/.zshenv` never exported the variable."""
+    for env in envs:
+        value = os.environ.get(env, "").strip()
+        if value:
+            return value
+    try:
+        with open(os.path.expanduser(path), encoding="utf-8") as fh:
+            return fh.read().strip() or None
+    except OSError:
+        return None
+
+
+def omp_login_key(provider):
+    """The API key omp's login store holds for `provider` (`omp auth login`),
+    stripped, else None: the newest enabled `api_key` row's `data.key`, read
+    read-only. Any error - no store, another schema, a locked file - is None."""
+    import sqlite3  # deferred: see have_typesafe_key()
+    store = os.path.join(os.path.expanduser("~"), ".omp", "agent", "agent.db")
+    try:
+        conn = sqlite3.connect("file:%s?mode=ro" % store, uri=True)
         try:
-            with open(os.path.join(HOME, home), encoding="utf-8") as fh:
-                if fh.read().strip():
-                    return True
-        except OSError:
-            pass
-    return False
+            rows = conn.execute(
+                "select data from auth_credentials where provider = ? and "
+                "disabled_cause is null order by id desc", (provider,)).fetchall()
+        finally:
+            conn.close()
+    except (sqlite3.Error, OSError):
+        return None
+    for (data,) in rows:
+        try:
+            value = json.loads(data).get("key")
+        except (TypeError, ValueError, AttributeError):
+            continue
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def typesafe_key():
+    """TypeSafe's credential: TYPESAFE_API_KEY, else `~/.config/typesafe/key`,
+    else the active omp login (`omp_login_key("typesafe")`), else None."""
+    return (key_from(("TYPESAFE_API_KEY",), "~/.config/typesafe/key")
+            or omp_login_key("typesafe"))
+
+
+def openrouter_key():
+    """OpenRouter's credential: OPENROUTER_API_KEY, else its key file."""
+    return key_from(("OPENROUTER_API_KEY",), "~/.config/openrouter/key")
+
+
+def cloudflare_account():
+    """The Workers AI account id: CLOUDFLARE_ACCOUNT_ID, else its file."""
+    return key_from(("CLOUDFLARE_ACCOUNT_ID",), "~/.config/cloudflare/account_id")
+
+
+def cloudflare_token():
+    """The Workers AI token: JEV_CLOUDFLARE_API_TOKEN, else CLOUDFLARE_API_TOKEN,
+    else `~/.config/cloudflare/token`."""
+    return key_from(("JEV_CLOUDFLARE_API_TOKEN", "CLOUDFLARE_API_TOKEN"),
+                    "~/.config/cloudflare/token")
+
+
+# The Jev carrier a user may choose (`jev_choice()`), and the order `auto`
+# tries them in: TypeSafe direct, OpenRouter's System One endpoint, Cloudflare
+# Workers AI, any System One-compatible URL (JEV_API_BASE_URL + JEV_API_KEY,
+# the names the public jev-mcp server reads), then Cloudflare's own System One
+# models Clef and Clef-flash on Workers AI (the same Cloudflare credential).
+JEV_CHOICES = ("auto", "typesafe", "openrouter", "cloudflare", "compatible",
+               "clef", "clef-flash")
+
+
+def jev_name(value):
+    """A carrier choice as written by a user, lowercased and with the Workers AI
+    catalog prefix dropped: `@cf/cloudflare/clef-flash` is what Cloudflare's
+    dashboard and docs show, and it names the `clef-flash` carrier."""
+    value = value.strip().lower()
+    return value[len("@cf/cloudflare/"):] if value.startswith("@cf/cloudflare/") else value
+
+
+def jev_choice():
+    """TEZGAH_JEV_PROVIDER, else JEV_PROVIDER (jev-mcp's name), else config.json
+    `jev`, else `auto` - through `jev_name`. An unknown value is kept, so it
+    resolves to no carrier instead of silently to another one."""
+    for env in ("TEZGAH_JEV_PROVIDER", "JEV_PROVIDER"):
+        value = jev_name(os.environ.get(env, ""))
+        if value:
+            return value
+    cfg = config()
+    value = cfg.get("jev") if isinstance(cfg, dict) else None
+    value = jev_name(value) if isinstance(value, str) else ""
+    return value or "auto"
+
+
+def jev_carriers():
+    """[(carrier, secret), ...] the chosen Jev carriers in the order the seam
+    asks them. `auto`: every carrier whose credential resolves. A named one: that
+    carrier alone, its secret None when it does not resolve - the seam records
+    why rather than substituting another carrier. Only the chosen carrier's
+    credential is read: the status line asks this on every redraw, and the
+    TypeSafe channel ends in omp's login database."""
+    def compatible():
+        return (os.environ.get("JEV_API_KEY", "").strip() or None
+                if os.environ.get("JEV_API_BASE_URL", "").strip() else None)
+
+    def workers_ai():
+        return cloudflare_token() if cloudflare_account() else None
+    found = [("typesafe", typesafe_key), ("jev-openrouter", openrouter_key),
+             ("jev-cloudflare", workers_ai), ("jev-compatible", compatible),
+             ("clef", workers_ai), ("clef-flash", workers_ai)]
+    choice = jev_choice()
+    if choice == "auto":
+        return [(name, secret) for name, secret in ((n, read()) for n, read in found)
+                if secret]
+    name = choice if choice in ("typesafe", "clef", "clef-flash") else "jev-" + choice
+    read = dict(found).get(name)
+    return [(name, read() if read else None)]
 
 
 # How far a model call may leave the session's own vendor (config.json
@@ -544,16 +656,39 @@ def fallback_policy():
     return value if value in FALLBACKS else "vendor"
 
 
+# The session CLIs the judgement seam can ask, in detection order, each with
+# the env vars its host sets in the processes it spawns. omp sets CLAUDECODE
+# too, so it comes first. opencode sets OPENCODE=1 in its own process at start
+# (`process.env.OPENCODE="1"` in the 1.18.31 binary), so its plugin's children
+# and its shell tool inherit it. cursor-agent gives its shell tool CURSOR_AGENT=1
+# and its hooks CURSOR_VERSION (`buildHookEnvironment` in the 2026.10.01
+# bundle). codex gives its shell tool CODEX_THREAD_ID (codex-rs
+# protocol/src/shell_environment.rs `populate_env`); its hooks get only codex's
+# own process env (codex-rs hooks/src/registry.rs), so a codex hook names no
+# session - `judge_cli` picks it there.
+SESSION_CLIS = (("omp", ("OMPCODE",)), ("claude", ("CLAUDECODE",)),
+                ("opencode", ("OPENCODE",)), ("cursor", ("CURSOR_AGENT", "CURSOR_VERSION")),
+                ("codex", ("CODEX_THREAD_ID",)))
+
+
 def session_cli():
-    """`omp` or `claude` - the CLI of the host this process runs under, when it
-    is installed - else None. omp sets CLAUDECODE too, so OMPCODE is read first,
-    and an omp session whose binary is missing is None rather than Claude: the
-    session's credential is omp's, not whatever `claude` is logged in as."""
-    if os.environ.get("OMPCODE"):
-        return "omp" if omp_bin() else None
-    if os.environ.get("CLAUDECODE"):
-        return "claude" if claude_bin() else None
-    return None
+    """The session CLI the judgement seam asks - `omp`, `claude`, `opencode`,
+    `cursor` or `codex` - else None.
+
+    TEZGAH_JUDGE_CLI, else config.json `judge_cli`, picks one by name; `auto`
+    (the default, and any other value) reads the host this process runs under:
+    the first CLI in SESSION_CLIS whose marker is set. Either way the answer is
+    None when that CLI's binary is missing - an omp session is not handed to
+    whatever `claude` is logged in as, and a picked CLI has no stand-in."""
+    bins = {"omp": omp_bin, "claude": claude_bin, "opencode": opencode_bin,
+            "cursor": cursor_bin, "codex": codex_bin}
+    cfg = config()
+    pick = (os.environ.get("TEZGAH_JUDGE_CLI", "").strip()
+            or (cfg.get("judge_cli") if isinstance(cfg, dict) else None))
+    if not isinstance(pick, str) or pick not in bins:
+        pick = next((name for name, markers in SESSION_CLIS
+                     if any(os.environ.get(m) for m in markers)), None)
+    return pick if pick and bins[pick]() else None
 
 
 def orx_bin():
@@ -584,6 +719,24 @@ def claude_bin():
     return which_user(os.environ.get("TEZGAH_CLAUDE_BIN") or "claude")
 
 
+def opencode_bin():
+    """The opencode CLI (TEZGAH_OPENCODE_BIN, else `opencode`), or None - the
+    lookup `omp_bin()` makes."""
+    return which_user(os.environ.get("TEZGAH_OPENCODE_BIN") or "opencode")
+
+
+def cursor_bin():
+    """Cursor's agent CLI (TEZGAH_CURSOR_BIN, else `cursor-agent`), or None -
+    the lookup `omp_bin()` makes."""
+    return which_user(os.environ.get("TEZGAH_CURSOR_BIN") or "cursor-agent")
+
+
+def codex_bin():
+    """The Codex CLI (TEZGAH_CODEX_BIN, else `codex`), or None - the lookup
+    `omp_bin()` makes."""
+    return which_user(os.environ.get("TEZGAH_CODEX_BIN") or "codex")
+
+
 # The values `reply_lang` (config.json) takes. The value itself is the switch:
 # `tr` (the default, and what an install without the key reads) asks for Turkish
 # replies, `en` for English ones, and `any` drops the Stop language check.

package/hooks/tezgah_policy.py

@@ -237,7 +237,15 @@ rewrite it plainly.
 on a merge. Review first with a FRESH reviewer (never my own read of my own
 code), run the full suite, and if the review is clean and every test passes,
 merge, move the plan to `.tezgah/plans/done/`, and report the outcome. Bring it back
-to the user only on a critical or high-severity finding, or a failing test.
+to the user only on a critical or major finding left after round two, or a
+failing test. One review per plan, over its whole diff in the verification
+phase; at most two rounds - only a confirmed critical or major finding opens
+round two, a minor or suggestion one is recorded fix-later, and after round two
+what is left goes to the user or is recorded fix-later, never a third round.
+A round spawns its reviewers in ONE message, one per dimension (correctness
+and contract, security, tests and performance) or file group; a diff under 300
+changed lines gets one reviewer. Per-task work gets tests, not a reviewer, and
+`tezgah-task review` refuses a third round.
 
 **Attribution: none, anywhere, ever.** Nothing you persist or publish may name
 the assistant, model, vendor or "AI" as author, co-author, generator or helper -
@@ -283,9 +291,11 @@ independent work remains. Fan out only when
 the subtasks share no mutable file and no interface: if two of them would edit
 the same file, or one's answer decides the other's, keep them in one context or
 sequence them. The shared artifact is the coordination channel, not chatter -
-naming a lead coordinates nothing by itself. If the work
-cannot be split - one file, one bounded change, a strictly serial chain - do it
-directly. Never spawn a subagent whose briefing is bigger than the work.
+naming a lead coordinates nothing by itself. Only a single item - one file, one
+bounded change, a strictly serial chain - is done directly; a list of
+independent items is never worked one by one on the main thread, however small
+each item is, and that holds at every phase: a plan's tasks, its acceptance
+commands and the sources of a survey fan out the same way.
 A slice that needs its own checkout: inside Orca (the session-start `Orca:`
 line) create it with `orca worktree create --name <slug> --parent-worktree
 active --json` and track it with `orca worktree ps --json` or `tezgah-status
@@ -293,8 +303,10 @@ active --json` and track it with `orca worktree ps --json` or `tezgah-status
 status in Orca; outside Orca, `git worktree add`. Either way the brief names
 absolute paths under that checkout.
 Routing: `{ROUTE_BIN} "<brief>"` names the worker - tezgah-cheap, -standard or
--frontier (overrides for stored data, credentials, security first; then a Jev
-judgement; the static phase table with no key). A worker that answers
+-frontier, or the specialist whose whole job the brief is (tezgah-tester,
+-docs, -security, -ui, -researcher, -reviewer) - and the spawn uses that name,
+never the host's generic task agent (overrides for stored data, credentials,
+security first; then a Jev judgement; the static phase table with no key). A worker that answers
 `ESCALATE:` is restarted on tezgah-frontier with the original brief, never
 continued; the main thread never switches model (the cache is per model). A
 code-discovery brief names codegraph's tools (`codegraph callers`, `callees`,
@@ -330,7 +342,8 @@ guards against.
 
 ### The gate, for anything either tier produces
 Read the diff yourself. Then tests, lint and type check must pass, and anything
-non-trivial gets an independent review before it lands. A delegate's output is
+non-trivial gets an independent review before it lands - once per plan, not
+per task or commit. A delegate's output is
 a draft until the router has evidence; "the agent said it works" is not
 evidence.
 
@@ -897,8 +910,14 @@ project root and never `git add -f` anything under `.tezgah/`. Off:
 **Parallel by default: fan out independent items.** A request with two or
 more independent items - a numbered or bulleted list, several files or areas, a
 todo list whose entries share no file and no interface - is delegated without
-being asked: one subagent per item, all spawned in ONE message, while the main
-thread decomposes, integrates, verifies and reports. Every writing slice gets
+being asked: count the independent items, spawn one subagent per item in ONE
+message, and keep the main thread for decomposing, integrating, verifying and
+reporting. It holds at every phase, not only the first message: a plan's tasks,
+its acceptance commands and the sources of a survey are items too, and checks
+that share no state are tool calls in one message, never a queue (one suite run
+at a time: two runs of one suite storm the CPU and race on its temp state).
+No item is too small to delegate while another runs beside it; only a single
+item is done inline. Every writing slice gets
 its own branch and checkout - inside Orca `orca worktree create --name <slug>
 --parent-worktree active --json`, else `git worktree add -b <branch> <absolute
 path>`; its brief names every read, edit and shell `cwd` as an absolute path
@@ -907,7 +926,8 @@ not grow. Read-only slices need no worktree. Pick each agent by task class from
 the specialists line; `{ROUTE_BIN}` names the tier for code work. Serialize
 only a real dependency - one slice's output is another's input, or two slices
 edit one file - and say which. Never wait idle on a spawned slice while
-independent work remains. Off: `orchestrate-off`.
+independent work remains. A subagent does its own slice and never fans out
+again. Off: `orchestrate-off`.
 
 **Kill switches:** each one removes its own rule from this text, not just the
 status mark. `~/.config/tezgah/`: `exec-mode.off`, `orchestrate-off`,
@@ -928,6 +948,17 @@ The ponytail intensity level is not a switch: `tezgah-pony lite|full|ultra`.
 # CORE_RULES labels in hooks/tezgah_context.py.
 CONDITIONAL_KEYS = ("spec", "consult", "research", "product", "graph", "fanout")
 
+# The fan-out rule's action, which the one-line repeat of an armed paragraph
+# (hooks/tezgah_context.armed_again) carries: a bare "Armed again" named a rule
+# the session had to recall, and the second list of a session was worked one
+# item at a time. It is the paragraph's own clause, cut to one sentence.
+FANOUT_ACTION = ("count the independent items, spawn one subagent per item in "
+                 "ONE message, each the agent `tezgah-route` names - a specialist "
+                 "by name, never the generic task agent - (each writing slice in "
+                 "its own worktree, absolute paths), and keep the main thread for "
+                 "integrating and verifying; a subagent does its own slice and "
+                 "never fans out again.")
+
 # The always-on replacement for the conditional paragraphs: one line each so a
 # host without a per-turn hook still knows the rule exists and where the full
 # text lives.

package/hooks/tezgah_replay.py

@@ -6,7 +6,7 @@ code, a blind label sheet drawn from them, and the report that reads the labels
   tezgah-gate replay [--cutoff WHEN] [--since WHEN] [--json]
   tezgah-gate replay --report [--run DIR] [--labels FILE ...] [--json]
   tezgah-gate replay --sheet [--run DIR] [--seed N] [--rules FILE]
-  tezgah-gate replay --label-model --prompt FILE [--provider typesafe|deepseek]
+  tezgah-gate replay --label-model --prompt FILE [--provider jev|deepseek]
                      [--model ID] [--run DIR]
 
 **Corpus.** Every ledger under the cache's `evidence/` is read read-only; a
@@ -864,9 +864,9 @@ def report(run, label_files=()):
 
 # ----------------------------------------------------------------- raters --
 
-# Rater 2 (H2 amendment 2026-10-07): a model through the judge seam, TypeSafe
-# only, billed per million input tokens and nothing for output, at the price
-# `bin/tezgah-triage::PRICE_PER_MILLION` quotes.
+# Rater 2 (H2 amendment 2026-10-07): the Jev model through the judge seam, any
+# Jev carrier (`tezgah_judge.JEV_CARRIERS`), billed per million input tokens and
+# nothing for output, at the price `bin/tezgah-triage::PRICE_PER_MILLION` quotes.
 RATER_MODEL = "jev-latest"
 JEV_PRICE_PER_MILLION = 0.042
 LABEL_WORKERS = 4
@@ -903,9 +903,10 @@ def _deepseek(secret, model):
     return ask
 
 
-def label_model(run, prompt_file, provider="typesafe", model=None):
+def label_model(run, prompt_file, provider="jev", model=None):
     """One `choice` question per blind sheet row, the row's text redacted
-    (`ti.redact`). `typesafe` asks through the judge seam and writes
+    (`ti.redact`). `jev` (old name `typesafe`) asks the Jev model through the
+    judge seam, whichever carrier resolves, and writes
     `labels-model.jsonl` (rater 2); `deepseek` asks DeepSeek's chat endpoint and
     writes `labels-deepseek.jsonl` (rater 1). Rows already labelled there are not
     asked again; a reply without a label among the prompt's criteria stays
@@ -920,13 +921,15 @@ def label_model(run, prompt_file, provider="typesafe", model=None):
         ask, rater = _deepseek(secret, model or "deepseek-v4-pro"), "deepseek"
         price = DEEPSEEK_PRICE_PER_MILLION
     else:
-        used = tj.credential()[0]
-        if used != "typesafe" or not tj.available():
-            raise SystemExit("label-model: the judge seam must answer through TypeSafe "
-                             "(provider: %s)" % used)
+        if tj.tp.off("judge-off") or not tj.named(("jev",)):
+            raise SystemExit("label-model: the judge seam must answer through a Jev "
+                             "carrier (TypeSafe, OpenRouter System One, Cloudflare "
+                             "Workers AI or JEV_API_BASE_URL; TEZGAH_JEV_PROVIDER picks "
+                             "one), and none resolves")
 
         def ask(state, questions):
-            return tj.ask(state, questions, model=model or RATER_MODEL, timeout=60)
+            return tj.ask(state, questions, model=model or RATER_MODEL, timeout=60,
+                          only=("jev",))
         rater, price = "model", (JEV_PRICE_PER_MILLION, 0.0)
     with open(prompt_file, encoding="utf-8") as fh:
         prompt = json.load(fh)
@@ -942,7 +945,7 @@ def label_model(run, prompt_file, provider="typesafe", model=None):
         label = tj.choice(result, "label")
         return row, result, label if label in question["criteria"] else None
 
-    tokens, out_tokens, models, new = 0, 0, Counter(), 0
+    tokens, out_tokens, models, new, spent, prices = 0, 0, Counter(), 0, 0.0, set()
     fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
     os.fchmod(fd, 0o600)
     # Each answered row is appended as it arrives, so a run that dies mid-way
@@ -953,6 +956,12 @@ def label_model(run, prompt_file, provider="typesafe", model=None):
                 tokens += result["usage"]["input_tokens"]
                 out_tokens += result["usage"]["output_tokens"]
                 models["%s/%s" % (result["provider"], result["model"])] += 1
+                # a typed carrier is billed at its own price (Clef's is not Jev's)
+                typed = tj.input_price(result["provider"])
+                row_price = (typed, 0.0) if typed is not None else price
+                prices.add(row_price)
+                spent += (result["usage"]["input_tokens"] * row_price[0]
+                          + result["usage"]["output_tokens"] * row_price[1]) / 1e6
             if label:
                 fh.write(json.dumps({"set": row["set"], "n": row["n"], "label": label,
                                      "rater": rater, "model": result["model"],
@@ -962,8 +971,9 @@ def label_model(run, prompt_file, provider="typesafe", model=None):
                 new += 1
     return {"path": path, "asked": len(todo), "labelled": new,
             "total": len(done) + new, "input_tokens": tokens, "output_tokens": out_tokens,
-            "price": price,
-            "cost_usd": (tokens * price[0] + out_tokens * price[1]) / 1e6,
+            # the printed formula names the rate the rows were billed at, when one
+            "price": prices.pop() if len(prices) == 1 else price,
+            "cost_usd": spent,
             "models": dict(models)}
 
 
@@ -1034,7 +1044,8 @@ def main(argv):
     p.add_argument("--report", action="store_true")
     p.add_argument("--label-model", action="store_true")
     p.add_argument("--prompt")
-    p.add_argument("--provider", choices=("typesafe", "deepseek"), default="typesafe")
+    # `typesafe` is the old name of `jev`, kept for the commands already written down
+    p.add_argument("--provider", choices=("jev", "typesafe", "deepseek"), default="jev")
     p.add_argument("--model")
     p.add_argument("--sheet", action="store_true")
     p.add_argument("--run")