@r1z4x/tezgah 1.8.2 → 1.9.0

package/hooks/tezgah_integrity.py

@@ -3483,8 +3483,9 @@ def note_tool(session_id, tool, inp, failed=None, *, interrupted=False,
 # so the call's outcome is the slice's: Claude/dsh/Cursor `Agent`/`Task`. omp's
 # `task` and Codex `spawn_agent` return while the child still runs (a Codex
 # rollout shows the call answered with its `task_name` alone), so their records
-# stay open: omp's for `tezgah_task.pending` to close from the child
-# transcripts, Codex's until `pending` closes them `stale`.
+# stay open: omp's for `tezgah_task.pending` to close from the child transcripts,
+# and Codex's until `pending` closes them `stopped` with no failure class - an
+# end this machine cannot see is owed work, not a `stale` record (plan 108).
 SYNC_SPAWN_HOSTS = frozenset(("claude", "dsh", "cursor"))
 
 
@@ -4493,18 +4494,6 @@ def stop_reason(text, session_id, cwd=None, after_block=0,
         detail, kind = "ok", "claim"
     else:
         return None
-    # The temporal spec's verdict, in shadow (plan 063): recorded beside this
-    # one and never read back, and only for a reply that leaves a claim or a
-    # refusal row - the population its agreement bar is read on - so a quiet
-    # allowed reply pays nothing. Its own guard, because the host wraps this
-    # whole function in `safe()` and an escaping exception would lose the refusal.
-    if not record_only:
-        try:
-            import tezgah_stopspec
-            tezgah_stopspec.shadow(cls, text, session_id, rows, cwd, True, key)
-        except Exception:
-            if os.environ.get("TEZGAH_STOPSPEC_STRICT"):
-                raise
     # A refusal is skipped only as the same verdict on the same reply: the same
     # reply text refused for a new class is the turn's next refusal, and
     # `_record_only` counts refusals by these rows. A row bound for a parent's
@@ -4879,15 +4868,14 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
     scoped the way `_partial_state`'s already was, and the Stop path still reads
     the file once per turn.
 
-    `fold` is the evidence fold the selector below calls, `_evidence_block` by
-    default; `tezgah_stopspec.judge` passes the temporal spec's. Under
-    `TEZGAH_STOPSPEC_STRICT` (tests) the default call also asks the spec and
-    raises on a disagreement."""
+    `fold` is the evidence fold the selector below calls. None, the default,
+    is the temporal spec's (`tezgah_stopspec.fold`: the class from its formulas,
+    the text from `_evidence_text`), and that outer call fills the text's
+    placeholders once (`_said`)."""
     if fold is None:
-        verdict = _stop_block(text, session_id, rows, cwd, shape, _evidence_block)
-        if os.environ.get("TEZGAH_STOPSPEC_STRICT"):
-            import tezgah_stopspec
-            tezgah_stopspec.check(verdict[0], text, session_id, rows, cwd, shape)
+        # imported here: tezgah_stopspec imports this module at its top
+        import tezgah_stopspec
+        verdict = _stop_block(text, session_id, rows, cwd, shape, tezgah_stopspec.fold)
         return (verdict[0], verdict[1] and _said(verdict[1]))
     t = str(text or "")
     shaped = _shape_block(t, cwd) if shape else (None, None)
@@ -4957,11 +4945,19 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
         return _residual_block(t, rows, shape,
                                fold(rows, worked | {BEGAN_KIND}, external),
                                session_id, cwd)
+    # A check that answered with an outcome nobody saw (exit 0 and nothing
+    # returned, a status a pipe owns: not `passing_check`) is no pass, and as a
+    # check it is no work row either. A done or tested claim resting on it owes
+    # the `no verify_ok` floor a lost check owes (plan 101: a work-free turn of
+    # one such row let "Tamamlandı, tüm testler geçti" end), so it is read
+    # before the settled exit below, which an earlier pass would otherwise open.
+    unseen = (done or verified) and any(
+        r.get("kind") == "verify_ok" and not passing_check(r) for r in rows)
     # Two shapes the turn's own rows cannot judge, so they are judged against
     # the session's (the contract says "no successful check recorded in the
     # session"). Read only for these two, so every other turn still pays for
     # its own rows alone. Both ask the same fold
-    # this turn is judged by (`_evidence_block`), over the session's rows BEFORE
+    # this turn is judged by (`fold`, the spec's), over the session's rows BEFORE
     # this turn - every class it has, the UI/design and partial-failure ones
     # included, so a state the earlier turns left refused stays refused (review
     # F5). The current turn is left out because it holds no work of its own
@@ -4978,7 +4974,7 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
             # failed check, a command this cannot read as bookkeeping - keeps
             # the turn fold below, which asks for a fresh check.
             srows = events(session_id)
-            if not external and _settled(srows):
+            if not external and not unseen and _settled(srows):
                 return _residual_block(t, rows, shape, fold(
                     _before_turn(srows), True, None, "this session"),
                     session_id, cwd)
@@ -4999,6 +4995,8 @@ def _stop_block(text, session_id, rows=None, cwd=None, shape=True, fold=None):
         # turn can prove
         judged, worked = [r for r in rows if not _work_row(r) or (
             external and _external_read_row([r]) == 0)], set()
+    if unseen:
+        worked = worked | {"verify_ok"}
     return _residual_block(t, rows, shape, fold(judged, worked, external),
                            session_id, cwd)
 
@@ -5028,21 +5026,18 @@ def _before_turn(rows):
     return out
 
 
-def _evidence_block(rows, worked, external, where="this turn"):
-    """The evidence half of `_stop_block` over `rows`: (class, text) or (None,
-    None). `where` names the span the rows cover in the refusal text."""
-    # the newest check decides: "the tests pass" is false when a later run
-    # failed, even though an earlier one succeeded
-    if _last_verify(rows) == "fail":
+def _evidence_text(cls, rows, external, where="this turn"):
+    """(class, block text) for the evidence class the temporal spec picked over
+    `rows` (`tezgah_stopspec.fold`), or (None, None) for none. The spec decides
+    the class; this words it, reading the rows only for what the text names.
+    `where` names the span the rows cover."""
+    if cls == "check failed":
         return ("check failed",
                 "A check failed in %s and the reply claims success. "
                 "Report the failure with its exact error line, or fix it and "
                 "re-run; do not describe a failed check as passing. %s."
                 % (where, ADMISSION))
-    # a failure the turn never resolved: the newest check is not a pass, so an
-    # earlier green run over a different command does not license the claim
-    state = _partial_state(rows)
-    if state["failed"] and not state["verified"]:
+    if cls == "partial failure":
         return ("partial failure",
                 "Partial failure: %s failed %s and no check has passed since, so "
                 "an earlier green run does not cover it. Report that failure "
@@ -5050,89 +5045,44 @@ def _evidence_block(rows, worked, external, where="this turn"):
                 "not describe a partial result as done. If you are deliberately "
                 "stopping on the failure, say what is still broken; %s."
                 % (_failed_check(rows),
-                   "after %s's edits" % where if state["edited"] else "in " + where,
-                   ADMISSION))
-    # A passing check licenses the claim only when it is newer than the newest
-    # write the gate saw change the tree: a green run over the previous revision
-    # is not evidence about this one, and the ledger already carries both sides
-    # (the check's position, and `changed` on the write). The admission is the
-    # reply's own "doğrulanmadı" after a check that failed since that write
-    # (`_admitted`). The pass has to be one
-    # run in the newest change's own repository (`_last_pass`'s `repo`).
-    last_change = _last_change(rows)
-    last_pass = _last_pass(rows, _change_repo(rows, last_change))
-    # The UI half, read before the generic freshness pair because it is a stricter
-    # question about the same rows: a proof of the screen - a check that renders,
-    # or a read of the rendered screen - stands where a unit pass stands, and only
-    # when it is newer than the write it is a proof of. A green unit run is not
-    # that proof, which is the whole point: it never sees what a person sees.
-    # The write it is a proof of is the newest UI write, not the newest write of
-    # anything: a later edit to a `.py` file does not unmake a screen read, and
-    # reading the fold that way refused honest turns and named a screen check the
-    # turn had in fact run.
-    ui_write, ui_proof = _ui_evidence(rows)
-    if ui_write >= 0 and ui_proof <= ui_write:
+                   "after %s's edits" % where if _partial_state(rows)["edited"]
+                   else "in " + where, ADMISSION))
+    if cls in ("no ui_ok", "stale evidence"):
         names = _stale_paths(rows)
         shown = ", ".join(names[:3]) + (" (+%d more)" % (len(names) - 3)
                                         if len(names) > 3 else "")
