auto-coder 3.0.34__tar.gz → 3.0.36__tar.gz

{auto_coder-3.0.34/src/auto_coder.egg-info → auto_coder-3.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.34
+Version: 3.0.36
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.34 → auto_coder-3.0.36}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.34"
+version = "3.0.36"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}

{auto_coder-3.0.34 → auto_coder-3.0.36/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.34
+Version: 3.0.36
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/auto_coder.egg-info/SOURCES.txt

@@ -545,6 +545,8 @@ src/autocoder/common/v2/agent/subagents/models.py
 src/autocoder/common/v2/agent/subagents/prompt_provider.py
 src/autocoder/common/v2/agent/subagents/backends/__init__.py
 src/autocoder/common/v2/agent/subagents/backends/cli_process.py
+src/autocoder/common/v2/agent/subagents/backends/external_cli_drivers.py
+src/autocoder/common/v2/agent/subagents/backends/external_cli_process.py
 src/autocoder/common/v2/agent/subagents/backends/in_process.py
 src/autocoder/common/v2/agent/subagents/tests/__init__.py
 src/autocoder/common/v2/agent/subagents/tests/test_subagent_client.py

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/rulefiles/api.py

@@ -118,6 +118,7 @@ def get_required_and_index_rules(
     *,
     is_sub_agent: bool = False,
     subagent_name: str | None = None,
+    args: AutoCoderArgs | None = None,
 ) -> dict[str, str]:
     """
     获取所有必须应用的规则文件(always_apply=True)和Index.md文件。
@@ -135,14 +136,19 @@ def get_required_and_index_rules(
     )
 
     for rule in filtered:
+        content = rule.content
+        # 如果提供了args，尝试渲染模板
+        if args is not None:
+            content = _rules_manager.render_rule_content(rule, args)
+            
         if rule.always_apply:
-            result[rule.file_path] = rule.content
+            result[rule.file_path] = content
             logger.debug(
                 f"[RULES] 添加必须应用的规则 | stage=load file_path={os.path.basename(rule.file_path)}"
             )
 
         if os.path.basename(rule.file_path).lower() == "index.md":
-            result[rule.file_path] = rule.content
+            result[rule.file_path] = content
             logger.debug(
                 f"[RULES] 添加Index.md文件 | stage=load file_path={rule.file_path}"
             )
@@ -246,6 +252,7 @@ def get_rules_for_conversation(
     *,
     is_sub_agent: bool = False,
     subagent_name: str | None = None,
+    args: AutoCoderArgs | None = None,
 ) -> str | None:
     """
     获取格式化的规则文本，用于添加到对话中。
@@ -294,7 +301,13 @@ def get_rules_for_conversation(
                         f"**Applicable Files**: {', '.join(rule.globs)}"
                     )
                 message_parts.append("")
-                message_parts.append(rule.content)
+                
+                # 如果提供了args，尝试渲染模板
+                content = rule.content
+                if args is not None and _rules_manager is not None:
+                    content = _rules_manager.render_rule_content(rule, args)
+                    
+                message_parts.append(content)
                 message_parts.append("")
 
         # 添加条件规则的描述和路径

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/rulefiles/core/manager.py

@@ -9,9 +9,10 @@ import os
 import re
 import time
 from threading import Lock
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import yaml
+from jinja2 import Template, TemplateError
 from loguru import logger
 
 # 导入数据模型
@@ -286,6 +287,7 @@ class AutocoderRulesManager:
                 globs=metadata.get("globs", []),
                 always_apply=metadata.get("alwaysApply", False),
                 subagents=_normalize_subagents(metadata.get("subagents")),
+                variables=metadata.get("variables", {}),
                 content=markdown_content.strip(),
                 file_path=file_path,
             )
@@ -346,6 +348,44 @@ class AutocoderRulesManager:
             parsed_rule = self.parse_rule_file(file_path)
             parsed_rules.append(parsed_rule)
         return parsed_rules
