controlmesh 0.40.2__tar.gz → 0.41.0__tar.gz

{controlmesh-0.40.2 → controlmesh-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: controlmesh
-Version: 0.40.2
+Version: 0.41.0
 Summary: ControlMesh brings official coding CLIs into Telegram, Matrix, and Feishu with persistent workspaces, long-running jobs, and production-friendly bot operations.
 Project-URL: Homepage, https://github.com/muqiao215/ControlMesh
 Project-URL: Repository, https://github.com/muqiao215/ControlMesh
@@ -74,12 +74,20 @@ ControlMesh is a chat-native task runtime for official coding CLIs, with a
 file-backed memory layer, a first-class multi-agent runtime
 ## 中文
 
-### 手机端多代理平台
+### Enhanced Terminal 与手机端多代理平台
 
 ControlMesh 是一个开源的 chat-native task runtime：把 Claude、Codex、
 Gemini 等官方编码 CLI 接进飞书、Telegram 和微信，让它们像长期在线的任务
 机器人一样执行工作，并带上文件型记忆层和多代理运行时。
 
+从 0.41.0 开始，在交互式终端直接运行 `controlmesh` 会进入
+ControlMesh Enhanced Terminal：
+
+- 默认提示符是 `cm>`，普通输入复用 ControlMesh Orchestrator、记忆、任务和路由能力。
+- 输入 `/cm` 进入真实 Codex/Claude/OpenCode 等 provider 原生 CLI。
+- 在原生模式输入 `/back` 回到 `cm>`。
+- 旧聊天机器人 runtime 仍保留为 `controlmesh bot`。
+
 它不是一次性的聊天壳。主线是飞书里的后台任务闭环：创建任务、任务后台执行、
 任务缺信息时通过 `ask_parent` 回问飞书、父会话恢复任务、结果回到同一聊天上下文。
 支持对接Telegram 和微信/WeChat ；Matrix 保留为次级兼容 transport。
@@ -183,6 +191,13 @@ pipx install controlmesh
 controlmesh
 ```
 
+交互式 `controlmesh` 会进入 enhanced terminal。要启动旧的聊天 transport
+runtime，使用：
+
+```bash
+controlmesh bot
+```
+
 如果你想直接跟踪 GitHub 最新 `main`，不用等下一次 PyPI 发布：
 
 ```bash

{controlmesh-0.40.2 → controlmesh-0.41.0}/README.md

@@ -6,12 +6,20 @@ ControlMesh is a chat-native task runtime for official coding CLIs, with a
 file-backed memory layer, a first-class multi-agent runtime
 ## 中文
 
-### 手机端多代理平台
+### Enhanced Terminal 与手机端多代理平台
 
 ControlMesh 是一个开源的 chat-native task runtime：把 Claude、Codex、
 Gemini 等官方编码 CLI 接进飞书、Telegram 和微信，让它们像长期在线的任务
 机器人一样执行工作，并带上文件型记忆层和多代理运行时。
 
+从 0.41.0 开始，在交互式终端直接运行 `controlmesh` 会进入
+ControlMesh Enhanced Terminal：
+
+- 默认提示符是 `cm>`，普通输入复用 ControlMesh Orchestrator、记忆、任务和路由能力。
+- 输入 `/cm` 进入真实 Codex/Claude/OpenCode 等 provider 原生 CLI。
+- 在原生模式输入 `/back` 回到 `cm>`。
+- 旧聊天机器人 runtime 仍保留为 `controlmesh bot`。
+
 它不是一次性的聊天壳。主线是飞书里的后台任务闭环：创建任务、任务后台执行、
 任务缺信息时通过 `ask_parent` 回问飞书、父会话恢复任务、结果回到同一聊天上下文。
 支持对接Telegram 和微信/WeChat ；Matrix 保留为次级兼容 transport。
@@ -115,6 +123,13 @@ pipx install controlmesh
 controlmesh
 ```
 
+交互式 `controlmesh` 会进入 enhanced terminal。要启动旧的聊天 transport
+runtime，使用：
+
+```bash
+controlmesh bot
+```
+
 如果你想直接跟踪 GitHub 最新 `main`，不用等下一次 PyPI 发布：
 
 ```bash

{controlmesh-0.40.2 → controlmesh-0.41.0}/config.example.json

@@ -28,6 +28,27 @@
     "transport": "telegram",
     "transports": ["telegram"],
 
+    "terminal": {
+        "enabled": true,
+        "default_provider": "codex",
+        "default_model": "gpt-5.5",
+        "default_mode": "enhanced",
+        "prompt": "cm> ",
+        "native_escape_command": "/cm",
+        "back_command": "/back",
+        "show_background_notifications": true,
+        "background_notification_interval_seconds": 2.0,
+        "inbox_enabled": true,
+        "memory_auto_context": false,
+        "memory_inject_requires_confirmation": true,
+        "pty_raw_mode": true,
+        "pty_line_mode_fallback": true,
+        "foreground_provider_reuse": true,
+        "foreground_session_name": "terminal-main",
+        "enable_background_agents": true,
+        "native_provider_args": {}
+    },
+
     "telegram_token": "YOUR_BOT_TOKEN_HERE",
     "allowed_user_ids": [
         123456789

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/__init__.py

@@ -1,3 +1,3 @@
 """ControlMesh public package and CLI entrypoint surface."""
 
-__version__ = "0.40.2"
+__version__ = "0.41.0"

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/__main__.py

@@ -47,6 +47,7 @@ from controlmesh.cli_commands.status import (
     print_usage as _print_usage,
 )
 from controlmesh.cli_commands.tasks import cmd_tasks as _cmd_tasks
+from controlmesh.cli_commands.terminal import cmd_terminal as _cmd_terminal
 from controlmesh.config import (
     DEFAULT_EMPTY_GEMINI_API_KEY,
     AgentConfig,
@@ -557,6 +558,11 @@ def _default_action(verbose: bool) -> None:
     _start_bot(verbose)
 
 
+def _cmd_bot(verbose: bool) -> None:
+    """Run the legacy chat transport runtime."""
+    _default_action(verbose)
+
+
 def _print_version() -> None:
     """Print the installed ControlMesh version."""
     _console.print(get_current_version())
@@ -617,6 +623,9 @@ _COMMANDS: dict[str, str] = {
     "auth": "auth",
     "runtime": "runtime",
     "tasks": "tasks",
+    "terminal": "terminal",
+    "term": "terminal",
+    "bot": "bot",
     "feishu": "feishu",
     "qq": "qq",
 }
@@ -661,12 +670,16 @@ def main() -> None:
         "auth": lambda: _cmd_auth(args),
         "runtime": lambda: _cmd_runtime(args),
         "tasks": lambda: _cmd_tasks(args),
+        "terminal": lambda: _cmd_terminal(args),
+        "bot": lambda: _cmd_bot(verbose),
         "feishu": lambda: _cmd_feishu(args),
     }
 
     handler = dispatch.get(action) if action else None
     if handler is not None:
         handler()
+    elif sys.stdin.isatty() and sys.stdout.isatty():
+        _cmd_terminal(args)
     else:
         _default_action(verbose)
 

controlmesh-0.41.0/controlmesh/cli_commands/terminal.py

@@ -0,0 +1,20 @@
+"""CLI command for the ControlMesh enhanced terminal."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+
+
+def cmd_terminal(args: Sequence[str]) -> None:
+    """Run the enhanced terminal."""
+    asyncio.run(_run(args))
+
+
+async def _run(args: Sequence[str]) -> None:
+    from controlmesh.__main__ import load_config
+    from controlmesh.terminal.app import TerminalApp
+
+    config = load_config()
+    app = TerminalApp.from_args(config=config, args=args)
+    await app.run()

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/config.py

@@ -166,6 +166,29 @@ class CLIParametersConfig(BaseModel):
     gemini: list[str] = Field(default_factory=list)
 
 
+class TerminalConfig(BaseModel):
+    """Settings for the local ControlMesh enhanced terminal."""
+
+    enabled: bool = True
+    default_provider: str = "codex"
+    default_model: str = "gpt-5.5"
+    default_mode: Literal["enhanced", "native"] = "enhanced"
+    prompt: str = "cm> "
+    native_escape_command: str = "/cm"
+    back_command: str = "/back"
+    show_background_notifications: bool = True
+    background_notification_interval_seconds: float = 2.0
+    inbox_enabled: bool = True
+    memory_auto_context: bool = False
+    memory_inject_requires_confirmation: bool = True
+    pty_raw_mode: bool = True
+    pty_line_mode_fallback: bool = True
+    foreground_provider_reuse: bool = True
+    foreground_session_name: str = "terminal-main"
+    enable_background_agents: bool = True
+    native_provider_args: dict[str, list[str]] = Field(default_factory=dict)
+
+
 class MatrixConfig(BaseModel):
     """Matrix homeserver connection settings."""
 
@@ -207,6 +230,40 @@ class FeishuGroupConfig(BaseModel):
         default_factory=list,
         validation_alias=AliasChoices("allow_from_users", "allowFromUsers"),
     )
+    agent_roster: list[str] = Field(
+        default_factory=list,
+        validation_alias=AliasChoices("agent_roster", "agentRoster"),
+    )
+    default_agent: str = Field(
+        default="",
+        validation_alias=AliasChoices("default_agent", "defaultAgent"),
+    )
+    allow_interagent_handoff: bool = Field(
+        default=False,
+        validation_alias=AliasChoices("allow_interagent_handoff", "allowInteragentHandoff"),
+    )
+    max_handoff_depth: int = Field(
+        default=1,
+        validation_alias=AliasChoices("max_handoff_depth", "maxHandoffDepth"),
+    )
+
+    @field_validator("agent_roster")
+    @classmethod
+    def _validate_agent_roster(cls, value: list[str]) -> list[str]:
+        return [item.strip() for item in value if item.strip()]
+
+    @field_validator("default_agent")
+    @classmethod
+    def _validate_default_agent(cls, value: str) -> str:
+        return value.strip()
+
+    @field_validator("max_handoff_depth")
+    @classmethod
+    def _validate_max_handoff_depth(cls, value: int) -> int:
+        if value < 0:
+            msg = "Feishu group max_handoff_depth must be >= 0"
+            raise ValueError(msg)
+        return value
 
 
 class FeishuConfig(BaseModel):
@@ -617,6 +674,7 @@ class AgentConfig(BaseModel):
     webhooks: WebhookConfig = Field(default_factory=WebhookConfig)
     api: ApiConfig = Field(default_factory=ApiConfig)
     cli_parameters: CLIParametersConfig = Field(default_factory=CLIParametersConfig)
+    terminal: TerminalConfig = Field(default_factory=TerminalConfig)
     image: ImageConfig = Field(default_factory=ImageConfig)
     timeouts: TimeoutConfig = Field(default_factory=TimeoutConfig)
     tasks: TasksConfig = Field(default_factory=TasksConfig)

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/messenger/feishu/bot.py

@@ -118,6 +118,24 @@ _TextStreamCallback = Callable[[str], Awaitable[None]]
 _StatusStreamCallback = Callable[[str | None], Awaitable[None]]
 _ToolEventStreamCallback = Callable[[ToolUseEvent | ToolResultEvent], Awaitable[None]]
 _FEISHU_COMMAND_GUIDE_VERSION = 3
+_FEISHU_AGENT_TARGET_PREFIXES = ("agent:", "agent=", "@agent:")
+
+
+@dataclass(frozen=True, slots=True)
+class FeishuAgentRoute:
+    """Resolved Feishu group routing target."""
+
+    agent: str
+    text: str
+    via_default: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class SimpleTextResult:
+    """Small result adapter for Feishu delivery paths."""
+
+    text: str
+    status: str = "completed"
 
 
 def _stream_callbacks_for_output_mode(
@@ -472,12 +490,20 @@ class FeishuBot:
                     progress.start()
                 if content_key:
                     self._inflight_content_keys.add(content_key)
-                auth_routed, result = await self._run_streaming_turn(
-                    message,
-                    chat_id=chat_id,
-                    topic_id=topic_id,
-                    progress=progress,
-                )
+                route = self._resolve_group_agent_route(message)
+                if route is not None:
+                    result = await self._run_group_agent_route(
+                        message,
+                        route=route,
+                    )
+                    auth_routed = False
+                else:
+                    auth_routed, result = await self._run_streaming_turn(
+                        message,
+                        chat_id=chat_id,
+                        topic_id=topic_id,
+                        progress=progress,
+                    )
         except Exception as exc:
             await progress.finish_failure(str(exc))
             raise
@@ -1033,6 +1059,131 @@ class FeishuBot:
             return True, None
         return False, result
 
+    async def _run_group_agent_route(
+        self,
+        message: FeishuIncomingText,
+        *,
+        route: FeishuAgentRoute,
+    ) -> Any:
+        bus = self._interagent_bus()
+        if bus is None:
+            return SimpleTextResult(
+                text="Agent handoff is unavailable: multi-agent runtime is not active.",
+                status="failed",
+            )
+        prompt = self._build_group_agent_handoff_prompt(message, route=route)
+        response = await bus.send(
+            sender=self._agent_name,
+            recipient=route.agent,
+            message=prompt,
+            new_session=False,
+        )
+        if not response.success:
+            error = response.error or f"Agent `{route.agent}` did not return a result."
+            return SimpleTextResult(text=error, status="failed")
+        visible = f"[{route.agent}]\n{response.text.strip()}" if response.text.strip() else ""
+        return SimpleTextResult(text=visible, status="completed")
+
+    def _interagent_bus(self) -> Any | None:
+        if self._orchestrator is None:
+            return None
+        supervisor = getattr(self._orchestrator, "supervisor", None)
+        return getattr(supervisor, "bus", None)
+
+    def _resolve_group_agent_route(self, message: FeishuIncomingText) -> FeishuAgentRoute | None:
+        if not self._is_group_message(message):
+            return None
+        overrides = self._group_overrides_for_message(message)
+        if overrides is None:
+            return None
+        roster = self._group_agent_roster_for_message(message)
+        if not roster:
+            return None
+
+        explicit = self._extract_explicit_agent_target(message.text, roster)
+        if explicit is not None:
+            agent, routed_text = explicit
+            if agent == self._agent_name:
+                return None
+            return FeishuAgentRoute(agent=agent, text=routed_text)
+
+        default_agent = overrides.default_agent
+        if default_agent and default_agent in roster and default_agent != self._agent_name:
+            return FeishuAgentRoute(agent=default_agent, text=message.text.strip(), via_default=True)
+        return None
+
+    def _group_agent_roster_for_message(self, message: FeishuIncomingText) -> list[str]:
+        overrides = self._group_overrides_for_message(message)
+        if overrides is None:
+            return []
+        return [name for name in overrides.agent_roster if name != self._agent_name]
+
+    def _extract_explicit_agent_target(
+        self,
+        text: str,
+        roster: list[str],
+    ) -> tuple[str, str] | None:
+        stripped = text.strip()
+        if not stripped:
+            return None
+        words = stripped.split(maxsplit=1)
+        first = words[0]
+        rest = words[1].strip() if len(words) > 1 else ""
+        for prefix in _FEISHU_AGENT_TARGET_PREFIXES:
+            if first.lower().startswith(prefix):
+                candidate = first[len(prefix) :].strip()
+                if candidate in roster:
+                    return candidate, rest
+        if first.startswith("@"):
+            candidate = first[1:].strip()
+            if candidate in roster:
+                return candidate, rest
+        return None
+
+    def _build_group_agent_handoff_prompt(
+        self,
+        message: FeishuIncomingText,
+        *,
+        route: FeishuAgentRoute,
+    ) -> str:
+        overrides = self._group_overrides_for_message(message)
+        allow_handoff = bool(overrides and overrides.allow_interagent_handoff)
+        configured_depth = overrides.max_handoff_depth if allow_handoff and overrides else 0
+        handoff_depth_used = 1 if allow_handoff and configured_depth > 0 else 0
+        remaining_depth = max(configured_depth - handoff_depth_used, 0)
+
+        routed_message = FeishuIncomingText(
+            sender_id=message.sender_id,
+            chat_id=message.chat_id,
+            message_id=message.message_id,
+            text=route.text or message.text,
+            thread_id=message.thread_id,
+            create_time_ms=message.create_time_ms,
+            message_type=message.message_type,
+            root_id=message.root_id,
+            parent_id=message.parent_id,
+            quote_summary=message.quote_summary,
+            post_title=message.post_title,
+            chat_type=message.chat_type,
+            mentions_bot=message.mentions_bot,
+            replies_to_bot=message.replies_to_bot,
+        )
+        user_text = build_feishu_agent_input(routed_message)
+        return (
+            "[Feishu controlled group handoff]\n"
+            f"source_agent={self._agent_name}\n"
+            f"target_agent={route.agent}\n"
+            f"chat_id={message.chat_id}\n"
+            f"thread_id={message.thread_id or ''}\n"
+            f"reply_target=original_feishu_group_thread\n"
+            f"handoff_allowed={'true' if allow_handoff else 'false'}\n"
+            f"remaining_handoff_depth={remaining_depth}\n"
+            "Do not start a free bot-to-bot conversation. Answer this delegated request and "
+            "return the final answer here.\n"
+            "[/Feishu controlled group handoff]\n\n"
+            f"{user_text}"
+        )
+
     def _should_use_bundled_native_runtime(self) -> bool:
         if self._config.feishu.runtime_mode != "native" or self._orchestrator is None:
             return False
@@ -2079,9 +2230,6 @@ class FeishuBot:
                 open_id = mention_id.get("open_id")
                 if isinstance(open_id, str) and open_id and open_id == bot_sender_id:
                     return True
-            key = item.get("key")
-            if isinstance(key, str) and key.lower() == "@all":
-                return True
         return False
 
     def _message_replies_to_bot(self, message: dict[str, Any]) -> bool:

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/multiagent/bus.py

@@ -100,6 +100,28 @@ class AsyncInterAgentResult:
 AsyncResultCallback = Callable[["AsyncInterAgentResult"], Awaitable[None]]
 
 
+def _stack_orchestrator(stack: AgentStack):
+    """Return an orchestrator from real AgentStack or legacy test doubles."""
+    bot = getattr(stack, "bot", None)
+    if bot is not None:
+        try:
+            return bot.orchestrator
+        except AttributeError:
+            pass
+    return getattr(stack, "orchestrator", None)
+
+
+def _stack_notification_service(stack: AgentStack):
+    """Return a notification service from real AgentStack or test doubles."""
+    bot = getattr(stack, "bot", None)
+    if bot is not None:
+        try:
+            return bot.notification_service
+        except AttributeError:
+            pass
+    return getattr(stack, "notification_service", None)
+
+
 class InterAgentBus:
     """In-memory async bus for agent-to-agent communication.
 
@@ -161,7 +183,7 @@ class InterAgentBus:
         logger.info("Bus: %s -> %s (%d chars)", sender, recipient, len(message))
 
         try:
-            orch = target.bot.orchestrator
+            orch = _stack_orchestrator(target)
             if orch is None:
                 return InterAgentResponse(
                     sender=recipient,
@@ -272,7 +294,7 @@ class InterAgentBus:
         t0 = time.time()
         try:
             target = self._agents[task.recipient]
-            orch = target.bot.orchestrator
+            orch = _stack_orchestrator(target)
             if orch is None:
                 await self._deliver_async_result(
                     AsyncInterAgentResult(
@@ -381,7 +403,9 @@ class InterAgentBus:
             if target is None:
                 return
 
-            ns = target.bot.notification_service
+            ns = _stack_notification_service(target)
+            if ns is None:
+                return
 
             # Use explicit summary if provided, otherwise truncate message
             if task.summary:

{controlmesh-0.40.2 → controlmesh-0.41.0}/controlmesh/multiagent/models.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Literal
 
 from pydantic import BaseModel
 
@@ -28,14 +29,17 @@ class SubAgentConfig(BaseModel):
     """
 
     name: str
+    mode: Literal["transport", "headless"] = "transport"
     transport: str = "telegram"  # "telegram" | "matrix"
+    workspace_policy: Literal["isolated", "shared", "shared_readonly"] = "isolated"
+    terminal_visible: bool = True
 
-    # Telegram credentials (required when transport=telegram)
+    # Telegram credentials (required when mode=transport and transport=telegram)
     telegram_token: str = ""
     allowed_user_ids: list[int] | None = None
     allowed_group_ids: list[int] | None = None
 
-    # Matrix credentials (required when transport=matrix)
+    # Matrix credentials (required when mode=transport and transport=matrix)
     matrix: MatrixConfig | None = None
 
     # Group behaviour