@r1z4x/tezgah 1.3.0 → 1.5.0

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,12 +310,23 @@ 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`
@@ -311,27 +337,51 @@ def verification_steps(text, path):
              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

@@ -34,15 +34,17 @@ judge's provider (`hooks/tezgah_judge.py` names it); with no credential or
 `judge-off` set they send nothing and exit 2.
 
 `learn` is taste-1's pipeline on tezgah (research line taste-architecture,
-design T1P). Each prompt after a writing turn - from the capture rows in
-`<repo>/.tezgah/taste/signals.jsonl`, or with `--from-transcripts` 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 `defects.jsonl`, never
-into the ledger. The ledger itself is `hooks/tezgah_taste_ledger.py`. A
+design T1P). Each prompt after a writing turn - from the capture rows in the
+`signals` table of `<repo>/.tezgah/taste/taste.db`, or with `--from-transcripts`
+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
+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).
 
@@ -70,6 +72,7 @@ sys.path.insert(0, os.path.join(HERE, "hooks"))
 import tezgah_integrity as ti  # noqa: E402
 import tezgah_judge  # noqa: E402
 import tezgah_models  # noqa: E402
+import tezgah_paths  # noqa: E402
 import tezgah_taste_ledger as tl  # noqa: E402
 
 WRITE_TOOLS = {"omp": {"edit", "write"},
@@ -319,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,
@@ -331,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)")
@@ -369,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):
@@ -466,18 +481,13 @@ def iso_day(ts):
 
 
 def _snapshots():
-    """{absolute path: [(ts, id, after)]} over the snapshot store, oldest first."""
-    import tezgah_snapshot as ts
+    """{absolute path: [(ts, id, after)]} over the snapshot index, oldest first."""
+    import tezgah_store
     out = {}
-    for d in ts._dirs():
-        try:
-            with open(os.path.join(d, "meta.json"), encoding="utf-8") as fh:
-                meta = json.load(fh)
-        except (OSError, ValueError):
-            continue
-        if isinstance(meta, dict) and meta.get("path"):
+    for meta in tezgah_store.snapshots():
+        if isinstance(meta, dict) and meta.get("path") and meta.get("id"):
             out.setdefault(meta["path"], []).append(
-                (int(meta.get("ts") or 0), os.path.basename(d), bool(meta.get("after"))))
+                (int(meta.get("ts") or 0), meta["id"], bool(meta.get("after"))))
     for rows in out.values():
         rows.sort()
     return out
@@ -522,7 +532,7 @@ def user_diff(repo, rel, after_sid, snaps):
 def capture_signals(repo):
     """One signal per prompt that followed a writing turn, from the capture rows."""
     snaps, turns, out = None, {}, []
-    for row in tl.rows(os.path.join(tl.store_dir(repo), "signals.jsonl")):
+    for row in tl.rows(repo, "signals"):
         session = row.get("session") or ""
         turn = turns.setdefault(session, {"edits": [], "after": []})
         if row.get("kind") == "edit":
@@ -632,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:
@@ -647,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
 
 
@@ -666,9 +676,15 @@ def write_line(learning):
 
 
 def store_or_exit(args):
+    """The repository whose taste store a command opens. Refused when its
+    `.tezgah` came with the clone: those files are the project's data, and
+    opening the store would import, rename or create files in them."""
     repo = repo_root(os.path.abspath(args.repo or os.getcwd()))
     if not repo:
         raise SystemExit(misuse("not inside a git repository"))
+    if tezgah_paths.workspace_from_repo(repo):
+        raise SystemExit(misuse("%s/.tezgah came with the repository; its taste "
+                                "store is not opened" % repo))
     return repo
 
 
@@ -676,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]:
@@ -689,17 +705,17 @@ def cmd_learn(args):
     signals = (transcript_signals(repo, args.host) if args.from_transcripts
                else capture_signals(repo))
     decided = {}
-    for r in tl.rows(os.path.join(tl.store_dir(repo), "decisions.jsonl")):
-        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
+    for r in tl.rows(repo, "decisions"):
+        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)
@@ -708,8 +724,10 @@ 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(os.path.join(tl.store_dir(repo), "decisions.jsonl"), {
+        tl.append(repo, "decisions", {
             "id": sig["id"], "day": day, "at": sig.get("at"), "session": sig["session"],
             "provider": result.get("provider"), "model": result.get("model"),
             "verified": dec["verified"], "kind": dec["kind"][0], "p": dec["kind"][1],
@@ -719,10 +737,10 @@ 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(os.path.join(tl.store_dir(repo), "defects.jsonl"),
+            tl.append(repo, "defects",
                       {"id": sig["id"], "day": day, "session": sig["session"],
                        "text": ti.redact(sig["text"])[:600], "paths": sig["paths"][:8]},
                       strict=True)
@@ -741,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
 
 
@@ -806,17 +826,16 @@ 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)
-    store = tl.store_dir(repo)
-    decided = {r["id"]: r for r in tl.rows(os.path.join(store, "decisions.jsonl"))
-               if r.get("provider") == "typesafe" and r.get("id")}
-    labelled = {r.get("id") for r in tl.rows(os.path.join(store, "labels.jsonl"))}
+    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:
             return misuse("label is one of %s" % ", ".join(CLASSES))
         row = decided.get(args.id)
         if row is None:
             return misuse("no typed decision %s" % args.id)
-        tl.append(os.path.join(store, "labels.jsonl"),
+        tl.append(repo, "labels",
                   {"id": args.id, "label": args.label, "decided": row.get("kind"),
                    "provider": row.get("provider"), "day": tl.now_day()}, strict=True)
         print("%s labelled %s (decided %s)" % (args.id, args.label, row.get("kind")))
@@ -872,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)
@@ -882,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"):
@@ -910,7 +929,7 @@ def main(argv):
                "gate": cmd_gate}[args.cmd]
     if args.cmd not in ("learn", "accept", "reject", "edit", "label"):
         return handler(args)
-    # the commands that rewrite ledger.json: one at a time, or the last one
+    # the commands that rewrite the ledgers: one at a time, or the last one
     # to finish would silently drop what the other wrote
     try:
         repo = store_or_exit(args)

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

@@ -154,10 +154,10 @@ lowest-value blocks are dropped in a fixed order rather than the rules
 
 | Store | Path | Writer | Authoritative for |
 |---|---|---|---|
-| Evidence ledger | `~/.cache/tezgah/evidence/<session>.jsonl` (`hooks/tezgah_integrity.py::_path`) | `note_tool` from each host's PostToolUse (`hooks/tezgah_integrity.py::note_tool`) | what a session actually ran, and therefore the Stop verdict |
-| Session store (used marks) | the chosen cache dir, `sessions/<session>.jsonl` (`hooks/tezgah_context.py::record`) | `record` (`hooks/tezgah_context.py::record`) from every adapter | nothing evidential: a convenience channel for a surface that has no transcript; an `orch` mark is also written to the evidence ledger (`hooks/tezgah_context.py::record`) so `fanout` can count it |
-| Snapshot store | `<cache dir>/snapshots` (`hooks/tezgah_snapshot.py::_store`) | `capture` on the write path (`hooks/tezgah_snapshot.py::capture`) | the pre-write bytes; the rollback source |
-| Turn stamp | `<cache dir>/turns/<session>.json` (`hooks/tezgah_context.py::_stamp_path`) | `write_stamp` (`hooks/tezgah_context.py::write_stamp`) | the comparison behind the one-line delta, nothing else |
+| Evidence ledger | the `evidence` rows of `~/.cache/tezgah/tezgah.db`, keyed by the session's `evidence/<session>.jsonl` path (`hooks/tezgah_integrity.py::_path`, `hooks/tezgah_store.py::EVIDENCE_SCHEMA`); an old JSONL file at that path is imported (`hooks/tezgah_store.py::_sync`) | `note_tool` from each host's PostToolUse (`hooks/tezgah_integrity.py::note_tool`) | what a session actually ran, and therefore the Stop verdict |
+| Session store (used marks) | the `used` rows of the cache dir's `tezgah.db`, one per session and kind (`hooks/tezgah_store.py::use`) | `record` (`hooks/tezgah_context.py::record`) from every adapter | nothing evidential: a convenience channel for a surface that has no transcript; an `orch` mark is also written to the evidence ledger (`hooks/tezgah_context.py::record`) so `fanout` can count it |
+| Snapshot store | the blobs under `<cache dir>/snapshots` (`hooks/tezgah_snapshot.py::_store`), their manifests the `snapshots` rows of `tezgah.db` (`hooks/tezgah_store.py::add_snapshot`) | `capture` on the write path (`hooks/tezgah_snapshot.py::capture`) | the pre-write bytes; the rollback source |
+| Turn stamp | the `turns` rows of the cache dir's `tezgah.db`, one per session (`hooks/tezgah_context.py::write_stamp`) | `write_stamp` (`hooks/tezgah_context.py::write_stamp`) | the comparison behind the one-line delta, nothing else |
 | Installed config dir | `~/.config/tezgah` (`hooks/tezgah_paths.py::CONFIG_DIR`) | the installer and the user | which roots are armed, which kill switches are on |
 | Plugin copy | `~/.claude/plugins/cache/<marketplace>/tezgah/<version>/` (`bin/tezgah-setup::plugin_copies`) | `tezgah-setup --sync` (`bin/tezgah-setup::sync`) | what Claude Code actually executes — a copy, never this checkout |