agent-bios 0.3.0 → 0.4.0

package/scripts/agent-launch.py

@@ -44,6 +44,17 @@ EFFORT_DESCRIPTIONS = {
 }
 CUSTOM_PRESET = "__custom__"
 OTHER_MODEL = "__other_model__"
+# Root-menu grouping for presets: "builder" (tunable, includes Custom), "general"
+# (plain CLI presets like Vanilla), "distill" (opens the Session Distill hub).
+# A preset with a missing/unknown mode defaults to "builder" so presets written
+# before this field existed (including saved/local user presets) keep working.
+GENERAL_MODE = "general"
+DEFAULT_PRESET_MODE = "builder"
+# The mode value that opens the Session Distill hub instead of a preset
+# submenu; doubles as the option value on the root Mode menu so selecting it
+# needs no translation.
+DISTILL_MODE = "distill"
+PRESET_MODES = (GENERAL_MODE, DEFAULT_PRESET_MODE, DISTILL_MODE)
 # User-saved presets live beside the deployed config, in a file the installer
 # neither deploys nor verifies, so they survive `agent-bios install`.
 USER_PRESETS_NAME = "presets.local.toml"
@@ -62,8 +73,9 @@ class MenuOption:
     description: str
     enabled: bool = True
     unavailable_reason: str = ""
-CODEX_POLICIES = {"bypass", "workspace-write", "read-only"}
-CLAUDE_POLICIES = {"acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan"}
+STANDARD_POLICY = "standard"
+CODEX_POLICIES = {"bypass", "workspace-write", "read-only", STANDARD_POLICY}
+CLAUDE_POLICIES = {"acceptEdits", "auto", "bypassPermissions", "manual", "dontAsk", "plan", STANDARD_POLICY}
 REVIEW_SETUPS = {
     "none": {
         "label": "None",
@@ -543,7 +555,6 @@ _UI_CANCEL = "\x00cancel"
 def _build_app_class():
     """Import textual lazily and build the App/Screen classes, so importing this
     module and every non-interactive path stays free of the textual dependency."""
-    from rich.text import Text
     from textual import work
     from textual.app import App
     from textual.binding import Binding
@@ -583,8 +594,8 @@ def _build_app_class():
         border: round $secondary; border-title-color: $secondary;
         border-title-style: bold; padding: 0 1; height: 5;
     }
-    #al-learning-title { background: $warning; color: black; text-style: bold; padding: 0 1; }
-    #al-learning {
+    #al-corpus-title { background: $warning; color: black; text-style: bold; padding: 0 1; }
+    #al-corpus {
         border: round $warning; padding: 0 1; height: auto;
     }
     #al-hdr { color: $text-muted; text-style: bold; padding: 0 1; }
@@ -606,7 +617,7 @@ def _build_app_class():
         ]
 
         def __init__(
-            self, title, options, default, allow_back, plan, preview=None, learning=None
+            self, title, options, default, allow_back, plan, preview=None, corpus=None
         ):
             super().__init__()
             self._title = title
@@ -615,14 +626,14 @@ def _build_app_class():
             self._allow_back = allow_back
             self._plan = plan
             self._preview = preview
-            self._learning = learning
+            self._corpus = corpus
 
         def compose(self):
             yield Static(self._title, id="al-title")
             yield setup_panel(self._plan)
-            if self._learning:
-                yield Static("Session Learning", id="al-learning-title")
-                yield Static("\n".join(self._learning), id="al-learning")
+            if self._corpus:
+                yield Static("Corpus status", id="al-corpus-title")
+                yield Static("\n".join(self._corpus), id="al-corpus")
             detail = Static("", id="al-detail")
             detail.border_title = "About highlighted option"
             yield detail
@@ -632,19 +643,6 @@ def _build_app_class():
             option_list = OptionList()
             for option in self._options:
                 label = option.label + ("" if option.enabled else "  [unavailable]")
-                if option.value == LEARNING_HUB:
-                    # The learning area is a different kind of destination than
-                    # the launch presets: separated, marked, and warning-toned
-                    # to match its status panel.
-                    option_list.add_option(None)
-                    option_list.add_option(
-                        Option(
-                            Text(f"◆ {label}", style="bold yellow"),
-                            id=option.value,
-                            disabled=not option.enabled,
-                        )
-                    )
-                    continue
                 option_list.add_option(
                     Option(label, id=option.value, disabled=not option.enabled)
                 )