+        
+    def render_rule_content(self, rule: RuleFile, args: Any) -> str:
+        """
+        使用Jinja2渲染规则正文内容
+        
+        Args:
+            rule: 规则文件对象
+            args: AutoCoderArgs配置对象
+            
+        Returns:
+            str: 渲染后的规则内容
+            
+        Raises:
+            TemplateError: 当模板渲染出错时抛出，便于上层处理
+        """
+        # 如果没有变量也没有模板标记，直接返回原始内容
+        content = rule.content
+        if not rule.variables and "{{" not in content and "{%" not in content:
+            return content
+            
+        try:
+            # 构建安全的上下文，仅暴露必要信息
+            context = {
+                "args": args,
+                "variables": rule.variables
+            }
+            
+            # 创建模板并渲染
+            template = Template(content)
+            rendered_content = template.render(context)
+            return rendered_content
+            
+        except TemplateError as e:
+            logger.error(
+                f"[RULES] 规则模板渲染失败 | stage=render file_path={rule.file_path} error={str(e)}"
+            )
+            # 渲染错误时抛出异常，保持错误可见
+            raise RuntimeError(f"规则文件 {rule.file_path} 模板渲染失败: {str(e)}") from e
 
     @classmethod
     def reset_instance(cls):

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/rulefiles/models/rule_file.py

@@ -22,5 +22,6 @@ class RuleFile(BaseModel):
             '["*"]=任何子 agent 都加载'
         ),
     )
+    variables: dict = Field(default_factory=dict, description="规则文件中定义的模板变量")
     content: str = Field(default="", description="规则文件的正文内容")
     file_path: str = Field(default="", description="规则文件的路径")

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/rulefiles/test_rulefiles.py

