omnilane 0.42.9 → 0.45.0

package/scripts/aa_rebaseline.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""Re-baseline config/aa-model-policy.json onto a newer AA Intelligence Index.
+
+    fetch   download one AA model page and save the per-model records as an extract
+    build   regenerate the registry from a saved extract (never from the network)
+    report  write per-vendor evidence tables and the old-vs-new score diff
+    matrix  show, per controller, the first reachable target of every lane
+    lanes   print, per lane, each candidate with the measurements the lane is ordered on
+
+The registry is an approval artifact: build only rewrites the file. Pinning its
+sha256 in scripts/lib/aa_policy.py and re-signing the host overlay stay manual.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime
+from decimal import ROUND_HALF_UP, Decimal
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[1]
+REGISTRY = REPO / "config/aa-model-policy.json"
+PAGE = "https://artificialanalysis.ai/models/{slug}"
+UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+      "(KHTML, like Gecko) Chrome/140.0 Safari/537.36")
+VENDOR_SLUG = re.compile(r"^(gpt|claude|gemini|grok)-")
+KEEP = (
+    "name", "intelligenceIndex", "intelligenceIndexIsEstimated", "releaseDate", "deprecated",
+    "contextWindowTokens", "terminalBench21", "terminalbenchHard", "scicode", "hle", "gpqa",
+    "omniscience", "tau2", "lcr", "ifbench", "critpt", "gdpvalNormalized", "itBenchSre",
+    "apexAgents", "price1mInputTokens", "price1mOutputTokens", "price1mBlended7To2To1",
+    "intelligenceIndexOutputTokensPerTask", "timeToFirstAnswerToken",
+    # what routing.yaml orders its lanes on
+    "terminalBench40", "automationBenchPartialScore", "tauBanking", "mlcrOverall", "mmmuPro",
+    "omniscienceBreakdown", "briefcaseBreakdown", "intelligenceIndexCost", "intelligenceIndexTimePerTask",
+)
+
+# Rows this snapshot adds. identity mirrors the sibling rows of the same model.
+NEW_ROWS = [
+    # (id, vendor, model, effort, reasoning, aa_slug, copy transport/shape from)
+    ("grok/grok-4-7", "grok", "grok-4.7", "xhigh", "reasoning", "grok-4-7", "grok/grok-4-6-xhigh"),
+    ("grok/grok-4-7-high", "grok", "grok-4.7", "high", "reasoning", "grok-4-7-high", "grok/grok-4-6"),
+    ("claude/claude-sonnet-5-xhigh", "claude", "claude-sonnet-5", "xhigh", "adaptive",
+     "claude-sonnet-5-xhigh", "claude/claude-sonnet-5"),
+    ("claude/claude-sonnet-5-high", "claude", "claude-sonnet-5", "high", "adaptive",
+     "claude-sonnet-5-high", "claude/claude-sonnet-5"),
+    ("claude/claude-sonnet-5-medium", "claude", "claude-sonnet-5", "medium", "adaptive",
+     "claude-sonnet-5-medium", "claude/claude-sonnet-5"),
+    ("claude/claude-sonnet-5-low", "claude", "claude-sonnet-5", "low", "adaptive",
+     "claude-sonnet-5-low", "claude/claude-sonnet-5"),
+]
+NEW_ALIASES = {"grok-4.7": "grok-4.6"}  # new catalog model -> alias entry to clone
+
+
+def half_up(value: float) -> int:
+    # round() is banker's rounding; a registry score must not depend on parity.
+    return int(Decimal(str(value)).quantize(Decimal("1"), rounding=ROUND_HALF_UP))
+
+
+def dump(value: dict) -> bytes:
+    return (json.dumps(value, indent=2, ensure_ascii=False) + "\n").encode()
+
+
+def parse_records(body: str) -> dict[str, dict]:
+    """The page embeds every model as escaped JSON; take each object that carries a score."""
+    text = body.replace('\\"', '"').replace("\\\\", "\\")
+    records: dict[str, dict] = {}
+    for match in re.finditer(r'"intelligenceIndex":', text):
+        start, depth = match.start(), 0
+        while start > 0:
+            char = text[start]
+            if char == "}":
+                depth += 1
+            elif char == "{":
+                if depth == 0:
+                    break
+                depth -= 1
+            start -= 1
+        end, depth = match.start(), 0
+        while end < len(text):
+            char = text[end]
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                if depth == 0:
+                    break
+                depth -= 1
+            end += 1
+        try:
+            obj = json.loads(text[start:end + 1])
+        except ValueError:
+            continue
+        slug = obj.get("slug")
+        if not isinstance(slug, str):
+            continue
+        # A model appears several times, each copy carrying a different subset of
+        # fields; which copy comes first varies between fetches.
+        merged = records.setdefault(slug, {})
+        for key, value in obj.items():
+            if merged.get(key) is None:
+                merged[key] = value
+    return records
+
+
+def cmd_fetch(args) -> int:
+    url = PAGE.format(slug=args.slug)
+    body = subprocess.run(["curl", "-sSL", "--fail", "-A", UA, "--max-time", "120", url],
+                          check=True, capture_output=True, text=True).stdout
+    version = re.search(r"Intelligence Index v([0-9.]+)", body)
+    if not version:
+        sys.exit("fetch: the page names no Intelligence Index version")
+    records = parse_records(body)
+    kept = {}
+    for slug, obj in sorted(records.items()):
+        if not VENDOR_SLUG.match(slug) or obj.get("intelligenceIndex") is None:
+            continue
+        row = {key: obj.get(key) for key in KEEP}
+        effort = obj.get("effort")
+        row["effort_label"] = effort.get("slug") if isinstance(effort, dict) else effort
+        kept[slug] = row
+    extract = {
+        "source_url": url,
+        "fetched_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+        "page_sha256": hashlib.sha256(body.encode()).hexdigest(),
+        "benchmark_version": version.group(1),
+        "records_on_page": len(records),
+        "records": kept,
+    }
+    Path(args.out).write_bytes(dump(extract))
+    print(f"fetch: AA v{extract['benchmark_version']}, {len(records)} records on page, "
+          f"{len(kept)} vendor records kept -> {args.out}")
+    return 0
+
+
+def rescore(row: dict, record: dict, version: str, as_of: str, report: str) -> None:
+    row["score"] = half_up(record["intelligenceIndex"])
+    row["score_raw"] = round(record["intelligenceIndex"], 2)
+    row["estimated"] = bool(record["intelligenceIndexIsEstimated"])
+    row["evidence_marker"] = "estimated" if row["estimated"] else "unmarked"
+    row["benchmark_version"], row["as_of"], row["evidence_report"] = version, as_of, report
+
+
+def cmd_build(args) -> int:
+    extract = json.loads(Path(args.extract).read_text())
+    records, version, as_of = extract["records"], extract["benchmark_version"], args.as_of
+    old = json.loads(Path(args.base).read_text())
+    new = copy.deepcopy(old)
+    report = lambda vendor: f"docs/reports/aa-{vendor}-evidence-{as_of}.md"  # noqa: E731
+
+    scored, dropped = [], []
+    for row in new["scored_configs"]:
+        record = records.get(row["aa_slug"])
+        if record is None:
+            dropped.append(row)
+            continue
+        rescore(row, record, version, as_of, report(row["vendor"]))
+        scored.append(row)
+    by_id = {row["id"]: row for row in old["scored_configs"]}
+    for cid, vendor, model, effort, reasoning, slug, shape in NEW_ROWS:
+        if cid in {row["id"] for row in scored}:
+            continue
+        if slug not in records:
+            sys.exit(f"build: {slug} is not in the extract")
+        row = copy.deepcopy(by_id[shape])
+        row.update(id=cid, vendor=vendor, model=model, effort=effort, reasoning=reasoning,
+                   fallback=None, aa_slug=slug, source_urls=[PAGE.format(slug=slug)])
+        row["transport_mapping"]["candidate_model_ids"] = [model]
+        rescore(row, records[slug], version, as_of, report(vendor))
+        scored.append(row)
+    scored.sort(key=lambda row: (-row["score"], -row["score_raw"], row["id"]))
+    new["scored_configs"] = scored
+
+    added = {(v, m, e, r) for _, v, m, e, r, _, _ in NEW_ROWS}
+    unknown = [row for row in new["unknown_configs"]
+               if (row["vendor"], row["model"], row["effort"], row["reasoning"]) not in added]
+    for row in unknown:
+        row["benchmark_version"], row["as_of"] = version, as_of
+        row["evidence_report"] = report(row["vendor"])
+    for row in dropped:
+        unknown.append({
+            "id": "/".join(str(row[key]) for key in ("vendor", "model", "effort", "reasoning")).replace("None", "none"),
+            **{key: row[key] for key in ("vendor", "model", "effort", "reasoning", "fallback")},
+            "score": None, "estimated": None, "benchmark_version": version, "as_of": as_of,
+            "status": "unknown", "authority_eligible": False,
+            "reason": f"AA v{version} no longer lists {row['aa_slug']}; the earlier score is not carried over",
+            "source_urls": [], "evidence_report": report(row["vendor"]), "mapping_status": "unknown",
+            "transport_mapping": {"status": "unknown", "runtime_verified": False, "resolved_config_id": None},
+        })
+    new["unknown_configs"] = unknown
+
+    for row in new["reference_configs"]:
+        if row["aa_slug"] in records:
+            rescore(row, records[row["aa_slug"]], version, as_of, report(row["vendor"]))
+
+    live_ids = {row["id"] for row in scored}
+    for alias in new["aliases"]:
+        alias["candidate_config_ids"] = [cid for cid in alias["candidate_config_ids"] if cid in live_ids]
+        for cid, vendor, model, *_ in NEW_ROWS:
+            if (alias["catalog_vendor"], alias["catalog_model"]) == (vendor, model) \
+                    and cid not in alias["candidate_config_ids"]:
+                alias["candidate_config_ids"].append(cid)
+    # aliases mirror scripts/configure.sh's catalog, so a new alias needs the model there too.
+    have = {(alias["catalog_vendor"], alias["catalog_model"]) for alias in new["aliases"]}
+    for model, source in NEW_ALIASES.items():
+        template = next(a for a in new["aliases"] if a["catalog_model"] == source)
+        if (template["catalog_vendor"], model) not in have:
+            clone = copy.deepcopy(template)
+            clone["catalog_model"] = model
+            clone["candidate_config_ids"] = [cid for cid, _, m, *_ in NEW_ROWS if m == model]
+            new["aliases"].insert(new["aliases"].index(template), clone)
+
+    vendors: dict[str, int] = {}
+    for row in scored:
+        vendors[row["vendor"]] = vendors.get(row["vendor"], 0) + 1
+    new["coverage"] = {"scored_configs": len(scored), "reference_configs": len(new["reference_configs"]),
+                       "unknown_configs": len(unknown), "aliases": len(new["aliases"]),
+                       "by_vendor": {v: vendors[v] for v in old["coverage"]["by_vendor"]}}
+    new["snapshot"].update(
+        id=f"aa-v{version}-{as_of}-v1", benchmark_version=version, as_of=as_of,
+        source={"extract": str(Path(args.extract).resolve().relative_to(REPO)),
+                "page_url": extract["source_url"], "page_sha256": extract["page_sha256"],
+                "fetched_at": extract["fetched_at"]},
+        approval={"status": args.approval, "scope": f"aa-v{version}-rebaseline",
+                  "source": f"docs/reports/aa-rebaseline-{as_of}.md",
+                  "estimated_scores": "approved_provisional" if args.approval == "approved"
+                  else "provisional_pending_review"})
+    new.setdefault("schema_notes", {})["score_rounding"] = (
+        "score is score_raw rounded half-up to an integer; score_raw is the AA index to two decimals")
+    REGISTRY.write_bytes(dump(new))
+    print(f"build: {len(scored)} scored ({sum(r['estimated'] for r in scored)} estimated), "
+          f"{len(unknown)} unknown, dropped {[r['id'] for r in dropped]}")
+    print(f"build: sha256 {hashlib.sha256(REGISTRY.read_bytes()).hexdigest()}")
+    return 0
+
+
+def cmd_report(args) -> int:
+    old = {row["id"]: row for row in json.loads(Path(args.old).read_text())["scored_configs"]}
+    new = json.loads(REGISTRY.read_text())
+    as_of, version = new["snapshot"]["as_of"], new["snapshot"]["benchmark_version"]
+    out = REPO / "docs/reports"
+    out.mkdir(parents=True, exist_ok=True)
+    for vendor in new["coverage"]["by_vendor"]:
+        lines = [f"# AA v{version} evidence: {vendor} ({as_of})", "",
+                 f"Generated by `scripts/aa_rebaseline.py report` from `{new['snapshot']['source']['extract']}` "
+                 f"(page sha256 `{new['snapshot']['source']['page_sha256'][:16]}…`).", "",
+                 "| config | effort | raw | score | estimated | previous | source |", "|---|---|---|---|---|---|---|"]
+        for row in new["scored_configs"]:
+            if row["vendor"] != vendor:
+                continue
+            before = old.get(row["id"])
+            lines.append(f"| {row['id']} | {row['effort']} | {row['score_raw']} | {row['score']} | "
+                         f"{'yes' if row['estimated'] else 'no'} | "
+                         f"{before['score'] if before else 'new'} | {row['source_urls'][0]} |")
+        gone = [cid for cid, row in old.items() if row["vendor"] == vendor
+                and cid not in {r["id"] for r in new["scored_configs"]}]
+        if gone:
+            lines += ["", "No longer listed by AA, moved to unknown_configs: " + ", ".join(gone)]
+        (out / f"aa-{vendor}-evidence-{as_of}.md").write_text("\n".join(lines) + "\n")
+    print(f"report: wrote {len(new['coverage']['by_vendor'])} vendor reports under {out}")
+    return 0
+
+
+def lane_table(path: Path) -> dict[str, list[tuple[str, str, str | None]]]:
+    table = {}
+    for line in path.read_text().splitlines():
+        match = re.match(r"^([a-z][a-z-]*):\s*(.+)$", line.split("#")[0].rstrip())
+        if not match or match.group(2).split()[0] in ("off", "vote"):
+            continue
+        chain = []
+        for segment in match.group(2).split("|"):
+            parts = segment.split()
+            if len(parts) >= 2:
+                chain.append((parts[0], parts[1], parts[2] if len(parts) > 2 and parts[2] != "-" else None))
+        table[match.group(1)] = chain
+    return table
+
+
+def target_row(rows: list[dict], vendor: str, model: str, effort: str | None) -> dict | None:
+    hits = [row for row in rows if row["vendor"] == vendor and row["reasoning"] != "non-reasoning"
+            and (f"{row['model']}-{row['effort']}" == model if vendor == "gemini"
+                 else row["model"] == model and row["effort"] == effort)]
+    return hits[0] if len(hits) == 1 else None
+
+
+def cmd_matrix(args) -> int:
+    """Score-only view: it ignores transport verification, which is per host."""
+    rows = json.loads(Path(args.registry).read_text())["scored_configs"]
+    by_id = {row["id"]: row for row in rows}
+    table = lane_table(Path(args.routing))
+    print("| controller (ceiling) | " + " | ".join(table) + " |")
+    print("|---|" + "---|" * len(table))
+    for cid in args.controller:
+        ceiling = by_id[cid]["score"]
+        cells = []
+        for chain in table.values():
+            cell = "none"
+            for index, (vendor, model, effort) in enumerate(chain):
+                row = target_row(rows, vendor, model, effort)
+                if row and row["score"] <= ceiling:
+                    cell = f"{row['id'].split('/')[1]} {row['score']}" + (f" (#{index + 1})" if index else "")
+                    break
+            cells.append(cell)
+        print(f"| {cid.split('/')[1]} ({ceiling}) | " + " | ".join(cells) + " |")
+    return 0
+
+
+def _nested(*path):
+    def read(record):
+        for key in path:
+            record = (record or {}).get(key)
+        return record
+    return read
+
+
+MEASURES = {  # column title -> (reader, decimals, scale)
+    "index": (_nested("intelligenceIndex"), 1, 1),
+    "Terminal-Bench 4.0": (_nested("terminalBench40"), 3, 1),
+    "Terminal-Bench 2.1": (_nested("terminalBench21"), 3, 1),
+    "SciCode": (_nested("scicode"), 3, 1),
+    "hallucination rate": (_nested("omniscienceBreakdown", "hallucinationRate"), 3, 1),
+    "knowledge (omniscience)": (_nested("omniscience"), 1, 1),
+    "HLE": (_nested("hle"), 3, 1),
+    "GPQA": (_nested("gpqa"), 3, 1),
+    "CritPt": (_nested("critpt"), 3, 1),
+    "Briefcase analytical Elo": (_nested("briefcaseBreakdown", "analyticalQuality", "elo"), 0, 1),
+    "Briefcase overall Elo": (_nested("briefcaseBreakdown", "overall", "elo"), 0, 1),
+    "Briefcase presentation Elo": (_nested("briefcaseBreakdown", "presentation", "elo"), 0, 1),
+    "GDPval": (_nested("gdpvalNormalized"), 3, 1),
+    "AutomationBench": (_nested("automationBenchPartialScore"), 3, 1),
+    "MMMU-Pro": (_nested("mmmuPro"), 3, 1),
+    "mlcrOverall": (_nested("mlcrOverall"), 3, 1),
+    "AA-LCR": (_nested("lcr"), 3, 1),
+    "minutes / task": (_nested("intelligenceIndexTimePerTask"), 1, 1 / 60),
+    "first answer token (s)": (_nested("timeToFirstAnswerToken", "total"), 0, 1),
+    "index run cost ($)": (_nested("intelligenceIndexCost", "total"), 0, 1),
+}
+LANE_MEASURES = {
+    "hardest-coding": ("Terminal-Bench 4.0", "Terminal-Bench 2.1", "SciCode", "hallucination rate"),
+    "bulk-mechanical": ("Terminal-Bench 4.0", "Terminal-Bench 2.1", "hallucination rate", "minutes / task",
+                        "index run cost ($)"),
+    "triage": ("index", "index run cost ($)", "minutes / task"),
+    "hard-judgment": ("HLE", "GPQA", "CritPt", "Briefcase analytical Elo", "hallucination rate"),
+    "taste-final": ("Briefcase overall Elo", "Briefcase presentation Elo", "GDPval"),
+    "consult": ("index",),
+    "ui-draft": ("MMMU-Pro", "Terminal-Bench 4.0"),
+    "long-context": ("mlcrOverall", "AA-LCR", "index run cost ($)"),
+    "fast-agentic": ("AutomationBench", "minutes / task", "first answer token (s)"),
+    "live-search": ("hallucination rate", "knowledge (omniscience)"),
+    "coding-overflow": ("Terminal-Bench 4.0", "SciCode"),
+}
+
+
+def cmd_lanes(args) -> int:
+    """Per lane, every candidate with the measurements that lane is ordered on."""
+    records = json.loads(Path(args.extract).read_text())["records"]
+    rows = json.loads(Path(args.registry).read_text())["scored_configs"]
+    for lane, chain in lane_table(Path(args.routing)).items():
+        titles = LANE_MEASURES.get(lane, ("index",))
+        print(f"\n**{lane}**\n\n| # | candidate | score | " + " | ".join(titles) + " |")
+        print("|---|---|---|" + "---|" * len(titles))
+        for index, (vendor, model, effort) in enumerate(chain, 1):
+            row = target_row(rows, vendor, model, effort)
+            name = f"{vendor} {model}" + (f" {effort}" if effort else "")
+            if row is None:
+                print(f"| {index} | {name} | not scored | " + " | ".join("—" for _ in titles) + " |")
+                continue
+            cells = []
+            for title in titles:
+                reader, places, scale = MEASURES[title]
+                value = reader(records.get(row["aa_slug"]))
+                cells.append("not published" if value is None else f"{value * scale:.{places}f}")
+            print(f"| {index} | {name} | {row['score']} | " + " | ".join(cells) + " |")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    sub = parser.add_subparsers(dest="command", required=True)
+    fetch = sub.add_parser("fetch")
+    fetch.add_argument("--slug", default="grok-4-7")
+    fetch.add_argument("--out", required=True)
+    build = sub.add_parser("build")
+    build.add_argument("--extract", required=True)
+    build.add_argument("--as-of", required=True)
+    build.add_argument("--base", default=str(REGISTRY),
+                       help="the registry to re-score; pass the previous snapshot to rebuild from scratch")
+    build.add_argument("--approval", default="proposed", choices=("proposed", "approved"))
+    report = sub.add_parser("report")
+    report.add_argument("--old", required=True, help="the previous registry file")
+    matrix = sub.add_parser("matrix")
+    matrix.add_argument("--registry", default=str(REGISTRY))
+    matrix.add_argument("--routing", default=str(REPO / "routing.yaml"))
+    matrix.add_argument("--controller", nargs="+", required=True, help="registry config ids")
+    lanes = sub.add_parser("lanes")
+    lanes.add_argument("--extract", required=True)
+    lanes.add_argument("--registry", default=str(REGISTRY))
+    lanes.add_argument("--routing", default=str(REPO / "routing.yaml"))
+    args = parser.parse_args()
+    return {"fetch": cmd_fetch, "build": cmd_build, "report": cmd_report, "matrix": cmd_matrix,
+            "lanes": cmd_lanes}[args.command](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/configure.sh

@@ -154,7 +154,7 @@ CODEX_EFFORTS=("xhigh" "max" "ultra" "high" "medium" "low" "minimal" "none")
 CLAUDE_MODELS=("default" "best" "fable" "opus" "sonnet" "haiku" "opus[1m]" "sonnet[1m]" "opusplan" "claude-fable-5" "claude-fable-5-1" "claude-opus-5" "claude-sonnet-5" "claude-opus-4-8" "claude-opus-4-7" "claude-opus-4-6" "claude-opus-4-5-20251101" "claude-sonnet-4-6" "claude-sonnet-4-5-20250929" "claude-haiku-4-5" "claude-haiku-4-5-20251001")
 CLAUDE_EFFORTS=("max" "xhigh" "high" "medium" "low" "-")
 GEMINI_MODELS=("gemini-3.8-flash-high" "gemini-3.8-flash-medium" "gemini-3.8-flash-low" "gemini-3.7-flash-high" "gemini-3.7-flash-medium" "gemini-3.7-flash-low" "gemini-3.6-flash-high" "gemini-3.6-flash-medium" "gemini-3.6-flash-low" "gemini-3.1-pro-high" "gemini-3.1-pro-low" "claude-sonnet-4-6" "claude-opus-4-6-thinking" "gpt-oss-120b-medium")
-GROK_MODELS=("grok-4.6" "headroom-grok-build" "grok-4.3-official")
+GROK_MODELS=("grok-4.7" "grok-4.6" "headroom-grok-build" "grok-4.3-official")
 KIMI_MODELS=("kimi-k3" "kimi-k2.7-code" "kimi-k2.5")
 QWEN_MODELS=("qwen3.7-max" "qwen3.7-plus" "qwen3.6-plus" "qwen3.5-plus" "qwen3-max-2026-01-23" "qwen3-coder-next" "qwen3-coder-plus" "qwen3-coder-flash")
 # OpenCode models use provider/model form; OpenRouter models use catalog slugs.

package/scripts/dispatch.sh

@@ -35,7 +35,7 @@ MODE="advise"; WORKDIR="$PWD"; BACKGROUND=0; DRY_RUN=0
 OVERRIDE_VENDOR=""; OVERRIDE_MODEL=""; OVERRIDE_EFFORT=""; OVERRIDE_TIMEOUT=""
 OVERRIDE_JOB_TIMEOUT=""; OVERRIDE_IDLE_TIMEOUT=""; SESSION_REQUEST="auto"
 THREAD_NAME=""; THREAD_MODE=""; THREAD_ID=""; THREAD_TURN=""; THREAD_CREATED=""
-EXECUTOR="auto"; NATIVE_CONTEXT=""; RESOLVE_WITH_CONTEXT=0
+EXECUTOR="auto"; NATIVE_CONTEXT=""; RESOLVE_WITH_CONTEXT=0; INHERIT=0
 SELECTED_EXECUTOR="cli"; EXECUTOR_REASON="no-native-context"
 AA_POLICY_FILE="${OMNILANE_AA_POLICY_FILE:-$OMNILANE_REPO/config/aa-model-policy.json}"
 AA_CALLER_CONTEXT="${OMNILANE_AA_CALLER_CONTEXT:-}"
@@ -67,6 +67,8 @@ flags:
                          before any provider call or job state
   --executor auto|native|cli  caller-owned native handoff or legacy CLI
   --native-context FILE      explicit JSON capabilities; native is not a binary
+  --inherit                  native worker on the caller's own model and effort; resolves no
+                             lane target, needs --native-context with inherits_caller_runtime
   --caller-context FILE      exact model caller identity plus inherited ceiling
   --operator-asserted-human  explicit AA model-ceiling exemption; assertion only
   --aa-policy FILE           frozen AA policy registry (default: repo config)
@@ -368,6 +370,18 @@ routing_candidate_available() {
   fi
 }
 
+aa_print_refusal() {
+  # Refusal JSON on stderr, with the lanes this caller can still reach appended.
+  local helper="$OMNILANE_REPO/scripts/lib/aa_lanes.py"
+  if [[ -n "$AA_LAST_DECISION" && -r "$helper" ]] && command -v python3 >/dev/null 2>&1; then
+    printf '%s\n' "$AA_LAST_DECISION" | python3 "$helper" --registry "$AA_POLICY_FILE" --lane "${LANE:-}" \
+      --routing "$OMNILANE_HOME/routing.local.yaml" --routing "$OMNILANE_REPO/routing.yaml" >&2 \
+      || printf '%s\n' "$AA_LAST_DECISION" >&2
+  else
+    printf '%s\n' "$AA_LAST_DECISION" >&2
+  fi
+}
+
 aa_policy_decide() {
   # vendor model effort [target-config] -> structured JSON in AA_LAST_DECISION
   local vendor="$1" model="$2" effort="$3" target_config="${4:-}" rc=0
@@ -712,6 +726,7 @@ while [[ $# -gt 0 ]]; do
       }
       SESSION_REQUEST="single-shot"; shift ;;
     --dry-run) DRY_RUN=1; shift ;;
+    --inherit) INHERIT=1; shift ;;
     --operator-asserted-human)
       AA_OPERATOR_ASSERTED_HUMAN=1; shift ;;
     --mode|--workdir|--vendor|--model|--effort|--timeout|--job-timeout|--idle-timeout|--thread|--executor|--native-context|--caller-context|--aa-policy|--target-config|--transport-overlay)
