@r1z4x/tezgah 1.9.2 → 1.11.0

package/hooks/tezgah_judge.py

@@ -195,10 +195,12 @@ SESSION_ARGV = {
     # None of the next three takes a system prompt or drops its tools, so
     # `_session_request` puts the system prompt in front of the prompt text and
     # the empty temp cwd is what keeps tools from reaching a repository. Each
-    # set is from the CLI's own `--help` (checked 2026-10-09). opencode 1.18.31
-    # `run`: `--pure` "run without external plugins", `--format json` "raw JSON
-    # events"; it has no flag that skips the session record.
-    "opencode": ["run", "--pure", "--format", "json"],
+    # set is from the CLI's own `--help` (opencode rechecked 2026-10-19):
+    # opencode 2.0.32 `run` lists `--format json` and no longer the 1.18
+    # `--pure` (it exits 1 "Unrecognized flag: --pure"), so its plugins load
+    # again and the inline config below is what keeps its tools denied; no flag
+    # skips the session record either.
+    "opencode": ["run", "--format", "json"],
     # cursor-agent 2026.10.01: `-p` print, `--output-format json` (only with
     # --print), `--mode ask` "Q&A style ... (read-only)", `--trust` "Trust the
     # current workspace without prompting" - the temp cwd is never trusted.

package/hooks/tezgah_models.py

@@ -55,7 +55,7 @@ READ_ON = "2026-09-30"
 STALE_DAYS = 60
 OVERLAY = os.path.join(tp.CONFIG_DIR, "models.json")
 OPENROUTER_MODELS = "https://openrouter.ai/api/v1/models"
-MODES = ("auto", "anthropic", "zai", "any", "openai", "off")
+MODES = ("auto", "anthropic", "zai", "any", "experientiallabs", "openai", "off")
 # The two status markers `bin/tezgah-setup` classifies an `apply_omp()` line by:
 # a skip is not a write and not a failure - the user's omp is left untouched, and
 # nothing is left to repair, which is why the status report excuses it rather
@@ -84,18 +84,24 @@ TIERS = ("cheap", "standard", "frontier")
 # against GLM-5.3's 95.4 at $0.34 (vals.ai, artifacts/model-table.json), so the
 # cheap slots take the flash id and standard the plain one.
 SLOTS = {
+    # The experientiallabs column: the gateway's uncensored DeepSeek V4.1 Flash
+    # serves efforts none/low/high/max only, so cheap and explore carry `low`
+    # where the Anthropic column carries `medium`.
     "cheap": {"anthropic": ("claude-opus-5-5", "low"),
               "openai": ("gpt-6.1-sol", "low"),
               "zai": ("zai/glm-5.3-flash", None),
-              "any": ("z-ai/glm-5.3-flash", None)},
+              "any": ("z-ai/glm-5.3-flash", None),
+              "experientiallabs": ("deepseek-v4.1-flash-uncensored", "low")},
     "explore": {"anthropic": ("claude-opus-5-5", "medium"),
                 "openai": ("gpt-6.1-sol", "low"),
                 "zai": ("zai/glm-5.3-flash", None),
-                "any": ("deepseek/deepseek-v4.1-flash", None)},
+                "any": ("deepseek/deepseek-v4.1-flash", None),
+                "experientiallabs": ("deepseek-v4.1-flash-uncensored", "low")},
     "standard": {"anthropic": ("claude-opus-5-5", "medium"),
                  "openai": ("gpt-6.1-sol", "high"),
                  "zai": ("zai/glm-5.3", None),
-                 "any": ("openai/gpt-6.1-sol", "high")},
+                 "any": ("openai/gpt-6.1-sol", "high"),
+                 "experientiallabs": ("deepseek-v4.1-flash-uncensored", "high")},
     # The frontier row names a concrete model on every family: the strongest
     # Anthropic run the snapshot prices (Opus 5.5 @high, 56.6 Terminal-Bench 4.0
     # at $1.82/task on AA v4.3), OpenAI's own frontier id, and the same Opus 5.5
