henosis-cli 0.6.4__py3-none-any.whl → 0.6.7__py3-none-any.whl

cli.py

@@ -800,8 +800,9 @@ class ChatCLI:
         # - concise: only model (+thinking level when applicable) and context meter
         # - verbose: full details (current behavior)
         self.usage_info_mode: str = "verbose"
-        # Reasoning effort selector for OpenAI reasoning models (low|medium|high). Default: medium
-        self.reasoning_effort: str = "medium"
+        # Reasoning effort selector for OpenAI reasoning models (low|medium|high|xhigh). Default: medium
+        # Note: 'xhigh' is only applied by the server for models that support it (e.g., gpt-5.2* and gpt-5.1-codex-max).
+        self.reasoning_effort: str = "medium"
         # Retain provider-native tool results between turns (e.g., Kimi reasoning/tool messages)
         self.retain_native_tool_results: bool = False
         # Anthropic thinking-mode budget tokens (applies to '-thinking' models; None = server default)
@@ -1340,37 +1341,28 @@ class ChatCLI:
         # Match server chat_adapter PRICING_PER_MILLION (subset is fine; unknown -> 0)
         return {
             # OpenAI
-            "gpt-5.1": {"input": 1.75, "output": 14.00, "provider": "openai"},
             "gpt-5.2": {"input": 2.00, "output": 14.25, "provider": "openai"},
-            "gpt-5.1-codex": {"input": 1.75, "output": 14.00, "provider": "openai"},
-            "gpt-5.1-codex-max": {"input": 1.75, "output": 14.00, "provider": "openai"},
-            "gpt-5.1-codex": {"input": 1.75, "output": 14.00, "provider": "openai"},
-            "gpt-5.1-mini": {"input": 0.35, "output": 2.80, "provider": "openai"},
+            # From gpt5.2.txt: $21/$168 base, plus +$0.25 margin each -> $21.25/$168.25
+            "gpt-5.2-pro": {"input": 21.25, "output": 168.25, "provider": "openai"},
             "gpt-5": {"input": 1.75, "output": 14.00, "provider": "openai"},
             "gpt-5-2025-08-07": {"input": 1.75, "output": 14.00, "provider": "openai"},
             "gpt-5-codex": {"input": 1.75, "output": 14.00, "provider": "openai"},
-            "gpt-5-pro": {"input": 15.00, "output": 120.00, "provider": "openai"},
-            "gpt-5-pro-2025-10-06": {"input": 15.00, "output": 120.00, "provider": "openai"},
-            "gpt-5-mini-2025-08-07": {"input": 0.35, "output": 2.80, "provider": "openai"},
-            "gpt-4o-mini": {"input": 0.21, "output": 0.84, "provider": "openai"},
+            "gpt-4o-mini": {"input": 0.21, "output": 0.84, "provider": "openai"},
             # Codex Mini (fine-tuned o4-mini for CLI). Pricing includes 1.4x margin per codex-mini.txt.
             # Cached input tokens override: $0.375 * 1.4 = $0.525 per 1M (25% of input rate).
             "codex-mini-latest": {"input": 2.10, "output": 8.40, "cached_input": 0.525, "provider": "openai"},
             # Anthropic
             "claude-sonnet-4-20250514": {"input": 4.20, "output": 21.00, "provider": "anthropic"},
             "claude-sonnet-4-20250514-thinking": {"input": 4.20, "output": 21.00, "provider": "anthropic"},
-            "claude-haiku-4-5-20251001": {"input": 1.40, "output": 7.00, "provider": "anthropic"},
-            "claude-haiku-4-5-20251001-thinking": {"input": 1.40, "output": 7.00, "provider": "anthropic"},
-            "claude-sonnet-4-5-20250929": {"input": 4.20, "output": 21.00, "provider": "anthropic"},
+            "claude-sonnet-4-5-20250929": {"input": 4.20, "output": 21.00, "provider": "anthropic"},
             "claude-sonnet-4-5-20250929-thinking": {"input": 4.20, "output": 21.00, "provider": "anthropic"},
-            "claude-opus-4-1-20250805": {"input": 21.00, "output": 105.00, "provider": "anthropic"},
-            "claude-opus-4-1-20250805-thinking": {"input": 21.00, "output": 105.00, "provider": "anthropic"},
-            # New Opus 4.5 (provider base $5/$25 with 1.4x margin -> $7.00/$35.00)
+            # New Opus 4.5 (provider base $5/$25 with 1.4x margin -> $7.00/$35.00)
             "claude-opus-4-5-20251101": {"input": 7.00, "output": 35.00, "provider": "anthropic"},
             "claude-opus-4-5-20251101-thinking": {"input": 7.00, "output": 35.00, "provider": "anthropic"},
             # Gemini
             "gemini-2.5-pro": {"input": 1.75, "output": 14.00, "provider": "gemini"},
-            "gemini-2.5-flash": {"input": 0.21, "output": 0.84, "provider": "gemini"},
+            # Gemini 3 Flash Preview (priced same as prior Gemini 2.5 Flash per request)
+            "gemini-3-flash-preview": {"input": 0.21, "output": 0.84, "provider": "gemini"},
             # Gemini 3 Pro Preview ("newgem"). Base: $2/$12 and $4/$18 per 1M;
             # CLI uses the low-tier 1.4x margin rates for estimates. High-tier
             # pricing based on total_tokens > 200K is applied on the server.
@@ -1414,6 +1406,8 @@ class ChatCLI:
             "gemini-3": "gemini-3-pro-preview",
             "gemini-3-pro": "gemini-3-pro-preview",
             "gemini-3-preview": "gemini-3-pro-preview",
+            "gemini-3-flash": "gemini-3-flash-preview",
+            "gemini-flash-3": "gemini-3-flash-preview",
             "gemini-new": "gemini-3-pro-preview",
             "new-gemini": "gemini-3-pro-preview",
             "gemini-pro-3": "gemini-3-pro-preview",
@@ -1437,18 +1431,13 @@ class ChatCLI:
         except Exception:
             model_name = ""
         try:
-            if model_name in {"gpt-5-pro", "gpt-5-pro-2025-10-06"}:
-                if getattr(self, "reasoning_effort", None) != "high":
+            if model_name in {"gpt-5.2-pro"}:
+                # Default these to high, but don't clobber a user-chosen xhigh.
+                if getattr(self, "reasoning_effort", None) not in ("high", "xhigh"):
                     self.reasoning_effort = "high"
             # Codex family: disable preambles for better behavior
             if "codex" in model_name:
                 self.preambles_enabled = False
-            # Codex Max: default web search OFF when this model is selected (user can re-enable manually)
-            if model_name == "gpt-5.1-codex-max":
-                try:
-                    self.web_search_enabled = False
-                except Exception:
-                    pass
         except Exception:
             try:
                 self.reasoning_effort = "high"
@@ -1459,20 +1448,16 @@ class ChatCLI:
             return bool(model) and ("codex" in str(model).lower())
         except Exception:
             return False
-    def _is_codex_max(self, model: Optional[str]) -> bool:
-        try:
-            return bool(model) and (str(model).strip().lower() == "gpt-5.1-codex-max")
-        except Exception:
-            return False
-
     def _supports_xhigh_reasoning_effort(self, model: Optional[str]) -> bool:
         """Return True if the OpenAI model supports reasoning_effort='xhigh'.
 
-        Historically we only exposed this for Codex Max, but GPT-5.2 also supports it.
+        OpenAI supports xhigh on:
+        - gpt-5.1-codex-max
+        - the gpt-5.2* family
         """
         try:
             m = (str(model).strip().lower() if model else "")
-            return m in {"gpt-5.1-codex-max", "gpt-5.2", "gpt-5-2025-08-07"}
+            return m.startswith("gpt-5.2")
         except Exception:
             return False
 
@@ -2049,13 +2034,13 @@ class ChatCLI:
                         self.usage_info_mode = val
                 except Exception:
                     pass
-            # Reasoning effort (default medium if missing/invalid)
-            try:
-                val = data.get("reasoning_effort")
-                if isinstance(val, str) and val in ("low", "medium", "high"):
-                    self.reasoning_effort = val
-            except Exception:
-                pass
+            # Reasoning effort (default medium if missing/invalid)
+            try:
+                val = data.get("reasoning_effort")
+                if isinstance(val, str) and val in ("low", "medium", "high", "xhigh"):
+                    self.reasoning_effort = val
+            except Exception:
+                pass
             # Text verbosity selector
             try:
                 v = data.get("text_verbosity")
@@ -2485,7 +2470,7 @@ class ChatCLI:
             {"name": "/infomode", "usage": "/infomode concise|verbose", "desc": "Set Usage & Info panel mode"},
             {"name": "/tools", "usage": "/tools on|off|default", "desc": "Toggle per-request tools"},
             {"name": "/websearch", "usage": "/websearch on|off|domains|sources|location", "desc": "Configure OpenAI web search"},
-            {"name": "/reasoning", "usage": "/reasoning low|medium|high", "desc": "Set OpenAI reasoning effort (default: medium)"},
+            {"name": "/reasoning", "usage": "/reasoning low|medium|high|xhigh", "desc": "Set OpenAI reasoning effort (default: medium; xhigh supported on gpt-5.2*)"},
             {"name": "/thinkingbudget", "usage": "/thinkingbudget <tokens>|default", "desc": "Set Anthropic thinking budget tokens for -thinking models"},
             {"name": "/fs", "usage": "/fs workspace|host|default", "desc": "Set filesystem scope"},
             {"name": "/agent-scope", "usage": "/agent-scope <absolute path>", "desc": "Alias for /hostbase (set Agent scope)"},
@@ -2508,35 +2493,26 @@ class ChatCLI:
     def _model_presets(self) -> List[Tuple[str, str]]:
         """Shared list of (model, label) used by settings UI and /model menu."""
         return [
-            ("gpt-5.1", "OpenAI: gpt-5.1"),
             ("gpt-5.2", "OpenAI: gpt-5.2"),
+            ("gpt-5.2-pro", "OpenAI: gpt-5.2-pro (streaming, very expensive)"),
             ("gpt-5", "OpenAI: gpt-5"),
             ("gpt-5-codex", "OpenAI: gpt-5-codex"),
-            ("gpt-5.1-codex", "OpenAI: gpt-5.1-codex"),
-            ("gpt-5.1-codex-max", "OpenAI: gpt-5.1-codex-max"),
-            ("gpt-5.1-mini", "OpenAI: gpt-5.1-mini"),
-            ("gpt-5-pro", "OpenAI: gpt-5-pro (non-streaming, very expensive)"),
-            ("gpt-5-mini-2025-08-07", "OpenAI: gpt-5-mini-2025-08-07"),
-            ("codex-mini-latest", "OpenAI: codex-mini-latest (fast reasoning)"),
+            ("codex-mini-latest", "OpenAI: codex-mini-latest (fast reasoning)"),
             ("deepseek-chat-3.2", "DeepSeek: deepseek-chat 3.2"),
             ("deepseek-reasoner-3.2", "DeepSeek: deepseek-reasoner 3.2"),
             ("deepseek-3.2-speciale", "DeepSeek: deepseek 3.2 Speciale (no tools)"),
             ("kimi-k2-thinking", "Kimi: kimi-k2-thinking"),
             ("kimi-k2-0905-preview", "Kimi: kimi-k2-0905-preview"),
-            ("gemini-2.5-pro", "Gemini: gemini-2.5-pro"),
-            ("gemini-2.5-flash", "Gemini: gemini-2.5-flash"),
-            ("gemini-3-pro-preview", "Gemini: gemini-3-pro-preview"),
+            ("gemini-2.5-pro", "Gemini: gemini-2.5-pro"),
+            ("gemini-3-flash-preview", "Gemini: gemini-3-flash-preview"),
+            ("gemini-3-pro-preview", "Gemini: gemini-3-pro-preview"),
             ("grok-4-1-fast-reasoning", "xAI: grok-4-1-fast-reasoning"),
             ("grok-4-1-fast-non-reasoning", "xAI: grok-4-1-fast-non-reasoning"),
             ("grok-4", "xAI: grok-4"),
             ("grok-code-fast-1", "xAI: grok-code-fast-1"),
-            ("claude-haiku-4-5-20251001", "Anthropic: claude-haiku-4-5-20251001 (thinking OFF)"),
-            ("claude-haiku-4-5-20251001-thinking", "Anthropic: claude-haiku-4-5-20251001 (thinking ON)"),
-            ("claude-sonnet-4-5-20250929", "Anthropic: claude-sonnet-4-5-20250929 (thinking OFF)"),
-            ("claude-sonnet-4-5-20250929-thinking", "Anthropic: claude-sonnet-4-5-20250929 (thinking ON)"),
-            ("claude-opus-4-1-20250805", "Anthropic: claude-opus-4-1-20250805 (thinking OFF)"),
-            ("claude-opus-4-1-20250805-thinking", "Anthropic: claude-opus-4-1-20250805 (thinking ON)"),
-            ("claude-opus-4-5-20251101", "Anthropic: claude-opus-4-5-20251101 (thinking OFF)"),
+            ("claude-sonnet-4-5-20250929", "Anthropic: claude-sonnet-4-5-20250929 (thinking OFF)"),
+            ("claude-sonnet-4-5-20250929-thinking", "Anthropic: claude-sonnet-4-5-20250929 (thinking ON)"),
+            ("claude-opus-4-5-20251101", "Anthropic: claude-opus-4-5-20251101 (thinking OFF)"),
             ("claude-opus-4-5-20251101-thinking", "Anthropic: claude-opus-4-5-20251101 (thinking ON)"),
             ("glm-4.6", "GLM: glm-4.6"),
         ]
@@ -2603,11 +2579,11 @@ class ChatCLI:
             "deepseek-reasoner-3.2",
             "claude-opus-4-5-20251101",
             "gemini-3-pro-preview",
+            "gemini-3-flash-preview",
             "gpt-5",
             "gpt-5.2",
             "kimi-k2-thinking",
             "grok-code-fast-1",
-            "gpt-5.1-codex-max",
         }
         rec_list: List[Tuple[str, str]] = [(m, lbl) for (m, lbl) in model_presets if m in rec_keys]
         other_list: List[Tuple[str, str]] = [(m, lbl) for (m, lbl) in model_presets if m not in rec_keys]
@@ -2662,7 +2638,9 @@ class ChatCLI:
                 },
                 {"id": "auto_approve", "label": "Auto-approve tools (comma)", "type": "text"},
                 {"id": "show_tool_calls", "label": "Show tool call logs", "type": "bool"},
-                {"id": "reasoning_effort", "label": "OpenAI reasoning effort", "type": "enum", "options": (["low", "medium", "high", "xhigh"] if self._supports_xhigh_reasoning_effort(self.model) else ["low", "medium", "high"]), "render": {"low": "Low", "medium": "Medium", "high": "High", "xhigh": "XHigh (Codex Max / GPT-5.2)"}},
+                # Note: options are static for this Settings UI session, so include xhigh unconditionally.
+                # The server will safely downgrade xhigh on models that don't support it.
+                {"id": "reasoning_effort", "label": "OpenAI reasoning effort", "type": "enum", "options": ["low", "medium", "high", "xhigh"], "render": {"low": "Low", "medium": "Medium", "high": "High", "xhigh": "XHigh (gpt-5.2* / Codex Max; otherwise downgrades)"}},
                 {"id": "codex_max_allow_all_tools", "label": "Codex Max: allow ALL tools", "type": "bool"},
                 {"id": "retain_native_tool_results", "label": "Retain provider-native tool results across turns", "type": "bool"},
                 {"id": "thinking_budget_tokens", "label": "Anthropic thinking budget (tokens)", "type": "int"},
@@ -2721,10 +2699,10 @@ class ChatCLI:
             try:
                 if rid == "model":
                     if value == "custom":
-                        typed = self.ui.prompt(
-                            "Enter model name (e.g., deepseek-chat, gpt-5, gemini-2.5-flash)",
-                            default=self.model or "",
-                        )
+                        typed = self.ui.prompt(
+                            "Enter model name (e.g., deepseek-chat, gpt-5, gemini-3-flash-preview)",
+                            default=self.model or "",
+                        )
                         working["model"] = typed.strip() or None
                     self._apply_model_side_effects()
                 elif rid == "text_verbosity" and isinstance(value, str):
@@ -4417,20 +4395,25 @@ class ChatCLI:
             self.ui.warn("Unknown /websearch subcommand. Use on, off, domains, sources, or location.")
             return True
 
-        if cmd.startswith("/reasoning"):
-            parts = cmd.split(maxsplit=1)
-            if len(parts) == 1:
-                self.ui.info("Usage: /reasoning low|medium|high")
-                self.ui.info(f"Current: {self.reasoning_effort}")
-                return True
-            arg = (parts[1] or "").strip().lower()
-            if arg in ("low", "medium", "high"):
-                self.reasoning_effort = arg
-                self.ui.success(f"Reasoning effort set to: {self.reasoning_effort}")
-                self.save_settings()
-            else:
-                self.ui.warn("Invalid value. Use: low, medium, or high")
-            return True
+        if cmd.startswith("/reasoning"):
+            parts = cmd.split(maxsplit=1)
+            if len(parts) == 1:
+                self.ui.info("Usage: /reasoning low|medium|high|xhigh")
+                self.ui.info(f"Current: {self.reasoning_effort}")
+                return True
+            arg = (parts[1] or "").strip().lower()
+            if arg in ("low", "medium", "high", "xhigh"):
+                self.reasoning_effort = arg
+                if arg == "xhigh" and not self._supports_xhigh_reasoning_effort(self.model):
+                    # Keep the user's preference, but be explicit about server-side downgrading.
+                    self.ui.warn(
+                        "Note: xhigh is only applied on models that support it (e.g., gpt-5.2* / gpt-5.1-codex-max). The server may downgrade it on other models."
+                    )
+                self.ui.success(f"Reasoning effort set to: {self.reasoning_effort}")
+                self.save_settings()
+            else:
+                self.ui.warn("Invalid value. Use: low, medium, high, or xhigh")
+            return True
 
         if cmd.startswith("/thinkingbudget"):
             parts = cmd.split(maxsplit=1)
