agent-bios 0.9.9 → 0.11.0

package/launch/agent-launch.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import argparse
 import copy
+import fcntl
 import hashlib
 import json
 import os
@@ -87,6 +88,176 @@ USER_PRESETS_HEADER = (
     "# survive upgrades. Shipped presets live in the deployed profiles.toml and\n"
     "# are overridden by a preset of the same name here.\n"
 )
+# ── UI language (interface text only) ─────────────────────────────────────────
+# Deploy-managed catalogs, sibling directory of the config: launch/i18n/ in a
+# checkout, ~/.config/agent-launch/i18n/ deployed. `en` is the reference
+# key-set; the parity gate holds ko/ja to exactly it, both directions, so an
+# incomplete catalog is unshippable rather than silently hybrid. Chrome
+# language never reaches a rendered launch contract — a golden scenario pins
+# that. Internal codes only here; "JP" is a display label for `ja`.
+I18N_DIR_NAME = "i18n"
+I18N_LANGUAGES = ("en", "ko", "ja")
+I18N_ENV = "AGENT_LAUNCH_LANG"
+
+
+def _module_catalog(language: str) -> dict[str, str]:
+    """The catalog shipped beside this module, or empty. The module-adjacent set
+    is the default for in-process consumers that never reach main() (gate legs
+    import the module and drive flows directly); load_catalogs() replaces it
+    with the config-sibling deployment when one exists."""
+    path = pathlib.Path(__file__).resolve().parent / I18N_DIR_NAME / f"{language}.toml"
+    try:
+        raw = tomllib.loads(path.read_text())
+    except (OSError, tomllib.TOMLDecodeError):
+        return {}
+    return {key: value for key, value in raw.items() if isinstance(value, str)}
+
+
+_CATALOG_EN: dict[str, str] = _module_catalog("en")
+_CATALOG: dict[str, str] = _CATALOG_EN
+# Keys asked for but absent from the active catalog. The completeness gate makes
+# this state unshippable; the set is the runtime tripwire for the state the gate
+# should have made impossible (surfaced by the Stage-2 banner).
+_CATALOG_MISSING: set[str] = set()
+
+
+def i18n_dir(config_path: pathlib.Path) -> pathlib.Path:
+    return config_path.with_name(I18N_DIR_NAME)
+
+
+# User-owned launcher preferences, sibling to the other two `.local.toml` files
+# and owned the same way: written by the launcher on an explicit selection only,
+# never deployed, never overwritten by an install. One table, one key, until
+# another preference earns its place.
+USER_LAUNCHER_NAME = "launcher.local.toml"
+
+
+def user_launcher_path(config_path: pathlib.Path) -> pathlib.Path:
+    return config_path.with_name(USER_LAUNCHER_NAME)
+
+
+def saved_language(config_path: pathlib.Path) -> str | None:
+    """The persisted UI language, or None. A malformed file or value is a
+    loud notice and None — a preference must never block launching."""
+    path = user_launcher_path(config_path)
+    if not path.is_file():
+        return None
+    try:
+        value = tomllib.loads(path.read_text()).get("ui", {}).get("language")
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        print(f"agent-launch: cannot read {path}: {exc}; using en", file=sys.stderr)
+        return None
+    if value in I18N_LANGUAGES:
+        return value
+    if value is not None:
+        print(
+            f"agent-launch: {path} names language {value!r}, not one of "
+            f"{'/'.join(I18N_LANGUAGES)}; using en", file=sys.stderr,
+        )
+    return None
+
+
+def save_language(config_path: pathlib.Path, language: str) -> None:
+    """Persist the UI language atomically. The whole file is launcher-authored
+    (one table, one key), so a full rewrite loses nothing user-written."""
+    path = user_launcher_path(config_path)
+    content = (
+        "# agent-launch user preferences, written by the launcher.\n"
+        "# agent-bios install never deploys or verifies this file.\n"
+        f'\n[ui]\nlanguage = "{language}"\n'
+    )
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    temporary.write_text(content)
+    os.replace(temporary, path)
+
+
+def ui_language(config_path: pathlib.Path | None = None) -> str:
+    """The active UI language. Env override first (what gates pin), then the
+    user preference file, then English."""
+    explicit = os.environ.get(I18N_ENV, "")
+    if explicit in I18N_LANGUAGES:
+        return explicit
+    if explicit:
+        print(
+            f"agent-launch: {I18N_ENV}={explicit!r} is not one of "
+            f"{'/'.join(I18N_LANGUAGES)}; using en", file=sys.stderr,
+        )
+        return "en"
+    if config_path is not None:
+        preferred = saved_language(config_path)
+        if preferred:
+            return preferred
+    return "en"
+
+
+def load_catalogs(config_path: pathlib.Path) -> None:
+    """Load the English reference UI text catalog and the active language's catalog from
+    the config's sibling i18n directory, falling back to the module-adjacent set.
+
+    A selected language whose catalog fails to LOAD falls to English with a loud
+    notice — never silently. English missing from BOTH homes leaves keys
+    rendering as themselves, which the completeness gate makes unreachable on a
+    shipped tree."""
+    global _CATALOG, _CATALOG_EN
+    directory = i18n_dir(config_path)
+
+    def read(language: str) -> dict[str, str] | None:
+        path = directory / f"{language}.toml"
+        try:
+            raw = tomllib.loads(path.read_text())
+        except OSError:
+            return None
+        except tomllib.TOMLDecodeError as exc:
+            print(
+                f"agent-launch: UI text catalog {path} does not parse: {exc}",
+                file=sys.stderr,
+            )
+            return None
+        return {key: value for key, value in raw.items() if isinstance(value, str)}
+
+    deployed_en = read("en")
+    if deployed_en is not None:
+        _CATALOG_EN = deployed_en
+    elif not _CATALOG_EN:
+        print(
+            f"agent-launch: no UI text catalog for en under {directory} or beside "
+            "the launcher; UI text keys will render as themselves", file=sys.stderr,
+        )
+    language = ui_language(config_path)
+    if language == "en":
+        _CATALOG = _CATALOG_EN
+        return
+    selected = read(language)
+    if selected is None:
+        selected = _module_catalog(language)
+    if selected:
+        # A deployed catalog older than the launcher is invisible to the
+        # source-tree completeness gate; the skew is loud here instead of
+        # surfacing as silently-English strings one key at a time.
+        skew = len(set(_CATALOG_EN) - set(selected))
+        if skew:
+            print(
+                f"agent-launch: UI text catalog {language} is missing {skew} "
+                "key(s) vs en (deployed version skew?); those strings render "
+                "in English", file=sys.stderr,
+            )
+        _CATALOG = selected
+        return
+    print(
+        f"agent-launch: no UI text catalog for {language}; showing English",
+        file=sys.stderr,
+    )
+    _CATALOG = _CATALOG_EN
+
+
+def t(key: str) -> str:
+    """One UI text string. Missing keys fall to English and trip the tripwire;
+    a key missing from English too renders as itself rather than crashing."""
+    value = _CATALOG.get(key)
+    if value is not None:
+        return value
+    _CATALOG_MISSING.add(key)
+    return _CATALOG_EN.get(key, key)
 
 
 @dataclass(frozen=True)
