@r1z4x/tezgah 1.8.3 → 1.9.0

package/CHANGELOG.md

@@ -6,6 +6,39 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.9.0] - 2026-10-17
+
+### Added
+
+- **The opencode plugin loads on opencode v2.** v2 validates a plugin's default export: an object with an `id` and a `setup(ctx)`. It rejects a module that only exports a callable, which is why opencode v2 refused both tezgah entrypoints at load. The module now carries both shapes, and opencode 1 keeps the callable it uses. The v2 `setup` registers the tool envelopes, the shell env hook and the event subscription. It passes the v2 event as the v1 `input`. It rebuilds the `args` field the v1 callback reads, so a refusal stays the same thrown error. The session, permission, compaction and TUI hooks follow once a probe measures their v2 event.
+- **`tezgah-optimize` decides what a change costs to check.** `next` reads the commands the active plan's Acceptance names and answers `run now`, `defer` or `already green`. The planner spends a green row for the same change on a clean tree. A command whose recorded median is at or above 105 s defers to the merge step. Everything else runs now. `record` appends the row `next` reads. `push` prints the one push a change gets, and a second push of the same sha inside 300 s refuses. The rows live in the repository's own store. Measurement sets the tiers rather than a declaration, so a project that never adopted `AGENTS.md` still gets a batch. See `docs/testing.md`.
+
+### Changed
+
+- **`tezgah-task sweep` clears the last session's leftovers.** It lists every pending slice with its `slice resume` command. It removes landed worktrees and branches but keeps the checkout it runs in. It clears a missing branch's `phase:` only when git answers and a checkpoint, landing or reviewed commit proves the phase ran in a checkout. A declared, never-created branch stays active. A second run reports `0 change(s)`. Pending slices stay open for the session to resume.
+- **An idle slice stays owed without inventing a failure.** `pending` used to close an open record as `stale` after six hours. A slice with no observed end now closes `stopped` with an empty failure class and keeps its resume brief. Unknown endings no longer fabricate `cut_off` signatures. Signature counts stay quiet for hosts whose endings tezgah cannot observe. Only a `job` record closes `stale`. The parent transcript already holds its result.
+- **A linked worktree's `.tezgah` link no longer reads as untracked.** `.gitignore` carried `/.tezgah/`, and that pattern matches a directory only. Git therefore never ignored the symlink a worktree shows. The tree read dirty forever. Its implementation phase began on a `checkpoint: pending`. Only a commit adding the link to the repository could clear that. The pattern is `/.tezgah` now.
+- **A phase move reports every precondition at once.** `tezgah-task phase` stopped at the first group it met. The groups are the scope, the Acceptance items that name no command, and an unanswered spike. A plan that owed more than one learned them one refused attempt at a time. The command now prints all of them in one run (`bin/tezgah-task::cmd_phase`).
+- **`close` records why a worktree stayed.** It printed the reason once, and the print went with the session. The next session re-derived the same decision. The kept worktrees and kept branches now go on the record it closes, as `worktrees_kept:`.
+- **`tezgah-task unmet` records an item the owner accepted.** `close NNN done` refuses an unticked Acceptance item that carries no `UNMET:`. Nothing could write that marker: the gate refuses a write to the record itself. So a hand edit was the only way, and the plan could not close. The verb is the record's fifth body writer beside `tick`, `note`, `spike` and `sweep`. It commits nothing.
+- **The temporal spec decides the Stop rule's evidence classes.** Its shadow run agreed on all 420 live Stops it reached. `_stop_block` now asks `tezgah_stopspec`, and the refusal texts stay the same. The `stop_spec` shadow row and `TEZGAH_STOPSPEC_STRICT` are gone. `tests/stop_spec_eval.py` keeps only `--mutants`, and the neuter workflow also runs on a change to the spec.
+- **A claim needs a check someone saw pass.** A done or tested claim over a `verify_ok` row with no passing output now owes `no verify_ok`. An earlier pass and a turn of git bookkeeping no longer excuse it.
+- **A research, analysis, review or plan ask ends at the plan.** The contract now says so. Building that plan waits for the user's answer, and a finding outside the ask becomes a plan, not code.
+- **No plan, no third product file, on any branch.** The no-plan rule held only `main` and `master`, and counted only tezgah's own folders. It now holds every branch that no open plan binds, and counts any path in the checkout. Only `.tezgah/`, `.codegraph/`, `.git/` and the hosts' generated `agents/` sets stay out. A `plan/NNN-*` branch binds only an open plan NNN. A worktree on the branch an open plan names in `branch:` answers to that plan, so Orca's `r1z4x/<name>` worktrees bind too. `tezgah-task start NNN --phase P --branch <name>` writes that binding, and the refusal names it. A merge or rebase in progress passes.
+- **`tezgah-route --mode` switches every routed agent at once.** It writes the table over omp selectors set by hand. That covers the 12 routed agents and the plan and slow roles, and it names each one it replaced. Before, a hand-set selector kept every subagent on another family after a switch. The automatic re-apply at session start still leaves hand-set selectors alone.
+- **`tezgah-route --mode openai`.** It runs every routed omp agent on `openai-codex/gpt-6-luna`, with effort low, medium or high by tier. That is omp's ChatGPT provider. It is no fallback for the other modes, and with no `openai-codex` login it writes nothing and says why.
+
+### Fixed
+
+- **The closed-plan census uses the same Acceptance predicate as `close`.** Only `status: done` records count, and each unticked Acceptance item needs its own `UNMET: <reason>`. A marker on another item, a box outside Acceptance or a legitimately discarded record no longer distorts the result.
+- **A bare repository's worktrees share one workspace.** It lives in the bare git directory, `<bare>/.tezgah`, and each worktree's `.tezgah` links to it. No `git worktree remove`, detach or branch switch removes it, and a plan worktree there is held to its plan. Commands read project files in the worktree they run in. That covers the checkpoint, research files and claims, the arena evaluator, the merge checks and `tezgah-taste mine`. A bare repository with one worktree prints no worktrees line.
+- **`close` prunes a worktree whose `.tezgah` is a link.** It read the link to the workspace as the worktree's own data and kept the worktree. The merge step's deferred checks are now looked up in the plan's own worktree when one holds the plan.
+- **A plan worktree moves only its own plan's record.** In a `plan/NNN-*` worktree whose plan is not active, `allow`, `phase` and `stop` refuse. They used to change the main checkout's first phased plan.
+- **`close` prunes a worktree of generated files.** Managed agent files and the `.codegraph` index regenerate, so they keep no landed worktree. Any other ignored file still keeps it. So do a FIFO, a directory link and a directory `close` cannot list.
+- **A Ctrl-C as an installer starts still stops it.** `--deps` armed its group kill only after the installer had started. A Ctrl-C in that gap left the installer running on its own, and a test timed out on it under load.
+- **`close` drops the branch of a worktree Orca removed.** Orca answers before the checkout is gone. Git then refused to delete the branch, and close printed `branch kept`. Close now waits up to 10 seconds for the directory to go, and names a checkout still there as kept.
+- **The no-plan rule reads a `~/` path as a home path.** It joined `~/...` onto the session's directory. A plan worktree's files written by `~/` paths then counted as `main`'s, so the gate refused the third.
+
 ## [1.8.3] - 2026-10-13
 
 ### Changed