-        return ("no ui_ok",
-                "UI evidence: %s changed a UI source (%s) and the check "
-                "that passed was not one that sees the screen - a unit run "
-                "never does. Run the browser/e2e or visual check and report "
-                "its output, or read the rendered screen (`analyze-app`: the "
-                "accessibility/DOM tree, a screenshot at the widths in scope) "
-                "and say what it showed. A green unit suite does not cover "
-                "what a person sees, and \"{UNVERIFIED}\" does not stand in for "
-                "the screen; if nothing can render it here, write "
-                "\"{UNVERIFIED}\" and name it under \"{BLOCKERS_HEADING}\" as {ENV} "
-                "with the command that failed."
-                % (where, shown or "a UI file"))
-    if ui_write >= 0:
-        # The floor, asked of a component turn on top of the screen proof: a
-        # screenshot or a rendered check says what the thing looks like and
-        # nothing about whether it is on the repository's own contract. A screen
-        # a person looks at is unchanged - it is the component that owes this,
-        # and the check has to be newer than the component write it judges.
-        component, design = _design_evidence(rows)
-        if component >= 0 and design <= component:
-            names = _stale_paths(rows)
-            shown = ", ".join(names[:3]) + (" (+%d more)" % (len(names) - 3)
-                                            if len(names) > 3 else "")
+    if cls == "no ui_ok":
+        # the screen half is asked first, so a turn that owes both reads the
+        # screen's text; the design floor is the component's (`_design_evidence`)
+        ui_write, ui_proof = _ui_evidence(rows)
+        if ui_write >= 0 and ui_proof <= ui_write:
             return ("no ui_ok",
-                    "Design contract: %s changed a component (%s) and no "
-                    "`tezgah-design check` ran over a measurement, so nothing "
-                    "says the component is on the repository's floor - a read of "
-                    "the screen says what it looks like, not whether it is on "
-                    "that floor. Run `tezgah-design check --contract "
-                    ".tezgah/design-contract.md --measured <measurement.json>` "
-                    "(`tezgah-design derive` writes the contract when the repo "
-                    "has none; the measurement is the per-component styles and "
-                    "states the analyze-app loop produces) and report every "
-                    "violation it prints; if the check cannot run here, write "
+                    "UI evidence: %s changed a UI source (%s) and the check "
+                    "that passed was not one that sees the screen - a unit run "
+                    "never does. Run the browser/e2e or visual check and report "
+                    "its output, or read the rendered screen (`analyze-app`: the "
+                    "accessibility/DOM tree, a screenshot at the widths in scope) "
+                    "and say what it showed. A green unit suite does not cover "
+                    "what a person sees, and \"{UNVERIFIED}\" does not stand in for "
+                    "the screen; if nothing can render it here, write "
                     "\"{UNVERIFIED}\" and name it under \"{BLOCKERS_HEADING}\" as {ENV} "
                     "with the command that failed."
-                    % (where, shown or "a component file"))
-    # A screen proof stands where a unit pass stands for the rest of this fold,
-    # so a UI turn whose UI work is proven is not asked for a check it already
-    # has - and one whose UI work is not proven was refused above, so an
-    # unrelated write it left unverified is still the generic question below.
-    # The read of the authoritative source stands where a passing check stands,
-    # for the one claim it is evidence about (`external`): a reply that states
-    # the state of a registry, a release or a CI run and carried the read that
-    # answers it has settled that half of itself. It is folded into the proof
-    # only for that claim - an `npm view` run is not evidence about the tree, and
-    # letting it stand for a turn's own work would excuse every unverified edit
-    # beside it.
-    ext_read = _external_read_row(rows) if external else -1
-    unread = external is not None and ext_read < 0
-    proof = max(last_pass, ui_proof, ext_read)
-    if proof > last_change:
-        if not unread:
-            return (None, None)
-    elif last_pass >= 0:
-        names = _stale_paths(rows)
-        shown = ", ".join(names[:3]) + (" (+%d more)" % (len(names) - 3)
-                                        if len(names) > 3 else "")
+                    % (where, shown or "a UI file"))
+        return ("no ui_ok",
+                "Design contract: %s changed a component (%s) and no "
+                "`tezgah-design check` ran over a measurement, so nothing "
+                "says the component is on the repository's floor - a read of "
+                "the screen says what it looks like, not whether it is on "
+                "that floor. Run `tezgah-design check --contract "
+                ".tezgah/design-contract.md --measured <measurement.json>` "
+                "(`tezgah-design derive` writes the contract when the repo "
+                "has none; the measurement is the per-component styles and "
+                "states the analyze-app loop produces) and report every "
+                "violation it prints; if the check cannot run here, write "
+                "\"{UNVERIFIED}\" and name it under \"{BLOCKERS_HEADING}\" as {ENV} "
+                "with the command that failed."
+                % (where, shown or "a component file"))
+    if cls == "stale evidence":
         return ("stale evidence",
                 "Stale evidence: the newest check that passed ran before %s %s "
                 "written, so it verified an earlier revision of the tree than the "
@@ -5142,18 +5092,19 @@ def _evidence_block(rows, worked, external, where="this turn"):
                 "A green run over the previous revision does not cover this one."
                 % (shown or "a file this session wrote",
                    "was" if len(names) <= 1 else "were", ADMISSION))
