Route root model on the launch-time seed prompt when present

When the user's first prompt is on the command line (`codex "<prompt>"`,
`codex exec "<prompt>"`, or after `--`), route the root-session model on that
actual prompt. A bare interactive launch carries no prompt, so routing is
skipped entirely and the user's configured default model is kept — with no
task signal the router could only return its floor arm, so routing there would
add a round-trip and silently downgrade the default. Routing a typed-in first
prompt is out of scope (no hook/MCP can retarget the root model mid-session on
Codex or Claude Code).

Adds a shared, conservative `extract_seed_prompt` to routing.py: it skips
value-taking options and their values, treats unknown flags as booleans, and
honors the `--` positional separator, returning None (→ skip routing) unless it
is confident it found the prompt.

Co-authored-by: Isaac

Author: masonc08

src/ucode/smart_routing/codex_routing.py

@@ -13,7 +13,6 @@
 # ``codex_routing.urllib.request`` — the actual call lives in ``routing``, but
 # Python modules are singletons so patching this name patches the one call site.
 import urllib.request  # noqa: F401
-from pathlib import Path
 from typing import Any
 
 from ucode.config_io import APP_DIR
@@ -43,7 +42,18 @@
 
 
 def route_launch_model(state: dict, tool_args: list[str]):
-    """Route a root Codex launch before the Codex process starts."""
+    """Route a root Codex launch on the launch-time prompt, if there is one.
+
+    Returns (None, None) when the launch carries no prompt (a bare interactive
+    session): with no task signal the router can only return its floor arm, so
+    routing would just add a round-trip and silently override the user's default
+    model. In that case we don't route and keep the configured default. Routing
+    on a typed-in first prompt is out of scope — no hook/MCP can retarget the
+    root model once the session is running.
+    """
+    task = _launch_routing_task(tool_args)
+    if task is None:
+        return None, None
     workspace = state.get("workspace")
     models = state.get("codex_models")
     if not isinstance(workspace, str) or not isinstance(models, list):
@@ -52,18 +62,43 @@ def route_launch_model(state: dict, tool_args: list[str]):
         token = get_databricks_token(workspace, state.get("profile"))
     except RuntimeError as exc:
         return None, f"could not authenticate the routing request: {exc}"
-    task = _launch_routing_task(tool_args)
     return request_routing_decision(workspace, token, task, models)
 
 