@@ -26,6 +26,7 @@ from autocoder.common.rulefiles import (
     get_required_and_index_rules,
     get_rules,
     get_rules_cache_stats,
+    get_rules_for_conversation,
     invalidate_rules_cache,
     parse_rule_file,
     reset_rules_manager,
@@ -832,3 +833,187 @@ class TestIntegrationScenarios:
             # 清理所有缓存管理器
             for cache_manager in cache_managers:
                 cache_manager.cleanup()
+
+
+
+
+class TestRuleTemplateRendering:
+    """测试规则文件Jinja2模板渲染功能"""
+    
+    def test_variables_front_matter_parsing(self, temp_project_dir, rules_dir):
+        """测试variables front-matter字段解析功能
+        验证：
+        1. variables字段能正确从YAML头中解析为字典
+        2. 没有variables字段时默认是空字典
+        """
+        # 创建带variables的规则文件
+        rule_content = """---
+description: 测试变量
+variables:
+  project_name: AutoCoder
+  version: 0.1.0
+  features:
+    - 多语言支持
+    - 模板渲染
+alwaysApply: true
+---
+这是规则内容
+"""
+        rule_file = os.path.join(rules_dir, "test_variables.md")
+        with open(rule_file, "w", encoding="utf-8") as f:
+            f.write(rule_content)
+            
+        # 解析规则
+        rules = get_parsed_rules()
+        assert len(rules) == 1
+        rule = rules[0]
+        
+        # 验证变量正确解析
+        assert rule.variables == {
+            "project_name": "AutoCoder",
+            "version": "0.1.0",
+            "features": ["多语言支持", "模板渲染"]
+        }
+        assert rule.always_apply is True
+        
+        # 创建没有variables字段的规则文件
+        rule_content2 = """---
+description: 无变量测试
+alwaysApply: true
+---
+这是无变量规则内容
+"""
+        rule_file2 = os.path.join(rules_dir, "test_no_variables.md")
+        with open(rule_file2, "w", encoding="utf-8") as f:
+            f.write(rule_content2)
+            
+        reset_rules_manager()
+        rules = get_parsed_rules()
+        assert len(rules) == 2
+        rule_without_vars = [r for r in rules if "no_variables" in r.file_path][0]
+        assert rule_without_vars.variables == {}  # 没有variables字段时默认是空字典
+        
+    def test_template_rendering_with_args_and_variables(self, temp_project_dir, rules_dir):
+        """测试模板渲染功能，同时使用args和variables
+        验证：
+        1. 能正确引用args中的属性
+        2. 能正确引用variables中的属性
+        3. 渲染结果正确
+        """
+        # 创建带模板的规则文件
+        rule_content = """---
+description: 模板测试
+variables:
+  project_name: AutoCoder
+  default_model: gpt-4o
+alwaysApply: true
+---
+项目名称：{{ variables.project_name }}
+默认模型：{{ variables.default_model }}
+当前模型：{{ args.model }}
+查询：{{ args.query }}
+"""
+        rule_file = os.path.join(rules_dir, "test_template.md")
+        with open(rule_file, "w", encoding="utf-8") as f:
+            f.write(rule_content)
+            
+        # 模拟AutoCoderArgs对象
+        mock_args = Mock()
+        mock_args.model = "doubao-seed-2.0-pro"
+        mock_args.query = "实现新功能"
+        
+        # 获取必须应用的规则并渲染
+        rules_content = get_required_and_index_rules(args=mock_args)
+        assert len(rules_content) == 1
+        content = list(rules_content.values())[0]
+        
+        # 验证渲染结果
+        assert "项目名称：AutoCoder" in content
+        assert "默认模型：gpt-4o" in content
+        assert "当前模型：doubao-seed-2.0-pro" in content
+        assert "查询：实现新功能" in content
+        
+    def test_backward_compatibility_no_template(self, temp_project_dir, rules_dir):
+        """测试向后兼容性：没有模板标记的规则内容保持不变
+        验证：
+        1. 没有{{和{%标记的内容直接返回原始值
+        2. 即使提供了args，没有模板标记也不会改变内容
+        """
+        rule_content = """---
+description: 无模板测试
+alwaysApply: true
+---
+这是普通规则内容，没有模板标记
+包含一些特殊字符但不是模板语法
+纯文本内容应该原样保留
+"""
+        rule_file = os.path.join(rules_dir, "test_no_template.md")
+        with open(rule_file, "w", encoding="utf-8") as f:
+            f.write(rule_content)
+            
+        mock_args = Mock()
+        mock_args.model = "test-model"
+        
+        # 没有模板标记的内容应该保持不变
+        rules_content = get_required_and_index_rules(args=mock_args)
+        assert len(rules_content) == 1
+        content = list(rules_content.values())[0]
+        
+        assert "这是普通规则内容，没有模板标记" in content
+        assert "包含一些特殊字符但不是模板语法" in content
+        assert "纯文本内容应该原样保留" in content
+        
+    def test_template_rendering_error_handling(self, temp_project_dir, rules_dir):
+        """测试模板渲染错误处理
+        验证：
+        1. 模板语法错误时会抛出异常
+        2. 错误信息包含文件路径和具体错误原因
+        """
+        # 创建有语法错误的模板
+        rule_content = """---
+description: 错误模板测试
+alwaysApply: true
+---
+这是错误的模板：{{ args.non_existent_attribute + }}
+"""
+        rule_file = os.path.join(rules_dir, "test_error_template.md")
+        with open(rule_file, "w", encoding="utf-8") as f:
+            f.write(rule_content)
+            
+        mock_args = Mock()
+        mock_args.model = "test-model"
+        
+        # 验证渲染失败会抛出异常
+        with pytest.raises(RuntimeError) as exc_info:
+            get_required_and_index_rules(args=mock_args)
+            
+        assert "test_error_template.md" in str(exc_info.value)
+        assert "模板渲染失败" in str(exc_info.value)
+        
+    def test_get_rules_for_conversation_rendering(self, temp_project_dir, rules_dir):
+        """测试get_rules_for_conversation接口也支持模板渲染
+        验证：
+        1. 对话用的规则内容也会被正确渲染
+        """
+        rule_content = """---
+description: 对话规则测试
+variables:
+  rule_type: 对话规则
+alwaysApply: true
+---
+这是对话中的规则，当前模型是：{{ args.model }}
+规则类型：{{ variables.rule_type }}
+"""
+        rule_file = os.path.join(rules_dir, "test_conversation_rule.md")
+        with open(rule_file, "w", encoding="utf-8") as f:
+            f.write(rule_content)
+            
+        mock_args = Mock()
+        mock_args.model = "conversation-model"
+        
+        # 获取对话规则
+        rules_text = get_rules_for_conversation(args=mock_args)
+        assert rules_text is not None
+        assert "当前模型是：conversation-model" in rules_text
+        assert "规则类型：对话规则" in rules_text
+

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/rulefiles/utils/parser.py

@@ -77,6 +77,7 @@ def parse_rule_file(file_path: str) -> RuleFile:
             globs=metadata.get("globs", []),
             always_apply=metadata.get("alwaysApply", False),
             subagents=_normalize_subagents(metadata.get("subagents")),
+            variables=metadata.get("variables", {}),
             content=markdown_content.strip(),
             file_path=file_path,
         )

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/terminal_paste/paste_handler.py

