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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kimi-cli
-Version: 1.43.0
+Version: 1.45.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

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

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

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

@@ -11,6 +11,16 @@ Only write entries that are worth mentioning to users.
 
 ## Unreleased
 
+## 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
+- Shell: Fix misleading "Quota exceeded" prefix shown on every 403 error
+
+## 1.44.0 (2026-05-13)
+
+- Shell: Add slash command alias resolution — aliases such as `/h`, `?`, and `status` now resolve to their canonical commands (`/help`, `/usage`); the completer and help output display alias matches as `/name (alias)` for clarity
+- Shell: Fix `/usage` alias registration — the alias was incorrectly stored as `"/status"` instead of `"status"`, causing alias lookup to fail
+
 ## 1.43.0 (2026-05-12)
 
 - Security: Bump pillow to 12.2.0 to address CVE-2026-25990 (out-of-bounds write when loading PSD images); unblocks installs in environments that gate on the older pinned version

kimi_cli-1.45.0/src/kimi_cli/_build_info.py

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

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

@@ -759,10 +759,10 @@ class KimiCLI:
             WelcomeInfoItem(
                 name="\nTip",
                 value=(
-                    "Spot a bug or have feedback? Type /feedback right in this session"
-                    " — every report makes Kimi better."
+                    "We just released Kimi Code — our new coding agent. "
+                    "Check it out at https://moonshotai.github.io/kimi-code"
                 ),
-                level=WelcomeInfoItem.Level.INFO,
+                level=WelcomeInfoItem.Level.WARN,
             )
         )
         async with self._env():

{kimi_cli-1.43.0 → kimi_cli-1.45.0}/src/kimi_cli/soul/btw.py