@@ -823,6 +838,34 @@ case "$EXECUTOR" in
 esac
 
 CHAIN="$(raw_lane_line "$LANE")" || { echo "omnilane: unknown lane '$LANE' (try --list)" >&2; exit 2; }
+if [[ "$INHERIT" -eq 1 ]]; then
+  # A worker that inherits this caller's own model and effort runs inside the
+  # harness: no lane target is resolved, no vendor CLI or transport overlay is
+  # involved, and the lane is only a label for what the work is.
+  [[ -z "$OVERRIDE_VENDOR$OVERRIDE_MODEL$OVERRIDE_EFFORT$AA_TARGET_CONFIG" ]] || {
+    echo "omnilane: --inherit takes no --vendor, --model, --effort or --target-config; it overrides nothing" >&2
+    exit 2
+  }
+  [[ "$EXECUTOR" != "cli" ]] || { echo "omnilane: --inherit is native only" >&2; exit 2; }
+  command -v python3 >/dev/null 2>&1 || { echo "omnilane: native protocol requires Python 3" >&2; exit 2; }
+  INHERIT_TIMEOUT="${OVERRIDE_TIMEOUT:-${OMNILANE_TIMEOUT:-600}}"
+  [[ "$INHERIT_TIMEOUT" =~ ^[1-9][0-9]*$ ]] || {
+    echo "omnilane: invalid timeout (want a positive integer of seconds)" >&2; exit 2
+  }
+  INHERIT_ARGS=(route --inherit --home "$OMNILANE_HOME" --executor native --lane "$LANE"
+    --workdir "$WORKDIR" --mode "$MODE" --task="$TASK" --session "$SESSION_REQUEST"
+    --thread "$THREAD_NAME" --policy "$AA_POLICY_FILE" --timeout "$INHERIT_TIMEOUT"
+    --job-timeout "${OVERRIDE_JOB_TIMEOUT:-}" --idle-timeout "${OVERRIDE_IDLE_TIMEOUT:-}")
+  [[ -z "$NATIVE_CONTEXT" ]] || INHERIT_ARGS+=(--context "$NATIVE_CONTEXT")
+  if [[ "$AA_OPERATOR_ASSERTED_HUMAN" == "1" ]]; then
+    INHERIT_ARGS+=(--operator-asserted-human)
+  elif [[ -n "$AA_CALLER_CONTEXT" ]]; then
+    INHERIT_ARGS+=(--caller-context "$AA_CALLER_CONTEXT")
+  fi
+  [[ "$BACKGROUND" -eq 0 ]] || INHERIT_ARGS+=(--background)
+  [[ "$DRY_RUN" -eq 0 ]] || INHERIT_ARGS+=(--dry-run)
+  exec python3 "$OMNILANE_REPO/scripts/lib/native.py" "${INHERIT_ARGS[@]}"
+fi
 if [[ -n "$OVERRIDE_VENDOR" ]]; then
   if resolve_chain "$CHAIN" "$OVERRIDE_VENDOR"; then
     :