-    elif worked and _last_pass(rows) > last_change:
-        # a pass newer than the change exists, only in another repository: the
-        # class stays (ledger continuity), the text names the real reason
-        return ("no verify_ok",
-                "%s changed %s, and the check that passed after it ran in "
-                "another repository (%s), so it says nothing about this one. "
-                "Run the check in the repository you changed and report its "
-                "output; %s."
-                % (where.capitalize(), _change_repo(rows, last_change),
-                   rows[max(i for i, r in enumerate(rows)
-                            if passing_check(r))].get("repo"), ADMISSION))
-    elif worked:
+    if cls == "no verify_ok":
+        last_change = _last_change(rows)
+        if _last_pass(rows) > last_change:
+            # a pass newer than the change exists, only in another repository:
+            # the class stays (ledger continuity), the text names the real reason
+            return ("no verify_ok",
+                    "%s changed %s, and the check that passed after it ran in "
+                    "another repository (%s), so it says nothing about this one. "
+                    "Run the check in the repository you changed and report its "
+                    "output; %s."
+                    % (where.capitalize(), _change_repo(rows, last_change),
+                       rows[max(i for i, r in enumerate(rows)
+                                if passing_check(r))].get("repo"), ADMISSION))
         return ("no verify_ok",
                 "%s did work (edits or commands) and no check ran "
                 "successfully in it (nothing recorded as verify_ok with a "
@@ -5164,11 +5115,7 @@ def _evidence_block(rows, worked, external, where="this turn"):
                 "%s. Do not "
                 "describe a check you did not run as if it ran."
                 % (where.capitalize(), ADMISSION))
-    # Last, so none of the classes above loses its turn to it: every shape this
-    # one refuses is a shape the fold was about to allow. That is the whole
-    # ordering rule of this function - the branch is asked only where the answer
-    # would otherwise be "this turn may end".
-    if unread:
+    if cls == "no external read":
         return ("no external read", _external_text(external, where))
     return (None, None)
 
@@ -5392,8 +5339,7 @@ def _admitted(fold, text):
     is the check that ran and failed (`_proof_attempt_failed`), and an external
     claim with no read of its system still owes the read (`no external read`) -
     otherwise a failed unit check would end a turn its passing twin cannot.
-    Wrapped around whichever fold the selector was given, so the live rule and
-    the temporal spec read the admission the same way."""
+    Wrapped around whichever fold the selector was given."""
     if not NEGATED.search(_prose(text)):
         return fold
 
@@ -5882,6 +5828,9 @@ def _now_closed(item, label):
 QUESTION_END = re.compile(r"(?:\?|\b(?:%s)[.!]?)$" % alts("question_end"))
 PROCESS_ASK = re.compile(alts("ask", "process"), re.I)
 NEVER_DEFAULT = re.compile(alts("ask", "never_default"), re.I)
+# A reply that names a plan it wrote, or asks to build one: building a plan the
+# turn wrote is class F (plan 105), so asking it is the policy, not a needless ask
+PLAN_BUILD = re.compile(alts("ask", "plan_build"), re.I)
 SPEND = re.compile(alts("ask", "spend"), re.I)
 AMOUNT = re.compile(r"\$\s?(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s?(?:\$|usd\b|dolar)", re.I)
 DEFAULT_MARK = re.compile(alts("ask", "default_mark"), re.I)
@@ -5902,7 +5851,8 @@ NEEDLESS_ASK = (
     "merge, a run parameter within the standing spend cap - are taken and "
     "stated in one line, and an outward step the user granted this session is "
     "taken, not asked again. An outward step the user has not granted waits "
-    "for the answer and never proceeds on a default. Do it now, or, when only "
+    "for the answer and never proceeds on a default, and so does building a "
+    "plan this turn wrote. Do it now, or, when only "
     "the user can decide it, put it under a \"{APPROVAL_HEADING}\" heading with "
     "a \"{RECOMMENDED}:\" default and proceed on that default.")
 
@@ -5963,7 +5913,8 @@ def needless_ask(text, granted=frozenset):
     if not lines or not QUESTION_END.search(lines[-1]):
         return None
     last = lines[-1]
-    if never_default(last) or DEFAULT_MARK.search(_tr_lower(re.split(r"\n\s*\n", t)[-1])):
+    if (never_default(last) or PLAN_BUILD.search(_tr_lower(t))
+            or DEFAULT_MARK.search(_tr_lower(re.split(r"\n\s*\n", t)[-1]))):
         return None
     low = _tr_lower(last)
     outward = outward_classes(low)
@@ -6180,8 +6131,13 @@ def ready_left(text, rows, session_id, cwd=None):
 def open_left(text, row, session_id=None, cwd=None):
     """The heads of the in-progress items a done claim leaves (the `open todo`
     class): the row's `open - blocked - ready` count, named by its `taken`
-    heads, when the reply claims done (`asserted_claims`). A blocked item is
-    not counted, an in-progress one a running slice of this session works on
+    heads, when the reply claims done (`asserted_claims`); a turn that did work
+    and leaves an in-progress item without a claim is not judged here, because a
+    session waiting on a running suite and a session that stopped are the same
+    row - the `ready steps` class covers the ready ones (tests/test_integrity.py
+    StopHook.test_a_done_claim_over_an_in_progress_todo_is_refused_once, plan
+    097). A blocked item is not counted, an in-progress one a running slice of
+    this session works on
     (`_not_running`: Claude's TodoWrite has no blocked status, so a dispatched
     step reads in_progress) is not either, and one the reply types with its
     blocker (`_untyped`) passes. A `partial` row (Cursor `merge: true`) holds

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", "off")
+MODES = ("auto", "anthropic", "zai", "any", "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
@@ -105,6 +105,13 @@ SLOTS = {
                  "zai": ("zai/glm-5.3", None),
                  "any": ("anthropic/claude-opus-5.5", "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
+# gpt-5.6-luna, gpt-5.6-terra and gpt-6-luna and none of SLOTS' `openai` ids,
+# which stay the Codex host's. One model, effort as the lever, as the
+# Anthropic column does it.
+OMP_OPENAI = {"cheap": ("gpt-6-luna", "low"), "explore": ("gpt-6-luna", "medium"),
+              "standard": ("gpt-6-luna", "medium"), "frontier": ("gpt-6-luna", "high")}
 AGENT_SLOT = {"tezgah-cheap": "cheap", "tezgah-standard": "standard",
               "tezgah-frontier": "frontier", "tezgah-reviewer": "frontier",
               "tezgah-tester": "cheap", "tezgah-docs": "standard",
@@ -209,7 +216,12 @@ OMP_FAMILIES = ("anthropic", "zai", "any")
 # (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",))}
+            "any": ("openrouter", ("OPENROUTER_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
+# (2026-10-11) named zai, so it is reached only when named.
+MODE_FAMILIES = OMP_FAMILIES + ("openai",)
 
 
 def _omp_stored_providers():
@@ -413,7 +425,7 @@ def other_family_up(text):
     if os.environ.get("TEZGAH_HEALTH_CHECK") == "0":
         return None
     mode = omp_mode()
-    if mode not in OMP_FAMILIES:
+    if mode not in MODE_FAMILIES:
         return None
     funded = funded_families(live=True)
     chained = {sel for slot in SLOTS for sel in _chain(mode, slot, funded)}
@@ -561,17 +573,17 @@ def start_health():
 
 
 def omp_mode(default_selector=None):
-    """`anthropic`, `zai` or `any`: the saved mode, else the default's own family.
+    """`anthropic`, `zai`, `openai` or `any`: the saved mode, else the
+    default's own family.
 
-    A non-Anthropic default reads as `any`, never as a silent fall back to the
-    Anthropic column - the caller decides what to do when the OpenRouter
-    credential the `any` selectors need is missing (`apply_omp` writes nothing
-    and says so)."""
+    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", "off"):
+    if mode in ("anthropic", "zai", "any", "openai", "off"):
         return mode
