illusion-code 0.1.0__py3-none-any.whl

illusion/commands/registry.py

@@ -0,0 +1,1934 @@
+"""
+斜杠命令注册模块
+==============
+
+本模块提供 IllusionCode 斜杠命令的注册和管理功能。
+
+主要功能：
+    - 注册和管理斜杠命令 (/xxx)
+    - 解析命令参数
+    - 提供内置命令处理器
+
+类说明：
+    - CommandResult: 命令执行结果
+    - CommandContext: 命令执行上下文
+    - SlashCommand: 斜杠命令定义
+    - CommandRegistry: 命令注册表
+
+函数说明：
+    - create_default_command_registry: 创建默认命令注册表
+
+内置命令列表：
+    - /exit, /clear, /version, /status, /context, /summary
+    - /compact, /memory, /hooks, /resume
+    - /export, /share, /copy, /rewind, /files
+    - /init, /bridge, /login, /logout, /feedback
+    - /skills, /config, /mcp, /plugin, /reload-plugins
+    - /permissions, /plan, /thinking, /fast, /effort, /passes, /turns
+    - /continue, /model, /language, /output-style
+    - /doctor, /diff, /branch, /commit
+    - /issue, /pr_comments, /privacy-settings
+    - /delete, /rules
+
+使用示例：
+    >>> from illusion.commands import create_default_command_registry
+    >>> registry = create_default_command_registry()
+    >>> result = registry.lookup("/version")
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import subprocess
+import sys
+
+from illusion.config.i18n import (
+    COMMAND_DESCRIPTIONS_ZH,
+    _is_zh,
+    translate_command_message,
+)
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TYPE_CHECKING, Awaitable, Callable, Literal, get_args
+
+import pyperclip
+
+from illusion.config.paths import (
+    get_config_dir,
+    get_data_dir,
+    get_feedback_log_path,
+    get_project_config_dir,
+    get_project_issue_file,
+    get_project_pr_comments_file,
+)
+from illusion.bridge import get_bridge_manager
+from illusion.bridge.types import WorkSecret
+from illusion.bridge.work_secret import build_sdk_url, decode_work_secret, encode_work_secret
+from illusion.api.provider import auth_status, detect_provider
+from illusion.config.settings import Settings, load_settings, save_settings
+from illusion.engine.messages import ConversationMessage
+from illusion.engine.query_engine import QueryEngine
+from illusion.memory import (
+    add_memory_entry,
+    get_memory_entrypoint,
+    get_project_memory_dir,
+    list_memory_files,
+    remove_memory_entry,
+)
+from illusion.output_styles import load_output_styles
+from illusion.permissions import PermissionChecker, PermissionMode
+from illusion.plugins import load_plugins
+from illusion.prompts import build_runtime_system_prompt
+from illusion.plugins.installer import install_plugin_from_path, uninstall_plugin
+from illusion.services import (
+    estimate_conversation_tokens,
+    export_session_markdown,
+    save_session_snapshot,
+    summarize_messages,
+)
+from illusion.services.session_storage import get_project_session_dir, load_session_snapshot
+from illusion.services.file_history import rewind_to
+from illusion.skills import load_skill_registry
+
+if TYPE_CHECKING:
+    from illusion.state import AppStateStore
+    from illusion.tools.base import ToolRegistry
+
+
+@dataclass
+class CommandResult:
+    """斜杠命令执行结果
+    
+    Attributes:
+        message: 返回给用户的消息
+        should_exit: 是否应该退出程序
+        clear_screen: 是否应该清除屏幕
+        replay_messages: 要在TUI中重放的消息列表
+        continue_pending: 是否继续待处理的工具循环
+        continue_turns: 继续的回合数
+    """
+
+    message: str | None = None  # 返回消息
+    should_exit: bool = False  # 退出标志
+    clear_screen: bool = False  # 清屏标志
+    replay_messages: list | None = None  # ConversationMessage列表用于TUI重放
+    needs_api_rebuild: bool = False  # 需要重建 API 客户端（跨 env 切换模型时）
+    continue_pending: bool = False  # 继续待处理标志
+    continue_turns: int | None = None  # 继续回合数
+    reset_session: bool = False  # 是否重置会话ID
+    restored_session_id: str | None = None  # 恢复的会话ID
+
+
+def _resolve_ui_language(context: "CommandContext | None") -> str:
+    if context is not None and context.app_state is not None:
+        value = str(context.app_state.get().ui_language or "")
+        if value:
+            return value
+    return str(load_settings().ui_language)
+
+
+
+
+def _translate_command_message(message: str, *, locale: str) -> str:
+    """翻译命令消息（委托给 i18n 模块）"""
+    return translate_command_message(message, locale=locale)
+
+
+@dataclass
+class CommandContext:
+    """命令处理器可用的上下文
+    
+    Attributes:
+        engine: 查询引擎实例
+        hooks_summary: hooks摘要
+        mcp_summary: MCP摘要
+        plugin_summary: 插件摘要
+        cwd: 当前工作目录
+        tool_registry: 工具注册表
+        app_state: 应用状态存储
+    """
+
+    engine: QueryEngine  # 查询引擎
+    hooks_summary: str = ""  # hooks摘要
+    mcp_summary: str = ""  # MCP摘要
+    plugin_summary: str = ""  # 插件摘要
+    cwd: str = "."  # 当前工作目录
+    tool_registry: ToolRegistry | None = None  # 工具注册表
+    app_state: AppStateStore | None = None  # 应用状态
+    session_id: str = ""  # 当前会话ID
+
+
+# 命令处理器类型别名
+CommandHandler = Callable[[str, CommandContext], Awaitable[CommandResult]]
+
+
+@dataclass
+class SlashCommand:
+    """斜杠命令定义
+    
+    Attributes:
+        name: 命令名称 (不含前导/)
+        description: 命令描述
+        handler: 命令处理器函数
+    """
+
+    name: str  # 命令名称
+    description: str  # 命令描述
+    handler: CommandHandler  # 处理器函数
+
+
+class CommandRegistry:
+    """斜杠命令到处理器的映射容器
+    
+    Attributes:
+        _commands: 命令名到SlashCommand的映射
+    """
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommand] = {}  # 命令映射初始化
+
+    def register(self, command: SlashCommand) -> None:
+        """注册命令
+        
+        Args:
+            command: 要注册的SlashCommand
+        """
+        original_handler = command.handler
+
+        async def _localized_handler(args: str, context: CommandContext) -> CommandResult:
+            result = await original_handler(args, context)
+            if result.message:
+                result.message = _translate_command_message(
+                    result.message,
+                    locale=_resolve_ui_language(context),
+                )
+            return result
+
+        self._commands[command.name] = SlashCommand(
+            name=command.name,
+            description=command.description,
+            handler=_localized_handler,
+        )
+
+    def lookup(self, raw_input: str) -> tuple[SlashCommand, str] | None:
+        """解析斜杠命令并返回其处理器和原始参数
+        
+        Args:
+            raw_input: 原始输入字符串
+        
+        Returns:
+            tuple[SlashCommand, str] | None: (命令对象, 参数) 或 None
+        """
+        if not raw_input.startswith("/"):  # 不是斜杠命令
+            return None
+        name, _, args = raw_input[1:].partition(" ")  # 分割名称和参数
+        command = self._commands.get(name)  # 查找命令
+        if command is None:  # 未找到
+            return None
+        return command, args.strip()  # 返回命令和参数
+
+    def help_text(self) -> str:
+        """返回所有已注册命令的格式化摘要
+        
+        Returns:
+            str: 格式化的命令帮助文本
+        """
+        locale = _resolve_ui_language(None)
+        lines = ["可用命令：" if _is_zh(locale) else "Available commands:"]  # 标题
+        for command in sorted(self._commands.values(), key=lambda item: item.name):  # 遍历命令
+            description = command.description
+            if _is_zh(locale):
+                description = COMMAND_DESCRIPTIONS_ZH.get(command.name, description)
+            lines.append(f"/{command.name:<12} {description}")  # 格式化输出
+        return "\n".join(lines)
+
+    def list_commands(self) -> list[SlashCommand]:
+        """按照注册顺序返回命令列表
+        
+        Returns:
+            list[SlashCommand]: 命令列表
+        """
+        return list(self._commands.values())
+
+
+def _run_git_command(cwd: str, *args: str) -> tuple[bool, str]:
+    """执行git命令并返回结果
+    
+    Args:
+        cwd: 工作目录
+        args: git子命令和参数
+    
+    Returns:
+        tuple[bool, str]: (是否成功, 输出内容)
+    """
+    try:
+        run_kwargs: dict = {}
+        if sys.platform == "win32":
+            run_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+        completed = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=False,
+            stdin=subprocess.DEVNULL,
+            **run_kwargs,
+        )
+    except FileNotFoundError:  # git未安装
+        return False, "git is not installed."
+    output = (completed.stdout or completed.stderr).strip()  # 合并输出
+    if completed.returncode != 0:  # 失败
+        return False, output or f"git {' '.join(args)} failed"
+    return True, output  # 成功
+
+
+def _copy_to_clipboard(text: str) -> tuple[bool, str]:
+    """复制文本到剪贴板
+    
+    尝试多种复制方式: pyperclip, pbcopy, wl-copy, xclip, xsel
+    
+    Args:
+        text: 要复制的文本
+    
+    Returns:
+        tuple[bool, str]: (是否成功, 目标位置)
+    """
+    try:
+        pyperclip.copy(text)
+        return True, "clipboard"
+    except Exception:
+        clip_kwargs: dict = {}
+        if sys.platform == "win32":
+            clip_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+        for command in (["pbcopy"], ["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard"]):
+            try:
+                subprocess.run(command, input=text, text=True, check=True, capture_output=True, **clip_kwargs)
+                return True, "clipboard"
+            except Exception:
+                continue
+    fallback = get_data_dir() / "last_copy.txt"  # 后备方案：文件
+    fallback.write_text(text, encoding="utf-8")
+    return False, str(fallback)
+
+
+def _last_message_text(messages: list[ConversationMessage]) -> str:
+    """获取最后一条有内容的用户消息
+    
+    Args:
+        messages: 消息列表
+    
+    Returns:
+        str: 消息文本，空字符串若无
+    """
+    for message in reversed(messages):  # 反向遍历
+        if message.text.strip():  # 有内容
+            return message.text.strip()
+    return ""
+
+
+def _rewind_turns(messages: list[ConversationMessage], turns: int) -> list[ConversationMessage]:
+    """回退指定数量的对话回合
+    
+    回退到上一个非空的、非斜杠命令的 user 消息
+    
+    Args:
+        messages: 消息列表
+        turns: 回退回合数
+    
+    Returns:
+        list[ConversationMessage]: 回退后的消息列表
+    """
+    updated = list(messages)
+    for _ in range(max(0, turns)):
+        if not updated:
+            break
+        while updated:
+            popped = updated.pop()
+            if popped.role == "user" and popped.text.strip() and not popped.text.strip().startswith("/"):
+                break
+    return updated
+
+
+def _coerce_setting_value(settings: Settings, key: str, raw: str):
+    """将字符串值强制转换为设置字段的正确类型
+    
+    Args:
+        settings: 设置对象
+        key: 字段名
+        raw: 原始字符串值
+    
+    Returns:
+        转换后的值
+    
+    Raises:
+        KeyError: 字段不存在
+        ValueError: 值无效
+    """
+    field = Settings.model_fields.get(key)  # 获取字段定义
+    if field is None:  # 不存在
+        raise KeyError(key)
+    annotation = field.annotation  # 类型注解
+    if annotation is bool:  # 布尔类型
+        lowered = raw.lower()
+        if lowered in {"1", "true", "yes", "on"}:  # 真值
+            return True
+        if lowered in {"0", "false", "no", "off"}:  # 假值
+            return False
+        raise ValueError(f"Invalid boolean value for {key}: {raw}")
+    if annotation is int:  # 整数类型
+        return int(raw)
+    if annotation is str:  # 字符串类型
+        return raw
+    if annotation is Literal or getattr(annotation, "__origin__", None) is Literal:  # 字面量类型
+        allowed = get_args(annotation)
+        if raw not in allowed:  # 不在允许值中
+            raise ValueError(f"Invalid value for {key}: {raw}")
+        return raw
+    return raw
+
+
+def _explore_codebase(root: Path) -> dict[str, Any]:
+    """探索代码库结构，识别项目类型和工具链
+    
+    Args:
+        root: 项目根目录
+        
+    Returns:
+        包含项目信息的字典
+    """
+    findings: dict[str, Any] = {
+        "languages": [],
+        "frameworks": [],
+        "package_manager": None,
+        "build_commands": [],
+        "test_commands": [],
+        "lint_commands": [],
+        "format_commands": [],
+        "existing_configs": [],
+        "ci_config": None,
+        "has_gitignore": False,
+        "readme_summary": None,
+    }
+    
+    # 扫描文件结构
+    try:
+        all_files = [
+            p for p in root.rglob("*")
+            if p.is_file()
+            and ".git" not in p.parts
+            and ".venv" not in p.parts
+            and "node_modules" not in p.parts
+            and "__pycache__" not in p.parts
+        ]
+    except Exception:
+        all_files = []
+    
+    # 检测语言
+    lang_indicators = {
+        ".py": "Python",
+        ".js": "JavaScript",
+        ".ts": "TypeScript",
+        ".jsx": "React",
+        ".tsx": "React",
+        ".java": "Java",
+        ".go": "Go",
+        ".rs": "Rust",
+        ".rb": "Ruby",
+        ".php": "PHP",
+        ".cs": "C#",
+        ".cpp": "C++",
+        ".c": "C",
+        ".swift": "Swift",
+        ".kt": "Kotlin",
+    }
+    
+    detected_langs = set()
+    for f in all_files:
+        if f.suffix in lang_indicators:
+            detected_langs.add(lang_indicators[f.suffix])
+    findings["languages"] = sorted(detected_langs)
+    
+    # 检测框架和语言指示文件
+    framework_indicators = {
+        "package.json": None,
+        "requirements.txt": "Python",
+        "pyproject.toml": "Python",
+        "setup.py": "Python",
+        "Cargo.toml": "Rust",
+        "go.mod": "Go",
+        "pom.xml": "Java",
+        "build.gradle": "Java",
+        "Gemfile": "Ruby",
+        "composer.json": "PHP",
+    }
+    
+    for indicator, lang in framework_indicators.items():
+        if (root / indicator).exists():
+            if lang and lang not in findings["languages"]:
+                findings["languages"].append(lang)
+    
+    # 检测配置文件关联的语言
+    config_lang_indicators = {
+        "tsconfig.json": "TypeScript",
+        "jsconfig.json": "JavaScript",
+        "webpack.config.js": "JavaScript",
+        "vite.config.ts": "TypeScript",
+        "vite.config.js": "JavaScript",
+        "next.config.js": "Next.js",
+        "nuxt.config.js": "Nuxt",
+        "angular.json": "Angular",
+        "vue.config.js": "Vue",
+        "svelte.config.js": "Svelte",
+    }
+    
+    for config_file, lang in config_lang_indicators.items():
+        if (root / config_file).exists():
+            if lang not in findings["languages"] and lang not in ["Next.js", "Nuxt", "Angular", "Vue", "Svelte"]:
+                findings["languages"].append(lang)
+            elif lang in ["Next.js", "Nuxt", "Angular", "Vue", "Svelte"] and lang not in findings["frameworks"]:
+                findings["frameworks"].append(lang)
+    
+    # 检测包管理器
+    if (root / "package.json").exists():
+        if (root / "yarn.lock").exists():
+            findings["package_manager"] = "yarn"
+        elif (root / "pnpm-lock.yaml").exists():
+            findings["package_manager"] = "pnpm"
+        else:
+            findings["package_manager"] = "npm"
+    elif (root / "requirements.txt").exists() or (root / "pyproject.toml").exists():
+        findings["package_manager"] = "pip"
+    elif (root / "Cargo.toml").exists():
+        findings["package_manager"] = "cargo"
+    elif (root / "go.mod").exists():
+        findings["package_manager"] = "go"
+    
+    # 读取 package.json 获取脚本
+    package_json = root / "package.json"
+    if package_json.exists():
+        try:
+            with open(package_json, encoding="utf-8") as f:
+                data = json.load(f)
+                scripts = data.get("scripts", {})
+                if "build" in scripts:
+                    findings["build_commands"].append("npm run build")
+                if "test" in scripts:
+                    findings["test_commands"].append("npm test")
+                if "lint" in scripts:
+                    findings["lint_commands"].append("npm run lint")
+                if "dev" in scripts:
+                    findings["build_commands"].append("npm run dev")
+                if "format" in scripts:
+                    findings["format_commands"].append("npm run format")
+        except Exception:
+            pass
+    
+    # 读取 pyproject.toml 获取命令
+    pyproject = root / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            import tomllib
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+                scripts = data.get("tool", {}).get("poetry", {}).get("scripts", {})
+                if scripts:
+                    findings["build_commands"].append("poetry run <script>")
+                # 检测 ruff/black 格式化配置
+                if "tool" in data:
+                    if "ruff" in data["tool"]:
+                        findings["format_commands"].append("ruff format")
+                        if "lint" not in findings["lint_commands"]:
+                            findings["lint_commands"].append("ruff check")
+                    if "black" in data["tool"]:
+                        findings["format_commands"].append("black")
+        except Exception:
+            pass
+    
+    # 检测 Makefile
+    makefile = root / "Makefile"
+    if makefile.exists():
+        try:
+            content = makefile.read_text(encoding="utf-8")
+            if "build:" in content:
+                findings["build_commands"].append("make build")
+            if "test:" in content:
+                findings["test_commands"].append("make test")
+            if "lint:" in content:
+                findings["lint_commands"].append("make lint")
+            if "fmt:" in content or "format:" in content:
+                findings["format_commands"].append("make fmt")
+        except Exception:
+            pass
+    
+    # 检测格式化工具配置
+    format_configs = {
+        ".prettierrc": "prettier",
+        ".prettierrc.json": "prettier",
+        ".prettierrc.js": "prettier",
+        "prettier.config.js": "prettier",
+        "biome.json": "biome",
+        ".eslintrc": "eslint",
+        ".eslintrc.json": "eslint",
+        ".eslintrc.js": "eslint",
+        "eslint.config.js": "eslint",
+        ".golangci.yml": "golangci-lint",
+        ".golangci.yaml": "golangci-lint",
+        "rustfmt.toml": "rustfmt",
+        ".rustfmt.toml": "rustfmt",
+    }
+    
+    for config_file, tool_name in format_configs.items():
+        if (root / config_file).exists():
+            if tool_name not in findings["format_commands"]:
+                findings["format_commands"].append(tool_name)
+    
+    # 检测 CI 配置
+    ci_configs = {
+        ".github/workflows": "GitHub Actions",
+        ".gitlab-ci.yml": "GitLab CI",
+        "Jenkinsfile": "Jenkins",
+        ".circleci/config.yml": "CircleCI",
+        ".travis.yml": "Travis CI",
+    }
+    
+    for ci_path, ci_name in ci_configs.items():
+        if (root / ci_path).exists():
+            findings["ci_config"] = ci_name
+            break
+    
+    # 检测 .gitignore
+    findings["has_gitignore"] = (root / ".gitignore").exists()
+    
+    # 检测现有 AI 配置
+    ai_configs = [
+        ".cursor/rules",
+        ".cursorrules",
+        ".github/copilot-instructions.md",
+        ".windsurfrules",
+        ".clinerules",
+        "AGENTS.md",
+        "CLAUDE.md",
+        "ILLUSION.md",
+    ]
+    for config in ai_configs:
+        if (root / config).exists():
+            findings["existing_configs"].append(config)
+    
+    # 检测常用框架
+    if (root / "package.json").exists():
+        try:
+            with open(root / "package.json", encoding="utf-8") as f:
+                data = json.load(f)
+                deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                if "react" in deps:
+                    findings["frameworks"].append("React")
+                if "vue" in deps:
+                    findings["frameworks"].append("Vue")
+                if "svelte" in deps:
+                    findings["frameworks"].append("Svelte")
+                if "next" in deps:
+                    findings["frameworks"].append("Next.js")
+                if "nuxt" in deps:
+                    findings["frameworks"].append("Nuxt")
+                if "express" in deps:
+                    findings["frameworks"].append("Express")
+                if "fastapi" in deps:
+                    findings["frameworks"].append("FastAPI")
+                if "django" in deps:
+                    findings["frameworks"].append("Django")
+                if "flask" in deps:
+                    findings["frameworks"].append("Flask")
+                if "angular" in deps or "@angular/core" in deps:
+                    findings["frameworks"].append("Angular")
+        except Exception:
+            pass
+    
+    # 提取 README 摘要
+    readme = root / "README.md"
+    if readme.exists():
+        try:
+            content = readme.read_text(encoding="utf-8")
+            # 提取前几行作为项目描述，跳过 HTML 和图片
+            desc_lines = []
+            in_code_block = False
+            in_html_block = False
+            for line in content.split("\n")[:50]:
+                stripped = line.strip()
+                # 跳过代码块
+                if stripped.startswith("```"):
+                    in_code_block = not in_code_block
+                    continue
+                if in_code_block:
+                    continue
+                # 跳过 HTML 块
+                if stripped.startswith("<") and not stripped.startswith("</"):
+                    if stripped.endswith(">") and "/" not in stripped:
+                        in_html_block = True
+                    continue
+                if in_html_block:
+                    if stripped.startswith("</") or stripped.endswith("/>"):
+                        in_html_block = False
+                    continue
+                # 跳过图片和空行
+                if stripped.startswith("![") or not stripped:
+                    continue
+                # 跳过标题行
+                if stripped.startswith("#"):
+                    continue
+                # 跳过 badge 和链接
+                if stripped.startswith("[") and "badges" in stripped.lower():
+                    continue
+                # 保留有意义的文本
+                if len(stripped) > 10:  # 过短的行通常是装饰
+                    desc_lines.append(stripped)
+                if len(desc_lines) >= 3:
+                    break
+            if desc_lines:
+                findings["readme_summary"] = " ".join(desc_lines)
+        except Exception:
+            pass
+    
+    return findings
+
+
+def _generate_claudemd(findings: dict[str, Any], root: Path) -> str:
+    """基于项目发现生成 CLAUDE.md 内容
+    
+    Args:
+        findings: 项目探索结果
+        root: 项目根目录
+        
+    Returns:
+        CLAUDE.md 内容
+    """
+    lines = [
+        "# CLAUDE.md",
+        "",
+        "This file provides guidance to Illusion Code when working with code in this repository.",
+        "",
+    ]
+    
+    # 项目概述
+    if findings.get("readme_summary"):
+        lines.append("## 项目概述")
+        lines.append(findings["readme_summary"])
+        lines.append("")
+    
+    # 技术栈
+    if findings["languages"] or findings["frameworks"] or findings["package_manager"]:
+        lines.append("## 技术栈")
+        if findings["languages"]:
+            lines.append(f"- 主要语言: {', '.join(findings['languages'])}")
+        if findings["frameworks"]:
+            lines.append(f"- 框架: {', '.join(findings['frameworks'])}")
+        if findings["package_manager"]:
+            lines.append(f"- 包管理器: {findings['package_manager']}")
+        if findings.get("ci_config"):
+            lines.append(f"- CI/CD: {findings['ci_config']}")
+        lines.append("")
+    
+    # 常用命令
+    has_commands = any([
+        findings["build_commands"],
+        findings["test_commands"],
+        findings["lint_commands"],
+        findings.get("format_commands")
+    ])
+    if has_commands:
+        lines.append("## 常用命令")
+        if findings["build_commands"]:
+            lines.append(f"- 构建: `{findings['build_commands'][0]}`")
+        if findings["test_commands"]:
+            lines.append(f"- 测试: `{findings['test_commands'][0]}`")
+        if findings["lint_commands"]:
+            lines.append(f"- 代码检查: `{findings['lint_commands'][0]}`")
+        if findings.get("format_commands"):
+            lines.append(f"- 格式化: `{findings['format_commands'][0]}`")
+        lines.append("")
+    
+    # 开发规范
+    lines.extend([
+        "## 开发规范",
+        "- 修改后请验证测试是否通过",
+        "- 保持代码变更最小化",
+    ])
+    
+    # 如果有格式化工具，添加格式化规范
+    if findings.get("format_commands"):
+        lines.append(f"- 代码格式化: 使用 `{findings['format_commands'][0]}`")
+    
+    lines.append("")
+    
+    # 如果有现有配置，提示用户
+    if findings["existing_configs"]:
+        lines.append("## 现有 AI 配置")
+        lines.append("检测到以下 AI 配置文件，内容可能需要合并：")
+        for config in findings["existing_configs"]:
+            lines.append(f"- `{config}`")
+        lines.append("")
+    
+    return "\n".join(lines)
+
+
+def create_default_command_registry() -> CommandRegistry:
+    """Create the built-in command registry."""
+    registry = CommandRegistry()
+
+    async def _exit_handler(_: str, context: CommandContext) -> CommandResult:
+        del context
+        return CommandResult(should_exit=True)
+
+    async def _new_handler(_: str, context: CommandContext) -> CommandResult:
+        if context.session_id and context.engine.messages:
+            settings = load_settings()
+            system_prompt = build_runtime_system_prompt(settings, cwd=context.cwd)
+            save_session_snapshot(
+                cwd=context.cwd,
+                model=settings.active_model_name,
+                system_prompt=system_prompt,
+                messages=context.engine.messages,
+                usage=context.engine.total_usage,
+                session_id=context.session_id,
+            )
+        context.engine.clear()
+        return CommandResult(
+            message="Started a new conversation session.",
+            clear_screen=True,
+            reset_session=True,
+        )
+
+    async def _status_handler(_: str, context: CommandContext) -> CommandResult:
+        usage = context.engine.total_usage
+        state = context.app_state.get() if context.app_state is not None else None
+        return CommandResult(
+            message=(
+                f"Messages: {len(context.engine.messages)}\n"
+                f"Usage: input={usage.input_tokens} output={usage.output_tokens}\n"
+                f"Effort: {state.effort if state is not None else load_settings().effort}\n"
+                f"Passes: {state.passes if state is not None else load_settings().passes}"
+            )
+        )
+
+    async def _version_handler(_: str, context: CommandContext) -> CommandResult:
+        del context
+        try:
+            version = importlib.metadata.version("illusion")
+        except importlib.metadata.PackageNotFoundError:
+            version = "0.1.0"
+        return CommandResult(message=f"IllusionCode {version}")
+
+    async def _context_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split(maxsplit=1)
+        subcommand = tokens[0] if tokens else "prompt"
+
+        if subcommand == "prompt":
+            prompt = build_runtime_system_prompt(settings, cwd=context.cwd)
+            return CommandResult(message=prompt)
+        if subcommand == "window" or subcommand == "show":
+            return CommandResult(message=f"Context window: {settings.context_window:,} tokens")
+        if subcommand == "__usage__":
+            from illusion.services.compact import estimate_conversation_tokens, get_context_window
+            estimated = estimate_conversation_tokens(context.engine.messages)
+            usage = context.engine.total_usage
+            context_window = get_context_window(settings.active_model_name)
+            percentage = int(estimated * 100 / context_window) if context_window > 0 else 0
+            remaining = max(0, context_window - estimated)
+            return CommandResult(
+                message=(
+                    f"Context Window: {context_window:,} tokens\n"
+                    f"Estimated Used: ~{estimated:,} tokens ({percentage}%)\n"
+                    f"Remaining: ~{remaining:,} tokens\n"
+                    f"Actual API Usage: input={usage.input_tokens:,} output={usage.output_tokens:,}\n"
+                    f"Messages: {len(context.engine.messages)}"
+                )
+            )
+        if subcommand == "set" and len(tokens) == 2:
+            try:
+                value = int(tokens[1])
+                if value <= 0:
+                    return CommandResult(message="Error: context window must be positive")
+                settings.context_window = value
+                save_settings(settings)
+                return CommandResult(message=f"Context window set to {value:,} tokens")
+            except ValueError:
+                return CommandResult(message="Error: invalid number")
+        return CommandResult(message="Usage: /context [prompt|window|set N]")
+
+    async def _summary_handler(args: str, context: CommandContext) -> CommandResult:
+        max_messages = 8
+        if args:
+            try:
+                max_messages = max(1, int(args))
+            except ValueError:
+                return CommandResult(message="Usage: /summary [MAX_MESSAGES]")
+        summary = summarize_messages(context.engine.messages, max_messages=max_messages)
+        return CommandResult(message=summary or "No conversation content to summarize.")
+
+    async def _compact_handler(args: str, context: CommandContext) -> CommandResult:
+        from illusion.services.compact import compact_conversation, compact_messages
+
+        # 解析参数：/compact [PRESERVE_RECENT] 或 /compact [custom instructions text]
+        preserve_recent = 6
+        custom_instructions: str | None = None
+
+        if args:
+            stripped = args.strip()
+            # 尝试解析为数字（preserve_recent）
+            try:
+                preserve_recent = max(1, int(stripped))
+            except ValueError:
+                # 非数字则视为自定义指令
+                custom_instructions = stripped
+
+        before = len(context.engine.messages)
+        before_tokens = estimate_conversation_tokens(context.engine.messages)
+
+        # 优先尝试 LLM 摘要；如果 API 客户端不可用则回退到传统方法
+        try:
+            settings = load_settings()
+            system_prompt = build_runtime_system_prompt(settings, cwd=context.cwd)
+            compacted = await compact_conversation(
+                context.engine.messages,
+                api_client=context.engine._api_client,
+                model=context.engine._model,
+                system_prompt=system_prompt,
+                preserve_recent=preserve_recent,
+                custom_instructions=custom_instructions,
+                suppress_follow_up=False,
+            )
+        except Exception as exc:
+            # LLM 摘要失败，回退到传统方法
+            import logging
+            logging.getLogger(__name__).warning("LLM compact failed, falling back to simple compact: %s", exc)
+            compacted = compact_messages(context.engine.messages, preserve_recent=preserve_recent)
+
+        context.engine.load_messages(compacted)
+        after_tokens = estimate_conversation_tokens(compacted)
+        saved = max(0, before_tokens - after_tokens)
+        from illusion.config.i18n import t
+        return CommandResult(
+            message=t("compact_result", before=before, after=len(compacted), saved=f"{saved:,}")
+        )
+
+    async def _memory_handler(args: str, context: CommandContext) -> CommandResult:
+        tokens = args.split(maxsplit=1)
+        if not tokens:
+            memory_dir = get_project_memory_dir(context.cwd)
+            entrypoint = get_memory_entrypoint(context.cwd)
+            return CommandResult(
+                message=f"Memory directory: {memory_dir}\nEntrypoint: {entrypoint}"
+            )
+        action = tokens[0]
+        rest = tokens[1] if len(tokens) == 2 else ""
+        if action == "list":
+            memory_files = list_memory_files(context.cwd)
+            if not memory_files:
+                return CommandResult(message="No memory files.")
+            return CommandResult(message="\n".join(path.name for path in memory_files))
+        if action == "show" and rest:
+            memory_dir = get_project_memory_dir(context.cwd)
+            path = memory_dir / rest
+            if not path.exists():
+                path = memory_dir / f"{rest}.md"
+            if not path.exists():
+                return CommandResult(message=f"Memory entry not found: {rest}")
+            return CommandResult(message=path.read_text(encoding="utf-8"))
+        if action == "add" and rest:
+            title, separator, content = rest.partition("::")
+            if not separator or not title.strip() or not content.strip():
+                return CommandResult(message="Usage: /memory add TITLE :: CONTENT")
+            path = add_memory_entry(context.cwd, title.strip(), content.strip())
+            return CommandResult(message=f"Added memory entry {path.name}")
+        if action == "remove" and rest:
+            if remove_memory_entry(context.cwd, rest.strip()):
+                return CommandResult(message=f"Removed memory entry {rest.strip()}")
+            return CommandResult(message=f"Memory entry not found: {rest.strip()}")
+        return CommandResult(message="Usage: /memory [list|show NAME|add TITLE :: CONTENT|remove NAME]")
+
+    async def _hooks_handler(_: str, context: CommandContext) -> CommandResult:
+        return CommandResult(message=context.hooks_summary or "No hooks configured.")
+
+    async def _resume_handler(args: str, context: CommandContext) -> CommandResult:
+        from illusion.services.session_storage import list_session_snapshots, load_session_by_id
+
+        tokens = args.strip().split()
+
+        # /resume <session_id> — load a specific session
+        if tokens:
+            sid = tokens[0]
+            snapshot = load_session_by_id(context.cwd, sid)
+            if snapshot is None:
+                return CommandResult(message=f"Session not found: {sid}")
+            messages = [
+                ConversationMessage.model_validate(item)
+                for item in snapshot.get("messages", [])
+            ]
+            context.engine.load_messages(messages)
+            summary = snapshot.get("summary", "")[:60]
+            return CommandResult(
+                message=f"Restored {len(messages)} messages from session {sid}"
+                + (f" ({summary})" if summary else ""),
+                replay_messages=messages,
+                restored_session_id=str(snapshot.get("session_id") or sid),
+            )
+
+        # /resume — list sessions (for the TUI to show a picker)
+        sessions = list_session_snapshots(context.cwd, limit=10)
+        if not sessions:
+            # Fall back to latest.json
+            snapshot = load_session_snapshot(context.cwd)
+            if snapshot is None:
+                return CommandResult(message="No saved sessions found for this project.")
+            messages = [
+                ConversationMessage.model_validate(item)
+                for item in snapshot.get("messages", [])
+            ]
+            context.engine.load_messages(messages)
+            return CommandResult(
+                message=f"Restored {len(messages)} messages from the latest session.",
+                replay_messages=messages,
+                restored_session_id=str(snapshot.get("session_id", "")),
+            )
+
+        # Format session list for display / picker
+        import time
+        lines = ["Saved sessions:"]
+        for s in sessions:
+            ts = time.strftime("%m/%d %H:%M", time.localtime(s["created_at"]))
+            summary = s["summary"][:50] or "(no summary)"
+            lines.append(f"  {s['session_id']}  {ts}  {s['message_count']}msg  {summary}")
+        lines.append("")
+        lines.append("Use /resume <session_id> to restore a specific session.")
+        return CommandResult(message="\n".join(lines))
+
+    async def _export_handler(_: str, context: CommandContext) -> CommandResult:
+        path = export_session_markdown(cwd=context.cwd, messages=context.engine.messages)
+        return CommandResult(message=f"Exported transcript to {path}")
+
+    async def _share_handler(_: str, context: CommandContext) -> CommandResult:
+        path = export_session_markdown(cwd=context.cwd, messages=context.engine.messages)
+        return CommandResult(message=f"Created shareable transcript snapshot at {path}")
+
+    async def _copy_handler(args: str, context: CommandContext) -> CommandResult:
+        text = args.strip() or _last_message_text(context.engine.messages)
+        if not text:
+            return CommandResult(message="Nothing to copy.")
+        copied, target = _copy_to_clipboard(text)
+        if copied:
+            return CommandResult(message=f"Copied {len(text)} characters to the clipboard.")
+        return CommandResult(message=f"Clipboard unavailable. Saved copied text to {target}")
+
+    async def _rewind_handler(args: str, context: CommandContext) -> CommandResult:
+        turns = 1
+        if args.strip():
+            try:
+                turns = max(1, int(args.strip()))
+            except ValueError:
+                return CommandResult(message="Usage: /rewind [TURNS]")
+        before = len(context.engine.messages)
+        updated = _rewind_turns(context.engine.messages, turns)
+        removed = before - len(updated)
+
+        # 文件回退：找到目标快照并恢复文件
+        reverted_count = 0
+        fh = context.engine.file_history
+        if fh is not None and fh.snapshots:
+            # 目标轮次索引 = 当前快照数 - 回退轮次数
+            target_turn = max(0, len(fh.snapshots) - turns)
+            reverted_files = rewind_to(fh, target_turn)
+            reverted_count = len(reverted_files)
+
+        # 硬删除：直接截断消息列表
+        context.engine.load_messages(updated)
+
+        # 构建反馈消息
+        lines = [f"Rewound {turns} turn(s); removed {removed} message(s)."]
+        if reverted_count > 0:
+            lines.append(f"Reverted {reverted_count} file(s).")
+
+        return CommandResult(
+            clear_screen=True,
+            replay_messages=list(updated),
+            message="\n".join(lines),
+        )
+
+    async def _files_handler(args: str, context: CommandContext) -> CommandResult:
+        raw = args.strip()
+        root = Path(context.cwd)
+        max_items = 30
+        tokens = raw.split(maxsplit=1)
+        if tokens and tokens[0] == "dirs":
+            dirs = [
+                path
+                for path in sorted(root.rglob("*"))
+                if path.is_dir() and ".git" not in path.parts and ".venv" not in path.parts
+            ]
+            lines = [str(path.relative_to(root)) for path in dirs[:max_items]]
+            if len(dirs) > max_items:
+                lines.append(f"... {len(dirs) - max_items} more")
+            return CommandResult(message="\n".join(lines) if lines else "(no directories)")
+        if tokens and tokens[0].isdigit():
+            max_items = max(1, min(int(tokens[0]), 200))
+            raw = tokens[1] if len(tokens) == 2 else ""
+        needle = raw.lower()
+        files = [
+            path
+            for path in sorted(root.rglob("*"))
+            if path.is_file() and ".git" not in path.parts and ".venv" not in path.parts
+        ]
+        if needle:
+            files = [path for path in files if needle in str(path.relative_to(root)).lower()]
+        lines = [str(path.relative_to(root)) for path in files[:max_items]]
+        if len(files) > max_items:
+            lines.append(f"... {len(files) - max_items} more")
+        return CommandResult(
+            message="\n".join(lines) if lines else "(no matching files)"
+        )
+
+    async def _init_handler(args: str, context: CommandContext) -> CommandResult:
+        """智能初始化项目配置
+        
+        流程：
+        1. 探索代码库结构
+        2. 识别项目类型和工具链
+        3. 生成有针对性的配置
+        """
+        del args
+        root = Path(context.cwd)
+        project_dir = get_project_config_dir(context.cwd)
+        created: list[str] = []
+        findings: dict[str, Any] = {}
+        
+        # Phase 1: 探索代码库
+        findings = _explore_codebase(root)
+        
+        # Phase 2: 生成 CLAUDE.md
+        claudemd = root / "CLAUDE.md"
+        if not claudemd.exists():
+            content = _generate_claudemd(findings, root)
+            claudemd.write_text(content, encoding="utf-8")
+            created.append("CLAUDE.md")
+        
+        # Phase 3: 创建项目配置目录
+        for relative, content in (
+            (
+                project_dir / "README.md",
+                "# Project IllusionCode Config\n\nThis directory stores project-specific IllusionCode state.\n",
+            ),
+            (
+                project_dir / "memory" / "MEMORY.md",
+                "# Project Memory\n\nAdd reusable project knowledge here.\n",
+            ),
+            (
+                project_dir / "plugins" / ".gitkeep",
+                "",
+            ),
+            (
+                project_dir / "skills" / ".gitkeep",
+                "",
+            ),
+        ):
+            relative.parent.mkdir(parents=True, exist_ok=True)
+            if not relative.exists():
+                relative.write_text(content, encoding="utf-8")
+                created.append(str(relative.relative_to(root)))
+        
+        # Phase 4: 生成报告
+        if not created:
+            return CommandResult(message="Project already initialized for IllusionCode.")
+        
+        report_lines = [
+            "✨ **Illusion Code 项目初始化完成**\n",
+            "## 已创建文件",
+            *[f"- {item}" for item in created],
+            "",
+            "## 项目分析",
+        ]
+        
+        if findings.get("languages"):
+            report_lines.append(f"- **检测到语言**: {', '.join(findings['languages'])}")
+        if findings.get("frameworks"):
+            report_lines.append(f"- **检测到框架**: {', '.join(findings['frameworks'])}")
+        if findings.get("package_manager"):
+            report_lines.append(f"- **包管理器**: {findings['package_manager']}")
+        if findings.get("build_commands"):
+            report_lines.append(f"- **构建命令**: {', '.join(findings['build_commands'])}")
+        if findings.get("test_commands"):
+            report_lines.append(f"- **测试命令**: {', '.join(findings['test_commands'])}")
+        if findings.get("lint_commands"):
+            report_lines.append(f"- **代码检查**: {', '.join(findings['lint_commands'])}")
+        if findings.get("format_commands"):
+            report_lines.append(f"- **格式化工具**: {', '.join(findings['format_commands'])}")
+        if findings.get("ci_config"):
+            report_lines.append(f"- **CI/CD**: {findings['ci_config']}")
+        
+        report_lines.extend([
+            "",
+            "## 下一步建议",
+            "- 查看 `CLAUDE.md` 了解项目配置",
+            "- 运行 `/memory` 管理项目记忆",
+            "- 运行 `/skills` 查看可用技能",
+            "- 根据需要调整 CLAUDE.md 中的配置",
+        ])
+        
+        return CommandResult(message="\n".join(report_lines))
+
+    async def _bridge_handler(args: str, context: CommandContext) -> CommandResult:
+        tokens = args.split()
+        if not tokens or tokens[0] == "show":
+            sessions = get_bridge_manager().list_sessions()
+            lines = [
+                "Bridge summary:",
+                "- backend host: available",
+                f"- cwd: {context.cwd}",
+                f"- sessions: {len(sessions)}",
+                "- utilities: encode, decode, sdk, spawn, list, output, stop",
+            ]
+            return CommandResult(message="\n".join(lines))
+        if tokens[0] == "encode" and len(tokens) == 3:
+            encoded = encode_work_secret(
+                WorkSecret(version=1, session_ingress_token=tokens[2], api_base_url=tokens[1])
+            )
+            return CommandResult(message=encoded)
+        if tokens[0] == "decode" and len(tokens) == 2:
+            secret = decode_work_secret(tokens[1])
+            return CommandResult(message=json.dumps(secret.__dict__, indent=2))
+        if tokens[0] == "sdk" and len(tokens) == 3:
+            return CommandResult(message=build_sdk_url(tokens[1], tokens[2]))
+        if tokens[0] == "spawn" and len(tokens) >= 2:
+            command = args[len("spawn ") :]
+            handle = await get_bridge_manager().spawn(
+                session_id=f"bridge-{datetime.now(timezone.utc).strftime('%H%M%S')}",
+                command=command,
+                cwd=context.cwd,
+            )
+            return CommandResult(
+                message=f"Spawned bridge session {handle.session_id} pid={handle.process.pid}"
+            )
+        if tokens[0] == "list":
+            sessions = get_bridge_manager().list_sessions()
+            if not sessions:
+                return CommandResult(message="No bridge sessions.")
+            return CommandResult(
+                message="\n".join(
+                    f"{item.session_id} [{item.status}] pid={item.pid} {item.command}"
+                    for item in sessions
+                )
+            )
+        if tokens[0] == "output" and len(tokens) == 2:
+            return CommandResult(message=get_bridge_manager().read_output(tokens[1]) or "(no output)")
+        if tokens[0] == "stop" and len(tokens) == 2:
+            try:
+                await get_bridge_manager().stop(tokens[1])
+            except ValueError as exc:
+                return CommandResult(message=str(exc))
+            return CommandResult(message=f"Stopped bridge session {tokens[1]}")
+        return CommandResult(
+            message="Usage: /bridge [show|encode API_BASE_URL TOKEN|decode SECRET|sdk API_BASE_URL SESSION_ID|spawn CMD|list|output SESSION_ID|stop SESSION_ID]"
+        )
+
+    async def _reload_plugins_handler(_: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        plugins = load_plugins(settings, context.cwd)
+        if not plugins:
+            return CommandResult(message="No plugins discovered.")
+        lines = ["Reloaded plugins:"]
+        for plugin in plugins:
+            state = "enabled" if plugin.enabled else "disabled"
+            lines.append(f"- {plugin.manifest.name} [{state}]")
+        return CommandResult(message="\n".join(lines))
+
+    async def _skills_handler(args: str, context: CommandContext) -> CommandResult:
+        skill_registry = load_skill_registry(context.cwd)
+        if args:
+            skill = skill_registry.get(args)
+            if skill is None:
+                return CommandResult(message=f"Skill not found: {args}")
+            return CommandResult(message=skill.content)
+        skills = skill_registry.list_skills()
+        if not skills:
+            return CommandResult(message="No skills available.")
+        lines = ["Available skills:"]
+        for skill in skills:
+            source = f" [{skill.source}]"
+            lines.append(f"- {skill.name}{source}: {skill.description}")
+        return CommandResult(message="\n".join(lines))
+
+    async def _config_handler(args: str, context: CommandContext) -> CommandResult:
+        del context
+        settings = load_settings()
+        tokens = args.split(maxsplit=2)
+        if not tokens or tokens[0] == "show":
+            return CommandResult(message=settings.model_dump_json(indent=2))
+        if tokens[0] == "set" and len(tokens) == 3:
+            key, value = tokens[1], tokens[2]
+            if key not in Settings.model_fields:
+                return CommandResult(message=f"Unknown config key: {key}")
+            try:
+                coerced = _coerce_setting_value(settings, key, value)
+            except ValueError as exc:
+                return CommandResult(message=str(exc))
+            setattr(settings, key, coerced)
+            save_settings(settings)
+            return CommandResult(message=f"Updated {key}")
+        return CommandResult(message="Usage: /config [show|set KEY VALUE]")
+
+    async def _login_handler(args: str, context: CommandContext) -> CommandResult:
+        del context
+        settings = load_settings()
+        provider = detect_provider(settings)
+        api_key = args.strip()
+        if not api_key:
+            masked = (
+                f"{settings.api_key[:6]}...{settings.api_key[-4:]}"
+                if settings.api_key
+                else "(not configured)"
+            )
+            return CommandResult(
+                message=(
+                    f"Auth status:\n"
+                    f"- provider: {provider.name}\n"
+                    f"- auth_status: {auth_status(settings)}\n"
+                    f"- base_url: {settings.base_url or '(default)'}\n"
+                    f"- model: {settings.model}\n"
+                    f"- api_key: {masked}\n"
+                    "Usage: /login API_KEY"
+                )
+            )
+        env_key = settings._active_env_key
+        env = settings._active_env
+        env.api_key = api_key
+        settings.model_extra[env_key] = env.model_dump()
+        save_settings(settings)
+        return CommandResult(message="Stored API key in ~/.illusion/settings.json")
+
+    async def _logout_handler(_: str, context: CommandContext) -> CommandResult:
+        del context
+        settings = load_settings()
+        env_key = settings._active_env_key
+        env = settings._active_env
+        env.api_key = ""
+        settings.model_extra[env_key] = env.model_dump()
+        save_settings(settings)
+        return CommandResult(message="Cleared stored API key.")
+
+    async def _feedback_handler(args: str, context: CommandContext) -> CommandResult:
+        del context
+        path = get_feedback_log_path()
+        if not args.strip():
+            return CommandResult(message=f"Feedback log: {path}\nUsage: /feedback TEXT")
+        timestamp = datetime.now(timezone.utc).isoformat()
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(f"[{timestamp}] {args.strip()}\n")
+        return CommandResult(message=f"Saved feedback to {path}")
+
+    async def _fast_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        current = (
+            context.app_state.get().fast_mode
+            if context.app_state is not None
+            else settings.fast_mode
+        )
+        action = args.strip() or "toggle"
+        if action == "show":
+            return CommandResult(message=f"Fast mode: {'on' if current else 'off'}")
+        enabled = {"on": True, "off": False, "toggle": not current}.get(action)
+        if enabled is None:
+            return CommandResult(message="Usage: /fast [show|on|off|toggle]")
+        settings.fast_mode = enabled
+        save_settings(settings)
+        if context.app_state is not None:
+            context.app_state.set(fast_mode=enabled)
+        return CommandResult(message=f"Fast mode {'enabled' if enabled else 'disabled'}.")
+
+    async def _thinking_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        current = (
+            context.app_state.get().show_thinking
+            if context.app_state is not None
+            else settings.show_thinking
+        )
+        action = args.strip() or "toggle"
+        if action == "show":
+            return CommandResult(message=f"Thinking mode: {'on' if current else 'off'}")
+        enabled = {"on": True, "off": False, "toggle": not current}.get(action)
+        if enabled is None:
+            return CommandResult(message="Usage: /thinking [show|on|off|toggle]")
+        settings.show_thinking = enabled
+        save_settings(settings)
+        if context.app_state is not None:
+            context.app_state.set(show_thinking=enabled)
+        return CommandResult(message=f"Thinking mode {'enabled' if enabled else 'disabled'}.")
+
+    async def _help_handler(args: str, context: CommandContext) -> CommandResult:
+        return CommandResult(message=registry.help_text())
+
+    async def _effort_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        current = context.app_state.get().effort if context.app_state is not None else settings.effort
+        value = args.strip() or "show"
+        if value == "show":
+            return CommandResult(message=f"Reasoning effort: {current}")
+        if value not in {"low", "medium", "high", "xhigh", "max"}:
+            return CommandResult(message="Usage: /effort [show|low|medium|high|xhigh|max]")
+        # 验证 effort 级别
+        try:
+            from illusion.api.effort import EffortMapper
+            effort_level = EffortMapper.normalize(value)
+        except ValueError:
+            return CommandResult(message="Usage: /effort [show|low|medium|high|xhigh|max]")
+        settings.effort = value
+        save_settings(settings)
+        # 更新 QueryEngine 的 effort 值
+        context.engine.effort = effort_level
+        context.engine.set_system_prompt(build_runtime_system_prompt(settings, cwd=context.cwd))
+        if context.app_state is not None:
+            context.app_state.set(effort=value)
+        return CommandResult(message=f"Reasoning effort set to {value}.")
+
+    async def _passes_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        current = context.app_state.get().passes if context.app_state is not None else settings.passes
+        value = args.strip() or "show"
+        if value == "show":
+            return CommandResult(message=f"Passes: {current}")
+        try:
+            passes = max(1, min(int(value), 8))
+        except ValueError:
+            return CommandResult(message="Usage: /passes [show|COUNT]")
+        settings.passes = passes
+        save_settings(settings)
+        context.engine.set_system_prompt(build_runtime_system_prompt(settings, cwd=context.cwd))
+        if context.app_state is not None:
+            context.app_state.set(passes=passes)
+        return CommandResult(message=f"Pass count set to {passes}.")
+
+    async def _turns_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split()
+        if not tokens or tokens[0] == "show":
+            return CommandResult(
+                message=(
+                    f"Max turns (engine): {context.engine.max_turns}\n"
+                    f"Max turns (config): {settings.max_turns}\n"
+                    "Usage: /turns [show|COUNT]"
+                )
+            )
+        if tokens[0] == "set" and len(tokens) == 2:
+            raw = tokens[1]
+        elif len(tokens) == 1:
+            raw = tokens[0]
+        else:
+            return CommandResult(message="Usage: /turns [show|COUNT]")
+        try:
+            turns = int(raw)
+        except ValueError:
+            return CommandResult(message="Usage: /turns [show|COUNT]")
+        turns = max(1, min(turns, 512))
+        settings.max_turns = turns
+        save_settings(settings)
+        context.engine.set_max_turns(turns)
+        return CommandResult(message=f"Max turns set to {turns}.")
+
+    async def _continue_handler(args: str, context: CommandContext) -> CommandResult:
+        raw = args.strip()
+        if not context.engine.has_pending_continuation():
+            return CommandResult(message="Nothing to continue (no pending tool results).")
+
+        turns: int | None = None
+        if raw:
+            tokens = raw.split()
+            if tokens[0] == "set" and len(tokens) == 2:
+                raw = tokens[1]
+            try:
+                turns = int(raw)
+            except ValueError:
+                return CommandResult(message="Usage: /continue [COUNT]")
+            turns = max(1, min(turns, 512))
+
+        return CommandResult(
+            message="Continuing pending tool loop...",
+            continue_pending=True,
+            continue_turns=turns,
+        )
+
+    async def _issue_handler(args: str, context: CommandContext) -> CommandResult:
+        path = get_project_issue_file(context.cwd)
+        tokens = args.split(maxsplit=1)
+        action = tokens[0] if tokens else "show"
+        rest = tokens[1] if len(tokens) == 2 else ""
+        if action == "show":
+            if not path.exists():
+                return CommandResult(message=f"No issue context. File path: {path}")
+            return CommandResult(message=path.read_text(encoding="utf-8"))
+        if action == "set" and rest:
+            title, separator, body = rest.partition("::")
+            if not separator or not title.strip() or not body.strip():
+                return CommandResult(message="Usage: /issue set TITLE :: BODY")
+            content = f"# {title.strip()}\n\n{body.strip()}\n"
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+            return CommandResult(message=f"Saved issue context to {path}")
+        if action == "clear":
+            if path.exists():
+                path.unlink()
+                return CommandResult(message="Cleared issue context.")
+            return CommandResult(message="No issue context to clear.")
+        return CommandResult(message="Usage: /issue [show|set TITLE :: BODY|clear]")
+
+    async def _pr_comments_handler(args: str, context: CommandContext) -> CommandResult:
+        path = get_project_pr_comments_file(context.cwd)
+        tokens = args.split(maxsplit=1)
+        action = tokens[0] if tokens else "show"
+        rest = tokens[1] if len(tokens) == 2 else ""
+        if action == "show":
+            if not path.exists():
+                return CommandResult(message=f"No PR comments context. File path: {path}")
+            return CommandResult(message=path.read_text(encoding="utf-8"))
+        if action == "add" and rest:
+            location, separator, comment = rest.partition("::")
+            if not separator or not location.strip() or not comment.strip():
+                return CommandResult(message="Usage: /pr_comments add FILE[:LINE] :: COMMENT")
+            existing = path.read_text(encoding="utf-8") if path.exists() else "# PR Comments\n"
+            if not existing.endswith("\n"):
+                existing += "\n"
+            existing += f"- {location.strip()}: {comment.strip()}\n"
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(existing, encoding="utf-8")
+            return CommandResult(message=f"Added PR comment to {path}")
+        if action == "clear":
+            if path.exists():
+                path.unlink()
+                return CommandResult(message="Cleared PR comments context.")
+            return CommandResult(message="No PR comments context to clear.")
+        return CommandResult(message="Usage: /pr_comments [show|add FILE[:LINE] :: COMMENT|clear]")
+
+    async def _mcp_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split()
+        if tokens and tokens[0] == "auth" and len(tokens) >= 3:
+            server_name = tokens[1]
+            config = settings.mcp_servers.get(server_name)
+            if config is None:
+                return CommandResult(message=f"Unknown MCP server: {server_name}")
+
+            if len(tokens) == 3:
+                mode = "bearer"
+                key = None
+                value = tokens[2]
+            elif len(tokens) == 4:
+                mode = tokens[2]
+                key = None
+                value = tokens[3]
+            elif len(tokens) == 5:
+                mode = tokens[2]
+                key = tokens[3]
+                value = tokens[4]
+            else:
+                return CommandResult(
+                    message="Usage: /mcp auth SERVER TOKEN | /mcp auth SERVER [bearer|env] VALUE | /mcp auth SERVER header KEY VALUE"
+                )
+
+            if hasattr(config, "headers"):
+                if mode not in {"bearer", "header"}:
+                    return CommandResult(message="HTTP/WS MCP auth supports bearer or header modes.")
+                header_key = key or "Authorization"
+                header_value = (
+                    f"Bearer {value}" if mode == "bearer" and header_key == "Authorization" else value
+                )
+                headers = dict(getattr(config, "headers", {}) or {})
+                headers[header_key] = header_value
+                settings.mcp_servers[server_name] = config.model_copy(update={"headers": headers})
+            elif hasattr(config, "env"):
+                if mode not in {"bearer", "env"}:
+                    return CommandResult(message="stdio MCP auth supports bearer or env modes.")
+                env_key = key or "MCP_AUTH_TOKEN"
+                env_value = f"Bearer {value}" if mode == "bearer" else value
+                env = dict(getattr(config, "env", {}) or {})
+                env[env_key] = env_value
+                settings.mcp_servers[server_name] = config.model_copy(update={"env": env})
+            else:
+                return CommandResult(message=f"Server {server_name} does not support auth updates")
+            save_settings(settings)
+            return CommandResult(message=f"Saved MCP auth for {server_name}. Restart session to reconnect.")
+        return CommandResult(message=context.mcp_summary or "No MCP servers configured.")
+
+    async def _plugin_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split()
+        if not tokens or tokens[0] == "list":
+            return CommandResult(message=context.plugin_summary or "No plugins discovered.")
+        if tokens[0] == "enable" and len(tokens) == 2:
+            settings.enabled_plugins[tokens[1]] = True
+            save_settings(settings)
+            return CommandResult(message=f"Enabled plugin '{tokens[1]}'. Restart session to reload.")
+        if tokens[0] == "disable" and len(tokens) == 2:
+            settings.enabled_plugins[tokens[1]] = False
+            save_settings(settings)
+            return CommandResult(message=f"Disabled plugin '{tokens[1]}'. Restart session to reload.")
+        if tokens[0] == "install" and len(tokens) == 2:
+            path = install_plugin_from_path(tokens[1])
+            return CommandResult(message=f"Installed plugin to {path}")
+        if tokens[0] == "uninstall" and len(tokens) == 2:
+            if uninstall_plugin(tokens[1]):
+                return CommandResult(message=f"Uninstalled plugin '{tokens[1]}'")
+            return CommandResult(message=f"Plugin '{tokens[1]}' not found")
+        plugins = load_plugins(settings, context.cwd)
+        if plugins:
+            return CommandResult(message=context.plugin_summary)
+        return CommandResult(message="Usage: /plugin [list|enable NAME|disable NAME|install PATH|uninstall NAME]")
+
+    _MODE_LABELS = {"default": "Default", "plan": "Plan Mode", "full_auto": "Auto"}
+
+    async def _permissions_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split()
+        if not tokens or tokens[0] == "show":
+            permission = settings.permission
+            label = _MODE_LABELS.get(permission.mode.value, permission.mode.value)
+            return CommandResult(
+                message=(
+                    f"Mode: {label}\n"
+                    f"Allowed tools: {permission.allowed_tools}\n"
+                    f"Denied tools: {permission.denied_tools}"
+                )
+            )
+        if tokens[0] == "set" and len(tokens) == 2:
+            settings.permission.mode = PermissionMode(tokens[1])
+            save_settings(settings)
+            context.engine.set_permission_checker(PermissionChecker(settings.permission))
+            if context.app_state is not None:
+                context.app_state.set(permission_mode=settings.permission.mode.value)
+            label = _MODE_LABELS.get(tokens[1], tokens[1])
+            return CommandResult(message=f"Permission mode set to {label}")
+        return CommandResult(message="Usage: /permissions [show|set MODE]")
+
+    async def _plan_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        mode = args.strip() or "on"
+        if mode in {"on", "enter"}:
+            settings.permission.mode = PermissionMode.PLAN
+            save_settings(settings)
+            context.engine.set_permission_checker(PermissionChecker(settings.permission))
+            if context.app_state is not None:
+                context.app_state.set(permission_mode=settings.permission.mode.value)
+            return CommandResult(message="Plan mode enabled.")
+        if mode in {"off", "exit"}:
+            settings.permission.mode = PermissionMode.DEFAULT
+            save_settings(settings)
+            context.engine.set_permission_checker(PermissionChecker(settings.permission))
+            if context.app_state is not None:
+                context.app_state.set(permission_mode=settings.permission.mode.value)
+            return CommandResult(message="Plan mode disabled.")
+        return CommandResult(message="Usage: /plan [on|off]")
+
+    async def _model_handler(args: str, context: CommandContext) -> CommandResult:
+        from illusion.config.i18n import t as i18n_t
+        settings = load_settings()
+        tokens = args.split(maxsplit=1)
+        if not tokens or tokens[0] == "show":
+            env = settings._active_env
+            return CommandResult(
+                message=i18n_t("model_active", model=settings.model) + "\n" +
+                        i18n_t("model_env_model", name=settings.active_model_name) + "\n" +
+                        i18n_t("model_api_format", fmt=env.api_format) + "\n" +
+                        i18n_t("model_base_url", url=env.base_url or i18n_t("model_default_url"))
+            )
+        if tokens[0] == "list":
+            lines = []
+            for env_key, env in settings.list_envs().items():
+                for model_key, model_name in env.list_models().items():
+                    ref = f"{env_key}.{model_key}"
+                    active = " (active)" if ref == settings.model else ""
+                    lines.append(f"  {ref}{active}: {model_name} ({env.api_format})")
+            return CommandResult(message=i18n_t("model_list_title") + "\n" + "\n".join(lines))
+        # 切换模型
+        model_ref = tokens[0] if tokens[0] != "set" else (tokens[1] if len(tokens) > 1 else "")
+        if "." in model_ref:
+            env_key, model_key = model_ref.split(".", 1)
+            env = settings.get_env(env_key)
+            if env and env.get_model(model_key):
+                old_env_key = settings._active_env_key
+                settings.model = model_ref
+                save_settings(settings)
+                context.engine.set_model(env.get_model(model_key))
+                if context.app_state is not None:
+                    context.app_state.set(model=env.get_model(model_key))
+                # 跨 env 切换时告知调用方需要重建 API 客户端
+                needs_rebuild = env_key != old_env_key
+                return CommandResult(
+                    message=i18n_t("model_set_to", ref=model_ref, name=env.get_model(model_key)),
+                    needs_api_rebuild=needs_rebuild,
+                )
+        return CommandResult(message=i18n_t("model_unknown", ref=model_ref))
+
+    async def _language_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        current = (
+            str(context.app_state.get().ui_language)
+            if context.app_state is not None
+            else settings.ui_language
+        )
+        tokens = args.split()
+        if not tokens or tokens[0] == "show":
+            return CommandResult(message=f"UI language: {current}")
+        if tokens[0] == "list":
+            return CommandResult(message="Available UI languages: zh-CN, en")
+        if tokens[0] == "set" and len(tokens) == 2:
+            value = tokens[1]
+            if value not in {"zh-CN", "en"}:
+                return CommandResult(message="Usage: /language [show|list|set zh-CN|set en]")
+            settings.ui_language = value
+            save_settings(settings)
+            if context.app_state is not None:
+                context.app_state.set(ui_language=value)
+            return CommandResult(message=f"UI language set to {value}")
+        return CommandResult(message="Usage: /language [show|list|set zh-CN|set en]")
+
+    async def _output_style_handler(args: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        tokens = args.split(maxsplit=1)
+        styles = load_output_styles()
+        available = {style.name: style for style in styles}
+        current = (
+            context.app_state.get().output_style
+            if context.app_state is not None
+            else settings.output_style
+        )
+        if not tokens or tokens[0] == "show":
+            return CommandResult(message=f"Output style: {current}")
+        if tokens[0] == "list":
+            return CommandResult(
+                message="\n".join(f"{style.name} [{style.source}]" for style in styles)
+            )
+        if tokens[0] == "set" and len(tokens) == 2:
+            if tokens[1] not in available:
+                return CommandResult(message=f"Unknown output style: {tokens[1]}")
+            settings.output_style = tokens[1]
+            save_settings(settings)
+            if context.app_state is not None:
+                context.app_state.set(output_style=tokens[1])
+            return CommandResult(message=f"Output style set to {tokens[1]}")
+        return CommandResult(message="Usage: /output-style [show|list|set NAME]")
+
+    async def _doctor_handler(_: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        memory_dir = get_project_memory_dir(context.cwd)
+        state = context.app_state.get() if context.app_state is not None else None
+        lines = [
+            "Doctor summary:",
+            f"- cwd: {context.cwd}",
+            f"- model: {settings.model}",
+            f"- permission_mode: {state.permission_mode if state is not None else settings.permission.mode}",
+            f"- output_style: {state.output_style if state is not None else settings.output_style}",
+            f"- ui_language: {state.ui_language if state is not None else settings.ui_language}",
+            f"- effort: {state.effort if state is not None else settings.effort}",
+            f"- passes: {state.passes if state is not None else settings.passes}",
+            f"- memory_dir: {memory_dir}",
+            f"- plugin_count: {max(len(context.plugin_summary.splitlines()) - 1, 0) if context.plugin_summary else 0}",
+            f"- mcp_configured: {'yes' if context.mcp_summary and 'No MCP' not in context.mcp_summary else 'no'}",
+        ]
+        return CommandResult(message="\n".join(lines))
+
+    async def _privacy_settings_handler(_: str, context: CommandContext) -> CommandResult:
+        settings = load_settings()
+        session_dir = get_project_session_dir(context.cwd)
+        lines = [
+            "Privacy settings:",
+            f"- user_config_dir: {get_config_dir()}",
+            f"- project_config_dir: {get_project_config_dir(context.cwd)}",
+            f"- session_dir: {session_dir}",
+            f"- feedback_log: {get_feedback_log_path()}",
+            f"- api_base_url: {settings.base_url or '(default Anthropic-compatible endpoint)'}",
+            "- network: enabled only for provider and explicit web/MCP calls",
+            "- storage: local files under ~/.illusion and project .illusion",
+        ]
+        return CommandResult(message="\n".join(lines))
+
+    async def _diff_handler(args: str, context: CommandContext) -> CommandResult:
+        if args.strip() == "full":
+            ok, output = _run_git_command(context.cwd, "diff", "HEAD")
+            return CommandResult(message=output or "(no diff)")
+        ok, output = _run_git_command(context.cwd, "diff", "--stat")
+        if not ok:
+            return CommandResult(message=output)
+        return CommandResult(message=output or "(no diff)")
+
+    async def _branch_handler(args: str, context: CommandContext) -> CommandResult:
+        action = args.strip() or "show"
+        if action == "show":
+            ok, current = _run_git_command(context.cwd, "branch", "--show-current")
+            if not ok:
+                return CommandResult(message=current)
+            return CommandResult(message=f"Current branch: {current or '(detached HEAD)'}")
+        if action == "list":
+            ok, branches = _run_git_command(context.cwd, "branch", "--format", "%(refname:short)")
+            return CommandResult(message=branches if ok else branches)
+        return CommandResult(message="Usage: /branch [show|list]")
+
+    async def _commit_handler(args: str, context: CommandContext) -> CommandResult:
+        message = args.strip()
+        if not message:
+            ok, status = _run_git_command(context.cwd, "status", "--short")
+            return CommandResult(message=status if ok and status else "(working tree clean)")
+        ok, status = _run_git_command(context.cwd, "status", "--short")
+        if not ok:
+            return CommandResult(message=status)
+        if not status.strip():
+            return CommandResult(message="Nothing to commit.")
+        ok, output = _run_git_command(context.cwd, "add", "-A")
+        if not ok:
+            return CommandResult(message=output)
+        ok, output = _run_git_command(context.cwd, "commit", "-m", message)
+        return CommandResult(message=output if ok else output)
+
+    async def _delete_handler(args: str, context: CommandContext) -> CommandResult:
+        from illusion.services.session_storage import (
+            delete_all_sessions,
+            delete_session_by_id,
+            list_session_snapshots,
+        )
+        from illusion.services.file_history import cleanup_file_history, cleanup_all_file_histories
+
+        tokens = args.strip().split()
+
+        # /delete — 列出会话供选择
+        if not tokens:
+            sessions = list_session_snapshots(context.cwd, limit=10)
+            if not sessions:
+                return CommandResult(message="No saved sessions found for this project.")
+            import time
+            lines = ["Saved sessions:"]
+            for s in sessions:
+                ts = time.strftime("%m/%d %H:%M", time.localtime(s["created_at"]))
+                summary = s["summary"][:50] or "(no summary)"
+                lines.append(f"  {s['session_id']}  {ts}  {s['message_count']}msg  {summary}")
+            lines.append("")
+            lines.append("Usage: /delete <session_id>  — delete a specific session")
+            lines.append("       /delete all           — delete all sessions")
+            return CommandResult(message="\n".join(lines))
+
+        # /delete all / /delete __all__ — 清除所有会话
+        if tokens[0] in ("all", "__all__"):
+            count = delete_all_sessions(context.cwd)
+            cleanup_all_file_histories()
+            context.engine.clear()
+            return CommandResult(
+                message=f"Deleted {count} session file(s).",
+                clear_screen=True,
+                reset_session=True,
+            )
+
+        # /delete <session_id> — 删除指定会话
+        sid = tokens[0]
+        if delete_session_by_id(context.cwd, sid):
+            cleanup_file_history(sid)
+            if sid == context.session_id:
+                context.engine.clear()
+                return CommandResult(
+                    message=f"Deleted current session: {sid}",
+                    clear_screen=True,
+                    reset_session=True,
+                )
+            return CommandResult(message=f"Deleted session: {sid}")
+        return CommandResult(message=f"Session not found: {sid}")
+
+    async def _rules_handler(args: str, context: CommandContext) -> CommandResult:
+        from illusion.skills.loader import get_project_rules_dir
+
+        rules_dir = get_project_rules_dir(context.cwd)
+        rule_files = sorted(rules_dir.glob("*.md"))
+
+        if not rule_files:
+            return CommandResult(message=f"No rules found in {rules_dir}")
+
+        tokens = args.strip().split()
+
+        # /rules — 列出所有规则
+        if not tokens:
+            lines = [f"Rules directory: {rules_dir}", ""]
+            for i, path in enumerate(rule_files, 1):
+                # 读取第一行作为预览
+                content = path.read_text(encoding="utf-8", errors="replace").strip()
+                first_line = content.split("\n", 1)[0][:60] if content else "(empty)"
+                lines.append(f"  {i}. {path.stem}  —  {first_line}")
+            lines.append("")
+            lines.append("Usage: /rules <name|number>  — view a specific rule")
+            return CommandResult(message="\n".join(lines))
+
+        # /rules <name|number> — 显示指定规则内容
+        target = tokens[0]
+        selected = None
+
+        # 按编号选择
+        try:
+            idx = int(target) - 1
+            if 0 <= idx < len(rule_files):
+                selected = rule_files[idx]
+        except ValueError:
+            pass
+
+        # 按名称选择
+        if selected is None:
+            for path in rule_files:
+                if path.stem.lower() == target.lower():
+                    selected = path
+                    break
+
+        if selected is None:
+            return CommandResult(message=f"Rule not found: {target}. Use /rules to list available rules.")
+
+        content = selected.read_text(encoding="utf-8", errors="replace").strip()
+        return CommandResult(message=f"# {selected.stem}\n\n{content}")
+
+    registry.register(SlashCommand("exit", "Exit IllusionCode", _exit_handler))
+    registry.register(SlashCommand("clear", "Clear conversation and start a new session", _new_handler))
+    registry.register(SlashCommand("new", "Start a new conversation session", _new_handler))
+    registry.register(SlashCommand("version", "Show the installed IllusionCode version", _version_handler))
+    registry.register(SlashCommand("status", "Show session status", _status_handler))
+    registry.register(SlashCommand("context", "Show active system prompt or manage context window", _context_handler))
+    registry.register(SlashCommand("summary", "Summarize conversation history", _summary_handler))
+    registry.register(SlashCommand("compact", "Compact older conversation history", _compact_handler))
+    registry.register(SlashCommand("memory", "Inspect and manage project memory", _memory_handler))
+    registry.register(SlashCommand("hooks", "Show configured hooks", _hooks_handler))
+    registry.register(SlashCommand("resume", "Restore the latest saved session", _resume_handler))
+    registry.register(SlashCommand("export", "Export the current transcript", _export_handler))
+    registry.register(SlashCommand("share", "Create a shareable transcript snapshot", _share_handler))
+    registry.register(SlashCommand("copy", "Copy the latest response or provided text", _copy_handler))
+    registry.register(SlashCommand("rewind", "Remove the latest conversation turn(s)", _rewind_handler))
+    registry.register(SlashCommand("files", "List files in the current workspace", _files_handler))
+    registry.register(SlashCommand("init", "Initialize project IllusionCode files", _init_handler))
+    registry.register(SlashCommand("bridge", "Inspect bridge helpers and spawn bridge sessions", _bridge_handler))
+    registry.register(SlashCommand("login", "Show auth status or store an API key", _login_handler))
+    registry.register(SlashCommand("logout", "Clear the stored API key", _logout_handler))
+    registry.register(SlashCommand("feedback", "Save CLI feedback to the local feedback log", _feedback_handler))
+    registry.register(SlashCommand("skills", "List or show available skills", _skills_handler))
+    registry.register(SlashCommand("config", "Show or update configuration", _config_handler))
+    registry.register(SlashCommand("mcp", "Show MCP status", _mcp_handler))
+    registry.register(SlashCommand("plugin", "Manage plugins", _plugin_handler))
+    registry.register(SlashCommand("reload-plugins", "Reload plugin discovery for this workspace", _reload_plugins_handler))
+    registry.register(SlashCommand("permissions", "Show or update permission mode", _permissions_handler))
+    registry.register(SlashCommand("plan", "Toggle plan permission mode", _plan_handler))
+    registry.register(SlashCommand("thinking", "Show or update thinking mode", _thinking_handler))
+    registry.register(SlashCommand("help", "Show available commands and their usage", _help_handler))
+    registry.register(SlashCommand("fast", "Show or update fast mode", _fast_handler))
+    registry.register(SlashCommand("effort", "Show or update reasoning effort", _effort_handler))
+    registry.register(SlashCommand("passes", "Show or update reasoning pass count", _passes_handler))
+    registry.register(SlashCommand("turns", "Show or update maximum agentic turn count", _turns_handler))
+    registry.register(SlashCommand("continue", "Continue the previous tool loop if it was interrupted", _continue_handler))
+    registry.register(SlashCommand("model", "Show or update the default model", _model_handler))
+    registry.register(SlashCommand("language", "Show or update UI language", _language_handler))
+    registry.register(SlashCommand("output-style", "Show or update output style", _output_style_handler))
+    registry.register(SlashCommand("doctor", "Show environment diagnostics", _doctor_handler))
+    registry.register(SlashCommand("diff", "Show git diff output", _diff_handler))
+    registry.register(SlashCommand("branch", "Show git branch information", _branch_handler))
+    registry.register(SlashCommand("commit", "Show status or create a git commit", _commit_handler))
+    registry.register(SlashCommand("issue", "Show or update project issue context", _issue_handler))
+    registry.register(SlashCommand("pr_comments", "Show or update project PR comments context", _pr_comments_handler))
+    registry.register(SlashCommand("privacy-settings", "Show local privacy and storage settings", _privacy_settings_handler))
+    registry.register(SlashCommand("delete", "Delete saved sessions", _delete_handler))
+    registry.register(SlashCommand("rules", "View project rules", _rules_handler))
+    return registry