Set Codex lane defaults to GPT-5.5 xhigh fast

agent/telegram_bot.py

@@ -258,6 +258,11 @@ def random_thinking_reaction() -> str:
 CODEX_REASONING_EFFORTS = ("low", "medium", "high", "xhigh")
 CODEX_MODEL_CHOICES = ("gpt-5.5", "gpt-5.4", "gpt-5.4-mini")
 CODEX_FAST_SERVICE_TIER = "priority"
+CODEX_DEFAULT_SETTINGS = {
+    "model": "gpt-5.5",
+    "reasoning_effort": "xhigh",
+    "service_tier": CODEX_FAST_SERVICE_TIER,
+}
 
 
 # Registered with Telegram via setMyCommands at boot. Order = order shown
@@ -1389,8 +1394,8 @@ def _set_agent_for(key: LaneKey, agent: str, state: dict) -> None:
 def _codex_settings_for(key: LaneKey, state: dict) -> dict:
     raw = (state.get("codex_settings") or {}).get(_lane_slug(key)) or {}
     if not isinstance(raw, dict):
-        return {}
-    out: dict[str, str] = {}
+        raw = {}
+    out: dict[str, str] = dict(CODEX_DEFAULT_SETTINGS)
     model = str(raw.get("model") or "").strip()
     if model:
         out["model"] = model
@@ -1400,6 +1405,8 @@ def _codex_settings_for(key: LaneKey, state: dict) -> dict:
     service_tier = str(raw.get("service_tier") or "").strip().lower()
     if service_tier == CODEX_FAST_SERVICE_TIER:
         out["service_tier"] = service_tier
+    elif "service_tier" in raw:
+        out.pop("service_tier", None)
     return out
 
 