@@ -5048,10 +5031,10 @@ class ChatCLI:
         # Recommended models (ordered list for shuffling)
         # Curated list per request (include Codex Max as recommended)
         rec_keys = [
-            "gpt-5.1-codex-max",
             "deepseek-reasoner-3.2",
             "claude-opus-4-5-20251101",
             "gemini-3-pro-preview",
+            "gemini-3-flash-preview",
             "gpt-5",
             "gpt-5.2",
             "kimi-k2-thinking",
@@ -5122,10 +5105,10 @@ class ChatCLI:
             self.model = None
             self.ui.info("Model cleared; server default will be used.")
         elif picked == "custom":
-            typed = self.ui.prompt(
-                "Enter model name (e.g., deepseek-chat, gpt-5, gemini-2.5-flash)",
-                default=self.model or "",
-            )
+            typed = self.ui.prompt(
+                "Enter model name (e.g., deepseek-chat, gpt-5, gemini-3-flash-preview)",
+                default=self.model or "",
+            )
             self.model = self._resolve_model_alias(typed.strip() or None)
             if not self.model:
                 self.ui.info("Model cleared; server default will be used.")
@@ -5315,12 +5298,6 @@ class ChatCLI:
         payload: Dict[str, Any] = {"messages": self._build_messages(user_input)}
         if self.model:
             payload["model"] = self.model
-        # Codex Max: allow ALL tools per-request when enabled in settings
-        try:
-            if self._is_codex_max(payload.get("model")) and bool(getattr(self, "codex_max_allow_all_tools", False)):
-                payload["codex_max_allow_all_tools"] = True
-        except Exception:
-            pass
         # Include terminal identifier so the server can isolate per-terminal workspace if it executes tools
         try:
             if self.terminal_id:
@@ -5375,18 +5352,11 @@ class ChatCLI:
                 payload["auto_approve_command_bases"] = cmd_bases
         except Exception:
             pass
-        # Reasoning effort (OpenAI reasoning models only; server will ignore for others)
+        # Reasoning effort (OpenAI reasoning models only; server will ignore for others).
+        # Let the server decide whether xhigh is supported for the selected (or default) model.
         try:
-            if isinstance(self.reasoning_effort, str):
-                if self.reasoning_effort in ("low", "medium", "high"):
-                    payload["reasoning_effort"] = self.reasoning_effort
-                elif self.reasoning_effort == "xhigh":
-                    if self._supports_xhigh_reasoning_effort(payload.get("model")):
-                        payload["reasoning_effort"] = "xhigh"
-                    else:
-                        payload["reasoning_effort"] = "medium"
-                else:
-                    payload["reasoning_effort"] = "medium"
+            if isinstance(self.reasoning_effort, str) and self.reasoning_effort in ("low", "medium", "high", "xhigh"):
+                payload["reasoning_effort"] = self.reasoning_effort
             else:
                 payload["reasoning_effort"] = "medium"
         except Exception:
@@ -5619,15 +5589,18 @@ class ChatCLI:
                                     self._rawlog_write(msg)
                             except Exception:
                                 pass
-                        # Idle "thinking" indicator shown while waiting for the next event (first tokens or next tool call)
-                        indicator_task = None
-                        indicator_active = False
-                        indicator_started = False  # used only to adjust leading newline behavior on first assistant header
-                        # Mode: animate or static (default static for stability)
-                        try:
-                            _animate_indicator = (os.getenv("HENOSIS_THINKING_ANIMATE", "").strip().lower() in ("1", "true", "yes", "on"))
-                        except Exception:
-                            _animate_indicator = False
+                        # Idle "thinking" indicator shown while waiting for the next event (first tokens or next tool call)
+                        indicator_task = None
+                        indicator_active = False
+                        indicator_started = False  # used only to adjust leading newline behavior on first assistant header
+                        # Track whether we're currently positioned at the start of a fresh line.
+                        # This prevents double-newlines between back-to-back tool events.
+                        at_line_start = True
+                        # Mode: animate or static (default static for stability)
+                        try:
+                            _animate_indicator = (os.getenv("HENOSIS_THINKING_ANIMATE", "").strip().lower() in ("1", "true", "yes", "on"))
+                        except Exception:
+                            _animate_indicator = False
 
                         async def _thinking_indicator_loop(chosen_word: str, spacing: int = 3) -> None:
                             """Animate a transient thinking word on a single line until indicator_active becomes False.
@@ -5666,8 +5639,8 @@ class ChatCLI:
                                 except Exception:
                                     pass
 
-                        async def _indicator_start() -> None:
-                            nonlocal indicator_task, indicator_active, indicator_started
+                        async def _indicator_start() -> None:
+                            nonlocal indicator_task, indicator_active, indicator_started, at_line_start
                             # Choose a random word and spacing each start
                             word_bank = list(self._thinking_words or ["thinking", "working..."])
                             if not word_bank:
@@ -5695,21 +5668,28 @@ class ChatCLI:
                                     c = colors[i % len(colors)]
                                     out_chars.append(f"\x1b[38;5;{c}m{ch}\x1b[0m")
                                 line = " " + joiner.join(out_chars) + " "
-                                # Start on a dedicated new line so we never clobber prior output
-                                sys.stdout.write("\n")
-                                sys.stdout.write("\r\x1b[2K" + line)
-                                sys.stdout.flush()
+                                # Start on a dedicated new line so we never clobber prior output.
+                                # If we're already at a fresh line, don't emit an extra newline (prevents
+                                # visible blank lines between back-to-back tool events).
+                                if not at_line_start:
+                                    sys.stdout.write("\n")
+                                sys.stdout.write("\r\x1b[2K" + line)
+                                sys.stdout.flush()
+                                at_line_start = False
                                 # File debug
                                 try:
                                     self.ui.debug_log(f"indicator.start word='{chosen}' animate={_animate_indicator}")
                                 except Exception:
                                     pass
-                            except Exception:
-                                try:
-                                    sys.stdout.write("\n" + (" " + joiner.join(list(str(chosen))) + " "))
-                                    sys.stdout.flush()
-                                except Exception:
-                                    pass
+                            except Exception:
+                                try:
+                                    if not at_line_start:
+                                        sys.stdout.write("\n")
+                                    sys.stdout.write("\r\x1b[2K" + (" " + joiner.join(list(str(chosen))) + " "))
+                                    sys.stdout.flush()
+                                    at_line_start = False
+                                except Exception:
+                                    pass
                             indicator_started = True
                             if _animate_indicator:
                                 try:
@@ -5719,8 +5699,8 @@ class ChatCLI:
                                     indicator_task = None
                                     indicator_active = False
 
-                        async def _indicator_stop(clear: bool = False) -> None:
-                            nonlocal indicator_task, indicator_active, indicator_started
+                        async def _indicator_stop(clear: bool = False) -> None:
+                            nonlocal indicator_task, indicator_active, indicator_started, at_line_start
                             # Only clear the line if an indicator was actually started.
                             was_started = bool(indicator_started)
                             indicator_active = False
@@ -5738,19 +5718,21 @@ class ChatCLI:
                             finally:
                                 indicator_task = None
                                 # Default to not clearing to avoid erasing streamed content lines
-                                if was_started and clear:
-                                    try:
-                                        sys.stdout.write("\r\x1b[2K")
-                                        sys.stdout.flush()
-                                    except Exception:
-                                        pass
-                                elif was_started:
-                                    # Move to the next line to separate subsequent output
-                                    try:
-                                        sys.stdout.write("\n")
-                                        sys.stdout.flush()
-                                    except Exception:
-                                        pass
+                                if was_started and clear:
+                                    try:
+                                        sys.stdout.write("\r\x1b[2K")
+                                        sys.stdout.flush()
+                                        at_line_start = True
+                                    except Exception:
+                                        pass
+                                elif was_started:
+                                    # Move to the next line to separate subsequent output
+                                    try:
+                                        sys.stdout.write("\n")
+                                        sys.stdout.flush()
+                                        at_line_start = True
+                                    except Exception:
+                                        pass
                                 # Reset started flag after stopping
                                 indicator_started = False
                                 try:
@@ -5810,14 +5792,16 @@ class ChatCLI:
                                     pass
                                 continue
     
-                            elif event == "message.delta":
-                                # Stop any transient indicator before printing content and clear the line
-                                try:
-                                    await _indicator_stop(clear=True)
-                                except Exception:
-                                    pass
-                                text = data.get("text", "")
-                                if text:
+                            elif event == "message.delta":
+                                # Stop any transient indicator before printing content and clear the line
+                                try:
+                                    await _indicator_stop(clear=True)
+                                except Exception:
+                                    pass
+                                # Indicator line cleared; we're now at the start of a fresh line.
+                                at_line_start = True
+                                text = data.get("text", "")
+                                if text:
                                     try:
                                         _deltas_total += 1
                                     except Exception:
@@ -5852,21 +5836,23 @@ class ChatCLI:
                                                 print(str(model_label) + ": ", end="", flush=True)
                                             except Exception:
                                                 pass
-                                        header_printed = True
-                                        try:
-                                            self.ui.debug_log(f"header.printed model='{model_label}' on_first_delta")
-                                        except Exception:
-                                            pass
+                                        header_printed = True
+                                        at_line_start = False
+                                        try:
+                                            self.ui.debug_log(f"header.printed model='{model_label}' on_first_delta")
+                                        except Exception:
+                                            pass
                                     assistant_buf.append(text)
                                     # Print the token delta raw to avoid any wrapping/markup side-effects
                                     try:
                                         self.ui.print(text, style=self.ui.theme["assistant"], end="")
-                                    except Exception:
-                                        try:
-                                            print(str(text), end="", flush=True)
-                                        except Exception:
-                                            pass
-                                    # Deep debug: show each delta's size/preview
+                                    except Exception:
+                                        try:
+                                            print(str(text), end="", flush=True)
+                                        except Exception:
+                                            pass
+                                    at_line_start = False
+                                    # Deep debug: show each delta's size/preview
                                     try:
                                         if DEBUG_SSE:
                                             prev = text[:40].replace("\n", "\\n")
@@ -5885,17 +5871,29 @@ class ChatCLI:
                                     except Exception:
                                         pass
     
-                            elif event == "tool.call":
-                                # Ensure any prior indicator state is reset cleanly, then restart
-                                # a fresh indicator while waiting for the tool to run.
-                                try:
-                                    await _indicator_stop(clear=True)
-                                except Exception:
-                                    pass
-
-                                name = data.get("name")
-                                args = data.get("args", {}) or {}
-                                call_id = data.get("call_id")
+                            elif event == "tool.call":
+                                # Ensure any prior indicator state is reset cleanly, then restart
+                                # a fresh indicator while waiting for the tool to run.
+                                try:
+                                    await _indicator_stop(clear=True)
+                                except Exception:
+                                    pass
+
+                                # If we were mid-line (e.g., streamed assistant text), break cleanly before
+                                # showing the transient tool-wait indicator.
+                                if not at_line_start:
+                                    try:
+                                        self.ui.print()
+                                    except Exception:
+                                        try:
+                                            print()
+                                        except Exception:
+                                            pass
+                                    at_line_start = True
+
+                                name = data.get("name")
+                                args = data.get("args", {}) or {}
+                                call_id = data.get("call_id")
                                 try:
                                     self.ui.debug_log(f"tool.call name='{name}' call_id={call_id}")
                                 except Exception:
@@ -5982,17 +5980,23 @@ class ChatCLI:
                                 name = str(data.get("name"))
                                 result = data.get("result", {}) or {}
                                 call_id = data.get("call_id")
-                                # Stop any indicator before rendering results
-                                try:
-                                    await _indicator_stop(clear=True)
-                                except Exception:
-                                    pass
-                                # Ensure tool result starts on a fresh line if assistant text was mid-line
-                                try:
-                                    buf_str = "".join(assistant_buf)
-                                except Exception:
-                                    buf_str = ""
-                                self.ui.ensure_newline(buf_str)
+                                # Stop any indicator before rendering results
+                                try:
+                                    await _indicator_stop(clear=True)
+                                except Exception:
+                                    pass
+                                # Ensure tool result starts on a fresh line if assistant text was mid-line.
+                                # Don't rely on assistant_buf ending with "\n" because UI.ensure_newline()
+                                # prints without mutating the buffer, which can cause repeated blank lines.
+                                if not at_line_start:
+                                    try:
+                                        self.ui.print()
+                                    except Exception:
+                                        try:
+                                            print()
+                                        except Exception:
+                                            pass
+                                at_line_start = True
                                 # Concise default: one professional, natural-language line per tool call.
                                 if not self.ui.verbose:
                                     try:
@@ -6048,13 +6052,18 @@ class ChatCLI:
                                     except Exception:
                                         # Fall back to legacy renderer on unexpected issues
                                         self._render_tool_result(name, result, call_id=call_id)
-                                else:
-                                    # Verbose mode retains the richer summary with previews
-                                    self._render_tool_result(name, result, call_id=call_id)
-                                try:
-                                    await self._ws_broadcast("tool.result", {"name": name, "result": result, "call_id": call_id})
-                                except Exception:
-                                    pass
+                                else:
+                                    # Verbose mode retains the richer summary with previews
+                                    self._render_tool_result(name, result, call_id=call_id)
+
+                                # Tool result output is line-oriented; after rendering we should be positioned
+                                # at the start of a fresh line so the next tool.call indicator doesn't insert
+                                # an extra blank line.
+                                at_line_start = True
+                                try:
+                                    await self._ws_broadcast("tool.result", {"name": name, "result": result, "call_id": call_id})
+                                except Exception:
+                                    pass
                                 # For Kimi, append provider-native tool result to raw history so it's threaded correctly
                                 try:
                                     if bool(getattr(self, "retain_native_tool_results", False)) and isinstance(self.model, str) and self.model.startswith("kimi-") and call_id:
@@ -6683,12 +6692,13 @@ class ChatCLI:
                                 # Compact style: include reasoning effort inline with model name when applicable
                                 try:
                                     effort_seg = ""
-                                    if self._is_openai_reasoning_model(model_used):
-                                        # Convert low|medium|high -> Low|Medium|High for display
-                                        lvl = str(self.reasoning_effort or "medium").strip().lower()
-                                        if lvl not in ("low", "medium", "high"):
-                                            lvl = "medium"
-                                        effort_seg = f" {lvl.capitalize()}"
+                                    if self._is_openai_reasoning_model(model_used):
+                                        # Convert low|medium|high|xhigh -> Low|Medium|High|XHigh for display
+                                        lvl = str(self.reasoning_effort or "medium").strip().lower()
+                                        if lvl not in ("low", "medium", "high", "xhigh"):
+                                            lvl = "medium"
+                                        disp = {"low": "Low", "medium": "Medium", "high": "High", "xhigh": "XHigh"}.get(lvl, "Medium")
+                                        effort_seg = f" {disp}"
                                 except Exception:
                                     effort_seg = ""
                                 model_only_line = f"model: {model_used or '(unknown)'}{effort_seg}"
@@ -7375,11 +7385,12 @@ class ChatCLI:
                     # Reasoning effort tag for OpenAI reasoning models
                     try:
                         effort_seg = ""
-                        if self._is_openai_reasoning_model(model_label):
-                            lvl = str(self.reasoning_effort or "medium").strip().lower()
-                            if lvl not in ("low", "medium", "high"):
-                                lvl = "medium"
-                            effort_seg = f" {lvl.capitalize()}"
+                        if self._is_openai_reasoning_model(model_label):
+                            lvl = str(self.reasoning_effort or "medium").strip().lower()
+                            if lvl not in ("low", "medium", "high", "xhigh"):
+                                lvl = "medium"
+                            disp = {"low": "Low", "medium": "Medium", "high": "High", "xhigh": "XHigh"}.get(lvl, "Medium")
+                            effort_seg = f" {disp}"
                     except Exception:
                         effort_seg = ""
                     try:
@@ -7506,13 +7517,8 @@ class ChatCLI:
                     if self.auto_approve:
                         new_payload["auto_approve"] = self.auto_approve
                     try:
-                        if isinstance(self.reasoning_effort, str):
-                            if self.reasoning_effort in ("low", "medium", "high"):
-                                new_payload["reasoning_effort"] = self.reasoning_effort
-                            elif self.reasoning_effort == "xhigh" and self._supports_xhigh_reasoning_effort(self.model):
-                                new_payload["reasoning_effort"] = "xhigh"
-                            else:
-                                new_payload["reasoning_effort"] = "medium"
+                        if isinstance(self.reasoning_effort, str) and self.reasoning_effort in ("low", "medium", "high", "xhigh"):
+                            new_payload["reasoning_effort"] = self.reasoning_effort
                         else:
                             new_payload["reasoning_effort"] = "medium"
                     except Exception:
@@ -7788,16 +7794,14 @@ class ChatCLI:
         if not ctx_map:
             try:
                 ctx_map.update({
-                    "gpt-5.1": 400000,
                     "gpt-5.2": 400000,
-                    "gpt-5.1-mini": 400000,
+                    "gpt-5.2-pro": 400000,
                     "gpt-5": 400000,
                     "gpt-5-2025-08-07": 400000,
-                    "gpt-5-mini-2025-08-07": 400000,
                     "codex-mini-latest": 200000,
                     "gemini-2.5-pro": 1048576,
-                    "gemini-2.5-flash": 1048576,
-                    "gemini-3-pro-preview": 1000000,
+                    "gemini-3-flash-preview": 1048576,
+                    "gemini-3-pro-preview": 1000000,
                     "grok-4-1-fast-reasoning": 2000000,
                     "grok-4-1-fast-non-reasoning": 2000000,
                     "grok-4": 200000,
@@ -7808,13 +7812,9 @@ class ChatCLI:
                     "kimi-k2-0905-preview": 262144,
                     "claude-sonnet-4-20250514": 1000000,
                     "claude-sonnet-4-20250514-thinking": 1000000,
-                    "claude-sonnet-4-5-20250929": 1000000,
-                    "claude-sonnet-4-5-20250929-thinking": 1000000,
-                    "claude-haiku-4-5-20251001": 200000,
-                    "claude-haiku-4-5-20251001-thinking": 200000,
-                    "claude-opus-4-1-20250805": 200000,
-                    "claude-opus-4-1-20250805-thinking": 200000,
-                    "claude-opus-4-5-20251101": 200000,
+                    "claude-sonnet-4-5-20250929": 1000000,
+                    "claude-sonnet-4-5-20250929-thinking": 1000000,
+                    "claude-opus-4-5-20251101": 200000,
                     "claude-opus-4-5-20251101-thinking": 200000,
                     "glm-4.6": 200000,
                 })
@@ -7846,19 +7846,19 @@ class ChatCLI:
 
     # --------------------- Tier-aware defaults -------------------------
 
-    def _recommended_default_model(self) -> str:
-        """Return the tier-aware recommended default model.
+    def _recommended_default_model(self) -> str:
+        """Return the tier-aware recommended default model.
 
         - Free-tier users: recommend Kimi k2-thinking (free-tier friendly reasoning model).
-        - All other users: recommend gpt-5.1 (best overall default).
-        When tier is unknown, fall back to gpt-5.1.
-        """
+        - All other users: recommend gpt-5.2 (best overall default).
+        When tier is unknown, fall back to gpt-5.2.
+        """
         try:
             if bool(self.is_free_tier):
                 return "kimi-k2-thinking"
         except Exception:
             pass
-        return "gpt-5.1"
+        return "gpt-5.2"
 
     # --------------------- Onboarding and Welcome ---------------------
     async def _welcome_flow(self) -> None:

{henosis_cli-0.6.4.dist-info → henosis_cli-0.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henosis-cli
-Version: 0.6.4
+Version: 0.6.7
 Summary: henosis-cli — interactive CLI for the Henosis multi-provider streaming chat backend, with optional local tools.
 Author-email: henosis <henosis@henosis.us>
 License-Expression: LicenseRef-Proprietary

henosis_cli-0.6.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+cli.py,sha256=XgyMuIBF-b20rQ2mIAAYDLVxEzZB4-4DlZQ0a4V_1UY,501266
+henosis_cli_tools/__init__.py,sha256=x3uaN_ub32uALx_oURna0VnuoSsj7i9NYY6uRsc2ZzM,1147
+henosis_cli_tools/cli_entry.py,sha256=OZTe_s9Hfy3mcsYG77T3RTdtCDod-CSwmhskbXjmmqs,1713
+henosis_cli_tools/input_engine.py,sha256=kGW6AgDGbdcVxlx5mvTPKYe4lYhho5wztvUAw7WlmTs,15286
+henosis_cli_tools/settings_ui.py,sha256=8rWsp0S3wT-dgkP0y20FOBmBBy7jYbDy8AuftmKcp4w,21368
+henosis_cli_tools/tool_impl.py,sha256=0iojZbVZhhPJybcmb2qYAuCesgQMp83JgPL2Py4PjT8,39250
+henosis_cli-0.6.7.dist-info/METADATA,sha256=orIj5bXfMXfOSh3TeKpGkgOUWv6Ea2pBKB5rzkAbcKk,5787
+henosis_cli-0.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+henosis_cli-0.6.7.dist-info/entry_points.txt,sha256=KmXDdmIjq1SVMs8FK3wHPA2i89RMaerzZHIetllMLIk,74
+henosis_cli-0.6.7.dist-info/top_level.txt,sha256=u7XMBcJ8Kb0n91WaSU-4Db8yURSUXFuOxGMsXti0a-g,34
+henosis_cli-0.6.7.dist-info/RECORD,,

henosis_cli_tools/tool_impl.py

@@ -70,12 +70,37 @@ _DEFAULT_ALLOWED_EXTS = {
     ".conf",
 }
 
-_MAX_FILE_BYTES = int(os.getenv("HENOSIS_MAX_FILE_BYTES", str(1_073_741_824)))
-_MAX_EDIT_BYTES = int(os.getenv("HENOSIS_MAX_EDIT_BYTES", str(1_073_741_824)))
-_EDIT_SAFEGUARD_MAX_LINES = int(os.getenv("HENOSIS_EDIT_SAFEGUARD_MAX_LINES", "3000"))
-_COMMAND_TIMEOUT_SEC = float(os.getenv("HENOSIS_COMMAND_TIMEOUT_SEC", "30"))
-# Max chars for stdout/stderr before truncation notice is applied
-_CMD_OUTPUT_MAX_CHARS = 3000
+_MAX_FILE_BYTES = int(os.getenv("HENOSIS_MAX_FILE_BYTES", str(1_073_741_824)))
+_MAX_EDIT_BYTES = int(os.getenv("HENOSIS_MAX_EDIT_BYTES", str(1_073_741_824)))
+_EDIT_SAFEGUARD_MAX_LINES = int(os.getenv("HENOSIS_EDIT_SAFEGUARD_MAX_LINES", "3000"))
+
+# Command timeout behavior:
+# - The tool call can request a per-invocation timeout via the `timeout` argument.
+# - The client/user may configure a DEFAULT (used when the tool omits timeout)
+#   and a MAX (hard cap for safety).
+# - Backward compatibility: legacy env var HENOSIS_COMMAND_TIMEOUT_SEC is treated as MAX.
+def _env_float(name: str, default: float) -> float:
+    try:
+        v = os.getenv(name, "")
+        if v is None:
+            return float(default)
+        s = str(v).strip()
+        if not s:
+            return float(default)
+        return float(s)
+    except Exception:
+        return float(default)
+
+
+_COMMAND_TIMEOUT_DEFAULT_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_DEFAULT_SEC", 360.0)
+_LEGACY_COMMAND_TIMEOUT_SEC_RAW = os.getenv("HENOSIS_COMMAND_TIMEOUT_SEC", "")
+if str(_LEGACY_COMMAND_TIMEOUT_SEC_RAW or "").strip():
+    _COMMAND_TIMEOUT_MAX_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_SEC", 900.0)
+else:
+    _COMMAND_TIMEOUT_MAX_SEC = _env_float("HENOSIS_COMMAND_TIMEOUT_MAX_SEC", 900.0)
+
+# Max chars for stdout/stderr before truncation notice is applied
+_CMD_OUTPUT_MAX_CHARS = 3000
 
 _VERBOSE_NOTICE = (
     "console output was EXTEREMELY verbose the ouput was truncated as to not overflow your context. here are the last 3k chars:\n"
@@ -322,13 +347,22 @@ def run_command(cmd: str, policy: FileToolPolicy, cwd: Optional[str] = None, tim
     base = os.path.basename(exe).lower()
     if (not allow_all) and (base not in allow_set):
         return {"ok": False, "error": f"command '{base}' not allowed"}
-    try:
-        requested = float(timeout) if timeout is not None else _COMMAND_TIMEOUT_SEC
-    except Exception:
-        requested = _COMMAND_TIMEOUT_SEC
-    timeout_s = min(max(0.01, requested), float(_COMMAND_TIMEOUT_SEC))
-    start = time.time()
-    try:
+    # Determine effective timeout: tool-controlled within a user-configurable maximum.
+    try:
+        requested = float(timeout) if timeout is not None else float(_COMMAND_TIMEOUT_DEFAULT_SEC)
+    except Exception:
+        requested = float(_COMMAND_TIMEOUT_DEFAULT_SEC)
+    try:
+        max_sec = float(_COMMAND_TIMEOUT_MAX_SEC)
+    except Exception:
+        max_sec = 900.0
+    if max_sec <= 0:
+        # Degenerate config; keep tool safe.
+        max_sec = 0.01
+    timeout_s = min(max(0.01, requested), max_sec)
+    timeout_was_clamped = bool(requested > max_sec)
+    start = time.time()
+    try:
         # Force UTF-8 decoding with replacement to avoid locale-dependent decode errors
         # on Windows (e.g., cp1252 UnicodeDecodeError in reader thread).
         proc = subprocess.run(
@@ -341,39 +375,51 @@ def run_command(cmd: str, policy: FileToolPolicy, cwd: Optional[str] = None, tim
             errors="replace",
             timeout=timeout_s,
         )
-        dur_ms = int((time.time() - start) * 1000)
+        dur_ms = int((time.time() - start) * 1000)
         # Truncate very verbose outputs to protect context size
         out = _truncate_if_verbose(proc.stdout)
         err = _truncate_if_verbose(proc.stderr)
-        return {
-            "ok": True,
-            "data": {
-                "cmd": cmd_str,
-                "cwd": str(cwd_path),
-                "exit_code": proc.returncode,
-                "stdout": out,
-                "stderr": err,
-                "timed_out": False,
-                "duration_ms": dur_ms,
-            },
-        }
-    except subprocess.TimeoutExpired as e:
-        dur_ms = int((time.time() - start) * 1000)
+        return {
+            "ok": True,
+            "data": {
+                "cmd": cmd_str,
+                "cwd": str(cwd_path),
+                "exit_code": proc.returncode,
+                "stdout": out,
+                "stderr": err,
+                "timed_out": False,
+                "duration_ms": dur_ms,
+                "timeout_requested_sec": requested,
+                "timeout_effective_sec": timeout_s,
+                "timeout_max_sec": max_sec,
+                "timeout_was_clamped": timeout_was_clamped,
+            },
+        }
+    except subprocess.TimeoutExpired as e:
+        dur_ms = int((time.time() - start) * 1000)
         # Even in timeout, ensure any captured output is truncated if overly verbose
         out = _truncate_if_verbose(e.stdout or "")
         err = _truncate_if_verbose(e.stderr or "")
-        return {
-            "ok": True,
-            "data": {
-                "cmd": cmd_str,
-                "cwd": str(cwd_path),
-                "exit_code": None,
-                "stdout": out,
-                "stderr": err,
-                "timed_out": True,
-                "duration_ms": dur_ms,
-            },
-        }
+        return {
+            "ok": True,
+            "data": {
+                "cmd": cmd_str,
+                "cwd": str(cwd_path),
+                "exit_code": None,
+                "stdout": out,
+                "stderr": err,
+                "timed_out": True,
+                "duration_ms": dur_ms,
+                "timeout_requested_sec": requested,
+                "timeout_effective_sec": timeout_s,
+                "timeout_max_sec": max_sec,
+                "timeout_was_clamped": timeout_was_clamped,
+                "message": (
+                    f"Command exceeded timeout (effective_timeout={timeout_s}s). "
+                    "Process was terminated."
+                ),
+            },
+        }
 
 # ---------------------------- apply_patch ----------------------------#
 def _ap_normalize_unicode(s: str) -> str:

henosis_cli-0.6.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-cli.py,sha256=2btVCM5KSbsbhf6_8y-7Of0yUB4EbZUqm1Q_HmmjUIk,500984
-henosis_cli_tools/__init__.py,sha256=x3uaN_ub32uALx_oURna0VnuoSsj7i9NYY6uRsc2ZzM,1147
-henosis_cli_tools/cli_entry.py,sha256=OZTe_s9Hfy3mcsYG77T3RTdtCDod-CSwmhskbXjmmqs,1713
-henosis_cli_tools/input_engine.py,sha256=kGW6AgDGbdcVxlx5mvTPKYe4lYhho5wztvUAw7WlmTs,15286
-henosis_cli_tools/settings_ui.py,sha256=8rWsp0S3wT-dgkP0y20FOBmBBy7jYbDy8AuftmKcp4w,21368
-henosis_cli_tools/tool_impl.py,sha256=oZGajJMkR2jfyuPVe-iq2s6ktOl5-2K3RzX2R7FIAFQ,37414
-henosis_cli-0.6.4.dist-info/METADATA,sha256=VhjQpdEqWxDfMv5nAR_sfovg1XYt_PiurHQsz-LGGwo,5787
-henosis_cli-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-henosis_cli-0.6.4.dist-info/entry_points.txt,sha256=KmXDdmIjq1SVMs8FK3wHPA2i89RMaerzZHIetllMLIk,74
-henosis_cli-0.6.4.dist-info/top_level.txt,sha256=u7XMBcJ8Kb0n91WaSU-4Db8yURSUXFuOxGMsXti0a-g,34
-henosis_cli-0.6.4.dist-info/RECORD,,