Rename intelligent routing to smart routing; share one opt-in across agents

- Rename the feature "intelligent routing" -> "smart routing" throughout
  (package dir smart_routing/, symbols, CLI flags --enable/--disable-smart-routing,
  hidden *-router-hook commands, user-facing strings) per naming guidance.
- Unify the per-agent state keys into one shared "smart_routing_enabled", so a
  workspace enables smart routing once for every routing-capable tool (codex,
  claude) rather than per tool.

Co-authored-by: Isaac

Author: masonc08

src/ucode/agents/claude.py

@@ -28,11 +28,11 @@
     build_tool_base_url,
     get_databricks_token,
 )
-from ucode.intelligent_routing.claude_hooks import (
-    remove_intelligent_routing_hooks,
-    sync_intelligent_routing_hooks,
-)
 from ucode.launcher import exec_or_spawn
+from ucode.smart_routing.claude_hooks import (
+    remove_smart_routing_hooks,
+    sync_smart_routing_hooks,
+)
 from ucode.state import mark_tool_managed, save_state
 from ucode.telemetry import agent_version, ucode_version
 from ucode.tracing import tracing_env
@@ -50,8 +50,11 @@
     "backup_path": CLAUDE_BACKUP_PATH,
 }
 
-# Per-workspace opt-in flag for Claude Code intelligent routing (state key).
-INTELLIGENT_ROUTING_STATE_KEY = "claude_intelligent_routing_enabled"
+# Per-workspace opt-in flag for Claude Code smart routing (state key).
+# Shared across agents: one opt-in enables smart routing for every routing-capable
+# tool (codex, claude), so a workspace turns it on once. Kept identical to
+# codex.SMART_ROUTING_STATE_KEY on purpose.
+SMART_ROUTING_STATE_KEY = "smart_routing_enabled"
 # Claude Code settings.json hook events ucode manages when routing is enabled;
 # marked managed so they're tracked/reverted with the rest of ucode's config.
 CLAUDE_ROUTING_HOOK_EVENTS = ("PreToolUse", "SessionStart", "SubagentStart")
@@ -230,7 +233,7 @@ def render_overlay(
     # shows only one row per model. `ucode claude -- --model X` still overrides for
     # a single session via Claude Code's own --model flag.
     #
-    # The one exception is intelligent routing: `route_root_model` pins the
+    # The one exception is smart routing: `route_root_model` pins the
     # router's per-launch pick for the root session as ANTHROPIC_MODEL. The
     # duplicate-picker-row cost is acceptable because the whole point is to launch
     # on the routed model rather than the family default.
@@ -354,29 +357,29 @@ def _unregister_web_search_mcp() -> None:
             pass
 
 
-def intelligent_routing_enabled(state: dict) -> bool:
+def smart_routing_enabled(state: dict) -> bool:
     """Return whether the current workspace opted into Claude Code routing."""
-    return state.get(INTELLIGENT_ROUTING_STATE_KEY) is True
+    return state.get(SMART_ROUTING_STATE_KEY) is True
 
 
-def enable_intelligent_routing(state: dict) -> dict:
-    """Persist the current workspace's Claude Code intelligent-routing opt-in."""
-    state[INTELLIGENT_ROUTING_STATE_KEY] = True
+def enable_smart_routing(state: dict) -> dict:
+    """Persist the current workspace's Claude Code smart-routing opt-in."""
+    state[SMART_ROUTING_STATE_KEY] = True
     return state
 
 
-def disable_intelligent_routing(state: dict) -> bool:
+def disable_smart_routing(state: dict) -> bool:
     """Disable routing and remove only ucode's Claude Code routing hooks."""
-    state.pop(INTELLIGENT_ROUTING_STATE_KEY, None)
+    state.pop(SMART_ROUTING_STATE_KEY, None)
     if state.get("workspace"):
         save_state(state)
     changed = False
     if CLAUDE_SETTINGS_PATH.exists():
         doc = read_json_safe(CLAUDE_SETTINGS_PATH)
-        if remove_intelligent_routing_hooks(doc):
+        if remove_smart_routing_hooks(doc):
             write_json_file(CLAUDE_SETTINGS_PATH, doc)
             changed = True
-    from ucode.intelligent_routing.claude_routing import clear_routing_artifacts
+    from ucode.smart_routing.claude_routing import clear_routing_artifacts
 
     clear_routing_artifacts()
     return changed
@@ -452,11 +455,11 @@ def write_tool_config(
     if isinstance(merged_env, dict):
         for key in CLAUDE_REMOVED_ENV_KEYS:
             merged_env.pop(key, None)
-    # Intelligent-routing hooks: install ucode's PreToolUse/SessionStart/
+    # Smart-routing hooks: install ucode's PreToolUse/SessionStart/
     # SubagentStart hooks when routing is enabled (and not under a provider,
     # which pins no Databricks model), else surgically strip only ucode's own.
-    routing_enabled = intelligent_routing_enabled(state) and provider is None
-    sync_intelligent_routing_hooks(merged, state, enabled=routing_enabled)
+    routing_enabled = smart_routing_enabled(state) and provider is None
+    sync_smart_routing_hooks(merged, state, enabled=routing_enabled)
     if routing_enabled:
         managed_keys = managed_keys + [["hooks", event] for event in CLAUDE_ROUTING_HOOK_EVENTS]
     write_json_file(CLAUDE_SETTINGS_PATH, merged)

src/ucode/agents/codex.py

@@ -20,11 +20,11 @@
     build_tool_base_url,
     get_databricks_token,
 )
-from ucode.intelligent_routing.codex_hooks import (
-    remove_intelligent_routing_hooks,
-    sync_intelligent_routing_hooks,
-)
 from ucode.launcher import exec_or_spawn
+from ucode.smart_routing.codex_hooks import (
+    remove_smart_routing_hooks,
+    sync_smart_routing_hooks,
+)
 from ucode.state import mark_tool_managed, save_state
 from ucode.telemetry import agent_version, ucode_version
 
@@ -39,7 +39,9 @@
 MINIMUM_CODEX_VERSION_TEXT = "0.134.0"
 MINIMUM_ROUTING_CODEX_VERSION = (0, 145, 0)
 MINIMUM_ROUTING_CODEX_VERSION_TEXT = "0.145.0"
-INTELLIGENT_ROUTING_STATE_KEY = "codex_intelligent_routing_enabled"
+# Shared across agents: one opt-in enables smart routing for every routing-capable
+# tool (codex, claude), so a workspace turns it on once.
+SMART_ROUTING_STATE_KEY = "smart_routing_enabled"
 
 
 SPEC: ToolSpec = {
@@ -325,10 +327,9 @@ def write_tool_config(state: dict, model: str | None = None, provider: str | Non
     databricks_profile = state.get("profile")
 
     if _use_legacy_layout():
-        if intelligent_routing_enabled(state) and provider is None:
+        if smart_routing_enabled(state) and provider is None:
             raise RuntimeError(
-                "Codex intelligent routing requires Codex "
-                f"{MINIMUM_ROUTING_CODEX_VERSION_TEXT} or newer."
+                f"Codex smart routing requires Codex {MINIMUM_ROUTING_CODEX_VERSION_TEXT} or newer."
             )
         # Codex < 0.134.0 only reads ~/.codex/config.toml. Write the shared
         # config with [profiles.ucode] + shared [model_providers.ucode-databricks]
@@ -370,10 +371,10 @@ def write_tool_config(state: dict, model: str | None = None, provider: str | Non
         # deep_merge can't drop keys, so clear a `model` pinned by an earlier
         # non-provider run that the provider overlay omits.
         doc.pop("model", None)
-    sync_intelligent_routing_hooks(
+    sync_smart_routing_hooks(
         doc,
         state,
-        enabled=intelligent_routing_enabled(state) and provider is None,
+        enabled=smart_routing_enabled(state) and provider is None,
     )
     write_toml_file(CODEX_CONFIG_PATH, doc)
     state = mark_tool_managed(state, "codex", MANAGED_KEYS)
@@ -416,38 +417,38 @@ def launch(state: dict, tool_args: list[str]) -> None:
     exec_or_spawn([binary, "--profile", CODEX_PROFILE_NAME, *tool_args])
 
 
-def intelligent_routing_enabled(state: dict) -> bool:
+def smart_routing_enabled(state: dict) -> bool:
     """Return whether the current workspace opted into Codex routing."""
-    return state.get(INTELLIGENT_ROUTING_STATE_KEY) is True
+    return state.get(SMART_ROUTING_STATE_KEY) is True
 
 
-def enable_intelligent_routing(state: dict) -> dict:
-    """Persist the current workspace's Codex intelligent-routing opt-in."""
+def enable_smart_routing(state: dict) -> dict:
+    """Persist the current workspace's Codex smart-routing opt-in."""
     parsed = _parse_version(agent_version(SPEC["binary"]))
     if parsed is not None and parsed < MINIMUM_ROUTING_CODEX_VERSION:
         raise RuntimeError(
-            "Codex intelligent routing requires Codex "
+            "Codex smart routing requires Codex "
             f"{MINIMUM_ROUTING_CODEX_VERSION_TEXT} or newer; found "
             f"{agent_version(SPEC['binary'])}."
         )
-    state[INTELLIGENT_ROUTING_STATE_KEY] = True
+    state[SMART_ROUTING_STATE_KEY] = True
     return state
 
 
-def disable_intelligent_routing(state: dict) -> bool:
+def disable_smart_routing(state: dict) -> bool:
     """Disable routing and remove only ucode's Codex routing hooks."""
-    state.pop(INTELLIGENT_ROUTING_STATE_KEY, None)
+    state.pop(SMART_ROUTING_STATE_KEY, None)
     if state.get("workspace"):
         save_state(state)
     changed = False
     for path in (CODEX_CONFIG_PATH, LEGACY_CODEX_CONFIG_PATH):
         if not path.exists():
             continue
         doc = read_toml_safe(path)
-        if remove_intelligent_routing_hooks(doc):
+        if remove_smart_routing_hooks(doc):
             write_toml_file(path, doc)
             changed = True
-    from ucode.intelligent_routing.codex_routing import clear_routing_artifacts
+    from ucode.smart_routing.codex_routing import clear_routing_artifacts
 
     clear_routing_artifacts()
     return changed