agent-bios 0.2.0 → 0.4.0

package/scripts/agent-launch.py

@@ -10,6 +10,7 @@ import json
 import os
 import pathlib
 import shutil
+import subprocess
 import sys
 import textwrap
 import tomllib
@@ -18,6 +19,9 @@ from typing import Any, NoReturn
 
 
 TIER_ORDER = ("frontier", "helm", "workhorse", "sweep")
+# Tiers projected as spawnable subagents. HELM is the main role, never a
+# spawnable worker — registering it invited helm-as-subagent misuse.
+SPAWNABLE_TIERS = ("frontier", "workhorse", "sweep")
 EFFORT_ORDER = ("low", "medium", "high", "xhigh", "max", "ultra")
 HOST_EFFORTS = {
     "codex": {"low", "medium", "high", "xhigh", "max", "ultra"},
@@ -40,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"
@@ -58,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",
@@ -569,7 +585,7 @@ def _build_app_class():
 
     app_css = """
     Screen { background: $surface; }
-    #al-title { color: $accent; text-style: bold; padding: 0 1; }
+    #al-title { background: $primary; color: black; text-style: bold; padding: 0 1; }
     #al-setup {
         border: round $primary; border-title-color: $primary;
         border-title-style: bold; padding: 0 1; height: auto;
@@ -578,6 +594,10 @@ def _build_app_class():
         border: round $secondary; border-title-color: $secondary;
         border-title-style: bold; padding: 0 1; height: 5;
     }
+    #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; }
     OptionList { height: 1fr; border: none; padding: 0 1; }
     #al-footer { color: $text-muted; dock: bottom; padding: 0 1; background: $panel; }
@@ -596,7 +616,9 @@ def _build_app_class():
             Binding("ctrl+c", "cancel", "cancel", priority=True),
         ]
 
-        def __init__(self, title, options, default, allow_back, plan, preview=None):
+        def __init__(
+            self, title, options, default, allow_back, plan, preview=None, corpus=None
+        ):
             super().__init__()
             self._title = title
             self._options = options
@@ -604,10 +626,14 @@ def _build_app_class():
             self._allow_back = allow_back
             self._plan = plan
             self._preview = preview
+            self._corpus = corpus
 
         def compose(self):
             yield Static(self._title, id="al-title")
             yield setup_panel(self._plan)
+            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
@@ -775,10 +801,13 @@ class TextualUI:
         default: str,
         allow_back: bool,
         preview=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),
+            self._menu_screen(
+                title, options, default, allow_back, self.plan, preview, corpus_lines
+            ),
         )
         if result == _UI_BACK:
             raise BackRequested
@@ -814,13 +843,23 @@ def run_textual_flow(
 
 
 def choose_lines(
-    title: str, options: list[MenuOption], default: str, allow_back: bool
+    title: str,
+    options: list[MenuOption],
+    default: str,
+    allow_back: bool,
+    corpus_lines: list[str] | None = None,
 ) -> str:
     print(f"\n{title}")
+    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 ""
-        print(f"  {index}. {option.label}{marker}{selected} - {option.description}")
+        label = option.label
+        print(f"  {index}. {label}{marker}{selected} - {option.description}")
         if not option.enabled:
             print(f"     Unavailable: {option.unavailable_reason}")
     while True:
@@ -854,12 +893,13 @@ def choose(
     ui: TextualUI | None = None,
     allow_back: bool = False,
     preview=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)
-    return choose_lines(title, options, default, allow_back)
+        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:
@@ -950,6 +990,17 @@ 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")
+    trigger = preset.get("trigger")
+    if trigger is not None and (not isinstance(trigger, str) or not trigger):
+        raise LaunchError(f"presets.{preset_name}.trigger must be a non-empty string")
     review_family = preset.get("review_family", "cross")
     review_host = REVIEW_HOST[host]
     opposite = config.get("hosts", {}).get(review_host)
@@ -973,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,
@@ -988,6 +1040,8 @@ def build_plan(config: dict[str, Any], host: str, preset_name: str) -> dict[str,
         "review_backend": review_backend,
         "agent_templates": copy.deepcopy(config["hosts"][host].get("agent_templates")),
         "capabilities": copy.deepcopy(config.get("capabilities", {})),
+        "mission": mission,
+        "trigger": trigger,
     }
 
 
@@ -1173,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"
@@ -1208,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)"
@@ -1386,6 +1450,336 @@ def customize(
             raise KeyboardInterrupt
 
 
+DISTILL_PRESET = "session-distill"
+CORPUS_STATUS_PATH = pathlib.Path(
+    os.environ.get(
+        "AGENT_BIOS_CORPUS_STATUS",
+        str(pathlib.Path.home() / ".local/share/agent-bios/corpus-status.json"),
+    )
+)
+
+
+def load_corpus_status() -> dict[str, Any] | None:
+    try:
+        return json.loads(CORPUS_STATUS_PATH.read_text())
+    except (OSError, ValueError):
+        return None
+
+
+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 ["corpus status not projected yet — run: agent-bios install"]
+    current = status.get("current_version", "?")
+    latest = status.get("latest_version", "?")
+    head = f"Applied version  {current}"
+    if status.get("rolled_back_to"):
+        head += f"  (ROLLED BACK; latest is {latest})"
+    layers = status.get("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 "none"
+    by_status = status.get("summary", {}).get("by_status", {})
+    return [
+        head,
+        f"Mechanisms       {layer_text}",
+        f"Ledger           placed {by_status.get('placed', 0)} · "
+        f"incubating {by_status.get('incubating', 0) + by_status.get('incubating-G', 0)} · "
+        f"versions {len(status.get('versions', []))}",
+    ]
+
+
+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 Distill.")]
+    try:
+        choose(title, options, "back", ui, allow_back=True, corpus_lines=lines)
+    except BackRequested:
+        pass
+
+
+def _corpus_rollback(status: dict[str, Any], version: str, ui: TextualUI | None) -> None:
+    confirm = choose(
+        f"Roll back corpus to {version}?",
+        [
+            MenuOption(
+                "cancel", "Cancel", "Keep the currently deployed corpus content."
+            ),
+            MenuOption(
+                "rollback",
+                f"Roll back to {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.",
+            ),
+        ],
+        "cancel",
+        ui,
+        allow_back=True,
+    )
+    if confirm != "rollback":
+        return
+    script = pathlib.Path(status["repo"]) / "scripts/session-distill/corpus-state.py"
+    result = subprocess.run(
+        [sys.executable, str(script), "rollback", "--version", version],
+        capture_output=True,
+        text=True,
+    )
+    output = (result.stdout + result.stderr).strip().splitlines()
+    tail = output[-1] if output else ""
+    verdict = "Rollback complete." if result.returncode == 0 else "Rollback FAILED."
+    _corpus_info(ui, verdict, [tail] if tail else [])
+
+
+def _corpus_versions(ui: TextualUI | None) -> None:
+    while True:
+        status = load_corpus_status()
+        if status is None:
+            _corpus_info(ui, "Versions & rollback", corpus_summary_lines(None))
+            return
+        current = status.get("current_version")
+        options = []
+        for v in reversed(status.get("versions", [])):
+            name = v["version"]
+            label = f"{name} (current)" if name == current else name
+            options.append(
+                MenuOption(
+                    name,
+                    label,
+                    f"closed {v.get('closed', '?')} · commit {v.get('commit', '')[:12]} · "
+                    f"{v.get('summary', '')}",
+                )
+            )
+        options.append(MenuOption("back", "Back", "Return to Session Distill."))
+        try:
+            selected = choose(
+                "Versions & rollback",
+                options,
+                options[0].value,
+                ui,
+                allow_back=True,
+                corpus_lines=corpus_summary_lines(status),
+            )
+        except BackRequested:
+            return
+        if selected == "back":
+            return
+        if selected == current:
+            _corpus_info(
+                ui,
+                f"{selected} is the currently applied version",
+                ["Select a different version to roll back or forward."],
+            )
+            continue
+        _corpus_rollback(status, selected, ui)
+
+
+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_corpus_status()
+    if status is 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 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 Distill."),
+    ]
+    try:
+        choose(
+            "Corpus packages",
+            options,
+            "back",
+            ui,
+            allow_back=True,
+            corpus_lines=corpus_summary_lines(status),
+        )
+    except BackRequested:
+        pass
+
+
+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 session-distill preset, "back" otherwise.
+    """
+    while True:
+        status = load_corpus_status()
+        options = [
+            MenuOption(
+                "start",
+                "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=DISTILL_PRESET in config["presets"],
+                unavailable_reason=f"preset {DISTILL_PRESET!r} not configured",
+            ),
+            MenuOption(
+                "packages",
+                "Corpus packages",
+                "What corpus content is applied, as installable packages "
+                "(v1: single core corpus).",
+            ),
+            MenuOption(
+                "versions",
+                "Versions & rollback",
+                "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 Distill",
+                options,
+                "start",
+                ui,
+                allow_back=True,
+                corpus_lines=corpus_summary_lines(status),
+            )
+        except BackRequested:
+            return "back"
+        if selected == "back":
+            return "back"
+        if selected == "start":
+            return "start"
+        if selected == "packages":
+            _corpus_packages(ui)
+        elif selected == "versions":
+            _corpus_versions(ui)
+
+
+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,
+    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"]
+    mode = resume_mode
+    while True:
+        if mode is None:
+            mode_options = [
+                MenuOption(
+                    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,
+                    "Custom",
+                    "Open a settings hub for tiers, review setup, policy, and final confirmation.",
+                )
+            )
+        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_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, 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,
@@ -1397,42 +1791,14 @@ def select_plan(
     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:
-            options = [
-                MenuOption(
-                    name,
-                    data["label"],
-                    data.get("description", f"Launch the {data['label']} preset."),
-                )
-                for name, data in presets.items()
-            ]
-            options.append(
-                MenuOption(
-                    CUSTOM_PRESET,
-                    "Custom",
-                    "Open a settings hub for tiers, review setup, policy, and final confirmation.",
-                )
+            selected_name, selected_custom, resume_mode = pick_mode_and_preset(
+                config, host, ui, resume_mode
             )
-            default = "balanced" if "balanced" in presets else next(iter(presets))
-            if ui is not None:
-                ui.set_plan(build_plan(config, host, default))
-            selected = choose(
-                "Preset",
-                options,
-                default,
-                ui,
-                preview=lambda value: build_plan(
-                    config, host, default if value == CUSTOM_PRESET else value
-                ),
-            )
-            if selected == CUSTOM_PRESET:
-                selected_name = default
-                selected_custom = True
-            else:
-                selected_name = selected
         if selected_name not in presets:
             raise LaunchError(f"unknown preset: {selected_name}")
         plan = build_plan(config, host, selected_name)
@@ -1468,7 +1834,7 @@ def codex_agent_configs(
     if not isinstance(templates, dict):
         raise LaunchError("Codex delegation requires [hosts.codex.agent_templates]")
     rendered: dict[str, tuple[str, str]] = {}
-    for tier in ("frontier", "workhorse", "sweep"):
+    for tier in SPAWNABLE_TIERS:
         source_value = templates.get(tier)
         if not isinstance(source_value, str) or not source_value:
             raise LaunchError(f"Codex agent template missing: {tier}")
@@ -1630,7 +1996,12 @@ def run_contract(plan: dict[str, Any]) -> str:
         if plan["host"] == "codex"
         else "Main and child model/effort defaults are CLI-projected."
     )
+    mission = plan.get("mission")
+    if mission and plan.get("trigger"):
+        mission = mission.replace("{trigger}", plan["trigger"])
+    mission_prefix = f"Mission: {mission} " if mission else ""
     return (
+        f"{mission_prefix}"
         f"LaunchPlan: main={plan['main_tier']} ({plan['tiers'][plan['main_tier']]['model']}/"
         f"{tier_effort(plan, plan['main_tier'])}); tiers: {bindings}. "
         f"Delegation={'on' if plan['delegation'] else 'off'}. Review family={family}. "
@@ -1643,7 +2014,7 @@ def run_contract(plan: dict[str, Any]) -> str:
 
 def claude_agents(plan: dict[str, Any]) -> str:
     roles = {}
-    for tier in TIER_ORDER:
+    for tier in SPAWNABLE_TIERS:
         binding = plan["tiers"][tier]
         roles[tier] = {
             "description": f"{tier.upper()} tier: {binding['model']} at {tier_effort(plan, tier)}",
@@ -1659,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)
@@ -1671,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():
@@ -1699,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"])
@@ -1782,6 +2161,49 @@ def print_summary(
         print("  Argv           " + json.dumps([command, *args]), file=stream)
 
 
+SESSION_DISTILL_STATE = pathlib.Path(
+    os.environ.get(
+        "AGENT_BIOS_SESSION_DISTILL_STATE",
+        str(pathlib.Path.home() / ".local/share/agent-bios/session-distill-state.json"),
+    )
+)
+
+
+def _line_count(path: pathlib.Path) -> int:
+    try:
+        with path.open("rb") as fh:
+            return sum(chunk.count(b"\n") for chunk in iter(lambda: fh.read(1 << 20), b""))
+    except OSError:
+        return 0
+
+
+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-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_DISTILL_STATE.read_text())
+        baseline = int(state["history_lines_total"])
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+    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"
+    )
+    delta = current - baseline
+    if delta < threshold:
+        return None
+    return (
+        f"session-distill due: ~{delta} new session entries since "
+        f"{state.get('window_end', '?')} (threshold {threshold}) — launch the "
+        "Session distill preset to run the next mining window"
+    )
+
+
 def parse_args(argv: list[str]) -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--config", type=pathlib.Path, default=default_config_path())
@@ -1811,6 +2233,12 @@ 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_distill_nudge(config)
+    if nudge:
+        print(f"agent-launch: {nudge}", file=sys.stderr)
+        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()
     if not tty and args.dry_run and not args.preset and not args.custom:
         if "balanced" not in config["presets"]:
@@ -1848,6 +2276,12 @@ def main(argv: list[str]) -> int:
     projected = [*project_args(plan, materialize_agents=not args.dry_run), *args.forward]
     summary_stream = sys.stdout if tty or args.dry_run else sys.stderr
     print_summary(plan, command, projected, summary_stream, bool(args.forward))
+    trigger = plan.get("trigger")
+    if trigger:
+        # 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 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))
         return 0