dashscope 1.27.0__tar.gz → 1.27.2__tar.gz

{dashscope-1.27.0 → dashscope-1.27.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dashscope
-Version: 1.27.0
+Version: 1.27.2
 Summary: dashscope client sdk library
 Home-page: https://dashscope.aliyun.com/
 Author: Alibaba Cloud
@@ -176,6 +176,21 @@ The SDK ships with an interactive AI assistant, **DashScope SDK Expert**, built
 
 For the latest model list, visit [Bailian Model Plaza](https://bailian.console.aliyun.com/).
 
+## Shell Completion
+
+Run the appropriate command once, then restart your shell (or re-source your config file):
+
+| Shell | Install command |
+|-------|-----------------|
+| **bash** | `dashscope --install-completion bash` |
+| **zsh** | `dashscope --install-completion zsh` |
+| **fish** | `dashscope --install-completion fish` |
+
+To preview the completion script without installing:
+```shell
+dashscope --show-completion bash
+```
+
 ## Logging
 To output Dashscope logs, you need to configure the logger.
 ```shell

{dashscope-1.27.0 → dashscope-1.27.2}/README.md

@@ -107,6 +107,21 @@ The SDK ships with an interactive AI assistant, **DashScope SDK Expert**, built
 
 For the latest model list, visit [Bailian Model Plaza](https://bailian.console.aliyun.com/).
 
+## Shell Completion
+
+Run the appropriate command once, then restart your shell (or re-source your config file):
+
+| Shell | Install command |
+|-------|-----------------|
+| **bash** | `dashscope --install-completion bash` |
+| **zsh** | `dashscope --install-completion zsh` |
+| **fish** | `dashscope --install-completion fish` |
+
+To preview the completion script without installing:
+```shell
+dashscope --show-completion bash
+```
+
 ## Logging
 To output Dashscope logs, you need to configure the logger.
 ```shell

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 # Expose the lightweight programmatic SDK at the package root.
 try:

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/agent.py

@@ -235,9 +235,32 @@ class Agent:
         self.messages = []
 
     def load_session(self) -> int:
-        """Restore self.messages from session_path. Returns the number of
-        messages loaded (0 if no file, file empty, or parse failed)."""
-        if not self.session_path or not self.session_path.exists():
+        """Restore self.messages. Returns the number of messages loaded
+        (0 if nothing could be restored).
+
+        The per-topic event stream is the source of truth: the latest
+        ``messages/snapshot`` wins when present (crash recovery via
+        append-only replay; torn trailing lines are skipped). The
+        ``history.json`` file remains as the compat fallback for
+        sessions written before snapshots existed.
+        """
+        if not self.session_path:
+            return 0
+        try:
+            from dashscope.acli.session_events import (
+                EVENTS_FILENAME,
+                SessionEventLog,
+                latest_snapshot_messages,
+            )
+
+            log = SessionEventLog(self.session_path.parent / EVENTS_FILENAME)
+            resumed = latest_snapshot_messages(log.read_raw())
+            if resumed:
+                self.messages = resumed
+                return len(resumed)
+        except Exception:
+            pass
+        if not self.session_path.exists():
             return 0
         try:
             data = json.loads(self.session_path.read_text())
@@ -326,11 +349,25 @@ class Agent:
             experience_tracker=self.experience_tracker,
             disabled_caps_provider=self.disabled_caps_provider,
             directives_provider=self.directives_provider,
+            scene_provider=self._scene_section,
             current_turn_tools=self._current_turn_tools,
             connected_mcp_services=self._connected_mcp_services,
         )
         return self._prompt_pipeline.render(ctx)
 
+    def _scene_section(self) -> str:
+        """Scene memory of the current session topic (best-effort).
+
+        Subagents and SDK callers may run without a session manager;
+        any failure simply yields no scene section.
+        """
+        try:
+            from dashscope.acli.session import get_session_manager
+
+            return get_session_manager().get_scene()
+        except Exception:
+            return ""
+
     def _reflection_section(self) -> str:
         """Inject reflection hints when repeated failures detected."""
         tracker = self.memory_manager.session.reflection
@@ -524,9 +561,9 @@ class Agent:
             async for chunk in self.provider.chat_stream(
                 normalize_for_model(messages_with_system, self.model_name),
                 tools_schema,
-                response_format={"type": "json_object"}
-                if self.json_mode
-                else None,
+                response_format=(
+                    {"type": "json_object"} if self.json_mode else None
+                ),
             ):
                 if chunk.delta_content:
                     full_content += chunk.delta_content
@@ -765,6 +802,39 @@ class Agent:
             ),
         )
 
