mindcode 0.5.2__tar.gz → 0.5.5__tar.gz

{mindcode-0.5.2 → mindcode-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mindcode
-Version: 0.5.2
+Version: 0.5.5
 Summary: codex-style interactive coding agent on top of mindagent
 Author: mindcode
 License: MIT
@@ -35,7 +35,7 @@ Requires-Dist: prompt-toolkit>=3.0.30
 - **可选 Subagent 模式**：`mindcode --subagents` 启用受限的 master/coder 协作；master 仅能委派，coder 才能访问 workspace
 - 全屏 TUI：顶部 logo/会话信息、可滚动 Markdown 消息区、固定带边框多行输入框与状态栏
 - 顶部信息栏显示本会话累计 token 消耗；provider 未返回 usage 时显示 `tokens —`
-- Rich 富渲染：Markdown、彩色工具面板、file_edit diff 高亮和流式 LLM 输出
+- Rich 富渲染：Markdown、彩色工具面板、edit diff 高亮和流式 LLM 输出
 - TUI 内选择菜单：`/models`、`/permissions` 用方向键选择
 - REPL 权限模式：`ask_user`（默认，写入和危险操作逐项询问）/ `full_accept`（接受权限上限内的操作风险）
 - 会话持久化与恢复：基于 `LocalConversationStore`，存到 `~/.cache/mindcode/sessions/`
@@ -168,7 +168,7 @@ mindcode --subagents "审查当前改动并运行相关测试"
 ```bash
 mindcode                                     # 默认进 shell
 › 在 workspace 创建 hello.txt 写入 hi
-   › file_edit (create) hello.txt [WRITE]
+   › edit (create) hello.txt [WRITE]
    ask_user 将在执行前询问；也可切换到 /permissions full_accept
    ┌─ diff: hello.txt ──────────────────────┐
    │ +hi                                     │
@@ -333,15 +333,15 @@ mindcode/
   持久化；运行结束会清理未消费的授权，不自动新增磁盘审计文件。
 - 普通问答使用 `USER_INPUT_REQUIRED` 与 `submit_user_input()`；旧 `approve_run()`
   因未绑定授权请求而被拒绝。
-- `exec_command` 只限制 `cwd`，不会隔离子进程访问的文件。`sed`、`find`、`git diff`
+- `command` 只限制 `cwd`，不会隔离子进程访问的文件。`sed`、`find`、`git diff`
   等命令保守按写风险审批，具体范围见
   [策略与权限](../../docs/guides/policies-and-approval.md)。
 
 ## 局限
 
-- 不支持 `/undo`：`exec_command` 的副作用可能不可逆，回滚复杂。
+- 不支持 `/undo`：`command` 的副作用可能不可逆，回滚复杂。
 - 会话恢复只续聊 user/assistant 历史，不恢复 TaskState / Evidence / pending continuation。
 - `task resume` 是重新观察 workspace 后创建新 Run，不会重放未确认的旧 Action。
 - 后台任务目前依赖本机 PID；不提供跨主机监督或精确进程身份恢复。
-- `bench run` 第一版仅支持串行（concurrency=1）；`exec_command` 无沙箱，
+- `bench run` 第一版仅支持串行（concurrency=1）；`command` 无沙箱，
   SWE-bench / Terminal-Bench 评测依赖本机对应的评测环境。

{mindcode-0.5.2 → mindcode-0.5.5}/README.md

@@ -19,7 +19,7 @@
 - **可选 Subagent 模式**：`mindcode --subagents` 启用受限的 master/coder 协作；master 仅能委派，coder 才能访问 workspace
 - 全屏 TUI：顶部 logo/会话信息、可滚动 Markdown 消息区、固定带边框多行输入框与状态栏
 - 顶部信息栏显示本会话累计 token 消耗；provider 未返回 usage 时显示 `tokens —`
-- Rich 富渲染：Markdown、彩色工具面板、file_edit diff 高亮和流式 LLM 输出
+- Rich 富渲染：Markdown、彩色工具面板、edit diff 高亮和流式 LLM 输出
 - TUI 内选择菜单：`/models`、`/permissions` 用方向键选择
 - REPL 权限模式：`ask_user`（默认，写入和危险操作逐项询问）/ `full_accept`（接受权限上限内的操作风险）
 - 会话持久化与恢复：基于 `LocalConversationStore`，存到 `~/.cache/mindcode/sessions/`
@@ -152,7 +152,7 @@ mindcode --subagents "审查当前改动并运行相关测试"
 ```bash
 mindcode                                     # 默认进 shell
 › 在 workspace 创建 hello.txt 写入 hi
-   › file_edit (create) hello.txt [WRITE]
+   › edit (create) hello.txt [WRITE]
    ask_user 将在执行前询问；也可切换到 /permissions full_accept
    ┌─ diff: hello.txt ──────────────────────┐
    │ +hi                                     │
@@ -317,15 +317,15 @@ mindcode/
   持久化；运行结束会清理未消费的授权，不自动新增磁盘审计文件。
 - 普通问答使用 `USER_INPUT_REQUIRED` 与 `submit_user_input()`；旧 `approve_run()`
   因未绑定授权请求而被拒绝。
-- `exec_command` 只限制 `cwd`，不会隔离子进程访问的文件。`sed`、`find`、`git diff`
+- `command` 只限制 `cwd`，不会隔离子进程访问的文件。`sed`、`find`、`git diff`
   等命令保守按写风险审批，具体范围见
   [策略与权限](../../docs/guides/policies-and-approval.md)。
 
 ## 局限
 
-- 不支持 `/undo`：`exec_command` 的副作用可能不可逆，回滚复杂。
+- 不支持 `/undo`：`command` 的副作用可能不可逆，回滚复杂。
 - 会话恢复只续聊 user/assistant 历史，不恢复 TaskState / Evidence / pending continuation。
 - `task resume` 是重新观察 workspace 后创建新 Run，不会重放未确认的旧 Action。
 - 后台任务目前依赖本机 PID；不提供跨主机监督或精确进程身份恢复。
-- `bench run` 第一版仅支持串行（concurrency=1）；`exec_command` 无沙箱，
+- `bench run` 第一版仅支持串行（concurrency=1）；`command` 无沙箱，
   SWE-bench / Terminal-Bench 评测依赖本机对应的评测环境。

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/_version.py

@@ -1,6 +1,6 @@
 """mindcode 版本与品牌信息。"""
 
-__version__ = "0.5.2"
+__version__ = "0.5.5"
 
 __logo__ = r"""
 [bold cyan]                           _           _[/bold cyan]

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/acp_agent/__main__.py

@@ -14,6 +14,7 @@ from pathlib import Path
 
 from acp import run_agent
 
+from ..policy import ApprovalMode
 from .agent import _AgentHarness
 
 
@@ -37,6 +38,23 @@ def main(argv: list[str] | None = None) -> int:
         default=None,
         help="Default workspace used when a client connects without a cwd",
     )
+    parser.add_argument(
+        "--approval-mode",
+        choices=[mode.value for mode in ApprovalMode],
+        default=None,
+        help=(
+            "Override the approval mode read from config.toml. This is a "
+            "host-side launch decision; ACP requests can never change it."
+        ),
+    )
+    parser.add_argument(
+        "--allow-dangerous",
+        action="store_true",
+        help=(
+            "Allow ActionRisk.DANGEROUS tools in created sessions. Only for "
+            "trusted, attended hosts: it lifts the SessionPolicy ceiling."
+        ),
+    )
     parser.add_argument("--verbose", action="store_true", help="stderr debug logs")
     args = parser.parse_args(argv)
 
@@ -49,6 +67,8 @@ def main(argv: list[str] | None = None) -> int:
             harness = _AgentHarness(
                 conn,  # type: ignore[arg-type]
                 cwd=Path(args.cwd).expanduser() if args.cwd else None,
+                approval_mode=args.approval_mode,
+                allow_dangerous=args.allow_dangerous,
             )
             harness_holder.append(harness)
             return harness

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/acp_agent/agent.py

@@ -11,8 +11,10 @@ approval callback / event stream.  Hard rules honoured here:
 
 - stdout carries protocol frames only; every log line goes to stderr.
 - one run per session at a time; a second ``session/prompt`` is rejected.
-- provider/model/approval configuration always comes from ``ConfigStore``
-  (fresh ``read()`` per session); clients cannot widen the SessionPolicy.
+- provider/model/approval configuration comes from ``ConfigStore`` (fresh
+  ``read()`` per session); an ACP *request* can never widen it. Only the host
+  that launched this process may override approval/session limits, through
+  explicit CLI flags (``--approval-mode``, ``--allow-dangerous``).
 - unimplemented stable methods (``session/load``, ``session/set_mode``)
   answer with a JSON-RPC error instead of pretending support.
 """
@@ -34,7 +36,6 @@ from acp.schema import (
     PermissionOption,
     PromptCapabilities,
     PromptResponse,
-    RequestPermissionResponse,
     TextContentBlock,
     ToolCallStart,
 )
@@ -43,6 +44,8 @@ from mindagent.core import (
     AgentSession,
     AgentRuntime,
     EventType,
+    ExternalFileReadDecision,
+    ExternalFileReadRequest,
     LocalConversationStore,
     RunOutcome,
     SessionEnvironment,
@@ -50,7 +53,7 @@ from mindagent.core import (
     SessionPolicy,
 )
 from ..approval import describe_action
-from ..config import ConfigError, ConfigStore, ProviderConfig
+from ..config import BUILTIN_SETTINGS, ConfigError, ConfigStore, ProviderConfig
 from ..policy import ApprovalMode
 from ..runtime import build_runtime
 
@@ -58,9 +61,6 @@ logger = logging.getLogger("mindcode.acp_agent")
 
 PROTOCOL_VERSION = 1  # stable ACP v1; see docs/acp-layering.md §5
 
-_PERMISSION_TIMEOUT_S = 120.0
-
-
 def _stop_reason(result: Any) -> str:
     """Map a native run result to an ACP v1 stop reason (layering §3)."""
     outcome = getattr(result, "outcome", None)
@@ -72,9 +72,9 @@ def _stop_reason(result: Any) -> str:
 
 
 def _tool_kind(action_name: str) -> str:
-    if action_name.startswith("file_read"):
+    if action_name.startswith("read"):
         return "read"
-    if action_name in ("file_write", "file_edit"):
+    if action_name in ("write", "edit"):
         return "edit"
     if action_name.startswith("exec_") or "command" in action_name:
         return "execute"
@@ -123,12 +123,29 @@ class _AgentHarness:
         config_store: ConfigStore | None = None,
         cwd: Path | None = None,
         subagents: bool = False,
-        permission_timeout_s: float = _PERMISSION_TIMEOUT_S,
+        approval_mode: str | None = None,
+        allow_dangerous: bool = False,
+        permission_timeout_s: float | None = None,
     ) -> None:
         self._conn = conn
         self._config_store = config_store or ConfigStore()
         self._cwd = cwd or Path.cwd()
         self._subagents = subagents
+        # Explicit launch-time policy, always from the *host* that started
+        # this process (CLI flags, i.e. the user's own settings) — never from
+        # an ACP request. ``None`` keeps the ConfigStore value.
+        self._approval_mode = approval_mode
+        self._allow_dangerous = allow_dangerous
+        self._permission_timeout_from_config = permission_timeout_s is None
+        if permission_timeout_s is None:
+            try:
+                permission_timeout_s = (
+                    self._config_store.read()
+                    .runtime_settings.permission_timeout_s
+                )
+            except AttributeError:
+                # Lightweight test/fake stores may only implement resolve().
+                permission_timeout_s = BUILTIN_SETTINGS.permission_timeout_s
         self._permission_timeout_s = permission_timeout_s
         self._sessions: dict[str, _ManagedSession] = {}
         self._new_session_lock = asyncio.Lock()
@@ -171,16 +188,23 @@ class _AgentHarness:
                 resolved = self._config_store.resolve()
             except ConfigError as exc:
                 raise RequestError.internal_error(str(exc)) from exc
+            if self._permission_timeout_from_config:
+                self._permission_timeout_s = (
+                    resolved.runtime_settings.permission_timeout_s
+                )
             store = LocalConversationStore(
                 self._config_store.root / "sessions"
             )
+            effective_mode = self._approval_mode or resolved.approval_mode
+            effective_approval = ApprovalMode(effective_mode)
             runtime = build_runtime(
                 workspace,
                 provider_config=resolved,
-                approve_mode=ApprovalMode(resolved.approval_mode),
+                approve_mode=effective_approval,
                 stream=True,
                 event_handler=None,
                 approval_callback=self._make_approval(resolved),
+                file_access_callback=self._make_file_access_approval(),
             )
             try:
                 session = runtime.create_session(
@@ -190,7 +214,7 @@ class _AgentHarness:
                     ),
                     policy=SessionPolicy(
                         allow_write=True,
-                        allow_dangerous=False,
+                        allow_dangerous=self._allow_dangerous,
                         max_parallel_actions=1,
                     ),
                     conversation_store=store,
@@ -203,12 +227,13 @@ class _AgentHarness:
                 session_id, session, runtime
             )
             logger.info(
-                "session %s created (workspace=%s provider=%s model=%s approval=%s)",
+                "session %s created (workspace=%s provider=%s model=%s approval=%s allow_dangerous=%s)",
                 session_id,
                 workspace,
                 resolved.name,
                 resolved.model,
-                resolved.approval_mode,
+                effective_mode,
+                self._allow_dangerous,
             )
             return NewSessionResponse(session_id=session_id)
 
