kiwi-code 0.0.431__tar.gz → 0.0.433__tar.gz

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.431
+Version: 0.0.433
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.431"
+version = "0.0.433"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/auth.py

@@ -1,7 +1,4 @@
 """Authentication and token management."""
-
-from __future__ import annotations
-
 import json
 import os
 import sys

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/cli.py

@@ -1,13 +1,9 @@
 """Typer CLI for Autobots — thin wrapper over commands.py."""
-
 from typing import Optional, Callable
-
 from loguru import logger
 logger.remove()  # Suppress loguru console output in CLI mode
-
 import typer
 from autobots_client import AuthenticatedClient
-
 from .auth import TokenManager
 from .models import AppConfig
 from .server import http_url_from_server

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/client.py

@@ -1,5 +1,4 @@
 """Autobots client wrapper for API interactions."""
-
 from datetime import datetime, timedelta
 from typing import Optional, Callable
 import time
@@ -11,7 +10,6 @@ from autobots_client import Client, AuthenticatedClient
 from autobots_client.api.hello import hello_v1_hello_get
 from autobots_client.api.auth import (
     return_user_and_session_v1_auth_post,
-    refresh_password_email_v1_auth_session_refresh_post,
 )
 from autobots_client.api.actions import async_run_action_v1_actions_id_async_run_post
 from autobots_client.api.action_results import get_action_result_v1_action_results_id_get
@@ -24,7 +22,6 @@ from autobots_client.models.body_async_run_action_v1_actions_id_async_run_post i
 from autobots_client.models.body_async_run_action_v1_actions_id_async_run_post_input import (
     BodyAsyncRunActionV1ActionsIdAsyncRunPostInput,
 )
-
 from .models import AuthTokens, LoginCredentials
 
 
@@ -525,18 +522,42 @@ class AutobotsClientWrapper:
 
         return False, result, f"Polling timeout after {max_attempts * interval}s - action may still be running"
 
-    async def stream_action_result(self, run_id: str, on_message: Callable[[dict], None]) -> None:
-        """Stream action result updates via Server-Sent Events.
+    async def stream_action_result(
+        self,
+        run_id: str,
+        on_message: Callable[[dict], None],
+        *,
+        topic: str | None = None,
+        stop_on_terminal_status: bool = True,
+        plain_text_type: str = "status",
+    ) -> None:
+        """Stream action run updates via Server-Sent Events.
+
+        The backend publishes plain text frames to Redis topics. Historically Kiwi Code
+        subscribed only to the `run_id` topic and wrapped non-JSON frames as
+        `{type: 'status', text: ...}`.
+
+        Some providers (notably OpenAI Responses) publish the assistant text stream to
+        a separate topic: `f"{run_id}-text"`. Callers can subscribe to that topic by
+        passing `topic=f"{run_id}-text"` and setting `plain_text_type='text'`.
+        That topic does not emit JSON status payloads, so callers should typically set
+        `stop_on_terminal_status=False` and cancel the stream when polling detects
+        completion.
 
         Args:
