kimi-cli 1.45.0__tar.gz → 1.47.0__tar.gz

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kimi-cli
-Version: 1.45.0
+Version: 1.47.0
 Summary: Kimi Code CLI is your next CLI agent.
 Requires-Dist: agent-client-protocol==0.8.0
 Requires-Dist: aiofiles>=24.0,<26.0
@@ -34,7 +34,7 @@ Requires-Dist: setproctitle>=1.3.0
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 
-# Kimi Code CLI
+# Kimi CLI
 
 [![Commit Activity](https://img.shields.io/github/commit-activity/w/MoonshotAI/kimi-cli)](https://github.com/MoonshotAI/kimi-cli/graphs/commit-activity)
 [![Checks](https://img.shields.io/github/check-runs/MoonshotAI/kimi-cli/main)](https://github.com/MoonshotAI/kimi-cli/actions)
@@ -44,17 +44,20 @@ Description-Content-Type: text/markdown
 
 [Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
 
-Kimi Code CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
+> [!IMPORTANT]
+> **Kimi CLI is evolving into [Kimi Code CLI](https://github.com/MoonshotAI/kimi-code)** — the next-generation terminal AI agent from the same team. Installing Kimi Code CLI automatically migrates your configuration and sessions. This project will be gradually wound down; the docs and existing installations remain available.
+
+Kimi CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
 
 ## Getting Started
 
-See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi Code CLI.
+See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi CLI.
 
 ## Key Features
 
 ### Shell command mode
 
-Kimi Code CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi Code CLI.
+Kimi CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi CLI.
 
 ![](./docs/media/shell-mode.gif)
 
@@ -63,24 +66,24 @@ Kimi Code CLI is not only a coding agent, but also a shell. You can switch the s
 
 ### VS Code extension
 
-Kimi Code CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
+Kimi CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
 
 ![VS Code Extension](./docs/media/vscode.png)
 
 ### IDE integration via ACP
 
-Kimi Code CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
+Kimi CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
 
 [Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
 
-To use Kimi Code CLI with ACP clients, make sure to run Kimi Code CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi Code CLI as an ACP agent server with command `kimi acp`.
+To use Kimi CLI with ACP clients, make sure to run Kimi CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi CLI as an ACP agent server with command `kimi acp`.
 
-For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
+For example, to use Kimi CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
 
 ```json
 {
   "agent_servers": {
-    "Kimi Code CLI": {
+    "Kimi CLI": {
       "type": "custom",
       "command": "kimi",
       "args": ["acp"],
@@ -90,13 +93,13 @@ For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](ht
 }
 ```
 
-Then you can create Kimi Code CLI threads in IDE's agent panel.
+Then you can create Kimi CLI threads in IDE's agent panel.
 
 ![](./docs/media/acp-integration.gif)
 
 ### Zsh integration
 
-You can use Kimi Code CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+You can use Kimi CLI together with Zsh, to empower your shell experience with AI agent capabilities.
 
 Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
 
@@ -118,7 +121,7 @@ After restarting Zsh, you can switch to agent mode by pressing `Ctrl-X`.
 
 ### MCP support
 
-Kimi Code CLI supports MCP (Model Context Protocol) tools.
+Kimi CLI supports MCP (Model Context Protocol) tools.
 
 **`kimi mcp` sub-command group**
 
@@ -146,7 +149,7 @@ kimi mcp auth linear
 
 **Ad-hoc MCP configuration**
 
-Kimi Code CLI also supports ad-hoc MCP server configuration via CLI option.
+Kimi CLI also supports ad-hoc MCP server configuration via CLI option.
 
 Given an MCP config file in the well-known MCP config format like the following:
 
@@ -179,7 +182,7 @@ See more features in the [Documentation](https://moonshotai.github.io/kimi-cli/e
 
 ## Development
 
-To develop Kimi Code CLI, run:
+To develop Kimi CLI, run:
 
 ```sh
 git clone https://github.com/MoonshotAI/kimi-cli.git
@@ -188,17 +191,17 @@ cd kimi-cli
 make prepare  # prepare the development environment
 ```
 
-Then you can start working on Kimi Code CLI.
+Then you can start working on Kimi CLI.
 
 Refer to the following commands after you make changes:
 
 ```sh
-uv run kimi  # run Kimi Code CLI
+uv run kimi  # run Kimi CLI
 
 make format  # format code
 make check  # run linting and type checking
 make test  # run tests
-make test-kimi-cli  # run Kimi Code CLI tests only
+make test-kimi-cli  # run Kimi CLI tests only
 make test-kosong  # run kosong tests only
 make test-pykaos  # run pykaos tests only
 make build-web  # build the web UI and sync it into the package (requires Node.js/npm)

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/README.md

@@ -1,4 +1,4 @@
-# Kimi Code CLI
+# Kimi CLI
 
 [![Commit Activity](https://img.shields.io/github/commit-activity/w/MoonshotAI/kimi-cli)](https://github.com/MoonshotAI/kimi-cli/graphs/commit-activity)
 [![Checks](https://img.shields.io/github/check-runs/MoonshotAI/kimi-cli/main)](https://github.com/MoonshotAI/kimi-cli/actions)
@@ -8,17 +8,20 @@
 
 [Kimi Code](https://www.kimi.com/code/) | [Documentation](https://moonshotai.github.io/kimi-cli/en/) | [文档](https://moonshotai.github.io/kimi-cli/zh/)
 
-Kimi Code CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
+> [!IMPORTANT]
+> **Kimi CLI is evolving into [Kimi Code CLI](https://github.com/MoonshotAI/kimi-code)** — the next-generation terminal AI agent from the same team. Installing Kimi Code CLI automatically migrates your configuration and sessions. This project will be gradually wound down; the docs and existing installations remain available.
+
+Kimi CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.
 
 ## Getting Started
 
-See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi Code CLI.
+See [Getting Started](https://moonshotai.github.io/kimi-cli/en/guides/getting-started.html) for how to install and start using Kimi CLI.
 
 ## Key Features
 
 ### Shell command mode
 
-Kimi Code CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi Code CLI.
+Kimi CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing `Ctrl-X`. In this mode, you can directly run shell commands without leaving Kimi CLI.
 
 ![](./docs/media/shell-mode.gif)
 
@@ -27,24 +30,24 @@ Kimi Code CLI is not only a coding agent, but also a shell. You can switch the s
 
 ### VS Code extension
 
-Kimi Code CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
+Kimi CLI can be integrated with [Visual Studio Code](https://code.visualstudio.com/) via the [Kimi Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=moonshot-ai.kimi-code).
 
 ![VS Code Extension](./docs/media/vscode.png)
 
 ### IDE integration via ACP
 
-Kimi Code CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
+Kimi CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
 
 [Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
 
-To use Kimi Code CLI with ACP clients, make sure to run Kimi Code CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi Code CLI as an ACP agent server with command `kimi acp`.
+To use Kimi CLI with ACP clients, make sure to run Kimi CLI in the terminal and send `/login` to complete the login first. Then, you can configure your ACP client to start Kimi CLI as an ACP agent server with command `kimi acp`.
 
-For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
+For example, to use Kimi CLI with [Zed](https://zed.dev/) or [JetBrains](https://blog.jetbrains.com/ai/2025/12/bring-your-own-ai-agent-to-jetbrains-ides/), add the following configuration to your `~/.config/zed/settings.json` or `~/.jetbrains/acp.json` file:
 
 ```json
 {
   "agent_servers": {
-    "Kimi Code CLI": {
+    "Kimi CLI": {
       "type": "custom",
       "command": "kimi",
       "args": ["acp"],
@@ -54,13 +57,13 @@ For example, to use Kimi Code CLI with [Zed](https://zed.dev/) or [JetBrains](ht
 }
 ```
 
-Then you can create Kimi Code CLI threads in IDE's agent panel.
+Then you can create Kimi CLI threads in IDE's agent panel.
 
 ![](./docs/media/acp-integration.gif)
 
 ### Zsh integration
 
-You can use Kimi Code CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+You can use Kimi CLI together with Zsh, to empower your shell experience with AI agent capabilities.
 
 Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
 
@@ -82,7 +85,7 @@ After restarting Zsh, you can switch to agent mode by pressing `Ctrl-X`.
 
 ### MCP support
 
-Kimi Code CLI supports MCP (Model Context Protocol) tools.
+Kimi CLI supports MCP (Model Context Protocol) tools.
 
 **`kimi mcp` sub-command group**
 
@@ -110,7 +113,7 @@ kimi mcp auth linear
 
 **Ad-hoc MCP configuration**
 
-Kimi Code CLI also supports ad-hoc MCP server configuration via CLI option.
+Kimi CLI also supports ad-hoc MCP server configuration via CLI option.
 
 Given an MCP config file in the well-known MCP config format like the following:
 
@@ -143,7 +146,7 @@ See more features in the [Documentation](https://moonshotai.github.io/kimi-cli/e
 
 ## Development
 
-To develop Kimi Code CLI, run:
+To develop Kimi CLI, run:
 
 ```sh
 git clone https://github.com/MoonshotAI/kimi-cli.git
@@ -152,17 +155,17 @@ cd kimi-cli
 make prepare  # prepare the development environment
 ```
 
-Then you can start working on Kimi Code CLI.
+Then you can start working on Kimi CLI.
 
 Refer to the following commands after you make changes:
 
 ```sh
-uv run kimi  # run Kimi Code CLI
+uv run kimi  # run Kimi CLI
 
 make format  # format code
 make check  # run linting and type checking
 make test  # run tests
-make test-kimi-cli  # run Kimi Code CLI tests only
+make test-kimi-cli  # run Kimi CLI tests only
 make test-kosong  # run kosong tests only
 make test-pykaos  # run pykaos tests only
 make build-web  # build the web UI and sync it into the package (requires Node.js/npm)

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kimi-cli"
-version = "1.45.0"
+version = "1.47.0"
 description = "Kimi Code CLI is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.12"

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/CHANGELOG.md

@@ -11,6 +11,18 @@ Only write entries that are worth mentioning to users.
 
 ## Unreleased
 
+## 1.47.0 (2026-06-05)
+
+- Shell: Guide users to the new standalone Kimi Code — adds a `/upgrade` command that installs it (migrating your config & sessions automatically), a welcome-screen nudge, and a once-per-day tip shown on exit
+- Shell: Show trailing output in tool error briefs when commands fail
+
+## 1.46.0 (2026-05-28)
+
+- Shell: Support styled text in welcome tips
+- ACP: Replay session history on load
+- Core: Prevent TTY hang on exit
+- Core: Close MCP connections during shutdown
+
 ## 1.45.0 (2026-05-26)
 
 - Shell: `/clear` is now an alias for `/new` — both commands start a new session; previously `/clear` only cleared context without creating a new session

kimi_cli-1.47.0/src/kimi_cli/_build_info.py

@@ -0,0 +1 @@
+BUILD_SHA = "github.com/MoonshotAI/kimi-cli@36c91b387436"

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/acp/server.py

@@ -265,8 +265,8 @@ class ACPServer:
         # Check authentication before loading session
         self._check_auth()
 
-        await self._setup_session(cwd, session_id, mcp_servers)
-        # TODO: replay session history?
+        acp_session, _ = await self._setup_session(cwd, session_id, mcp_servers)
+        await acp_session.replay_history(acp_session.cli.soul.runtime.session.wire_file)
 
     async def resume_session(
         self, cwd: str, session_id: str, mcp_servers: list[MCPServer] | None = None, **kwargs: Any

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/acp/session.py

@@ -19,6 +19,7 @@ from kimi_cli.app import KimiCLI
 from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled
 from kimi_cli.tools import extract_key_argument
 from kimi_cli.utils.logging import logger
+from kimi_cli.wire.file import WireFile
 from kimi_cli.wire.types import (
     ApprovalRequest,
     ApprovalResponse,
@@ -246,6 +247,63 @@ class ACPSession:
             _current_turn_id.reset(token)
         return acp.PromptResponse(stop_reason="end_turn")
 
+    async def replay_history(self, wire_file: WireFile) -> None:
+        """Replay persisted wire history to an ACP client during session/load."""
+        token = _current_turn_id.set(None)
+        terminal_tool_calls_token = _terminal_tool_call_ids.set(set())
+        try:
+            async for record in wire_file.iter_records():
+                wire_msg = record.to_wire_message()
+                match wire_msg:
+                    case TurnBegin(user_input=user_input) | SteerInput(user_input=user_input):
+                        self._turn_state = _TurnState()
+                        _current_turn_id.set(self._turn_state.id)
+                        await self._send_user_input(user_input)
+                    case TurnEnd() | StepInterrupted():
+                        self._turn_state = None
+                        _current_turn_id.set(None)
+                    case StepBegin():
+                        pass
+                    case CompactionBegin() | CompactionEnd():
+                        pass
+                    case MCPLoadingBegin() | MCPLoadingEnd():
+                        pass
+                    case StatusUpdate():
+                        pass
+                    case Notification():
+                        await self._send_notification(wire_msg)
+                    case ThinkPart(think=think):
+                        await self._send_thinking(think)
+                    case TextPart(text=text):
+                        await self._send_text(text)
+                    case ContentPart():
+                        await self._send_text(f"[{wire_msg.__class__.__name__}]")
+                    case ToolCall():
+                        self._ensure_turn_state()
+                        await self._send_tool_call(wire_msg)
+                    case ToolCallPart():
+                        if self._turn_state is not None:
+                            await self._send_tool_call_part(wire_msg)
+                    case ToolResult():
+                        if self._turn_state is not None:
+                            await self._send_tool_result(wire_msg)
+                    case PlanDisplay():
+                        pass
+                    case ApprovalResponse() | SubagentEvent():
+                        pass
+                    case ApprovalRequest() | ToolCallRequest() | QuestionRequest():
+                        pass
+                    case _:
+                        pass
+        except Exception:
+            logger.exception(
+                "Failed to replay ACP session history from {file}:", file=wire_file.path
+            )
+        finally:
+            self._turn_state = None
+            _terminal_tool_call_ids.reset(terminal_tool_calls_token)
+            _current_turn_id.reset(token)
+
     async def cancel(self) -> None:
         if self._turn_state is None:
             logger.warning("Cancel requested but no prompt is running")
@@ -253,6 +311,32 @@ class ACPSession:
 
         self._turn_state.cancel_event.set()
 
+    def _ensure_turn_state(self) -> None:
+        if self._turn_state is None:
+            self._turn_state = _TurnState()
+            _current_turn_id.set(self._turn_state.id)
+
+    async def _send_user_input(self, user_input: str | list[ContentPart]) -> None:
+        if not self._id or not self._conn:
+            return
+
+        parts = [TextPart(text=user_input)] if isinstance(user_input, str) else user_input
+        for part in parts:
+            if isinstance(part, TextPart):
+                content: ACPContentBlock = acp.schema.TextContentBlock(type="text", text=part.text)
+            else:
+                logger.warning("Unsupported replay user input part: {part}", part=part)
+                content = acp.schema.TextContentBlock(
+                    type="text", text=f"[{part.__class__.__name__}]"
+                )
+            await self._conn.session_update(
+                session_id=self._id,
+                update=acp.schema.UserMessageChunk(
+                    content=content,
+                    session_update="user_message_chunk",
+                ),
+            )
+
     async def _send_thinking(self, think: str):
         """Send thinking content to client."""
         if not self._id or not self._conn:

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/acp/tools.py

@@ -142,20 +142,22 @@ class Terminal(CallableTool2[ShellParams]):
                 else ""
             )
 
+            tail = builder.tail()
+            tail_md = f"\n{tail}" if tail else ""
             if timed_out:
                 return builder.error(
                     f"Command killed by timeout ({timeout_label}){truncated_note}",
-                    brief=f"Killed by timeout ({timeout_label})",
+                    brief=f"Killed by timeout ({timeout_label}){tail_md}",
                 )
             if exit_signal:
                 return builder.error(
                     f"Command terminated by signal: {exit_signal}.{truncated_note}",
-                    brief=f"Signal: {exit_signal}",
+                    brief=f"Signal: {exit_signal}{tail_md}",
                 )
             if exit_code not in (None, 0):
                 return builder.error(
                     f"Command failed with exit code: {exit_code}.{truncated_note}",
-                    brief=f"Failed with exit code: {exit_code}",
+                    brief=f"Failed with exit code: {exit_code}{tail_md}",
                 )
             return builder.ok(f"Command executed successfully.{truncated_note}")
         finally:

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/app.py

@@ -27,6 +27,7 @@ from kimi_cli.soul import RunCancelled, run_soul
 from kimi_cli.soul.agent import Runtime, load_agent
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.soul.toolset import KimiToolset
 from kimi_cli.utils.aioqueue import QueueShutDown
 from kimi_cli.utils.envvar import get_env_bool
 from kimi_cli.utils.logging import logger, open_original_stderr, redirect_stderr_to_logger
@@ -415,6 +416,15 @@ class KimiCLI:
         if self._bg_refresh_task is not None and not self._bg_refresh_task.done():
             self._bg_refresh_task.cancel()
 
+        # Close MCP client connections so stdio/WebSocket transports do not
+        # outlive the CLI process and trigger firewall warnings.
+        try:
+            toolset = self.soul.agent.toolset
+            if isinstance(toolset, KimiToolset):
+                await toolset.cleanup()
+        except (Exception, asyncio.CancelledError):
+            logger.warning("Error during toolset cleanup; continuing exit", exc_info=True)
+
         bg_config = self._runtime.config.background
         if bg_config.keep_alive_on_exit:
             return
@@ -652,6 +662,7 @@ class KimiCLI:
                     user_input,
                     _ui_loop_fn,
                     run_cancel_event,
+                    self._runtime.session.wire_file,
                     runtime=self._runtime,
                 )
             )
@@ -755,12 +766,19 @@ class KimiCLI:
                         level=WelcomeInfoItem.Level.WARN,
                     )
                 )
+        from kimi_cli.ui.shell.migration_nudge import (
+            already_installed_text,
+            kimi_code_installed,
+            welcome_card_text,
+        )
+
         welcome_info.append(
             WelcomeInfoItem(
-                name="\nTip",
+                name="\n✨ Update",
                 value=(
-                    "We just released Kimi Code — our new coding agent. "
-                    "Check it out at https://moonshotai.github.io/kimi-code"
+                    already_installed_text(sys.platform)
+                    if kimi_code_installed()
+                    else welcome_card_text()
                 ),
                 level=WelcomeInfoItem.Level.WARN,
             )

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/soul/toolset.py

@@ -772,11 +772,14 @@ class KimiToolset:
         self._deferred_mcp_load = None
         if self._mcp_loading_task:
             self._mcp_loading_task.cancel()
-            with contextlib.suppress(Exception):
+            with contextlib.suppress(Exception, asyncio.CancelledError):
                 await self._mcp_loading_task
         for server_info in self._mcp_servers.values():
             if server_info.client is not None:
-                await server_info.client.close()
+                try:
+                    await server_info.client.close()
+                except Exception:
+                    logger.warning("Failed to close MCP client", exc_info=True)
 
 
 @dataclass(slots=True)

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/tools/shell/__init__.py

@@ -117,9 +117,13 @@ class Shell(CallableTool2[Params]):
             if exitcode == 0:
                 return builder.ok("Command executed successfully.")
             else:
+                brief = f"Failed with exit code: {exitcode}"
+                tail = builder.tail()
+                if tail:
+                    brief += f"\n{tail}"
                 return builder.error(
                     f"Command failed with exit code: {exitcode}.",
-                    brief=f"Failed with exit code: {exitcode}",
+                    brief=brief,
                 )
         except TimeoutError:
             return builder.error(

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/tools/utils.py

@@ -127,6 +127,26 @@ class ToolResultBuilder:
 
         return chars_written
 
+    def tail(self, max_lines: int = 5, max_line_len: int = 200) -> str:
+        """Return the last non-empty lines from the buffer, joined with newlines.
+
+        Useful for surfacing actionable error context (stderr) in tool result briefs.
+        """
+        collected: list[str] = []
+        for chunk in reversed(self._buffer):
+            for line in reversed(chunk.splitlines()):
+                stripped = line.rstrip()
+                if not stripped.strip():
+                    continue
+                if len(stripped) > max_line_len:
+                    stripped = stripped[:max_line_len] + "..."
+                collected.append(stripped)
+                if len(collected) >= max_lines:
+                    break
+            if len(collected) >= max_lines:
+                break
+        return "\n".join(reversed(collected))
+
     def display(self, *blocks: DisplayBlock) -> None:
         """Add display blocks to the tool result."""
         self._display.extend(blocks)

{kimi_cli-1.45.0 → kimi_cli-1.47.0}/src/kimi_cli/ui/shell/__init__.py

@@ -32,6 +32,7 @@ from kimi_cli.ui.shell import update as _update_mod
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.echo import render_user_echo_text
 from kimi_cli.ui.shell.mcp_status import render_mcp_prompt
+from kimi_cli.ui.shell.migration_nudge import print_migration_goodbye
 from kimi_cli.ui.shell.prompt import (
     BgTaskCounts,
     CustomPromptSession,
@@ -578,7 +579,7 @@ class Shell:
                         else:
                             bg_auto_failures = 0
                         if self._exit_after_run:
-                            console.print("Bye!")
+                            print_migration_goodbye(console)
                             break
                         continue
 
@@ -596,7 +597,7 @@ class Shell:
                         continue
 
                     if event.kind == "eof":
-                        console.print("Bye!")
+                        print_migration_goodbye(console)
                         break
 
                     if event.kind == "cwd_lost":
@@ -623,7 +624,7 @@ class Shell:
 
                     if self._should_exit_input(user_input):
                         logger.debug("Exiting by slash command")
-                        console.print("Bye!")
+                        print_migration_goodbye(console)
                         break
 
                     if user_input.mode == PromptMode.SHELL:
@@ -668,7 +669,7 @@ class Shell:
                             await self.run_soul_command(slash_cmd_call.raw_input)
                             console.print()
                             if self._exit_after_run:
-                                console.print("Bye!")
+                                print_migration_goodbye(console)
                                 break
                         else:
                             await self._run_slash_command(slash_cmd_call)
@@ -680,7 +681,7 @@ class Shell:
                     await self.run_soul_command(user_input.content)
                     console.print()
                     if self._exit_after_run:
-                        console.print("Bye!")
+                        print_migration_goodbye(console)
                         break
             finally:
                 prompt_task.cancel()
@@ -1475,7 +1476,7 @@ class WelcomeInfoItem:
         ERROR = "red"
 
     name: str
-    value: str
+    value: str | Text
     level: Level = Level.INFO
 
 
@@ -1495,7 +1496,10 @@ def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
     if info_items:
         rows.append(Text(""))  # empty line
     for item in info_items:
-        rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
+        if isinstance(item.value, Text):
+            rows.append(Text.assemble(f"{item.name}: ", item.value, style=item.level.value))
+        else:
+            rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
 
     if LATEST_VERSION_FILE.exists():
         from kimi_cli.constant import VERSION as current_version