@@ -309,6 +334,52 @@ class _AgentHarness:
 
         return approve
 
+    def _make_file_access_approval(self) -> Any:
+        async def approve(
+            context: Any,
+            request: ExternalFileReadRequest,
+        ) -> ExternalFileReadDecision:
+            managed = self._managed(context.session_id)
+            started = helpers.start_tool_call(
+                tool_call_id=f"external-read-{request.request_id}",
+                title=f"Read external file {request.path}",
+                kind="read",
+                status="pending",
+            )
+            await self._notify_update(managed, started)
+            options = [
+                PermissionOption(
+                    option_id="allow", name="Allow once", kind="allow_once"
+                ),
+                PermissionOption(
+                    option_id="reject", name="Reject", kind="reject_once"
+                ),
+            ]
+            approved = False
+            try:
+                response = await asyncio.wait_for(
+                    self._conn.request_permission(
+                        session_id=managed.session_id,
+                        tool_call=started,
+                        options=options,
+                    ),
+                    timeout=self._permission_timeout_s,
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "external read permission timed out after %.0fs → deny",
+                    self._permission_timeout_s,
+                )
+            else:
+                outcome = response.outcome
+                approved = (
+                    getattr(outcome, "outcome", None) != "cancelled"
+                    and getattr(outcome, "option_id", None) == "allow"
+                )
+            return ExternalFileReadDecision(request.request_id, approved)
+
+        return approve
+
     # ----- event-stream translation (native port 5 → session/update) -----
 
     async def _notify_update(self, managed: _ManagedSession, update: Any) -> None:
@@ -459,6 +530,8 @@ def build_harness(
     config_store: ConfigStore | None = None,
     cwd: Path | None = None,
     subagents: bool = False,
+    approval_mode: str | None = None,
+    allow_dangerous: bool = False,
 ) -> _AgentHarness:
     """Factory used by ``__main__`` and tests."""
     return _AgentHarness(
@@ -466,4 +539,6 @@ def build_harness(
         config_store=config_store,
         cwd=cwd,
         subagents=subagents,
+        approval_mode=approval_mode,
+        allow_dangerous=allow_dangerous,
     )

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/approval.py

@@ -42,17 +42,17 @@ def describe_action(action: ActionRequest) -> str:
     arguments = (
         action.arguments if isinstance(action.arguments, dict) else {}
     )
-    if name in ("file_edit", "file_write"):
-        verb = "Edit" if name == "file_edit" else "Write"
+    if name in ("edit", "write"):
+        verb = "Edit" if name == "edit" else "Write"
         path = _one_line(arguments.get("path", "?"))
         return f"{verb} {path} [{risk_label(action.risk)}]"
-    if name == "exec_command":
+    if name == "command":
         command = arguments.get("command", "")
         preview = _one_line(command) if isinstance(command, str) else ""
         if len(preview) > 120:
             preview = preview[:117] + "..."
         return f"Command {preview} [{risk_label(action.risk)}]"
-    if name in ("file_read", "memory_read"):
+    if name in ("read", "memory_read"):
         path = _one_line(arguments.get("path", "?"))
         return f"Read {path} [{risk_label(action.risk)}]"
     payload = json.dumps(arguments, ensure_ascii=False, sort_keys=True)

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/bench/schema.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from ..config import BUILTIN_SETTINGS
+
 
 @dataclass(frozen=True)
 class BenchmarkFile:
@@ -59,9 +61,9 @@ class BenchmarkRunConfig:
     limit: int | None = None
     case_ids: tuple[str, ...] = ()
     concurrency: int = 1
-    max_steps: int = 50
-    step_timeout_s: float | None = 300.0
-    total_timeout_s: float | None = 1800.0
+    max_steps: int = BUILTIN_SETTINGS.benchmark.max_steps
+    step_timeout_s: float | None = BUILTIN_SETTINGS.benchmark.step_timeout_s
+    total_timeout_s: float | None = BUILTIN_SETTINGS.benchmark.total_timeout_s
     enable_subagents: bool = False
     enable_background_tasks: bool = False
     seed: int | None = None

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/cli/__init__.py

@@ -20,7 +20,13 @@
 from __future__ import annotations
 
 import typer
-from click import UsageError
+
+try:
+    # Typer 0.27 vendors Click to keep its exception types aligned with its
+    # renderer; older Typer releases use the public Click package directly.
+    from typer.core import _click
+except ImportError:  # pragma: no cover - compatibility with older Typer
+    import click as _click
 
 from .._version import __version__
 from ._shared import console
@@ -46,9 +52,10 @@ class DefaultShellGroup(typer.core.TyperGroup):
         if args:
             first = args[0]
             if first == "shell":
-                raise UsageError(
+                raise _click.exceptions.UsageError(
                     "`mindcode shell` 已移除；请改用 "
-                    "`mindcode [PROMPT] [OPTIONS]`"
+                    "`mindcode [PROMPT] [OPTIONS]`",
+                    ctx,
                 )
             if (
                 first in PUBLIC_SUBCOMMANDS

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/cli/commands/bench.py

@@ -86,15 +86,22 @@ def run(
         "--benchmark-root",
         help="benchmark case 根目录",
     ),
-    max_steps: int = typer.Option(50, "--max-steps", help="每 case 最大 step"),
+    max_steps: int | None = typer.Option(
+        None, "--max-steps", help="每 case 最大 step"
+    ),
     total_timeout: float | None = typer.Option(
-        600.0,
+        None,
         "--total-timeout",
-        help="每 case 总超时秒数",
+        help="每 case 总超时秒数，0 表示禁用",
     ),
 ) -> None:
     run_id = f"{suite}-{time.strftime('%Y%m%d-%H%M%S')}"
     try:
+        total_timeout_disabled = total_timeout == 0
+        if total_timeout is not None and total_timeout < 0:
+            raise ValueError("total timeout 必须为 0 或大于 0")
+        if total_timeout_disabled:
+            total_timeout = None
         approval_override = (
             ApprovalMode(approve_mode).value
             if approve_mode is not None
@@ -106,6 +113,11 @@ def run(
             approval_override=approval_override,
         )
         selected_approve_mode = resolved.approval_mode
+        benchmark_defaults = resolved.runtime_settings.benchmark
+        if max_steps is None:
+            max_steps = benchmark_defaults.max_steps
+        if total_timeout is None and not total_timeout_disabled:
+            total_timeout = benchmark_defaults.total_timeout_s
         output_root = Path(output).expanduser()
         run_output_dir = _run_output_dir(output_root, run_id)
         run_config = BenchmarkRunConfig(

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/cli/commands/chat.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import typer
 
+from ...config import BUILTIN_SETTINGS
 from ...policy import ApprovalMode
 from .._shared import console
 from ..shell import run_shell
@@ -41,15 +42,25 @@ def chat(
         False, "--no-stream", help="关闭流式输出"
     ),
     max_steps: int | None = typer.Option(
-        None, "--max-steps", help="最大 step 数（默认 50）"
+        None,
+        "--max-steps",
+        help=f"最大 step 数（默认 {BUILTIN_SETTINGS.one_shot.max_steps}）",
     ),
     step_timeout: float | None = typer.Option(
         None,
         "--step-timeout",
-        help="单步超时秒数（默认 300，必须大于 0）",
+        help=(
+            "单步超时秒数（默认 "
+            f"{BUILTIN_SETTINGS.one_shot.step_timeout_s:g}，必须大于 0）"
+        ),
     ),
     total_timeout: float | None = typer.Option(
-        None, "--total-timeout", help="总超时秒数，0 表示禁用（默认 1800）"
+        None,
+        "--total-timeout",
+        help=(
+            "总超时秒数，0 表示禁用（默认 "
+            f"{BUILTIN_SETTINGS.one_shot.total_timeout_s:g}）"
+        ),
     ),
 ) -> None:
     """发送单条消息，不进入交互模式。"""
@@ -78,13 +89,32 @@ def chat(
             resume=resume,
             stream=not no_stream,
             one_shot_prompt=message,
-            max_steps=max_steps if max_steps is not None else 50,
+            max_steps=(
+                max_steps
+                if max_steps is not None
+                else BUILTIN_SETTINGS.one_shot.max_steps
+            ),
             step_timeout_s=(
-                step_timeout if step_timeout is not None else 300.0
+                step_timeout
+                if step_timeout is not None
+                else BUILTIN_SETTINGS.one_shot.step_timeout_s
             ),
             total_timeout_s=None
             if total_timeout == 0
-            else (total_timeout if total_timeout is not None else 1800.0),
+            else (
+                total_timeout
+                if total_timeout is not None
+                else BUILTIN_SETTINGS.one_shot.total_timeout_s
+            ),
+            settings_defaults=frozenset(
+                name
+                for name, value in (
+                    ("max_steps", max_steps),
+                    ("step_timeout_s", step_timeout),
+                    ("total_timeout_s", total_timeout),
+                )
+                if value is None
+            ),
         )
     except ValueError as exc:
         console.print(f"[red]配置错误:[/red] {exc}")

{mindcode-0.5.2 → mindcode-0.5.5}/mindcode/cli/commands/shell.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import typer
 
+from ...config import BUILTIN_SETTINGS
 from ...policy import ApprovalMode
 from .._shared import console
 from ..shell import run_shell
@@ -46,23 +47,34 @@ def shell(
     no_stream: bool = typer.Option(
         False, "--no-stream", help="关闭流式输出"
     ),
+    no_markdown: bool = typer.Option(
+        False, "--no-markdown", help="关闭交互消息的 Markdown 渲染"
+    ),
     subagents: bool = typer.Option(
         False,
         "--subagents",
         help="使用 master/coder 委派模式（await_result）",
     ),
     max_steps: int | None = typer.Option(
-        None, "--max-steps", help="最大 step 数（默认 50）"
+        None,
+        "--max-steps",
+        help=f"最大 step 数（默认 {BUILTIN_SETTINGS.one_shot.max_steps}）",
     ),
     step_timeout: float | None = typer.Option(
         None,
         "--step-timeout",
-        help="单步超时秒数（交互默认不限制；one-shot 默认 300，必须大于 0）",
+        help=(
+            "单步超时秒数（交互默认不限制；one-shot 默认 "
+            f"{BUILTIN_SETTINGS.one_shot.step_timeout_s:g}，必须大于 0）"
+        ),
     ),
     total_timeout: float | None = typer.Option(
         None,
         "--total-timeout",
-        help="总超时秒数，0 表示禁用（交互默认禁用；一次性/子代理默认 1800）",
+        help=(
+            "总超时秒数，0 表示禁用（交互默认禁用；一次性/子代理默认 "
+            f"{BUILTIN_SETTINGS.one_shot.total_timeout_s:g}）"
+        ),
     ),
 ) -> None:
     """启动顶层 `mindcode` 交互或 one-shot 模式。"""
@@ -95,7 +107,9 @@ def shell(
         selected_total_timeout = None
     else:
         selected_total_timeout = (
-            total_timeout if total_timeout is not None else 1800.0
+            total_timeout
+            if total_timeout is not None
+            else BUILTIN_SETTINGS.one_shot.total_timeout_s
         )
 
     try:
@@ -107,15 +121,37 @@ def shell(
             session_id=session,
             resume=resume,
             stream=not no_stream,
+            markdown_enabled=False if no_markdown else None,
             subagents=subagents,
             one_shot_prompt=prompt,
-            max_steps=max_steps if max_steps is not None else 50,
+            max_steps=(
+                max_steps
+                if max_steps is not None
+                else (
+                    BUILTIN_SETTINGS.interactive.max_steps
+                    if prompt is None
+                    else BUILTIN_SETTINGS.one_shot.max_steps
+                )
+            ),
             step_timeout_s=(
                 step_timeout
                 if step_timeout is not None
-                else (None if prompt is None else 300.0)
+                else (
+                    BUILTIN_SETTINGS.interactive.step_timeout_s
+                    if prompt is None
+                    else BUILTIN_SETTINGS.one_shot.step_timeout_s
+                )
             ),
             total_timeout_s=selected_total_timeout,
+            settings_defaults=frozenset(
+                name
+                for name, value in (
+                    ("max_steps", max_steps),
+                    ("step_timeout_s", step_timeout),
+                    ("total_timeout_s", total_timeout),
+                )
+                if value is None
+            ),
         )
     except ValueError as exc:
         console.print(f"[red]配置错误:[/red] {exc}")