@@ -1417,8 +1424,9 @@ def _set_codex_settings(
     if clear:
         settings_by_lane.pop(slug, None)
         save_state(state)
-        return {}
-    current = dict(_codex_settings_for(key, state))
+        return dict(CODEX_DEFAULT_SETTINGS)
+    raw = settings_by_lane.get(slug) or {}
+    current = dict(raw) if isinstance(raw, dict) else {}
     if model is not None:
         model = model.strip()
         if model:
@@ -1436,13 +1444,13 @@ def _set_codex_settings(
         if service_tier == CODEX_FAST_SERVICE_TIER:
             current["service_tier"] = service_tier
         elif not service_tier:
-            current.pop("service_tier", None)
+            current["service_tier"] = "off"
     if current:
         settings_by_lane[slug] = current
     else:
         settings_by_lane.pop(slug, None)
     save_state(state)
-    return current
+    return _codex_settings_for(key, state)
 
 
 def _format_codex_settings(settings: dict) -> str:
@@ -1460,23 +1468,13 @@ def _codex_model_picker_markup(settings: dict) -> dict:
     def label(text: str, active: bool) -> str:
         return f"✓ {text}" if active else text
 
-    model_row = [
-        {
-            "text": label("Default", not current_model),
-            "callback_data": "codex_model:model:default",
-        }
-    ]
+    model_row = []
     for model in CODEX_MODEL_CHOICES:
         model_row.append({
             "text": label(model.replace("gpt-", ""), current_model == model),
             "callback_data": f"codex_model:model:{model}",
         })
     effort_row = [
-        {
-            "text": label("Default", not current_effort),
-            "callback_data": "codex_model:effort:default",
-        }
-    ] + [
         {
             "text": label(effort.title(), current_effort == effort),
             "callback_data": f"codex_model:effort:{effort}",

agent/test_telegram_bot.py

@@ -36,7 +36,7 @@ def test_codex_settings_are_per_lane(self) -> None:
             telegram_bot._codex_settings_for(first, state),
             {"model": "gpt-5.4-mini", "reasoning_effort": "low", "service_tier": "priority"},
         )
-        self.assertEqual(telegram_bot._codex_settings_for(second, state), {})
+        self.assertEqual(telegram_bot._codex_settings_for(second, state), telegram_bot.CODEX_DEFAULT_SETTINGS)
 
     def test_clear_codex_settings(self) -> None:
         state = {
@@ -49,8 +49,11 @@ def test_clear_codex_settings(self) -> None:
         with mock.patch.object(telegram_bot, "save_state"):
             settings = telegram_bot._set_codex_settings((1, 10), state, clear=True)
 
-        self.assertEqual(settings, {})
-        self.assertEqual(telegram_bot._codex_settings_for((1, 10), state), {})
+        self.assertEqual(settings, telegram_bot.CODEX_DEFAULT_SETTINGS)
+        self.assertEqual(
+            telegram_bot._codex_settings_for((1, 10), state),
+            telegram_bot.CODEX_DEFAULT_SETTINGS,
+        )
 
     def test_invalid_effort_is_ignored(self) -> None:
         state = {"offset": 0, "agents": {}, "codex_settings": {}, "owners": {}}
@@ -63,7 +66,10 @@ def test_invalid_effort_is_ignored(self) -> None:
                 reasoning_effort="turbo",
             )
 
-        self.assertEqual(settings, {"model": "gpt-5.4"})
+        self.assertEqual(
+            settings,
+            {"model": "gpt-5.4", "reasoning_effort": "xhigh", "service_tier": "priority"},
+        )
 
     def test_invalid_service_tier_is_ignored(self) -> None:
         state = {"offset": 0, "agents": {}, "codex_settings": {}, "owners": {}}
@@ -75,7 +81,7 @@ def test_invalid_service_tier_is_ignored(self) -> None:
                 service_tier="turbo",
             )
 
-        self.assertEqual(settings, {})
+        self.assertEqual(settings, telegram_bot.CODEX_DEFAULT_SETTINGS)
 
     def test_model_picker_marks_current_choices(self) -> None:
         markup = telegram_bot._codex_model_picker_markup(
@@ -163,11 +169,11 @@ def fake_call(method: str, **kwargs):
 
         self.assertEqual(
             bot.state["codex_settings"]["100_123"],
-            {"service_tier": "priority"},
+            {"service_tier": "off"},
         )
         self.assertTrue(any(method == "editMessageText" for method, _ in calls))
 
-    def test_plain_fast_switches_codex_fast_service_tier(self) -> None:
+    def test_plain_fast_toggles_default_fast_service_tier_off(self) -> None:
         sent: list[tuple[str, dict]] = []
         bot = telegram_bot.Bot.__new__(telegram_bot.Bot)
         bot.state = {"offset": 0, "agents": {}, "codex_settings": {}, "owners": {}}
@@ -195,18 +201,18 @@ def test_plain_fast_switches_codex_fast_service_tier(self) -> None:
         self.assertEqual(bot.state["agents"]["100_main"], "codex")
         self.assertEqual(
             bot.state["codex_settings"]["100_main"],
-            {"service_tier": "priority"},
+            {"service_tier": "off"},
         )
-        self.assertIn("Fast mode on.", sent[-1][0])
+        self.assertIn("Fast mode off.", sent[-1][0])
         self.assertNotIn("reply_markup", sent[-1][1])
 
-    def test_plain_fast_toggles_fast_service_tier_off(self) -> None:
+    def test_plain_fast_toggles_fast_service_tier_on(self) -> None:
         sent: list[tuple[str, dict]] = []
         bot = telegram_bot.Bot.__new__(telegram_bot.Bot)
         bot.state = {
             "offset": 0,
             "agents": {},
-            "codex_settings": {"100_main": {"service_tier": "priority", "reasoning_effort": "xhigh"}},
+            "codex_settings": {"100_main": {"service_tier": "off", "reasoning_effort": "xhigh"}},
             "owners": {},
         }
         bot.setup_token = None
@@ -232,9 +238,9 @@ def test_plain_fast_toggles_fast_service_tier_off(self) -> None:
 
         self.assertEqual(
             bot.state["codex_settings"]["100_main"],
-            {"reasoning_effort": "xhigh"},
+            {"service_tier": "priority", "reasoning_effort": "xhigh"},
         )
-        self.assertIn("Fast mode off.", sent[-1][0])
+        self.assertIn("Fast mode on.", sent[-1][0])
 
     def test_codex_goal_feature_enablement_is_idempotent(self) -> None:
         with tempfile.TemporaryDirectory() as tmp: