auto-coder 3.0.64__tar.gz → 3.0.65__tar.gz

{auto_coder-3.0.64/src/auto_coder.egg-info → auto_coder-3.0.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.64
+Version: 3.0.65
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.64 → auto_coder-3.0.65}/pyproject.toml

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

{auto_coder-3.0.64 → auto_coder-3.0.65/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.64
+Version: 3.0.65
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/auto_coder.egg-info/SOURCES.txt

@@ -674,6 +674,7 @@ src/autocoder/dream/computer_index_query.py
 src/autocoder/dream/computer_index_xpath.py
 src/autocoder/dream/defaults.py
 src/autocoder/dream/extractor.py
+src/autocoder/dream/jobs_jsonl.py
 src/autocoder/dream/models.py
 src/autocoder/dream/paths.py
 src/autocoder/dream/processor.py
@@ -683,6 +684,9 @@ src/autocoder/dream/service.py
 src/autocoder/dream/sources.py
 src/autocoder/dream/store.py
 src/autocoder/dream/test_agenda.py
+src/autocoder/dream/test_agenda_history_reconciliation.py
+src/autocoder/dream/test_agenda_review_cas.py
+src/autocoder/dream/test_jobs_jsonl.py
 src/autocoder/dream/test_store_artifacts.py
 src/autocoder/dream/test_store_jobs.py
 src/autocoder/events/__init__.py
@@ -947,6 +951,7 @@ src/autocoder/terminal/utils/errors.py
 src/autocoder/terminal/utils/paths.py
 src/autocoder/terminal/utils/shell.py
 src/autocoder/terminal_core/__init__.py
+src/autocoder/terminal_core/agent_profiles.py
 src/autocoder/terminal_core/backends.py
 src/autocoder/terminal_core/cloud_block_command.py
 src/autocoder/terminal_core/cloud_bridge.py
@@ -1033,6 +1038,7 @@ src/autocoder/workflow_agents/tests/test_loader.py
 src/autocoder/workflow_agents/tests/test_session.py
 src/autocoder/workflow_agents/tests/test_types.py
 src/autocoder/workflow_agents/tests/test_utils.py
+tests/test_agent_profiles.py
 tests/test_agent_session_tools.py
 tests/test_agentic_edit_finalize_session.py
 tests/test_args_parser.py

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/auto_coder_terminal_v3.py

@@ -70,6 +70,7 @@ V3_COMMANDS = [
     "/sessions",
     "/side",
     "/status",
+    "/switch_model",
     "/tunnel",
     "/workflow",
 ]

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/backends/providers/cursor/provider.py

@@ -7,11 +7,15 @@ from autocoder.tools.agent_session_models import BackendConversation
 from . import session
 
 CURSOR_AGENT_MODEL_IDS = {
+    "claude-fable-5-max",
+    "claude-fable-5-thinking-max",
     "composer-2.5-fast",
     "glm-5.2-max",
     "gpt-5.5-extra-high",
+    "gpt-5.6-sol-max",
     "claude-4.6-opus-max",
     "claude-opus-4-8-xhigh",
+    "grok-4.5-fast-high",
 }
 
 

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/chat/conf_spec.py

@@ -179,6 +179,16 @@ def get_config_value_candidates(
                 if sv.startswith(value_prefix):
                     candidates.append((sv, sv))
             return candidates
+        allowed_items = spec.get("allowed_items")
+        if allowed_items:
+            prefix_head, separator, item_prefix = value_prefix.rpartition(",")
+            rendered_prefix = f"{prefix_head}," if separator else ""
+            for value in allowed_items:
+                item = str(value)
+                if item.startswith(item_prefix):
+                    candidate = f"{rendered_prefix}{item}"
+                    candidates.append((candidate, candidate))
+            return candidates
 
     field_info = AutoCoderArgs.model_fields.get(key)
     if field_info and field_info.annotation is bool:
@@ -187,6 +197,31 @@ def get_config_value_candidates(
                 candidates.append((v, v))
         return candidates
 
+    if key == "agent_backend_model":
+        conf = conf or {}
+        backend_values = [
+            item.strip()
+            for item in str(conf.get("agent_backend", "") or "").split(",")
+            if item.strip()
+        ]
+        profile_index = value_prefix.count(",")
+        if backend_values and profile_index < len(backend_values):
+            backend_value = backend_values[profile_index]
+            try:
+                backend = backend_registry.normalize(backend_value)
+            except ValueError:
+                backend = None
+            completed_prefix, separator, model_prefix = value_prefix.rpartition(",")
+            rendered_prefix = f"{completed_prefix}," if separator else ""
+            for model, display in _backend_model_hint_pairs(
+                key,
+                backend,
+                model_names=model_names,
+            ):
+                if model.startswith(model_prefix) or not model_prefix:
+                    candidates.append((f"{rendered_prefix}{model}", display))
+            return candidates
+
     if key in BACKEND_AWARE_MODEL_KEYS:
         backend = resolve_model_key_backend(key, conf)
         for model, display in _backend_model_hint_pairs(
@@ -294,6 +329,9 @@ def resolve_model_key_backend(
             backend_value = ConfigValidator.CONFIG_SPEC.get(
                 backend_config_key, {}
             ).get("default", "auto-coder")
+        # agent_backend may now be a comma-separated profile list. Completion
+        # for agent_backend_model starts with the default profile's backend.
+        backend_value = backend_value.split(",", 1)[0].strip()
         normalized = backend_value.lower().replace("_", "-")
         if normalized in _DISABLED_BACKEND_VALUES:
             return None

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/command_skills.py

@@ -332,9 +332,10 @@ auto-coder.run --skill
 
 Use `auto-coder.chat.lite` when a human or operator needs the main interactive
 AutoCoder experience: full-screen prompt_toolkit TUI, slash commands,
-conversation history, `/conf`, `/models`, `/auto`, `/goal`, `/connect`, and
-local workflow control. When connected to auto-coder.chat, it can also hand
-the current conversation to another online instance with `/handoff`.
+conversation history, `/conf`, `/switch_model`, `/models`, `/auto`, `/goal`,
+`/connect`, and local workflow control. When connected to auto-coder.chat, it
+can also hand the current conversation to another online instance with
+`/handoff`.
 
 It can also connect to auto-coder.chat through CloudBridge, but starting it
 opens the TUI. For a background remote execution node without UI, use
@@ -378,6 +379,11 @@ Inside the TUI, use slash commands:
 /conf goal-model:gpt-5-codex
 /conf goal-verifier-backend:codex
 /conf goal-verifier-model:gpt-5.5
+/conf agent_backend:codex,cursor
+/conf agent_backend_model:gpt-5.5,composer-2.5-fast
+/switch_model
+/switch_model 2
+/switch_model reset
 /models /list
 /connect <api_key> [base_url]
 /fusion --fusion_code_models codex:gpt-5.5:2 --fusion_review_models cursor::1 fix the failing tests
@@ -400,6 +406,15 @@ Inside the TUI, use slash commands:
 `/new` and the new foreground main session created by `/bg` use simple
 conversation names such as `main01`, `main02`, and so on.
 
+`agent_backend` and `agent_backend_model` may contain positionally paired,
+comma-separated values. Profile #1 is the global default. `/switch_model N`
+stores the resolved backend/model pair in the current conversation, so other
+conversations remain unchanged and list reordering does not silently retarget
+the selection. `/switch_model reset` clears the conversation selection. When
+more than one profile is configured, this local catalog is authoritative for
+CloudBridge runs; Dashboard backend/model hints remain active in legacy
+single-profile mode.
+
 ## Cloud behavior
 
 If cloud config is complete, `auto-coder.chat.lite` creates:
@@ -413,6 +428,8 @@ CloudBridge.start()
 It registers the current project with the remote auto-coder.chat service,
 heartbeats, polls pending runs, executes through `ExecutionBroker`, and reports
 results. The same bridge engine is reused by `auto-coder.cloud`.
+Remote `/switch_model` commands use the same project profile list and persist
+against the mapped local conversation before subsequent runs are executed.
 
 `/handoff` lists other online instances for the same cloud account, exports the
 current local conversation as Markdown, uploads that Markdown as a run
@@ -497,6 +514,14 @@ Local service state:
 ~/.auto-coder/daemon/logs/<service_id>.log
 ```
 
+Agent execution profiles use the project's `/conf` values. Configure
+positionally paired comma-separated lists in `agent_backend` and
+`agent_backend_model`; profile #1 is the default. A remote
+`/switch_model <number>` command persists the selected pair on that mapped
+conversation, while `/switch_model reset` restores the default profile. In
+multi-profile mode the local catalog takes precedence over Dashboard run
+hints; single-profile projects retain the previous Dashboard behavior.
+
 ## Execution chain
 
 ```text

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/common/conf_validator.py

@@ -85,14 +85,14 @@ class ConfigValidator:
         },
         "agent_backend": {
             "type": str,
-            "allowed": ["auto-coder", "codex", "cursor", "claude-code"],
+            "allowed_items": ["auto-coder", "codex", "cursor", "claude-code"],
             "default": "auto-coder",
-            "description": "Agent执行后端(auto-coder/codex/cursor/claude-code)"
+            "description": "Agent执行后端列表，多个用逗号分隔并与 agent_backend_model 按位置配对"
         },
         "agent_backend_model": {
             "type": str,
             "default": "",
-            "description": "外部Agent后端默认模型(留空使用后端自身默认)"
+            "description": "Agent后端模型列表，多个用逗号分隔并与 agent_backend 按位置配对"
         },
         "goal-backend": {
             "type": str,
@@ -281,7 +281,21 @@ class ConfigValidator:
             )
 
         # 枚举值检查
-        if 'allowed' in spec and converted_value not in spec['allowed']:
+        if 'allowed_items' in spec:
+            items = [item.strip() for item in str(converted_value).split(',')]
+            invalid_items = [
+                item for item in items
+                if not item or item not in spec['allowed_items']
+            ]
+            if invalid_items:
+                raise ConfigValidationError(
+                    get_message_with_format(
+                        "invalid_enum_value",
+                        value=', '.join(invalid_items),
+                        allowed=', '.join(map(str, spec['allowed_items']))
+                    )
+                )
+        elif 'allowed' in spec and converted_value not in spec['allowed']:
             raise ConfigValidationError(
                 get_message_with_format("invalid_enum_value", 
                           value=converted_value,
@@ -324,6 +338,8 @@ class ConfigValidator:
             ]
             if "allowed" in spec:
                 desc.append(f"  允许值: {', '.join(spec['allowed'])}")
+            if "allowed_items" in spec:
+                desc.append(f"  允许值: {', '.join(spec['allowed_items'])}")
             if "min" in spec and "max" in spec:
                 desc.append(f"  取值范围: {spec['min']}~{spec['max']}")
             docs.append("\n".join(desc))

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/common/global_cancel.py

@@ -3,8 +3,14 @@ Cancellation framework based on CancellationToken + Scope pattern.
 
 Key design choices:
 - **Sticky cancellation**: once a token is cancelled, it stays cancelled until
-  the owning scope exits (or an explicit reset). Multiple observers can all
-  see the cancelled state.
+  an explicit reset. Multiple observers can all see the cancelled state.
+  Notably the cancelled state (and its callbacks) survives scope exit: the
+  scope owner is often an asyncio task that unwinds immediately on
+  ``task.cancel()``, while worker threads / external CLI subprocesses spawned
+  for the same token are still shutting down and must keep observing
+  ``is_requested(token) == True`` (and late ``on_cancel`` registrations must
+  still fire). Cleanup of cancelled tokens is the run owner's job via
+  ``reset_token`` once every observer finished.
 - **CancellationScope**: context-manager that auto-registers / unregisters a
   token and propagates it via ``contextvars`` so deep call-chains don't need
   to pass the token explicitly.
@@ -115,6 +121,10 @@ class GlobalCancel:
         ``_current_cancel_token`` is set so that ``check_and_raise()`` /
         ``raise_if_cancelled()`` can discover it automatically.
 
+        Note: if the token got cancelled, its cancelled state survives the
+        scope exit (see ``_unregister_token``); call ``reset_token`` once all
+        observers (worker threads, subprocesses) have finished.
+
         Usage::
 
             with global_cancel.scope(cancel_token):
@@ -148,7 +158,17 @@ class GlobalCancel:
             self._current_task_token = token
 
     def _unregister_token(self, token: str) -> None:
-        """Decrement active count; remove state when no scopes remain."""
+        """Decrement active count; remove state when no scopes remain.
+
+        A **cancelled** token's state is preserved (sticky) even after the
+        last scope exits: the scope owner (e.g. an asyncio task hit by
+        ``task.cancel()``) usually unwinds before worker threads and external
+        subprocesses tied to the same token have finished. Those late
+        observers still need ``is_requested(token)`` to return True and late
+        ``on_cancel`` registrations to fire immediately, otherwise the
+        cancellation is silently lost (orphaned external CLI processes).
+        Cancelled states are cleaned up via ``reset_token`` / ``reset``.
+        """
         with self._lock:
             state = self._tokens.get(token)
             if state is None:
@@ -156,9 +176,10 @@ class GlobalCancel:
             state.active_count = max(0, state.active_count - 1)
             if state.active_count <= 0:
                 self._active_tokens.discard(token)
-                del self._tokens[token]
                 if self._current_task_token == token:
                     self._current_task_token = None
+                if not state.cancelled:
+                    del self._tokens[token]
 
     # ------------------------------------------------------------------
     # Query

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/common/goals/goal_executor.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import time
 import xml.sax.saxutils
 from dataclasses import dataclass
@@ -28,6 +29,10 @@ from .goal_verifier import (
 EventSink = Callable[[Any], None]
 TurnRunner = Callable[[str, GoalState, Optional[str], Optional[str], dict], Iterable[Any]]
 
+# 单个 goal turn 的最大尝试次数（含首次执行）。
+DEFAULT_MAX_TURN_ATTEMPTS = 5
+_MAX_TURN_RETRY_DELAY_SECONDS = 16.0
+
 _NON_RESUMABLE_MODEL_API_ERROR_HINTS = (
     "401",
     "402",
@@ -99,6 +104,57 @@ _TRANSIENT_MODEL_API_ERROR_HINTS = (
 )
 
 
+def _resolve_max_turn_attempts(value: Optional[int] = None) -> int:
+    if value is not None:
+        return max(int(value), 1)
+    raw = (os.environ.get("AUTOCODER_GOAL_MAX_TURN_ATTEMPTS") or "").strip()
+    if raw:
+        try:
+            return max(int(raw), 1)
+        except ValueError:
+            pass
+    return DEFAULT_MAX_TURN_ATTEMPTS
+
+
+# 外部 CLI backend（cursor/codex/claude）turn 级失败特征。与
+# _TRANSIENT_MODEL_API_ERROR_HINTS 分开维护：后者保持“模型/API 网络错误”
+# 的原始语义，_is_retryable_turn_error 对两者取 OR。
+_BACKEND_TURN_FAILURE_HINTS = (
+    "claude -p failed",
+    "codex exec failed",
+    "cursor agent failed",
+    "cursor create-chat failed",
+    "ping timed out",
+    "unavailable",
+)
+
+
+def _is_backend_turn_failure(exc: BaseException) -> bool:
+    for item in _exception_chain(exc):
+        text = f"{type(item).__name__} {item}".lower()
+        if any(hint in text for hint in _BACKEND_TURN_FAILURE_HINTS):
+            return True
+        # External backends surface process failures as RuntimeError.
+        if isinstance(item, RuntimeError) and (
+            "failed" in text or "timed out" in text or "timeout" in text
+        ):
+            return True
+    return False
+
+
+def _is_retryable_turn_error(exc: BaseException) -> bool:
+    """Transient/backend turn failures are retried; auth/billing is not."""
+    if isinstance(exc, (CancelRequestedException, KeyboardInterrupt, SystemExit)):
+        return False
+    if _is_non_resumable_model_api_error(exc):
+        return False
+    return _is_transient_model_api_network_error(exc) or _is_backend_turn_failure(exc)
+
+
+def _format_turn_error(exc: BaseException) -> str:
+    return f"{type(exc).__name__}: {exc}"
+
+
 @dataclass
 class GoalRunSummary:
     goal: GoalState
@@ -407,11 +463,13 @@ class GoalExecutor:
         turn_runner: Optional[TurnRunner] = None,
         event_sink: Optional[EventSink] = None,
         verifier: Optional[GoalCompletionVerifier] = None,
+        max_turn_attempts: Optional[int] = None,
     ):
         self.store = store or GoalStore()
         self.turn_runner = turn_runner or self._run_backend_turn
         self.event_sink = event_sink
         self.verifier = verifier or GoalCompletionVerifier()
+        self.max_turn_attempts = _resolve_max_turn_attempts(max_turn_attempts)
 
     def run(
         self,
@@ -490,64 +548,103 @@ class GoalExecutor:
 
                 self.store.heartbeat(current.goal_id)
                 started = time.time()
+                # token_delta 跨 attempt 累加：失败 attempt 已经真实消耗了
+                # LLM tokens，必须计入 turn 记账；seen_usage_ids 按 attempt
+                # 独立（基于 id() 去重，跨 attempt 复用会误判新事件为已见）。
                 token_delta = 0
-                seen_usage_ids: set[int] = set()
-                try:
-                    run_extra_args = {
-                        **(extra_args or {}),
-                        "backend": current.backend,
-                    }
-                    backend_name = self._normalize_turn_backend(run_extra_args["backend"])
-                    prompt = build_goal_prompt(
-                        current,
-                        first_turn=current.iteration_count == 0 and iterations_run == 0,
-                        protocol=(
+                turn_succeeded = False
+                for attempt in range(1, self.max_turn_attempts + 1):
+                    attempt_seen_usage_ids: set[int] = set()
+                    try:
+                        run_extra_args = {
+                            **(extra_args or {}),
+                            "backend": current.backend,
+                        }
+                        backend_name = self._normalize_turn_backend(
+                            run_extra_args["backend"]
+                        )
+                        prompt = build_goal_prompt(
+                            current,
+                            first_turn=(
+                                current.iteration_count == 0 and iterations_run == 0
+                            ),
+                            protocol=(
+                                "xml_tools"
+                                if self._is_auto_coder_backend(backend_name)
+                                else "external_result_line"
+                            ),
+                        )
+                        turn_model = self._turn_model_for_backend(
+                            model, current, backend_name
+                        )
+                        protocol = (
                             "xml_tools"
                             if self._is_auto_coder_backend(backend_name)
                             else "external_result_line"
-                        ),
-                    )
-                    turn_model = self._turn_model_for_backend(
-                        model, current, backend_name
-                    )
-                    protocol = (
-                        "xml_tools"
-                        if self._is_auto_coder_backend(backend_name)
-                        else "external_result_line"
-                    )
-                    logger.info(
-                        "[goal:{}] turn start iteration={} backend={} "
-                        "protocol={} model={} conversation={}",
-                        current.goal_id,
-                        current.iteration_count + 1,
-                        backend_name,
-                        protocol,
-                        turn_model or "-",
-                        current.conversation_id or "-",
-                    )
-                    for event in self.turn_runner(
-                        prompt,
-                        current,
-                        turn_model,
-                        cancel_token,
-                        run_extra_args,
-                    ):
-                        self._handle_event(current.goal_id, event)
-                        token_delta += _token_delta_from_event(
-                            event,
-                            seen_usage_ids,
                         )
-                except CancelRequestedException:
-                    stop_reason = "cancelled; goal remains active"
-                    break
-                except KeyboardInterrupt:
-                    stop_reason = "interrupted; goal remains active"
-                    break
-                except Exception as exc:
-                    if _is_transient_model_api_network_error(exc):
+                        logger.info(
+                            "[goal:{}] turn start iteration={} attempt={}/{} "
+                            "backend={} protocol={} model={} conversation={}",
+                            current.goal_id,
+                            current.iteration_count + 1,
+                            attempt,
+                            self.max_turn_attempts,
+                            backend_name,
+                            protocol,
+                            turn_model or "-",
+                            current.conversation_id or "-",
+                        )
+                        for event in self.turn_runner(
+                            prompt,
+                            current,
+                            turn_model,
+                            cancel_token,
+                            run_extra_args,
+                        ):
+                            self._handle_event(current.goal_id, event)
+                            token_delta += _token_delta_from_event(
+                                event,
+                                attempt_seen_usage_ids,
+                            )
+                        turn_succeeded = True
+                        break
+                    except CancelRequestedException:
+                        stop_reason = "cancelled; goal remains active"
+                        break
+                    except KeyboardInterrupt:
+                        stop_reason = "interrupted; goal remains active"
+                        break
+                    except Exception as exc:
+                        if not _is_retryable_turn_error(exc):
+                            self.store.set_status(
+                                current.goal_id,
+                                "failed",
+                                _format_turn_error(exc),
+                                clear_owner=True,
+                            )
+                            raise
+                        if attempt < self.max_turn_attempts:
+                            delay = min(
+                                2.0 ** (attempt - 1),
+                                _MAX_TURN_RETRY_DELAY_SECONDS,
+                            )
+                            logger.warning(
+                                "[goal:{}] turn attempt {}/{} failed "
+                                "({}): {}; retrying in {:.1f}s",
+                                current.goal_id,
+                                attempt,
+                                self.max_turn_attempts,
+                                type(exc).__name__,
+                                exc,
+                                delay,
+                            )
+                            time.sleep(delay)
+                            self.store.heartbeat(current.goal_id)
+                            continue
                         reason = (
-                            "Paused after transient model/API network error: "
-                            f"{type(exc).__name__}: {exc}"
+                            "Paused after "
+                            f"{self.max_turn_attempts} failed turn attempts: "
+                            f"{_format_turn_error(exc)}"
                         )
                         current = self.store.set_status(
                             current.goal_id,
@@ -558,13 +655,9 @@ class GoalExecutor:
                         stop_reason = self._stop_reason(current)
                         logger.warning("[goal:{}] {}", current.goal_id, reason)
                         break
-                    self.store.set_status(
-                        current.goal_id,
-                        "failed",
-                        f"{type(exc).__name__}: {exc}",
-                        clear_owner=True,
-                    )
-                    raise
+
+                if not turn_succeeded:
+                    break
 
                 elapsed = int(time.time() - started)
                 current = self.store.account_turn(

{auto_coder-3.0.64 → auto_coder-3.0.65}/src/autocoder/common/priority_directory_finder/test_priority_directory_finder.py

@@ -71,7 +71,9 @@ class TestDirectoryConfig(unittest.TestCase):
         """测试路径展开"""
         config = DirectoryConfig("~/test")
         expanded = config.get_expanded_path()
-        self.assertTrue(expanded.startswith(os.path.expanduser("~")))
+        self.assertTrue(
+            expanded.startswith(os.path.abspath(os.path.expanduser("~")))
+        )
         self.assertTrue(os.path.isabs(expanded))
     
     def test_validate_directory_exists(self):
@@ -428,4 +430,4 @@ class TestIntegration(unittest.TestCase):
 
 
 if __name__ == '__main__':
-    unittest.main() 
+    unittest.main()