@@ -103,7 +109,8 @@ SLOTS = {
     "frontier": {"anthropic": ("claude-opus-5-5", "high"),
                  "openai": ("gpt-6-astra", "high"),
                  "zai": ("zai/glm-5.3", None),
-                 "any": ("anthropic/claude-opus-5.5", "high")},
+                 "any": ("anthropic/claude-opus-5.5", "high"),
+                 "experientiallabs": ("deepseek-v4.1-flash-uncensored", "high")},
 }
 # omp's own OpenAI column (plan 107): omp reaches OpenAI through its
 # `openai-codex` provider (a ChatGPT login), which on 2026-10-13 listed
@@ -124,6 +131,10 @@ SNAPSHOT = {"anthropic/claude-opus-5.5": (4.0, 20.0),
             "openai/gpt-6-astra": (10.0, 50.0),
             "z-ai/glm-5.3-flash": (0.15, 0.5),
             "deepseek/deepseek-v4.1-flash": (0.0198, 0.396)}
+# `experientiallabs` has no SNAPSHOT row on purpose: SNAPSHOT holds OpenRouter
+# ids, and `refresh` reads its list - a custom-provider id here would be a
+# permanent false "no longer in the OpenRouter list" flag. Its prices live in
+# ~/.omp/agent/models.yml `cost`.
 
 # ---------------------------------------------------------------- overlay ----
 
@@ -211,12 +222,13 @@ def openrouter_ready():
 # provider lists none of the column's ids on this machine (`omp models
 # openai-codex`, 2026-10-01: gpt-5.5, gpt-5.6-luna/-terra, gpt-6-luna), so a
 # pattern for it would never resolve.
-OMP_FAMILIES = ("anthropic", "zai", "any")
+OMP_FAMILIES = ("anthropic", "zai", "any", "experientiallabs")
 # family -> (omp's auth-store provider id, the env names omp reads for it)
 # (omp://providers.md:39, omp://environment-variables.md:39-40,71,73).
 OMP_AUTH = {"anthropic": ("anthropic", ("ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY")),
             "zai": ("zai", ("ZAI_API_KEY",)),
             "any": ("openrouter", ("OPENROUTER_API_KEY",)),
+            "experientiallabs": ("experientiallabs", ("EXPERIMENTALLABS_API_KEY",)),
             "openai": ("openai-codex", ("OPENAI_CODEX_OAUTH_TOKEN",))}
 # Every family `--mode` can pin. `openai` is no fallback for the others: it is
 # its own subscription with its own limit, and the owner's fallback ask
@@ -573,16 +585,16 @@ def start_health():
 
 
 def omp_mode(default_selector=None):
-    """`anthropic`, `zai`, `openai` or `any`: the saved mode, else the
-    default's own family.
+    """`anthropic`, `zai`, `openai`, `experientiallabs` or `any`: the saved
+    mode, else the default's own family.
 
     A default of no listed family reads as `any`, never as a silent fall back
     to the Anthropic column - the caller decides what to do when the credential
     the selectors need is missing (`apply_omp` writes nothing and says so)."""
     mode = overlay().get("mode")
-    if mode in ("anthropic", "zai", "any", "openai", "off"):
+    if mode in MODES and mode != "auto":
         return mode
-    for family in ("anthropic", "zai", "openai"):
+    for family in ("anthropic", "zai", "openai", "experientiallabs"):
         if str(default_selector or "").startswith(FAMILY_PREFIX[family] or family + "/"):
             return family
     return "any"
@@ -597,8 +609,10 @@ OMP_ROLES = ("plan", "slow")
 
 # The prefix each family's stored id needs to become an omp selector. `zai` needs
 # none: its id already is `<provider>/<model>`, the shape omp's own config uses.
+# `experientiallabs` is a custom models.yml provider, so its prefix is that
+# provider's own id (~/.omp/agent/models.yml).
 FAMILY_PREFIX = {"anthropic": "anthropic/", "zai": "", "any": "openrouter/",
-                 "openai": "openai-codex/"}
+                 "experientiallabs": "experientiallabs/", "openai": "openai-codex/"}
 
 
 def _row(family, slot):
@@ -1102,7 +1116,7 @@ WRITES = re.compile(r"\b(?:fix|implement|edit|write|add|refactor|patch|migrate|"
                     r"rename|delete|remove|rotate)\w*\b", re.I)
 
 
-def route(brief, phase=None, ask=None):
+def route(brief, phase=None, ask=None, cwd=None):
     """{"agent", "tier", "why", "via", "judge", "judged"} for one delegation
     brief; `via` is what set the tier: `rule`, `jev`, `phase` or `default`, and
     `judge` is the `provider/model` that answered when a judgement set it.