@@ -216,11 +216,6 @@ def resolve_paste_placeholders(text: str) -> str:
     # Replace all placeholders in the text
     resolved_text = PLACEHOLDER_PATTERN.sub(replace_placeholder, text)
 
-    # Show user if any replacements were made
-    if resolved_text != text:
-        placeholder_count = len(PLACEHOLDER_PATTERN.findall(text))
-        print(f"\033[92m✓ Resolved {placeholder_count} paste placeholder(s)\033[0m")
-
     return resolved_text
 
 

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -986,7 +986,7 @@ class AgenticEdit:
          </run_named_subagents>
 
          ## run_subagents
-         Description: Run subagents using the unified SubagentClient API. Supports in-process (default, faster, shares memory) and cli-process (isolated subprocess) backends. Use this tool for better performance and structured result handling.
+         Description: Run subagents using the unified SubagentClient API. Supports three backends: in-process (default, faster, shares memory), cli-process (isolated auto-coder.run subprocess), and external-cli-process (external CLI tools like Cursor CLI or Claude Code CLI). Each subagent runs in a completely isolated new session — no session sharing or resumption between subagents.
          Parameters:
          - subagents: (required) The subagents to run, in JSON or YAML format.
            - A JSON Array: [{"name": "agent_name", "task": "task description", "model": "optional_model"}]
@@ -1000,7 +1000,11 @@ class AgenticEdit:
              - name: (optional) A label for this subagent. If the name matches a pre-defined agent in .autocoderagents, its system prompt and model will be loaded automatically. Otherwise the subagent runs with the default system prompt.
              - task: (required) The task description for the subagent
              - model: (optional) Override the model for this specific subagent. If not specified, uses the model defined in the agent definition or the current model.
-         - backend: (optional) Execution backend. "in_process" (default, faster) or "cli_process" (isolated subprocess). Default is "in_process".
+         - backend: (optional) Execution backend. Default is "in_process".
+             - "in_process": fastest, shares memory with parent agent
+             - "cli_process": isolated auto-coder.run subprocess
+             - "external_cli_process": external CLI tool (requires external_cli parameter)
+         - external_cli: (optional) Which external CLI to use when backend is "external_cli_process". Must be "cursor" (Cursor CLI) or "claude_code" (Claude Code CLI). The external CLI tool must be installed and authenticated.
          - max_concurrency: (optional) Maximum number of subagents to run in parallel. Only applies when mode is "parallel". Default is no limit (all run concurrently).
          Usage:
          <run_subagents>
@@ -2163,11 +2167,11 @@ class AgenticEdit:
 
          ===
 
-         SUB AGENTS
+         SUBAGENTS
 
          ## Overview
 