@@ -803,12 +801,12 @@ class TextualUI:
         default: str,
         allow_back: bool,
         preview=None,
-        learning_lines: list[str] | None = None,
+        corpus_lines: list[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, learning_lines
+                title, options, default, allow_back, self.plan, preview, corpus_lines
             ),
         )
         if result == _UI_BACK:
@@ -849,21 +847,18 @@ def choose_lines(
     options: list[MenuOption],
     default: str,
     allow_back: bool,
-    learning_lines: list[str] | None = None,
+    corpus_lines: list[str] | None = None,
 ) -> str:
     print(f"\n{title}")
-    if learning_lines:
-        print("  -- Session Learning --")
-        for line in learning_lines:
+    if corpus_lines:
+        print("  -- Corpus status --")
+        for line in corpus_lines:
             print(f"  {line}")
         print("  --")
     for index, option in enumerate(options, 1):
         marker = "" if option.enabled else " [unavailable]"
         selected = " *" if option.value == default and option.enabled else ""
         label = option.label
-        if option.value == LEARNING_HUB:
-            print("  " + "-" * 30)
-            label = f"◆ {label}"
         print(f"  {index}. {label}{marker}{selected} - {option.description}")
         if not option.enabled:
             print(f"     Unavailable: {option.unavailable_reason}")
@@ -898,13 +893,13 @@ def choose(
     ui: TextualUI | None = None,
     allow_back: bool = False,
     preview=None,
-    learning_lines: list[str] | None = None,
+    corpus_lines: list[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, learning_lines)
-    return choose_lines(title, options, default, allow_back, learning_lines)
+        return ui.choose(title, options, default, allow_back, preview, corpus_lines)
+    return choose_lines(title, options, default, allow_back, corpus_lines)
 
 
 def read_input(prompt: str) -> str:
@@ -995,6 +990,11 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
     label = preset.get("label", preset_name)
     if not isinstance(label, str) or not label:
         raise LaunchError(f"invalid label in preset {preset_name}")
+    mode = preset.get("mode")
+    if not isinstance(mode, str) or mode not in PRESET_MODES:
+        # Missing/unknown mode (older or user/local presets) defaults to builder
+        # rather than failing closed, so existing presets keep working unchanged.
+        mode = DEFAULT_PRESET_MODE
     mission = preset.get("mission")
     if mission is not None and (not isinstance(mission, str) or not mission):
         raise LaunchError(f"presets.{preset_name}.mission must be a non-empty string")
@@ -1024,6 +1024,7 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         "preset": preset_name,
         "label": label,
         "description": preset.get("description", f"Launch the {label} preset."),
+        "mode": mode,
         "main_tier": main_tier,
         "frontier_effort": frontier_effort,
         "review_setup": review_setup,
@@ -1226,6 +1227,11 @@ def customize(
                 "Read-only sandbox",
                 "Allow inspection while blocking file writes through the Codex sandbox.",
             ),
+            MenuOption(
+                STANDARD_POLICY,
+                "Standard",
+                "Pass no policy flag; use Codex's own default approval and sandbox behavior.",
+            ),
         ]
         policy_field = "codex_execution_policy"
         policy_title = "Codex execution policy"
@@ -1261,6 +1267,11 @@ def customize(
                 "Plan mode",
                 "Start Claude in planning mode without direct implementation.",
             ),
+            MenuOption(
+                STANDARD_POLICY,
+                "Standard",
+                "Pass no policy flag; use Claude's own default permission prompts.",
+            ),
         ]
         policy_field = "claude_permission_mode"
         policy_title = "Claude permission mode (not an OS sandbox)"