@@ -1112,7 +1126,10 @@ def route(brief, phase=None, ask=None):
     goes out redacted (`ti.redact`, the reader the ledger uses) and only when no
     override matched: a brief matching the override vocabulary never leaves the
     machine. Answers are read through the seam's own accessors, so a malformed
-    reply is the same as no reply and this never raises."""
+    reply is the same as no reply and this never raises.
+
+    The repository's own `agents` (`_repo_route`) are read last, at `cwd`
+    (None: this process's directory, the shell `tezgah-route` runs in)."""
     hit = OVERRIDE.search(brief or "")
     if hit:
         if REVIEW_ONLY.search(brief) and not WRITES.search(brief):
@@ -1131,14 +1148,37 @@ def route(brief, phase=None, ask=None):
         out["judge"] = "%s/%s" % (result.get("provider") or "-",
                                   result.get("model") or "-")
         out["judged"] = result
-        return out
+        return _repo_route(out, brief, cwd)
     if phase in PHASE_AGENT:
-        return _agent(PHASE_AGENT[phase], "no judgement; phase %s names it" % phase,
-                      "phase")
-    if phase in PHASE_TIER:
-        return _pick(PHASE_TIER[phase], "no judgement; static table for phase %s" % phase,
+        out = _agent(PHASE_AGENT[phase], "no judgement; phase %s names it" % phase,
                      "phase")
-    return _pick("standard", "no judgement and no phase; the middle tier", "default")
+    elif phase in PHASE_TIER:
+        out = _pick(PHASE_TIER[phase], "no judgement; static table for phase %s" % phase,
+                    "phase")
+    else:
+        out = _pick("standard", "no judgement and no phase; the middle tier", "default")
+    return _repo_route(out, brief, cwd)
+
+
+def _repo_route(out, brief, cwd):
+    """`out` with the repository's declared agent in place of tezgah's when one
+    of the manifest's `agents` matches the brief (`tezgah_extension.repo_agent`).
+
+    Read after the harness judgement and never before it: the tier, `via` and
+    the judge stay the harness's, only the agent that runs it is the repo's.
+    The override rule returns before this is reached, so a brief the harness
+    pinned by rule keeps its agent. A broken manifest, a missing module or a
+    vanished cwd keeps `out` as it was."""
+    try:
+        import tezgah_extension
+        found = tezgah_extension.repo_agent(brief, cwd or os.getcwd())
+    except Exception:
+        found = None
+    if not found:
+        return out
+    agent, pattern = found
+    return dict(out, agent=agent,
+                why="%s; repo agent %s (match %r)" % (out["why"], agent, pattern))
 
 
 def _agent(agent, why, via):

package/hooks/tezgah_orca.py

@@ -116,7 +116,7 @@ def context_line(env=None):
             "`git worktree add`, which Orca does not list. A long job runs in "
             "`orca terminal create --worktree <selector> --command <cmd> --json`, "
             "not a background shell. Track with `orca worktree ps --json` and "
-            "`tezgah-status --orca`; mark checkpoints with `orca worktree set "
+            "`~/.config/tezgah/bin/tezgah-status --orca`; mark checkpoints with `orca worktree set "
             "--worktree active --comment <text>`. Full guide: `orca skills get "
             "orca-cli`." % where)
 

package/hooks/tezgah_paths.py