+        # Record the completed turn as events (session-as-event-log
+        # direction) BEFORE persisting history.json: the event stream is
+        # the source of truth, so it must never be older than the
+        # fallback store if we crash between the two writes. Best-effort:
+        # subagents/SDK callers may run without a session manager, and
+        # event recording must never break the loop.
+        try:
+            from dashscope.acli.session import get_session_manager
+
+            turn_topic = (
+                self.session_path.parent.name if self.session_path else None
+            )
+            get_session_manager().record_turn_event(
+                user_text=text_of(user_input),
+                assistant_text=last_content,
+                tools_used=self._current_turn_tools,
+                outcome=(
+                    _classify_outcome(
+                        self._turn_tool_successes,
+                        self._turn_tool_failures,
+                    )
+                    if self._current_turn_tools
+                    else ""
+                ),
+                topic=turn_topic,
+            )
+            get_session_manager().record_messages_snapshot(
+                self.messages,
+                topic=turn_topic,
+            )
+        except Exception:
+            pass
+
         # Persist session before memory write so a memory exception can't
         # cost us the conversation.
         self.save_session()

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/__init__.py

@@ -52,9 +52,7 @@ from dashscope.acli.cli.dispatch import (  # noqa: F401,E402
     _handle_slash_command,
     dispatch_async_command,
 )
