agent-bios 0.14.0 → 0.16.0

package/launch/agent-launch.py

@@ -16,6 +16,7 @@ import string
 import subprocess
 import sys
 import tempfile
+import time
 import unicodedata
 import textwrap
 import tomllib
@@ -518,13 +519,17 @@ LEGACY_REVIEW_LOWERING = {
 
 @dataclass(frozen=True)
 class ReviewBinding:
-    """Which verifier adjudicates. `model` and `effort` are inseparable: a `tier`
-    reference satisfies that by construction, a bare `model` must carry its own."""
+    """Which verifier adjudicates.
+
+    Review plans normally carry a model/effort pair. A tier may resolve to a
+    no-effort model; the selected-row renderer names the ledger limitation before
+    that row could serialize an ambiguous null.
+    """
 
     provider: str
     host: str
     model: str
-    effort: str
+    effort: str | None
     service_tier: str = DEFAULT_SERVICE_TIER
     tier: str | None = None
 
@@ -677,11 +682,18 @@ def parse_review_binding(
     else:
         if not isinstance(raw["model"], str) or not raw["model"]:
             raise LaunchError(f"{context}.model must be a non-empty string")
-        if "effort" not in raw:
+        # Preserve the host-independent validation for an unseated binding. The
+        # one exception is the actual Claude Haiku seat; accepting omission for
+        # any arbitrary model merely because this profile lacks its host would
+        # defer a malformed review binding until a later machine gains that host.
+        is_haiku = provider == "anthropic" and raw["model"] == "claude-haiku-4-5"
+        if not is_haiku and "effort" not in raw:
             raise LaunchError(
                 f"{context}.effort is required with model: a model without an effort would "
                 "leave the verifier's rigour for the designer to pick at dispatch time"
             )
+        if is_haiku and "effort" in raw:
+            validate_effort("claude", raw["model"], raw["effort"], context)
     # Only now may an absent host end the parse. Everything above holds whatever hosts
     # exist, and leaving any of it below this line let a malformed binding through as
     # "unseated" — accepted today, rejected the day the host appears, and in the
@@ -716,7 +728,12 @@ def parse_review_binding(
     else:
         tier = None
         model = raw["model"]
-        effort = validate_effort(host, model, raw["effort"], context)
+        if model_requires_effort(host, model) and "effort" not in raw:
+            raise LaunchError(
+                f"{context}.effort is required with model: a model without an effort would "
+                "leave the verifier's rigour for the designer to pick at dispatch time"
+            )
+        effort = validate_effort(host, model, raw.get("effort"), context)
     return ReviewBinding(provider, host, model, effort, service_tier, tier)
 
 
@@ -888,6 +905,11 @@ def legacy_review_plan(setup: str, family: str) -> ReviewPlan:
     )
 
 
+def review_is_requested(review: ReviewPlan) -> bool:
+    """Whether this plan would project any review capability or availability claim."""
+    return review.source == "composable" or review.legacy_setup != "none"
+
+
 # ── review methods: the declarative surface (DESIGN.md §1) ──────────────────
 # A METHOD says how to review. A CAPABILITY says how an installed tool exposes an
 # operation. A BINDING says which verifier adjudicates. The MECHANISM is derived by
@@ -1554,6 +1576,11 @@ def render_review_method(
     discipline clause to every row, method-blind, the way the severity translation is
     appended — an author never writes it and a slot never carries it."""
     binding = mechanism.binding
+    if binding.effort is None:
+        raise LaunchError(
+            f"review method {method.method_id!r} cannot render {binding.model}: its "
+            "instruction and ReviewPlan/v1 seat require an explicit effort"
+        )
     slots = {
         "command": mechanism.command or "",
         "model": binding.model,
@@ -1607,7 +1634,7 @@ def render_review_method(
             )
     rendered = (
         f"{method.method_id}: {body} "
-        f"[{mechanism.shape}; {binding.model}/{binding.effort}"
+        f"[{mechanism.shape}; {format_model_effort(binding.model, binding.effort)}"
         f"{controls_clause(method)}{criterion_clause(criterion)}{severity_translation(method)}]"
     )
     # The assembled ROW, after the body. The body check above catches a SLOT value and says
@@ -1785,6 +1812,10 @@ def independence_grade(reviewer: ReviewBinding, main: ReviewBinding) -> str:
         return "provider_difference"
     if reviewer.model != main.model:
         return "model_difference"
+    # A no-effort seat is rejected before a composable review is serialized, but
+    # keep this grade total for direct callers and future structural readers.
+    if reviewer.effort is None or main.effort is None:
+        return "perspective_floor"
     if EFFORT_ORDER.index(reviewer.effort) > EFFORT_ORDER.index(main.effort):
         return "higher_effort"
     return "perspective_floor"
@@ -1844,7 +1875,8 @@ def _resolve_one(
         return ReviewMethodReport(
             method.method_id, STATUS_DROPPED, None,
             f"{detail}; it would have run on "
-            f"{binding.provider}:{binding.model}/{binding.effort} via {mechanism.adapter}",
+            f"{binding.provider}:{format_model_effort(binding.model, binding.effort)} "
+            f"via {mechanism.adapter}",
         )
     grade = independence_grade(binding, main)
     # Accumulated, not assigned: more than one of these can be true at once, and the
@@ -1975,7 +2007,10 @@ def render_review_report(report: ReviewReport) -> str:
         if row.grade:
             head += f"/{row.grade}"
         if row.model:
-            head += f" on {row.provider}:{row.model}/{row.effort} via {row.mechanism}"
+            head += (
+                f" on {row.provider}:{format_model_effort(row.model, row.effort)} "
+                f"via {row.mechanism}"
+            )
         if row.detail:
             head += f" — {row.detail}"
         lines.append(head)
@@ -4084,6 +4119,85 @@ def exec_backend(command: str, args: list[str], env: dict[str, str] | None = Non
     os.execve(command, [command, *args], os.environ.copy() if env is None else env)
 
 
+def private_corpus_enabled() -> bool:
+    explicit = os.environ.get("AGENT_BIOS_PRIVATE_CORPUS")
+    if explicit is not None:
+        return explicit == "1"
+    state = pathlib.Path(os.environ.get("AGENT_BIOS_STATE_DIR", str(pathlib.Path.home() / ".local/share/agent-bios")))
+    return (state / "runtime/private-install.json").is_file()
+
+
+def corpus_package_root() -> pathlib.Path:
+    explicit = os.environ.get("AGENT_BIOS_PACKAGE_ROOT")
+    if explicit:
+        return pathlib.Path(explicit).resolve()
+    source = pathlib.Path(__file__).resolve().parents[1]
+    if (source / "compose/corpus_store.py").is_file():
+        return source
+    state = pathlib.Path(os.environ.get("AGENT_BIOS_STATE_DIR", str(pathlib.Path.home() / ".local/share/agent-bios")))
+    try:
+        root = pathlib.Path(json.loads((state / "runtime/private-install.json").read_text())["package_root"])
+    except (OSError, ValueError, KeyError, TypeError) as exc:
+        raise LaunchError("private corpus runtime missing; run agent-bios install") from exc
+    if not (root / "compose/corpus_store.py").is_file():
+        raise LaunchError("private corpus runtime missing; run agent-bios install")
+    return root
+
+
+def corpus_store():
+    root = corpus_package_root()
+    module_root = str(root / "compose")
+    if module_root not in sys.path:
+        sys.path.insert(0, module_root)
+    from corpus_store import CorpusStore
+    return CorpusStore(root)
+
+
+def _corpus_generation(state_root: pathlib.Path, config_path: pathlib.Path) -> str:
+    paths = {state_root / "runtime/private-install.json", state_root / "runtime/state.json", config_path}
+    digest = hashlib.sha256()
+    for path in sorted(paths):
+        digest.update(str(path).encode() + b"\0")
+        digest.update(path.read_bytes() if path.is_file() else b"<absent>")
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _load_private_config(config_path: pathlib.Path, *, replay_only: bool = False):
+    """Read one coherent configuration; verify its generation again at activation."""
+    root = corpus_package_root()
+    module_root = str(root / "compose")
+    if module_root not in sys.path:
+        sys.path.insert(0, module_root)
+    from corpus_transaction import transaction_lock, guard_pending, confirmed_release, TransactionPendingError
+    state_root = corpus_store().state_root
+    with transaction_lock(state_root):
+        try:
+            guard_pending(state_root)
+        except TransactionPendingError:
+            if not replay_only:
+                raise
+            config_path = confirmed_release(state_root) / "launch/agent-launch.toml"
+        config = load_config(config_path)
+        return config, _corpus_generation(state_root, config_path)
+
+
+def _snapshot_from_config(store, config_path, generation, host, selected, *, dry_run, native):
+    from corpus_transaction import transaction_lock, guard_pending
+    with transaction_lock(store.state_root):
+        guard_pending(store.state_root)
+        if generation != _corpus_generation(store.state_root, config_path):
+            raise LaunchError("corpus installation or launch settings changed during setup; reopen the launcher")
+        return store.snapshot(host, selected, dry_run=dry_run, native=native)
+
+
+def open_corpus_studio() -> None:
+    root = corpus_package_root()
+    result = subprocess.run([sys.executable, str(root / "compose/corpus.py"), "--repo", str(root)])
+    if result.returncode:
+        print(f"agent-launch: Corpus Studio exited {result.returncode}", file=sys.stderr)
+
+
 def default_config_path() -> pathlib.Path:
     explicit = os.environ.get("AGENT_LAUNCH_CONFIG")
     if explicit:
@@ -4336,7 +4450,51 @@ def resolve_backend(config: dict[str, Any], host: str) -> tuple[str, list[str]]:
     return command, bare_value
 
 
-def validate_effort(host: str, model: str, effort: Any, context: str) -> str:
+def model_requires_effort(host: str, model: str) -> bool:
+    """Whether this concrete seat accepts the launcher's effort setting.
+
+    `effort` remains required for every supported model except Claude Haiku 4.5.
+    Its absence is a property of that model capability, not a third effort value.
+    """
+    return not (host == "claude" and model == "claude-haiku-4-5")
+
+
+def format_model_effort(model: str, effort: str | None, separator: str = "/") -> str:
+    """The display/contract spelling of a seat, without inventing an absent effort."""
+    return f"{model}{separator}{effort}" if effort is not None else model
+
+
+def binding_for_selected_model(
+    host: str,
+    binding: dict[str, Any],
+    model: str,
+    *,
+    default_effort: str | None = None,
+) -> dict[str, Any]:
+    """Return one editable tier binding after its model changes.
+
+    Crossing into Haiku removes the effort field. Crossing back starts at this
+    tier's configured default (or the host fallback) instead of retaining that
+    absence as an invalid pseudo-effort; other explicit effort choices are
+    preserved.
+    """
+    updated = {**binding, "model": model}
+    if model_requires_effort(host, model):
+        if updated.get("effort") is None:
+            updated["effort"] = default_effort or host_default_effort(host)
+    else:
+        updated.pop("effort", None)
+    return updated
+
+
+def validate_effort(host: str, model: str, effort: Any, context: str) -> str | None:
+    if not model_requires_effort(host, model):
+        if effort is not None:
+            raise LaunchError(
+                f"unsupported effort for {context}: {model} does not accept an effort; "
+                "remove the effort key"
+            )
+        return None
     if not isinstance(effort, str) or effort not in HOST_EFFORTS[host]:
         raise LaunchError(f"unsupported effort for {context}: {effort!r}")
     if host == "codex" and model == "gpt-5.6-luna" and effort == "ultra":
@@ -4516,6 +4674,11 @@ def plan_projects_nothing(plan: dict[str, Any]) -> bool:
     return plan.get("mode") == SWE_MODE
 
 
+def sweep_main(plan: dict[str, Any]) -> bool:
+    """Whether this launch's main is the deliberately read-only SWEEP seat."""
+    return plan["main_tier"] == "sweep"
+
+
 def active_tiers(plan: dict[str, Any]) -> tuple[str, ...]:
     """The tiers this launch actually binds, in TIER_ORDER: the main one, plus the
     children argv really carries.
@@ -4547,35 +4710,73 @@ def inactive_tier_reason(plan: dict[str, Any]) -> str:
     """Why the inactive tiers are inactive. Delegation-off removes every child at once
     and is reported as itself; otherwise the cause is that the main is not a spawnable
     tier's peer — the tier is neither this launch's main nor one of its children."""
+    if sweep_main(plan):
+        return "SWEEP main disables delegation to preserve its read-only one-rule-per-item boundary"
     if not plan["delegation"]:
         return "delegation is off"
     return f"the only spawnable child tiers are {', '.join(SPAWNABLE_TIERS)}"
 
 
+def setup_panel_column(label: str, width: int = 10) -> str:
+    """A label padded to the panel's value column, measured in terminal CELLS.
+
+    `f"{label:<10}"` pads by character count, so a translated label of three CJK glyphs
+    is padded as three and drawn as six — the value column moves for that row only."""
+    return label + " " * max(1, width - display_width(label))
+
+
 def setup_summary_lines(plan: dict[str, Any] | None) -> list[str]:
+    """The panel every screen carries at its top. Labels are translated; VALUES never
+    are — a host name, a model id, a tier slot, `on`/`off` are the words the user has to
+    find again in a config file or a CLI flag, and a screen that renames them makes the
+    two impossible to line up.
+
+    `inactive_tier_reason` stays English for a harder reason: `run_contract` renders the
+    same call, and a launch contract must not vary by UI language. It is a shared value,
+    not chrome, so it is passed through rather than translated."""
     if plan is None:
-        return ["No setup selected."]
+        return [t("setup.none")]
     if plan_projects_nothing(plan):
         return [
-            f"Host {plan['host']} | Preset {plan['label']}",
-            "Bare backend — no launch contract, no tier bindings, no review route,",
-            "no permission flag. The repo's own AGENTS.md/CLAUDE.md is all that applies.",
+            t("setup.host").format(host=plan["host"], preset=plan["label"]),
+            *t("setup.bare").split("\n"),
         ]
     host = plan["host"]
     execution = (
-        plan["codex_execution_policy"]
-        if host == "codex"
-        else plan["claude_permission_mode"]
+        "restricted"
+        if sweep_main(plan)
+        else (
+            plan["codex_execution_policy"]
+            if host == "codex"
+            else plan["claude_permission_mode"]
+        )
     )
     lines = [
-        f"Host {host} | Preset {plan['label']}",
+        t("setup.host").format(host=host, preset=plan["label"]),
         # A composable plan has no legacy name and printed the literal "None" here — the
         # same defect print_summary carried, in the one place a user reads before
         # launching. The legacy branch keeps emitting the raw setup value, byte for byte.
-        f"Main {plan['main_tier'].upper()} | Review "
-        f"{review_setup_label(plan) if plan.get('review_report') else plan['review_setup']}",
-        f"Delegation {'on' if plan['delegation'] else 'off'} | Execution {execution}",
+        t("setup.main").format(
+            tier=plan["main_tier"].upper(),
+            review=(review_setup_label(plan) if plan.get("review_report")
+                    else plan["review_setup"]),
+        ),
+        t("setup.delegation").format(
+            delegation="on" if plan["delegation"] else "off", execution=execution,
+        ),
     ]
+    if private_corpus_enabled():
+        lines.append(
+            setup_panel_column(t("setup.global-instructions.label"))
+            + " "
+            + t("global-instructions.summary").format(
+                choice=t(
+                    "global-instructions.include.label"
+                    if plan.get("include_global_instructions", True)
+                    else "global-instructions.exclude.label"
+                )
+            )
+        )
     for tier in active_tiers(plan):
         # The set run_contract, both argv builders and print_summary take. This panel
         # calls itself the "Current setup" and listed a binding row for every tier whatever
@@ -4584,10 +4785,10 @@ def setup_summary_lines(plan: dict[str, Any] | None) -> list[str]:
         # TUI and the Custom hub actually show (round 22, #8). With delegation ON it still
         # printed a HELM row under a non-HELM main, which nothing binds (round 23, #1).
         binding = plan["tiers"][tier]
-        effort = (
-            plan["frontier_effort"] if tier == "frontier" else binding["effort"]
+        lines.append(
+            f"{setup_panel_column(tier.upper())} "
+            f"{format_model_effort(binding['model'], tier_effort(plan, tier), ' · ')}"
         )
-        lines.append(f"{tier.upper():<10} {binding['model']} / {effort}")
     inactive = inactive_tiers(plan)
     if inactive:
         # Named rather than dropped, matching the contract's and the summary's wording, so
@@ -4595,8 +4796,11 @@ def setup_summary_lines(plan: dict[str, Any] | None) -> list[str]:
         # rather than "Children" because under delegation-on the one inactive tier is HELM,
         # which is precisely not a child.
         lines.append(
-            f"{'Inactive':<10} {', '.join(inactive)} — inactive, not projected because "
-            f"{inactive_tier_reason(plan)}"
+            setup_panel_column(t("setup.inactive.label"))
+            + " "
+            + t("setup.inactive.value").format(
+                tiers=", ".join(inactive), reason=inactive_tier_reason(plan),
+            )
         )
     return lines
 
@@ -4677,6 +4881,7 @@ def _build_app_class():
     from textual.screen import ModalScreen
     from textual.widgets import Input, OptionList, Static
     from textual.widgets.option_list import Option
+    from rich.text import Text
     from textual.theme import Theme
 
     # Host-matched palettes so the preflight reads as the CLI it launches.
@@ -4723,6 +4928,12 @@ def _build_app_class():
         border: round $secondary; border-title-color: $secondary;
         border-title-style: bold; padding: 0 1; height: 5;
     }
+    #al-detail-scroll {
+        border: round $secondary; border-title-color: $secondary;
+        border-title-style: bold; padding: 0 1;
+        height: auto; min-height: 5; max-height: 45vh;
+    }
+    #al-detail-scroll > #al-detail { border: none; padding: 0; height: auto; }
     #al-corpus-title { background: $warning; color: black; text-style: bold; padding: 0 1; }
     /* No cap and no scroller of its own: one nested scroll region inside another is a
        worse answer than a body that simply scrolls. */
@@ -4740,7 +4951,7 @@ def _build_app_class():
 
     def setup_panel(plan):
         panel = Static("\n".join(setup_summary_lines(plan)), id="al-setup")
-        panel.border_title = "Current setup"
+        panel.border_title = t("tui.setup.title")
         release = version_label()
         if release:
             panel.border_subtitle = release
@@ -4751,12 +4962,23 @@ def _build_app_class():
         # on_mount focuses the option list, whose Up/Down are the only movement keys the
         # footer advertises, and the body holds no focusable widget of its own. A scrollbar
         # that exists numerically is not a way for a keyboard user to read anything.
+        # One key, one meaning, across every screen: arrows navigate (left leaves this
+        # one), Enter decides, Space changes something that is not yet decided, Escape
+        # aborts. Escape used to mean "back" here, which made the abort key the same key
+        # as the one that goes up a level — a screen you cannot leave without deciding
+        # whether you are cancelling.
         BINDINGS = [
-            Binding("escape", "back", "back", priority=True),
+            Binding("left", "back", "back", priority=True),
+            Binding("space", "pick", "pick", priority=True),
+            Binding("escape", "cancel", "cancel", priority=True),
             Binding("q", "cancel", "cancel", priority=True),
             Binding("ctrl+c", "cancel", "cancel", priority=True),
             Binding("pagedown", "body_down", "scroll", priority=True),
             Binding("pageup", "body_up", "scroll", priority=True),
+            Binding("shift+pagedown", "detail_down", "details", priority=True),
+            Binding("shift+pageup", "detail_up", "details", priority=True),
+            Binding("j", "detail_down", "details", priority=True),
+            Binding("k", "detail_up", "details", priority=True),
         ]
 
         def _body(self):
@@ -4773,8 +4995,33 @@ def _build_app_class():
             if body is not None:
                 body.scroll_page_up(animate=False)
 
+        def action_detail_down(self):
+            self.query_one("#al-detail-scroll", VerticalScroll).scroll_page_down(animate=False)
+
+        def action_detail_up(self):
+            self.query_one("#al-detail-scroll", VerticalScroll).scroll_page_up(animate=False)
+
+        def _size_detail(self):
+            # A queued refresh can run after this screen has been dismissed and its
+            # children removed. Only the active, mounted screen owns layout work.
+            if not self.is_mounted or self.app.screen is not self:
+                return
+            # Keep navigation and a readable reference viewport available even when
+            # a long menu and a wrapped explanation compete for a short terminal.
+            reserved = 3 + sum(
+                self.query_one(selector).outer_size.height
+                for selector in ("#al-title", "#al-hdr", "#al-footer", "OptionList")
+            )
+            self.query_one("#al-detail-scroll").styles.max_height = max(
+                5, min(int(self.size.height * 0.45), self.size.height - reserved),
+            )
+
+        def on_resize(self):
+            self.call_after_refresh(self._size_detail)
+
         def __init__(
-            self, title, options, default, allow_back, plan, preview=None, corpus=None
+            self, title, options, default, allow_back, plan, preview=None, corpus=None,
+            confirm=None,
         ):
             super().__init__()
             self._title = title
@@ -4784,6 +5031,10 @@ def _build_app_class():
             self._plan = plan
             self._preview = preview
             self._corpus = corpus
+            # The value Enter decides on, for a screen whose rows are changes rather than
+            # choices. Without it Enter and Space would both mean "act on the highlighted
+            # row", and a checklist would have no key that means "I am done".
+            self._confirm = confirm
 
         def compose(self):
             yield Static(self._title, id="al-title")
@@ -4794,17 +5045,28 @@ def _build_app_class():
             with VerticalScroll(id=BODY_PANEL_ID):
                 yield setup_panel(self._plan)
                 if self._corpus:
-                    yield Static("Corpus status", id="al-corpus-title")
+                    yield Static(t("tui.corpus.title"), id="al-corpus-title")
                     yield Static("\n".join(self._corpus), id=CORPUS_PANEL_ID)
-            detail = Static("", id="al-detail")
-            detail.border_title = "About highlighted option"
+            detail = VerticalScroll(Static("", id="al-detail", markup=False), id="al-detail-scroll")
+            detail.border_title = t("tui.detail.title")
+            detail.border_subtitle = t("tui.detail.scroll")
             yield detail
             yield Static(
-                f"Options (1-{len(self._options)} of {len(self._options)})", id="al-hdr"
+                t("tui.options.header").format(count=len(self._options)), id="al-hdr"
             )
             option_list = OptionList()
             for option in self._options:
-                label = option.label + ("" if option.enabled else "  [unavailable]")
+                # A str prompt is parsed as markup, which eats any bracketed run that
+                # looks like a tag: `[x]` vanished while `[ ]` survived, so a selected
+                # row rendered blank and only a deselected one showed its box, and
+                # `[unavailable]` never reached the screen at all. A Text is rendered
+                # as written, and option labels carry manifest-supplied names this
+                # module does not control.
+                label = option.label
+                if not isinstance(label, Text):
+                    label = Text(label)
+                if not option.enabled:
+                    label = label + f"  [{t('prompt.unavailable').lower()}]"
                 option_list.add_option(
                     Option(label, id=option.value, disabled=not option.enabled)
                 )
@@ -4812,9 +5074,9 @@ def _build_app_class():
             # The panel keys are advertised only when there is a panel: a footer naming a
             # key that does nothing teaches the same wrong thing a screen stating an
             # unenforced rule does.
-            footer = "Up/Down move | Enter select | PgUp/PgDn scroll | "
-            footer += "Esc back | q cancel" if self._allow_back else "Esc cancel | q cancel"
-            yield Static(footer, id="al-footer")
+            yield Static(
+                menu_footer(self._allow_back, self._confirm is not None), id="al-footer"
+            )
 
         def on_mount(self):
             option_list = self.query_one(OptionList)
@@ -4844,8 +5106,10 @@ def _build_app_class():
             option = self._options[index]
             detail = option.description
             if not option.enabled and option.unavailable_reason:
-                detail = f"{detail} Unavailable: {option.unavailable_reason}"
+                detail = f"{detail} {t('prompt.unavailable')}: {option.unavailable_reason}"
             self.query_one("#al-detail", Static).update(detail)
+            self.query_one("#al-detail-scroll", VerticalScroll).scroll_home(animate=False)
+            self.call_after_refresh(self._size_detail)
             # Live-preview the highlighted option's effect in the setup panel.
             if self._preview is not None:
                 try:
@@ -4857,7 +5121,25 @@ def _build_app_class():
                     pass
 
         def on_option_list_option_selected(self, event):
-            self.dismiss(event.option.id)
+            # Enter. On a screen with a confirm target that target is the decision, so a
+            # row under the cursor is not what Enter acts on — Space is.
+            if self._confirm is None:
+                self.dismiss(event.option.id)
+                return
+            if any(
+                option.value == self._confirm and option.enabled
+                for option in self._options
+            ):
+                self.dismiss(self._confirm)
+
+        def action_pick(self):
+            option_list = self.query_one(OptionList)
+            index = option_list.highlighted
+            if index is None:
+                return
+            option = self._options[index]
+            if option.enabled and option.value != self._confirm:
+                self.dismiss(option.value)
 
         def action_back(self):
             self.dismiss(_UI_BACK if self._allow_back else _UI_CANCEL)
@@ -4881,8 +5163,8 @@ def _build_app_class():
             yield Static(self._label, id="al-title")
             yield setup_panel(self._plan)
             box = Static(
-                f"Current value: {self._default}\n"
-                "New value (leave blank to keep current):",
+                t("tui.input.current").format(value=self._default)
+                + "\n" + t("tui.input.new"),
                 id="al-detail",
             )
             # The screen already knows what it is asking for; it labelled every
@@ -4891,10 +5173,8 @@ def _build_app_class():
             box.border_title = self._label
             yield box
             yield Static("", id="al-hdr")
-            yield Input(placeholder="leave blank to keep the current value")
-            yield Static(
-                "Enter confirm | Esc/Ctrl-C cancel | q + Enter cancel", id="al-footer"
-            )
+            yield Input(placeholder=t("tui.input.placeholder"))
+            yield Static(t("tui.input.footer"), id="al-footer")
 
         def on_mount(self):
             self.query_one(Input).focus()
@@ -4971,11 +5251,13 @@ class TextualUI:
         allow_back: bool,
         preview=None,
         corpus_lines: list[str] | None = None,
+        confirm: str | None = None,
     ) -> str:
         result = self.app.call_from_thread(
             self.app.push_screen_wait,
             self._menu_screen(
-                title, options, default, allow_back, self.plan, preview, corpus_lines
+                title, options, default, allow_back, self.plan, preview, corpus_lines,
+                confirm,
             ),
         )
         if result == _UI_BACK:
@@ -5011,6 +5293,29 @@ def run_textual_flow(
     return value
 
 
+def menu_footer(allow_back: bool, confirm: bool) -> str:
+    """The key line under a menu, in the active language.
+
+    Built here rather than inline in the screen because two other things read it: the
+    picker scenarios use it to tell WHICH screen is drawn, and a leg asserts the forms
+    stay mutually exclusive and fit the terminal. A gate holding its own copy of this
+    string is a second authority that drifts; asking the launcher is not.
+
+    The key NAMES are not translated — you press Enter, not 입력 — so each catalog entry
+    is a key name and a verb, and only the verb moves."""
+    parts = [t("tui.key.move"), t("tui.key.apply") if confirm else t("tui.key.select")]
+    if confirm:
+        parts.append(t("tui.key.toggle"))
+    parts.append(t("tui.key.scroll"))
+    if allow_back:
+        parts.append(t("tui.key.back"))
+    # `q` stays advertised because `q` stays bound: dropping the notice for a key that
+    # still works teaches the same wrong thing as naming one that does not. The numbered
+    # renderer names the same key from the same entry.
+    parts += [t("tui.key.cancel"), t("prompt.cancel")]
+    return " | ".join(parts)
+
+
 def choose_lines(
     title: str,
     options: list[MenuOption],
@@ -5029,7 +5334,10 @@ def choose_lines(
         marker = "" if option.enabled else f" [{unavailable.lower()}]"
         selected = " *" if option.value == default and option.enabled else ""
         label = option.label
-        print(f"  {index}. {label}{marker}{selected} - {option.description}")
+        description = option.description.splitlines() or [""]
+        print(f"  {index}. {label}{marker}{selected} - {description[0]}")
+        for line in description[1:]:
+            print(f"     {line}")
         if not option.enabled:
             print(f"     {unavailable}: {option.unavailable_reason}")
     while True:
@@ -5065,11 +5373,14 @@ def choose(
     allow_back: bool = False,
     preview=None,
     corpus_lines: list[str] | None = None,
+    confirm: str | None = None,
 ) -> str:
     if not any(option.enabled for option in options):
         raise LaunchError(f"no available options for {title}")
     if ui is not None:
-        return ui.choose(title, options, default, allow_back, preview, corpus_lines)
+        return ui.choose(
+            title, options, default, allow_back, preview, corpus_lines, confirm
+        )
     return choose_lines(title, options, default, allow_back, corpus_lines)
 
 
@@ -5085,7 +5396,9 @@ def read_input(prompt: str) -> str:
 def prompt_text(label: str, default: str, ui: TextualUI | None = None) -> str:
     if ui is not None:
         return ui.prompt_text(label, default)
-    value = read_input(f"{label} [{default}] (q cancel): ").strip()
+    value = read_input(
+        t("prompt.text").format(label=label, default=default, cancel=t("prompt.cancel"))
+    ).strip()
     if value.lower() == "q":
         raise KeyboardInterrupt
     return value or default
@@ -5107,7 +5420,7 @@ def host_models(config: dict[str, Any], host: str, tiers: dict[str, Any]) -> lis
 
 def resolve_review_for_plan(
     review: ReviewPlan, config: dict[str, Any], host: str, main_model: str,
-    main_effort: str, context: str, criterion: bool = False,
+    main_effort: str | None, context: str, criterion: bool = False,
 ) -> tuple[dict, "ReviewReport | None"]:
     """(method registry, resolved report) for a review against the main seat.
 
@@ -5311,13 +5624,21 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         override_model = effective_tier_model(config, host, tier, all_overrides)
         if not isinstance(override_model, str) or not override_model:
             raise LaunchError(f"invalid override model: {preset_name}.tier_overrides.{host}.{tier}")
-        override_effort = override.get("effort", tiers[tier]["effort"])
+        # Haiku has no configurable effort. A model override to it must therefore
+        # clear the inherited tier setting rather than preserve an invalid value.
+        override_effort = (
+            override.get("effort")
+            if "effort" in override
+            else (tiers[tier].get("effort") if model_requires_effort(host, override_model) else None)
+        )
         validate_effort(host, override_model, override_effort, f"{preset_name}.tier_overrides.{host}.{tier}")
-        tiers[tier] = {"model": override_model, "effort": override_effort}
+        tiers[tier] = {"model": override_model}
+        if override_effort is not None:
+            tiers[tier]["effort"] = override_effort
     main_tier = preset.get("main_tier")
     if not isinstance(main_tier, str) or main_tier not in tiers:
         raise LaunchError(f"invalid main_tier in preset {preset_name}: {main_tier}")
-    authored_frontier_effort = preset.get("frontier_effort", tiers["frontier"]["effort"])
+    authored_frontier_effort = preset.get("frontier_effort", tiers["frontier"].get("effort"))
     frontier_effort = authored_frontier_effort
     if isinstance(frontier_effort, dict):
         frontier_effort = frontier_effort.get(host)
@@ -5376,11 +5697,30 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
                 f"tier_overrides.{other}.frontier.effort={authored_override!r}; FRONTIER's "
                 "effort has one value — remove one of them"
             )
-    tiers["frontier"] = {**tiers["frontier"], "effort": frontier_effort}
-    delegation = preset.get("delegation", True)
-    if not isinstance(delegation, bool):
+    tiers["frontier"] = {**tiers["frontier"]}
+    if frontier_effort is None:
+        tiers["frontier"].pop("effort", None)
+    else:
+        tiers["frontier"]["effort"] = frontier_effort
+    delegation_requested = preset.get("delegation", True)
+    if not isinstance(delegation_requested, bool):
         raise LaunchError(f"delegation must be boolean in preset {preset_name}")
+    # SWEEP's contract is one explicit read-only rule per item. Child delegation
+    # would hand that main a writable escape through another tier, so its
+    # projection is deliberately single-seat whatever the preset requested.
+    delegation = delegation_requested and main_tier != "sweep"
+    include_global_instructions = preset.get("include_global_instructions", True)
+    if not isinstance(include_global_instructions, bool):
+        raise LaunchError(
+            f"include_global_instructions must be boolean in preset {preset_name}"
+    )
     review = read_review(preset, preset_name, config, host)
+    if main_tier == "sweep" and review_is_requested(review):
+        raise LaunchError(
+            f"presets.{preset_name} requests review, but SWEEP main exposes only its "
+            "read-only one-rule-per-item surface and cannot dispatch a reviewer. Turn "
+            "review off (the Solo setup) or choose HELM or WORKHORSE as main."
+        )
     review_arms = read_review_arms(preset)
     # Authoring [review] IS the opt-in. Shipped presets stay on review_setup, so the
     # default launch is byte-identical; only a preset that asks for the composable
@@ -5390,7 +5730,7 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
     # Resolved HERE, not at render time: a composable preset whose base panel has no
     # isolated mechanism is an invalid launch, and that has to fail while the plan is
     # being built rather than halfway through printing a contract.
-    main_effort = frontier_effort if main_tier == "frontier" else tiers[main_tier]["effort"]
+    main_effort = frontier_effort if main_tier == "frontier" else tiers[main_tier].get("effort")
     # The criterion-discipline toggle. A BOOLEAN, deliberately: the criterion itself is
     # per-review and rides the packet, which packet_sha256 binds — a preset carrying its
     # content would put per-review text into the per-launch contract the golden pins.
@@ -5469,6 +5809,13 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         "review_report": review_report,
         "review_methods": review_methods,
         "delegation": delegation,
+        # The persistent user choice, kept distinct from SWEEP's derived runtime
+        # restriction so Save As and a later move back to another main do not
+        # silently turn a requested fan-out off forever.
+        "delegation_requested": delegation_requested,
+        # The execution boundary decides whether a host can honour false. Keeping the
+        # authored value here lets Custom repair an old unsupported saved choice first.
+        "include_global_instructions": include_global_instructions,
         "codex_execution_policy": codex_policy,
         "claude_permission_mode": claude_policy,
         "tiers": tiers,
@@ -5505,7 +5852,10 @@ AUTHOR_COMPOSABLE = "__author_composable__"
 def review_binding_label(binding: "ReviewBinding | None") -> str:
     if binding is None:
         return "not set"
-    seat = f"tier {binding.tier}" if binding.tier else f"{binding.model}/{binding.effort}"
+    seat = (
+        f"tier {binding.tier}"
+        if binding.tier else format_model_effort(binding.model, binding.effort)
+    )
     return f"{binding.provider} · {seat}"
 
 
@@ -5730,15 +6080,15 @@ def choose_review_binding(
     seats = [
         MenuOption(
             f"tier:{tier}",
-            f"{tier.upper()}: {tiers[tier]['model']} / {tiers[tier]['effort']}",
-            f"Bind to the {host} {tier.upper()} tier; model and effort move together.",
+            f"{tier.upper()}: {format_model_effort(tiers[tier]['model'], tiers[tier].get('effort'), ' / ')}",
+            f"Bind to the {host} {tier.upper()} tier; its model and supported effort setting move together.",
         )
         for tier in TIER_ORDER
         if isinstance(tiers.get(tier), dict)
     ]
     seats.append(
-        MenuOption(OTHER_MODEL, "Custom model and effort",
-                   "Name the exact model, then its reasoning effort.")
+        MenuOption(OTHER_MODEL, "Custom model (and effort when supported)",
+                   "Name the exact model, then choose its reasoning effort when it supports one.")
     )
     default_seat = (
         f"tier:{current.tier}"
@@ -5753,15 +6103,20 @@ def choose_review_binding(
         model = prompt_text(
             f"{title} — model", current.model if current is not None else "", ui
         )
-        effort = choose(
-            f"{title} — effort", effort_options(host, model),
-            # HOST_EFFORTS values are SETS: indexing one raised TypeError before
-            # the effort picker drew. EFFORT_ORDER gives a deterministic first
-            # supported effort, where a set gives none at all.
-            current.effort if current is not None else host_default_effort(host), ui,
-            allow_back=True,
-        )
-        raw = {"provider": provider, "model": model, "effort": effort}
+        if model_requires_effort(host, model):
+            effort = choose(
+                f"{title} — effort", effort_options(host, model),
+                # HOST_EFFORTS values are SETS: indexing one raised TypeError before
+                # the effort picker drew. EFFORT_ORDER gives a deterministic first
+                # supported effort, where a set gives none at all. A previous no-effort
+                # model starts at the supported default rather than preserving absence.
+                (current.effort if current is not None and current.effort is not None
+                 else host_default_effort(host)), ui,
+                allow_back=True,
+            )
+            raw = {"provider": provider, "model": model, "effort": effort}
+        else:
+            raw = {"provider": provider, "model": model}
     return parse_review_binding(raw, config, f"custom.{title}")
 
 
@@ -6528,6 +6883,10 @@ def host_default_effort(host: str) -> str:
 
 
 def effort_options(host: str, model: str) -> list[MenuOption]:
+    if not model_requires_effort(host, model):
+        # The caller skips this menu entirely. Returning no choices makes a direct
+        # consumer unable to turn absence into a deceptive selected value.
+        return []
     descriptions = effort_descriptions()
     options = []
     for effort in EFFORT_ORDER:
@@ -6579,7 +6938,8 @@ def review_binding_fields(binding: ReviewBinding) -> dict[str, str]:
         fields["tier"] = binding.tier
     else:
         fields["model"] = binding.model
-        fields["effort"] = binding.effort
+        if binding.effort is not None:
+            fields["effort"] = binding.effort
     if binding.service_tier != DEFAULT_SERVICE_TIER:
         fields["service_tier"] = binding.service_tier
     return fields
@@ -6659,10 +7019,14 @@ def preset_from_plan(
         # hub calls "Save these settings".
         "mode": preset_mode(plan),
         "main_tier": plan["main_tier"],
-        "delegation": plan["delegation"],
+        "delegation": plan.get("delegation_requested", plan["delegation"]),
         "codex_execution_policy": plan["codex_execution_policy"],
         "claude_permission_mode": plan["claude_permission_mode"],
     }
+    # True is the schema default, so existing saved presets stay byte-identical. False
+    # changes native instruction scope and must survive Save As.
+    if not plan.get("include_global_instructions", True):
+        fields["include_global_instructions"] = False
     if plan.get("criterion"):
         # Save As from a criterion-toggled plan silently dropped the discipline: the
         # routed-name guard covers same-name shadowing, not a fresh name, and the
@@ -6687,8 +7051,12 @@ def preset_from_plan(
         override: dict[str, str] = {}
         if plan["tiers"][tier]["model"] != default_tiers[tier]["model"]:
             override["model"] = plan["tiers"][tier]["model"]
-        if tier_effort(plan, tier) != default_tiers[tier]["effort"]:
-            override["effort"] = tier_effort(plan, tier)
+        effort = tier_effort(plan, tier)
+        default_effort = default_tiers[tier].get("effort")
+        # Omission is the only valid Haiku representation. A supporting model
+        # remains subject to validate_effort before this save path runs.
+        if effort is not None and effort != default_effort:
+            override["effort"] = effort
         if override:
             overrides[tier] = override
     # The OTHER host's overrides are carried, not re-derived. "Scoped to the plan's host"
@@ -6760,6 +7128,15 @@ def preset_from_plan(
                 effort = authored_frontier[other]
             else:
                 effort = authored_frontier
+            other_frontier_model = effective_tier_model(
+                config, other, "frontier", plan.get("tier_overrides", {})
+            )
+            if effort is None and isinstance(other_frontier_model, str) and not model_requires_effort(
+                other, other_frontier_model
+            ):
+                # The only no-effort model has no serializable top-level effort
+                # value. Its tier override already carries the model selection.
+                continue
             if not isinstance(effort, str) or not effort:
                 # NAMED, not skipped. `build_plan` refuses such a profile now, so this is
                 # the door for a plan assembled some other way — and the alternative here
@@ -7236,9 +7613,8 @@ def save_preset(
                         # that host nothing.
                         continue
                 try:
-                    projected = project_args(
-                        build_plan(rebuilt, host, name), materialize_agents=False
-                    )
+                    rebuilt_plan = build_plan(rebuilt, host, name)
+                    projected = project_args(rebuilt_plan, materialize_agents=False)
                 except LaunchError as exc:
                     raise LaunchError(
                         f"saving {name!r} would write a preset that no longer builds on "
@@ -7262,6 +7638,13 @@ def save_preset(
                         f"{_at(intended, where)} ({len(intended)} argument(s)); nothing was "
                         f"written"
                     )
+                if rebuilt_plan["include_global_instructions"] != plan.get(
+                    "include_global_instructions", True
+                ):
+                    raise LaunchError(
+                        f"saving {name!r} would write a different global instruction "
+                        "file setting; nothing was written"
+                    )
             # Through the shared primitive, which is where the temporary's removal on
             # failure lives. This site had the same two lines and no cleanup, so an
             # `os.replace` that failed left the complete candidate sitting beside the
@@ -7278,9 +7661,23 @@ def customize(
     ui: TextualUI | None = None,
 ) -> None:
     descriptions = tier_descriptions()
-    tier_options = [
-        MenuOption(tier, tier.upper(), descriptions[tier]) for tier in TIER_ORDER
-    ]
+    sweep_review_reason = (
+        "SWEEP main is read-only and cannot dispatch review. Turn review off or choose "
+        "HELM or WORKHORSE."
+    )
+
+    def tier_options() -> list[MenuOption]:
+        review_requested = review_is_requested(plan["review_plan"])
+        return [
+            MenuOption(
+                tier,
+                tier.upper(),
+                descriptions[tier],
+                enabled=not (tier == "sweep" and review_requested),
+                unavailable_reason=sweep_review_reason if tier == "sweep" and review_requested else "",
+            )
+            for tier in TIER_ORDER
+        ]
     available_routes = route_availability(plan)
     cross = plan.get("review_family", "cross") == "cross"
     review_options = []
@@ -7386,6 +7783,17 @@ def customize(
                 t("custom.policy.label").format(policy=policy_label),
                 t("custom.policy.description"),
             ),
+            MenuOption(
+                "global-instructions",
+                t("custom.global-instructions.label").format(
+                    choice=t(
+                        "global-instructions.include.label"
+                        if plan.get("include_global_instructions", True)
+                        else "global-instructions.exclude.label"
+                    )
+                ),
+                t("custom.global-instructions.description"),
+            ),
         ]
         for tier in TIER_ORDER:
             binding = plan["tiers"][tier]
@@ -7394,7 +7802,8 @@ def customize(
                     f"tier:{tier}",
                     # Model and effort only — the row is data, and the tier name it
                     # leads with is an identifier the contract uses, not UI text.
-                    f"{tier.upper()}: {binding['model']} / {tier_effort(plan, tier)}",
+                    f"{tier.upper()}: "
+                    f"{format_model_effort(binding['model'], tier_effort(plan, tier), ' / ')}",
                     t("custom.tier.description").format(tier=tier.upper()),
                 )
             )
@@ -7432,29 +7841,61 @@ def customize(
             if action == "main":
                 plan["main_tier"] = choose(
                     t("tier.title"),
-                    tier_options,
+                    tier_options(),
                     plan["main_tier"],
                     ui,
                     allow_back=True,
-                    preview=lambda value: {**plan, "main_tier": value},
+                    preview=lambda value: {
+                        **plan,
+                        "main_tier": value,
+                        "delegation": (
+                            plan.get("delegation_requested", plan["delegation"])
+                            and value != "sweep"
+                        ),
+                    },
+                )
+                plan["delegation"] = (
+                    plan.get("delegation_requested", plan["delegation"])
+                    and not sweep_main(plan)
                 )
                 reseat_review(plan, config)
             elif action == "review":
                 if plan["review_plan"].source == "composable":
+                    if sweep_main(plan):
+                        raise LaunchError(sweep_review_reason)
                     review_editor(plan, config, ui, config_path)
                 else:
-                    chosen = choose(
-                        "Review setup",
-                        review_options
-                        + [
+                    available_review_options = review_options
+                    composer_option = MenuOption(
+                        AUTHOR_COMPOSABLE,
+                        "Compose review (explicit bindings)…",
+                        "Author the base panel and each method's exact "
+                        "provider/model/effort instead of picking a combination "
+                        f"name. {REVIEW_RECOMMENDATION}",
+                    )
+                    if sweep_main(plan):
+                        available_review_options = [
                             MenuOption(
-                                AUTHOR_COMPOSABLE,
-                                "Compose review (explicit bindings)…",
-                                "Author the base panel and each method's exact "
-                                "provider/model/effort instead of picking a combination "
-                                f"name. {REVIEW_RECOMMENDATION}",
+                                option.value,
+                                option.label,
+                                option.description,
+                                enabled=option.value == "none",
+                                unavailable_reason=(
+                                    "" if option.value == "none" else sweep_review_reason
+                                ),
                             )
-                        ],
+                            for option in review_options
+                        ]
+                        composer_option = MenuOption(
+                            composer_option.value,
+                            composer_option.label,
+                            composer_option.description,
+                            enabled=False,
+                            unavailable_reason=sweep_review_reason,
+                        )
+                    chosen = choose(
+                        "Review setup",
+                        available_review_options + [composer_option],
                         plan["review_setup"],
                         ui,
                         allow_back=True,
@@ -7488,12 +7929,47 @@ def customize(
                     allow_back=True,
                     preview=lambda value: {**plan, policy_field: value},
                 )
+            elif action == "global-instructions":
+                exclude_available = private_corpus_enabled() and plan["host"] == "claude"
+                exclude_reason = (
+                    t("global-instructions.exclude.codex-unavailable")
+                    if plan["host"] == "codex"
+                    else t("global-instructions.exclude.private-unavailable")
+                )
+                choice = choose(
+                    t("global-instructions.title"),
+                    [
+                        MenuOption(
+                            "include",
+                            t("global-instructions.include.label"),
+                            t("global-instructions.include.description"),
+                        ),
+                        MenuOption(
+                            "exclude",
+                            t("global-instructions.exclude.label"),
+                            t("global-instructions.exclude.description"),
+                            enabled=exclude_available,
+                            unavailable_reason=exclude_reason,
+                        ),
+                    ],
+                    "include" if plan.get("include_global_instructions", True) else "exclude",
+                    ui,
+                    allow_back=True,
+                    preview=lambda value: {
+                        **plan, "include_global_instructions": value == "include"
+                    },
+                )
+                plan["include_global_instructions"] = choice == "include"
         except BackRequested:
             continue
 
         if action.startswith("tier:"):
             tier = action.split(":", 1)[1]
             binding = plan["tiers"][tier]
+            configured_default_effort = (
+                config.get("hosts", {}).get(plan["host"], {}).get("tiers", {})
+                .get(tier, {}).get("effort")
+            )
             # `binding` IS the plan's dict, so every assignment below lands on the live
             # plan the moment it is made. Choosing a model and then backing out of the
             # effort screen — which loops to the model screen — and backing out again left
@@ -7501,6 +7977,7 @@ def customize(
             # snapshot is what Escape restores; the plan is only allowed to keep an edit
             # that reached the end of the edit.
             original_binding = dict(binding)
+            original_frontier_effort = plan["frontier_effort"] if tier == "frontier" else None
             cancelled = False
             while True:
                 default_model = (
@@ -7519,12 +7996,11 @@ def customize(
                             **plan,
                             "tiers": {
                                 **plan["tiers"],
-                                tier: {
-                                    **binding,
-                                    "model": binding["model"]
-                                    if value == OTHER_MODEL
-                                    else value,
-                                },
+                                tier: binding_for_selected_model(
+                                    plan["host"], binding,
+                                    binding["model"] if value == OTHER_MODEL else value,
+                                    default_effort=configured_default_effort,
+                                ),
                             },
                         },
                     )
@@ -7537,27 +8013,46 @@ def customize(
                     )
                 else:
                     binding["model"] = chosen_model
-                current_effort = tier_effort(plan, tier)
-                try:
-                    binding["effort"] = choose(
-                        t("effort.title").format(tier=tier.upper()),
-                        effort_options(plan["host"], binding["model"]),
-                        current_effort,
-                        ui,
-                        allow_back=True,
-                        preview=lambda value: {
-                            **plan,
-                            "frontier_effort": value
-                            if tier == "frontier"
-                            else plan["frontier_effort"],
-                            "tiers": {
-                                **plan["tiers"],
-                                tier: {**binding, "effort": value},
+                selected_binding = binding_for_selected_model(
+                    plan["host"], binding, binding["model"],
+                    default_effort=configured_default_effort,
+                )
+                binding.clear()
+                binding.update(selected_binding)
+                if tier == "frontier":
+                    # `tier_effort` deliberately projects the FRONTIER scalar.
+                    # Keep it coherent before the effort menu asks for its default
+                    # and before that menu previews an edited plan.
+                    plan["frontier_effort"] = binding.get("effort")
+                if model_requires_effort(plan["host"], binding["model"]):
+                    # `binding_for_selected_model` supplies a default when the prior
+                    # model had no effort; supporting-to-supporting moves retain their
+                    # explicit chosen effort as before.
+                    current_effort = binding["effort"]
+                    try:
+                        binding["effort"] = choose(
+                            t("effort.title").format(tier=tier.upper()),
+                            effort_options(plan["host"], binding["model"]),
+                            current_effort,
+                            ui,
+                            allow_back=True,
+                            preview=lambda value: {
+                                **plan,
+                                "frontier_effort": value
+                                if tier == "frontier"
+                                else plan["frontier_effort"],
+                                "tiers": {
+                                    **plan["tiers"],
+                                    tier: {**binding, "effort": value},
+                                },
                             },
-                        },
-                    )
-                except BackRequested:
-                    continue
+                        )
+                    except BackRequested:
+                        continue
+                else:
+                    # Claude Haiku 4.5 exposes no effort selector. Delete rather
+                    # than store a sentinel, so Save As emits no TOML effort key.
+                    binding.pop("effort", None)
                 break
             # Only when the edit was actually completed. FRONTIER's effort has two homes —
             # the tier binding and `plan["frontier_effort"]`, which is the preset's
@@ -7568,9 +8063,11 @@ def customize(
             if cancelled:
                 binding.clear()
                 binding.update(original_binding)
+                if tier == "frontier":
+                    plan["frontier_effort"] = original_frontier_effort
             else:
                 if tier == "frontier":
-                    plan["frontier_effort"] = binding["effort"]
+                    plan["frontier_effort"] = binding.get("effort")
                 # Editing the MAIN tier's binding moves the seat the review was graded
                 # against just as surely as picking a different main tier does.
                 if tier == plan["main_tier"]:
@@ -7622,6 +8119,94 @@ VERSION_INFO_PATH = pathlib.Path(
     )
 )
 
+UPDATE_CHECK_PATH = pathlib.Path(
+    os.environ.get(
+        "AGENT_BIOS_UPDATE_CHECK_STATE",
+        str(pathlib.Path.home() / ".local/share/agent-bios/update-check.json"),
+    )
+)
+
+# Once a day. The launcher never performs the lookup itself — it reads this cache and
+# at most SPAWNS the installer, detached, to refresh it. Two reasons, both load-bearing:
+# `npm view` routinely takes seconds and a launcher that blocks on the network is worse
+# than one that shows a stale badge, and the network operation belongs to the component
+# that already owns fetch-corpus (ENDPOINTS.md) rather than to the UI.
+UPDATE_CHECK_INTERVAL_S = 24 * 60 * 60
+
+
+def _version_tuple(text: str) -> tuple[int, ...] | None:
+    """Numeric release prefix, or None when it is not one.
+
+    Deliberately refuses anything it does not fully understand rather than guessing:
+    a prerelease like 1.2.3-rc1 returns None, so it is never compared and never
+    announced. Announcing an upgrade to a version the user cannot get is worse than
+    announcing nothing."""
+    parts = text.strip().split(".")
+    if not (2 <= len(parts) <= 4):
+        return None
+    out = []
+    for part in parts:
+        if not part.isdigit():
+            return None
+        out.append(int(part))
+    return tuple(out)
+
+
+def read_update_cache() -> dict | None:
+    try:
+        data = json.loads(UPDATE_CHECK_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def update_available(deployed: str | None, cache: dict | None) -> str | None:
+    """The version to announce, or None.
+
+    None whenever anything is unknown — no cache, a cache whose lookup failed (it
+    carries checked_at but no latest), an unparseable version on either side, or a
+    latest that is not strictly greater. `latest` missing means "asked, no answer",
+    which must not read as "up to date"; it simply says nothing."""
+    if not deployed or not cache:
+        return None
+    latest = cache.get("latest")
+    if not isinstance(latest, str):
+        return None
+    here, there = _version_tuple(deployed), _version_tuple(latest)
+    if here is None or there is None:
+        return None
+    return latest if there > here else None
+
+
+def update_check_due(cache: dict | None, now: float) -> bool:
+    if os.environ.get("AGENT_BIOS_UPDATE_CHECK") == "0":
+        return False
+    if cache is None:
+        return True
+    checked = cache.get("checked_at")
+    if not isinstance(checked, (int, float)):
+        return True
+    return (now - checked) >= UPDATE_CHECK_INTERVAL_S
+
+
+def spawn_update_check() -> None:
+    """Fire and forget. Every failure here is silent BY DESIGN — a background
+    refresh that reported its own problems would interrupt a launch to say something
+    the user did not ask for and cannot act on."""
+    installer = shutil.which("agent-bios")
+    if not installer:
+        return
+    try:
+        subprocess.Popen(
+            [installer, "update", "--check"],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except OSError:
+        pass
+
 
 def load_corpus_status() -> dict[str, Any] | None:
     """The corpus status projection, or None when the file is unreadable or is not
@@ -7633,6 +8218,12 @@ def load_corpus_status() -> dict[str, Any] | None:
     before it drew, and each new consumer would add another field to remember. The
     depth is unbounded, so the readers DEGRADE instead — see corpus_summary_lines.
     """
+    if private_corpus_enabled():
+        try:
+            return {"private": corpus_store().status()}
+        except (OSError, ValueError, RuntimeError) as exc:
+            print(f"agent-launch: cannot read private corpus: {exc}", file=sys.stderr)
+            return None
     try:
         data = json.loads(CORPUS_STATUS_PATH.read_text(encoding="utf-8"))
     except (OSError, ValueError):
@@ -7653,7 +8244,12 @@ def version_label() -> str | None:
     if not version:
         return None
     released = info.get("releaseDate")
-    return f"agent-bios v{version} · {released}" if released else f"agent-bios v{version}"
+    label = f"agent-bios v{version} · {released}" if released else f"agent-bios v{version}"
+    cache = read_update_cache()
+    if update_check_due(cache, time.time()):
+        spawn_update_check()
+    newer = update_available(version, cache)
+    return f"{label} · update v{newer} available" if newer else label
 
 
 def display_width(text: str) -> int:
@@ -7710,44 +8306,232 @@ def status_list(value: Any) -> list:
     return value if isinstance(value, list) else []
 
 
+_CORPUS_FACTS: dict[tuple, dict[str, Any] | None] = {}
+
+
+def size_label(chars: int) -> str:
+    """Text size in KB. Characters, not tokens, and the caller says so on screen:
+    this launcher has no tokenizer, and an estimate printed as a bare number is read
+    as a measurement."""
+    return f"{chars / 1024:.1f} KB"
+
+
+def corpus_facts(status: dict[str, Any] | None) -> dict[str, Any] | None:
+    """What each domain package holds and what it costs, or None when the package the
+    projection points at cannot be read.
+
+    Derived by running the package's OWN assembler over its own manifest and monolith,
+    never by a second copy of the tier rule kept here. A size this module computed from
+    its own reading of `domains.json` would drift from the bundle the installer actually
+    writes, and a wrong number under a chooser is worse than no number: it is the basis
+    the user was told to choose on.
+
+    Two figures per domain, never one. A domain's rules land in the global that every
+    session and every subagent loads; its guides are deployed but read only when a rule
+    points at one. Here they differ by more than an order of magnitude — 0.3-7 KB of
+    rules against 12-114 KB of guides — so a single "size" would mislead on both.
+
+    Failure is None, in every direction: a missing package, a manifest the assembler
+    refuses (it calls sys.exit, which is not an Exception), a monolith that disagrees
+    with the manifest. This runs behind the root menu, so nothing it does may end the
+    session, and a screen that cannot size the packages still lets the user pick them.
+    """
+    repo = (status or {}).get("repo")
+    if not isinstance(repo, str) or not repo:
+        return None
+    manifest_path = pathlib.Path(repo) / "compose" / "domains.json"
+    applied = tuple(sorted(status_list(((status or {}).get("domains") or {}).get("applied"))))
+    try:
+        stamp = (repo, manifest_path.stat().st_mtime, applied)
+    except OSError:
+        return None
+    if stamp in _CORPUS_FACTS:
+        return _CORPUS_FACTS[stamp]
+    _CORPUS_FACTS[stamp] = None  # a repeat of a failing read must not repeat the cost
+    try:
+        facts = _corpus_facts(pathlib.Path(repo), manifest_path, set(applied))
+    except SystemExit:
+        # assemble.die() on a manifest/monolith disagreement. Not an Exception, so it
+        # would otherwise leave the launcher through every absorber in this file.
+        return None
+    except Exception as exc:  # noqa: BLE001 — sizing is decoration; picking is not
+        print(f"agent-launch: cannot size the corpus packages in {repo} "
+              f"({type(exc).__name__}: {exc})", file=sys.stderr)
+        return None
+    _CORPUS_FACTS[stamp] = facts
+    return facts
+
+
+def _load_assembler(repo: pathlib.Path):
+    """The package's own assembler, loaded by PATH rather than by name.
+
+    `sys.path.insert` plus a plain import returns whatever is already cached under that
+    name, so in a process that has imported some other `assemble` the figures would come
+    from the wrong file and still look entirely plausible. Loading by location under a
+    private name pins which file answers, and leaves sys.path alone for everyone else in
+    the process."""
+    import importlib.util
+
+    path = repo / "compose" / "assemble.py"
+    spec = importlib.util.spec_from_file_location("agent_bios_assemble", path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"no assembler to load at {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _corpus_facts(repo: pathlib.Path, manifest_path: pathlib.Path, applied: set) -> dict[str, Any]:
+    """The derivation proper, with every failure left to the caller to absorb."""
+    assemble = _load_assembler(repo)
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    monolith = (repo / "claude" / "CLAUDE.md").read_text(encoding="utf-8")
+    guide_dir = repo / "claude" / "guides"
+
+    def guide_chars(names) -> int:
+        return sum(
+            (guide_dir / name).stat().st_size
+            for name in names if (guide_dir / name).is_file()
+        )
+
+    base_text, base_rules = assemble.build_bundle(monolith, manifest, set(), "claude")
+    base_guides = set(assemble.filtered_files(manifest, "guides", set()))
+    domains = {}
+    for name, description in (manifest.get("domains") or {}).items():
+        text, rules = assemble.build_bundle(monolith, manifest, {name}, "claude")
+        # Every selection carries the universal files too, so a domain's OWN set is the
+        # difference. Without the subtraction each domain claimed the two core guides.
+        own = sorted(set(assemble.filtered_files(manifest, "guides", {name})) - base_guides)
+        domains[name] = {
+            "description": description if isinstance(description, str) else "",
+            "rules": rules - base_rules,
+            "chars": len(text) - len(base_text),
+            "guides": len(own),
+            "guide_chars": guide_chars(own),
+        }
+    # The applied set is assembled OUTRIGHT rather than summed from the per-domain
+    # deltas above. A section header is emitted once per bundle but appears in every
+    # delta that needs it, so the sum overstated the real deployed global — by 23
+    # characters here, which is small and would have been reported as measured.
+    known = applied & set(domains)
+    selected_text, selected_rules = assemble.build_bundle(monolith, manifest, known, "claude")
+    selected_guides = assemble.filtered_files(manifest, "guides", known)
+    return {
+        "domains": domains,
+        "base": {
+            "rules": base_rules,
+            "chars": len(base_text),
+            "guides": len(base_guides),
+            "guide_chars": guide_chars(base_guides),
+        },
+        "selected": {
+            "rules": selected_rules,
+            "chars": len(selected_text),
+            "guides": len(selected_guides),
+            "guide_chars": guide_chars(selected_guides),
+            # A projection can name a domain the installed package does not carry;
+            # the figures above then describe a smaller corpus than the row above them
+            # claims, so the gap is reported rather than folded in.
+            "unknown": sorted(applied - set(domains)),
+        },
+    }
+
+
 def _corpus_summary_lines(status: dict[str, Any] | None) -> list[str]:
     """The panel body proper. The label column is derived at render time from the
     widest label in the ACTIVE language and measured in display cells: a pad written
     for English cannot align a translated panel."""
     if status is None:
         return [t("panel.unprojected")]
-    labels = (t("panel.version.label"), t("panel.mechanisms.label"),
-              t("panel.ledger.label"), t("panel.domains.label"))
+    if isinstance(status.get("private"), dict):
+        current = status["private"]
+        selection = current.get("selection")
+        selected = ", ".join(selection) if selection else t("corpus.launch.base")
+        return [t("corpus.private.relationship"),
+                f"{t('panel.domains.label')} {selected}",
+                f"{t('panel.version.label')} {current.get('selected_baseline_ref') or '—'}"]
+    # `versions is None` is the projection saying "this install cannot know" — a packaged
+    # install has no author-side registry (compose/corpus-state.py). Three rows then read
+    # "unavailable", which is true of the ledger and says nothing about the corpus the
+    # user actually has. The package carries the manifest and the monolith the installer
+    # assembled from, so those rows are answerable from it; the absence is still stated,
+    # once, on the row it belongs to.
+    unavailable = status.get("versions") is None
+    domains = status.get("domains")
+    applied_raw = domains.get("applied") if isinstance(domains, dict) else None
+    facts = corpus_facts(status)
+    # An unapplied install is NOT sized: what is deployed is whatever the install put
+    # there, and the manifest cannot say which. A guess here would read as a reading.
+    packaged = unavailable and facts is not None and applied_raw is not None
+    labels = (
+        (t("panel.rules.label"), t("panel.guides.label"))
+        if packaged else (t("panel.version.label"), t("panel.mechanisms.label"))
+    ) + (t("panel.ledger.label"), t("panel.domains.label"))
     column = max(display_width(label) for label in labels) + 2
 
     def row(label: str, value: str) -> str:
         return label + " " * max(1, column - display_width(label)) + value
 
+    if packaged:
+        selected = facts["selected"]
+        lines = [
+            row(labels[0], t("panel.rules.value").format(
+                rules=selected["rules"], size=size_label(selected["chars"]))),
+            row(labels[1], t("panel.guides.value").format(
+                guides=selected["guides"], size=size_label(selected["guide_chars"]))),
+            row(labels[2], t("panel.ledger.author-only")),
+        ]
+        if selected["unknown"]:
+            # The projection names a package this install does not carry, so the two
+            # rows above describe less than the domain row below them claims.
+            lines.append(t("panel.domains.unknown").format(
+                names=", ".join(selected["unknown"])))
+        return lines + _corpus_domain_lines(status, applied_raw, row, labels[3])
+
+    # `versions is None` is the projection saying "this install cannot know" — a packaged
+    # install has no author version/ledger registry (compose/corpus-state.py). It is not
+    # `[]`, which would mean a checkout whose registry is genuinely empty, and it must not
+    # render as `0 placed · 0 versions`: a fabricated zero is worse than a blank, because
+    # a reader cannot tell it from a real count. The domain rows below stay real, which is
+    # the whole point of degrading rather than withholding the projection.
+    summary = status.get("summary") or {}
     current = status.get("current_version", "?")
     latest = status.get("latest_version", "?")
-    head = row(labels[0], str(current))
+    # `str(current)` printed the literal "None" on a checkout whose registry exists but
+    # holds no version — pre-existing, and visible the moment the row above it learned to
+    # say "unavailable". A known absence reads as none; an unknown one says so.
+    head = row(labels[0], t("panel.unavailable") if unavailable
+               else str(current) if current else t("panel.layers.none"))
     if status.get("rolled_back_to"):
         head += "  " + t("panel.rolled-back").format(latest=latest)
-    layers = status.get("summary", {}).get("placed_by_layer", {})
+    layers = summary.get("placed_by_layer", {})
     order = ("global", "guide", "hook", "enforcement", "gate")
     layer_text = " · ".join(
         f"{name} {layers[name]}" for name in order if layers.get(name)
     ) or t("panel.layers.none")
-    by_status = status.get("summary", {}).get("by_status", {})
+    by_status = summary.get("by_status", {})
     lines = [
         head,
-        row(labels[1], layer_text),
-        row(labels[2], t("panel.ledger.value").format(
+        row(labels[1], t("panel.unavailable") if unavailable else layer_text),
+        row(labels[2], t("panel.unavailable") if unavailable else t("panel.ledger.value").format(
             placed=by_status.get("placed", 0),
             incubating=by_status.get("incubating", 0) + by_status.get("incubating-G", 0),
             versions=len(status_list(status.get("versions"))),
         )),
     ]
-    domains = status.get("domains")
-    if isinstance(domains, dict):
-        applied = domains.get("applied")
-        applied = None if applied is None else status_list(applied)
-        lines.append(row(labels[3], t("panel.domains.unset") if applied is None
+    return lines + _corpus_domain_lines(status, applied_raw, row, labels[3])
+
+
+def _corpus_domain_lines(status, applied_raw, row, label: str) -> list[str]:
+    """The rows both panels end on: what is applied, and a failed apply if there is one.
+
+    Shared rather than written twice — a packaged panel that quietly dropped the failed
+    apply would hide exactly the state the row exists for."""
+    lines = []
+    if isinstance(status.get("domains"), dict):
+        applied = None if applied_raw is None else status_list(applied_raw)
+        lines.append(row(label, t("panel.domains.unset") if applied is None
                          else ", ".join(applied) or t("corpus.core-only")))
     last_apply = status.get("last_apply")
     if isinstance(last_apply, dict) and last_apply.get("outcome") not in (None, "applied"):
@@ -8046,6 +8830,10 @@ class CorpusApplyRequested(Exception):
         self.selection = selection
 
 
+class CorpusStudioRequested(Exception):
+    """Release Textual's terminal before starting the standalone manager."""
+
+
 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
@@ -8090,6 +8878,107 @@ def run_corpus_apply(selection: list[str]) -> None:
         print("\nagent-launch: corpus selection applied.", flush=True)
 
 
+def checkbox_label(checked: bool, name: str, trailing: str = ""):
+    """`[✓] name`, with the mark in green wherever the renderer carries style.
+
+    Returned as a Text rather than an f-string because an option label is rendered as
+    markup: `[x]` is consumed as a tag and disappears, while `[ ]` does not match the
+    tag shape and survives. Built as a plain string only where rich is absent, which is
+    the same path that has no colour to lose."""
+    try:
+        from rich.text import Text
+    except ImportError:
+        return f"[{'✓' if checked else ' '}] {name}{trailing}"
+    box = ("[", ("✓", "bold green"), "] ") if checked else ("[ ] ",)
+    return Text.assemble(*box, name, (trailing, "dim"))
+
+
+def _corpus_domain_content(name: str, fallback: str = "") -> str:
+    """Localized content help; unfamiliar packages retain their manifest description."""
+    descriptions = {
+        "builder-base": t("corpus.domain.builder-base"),
+        "llm-pipeline-dev": t("corpus.domain.llm-pipeline-dev"),
+        "multi-agent-orchestration": t("corpus.domain.multi-agent-orchestration"),
+        "visualization-docs": t("corpus.domain.visualization-docs"),
+        "office-work": t("corpus.domain.office-work"),
+    }
+    return descriptions.get(name, fallback).strip()
+
+
+def corpus_domain_labels() -> dict[str, str]:
+    return {
+        "builder-base": t("corpus.domain.builder-base.label"),
+        "llm-pipeline-dev": t("corpus.domain.llm-pipeline-dev.label"),
+        "multi-agent-orchestration": t("corpus.domain.multi-agent-orchestration.label"),
+        "visualization-docs": t("corpus.domain.visualization-docs.label"),
+        "office-work": t("corpus.domain.office-work.label"),
+    }
+
+
+def preset_descriptions() -> dict[str, str]:
+    """Human-facing help for the built-in choices, independent of launch-contract text."""
+    return {
+        "balanced": t("preset.balanced.description"),
+        "deep-review": t("preset.deep-review.description"),
+        "fast-batch": t("preset.fast-batch.description"),
+        "solo": t("preset.solo.description"),
+        "vanilla": (t("corpus.private.vanilla") if private_corpus_enabled()
+                    else t("preset.vanilla.description")),
+    }
+
+
+def _corpus_launch_description(status: dict[str, Any] | None) -> str:
+    """Explain the installed selection shared by modes without claiming a launch applies it."""
+    if private_corpus_enabled():
+        return t("corpus.private.relationship")
+    lines = [t("corpus.launch.relationship")]
+    domains = (status or {}).get("domains")
+    applied = domains.get("applied") if isinstance(domains, dict) else None
+    if not isinstance(applied, list) or not all(isinstance(name, str) for name in applied):
+        message = (t("panel.domains.unset")
+                   if isinstance(domains, dict) and "applied" in domains and applied is None
+                   else t("panel.unprojected"))
+        return "\n".join([*lines, message])
+    lines += [t("corpus.launch.applied"), t("corpus.launch.base")]
+    facts = (corpus_facts(status) or {}).get("domains", {})
+    labels = corpus_domain_labels()
+    for name in applied:
+        content = _corpus_domain_content(
+            name, facts.get(name, {}).get("description") or t("corpus.launch.unknown"),
+        )
+        lines.append(f"• {labels.get(name, name)}: {content.splitlines()[0]}")
+    return "\n".join(lines)
+
+
+def _domain_description(info: dict[str, Any] | None, name: str = "") -> str:
+    """What this package is, and what choosing it costs.
+
+    The generic toggle hint was the description of every row, so the screen listed five
+    names and said the same sentence about all of them — nothing to choose on. The
+    package's own description carries what it is; the two figures carry what it costs,
+    and they are kept apart because they are spent differently: rules are in the global
+    that every session and every subagent loads, guides are on disk and read only when a
+    rule points at one."""
+    content = _corpus_domain_content(name, info.get("description", "") if info else "")
+    if info is None:
+        return "\n\n".join(filter(None, [content, t("corpus.toggle.description")]))
+    # Both keys are named at a literal call site rather than chosen into a variable:
+    # the catalog gate finds keys by reading the quoted argument of each t() call, so a
+    # computed key is a string no language is ever checked for.
+    if info["guides"]:
+        sizes = t("corpus.size.detail").format(
+            rules=info["rules"],
+            size=size_label(info["chars"]),
+            guides=info["guides"],
+            guide_size=size_label(info["guide_chars"]),
+        )
+    else:
+        sizes = t("corpus.size.detail.noguides").format(
+            rules=info["rules"], size=size_label(info["chars"]),
+        )
+    return "\n\n".join(filter(None, [content, sizes, t("corpus.toggle.description")]))
+
+
 def corpus_checklist(ui: "TextualUI | None") -> None:
     """Toggle-and-apply loop over the optional domain packages.
 
@@ -8125,12 +9014,25 @@ def corpus_checklist(ui: "TextualUI | None") -> None:
     applied = set(status_list(applied_raw))
     never_applied = applied_raw is None
     toggles = set(applied)
+    # What each package contains and costs. None when the installed package cannot be
+    # read, and every use below falls back to the bare name — a checklist that cannot
+    # size its packages is still a checklist, and this screen is how a user reaches the
+    # installer that would repair the projection.
+    facts = corpus_facts(status)
+    sized = (facts or {}).get("domains", {})
+    labels = corpus_domain_labels()
+    display_names = {name: f"{labels[name]} ({name})" if name in labels else name for name in available}
+    column = max(display_width(label) for label in display_names.values()) + 2
     while True:
         options = [
             MenuOption(
                 name,
-                f"[{'x' if name in toggles else ' '}] {name}",
-                t("corpus.toggle.description"),
+                checkbox_label(
+                    name in toggles,
+                    display_names[name] + " " * max(1, column - display_width(display_names[name])),
+                    "" if name not in sized else size_label(sized[name]["chars"]),
+                ),
+                _domain_description(sized.get(name), name),
             )
             for name in available
         ]
@@ -8150,7 +9052,12 @@ def corpus_checklist(ui: "TextualUI | None") -> None:
         try:
             choice = choose(
                 t("corpus.title"), options, CORPUS_APPLY, ui, allow_back=True,
-                corpus_lines=[t("corpus.core.line"), *corpus_summary_lines(status)],
+                corpus_lines=[
+                    t("corpus.core.line"),
+                    *([] if not sized else [t("corpus.size.legend")]),
+                    *corpus_summary_lines(status),
+                ],
+                confirm=CORPUS_APPLY,
             )
         except BackRequested:
             return
@@ -8229,25 +9136,33 @@ def pick_mode_and_preset(
     dropping all the way back to the top mode picker.
     """
     presets = config["presets"]
+    # User-authored preset descriptions stay as authored, including a local preset
+    # that replaces a built-in name. Translations belong only to the shipped choices.
+    user_names = set(load_user_presets(user_presets_path(config_path))) if config_path else set()
     mode = resume_mode
     while True:
+        status = load_corpus_status()
+        corpus_description = _corpus_launch_description(status)
         if mode is None:
             mode_options = [
-                MenuOption(SWE_MODE, t("mode.swe.label"), t("mode.swe.description")),
+                MenuOption(SWE_MODE, t("mode.swe.label"),
+                           t("mode.swe.description") + "\n\n" + corpus_description),
                 MenuOption(
                     DEFAULT_PRESET_MODE,
                     t("mode.builder.label"),
-                    t("mode.builder.description"),
+                    t("mode.builder.description") + "\n\n" + corpus_description,
                 ),
                 MenuOption(
                     DISTILL_MODE,
                     t("mode.distill.label"),
-                    t("mode.distill.description"),
+                    t("mode.distill.description") + "\n\n" + corpus_description,
                 ),
             ]
             mode_options.append(
                 MenuOption(
-                    CORPUS_OPTION, t("corpus.label"), t("corpus.description")
+                    CORPUS_OPTION,
+                    t("corpus.private.title") if private_corpus_enabled() else t("corpus.label"),
+                    t("corpus.private.description") if private_corpus_enabled() else t("corpus.description"),
                 )
             )
             if config_path is not None:
@@ -8290,9 +9205,15 @@ def pick_mode_and_preset(
                 DEFAULT_PRESET_MODE,
                 ui,
                 preview=preview_mode,
-                corpus_lines=corpus_summary_lines(load_corpus_status()),
+                corpus_lines=corpus_summary_lines(status),
             )
         if mode == CORPUS_OPTION:
+            if private_corpus_enabled():
+                if ui is not None:
+                    raise CorpusStudioRequested()
+                open_corpus_studio()
+                mode = None
+                continue
             _corpus_screen(ui, lambda: corpus_checklist(ui))
             mode = None
             continue
@@ -8311,7 +9232,9 @@ def pick_mode_and_preset(
             MenuOption(
                 name,
                 data["label"],
-                data.get("description", f"Launch the {data['label']} preset."),
+                (preset_descriptions().get(name, data.get("description", ""))
+                 if name not in user_names else data.get("description", ""))
+                + "\n\n" + corpus_description,
             )
             for name, data in presets.items()
             if preset_mode(data) == mode
@@ -8320,8 +9243,9 @@ def pick_mode_and_preset(
             options.append(
                 MenuOption(
                     CUSTOM_PRESET,
-                    "Custom",
-                    "Open a settings hub for tiers, review setup, policy, and final confirmation.",
+                    t("preset.custom.label"),
+                    t("preset.custom.description")
+                    + "\n\n" + corpus_description,
                 )
             )
         default = mode_default_preset(presets, mode) or CUSTOM_PRESET
@@ -8365,7 +9289,7 @@ def pick_mode_and_preset(
 
         try:
             selected = choose(
-                "Preset", options, default, ui, allow_back=True, preview=preview_preset
+                t("preset.title"), options, default, ui, allow_back=True, preview=preview_preset
             )
         except BackRequested:
             mode = None
@@ -8444,8 +9368,8 @@ def validate_review_setup(plan: dict[str, Any]) -> None:
     effective_review(plan)
 
 
-def tier_effort(plan: dict[str, Any], tier: str) -> str:
-    return plan["frontier_effort"] if tier == "frontier" else plan["tiers"][tier]["effort"]
+def tier_effort(plan: dict[str, Any], tier: str) -> str | None:
+    return plan["frontier_effort"] if tier == "frontier" else plan["tiers"][tier].get("effort")
 
 
 def child_agent_registrations(
@@ -8491,6 +9415,11 @@ def child_agent_registrations(
             raise LaunchError(f"Codex agent template requires description: {source}")
         data["model"] = plan["tiers"][tier]["model"]
         data["model_reasoning_effort"] = tier_effort(plan, tier)
+        if plan.get("corpus_instruction_text"):
+            # The child's own instruction body and the selected parent corpus are
+            # composed before the content-addressed config path is derived.
+            existing = data.get("developer_instructions", "")
+            data["developer_instructions"] = existing + "\n\n" + plan["corpus_instruction_text"]
         lines = []
         for key, value in data.items():
             if not isinstance(value, (str, int, float, bool)):
@@ -8633,7 +9562,9 @@ def _cross_review_route(
     main_family = LEGACY_HOST_FAMILY[plan["host"]][0]
     review_family = LEGACY_HOST_FAMILY[review_host][0]
     review_bindings = ", ".join(
-        f"{tier}={plan['review_tiers'][tier]['model']}/{plan['review_tiers'][tier]['effort']}"
+        f"{tier}={format_model_effort(
+            plan['review_tiers'][tier]['model'], plan['review_tiers'][tier].get('effort')
+        )}"
         for tier in TIER_ORDER
         if tier in plan["review_tiers"]
     )
@@ -8747,7 +9678,9 @@ def run_contract(
         # the session never received, which is round 18 #9's defect under a second cause
         # (round 23, #1).
         bindings = ", ".join(
-            f"{tier}={plan['tiers'][tier]['model']}/{tier_effort(plan, tier)}"
+            f"{tier}={format_model_effort(
+                plan['tiers'][tier]['model'], tier_effort(plan, tier)
+            )}"
             for tier in active_tiers(plan)
         )
         tiers_clause = f"tiers: {bindings}"
@@ -8769,8 +9702,9 @@ def run_contract(
         # set after one of the two reasons it can be inactive, and it happens to be the
         # branch that can hold the tier the name is false of (round 24, #12).
         tiers_clause = (
-            f"tiers: {main_tier}={plan['tiers'][main_tier]['model']}/"
-            f"{tier_effort(plan, main_tier)} only; inactive tiers "
+            f"tiers: {main_tier}={format_model_effort(
+                plan['tiers'][main_tier]['model'], tier_effort(plan, main_tier)
+            )} only; inactive tiers "
             f"({', '.join(inactive)}) are "
             f"inactive and not projected because {inactive_tier_reason(plan)}"
         )
@@ -8827,7 +9761,8 @@ def run_contract(
     # is the point: a command or an argument carrying a space would otherwise read as two.
     # Empty on every route that registers nothing, which includes every legacy one.
     registrations = (
-        review_mcp_servers(plan) if mcp_registrations is None else mcp_registrations
+        [] if sweep_main(plan)
+        else (review_mcp_servers(plan) if mcp_registrations is None else mcp_registrations)
     )
     mcp_clause = ""
     if registrations:
@@ -8872,17 +9807,17 @@ def run_contract(
         )
     if plan["delegation"]:
         authority = (
-            "Main and native child model/effort defaults are config-projected. Use the "
+            "Main and native child bindings are config-projected. Use the "
             "installed codex-run adapter when a separate child root or stricter reach "
             "boundary matters."
             if plan["host"] == "codex"
-            else "Main and child model/effort defaults are CLI-projected."
+            else "Main and child bindings are CLI-projected."
         )
     else:
         authority = (
-            "The main model/effort default is config-projected; no child binding is."
+            "The main binding is config-projected; no child binding is."
             if plan["host"] == "codex"
-            else "The main model/effort default is CLI-projected; no child binding is."
+            else "The main binding is CLI-projected; no child binding is."
         )
     mission = plan.get("mission")
     if mission and plan.get("trigger"):
@@ -8890,9 +9825,11 @@ def run_contract(
     mission_prefix = f"Mission: {mission} " if mission else ""
     prose = (
         f"{mission_prefix}"
-        f"LaunchPlan: main={main_tier} ({plan['tiers'][main_tier]['model']}/"
-        f"{tier_effort(plan, main_tier)}); {tiers_clause}. "
-        f"{delegation_clause(plan['delegation'])}"
+        f"LaunchPlan: main={main_tier} ({format_model_effort(
+            plan['tiers'][main_tier]['model'], tier_effort(plan, main_tier)
+        )}); {tiers_clause}. "
+        f"{delegation_clause(plan)}"
+        f"{sweep_main_clause(plan)}"
         f"{child_clause}"
         f"{execution_clause(plan)}"
         f"{review_section}"
@@ -8952,6 +9889,18 @@ def execution_clause(plan: dict[str, Any]) -> str:
 
     `standard` is named rather than omitted, because "no flag" is itself the posture: the
     backend's own default applies, and a silent contract cannot say which one that is."""
+    if sweep_main(plan):
+        if plan["host"] == "codex":
+            return (
+                "Execution=SWEEP restricted: Codex runs with --sandbox read-only; "
+                "the preset's ordinary execution policy is not projected. "
+            )
+        return (
+            "Execution=SWEEP restricted: Claude runs with --restricted and only "
+            "Read, Glob, and Grep available, plus --strict-mcp-config with an empty "
+            "MCP table so inherited MCP servers are unavailable; the preset's ordinary "
+            "permission mode is not projected. "
+        )
     if plan["host"] == "codex":
         policy = plan["codex_execution_policy"]
         if policy == STANDARD_POLICY:
@@ -8969,7 +9918,7 @@ def execution_clause(plan: dict[str, Any]) -> str:
     return f"Execution=claude permission mode {policy} (not an OS sandbox). "
 
 
-def delegation_clause(delegation: bool) -> str:
+def delegation_clause(plan: dict[str, Any]) -> str:
     """How the contract states delegation — and, when it is on, WHOSE decision that was.
 
     Claude Code's own Opus-5 prompt bundle appends "Do not call the AgentTool unless the
@@ -8983,7 +9932,12 @@ def delegation_clause(delegation: bool) -> str:
     corpus's standing spawn policy is their instruction — so the contract says so in the
     words that clause is looking for. Nothing is overridden; a fact that was already true
     is simply stated where the reader can see it."""
-    if not delegation:
+    if sweep_main(plan):
+        return (
+            "Delegation=off: SWEEP main disables child delegation to preserve its "
+            "read-only one-rule-per-item boundary. "
+        )
+    if not plan["delegation"]:
         return "Delegation=off. "
     return (
         "Delegation=on — the user requested delegation by selecting this launch, and their "
@@ -8991,19 +9945,43 @@ def delegation_clause(delegation: bool) -> str:
     )
 
 
+def sweep_main_clause(plan: dict[str, Any]) -> str:
+    """The executable role boundary for a SWEEP main, stated in its contract."""
+    if not sweep_main(plan):
+        return ""
+    return (
+        "SWEEP main: apply one explicit read-only rule per item; do not make semantic "
+        "judgments. "
+    )
+
+
 def claude_agents(plan: dict[str, Any]) -> str:
     roles = {}
     for tier in SPAWNABLE_TIERS:
         binding = plan["tiers"][tier]
-        roles[tier] = {
-            "description": f"{tier.upper()} tier: {binding['model']} at {tier_effort(plan, tier)}",
-            "prompt": (
-                f"Act as the bounded {tier.upper()} role at requested effort "
-                f"{tier_effort(plan, tier)}. Return evidence and verification; stay in scope."
-            ),
+        effort = tier_effort(plan, tier)
+        prompt = (
+            f"Act as the bounded {tier.upper()} role"
+            + (f" at requested effort {effort}" if effort is not None else "")
+            + ". Return evidence and verification; stay in scope."
+        )
+        if tier == "sweep":
+            # Sweep is the mechanical, read-only lane. The narrow native tool
+            # allowlist enforces its one-rule-per-item contract instead of merely
+            # restating it in the prompt.
+            prompt += " Apply one explicit read-only rule per item; do not make semantic judgments."
+        if plan.get("corpus_instruction_text"):
+            prompt += "\n\n" + plan["corpus_instruction_text"]
+        role = {
+            "description": f"{tier.upper()} tier: {format_model_effort(binding['model'], effort)}",
+            "prompt": prompt,
             "model": binding["model"],
-            "effort": tier_effort(plan, tier),
         }
+        if effort is not None:
+            role["effort"] = effort
+        if tier == "sweep":
+            role["tools"] = ["Read", "Glob", "Grep"]
+        roles[tier] = role
     return json.dumps(roles, separators=(",", ":"))
 
 
@@ -9011,6 +9989,10 @@ MCP_STDIO_ADAPTER = "mcp-stdio-v1"
 # The argv every stdio MCP capability registered here uses today. A capability
 # needing different arguments is a registry data addition, not a branch.
 MCP_STDIO_ARGS = ["mcp"]
+# SWEEP's native capability surface is intentionally empty. `--restricted` alone
+# does not exclude inherited MCP servers, so its matching strict flag and this
+# explicit empty table travel together in the Claude argv.
+SWEEP_EMPTY_MCP_CONFIG = json.dumps({"mcpServers": {}}, separators=(",", ":"))
 
 
 def review_mcp_servers(plan: dict[str, Any]) -> list[tuple[str, str, list[str]]]:
@@ -9256,7 +10238,10 @@ def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[
     # L7). The child projection is computed exactly where both of its consumers live:
     # codex argv with delegation on, and the contract's child clause, which renders under
     # the same condition.
-    mcp_registrations = review_mcp_servers(plan)
+    # SWEEP exposes no MCP capability surface. Do not even compute a selected
+    # registration set: a row that reaches argv through an inherited or review
+    # path would contradict its strict empty MCP configuration.
+    mcp_registrations = [] if sweep_main(plan) else review_mcp_servers(plan)
     child_registrations = (
         child_agent_registrations(plan)
         if plan["delegation"] and host == "codex"
@@ -9270,7 +10255,7 @@ def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[
             "-c", f"developer_instructions={json.dumps(contract)}",
             "-c", f"features.multi_agent={'true' if plan['delegation'] else 'false'}",
         ]
-        policy = plan["codex_execution_policy"]
+        policy = "read-only" if sweep_main(plan) else plan["codex_execution_policy"]
         if policy == "bypass":
             policy_args = ["--dangerously-bypass-approvals-and-sandbox"]
         elif policy == STANDARD_POLICY:
@@ -9293,15 +10278,23 @@ def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[
                 "-c", f"mcp_servers.{name}.args={json.dumps(server_args)}",
             ]
         return args
-    args = [
-        "--model", main["model"],
-        "--effort", main_effort,
-        "--append-system-prompt", contract,
-    ]
+    args = ["--model", main["model"]]
+    if main_effort is not None:
+        args += ["--effort", main_effort]
+    args += ["--append-system-prompt", contract]
     if plan["delegation"]:
         args += ["--agents", claude_agents(plan)]
     policy = plan["claude_permission_mode"]
-    if policy == "bypassPermissions":
+    if sweep_main(plan):
+        policy_args = [
+            "--restricted",
+            "--tools",
+            "Read,Glob,Grep",
+            "--strict-mcp-config",
+            "--mcp-config",
+            SWEEP_EMPTY_MCP_CONFIG,
+        ]
+    elif policy == "bypassPermissions":
         policy_args = ["--dangerously-skip-permissions"]
     elif policy == STANDARD_POLICY:
         policy_args = []
@@ -9349,8 +10342,8 @@ def print_summary(
         )
     else:
         print(
-            f"  Main           {plan['main_tier'].upper()} · {main['model']} · "
-            f"{tier_effort(plan, plan['main_tier'])}",
+            f"  Main           {plan['main_tier'].upper()} · "
+            f"{format_model_effort(main['model'], tier_effort(plan, plan['main_tier']), ' · ')}",
             file=stream,
         )
         # The same set run_contract and both argv builders take. This one did not branch at
@@ -9362,7 +10355,11 @@ def print_summary(
             for tier in active_tiers(plan):
                 binding = plan["tiers"][tier]
                 effort = tier_effort(plan, tier)
-                print(f"  {tier.upper():<14} {binding['model']} · {effort}", file=stream)
+                print(
+                    f"  {tier.upper():<14} "
+                    f"{format_model_effort(binding['model'], effort, ' · ')}",
+                    file=stream,
+                )
         inactive = inactive_tiers(plan)
         if inactive:
             # Named rather than dropped, matching the contract's wording, so the reader still
@@ -9421,9 +10418,9 @@ def print_summary(
         )
         tier_authority = (
             (
-                "base main + native child model/effort configured"
+                "base main + native child bindings configured"
                 if plan["host"] == "codex"
-                else "base main + child model/effort configured"
+                else "base main + child bindings configured"
             )
             if plan["delegation"]
             else "base main only; no child binding is projected"
@@ -9439,7 +10436,16 @@ def print_summary(
     # applies no permission flag — the Projection line says so — and naming one here would
     # contradict it two lines later.
     if not plan_projects_nothing(plan):
-        if plan["host"] == "codex":
+        if sweep_main(plan):
+            if plan["host"] == "codex":
+                print("  Execution      SWEEP restricted · Codex sandbox read-only", file=stream)
+            else:
+                print(
+                    "  Execution      SWEEP restricted · Claude Read/Glob/Grep only · "
+                    "strict empty MCP",
+                    file=stream,
+                )
+        elif plan["host"] == "codex":
             print(f"  Execution      Codex {plan['codex_execution_policy']}", file=stream)
         else:
             print(
@@ -9447,6 +10453,18 @@ def print_summary(
                 "(permission mode, not OS sandbox)",
                 file=stream,
             )
+        if private_corpus_enabled():
+            print(
+                "  Global files   "
+                + t("global-instructions.summary").format(
+                    choice=t(
+                        "global-instructions.include.label"
+                        if plan.get("include_global_instructions", True)
+                        else "global-instructions.exclude.label"
+                    )
+                ),
+                file=stream,
+            )
     print(f"  Backend        {command}", file=stream)
     if os.environ.get("AGENT_LAUNCH_DEBUG") == "1":
         print("  Argv           " + json.dumps([command, *args]), file=stream)
@@ -9517,6 +10535,15 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     )
     parser.add_argument("--yes", action="store_true", help="skip launch confirmation")
     parser.add_argument("--dry-run", action="store_true", help="print projection without launching")
+    parser.add_argument("--corpus", action="store_true", help="open private Corpus Studio")
+    parser.add_argument("--corpus-domains", help="domain selection for this activated session only")
+    parser.add_argument("--corpus-native", action="store_true", help="opt into selected Claude corpus hook execution and native agents for this session only")
+    parser.add_argument(
+        "--exclude-global-instructions",
+        action="store_true",
+        help="omit only personal global AGENTS.md/CLAUDE.md files and imports for this private Claude session",
+    )
+    parser.add_argument("--resume-session", help="resume a host session with its pinned corpus")
     parser.add_argument(
         "--verify-receipts", nargs=2, metavar=("PLAN", "RECEIPTS"),
         help="adjudicate a ReviewPlan/v1 record against a ReviewReceipts/v1 bundle and exit",
@@ -9588,7 +10615,7 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     hostless = (
         args.verify_receipts or args.emit_receipt or args.fold_receipts
         or args.check_adapter or args.compile_criterion or args.check_findings
-        or args.check_schema_flag
+        or args.check_schema_flag or args.corpus
     )
     if args.host is None and not hostless:
         parser.error("the following arguments are required: host")
@@ -9828,6 +10855,9 @@ def _tolerate_narrow_stdout() -> None:
 def main(argv: list[str]) -> int:
     _tolerate_narrow_stdout()
     args = parse_args(drop_check_adapter_separator(argv))
+    if args.corpus:
+        open_corpus_studio()
+        return 0
     if args.verify_receipts:
         return verify_receipts_command(
             *args.verify_receipts, config_path=args.config.expanduser(),
@@ -9850,8 +10880,59 @@ def main(argv: list[str]) -> int:
             raise LaunchError("--check-adapter takes a seat and then the adapter command")
         return check_adapter_command(args.check_adapter[0], args.check_adapter[1:])
     config_path = args.config.expanduser()
-    config = load_config(config_path)
+    generation = None
+    if private_corpus_enabled():
+        bare = not args.preset and not args.custom and not args.dry_run and (
+            args.no_tui or bool(args.forward) or os.environ.get("AGENT_LAUNCH_TUI") == "0"
+            or not (sys.stdin.isatty() and sys.stdout.isatty()))
+        config, generation = _load_private_config(
+            config_path, replay_only=bool(args.resume_session or bare or args.preset == "vanilla"))
+    else:
+        config = load_config(config_path)
     command, bare_args = resolve_backend(config, args.host)
+    if args.exclude_global_instructions and not args.resume_session:
+        if not private_corpus_enabled():
+            raise LaunchError(
+                "excluding global instruction files requires an agent-bios activated session"
+            )
+        if args.host == "codex":
+            raise LaunchError(
+                "the current Codex adapter does not support a safe way to exclude only "
+                "global instruction files"
+            )
+        # Make the CLI choice the starting state Custom sees, rather than a late override
+        # that could contradict its visible row or the preset it saves. This is an
+        # invocation-local copy: no profile or user preset is rewritten merely by using
+        # the flag. The distill hub eventually starts its configured preset too.
+        config = copy.deepcopy(config)
+        for preset in config.get("presets", {}).values():
+            if isinstance(preset, dict):
+                preset["include_global_instructions"] = False
+    if args.corpus_native and not private_corpus_enabled():
+        raise LaunchError("--corpus-native requires a private installation; run agent-bios install first")
+    if private_corpus_enabled():
+        # Private templates retain the native host's config home and registrations.
+        private_root = corpus_package_root()
+        os.environ["AGENT_BIOS_PACKAGE_ROOT"] = str(private_root)
+        config["hosts"]["codex"]["agent_templates"] = {
+            tier: str(private_root / "codex/agents" / f"{tier}.toml") for tier in SPAWNABLE_TIERS
+        }
+    if args.resume_session:
+        if (
+            args.corpus_native
+            or args.corpus_domains is not None
+            or args.exclude_global_instructions
+        ):
+            raise LaunchError(
+                "resume uses its pinned corpus/native/global-instruction configuration; "
+                "start a new session to change it"
+            )
+        if not private_corpus_enabled():
+            raise LaunchError("a corpus-pinned resume requires a private installation")
+        store = corpus_store()
+        import corpus_session
+        return corpus_session.launch(command, [], store.state_root, args.host, {},
+                                     resume_id=args.resume_session)
     nudge = session_distill_nudge(config)
     if nudge:
         print(f"agent-launch: {nudge}", file=sys.stderr)
@@ -9867,6 +10948,12 @@ def main(argv: list[str]) -> int:
         args.preset = "balanced"
     bypass = args.no_tui or bool(args.forward) or os.environ.get("AGENT_LAUNCH_TUI") == "0"
     if (bypass or not tty) and not args.preset and not args.custom and not args.dry_run:
+        if (
+            args.corpus_native
+            or args.corpus_domains is not None
+            or args.exclude_global_instructions
+        ):
+            raise LaunchError("corpus launch options require --preset NAME or an interactive configured launch")
         # The bare launch: nothing decides policy but the backend's own bare-launch
         # arguments. Every other path below projects the preset's policy instead.
         exec_backend(command, [*bare_args, *args.forward])
@@ -9924,7 +11011,39 @@ def main(argv: list[str]) -> int:
             # status projection afterwards.
             run_corpus_apply(request.selection)
             continue
+        except CorpusStudioRequested:
+            open_corpus_studio()
+            continue
     validate_review_setup(plan)
+    if not plan.get("include_global_instructions", True):
+        if not private_corpus_enabled():
+            raise LaunchError(
+                "excluding global instruction files requires an agent-bios activated session"
+            )
+        if plan_projects_nothing(plan):
+            raise LaunchError(
+                "excluding global instruction files is unavailable for Vanilla; start a private configured session"
+            )
+        if args.host == "codex":
+            raise LaunchError(
+                "the current Codex adapter does not support a safe way to exclude only "
+                "global instruction files"
+            )
+    snapshot = None
+    store = None
+    if private_corpus_enabled() and not plan_projects_nothing(plan):
+        store = corpus_store()
+        selected = None
+        if args.corpus_domains is not None:
+            raw = [x.strip() for x in args.corpus_domains.split(",") if x.strip()]
+            if "none" in raw and raw != ["none"]:
+                raise LaunchError("--corpus-domains none cannot be combined with other domains")
+            selected = [] if raw == ["none"] else [
+                x if x.startswith("@") else f"@agent-bios/core/{x}" for x in raw
+            ]
+        snapshot = _snapshot_from_config(store, config_path, generation, args.host, selected,
+                                         dry_run=args.dry_run, native=args.corpus_native)
+        plan["corpus_instruction_text"] = snapshot["instruction_text"]
     projected_args = project_args(plan, materialize_agents=not args.dry_run)
     collisions = forwarded_collisions(projected_args, args.forward)
     if collisions:
@@ -9934,7 +11053,23 @@ def main(argv: list[str]) -> int:
             f"preset or --custom, or launch bare (no --preset) to pass them through"
         )
     projected = [*projected_args, *args.forward]
+    if snapshot is not None and args.dry_run:
+        import corpus_session
+        projected = corpus_session.compose_argv(
+            command,
+            projected,
+            args.host,
+            snapshot,
+            include_global_instructions=plan["include_global_instructions"],
+        )
     summary_stream = sys.stdout if tty or args.dry_run else sys.stderr
+    if snapshot is not None:
+        print(f"  Corpus snapshot {snapshot['content_ref']} · private · next session only", file=summary_stream)
+        if args.corpus_native:
+            plugins = snapshot.get("assets", {}).get("claude_plugins", [])
+            print(f"  Native corpus opt-in: {len(plugins)} session-only plugin(s); selected hook code can execute.", file=summary_stream)
+        for unavailable in snapshot.get("unavailable", []):
+            print(f"  Corpus unavailable: {unavailable}", file=summary_stream)
     print_summary(plan, command, projected, summary_stream, bool(args.forward))
     trigger = plan.get("trigger")
     if trigger:
@@ -9961,6 +11096,11 @@ def main(argv: list[str]) -> int:
     env = os.environ.copy()
     env["AGENT_LAUNCH_ACTIVE"] = "1"
     summary_stream.flush()
+    if snapshot is not None:
+        import corpus_session
+        return corpus_session.launch(command, projected, store.state_root, args.host,
+                                     snapshot, env=env,
+                                     include_global_instructions=plan["include_global_instructions"])
     exec_backend(command, projected, env)
 
 
@@ -9970,6 +11110,9 @@ if __name__ == "__main__":
     except LaunchError as exc:
         print(f"agent-launch: {exc}", file=sys.stderr)
         raise SystemExit(2)
+    except RuntimeError as exc:
+        print(f"agent-launch: {type(exc).__name__}: {exc}", file=sys.stderr)
+        raise SystemExit(2)
     except KeyboardInterrupt:
         print("\nCancelled.", file=sys.stderr)
         raise SystemExit(130)