@@ -136,66 +307,41 @@ REVIEW_SETUPS = {
             "codex": "Use Codex's built-in /review when review gates fire.",
         },
     },
-    "onto": {
-        "label": "onto-mcp",
-        "requirements": {"codex": ("onto",), "claude": ("onto",)},
-        "description": (
-            "Structured multi-lens review through onto-mcp. Best for concept/ontology "
-            "and design work; needs onto installed."
-        ),
-        "contract": "Use onto-mcp as the structured review lens when review gates fire.",
-    },
     "ultracode": {
-        "label": "Ultracode",
-        "requirements": {"codex": ("ultracode-for-codex",), "claude": ("ultracode-for-codex",)},
+        "label": "Deep review",
+        "requirements": {"codex": ("codex-exec",), "claude": ("codex-exec",)},
         "description": (
-            "Workflow-orchestrated review fanned out over many agents. Best for "
-            "exhaustive audits; slowest and most expensive."
+            "The review family's deep mechanism: plain codex exec at ultra effort on "
+            "a Codex seat, the Claude workflow when review lands on a Claude seat."
         ),
         "contract": (
-            "Run the configured Ultracode CLI as a Codex-backed review route when "
-            "review gates fire."
-        ),
-    },
-    "hybrid": {
-        "label": "Hybrid",
-        "requirements": {
-            "codex": ("onto", "ultracode-for-codex"),
-            "claude": ("onto", "ultracode-for-codex"),
-        },
-        "description": (
-            "onto + native + Ultracode together, acting on their union. Widest net for "
-            "risky work; missing routes degrade rather than fail."
+            "Run the Codex CLI in non-interactive exec mode (codex exec -s read-only -m "
+            '<frontier-tier model> -c model_reasoning_effort="ultra", self-contained packet '
+            "on stdin) as a Codex-backed deep review route when review gates fire."
         ),
-        "contract": {
-            "codex": "Use onto plus native and Codex-backed Ultracode review kinds; act on their union.",
-            "claude": "Use onto plus native multi-perspective and Codex-backed Ultracode review kinds; act on their union.",
-        },
     },
 }
 
 # Each review setup decomposes into review routes. "native" is same-model
-# multi-perspective subagent review (needs delegation); "onto"/"ultracode" are
-# external routes gated on a resolvable capability command. A missing external
+# multi-perspective subagent review (needs delegation); "ultracode" is an
+# external route gated on a resolvable capability command. A missing external
 # route degrades to native instead of failing closed; only the delegation
 # contradiction (native required with delegation off) stays fail-closed.
 # The legacy route token "ultracode" is SETUP vocabulary, not a capability id — it was
 # used as one, so renaming the tool silently repointed the legacy route at whatever else
 # held the bare name. Bound explicitly here: the token stays frozen, the tool it resolves
 # to is stated once, and the two can differ.
-LEGACY_ULTRACODE_CAPABILITY = "ultracode-for-codex"
+LEGACY_ULTRACODE_CAPABILITY = "codex-exec"
 # Every legacy route that gates on an installed tool, and which capability that is. The
 # token and the id were the same string in four places — availability, the install hint,
 # the executable line and the lowering — so each was a separate way for a rename to
 # repoint a frozen route at the wrong tool. One map, one place to be right.
-LEGACY_ROUTE_CAPABILITY = {"onto": "onto", "ultracode": LEGACY_ULTRACODE_CAPABILITY}
+LEGACY_ROUTE_CAPABILITY = {"ultracode": LEGACY_ULTRACODE_CAPABILITY}
 REVIEW_ROUTES = {
     "none": (),
     "native-panel": ("native",),
     "slash-review": ("slash",),
-    "onto": ("onto",),
     "ultracode": ("ultracode",),
-    "hybrid": ("onto", "native", "ultracode"),
 }
 # Routes that are host-native review commands: they always resolve (no capability
 # to install) but run on the main's own family, so cross-family mode cannot dispatch
@@ -204,14 +350,11 @@ SAME_FAMILY_ROUTES = {"slash"}
 ROUTE_LABELS = {
     "native": "native same-model multi-perspective review",
     "slash": "host-native slash-command review",
-    "onto": "onto structured-lens review",
-    "ultracode": "Codex-backed Ultracode review",
+    "ultracode": "Codex-backed deep exec review",
 }
 # review_family selects whether review runs on the opposite model family (cross,
 # the default) or the same family as the main (same, today's projection).
 REVIEW_FAMILIES = {"cross", "same"}
-# onto llmOverride provider enum (onto MCP tool schema, settings-chain).
-ONTO_PROVIDERS = {"openai", "anthropic", "grok", "lmstudio"}
 # The opposite model family for cross review, keyed on the launch host.
 REVIEW_HOST = {"codex": "claude", "claude": "codex"}
 # The family a legacy cross contract ADVERTISES for each host, and the provider that
@@ -251,9 +394,7 @@ LEGACY_REVIEW_LOWERING = {
     "none": (False, ()),
     "native-panel": (True, ()),
     "slash-review": (True, ("host-review",)),
-    "onto": (True, ("onto",)),
-    "ultracode": (True, ("ultracode-for-codex",)),
-    "hybrid": (True, ("onto", "ultracode-for-codex")),
+    "ultracode": (True, ("codex-exec",)),
 }
 
 
@@ -625,7 +766,7 @@ def legacy_review_plan(setup: str, family: str) -> ReviewPlan:
 # core and never configured — configuration names no MCP, CLI, API, or subagent.
 #
 # Stage 3 is the falsifying stage: if a shipped method needed an `if method ==
-# "onto"` branch anywhere below, the seam would be wrong. There is deliberately no
+# "codex-exec"` branch anywhere below, the seam would be wrong. There is deliberately no
 # such branch, and gates/check_parity.py proves it by projecting a method whose name
 # is generated at runtime and appears in no source file.
 
@@ -746,10 +887,10 @@ def parse_review_method(method_id: str, raw: Any, context: str) -> ReviewMethod:
     # Two separate facts, and the gap between them is where a wrong map hid. `emits` is a
     # claim about the WORLD — what this tool actually reports — and only someone who knows
     # the tool can supply it. `severity_map` is OUR decision about how to translate it.
