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 instead of a generic placeholder. A bare interactive launch has
no prompt yet and falls back to the placeholder — the root model can't be
re-routed once the TUI is running (no hook/MCP seam exists for it on either
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 (→ placeholder) unless it
is confident it found the prompt.

Co-authored-by: Isaac

Author: masonc08

src/ucode/smart_routing/codex_routing.py

@@ -56,13 +56,42 @@ def route_launch_model(state: dict, tool_args: list[str]):
     return request_routing_decision(workspace, token, task, models)
 
 
+# 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:
-    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)
+    # Route on 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, so fall back to a generic task — the
+    # root model can't be re-routed once the TUI is running (no hook/MCP seam).
+    seed = routing.extract_seed_prompt(tool_args, _CODEX_VALUE_OPTIONS)
+    if seed:
+        return seed
     return f"Start an interactive Codex coding session in {Path.cwd().name}."
 
 

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,35 @@ 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_falls_back_to_placeholder(self):
+        # No prompt on the command line → generic task (root model can't be
+        # re-routed once the TUI is up).
+        task = codex_routing._launch_routing_task([])
+        assert "interactive Codex" in task
+
+    def test_launch_task_flags_only_falls_back_to_placeholder(self):
+        task = codex_routing._launch_routing_task(["--search", "-m", "gpt-5"])
+        assert "interactive Codex" in task
+
 
 class TestCodexRemoveLegacyProfile:
     def test_drops_provider_block_on_modern_path(self, tmp_path, monkeypatch):