@@ -835,7 +878,7 @@ if [[ -n "$OVERRIDE_VENDOR" ]]; then
         exit 4
         ;;
     6)
-      printf '%s\n' "$AA_LAST_DECISION" >&2
+      aa_print_refusal
       exit 3
       ;;
     5)
@@ -852,11 +895,11 @@ else
   resolve_rc=0
   resolve_chain "$CHAIN" || resolve_rc=$?
   if [[ "$resolve_rc" -eq 6 ]]; then
-    printf '%s\n' "$AA_LAST_DECISION" >&2
+    aa_print_refusal
     exit 3
   elif [[ "$resolve_rc" -ne 0 ]]; then
     echo "omnilane: no eligible available target for lane '$LANE' (chain:$CHAIN)." >&2
-    [[ -z "$AA_LAST_DECISION" ]] || printf '%s\n' "$AA_LAST_DECISION" >&2
+    [[ -z "$AA_LAST_DECISION" ]] || aa_print_refusal
     exit 4
   fi
 fi
@@ -1110,6 +1153,13 @@ if [[ "$DRY_RUN" -eq 1 ]]; then
 fi
 
 printf 'omnilane: executor=cli reason=%s\n' "$EXECUTOR_REASON" >&2
+if [[ "$EXECUTOR_REASON" == "no-native-context" && -n "$AA_CALLER_CONTEXT" && -r "$AA_CALLER_CONTEXT" ]]; then
+  CALLER_VENDOR="$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["caller"]["vendor"])' "$AA_CALLER_CONTEXT" 2>/dev/null || true)"
+  if [[ -n "$CALLER_VENDOR" && "$CALLER_VENDOR" == "$VENDOR" ]]; then
+    # Same vendor is not same model, so this is an offer, never a silent switch.
+    echo "omnilane: the target is this harness's own vendor, yet it goes out through an external CLI because no capability file was given. To use your own sub-agent tool: omnilane native-context --workdir \"$WORKDIR\", then pass --native-context FILE (or --inherit for a worker on your own model and effort)" >&2
+  fi
+fi
 mkdir -p "$OMNILANE_HOME"
 if [[ ! -d "$JOBS_ROOT" ]]; then
   mkdir -m 700 "$JOBS_ROOT"