-            run_id: ID of the action run
-            on_message: Callback function to handle incoming messages
+            run_id: Action run id (used for auth and (optionally) terminal detection).
+            on_message: Callback for parsed payloads (dict).
+            topic: Redis topic to subscribe to. Defaults to `run_id`.
+            stop_on_terminal_status: Stop the stream when a JSON payload includes a terminal
+                `status` field. Disable for topics that don't send status (e.g. *-text).
+            plain_text_type: When a frame is not valid JSON, wrap it as
+                `{'type': plain_text_type, 'text': <payload>}`.
         """
-        sse_endpoint = f"{self.base_url}/v1/server_sent_events/stream/{run_id}"
+        topic = topic or run_id
+        sse_endpoint = f"{self.base_url}/v1/server_sent_events/stream/{topic}"
         logger.info(f"Connecting to SSE: {sse_endpoint}")
 
         try:
-            # Create headers
             headers = {
                 "Accept": "text/event-stream",
                 "Cache-Control": "no-cache",
@@ -545,7 +566,6 @@ class AutobotsClientWrapper:
             if self.access_token:
                 headers["Authorization"] = f"Bearer {self.access_token}"
 
-            # Use httpx to stream SSE with longer timeout
             async with httpx.AsyncClient(timeout=None) as client:
                 async with client.stream("GET", sse_endpoint, headers=headers) as response:
                     logger.info(f"SSE connected, status: {response.status_code}")
@@ -554,68 +574,61 @@ class AutobotsClientWrapper:
                         logger.error(f"SSE connection failed with status {response.status_code}")
                         return
 
-                    # Use incremental UTF-8 decoder to handle multi-byte characters across chunk boundaries
                     decoder = codecs.getincrementaldecoder("utf-8")()
                     buffer = ""
+                    event_data_lines: list[str] = []
+
+                    def _flush_event() -> bool:
+                        if not event_data_lines:
+                            return False
+                        data_str = "\n".join(event_data_lines).rstrip()
+                        event_data_lines.clear()
+                        if not data_str:
+                            return False
+                        try:
+                            data = json.loads(data_str)
+                            on_message(data)
+                            if stop_on_terminal_status and isinstance(data, dict):
+                                status = str(data.get("status", "") or "").lower()
+                                if status in ["completed", "success", "finished", "failed", "error"]:
+                                    return True
+                        except json.JSONDecodeError:
+                            on_message({"type": plain_text_type, "text": data_str})
+                        except Exception as e:
+                            logger.error(f"Error processing SSE data: {e}")
+                        return False
 
-                    # Process SSE stream byte by byte with incremental decoder
                     async for chunk in response.aiter_bytes():
-                        # Decode chunk with incremental decoder (handles partial multi-byte chars)
                         text_chunk = decoder.decode(chunk, final=False)
                         buffer += text_chunk
 
-                        # Process complete lines from buffer
                         while "\n" in buffer:
                             line, buffer = buffer.split("\n", 1)
-                            line = line.strip()
+                            line = line.rstrip("\r")
 
-                            # Skip empty lines
-                            if not line:
+                            # SSE event boundary (blank line)
+                            if line == "":
+                                if _flush_event():
+                                    return
                                 continue
 
-                            # Skip keep-alive comments (`:keep-alive`)
                             if line.startswith(":"):
-                                logger.debug("Received SSE keep-alive")
+                                # keep-alive comments
                                 continue
 
-                            # Parse SSE data format: "data: {...}" or "data: plain text"
-                            if line.startswith("data: "):
-                                data_str = line[6:].strip()
-
-                                # Try to parse as JSON first
-                                try:
-                                    data = json.loads(data_str)
-                                    logger.info(f"SSE JSON received, keys: {data.keys() if isinstance(data, dict) else type(data)}")
-
-                                    # Call the callback with parsed data
-                                    on_message(data)
-
-                                    # Check if action is complete
-                                    if isinstance(data, dict):
-                                        status = data.get("status", "").lower()
-                                        if status in ["completed", "success", "finished", "failed", "error"]:
-                                            logger.info(f"Action completed with status: {status}")
-                                            return
-
-                                except json.JSONDecodeError:
-                                    # Not JSON, treat as plain text status message
-                                    logger.info(f"SSE text message: {data_str}")
-
-                                    # Mark as status so dashboard can distinguish from real output
-                                    text_data = {
-                                        "type": "status",
-                                        "text": data_str,
-                                    }
-                                    on_message(text_data)
-
-                                except Exception as e:
-                                    logger.error(f"Error processing SSE data: {e}")
+                            if line.startswith("data:"):
+                                val = line[5:]
+                                if val.startswith(" "):
+                                    val = val[1:]
+                                event_data_lines.append(val)
+                                continue
 
-                    # Flush any remaining bytes in decoder
-                    remaining = decoder.decode(b"", final=True)
-                    if remaining:
-                        buffer += remaining
+                            if event_data_lines:
+                                event_data_lines.append(line)
 
+                    # Flush any remaining bytes in decoder + any pending event data.
+                    decoder.decode(b"", final=True)
+                    _flush_event()
         except Exception as e:
             logger.error(f"SSE error: {e}")
             raise

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/commands.py

@@ -5,7 +5,6 @@ and returns a list of strings (output lines).
 """
 
 from typing import Optional
