kolega-code 0.35.0__tar.gz → 0.36.0__tar.gz

{kolega_code-0.35.0 → kolega_code-0.36.0}/CHANGELOG.md

@@ -6,6 +6,45 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.36.0 - 2026-09-07
+
+### Added
+
+- **GPT-6 Astra.** OpenAI's new flagship model is available on both the API
+  and ChatGPT-subscription providers: 1M-token context with 128K output,
+  vision, hosted web search, `codex_apply_patch` editing, and
+  `low`–`max` reasoning effort levels (default `medium`). The
+  ChatGPT-subscription route keeps the conservative 400K input budget until
+  Astra's larger window is verified on the Codex backend.
+- **Pre-registered OAuth credentials for remote MCP servers.** Servers that
+  don't implement Dynamic Client Registration (HubSpot, Slack, GitHub
+  Copilot, enterprise IdPs) can now be connected with a pre-registered
+  client: new `--oauth-client-id`, `--oauth-client-secret`,
+  `--oauth-client-secret-env`, and `--oauth-auth-method` flags on
+  `kolega-code mcp add`, matching OAuth controls on the MCP page in TUI
+  settings, preserved explicit redirect ports/hosts, actionable diagnostics
+  when registration fails, and PBKDF2-salted OAuth cache fingerprints with
+  refresh tokens preserved across reconnects.
+
+### Fixed
+
+- **Gateway (Telegram):** the typing indicator now stays alive for the whole
+  turn. Telegram expires typing actions after ~5 seconds, so it previously
+  vanished during exactly the stretches where feedback matters — model
+  thinking before the first chunk and long-running tool calls.
+
+## 0.35.1 - 2026-09-03
+
+### Fixed
+
+- **Gateway (Telegram):** the tool-activity status now re-appears below the
+  newest reply bubble. Previously it stayed stranded in an older message once
+  a reply opened, so later tool calls looked detached from the conversation.
+  Adapters without message-delete support keep the edit-in-place behavior.
+- **Gateway service:** the background daemon now launches through the user's
+  login shell, so gateway-driven agent sessions see user-installed tools such
+  as Homebrew instead of the minimal `PATH` that launchd and systemd provide.
+
 ## 0.35.0 - 2026-09-03
 
 ### Added