-         When facing complex tasks that can be decomposed into independent subtasks, you can leverage the `run_subagents` tool to delegate work to sub-agents. Sub-agents run in-process by default (fast, shares memory) or as isolated CLI subprocesses. This allows you to delegate specific, isolated tasks to separate AI instances, significantly improving efficiency and task completion speed.
+         When facing complex tasks that can be decomposed into independent subtasks, you can leverage the `run_subagents` tool to delegate work to sub-agents. Sub-agents run in-process by default (fast, shares memory), as isolated auto-coder.run CLI subprocesses, or via external CLI tools (Cursor CLI / Claude Code CLI). Each subagent always runs in a completely isolated new session — no two subagents share context or conversation history. This allows you to delegate specific, isolated tasks to separate AI instances, significantly improving efficiency and task completion speed.
 
          ## When to Use Sub-Agents
 
@@ -2285,8 +2289,9 @@ class AgenticEdit:
 
          ### Backend Selection
 
-         - `in_process` (default): Faster, shares memory with the parent agent. Best for most tasks.
+         - `in_process` (default): Fastest, shares memory with the parent agent. Best for most tasks.
          - `cli_process`: Runs as isolated `auto-coder.run` subprocess. Use when full process isolation is required.
+         - `external_cli_process`: Runs via an external CLI tool. Set `external_cli` to `"cursor"` (Cursor CLI `agent` command) or `"claude_code"` (Claude Code CLI `claude` command). The external tool must be installed and authenticated by the user. Use when you want to leverage a different AI agent runtime.
 
          ### Task Delegation Strategy
          1. Analyze the main task to identify independent subtasks
@@ -2313,28 +2318,15 @@ class AgenticEdit:
 
          ## Limitations and Considerations
 
-         1. No Inter-Task Communication: Sub-agents cannot communicate with each other
-         2. No Shared Context: Each sub-agent starts with a fresh context, make sure you provide the enough context for each sub-agent
-
-         ## Get specific sub-agent output
-
-         If you want to control the final output of the subagent, you can add the following content in your prompt/task description
-         when invoking the subagent:
-
-         you should output what you find in attempt_completion tool in this format:
-
-         ```json
-         {
-            "files": [
-               {
-                  "path": "path/to/file.py",
-                  "operation": "modify"
-               }
-            ]
-         }
-         ```
-
-         you can always get the output of the subagent by using the attempt_completion tool.
+         1. **No Inter-Task Communication**: Sub-agents cannot communicate with each other during execution. There is no message passing, shared memory, or signaling mechanism between concurrent sub-agents.
+         2. **No Shared Context — This is critical**: Each sub-agent starts with a completely fresh, empty context. Sub-agents do NOT inherit your conversation history, previously read file contents, analysis results, or any other state from the parent agent. Consecutive sub-agents also do NOT share context with each other — the output of sub-agent A is NOT automatically available to sub-agent B.
+            Therefore, you MUST explicitly include ALL necessary context in each sub-agent's `task` field. This includes:
+            - **File paths**: Exact file paths that the sub-agent needs to read or modify (do not assume the sub-agent knows which files are relevant)
+            - **Code snippets / signatures**: If the sub-agent needs to know about specific classes, functions, or data structures, paste the relevant code or signatures directly into the task description
+            - **Findings from previous sub-agents**: If this sub-agent depends on results from an earlier sub-agent, you must copy those results into the task description verbatim
+            - **Project conventions**: Any coding style, naming conventions, or architectural patterns the sub-agent should follow
+            - **Modification instructions**: Precise descriptions of what to change, including the old code and new code when possible
+            Treat each sub-agent's `task` field as a **self-contained, standalone brief** — it should contain everything the sub-agent needs to complete its work without asking any follow-up questions.                
 
          ## Advanced Pattern: Staged Parallel Execution
 

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/agentic_edit_tools/execute_external_tool_resolver.py

@@ -492,8 +492,9 @@ class ExecuteExternalToolResolver(BaseToolResolver):
             else:
                 # 前台执行
                 timeout = self.tool.timeout
+                verbose = not get_run_context().is_terminal()
                 exit_code, output = execute_command(
-                    command, timeout=timeout, verbose=True, cwd=source_dir
+                    command, timeout=timeout, verbose=verbose, cwd=source_dir
                 )
 
                 logger.info(f"External tool executed: {masked_command}")

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/agentic_edit_tools/run_named_subagents_tool_resolver.py

@@ -337,8 +337,10 @@ class RunNamedSubagentsToolResolver(BaseToolResolver):
                 )
 
                 project_root = self.args.source_dir or "."
+                from autocoder.run_context import get_run_context
+                verbose = not get_run_context().is_terminal()
                 process_info = execute_command_background(
-                    command=argv, cwd=project_root, verbose=True
+                    command=argv, cwd=project_root, verbose=verbose
                 )
 
                 bg_proc: Dict[str, Any] = {

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/agentic_edit_tools/run_subagents_tool_resolver.py

@@ -1,8 +1,10 @@
 """
 Run Subagents Tool Resolver
 
-通过 SubagentClient 统一 API 执行子代理，支持 in_process / cli_process 后端切换
-和并发控制（max_concurrency）。
+通过 SubagentClient 统一 API 执行子代理，支持 in_process / cli_process /
+external_cli_process 后端切换和并发控制（max_concurrency）。
+
+每个 subagent 强制使用全新独立会话（share_mode=NEW），禁止任何会话共享或恢复。
 
 实现了 resolve_stream()，在子代理执行期间向 TUI 推送进度信息
 （ToolStreamEvent），避免长时间无反馈。
@@ -17,7 +19,6 @@ import yaml
 from loguru import logger
 
 from autocoder.common import AutoCoderArgs
-from autocoder.common.agents import AgentManager
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import (
     BaseToolResolver,
 )
@@ -41,9 +42,10 @@ class RunSubagentsToolResolver(BaseToolResolver):
 
     与 RunNamedSubagentsToolResolver 的区别：
     - 使用 SubagentClient 统一 API 而非 shell 命令拼接
-    - 支持 in_process（默认）和 cli_process 两种后端
+    - 支持 in_process（默认）、cli_process 和 external_cli_process 三种后端
     - 通过 max_concurrency 参数控制并行度
     - 返回结构化 SubagentResult
+    - 强制每个 subagent 使用全新独立会话（share_mode=NEW）
     """
 
     def __init__(
@@ -55,9 +57,6 @@ class RunSubagentsToolResolver(BaseToolResolver):
         super().__init__(agent, tool, args)
         self.tool: RunSubagentsTool = tool
 
-        project_root = args.source_dir if args.source_dir else "."
-        self.agent_manager = AgentManager(project_root)
-
     def resolve(self) -> ToolResult:
         from autocoder.common.v2.agent.agentic_edit_tools.run_named_subagents_tool_resolver import (
             _check_subagent_recursion,
@@ -216,7 +215,10 @@ class RunSubagentsToolResolver(BaseToolResolver):
             ]
             parallel = execution_mode == "parallel"
 
-            model_display = self.args.model or "unknown"
+            if backend_str == "external_cli_process":
+                model_display = "external CLI default"
+            else:
+                model_display = self.args.model or "unknown"
             yield f"Starting {total} sub-agents ({execution_mode} mode, backend={backend_str}, model={model_display})...\n"
             for i, name in enumerate(agent_names):
                 task_preview = subagents_list[i]["task"][:60]
@@ -314,11 +316,12 @@ class RunSubagentsToolResolver(BaseToolResolver):
         mapping = {
             "in_process": SubagentBackend.IN_PROCESS,
             "cli_process": SubagentBackend.CLI_PROCESS,
+            "external_cli_process": SubagentBackend.EXTERNAL_CLI_PROCESS,
         }
         if backend_str not in mapping:
             raise ValueError(
                 f"无效的 backend: '{backend_str}'，"
-                f"必须是 'in_process' 或 'cli_process'"
+                f"必须是 'in_process'、'cli_process' 或 'external_cli_process'"
             )
         return mapping[backend_str]
 
@@ -371,9 +374,9 @@ class RunSubagentsToolResolver(BaseToolResolver):
     ) -> Dict[str, Any]:
         """校验格式和必填字段。
 
-        注意：run_subagents 是通用工具，agent name 不要求在 .autocoderagents
-        中预定义。如果 name 对应的 agent 不存在，SubagentClient 会优雅降级
-        （不注入 system_prompt，使用默认提示词）。
+        注意：run_subagents 是通用工具，不会加载 .autocoderagents 中的 agent
+        定义。name 仅用于展示标签，不会触发 agent spec 查找或模型回填。
+        如需使用预定义 agent，请使用 run_named_subagents。
         """
         errors: List[str] = []
 
@@ -398,23 +401,41 @@ class RunSubagentsToolResolver(BaseToolResolver):
         subagents_list: List[Dict[str, str]],
         backend: "SubagentBackend",
     ) -> List["SubagentRequest"]:
-        from autocoder.common.v2.agent.subagents import SubagentRequest
+        from autocoder.common.v2.agent.subagents import (
+            ExternalCLIType,
+            SubagentBackend as _SubagentBackend,
+            SubagentRequest,
+            SubagentSessionOptions,
+            SubagentSessionShareMode,
+        )
 
         requests: List[SubagentRequest] = []
         timeout = self.args.call_subagent_timeout
+        tool_external_cli = self.tool.external_cli
 
         for entry in subagents_list:
             task = entry["task"]
             agent_name = entry.get("name") or None
             model = entry.get("model") or None
 
+            external_cli: Optional[ExternalCLIType] = None
+            if backend == _SubagentBackend.EXTERNAL_CLI_PROCESS:
+                external_cli_str = entry.get("external_cli") or tool_external_cli
+                if external_cli_str:
+                    external_cli = ExternalCLIType(external_cli_str)
+
             requests.append(
                 SubagentRequest(
                     task=task,
                     agent_name=agent_name,
                     backend=backend,
+                    external_cli=external_cli,
                     model=model,
                     timeout_seconds=int(timeout) if timeout else None,
+                    session=SubagentSessionOptions(
+                        share_mode=SubagentSessionShareMode.NEW,
+                    ),
+                    resolve_agent_spec=False,
                 )
             )
 

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/agentic_edit_types.py

@@ -161,11 +161,16 @@ class RunNamedSubagentsTool(BaseTool):
 class RunSubagentsTool(BaseTool):
     """
     Tool for running subagents via SubagentClient.
-    Supports in_process and cli_process backends with concurrency control.
+    Supports in_process, cli_process and external_cli_process backends
+    with concurrency control.
+
+    When backend="external_cli_process", external_cli must be set to
+    "cursor" or "claude_code" to select the external CLI tool.
     """
 
     subagents: str
     backend: Optional[str] = "in_process"
+    external_cli: Optional[str] = None
     max_concurrency: Optional[int] = None
 
 

{auto_coder-3.0.34 → auto_coder-3.0.36}/src/autocoder/common/v2/agent/subagents/__init__.py

@@ -19,6 +19,7 @@ Usage::
 from .client import SubagentClient
 from .models import (
     AgentPromptSpec,
+    ExternalCLIType,
     SubagentBackend,
     SubagentRequest,
     SubagentResult,
@@ -32,6 +33,7 @@ __all__ = [
     "SubagentRequest",
     "SubagentResult",
     "SubagentBackend",
+    "ExternalCLIType",
     "SubagentSessionShareMode",
     "SubagentSessionOptions",
     "AgentPromptSpec",

auto_coder-3.0.36/src/autocoder/common/v2/agent/subagents/backends/__init__.py

@@ -0,0 +1,5 @@
+from .in_process import InProcessBackend
+from .cli_process import CLIProcessBackend
+from .external_cli_process import ExternalCLIProcessBackend
+
+__all__ = ["InProcessBackend", "CLIProcessBackend", "ExternalCLIProcessBackend"]