@@ -1439,28 +1450,27 @@ def customize(
             raise KeyboardInterrupt
 
 
-LEARNING_HUB = "__learning__"
-LEARNING_PRESET = "session-learning"
-LEARNING_STATUS_PATH = pathlib.Path(
+DISTILL_PRESET = "session-distill"
+CORPUS_STATUS_PATH = pathlib.Path(
     os.environ.get(
-        "AGENT_BIOS_LEARNING_STATUS",
-        str(pathlib.Path.home() / ".local/share/agent-bios/learning-status.json"),
+        "AGENT_BIOS_CORPUS_STATUS",
+        str(pathlib.Path.home() / ".local/share/agent-bios/corpus-status.json"),
     )
 )
 
 
-def load_learning_status() -> dict[str, Any] | None:
+def load_corpus_status() -> dict[str, Any] | None:
     try:
-        return json.loads(LEARNING_STATUS_PATH.read_text())
+        return json.loads(CORPUS_STATUS_PATH.read_text())
     except (OSError, ValueError):
         return None
 
 
-def learning_summary_lines(status: dict[str, Any] | None) -> list[str]:
-    """Panel body for the Session Learning area: which learning content is
+def corpus_summary_lines(status: dict[str, Any] | None) -> list[str]:
+    """Panel body for the Session Distill area: which corpus content is
     live, through which mechanisms, and whether the corpus is rolled back."""
     if status is None:
-        return ["learning status not projected yet — run: agent-bios install"]
+        return ["corpus status not projected yet — run: agent-bios install"]
     current = status.get("current_version", "?")
     latest = status.get("latest_version", "?")
     head = f"Applied version  {current}"
@@ -1481,26 +1491,26 @@ def learning_summary_lines(status: dict[str, Any] | None) -> list[str]:
     ]
 
 
-def _learning_info(ui: TextualUI | None, title: str, lines: list[str]) -> None:
+def _corpus_info(ui: TextualUI | None, title: str, lines: list[str]) -> None:
     """Info screen in both UIs: options carry the content; only exit is back."""
-    options = [MenuOption("back", "Back", "Return to Session Learning.")]
+    options = [MenuOption("back", "Back", "Return to Session Distill.")]
     try:
-        choose(title, options, "back", ui, allow_back=True, learning_lines=lines)
+        choose(title, options, "back", ui, allow_back=True, corpus_lines=lines)
     except BackRequested:
         pass
 
 
-def _learning_rollback(status: dict[str, Any], version: str, ui: TextualUI | None) -> None:
+def _corpus_rollback(status: dict[str, Any], version: str, ui: TextualUI | None) -> None:
     confirm = choose(
-        f"Roll back learning corpus to {version}?",
+        f"Roll back corpus to {version}?",
         [
             MenuOption(
-                "cancel", "Cancel", "Keep the currently deployed learning content."
+                "cancel", "Cancel", "Keep the currently deployed corpus content."
             ),
             MenuOption(
                 "rollback",
                 f"Roll back to {version}",
-                "Re-deploys globals/guides/hooks as of that learning version. "
+                "Re-deploys globals/guides/hooks as of that corpus version. "
                 "System deployment (launcher, wrappers) stays current. Roll "
                 "forward again by selecting the latest version.",
             ),
@@ -1511,7 +1521,7 @@ def _learning_rollback(status: dict[str, Any], version: str, ui: TextualUI | Non
     )
     if confirm != "rollback":
         return
-    script = pathlib.Path(status["repo"]) / "scripts/session-learning/learning-state.py"
+    script = pathlib.Path(status["repo"]) / "scripts/session-distill/corpus-state.py"
     result = subprocess.run(
         [sys.executable, str(script), "rollback", "--version", version],
         capture_output=True,
@@ -1520,14 +1530,14 @@ def _learning_rollback(status: dict[str, Any], version: str, ui: TextualUI | Non
     output = (result.stdout + result.stderr).strip().splitlines()
     tail = output[-1] if output else ""
     verdict = "Rollback complete." if result.returncode == 0 else "Rollback FAILED."
-    _learning_info(ui, verdict, [tail] if tail else [])
+    _corpus_info(ui, verdict, [tail] if tail else [])
 
 
-def _learning_versions(ui: TextualUI | None) -> None:
+def _corpus_versions(ui: TextualUI | None) -> None:
     while True:
-        status = load_learning_status()
+        status = load_corpus_status()
         if status is None:
-            _learning_info(ui, "Versions & rollback", learning_summary_lines(None))
+            _corpus_info(ui, "Versions & rollback", corpus_summary_lines(None))
             return
         current = status.get("current_version")
         options = []
@@ -1542,7 +1552,7 @@ def _learning_versions(ui: TextualUI | None) -> None:
                     f"{v.get('summary', '')}",
                 )
             )
-        options.append(MenuOption("back", "Back", "Return to Session Learning."))
+        options.append(MenuOption("back", "Back", "Return to Session Distill."))
         try:
             selected = choose(
                 "Versions & rollback",
@@ -1550,91 +1560,91 @@ def _learning_versions(ui: TextualUI | None) -> None:
                 options[0].value,
                 ui,
                 allow_back=True,
-                learning_lines=learning_summary_lines(status),
+                corpus_lines=corpus_summary_lines(status),
             )
         except BackRequested:
             return
         if selected == "back":
             return
         if selected == current:
-            _learning_info(
+            _corpus_info(
                 ui,
                 f"{selected} is the currently applied version",
                 ["Select a different version to roll back or forward."],
             )
             continue
-        _learning_rollback(status, selected, ui)
+        _corpus_rollback(status, selected, ui)
 
 
-def _learning_packages(ui: TextualUI | None) -> None:
+def _corpus_packages(ui: TextualUI | None) -> None:
     """v1: the corpus ships as a single core package; the list shape is ready
     for the domain-packaging backlog to populate with real packages."""
-    status = load_learning_status()
+    status = load_corpus_status()
     if status is None:
-        _learning_info(ui, "Learning packages", learning_summary_lines(None))
+        _corpus_info(ui, "Corpus packages", corpus_summary_lines(None))
         return
     layers = status.get("summary", {}).get("placed_by_layer", {})
     options = [
         MenuOption(
             "core",
             f"core corpus @ {status.get('current_version', '?')}",
-            "All learning domains in one package until domain packaging "
+            "All corpus domains in one package until domain packaging "
             f"lands (backlog). Layers: {json.dumps(layers, separators=(', ', ' '))}. "
             "Per-domain selection, versions, and rollback will appear here.",
         ),
-        MenuOption("back", "Back", "Return to Session Learning."),
+        MenuOption("back", "Back", "Return to Session Distill."),
     ]
     try:
         choose(
-            "Learning packages",
+            "Corpus packages",
             options,
             "back",
             ui,
             allow_back=True,
-            learning_lines=learning_summary_lines(status),
+            corpus_lines=corpus_summary_lines(status),
         )
     except BackRequested:
         pass
 
 
-def learning_hub(config: dict[str, Any], ui: TextualUI | None) -> str:
-    """Session Learning area: status, packages, versions/rollback, session start.
+def distill_hub(config: dict[str, Any], ui: TextualUI | None) -> str:
+    """Session Distill area: status, packages, versions/rollback, session start.
 
-    Returns "start" to launch the learning-session preset, "back" otherwise.
+    Returns "start" to launch the session-distill preset, "back" otherwise.
     """
     while True:
-        status = load_learning_status()
+        status = load_corpus_status()
         options = [
             MenuOption(
                 "start",
-                "Start a learning session",
-                "Launch with the Session learning preset: the mission line "
+                "Start a session distill run",
+                "Launch with the Session distill preset: the mission line "
                 "directs the session to the workflow guide and the SSOT.",
-                enabled=LEARNING_PRESET in config["presets"],
-                unavailable_reason=f"preset {LEARNING_PRESET!r} not configured",
+                enabled=DISTILL_PRESET in config["presets"],
+                unavailable_reason=f"preset {DISTILL_PRESET!r} not configured",
             ),
             MenuOption(
                 "packages",
-                "Learning packages",
-                "What learning content is applied, as installable packages "
+                "Corpus packages",
+                "What corpus content is applied, as installable packages "
                 "(v1: single core corpus).",
             ),
             MenuOption(
                 "versions",
                 "Versions & rollback",
-                "Learning content versions (distinct from system deployment); "
+                "Corpus content versions (distinct from system deployment); "
                 "roll the corpus back or forward.",
             ),
             MenuOption("back", "Back", "Return to the launch menu."),
         ]
         try:
             selected = choose(
-                "Session Learning",
+                "Session Distill",
                 options,
                 "start",
                 ui,
                 allow_back=True,
-                learning_lines=learning_summary_lines(status),
+                corpus_lines=corpus_summary_lines(status),
             )
         except BackRequested:
             return "back"
@@ -1643,34 +1653,106 @@ def learning_hub(config: dict[str, Any], ui: TextualUI | None) -> str:
         if selected == "start":
             return "start"
         if selected == "packages":
-            _learning_packages(ui)
+            _corpus_packages(ui)
         elif selected == "versions":
-            _learning_versions(ui)
+            _corpus_versions(ui)
 
 
-def select_plan(
+def preset_mode(data: dict[str, Any]) -> str:
+    """A preset's root-menu group. Missing/unknown falls back to builder — the
+    same default build_plan applies — so listing presets for a menu never
+    raises on a not-yet-migrated user preset."""
+    mode = data.get("mode")
+    return mode if isinstance(mode, str) and mode in PRESET_MODES else DEFAULT_PRESET_MODE
+
+
+def mode_default_preset(presets: dict[str, Any], mode: str) -> str | None:
+    """First configured preset in a mode; builder prefers 'balanced' so the
+    long-standing everyday default stays the highlighted choice. None means
+    the mode has no presets configured (only reachable via a stripped-down
+    user config; Custom still covers builder in that case)."""
+    names = [name for name, data in presets.items() if preset_mode(data) == mode]
+    if mode == DEFAULT_PRESET_MODE and "balanced" in names:
+        return "balanced"
+    return names[0] if names else None
+
+
+def pick_mode_and_preset(
     config: dict[str, Any],
     host: str,
-    preset_name: str | None,
-    custom_requested: bool,
-    ui: TextualUI | None = None,
-    config_path: pathlib.Path | None = None,
-) -> dict[str, Any]:
+    ui: TextualUI | None,
+    resume_mode: str | None,
+) -> tuple[str, bool, str]:
+    """Root menu: a 3-way mode picker (General user / Builder / Session
+    distill), then that mode's preset submenu (Builder also lists Custom).
+
+    Esc in the submenu returns to the mode picker; Esc at the mode picker
+    cancels the launcher, matching the picker's prior root Esc/q semantics.
+    Returns (preset_name, custom_requested, mode) — the mode is handed back so
+    a later Esc out of the Custom hub resumes this same submenu instead of
+    dropping all the way back to the top mode picker.
+    """
     presets = config["presets"]
-    explicit_preset = preset_name
-    show_picker = explicit_preset is None
+    mode = resume_mode
     while True:
-        selected_name = explicit_preset
-        selected_custom = custom_requested
-        if show_picker:
-            options = [
+        if mode is None:
+            mode_options = [
                 MenuOption(
-                    name,
-                    data["label"],
-                    data.get("description", f"Launch the {data['label']} preset."),
-                )
-                for name, data in presets.items()
+                    GENERAL_MODE,
+                    "General user",
+                    "Plain presets with nothing launch-specific applied, like "
+                    "Vanilla: no tier bindings or launch contract.",
+                ),
+                MenuOption(
+                    DEFAULT_PRESET_MODE,
+                    "Builder",
+                    "Tune tiers, review routes, and permissions across fixed "
+                    "presets; includes Custom.",
+                ),
+                MenuOption(
+                    DISTILL_MODE,
+                    "Session distill",
+                    "Enter the dedicated session-distill hub: status, "
+                    "packages, versions, and session start.",
+                ),
             ]
+
+            def preview_mode(value: str) -> dict[str, Any] | None:
+                target = (
+                    DISTILL_PRESET
+                    if value == DISTILL_MODE
+                    else mode_default_preset(presets, value)
+                )
+                return build_plan(config, host, target) if target else None
+
+            initial = preview_mode(DEFAULT_PRESET_MODE)
+            if ui is not None and initial is not None:
+                ui.set_plan(initial)
+            mode = choose(
+                "Mode",
+                mode_options,
+                DEFAULT_PRESET_MODE,
+                ui,
+                preview=preview_mode,
+                corpus_lines=corpus_summary_lines(load_corpus_status()),
+            )
+        if mode == DISTILL_MODE:
+            if distill_hub(config, ui) != "start":
+                mode = None
+                continue
+            if DISTILL_PRESET not in presets:
+                raise LaunchError(f"preset {DISTILL_PRESET!r} missing from config")
+            return DISTILL_PRESET, False, mode
+        options = [
+            MenuOption(
+                name,
+                data["label"],
+                data.get("description", f"Launch the {data['label']} preset."),
+            )
+            for name, data in presets.items()
+            if preset_mode(data) == mode
+        ]
+        if mode == DEFAULT_PRESET_MODE:
             options.append(
                 MenuOption(
                     CUSTOM_PRESET,
@@ -1678,46 +1760,45 @@ def select_plan(
                     "Open a settings hub for tiers, review setup, policy, and final confirmation.",
                 )
             )
-            options.append(
-                MenuOption(
-                    LEARNING_HUB,
-                    "Enter Session Learning Mode",
-                    "Learning-refinement mode: applied versions and mechanisms, "
-                    "packages, rollback — and start a dedicated learning session "
-                    "(preselected on entry).",
-                )
-            )
-            default = "balanced" if "balanced" in presets else next(iter(presets))
-            if ui is not None:
-                ui.set_plan(build_plan(config, host, default))
+        default = mode_default_preset(presets, mode) or CUSTOM_PRESET
+        if ui is not None and default != CUSTOM_PRESET:
+            ui.set_plan(build_plan(config, host, default))
 
-            def preview_name(value: str) -> str:
-                if value == CUSTOM_PRESET:
-                    return default
-                if value == LEARNING_HUB:
-                    return LEARNING_PRESET if LEARNING_PRESET in presets else default
-                return value
+        def preview_preset(value: str) -> dict[str, Any]:
+            target = default if value == CUSTOM_PRESET else value
+            return build_plan(config, host, target)
 
+        try:
             selected = choose(
-                "Preset",
-                options,
-                default,
-                ui,
-                preview=lambda value: build_plan(config, host, preview_name(value)),
-                learning_lines=learning_summary_lines(load_learning_status()),
+                "Preset", options, default, ui, allow_back=True, preview=preview_preset
+            )
+        except BackRequested:
+            mode = None
+            continue
+        if selected == CUSTOM_PRESET:
+            return default, True, mode
+        return selected, False, mode
+
+
+def select_plan(
+    config: dict[str, Any],
+    host: str,
+    preset_name: str | None,
+    custom_requested: bool,
+    ui: TextualUI | None = None,
+    config_path: pathlib.Path | None = None,
+) -> dict[str, Any]:
+    presets = config["presets"]
+    explicit_preset = preset_name
+    show_picker = explicit_preset is None
+    resume_mode: str | None = None
+    while True:
+        selected_name = explicit_preset
+        selected_custom = custom_requested
+        if show_picker:
+            selected_name, selected_custom, resume_mode = pick_mode_and_preset(
+                config, host, ui, resume_mode
             )
-            if selected == CUSTOM_PRESET:
-                selected_name = default
-                selected_custom = True
-            elif selected == LEARNING_HUB:
-                if learning_hub(config, ui) != "start":
-                    continue
-                if LEARNING_PRESET not in presets:
-                    raise LaunchError(f"preset {LEARNING_PRESET!r} missing from config")
-                selected_name = LEARNING_PRESET
-                selected_custom = False
-            else:
-                selected_name = selected
         if selected_name not in presets:
             raise LaunchError(f"unknown preset: {selected_name}")
         plan = build_plan(config, host, selected_name)
@@ -1949,6 +2030,12 @@ def claude_agents(plan: dict[str, Any]) -> str:
 
 def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[str]:
     host = plan["host"]
+    if plan.get("mode") == GENERAL_MODE:
+        # General mode is defined as the plain backend with nothing applied: no
+        # launch contract, no tier pinning, no agents, no permission/sandbox
+        # flag. Short-circuit here so that invariant holds structurally instead
+        # of depending on every general-mode preset being configured just so.
+        return []
     main = plan["tiers"][plan["main_tier"]]
     main_effort = tier_effort(plan, plan["main_tier"])
     contract = run_contract(plan)
@@ -1961,11 +2048,12 @@ def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[
             "-c", f"features.multi_agent={'true' if plan['delegation'] else 'false'}",
         ]
         policy = plan["codex_execution_policy"]
-        policy_args = (
-            ["--dangerously-bypass-approvals-and-sandbox"]
-            if policy == "bypass"
-            else ["--sandbox", policy]
-        )
+        if policy == "bypass":
+            policy_args = ["--dangerously-bypass-approvals-and-sandbox"]
+        elif policy == STANDARD_POLICY:
+            policy_args = []
+        else:
+            policy_args = ["--sandbox", policy]
         args += policy_args
         if plan["delegation"]:
             for tier, (path, description) in codex_agent_configs(plan, materialize_agents).items():
@@ -1989,11 +2077,12 @@ def project_args(plan: dict[str, Any], materialize_agents: bool = True) -> list[
     if plan["delegation"]:
         args += ["--agents", claude_agents(plan)]
     policy = plan["claude_permission_mode"]
-    policy_args = (
-        ["--dangerously-skip-permissions"]
-        if policy == "bypassPermissions"
-        else ["--permission-mode", policy]
-    )
+    if policy == "bypassPermissions":
+        policy_args = ["--dangerously-skip-permissions"]
+    elif policy == STANDARD_POLICY:
+        policy_args = []
+    else:
+        policy_args = ["--permission-mode", policy]
     args += policy_args
     if "onto" in effective_routes:
         onto_command = resolve_command(plan["capabilities"]["onto"]["command"])
@@ -2072,10 +2161,10 @@ def print_summary(
         print("  Argv           " + json.dumps([command, *args]), file=stream)
 
 
-SESSION_LEARNING_STATE = pathlib.Path(
+SESSION_DISTILL_STATE = pathlib.Path(
     os.environ.get(
-        "AGENT_BIOS_SESSION_LEARNING_STATE",
-        str(pathlib.Path.home() / ".local/share/agent-bios/session-learning-state.json"),
+        "AGENT_BIOS_SESSION_DISTILL_STATE",
+        str(pathlib.Path.home() / ".local/share/agent-bios/session-distill-state.json"),
     )
 )
 
@@ -2088,19 +2177,19 @@ def _line_count(path: pathlib.Path) -> int:
         return 0
 
 
-def session_learning_nudge(config: dict[str, Any]) -> str | None:
+def session_distill_nudge(config: dict[str, Any]) -> str | None:
     """Nudge when enough sessions accumulated since the last mining window.
 
-    The baseline is written by scripts/session-learning/update-state.py at
+    The baseline is written by scripts/session-distill/update-state.py at
     window close; provider history line counts are a cheap proxy for new
     sessions. No state file means no nudge.
     """
     try:
-        state = json.loads(SESSION_LEARNING_STATE.read_text())
+        state = json.loads(SESSION_DISTILL_STATE.read_text())
         baseline = int(state["history_lines_total"])
     except (OSError, ValueError, KeyError, TypeError):
         return None
-    settings = config.get("session_learning", {})
+    settings = config.get("session_distill", {})
     threshold = settings.get("nudge_after", 250) if isinstance(settings, dict) else 250
     current = _line_count(pathlib.Path.home() / ".claude/history.jsonl") + _line_count(
         pathlib.Path.home() / ".codex/history.jsonl"
@@ -2109,9 +2198,9 @@ def session_learning_nudge(config: dict[str, Any]) -> str | None:
     if delta < threshold:
         return None
     return (
-        f"session-learning due: ~{delta} new session entries since "
+        f"session-distill due: ~{delta} new session entries since "
         f"{state.get('window_end', '?')} (threshold {threshold}) — launch the "
-        "Session learning preset to run the next mining window"
+        "Session distill preset to run the next mining window"
     )
 
 
@@ -2144,10 +2233,10 @@ def main(argv: list[str]) -> int:
     config_path = args.config.expanduser()
     config = load_config(config_path)
     command, passthrough = resolve_backend(config, args.host)
-    nudge = session_learning_nudge(config)
+    nudge = session_distill_nudge(config)
     if nudge:
         print(f"agent-launch: {nudge}", file=sys.stderr)
-        nudged = config["presets"].get("session-learning")
+        nudged = config["presets"].get("session-distill")
         if isinstance(nudged, dict):
             nudged["description"] = f"{nudged.get('description', '')} ⚠ {nudge}".strip()
     tty = sys.stdin.isatty() and sys.stdout.isatty()
@@ -2189,9 +2278,9 @@ def main(argv: list[str]) -> int:
     print_summary(plan, command, projected, summary_stream, bool(args.forward))
     trigger = plan.get("trigger")
     if trigger:
-        # Black-on-yellow to match the Session Learning identity; the session
+        # Black-on-yellow to match the Session Distill identity; the session
         # waits for this exact phrase before starting the workflow.
-        line = f'  Once the session is up, type "{trigger}" to begin the learning workflow.  '
+        line = f'  Once the session is up, type "{trigger}" to begin the session-distill workflow.  '
         print(f"\n\x1b[1;30;43m{line}\x1b[0m", file=summary_stream)
     if args.dry_run:
         print(json.dumps([command, *projected], ensure_ascii=False))