-def _launch_routing_task(tool_args: list[str]) -> str:
-    if "exec" in tool_args:
-        prompt_parts = tool_args[tool_args.index("exec") + 1 :]
-        if prompt_parts:
-            return " ".join(prompt_parts)
-    if tool_args:
-        return "Start a Codex session with options: " + " ".join(tool_args)
-    return f"Start an interactive Codex coding session in {Path.cwd().name}."
+# Codex CLI options that consume a following value (from `codex --help`); their
+# values must not be mistaken for the seed prompt when parsing launch args.
+_CODEX_VALUE_OPTIONS = frozenset(
+    {
+        "-c",
+        "--config",
+        "-i",
+        "--image",
+        "-m",
+        "--model",
+        "-p",
+        "--profile",
+        "-s",
+        "--sandbox",
+        "-a",
+        "--ask-for-approval",
+        "-C",
+        "--cd",
+        "--add-dir",
+        "--enable",
+        "--disable",
+        "--local-provider",
+        "--remote",
+        "--remote-auth-token-env",
+    }
+)
+
+
+def _launch_routing_task(tool_args: list[str]) -> str | None:
+    # The routing task is the user's real first prompt when it's on the command
+    # line (`codex "<prompt>"`, `codex exec "<prompt>"`, or after `--`). A bare
+    # interactive launch has no prompt yet → None, and the caller skips routing
+    # (the root model can't be re-routed once the TUI is running).
+    return routing.extract_seed_prompt(tool_args, _CODEX_VALUE_OPTIONS)
 
 
 def request_routing_decision(

src/ucode/smart_routing/routing.py

@@ -48,6 +48,60 @@ def normalize_model(model: str) -> str:
     return tail.lower()
 
 
+def extract_seed_prompt(tool_args: list[str], value_options: frozenset[str]) -> str | None:
+    """Recover a launch-time seed prompt from the passthrough CLI args.
+
+    A coding agent launched as ``<tool> [OPTIONS] [PROMPT]`` (or with an explicit
+    ``exec <PROMPT>`` subcommand) may carry the user's first prompt on the command
+    line. When it does, routing the root-session model on that real prompt beats
+    the generic placeholder. Everything after a ``--`` separator is treated as
+    positional (the agent's own convention for "stop parsing flags").
+
+    ``value_options`` is the set of the tool's flags that consume a following
+    value (e.g. ``-m``/``--model``); their values are skipped so a flag argument
+    is never mistaken for the prompt. Returns the joined positional tokens, or
+    None when the args carry no unambiguous prompt (bare launch, or only flags) —
+    the caller then falls back to its placeholder task.
+
+    Conservative by design: an unrecognized ``--flag`` (not in ``value_options``)
+    is treated as a boolean and skipped, and ``--flag=value`` forms are skipped
+    whole. We only return text we are confident is the user's prompt.
+    """
+    if "exec" in tool_args:
+        after = tool_args[tool_args.index("exec") + 1 :]
+        positionals = _positional_args(after, value_options)
+        return " ".join(positionals) if positionals else None
+    positionals = _positional_args(tool_args, value_options)
+    return " ".join(positionals) if positionals else None
+
+
+def _positional_args(args: list[str], value_options: frozenset[str]) -> list[str]:
+    positionals: list[str] = []
+    i = 0
+    seen_double_dash = False
+    while i < len(args):
+        arg = args[i]
+        if seen_double_dash:
+            positionals.append(arg)
+            i += 1
+            continue
+        if arg == "--":
+            seen_double_dash = True
+            i += 1
+            continue
+        if arg.startswith("-") and arg != "-":
+            # `--opt=value` carries its own value; a bare option in value_options
+            # consumes the next token. Anything else is a boolean flag we skip.
+            if "=" not in arg and arg in value_options:
+                i += 2
+            else:
+                i += 1
+            continue
+        positionals.append(arg)
+        i += 1
+    return positionals
+
+
 def select_route(
     workspace: str,
     token: str,

tests/test_agent_codex.py

@@ -366,6 +366,46 @@ def test_disable_removes_only_ucode_hooks(self, tmp_path, monkeypatch):
     def test_launch_task_uses_exec_prompt(self):
         assert codex_routing._launch_routing_task(["exec", "fix the parser"]) == "fix the parser"
 
+    def test_launch_task_uses_positional_interactive_prompt(self):
+        # `codex "fix the parser"` — the seed prompt is routed directly, not
+        # wrapped in a placeholder.
+        assert codex_routing._launch_routing_task(["fix the parser"]) == "fix the parser"
+
+    def test_launch_task_skips_value_option_before_prompt(self):
+        # `-m <model>` consumes its value; the model id must not be taken as the
+        # prompt.
+        assert (
+            codex_routing._launch_routing_task(["-m", "gpt-5", "refactor the parser"])
+            == "refactor the parser"
+        )
+
+    def test_launch_task_honors_double_dash(self):
+        assert (
+            codex_routing._launch_routing_task(["--", "--not-a-flag prompt"])
+            == "--not-a-flag prompt"
+        )
+
+    def test_launch_task_bare_launch_returns_none(self):
+        # No prompt on the command line → None, so the caller skips routing and
+        # keeps the user's default model (root model can't be re-routed once the
+        # TUI is up).
+        assert codex_routing._launch_routing_task([]) is None
+
+    def test_launch_task_flags_only_returns_none(self):
+        assert codex_routing._launch_routing_task(["--search", "-m", "gpt-5"]) is None
+
+    def test_route_launch_model_skips_routing_without_prompt(self, monkeypatch):
+        # Bare launch: no router call at all, no decision, no error.
+        def fail(*args, **kwargs):
+            raise AssertionError("router must not be called on a bare launch")
+
+        monkeypatch.setattr(codex_routing, "request_routing_decision", fail)
+        decision, error = codex_routing.route_launch_model(
+            {"workspace": WS, "codex_models": ["system.ai.gpt-5-6-sol"]}, []
+        )
+        assert decision is None
+        assert error is None
+
 
 class TestCodexRemoveLegacyProfile:
     def test_drops_provider_block_on_modern_path(self, tmp_path, monkeypatch):