@@ -1173,7 +1206,8 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   the copy could not find `hooks/` and died on import. It now links into the
   installed tree, and also installs the command as `tezgah`.
 
-[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.8.3...HEAD
+[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.9.0...HEAD
+[1.9.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.9.0
 [1.8.3]: https://github.com/r1z4x/tezgah/releases/tag/v1.8.3
 [1.8.2]: https://github.com/r1z4x/tezgah/releases/tag/v1.8.2
 [1.8.1]: https://github.com/r1z4x/tezgah/releases/tag/v1.8.1

package/MANIFEST

@@ -64,6 +64,8 @@ bin/tezgah-mcp
 bin/tezgah-mcp.py
 bin/tezgah-migrate
 bin/tezgah-migrate.py
+bin/tezgah-optimize
+bin/tezgah-optimize.py
 bin/tezgah-pony
 bin/tezgah-pony.py
 bin/tezgah-research
@@ -670,7 +672,9 @@ tests/impacted.py
 tests/install_cache.py
 tests/neuter_killers.json
 tests/neuter_matrix.py
+tests/plan_orphans.py
 tests/replay_context.py
+tests/replay_optimize.py
 tests/routing-fixtures.md
 tests/stop_spec_eval.py
 tests/support.py
@@ -728,6 +732,7 @@ tests/test_lang_packs.py
 tests/test_lesson_lineage.py
 tests/test_lessons.py
 tests/test_lessons_compile.py
+tests/test_lifecycle_sweep.py
 tests/test_live_probe.py
 tests/test_mcp_features.py
 tests/test_mcp_server.py
@@ -737,6 +742,7 @@ tests/test_neuter_matrix.py
 tests/test_omp_extension.py
 tests/test_omp_hook.py
 tests/test_opencode_plugin.py
+tests/test_optimize.py
 tests/test_orca.py
 tests/test_packaging.py
 tests/test_packaging_scripts.py

package/bin/tezgah-docs

@@ -106,7 +106,7 @@ RUN = re.compile(r"((?:`[A-Za-z_][A-Za-z0-9_]*(?:\(\))?`\s*[/,]?\s*){1,5})$")
 CITE = re.compile(r"`([\w.-]+(?:/[\w.-]+)+|[\w-]+\.\w+):(\d+)(?:-(\d+))?`"
                   r"|`(:(\d+)(?:-(\d+))?)`")
 # The symbol written after the citation instead of before it, the way a table
-# cell reads: `hooks/tezgah_policy.py:784-1100` (`CORE`).
+# cell reads: `hooks/tezgah_policy.py:787-1105` (`CORE`).
 AFTER = re.compile(r"\s*\(`([A-Za-z_][A-Za-z0-9_]*)(?:\(\))?`\)")
 # Any `path:line`, backticked or not: what CITE does not match of these (a
 # bare token, a comma list `x.py:12,40`) is counted as unjudged, so a citation
@@ -405,14 +405,15 @@ def ratchet_drift(unjudged, baseline):
 # audit reads a symbol: the gate's rules are the `_deny(session_id, "<rule>",
 # ...)` calls in hooks/tezgah_gate.py, and the Stop rule's triggers are the
 # classes `_stop_block` returns - including the four `_shape_block` and the six
-# `_evidence_block` hand back, and the one `_residual_block` adds at every exit
-# that would end the turn, which is why those three functions are read too.
+# `_evidence_text` words for the temporal spec's fold, and the one
+# `_residual_block` adds at every exit that would end the turn, which is why
+# those three functions are read too.
 
 GATE = os.path.join(HERE, "hooks", "tezgah_gate.py")
 STOP = os.path.join(HERE, "hooks", "tezgah_integrity.py")
 LEDGER = os.path.join(HERE, "docs", "gate.md")
 LEDGER_COLUMNS = ("rule", "incident", "evidence", "pin")
-STOP_FUNCS = ("_stop_block", "_shape_block", "_evidence_block", "_residual_block")
+STOP_FUNCS = ("_stop_block", "_shape_block", "_evidence_text", "_residual_block")
 
 
 def source(path):

package/bin/tezgah-optimize

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""tezgah-optimize - one decision over what verification a change costs.
+
+  tezgah-optimize next [--files PATH ...] [--cmd COMMAND ...] [--sha SHA] [--json]
+  tezgah-optimize record <COMMAND> --seconds N --exit N [--sha SHA]
+  tezgah-optimize push [--sha SHA]
+
+`next` answers, per candidate command, exactly one of three things. `already
+green` when a recorded row for this repository, this sha and this command exited
+0 - the analogue of a remote build cache, keyed by the change rather than by a
+file. `defer` when the command's recorded median wall time is at or above
+`TURN_SECONDS`, so it belongs to the merge step. Else `run now`. The candidates
+are the commands the active plan's Acceptance items name in backticks, plus every
+`--cmd`; the plan already carries the commands that prove its work, so the
+planner reads them instead of asking for a list a session would re-derive.
+
+The tier map is measured, not declared: with no row for a command the answer is
+`run now`, and the median of its rows moves it. A project that never adopted this
+repository's `AGENTS.md` therefore still gets a batch (plan 109, decision d1v1).
+
+`record` appends the row `next` reads, and `push` prints the one push the session
+should make for this change - or refuses while the last recorded push of the same
+sha is inside `PUSH_WINDOW`, because a second push pays the same CI minutes
+again. The rows live in the repository's own store
+(`<repo>/.tezgah/taste/taste.db`, tables `checks` and `pushes`), so a second
+session in the same checkout reads the first one's measurements.
+
+The orchestrating session calls these. A user does not, and no hook does.
+
+Exit codes: 0 ok, 1 a refusal or a problem, 2 misuse.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+sys.path.insert(0, os.path.join(HERE, "hooks"))
+import tezgah_store as store  # noqa: E402
+import tezgah_task as tt  # noqa: E402
+from tezgah_paths import project_top  # noqa: E402
+
+# A command whose recorded median is at or above this belongs to the merge step.
+# The repository's own measured tiers (AGENTS.md) put the impacted set in a turn
+# at about 10-95 s and the whole suite, about 105 s, at the merge step, so the bar
+# is the line between them. One number, not a table: the plan's decision rejected
+# a declared per-repository map (d1v2) because a second project would have to
+# write one before the planner helped it at all.
+TURN_SECONDS = 105.0
+# One push per sha inside this window. A second push of the same change pays the
+# same CI minutes again, which is the cost this command coalesces; the window is
+# long enough for a session's next edit to join the first push.
+PUSH_WINDOW = 300.0
+BACKTICK = re.compile(r"`([^`]+)`")
+
+
+def repo_root(path):
+    """The repository this run is about: git's own answer, else the directory it
+    was called in."""
+    try:
+        out = subprocess.run(["git", "-C", path, "rev-parse", "--show-toplevel"],
+                             capture_output=True, text=True)
+        if out.returncode == 0 and out.stdout.strip():
+            return project_top(out.stdout.strip())
+    except OSError:
+        pass
+    return os.path.realpath(path)
+
+
+def misuse(message):
+    print("tezgah-optimize: %s" % message, file=sys.stderr)
+    return 2
+
+
+def problems(items):
+    for problem in items:
+        print("FAIL %s" % problem)
+    return 1
+
+
+def now():
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def git_out(root, *args):
+    """One git command's stdout, or None when git cannot answer - a checkout git
+    cannot describe never refuses anything here."""
+    try:
+        out = subprocess.run(["git", "-C", root] + list(args),
+                             capture_output=True, text=True)
+    except OSError:
+        return None
+    return out.stdout.strip() if out.returncode == 0 else None
+
+
+def parse(args, repeats=(), valued=(), flags=()):
+    """(({repeat: [...]}, {plain: value}), positionals, problem). A repeatable
+    option collects every occurrence, a valued one keeps the last, a flag is
+    True, and any other `--x` is a problem."""
+    collected = {name: [] for name in repeats}
+    plain, pos, i = {}, [], 0
+    while i < len(args):
+        arg = args[i]
+        if arg in repeats or arg in valued:
+            if i + 1 >= len(args):
+                return None, None, "%s needs a value" % arg
+            if arg in repeats:
+                collected[arg].append(args[i + 1])
+            else:
+                plain[arg] = args[i + 1]
+            i += 2
+        elif arg in flags:
+            plain[arg] = True
+            i += 1
+        elif arg.startswith("--"):
+            return None, None, "unknown option %r" % arg
+        else:
+            pos.append(arg)
+            i += 1
+    return (collected, plain), pos, None
+
+
+def store_dir(root):
+    return os.path.join(root, ".tezgah", "taste")
+
+
+def recorded(root, table, where="", args=()):
+    """One table's rows in append order; [] when the store is not there yet, so a
+    first run answers from nothing instead of failing."""
+    try:
+        with store.taste(store_dir(root), create=False) as db:
+            return store.rows(db, table, where, args) if db else []
+    except store.ERRORS:
+        return []
+
+
+def median(values):
+    ordered = sorted(values)
+    if not ordered:
+        return None
+    mid = len(ordered) // 2
+    return ordered[mid] if len(ordered) % 2 else (ordered[mid - 1] + ordered[mid]) / 2.0
+
+
+PROGRAM = re.compile(
+    r"^(?:python3?|pytest|ruff|mypy|bash|sh|zsh|make|npm|npx|yarn|pnpm|cargo|go|gradle|"
+    r"\./gradlew|mvn|dotnet|swift|xcodebuild|git|gh|docker|bundle|rake|nox|tox|"
+    r"\./bin/[a-z][a-z-]*|bin/[a-z][a-z-]*)$")
+
+
+def plan_commands(root):
+    """The commands the active plan's Acceptance items name in backticks, in
+    order, deduplicated. The plan format asks each item for the command that
+    proves it, so this is the list the session would otherwise retype.
+
+    A backticked token counts when its first word is a program - `python3`, `ruff
+    check .`, `pytest`, `package.json`'s `npm test`, or a script under `bin/` - and
+    it carries no placeholder. An item's prose is backticked too (`stale`, a file
+    path such as `hooks/tezgah_store.py`), and a planner that took every token, or
+    every token with a slash in it, would hand the session a path as a check and
+    drop `ruff check .` (review of plan 109, F3). A command the rule cannot see is
+    what `--cmd` is for."""
+    task = tt.active(root, root, held=True)
+    if not task:
+        return []
+    try:
+        with open(task["path"], encoding="utf-8") as fh:
+            text = fh.read()
+    except OSError:
+        return []
+    out = []
+    for item in tt.acceptance_items(text):
+        for found in BACKTICK.findall(item["text"]):
+            command = " ".join(found.split())
+            words = command.split()
+            if "<" in command or ">" in command or command in out or not words:
+                continue
+            if not PROGRAM.match(words[0]):
+                continue
+            out.append(command)
+    return out
+
+
+def same_commit(one, other):
+    """True when two sha spellings name the same commit. Git prints a short sha
+    that grows as the repository does, so a row recorded with the full one would
+    never match the short one `next` reads (review of plan 109)."""
+    one, other = str(one or ""), str(other or "")
+    return bool(one) and bool(other) and (one.startswith(other) or other.startswith(one))
+
+
+def decide(root, command, sha):
+    """(verdict, why) for one command: the three answers `next` gives.
+
+    A green row for this change outranks the tier, because running it again would
+    add nothing - but only while the working tree is clean. Inside a turn the
+    edits are usually uncommitted, so HEAD does not move, and a row for that sha
+    can describe a tree this session has already changed: on a dirty tree the
+    answer is `run now` whatever the rows say (review of plan 109, F2)."""
+    history = [row for row in recorded(root, "checks")
+               if row.get("command") == command]
+    dirty = bool(git_out(root, "status", "--porcelain")) if sha else False
+    green = [row for row in history
+             if same_commit(row.get("sha"), sha) and not int(row.get("exit") or 0)
+             and row.get("tree") == "clean"]
+    if green and not dirty:
+        return "already green", "recorded exit 0 for %s at %s" % (
+            sha, green[-1].get("ts") or "?")
+    seconds = [float(row["seconds"]) for row in history
+               if isinstance(row.get("seconds"), (int, float))]
+    middle = median(seconds)
+    if green:
+        return "run now", ("a green row exists for %s, but the working tree holds "
+                           "uncommitted edits, so that pass is not this change" % sha)
+    if middle is None:
+        return "run now", "nothing measured for it yet"
+    if middle >= TURN_SECONDS:
+        return "defer", "its measured median is %.1fs, at or above the %.0fs in-turn bar" % (
+            middle, TURN_SECONDS)
+    return "run now", "its measured median is %.1fs" % middle
+
+
+def cmd_next(args):
+    parsed, pos, bad = parse(args, repeats=("--files", "--cmd"), valued=("--sha",),
+                             flags=("--json",))
+    if bad or pos:
+        return misuse(bad or "next takes options only (%r)" % pos[0])
+    collected, plain = parsed
+    root = repo_root(os.getcwd())
+    sha = plain.get("--sha") or git_out(root, "rev-parse", "--short", "HEAD") or ""
+    commands = []
+    for command in list(collected["--cmd"]) + plan_commands(root):
+        if command not in commands:
+            commands.append(command)
+    rows = [{"command": command, "verdict": decide(root, command, sha)[0],
+             "why": decide(root, command, sha)[1]} for command in commands]
+    payload = {"repo": root, "sha": sha, "files": collected["--files"],
+               "commands": rows, "turn_seconds": TURN_SECONDS}
+    if plain.get("--json"):
+        print(json.dumps(payload, indent=2, sort_keys=True))
+        return 0
+    print("repo %s at %s" % (root, sha or "(no commit yet)"))
+    if collected["--files"]:
+        print("  changed: %s" % ", ".join(collected["--files"]))
+    for row in rows:
+        print("  %-13s %s (%s)" % (row["verdict"], row["command"], row["why"]))
+    if not rows:
+        print("no candidate command: name one with --cmd, or give the active plan "
+              "an Acceptance item whose proof names one in backticks")
+    return 0
+
+
+def cmd_record(args):
+    parsed, pos, bad = parse(args, valued=("--seconds", "--exit", "--sha"))
+    if bad or len(pos) != 1:
+        return misuse(bad or "record takes one COMMAND")
+    _collected, plain = parsed
+    command = " ".join(pos[0].split())
+    if not command:
+        return misuse("record takes the command it measured")
+    for name in ("--seconds", "--exit"):
+        if name not in plain:
+            return misuse("record needs %s" % name)
+    try:
+        seconds, code = float(plain["--seconds"]), int(plain["--exit"])
+    except ValueError:
+        return misuse("--seconds takes a wall time and --exit an exit code")
+    if seconds < 0:
+        return misuse("--seconds takes a wall time, not a negative one")
+    root = repo_root(os.getcwd())
+    sha = plain.get("--sha") or git_out(root, "rev-parse", "--short", "HEAD") or ""
+    row = {"repo": root, "sha": sha, "command": command, "seconds": seconds,
+           "exit": code, "ts": now(),
+           # the tree the run describes: a green row recorded over uncommitted
+           # edits describes a tree nobody else has, and `decide` will not spend
+           # it as a pass (review of plan 109, F2)
+           "tree": "clean" if not git_out(root, "status", "--porcelain") else "dirty"}
+    try:
+        with store.taste(store_dir(root)) as db:
+            store.append(db, "checks", row)
+    except store.ERRORS as exc:
+        return problems(["cannot record in %s: %s" % (store_dir(root), exc)])
+    print("recorded: %s %s %.1fs exit %d" % (sha or "(no commit)", command,
+                                             seconds, code))
+    return 0
+
+
+def cmd_push(args):
+    parsed, pos, bad = parse(args, valued=("--sha",))
+    if bad or pos:
+        return misuse(bad or "push takes [--sha SHA]")
+    _collected, plain = parsed
+    root = repo_root(os.getcwd())
+    sha = plain.get("--sha") or git_out(root, "rev-parse", "--short", "HEAD") or ""
+    if not sha:
+        return problems(["%s has no commit to push" % root])
+    name = git_out(root, "symbolic-ref", "-q", "--short", "HEAD")
+    if not name:
+        return problems(["%s is on a detached HEAD: name the branch to push (check "
+                         "it out, or push an explicit ref)" % root])
+    at = time.time()
+    for row in reversed(recorded(root, "pushes")):
+        if row.get("sha") != sha or not isinstance(row.get("at"), (int, float)):
+            continue
+        waited = at - float(row["at"])
+        if waited < PUSH_WINDOW:
+            return problems([
+                "%s is already pushed and CI is paying for it: one push per change "
+                "is the point. Add the next edit to this one, or push again in %d s "
+                "(`tezgah-optimize push`)" % (sha, int(PUSH_WINDOW - waited))])
+    try:
+        with store.taste(store_dir(root)) as db:
+            store.append(db, "pushes", {"repo": root, "sha": sha, "branch": name,
+                                        "at": at})
+    except store.ERRORS as exc:
+        return problems(["cannot record the push in %s: %s" % (store_dir(root), exc)])
+    print("push: git push -u origin %s - one push for %s" % (name, sha))
+    return 0
+
+
+def main(argv):
+    if len(argv) < 2:
+        print(__doc__, file=sys.stderr)
+        return 2
+    cmd, rest = argv[1], argv[2:]
+    if cmd == "next":
+        return cmd_next(rest)
+    if cmd == "record":
+        return cmd_record(rest)
+    if cmd == "push":
+        return cmd_push(rest)
+    return misuse("unknown command %r (next, record, push)" % cmd)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/bin/tezgah-research

@@ -212,8 +212,8 @@ def cmd_init(args):
                           "candidate and the number it returns")
         evaluator = arena.get("--evaluator", "").strip()
         if evaluator and (os.path.isabs(evaluator) or ".." in evaluator.split("/")
-                          or not os.path.isfile(os.path.join(repo_root(os.getcwd()),
-                                                             evaluator))):
+                          or not os.path.isfile(os.path.join(
+                              tp.work_tree(repo_root(os.getcwd())), evaluator))):
             return misuse("--evaluator %r is not a file under the repository" % evaluator)
     elif arena:
         return misuse("--arena, --budget, --evaluator and --metric belong to "

package/bin/tezgah-route

@@ -5,7 +5,8 @@
   tezgah-route --check                          the table's age and refresh flags
   tezgah-route --refresh                        re-read prices/ids (OpenRouter),
                                                 resolve opencode selectors
-  tezgah-route --mode auto|anthropic|any        omp's family, then re-apply omp
+  tezgah-route --mode auto|anthropic|zai|any|openai|off
+                                                omp's family, then re-apply omp
   tezgah-route --health                         probe the other funded families;
                                                 one at a limit leaves the chain
                                                 until its reset; re-apply omp
@@ -151,7 +152,10 @@ def main(argv):
             print("could not write %s" % tm.OVERLAY, file=sys.stderr)
             return 1
         print("omp mode: %s" % args.mode)
-        print(tm.apply_omp() or "omp not answering; the mode applies at the next setup")
+        # the user named the family: it reaches every routed agent, hand-set
+        # selectors included (plan 106); the automatic re-apply leaves those alone
+        print(tm.apply_omp(take=True)
+              or "omp not answering; the mode applies at the next setup")
         return 0
     if not brief:
         print("usage: tezgah-route \"<brief>\" [--phase P] [--json] | --check | --refresh "

package/bin/tezgah-setup

@@ -2922,8 +2922,22 @@ def _run_bounded(argv, timeout):
     the group first: the new session puts the installer outside the terminal's
     process group, so the interrupt no longer reaches it and it would be left
     running as an orphan."""
-    proc = subprocess.Popen(argv, start_new_session=True)
+    # SIGINT is held across Popen and delivered inside the `try` below: one that
+    # landed as Popen returned skipped the group kill (plan 103). The child gets
+    # the old mask back before it execs, so the installer sees no change.
+    # read without changing it, so a KeyboardInterrupt from the block call
+    # itself still restores the mask (review of plan 103)
+    old = signal.pthread_sigmask(signal.SIG_BLOCK, ())
     try:
+        signal.pthread_sigmask(signal.SIG_BLOCK, {signal.SIGINT})
+        proc = subprocess.Popen(argv, start_new_session=True,
+                                preexec_fn=lambda: signal.pthread_sigmask(
+                                    signal.SIG_SETMASK, old))
+    except BaseException:
+        signal.pthread_sigmask(signal.SIG_SETMASK, old)
+        raise
+    try:
+        signal.pthread_sigmask(signal.SIG_SETMASK, old)
         return proc.wait(timeout=timeout)
     except BaseException:
         try: