omnilane 0.42.5 → 0.42.6

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "One routing table, native-first or CLI delegation, supervised completion workflows.",
-    "version": "0.42.5"
+    "version": "0.42.6"
   },
   "plugins": [
     {
       "name": "omnilane",
       "source": "./",
       "description": "Route each subtask to the model that fits, then delegate through a compatible caller-owned native agent or vendor CLI.",
-      "version": "0.42.5",
+      "version": "0.42.6",
       "category": "development",
       "keywords": [
         "routing",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omnilane",
-  "version": "0.42.5",
+  "version": "0.42.6",
   "description": "One routing table, every harness: classify subtasks into lanes and delegate through compatible caller-owned native agents or vendor CLIs with exact-AA downward policy and supervised jobs.",
   "author": {
     "name": "Seraphim0916"

package/CHANGELOG.md

@@ -6,6 +6,66 @@ semantic version tags.
 
 ## [Unreleased]
 
+## [0.42.6] - 2026-09-10
+
+### Added
+
+- Every transport overlay mapping now records an `evidence_tier` saying how
+  strongly its probe identified the responder. `billed-model` is the provider
+  naming the model it charged for (Claude's `modelUsage`, grok's under
+  `--output-format json`); `client-echo` is the CLI recording the model it asked
+  for (codex's session rollout, agy's `cli.log` resolver line); `selector-only`
+  is a CLI accepting the selector and reporting nothing further. A verified
+  mapping previously flattened these into one word, which overstated two of the
+  four vendors in the same way the gate itself did before 0.42.5.
+- `omnilane doctor` reports the tier alongside each vendor's verified count and
+  names the vendors worth re-probing.
+
+### Changed
+
+- The tier is derived from what a run produced rather than assigned per vendor,
+  so evidence written before this release re-judges as `selector-only` and a CLI
+  that begins reporting a billed model is promoted with no code change.
+- `probe.py` gathers each CLI's own on-disk record of the request — codex through
+  the `thread.started` id that names its rollout, agy through the app data
+  directory prepared the way `run-gemini.sh` prepares it — and stores a digest of
+  the model-bearing lines beside the streams, so the judgement stays a pure
+  function that can re-judge an old sweep offline.
+- Grok probes accept the billed model only as an exact match or with the single
+  `-build` suffix the provider adds; a prefix test would let `grok-4.6-anything`
+  pass as `grok-4.6`.
+
+### Fixed
+
+- The overlay anchored vendor executables by paths written into
+  `build_overlay.py`, which drift out of use without failing: the live overlay
+  hashed claude `2.1.263` while every dispatch ran `2.1.266`, so eleven mappings
+  were verified against a binary that had not run in a day. Core evidence now
+  anchors the executable the runners resolve.
+- The last two mappings carrying `PRIOR:` references instead of probe evidence
+  were re-probed, so every signed mapping now has a descriptor a reader can open.
+- A failing codex probe recorded `exit-code: 1` and nothing else. Under
+  `exec --json` the refusal that ends a run is an stdout event, so the reason
+  never reached `unproven[]`.
+
+### Removed
+
+- The three `gpt-5.4-mini` mappings. The model passed its probe on 2026-09-07
+  and now returns HTTP 400 — "not supported when using Codex with a ChatGPT
+  account" — so those configurations move to `unproven[]` carrying that reason.
+  A signed overlay does not notice a lane dying upstream; only a re-probe does.
+  The overlay now holds 46 mappings and 9 unproven configurations.
+
+### Notes
+
+- The tier is reported and never enforced. Dispatch continues to turn on
+  `runtime_verified` alone, covered by a test asserting every decision is
+  byte-identical under all three tiers.
+- agy and grok update themselves in the background when invoked; agy's `cli.log`
+  records `auto_updater.go: Spawned background update process`. Overlay evidence
+  drift is a routine consequence of using a vendor rather than an operator
+  action, and per-vendor degradation is what keeps that from stopping work.
+
 ## [0.42.5] - 2026-09-09
 
 ### Fixed

package/README.ja.md

@@ -573,6 +573,16 @@ work の別名ではありません。サービス管理など、work の境界
 
 ## 📜 リリース履歴
 
+## v0.42.6 の新機能
+
+- **「検証済み」が、どう検証されたかを示すようになりました。** 各 overlay マッピングは `evidence_tier` を持ちます。`billed-model` はプロバイダー自身が課金対象のモデル名を返した場合（claude、grok）、`client-echo` は CLI が自ら送信したモデルを記録した場合（codex、agy）、`selector-only` は CLI がセレクターを受け付けただけの場合です。`client-echo` は CLI が控えた注文書、`billed-model` はプロバイダーが発行した領収書です。
+- **報告するだけで、拒否はしません。** ディスパッチは従来どおり `runtime_verified` のみで判断するため、ティアが低くても動いていたレーンが拒否されることはありません。3 つのティアすべてで判定が変わらないことをテストで保証しています。
+- **ティアはベンダーではなく証拠に従います。** 本リリース以前のプローブは `selector-only` として再判定され、課金モデルを返すようになった CLI はコード変更なしに昇格します。
+- **`omnilane doctor` が内訳を表示**し、再プローブすべきベンダーを名指しします。
+- **overlay は実際に実行されるバイナリを固定します。** 従来はパスが `build_overlay.py` に直書きされ、使われていないバージョンを黙って指していました。実際には claude `2.1.266` が実行されているのに、overlay は `2.1.263` をハッシュしていました。
+- **失われた 3 レーンを検出。** `gpt-5.4-mini` は 2026-09-07 のプローブでは通っていましたが、現在は HTTP 400（ChatGPT アカウントの Codex では非対応）を返します。署名済みの overlay はレーンが上流で失われても気付きません。該当の 3 構成は理由付きで `unproven[]` に移り、マッピングは 46 件になりました。
+- **アップグレード。** npm 公開後は `npm i -g omnilane@0.42.6` を実行してください。
+
 ## v0.42.5 の新機能
 
 - **1 つの CLI 更新が全ベンダーを止めることはなくなりました。** overlay の evidence に `vendor` タグを付与でき、タグ付きエントリのハッシュ差異やファイル消失は当該ベンダーのみを `unknown-target-runtime` に降格させます。タグなしの evidence は従来どおり全体を fail-closed にします。

package/README.ko.md

@@ -558,6 +558,16 @@ doctor가 파일과 벤더를 지목하며, 재서명 절차는 디스패치 스
 
 ## 📜 릴리스 기록
 
+## v0.42.6 새 기능
+
+- **"검증됨"이 어떻게 검증했는지도 알려줍니다.** 각 overlay 매핑은 `evidence_tier`를 가집니다. `billed-model`은 공급자가 과금한 모델을 직접 밝힌 경우(claude, grok), `client-echo`는 CLI가 자신이 보낸 모델을 기록한 경우(codex, agy), `selector-only`는 CLI가 셀렉터를 받아들이기만 한 경우입니다. `client-echo`는 CLI가 적어 둔 주문서이고, `billed-model`은 공급자가 발행한 영수증입니다.
+- **보고만 하고 막지 않습니다.** 디스패치는 여전히 `runtime_verified`만으로 결정되므로, 낮은 등급이 기존에 동작하던 레인을 거부하는 일은 없습니다. 세 등급 모두에서 판정이 동일함을 테스트로 보장합니다.
+- **등급은 공급업체가 아니라 증거를 따릅니다.** 이번 릴리스 이전의 프로브는 `selector-only`로 재판정되며, 과금 모델을 보고하기 시작한 CLI는 코드 변경 없이 승격됩니다.
+- **`omnilane doctor`가 분포를 표시**하고 다시 프로브할 공급업체를 지목합니다.
+- **overlay는 실제로 실행되는 바이너리를 고정합니다.** 기존에는 경로가 `build_overlay.py`에 하드코딩되어 사용되지 않는 버전을 조용히 가리켰습니다. 모든 디스패치가 claude `2.1.266`을 실행하는 동안 overlay는 `2.1.263`을 해시하고 있었습니다.
+- **죽은 레인 3개를 찾았습니다.** `gpt-5.4-mini`는 2026-09-07 프로브에서는 통과했지만 지금은 HTTP 400(ChatGPT 계정의 Codex에서는 미지원)을 반환합니다. 서명된 overlay는 레인이 상류에서 사라져도 알아차리지 못합니다. 해당 3개 구성은 이유와 함께 `unproven[]`으로 이동했고, 매핑은 46개가 되었습니다.
+- **업그레이드.** npm 게시 후 `npm i -g omnilane@0.42.6`를 실행하세요.
+
 ## v0.42.5 새 기능
 
 - **CLI 하나를 업그레이드해도 모든 벤더가 막히지 않습니다.** overlay evidence 항목에 `vendor` 태그를 붙일 수 있으며, 태그가 있는 항목의 해시가 바뀌거나 파일이 사라지면 해당 벤더만 `unknown-target-runtime`으로 강등됩니다. 태그가 없는 evidence는 기존처럼 전체 fail-closed입니다.

package/README.md

@@ -647,6 +647,35 @@ vendor; the dispatch skill carries the re-signing runbook.
 
 </details>
 
+<details>
+<summary><b>What does my mapping's evidence tier mean?</b></summary>
+
+<br/>
+
+It says how strongly the probe pinned down who answered. It does not affect
+whether you can dispatch.
+
+`billed-model` — the provider named the model it charged for. Claude reports it
+in `modelUsage`; grok reports it the same way under `--output-format json`. This
+is the provider's receipt.
+
+`client-echo` — the CLI wrote down the model it asked for, and that record
+matches your request. Codex keeps it in the session rollout; agy writes it to
+`cli.log`. This is the CLI's copy of your order, not the provider's receipt: it
+proves the request left as intended, not who served it.
+
+`selector-only` — the CLI accepted the selector and reported nothing further.
+Every mapping probed before v0.42.6 reads this way. It still dispatches; it is
+simply the weakest of the three, and `omnilane doctor` names the vendors worth
+re-probing.
+
+None of the three certifies upstream provider identity, and none of them can
+refuse a lane. The tier is derived from what a probe produced rather than from
+the vendor, so a CLI that starts reporting a billed model is promoted on its
+next sweep with no change to omnilane.
+
+</details>
+
 ## 📊 Defaults and provenance
 
 Default lane assignments follow Artificial Analysis coding/intelligence data
@@ -670,6 +699,16 @@ working notes, including per-benchmark caveats, live in
 
 ## 📜 Release history
 
+## What's new in v0.42.6
+
+- **A verified mapping now says how it was verified.** Each overlay mapping carries an `evidence_tier`: `billed-model` when the provider named the model it charged for (Claude, grok), `client-echo` when the CLI recorded the model it asked for (codex, agy), `selector-only` when the CLI accepted the selector and said nothing more. `client-echo` is the CLI's copy of your order; `billed-model` is the provider's receipt.
+- **Reported, never enforced.** Dispatch still turns on `runtime_verified` alone, so a weaker tier never refuses a lane that used to run. A test asserts every decision is unchanged under all three tiers.
+- **The tier follows the evidence, not the vendor.** A sweep predating this release re-judges as `selector-only`, and a CLI that begins reporting a billed model is promoted with no code change.
+- **`omnilane doctor` shows the spread** and names the vendors worth re-probing.
+- **Overlay evidence anchors the binary that runs.** Paths were written into `build_overlay.py` and drifted out of use silently — the live overlay hashed claude `2.1.263` while every dispatch ran `2.1.266`. Core evidence now resolves the executable the runners resolve.
+- **Three dead lanes found.** `gpt-5.4-mini` passed its probe on 2026-09-07 and now returns HTTP 400 — "not supported when using Codex with a ChatGPT account". A signed overlay never notices a lane dying upstream; the re-probe did. Those three configurations move to `unproven[]` with that reason attached, leaving 46 mappings.
+- **Upgrade.** After npm publication, run `npm i -g omnilane@0.42.6`. Existing repo-symlink installations can update their checkout and verify `omnilane --version` without rerunning installation.
+
 ## What's new in v0.42.5
 
 - **One CLI upgrade no longer refuses every vendor.** Overlay evidence entries take a `vendor` tag; a tagged entry whose hash drifts or whose file has disappeared degrades only that vendor to `unknown-target-runtime`. Untagged evidence stays globally fail-closed.

package/README.zh-CN.md

@@ -508,6 +508,30 @@ overlay 钉住每家的可执行文件与 runner 脚本哈希，而 Codex 与 Cl
 
 </details>
 
+<details>
+<summary><b>映射上的证据等级是什么意思？</b></summary>
+
+<br/>
+
+它说明这次探测把「谁回答的」钉到多紧。它**不影响**你能不能派工。
+
+`billed-model`——供应商自己说出它计费的模型。claude 放在 `modelUsage`；
+grok 在 `--output-format json` 下也一样。这是供应商开的收据。
+
+`client-echo`——CLI 记下自己送出的模型，而且那笔记录与你的请求相符。
+codex 记在 session rollout，agy 写进 `cli.log`。这是 CLI 自己抄的订单，
+不是收据：它证明请求照原样送出去了，不能证明是谁接的。
+
+`selector-only`——CLI 收下选择器，其余不表态。v0.42.6 之前探测的每一条映射
+都是这一级。它照样能派工，只是三级里最弱的一级；`omnilane doctor` 会点名
+哪几家值得重探。
+
+三者都不能证明上游供应商身分，也都不会让任何车道被拒。等级是从探测产出的
+东西推导出来的，不是按厂商指定，所以哪支 CLI 开始汇报计费模型，下一次重探
+就会自动升级，omnilane 不用改。
+
+</details>
+
 ## 📊 默认值与数据来源
 
 默认通道配置依据 Artificial Analysis 2026-07 快照(已对 AA 站上原始记录与
@@ -530,6 +554,16 @@ overlay 钉住每家的可执行文件与 runner 脚本哈希，而 Codex 与 Cl
 
 ## 📜 版本历程
 
+## v0.42.6 新功能
+
+- **「已验证」现在会说明是怎么验的。** 每条 overlay 映射带一个 `evidence_tier`：`billed-model` 是供应商自己说出计费的模型（claude、grok），`client-echo` 是 CLI 记下自己送出的模型（codex、agy），`selector-only` 是 CLI 收下选择器、其余不表态。`client-echo` 是 CLI 自己抄的订单，`billed-model` 是供应商开的收据。
+- **只汇报，不拦截。** 派工照旧只看 `runtime_verified`，等级低不会让原本跑得动的车道被拒。已有测试确认三种等级下每个判定都不变。
+- **等级跟着证据走，不跟着厂商走。** 本次发布之前的探测会重判为 `selector-only`；哪天某支 CLI 开始汇报计费模型，不改代码就自动升级。
+- **`omnilane doctor` 显示分布**，并点名哪几家值得重探。
+- **overlay 锚定的是真正在跑的可执行文件。** 过去路径写死在 `build_overlay.py` 里，会无声地锚到没在用的版本——线上 overlay 哈希的是 claude `2.1.263`，但每次派工跑的都是 `2.1.266`。
+- **抓到三条已死的车道。** `gpt-5.4-mini` 在 2026-09-07 探测还会过，现在回 HTTP 400——「ChatGPT 账号使用 Codex 时不支持此模型」。签好的 overlay 永远不会发现某条车道在上游死掉，重探才会。那三条移进 `unproven[]` 并附上原因，映射剩 46 条。
+- **升级。** npm 发布后运行 `npm i -g omnilane@0.42.6`。既有的 repo symlink 安装更新检出后确认 `omnilane --version` 即可。
+
 ## v0.42.5 新功能
 
 - **升级一支 CLI 不再阻断所有厂商。** overlay 的证据项目可带 `vendor` 标签；带标签的项目哈希漂移或文件消失时，只让该厂商降级为 `unknown-target-runtime`。未标签的证据维持全局 fail-closed。

package/README.zh-TW.md

@@ -552,6 +552,30 @@ overlay 釘住每家的執行檔與 runner 腳本雜湊，而 Codex 與 Claude
 
 </details>
 
+<details>
+<summary><b>映射上的證據等級是什麼意思？</b></summary>
+
+<br/>
+
+它說明這次探測把「誰回答的」釘到多緊。它**不影響**你能不能派工。
+
+`billed-model`——供應商自己說出它計費的模型。claude 放在 `modelUsage`；
+grok 在 `--output-format json` 下也一樣。這是供應商開的收據。
+
+`client-echo`——CLI 記下自己送出的模型，而且那筆紀錄與你的請求相符。
+codex 記在 session rollout，agy 寫進 `cli.log`。這是 CLI 自己抄的訂單，
+不是收據：它證明請求照原樣送出去了，不能證明是誰接的。
+
+`selector-only`——CLI 收下選擇器，其餘不表態。v0.42.6 之前探測的每一條映射
+都是這一級。它照樣能派工，只是三級裡最弱的一級；`omnilane doctor` 會點名
+哪幾家值得重探。
+
+三者都不能證明上游供應商身分，也都不會讓任何車道被拒。等級是從探測產出的
+東西推導出來的，不是按廠商指定，所以哪支 CLI 開始回報計費模型，下一次重探
+就會自動升級，omnilane 不用改。
+
+</details>
+
 ## 📊 預設值與資料來源
 
 預設通道配置依據 Artificial Analysis 2026-07 快照(已對 AA 站上原始紀錄與
@@ -571,6 +595,16 @@ overlay 釘住每家的執行檔與 runner 腳本雜湊，而 Codex 與 Claude
 
 ## 📜 版本歷程
 
+## v0.42.6 新功能
+
+- **「已驗證」現在會說明是怎麼驗的。** 每條 overlay 映射帶一個 `evidence_tier`：`billed-model` 是供應商自己說出計費的模型（claude、grok），`client-echo` 是 CLI 記下自己送出的模型（codex、agy），`selector-only` 是 CLI 收下選擇器、其餘不表態。白話說：`client-echo` 是 CLI 自己抄的訂單，`billed-model` 是供應商開的收據。
+- **只回報，不擋人。** 派工照舊只看 `runtime_verified`，等級低不會讓原本跑得動的車道被拒。已有測試確認三種等級下每個判定都不變。
+- **等級跟著證據走，不跟著廠商走。** 本次發布之前的探測會重判為 `selector-only`；哪天某支 CLI 開始回報計費模型，不改程式就自動升級。
+- **`omnilane doctor` 顯示分佈**，並點名哪幾家值得重探。
+- **overlay 錨定的是真正在跑的執行檔。** 過去路徑寫死在 `build_overlay.py` 裡，會無聲地錨到沒在用的版本——線上 overlay 雜湊的是 claude `2.1.263`，但每次派工跑的都是 `2.1.266`。現在改用 runner 實際解析到的執行檔。
+- **抓到三條已死的車道。** `gpt-5.4-mini` 在 2026-09-07 探測還會過，現在回 HTTP 400——「ChatGPT 帳號使用 Codex 時不支援此模型」。簽好的 overlay 永遠不會發現某條車道在上游死掉，重探才會。那三條移進 `unproven[]` 並附上原因，映射剩 46 條。
+- **升級。** npm 發布後執行 `npm i -g omnilane@0.42.6`。既有的 repo symlink 安裝更新檢出後確認 `omnilane --version` 即可，不需重跑安裝。
+
 ## v0.42.5 新功能
 
 - **升級一支 CLI 不再擋掉所有廠商。** overlay 的證據項目可帶 `vendor` 標籤；帶標籤的項目雜湊漂移或檔案消失時，只讓該廠商降級為 `unknown-target-runtime`。未標籤的證據維持全域 fail-closed。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnilane",
-  "version": "0.42.5",
+  "version": "0.42.6",
   "description": "One routing table, every harness — classify subtasks into lanes and delegate each lane through a compatible caller-owned native agent or vendor CLI.",
   "bin": {
     "omnilane": "bin/omnilane"

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "omnilane",
-  "version": "0.42.5",
+  "version": "0.42.6",
   "description": "One routing table, every harness: classify subtasks into lanes and delegate through compatible caller-owned native agents or vendor CLIs with exact-AA downward policy and supervised jobs."
 }

package/scripts/lib/aa_policy.py

@@ -29,6 +29,10 @@ APPROVED_REGISTRY_SHA256 = "0782c87de123c02738c3ff60e4bc3c1cc10d110113e872b8f862
 
 IDENTITY_FIELDS = ("vendor", "model", "effort", "reasoning", "fallback")
 TRANSPORT_EVIDENCE_VENDORS = frozenset(("codex", "claude", "grok", "gemini"))
+# How strongly a mapping's probe identified the responder. Reported, never
+# enforced: dispatch turns on runtime_verified alone, as it did before the field
+# existed, so a weaker tier can never refuse a lane that used to run.
+TRANSPORT_EVIDENCE_TIERS = frozenset(("billed-model", "client-echo", "selector-only"))
 IDENTIFIER = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}\Z")
 
 
@@ -178,6 +182,7 @@ def apply_transport_overlay(registry: dict[str, Any]) -> None:
                 _check(False, "transport contract evidence changed")
             stale_vendors.add(vendor)
     _check(bool(overlay.get("evidence")), "transport overlay requires local evidence")
+    tiers: dict[str, str] = {}
     for mapping in overlay.get("mappings", []):
         rows = [row for row in registry["scored_configs"] if row["id"] == mapping.get("config_id")]
         _check(len(rows) == 1, "unknown overlay config")
@@ -197,8 +202,11 @@ def apply_transport_overlay(registry: dict[str, Any]) -> None:
             _check(mapping["runtime_model"].endswith("-" + row["effort"]), "encoded effort does not match exact tuple")
         else:
             _check(mapping.get("runtime_model") == row["model"], "overlay model mismatch")
+        tier = mapping.get("evidence_tier", "selector-only")
+        _check(tier in TRANSPORT_EVIDENCE_TIERS, "unknown transport evidence tier")
         if row["vendor"] in stale_vendors:
             continue
+        tiers[row["id"]] = tier
         row["transport_mapping"].update(
             status="verified", runtime_verified=True,
             runtime_model=mapping["runtime_model"], runtime_effort=mapping["runtime_effort"],
@@ -208,6 +216,7 @@ def apply_transport_overlay(registry: dict[str, Any]) -> None:
             overlay_sha256=digest, overlay_host=overlay["host"],
         )
     registry["_stale_transport_vendors"] = sorted(stale_vendors)
+    registry["_transport_evidence_tiers"] = tiers
 
 
 def load_registry(path: str | Path, expected_sha256: str | None = None) -> tuple[dict[str, Any], str]:

package/scripts/lib/build_overlay.py

@@ -10,7 +10,9 @@ import argparse
 import hashlib
 import json
 import os
+import shutil
 import socket
+from collections import Counter
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -37,13 +39,13 @@ for effort in ["xhigh", "medium"]:
     PROVEN[f"codex/gpt-5-4-mini" + ("" if effort == "xhigh" else f"-{effort}")] = (
         "model_and_effort", "gpt-5.4-mini", f"cx-gpt-5_4-mini-{effort}")
 
-PROVEN["grok/grok-4-6"] = ("cli_reasoning_effort", "grok-4.6", "PRIOR:grok-effort-2026-09-07")
+PROVEN["grok/grok-4-6"] = ("cli_reasoning_effort", "grok-4.6", "gk-grok-4_6-high")
 for effort in ["xhigh", "medium", "low"]:
     PROVEN[f"grok/grok-4-6-{effort}"] = ("cli_reasoning_effort", "grok-4.6", f"gk-grok-4_6-{effort}")
 PROVEN["grok/grok-4-5"] = ("cli_reasoning_effort", "grok-4.5", "gk-grok-4_5-high")
 
 for cid, rid, ev in [
-    ("gemini/gemini-3-8-flash", "gemini-3.8-flash-high", "PRIOR:gemini-flash-high"),
+    ("gemini/gemini-3-8-flash", "gemini-3.8-flash-high", "agy-gemini-3_8-flash-high"),
     ("gemini/gemini-3-8-flash-medium", "gemini-3.8-flash-medium", "agy-gemini-3_8-flash-medium"),
     ("gemini/gemini-3-8-flash-low", "gemini-3.8-flash-low", "agy-gemini-3_8-flash-low"),
     ("gemini/gemini-3-7-flash", "gemini-3.7-flash-high", "agy-gemini-3_7-flash-high"),
@@ -83,16 +85,32 @@ for effort in ["max", "xhigh", "high", "medium", "low"]:
 PROVEN["claude/claude-fable-5"] = (
     "model_and_effort", "claude-fable-5", "cl-claude-fable-5-max")
 
-CORE_EVIDENCE = [
-    (HOME / ".grok/downloads/grok-1.0.13-macos-aarch64", "grok"),
-    (REPO / "scripts/runners/run-grok.sh", "grok"),
-    (HOME / ".codex/packages/standalone/releases/0.153.4-aarch64-apple-darwin/bin/codex", "codex"),
-    (REPO / "scripts/runners/run-codex.sh", "codex"),
-    (HOME / ".local/share/claude/versions/2.1.263", "claude"),
-    (REPO / "scripts/runners/run-claude.sh", "claude"),
-    (HOME / ".local/bin/agy", "gemini"),
-    (REPO / "scripts/runners/run-gemini.sh", "gemini"),
-]
+def cli_path(name: str) -> Path:
+    """Anchor the executable the runners resolve, not a version pinned here.
+
+    The runners invoke bare names, so a pinned path can name a binary that has
+    not run since the last self-update; the overlay must hash what answers.
+    aa_policy opens evidence with O_NOFOLLOW, so this resolves past the symlink.
+    """
+    found = shutil.which(name)
+    if not found:
+        raise SystemExit(f"cannot resolve the {name} CLI to anchor its evidence")
+    return Path(found).resolve()
+
+
+def core_evidence() -> list[tuple[Path, str]]:
+    """Resolved when a build runs, not at import: a host missing one CLI can
+    still load this module to read PROVEN."""
+    return [
+        (cli_path("grok"), "grok"),
+        (REPO / "scripts/runners/run-grok.sh", "grok"),
+        (cli_path("codex"), "codex"),
+        (REPO / "scripts/runners/run-codex.sh", "codex"),
+        (cli_path("claude"), "claude"),
+        (REPO / "scripts/runners/run-claude.sh", "claude"),
+        (cli_path("agy"), "gemini"),
+        (REPO / "scripts/runners/run-gemini.sh", "gemini"),
+    ]
 
 
 def sha256(path: Path) -> str:
@@ -116,12 +134,12 @@ def main(argv: list[str] | None = None) -> None:
 
     manifest = {"probe_runs": {}}
     unproven = []
+    # Evidence written before 0.42.6 carries no tier; it proved the selector and
+    # nothing about who answered, which is exactly what selector-only records.
+    tiers: dict[str, str] = {}
     for cid, (_, _, ev) in sorted(PROVEN.items()):
-        if ev.startswith("PRIOR:"):
-            manifest["probe_runs"][cid] = {"source": ev, "note": "verified in the 2026-09-07 Codex run"}
-            continue
         entry = {}
-        for suffix in ("json", "stdout", "stderr"):
+        for suffix in ("json", "stdout", "stderr", "rollout", "cli_log"):
             path = root / "evidence" / f"{ev}.{suffix}"
             if path.exists():
                 entry[suffix] = {"path": str(path), "sha256": sha256(path)}
@@ -143,6 +161,10 @@ def main(argv: list[str] | None = None) -> None:
             })
             # Visibility only: failed evidence must not enter the signed manifest.
             continue
+        tier = descriptor.get("evidence_tier", "selector-only")
+        if tier not in ("billed-model", "client-echo", "selector-only"):
+            raise SystemExit(f"unknown evidence tier for {cid}: {tier}")
+        tiers[cid] = tier
         manifest["probe_runs"][cid] = entry
     manifest_path = root / "probe-manifest.json"
     manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")
@@ -159,6 +181,7 @@ def main(argv: list[str] | None = None) -> None:
             "runtime_effort": row["effort"],
             "selector_type": selector,
             "verification": "request-selector-contract",
+            "evidence_tier": tiers.get(cid, "selector-only"),
         }
         if selector == "cli_reasoning_effort":
             mapping["cli_flag"] = "--reasoning-effort"
@@ -166,7 +189,7 @@ def main(argv: list[str] | None = None) -> None:
 
     evidence = [
         {"path": str(path), "sha256": sha256(path), "vendor": vendor}
-        for path, vendor in CORE_EVIDENCE
+        for path, vendor in core_evidence()
     ]
     evidence.append({"path": str(manifest_path), "sha256": sha256(manifest_path)})
 
@@ -182,7 +205,9 @@ def main(argv: list[str] | None = None) -> None:
     }
     out = root / "transport-contracts.local.json"
     out.write_text(json.dumps(overlay, indent=2, ensure_ascii=False) + "\n")
+    spread = Counter(m["evidence_tier"] for m in mappings)
     print(f"wrote {out} with {len(mappings)} mappings and {len(evidence)} evidence anchors")
+    print("  evidence tiers: " + ", ".join(f"{tier} {count}" for tier, count in sorted(spread.items())))
 
 
 if __name__ == "__main__":

package/scripts/lib/overlay_health.py

@@ -68,17 +68,23 @@ def main() -> None:
         detail = "; ".join(offenders(Path(overlay_path))) or str(error)
         emit("FAIL", f"overlay rejected, every dispatch is refused: {error} ({detail})")
 
+    tiers = registry.get("_transport_evidence_tiers", {})
     verified = Counter()
     for row in registry["scored_configs"]:
         if row["transport_mapping"].get("runtime_verified") is True:
-            verified[row["vendor"]] += 1
-    summary = ", ".join(f"{v} {n}" for v, n in sorted(verified.items())) or "none"
+            verified[row["vendor"], tiers.get(row["id"], "selector-only")] += 1
+    summary = ", ".join(f"{vendor} {count} {tier}"
+                        for (vendor, tier), count in sorted(verified.items())) or "none"
 
     import json
 
     overlay = json.loads(Path(overlay_path).read_text())
     unproven = overlay.get("unproven", [])
     extra = f"; {len(unproven)} config(s) recorded unproven" if unproven else ""
+    weak = sorted({vendor for (vendor, tier) in verified if tier == "selector-only"})
+    if weak:
+        extra += (f"; {', '.join(weak)} prove only the request selector, re-probe to "
+                  "record who answered")
 
     stale = registry.get("_stale_transport_vendors", [])
     if stale:

package/scripts/lib/probe.py

@@ -3,11 +3,14 @@
 
 Runs one CLI invocation, captures raw stdout/stderr to files, and writes a
 descriptor with the original command/stream fields plus a vendor-specific
-verdict, its reason, and the observed model when the response proves it.
+verdict, its reason, the observed model, and the tier of evidence that model
+rests on.
 """
 import argparse
+import glob
 import json
 import os
+import re
 import subprocess
 import time
 from datetime import datetime, timezone
@@ -16,6 +19,88 @@ from pathlib import Path
 SWEEP_ID = os.environ.get("OMNILANE_TRANSPORT_SWEEP_ID", "overlay-reprobe-20260909")
 DEFAULT_ROOT = Path.home() / ".omnilane" / "transport-evidence" / SWEEP_ID
 
+# Ordered strongest first. The tier is read off the evidence a run produced, not
+# off the vendor: a CLI that starts reporting a billed model earns the higher
+# tier with no change here.
+TIER_BILLED = "billed-model"       # the provider named the model it charged for
+TIER_ECHO = "client-echo"          # the CLI recorded the model it asked for
+TIER_SELECTOR = "selector-only"    # the CLI accepted the selector and said no more
+EVIDENCE_TIERS = (TIER_BILLED, TIER_ECHO, TIER_SELECTOR)
+
+
+def codex_failure(stdout_text: str) -> str:
+    """The last thing codex's event stream said went wrong, if anything.
+
+    Later events supersede earlier ones: a retry notice is progress, the message
+    on `turn.failed` is the outcome.
+    """
+    latest = ""
+    for line in stdout_text.splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+        if event.get("type") == "turn.failed":
+            message = (event.get("error") or {}).get("message")
+        elif event.get("type") == "error":
+            message = event.get("message")
+        else:
+            continue
+        if isinstance(message, str) and message:
+            latest = message
+    return f"; codex-event: {latest[:200]}" if latest else ""
+
+
+def _requested_model(command: list) -> str | None:
+    requested = None
+    for index, argument in enumerate(command):
+        if not isinstance(argument, str):
+            continue
+        if argument in ("--model", "-m") and index + 1 < len(command):
+            requested = command[index + 1]
+        elif argument.startswith("--model="):
+            requested = argument.split("=", 1)[1]
+    return requested
+
+
+def record_values(record_text: str) -> list[str]:
+    """Comparable values from a client record digest: `key<TAB>value` lines.
+
+    `#` lines carry provenance and display labels that must never be compared —
+    agy's backend label is "Gemini 3.8 Flash (Low)", not a model identifier.
+    """
+    values = []
+    for line in (record_text or "").splitlines():
+        if line.startswith("#") or "\t" not in line:
+            continue
+        value = line.split("\t", 1)[1].strip()
+        if value:
+            values.append(value)
+    return values
+
+
+def _client_record(
+    evidence_json: dict,
+    record_text: str,
+    passed_reason: str,
+) -> tuple[str, str, str | None, str]:
+    """Judge a CLI's own on-disk record of the request it sent."""
+    values = record_values(record_text)
+    if not values:
+        return "pass", f"{passed_reason}; no-client-record", None, TIER_SELECTOR
+    observed_model = ", ".join(sorted(set(values)))
+    requested_model = _requested_model(evidence_json.get("command", []))
+    if not requested_model:
+        return "fail", "missing-requested-model", observed_model, TIER_SELECTOR
+    if requested_model not in values:
+        return "fail", "client-record-mismatch", observed_model, TIER_SELECTOR
+    return "pass", f"{passed_reason}-and-client-record-matched", observed_model, TIER_ECHO
+
 
 def verdict(
     evidence_json: dict,
@@ -23,25 +108,27 @@ def verdict(
     stderr_text: str,
     vendor: str,
     expected_token: str | None,
-) -> tuple[str, str, str | None]:
+    extra: dict | None = None,
+) -> tuple[str, str, str | None, str]:
     """Judge raw evidence without reading files, running commands or mutating it.
 
-    Only Claude's billed modelUsage keys currently prove the responding model.
-    A requested selector (including the Codex banner) is not observed identity.
+    `extra` carries text the caller already gathered from disk, so this stays a
+    pure function that can re-judge an old sweep offline.
     """
+    extra = extra or {}
     if evidence_json.get("timed_out"):
-        return "fail", "timeout", None
+        return "fail", "timeout", None, TIER_SELECTOR
     if not expected_token:
-        return "fail", "missing-expected-token", None
+        return "fail", "missing-expected-token", None, TIER_SELECTOR
 
     exit_code = evidence_json.get("exit_code")
     if vendor == "claude":
         try:
             response = json.loads(stdout_text)
         except (json.JSONDecodeError, TypeError):
-            return "fail", "invalid-json", None
+            return "fail", "invalid-json", None, TIER_SELECTOR
         if not isinstance(response, dict):
-            return "fail", "invalid-json-result", None
+            return "fail", "invalid-json-result", None, TIER_SELECTOR
         usage = response.get("modelUsage")
         models = sorted(usage) if isinstance(usage, dict) else []
         observed_model = ", ".join(models) or None
@@ -56,48 +143,168 @@ def verdict(
                 reason = "api-error"
             else:
                 reason = "result-error"
-            return "fail", f"{reason}: {result[:120]}", observed_model
+            return "fail", f"{reason}: {result[:120]}", observed_model, TIER_SELECTOR
         if not models:
-            return "fail", "missing-model-usage", None
-        command = evidence_json.get("command", [])
-        requested_model = None
-        for index, argument in enumerate(command):
-            if argument == "--model" and index + 1 < len(command):
-                requested_model = command[index + 1]
-            elif isinstance(argument, str) and argument.startswith("--model="):
-                requested_model = argument.split("=", 1)[1]
+            return "fail", "missing-model-usage", None, TIER_SELECTOR
+        requested_model = _requested_model(evidence_json.get("command", []))
         if not requested_model:
-            return "fail", "missing-requested-model", observed_model
+            return "fail", "missing-requested-model", observed_model, TIER_SELECTOR
         if models != [requested_model]:
-            return "fail", "model-mismatch", observed_model
+            return "fail", "model-mismatch", observed_model, TIER_SELECTOR
         if "unknown --effort" in stderr_text.lower():
-            return "fail", "effort-silently-defaulted", observed_model
+            return "fail", "effort-silently-defaulted", observed_model, TIER_SELECTOR
         if exit_code != 0:
-            return "fail", f"exit-code: {exit_code}", observed_model
+            return "fail", f"exit-code: {exit_code}", observed_model, TIER_SELECTOR
         if expected_token not in result:
-            return "fail", "missing-expected-token", observed_model
-        return "pass", "expected-token-and-model-matched", observed_model
+            return "fail", "missing-expected-token", observed_model, TIER_SELECTOR
+        return "pass", "expected-token-and-model-matched", observed_model, TIER_BILLED
+
+    if vendor == "grok":
+        if exit_code != 0:
+            return "fail", f"exit-code: {exit_code}: {stderr_text[:120]}", None, TIER_SELECTOR
+        if stderr_text:
+            return "fail", f"unexpected-stderr: {stderr_text[:120]}", None, TIER_SELECTOR
+        if expected_token not in stdout_text:
+            return "fail", "missing-expected-token", None, TIER_SELECTOR
+        try:
+            response = json.loads(stdout_text)
+        except (json.JSONDecodeError, TypeError):
+            response = None
+        usage = response.get("modelUsage") if isinstance(response, dict) else None
+        models = sorted(usage) if isinstance(usage, dict) else []
+        if not models:
+            return "pass", "expected-token-and-clean-stderr; no-billed-model", None, TIER_SELECTOR
+        observed_model = ", ".join(models)
+        requested_model = _requested_model(evidence_json.get("command", []))
+        if not requested_model:
+            return "fail", "missing-requested-model", observed_model, TIER_SELECTOR
+        # Grok bills `grok-4.6` as `grok-4.6-build`. Accept that one suffix and
+        # nothing else: a prefix test would let `grok-4.6-anything` pass.
+        if models not in ([requested_model], [f"{requested_model}-build"]):
+            return "fail", "model-mismatch", observed_model, TIER_SELECTOR
+        return "pass", "expected-token-and-billed-model-matched", observed_model, TIER_BILLED
 
-    if vendor in ("grok", "agy"):
+    if vendor == "agy":
         if exit_code != 0:
-            return "fail", f"exit-code: {exit_code}: {stderr_text[:120]}", None
+            return "fail", f"exit-code: {exit_code}: {stderr_text[:120]}", None, TIER_SELECTOR
         if stderr_text:
-            return "fail", f"unexpected-stderr: {stderr_text[:120]}", None
+            return "fail", f"unexpected-stderr: {stderr_text[:120]}", None, TIER_SELECTOR
         if expected_token not in stdout_text:
-            return "fail", "missing-expected-token", None
-        return "pass", "expected-token-and-clean-stderr", None
+            return "fail", "missing-expected-token", None, TIER_SELECTOR
+        return _client_record(evidence_json, extra.get("cli_log", ""),
+                              "expected-token-and-clean-stderr")
 
     if vendor == "codex":
         diagnostics = [line[:120] for line in stderr_text.splitlines()
                        if "error" in line.lower() or "warning" in line.lower()]
         review = "; stderr-review: " + " | ".join(diagnostics) if diagnostics else ""
+        # Under `--json` the refusal that ended the run is an stdout event, not
+        # a stderr line, so a failure would otherwise be recorded as a bare exit
+        # code and leave unproven[] saying nothing a reader can act on.
+        why = codex_failure(stdout_text)
         if exit_code != 0:
-            return "fail", f"exit-code: {exit_code}{review}", None
+            return "fail", f"exit-code: {exit_code}{why}{review}", None, TIER_SELECTOR
         if expected_token not in stdout_text:
-            return "fail", f"missing-expected-token{review}", None
-        return "pass", f"expected-token-matched{review}", None
+            return "fail", f"missing-expected-token{why}{review}", None, TIER_SELECTOR
+        result, reason, observed, tier = _client_record(
+            evidence_json, extra.get("rollout", ""), "expected-token-matched")
+        return result, f"{reason}{review}", observed, tier
+
+    return "fail", f"unsupported-vendor: {vendor}", None, TIER_SELECTOR
+
+
+def _sha256(path: Path) -> str:
+    import hashlib
+
+    digest = hashlib.sha256()
+    with open(path, "rb") as stream:
+        for block in iter(lambda: stream.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _walk_models(node, prefix: str, found: dict) -> None:
+    if isinstance(node, dict):
+        for key, value in node.items():
+            here = f"{prefix}.{key}" if prefix else key
+            if key == "model" and isinstance(value, str):
+                found.setdefault(here, value)
+            _walk_models(value, here, found)
+    elif isinstance(node, list):
+        for item in node:
+            _walk_models(item, f"{prefix}[]", found)
+
+
+def codex_record(stdout_text: str, sessions_dir: Path | None = None) -> str:
+    """Digest the rollout codex persisted for the thread this run started.
+
+    Needs `codex exec --json` for the thread id and no `--ephemeral`, which
+    would suppress the rollout this reads.
+    """
+    thread_id = None
+    for line in stdout_text.splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event, dict) and isinstance(event.get("thread_id"), str):
+            thread_id = event["thread_id"]
+            break
+    if not thread_id:
+        return ""
+    root = sessions_dir or Path.home() / ".codex" / "sessions"
+    matches = sorted(glob.glob(str(root / "**" / f"rollout-*{thread_id}.jsonl"), recursive=True))
+    if not matches:
+        return ""
+    path = Path(matches[0])
+    found: dict[str, str] = {}
+    for line in path.read_text(errors="replace").splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        _walk_models(event, "", found)
+    lines = [f"# thread_id\t{thread_id}", f"# source\t{path}", f"# sha256\t{_sha256(path)}"]
+    lines += [f"{key}\t{value}" for key, value in sorted(found.items())]
+    return "\n".join(lines) + "\n"
+
+
+AGY_MODEL = re.compile(r"Resolving model (\S+)")
+AGY_LABEL = re.compile(r'selected model override to backend: label="([^"]+)"')
+
 
-    return "fail", f"unsupported-vendor: {vendor}", None
+def agy_record(app_root: Path, since: float) -> str:
+    """Digest the model agy resolved in the logs this run wrote under app_root.
+
+    `since` rejects logs from an earlier run, so a reused app root cannot lend
+    its model string to a later probe.
+    """
+    app_root = Path(app_root).expanduser()
+    if not app_root.is_dir():
+        return ""
+    lines: list[str] = []
+    values: dict[str, str] = {}
+    for path in sorted(app_root.rglob("cli*.log")):
+        if not path.is_file() or path.stat().st_mtime < since - 2:
+            continue
+        text = path.read_text(errors="replace")
+        models = AGY_MODEL.findall(text)
+        if not models:
+            continue
+        lines += [f"# source\t{path}", f"# sha256\t{_sha256(path)}"]
+        lines += [f"# label\t{label}" for label in dict.fromkeys(AGY_LABEL.findall(text))]
+        for model in models:
+            values.setdefault(f"{path.name}:resolved-model:{model}", model)
+    if not values:
+        return ""
+    lines += [f"{key}\t{value}" for key, value in sorted(values.items())]
+    return "\n".join(lines) + "\n"
 
 
 def probe(
@@ -109,6 +316,7 @@ def probe(
     *,
     vendor: str | None = None,
     expected_token: str | None = None,
+    app_root: Path | None = None,
 ) -> dict:
     if not expected_token:
         raise ValueError("expected_token is required before running a probe")
@@ -148,10 +356,24 @@ def probe(
         "stdout": str(out_path),
         "stderr": str(err_path),
     }
-    record["verdict"], record["verdict_reason"], record["observed_model"] = verdict(
-        record, out_path.read_text(errors="replace"), err_path.read_text(errors="replace"),
-        vendor, expected_token,
-    )
+    stdout_text = out_path.read_text(errors="replace")
+    extra = {}
+    if vendor == "codex":
+        extra["rollout"] = codex_record(stdout_text)
+    elif vendor == "agy" and app_root is not None:
+        extra["cli_log"] = agy_record(app_root, started)
+    for key, text in extra.items():
+        if not text:
+            continue
+        # Stored so the sweep hashes it and verdict() can re-judge it offline.
+        record_path = evidence / f"{name}.{key}"
+        record_path.write_text(text)
+        record[key] = str(record_path)
+    record["verdict"], record["verdict_reason"], record["observed_model"], \
+        record["evidence_tier"] = verdict(
+            record, stdout_text, err_path.read_text(errors="replace"),
+            vendor, expected_token, extra,
+        )
     (evidence / f"{name}.json").write_text(json.dumps(record, indent=2) + "\n")
     return record
 
@@ -174,11 +396,13 @@ if __name__ == "__main__":
     parser.add_argument("--expect", required=True, help="expected response token")
     parser.add_argument("--vendor", choices=("claude", "grok", "agy", "codex"),
                         help="defaults to the command executable's basename")
+    parser.add_argument("--app-root", type=Path,
+                        help="agy app data root for this run, to read back its cli log")
     parser.add_argument("name")
     parser.add_argument("command", nargs=argparse.REMAINDER)
     args = parser.parse_args()
     if not args.command:
         parser.error("command is required")
-    rec = probe(args.name, args.command, root=args.root,
+    rec = probe(args.name, args.command, root=args.root, app_root=args.app_root,
                 vendor=args.vendor, expected_token=args.expect)
     print(json.dumps(rec, ensure_ascii=False))

package/skills/omnilane/SKILL.md

@@ -388,9 +388,24 @@ selector evidence. Evidence entries carry a `vendor` tag: a tagged entry that
 drifts marks only its own vendor stale, and the other three keep dispatching.
 Untagged evidence — `probe-manifest.json`, and any overlay built before the tags
 existed — still fails the whole gate closed, which is what an unpatched host
-looks like. Codex and Claude evidence paths embed version directories
-(`releases/0.153.4-…`, `versions/2.1.263`), so their upgrades remove the file
-rather than change its digest; both are treated as staleness, not corruption.
+looks like. Codex and Claude resolve through version directories
+(`releases/0.153.4-…`, `versions/2.1.266`), so their upgrades remove the anchored
+file rather than change its digest; both are treated as staleness, not corruption.
+
+Do not expect these upgrades to be operator actions. agy and grok update
+themselves in the background when invoked — agy's own `cli.log` records
+`auto_updater.go: Spawned background update process`, and both binaries changed
+under a probing session on 2026-09-10, minutes after their first call. Overlay
+drift is therefore a routine consequence of using a vendor, not an occasional
+maintenance event, which is why per-vendor degradation matters more than it
+looks. It also means any test asserting a fixed number of verified live
+mappings will go red on its own schedule.
+
+Because of that, `build_overlay.py` anchors the executable `shutil.which` resolves
+rather than a version written into the script. A pinned path drifts out of use
+silently: before 0.42.6 the overlay hashed claude `2.1.263` while every dispatch
+ran `2.1.266`, so eleven mappings were "verified" against a binary that had not
+run for a day.
 
 Re-signing is a probe, a rebuild, and an install, in that order. Back up
 `~/.omnilane/transport-contracts.local.json` first; restoring it is the rollback.
@@ -408,6 +423,30 @@ Keep the sweep where its default `--root` puts it,
 inside a repository is one `git clean -fdx` away from taking every vendor down
 at once — the same global refusal a re-signing session is usually trying to end.
 
+Every mapping carries an `evidence_tier` saying how strongly its probe pinned the
+responder. `billed-model` means the provider named the model it charged for —
+Claude's `modelUsage`, grok's under `--output-format json`. `client-echo` means
+the CLI wrote down the model it asked for — codex's session rollout, agy's
+`cli.log` resolver line. `selector-only` means the CLI accepted the selector and
+said nothing more. Put plainly: `client-echo` is the CLI's copy of your order,
+`billed-model` is the provider's receipt. Neither certifies upstream identity,
+but only one of them was written by the party that answered.
+
+The tier is reported, never enforced. Dispatch still turns on `runtime_verified`
+alone, so a mapping that drops to `selector-only` keeps working and simply shows
+up in doctor as worth re-probing. Do not add a tier check to the gate: that would
+rebuild the failure 0.42.5 removed, where evidence quality could refuse a lane
+that runs. The tier is read off the evidence a run produced rather than assigned
+per vendor, so a sweep predating 0.42.6 re-judges as `selector-only` and a CLI
+that starts reporting a billed model is promoted with no code change.
+
+Two probe details follow from this. Codex needs `exec --json` (the thread id that
+locates the rollout) and must *not* use `--ephemeral`, which suppresses the very
+rollout the tier reads. agy needs its own app data directory, prepared exactly
+the way `run-gemini.sh` does it — `prepare-agy-mode.py --mode advise` returns a
+path relative to `~/.gemini` that is passed as `--app_data_dir=`; the environment
+variables that look like they would do this are ignored.
+
 Never sign a probe you did not read. `probe.py` records a `verdict` because exit
 status alone is not evidence: the Claude CLI answers a quota refusal with a JSON
 body carrying `is_error`, and it accepts an unknown `--effort` by silently using