@@ -117,10 +117,19 @@ async def execute_side_question(
     Returns:
         (response_text, None) on success, (None, error_message) on failure.
     """
-    if soul._runtime.llm is None:  # pyright: ignore[reportPrivateUsage]
-        return None, "LLM is not set."
+    import time
+
+    from kimi_cli.telemetry import track
+
+    t0 = time.monotonic()
+    _outcome = "error"
+    _error_type: str | None = None
 
     try:
+        if soul._runtime.llm is None:  # pyright: ignore[reportPrivateUsage]
+            _error_type = "LLMNotSet"
+            return None, "LLM is not set."
+
         chat_provider = soul._runtime.llm.chat_provider  # pyright: ignore[reportPrivateUsage]
         system_prompt, history, toolset = _build_btw_context(soul, question)
 
@@ -146,6 +155,8 @@ async def execute_side_question(
             # didn't also call tools (mixed text+tool = incomplete preamble).
             response_text = "".join(text_chunks).strip()
             if response_text and not result.tool_calls:
+                _outcome = "success"
+                _error_type = None
                 return response_text, None
 
             # No text — did the LLM try to call a tool?
@@ -166,16 +177,30 @@ async def execute_side_question(
                 continue
 
             # Last turn and still no text — report the tool call attempt
+            _error_type = "ToolCallDenied"
             tool_names = [tc.function.name for tc in result.tool_calls]
             return None, (
                 f"Side question tried to call tools ({', '.join(tool_names)}) "
                 "instead of answering directly. Try rephrasing or ask in the main conversation."
             )
 
+        _error_type = "NoResponse"
         return None, "No response received."
     except Exception as e:
+        _error_type = type(e).__name__
         logger.warning("Side question failed: {error}", error=e)
         return None, str(e)
+    finally:
+        elapsed = time.monotonic() - t0
+        kwargs: dict[str, bool | int | float | str | None] = {
+            "tool_name": "btw",
+            "outcome": _outcome,
+            "duration_ms": int(elapsed * 1000),
+            "dup_type": "normal",
+        }
+        if _error_type is not None:
+            kwargs["error_type"] = _error_type
+        track("tool_call", **kwargs)
 
 
 def _tool_result_to_message(tool_result: ToolResult) -> Message:

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

@@ -11,7 +11,7 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, overload
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
 
 from kosong.tooling import (
     CallableTool,
@@ -83,6 +83,7 @@ def get_current_tool_call_or_none() -> ToolCall | None:
 
 
 type ToolType = CallableTool | CallableTool2[Any]
+type ToolCallKey = tuple[str, str]
 
 
 if TYPE_CHECKING:
@@ -91,7 +92,7 @@ if TYPE_CHECKING:
         _: Toolset = kimi_toolset
 
 
-_REMINDER_TEXT = (
+_REMINDER_TEXT_1 = (
     "\n\n<system-reminder>\n"
     "You are repeating the exact same tool call with identical parameters."
     " Please carefully analyze the previous result. If the task is not yet complete,"
@@ -100,7 +101,56 @@ _REMINDER_TEXT = (
 )
 
 
-def _append_reminder_to_return_value(return_value: Any) -> Any:
+def _make_reminder_text_2(tool_name: str, repeat_count: int, canonical_args: str) -> str:
+    return (
+        "\n\n<system-reminder>\n"
+        "You have repeatedly called the same tool with identical parameters many times.\n"
+        "Repeated tool call detected:\n"
+        f"- tool: {tool_name}\n"
+        f"- repeated_times: {repeat_count}\n"
+        f"- arguments: {canonical_args}\n"
+        "The previous repeated calls did not make progress. Do not call this exact same tool "
+        "with the exact same arguments again.\n"
+        "Carefully inspect the latest tool result and choose a different next action, "
+        "different parameters, or finish the task if enough evidence has been gathered."
+        "\n</system-reminder>"
+    )
+
+
+def _sort_json_value(value: object) -> object:
+    if isinstance(value, list):
+        return [_sort_json_value(item) for item in cast("list[object]", value)]
+    if isinstance(value, dict):
+        value_dict = cast("dict[str, object]", value)
+        return {key: _sort_json_value(value_dict[key]) for key in sorted(value_dict)}
+    return value
+
+
+def _canonical_tool_arguments(arguments: Any) -> str:
+    try:
+        return json.dumps(
+            _sort_json_value(arguments),
+            ensure_ascii=False,
+            separators=(",", ":"),
+        )
+    except (TypeError, ValueError):
+        return str(arguments)
+
+
+def _canonical_tool_arguments_text(arguments: str) -> str:
+    try:
+        return _canonical_tool_arguments(json.loads(arguments, strict=False))
+    except json.JSONDecodeError:
+        return arguments
+
+
+def _normalize_call_key(tool_name: str, arguments: str) -> ToolCallKey:
+    return (tool_name, _canonical_tool_arguments_text(arguments))
+
+
+def _append_reminder_to_return_value(
+    return_value: Any, reminder_text: str = _REMINDER_TEXT_1
+) -> Any:
     """Append dedup reminder text to a ToolReturnValue output."""
     from kosong.tooling import ToolReturnValue
 
@@ -108,16 +158,15 @@ def _append_reminder_to_return_value(return_value: Any) -> Any:
         return return_value
 
     output = return_value.output
-    reminder = _REMINDER_TEXT
 
     if isinstance(output, str):
-        new_output = output + reminder
+        new_output = output + reminder_text
     else:
         new_output = list(output)
         if new_output and isinstance(new_output[-1], TextPart):
-            new_output[-1] = TextPart(text=new_output[-1].text + reminder)
+            new_output[-1] = TextPart(text=new_output[-1].text + reminder_text)
         else:
-            new_output.append(TextPart(text=reminder))
+            new_output.append(TextPart(text=reminder_text))
 
     return return_value.model_copy(update={"output": new_output})
 
@@ -132,9 +181,13 @@ class KimiToolset:
         self._hook_engine: HookEngine = HookEngine()
 
         # Deduplication state
-        self._previous_step_calls: list[tuple[str, str]] = []
-        self._current_step_calls: list[tuple[str, str]] = []
-        self._current_step_tasks: dict[tuple[str, str], asyncio.Task[ToolResult]] = {}
+        self._previous_step_calls: list[ToolCallKey] = []
+        self._current_step_calls: list[ToolCallKey] = []
+        self._current_step_tasks: dict[ToolCallKey, asyncio.Task[ToolResult]] = {}
+        self._seen_call_keys: set[ToolCallKey] = set()
+        self._consecutive_key: ToolCallKey | None = None
+        self._consecutive_count: int = 0
+        self._step_closed: bool = False
         self._dedup_triggered: bool = False
         self._step_no: int = 0
         self._turn_id: str = ""
@@ -183,17 +236,51 @@ class KimiToolset:
         turn_id: str = "",
     ) -> None:
         """Called before each step to set up deduplication state."""
-        self._previous_step_calls = previous_calls
+        self._previous_step_calls = [
+            _normalize_call_key(tool_name, arguments) for tool_name, arguments in previous_calls
+        ]
         self._current_step_calls = []
         self._current_step_tasks = {}
+        self._step_closed = False
         self._dedup_triggered = False
         self._step_no = step_no
         self._turn_id = turn_id
+        if not self._previous_step_calls:
+            self._seen_call_keys = set()
+            self._consecutive_key = None
+            self._consecutive_count = 0
+        else:
+            self._seen_call_keys.update(self._previous_step_calls)
+            if self._consecutive_key is None and self._consecutive_count == 0:
+                self._advance_consecutive_streak(self._previous_step_calls)
 
     def end_step(self) -> list[tuple[str, str]]:
         """Called after each step to capture the calls made in this step."""
+        if not self._step_closed:
+            self._advance_consecutive_streak(self._current_step_calls)
+            self._seen_call_keys.update(self._current_step_calls)
+            self._step_closed = True
         return list(self._current_step_calls)
 
+    def _advance_consecutive_streak(self, calls: list[ToolCallKey]) -> None:
+        for call_key in calls:
+            if call_key == self._consecutive_key:
+                self._consecutive_count += 1
+            else:
+                self._consecutive_key = call_key
+                self._consecutive_count = 1
+
+    def _projected_streak_for_call(self, call_index: int) -> int:
+        consecutive_key = self._consecutive_key
+        consecutive_count = self._consecutive_count
+        for call_key in self._current_step_calls[: call_index + 1]:
+            if call_key == consecutive_key:
+                consecutive_count += 1
+            else:
+                consecutive_key = call_key
+                consecutive_count = 1
+        return consecutive_count
+
     @property
     def dedup_triggered(self) -> bool:
         """Whether a cross-step duplicate was blocked in the current step."""
@@ -202,9 +289,31 @@ class KimiToolset:
     def handle(self, tool_call: ToolCall) -> HandleResult:
         token = current_tool_call.set(tool_call)
         try:
-            call_key = (tool_call.function.name, tool_call.function.arguments or "{}")
+            tool_name = tool_call.function.name
+
+            if tool_name not in self._tool_dict:
+                return ToolResult(
+                    tool_call_id=tool_call.id,
+                    return_value=ToolNotFoundError(tool_name),
+                )
+
+            try:
+                arguments: JsonType = json.loads(tool_call.function.arguments or "{}", strict=False)
+            except json.JSONDecodeError as e:
+                logger.warning(
+                    "Tool call JSON parse error: {tool_name} (call_id={call_id}): {error}",
+                    tool_name=tool_name,
+                    call_id=tool_call.id,
+                    error=e,
+                )
+                return ToolResult(tool_call_id=tool_call.id, return_value=ToolParseError(str(e)))
+
+            canonical_args = _canonical_tool_arguments(arguments)
+            call_key = (tool_name, canonical_args)
+            call_index = len(self._current_step_calls)
+            self._current_step_calls.append(call_key)
 
-            # Same-step dedup: wait for the original task and copy its result
+            # Same-step dedup: wait for the original task and copy its result.
             if call_key in self._current_step_tasks:
                 from kimi_cli.telemetry import track
 
@@ -213,9 +322,9 @@ class KimiToolset:
                     session_id=_get_session_id(),
                     turn_id=self._turn_id,
                     step_no=self._step_no,
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     dup_type="same_step",
-                    args_hash=hashlib.sha256(call_key[1].encode()).hexdigest()[:8],
+                    args_hash=hashlib.sha256(canonical_args.encode()).hexdigest()[:8],
                 )
                 original_task = self._current_step_tasks[call_key]
 
@@ -228,7 +337,8 @@ class KimiToolset:
 
                 return asyncio.create_task(_await_dup())
 
-            is_cross_step_dup = call_key in self._previous_step_calls
+            is_cross_step_dup = call_key in self._seen_call_keys
+            reminder_text: str | None = None
             if is_cross_step_dup:
                 from kimi_cli.telemetry import track
 
@@ -237,30 +347,18 @@ class KimiToolset:
                     session_id=_get_session_id(),
                     turn_id=self._turn_id,
                     step_no=self._step_no,
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     dup_type="cross_step",
-                    args_hash=hashlib.sha256(call_key[1].encode()).hexdigest()[:8],
+                    args_hash=hashlib.sha256(canonical_args.encode()).hexdigest()[:8],
                 )
                 self._dedup_triggered = True
+                repeat_count = self._projected_streak_for_call(call_index)
+                if repeat_count == 3:
+                    reminder_text = _REMINDER_TEXT_1
+                elif repeat_count in (5, 8):
+                    reminder_text = _make_reminder_text_2(tool_name, repeat_count, canonical_args)
 
-            if tool_call.function.name not in self._tool_dict:
-                return ToolResult(
-                    tool_call_id=tool_call.id,
-                    return_value=ToolNotFoundError(tool_call.function.name),
-                )
-
-            tool = self._tool_dict[tool_call.function.name]
-
-            try:
-                arguments: JsonType = json.loads(tool_call.function.arguments or "{}", strict=False)
-            except json.JSONDecodeError as e:
-                logger.warning(
-                    "Tool call JSON parse error: {tool_name} (call_id={call_id}): {error}",
-                    tool_name=tool_call.function.name,
-                    call_id=tool_call.id,
-                    error=e,
-                )
-                return ToolResult(tool_call_id=tool_call.id, return_value=ToolParseError(str(e)))
+            tool = self._tool_dict[tool_name]
 
             async def _call():
                 tool_input_dict = arguments if isinstance(arguments, dict) else {}
@@ -270,11 +368,11 @@ class KimiToolset:
 
                 results = await self._hook_engine.trigger(
                     "PreToolUse",
-                    matcher_value=tool_call.function.name,
+                    matcher_value=tool_name,
                     input_data=events.pre_tool_use(
                         session_id=_get_session_id(),
                         cwd=str(Path.cwd()),
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         tool_input=tool_input_dict,
                         tool_call_id=tool_call.id,
                     ),
@@ -297,18 +395,18 @@ class KimiToolset:
                     tool_elapsed = time.monotonic() - t0
                     logger.exception(
                         "Tool execution failed: {tool_name} (call_id={call_id})",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         call_id=tool_call.id,
                     )
                     # --- PostToolUseFailure (fire-and-forget) ---
                     _hook_task = asyncio.create_task(
                         self._hook_engine.trigger(
                             "PostToolUseFailure",
-                            matcher_value=tool_call.function.name,
+                            matcher_value=tool_name,
                             input_data=events.post_tool_use_failure(
                                 session_id=_get_session_id(),
                                 cwd=str(Path.cwd()),
-                                tool_name=tool_call.function.name,
+                                tool_name=tool_name,
                                 tool_input=tool_input_dict,
                                 error=str(e),
                                 tool_call_id=tool_call.id,
@@ -323,7 +421,7 @@ class KimiToolset:
                     _error_type = type(e).__name__
                     track(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="error",
                         duration_ms=int(tool_elapsed * 1000),
                         error_type=_error_type,
@@ -336,7 +434,7 @@ class KimiToolset:
                 tool_elapsed = time.monotonic() - t0
                 logger.info(
                     "Tool {tool_name} completed in {elapsed:.1f}s (call_id={call_id})",
-                    tool_name=tool_call.function.name,
+                    tool_name=tool_name,
                     elapsed=tool_elapsed,
                     call_id=tool_call.id,
                 )
@@ -345,7 +443,7 @@ class KimiToolset:
                 if isinstance(ret, ToolError):
                     _track_tool_call(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="error",
                         duration_ms=int(tool_elapsed * 1000),
                         error_type=type(ret).__name__,
@@ -354,7 +452,7 @@ class KimiToolset:
                 else:
                     _track_tool_call(
                         "tool_call",
-                        tool_name=tool_call.function.name,
+                        tool_name=tool_name,
                         outcome="success",
                         duration_ms=int(tool_elapsed * 1000),
                         dup_type="cross_step" if is_cross_step_dup else "normal",
@@ -364,11 +462,11 @@ class KimiToolset:
                 _hook_task = asyncio.create_task(
                     self._hook_engine.trigger(
                         "PostToolUse",
-                        matcher_value=tool_call.function.name,
+                        matcher_value=tool_name,
                         input_data=events.post_tool_use(
                             session_id=_get_session_id(),
                             cwd=str(Path.cwd()),
-                            tool_name=tool_call.function.name,
+                            tool_name=tool_name,
                             tool_input=tool_input_dict,
                             tool_output=str(ret)[:2000],
                             tool_call_id=tool_call.id,
@@ -380,21 +478,21 @@ class KimiToolset:
                 return ToolResult(tool_call_id=tool_call.id, return_value=ret)
 
             task = asyncio.create_task(_call())
-            if is_cross_step_dup:
+            if reminder_text is not None:
 
                 async def _wrap_with_reminder(
                     inner_task: asyncio.Task[ToolResult],
+                    text: str,
                 ) -> ToolResult:
                     tr = await inner_task
                     return ToolResult(
                         tool_call_id=tr.tool_call_id,
-                        return_value=_append_reminder_to_return_value(tr.return_value),
+                        return_value=_append_reminder_to_return_value(tr.return_value, text),
                     )
 
-                task = asyncio.create_task(_wrap_with_reminder(task))
+                task = asyncio.create_task(_wrap_with_reminder(task, reminder_text))
 
             self._current_step_tasks[call_key] = task
-            self._current_step_calls.append(call_key)
             return task
         finally:
             current_tool_call.reset(token)

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

@@ -200,17 +200,39 @@ class Shell:
         self._current_prompt_approval_request: ApprovalRequest | None = None
         self._approval_modal: ApprovalPromptDelegate | None = None
         self._exit_after_run = False
+        soul_slash_commands = list(soul.available_slash_commands)
+        shell_slash_commands = shell_slash_registry.list_commands()
         self._available_slash_commands: dict[str, SlashCommand[Any]] = {
-            **{cmd.name: cmd for cmd in soul.available_slash_commands},
-            **{cmd.name: cmd for cmd in shell_slash_registry.list_commands()},
+            **{cmd.name: cmd for cmd in soul_slash_commands},
+            **{cmd.name: cmd for cmd in shell_slash_commands},
         }
-        """Shell-level slash commands + soul-level slash commands. Name to command mapping."""
+        """Shell-level slash commands + soul-level slash commands. Primary name mapping."""
+        self._available_slash_command_index = self._index_slash_commands(
+            [*soul_slash_commands, *shell_slash_commands]
+        )
+        """Shell-level slash commands + soul-level slash commands.
+        Primary name and alias mapping.
+        """
 
     @property
     def available_slash_commands(self) -> dict[str, SlashCommand[Any]]:
         """Get all available slash commands, including shell-level and soul-level commands."""
         return self._available_slash_commands
 
+    @staticmethod
+    def _index_slash_commands(commands: list[SlashCommand[Any]]) -> dict[str, SlashCommand[Any]]:
+        indexed: dict[str, SlashCommand[Any]] = {}
+        for command in commands:
+            indexed[command.name] = command
+            for alias in command.aliases:
+                indexed[alias] = command
+        return indexed
+
+    def _find_available_slash_command(self, name: str) -> SlashCommand[Any] | None:
+        return self._available_slash_command_index.get(name) or self._available_slash_commands.get(
+            name
+        )
+
     def _print_cwd_lost_crash(self) -> None:
         """Print a crash report when the working directory is no longer accessible."""
         runtime = self.soul.runtime if isinstance(self.soul, KimiSoul) else None
@@ -622,9 +644,6 @@ class Shell:
                     )
                     action = classify_input(input_text, is_streaming=False)
                     if action.kind == InputAction.BTW and isinstance(self.soul, KimiSoul):
-                        from kimi_cli.telemetry import track
-
-                        track("input_btw")
                         await self._run_btw_modal(action.args, prompt_session)
                         resume_prompt.set()
                         continue
@@ -634,14 +653,16 @@ class Shell:
                         continue
 
                     if slash_cmd_call := self._agent_slash_command_call(user_input):
+                        available_command = self._find_available_slash_command(slash_cmd_call.name)
                         is_soul_slash = (
-                            slash_cmd_call.name in self._available_slash_commands
+                            available_command is not None
                             and shell_slash_registry.find_command(slash_cmd_call.name) is None
                         )
                         if is_soul_slash:
                             from kimi_cli.telemetry import track
 
-                            track("input_command", command=slash_cmd_call.name)
+                            assert available_command is not None
+                            track("input_command", command=available_command.name)
                             background_autotrigger_armed = True
                             resume_prompt.set()
                             await self.run_soul_command(slash_cmd_call.raw_input)
@@ -755,7 +776,8 @@ class Shell:
         from kimi_cli.cli import Reload, SwitchToVis, SwitchToWeb
         from kimi_cli.telemetry import track
 
-        if command_call.name not in self._available_slash_commands:
+        available_command = self._find_available_slash_command(command_call.name)
+        if available_command is None:
             logger.info("Unknown slash command /{command}", command=command_call.name)
             track("input_command_invalid")
             console.print(
@@ -764,7 +786,7 @@ class Shell:
             )
             return
 
-        track("input_command", command=command_call.name)
+        track("input_command", command=available_command.name)
 
         command = shell_slash_registry.find_command(command_call.name)
         if command is None:
@@ -949,10 +971,7 @@ class Shell:
                     f"[red]Membership expired, please renew your plan[/red]\n[dim]Server: {e}[/dim]"
                 )
             elif isinstance(e, APIStatusError) and e.status_code == 403:
-                console.print(
-                    "[red]Quota exceeded, please upgrade your plan or retry later[/red]\n"
-                    f"[dim]Server: {e}[/dim]"
-                )
+                console.print(f"[red]Server: {e}[/red]")
             elif isinstance(e, APIConnectionError):
                 console.print(
                     f"[red]Network connection failed: {e}[/red]\n"

{kimi_cli-1.43.0 → kimi_cli-1.45.0}/src/kimi_cli/ui/shell/prompt.py

@@ -89,7 +89,7 @@ class CwdLostError(OSError):
 class SlashCommandCompleter(Completer):
     """
     A completer that:
-    - Shows one line per slash command using the canonical "/name"
+    - Shows canonical matches as "/name" and alias matches as "/name (alias)"
     - Fuzzy-matches by primary name or any alias while inserting the canonical "/name"
     - Only activates when the current token starts with '/'
     """
@@ -142,25 +142,32 @@ class SlashCommandCompleter(Completer):
         token = text[last_space + 1 :]
 
         typed = token[1:]
-        if typed and typed in self._command_lookup:
-            return
         mention_doc = Document(text=typed, cursor_position=len(typed))
         candidates = list(self._fuzzy.get_completions(mention_doc, complete_event))
 
         seen: set[str] = set()
-
+        candidate_triggers: list[str] = []
+        if typed and typed in self._command_lookup:
+            candidate_triggers.append(typed)
         for candidate in candidates:
-            commands = self._command_lookup.get(candidate.text)
+            if candidate.text not in candidate_triggers:
+                candidate_triggers.append(candidate.text)
+
+        for trigger in candidate_triggers:
+            commands = self._command_lookup.get(trigger)
             if not commands:
                 continue
             for cmd in commands:
                 if cmd.name in seen:
                     continue
                 seen.add(cmd.name)
+                completion_text = f"/{cmd.name}"
+                if trigger == cmd.name and typed == cmd.name:
+                    completion_text += " "
                 yield Completion(
-                    text=f"/{cmd.name}",
+                    text=completion_text,
                     start_position=-len(token),
-                    display=f"/{cmd.name}",
+                    display=cmd.display_name(trigger),
                     display_meta=cmd.description,
                 )