-
 from autobots_client import AuthenticatedClient
 from autobots_client.api.actions import (
     list_actions_v1_actions_get,
@@ -26,9 +25,7 @@ from autobots_client.api.action_graphs_results import (
 from autobots_client.types import UNSET
 
 
-# ---------------------------------------------------------------------------
 # Helpers
-# ---------------------------------------------------------------------------
 
 def _fmt_date(dt) -> str:
     if dt is None or isinstance(dt, type(UNSET)):
@@ -45,9 +42,7 @@ def _val(v) -> str:
     return str(v)
 
 
-# ---------------------------------------------------------------------------
 # actions
-# ---------------------------------------------------------------------------
 
 def actions_list(client: AuthenticatedClient, *, name: Optional[str] = None, limit: int = 20, offset: int = 0) -> list[str]:
     """List actions. Returns output lines."""
@@ -95,9 +90,7 @@ def actions_get(client: AuthenticatedClient, *, id: str) -> list[str]:
     ]
 
 
-# ---------------------------------------------------------------------------
 # runs (action results)
-# ---------------------------------------------------------------------------
 
 def runs_list(client: AuthenticatedClient, *, action_id: Optional[str] = None, action_name: Optional[str] = None,
               status: Optional[str] = None, limit: int = 20, offset: int = 0) -> list[str]:
@@ -164,9 +157,7 @@ def runs_get(client: AuthenticatedClient, *, id: str) -> list[str]:
     return lines
 
 
-# ---------------------------------------------------------------------------
 # graphs (action graphs)
-# ---------------------------------------------------------------------------
 
 def graphs_list(client: AuthenticatedClient, *, name: Optional[str] = None, limit: int = 20, offset: int = 0) -> list[str]:
     """List action graphs. Returns output lines."""
@@ -217,9 +208,7 @@ def graphs_get(client: AuthenticatedClient, *, id: str) -> list[str]:
     return [str(doc)]
 
 
-# ---------------------------------------------------------------------------
 # graph-runs (action graph results)
-# ---------------------------------------------------------------------------
 
 def graph_runs_list(client: AuthenticatedClient, *, action_graph_id: Optional[str] = None,
                     action_graph_name: Optional[str] = None, status: Optional[str] = None,
@@ -286,9 +275,7 @@ def graph_runs_get(client: AuthenticatedClient, *, id: str) -> list[str]:
     return lines
 
 
-# ---------------------------------------------------------------------------
 # Command dispatcher — parses "/command args" from TUI input
-# ---------------------------------------------------------------------------
 
 HELP_TEXT = """\
 Session:

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/models.py

@@ -1,7 +1,5 @@
 """Pydantic models for Autobots TUI."""
 
-from __future__ import annotations
-
 import base64
 import json
 from datetime import datetime, timedelta

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/server.py

@@ -10,10 +10,6 @@ The value can be:
 
 This module intentionally contains *no persistence*. It is runtime-only.
 """
-
-from __future__ import annotations
-
-
 SERVER_PRESETS: dict[str, dict[str, str]] = {
     "app": {"ws": "wss://api.meetkiwi.ai", "http": "https://api.meetkiwi.ai"},
     "dev": {"ws": "wss://dev.api.myautobots.com", "http": "https://dev.api.myautobots.com"},

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_cli/terminal_mode.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import asyncio
 import getpass
 import html

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_runtime/main.py

@@ -12,11 +12,7 @@ Usage:
     kiwi connect --server dev --scope full
     kiwi connect --server dev --allow /path/to/extra/dir
 """
-
-from __future__ import annotations
-
 from datetime import datetime
-
 import argparse
 import asyncio
 import getpass
@@ -29,6 +25,10 @@ import subprocess
 import sys
 from pathlib import Path
 from typing import Any
+import shutil
+import tempfile
+import uuid
+from dataclasses import dataclass
 
 
 IS_WINDOWS = sys.platform == "win32"
@@ -44,10 +44,7 @@ import websockets
 import threading
 FS_MAX_CONCURRENCY = 8
 
-# ---------------------------------------------------------------------------
 # Shared token storage (used by both kiwi-code and standalone kiwi-runtime)
-# ---------------------------------------------------------------------------
-
 TOKENS_PATH = Path.home() / ".kiwi" / "tokens.json"
 TOKENS_LOCK_PATH = Path.home() / ".kiwi" / "tokens.lock"
 TOKEN_EXPIRY_SKEW_SEC = 60  # refresh a bit early to avoid edge cases
@@ -311,12 +308,6 @@ _WINDOWS_SENTINEL_RESULT = re.compile(
     re.IGNORECASE,
 )
 
-import difflib
-import shutil
-import tempfile
-import uuid
-from dataclasses import dataclass
-
 
 @dataclass
 class ChunkedWriteState:
@@ -1203,10 +1194,7 @@ SERVER_PRESETS = {
     "local": {"ws": "ws://localhost:8000", "http": "http://localhost:8000"},
 }
 
-# ---------------------------------------------------------------------------
 # ANSI colors
-# ---------------------------------------------------------------------------
-
 RESET = "\033[0m"
 BOLD = "\033[1m"
 
@@ -1219,10 +1207,7 @@ YELLOW = "\033[93m"
 GREEN = "\033[92m"
 
 
-# ---------------------------------------------------------------------------
 # Banner — Kiwi logo (from SVG) + KIWI AI text side by side
-# ---------------------------------------------------------------------------
-
 # Logo: 32 wide x 16 tall (half-block, perfectly symmetric from SVG)
 LOGO = [
     "              ▄██▄              ",
@@ -1257,10 +1242,7 @@ TAGLINE = "Terminal Agent for AI-Powered Automation"
 
 
 
-# ---------------------------------------------------------------------------
 # Mini block-text renderer (3-row height, no dependencies)
-# ---------------------------------------------------------------------------
-
 _BLOCK_CHARS = {
     "A": ["█▀█", "█▀█", "▀ ▀"], "B": ["█▀▄", "█▀▄", "▀▀ "], "C": ["█▀▀", "█  ", "▀▀▀"],
     "D": ["█▀▄", "█ █", "▀▀ "], "E": ["█▀▀", "█▀▀", "▀▀▀"], "F": ["█▀▀", "█▀ ", "▀  "],
@@ -1408,10 +1390,7 @@ def print_pty_log(session_id: str, message: str, level: str = "info"):
     _safe_print(f"  {icon} {tag} {message}")
 
 
-# ---------------------------------------------------------------------------
 # Path validator for restricted mode
-# ---------------------------------------------------------------------------
-
 # Regex to detect Windows absolute paths like C:\ or D:/
 _WIN_ABS_PATH = re.compile(r'^[A-Za-z]:[/\\]')
 # Regex to detect UNC paths like \\server\share
@@ -1593,10 +1572,7 @@ def _is_within_allowed(resolved_path: str, allowed_dirs: list[str]) -> bool:
     return False
 
 
-# ---------------------------------------------------------------------------
 # Core logic
-# ---------------------------------------------------------------------------
-
 async def login(http_base_url: str, email: str, password: str) -> str:
     """Authenticate with email/password and return the access token.
 
@@ -1916,9 +1892,6 @@ if not IS_WINDOWS:
                     pass
                 self.slave_fd = None
 
-
-
-
 class PipeProcess:
     """Manages a persistent shell session using subprocess pipes (Windows-compatible)."""
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_tui/screens/dashboard.py

@@ -1028,6 +1028,84 @@ class DashboardScreen(Screen):
                 self.process_message(prompt)
                 return
 
+            if cmd == "/disconnect-cli":
+                """Disconnect (kill) the local CLI runtime for the current run (or pending runtime)."""
+                from kiwi_tui.runtime_agent import (
+                    get_running_pid_for_pending,
+                    get_running_pid_for_run,
+                    kill_pid,
+                    pid_path_for_pending,
+                    pid_path_for_run,
+                )
+
+                killed = False
+                pid: int | None = None
+                target: str | None = None
+
+                try:
+                    if self.current_run_id:
+                        target = f"run {self.current_run_id}"
+                        pid = get_running_pid_for_run(self.current_run_id)
+                        if pid:
+                            killed = bool(kill_pid(int(pid)))
+                            if killed:
+                                # Remove pid file so the next /connect-cli spawns a fresh runtime.
+                                try:
+                                    pid_path_for_run(self.current_run_id).unlink(missing_ok=True)
+                                except Exception:
+                                    pass
+                    else:
+                        pending_id = getattr(self.app, "pending_runtime_id", None)
+                        if pending_id:
+                            target = f"pending {pending_id}"
+                            pid = get_running_pid_for_pending(pending_id)
+                            if pid:
+                                killed = bool(kill_pid(int(pid)))
+                                if killed:
+                                    try:
+                                        pid_path_for_pending(pending_id).unlink(missing_ok=True)
+                                    except Exception:
+                                        pass
+                                    # Clear the session-scoped pending runtime id only when we killed it.
+                                    try:
+                                        self.app.pending_runtime_id = None
+                                    except Exception:
+                                        pass
+                            else:
+                                # No PID found => stale pending id in memory; clear it.
+                                try:
+                                    self.app.pending_runtime_id = None
+                                except Exception:
+                                    pass
+                except Exception:
+                    killed = False
+
+                if pid and killed:
+                    toast(
+                        f"Disconnected CLI runtime ({target}) by killing PID {pid}.",
+                        title="/disconnect-cli",
+                        severity="information",
+                    )
+                elif pid and not killed:
+                    toast(
+                        f"Failed to disconnect CLI runtime ({target}). Unable to kill PID {pid}.",
+                        title="/disconnect-cli",
+                        severity="error",
+                    )
+                elif target:
+                    toast(
+                        f"No running CLI runtime found for {target}.",
+                        title="/disconnect-cli",
+                        severity="warning",
+                    )
+                else:
+                    toast(
+                        "No CLI runtime is associated with this session yet.",
+                        title="/disconnect-cli",
+                        severity="warning",
+                    )
+                return
+
             if cmd == "/show-logs":
                 self.open_runtime_logs()
                 return
@@ -3051,6 +3129,69 @@ class DashboardScreen(Screen):
         # If we already mounted a placeholder row on submit, reuse it.
         status_widget_container = [getattr(self, "_streaming_widget_ref", None)]
 
+        # Streaming state: main assistant text + latest status/tool output.
+        main_text: str = ""
+        status_text: str = ""
+        tool_text: str = ""
+        openai_text_stream_seen: bool = False
+        text_task: asyncio.Task | None = None
+
+        _last_render: str = ""
+        _last_render_at: float = 0.0
+
+        def _looks_like_tool_text(t: str) -> bool:
+            tt = (t or "").strip()
+            if not tt:
+                return False
+            return (
+                tt.startswith("Calling tool:")
+                or tt.startswith("Calling tool ")
+                or "\nArguments:" in tt
+                or tt.startswith("Arguments:")
+                or tt.startswith("Function call")
+            )
+
+        def _build_stream_markdown() -> str:
+            base = (main_text or "").strip()
+            if not openai_text_stream_seen:
+                # Non-OpenAI providers stream their main output on the run_id topic.
+                # Preserve the previous behavior: show whatever the backend is streaming.
+                return base
+
+            extra_parts: list[str] = []
+            if status_text.strip():
+                extra_parts.append(status_text.strip())
+            if tool_text.strip():
+                extra_parts.append(tool_text.strip())
+
+            if not extra_parts:
+                return base
+            if not base:
+                return "\n\n".join(extra_parts)
+            return base + "\n\n" + "\n\n".join(extra_parts)
+
+        def _maybe_render(*, force: bool = False) -> None:
+            nonlocal _last_render, _last_render_at
+            try:
+                now = time.monotonic()
+                if not force and (now - _last_render_at) < 0.03:
+                    return
+                rendered = _build_stream_markdown()
+                if not rendered.strip():
+                    return
+                if not force and rendered == _last_render:
+                    return
+                status_widget_container[0] = self.update_streaming_message(
+                    {"blocks": [{"text": rendered}]},
+                    status_widget_container[0],
+                )
+                _last_render = rendered
+                _last_render_at = now
+            except Exception:
+                # Do not break streaming if a render fails mid-refresh.
+                return
+
+
         logger.info(f"Starting stream_results for {run_id}")
 
         def _remove_status_widget() -> None:
@@ -3184,34 +3325,58 @@ class DashboardScreen(Screen):
                     return True
             return False
 
+        def handle_text_message(data: dict) -> None:
+            """Handle OpenAI *-text topic stream (assistant text)."""
+            nonlocal main_text, openai_text_stream_seen
+            if not isinstance(data, dict) or got_final_result:
+                return
+            if data.get("type") != "text":
+                return
+            text = str(data.get("text", "") or "")
+            if not text.strip():
+                return
+            openai_text_stream_seen = True
+            main_text = text
+            _maybe_render()
+
         def handle_status_message(data: dict) -> None:
-            """Handle SSE messages — status updates and completion signals."""
+            """Handle SSE messages — provider-dependent streaming + status/tool updates."""
+            nonlocal main_text, status_text, tool_text
             if not isinstance(data, dict) or got_final_result:
                 return
 
-            # Plain-text status messages (type="status" set by client.py)
+            # Plain-text messages (wrapped as type="status" by the SSE client).
             if data.get("type") == "status":
-                text = data.get("text", "")
+                text = str(data.get("text", "") or "")
                 text_lower = text.lower()
                 logger.debug(f"SSE status: {text}")
 
-                # Show all non-empty status messages as progress
+                if not openai_text_stream_seen:
+                    # Non-OpenAI providers stream their main output on run_id; preserve old behavior.
+                    main_text = text
+                else:
+                    # OpenAI: keep the streamed answer from *-text and render status/tool separately.
+                    if _looks_like_tool_text(text):
+                        tool_text = text
+                    else:
+                        status_text = text
+
                 if text.strip():
-                    status_widget_container[0] = self.update_streaming_message(
-                        {"blocks": [{"text": text}]},
-                        status_widget_container[0],
-                    )
+                    _maybe_render()
 
-                # Detect completion from text signals (server sends these as plain text)
+                # Detect completion from text signals (server sends these as plain text).
                 if any(kw in text_lower for kw in ["finishing", "completed", "finished"]):
                     logger.info(f"Completion signal from SSE text: {text}")
                     asyncio.create_task(_try_fetch_final_result_async())
                 return
 
-            # JSON status messages
-            status = data.get("status", "").lower()
+            # JSON status messages (rare, but some server paths send them).
+            status = str(data.get("status", "") or "").lower()
             if status:
                 logger.info(f"SSE JSON status: {status}")
+                if openai_text_stream_seen:
+                    status_text = f"Status: {status}"
+                    _maybe_render()
             if status in ["completed", "success", "finished", "error", "failed"]:
                 asyncio.create_task(_try_fetch_final_result_async())
 
@@ -3239,11 +3404,30 @@ class DashboardScreen(Screen):
             client.stream_action_result(run_id, handle_status_message)
         )
 
+        # OpenAI Responses streams assistant text to a separate topic: f"{run_id}-text".
+        # Subscribe here; for non-OpenAI providers this is a no-op (no messages will be published).
+        try:
+            text_task = asyncio.create_task(
+                client.stream_action_result(
+                    run_id,
+                    handle_text_message,
+                    topic=f"{run_id}-text",
+                    stop_on_terminal_status=False,
+                    plain_text_type="text",
+                )
+            )
+        except Exception:
+            text_task = None
+
+
         try:
             while not got_final_result:
                 tasks: list[asyncio.Task] = [poll_task]
                 if status_task is not None:
                     tasks.append(status_task)
+                if text_task is not None:
+                    tasks.append(text_task)
+
 
                 done, _pending = await asyncio.wait(
                     tasks,
@@ -3264,6 +3448,15 @@ class DashboardScreen(Screen):
                         logger.warning(f"SSE stream ended for {run_id}: {e}")
                     status_task = None
 
+                if text_task is not None and text_task in done:
+                    try:
+                        text_task.result()
+                    except asyncio.CancelledError:
+                        pass
+                    except Exception as e:
+                        logger.warning(f"SSE text stream ended for {run_id}: {e}")
+                    text_task = None
+
             # Ensure polling completes (it exits when got_final_result becomes True).
             if not poll_task.done():
                 await poll_task
@@ -3271,6 +3464,8 @@ class DashboardScreen(Screen):
             logger.info(f"Stream cancelled for {run_id}")
             if status_task is not None:
                 status_task.cancel()
+            if text_task is not None:
+                text_task.cancel()
             poll_task.cancel()
             _remove_status_widget()
             self._set_streaming(False)
@@ -3295,6 +3490,13 @@ class DashboardScreen(Screen):
                 except (asyncio.CancelledError, Exception):
                     pass
 
+            if text_task is not None and not text_task.done():
+                text_task.cancel()
+                try:
+                    await text_task
+                except (asyncio.CancelledError, Exception):
+                    pass
+
         # Clean up status widget if it still exists (we keep it when it becomes the final output).
         if status_widget_container[0]:
             _remove_status_widget()

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_tui/slash_commands.py

@@ -41,6 +41,7 @@ SLASH_COMMANDS: list[SlashCommand] = [
 
     # Runtime (local CLI agent)
     SlashCommand("Runtime", "/connect-cli", "Tell the agent to connect to the local CLI", "/connect-cli"),
+    SlashCommand("Runtime", "/disconnect-cli", "Disconnect the local CLI runtime for the current run", "/disconnect-cli"),
     SlashCommand("Runtime", "/show-logs", "Show local CLI (runtime) logs", "/show-logs"),
     SlashCommand("Runtime", "/runtime", "Runtime commands (currently disabled)", "/runtime"),
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_tui/status_words.py

@@ -417,6 +417,28 @@ _STATUS_WORDS_RAW: tuple[str, ...] = (
     "Alchemizing",
     "Treasure-hunting",
     "Dragon-wrangling",
+    "Mapping",
+    "Correlating",
+    "Quantifying",
+    "Cascading",
+    "Reconnoitering",
+    "Dissecting",
+    "Unifying",
+    "Segmenting",
+    "Partitioning",
+    "Deconstructing",
+    "Reframing",
+    "Bootstrapping",
+    "Factoring",
+    "Defragmenting",
+    "Elucidating",
+    "Decoupling",
+    "Vectorizing",
+    "Rasterizing",
+    "Hashing",
+    "Checkpointing",
+    "Backtracking",
+    "Demultiplexing",
 )
 
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/src/kiwi_tui/widgets.py

@@ -124,6 +124,9 @@ class ChatInput(TextArea):
         if len(candidate) >= 2 and candidate[0] == candidate[-1] and candidate[0] in {'"', "'"}:
             candidate = candidate[1:-1]
 
+        if sys.platform == "win32":
+            candidate = candidate.replace("\\ ", " ")
+
         if candidate.startswith("file://"):
             parsed = urlparse(candidate)
             if parsed.scheme != "file":
@@ -144,7 +147,7 @@ class ChatInput(TextArea):
         token_sets: list[list[str]] = []
 
         try:
-            split_tokens = shlex.split(normalized, posix=True)
+            split_tokens = shlex.split(normalized, posix=(sys.platform != "win32"))
         except ValueError:
             split_tokens = []
         if split_tokens:

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/conftest.py

@@ -4,8 +4,6 @@ Every test that touches the filesystem through Kiwi's managers goes
 through the ``isolated_home`` fixture so that ``~/.kiwi/`` writes land in
 a tmp dir instead of polluting the developer's real home.
 """
-from __future__ import annotations
-
 import os
 from pathlib import Path
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_cli_help.py

@@ -5,8 +5,6 @@ mirror what ``pipx install kiwi-code`` users experience. They are the
 first line of defense against regressions in argument parsing,
 imports, and packaging.
 """
-from __future__ import annotations
-
 import subprocess
 import sys
 from pathlib import Path

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_imports.py

@@ -4,11 +4,8 @@ Walks every submodule of the three shipped packages and imports it.
 This is the cheapest way to catch syntax errors, circular imports and
 stale references before they reach end users via ``pipx install``.
 """
-from __future__ import annotations
-
 import importlib
 import pkgutil
-
 import pytest
 
 PACKAGES = ["kiwi_cli", "kiwi_tui", "kiwi_runtime"]

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_reexec_kiwi.py

@@ -6,15 +6,11 @@ The goal of the re-exec is to make the kernel-reported process name
 We verify that by spawning a child that exec's through the symlink and
 prints its own ``comm``.
 """
-from __future__ import annotations
-
 import os
 import subprocess
 import sys
 from pathlib import Path
-
 import pytest
-
 pytestmark = pytest.mark.skipif(
     sys.platform == "win32",
     reason="Windows uses native kiwi.exe launcher; no re-exec needed",

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_runtime_log_trimming.py

@@ -1,9 +1,4 @@
-from __future__ import annotations
-
 from pathlib import Path
-
-import pytest
-
 from kiwi_tui.runtime_agent import MAX_RUNTIME_LOG_BYTES, _trim_file_to_tail_bytes
 from kiwi_tui.screens.runtime_logs import _tail_lines
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_terminal_mode.py

@@ -1,9 +1,5 @@
-from __future__ import annotations
-
 import io
-
 import pytest
-
 from kiwi_cli.terminal_mode import TerminalModeArgs, TerminalModeError, validate_terminal_mode_args
 from kiwi_tui import main as kiwi_main
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_tokens.py

@@ -1,9 +1,6 @@
 """TokenManager tests."""
-from __future__ import annotations
-
 from pathlib import Path
 
-
 def test_no_tokens_when_fresh(isolated_home: Path) -> None:
     from kiwi_cli.auth import TokenManager
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_tui_headless.py

@@ -4,12 +4,9 @@ These exercise the real ``AutobotsTUI`` app the way a user would see it
 but drive it through Textual's Pilot so they run anywhere (including CI
 without a real terminal).
 """
-from __future__ import annotations
-
 import asyncio
 from pathlib import Path
 from types import SimpleNamespace
-
 import json
 import pytest
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_tui_interactive_runtime.py

@@ -1,12 +1,8 @@
-from __future__ import annotations
-
 import asyncio
 import json
 from pathlib import Path
 from types import SimpleNamespace
-
 import pytest
-
 from kiwi_runtime.main import _LocalInteractivePTYBridge, _tui_managed_control_dir
 from kiwi_tui.runtime_agent import control_dir_from_meta
 

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_tui_palette.py

@@ -1,6 +1,5 @@
 from textual.css.stylesheet import Stylesheet
 from pathlib import Path
-
 from kiwi_tui.main import AutobotsTUI
 from kiwi_tui.screens.attach_content import AttachContentScreen
 from kiwi_tui.screens.command_result import CommandResultScreen

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/tests/test_worktrees.py

@@ -1,13 +1,8 @@
-from __future__ import annotations
-
 import os
 import shutil
 import subprocess
-import sys
 from pathlib import Path
-
 import pytest
-
 from kiwi_tui.worktrees import WorktreeError, ensure_worktree
 
 
@@ -61,7 +56,7 @@ def test_ensure_worktree_creates_under_dot_kiwi(tmp_path: Path) -> None:
         cwd=str(repo),
         text=True,
     )
-    assert str(expected) in wt_list
+    assert expected.as_posix() in wt_list.replace("\\", "/")
 
 
 @pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")

{kiwi_code-0.0.431 → kiwi_code-0.0.433}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.431"
+version = "0.0.433"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },

kiwi_code-0.0.431/src/kiwi_runtime/snake_game/.gitignore

@@ -1,3 +0,0 @@
-highscore.json
-*.tmp
-__pycache__/

kiwi_code-0.0.431/src/kiwi_runtime/snake_game/requirements.txt

@@ -1,3 +0,0 @@
-# No dependencies needed on macOS/Linux.
-# On Windows, install curses support:
-windows-curses; platform_system == "Windows"