package/scripts/doctor.sh

@@ -419,7 +419,13 @@ overlay_path="$(
   printf '%s' "${OMNILANE_AA_TRANSPORT_OVERLAY:-}"
 )"
 if [[ -z "$overlay_path" ]]; then
-  report PASS transport-overlay "no overlay configured; every runtime mapping stays unverified"
+  # Only a model caller needs the overlay; a host whose operator asserts the human
+  # exemption is complete without one, and --strict must not fail it.
+  if [[ "${OMNILANE_AA_OPERATOR_ASSERTED_HUMAN:-0}" == "1" ]]; then
+    report PASS transport-overlay "no overlay configured; fine for a human operator, but a model caller would be refused on every lane (README, 'Let your AI assistant drive omnilane')"
+  else
+    report WARN transport-overlay "no overlay configured, so a model caller is refused on every lane (runtime-mapping-unverified). First install: probe_sweep.py --root ROOT, build_overlay.py --root ROOT, then export OMNILANE_AA_TRANSPORT_OVERLAY in local.sh; see the README, 'Let your AI assistant drive omnilane'"
+  fi
 elif ! command -v python3 >/dev/null 2>&1; then
   report WARN transport-overlay "python3 is absent; cannot load the AA transport overlay"
 elif [[ ! -r "$OVERLAY_HEALTH" ]]; then