agent-bios 0.1.0

package/scripts/check-parity.sh

@@ -0,0 +1,1703 @@
+#!/usr/bin/env bash
+# Parity gate for mirrored instruction files.
+# EN canonical (installed): claude/, codex/.  KO reference (never installed): ko/claude, ko/codex.
+# Checks:
+#   (1) EN guide dirs mirror:  claude/guides == codex/guides            (modulo config-home var)
+#   (2) KO guide dirs mirror:  ko/claude/guides == ko/codex/guides      (modulo config-home var)
+#   (3) EN globals mirror:     claude/CLAUDE.md == codex/AGENTS.md       (modulo title, config-home, declared Codex authorization)
+#   (4) KO globals mirror:     ko/claude/CLAUDE.md == ko/codex/AGENTS.md (same declared exception)
+#   (5) EN and KO guide sets match — every English guide has a Korean counterpart
+#   (6) every guide referenced by claude/CLAUDE.md exists in both EN guide dirs
+#   (7) frontmatter: guide_id matches filename; language matches tree (ko/ => ko, else en); parent resolves
+#   (8) anchor phrases: each intentional global↔guide restatement pair shares a fixed anchor
+#       phrase in both EN files, so editing one side without the other fails here
+#   (9) launch-profile, Codex role-slot, and wrapper defaults match runtime projections
+# Exit non-zero on any divergence. Run from the repo root; safe as a pre-commit hook.
+set -u
+cd "$(dirname "$0")/.."
+fail=0
+
+# Non-empty-subject guards: a parity check over missing inputs must fail, not pass vacuously.
+for p in claude/guides codex/guides ko/claude/guides ko/codex/guides; do
+  [ -d "$p" ] || { echo "FAIL: required dir missing: $p"; exit 1; }
+done
+for p in claude/CLAUDE.md codex/AGENTS.md ko/claude/CLAUDE.md ko/codex/AGENTS.md; do
+  [ -f "$p" ] || { echo "FAIL: required file missing: $p"; exit 1; }
+done
+guide_count=$(ls claude/guides/*.md 2>/dev/null | wc -l | tr -d ' ')
+[ "$guide_count" -ge 1 ] || { echo "FAIL: no guides found in claude/guides"; exit 1; }
+
+# Guide dirs mirror across CLIs modulo the config-home variable (both sides normalized).
+mirror_guides() {  # $1 = claude-side dir, $2 = codex-side dir
+  if ! diff <(ls "$1") <(ls "$2"); then
+    echo "FAIL: guide dirs hold different file sets: $1 vs $2"; fail=1
+  fi
+  for f in "$1"/*.md; do
+    name=$(basename "$f")
+    if ! diff <(sed 's|${CLAUDE_CONFIG_DIR:-$HOME/.claude}|__CONFIG__|g' "$f") \
+              <(sed 's|${CODEX_HOME:-$HOME/.codex}|__CONFIG__|g' "$2/$name") >/dev/null 2>&1; then
+      echo "FAIL: guide mirror diverges beyond config-home var: $2/$name"; fail=1
+    fi
+  done
+}
+mirror_guides claude/guides    codex/guides
+mirror_guides ko/claude/guides ko/codex/guides
+
+# Global files mirror across CLIs modulo title, config-home var, and the one
+# Codex-only standing-authorization bullet required by the host trigger contract.
+# The ko pair is reference-only but is held to the same bounded exception.
+check_global_mirror() {  # $1 = claude-side file, $2 = codex-side file
+  if ! diff <(sed -e 's|${CLAUDE_CONFIG_DIR:-$HOME/.claude}|__CONFIG__|g' -e '1s/.*/# GLOBAL/' "$1") \
+            <(sed -e 's|${CODEX_HOME:-$HOME/.codex}|__CONFIG__|g' -e '1s/.*/# GLOBAL/' -e '/^- Codex-only standing authorization:/d' "$2"); then
+    echo "FAIL: global files diverge beyond title/config-home/Codex-authorization exceptions: $1 vs $2"; fail=1
+  fi
+}
+check_global_mirror claude/CLAUDE.md    codex/AGENTS.md
+check_global_mirror ko/claude/CLAUDE.md ko/codex/AGENTS.md
+
+expected_codex_authorization='- Codex-only standing authorization: on root/main local tasks, ordinary subagent dispatch is authorized when the `When To Spawn` gates fire. Explicit no-fan-out wins. Delegated agents may re-delegate only when their role allows. This grants no destructive, remote, credential, install, OAuth, push, live-network-expanding, or broader-sandbox authority.'
+expected_ko_codex_authorization='- Codex-only standing authorization: root/main local task에서 `When To Spawn` gate가 발동하면 ordinary subagent dispatch를 상시 허용한다. Explicit no-fan-out이 우선하며 delegated agent는 role이 허용할 때만 재위임한다. 이는 destructive, remote, credential, install, OAuth, push, live-network-expanding, broader-sandbox authority를 주지 않는다.'
+grep -qxF -- "$expected_codex_authorization" codex/AGENTS.md || { echo "FAIL: exact Codex standing authorization missing or changed: codex/AGENTS.md"; fail=1; }
+grep -qxF -- "$expected_ko_codex_authorization" ko/codex/AGENTS.md || { echo "FAIL: exact Codex standing authorization missing or changed: ko/codex/AGENTS.md"; fail=1; }
+
+# EN/KO guide-set parity: every English guide has a Korean counterpart (same basenames).
+if ! diff <(ls claude/guides) <(ls ko/claude/guides); then
+  echo "FAIL: EN and KO guide sets differ (a guide lacks its Korean version, or vice versa)"; fail=1
+fi
+
+# Every guide referenced from the global file must exist in both EN guide dirs.
+refs=$(grep -o 'guides/[a-z0-9-]*\.md' claude/CLAUDE.md | sort -u)
+[ -n "$refs" ] || { echo "FAIL: global file references no guides (extraction empty)"; fail=1; }
+for ref in $refs; do
+  name=$(basename "$ref")
+  for dir in claude/guides codex/guides; do
+    [ -f "$dir/$name" ] || { echo "FAIL: $dir/$name referenced from a global file but missing"; fail=1; }
+  done
+done
+
+# Frontmatter gate: every guide declares guide_id/language; guide_id matches the
+# filename, language matches the tree (files under ko/ are ko, else en), and any
+# declared parent resolves to a sibling guide in the same dir.
+for f in claude/guides/*.md codex/guides/*.md ko/claude/guides/*.md ko/codex/guides/*.md; do
+  name=$(basename "$f")
+  case "$f" in ko/*) want_lang=ko ;; *) want_lang=en ;; esac
+  if [ "$(head -1 "$f")" != "---" ]; then
+    echo "FAIL: missing YAML frontmatter: $f"; fail=1; continue
+  fi
+  fm=$(awk '/^---$/{n++; next} n==1{print} n>=2{exit}' "$f")
+  gid=$(printf '%s\n' "$fm" | awk -F': ' '$1=="guide_id"{print $2; exit}')
+  lang=$(printf '%s\n' "$fm" | awk -F': ' '$1=="language"{print $2; exit}')
+  parent=$(printf '%s\n' "$fm" | awk -F': ' '$1=="parent"{print $2; exit}')
+  [ "$name" = "$gid.md" ] || { echo "FAIL: guide_id does not match filename: $f (guide_id=$gid)"; fail=1; }
+  [ "$lang" = "$want_lang" ] || { echo "FAIL: language does not match tree: $f (language=$lang, want=$want_lang)"; fail=1; }
+  if [ -n "$parent" ] && [ ! -f "$(dirname "$f")/$parent.md" ]; then
+    echo "FAIL: parent guide missing: $f (parent=$parent)"; fail=1
+  fi
+done
+
+# Anchor-phrase gate: the global↔guide restatement pairs kept on purpose share a
+# fixed anchor phrase; a one-sided edit that drops or rewords the anchor fails here.
+# Format: anchor|fileA|fileB (EN canonical only; ko is a translation, not checked).
+while IFS='|' read -r anchor fa fb; do
+  [ -n "$anchor" ] || continue
+  for f in "$fa" "$fb"; do
+    grep -qF "$anchor" "$f" || { echo "FAIL: anchor phrase '$anchor' missing from $f (restatement pair drifted)"; fail=1; }
+  done
+done <<'ANCHORS'
+difficulty × blast radius|claude/CLAUDE.md|claude/guides/cli-multi-model-workflow.md
+convergence heuristic by reviewer kind|claude/CLAUDE.md|claude/guides/cli-multi-model-workflow.md
+code-level circuit breaker|claude/CLAUDE.md|claude/guides/cli-multi-model-workflow.md
+current-state dashboard|claude/CLAUDE.md|claude/guides/implementation-map.md
+Verification Menus|claude/CLAUDE.md|claude/guides/coding-staged-workflow.md
+real Microsoft Excel engine|claude/CLAUDE.md|claude/guides/coding-staged-workflow.md
+severity contract|README.md|claude/guides/coding-staged-workflow.md
+ANCHORS
+
+# The launcher's Textual preflight UI tests need the managed venv (textual).
+# Provision it if missing; every non-UI check above runs under system python.
+VENV="${AGENT_LAUNCH_VENV:-$HOME/.local/share/agent-launch/venv}"
+if ! { [ -x "$VENV/bin/python" ] && "$VENV/bin/python" -c 'import textual' 2>/dev/null; }; then
+  echo "provisioning agent-launch venv for parity UI tests ($VENV) ..."
+  AGENT_LAUNCH_VENV="$VENV" bash "$(dirname "$0")/provision-venv.sh" >/dev/null 2>&1 || {
+    echo "FAIL: could not provision the textual venv required for UI parity tests"; exit 1; }
+fi
+export AGENT_LAUNCH_VENV="$VENV"
+
+if ! "$VENV/bin/python" - <<'PY'
+import pathlib
+import importlib.util
+import fcntl
+import json
+import re
+import pty
+import select
+import signal
+import struct
+import subprocess
+import sys
+import os
+import tempfile
+import termios
+import time
+import tomllib
+
+sys.dont_write_bytecode = True
+
+fail = 0
+
+
+def mark_fail(message):
+    global fail
+    print(f"FAIL: {message}")
+    fail = 1
+
+
+agent_dir = pathlib.Path("codex/agents")
+launch_profile_path = pathlib.Path("config/agent-launch.toml")
+launcher = pathlib.Path("scripts/agent-launch.py")
+shell_init = pathlib.Path("shell/agent-launch.zsh")
+
+for required in (launch_profile_path, launcher, shell_init):
+    if not required.is_file():
+        mark_fail(f"required launch asset missing: {required}")
+
+for doc_path, required_phrases in {
+    pathlib.Path("README.md"): (
+        "Every arrow-key TUI selection screen",
+        "persistent settings hub",
+        "Start with these settings",
+        "Exit without launching",
+        "`b` is the back command",
+    ),
+    pathlib.Path("ko/README.md"): (
+        "화살표 키 TUI의 모든 선택 화면",
+        "지속형 설정 허브",
+        "Start with these settings",
+        "Exit without launching",
+        "`b`가 뒤로가기 명령",
+    ),
+}.items():
+    doc_text = doc_path.read_text()
+    for phrase in required_phrases:
+        if phrase not in doc_text:
+            mark_fail(f"agent-launch documentation contract missing from {doc_path}: {phrase!r}")
+
+try:
+    launch_profile = tomllib.loads(launch_profile_path.read_text())
+except Exception as exc:
+    mark_fail(f"launch profile does not parse: {launch_profile_path} ({exc})")
+    launch_profile = {}
+
+expected_launch_tiers = {
+    "frontier": ("gpt-5.6-sol", "max"),
+    "helm": ("gpt-5.6-sol", "xhigh"),
+    "workhorse": ("gpt-5.6-terra", "high"),
+    "sweep": ("gpt-5.6-luna", "low"),
+}
+codex_launch_tiers = launch_profile.get("hosts", {}).get("codex", {}).get("tiers", {})
+if set(codex_launch_tiers) != set(expected_launch_tiers):
+    mark_fail("launch profile Codex tiers must be exactly frontier/helm/workhorse/sweep")
+for tier, (model, effort) in expected_launch_tiers.items():
+    binding = codex_launch_tiers.get(tier, {})
+    if (binding.get("model"), binding.get("effort")) != (model, effort):
+        mark_fail(f"launch profile Codex {tier} is {binding!r}, want {model}/{effort}")
+
+expected_claude_tiers = {
+    "frontier": ("claude-fable-5", "max"),
+    "helm": ("claude-opus-4-8", "xhigh"),
+    "workhorse": ("claude-sonnet-5", "high"),
+    "sweep": ("claude-haiku-4-5", "low"),
+}
+claude_launch_tiers = launch_profile.get("hosts", {}).get("claude", {}).get("tiers", {})
+if set(claude_launch_tiers) != set(expected_claude_tiers):
+    mark_fail("launch profile Claude tiers must be exactly frontier/helm/workhorse/sweep")
+for tier, (model, effort) in expected_claude_tiers.items():
+    binding = claude_launch_tiers.get(tier, {})
+    if (binding.get("model"), binding.get("effort")) != (model, effort):
+        mark_fail(f"launch profile Claude {tier} is {binding!r}, want {model}/{effort}")
+
+balanced = launch_profile.get("presets", {}).get("balanced", {})
+if (balanced.get("main_tier"), balanced.get("review_setup")) != ("helm", "native-panel"):
+    mark_fail("balanced launch preset must start HELM with native-panel review setup")
+deep_review = launch_profile.get("presets", {}).get("deep-review", {})
+deep_frontier = deep_review.get("frontier_effort", {})
+if (
+    deep_review.get("main_tier") != "helm"
+    or deep_frontier.get("codex") != "ultra"
+    or deep_frontier.get("claude") != "max"
+):
+    mark_fail("deep-review must keep HELM main, allow Codex FRONTIER Ultra, and cap Claude at max")
+
+expected_agents = {
+    "frontier.toml": ("frontier", "gpt-5.6-sol", None),
+    "workhorse.toml": ("workhorse", "gpt-5.6-terra", "high"),
+    "sweep.toml": ("sweep", "gpt-5.6-luna", "low"),
+    "reviewer.toml": ("reviewer", "gpt-5.6-terra", "high"),
+}
+
+missing_agents = sorted(set(expected_agents) - {path.name for path in agent_dir.glob("*.toml")}) if agent_dir.is_dir() else sorted(expected_agents)
+if missing_agents:
+    mark_fail(f"required Codex agent files missing: {', '.join(missing_agents)}")
+
+for filename, (expected_name, expected_model, expected_effort) in expected_agents.items():
+    path = agent_dir / filename
+    if not path.is_file():
+        continue
+    try:
+        data = tomllib.loads(path.read_text())
+    except Exception as exc:
+        mark_fail(f"agent TOML does not parse: {path} ({exc})")
+        continue
+    if data.get("name") != expected_name:
+        mark_fail(f"{path} name is {data.get('name')!r}, want {expected_name!r}")
+    for required_text_field in ("description", "developer_instructions"):
+        value = data.get(required_text_field)
+        if not isinstance(value, str) or not value.strip():
+            mark_fail(f"{path} requires non-empty {required_text_field}")
+    if data.get("model") != expected_model:
+        mark_fail(f"{path} model is {data.get('model')!r}, want {expected_model!r}")
+    if expected_effort is None and "model_reasoning_effort" in data:
+        mark_fail(f"{path} must omit model_reasoning_effort so HELM can pin task-fit effort per dispatch")
+    elif expected_effort is not None and data.get("model_reasoning_effort") != expected_effort:
+        mark_fail(
+            f"{path} effort is {data.get('model_reasoning_effort')!r}, "
+            f"want {expected_effort!r}"
+        )
+
+
+def table_row(path, slot):
+    for raw_line in path.read_text().splitlines():
+        line = raw_line.strip()
+        if not line.startswith("|") or not line.endswith("|"):
+            continue
+        cells = [cell.strip() for cell in line.strip("|").split("|")]
+        if cells and cells[0] == slot:
+            return cells
+    return None
+
+
+def has_exact_model(text, model):
+    return re.search(rf"(?<![\w.-]){re.escape(model)}(?![\w.-])", text) is not None
+
+
+for guide_name in [
+    "claude/guides/cli-multi-model-workflow.md",
+    "codex/guides/cli-multi-model-workflow.md",
+    "ko/claude/guides/cli-multi-model-workflow.md",
+    "ko/codex/guides/cli-multi-model-workflow.md",
+]:
+    guide = pathlib.Path(guide_name)
+    rows = {slot: table_row(guide, slot) for slot in ("FRONTIER", "HELM", "WORKHORSE", "SWEEP")}
+    for slot, row in rows.items():
+        if row is None or len(row) < 2:
+            mark_fail(f"{guide} missing Environment Binding row for {slot}")
+    if rows["FRONTIER"] and (
+        not has_exact_model(rows["FRONTIER"][1], "GPT-5.6 Sol")
+        or "max" not in rows["FRONTIER"][1]
+        or "Ultra" not in rows["FRONTIER"][1]
+    ):
+        mark_fail(f"{guide} FRONTIER must bind GPT-5.6 Sol at max with Ultra allowed")
+    if rows["HELM"] and (
+        not has_exact_model(rows["HELM"][1], "GPT-5.6 Sol")
+        or "xhigh" not in rows["HELM"][1]
+        or "bounded FRONTIER Ultra" not in rows["HELM"][1]
+        or not any(token in rows["HELM"][1] for token in ("explicit selection", "명시 선택"))
+    ):
+        mark_fail(f"{guide} HELM must keep the main at GPT-5.6 Sol xhigh, require explicit main Ultra selection, and allow bounded FRONTIER Ultra dispatch")
+    if rows["WORKHORSE"] and (
+        not has_exact_model(rows["WORKHORSE"][1], "GPT-5.6 Terra")
+        or "(high)" not in rows["WORKHORSE"][1]
+    ):
+        mark_fail(f"{guide} WORKHORSE must bind exact GPT-5.6 Terra (high)")
+    if rows["SWEEP"] and not has_exact_model(rows["SWEEP"][1], "GPT-5.6 Luna"):
+        mark_fail(f"{guide} SWEEP must bind exact GPT-5.6 Luna")
+    for slot, claude_model in (
+        ("FRONTIER", "Claude Fable 5"),
+        ("HELM", "Claude Opus 4.8"),
+        ("WORKHORSE", "Claude Sonnet 5"),
+        ("SWEEP", "Claude Haiku 4.5"),
+    ):
+        if rows[slot] and claude_model not in rows[slot][1]:
+            mark_fail(f"{guide} {slot} must bind exact {claude_model}")
+
+def invoke(argv, *, input_text=None, env=None):
+    return subprocess.run(argv, input=input_text, capture_output=True, text=True, env=env)
+
+
+def expect_text(result, label, present=(), absent=(), status=0):
+    if result.returncode != status:
+        mark_fail(f"{label} returned {result.returncode}, want {status}: {result.stderr.strip()}")
+        return False
+    for token in present:
+        if token not in result.stdout:
+            mark_fail(f"{label} missing {token!r}")
+    for token in absent:
+        if token in result.stdout:
+            mark_fail(f"{label} unexpectedly contains {token!r}")
+    return True
+
+
+helm = pathlib.Path("scripts/codex-helm.sh")
+
+
+def helm_dry(*args):
+    return invoke(["bash", str(helm), "--dry-run", "--reach", "hermetic", *args, "probe"])
+
+
+if not helm.is_file():
+    mark_fail("required file missing: scripts/codex-helm.sh")
+else:
+    if "Expert Codex config override" not in helm.read_text():
+        mark_fail("codex-helm must document -c as an expert override")
+    frontier_tokens = (
+        "Do not use native spawn_agent for FRONTIER",
+        "--model gpt-5.6-sol --effort <effort> --multi-agent auto --sandbox read-only",
+        "adapter enables native multi-agent only for ultra",
+        "agents.max_threads=4",
+        "agents.max_depth=1",
+    )
+    for mode in ("auto", "implement", "review", "scout", "single"):
+        result = helm_dry("--mode", mode)
+        if not expect_text(
+            result,
+            f"codex-helm {mode} dry-run",
+            ("--bypass-sandbox", "features.multi_agent=false"),
+            ("explicitly selected Codex Ultra",),
+        ):
+            continue
+        match = re.search(rf"^mode={mode} reach=hermetic model=(\S+) effort=(\S+) sandbox=(\S+) ", result.stdout, re.MULTILINE)
+        if not match or match.groups() != ("gpt-5.6-sol", "xhigh", "dangerously-bypass-approvals-and-sandbox"):
+            mark_fail(f"codex-helm {mode} defaults are missing or incorrect")
+        has_adapter = "Internal FRONTIER command base" in result.stdout
+        if has_adapter != (mode != "single"):
+            mark_fail(f"codex-helm {mode} FRONTIER adapter exposure is incorrect")
+        if mode != "single":
+            for token in frontier_tokens:
+                if token not in result.stdout:
+                    mark_fail(f"codex-helm {mode} missing FRONTIER contract token: {token}")
+
+    expect_text(
+        helm_dry("--effort", "ultra"),
+        "codex-helm Ultra dry-run",
+        ("explicitly selected Codex Ultra", "features.multi_agent=true"),
+    )
+    single_ultra = helm_dry("--mode", "single", "--effort", "ultra")
+    if single_ultra.returncode == 0 or "Ultra requires fan-out" not in single_ultra.stderr:
+        mark_fail("codex-helm single + Ultra must fail with the fan-out explanation")
+    expect_text(
+        helm_dry("--no-fanout"),
+        "codex-helm no-fanout dry-run",
+        ("Do not spawn subagents",),
+        ("Internal FRONTIER command base",),
+    )
+    limited = helm_dry("--max-threads", "2", "--max-depth", "2")
+    expect_text(
+        limited,
+        "codex-helm FRONTIER limits",
+        ("Internal FRONTIER command base",),
+    )
+    frontier_line = next((line for line in limited.stdout.splitlines() if line.startswith("- Internal FRONTIER command base:")), "")
+    if "agents.max_threads=2" not in frontier_line or "agents.max_depth=2" not in frontier_line:
+        mark_fail("codex-helm FRONTIER command does not carry the requested 2/2 limits")
+    for args in (
+        ("--sandbox", "read-only"),
+        ("--sandbox", "read-only", "--allow-danger"),
+        ("--allow-danger", "--sandbox", "read-only"),
+    ):
+        expect_text(
+            helm_dry(*args),
+            f"codex-helm explicit sandbox order {' '.join(args)}",
+            ("sandbox=read-only",),
+            ("--bypass-sandbox",),
+        )
+
+run = pathlib.Path("scripts/codex-run.sh")
+if not run.is_file():
+    mark_fail("required file missing: scripts/codex-run.sh")
+else:
+    with tempfile.TemporaryDirectory() as raw_tmp:
+        tmp = pathlib.Path(raw_tmp)
+        fake, argv_log = tmp / "codex", tmp / "argv"
+        fake.write_text(
+            "#!/usr/bin/env bash\n"
+            "printf '%s\\n' \"$@\" > \"$FAKE_CODEX_ARGV\"\n"
+            "printf 'progress-err\\n' >&2\n"
+            "printf 'final-out\\n'\n"
+            "exit \"${FAKE_CODEX_STATUS:-0}\"\n"
+        )
+        fake.chmod(0o755)
+        env = os.environ.copy()
+        env.update(PATH=f"{tmp}{os.pathsep}{env.get('PATH', '')}", FAKE_CODEX_ARGV=str(argv_log))
+
+        def fake_call(argv):
+            result = invoke(argv, input_text="probe\n", env=env)
+            return result, argv_log.read_text().splitlines()
+
+        def expect_args(label, received, present=(), absent=(), pair=None):
+            for token in present:
+                if token not in received:
+                    mark_fail(f"{label} missing argument: {token}")
+            for token in absent:
+                if token in received:
+                    mark_fail(f"{label} unexpectedly passed argument: {token}")
+            if pair and not any(received[i : i + 2] == list(pair) for i in range(len(received) - 1)):
+                mark_fail(f"{label} missing argument pair: {' '.join(pair)}")
+
+        result, received = fake_call([
+            "bash", str(run), "--profile", "inherit", "--bypass-sandbox",
+            "--model", "gpt-5.6-sol", "--effort", "max", "-",
+        ])
+        if (result.returncode, result.stdout, result.stderr) != (0, "final-out\n", "progress-err\n"):
+            mark_fail("codex-run does not preserve stdout/stderr/exit channels")
+        expect_args(
+            "codex-run bypass",
+            received,
+            ("--dangerously-bypass-approvals-and-sandbox", "gpt-5.6-sol", 'model_reasoning_effort="max"'),
+            ("--sandbox",),
+        )
+        result, received = fake_call(["bash", str(run), "--profile", "inherit", "--sandbox", "read-only"])
+        expect_args(
+            "codex-run explicit sandbox",
+            received,
+            absent=("--dangerously-bypass-approvals-and-sandbox",),
+            pair=("--sandbox", "read-only"),
+        )
+        if result.returncode != 0:
+            mark_fail("codex-run explicit sandbox fake runtime failed")
+
+        for effort, multi_agent in (("max", "false"), ("ultra", "true")):
+            result, received = fake_call([
+                "bash", str(run), "--profile", "inherit", "--effort", effort, "--multi-agent", "auto",
+            ])
+            if result.returncode != 0:
+                mark_fail(f"codex-run multi-agent auto failed at {effort}")
+            expect_args(
+                f"codex-run multi-agent auto {effort}",
+                received,
+                (f'model_reasoning_effort="{effort}"', f"features.multi_agent={multi_agent}"),
+            )
+
+        for effort, multi_agent in (("xhigh", "false"), ("ultra", "true")):
+            result, received = fake_call(["bash", str(helm), "--reach", "inherit", "--effort", effort, "probe"])
+            if result.returncode != 0:
+                mark_fail(f"codex-helm fake runtime failed at effort {effort}: {result.stderr.strip()}")
+            expect_args(
+                f"codex-helm {effort}",
+                received,
+                ("--dangerously-bypass-approvals-and-sandbox", f'model_reasoning_effort="{effort}"', f"features.multi_agent={multi_agent}"),
+                ("--sandbox",),
+            )
+
+        env["FAKE_CODEX_STATUS"] = "7"
+        failed, _ = fake_call(["bash", str(run), "--profile", "inherit", "--bypass-sandbox"])
+        if failed.returncode != 7:
+            mark_fail(f"codex-run returns {failed.returncode} instead of Codex exit status 7")
+
+if launcher.is_file() and launch_profile:
+    syntax = invoke([sys.executable, "-c", f"compile(open({str(launcher)!r}).read(), {str(launcher)!r}, 'exec')"])
+    if syntax.returncode != 0:
+        mark_fail(f"agent-launch Python syntax failed: {syntax.stderr.strip()}")
+    zsh_syntax = invoke(["zsh", "-n", str(shell_init)])
+    if zsh_syntax.returncode != 0:
+        mark_fail(f"agent-launch zsh syntax failed: {zsh_syntax.stderr.strip()}")
+
+    try:
+        spec = importlib.util.spec_from_file_location("agent_launch_under_test", launcher)
+        if spec is None or spec.loader is None:
+            raise RuntimeError("could not create import specification")
+        launcher_module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = launcher_module
+        spec.loader.exec_module(launcher_module)
+    except Exception as exc:
+        mark_fail(f"agent-launch test import failed: {exc}")
+        launcher_module = None
+
+    if launcher_module is not None:
+        class ScriptedUI:
+            def __init__(self):
+                self.plan = None
+                self.checked = False
+                self.hub_visits = 0
+
+            def set_plan(self, plan):
+                self.plan = plan
+
+            def choose(self, title, options, default, allow_back, preview=None):
+                if title == "Preset":
+                    if preview is not None:
+                        balanced = launcher_module.setup_summary_lines(preview("balanced"))
+                        deep = launcher_module.setup_summary_lines(preview("deep-review"))
+                        if balanced == deep:
+                            mark_fail(
+                                "agent-launch Preset menu does not live-preview the "
+                                "highlighted preset in the setup panel"
+                            )
+                    return launcher_module.CUSTOM_PRESET
+                if title == "Custom settings":
+                    self.hub_visits += 1
+                    if self.hub_visits == 1:
+                        return "main"
+                    summary = launcher_module.setup_summary_lines(self.plan)
+                    option_by_value = {option.value: option for option in options}
+                    if "Main WORKHORSE | Review native-panel" not in summary:
+                        mark_fail(
+                            "agent-launch did not project the selected main tier back "
+                            "into the Custom hub"
+                        )
+                    if not {"tier:frontier", "tier:workhorse", "start", "exit"} <= set(option_by_value):
+                        mark_fail("agent-launch Custom hub is missing tier or final actions")
+                    if (
+                        option_by_value["start"].label != "Start with these settings"
+                        or option_by_value["start"].description
+                        != "Confirm the complete setup shown above and continue to launch."
+                        or option_by_value["exit"].label != "Exit without launching"
+                        or option_by_value["exit"].description
+                        != "Discard this launch and return to the shell."
+                    ):
+                        mark_fail("agent-launch Custom final actions have mismatched semantics")
+                    self.checked = True
+                    return "start"
+                if title == "Main tier":
+                    if preview is not None:
+                        summary = launcher_module.setup_summary_lines(preview("sweep"))
+                        if "Main SWEEP | Review native-panel" not in summary:
+                            mark_fail(
+                                "agent-launch Main tier menu does not live-preview the "
+                                "highlighted tier in the setup panel"
+                            )
+                    return "workhorse"
+                raise AssertionError(f"unexpected scripted menu: {title}")
+
+        scripted_ui = ScriptedUI()
+        scripted_plan = launcher_module.select_plan(
+            launch_profile,
+            "codex",
+            None,
+            False,
+            scripted_ui,
+        )
+        if not scripted_ui.checked or not scripted_plan.get("_launch_confirmed"):
+            mark_fail("agent-launch scripted Custom hub did not reach final confirmation")
+
+    with tempfile.TemporaryDirectory() as raw_tmp:
+        tmp = pathlib.Path(raw_tmp)
+        backend = tmp / "backend"
+        argv_log = tmp / "backend.argv"
+        backend.write_text(
+            "#!/usr/bin/env bash\n"
+            "printf '%s\\n' \"$@\" > \"$FAKE_LAUNCH_ARGV\"\n"
+            "printf 'backend-output\\n'\n"
+            "exit \"${FAKE_LAUNCH_STATUS:-0}\"\n"
+        )
+        backend.chmod(0o755)
+        fake_onto = tmp / "onto"
+        fake_ultracode = tmp / "ultracode-for-codex"
+        for capability in (fake_onto, fake_ultracode):
+            capability.write_text("#!/usr/bin/env bash\nexit 0\n")
+            capability.chmod(0o755)
+        fake_profile = tmp / "profiles.toml"
+        profile_text = launch_profile_path.read_text()
+        profile_text = profile_text.replace('command = "codex"', f"command = {json.dumps(str(backend))}", 1)
+        profile_text = profile_text.replace('command = "claude"', f"command = {json.dumps(str(backend))}", 1)
+        profile_text = profile_text.replace('command = "onto"', f"command = {json.dumps(str(fake_onto))}", 1)
+        profile_text = profile_text.replace(
+            'command = "ultracode-for-codex"',
+            f"command = {json.dumps(str(fake_ultracode))}",
+            1,
+        )
+        portable_profile_text = profile_text
+        for tier in ("frontier", "workhorse", "sweep"):
+            profile_text = profile_text.replace(
+                f'${{CODEX_HOME}}/agents/{tier}.toml', str((agent_dir / f"{tier}.toml").resolve()), 1
+            )
+        fake_profile.write_text(profile_text)
+        fake_data = tomllib.loads(profile_text)
+        fake_commands = {
+            host: binding.get("command") for host, binding in fake_data.get("backends", {}).items()
+        }
+        if set(fake_commands) != {"codex", "claude"} or any(
+            command != str(backend) for command in fake_commands.values()
+        ):
+            mark_fail(f"fake launch profile did not replace every backend: {fake_commands!r}")
+            fake_profile = pathlib.Path("/nonexistent/unsafe-fixture")
+        env = os.environ.copy()
+        env.update(
+            FAKE_LAUNCH_ARGV=str(argv_log),
+            AGENT_LAUNCH_CONFIG=str(fake_profile),
+            XDG_CACHE_HOME=str(tmp / "cache"),
+        )
+
+        pty_env = env.copy()
+
+        def run_picker_scenario(
+            name,
+            steps,
+            timeout=3,
+            term="xterm-256color",
+            host="codex",
+            config_path=fake_profile,
+            dry_run=True,
+        ):
+            scenario_env = pty_env.copy()
+            scenario_env["TERM"] = term
+            picker_pid, master = pty.fork()
+            if picker_pid == 0:
+                try:
+                    child_argv = [
+                        sys.executable,
+                        str(launcher),
+                        "--config",
+                        str(config_path),
+                    ]
+                    if dry_run:
+                        child_argv.append("--dry-run")
+                    child_argv.append(host)
+                    os.execve(
+                        sys.executable,
+                        child_argv,
+                        scenario_env,
+                    )
+                except Exception:
+                    os._exit(127)
+            fcntl.ioctl(master, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 100, 0, 0))
+            transcript = bytearray()
+            picker_status = None
+            search_offset = 0
+
+            def read_until(token):
+                nonlocal search_offset
+                deadline = time.monotonic() + timeout
+                while time.monotonic() < deadline:
+                    found = transcript.find(token, search_offset)
+                    if found >= 0:
+                        search_offset = found + len(token)
+                        return True
+                    ready, _, _ = select.select([master], [], [], 0.1)
+                    if not ready:
+                        continue
+                    try:
+                        chunk = os.read(master, 4096)
+                    except OSError:
+                        break
+                    if not chunk:
+                        break
+                    transcript.extend(chunk)
+                found = transcript.find(token, search_offset)
+                if found >= 0:
+                    search_offset = found + len(token)
+                    return True
+                return False
+
+            try:
+                for expected, key in steps:
+                    if not read_until(expected):
+                        mark_fail(f"agent-launch {name} missing {expected.decode()!r}")
+                        break
+                    if isinstance(key, tuple):
+                        rows, columns = key[:2]
+                        if len(key) == 3:
+                            os.write(master, key[2])
+                            time.sleep(0.1)
+                        fcntl.ioctl(
+                            master,
+                            termios.TIOCSWINSZ,
+                            struct.pack("HHHH", rows, columns, 0, 0),
+                        )
+                        try:
+                            os.kill(picker_pid, signal.SIGWINCH)
+                        except ProcessLookupError:
+                            pass
+                    else:
+                        os.write(master, key)
+                deadline = time.monotonic() + timeout
+                while time.monotonic() < deadline:
+                    ready, _, _ = select.select([master], [], [], 0.05)
+                    if ready:
+                        try:
+                            chunk = os.read(master, 4096)
+                        except OSError:
+                            chunk = b""
+                        if chunk:
+                            transcript.extend(chunk)
+                    waited_pid, raw_status = os.waitpid(picker_pid, os.WNOHANG)
+                    if waited_pid:
+                        picker_status = os.waitstatus_to_exitcode(raw_status)
+                        break
+                if picker_status is not None:
+                    while select.select([master], [], [], 0)[0]:
+                        try:
+                            chunk = os.read(master, 4096)
+                        except OSError:
+                            break
+                        if not chunk:
+                            break
+                        transcript.extend(chunk)
+            finally:
+                if picker_status is None:
+                    try:
+                        os.kill(picker_pid, signal.SIGKILL)
+                    except ProcessLookupError:
+                        pass
+                    _, raw_status = os.waitpid(picker_pid, 0)
+                    picker_status = os.waitstatus_to_exitcode(raw_status)
+                os.close(master)
+            return bytes(transcript), picker_status
+
+        open_custom_steps = (
+            (b"native multi-perspective review", b""),
+            (b"Esc cancel | q cancel", b"\x1b[B"),
+            (b"hybrid onto", b"\x1b[B"),
+            (b"high-volume", b"\x1b[B"),
+            (b"Open a settings hub", b"\r"),
+        )
+        down = b"\x1b[B"
+
+        def hub_choice(offset):
+            return (b"Custom settings", down * offset + b"\r")
+
+        transcript, picker_status = run_picker_scenario(
+            "fixed layout",
+            ((b"Esc cancel | q cancel", b"q"),),
+        )
+        if picker_status != 130:
+            mark_fail(f"agent-launch fixed layout returned {picker_status}, want 130")
+        layout_tokens = (
+            b"Current setup",
+            b"FRONTIER",
+            b"HELM",
+            b"WORKHORSE",
+            b"SWEEP",
+            b"About highlighted option",
+            b"HELM default for everyday work",
+            b"Options (",
+        )
+        positions = {token: transcript.find(token) for token in layout_tokens}
+        if any(position < 0 for position in positions.values()):
+            missing = [token.decode() for token, position in positions.items() if position < 0]
+            mark_fail(f"agent-launch fixed layout missing sections: {missing!r}")
+        elif not (
+            positions[b"Current setup"]
+            < min(positions[token] for token in (b"FRONTIER", b"HELM", b"WORKHORSE", b"SWEEP"))
+            < positions[b"About highlighted option"]
+            < positions[b"HELM default for everyday work"]
+            < positions[b"Options ("]
+        ):
+            mark_fail("agent-launch layout is not setup then description then options")
+
+        _, picker_status = run_picker_scenario(
+            "root escape cancellation",
+            ((b"Esc cancel | q cancel", b"\x1b"),),
+        )
+        if picker_status != 130:
+            mark_fail(f"agent-launch root Esc returned {picker_status}, want 130")
+
+        if argv_log.exists():
+            argv_log.unlink()
+        _, picker_status = run_picker_scenario(
+            "launch confirmation q cancellation",
+            (
+                (b"Esc cancel | q cancel", b"\r"),
+                (b"Launch? [Y/n/q]:", b"q\r"),
+            ),
+            dry_run=False,
+        )
+        if picker_status != 130 or argv_log.exists():
+            mark_fail("agent-launch final confirmation q executed the backend")
+
+        if argv_log.exists():
+            argv_log.unlink()
+        transcript, picker_status = run_picker_scenario(
+            "Custom final start",
+            (
+                *open_custom_steps,
+                (b"Custom settings", down * 8),
+                (b"Confirm the complete setup shown above", b"\r"),
+            ),
+            dry_run=False,
+        )
+        if (
+            picker_status != 0
+            or not argv_log.exists()
+            or b"Launch? [Y/n/q]:" in transcript
+            or b"Start with these settings" not in transcript
+        ):
+            mark_fail("agent-launch Custom Start was not the final launch confirmation")
+
+        if argv_log.exists():
+            argv_log.unlink()
+        transcript, picker_status = run_picker_scenario(
+            "Custom explicit exit",
+            (
+                *open_custom_steps,
+                (b"Custom settings", down * 9),
+                (b"Discard this launch and return to the shell", b"\r"),
+            ),
+            dry_run=False,
+        )
+        if (
+            picker_status != 130
+            or argv_log.exists()
+            or b"Exit without launching" not in transcript
+        ):
+            mark_fail("agent-launch Custom Exit executed the backend")
+
+        transcript, picker_status = run_picker_scenario(
+            "Custom escape back",
+            (
+                *open_custom_steps,
+                (b"Custom settings", b"\x1b"),
+                (b"HELM default for everyday work", b"\r"),
+            ),
+        )
+        if picker_status != 0 or b"Preset         Balanced" not in transcript:
+            mark_fail("agent-launch Custom Esc did not return to the preset picker")
+
+        _, picker_status = run_picker_scenario(
+            "Custom interior escape back",
+            (
+                *open_custom_steps,
+                (b"Custom settings", b"\r"),
+                (b"Primary orchestrator for planning, delegation", b"\x1b"),
+                (b"Choose the primary orchestrator used for this session", b"q"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(
+                f"agent-launch interior Esc back returned {picker_status}, want 130"
+            )
+
+        _, picker_status = run_picker_scenario(
+            "current setup update",
+            (
+                *open_custom_steps,
+                (b"Custom settings", b"\r"),
+                (b"Primary orchestrator for planning, delegation", b"\x1b[B"),
+                (b"high-volume implementation", b"\r"),
+                (b"Main tier: WORKHORSE", b"q"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail("agent-launch main-tier selection flow did not reach Review setup")
+
+        transcript, picker_status = run_picker_scenario(
+            "Custom tier hub return",
+            (
+                *open_custom_steps,
+                hub_choice(3),
+                (b"Other (enter a model id)", down + b"\r"),
+                (b"strongest standard reasoning mode", down + b"\r"),
+                (b"FRONTIER: gpt-5.6-terra / ultra", down * 2 + b"\r"),
+                (b"Other (enter a model id)", down * 2 + b"\r"),
+                (b"Current value: gpt-5.6-terra", b"workhorse-local\r"),
+                (b"complex implementation and analysis", down + b"\r"),
+                (b"WORKHORSE: workhorse-local / xhigh", down * 3 + b"\r"),
+            ),
+        )
+        if picker_status != 0:
+            mark_fail(
+                f"agent-launch tier-to-hub flow returned {picker_status}, want 0"
+            )
+        for expected in (
+            "FRONTIER       gpt-5.6-terra · ultra".encode(),
+            "WORKHORSE      workhorse-local · xhigh".encode(),
+        ):
+            if expected not in transcript:
+                mark_fail(
+                    "agent-launch tier-to-hub flow did not visit "
+                    f"{expected.decode()!r}"
+                )
+
+        numbered_interior_back = invoke(
+            [
+                sys.executable,
+                str(launcher),
+                "--config",
+                str(fake_profile),
+                "--preset",
+                "balanced",
+                "--custom",
+                "--dry-run",
+                "codex",
+            ],
+            input_text="1\nb\n9\n",
+            env=env,
+        )
+        if (
+            numbered_interior_back.returncode != 0
+            or "b back | q cancel" not in numbered_interior_back.stdout
+            or numbered_interior_back.stdout.count("\nCustom settings\n") < 2
+            or "Preset         Custom (Balanced)" not in numbered_interior_back.stdout
+        ):
+            mark_fail("agent-launch numbered interior back did not return to Custom hub")
+
+        _, picker_status = run_picker_scenario(
+            "Custom model q cancellation",
+            (
+                *open_custom_steps,
+                hub_choice(3),
+                (b"Other (enter a model id)", down * 3 + b"\r"),
+                (b"Current value: gpt-5.6-sol", b"q\r"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(
+                f"agent-launch curses model q returned {picker_status}, want 130"
+            )
+
+        _, picker_status = run_picker_scenario(
+            "Custom model Esc cancellation",
+            (
+                *open_custom_steps,
+                hub_choice(3),
+                (b"Other (enter a model id)", down * 3 + b"\r"),
+                (b"Current value: gpt-5.6-sol", b"\x1b"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(
+                f"agent-launch curses model Esc returned {picker_status}, want 130"
+            )
+
+        _, picker_status = run_picker_scenario(
+            "Custom q-prefixed model preservation",
+            (
+                *open_custom_steps,
+                hub_choice(3),
+                (b"Other (enter a model id)", down * 3 + b"\r"),
+                (b"Current value: gpt-5.6-sol", b"qwen\r"),
+                (b"Options (", b"\x1b"),
+                (b"Other (enter a model id)", b"\r"),
+                (b"Current value: qwen", b"\x1b"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(
+                f"agent-launch q-prefixed model returned {picker_status}, want 130"
+            )
+
+        _, picker_status = run_picker_scenario(
+            "Custom model Ctrl-C cancellation",
+            (
+                *open_custom_steps,
+                hub_choice(3),
+                (b"Other (enter a model id)", down * 3 + b"\r"),
+                (b"Current value: gpt-5.6-sol", b"\x03"),
+            ),
+        )
+        if picker_status != 130:
+            mark_fail(
+                f"agent-launch curses model Ctrl-C returned {picker_status}, want 130"
+            )
+
+        numbered_model_q = invoke(
+            [
+                sys.executable,
+                str(launcher),
+                "--config",
+                str(fake_profile),
+                "--preset",
+                "balanced",
+                "--custom",
+                "--dry-run",
+                "codex",
+            ],
+            input_text="4\nq\n",
+            env=env,
+        )
+        if numbered_model_q.returncode != 130 or "Traceback" in numbered_model_q.stderr:
+            mark_fail("agent-launch numbered model q did not cancel cleanly")
+
+        _, picker_status = run_picker_scenario(
+            "arrow picker cancellation",
+            (*open_custom_steps, (b"Custom settings", b"\x03")),
+        )
+        if picker_status != 130:
+            mark_fail(f"agent-launch arrow picker returned {picker_status}, want 130")
+
+        transcript, picker_status = run_picker_scenario(
+            "Custom completion",
+            (*open_custom_steps, hub_choice(8)),
+        )
+        if picker_status != 0:
+            mark_fail(f"agent-launch Custom completion returned {picker_status}, want 0")
+        for expected in (
+            b"Preset         Custom (Balanced)",
+            b"Main           HELM",
+            b"Review setup   native-panel",
+            b"Execution      Codex bypass",
+        ):
+            if expected not in transcript:
+                mark_fail(f"agent-launch Custom projection missing {expected.decode()!r}")
+
+        claude_auto_profile = tmp / "claude-auto.toml"
+        claude_auto_profile.write_text(
+            profile_text.replace(
+                'claude_permission_mode = "bypassPermissions"',
+                'claude_permission_mode = "auto"',
+                1,
+            )
+        )
+        transcript, picker_status = run_picker_scenario(
+            "Claude Custom auto preservation",
+            (*open_custom_steps, hub_choice(8)),
+            host="claude",
+            config_path=claude_auto_profile,
+        )
+        if picker_status != 0:
+            mark_fail(
+                f"agent-launch Claude Custom auto returned {picker_status}, want 0"
+            )
+        for expected in (
+            b"Preset         Custom (Balanced)",
+            b"Execution      Claude auto",
+            b'"--permission-mode", "auto"',
+        ):
+            if expected not in transcript:
+                mark_fail(
+                    "agent-launch Claude Custom auto projection missing "
+                    f"{expected.decode()!r}"
+                )
+        if b'"--dangerously-skip-permissions"' in transcript:
+            mark_fail("agent-launch Claude Custom auto escalated to permission bypass")
+
+        claude_dont_ask_profile = tmp / "claude-dont-ask.toml"
+        claude_dont_ask_profile.write_text(
+            profile_text.replace(
+                'claude_permission_mode = "bypassPermissions"',
+                'claude_permission_mode = "dontAsk"',
+                1,
+            )
+        )
+        dont_ask = invoke(
+            [
+                sys.executable,
+                str(launcher),
+                "--config",
+                str(claude_dont_ask_profile),
+                "--preset",
+                "balanced",
+                "--custom",
+                "--dry-run",
+                "claude",
+            ],
+            input_text="9\n",
+            env=env,
+        )
+        if dont_ask.returncode != 0:
+            mark_fail(
+                "agent-launch numbered Claude Custom dontAsk failed: "
+                f"{dont_ask.stderr.strip()}"
+            )
+        else:
+            dont_ask_argv = json.loads(dont_ask.stdout.splitlines()[-1])
+            if dont_ask_argv[-2:] != ["--permission-mode", "dontAsk"]:
+                mark_fail(
+                    "agent-launch numbered Claude Custom did not preserve dontAsk"
+                )
+
+        # TERM=dumb routes to numbered prompts (textual renders on any usable
+        # terminal, so the numbered fallback is gated on TERM/non-TTY/textual
+        # availability, not a terminfo probe). 'b' is the numbered back command.
+        transcript, picker_status = run_picker_scenario(
+            "numbered fallback (TERM=dumb)",
+            (
+                (b"Open a settings hub", b"4\n"),
+                (b"Custom settings", b"b\n"),
+                (b"HELM default for everyday work", b"1\n"),
+            ),
+            term="dumb",
+        )
+        if (
+            picker_status != 0
+            or b"Traceback" in transcript
+            or b"Preset         Balanced" not in transcript
+        ):
+            mark_fail("agent-launch numbered fallback (TERM=dumb) did not preserve numbered back")
+
+        passed = invoke([
+            sys.executable, str(launcher), "--no-tui", "codex", "--", "exec", "--json", "probe"
+        ], env=env)
+        if passed.returncode != 0 or argv_log.read_text().splitlines() != ["exec", "--json", "probe"]:
+            mark_fail("agent-launch Codex argument-bearing bypass changed forwarded argv")
+
+        passed = invoke([
+            sys.executable, str(launcher), "--no-tui", "claude", "--", "-p", "probe"
+        ], env=env)
+        if passed.returncode != 0 or argv_log.read_text().splitlines() != [
+            "--dangerously-skip-permissions", "-p", "probe"
+        ]:
+            mark_fail("agent-launch Claude bypass did not preserve the existing backend default")
+
+        env["FAKE_LAUNCH_STATUS"] = "9"
+        failed = invoke([sys.executable, str(launcher), "--no-tui", "codex", "--", "probe"], env=env)
+        if failed.returncode != 9:
+            mark_fail(f"agent-launch returns {failed.returncode} instead of backend exit status 9")
+        env.pop("FAKE_LAUNCH_STATUS")
+
+        sleeper = tmp / "sleeper"
+        sleeper.write_text("#!/usr/bin/env bash\nexec sleep 30\n")
+        sleeper.chmod(0o755)
+        signal_profile = tmp / "signal.toml"
+        signal_profile.write_text(profile_text.replace(str(backend), str(sleeper)))
+        signal_process = subprocess.Popen([
+            sys.executable, str(launcher), "--config", str(signal_profile),
+            "--no-tui", "codex",
+        ], env=env)
+        time.sleep(0.2)
+        signal_process.terminate()
+        try:
+            signal_status = signal_process.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            signal_process.kill()
+            signal_process.wait()
+            mark_fail("agent-launch did not forward process lifetime through exec")
+        else:
+            if signal_status != -15:
+                mark_fail(f"agent-launch SIGTERM status is {signal_status}, want -15")
+
+        invalid_args_profile = tmp / "invalid-args.toml"
+        invalid_args_profile.write_text(
+            profile_text.replace("passthrough_args = []", 'passthrough_args = "--bad"', 1)
+        )
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_args_profile),
+            "--no-tui", "codex",
+        ], env=env)
+        if invalid.returncode != 2 or "passthrough_args" not in invalid.stderr:
+            mark_fail("agent-launch accepted string passthrough_args instead of failing closed")
+
+        invalid_delegation_profile = tmp / "invalid-delegation.toml"
+        invalid_delegation_profile.write_text(
+            profile_text.replace("delegation = true", 'delegation = "false"', 1)
+        )
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_delegation_profile),
+            "--preset", "balanced", "--dry-run", "codex",
+        ], env=env)
+        if invalid.returncode != 2 or "delegation must be boolean" not in invalid.stderr:
+            mark_fail("agent-launch accepted non-boolean delegation instead of failing closed")
+
+        no_delegation_profile = tmp / "no-delegation.toml"
+        no_delegation_profile.write_text(
+            profile_text.replace(
+                'review_setup = "native-panel"\ndelegation = true',
+                'review_setup = "none"\ndelegation = false',
+                1,
+            )
+        )
+        no_delegation = invoke([
+            sys.executable, str(launcher), "--config", str(no_delegation_profile),
+            "--preset", "balanced", "--dry-run", "claude",
+        ], env=env)
+        if no_delegation.returncode != 0:
+            mark_fail(f"agent-launch rejected valid delegation=false: {no_delegation.stderr.strip()}")
+        else:
+            no_delegation_argv = json.loads(no_delegation.stdout.splitlines()[-1])
+            if "--agents" in no_delegation_argv or "Delegation=off" not in " ".join(no_delegation_argv):
+                mark_fail("agent-launch Claude delegation=false still projected child agents")
+
+        # The native-requires-delegation contradiction is a same-family concept
+        # (cross native does not gate on delegation); test it under review_family=same.
+        for review_setup in ("native-panel", "hybrid"):
+            incompatible_review_profile = tmp / f"no-delegation-{review_setup}.toml"
+            incompatible_review_profile.write_text(
+                profile_text.replace(
+                    'review_setup = "native-panel"\ndelegation = true',
+                    f'review_setup = "{review_setup}"\nreview_family = "same"\ndelegation = false',
+                    1,
+                )
+            )
+            incompatible_review = invoke([
+                sys.executable,
+                str(launcher),
+                "--config",
+                str(incompatible_review_profile),
+                "--preset",
+                "balanced",
+                "--dry-run",
+                "claude",
+            ], env=env)
+            if (
+                incompatible_review.returncode != 2
+                or "requires delegation" not in incompatible_review.stderr
+            ):
+                mark_fail(
+                    "agent-launch accepted delegation=false with review setup "
+                    f"{review_setup}"
+                )
+
+        for field in ("codex_execution_policy", "claude_permission_mode"):
+            missing_policy_profile = tmp / f"missing-{field}.toml"
+            missing_policy_profile.write_text(
+                profile_text.replace(f'{field} = "bypass"\n', "", 1)
+                if field == "codex_execution_policy"
+                else profile_text.replace(f'{field} = "bypassPermissions"\n', "", 1)
+            )
+            missing_policy = invoke([
+                sys.executable, str(launcher), "--config", str(missing_policy_profile),
+                "--preset", "balanced", "--dry-run", "codex",
+            ], env=env)
+            if missing_policy.returncode != 2 or field not in missing_policy.stderr:
+                mark_fail(f"agent-launch accepted missing security policy: {field}")
+
+        for field, valid_value in (
+            ("codex_execution_policy", "bypass"),
+            ("claude_permission_mode", "bypassPermissions"),
+        ):
+            invalid_policy_profile = tmp / f"invalid-{field}.toml"
+            invalid_policy_profile.write_text(
+                profile_text.replace(
+                    f'{field} = "{valid_value}"',
+                    f'{field} = "unsupported-policy"',
+                    1,
+                )
+            )
+            invalid_policy = invoke([
+                sys.executable,
+                str(launcher),
+                "--config",
+                str(invalid_policy_profile),
+                "--preset",
+                "balanced",
+                "--dry-run",
+                "codex",
+            ], env=env)
+            if invalid_policy.returncode != 2 or field not in invalid_policy.stderr:
+                mark_fail(f"agent-launch accepted invalid security policy: {field}")
+
+        invalid_schema_profile = tmp / "invalid-schema.toml"
+        invalid_schema_profile.write_text(profile_text.replace("schema_version = 1", "schema_version = true", 1))
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_schema_profile),
+            "--no-tui", "codex",
+        ], env=env)
+        if invalid.returncode != 2 or "unsupported schema_version" not in invalid.stderr:
+            mark_fail("agent-launch accepted boolean schema_version instead of failing closed")
+
+        invalid_review_profile = tmp / "invalid-review.toml"
+        invalid_review_profile.write_text(
+            profile_text.replace('review_setup = "native-panel"', 'review_setup = ["native-panel"]', 1)
+        )
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_review_profile),
+            "--preset", "balanced", "--dry-run", "codex",
+        ], env=env)
+        if invalid.returncode != 2 or "unknown review setup" not in invalid.stderr:
+            mark_fail("agent-launch raised outside LaunchError for malformed review_setup")
+
+        invalid_models_profile = tmp / "invalid-models.toml"
+        invalid_models_profile.write_text(
+            profile_text.replace(
+                'models = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]',
+                "models = []",
+                1,
+            )
+        )
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_models_profile),
+            "--preset", "balanced", "--dry-run", "codex",
+        ], env=env)
+        if invalid.returncode != 2 or "must be a non-empty list of strings" not in invalid.stderr:
+            mark_fail("agent-launch accepted an empty models catalog instead of failing closed")
+
+        invalid_claude_effort_profile = tmp / "invalid-claude-effort.toml"
+        invalid_claude_effort_profile.write_text(
+            profile_text.replace('codex = "ultra", claude = "max"', 'codex = "ultra", claude = "ultra"')
+        )
+        invalid = invoke([
+            sys.executable, str(launcher), "--config", str(invalid_claude_effort_profile),
+            "--preset", "deep-review", "--dry-run", "claude",
+        ], env=env)
+        if invalid.returncode != 2 or "unsupported effort" not in invalid.stderr:
+            mark_fail("agent-launch accepted Claude Ultra instead of failing closed")
+
+        bare_dry_run = invoke([
+            sys.executable, str(launcher), "--dry-run", "codex",
+        ], env=env)
+        if bare_dry_run.returncode != 0 or "Preset         Balanced" not in bare_dry_run.stdout:
+            mark_fail("agent-launch non-TTY bare --dry-run did not select Balanced")
+
+        no_balanced_profile = tmp / "no-balanced.toml"
+        no_balanced_profile.write_text(
+            profile_text.replace("[presets.balanced]", "[presets.daily]", 1)
+        )
+        no_balanced = invoke([
+            sys.executable,
+            str(launcher),
+            "--config",
+            str(no_balanced_profile),
+            "--dry-run",
+            "codex",
+        ], env=env)
+        if (
+            no_balanced.returncode != 2
+            or "requires a 'balanced' preset" not in no_balanced.stderr
+        ):
+            mark_fail(
+                "agent-launch bare non-TTY dry-run selected an arbitrary custom preset"
+            )
+
+        configured_runtime = invoke([
+            sys.executable, str(launcher), "--preset", "balanced", "--yes", "codex", "--", "probe"
+        ], env=env)
+        if configured_runtime.stdout != "backend-output\n":
+            mark_fail("configured non-TTY launch polluted backend stdout with its summary")
+        if "Launch summary" not in configured_runtime.stderr:
+            mark_fail("configured non-TTY launch did not disclose its summary on stderr")
+        projected_agent_files = sorted((tmp / "cache/agent-launch/codex-agents").glob("*/*.toml"))
+        if len(projected_agent_files) != 3:
+            mark_fail("configured Codex launch did not materialize three pinned child agents")
+        for path in projected_agent_files:
+            data = tomllib.loads(path.read_text())
+            tier = path.stem
+            expected_model, expected_effort = expected_launch_tiers[tier]
+            if (data.get("model"), data.get("model_reasoning_effort")) != (
+                expected_model, expected_effort
+            ):
+                mark_fail(f"materialized Codex {tier} binding drifted: {path}")
+
+        custom_codex_home = tmp / "custom-codex-home"
+        (custom_codex_home / "agents").mkdir(parents=True)
+        for tier in ("frontier", "workhorse", "sweep"):
+            (custom_codex_home / "agents" / f"{tier}.toml").write_text(
+                (agent_dir / f"{tier}.toml").read_text()
+            )
+        portable_profile = tmp / "portable.toml"
+        portable_profile.write_text(portable_profile_text)
+        portable_env = env.copy()
+        portable_env.update(
+            CODEX_HOME=str(custom_codex_home),
+            XDG_CACHE_HOME=str(tmp / "portable-cache"),
+        )
+        portable = invoke([
+            sys.executable, str(launcher), "--config", str(portable_profile),
+            "--preset", "balanced", "--yes", "codex", "--", "probe",
+        ], env=portable_env)
+        if portable.returncode != 0 or len(
+            list((tmp / "portable-cache/agent-launch/codex-agents").glob("*/*.toml"))
+        ) != 3:
+            mark_fail("configured Codex launch did not honor non-default CODEX_HOME")
+
+        env["AGENT_LAUNCH_DEBUG"] = "1"
+        configured = invoke([
+            sys.executable, str(launcher), "--preset", "balanced", "--yes", "--dry-run",
+            "codex", "--", "exec", "probe",
+        ], env=env)
+        expect_text(
+            configured,
+            "agent-launch Codex configured projection",
+            (
+                "configured/requested · completed: not enforced",
+                'model_reasoning_effort=\\"xhigh\\"',
+                "features.multi_agent=true",
+                "--dangerously-bypass-approvals-and-sandbox",
+                "forwarded backend args appended last; may supersede defaults",
+                '"exec", "probe"',
+            ),
+        )
+        if configured.returncode == 0:
+            codex_argv = json.loads(configured.stdout.splitlines()[-1])
+            if codex_argv[-2:] != ["exec", "probe"]:
+                mark_fail("agent-launch Codex expert overrides were not appended last")
+        configured = invoke([
+            sys.executable, str(launcher), "--preset", "balanced", "--yes", "--dry-run",
+            "claude", "--", "-p", "probe",
+        ], env=env)
+        expect_text(
+            configured,
+            "agent-launch Claude configured projection",
+            (
+                "configured/requested · completed: not enforced",
+                "--append-system-prompt",
+                "--agents",
+                "--dangerously-skip-permissions",
+                '"-p", "probe"',
+            ),
+        )
+        if configured.returncode == 0:
+            try:
+                projected_argv = json.loads(configured.stdout.splitlines()[-1])
+                agents_arg = json.loads(projected_argv[projected_argv.index("--agents") + 1])
+            except (ValueError, IndexError, json.JSONDecodeError) as exc:
+                mark_fail(f"agent-launch Claude --agents projection is not valid JSON: {exc}")
+            else:
+                for tier, (model, effort) in expected_claude_tiers.items():
+                    role = agents_arg.get(tier, {})
+                    if role.get("model") != model or role.get("effort") != effort:
+                        mark_fail(f"agent-launch Claude {tier} role projection drifted: {role!r}")
+                if projected_argv[-2:] != ["-p", "probe"]:
+                    mark_fail(
+                        "agent-launch Claude expert overrides were not appended last"
+                    )
+
+        # Cross-family default: each main routes every review route to the OPPOSITE
+        # model family, with concrete tools/paths/bindings named in the contract.
+        # The cross CODEX_HOME needs the reviewer wrappers (bin) and the same-family
+        # agent templates (agents) that the codex fallback floor still materializes.
+        cross_home = tmp / "cross-codex-home"
+        (cross_home / "bin").mkdir(parents=True)
+        (cross_home / "agents").mkdir(parents=True)
+        for wrapper in ("codex-run", "codex-helm"):
+            wrapper_path = cross_home / "bin" / wrapper
+            wrapper_path.write_text("#!/usr/bin/env bash\nexit 0\n")
+            wrapper_path.chmod(0o755)
+        for tier in ("frontier", "workhorse", "sweep"):
+            (cross_home / "agents" / f"{tier}.toml").write_text(
+                (agent_dir / f"{tier}.toml").read_text()
+            )
+        cross_env = env.copy()
+        cross_env["CODEX_HOME"] = str(cross_home)
+
+        claude_cross = invoke([
+            sys.executable, str(launcher), "--preset", "deep-review", "--yes",
+            "--dry-run", "claude",
+        ], env=cross_env)
+        expect_text(
+            claude_cross,
+            "agent-launch Claude cross-family (gpt/codex) review projection",
+            (
+                "Review family=cross",
+                "run EVERY review route on OpenAI/Codex",
+                "codex-run --profile hermetic",
+                "onto: call onto_review",
+                "so onto runs OpenAI/Codex",
+                f"{fake_ultracode} (the $ultracode-for-codex Codex skill)",
+                "frontier=gpt-5.6-sol/max",
+            ),
+        )
+        codex_cross = invoke([
+            sys.executable, str(launcher), "--preset", "deep-review", "--yes",
+            "--dry-run", "codex",
+        ], env=cross_env)
+        expect_text(
+            codex_cross,
+            "agent-launch Codex cross-family (anthropic/claude) review projection",
+            (
+                "Review family=cross",
+                "run EVERY review route on Anthropic/Claude",
+                "-p --model <review tier>",
+                "--permission-mode plan",
+                "onto: call onto_review",
+                "so onto runs Anthropic/Claude",
+                "--effort ultracode -p",
+                "Claude Code /workflows ultracode mode, headless",
+                "frontier=claude-fable-5/max",
+            ),
+        )
+
+        # Module-level: the cross contract pins the exact onto llmOverride family+model.
+        cross_cfg = tomllib.loads(profile_text)
+        for main_host, provider, model in (
+            ("claude", "openai", "gpt-5.6-sol"),
+            ("codex", "anthropic", "claude-fable-5"),
+        ):
+            cross_plan = launcher_module.build_plan(cross_cfg, main_host, "deep-review")
+            contract = launcher_module.run_contract(cross_plan)
+            expected = f'llmOverride={{"provider":"{provider}","model":"{model}"}}'
+            if expected not in contract:
+                mark_fail(f"agent-launch {main_host} cross onto llmOverride missing: {expected}")
+
+        # A config with only one host degrades cross review to same-family instead of
+        # crashing on the absent opposite host.
+        single_host_cfg = tomllib.loads(profile_text)
+        single_host_cfg["hosts"].pop("claude", None)
+        single_host_cfg["backends"].pop("claude", None)
+        try:
+            single_plan = launcher_module.build_plan(single_host_cfg, "codex", "balanced")
+            if single_plan["review_family"] != "same":
+                mark_fail("agent-launch single-host config did not coerce cross review to same")
+            launcher_module.run_contract(single_plan)
+        except launcher_module.LaunchError as exc:
+            mark_fail(f"agent-launch single-host config raised instead of degrading: {exc}")
+        except Exception as exc:
+            mark_fail(f"agent-launch single-host config crashed (not a clean degrade): {exc!r}")
+
+        # An all-disabled option list raises a clean LaunchError, not a hang.
+        try:
+            launcher_module.choose(
+                "empty", [launcher_module.MenuOption("a", "A", "d", enabled=False)], "a"
+            )
+            mark_fail("agent-launch choose accepted an all-disabled option list")
+        except launcher_module.LaunchError:
+            pass
+
+        # review_family=same reproduces the earlier same-family hybrid contract verbatim.
+        same_family_profile = tmp / "same-family.toml"
+        same_family_profile.write_text(
+            profile_text.replace(
+                'review_setup = "hybrid"', 'review_setup = "hybrid"\nreview_family = "same"', 1
+            )
+        )
+        same_family_review = invoke([
+            sys.executable, str(launcher), "--config", str(same_family_profile),
+            "--preset", "deep-review", "--yes", "--dry-run", "claude",
+        ], env=env)
+        expect_text(
+            same_family_review,
+            "agent-launch review_family=same restores same-family contract",
+            (
+                "Review family=same",
+                "Codex-backed Ultracode review kinds",
+                f"Ultracode executable: {fake_ultracode}",
+            ),
+            ("cross-family review",),
+        )
+
+        frontier_profile = tmp / "frontier.toml"
+        frontier_profile.write_text(
+            profile_text.replace(
+                'main_tier = "helm"\nfrontier_effort = "max"',
+                'main_tier = "frontier"\nfrontier_effort = "ultra"',
+                1,
+            )
+        )
+        configured = invoke([
+            sys.executable, str(launcher), "--config", str(frontier_profile),
+            "--preset", "balanced", "--yes", "--dry-run", "codex",
+        ], env=env)
+        expect_text(
+            configured,
+            "agent-launch FRONTIER main effort projection",
+            ('Main           FRONTIER · gpt-5.6-sol · ultra', 'main=frontier (gpt-5.6-sol/ultra)'),
+        )
+
+        unavailable_profile = tmp / "unavailable.toml"
+        unavailable_profile.write_text(
+            profile_text.replace(
+                f"command = {json.dumps(str(fake_onto))}",
+                f"command = {json.dumps(str(tmp / 'missing-onto'))}",
+                1,
+            ).replace(
+                f"command = {json.dumps(str(fake_ultracode))}",
+                f"command = {json.dumps(str(tmp / 'missing-ultracode'))}",
+                1,
+            ).replace(
+                'review_setup = "hybrid"', 'review_setup = "hybrid"\nreview_family = "same"', 1
+            )
+        )
+        # Under review_family=same, missing external review capabilities (onto/ultracode
+        # CLI absent) degrade to native same-model review instead of failing closed.
+        unavailable = invoke([
+            sys.executable, str(launcher), "--config", str(unavailable_profile),
+            "--preset", "deep-review", "--yes", "--dry-run", "codex",
+        ], env=env)
+        expect_text(
+            unavailable,
+            "agent-launch codex degrade-to-native review",
+            (
+                "Review setup   hybrid → effective native (onto,ultracode unavailable)",
+                "degraded to native same-model",
+                "fall back to native same-model subagent review",
+            ),
+            ("mcp_servers.onto.enabled=true", "Ultracode executable:"),
+        )
+
+        unavailable_claude = invoke([
+            sys.executable, str(launcher), "--config", str(unavailable_profile),
+            "--preset", "deep-review", "--yes", "--dry-run", "claude",
+        ], env=env)
+        if expect_text(
+            unavailable_claude,
+            "agent-launch claude degrade-to-native review",
+            (
+                "Review setup   hybrid → effective native (onto,ultracode unavailable)",
+                "fall back to native same-model subagent review",
+            ),
+            ("--mcp-config",),
+        ):
+            claude_degraded_argv = json.loads(unavailable_claude.stdout.splitlines()[-1])
+            if "--agents" not in claude_degraded_argv:
+                mark_fail("agent-launch claude degrade dropped native --agents review")
+
+        # Stage C: a named preset save round-trips and stays host-scoped.
+        save_target = tmp / "save-target.toml"
+        save_target.write_text(profile_text)
+        save_cfg = tomllib.loads(save_target.read_text())
+        save_plan = launcher_module.build_plan(save_cfg, "codex", "balanced")
+        save_plan["main_tier"] = "workhorse"
+        save_plan["tiers"]["workhorse"]["model"] = "custom-wh"
+        save_plan["tiers"]["workhorse"]["effort"] = "xhigh"
+        save_plan["frontier_effort"] = "ultra"
+        launcher_module.save_preset(save_plan, save_cfg, save_target, "mysetup")
+        reloaded = launcher_module.load_config(save_target)
+        if "mysetup" not in reloaded["presets"] or "balanced" not in reloaded["presets"]:
+            mark_fail("save_preset did not persist the preset or clobbered existing ones")
+        else:
+            round_trip = launcher_module.build_plan(reloaded, "codex", "mysetup")
+            if (
+                round_trip["main_tier"] != "workhorse"
+                or round_trip["tiers"]["workhorse"] != {"model": "custom-wh", "effort": "xhigh"}
+                or launcher_module.tier_effort(round_trip, "frontier") != "ultra"
+            ):
+                mark_fail(f"saved preset did not round-trip: {round_trip['tiers']}")
+            claude_view = launcher_module.build_plan(reloaded, "claude", "mysetup")
+            if (
+                claude_view["tiers"]["workhorse"]["model"]
+                != save_cfg["hosts"]["claude"]["tiers"]["workhorse"]["model"]
+            ):
+                mark_fail("saved codex tier override leaked into the claude host")
+            launcher_module.save_preset(round_trip, reloaded, save_target, "mysetup")
+            if save_target.read_text().count("[presets.mysetup]") != 1:
+                mark_fail("re-saving a preset duplicated its block")
+
+        # The Custom hub 'save' action persists the named preset then launches.
+        ui_save_target = tmp / "ui-save.toml"
+        ui_save_target.write_text(profile_text)
+        if argv_log.exists():
+            argv_log.unlink()
+        ui_save = invoke([
+            sys.executable, str(launcher), "--config", str(ui_save_target),
+            "--preset", "balanced", "--custom", "codex",
+        ], input_text="8\ndaily-driver\n", env=env)
+        if ui_save.returncode != 0 or not argv_log.exists():
+            mark_fail(f"agent-launch custom save-and-start did not launch: {ui_save.stderr.strip()}")
+        elif "daily-driver" not in launcher_module.load_config(ui_save_target)["presets"]:
+            mark_fail("agent-launch custom hub save did not persist the named preset")
+
+        shell_bin = tmp / "shell-bin"
+        shell_bin.mkdir()
+        dispatch_log = tmp / "dispatch.argv"
+        shell_backend = shell_bin / "backend"
+        shell_backend.write_text(
+            "#!/usr/bin/env bash\n"
+            "printf '%s\\n' \"$(basename \"$0\")\" \"$@\" > \"$FAKE_DISPATCH_ARGV\"\n"
+        )
+        shell_backend.chmod(0o755)
+        (shell_bin / "codex").symlink_to(shell_backend)
+        (shell_bin / "claude").symlink_to(shell_backend)
+        shell_env = env.copy()
+        shell_env.update(
+            PATH=f"{shell_bin}{os.pathsep}{shell_env.get('PATH', '')}",
+            FAKE_DISPATCH_ARGV=str(dispatch_log),
+        )
+        for command, expected in (
+            ("codex exec probe", ["codex", "exec", "probe"]),
+            ("claude --no-tui -p probe", ["claude", "--dangerously-skip-permissions", "-p", "probe"]),
+            ("codex", ["codex"]),
+        ):
+            shell_result = invoke([
+                "zsh", "-f", "-c", f"source {shell_init}; {command}"
+            ], env=shell_env)
+            received = dispatch_log.read_text().splitlines() if dispatch_log.is_file() else []
+            if shell_result.returncode != 0 or received != expected:
+                mark_fail(f"shell dispatch for {command!r} is {received!r}, want {expected!r}")
+        alias_result = invoke([
+            "zsh", "-f", "-c",
+            f"alias codex='false'; alias claude='false'; source {shell_init}; codex exec alias-probe",
+        ], env=shell_env)
+        received = dispatch_log.read_text().splitlines() if dispatch_log.is_file() else []
+        if alias_result.returncode != 0 or received != [
+            "codex", "exec", "alias-probe"
+        ]:
+            mark_fail("shell init did not replace pre-existing codex/claude aliases")
+
+if fail == 0:
+    print("LAUNCH/BINDINGS OK: profile projections, bypass paths, role slots, and wrappers aligned")
+sys.exit(fail)
+PY
+then
+  fail=1
+fi
+
+[ "$fail" -eq 0 ] && echo "PARITY OK: mirrors, globals, guides, launch profile, bypass paths, role bindings, and wrapper defaults aligned"
+exit "$fail"