-from dashscope.acli.cli.examples import (  # noqa: E402
-    _handle_example_command,
-)
+from dashscope.acli.cli.examples import _handle_example_command  # noqa: E402
 from dashscope.acli.cli.handlers_capability import (  # noqa: F401,E402
     _cap_enabled,
     sync_extensions_into_catalog,
@@ -62,9 +60,7 @@ from dashscope.acli.cli.handlers_capability import (  # noqa: F401,E402
 from dashscope.acli.cli.handlers_misc import (  # noqa: F401,E402
     _handle_report_command,
 )
-from dashscope.acli.cli.handlers_setup import (  # noqa: F401,E402
-    _handle_setup,
-)
+from dashscope.acli.cli.handlers_setup import _handle_setup  # noqa: F401,E402
 
 # Import MCP management from submodule
 from dashscope.acli.cli.mcp import (  # noqa: F401,E402

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/constants.py

@@ -186,6 +186,7 @@ _TOP_LEVEL_COMMANDS = [
     "/report",
     "/feedback",
     "/history",
+    "/undo",
     "/json",
     "/save",
     "/privacy",
@@ -224,11 +225,11 @@ _SUBCOMMANDS: dict[str, list[str]] = {
     "/rule": ["list", "add", "remove", "edit", "clear"],
     "/profile": ["list", "search", "add", "remove", "clear"],
     "/memory": ["list", "search", "remove", "clear"],
-    "/session": ["new", "list", "switch", "rename", "remove"],
+    "/session": ["new", "list", "switch", "rename", "fork", "remove"],
     "/mcp": ["list", "add", "remove"],
     "/cron": ["add", "list", "remove", "pause", "resume"],
     "/feedback": ["good", "bad"],
-    "/history": ["stats", "list", "export", "clear"],
+    "/history": ["stats", "list", "search", "export", "clear"],
     "/json": ["on", "off"],
     "/privacy": ["on", "off", "status"],
     "/audit": ["recent", "query", "clear"],

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/dispatch.py

@@ -403,6 +403,11 @@ def _handle_slash_command(
     elif cmd.startswith("/history"):
         _handle_history_command(cmd)
         return True
+    elif cmd == "/undo":
+        from dashscope.acli.tools.checkpoint import handle_undo_command
+
+        handle_undo_command()
+        return True
     elif cmd.startswith("/privacy"):
         _handle_privacy_command(cmd, config)
         return True

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/handlers_misc.py

@@ -1,10 +1,14 @@
 # -*- coding: utf-8 -*-
 """Miscellaneous command handlers (trust, history, report)."""
 # pylint: disable=protected-access,too-many-branches,too-many-statements
+# pylint: disable=too-many-return-statements
 
 from __future__ import annotations
 
+from typing import Any
+
 from rich.console import Console
+from rich.markup import escape
 
 from dashscope.acli.agent import Agent
 
@@ -77,6 +81,86 @@ def _handle_trust_command(cmd: str, agent: Agent) -> None:
     )
 
 
+def _message_text(msg: dict[str, Any]) -> str:
+    """Flatten a chat message's content into one-line plain text."""
+    content = msg.get("content", "")
+    if isinstance(content, list):
+        content = " ".join(
+            part.get("text", "") for part in content if isinstance(part, dict)
+        )
+    if not isinstance(content, str):
+        return ""
+    return " ".join(content.split())
+
+
+def _search_snippet(text: str, idx: int, kw_len: int) -> str:
+    """Build a short one-line snippet centered on a match position."""
+    start = max(0, idx - 20)
+    end = min(len(text), idx + kw_len + 40)
+    prefix = "..." if start > 0 else ""
+    suffix = "..." if end < len(text) else ""
+    return prefix + text[start:end] + suffix
+
+
+def _highlight_keyword(text: str, keyword: str) -> str:
+    """Wrap keyword occurrences in rich markup (case-insensitive)."""
+    lower_kw = keyword.lower()
+    if not lower_kw:
+        return escape(text)
+    lower_text = text.lower()
+    out: list[str] = []
+    pos = 0
+    while True:
+        idx = lower_text.find(lower_kw, pos)
+        if idx < 0:
+            out.append(escape(text[pos:]))
+            break
+        out.append(escape(text[pos:idx]))
+        out.append("[bold yellow]")
+        out.append(escape(text[idx : idx + len(keyword)]))
+        out.append("[/bold yellow]")
+        pos = idx + len(keyword)
+    return "".join(out)
+
+
+def _history_search_matches(
+    keyword: str,
+    limit: int = 20,
+) -> list[dict[str, str]]:
+    """Case-insensitive substring search across all session history.
+
+    Scans every stored session's messages and returns up to ``limit``
+    matches, each carrying the session topic, a timestamp, the message
+    role, and a one-line snippet with match context.
+    """
+    from dashscope.acli.session import get_session_manager
+
+    needle = keyword.lower()
+    if not needle or limit <= 0:
+        return []
+    mgr = get_session_manager()
+    matches: list[dict[str, str]] = []
+    for meta in mgr.list_topics():
+        if len(matches) >= limit:
+            break
+        for msg in mgr.load_messages(meta.topic):
+            text = _message_text(msg)
+            idx = text.lower().find(needle) if text else -1
+            if idx < 0:
+                continue
+            matches.append(
+                {
+                    "session": meta.topic,
+                    "timestamp": meta.last_accessed or "",
+                    "role": str(msg.get("role", "?")),
+                    "snippet": _search_snippet(text, idx, len(needle)),
+                },
+            )
+            if len(matches) >= limit:
+                break
+    return matches
+
+
 def _handle_history_command(cmd: str) -> None:
     """Manage conversation history."""
     from dashscope.acli.platforms.local.history import (
@@ -107,6 +191,8 @@ def _handle_history_command(cmd: str) -> None:
             "\n[dim]Usage:\n"
             "  /history stats                          — show stats\n"
             "  /history list [n]                       — list recent n\n"
+            "  /history search <keyword> [limit]       — full-text "
+            "search\n"
             "  /history export <file> [--format json|md|html]  — export\n"
             "  /history clear                           — clear "
             "history[/dim]",
@@ -147,6 +233,41 @@ def _handle_history_command(cmd: str) -> None:
                 )
         return
 
+    if sub == "search":
+        if len(parts) < 3:
+            console.print(
+                "[dim]Usage: /history search <keyword> [limit][/dim]",
+            )
+            return
+        keyword = parts[2]
+        limit = 20
+        if len(parts) >= 4:
+            try:
+                limit = int(parts[3])
+            except ValueError:
+                limit = 0
+        if limit <= 0:
+            console.print(
+                "[red]limit must be a positive integer[/red]",
+            )
+            return
+        matches = _history_search_matches(keyword, limit=limit)
+        if not matches:
+            console.print(f"[dim]No matches for '{keyword}'[/dim]")
+            return
+        header = f"[bold]{len(matches)} match(es) for '{keyword}':[/bold]"
+        console.print(header)
+        for i, m in enumerate(matches, 1):
+            ts = m["timestamp"][:16]
+            head = (
+                f"  {i}. [cyan]{m['session']}[/cyan] "
+                f"[dim]{ts}[/dim] [bold]{m['role']}[/bold]"
+            )
+            console.print(head)
+            snippet = _highlight_keyword(m["snippet"], keyword)
+            console.print(f"     {snippet}")
+        return
+
     if sub == "export" and len(parts) >= 3:
         output_path = parts[2]
         fmt = "html"
@@ -174,7 +295,8 @@ def _handle_history_command(cmd: str) -> None:
         console.print(f"[green]✓ Cleared {count} history records[/green]")
         return
 
-    console.print("[dim]Usage: /history [stats|list|export|clear][/dim]")
+    usage = "[dim]Usage: /history [stats|list|search|export|clear][/dim]"
+    console.print(usage)
 
 
 def _handle_report_command(agent: Agent) -> None:

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/handlers_session.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Session management command handlers."""
 # pylint: disable=too-many-branches,too-many-statements,unused-argument
+# pylint: disable=too-many-return-statements
 
 from __future__ import annotations
 
@@ -8,6 +9,23 @@ from rich.console import Console
 
 console = Console()
 
+_SESSION_USAGE = (
+    "\n[dim]Usage:\n"
+    "  /session              — show current topic\n"
+    "  /session new [name]   — new session (default: default)\n"
+    "  /session list         — list all sessions\n"
+    "  /session switch <n>   — switch to a topic\n"
+    "  /session rename <old> <new> — rename\n"
+    "  /session fork <new> [src] — fork a session (default src: "
+    "current)\n"
+    "  /session remove <n>   — remove session "
+    "(default cannot be removed)\n"
+    "  /session scene        — show scene memory of the current topic\n"
+    "  /session scene <text> — append a note to scene memory\n"
+    "  /session scene set <text> — replace scene memory\n"
+    "  /session scene clear  — clear scene memory[/dim]"
+)
+
 
 def _handle_session_command(cmd: str, config, agent) -> None:
     """Handle /session commands for multi-topic session management."""
@@ -20,16 +38,7 @@ def _handle_session_command(cmd: str, config, agent) -> None:
         # Show current topic
         current = session_mgr.get_current_topic()
         console.print(f"[bold]Current session[/bold]: {current}")
-        console.print(
-            "\n[dim]Usage:\n"
-            "  /session              — show current topic\n"
-            "  /session new [name]   — new session (default: default)\n"
-            "  /session list         — list all sessions\n"
-            "  /session switch <n>   — switch to a topic\n"
-            "  /session rename <old> <new> — rename\n"
-            "  /session remove <n>   — remove session "
-            "(default cannot be removed)[/dim]",
-        )
+        console.print(_SESSION_USAGE)
         return
 
     subcmd = parts[1]
@@ -122,6 +131,35 @@ def _handle_session_command(cmd: str, config, agent) -> None:
                 f"or '{new_name}' already exists[/red]",
             )
 
+    elif subcmd == "fork":
+        if len(parts) < 3:
+            console.print(
+                "[dim]Usage: /session fork <new> [src][/dim]",
+            )
+            return
+        fork_args = parts[2].split(maxsplit=1)
+        dst = fork_args[0]
+        src = (
+            fork_args[1]
+            if len(fork_args) > 1
+            else (session_mgr.get_current_topic())
+        )
+        # Flush the live conversation when forking the active topic so
+        # the fork carries the latest messages.
+        if src == session_mgr.get_current_topic():
+            if agent.session_path and agent.messages:
+                agent.save_session()
+        if session_mgr.fork_topic(src, dst):
+            console.print(
+                f"[green]Forked session: {src} → {dst}[/green]\n"
+                f"  [dim]Switch with: /session switch {dst}[/dim]",
+            )
+        else:
+            console.print(
+                f"[red]Fork failed: '{src}' does not exist "
+                f"or '{dst}' already exists[/red]",
+            )
+
     elif subcmd == "remove":
         topic = parts[2] if len(parts) > 2 else ""
         if not topic:
@@ -137,14 +175,39 @@ def _handle_session_command(cmd: str, config, agent) -> None:
         else:
             console.print(f"[red]Session '{topic}' does not exist[/red]")
 
+    elif subcmd == "scene":
+        topic = session_mgr.get_current_topic()
+        rest = parts[2].strip() if len(parts) > 2 else ""
+        if not rest:
+            text = session_mgr.get_scene()
+            if text:
+                console.print(
+                    f"[bold]Scene memory[/bold] [dim]({topic})[/dim]:",
+                )
+                console.print(text)
+            else:
+                console.print(
+                    f"[dim]No scene memory for '{topic}' yet. Add one "
+                    f"with: /session scene <text>[/dim]",
+                )
+        elif rest == "clear":
+            session_mgr.set_scene("")
+            console.print(f"[green]Scene memory cleared ({topic})[/green]")
+        elif rest.startswith("set "):
+            text = rest[len("set ") :].strip()
+            if session_mgr.set_scene(text):
+                console.print(
+                    f"[green]Scene memory replaced ({topic})[/green]",
+                )
+            else:
+                console.print("[red]Failed to write scene memory[/red]")
+        else:
+            if session_mgr.append_scene(rest):
+                console.print(
+                    f"[green]Scene note appended ({topic})[/green]",
+                )
+            else:
+                console.print("[red]Failed to write scene memory[/red]")
+
     else:
-        console.print(
-            "[dim]Usage:\n"
-            "  /session              — show current topic\n"
-            "  /session new [name]   — new session (default: default)\n"
-            "  /session list         — list all sessions\n"
-            "  /session switch <n>   — switch to a topic\n"
-            "  /session rename <old> <new> — rename\n"
-            "  /session remove <n>   — remove session "
-            "(default cannot be removed)[/dim]",
-        )
+        console.print(_SESSION_USAGE)

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/mcp.py

@@ -7,6 +7,7 @@ from rich.console import Console
 from rich.status import Status
 
 from dashscope.acli.config import Config, MCPServerConfig
+from dashscope.acli.mcp_stdio import StdioMCPClient
 from dashscope.acli.platforms.bailian import MCPClient, MCPError
 from dashscope.acli.skills import list_known_services
 from dashscope.acli.tools.registry import registry
@@ -14,22 +15,34 @@ from dashscope.acli.tools.registry import registry
 console = Console()
 
 # Active MCP clients - shared state
-_mcp_clients: dict[str, MCPClient] = {}
+_mcp_clients: dict[str, MCPClient | StdioMCPClient] = {}
 
 
-async def _connect_mcp(service: str, config: Config, url: str = "") -> str:
+async def _connect_mcp(
+    service: str,
+    config: Config,
+    url: str = "",
+    server: MCPServerConfig | None = None,
+) -> str:
     """Connect to an MCP service and register its tools.
 
     Returns empty string on success, error message on failure."""
     if service in _mcp_clients:
         return ""
 
+    use_stdio = bool(server) and (
+        (server.transport or "").lower() == "stdio" or bool(server.command)
+    )
     try:
-        client = MCPClient(
-            service=service,
-            api_key=config.tongyi_api_key,
-            url=url,
-        )
+        client: MCPClient | StdioMCPClient
+        if use_stdio:
+            client = StdioMCPClient(server.command, server.args)
+        else:
+            client = MCPClient(
+                service=service,
+                api_key=config.tongyi_api_key,
+                url=url,
+            )
     except MCPError as e:
         return str(e)
 
@@ -136,14 +149,21 @@ async def _handle_mcp_command(cmd: str, config: Config):
             "  /mcp              — list connected services\n"
             "  /mcp list         — show Bailian available services\n"
             "  /mcp add <svc>    — add an MCP service\n"
-            "  /mcp remove <svc> — remove an MCP service[/dim]",
+            "  /mcp remove <svc> — remove an MCP service\n"
+            "Stdio servers: add [[mcp_servers]] in config.toml with "
+            'transport = "stdio", command and args[/dim]',
         )
 
 
 async def _init_mcp_servers(config: Config):
     """Connect to configured MCP servers on startup."""
     for mcp_cfg in config.mcp_servers:
-        error = await _connect_mcp(mcp_cfg.service, config, url=mcp_cfg.url)
+        error = await _connect_mcp(
+            mcp_cfg.service,
+            config,
+            url=mcp_cfg.url,
+            server=mcp_cfg,
+        )
         if not error:
             client = _mcp_clients[mcp_cfg.service]
             summary = f"{len(client.tools)} tools"

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/cli/startup.py

@@ -7,7 +7,7 @@ from rich.console import Console
 
 from dashscope.acli import __version__
 from dashscope.acli.cli.constants import ALL_CAPABILITY_KEYS
-from dashscope.acli.config import WORKSPACE_DIR, Config
+from dashscope.acli.config import Config
 from dashscope.acli.tools.registry import registry
 from dashscope.acli.utils import mask_secret
 
@@ -21,7 +21,8 @@ def _load_system_prompt() -> str | None:
     are discovered separately by Agent.__init__ and passed to the prompt
     pipeline for proper stable/ephemeral separation.
     """
-    from dashscope.acli.config import CONFIG_DIR
+    # Imported at call time so tests can patch acli.config.WORKSPACE_DIR.
+    from dashscope.acli.config import CONFIG_DIR, WORKSPACE_DIR
 
     base: str | None = None
     for d in (WORKSPACE_DIR, CONFIG_DIR):
@@ -50,7 +51,7 @@ def _load_references() -> str | None:
     Unlike skills (invoked on demand), references are knowledge docs that must
     always be in the system prompt — e.g. generated SDK API indexes.
     """
-    from dashscope.acli.config import CONFIG_DIR
+    from dashscope.acli.config import CONFIG_DIR, WORKSPACE_DIR
 
     parts: dict[str, str] = {}
     for d in (CONFIG_DIR, WORKSPACE_DIR):
@@ -82,7 +83,9 @@ def _compose_system_prompt(base: str | None) -> str | None:
     return f"{base}\n\n---\n\n{section}" if base else section
 
 
-def _print_banner(config: Config | None = None):
+def _print_banner(config: Config | None = None) -> None:
+    from dashscope.acli.config import WORKSPACE_DIR
+
     logo = (
         "     _                    _   _       ____ _     ___\n"
         "    / \\   __ _  ___ _ __ | |_(_) ___ / ___| |   |_ _|\n"

{dashscope-1.27.0 → dashscope-1.27.2}/dashscope/acli/commands.py

@@ -38,7 +38,11 @@ HELP_SECTIONS: list[tuple[str, list[tuple[str, str]]]] = [
                 "JSON output mode (replies forced to JSON when on)",
             ),
             ("/compress", "Compress context (LLM summary replaces history)"),
-            ("/history", "Conversation history (stats/list/export/clear)"),
+            (
+                "/history",
+                "Conversation history (stats/list/search/export/clear)",
+            ),
+            ("/undo", "Undo the last file write/delete (checkpoint)"),
             (
                 "/feedback good|bad",
                 "Rate task satisfaction (stored in experience memory)",
@@ -106,7 +110,10 @@ HELP_SECTIONS: list[tuple[str, list[tuple[str, str]]]] = [
         [
             ("/profile", "User profile (list/search/add/remove/clear)"),
             ("/memory", "Chat history (list/search/remove <id|num>/clear)"),
-            ("/session", "Session management (new/list/switch/rename/remove)"),
+            (
+                "/session",
+                "Sessions (new/list/switch/rename/fork/remove/scene)",
+            ),
             (
                 "/summarize",
                 "Summarize the current task; record key steps and lessons",