-    for family in ("anthropic", "zai"):
-        if str(default_selector or "").startswith(family + "/"):
+    for family in ("anthropic", "zai", "openai"):
+        if str(default_selector or "").startswith(FAMILY_PREFIX[family] or family + "/"):
             return family
     return "any"
 
@@ -585,15 +597,22 @@ 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.
-FAMILY_PREFIX = {"anthropic": "anthropic/", "zai": "", "any": "openrouter/"}
+FAMILY_PREFIX = {"anthropic": "anthropic/", "zai": "", "any": "openrouter/",
+                 "openai": "openai-codex/"}
+
+
+def _row(family, slot):
+    """(model, effort) of one slot on one family: omp's own OpenAI column for
+    `openai`, else the table's."""
+    return OMP_OPENAI[slot] if family == "openai" else SLOTS[slot][family]
 
 
 def _selector(family, slot):
     """`<provider>/<model>[:<effort>]` for one slot on one family, the shape omp
     takes for a model override and for a role alike (omp://models.md:492-505):
     the Anthropic column names the host's own id, `zai` a z.ai id, `any` an
-    OpenRouter one."""
-    model, effort = SLOTS[slot][family]
+    OpenRouter one, `openai` an `openai-codex` one."""
+    model, effort = _row(family, slot)
     return FAMILY_PREFIX[family] + model + (":" + effort if effort else "")
 
 
@@ -635,7 +654,7 @@ def _chain(mode, slot, funded, agent=""):
     if policy == "none":
         return [_selector(mode, slot)]
     if policy == "vendor":
-        model, effort = SLOTS[slot][mode]
+        model, effort = _row(mode, slot)
         out = [_selector(mode, slot)]
         for family in families[1:]:
             if _vendor(SLOTS[slot][family][0]) == _vendor(model):
@@ -652,8 +671,15 @@ def _chain(mode, slot, funded, agent=""):
     return [_selector(family, slot) for family in families]
 
 
+def codex_ready():
+    """True when omp holds an `openai-codex` login or its env token."""
+    return ("openai-codex" in _omp_stored_providers()
+            or bool(os.environ.get("OPENAI_CODEX_OAUTH_TOKEN", "").strip()))
+
+
 def _runnable(mode):
-    return mode in OMP_FAMILIES and not (mode == "any" and not openrouter_ready())
+    return mode in MODE_FAMILIES and not (mode == "any" and not openrouter_ready()) \
+        and not (mode == "openai" and not codex_ready())
 
 
 def omp_overrides(mode):
@@ -766,17 +792,17 @@ def _ours_by_shape(key, value):
     # writes chains: pre-chain installs hold single-family selectors, and the
     # bytes are ours whichever shape we wrote.
     slot = AGENT_SLOT.get(key) or BUNDLED.get(key)
-    if slot and any(_selector(family, slot) == value for family in OMP_FAMILIES):
+    if slot and any(_selector(family, slot) == value for family in MODE_FAMILIES):
         return True
     if key.split(".", 1)[-1] in OMP_ROLES and any(
-            _selector(family, "frontier") == value for family in OMP_FAMILIES):
+            _selector(family, "frontier") == value for family in MODE_FAMILIES):
         return True
     return any((omp_overrides(mode) or {}).get(key) == value or
                (omp_role_overrides(mode) or {}).get(key) == value
                for mode in MODES)
 
 
-def _reconcile(current, written, want):
+def _reconcile(current, written, want, taken=None):
     """(new, owns) for one flat {key: value} record, keys tezgah's own and the
     user's alike: `current` what omp holds, `written` the last recorded write,
     `want` what this mode asks for.
