@r1z4x/tezgah 1.4.0 → 1.5.1

package/bin/tezgah-task

@@ -5,7 +5,7 @@
   tezgah-task phase P [--any-path]                            change the active task's phase
   tezgah-task allow GLOB ... | --any-path                     replace the allowlist
   tezgah-task stop                                            deactivate (clear phase)
-  tezgah-task status [--json]                                 the active task, or "no active task"
+  tezgah-task status [--json]                                 the active task, then every open plan: progress, what it waits on, what can run at once
   tezgah-task review <NNN|path> <reviewer> approve|changes    record a fresh review's verdict
   tezgah-task close <NNN|path> done|discarded                 move a plan to .tezgah/plans/done
 
@@ -22,21 +22,27 @@ creates the plan, and `start` without `--allow` keeps it. A writing phase with
 no allowlist is refused unless `--any-path` says so explicitly, and the record
 keeps where its scope came from (`allowed_from:`), which `status` prints.
 
-`review` and `close` are the session's: the verification phase asks for a
-fresh reviewer's read of the diff, `review` records its verdict as
+`review` and `close` are the session's: the verification phase asks for one
+review of the plan's whole diff, `review` records its verdict as
 `review: <reviewer> <verdict> <date>` together with `reviewed_sha:` (the
 project's HEAD it read) and `review_round:`, so the next round reads only
-`git diff <reviewed_sha>..HEAD` and the two-round budget is countable; `close
-NNN done` refuses a plan whose review is missing or not `approve`. `close`
-refuses the active task - that one is the user's to stop first.
+`git diff <reviewed_sha>..HEAD`, and refuses a third round: the budget is two
+rounds per plan; `close NNN done` refuses a plan whose review is missing or not
+`approve`. `close` refuses the active task - that one is the user's to stop first.
 
 Two things the plan owes are asked here, at the only moment they can still be
 fixed - the phase move - because the record is the user's and the refusal is
-this CLI's: a writing phase needs at least one Acceptance item that names the
-command proving it (or says `unverifiable` and why), since the report CI runs
-afterwards reads the same items and refuses the same plan too late; and
-`implementation` needs the plan's spike answered, so the build starts on
-evidence rather than on the guess the spike exists to retire.
+this CLI's: a writing phase needs every Acceptance item to name the command
+proving it (or say `unverifiable` and why), since the report CI runs afterwards
+refuses an open plan on any one item that does neither, through the same
+predicate (`tezgah_task.unproven`); and `implementation` needs the plan's spike
+answered, so the build starts on evidence rather than on the guess the spike
+exists to retire.
+
+`status` lists every open plan after the active task: its Acceptance boxes
+ticked, the plans its `after:` still waits on, and - on a `parallel:` line - the
+ready plans whose `allowed_paths:` share no prefix, which can run at once. A
+status outside open|blocked, or an `after:` id no plan carries, is a `FAIL` line.
 
 Entering `implementation` also records where the risky work returns to: a
 `checkpoint:` field holding the pre-work commit's sha, or `pending <sha>` while
@@ -139,6 +145,14 @@ def write_fields(path, **fields):
 
 ANY_PATH = "--any-path"
 VERDICTS = ("approve", "changes")
+# The review budget, enforced here and nowhere else: `review` refuses a third
+# round, and every text that states the rule (the reviewer agent, the contract,
+# plan-sync) says the same two rounds.
+REVIEW_ROUNDS = 2
+# Under this many changed lines one reviewer reads every dimension; at or above
+# it the round fans out. ponytail: a line count, not a risk model - a small diff
+# that touches a trust boundary is the brief's to route to security.
+SMALL_DIFF = 300
 
 
 def allow_source(text):
@@ -279,13 +293,14 @@ def phase_problems(phase, text, path):
         items = tt.acceptance_gap(text)
         if items:
             out.append(
-                "%s cannot enter %s: all %d of its Acceptance items name no "
-                "command and none declares `unverifiable` (read by "
-                "hooks/tezgah_task.py:acceptance_items), so the work has no check "
-                "to be held to. Give at least one item the command that proves "
+                "%s cannot enter %s: %d of its %d Acceptance items name no "
+                "command and declare no `unverifiable` (read by "
+                "hooks/tezgah_task.py:acceptance_items; at %s), so that work has "
+                "no check to be held to. Give each one the command that proves "
                 "it, or `unverifiable` and why; "
-                "`tezgah-render-table --acceptance` reports the same items"
-                % (path, phase, len(items)))
+                "`tezgah-render-table --acceptance --strict` refuses the same items"
+                % (path, phase, len(items), len(tt.acceptance_items(text)),
+                   ", ".join("%s:%d" % (path, i["line"]) for i in items)))
     if phase == "implementation" and tt.spike_unanswered(text):
         out.append(
             "%s cannot enter implementation: its spike is unanswered - `spike:` "
@@ -295,43 +310,78 @@ def phase_problems(phase, text, path):
     return out
 
 
+def changed_lines(root, base):
+    """Lines `git diff <base>..HEAD` adds and removes, or None when git cannot
+    say (no base, not a repository)."""
+    stat = git_out(root, "diff", "--shortstat", base + "..HEAD") \
+        if base != "<base>" else None
+    if stat is None:
+        return None
+    return sum(int(n) for n in re.findall(r"(\d+) (?:insertion|deletion)", stat))
+
+
 def verification_steps(text, path):
     """What the verification phase requires before the plan is done: the plan's
-    own acceptance commands run once on the final tree, unpiped, and a fresh
-    reviewer's read of the diff, recorded with `review` - `close NNN done` refuses
-    without it. A round after the first reads only the delta since the sha the
-    last `review` recorded, and the review budget is two rounds."""
+    own acceptance commands run once on the final tree, unpiped, and ONE review
+    of the plan's whole diff, recorded with `review` - `close NNN done` refuses
+    without an approve. Round one fans out one reviewer per dimension, round two
+    reads only the delta since the sha round one recorded, and REVIEW_ROUNDS is
+    the budget `review` enforces."""
     fields = tt.frontmatter(text)
     ident = fields.get("id") or os.path.basename(path).split("-")[0]
-    # every item, not only the ones the command reader recognises: `pnpm test`
-    # carries no option or path and would otherwise vanish from the list
+    # every item, not only the ones the command reader recognises: a bare
+    # `pytest` is a command it does not read as one, and must not vanish here
     items = ["%s%s" % (i["text"], "" if i["state"] == "checkable" else
                        "  [%s]" % ("unverifiable" if i["state"] == "unverifiable"
                                    else "names no command"))
              for i in tt.acceptance_items(text)]
     # the project, not the private repository `.tezgah` may hold
     root = os.path.realpath(os.path.join(os.path.dirname(path), "..", "..", ".."))
-    reviewed = fields.get("reviewed_sha") or ""
+    reviewed = fields.get("reviewed_sha") or "(no commit)"
     prior = fields.get("review_round") or ""
     rounds = int(prior) if prior.isdigit() else 0
     print("verification - required before this plan is done:")
     print("  1. prove the acceptance items ONCE, on the final tree - not again per "
           "review round - every command run unpiped "
-          "(`cmd > /tmp/check.log 2>&1`, then read the file):")
+          "(`cmd > /tmp/check.log 2>&1`, then read the file); items that share "
+          "no state go out as tool calls in ONE message, one suite run at a time:")
     for item in items or ["(the plan has no Acceptance items)"]:
         print("     - %s" % item)
     if os.path.isfile(os.path.join(root, "tests", "impacted.py")):
         print("     the one full run here is `python3 tests/impacted.py --all`")
-    if reviewed:
-        print("  2. review round %d: a fresh tezgah-reviewer reads only the delta "
-              "`git diff %s..HEAD` and the test output above; it does not re-run "
-              "the suite" % (rounds + 1, reviewed))
-        if rounds >= 2:
-            print("     the 2-round budget is spent: triage what is left as block "
-                  "(back to the user) or fix-later (recorded), never a third loop")
+    if rounds and review_verdict(text) == "approve":
+        print("  2. the review approved in round %d at %s: no further round"
+              % (rounds, reviewed))
+        print("  3. `tezgah-task close %s done` once the work lands" % ident)
+        return
+    if rounds >= REVIEW_ROUNDS:
+        print("  2. the %d-round budget is spent: `tezgah-task review` refuses a "
+              "third round. A critical or major finding still confirmed goes to "
+              "the user (block); a minor or suggestion one is recorded fix-later "
+              "under the plan's ## State" % REVIEW_ROUNDS)
+        return
+    if rounds:
+        print("  2. review round 2 (the last): each confirmed critical or major "
+              "finding is fixed with a regression test that failed first; one "
+              "fresh tezgah-reviewer reads only the delta `git diff %s..HEAD`, the "
+              "round-1 hunks and direct callers of the symbols it touches, and the "
+              "test output above, and marks every round-1 finding closed or open; "
+              "it does not re-run the suite" % reviewed)
     else:
-        print("  2. a fresh reviewer - the host's tezgah-reviewer subagent - "
-              "reads `git diff %s..HEAD` and the test output above" % diff_base(root))
+        base = diff_base(root)
+        size = changed_lines(root, base)
+        print("  2. one review of the whole plan, at most %d rounds: spawn fresh "
+              "tezgah-reviewer subagents in ONE message, each owning one dimension "
+              "- correctness and contract, security, tests and performance - or one "
+              "file group of a large diff, over `git diff %s..HEAD` and the test "
+              "output above, then merge their findings into one verdict. Under %d "
+              "changed lines one reviewer reads every dimension (this diff: %s), "
+              "unless the diff touches auth, secrets or a gate, which keeps a "
+              "security reviewer" % (REVIEW_ROUNDS, base, SMALL_DIFF,
+                                     "unknown" if size is None else size))
+        print("     only a confirmed critical or major finding is `changes` and "
+              "opens round 2; a minor or suggestion one is recorded fix-later "
+              "under ## State and the verdict is `approve`")
     print("  3. record its verdict: `tezgah-task review %s <reviewer> approve|changes`"
           " (records the reviewed sha);"
           " `tezgah-task close %s done` refuses without an approve" % (ident, ident))
@@ -495,6 +545,16 @@ def review_verdict(text):
     return parts[1] if len(parts) >= 2 and parts[1] in VERDICTS else None
 
 
+def budget_spent(path, ident):
+    """The refusal once REVIEW_ROUNDS rounds are recorded: what is left belongs
+    to the user, never to a third round."""
+    return ("%s has spent its %d-round review budget: never a third round. A "
+            "critical or major finding still confirmed goes to the user, who "
+            "decides (block); a minor or suggestion one is recorded fix-later "
+            "under the plan's ## State; `tezgah-task close %s discarded` needs no "
+            "review" % (path, REVIEW_ROUNDS, ident))
+
+
 def cmd_review(args):
     if len(args) != 3 or args[2] not in VERDICTS:
         return misuse("review takes <NNN|path> <reviewer> %s" % "|".join(VERDICTS))
@@ -503,6 +563,8 @@ def cmd_review(args):
         return problems([problem])
     fields = tt.frontmatter(read(path))
     prior = fields.get("review_round") or ""
+    if prior.isdigit() and int(prior) >= REVIEW_ROUNDS:
+        return problems([budget_spent(path, os.path.basename(path).split("-")[0])])
     # the project's HEAD, never the private `.tezgah` repository's: the next
     # round's delta is `git diff <this>..HEAD` over the project
     root = os.path.realpath(os.path.join(os.path.dirname(path), "..", "..", ".."))
@@ -535,6 +597,9 @@ def cmd_close(args):
         return problems(["%s is the active task: the user stops it first "
                          "(`tezgah-task stop`)" % path])
     if args[1] == "done" and review_verdict(text) != "approve":
+        prior = tt.frontmatter(text).get("review_round") or ""
+        if prior.isdigit() and int(prior) >= REVIEW_ROUNDS:
+            return problems([budget_spent(path, ident)])
         return problems(["%s records no approving review: a fresh reviewer reads "
                          "the diff, then `tezgah-task review %s <reviewer> approve`"
                          % (path, ident)])
@@ -561,22 +626,50 @@ def cmd_status(args):
     bad = []
     for path in plans(root):
         fields = tt.frontmatter(read(path))
+        ident = fields.get("id") or os.path.basename(path).split("-")[0]
         phase = fields.get("phase") or ""
         if phase and phase not in tt.TASK_PHASES:
-            bad.append({"id": fields.get("id") or os.path.basename(path).split("-")[0],
-                        "phase": phase, "path": path})
+            bad.append({"id": ident, "phase": phase, "path": path,
+                        "problem": "phase %r is not one of %s, so the plan is ignored (%s)"
+                        % (phase, ", ".join(tt.TASK_PHASES), path)})
+        status = fields.get("status") or ""
+        if status not in tt.OPEN_STATUSES:
+            bad.append({"id": ident, "path": path,
+                        "problem": "status %r is not one of %s, which is what a plan "
+                        "under .tezgah/plans/open carries (%s)"
+                        % (status, ", ".join(tt.OPEN_STATUSES), path)})
+    rows = tt.queue(root)
+    for row in rows:
+        for ident, state in row["after"]:
+            if state == "missing":
+                bad.append({"id": row["id"], "path": row["path"],
+                            "problem": "`after: %s` names no plan under .tezgah/plans "
+                            "(%s)" % (ident, row["path"])})
+    together = tt.parallel(rows)
     if task:
         task["allowed_from"] = allow_source(read(task["path"]))[1]
     if as_json:
-        print(json.dumps({"active": task, "malformed": bad}, indent=2))
+        print(json.dumps({"active": task, "malformed": bad, "open": rows,
+                          "parallel": together}, indent=2))
     else:
         if task:
             show(task["path"])
         else:
             print("no active task")
+        if rows:
+            print("open plans: %d, %d ready" % (len(rows), sum(r["ready"] for r in rows)))
+        for row in rows:
+            waits = ["%s (%s)" % (ident, state) for ident, state in row["after"]
+                     if state != "done"]
+            print("  %s %s, acceptance %d/%d checked, %s" % (
+                row["id"], row["status"] or "(no status)", row["checked"], row["items"],
+                "ready" if row["ready"] else
+                "waits on %s" % ", ".join(waits) if waits else row["status"]))
+        if together:
+            print("parallel: %s - ready, and no two share an allowed_paths prefix"
+                  % ", ".join(together))
         for row in bad:
-            print("FAIL %s: phase %r is not one of %s, so the plan is ignored (%s)"
-                  % (row["id"], row["phase"], ", ".join(tt.TASK_PHASES), row["path"]))
+            print("FAIL %s: %s" % (row["id"], row["problem"]))
     return 1 if bad else 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/architecture.md

@@ -34,7 +34,7 @@ nothing about a host's event names or output envelope.
 | `tezgah_paths.py` | where tezgah is armed: [roots](glossary.md#root) and the linked worktrees of a repository under one, kill switches, the config dir, and the writable cache dir - the fallback resolved on use rather than at import, so a gated call does not pay for `tempfile`, `shutil` or `sqlite3` | `hooks/tezgah_paths.py:2-14`, `hooks/tezgah_paths.py::cache_dir`, `hooks/tezgah_paths.py::fallback_cache` |
 | `tezgah_snapshot.py` | pre-write bytes of every file a write is about to change, and the one explicit restore | `hooks/tezgah_snapshot.py:2-18`, `hooks/tezgah_snapshot.py::capture` |
 | `tezgah_untrusted.py` | the untrusted-content label on a result from outside the user and workspace, and the taint notice on the next effect | `hooks/tezgah_untrusted.py:2-22`, `hooks/tezgah_untrusted.py::marks` |
-| `tezgah_agents.py` | per-repo subagent definitions generated into each host that has an agent surface | `hooks/tezgah_agents.py:2-22`, `hooks/tezgah_agents.py::sync_root` |
+| `tezgah_agents.py` | subagent definitions generated into each host that has an agent surface: user-level for Claude, Codex and omp (written at install), per repo for Cursor and opencode | `hooks/tezgah_agents.py:2-30`, `hooks/tezgah_agents.py::sync_root`, `hooks/tezgah_agents.py::user_agents` |
 | `tezgah_research.py` | the in-repo research workspace and the check that a protocol predates its results | `hooks/tezgah_research.py:2-85`, `hooks/tezgah_research.py::check` |
 | `tezgah_index.py` | the detached graph auto-index worker (flock-guarded, bounded retry) | `hooks/tezgah_index.py:2-18`, `hooks/tezgah_index.py::main` |
 

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,
@@ -72,13 +72,13 @@
     "semicolons": 6
   },
   "docs/models.md": {
-    "long_sentences": 19,
+    "long_sentences": 18,
     "passive": 8,
     "replace_words": 0,
     "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`).