{kolega_code-0.35.0 → kolega_code-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.35.0
+Version: 0.36.0
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.35.0"
+__version__ = "0.36.0"

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.35.0"
+__version__ = "0.36.0"

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/cli/main.py

@@ -796,6 +796,14 @@ def _build_subcommand_parser() -> argparse.ArgumentParser:
     add.add_argument("--env", action="append", default=[], help="Environment variable as NAME=VALUE (repeatable).")
     add.add_argument("--cwd", help="Working directory for stdio command; relative paths resolve under project.")
     add.add_argument("--oauth", action="store_true", help="Enable OAuth for this HTTP MCP server.")
+    add.add_argument("--oauth-client-id", help="Pre-registered OAuth client ID.")
+    add.add_argument("--oauth-client-secret", help="Pre-registered OAuth client secret.")
+    add.add_argument("--oauth-client-secret-env", help="Environment variable name holding the OAuth client secret.")
+    add.add_argument(
+        "--oauth-auth-method",
+        choices=["client_secret_post", "client_secret_basic", "none"],
+        help="Token endpoint authentication method.",
+    )
     add.add_argument("--oauth-scope", help="OAuth scopes to request.")
     add.add_argument("--redirect-uri", help="OAuth redirect URI; defaults to an ephemeral localhost callback.")
     add.add_argument("--disabled", action="store_true", help="Add the server disabled.")
@@ -2697,6 +2705,12 @@ def _mcp_mutation_target(args: argparse.Namespace, project_path: Path, state_dir
 def _server_config_from_add_args(args: argparse.Namespace) -> MCPServerConfig:
     headers = _parse_key_value_options(getattr(args, "header", []) or [], "--header")
     env = _parse_key_value_options(getattr(args, "env", []) or [], "--env")
+    oauth_client_id = getattr(args, "oauth_client_id", None)
+    oauth_client_secret = getattr(args, "oauth_client_secret", None)
+    oauth_client_secret_env = getattr(args, "oauth_client_secret_env", None)
+    oauth_auth_method = getattr(args, "oauth_auth_method", None)
+    oauth_enabled = bool(args.oauth) or bool(oauth_client_id or oauth_client_secret or oauth_client_secret_env)
+
     payload: dict[str, Any] = {
         "id": args.server_id,
         "name": args.name,
@@ -2709,9 +2723,13 @@ def _server_config_from_add_args(args: argparse.Namespace) -> MCPServerConfig:
         "env": env,
         "cwd": args.cwd,
         "oauth": {
-            "enabled": bool(args.oauth),
+            "enabled": oauth_enabled,
             "scope": args.oauth_scope,
             "redirect_uri": args.redirect_uri,
+            "client_id": oauth_client_id,
+            "client_secret": oauth_client_secret,
+            "client_secret_env": oauth_client_secret_env,
+            "token_endpoint_auth_method": oauth_auth_method,
         },
     }
     return MCPServerConfig.model_validate(payload)

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/cli/provider_registry.py

@@ -90,6 +90,7 @@ MODEL_LABELS: dict[str, str] = {
     "claude-opus-4-5-20251101": "Claude Opus 4.5",
     "claude-haiku-4-5-20251001": "Claude Haiku 4.5",
     # OpenAI (shared labels across the API and ChatGPT-subscription providers)
+    "gpt-6-astra": "GPT-6 Astra",
     "gpt-5.6-sol": "GPT-5.6 Sol",
     "gpt-5.6-terra": "GPT-5.6 Terra",
     "gpt-5.6-luna": "GPT-5.6 Luna",

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/cli/tui/settings_panel.py

@@ -104,6 +104,12 @@ MCP_TRANSPORT_OPTIONS = [
     ("stdio command", "stdio"),
 ]
 MCP_ENABLED_OPTIONS = [("Enabled", "true"), ("Disabled", "false")]
+MCP_OAUTH_AUTH_METHOD_OPTIONS = [
+    ("Auto (POST if secret, none if public)", "auto"),
+    ("client_secret_post", "client_secret_post"),
+    ("client_secret_basic", "client_secret_basic"),
+    ("none (public client / PKCE)", "none"),
+]
 MCP_STATUS_MESSAGE_MAX = 96
 MCP_STATUS_NAME_MAX = 34
 # Compression threshold select: "default" maps to None (the agent's built-in 95%).
@@ -417,6 +423,16 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             self._update_mcp_transport_fields(str(event.value))
             return
 
+        if select_id == "mcp_oauth_select":
+            transport = "streamable_http"
+            try:
+                transport = str(self._settings_query_one("#mcp_transport_select", Select).value)
+            except NoMatches:
+                pass
+            http = transport in {"streamable_http", "sse"}
+            self._update_mcp_oauth_fields(http and str(event.value) == "true")
+            return
+
         row = _row_for_widget(select_id)
         if row is not None and select_id == row.provider_id:
             provider = str(event.value)
@@ -1477,6 +1493,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             set_input("mcp_url_input", "")
             set_input("mcp_headers_input", "")
             set_select("mcp_oauth_select", "false")
+            set_input("mcp_oauth_client_id_input", "")
+            set_input("mcp_oauth_client_secret_input", "")
+            set_input("mcp_oauth_client_secret_env_input", "")
+            set_input("mcp_oauth_redirect_uri_input", "")
+            set_input("mcp_oauth_scope_input", "")
+            set_select("mcp_oauth_auth_method_select", "auto")
             set_input("mcp_command_input", "")
             set_input("mcp_args_input", "")
             set_input("mcp_env_input", "")
@@ -1491,6 +1513,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
         set_input("mcp_url_input", server.url or "")
         set_input("mcp_headers_input", json.dumps(server.headers, sort_keys=True) if server.headers else "")
         set_select("mcp_oauth_select", "true" if server.oauth.enabled else "false")
+        set_input("mcp_oauth_client_id_input", server.oauth.client_id or "")
+        set_input("mcp_oauth_client_secret_input", server.oauth.client_secret or "")
+        set_input("mcp_oauth_client_secret_env_input", server.oauth.client_secret_env or "")
+        set_input("mcp_oauth_redirect_uri_input", server.oauth.redirect_uri or "")
+        set_input("mcp_oauth_scope_input", server.oauth.scope or "")
+        set_select("mcp_oauth_auth_method_select", server.oauth.token_endpoint_auth_method or "auto")
         set_input("mcp_command_input", server.command or "")
         set_input("mcp_args_input", " ".join(shlex.quote(arg) for arg in server.args))
         set_input("mcp_env_input", json.dumps(server.env, sort_keys=True) if server.env else "")
@@ -1503,6 +1531,26 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             self._set_mcp_source_hint("This server is stored in your global MCP config.")
         self._update_mcp_transport_fields(server.transport)
 
+    def _update_mcp_oauth_fields(self, visible: bool) -> None:
+        for widget_id in (
+            "mcp_oauth_client_id_label",
+            "mcp_oauth_client_id_input",
+            "mcp_oauth_client_secret_label",
+            "mcp_oauth_client_secret_input",
+            "mcp_oauth_client_secret_env_label",
+            "mcp_oauth_client_secret_env_input",
+            "mcp_oauth_redirect_uri_label",
+            "mcp_oauth_redirect_uri_input",
+            "mcp_oauth_scope_label",
+            "mcp_oauth_scope_input",
+            "mcp_oauth_auth_method_label",
+            "mcp_oauth_auth_method_select",
+        ):
+            try:
+                self._settings_query_one(f"#{widget_id}").display = visible
+            except NoMatches:
+                pass
+
     def _update_mcp_transport_fields(self, transport: str) -> None:
         http = transport in {"streamable_http", "sse"}
         for widget_id, visible in (
@@ -1525,6 +1573,12 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
                 self._settings_query_one(f"#{widget_id}").display = visible
             except NoMatches:
                 pass
+        oauth_enabled = False
+        try:
+            oauth_enabled = http and str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
+        except NoMatches:
+            pass
+        self._update_mcp_oauth_fields(oauth_enabled)
         try:
             url_input = self._settings_query_one("#mcp_url_input", Input)
             if transport == "streamable_http":
@@ -1621,7 +1675,8 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
         enabled = str(self._settings_query_one("#mcp_enabled_select", Select).value) == "true"
         url = self._settings_query_one("#mcp_url_input", Input).value.strip() or None
         headers_text = self._settings_query_one("#mcp_headers_input", Input).value.strip()
-        oauth_enabled = str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
+        http = transport in {"streamable_http", "sse"}
+        oauth_enabled = http and str(self._settings_query_one("#mcp_oauth_select", Select).value) == "true"
         command = self._settings_query_one("#mcp_command_input", Input).value.strip() or None
         args_text = self._settings_query_one("#mcp_args_input", Input).value.strip()
         env_text = self._settings_query_one("#mcp_env_input", Input).value.strip()
@@ -1640,6 +1695,77 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             else selected
         )
 
+        oauth_client_id = None
+        oauth_client_secret = None
+        oauth_client_secret_env = None
+        oauth_redirect_uri = None
+        oauth_scope = None
+        oauth_auth_method: Optional[Literal["client_secret_post", "client_secret_basic", "none"]] = None
+
+        if http:
+            try:
+                oauth_client_id = self._settings_query_one("#mcp_oauth_client_id_input", Input).value.strip() or None
+            except NoMatches:
+                pass
+            try:
+                oauth_client_secret = (
+                    self._settings_query_one("#mcp_oauth_client_secret_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_client_secret_env = (
+                    self._settings_query_one("#mcp_oauth_client_secret_env_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_redirect_uri = (
+                    self._settings_query_one("#mcp_oauth_redirect_uri_input", Input).value.strip() or None
+                )
+            except NoMatches:
+                pass
+            try:
+                oauth_scope = self._settings_query_one("#mcp_oauth_scope_input", Input).value.strip() or None
+            except NoMatches:
+                pass
+            try:
+                method_val = str(self._settings_query_one("#mcp_oauth_auth_method_select", Select).value)
+                if method_val in {"client_secret_post", "client_secret_basic", "none"}:
+                    oauth_auth_method = cast(Literal["client_secret_post", "client_secret_basic", "none"], method_val)
+            except NoMatches:
+                pass
+
+        client_name = "Kolega Code"
+        client_uri = None
+        client_metadata_url = None
+        timeout_seconds = 300.0
+        if selected != MCP_NEW_SERVER_VALUE:
+            try:
+                config = self._load_mcp_config_for_ui()
+                existing = config.servers.get(selected)
+                if existing:
+                    client_name = existing.oauth.client_name
+                    client_uri = existing.oauth.client_uri
+                    client_metadata_url = existing.oauth.client_metadata_url
+                    timeout_seconds = existing.oauth.timeout_seconds
+            except Exception:
+                pass
+
+        oauth = MCPOAuthConfig(
+            enabled=oauth_enabled,
+            client_id=oauth_client_id,
+            client_secret=oauth_client_secret,
+            client_secret_env=oauth_client_secret_env,
+            redirect_uri=oauth_redirect_uri,
+            scope=oauth_scope,
+            token_endpoint_auth_method=oauth_auth_method,
+            client_name=client_name,
+            client_uri=client_uri,
+            client_metadata_url=client_metadata_url,
+            timeout_seconds=timeout_seconds,
+        )
+
         return MCPServerConfig(
             id=server_id,
             name=name,
@@ -1647,7 +1773,7 @@ class SettingsPanelMixin(tui_app_base.KolegaAppBase):
             enabled=enabled,
             url=url,
             headers=headers,
-            oauth=MCPOAuthConfig(enabled=oauth_enabled),
+            oauth=oauth,
             command=command,
             args=args,
             env=env,

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/cli/tui/settings_screen.py

@@ -588,6 +588,26 @@ class SettingsScreen(ModalScreen[None]):
                     allow_blank=False,
                     value="false",
                 )
+                yield Label("OAuth Client ID", id="mcp_oauth_client_id_label")
+                yield Input(id="mcp_oauth_client_id_input", placeholder="e.g. client_abc123")
+                yield Label("OAuth Client Secret", id="mcp_oauth_client_secret_label")
+                yield Input(id="mcp_oauth_client_secret_input", placeholder="optional direct secret", password=True)
+                yield Label("OAuth Client Secret Env Var", id="mcp_oauth_client_secret_env_label")
+                yield Input(id="mcp_oauth_client_secret_env_input", placeholder="e.g. HUBSPOT_MCP_CLIENT_SECRET")
+                yield Label("OAuth Redirect URI", id="mcp_oauth_redirect_uri_label")
+                yield Input(
+                    id="mcp_oauth_redirect_uri_input",
+                    placeholder="e.g. http://127.0.0.1:33418/callback (default: ephemeral port)",
+                )
+                yield Label("OAuth Scopes", id="mcp_oauth_scope_label")
+                yield Input(id="mcp_oauth_scope_input", placeholder="e.g. read write")
+                yield Label("OAuth Token Auth Method", id="mcp_oauth_auth_method_label")
+                yield Select(
+                    settings_panel.MCP_OAUTH_AUTH_METHOD_OPTIONS,
+                    id="mcp_oauth_auth_method_select",
+                    allow_blank=False,
+                    value="auto",
+                )
                 yield Label("Command", id="mcp_command_label")
                 yield Input(id="mcp_command_input", placeholder="npx")
                 yield Label("Arguments", id="mcp_args_label")

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/gateway/bridge.py

@@ -12,10 +12,16 @@ turns:
 - a placeholder reply is created on first content and edited in place on a
   throttle until the turn ends (final-only transports get one message at the
   end);
-- tool activity lands in a separate "working…" status message, edited as
-  events arrive and deleted when the turn finishes;
+- each round of tool activity lands in its own "working…" message below the
+  newest reply bubble: a round that starts after text was streamed opens a
+  fresh message (Telegram cannot move messages, so appending to an older one
+  would surface above the latest text), and the messages persist as a trail
+  of what the agent did during the turn;
 - text is chunked at the adapter's limit; the first chunk is the edited
-  message and overflow chunks are sent as continuations on finalize.
+  message and overflow chunks are sent as continuations on finalize;
+- a typing action is re-sent every few seconds for the whole turn (chat
+  platforms expire it after ~5s), so thinking and long tool runs keep
+  showing "typing…" until the reply lands.
 
 Chunk content is *incremental*, so the renderer appends and re-renders the
 accumulated text — it never replaces with the last segment.
@@ -34,10 +40,14 @@ from kolega_code.gateway.adapters.telegram.formatting import chunk_text
 
 logger = logging.getLogger(__name__)
 
-#: Cap on status-message lines so a chatty turn cannot spam an unbounded edit.
+#: Cap on a round message's lines so a chatty turn cannot spam an unbounded edit.
 MAX_STATUS_LINES = 8
-#: Events the status pump renders; everything else on the stream is ignored.
-STATUS_MESSAGE_TYPES = {"tool_call", "tool_result", "tool_error"}
+#: Chat platforms expire a typing action after ~5 seconds (Telegram: "status
+#: is set for 5 seconds or less"); refresh slightly faster so the indicator
+#: never lapses while a turn is in progress.
+TYPING_REFRESH_SECONDS = 4.0
+#: Rendered status line: (icon, tool description, tool call id).
+StatusLine = tuple[str, str, str]
 
 
 class TurnRenderer:
@@ -51,6 +61,7 @@ class TurnRenderer:
         event_queue: asyncio.Queue[AgentEvent],
         chunk_limit: Optional[int] = None,
         edit_throttle_seconds: float = 1.0,
+        typing_refresh_seconds: float = TYPING_REFRESH_SECONDS,
         monotonic: Any = time.monotonic,
     ) -> None:
         self._adapter = adapter
@@ -58,6 +69,7 @@ class TurnRenderer:
         self._events = event_queue
         self._chunk_limit = chunk_limit or adapter.capabilities.text_chunk_limit
         self._edit_throttle = edit_throttle_seconds
+        self._typing_refresh = typing_refresh_seconds
         self._monotonic = monotonic
         # Per-segment state, mirroring the TUI's stream fold: a segment is one
         # contiguous assistant response identified by its chunk uuid (the
@@ -69,10 +81,17 @@ class TurnRenderer:
         self._reply_id: Optional[str] = None
         self._edited_text = ""
         self._last_flush = 0.0
+        #: The current tool round's message, one per burst of tool activity.
+        #: Older rounds' messages stay in the chat as a trail of the turn.
         self._status_id: Optional[str] = None
-        self._status_lines: list[str] = []
+        self._status_lines: list[StatusLine] = []
         self._status_sent_text = ""
         self._last_status_flush = 0.0
+        #: Set when a reply message was sent after the current round message:
+        #: the next tool event then opens a fresh round message below the
+        #: newest bubble (Telegram cannot move messages) instead of appending
+        #: to the stale one higher up the chat.
+        self._status_stale = False
 
     async def run(self, chunks: AsyncIterator[dict[str, Any]]) -> str:
         """Consume the turn generator and mirror it into the chat.
@@ -82,10 +101,12 @@ class TurnRenderer:
         reply stays visible.
         """
         pump: Optional[asyncio.Task[None]] = None
+        typing: Optional[asyncio.Task[None]] = None
         if self._events is not None:
             pump = asyncio.create_task(self._event_pump(), name="gateway-turn-event-pump")
         try:
             await self._adapter.set_typing(self._chat_id, True)
+            typing = asyncio.create_task(self._typing_keepalive(), name="gateway-turn-typing")
             async for chunk in chunks:
                 if chunk.get("type") != "response":
                     # Thinking chunks stay off the wire; they are reasoning, not output.
@@ -111,14 +132,30 @@ class TurnRenderer:
             await self._finalize_segment()
             return self._total_text
         finally:
-            if pump is not None:
-                pump.cancel()
-                try:
-                    await pump
-                except asyncio.CancelledError:
-                    pass
+            for task in (pump, typing):
+                if task is not None:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
             await self._adapter.set_typing(self._chat_id, False)
-            await self._finalize_status()
+
+    async def _typing_keepalive(self) -> None:
+        """Re-send the typing action so the indicator outlives its ~5s expiry.
+
+        Covers the silent stretches of a turn — model thinking before the
+        first chunk and long-running tool calls, where no message is sent or
+        edited. Refresh only (never hides: the ``False`` call is the
+        adapter's business); a failing adapter must not end the loop, since
+        typing is cosmetic.
+        """
+        while True:
+            await asyncio.sleep(self._typing_refresh)
+            try:
+                await self._adapter.set_typing(self._chat_id, True)
+            except Exception:  # noqa: BLE001 — typing indicators are cosmetic
+                logger.debug("gateway: typing refresh failed", exc_info=True)
 
     # -- Reply messages (one per response segment) -------------------------
 
@@ -144,6 +181,7 @@ class TurnRenderer:
                 return  # final-only transports send once, at the end
             self._reply_id = await self._adapter.send_text(self._chat_id, chunks[0])
             self._edited_text = chunks[0]
+            self._status_stale = True
             return
         if not final:
             if len(chunks) > 1:
@@ -155,6 +193,7 @@ class TurnRenderer:
         await self._edit_reply(chunks[0])
         for extra in chunks[1:]:
             await self._adapter.send_text(self._chat_id, extra)
+            self._status_stale = True
 
     async def _edit_reply(self, text: str) -> None:
         if text == self._edited_text:
@@ -163,39 +202,58 @@ class TurnRenderer:
             await self._adapter.edit_text(self._chat_id, self._reply_id or "", text)
         self._edited_text = text
 
-    # -- Tool status message ----------------------------------------------
+    # -- Tool round messages ----------------------------------------------
 
     async def _event_pump(self) -> None:
         try:
             while True:
                 event = await self._events.get()
-                line = self._status_line_for(event)
-                if line is None:
+                record = self._line_record_for(event)
+                if record is None:
                     continue
-                self._status_lines.append(line)
-                self._status_lines = self._status_lines[-MAX_STATUS_LINES:]
+                if self._status_stale:
+                    # The newest reply bubble was sent after the current round
+                    # message: open a fresh round message below it instead of
+                    # appending to the stale one higher up the chat.
+                    self._status_stale = False
+                    self._status_id = None
+                    self._status_lines = []
+                self._record_line(record)
                 await self._flush_status()
         except asyncio.CancelledError:
             raise
 
     @staticmethod
-    def _status_line_for(event: AgentEvent) -> Optional[str]:
+    def _line_record_for(event: AgentEvent) -> Optional[StatusLine]:
         if event.event_type != "chat_message":
             return None
         message_type = event.content.get("message_type")
+        description = str(event.content.get("tool_description") or "tool")
+        call_id = str(event.content.get("tool_call_id") or "")
         if message_type == "tool_call":
-            description = event.content.get("tool_description") or "tool"
-            return f"⏳ {description}"
+            return ("⏳", description, call_id)
         if message_type == "tool_result":
-            return "✅ tool finished"
+            return ("✅", description, call_id)
         if message_type == "tool_error":
-            return "❌ tool failed"
+            return ("❌", description, call_id)
         return None
 
+    def _record_line(self, record: StatusLine) -> None:
+        icon, _, call_id = record
+        if icon != "⏳" and call_id:
+            # A finished call replaces its pending line so the round message
+            # reads as a settled trail (⏳ bash -> ✅ bash), not an append log.
+            for index, (pending_icon, _, pending_id) in enumerate(self._status_lines):
+                if pending_icon == "⏳" and pending_id == call_id:
+                    self._status_lines[index] = record
+                    return
+        self._status_lines.append(record)
+        self._status_lines = self._status_lines[-MAX_STATUS_LINES:]
+
     async def _flush_status(self) -> None:
         if not self._status_lines:
             return
-        text = "\n".join(self._status_lines)
+        text = "\n".join(f"{icon} {description}" for icon, description, _ in self._status_lines)
         if text == self._status_sent_text:
             # Line-cap truncation can make a new event's rendered text
             # identical to the previous one; re-sending the same content is a
@@ -206,20 +264,10 @@ class TurnRenderer:
             return
         self._last_status_flush = now
         if self._status_id is None:
-            # No status message on transports that cannot edit it away.
+            # No round message on transports that cannot edit it away.
             if not self._adapter.capabilities.supports_edits:
                 return
             self._status_id = await self._adapter.send_text(self._chat_id, text)
         else:
             await self._adapter.edit_text(self._chat_id, self._status_id, text)
         self._status_sent_text = text
-
-    async def _finalize_status(self) -> None:
-        if self._status_id is None:
-            return
-        message_id, self._status_id = self._status_id, None
-        if self._adapter.capabilities.supports_delete:
-            try:
-                await self._adapter.delete_message(self._chat_id, message_id)
-            except Exception:  # noqa: BLE001 — a stuck status message is cosmetic
-                logger.debug("gateway: status delete failed for chat %s", self._chat_id)

{kolega_code-0.35.0 → kolega_code-0.36.0}/kolega_code/gateway/service.py

@@ -50,6 +50,34 @@ class ServiceInstallResult:
     unit_path: Optional[Path] = None
 
 
+def login_shell(platform: Optional[str] = None) -> str:
+    """The user's login shell: ``$SHELL`` when set, else the platform default.
+
+    launchd and systemd start service programs directly, so the daemon would
+    inherit the service manager's minimal environment (launchd gives agents
+    ``PATH=/usr/bin:/bin:/usr/sbin:/sbin``), which starves gateway-driven
+    agent sessions of Homebrew and other user-installed tools.  The service
+    therefore launches through the user's login shell: ``-l`` runs the shell
+    profile files, so the daemon's environment matches what an interactive
+    terminal sees, and nothing is captured at install time.
+    """
+    platform = platform if platform is not None else sys.platform
+    from_env = os.environ.get("SHELL")
+    if from_env:
+        return from_env
+    return "/bin/zsh" if platform == "darwin" else "/bin/bash"
+
+
+def service_launch_command(config: GatewayConfig, executable: str, *, shell: str) -> list[str]:
+    """The service-level argv: the login shell exec-ing the daemon.
+
+    ``exec`` replaces the shell process, so termination signals reach the
+    daemon directly and launchd/KeepAlive track the real process.
+    """
+    inner = " ".join(shlex.quote(part) for part in service_command(config, executable))
+    return [shell, "-l", "-c", f"exec {inner}"]
+
+
 def service_command(config: GatewayConfig, executable: str) -> list[str]:
     """The exact argv the service runs."""
     return [
@@ -69,6 +97,7 @@ def install_service(
     config: GatewayConfig,
     *,
     executable: Optional[str] = None,
+    shell: Optional[str] = None,
     systemd_dir: Optional[Path] = None,
     launchd_dir: Optional[Path] = None,
     platform: Optional[str] = None,
@@ -76,12 +105,16 @@ def install_service(
     """Write the service definition.
 
     ``systemd_dir``/``launchd_dir`` are the unit destination directories;
-    callers resolve the platform defaults (tests pass temp dirs).
+    callers resolve the platform defaults (tests pass temp dirs).  ``shell``
+    overrides the login shell the service launches through (tests pass one
+    for determinism); by default the user's ``$SHELL`` or the platform
+    default is used.
     """
     platform = platform if platform is not None else sys.platform
     executable = executable or shutil.which("kolega-code") or ""
     if not executable:
         raise RuntimeError("kolega-code executable not found; is it on PATH?")
+    launch_shell = shell or login_shell(platform)
     config.state_dir.mkdir(parents=True, exist_ok=True)
     result = ServiceInstallResult()
     if platform == "darwin":
@@ -90,7 +123,7 @@ def install_service(
         plist_path = launchd_dir / LAUNCHD_PLIST_NAME
         plist: dict[str, object] = {
             "Label": LAUNCHD_LABEL,
-            "ProgramArguments": service_command(config, executable),
+            "ProgramArguments": service_launch_command(config, executable, shell=launch_shell),
             "RunAtLoad": True,
             "KeepAlive": True,
             "StandardOutPath": str(config.state_dir / "gateway.log"),
@@ -103,10 +136,14 @@ def install_service(
         systemd_dir = systemd_dir or (Path.home() / ".config" / "systemd" / "user")
         systemd_dir.mkdir(parents=True, exist_ok=True)
         unit_path = systemd_dir / SYSTEMD_UNIT_NAME
-        command = " ".join(shlex.quote(part) for part in service_command(config, executable))
+        command = " ".join(shlex.quote(part) for part in service_launch_command(config, executable, shell=launch_shell))
         unit_path.write_text(_SYSTEMD_UNIT_TEMPLATE.format(command=command), encoding="utf-8")
         result.unit_path = unit_path
         result.notes.append(f"systemd user unit written to {unit_path}")
+    result.notes.append(
+        f"the service launches via your login shell ({launch_shell}), so it inherits your "
+        "normal terminal environment; restart it after changing your shell profile"
+    )
     result.notes.append(
         "the service reads settings.json from the same state dir — make sure your provider "
         "API keys are saved in Settings (they apply to the gateway too)"