@@ -69,13 +69,13 @@ OFF_DIRS = (CONFIG_DIR, os.path.join(HOME, ".claude"))
 # (bin/tezgah-setup OFF_SWITCH_NAMES), the context's off-note (`switches()`),
 # the opencode plugin's own `off()` and the gate's control rule all answer from
 # it, and tests/test_paths.py fails when any of them names a switch it lacks.
-# CORE_SWITCHES are the sixteen the always-on contract names. ADR 007 leaves
+# CORE_SWITCHES are the seventeen the always-on contract names. ADR 007 leaves
 # UNCLASSIFIED_SWITCHES open - three `off()` names CORE does not list (the
 # third, `slices-off`, stops the slice journal: hooks/tezgah_task.py) and two
 # opt-in markers read with `armed()` - and until the owner classifies them the
 # control rule protects them like the rest (bin/tezgah-docs carries the same
 # set for its inventory check; the test pins the two equal).
-CORE_SWITCHES = ("adhd-off", "consult-off", "docs-judge-off", "exec-mode.off",
+CORE_SWITCHES = ("adhd-off", "consult-off", "design-off", "docs-judge-off", "exec-mode.off",
                  "judge-off", "lang-off", "orchestrate-off", "ponytail-auto.off",
                  "pretooluse-off", "reminder-off", "research-off", "spec-off",
                  "task-off", "triage-off", "verify-off", "workspace-off")
@@ -245,15 +245,84 @@ def root_for(path):
     rs = roots()
     for r in rs:
         if real == r or real.startswith(r + os.sep):
-            return r
+            # Read lazily, in the branch where the root already matched: a path
+            # outside every configured root pays nothing for the marker.
+            return None if harness_excluded(real) else r
     top = worktree_top(real)
     if top:
         main = _linked_main_at(top)
         if main and any(main == r or main.startswith(r + os.sep) for r in rs):
-            return top
+            return None if harness_excluded(top) else top
     return None
 
 
+# --- the owner marker: a repository that says who owns its workspace --------
+# Every repository under a configured root is armed, because `roots()` is the
+# only switch and the kill switches are global (`~/.config/tezgah/*.off`) or
+# per-feature (`<repo>/.no-ponytail`). A project whose workspace is not this
+# harness's has no way to say so - and one measured consequence is a review of
+# an authorized offensive-security workspace where the harness's development
+# plan/task machine drove a lab engagement: three `tezgah-task` writes inside
+# the run and the per-turn phase line reaching a read-only review subagent
+# (that repository's `.tezgah/analysis/harness-review-and-gaps.md`, the plan-011
+# section; the line range is left out because a citation into another
+# repository's workspace cannot be judged against this tree).
+# The marker is that way: a file the repository owns, committed, reviewable in a
+# diff, and not produced by `tezgah-setup`, so a config rewrite cannot resurrect
+# the collision. Two settings, because they cost different things:
+#   tasks: off        - the plan/task machine and the per-turn task line stop;
+#                       the scope gate, research and lessons keep working.
+#   harness: excluded - `root_for` answers None and the harness is inert here
+#                       entirely: no workspace init, no plan/task/lesson record,
+#                       no gate envelope, no per-turn contract clause.
+OWNER_MARKER = "tezgah.owner"
+OWNER_KEYS = ("owner", "tasks", "harness")
+_OWNER_OFF = ("off", "false", "no")
+
+
+def owner_marker(path):
+    """The owner marker's fields for the repository holding `path`, or {}.
+
+    Read from the nearest `.git` top level at or above `path` (`_toplevel`), so a
+    path inside a workspace reads its project's marker and a repository cloned
+    inside that workspace answers for itself. A missing or unreadable file, a
+    line with no `:`, an unknown key and a blank value all answer {} rather than
+    raise: this runs inside `root_for`, which every gate call and every session
+    start reaches, and a marker that cannot be read must decide nothing."""
+    top = _toplevel(os.path.realpath(path))
+    if not top:
+        return {}
+    try:
+        with open(os.path.join(top, OWNER_MARKER), encoding="utf-8") as fh:
+            text = fh.read(4096)
+    except (OSError, UnicodeDecodeError):
+        return {}
+    out = {}
+    for line in text.splitlines():
+        key, _, value = line.split("#", 1)[0].partition(":")
+        key, value = key.strip().lower(), value.strip().lower()
+        if key in OWNER_KEYS and value:
+            out[key] = value
+    return out
+
+
+def harness_excluded(path):
+    """True when the repository holding `path` declares `harness: excluded`,
+    the state in which `root_for` answers None and nothing here is armed."""
+    return owner_marker(path).get("harness") == "excluded"
+
+
+def tasks_disabled(path):
+    """True when `path`'s repository says the plan/task machine must not run from
+    its plans: `tasks: off`, or `harness: excluded`, which implies it.
+
+    The narrower of the two settings, and the one a project takes first: the
+    task rule turns off while the seams a repository still wants - the scope
+    gate, `bin/run-tool`, research, lessons - keep reading its workspace."""
+    fields = owner_marker(path)
+    return fields.get("harness") == "excluded" or fields.get("tasks") in _OWNER_OFF
+
+
 def _toplevel(real):
     """The nearest directory at or above `real` holding a `.git` entry, else
     None - the project for a path inside its `.tezgah` (`project_top`)."""
@@ -492,7 +561,10 @@ CONSULT_CLIS = {
                "--model", "Anthropic Claude"),
     "codex": (["codex", "exec", "--skip-git-repo-check", "--ephemeral",
                "-s", "read-only", "--color", "never"], "-m", "OpenAI GPT"),
-    "opencode": (["opencode", "run", "--pure"], "-m",
+    # opencode 2.0.32 dropped the 1.18 `--pure` (`run` exits 1 "Unrecognized
+    # flag: --pure") and no flag replaces it, so the member runs the way the
+    # user's own `opencode run` does
+    "opencode": (["opencode", "run"], "-m",
                  "whichever provider/model opencode is configured for"),
     "cursor-agent": (["cursor-agent", "-p", "--output-format", "text"],
                      "--model", "whichever model Cursor is configured for"),
@@ -750,6 +822,16 @@ def orx_bin():
     return which_user(os.environ.get("TEZGAH_ORX_BIN") or ORX)
 
 
+def ocr_bin():
+    """The open-code-review `ocr` executable, or None when it is not installed.
+
+    TEZGAH_OCR_BIN points at a specific binary (tests, CI); otherwise the first
+    `ocr` on PATH wins, then a known per-user bin dir - the lookup `orx_bin()`
+    makes. Optional: without it the reviewer brief is today's (plan 125)."""
+    return which_user(os.environ.get("TEZGAH_OCR_BIN") or "ocr")
+
+
+
 def omp_bin():
     """The omp CLI, or None when it is not installed.
 
@@ -1282,10 +1364,24 @@ def ensure_workspace(repo):
     (its worktrees' links are excluded by `link_workspace`). A second call costs
     three stats and one file read: the subprocess runs only when `.tezgah/.git`
     does not exist yet. Fail-open: a read-only tree returns None and the session
-    goes on."""
+    goes on.
+
+    A linked worktree never gets a workspace of its own (plan 121): it gets the
+    main checkout's as a link, the same link `link_workspace` makes, so research,
+    migrate and the session start all land in the one store instead of forking a
+    second `.tezgah` that `git worktree remove` deletes."""
     bare = _bare_repo(repo)
     if not bare and not os.path.exists(os.path.join(repo, ".git")):
         return None
+    main = linked_main(repo)
+    if main and main != repo:
+        target = ensure_workspace(main)
+        # A `.tezgah` already on disk - the project's own or a fork an older
+        # tezgah made - is `link_workspace`'s to leave alone; the main
+        # checkout's is what every reader is handed either way.
+        if target and not os.path.lexists(workspace(repo)):
+            link_workspace(repo, main)
+        return target or None
     ws = workspace(repo)
     # A `.tezgah` that is a symlink (or anything but a directory) came with the
     # repository: following it would `git init` inside the target the clone