@@ -785,7 +811,9 @@ def _reconcile(current, written, want):
     `omp_written` recorded (or, on a machine written before that record existed,
     one of the table's own selectors - `_ours_by_shape`). A value the user
     changed by hand is left alone, an entry tezgah never wrote is never dropped,
-    and ours that is no longer wanted goes."""
+    and ours that is no longer wanted goes. With `taken` (a list, an explicit
+    `tezgah-route --mode`, plan 106) a wanted key the user set by hand is
+    written over too, and its key is appended to `taken`."""
     new, owns = {}, {}
     for key in sorted(set(current) | set(written) | set(want)):
         cur = current.get(key)
@@ -795,7 +823,9 @@ def _reconcile(current, written, want):
             # byte-identical to what we want counts as ours: claiming it writes
             # the same value and only records ownership, which is what lets the
             # next mode switch move it instead of leaving it behind
-            if cur is None or mine or cur == want[key]:
+            if cur is None or mine or cur == want[key] or taken is not None:
+                if taken is not None and not (cur is None or mine or cur == want[key]):
+                    taken.append(key)
                 new[key], owns[key] = want[key], want[key]
             else:
                 new[key] = cur  # the user's own choice for this key wins
@@ -811,7 +841,7 @@ def _reconcile(current, written, want):
     return new, owns
 
 
-def apply_omp(remove=False):
+def apply_omp(remove=False, take=False):
     """Write (or, with `remove`, drop) this table's entries of omp's
     `task.agentModelOverrides` and its `modelRoles.plan` and `.slow`, leaving
     everything else as it is.
@@ -846,12 +876,16 @@ def apply_omp(remove=False):
         elif mode == "any" and not openrouter_ready():
             return ("omp model overrides %s the any mode needs an OpenRouter key "
                     "(or `tezgah-route --mode anthropic`)" % SKIP_MARK)
+        elif mode == "openai" and not codex_ready():
+            return ("omp model overrides %s the openai mode needs omp's "
+                    "`openai-codex` login (`/login openai-codex` in omp)" % SKIP_MARK)
         else:
             want = omp_overrides(mode)
             want_roles = omp_role_overrides(mode)
     flat_roles = {"modelRoles." + role: roles.get(role) for role in OMP_ROLES}
-    new, owns = _reconcile(current, written, want)
-    new_roles, owns_roles = _reconcile(flat_roles, written, want_roles)
+    taken = [] if take else None
+    new, owns = _reconcile(current, written, want, taken)
+    new_roles, owns_roles = _reconcile(flat_roles, written, want_roles, taken)
     owns.update(owns_roles)
     merged = dict(roles)  # every other role the user set stays as it is
     for key in flat_roles:  # a role this table drops leaves no key behind
@@ -866,7 +900,7 @@ def apply_omp(remove=False):
     flat_chains = {"retry.fallbackChains." + role: chains.get(role)
                    for role in OMP_ROLES}
     want_chains = {} if remove else omp_role_chains(mode)
-    new_chains, owns_chains = _reconcile(flat_chains, written, want_chains)
+    new_chains, owns_chains = _reconcile(flat_chains, written, want_chains, taken)
     owns.update(owns_chains)
     merged_chains = dict(chains)
     for key in flat_chains:
@@ -898,7 +932,9 @@ def apply_omp(remove=False):
         return ("omp model overrides written, ownership NOT recorded "
                 "(overlay unreadable)")
     return ("omp model overrides removed (%s)" % (mode or "uninstall") if remove
-            else "omp model overrides written (%s)" % mode)
+            else "omp model overrides written (%s)%s" % (
+                mode, "; replaced %d hand-set: %s" % (len(taken), ", ".join(taken))
+                if taken else ""))
 
 
 # ---------------------------------------------------------------- refresh ----