-    # With the map alone, "is this complete?" is undecidable: the shipped ultracode
-    # descriptor carried the canonical ladder copied from the panel, mapping not one of
-    # the P0..P3 values the tool really emits, and nothing could tell that from a correct
-    # identity map like onto's — whose vocabulary genuinely IS the ladder.
+    # With the map alone, "is this complete?" is undecidable: a shipped descriptor once
+    # carried the canonical ladder copied from the panel, mapping not one of the P0..P3
+    # values its tool really emitted, and nothing could tell that from a correct
+    # identity map whose vocabulary genuinely IS the ladder.
     severity_emits = raw.get("severity_emits")
     if (
         not isinstance(severity_emits, list)
@@ -2028,16 +2169,11 @@ def load_config(path: pathlib.Path) -> dict[str, Any]:
         hint = capability.get("install")
         if hint is not None and (not isinstance(hint, str) or not hint):
             raise LaunchError(f"capabilities.{name}.install must be a non-empty string")
-    onto = capabilities.get("onto")
-    if onto is not None and (
-        not isinstance(onto.get("command"), str) or not onto["command"]
-    ):
-        raise LaunchError("capabilities.onto.command must be a non-empty string")
-    ultracode = capabilities.get("ultracode-for-codex")
-    if ultracode is not None and (
-        not isinstance(ultracode.get("command"), str) or not ultracode["command"]
+    codex_exec = capabilities.get("codex-exec")
+    if codex_exec is not None and (
+        not isinstance(codex_exec.get("command"), str) or not codex_exec["command"]
     ):
-        raise LaunchError("capabilities.ultracode-for-codex.command must be a non-empty string")
+        raise LaunchError("capabilities.codex-exec.command must be a non-empty string")
     for host_name, host_data in data["hosts"].items():
         if not isinstance(host_data, dict):
             raise LaunchError(f"host must be a table: {host_name}")
@@ -2050,40 +2186,7 @@ def load_config(path: pathlib.Path) -> dict[str, Any]:
             raise LaunchError(
                 f"hosts.{host_name}.models must be a non-empty list of strings"
             )
-        onto_review = host_data.get("onto_review")
-        if onto_review is not None:
-            if not isinstance(onto_review, dict):
-                raise LaunchError(f"hosts.{host_name}.onto_review must be a table")
-            if onto_review.get("provider") not in ONTO_PROVIDERS:
-                choices = ", ".join(sorted(ONTO_PROVIDERS))
-                raise LaunchError(
-                    f"hosts.{host_name}.onto_review.provider must be one of: {choices}"
-                )
-            if not isinstance(onto_review.get("model"), str) or not onto_review["model"]:
-                raise LaunchError(
-                    f"hosts.{host_name}.onto_review.model must be a non-empty string"
-                )
-            # The cross contract names the family of the review HOST while the override
-            # takes its provider from this pin, so pinning another provider makes the
-            # contract contradict itself — it says "run EVERY review route on
-            # Anthropic/Claude" and hands the reviewer a grok seat. Fail closed rather
-            # than advertise a family the review does not run on. Conditional because
-            # hosts.<h>.provider is optional on purpose (see below): a profile that never
-            # declares one is not asked to prove a match it cannot express.
-            host_provider = host_data.get("provider")
-            if (
-                isinstance(host_provider, str)
-                and host_provider
-                and onto_review["provider"] != host_provider
-            ):
-                raise LaunchError(
-                    f"hosts.{host_name}.onto_review.provider is {onto_review['provider']!r} "
-                    f"but that host speaks for {host_provider!r}; a cross-family contract "
-                    f"names the host's family, so an onto seat on another provider would "
-                    f"advertise a family it does not run on"
-                )
-        # OPTIONAL on purpose. Distinct from onto_review.provider (which pins what onto
-        # is *told* to run), this is the host's own family identity. Every schema-v1
+        # OPTIONAL on purpose. This is the host's own family identity. Every schema-v1
         # profile written before it existed omits it, and requiring it would reject
         # those profiles during load — before any preset is even selected, so a
         # legacy-only config would stop launching at all. A host without a provider
@@ -2093,12 +2196,11 @@ def load_config(path: pathlib.Path) -> dict[str, Any]:
         if provider is not None and (not isinstance(provider, str) or not provider):
             raise LaunchError(f"hosts.{host_name}.provider must be a non-empty string")
         # A host whose legacy family is hardcoded may only declare the provider that
-        # family IS. Checking the onto pin against this host's own declaration is not
-        # enough on its own: declare `hosts.claude.provider = "grok"` with a matching
-        # pin and the two agree while the contract still prints "run EVERY review route
-        # on Anthropic/Claude" over a grok seat. Anchoring to LEGACY_HOST_FAMILY closes
-        # that, because the sentence and the provider now read from one place. Still
-        # only when declared — the field stays optional for schema-v1 profiles.
+        # family IS: declare `hosts.claude.provider = "grok"` and the cross contract
+        # still prints "run EVERY review route on Anthropic/Claude" over a grok seat.
+        # Anchoring to LEGACY_HOST_FAMILY closes that, because the sentence and the
+        # provider now read from one place. Still only when declared — the field stays
+        # optional for schema-v1 profiles.
         if provider is not None and host_name in LEGACY_HOST_FAMILY:
             expected = LEGACY_HOST_FAMILY[host_name][1]
             if provider != expected:
@@ -2210,11 +2312,15 @@ def cross_helm_command(plan: dict[str, Any]) -> str | None:
 
 
 def cross_ultracode_command(plan: dict[str, Any]) -> str | None:
-    """The cross-family ultracode reviewer command, or None. For a claude main it
-    is the Codex-backed ultracode-for-codex (the $ultracode-for-codex skill); for
-    a codex main it is the claude backend (Claude Code /workflows ultracode)."""
+    """The cross-family deep reviewer command, or None. For a claude main it is
+    the Codex CLI itself (codex-exec, non-interactive exec mode); for a codex
+    main it is the claude backend (Claude Code /workflows ultracode)."""
     if plan["review_host"] == "codex":
-        value = plan.get("capabilities", {}).get("ultracode-for-codex", {}).get("command", "")
+        # Through capability_command, because the shipped codex-exec command is
+        # `${backend}` — rereading the raw value would resolve the literal token.
+        value = capability_command(
+            plan.get("capabilities", {}).get(LEGACY_ULTRACODE_CAPABILITY, {}), plan, "codex"
+        )
     else:
         value = plan["review_backend"]
     try:
@@ -2225,24 +2331,24 @@ def cross_ultracode_command(plan: dict[str, Any]) -> str | None:
 
 def route_availability(plan: dict[str, Any]) -> dict[str, bool]:
     """Which review routes can run right now. In same-family mode native gates on
-    delegation and onto/ultracode on a resolvable capability. In cross-family mode
-    native/ultracode gate on the opposite-family dispatcher resolving, and onto on
-    a mounted onto plus a review_onto pin to flip its family."""
+    delegation and ultracode on a resolvable capability. In cross-family mode
+    native/ultracode gate on the opposite-family dispatcher resolving."""
     capabilities = plan.get("capabilities", {})
     if plan.get("review_family", "cross") == "same":
         available = {"native": bool(plan["delegation"]), "slash": True}
-        for route, capability in LEGACY_ROUTE_CAPABILITY.items():
-            available[route] = _resolves(capabilities.get(capability, {}).get("command", ""))
+        for route, capability_id in LEGACY_ROUTE_CAPABILITY.items():
+            # Through capability_commands, because the shipped codex-exec command is
+            # `${backend}`: the raw value is a token, not something PATH can answer.
+            available[route] = any(
+                _resolves(command)
+                for command in capability_commands(capabilities.get(capability_id, {}), plan)
+            )
         return available
-    onto_ok = _resolves(capabilities.get("onto", {}).get("command", "")) and bool(
-        plan.get("review_onto")
-    )
     return {
         "native": cross_native_command(plan) is not None,
         # The host's own review command exists, but only for its own family; the
         # cross branch of effective_review routes it to the PROPOSED floor.
         "slash": True,
-        "onto": onto_ok,
         "ultracode": cross_ultracode_command(plan) is not None,
     }
 
@@ -2960,10 +3066,9 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         # Cross review needs the opposite host + backend; without them fall back to
         # same-family review (surfaced as review_family=same) rather than crashing.
         review_family = "same"
-        review_tiers, review_onto, review_backend = {}, None, ""
+        review_tiers, review_backend = {}, ""
     else:
         review_tiers = copy.deepcopy(opposite["tiers"])
-        review_onto = copy.deepcopy(opposite.get("onto_review"))
         review_backend = opposite_backend["command"]
     return {
         "host": host,
@@ -2991,7 +3096,6 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         "review_family": review_family,
         "review_host": review_host,
         "review_tiers": review_tiers,
-        "review_onto": review_onto,
         "review_backend": review_backend,
         "agent_templates": copy.deepcopy(config["hosts"][host].get("agent_templates")),
         "capabilities": copy.deepcopy(config.get("capabilities", {})),
@@ -3335,6 +3439,336 @@ def method_availability(method: ReviewMethod, config: dict[str, Any]) -> str:
     return method.description
 
 
+USER_METHODS_HEADER = (
+    "# agent-launch user review methods (and the capabilities they drive).\n"
+    "# Merged at launch and validated exactly like shipped entries; never\n"
+    "# deployed or overwritten by agent-bios install. A name that collides\n"
+    "# with a shipped one is refused at launch rather than preferred.\n"
+)
+
+
+def _toml_str(value: str) -> str:
+    """Deterministic TOML string: JSON escaping is a valid TOML basic string."""
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _toml_str_list(values: list[str]) -> str:
+    return "[" + ", ".join(_toml_str(v) for v in values) + "]"
+
+
+def _render_registration(answers: dict[str, Any]) -> str:
+    """The candidate's TOML block. Serialization only — every judgement about the
+    content belongs to the reader that will accept or refuse it."""
+    lines = [""]
+    if answers.get("capability"):
+        cap = answers["capability"]
+        lines += [f"[capabilities.{cap['name']}]", f"command = {_toml_str(cap['command'])}"]
+        if cap.get("install"):
+            lines.append(f"install = {_toml_str(cap['install'])}")
+        lines.append(
+            "offers = [{ operation = " + _toml_str(cap["operation"])
+            + ", adapter = " + _toml_str(cap["adapter"])
+            + ", hosts = " + _toml_str_list(cap["hosts"]) + " }]"
+        )
+        lines.append("")
+    lines += [
+        f"[review_methods.{answers['id']}]",
+        f"label = {_toml_str(answers['label'])}",
+        f"description = {_toml_str(answers['description'])}",
+    ]
+    if answers.get("capability"):
+        lines += [
+            f"capability = {_toml_str(answers['capability']['name'])}",
+            f"operation = {_toml_str(answers['capability']['operation'])}",
+        ]
+    lines += [
+        f"instructions = {_toml_str(answers['instructions'])}",
+        'output = "review-v1"',
+        f"perspectives = {_toml_str_list(answers['perspectives'])}",
+        f"trials = {answers['trials']}",
+        'order = "fixed"',
+        "swap_augmentation = false",
+        'aggregation = "union"',
+        f"severity_emits = {_toml_str_list(answers['severity_emits'])}",
+        "severity_map = { "
+        + ", ".join(
+            f"{_toml_str(k)} = {_toml_str(v)}" for k, v in answers["severity_map"].items()
+        )
+        + " }",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _trial_registration(
+    config_path: pathlib.Path, block: str
+) -> str | None:
+    """Prove the candidate through the REAL pipeline: a temp dir holding a copy of
+    the live config plus the user's local files with the block appended, run
+    through the genuine load_config — same merge order, same validation, same
+    collision refusal. Returns None on acceptance, the reader's message on refusal."""
+    trial = pathlib.Path(tempfile.mkdtemp(prefix="agent-launch-register-"))
+    shutil.copy(config_path, trial / config_path.name)
+    for sibling in (USER_PRESETS_NAME, USER_LAUNCHER_NAME):
+        source = config_path.with_name(sibling)
+        if source.is_file():
+            shutil.copy(source, trial / sibling)
+    methods_source = user_methods_path(config_path)
+    existing = methods_source.read_text() if methods_source.is_file() else USER_METHODS_HEADER
+    candidate = trial / USER_METHODS_NAME
+    candidate.write_text(existing + block)
+    candidate.chmod(0o600)
+    try:
+        load_config(trial / config_path.name)
+    except LaunchError as exc:
+        return str(exc)
+    return None
+
+
+def register_reviewer_wizard(
+    ui: TextualUI | None,
+    config_path: pathlib.Path,
+    config: dict[str, Any],
+    registry: dict[str, Any],
+) -> bool:
+    """Guided, ADD-ONLY registration into the user-owned methods file.
+
+    The wizard owns questions and serialization and nothing else: the only
+    validity oracle is the real reader, run over a trial copy before a byte is
+    written. Refusal shows the reader's own message and keeps the answers for
+    another pass; nothing lands until the trial is green, and the write is an
+    append through an atomic replace so the user's own formatting survives.
+    Editing or removing entries stays a hand edit of the named file."""
+    answers: dict[str, Any] = {}
+    target = user_methods_path(config_path)
+    while True:
+        try:
+            answers["id"] = prompt_text(
+                t("wizard.id.label"), answers.get("id", "my-reviewer"), ui
+            )
+            answers["label"] = prompt_text(
+                t("wizard.label.label"), answers.get("label", "My reviewer"), ui
+            )
+            answers["description"] = prompt_text(
+                t("wizard.description.label"),
+                answers.get("description", "Registered by the guided flow."), ui,
+            )
+            drives = choose(
+                t("wizard.drives.title"),
+                [
+                    MenuOption("tool", t("wizard.drives.tool.label"),
+                               t("wizard.drives.tool.description")),
+                    MenuOption("panel", t("wizard.drives.panel.label"),
+                               t("wizard.drives.panel.description")),
+                ],
+                "tool" if answers.get("capability") else "panel",
+                ui, allow_back=True,
+            )
+            if drives == "tool":
+                cap = answers.get("capability") or {}
+                cap["name"] = prompt_text(
+                    t("wizard.cap.name.label"), cap.get("name", answers["id"] + "-kit"), ui
+                )
+                cap["command"] = prompt_text(
+                    t("wizard.cap.command.label"), cap.get("command", cap["name"]), ui
+                )
+                install_line = prompt_text(
+                    t("wizard.cap.install.label"), cap.get("install") or "-", ui
+                )
+                cap["install"] = "" if install_line == "-" else install_line
+                cap["operation"] = prompt_text(
+                    t("wizard.cap.operation.label"), cap.get("operation", "vendor-review"), ui
+                )
+                cap["adapter"] = choose(
+                    t("wizard.cap.adapter.title"),
+                    [
+                        MenuOption(name, name, REVIEW_ADAPTERS[name])
+                        for name in sorted(REVIEW_ADAPTERS)
+                    ],
+                    cap.get("adapter", "exec-stdio-v1"), ui, allow_back=True,
+                )
+                hosts_pick = choose(
+                    t("wizard.cap.hosts.title"),
+                    [
+                        MenuOption("both", t("wizard.cap.hosts.both"), ""),
+                        MenuOption("codex", "codex", ""),
+                        MenuOption("claude", "claude", ""),
+                    ],
+                    "both", ui, allow_back=True,
+                )
+                cap["hosts"] = (
+                    ["codex", "claude"] if hosts_pick == "both" else [hosts_pick]
+                )
+                answers["capability"] = cap
+                answers.setdefault("perspectives", ["refutation"])
+                answers.setdefault("trials", 1)
+                default_instructions = "run {command} on {model}/{effort}"
+            else:
+                answers["capability"] = None
+                raw = prompt_text(
+                    t("wizard.perspectives.label"),
+                    ", ".join(answers.get("perspectives") or ["correctness", "refutation"]),
+                    ui,
+                )
+                answers["perspectives"] = [
+                    item.strip() for item in raw.split(",") if item.strip()
+                ]
+                while True:
+                    trials_raw = prompt_text(
+                        t("wizard.trials.label"), str(answers.get("trials", 2)), ui
+                    )
+                    try:
+                        answers["trials"] = int(trials_raw)
+                        break
+                    except ValueError:
+                        continue
+                default_instructions = (
+                    "dispatch {command} as a fresh read-only process for {trials} "
+                    "isolated passes over {perspectives} on {model}/{effort}"
+                )
+            answers["instructions"] = prompt_text(
+                t("wizard.instructions.label"),
+                answers.get("instructions", default_instructions), ui,
+            )
+            raw = prompt_text(
+                t("wizard.emits.label"),
+                ", ".join(answers.get("severity_emits") or SEVERITY_LADDER), ui,
+            )
+            answers["severity_emits"] = [
+                item.strip() for item in raw.split(",") if item.strip()
+            ]
+            mapping = {}
+            for value in answers["severity_emits"]:
+                if value in SEVERITY_LADDER:
+                    mapping[value] = value
+                    continue
+                mapping[value] = choose(
+                    t("wizard.map.title") + f" — {value}",
+                    [MenuOption(level, level, "") for level in SEVERITY_LADDER],
+                    "medium", ui, allow_back=True,
+                )
+            answers["severity_map"] = mapping
+        except BackRequested:
+            return False
+
+        block = _render_registration(answers)
+        # A symlinked methods file is written THROUGH, never replaced: os.replace
+        # on the link path would swap the link for a regular file and strand the
+        # canonical target. Resolved once; every later read/compare/write uses it.
+        write_target = (
+            target.resolve() if (target.exists() or target.is_symlink()) else target
+        )
+        existed = write_target.is_file()
+        # BYTES, captured BEFORE the trial: the write-time comparison against this
+        # is what catches a concurrent hand edit between proof and landing, and
+        # text-mode round-trips would silently normalize a CRLF file.
+        before = write_target.read_bytes() if existed else USER_METHODS_HEADER.encode()
+        verdict = _trial_registration(config_path, block)
+        if verdict is None:
+            confirm = choose(
+                t("wizard.confirm.title"),
+                [
+                    MenuOption("write", t("wizard.confirm.write.label"),
+                               t("wizard.confirm.write.description")),
+                    MenuOption("edit", t("wizard.confirm.edit.label"), ""),
+                ],
+                "write", ui, allow_back=True,
+                corpus_lines=[t("wizard.confirm.target") + f" {target}", *block.splitlines()],
+            )
+            if confirm == "edit":
+                continue
+            # The compare-and-replace is atomic under an exclusive lock, closing
+            # the recheck→replace window a bare comparison leaves open. The lock
+            # file is advisory and launcher-owned; hand edits do not take it, so
+            # the byte comparison inside the lock remains the real guard.
+            lock_path = write_target.with_name(write_target.name + ".lock")
+            # O_NOFOLLOW and no truncation: opening a lock path with "w" follows
+            # a planted symlink and truncates whatever it points at, merely by
+            # opening the wizard.
+            lock_fd = os.open(
+                lock_path, os.O_CREAT | os.O_WRONLY | os.O_NOFOLLOW, 0o600
+            )
+            with os.fdopen(lock_fd, "w") as lock_handle:
+                fcntl.flock(lock_handle, fcntl.LOCK_EX)
+                # Existence is part of the snapshot: a file created (or removed)
+                # since the trial must read as a race even when its bytes happen
+                # to equal the header the wizard would have invented.
+                if write_target.is_file() != existed:
+                    _corpus_info(ui, t("wizard.title"), [t("wizard.raced.line")],
+                                 back_hint=t("corpus.back.hint"))
+                    return False
+                current = (
+                    write_target.read_bytes() if write_target.is_file()
+                    else USER_METHODS_HEADER.encode()
+                )
+                if current != before:
+                    _corpus_info(ui, t("wizard.title"), [t("wizard.raced.line")],
+                                 back_hint=t("corpus.back.hint"))
+                    return False
+                mode = (write_target.stat().st_mode & 0o777) if existed else 0o600
+                temporary = write_target.with_name(
+                    f".{write_target.name}.{os.getpid()}.tmp"
+                )
+                temporary.write_bytes(before + block.encode())
+                temporary.chmod(mode)
+                os.replace(temporary, write_target)
+                # Unreachable while the trial is the real pipeline — and
+                # load-bearing exactly when it is not: a post-write failure must
+                # restore the pre-write state (bytes, mode, or ABSENCE) and say
+                # so, never leave a corrupt registry behind a green screen.
+                try:
+                    fresh = load_config(config_path)
+                except LaunchError:
+                    fresh = None
+                if fresh is None or answers["id"] not in load_review_methods(fresh):
+                    # Restore ONLY when the file still holds exactly our write:
+                    # unconditional rollback would destroy an edit that landed in
+                    # the meantime; if the bytes moved, the human owns the merge.
+                    current = (
+                        write_target.read_bytes() if write_target.is_file() else b""
+                    )
+                    if current != before + block.encode():
+                        _corpus_info(
+                            ui, t("wizard.title"), [t("wizard.postwrite.line")],
+                            back_hint=t("corpus.back.hint"),
+                        )
+                        return False
+                    if existed:
+                        restore = write_target.with_name(
+                            f".{write_target.name}.{os.getpid()}.restore"
+                        )
+                        restore.write_bytes(before)
+                        restore.chmod(mode)
+                        os.replace(restore, write_target)
+                    else:
+                        write_target.unlink(missing_ok=True)
+                    _corpus_info(ui, t("wizard.title"), [t("wizard.postwrite.line")],
+                                 back_hint=t("corpus.back.hint"))
+                    return False  # pre-write state restored above
+            config.clear()
+            config.update(fresh)
+            registry.clear()
+            registry.update(load_review_methods(config))
+            _corpus_info(
+                ui, t("wizard.title"),
+                [t("wizard.done.line") + f" {answers['id']}"],
+                back_hint=t("corpus.back.hint"),
+            )
+            return True
+        action = choose(
+            t("wizard.refused.title"),
+            [
+                MenuOption("edit", t("wizard.refused.edit.label"),
+                           t("wizard.refused.edit.description")),
+                MenuOption("contract", t("wizard.refused.contract.label"), ""),
+            ],
+            "edit", ui, allow_back=True,
+            corpus_lines=[t("wizard.refused.header"), "", *verdict.splitlines()],
+        )
+        if action == "contract":
+            register_reviewer_info(ui, config_path)
+
+
 def register_reviewer_info(ui: TextualUI | None, config_path: pathlib.Path) -> None:
     """Where a reviewer this launcher has never seen comes from.
 
@@ -3524,7 +3958,7 @@ def review_editor(
                     addable[0], ui, allow_back=True,
                 )
                 if method_id == REGISTER_REVIEWER:
-                    register_reviewer_info(ui, config_path)
+                    register_reviewer_wizard(ui, config_path, config, registry)
                     continue
             except BackRequested:
                 continue
@@ -3859,7 +4293,7 @@ def customize(
         missing = [
             route
             for route in REVIEW_ROUTES[name]
-            if route in ("onto", "ultracode") and not available_routes[route]
+            if route in LEGACY_ROUTE_CAPABILITY and not available_routes[route]
         ]
         if missing:
             note = "degrades to same-family native (PROPOSED)" if cross else "degrades to native"
@@ -4186,13 +4620,29 @@ def corpus_summary_lines(status: dict[str, Any] | None) -> list[str]:
         f"{name} {layers[name]}" for name in order if layers.get(name)
     ) or "none"
     by_status = status.get("summary", {}).get("by_status", {})
-    return [
+    lines = [
         head,
         f"Mechanisms       {layer_text}",
         f"Ledger           placed {by_status.get('placed', 0)} · "
         f"incubating {by_status.get('incubating', 0) + by_status.get('incubating-G', 0)} · "
         f"versions {len(status.get('versions', []))}",
     ]
+    domains = status.get("domains")
+    if isinstance(domains, dict):
+        applied = domains.get("applied")
+        lines.append(
+            "Domains          "
+            + ("(none selected yet)" if applied is None else ", ".join(applied) or "core+infra only")
+        )
+    last_apply = status.get("last_apply")
+    if isinstance(last_apply, dict) and last_apply.get("outcome") not in (None, "applied"):
+        # A failed apply must be loud on the panel, not a fact buried in a log:
+        # the deployed corpus and the requested selection disagree right now.
+        lines.append(
+            f"⚠ LAST APPLY {last_apply.get('outcome')} at {last_apply.get('at')} — "
+            f"requested: {', '.join(last_apply.get('requested') or []) or 'core+infra only'}"
+        )
+    return lines
 
 
 def _corpus_info(
@@ -4384,11 +4834,161 @@ def mode_default_preset(presets: dict[str, Any], mode: str) -> str | None:
     return names[0] if names else None
 
 
+class CorpusApplyRequested(Exception):
+    """Raised out of the interactive flow when the user confirms a corpus
+    selection: the Textual app must be torn down before the installer owns the
+    terminal, so the request travels as control flow and main() runs the apply
+    in the plain terminal, then re-enters the picker."""
+
+    def __init__(self, selection: list[str]):
+        super().__init__(",".join(selection))
+        self.selection = selection
+
+
+CORPUS_OPTION = "__corpus__"
+# A plain value, because the numbered prompt prints it as the default label.
+# Collision with a domain id is structurally impossible: domain slugs come from
+# compose/domains.json, which this repo owns and which carries no "apply".
+CORPUS_APPLY = "apply"
+
+
+def run_corpus_apply(selection: list[str]) -> None:
+    """Run the installer's onboard loop for the selection, in the caller's
+    terminal. The installer alone deploys, canaries, and records the outcome;
+    this function only streams it and reports the exit."""
+    status = load_corpus_status() or {}
+    domains = ",".join(selection) if selection else "none"
+    front = shutil.which("agent-bios")
+    if front:
+        argv = [front, "onboard", "--domains", domains]
+    else:
+        repo = status.get("repo") or ""
+        installer = pathlib.Path(repo) / "install.sh" if repo else None
+        if installer is None or not installer.is_file():
+            print(
+                "agent-launch: no agent-bios on PATH and no usable repo in "
+                f"corpus-status.json; run manually: agent-bios onboard --domains {domains}",
+                file=sys.stderr,
+            )
+            return
+        argv = ["bash", str(installer), "onboard", "--domains", domains]
+    print(f"\nagent-launch: applying corpus selection: {' '.join(argv)}\n", flush=True)
+    proc = subprocess.run(argv)
+    if proc.returncode != 0:
+        print(
+            f"\nagent-launch: corpus apply FAILED (exit {proc.returncode}); the "
+            "corpus panel shows the recorded outcome.", file=sys.stderr,
+        )
+    else:
+        print("\nagent-launch: corpus selection applied.", flush=True)
+
+
+def corpus_checklist(ui: "TextualUI | None") -> None:
+    """Toggle-and-apply loop over the optional domain packages.
+
+    The list and the applied set come from corpus-status.json — the installer's
+    projection — never from repo paths this launcher cannot know. Selection state
+    lives only on this screen; Apply hands the exact set to the installer
+    (raising through the Textual app so the terminal is free), and Esc leaves the
+    deployed corpus untouched."""
+    status = load_corpus_status()
+    domains = (status or {}).get("domains")
+    if not isinstance(domains, dict) or not isinstance(domains.get("available"), list):
+        _corpus_info(
+            ui, t("corpus.title"),
+            [t("corpus.unavailable.line1"), t("corpus.unavailable.line2")],
+            back_hint=t("corpus.back.hint"),
+        )
+        return
+    available = domains["available"]
+    applied_raw = domains.get("applied")
+    # None is "never selected", [] is a verified core+infra-only selection —
+    # the projection keeps them distinct, so the Apply rule must too: a
+    # first-time user applying core+infra only IS a change.
+    applied = set(applied_raw or [])
+    never_applied = applied_raw is None
+    toggles = set(applied)
+    while True:
+        options = [
+            MenuOption(
+                name,
+                f"[{'x' if name in toggles else ' '}] {name}",
+                t("corpus.toggle.description"),
+            )
+            for name in available
+        ]
+        changed = toggles != applied or never_applied
+        pending = "" if not changed else (
+            " → " + (", ".join(sorted(toggles)) or "core+infra only")
+        )
+        options.append(
+            MenuOption(
+                CORPUS_APPLY,
+                t("corpus.apply.label") + pending,
+                t("corpus.apply.description"),
+                enabled=changed,
+                unavailable_reason=t("corpus.apply.unchanged"),
+            )
+        )
+        try:
+            choice = choose(
+                t("corpus.title"), options, CORPUS_APPLY, ui, allow_back=True,
+                corpus_lines=[t("corpus.core.line"), *corpus_summary_lines(status)],
+            )
+        except BackRequested:
+            return
+        if choice == CORPUS_APPLY:
+            selection = sorted(toggles)
+            if ui is None:
+                run_corpus_apply(selection)
+                return
+            raise CorpusApplyRequested(selection)
+        if choice in toggles:
+            toggles.discard(choice)
+        else:
+            toggles.add(choice)
+
+
+LANGUAGE_OPTION = "__language__"
+# Language names render in their own language BY DESIGN — a reader hunting for
+# their language must be able to recognise it whatever UI language is active — so
+# these labels are deliberately catalog-independent.
+I18N_DISPLAY = {"en": "English", "ko": "한국어", "ja": "日本語"}
+
+
+def choose_language(
+    config_path: pathlib.Path | None, ui: "TextualUI | None"
+) -> None:
+    """Pick and persist the UI language, then reload the catalogs so the
+    menu the user returns to already speaks the choice."""
+    if config_path is None:
+        return
+    descriptions = {
+        "en": t("language.en.description"),
+        "ko": t("language.ko.description"),
+        "ja": t("language.ja.description"),
+    }
+    options = [
+        MenuOption(code, I18N_DISPLAY[code], descriptions[code])
+        for code in I18N_LANGUAGES
+    ]
+    try:
+        picked = choose(
+            t("language.title"), options, ui_language(config_path), ui,
+            allow_back=True,
+        )
+    except BackRequested:
+        return
+    save_language(config_path, picked)
+    load_catalogs(config_path)
+
+
 def pick_mode_and_preset(
     config: dict[str, Any],
     host: str,
     ui: TextualUI | None,
     resume_mode: str | None,
+    config_path: pathlib.Path | None = None,
 ) -> tuple[str, bool, str]:
     """Root menu: a 3-way mode picker (Software Engineer / Builder / Session
     distill), then that mode's preset submenu (Software Engineer and Builder
@@ -4405,26 +5005,31 @@ def pick_mode_and_preset(
     while True:
         if mode is None:
             mode_options = [
-                MenuOption(
-                    SWE_MODE,
-                    "Software Engineer",
-                    "Repo-scoped work that defers to the project's own "
-                    "AGENTS.md/CLAUDE.md: a bare Vanilla session, or Custom to "
-                    "configure one.",
-                ),
+                MenuOption(SWE_MODE, t("mode.swe.label"), t("mode.swe.description")),
                 MenuOption(
                     DEFAULT_PRESET_MODE,
-                    "Builder",
-                    "Tune tiers, review routes, and permissions across fixed "
-                    "presets; includes Custom.",
+                    t("mode.builder.label"),
+                    t("mode.builder.description"),
                 ),
                 MenuOption(
                     DISTILL_MODE,
-                    "Session distill",
-                    "Enter the dedicated session-distill hub: status, "
-                    "packages, versions, and session start.",
+                    t("mode.distill.label"),
+                    t("mode.distill.description"),
                 ),
             ]
+            mode_options.append(
+                MenuOption(
+                    CORPUS_OPTION, t("corpus.label"), t("corpus.description")
+                )
+            )
+            if config_path is not None:
+                mode_options.append(
+                    MenuOption(
+                        LANGUAGE_OPTION,
+                        t("language.label"),
+                        t("language.description"),
+                    )
+                )
 
             def preview_mode(value: str) -> dict[str, Any] | None:
                 target = (
@@ -4438,13 +5043,21 @@ def pick_mode_and_preset(
             if ui is not None and initial is not None:
                 ui.set_plan(initial)
             mode = choose(
-                "Mode",
+                t("mode.title"),
                 mode_options,
                 DEFAULT_PRESET_MODE,
                 ui,
                 preview=preview_mode,
                 corpus_lines=corpus_summary_lines(load_corpus_status()),
             )
+        if mode == CORPUS_OPTION:
+            corpus_checklist(ui)
+            mode = None
+            continue
+        if mode == LANGUAGE_OPTION:
+            choose_language(config_path, ui)
+            mode = None
+            continue
         if mode == DISTILL_MODE:
             if distill_hub(config, ui) != "start":
                 mode = None
@@ -4511,7 +5124,7 @@ def select_plan(
         selected_custom = custom_requested
         if show_picker:
             selected_name, selected_custom, resume_mode = pick_mode_and_preset(
-                config, host, ui, resume_mode
+                config, host, ui, resume_mode, config_path
             )
         if selected_name not in presets:
             raise LaunchError(f"unknown preset: {selected_name}")
@@ -4605,7 +5218,16 @@ def _same_review_route(plan: dict[str, Any], effective: list[str], dropped: list
         if isinstance(route, dict):
             route = route[plan["host"]]
     if "ultracode" in effective:
-        route = f"{route} Ultracode executable: {resolve_command(plan['capabilities'][LEGACY_ULTRACODE_CAPABILITY]['command'])}."
+        # Through capability_commands: the shipped codex-exec command is `${backend}`,
+        # and route_availability has already proven one of these resolves.
+        executable = next(
+            resolve_command(command)
+            for command in capability_commands(
+                plan["capabilities"].get(LEGACY_ULTRACODE_CAPABILITY, {}), plan
+            )
+            if _resolves(command)
+        )
+        route = f"{route} Deep-exec executable: {executable}."
     if "ultracode" in REVIEW_ROUTES[requested]:
         route = (
             f"{route} If the Codex-backed route is unavailable or unauthenticated "
@@ -4635,7 +5257,7 @@ def _cross_review_route(
         native = cross_native_command(plan)
         if review_host == "codex":
             helm = cross_helm_command(plan)
-            fanout = f" (or {helm} --mode review for hybrid fan-out)" if helm else ""
+            fanout = f" (or {helm} --mode review for review fan-out)" if helm else ""
             parts.append(
                 f"native: dispatch {native} --profile hermetic --model <review tier> "
                 f"--effort <e> --sandbox read-only{fanout}, self-contained packet on stdin, "
@@ -4647,31 +5269,19 @@ def _cross_review_route(
                 "--permission-mode plan --append-system-prompt <read-only reviewer role>, "
                 "self-contained packet, bounded report."
             )
-    if "onto" in effective:
-        onto = plan["review_onto"]
-        # Neither `auth` nor `effort`, both deliberately. onto's per-call override
-        # REPLACES a seat whose route differs and OVERLAYs one whose route matches,
-        # so a field stated here wins over the user's own onto settings.
-        #
-        # auth: onto selects the metered route only when a seat says so in writing —
-        # either `auth = "api_key"` or an `api_key_env` naming the variable to call —
-        # and defaults to the subscription worker otherwise. So an omitted auth cannot
-        # land on metered, and stating one only overrides a user who chose it: the
-        # switch to oauth is a route change, which drops their api_key_env with it.
-        #
-        # effort: a legacy setup names no reviewer effort at all (the enum hands the
-        # reader the whole tier table), so there is none to state, and inventing one
-        # would flatten every per-seat effort the user tuned.
-        parts.append(
-            f'onto: call onto_review/onto_prepare_review with llmOverride='
-            f'{{"provider":"{onto["provider"]}","model":"{onto["model"]}"}} so onto runs {review_family}.'
-        )
     if "ultracode" in effective:
         ultracode = cross_ultracode_command(plan)
         if review_host == "codex":
+            # `ultra` is the mechanism, not a seat binding: the whole point of this
+            # route is the deepest single pass, so the effort is stated as a literal
+            # the way the claude arm states its keyword. The model stays the review
+            # host's own frontier tier — the seat table remains the model authority.
+            deep_model = plan["review_tiers"].get("frontier", {}).get("model", "<frontier model>")
             parts.append(
-                f"ultracode: run {ultracode} (the $ultracode-for-codex Codex skill) "
-                f"for {review_family} workflow-orchestration review."
+                f'deep exec: run {ultracode} exec -s read-only -m {deep_model} '
+                f'-c model_reasoning_effort="ultra" with a self-contained review packet '
+                f"on stdin for {review_family} deep review (append -c "
+                f'service_tier="fast" only when a faster, shallower pass is explicitly wanted).'
             )
         else:
             parts.append(
@@ -4680,13 +5290,7 @@ def _cross_review_route(
                 "workflow-orchestration review."
             )
     if dropped:
-        detail = [
-            f"onto (add a [hosts.{review_host}].onto_review pin)"
-            if route == "onto" and not plan.get("review_onto")
-            else route
-            for route in dropped
-        ]
-        parts.append(f"Unavailable cross-family route(s) at launch: {', '.join(detail)}.")
+        parts.append(f"Unavailable cross-family route(s) at launch: {', '.join(dropped)}.")
     if floor == "native":
         parts.append(
             "No cross-family route resolved at launch; using same-family native "
@@ -4808,10 +5412,9 @@ def review_mcp_servers(plan: dict[str, Any]) -> list[tuple[str, str]]:
     a method's identity, so a third-party method reusing the tag is wired too."""
     report = plan.get("review_report")
     if report is None:
-        effective, _, _ = effective_review(plan)
-        if "onto" not in effective:
-            return []
-        return [("onto", resolve_command(plan["capabilities"]["onto"]["command"]))]
+        # No legacy route is MCP-backed: both deep routes are host CLIs dispatched
+        # as subprocesses, so a legacy plan registers nothing.
+        return []
     # One entry per capability AND HOST, in first-selected order. Two methods may share a
     # capability, and appending per row registered it twice — visible on codex as
     # duplicated -c overrides and invisible on claude, whose dict collapsed them. Keying on
@@ -5239,6 +5842,11 @@ def main(argv: list[str]) -> int:
         exec_backend(command, [*passthrough, *args.forward])
 
     interactive_setup = not args.preset or args.custom
+    if interactive_setup:
+        # UI text catalogs feed only interactive screens; headless runs (dry-run,
+        # --preset) render no interface text and must not gain a stderr notice from a
+        # fixture directory that ships no catalogs.
+        load_catalogs(config_path)
     use_textual = (
         interactive_setup
         and tty
@@ -5252,14 +5860,23 @@ def main(argv: list[str]) -> int:
                 "agent-launch: rich terminal UI unavailable; using numbered prompts.",
                 file=sys.stderr,
             )
-    if use_textual:
-        plan = run_textual_flow(
-            config, args.host, args.preset, args.custom, config_path
-        )
-    else:
-        plan = select_plan(
-            config, args.host, args.preset, args.custom, config_path=config_path
-        )
+    while True:
+        try:
+            if use_textual:
+                plan = run_textual_flow(
+                    config, args.host, args.preset, args.custom, config_path
+                )
+            else:
+                plan = select_plan(
+                    config, args.host, args.preset, args.custom, config_path=config_path
+                )
+            break
+        except CorpusApplyRequested as request:
+            # The Textual app is already torn down; the installer owns the
+            # terminal for the duration, and the picker re-opens on a fresh
+            # status projection afterwards.
+            run_corpus_apply(request.selection)
+            continue
     validate_review_setup(plan)
     projected = [*project_args(plan, materialize_agents=not args.dry_run), *args.forward]
     summary_stream = sys.stdout if tty or args.dry_run else sys.stderr