cecli-dev 1.3.2rc3__tar.gz → 1.4.0__tar.gz

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.3.2rc3
+Version: 1.4.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.2rc3'
-__version_tuple__ = version_tuple = (1, 3, 2, 'rc3')
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
 
-__commit_id__ = commit_id = 'ge2f9c56b1'
+__commit_id__ = commit_id = 'g1933dd2b7'

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/coders/base_coder.py

@@ -474,14 +474,14 @@ class Coder(metaclass=UsageMeta):
             self._inherited_tools = True
 
         self.interrupt_event = ThreadSafeEvent()
-        self.uuid = str(generate_unique_id())
+        self.uuid = str(generate_unique_id()).split("-")[0]
         self.reflected_message = None
 
         if uuid:
-            self.uuid = str(uuid)
+            self.uuid = str(uuid).split("-")[0]
 
         if parent_uuid:
-            self.parent_uuid = str(parent_uuid)
+            self.parent_uuid = str(parent_uuid).split("-")[0]
 
         self.map_cache_dir = map_cache_dir
 
@@ -4962,13 +4962,44 @@ class Coder(metaclass=UsageMeta):
         return edits
 
     def local_agent_folder(self, path):
+        primary_uuid = self._resolve_primary_agent_uuid()
+        primary_root = os.path.abspath(self.primary_root)
+
+        stripped = path.lstrip("/")
+
+        if self.uuid == primary_uuid:
+            rel_dir = f"{primary_root}/.cecli/agents/{GLOBAL_DATE}/{primary_uuid}"
+        else:
+            rel_dir = f"{primary_root}/.cecli/agents/{GLOBAL_DATE}/{primary_uuid}/s/{self.uuid}"
+
         os.makedirs(
-            self.abs_root_path(f".cecli/agents/{GLOBAL_DATE}/{self.uuid}"),
+            self.abs_root_path(rel_dir),
             exist_ok=True,
         )
 
-        stripped = path.lstrip("/")
-        return f".cecli/agents/{GLOBAL_DATE}/{self.uuid}/{stripped}"
+        return f"{rel_dir}/{stripped}"
+
+    def _resolve_primary_agent_uuid(self):
+        """Return the primary coder's uuid for this session (memoized).
+
+        All agents spawned under a primary coder share the same base folder,
+        so sub-agent files nest under one location regardless of delegation
+        depth. Falls back to this coder's own uuid when the service is
+        unavailable (e.g. in unit tests).
+        """
+        if getattr(self, "_primary_agent_uuid", None):
+            return self._primary_agent_uuid
+
+        primary_uuid = self.uuid
+        try:
+            from cecli.helpers.agents.service import AgentService
+
+            primary_uuid = AgentService.get_primary_uuid() or self.uuid
+        except Exception:
+            pass
+
+        self._primary_agent_uuid = primary_uuid
+        return primary_uuid
 
     async def auto_save_session(self, force=False):
         """Automatically save the current session to {auto-save-session-name}.json."""

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/helpers/agents/service.py

@@ -137,6 +137,15 @@ class AgentService:
         """Return the global sub-agent registry (name -> config)."""
         return cls._global_registry
 
+    @classmethod
+    def get_primary_uuid(cls) -> Optional[str]:
+        """Return the primary coder's uuid for the current session (memoized).
+
+        Fixed on the first :meth:`get_instance` call, so every agent spawned
+        in a session resolves to the same shared base uuid.
+        """
+        return cls._primary_agent_uuid
+
     @classmethod
     def get_all_agents(cls) -> List[Any]:
         """Return all live coder instances tracked in the global uuid map.
@@ -576,7 +585,7 @@ class AgentService:
 
         async with self._get_lock(self._spawn_locks, parent_coder.uuid):
             self._check_max_sub_agents()
-            new_uuid = str(uuid4())
+            new_uuid = str(uuid4()).split("-")[0]
 
         from cecli.coders import Coder
 

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/helpers/llms/litellm_compat.py

@@ -395,6 +395,8 @@ class _FacadeException(Exception):
     ) -> None:
         super().__init__(message or "")
         self.status_code = status_code
+        for k, v in kwargs.items():
+            setattr(self, k, v)
 
 
 class APIConnectionError(_FacadeException):
@@ -508,21 +510,23 @@ def _translate_http_error(err: httpx.HTTPStatusError) -> _FacadeException:
     if status == 400 and any(
         token in body for token in ("context", "context_length", "maximum context")
     ):
-        return ContextWindowExceededError(message=message, status_code=status)
+        return ContextWindowExceededError(
+            message=message, status_code=status, response=err.response
+        )
 
     if status in (401, 403):
-        return AuthenticationError(message=message, status_code=status)
+        return AuthenticationError(message=message, status_code=status, response=err.response)
 
     if status == 404:
-        return NotFoundError(message=message, status_code=status)
+        return NotFoundError(message=message, status_code=status, response=err.response)
 
     if status == 429:
-        return RateLimitError(message=message, status_code=status)
+        return RateLimitError(message=message, status_code=status, response=err.response)
 
     if status >= 500:
-        return InternalServerError(message=message, status_code=status)
+        return InternalServerError(message=message, status_code=status, response=err.response)
 
-    return APIError(message=message, status_code=status)
+    return APIError(message=message, status_code=status, response=err.response)
 
 
 # ---------------------------------------------------------------------------

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/main.py

@@ -1424,7 +1424,10 @@ async def main_async(
         pre_init_io.tool_output()
         webbrowser.open(urls.release_notes)
         return await graceful_exit(coder)
-    elif args.show_release_notes is None and is_first_run:
+    elif args.show_release_notes is None and is_first_run and not args.yes_always:
+        # Suppress the first-run release-notes prompt when --yes-always is set,
+        # so automated/headless runs don't have the browser hijacked by an
+        # auto-confirmed offer_url. Explicit --show-release-notes still opens.
         pre_init_io.tool_output()
         await pre_init_io.offer_url(
             urls.release_notes,
@@ -1781,13 +1784,21 @@ async def graceful_exit(coder=None, exit_code=0):
                         if (now - mtime) > week_seconds:
                             shutil.rmtree(agent_folder, ignore_errors=True)
                         else:
-                            # Remove empty sub-folders in remaining folders
-                            for sub_folder in agent_folder.iterdir():
-                                if sub_folder.is_dir():
-                                    try:
+                            # Find all nested subdirectories inside this agent folder
+                            all_subdirs = [d for d in agent_folder.rglob("*") if d.is_dir()]
+
+                            # Sort them by depth (deepest first) so child dirs are processed before parents
+                            all_subdirs.sort(key=lambda x: len(x.parts), reverse=True)
+
+                            for sub_folder in all_subdirs:
+                                try:
+                                    # rmdir() safely fails if a file is present
+                                    # any() checks if the directory has any files or remaining folders
+                                    if not any(sub_folder.iterdir()):
                                         sub_folder.rmdir()
-                                    except OSError:
-                                        pass
+                                except OSError:
+                                    pass
+
                     except (OSError, PermissionError):
                         pass
     except Exception:

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/models.py

@@ -12,12 +12,15 @@ from uuid import uuid4 as generate_unique_id
 
 import yaml
 
-from cecli import __version__
+from cecli import __version__, utils
 from cecli.decoding import safe_open
 from cecli.dump import dump
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import coroutines, nested
-from cecli.helpers.file_searcher import generate_search_path_list, handle_core_files
+from cecli.helpers.file_searcher import (
+    generate_search_path_list,
+    handle_core_files,
+)
 from cecli.helpers.model_config import get_default_config
 from cecli.helpers.model_config.utils import get_entry_from_raw
 from cecli.helpers.model_providers import ModelProviderManager
@@ -289,7 +292,9 @@ class ModelInfoManager:
             import re
 
             if re.search(
-                f"The model\\s*.*{re.escape(url_part)}.* is not available", html, re.IGNORECASE
+                f"The model\\s*.*{re.escape(url_part)}.* is not available",
+                html,
+                re.IGNORECASE,
             ):
                 print(f"\x1b[91mError: Model '{url_part}' is not available\x1b[0m")
                 return {}
@@ -497,7 +502,8 @@ class Model(ModelSettings):
                 "editor_model", nested.getter(from_model, "editor_model", None)
             )
             editor_edit_format = kwargs.get(
-                "editor_edit_format", nested.getter(from_model, "editor_edit_format", None)
+                "editor_edit_format",
+                nested.getter(from_model, "editor_edit_format", None),
             )
         else:
             agent_model = kwargs.get("agent_model", None)
@@ -538,7 +544,8 @@ class Model(ModelSettings):
         self.editor_model = None
         self.agent_model = None
         self.extra_model_settings = next(
-            (ms for ms in MODEL_SETTINGS if ms.name == "cecli/extra_params"), None
+            (ms for ms in MODEL_SETTINGS if ms.name == "cecli/extra_params"),
+            None,
         )
         self.info = self.get_model_info(model)
         self.model_config_defaults = get_default_config(
@@ -654,18 +661,24 @@ class Model(ModelSettings):
         for key, value in config.items():
             if key in ("agent", "model_settings", "model-settings"):
                 if not isinstance(value, dict):
-                    raise ValueError(f"override_kwargs '{key}' must be a dict, got {type(value)}")
+                    raise ValueError(
+                        f"override_kwargs '{key}' must be a dict, got" f" {type(value)}"
+                    )
 
                 for setting_key, setting_value in value.items():
                     if setting_key not in valid_model_settings_fields:
                         raise ValueError(
-                            f"Invalid model_settings key '{setting_key}'. "
-                            f"Must be one of: {sorted(valid_model_settings_fields)}"
+                            f"Invalid model_settings key '{setting_key}'. Must"
+                            f" be one of: {sorted(valid_model_settings_fields)}"
                         )
 
                     setattr(self, setting_key, setting_value)
 
-            elif has_structured_keys and key in ("api", "api_settings", "api-settings"):
+            elif has_structured_keys and key in (
+                "api",
+                "api_settings",
+                "api-settings",
+            ):
                 # api_settings: merge each sub-key into extra_params
                 if not isinstance(value, dict):
                     raise ValueError(f"override_kwargs '{key}' must be a dict, got {type(value)}")
@@ -687,11 +700,18 @@ class Model(ModelSettings):
                     if isinstance(api_value, dict) and isinstance(
                         self.extra_params.get(api_key), dict
                     ):
-                        self.extra_params[api_key] = {**self.extra_params[api_key], **api_value}
+                        self.extra_params[api_key] = {
+                            **self.extra_params[api_key],
+                            **api_value,
+                        }
                     else:
                         self.extra_params[api_key] = api_value
 
-            elif has_structured_keys and key in ("llm", "llm_settings", "llm-settings"):
+            elif has_structured_keys and key in (
+                "llm",
+                "llm_settings",
+                "llm-settings",
+            ):
                 # llm_settings: merge into self.info
                 if not isinstance(value, dict):
                     raise ValueError(f"override_kwargs '{key}' must be a dict, got {type(value)}")
@@ -1213,7 +1233,10 @@ class Model(ModelSettings):
                 elif "reasoning" in extra_body:
                     del extra_body["reasoning"]
             elif num_tokens > 0:
-                extra_body["thinking"] = {"type": "enabled", "budget_tokens": num_tokens}
+                extra_body["thinking"] = {
+                    "type": "enabled",
+                    "budget_tokens": num_tokens,
+                }
                 # extra_body is authoritative; drop any legacy top-level copy.
                 self.extra_params.pop("thinking", None)
             else:
@@ -1322,7 +1345,8 @@ class Model(ModelSettings):
 
         if effective_tools:
             sorted_tools = sorted(
-                effective_tools, key=lambda x: x.get("function", {}).get("name", "Invalid Name")
+                effective_tools,
+                key=lambda x: x.get("function", {}).get("name", "Invalid Name"),
             )
 
             try:
@@ -1352,7 +1376,10 @@ class Model(ModelSettings):
             if "name" in function:
                 tool_name = function.get("name")
                 if tool_name:
-                    kwargs["tool_choice"] = {"type": "function", "function": {"name": tool_name}}
+                    kwargs["tool_choice"] = {
+                        "type": "function",
+                        "function": {"name": tool_name},
+                    }
 
         if self.extra_params:
             kwargs.update(self.extra_params)
@@ -1456,10 +1483,15 @@ class Model(ModelSettings):
                 if ex_info.name == "ServiceUnavailableError":
                     should_retry = should_retry or self.retry_on_unavailable
 
-                if should_retry:
+                custom_retry_delay = self._extract_retry_delay(err)
+                if custom_retry_delay is not None:
+                    retry_delay = custom_retry_delay
+                    should_retry = True
+                elif should_retry:
                     retry_delay *= self.retry_backoff_factor
-                    if retry_delay > self.retry_timeout:
-                        should_retry = False
+
+                if retry_delay > self.retry_timeout:
+                    should_retry = False
 
                 # Check for non-retryable RateLimitError within ServiceUnavailableError
                 if (
@@ -1550,10 +1582,16 @@ class Model(ModelSettings):
                 if ex_info.description:
                     print(ex_info.description)
                 should_retry = ex_info.retry
-                if should_retry:
+                custom_retry_delay = self._extract_retry_delay(err)
+                if custom_retry_delay is not None:
+                    retry_delay = custom_retry_delay
+                    should_retry = True
+                elif should_retry:
                     retry_delay *= 2
-                    if retry_delay > RETRY_TIMEOUT:
-                        should_retry = False
+
+                if retry_delay > RETRY_TIMEOUT:
+                    should_retry = False
+
                 if not should_retry:
                     return None
                 print(f"Retrying in {retry_delay:.1f} seconds...")
@@ -1574,7 +1612,7 @@ class Model(ModelSettings):
                     finish_reason="stop",
                     index=0,
                     message=litellm.Message(
-                        content="Model API Response Error. Please retry the previous request"
+                        content=("Model API Response Error. Please retry the previous request")
                     ),
                 )
             ],
@@ -1584,6 +1622,104 @@ class Model(ModelSettings):
     async def model_error_response_stream(self):
         yield self.model_error_response()
 
+    def _extract_retry_delay(self, err):
+        """
+        Extract suggested retry delay (in seconds) from a 429 rate-limit error.
+
+        1. Gemini payload body: Google RPC APIs return `google.rpc.RetryInfo` with
+           a `retryDelay` field (e.g. "15.2s") inside the `error.details` array.
+        2. HTTP headers fallback: Standard providers (OpenAI, Anthropic, Groq, etc.)
+           supply `retry-after` (seconds) or `retry-after-ms` (milliseconds) headers.
+        """
+        status_code = nested.getter(err, ["status_code", "response.status_code"], None)
+        if isinstance(status_code, (int, str, float)) and str(status_code) != "429":
+            return None
+
+        # 1. Check Gemini response payload for google.rpc.RetryInfo retryDelay
+        candidates = []
+        response = nested.getter(err, "response")
+        if callable(getattr(response, "json", None)):
+            try:
+                data = response.json()
+                if isinstance(data, dict):
+                    candidates.append(data)
+            except Exception:
+                pass
+
+        sources = [
+            response,
+            nested.getter(err, "message"),
+            nested.getter(err, "body"),
+            nested.getter(err, "error"),
+            nested.getter(err, "raw_response"),
+            str(err) if isinstance(err, Exception) else None,
+            err,
+        ]
+
+        for src in sources:
+            if not src:
+                continue
+            if isinstance(src, dict):
+                candidates.append(src)
+            elif isinstance(src, (str, bytes)):
+                text_str = src.decode("utf-8", errors="ignore") if isinstance(src, bytes) else src
+                for chunk in utils.split_concatenated_json(text_str):
+                    try:
+                        parsed = json.loads(chunk)
+                        if isinstance(parsed, dict):
+                            candidates.append(parsed)
+                    except Exception:
+                        pass
+            else:
+                text = nested.getter(src, ["text", "content"])
+                if isinstance(text, (str, bytes)):
+                    text_str = (
+                        text.decode("utf-8", errors="ignore") if isinstance(text, bytes) else text
+                    )
+                    for chunk in utils.split_concatenated_json(text_str):
+                        try:
+                            parsed = json.loads(chunk)
+                            if isinstance(parsed, dict):
+                                candidates.append(parsed)
+                        except Exception:
+                            pass
+
+        for candidate in candidates:
+            if not isinstance(candidate, dict):
+                continue
+
+            details = nested.getter(candidate, "error.details")
+            if isinstance(details, list):
+                for item in details:
+                    delay_val = nested.getter(item, "retryDelay")
+                    if delay_val is not None:
+                        delay_str = str(delay_val).strip()
+                        if delay_str.endswith("s"):
+                            delay_str = delay_str[:-1]
+                        try:
+                            return float(delay_str)
+                        except (ValueError, TypeError):
+                            pass
+
+        # 2. Check HTTP headers fallback (retry-after, retry-after-ms)
+        headers = nested.getter(err, ["response.headers", "headers"], None)
+        if headers is not None:
+            retry_after = nested.getter(headers, ["retry-after"], None)
+            if retry_after is not None:
+                try:
+                    return float(str(retry_after).strip())
+                except (ValueError, TypeError):
+                    pass
+
+            retry_after_ms = nested.getter(headers, ["retry-after-ms"], None)
+            if retry_after_ms is not None:
+                try:
+                    return float(str(retry_after_ms).strip()) / 1000.0
+                except (ValueError, TypeError):
+                    pass
+
+        return None
+
     def _log_messages(self, messages, name="message"):
         """
         Log conversation messages to a JSON file.
@@ -1591,7 +1727,11 @@ class Model(ModelSettings):
         os.makedirs(".cecli/logs/messages", exist_ok=True)
         with safe_open(f".cecli/logs/messages/{name}-{time.time()}.log", "w") as f:
             json.dump(
-                messages, f, indent=4, ensure_ascii=False, default=lambda o: "<not serializable>"
+                messages,
+                f,
+                indent=4,
+                ensure_ascii=False,
+                default=lambda o: "<not serializable>",
             )
 
     def _log_request(self, model_call_dict):
@@ -1691,8 +1831,8 @@ async def sanity_check_model(io, model):
             io.tool_output(f"- {key}: {status}")
         if platform.system() == "Windows":
             io.tool_output(
-                "Note: You may need to restart your terminal or command prompt for `setx` to take"
-                " effect."
+                "Note: You may need to restart your terminal or command prompt"
+                " for `setx` to take effect."
             )
     elif not model.keys_in_environment:
         show = True
@@ -1721,7 +1861,10 @@ async def check_for_dependencies(io, model_name):
     """
     if model_name.startswith("bedrock/"):
         await check_pip_install_extra(
-            io, "boto3", "AWS Bedrock models require the boto3 package.", ["boto3"]
+            io,
+            "boto3",
+            "AWS Bedrock models require the boto3 package.",
+            ["boto3"],
         )
     elif model_name.startswith("vertex_ai/"):
         await check_pip_install_extra(

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/tools/delegate.py

@@ -49,6 +49,13 @@ class Tool(BaseTool):
                                         " If false, wait for the result."
                                     ),
                                 },
+                                "persist": {
+                                    "type": "boolean",
+                                    "default": False,
+                                    "description": (
+                                        "If true, keep the sub-agent active after the task is complete."
+                                    ),
+                                },
                             },
                             "required": ["name", "prompt"],
                         },
@@ -69,7 +76,7 @@ class Tool(BaseTool):
 
         if not delegations or not isinstance(delegations, list):
             response.append_error(
-                "'delegations' parameter must be a non-empty array of {name, prompt, async} objects."
+                "'delegations' parameter must be a non-empty array of {name, prompt, async, persist} objects."
             )
             return response
 
@@ -90,23 +97,35 @@ class Tool(BaseTool):
         agent_service = AgentService.get_instance(coder)
 
         # Separate async (fire-and-forget) and sync (blocking) delegations
-        async_delegations = [(d["name"], d["prompt"]) for d in delegations if d.get("async", True)]
+        async_delegations = [
+            (d["name"], d["prompt"], d.get("persist", False))
+            for d in delegations
+            if d.get("async", True)
+        ]
         sync_delegations = [
-            (d["name"], d["prompt"]) for d in delegations if not d.get("async", True)
+            (d["name"], d["prompt"], d.get("persist", False))
+            for d in delegations
+            if not d.get("async", True)
         ]
 
-        async def _spawn_one(name: str, prompt: str) -> tuple:
+        async def _spawn_one(name: str, prompt: str, persist: bool) -> tuple:
             """Spawn a single sub-agent (fire-and-forget). Returns (name, uuid_or_error, error)."""
+            auto_reap = None if not persist else False
             try:
-                new_coder, info = await agent_service.spawn(name, prompt, parent=coder)
+                new_coder, info = await agent_service.spawn(
+                    name, prompt, parent=coder, auto_reap=auto_reap
+                )
                 return name, info.coder.uuid, None
             except Exception as e:
                 return name, None, f"failed: {e}"
 
-        async def _invoke_one(name: str, prompt: str) -> tuple:
+        async def _invoke_one(name: str, prompt: str, persist: bool) -> tuple:
             """Invoke a single sub-agent (blocking). Returns (name, summary_or_error, error)."""
+            auto_reap = None if not persist else False
             try:
-                summary = await agent_service.invoke(name, prompt, parent=coder)
+                summary = await agent_service.invoke(
+                    name, prompt, parent=coder, auto_reap=auto_reap
+                )
                 return name, summary or "(no summary)", None
             except Exception as e:
                 return name, None, f"failed: {e}"
@@ -114,13 +133,13 @@ class Tool(BaseTool):
         # Process async delegations (fire-and-forget spawn)
         async_results = []
         if async_delegations:
-            tasks = [_spawn_one(n, p) for n, p in async_delegations]
+            tasks = [_spawn_one(n, p, persist) for n, p, persist in async_delegations]
             async_results = list(await asyncio.gather(*tasks))
 
         # Process sync delegations (blocking invoke)
         sync_results = []
         if sync_delegations:
-            tasks = [_invoke_one(n, p) for n, p in sync_delegations]
+            tasks = [_invoke_one(n, p, persist) for n, p, persist in sync_delegations]
             sync_results = list(await asyncio.gather(*tasks))
 
         # Build response
@@ -185,9 +204,11 @@ class Tool(BaseTool):
                 name = d.get("name", "")
                 prompt = d.get("prompt", "")
                 is_async = d.get("async", True)
+                is_persist = d.get("persist", False)
                 coder.io.tool_output(f"{color_start}delegation_{i + 1}:{color_end}")
                 coder.io.tool_output(f"agent: {name}")
                 coder.io.tool_output(f"mode: {'async' if is_async else 'sync'}")
+                coder.io.tool_output(f"persist: {'true' if is_persist else 'false'}")
                 coder.io.tool_output(f"task: {prompt}")
                 if i < len(delegations) - 1:
                     coder.io.tool_output("")

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/tui/app.py

@@ -1636,7 +1636,7 @@ class TUI(App):
             tuple[list[str], set[str]]: A tuple of (ordered_list, fast_lookup_set)
                 containing the matched path completions.
         """
-        coder = self.worker.coder
+        coder = AgentService.get_instance(self.worker.coder).foreground_coder
         root = Path(coder.root) if hasattr(coder, "root") else Path.cwd()
 
         # Try FileSystemService first for efficient lookups

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/website/docs/config/agent-mode.md

@@ -287,7 +287,7 @@ Tools are loaded automatically when the registry is built and will be available
 
 #### Sub-agent Behavior
 
-`Delegate` accepts one or more delegation objects. Each delegation includes a registered sub-agent `name`, a `prompt`, and an optional `async` flag. Asynchronous delegations run in the background; synchronous delegations wait for the sub-agent result. The system uses `Yield` to wait for outstanding child tasks when finishing the parent task.
+`Delegate` accepts one or more delegation objects. Each delegation includes a registered sub-agent `name`, a `prompt`, and optional `async` and `persist` flags. Asynchronous delegations run in the background; synchronous delegations wait for the sub-agent result. The system uses `Yield` to wait for outstanding child tasks when finishing the parent task.
 
 Sub-agent results are reported back to the parent conversation as summaries or errors. Sub-agents use `auto_reap: true` by default, so completed agents can be removed automatically after their work and descendants finish. Independent agents may be cleaned up shortly after completion, while the service also reaps completed agents when the configured limit requires space. Set `max_sub_agents` to `-1` to remove the limit on simultaneous sub agents.
 

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli/website/docs/config/subagents.md

@@ -164,7 +164,7 @@ You are a code review specialist.
 ```
 
 - **`/spawn-agent`** always spawns sub-agents with `auto_reap=false` — since these agents are created manually by the user, they should persist until explicitly reaped with `/reap-agent`.
-- **`Delegate` tool** uses the sub-agent's configured `auto_reap` value from its definition. If not set in the `.md` front matter, it defaults to `true`.
+- **`Delegate` tool** uses the sub-agent's configured `auto_reap` value from its definition. If not set in the `.md` front matter, it defaults to `true`. A delegation may set `persist: true` to keep that sub-agent alive by passing `auto_reap: false`; by default `persist` is `false`, deferring to the sub-agent's configured behavior.
 
 Sub-agents with `auto_reap: true` that finish their work are candidates for automatic cleanup when the agent limit is reached. Sub-agents with `auto_reap: false` are never automatically reaped and must be cleaned up manually.
 

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.3.2rc3
+Version: 1.4.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli_dev.egg-info/SOURCES.txt

@@ -825,6 +825,7 @@ tests/unit/test_load_mcp.py
 tests/unit/test_performance.py
 tests/unit/test_queues.py
 tests/unit/test_remove_mcp.py
+tests/unit/test_retry_backoff.py
 tests/unit/test_shallow_merge.py
 tests/unit/test_signals.py
 tests/unit/test_unit_load_mcp_tool.py

{cecli_dev-1.3.2rc3 → cecli_dev-1.4.0}/cecli_dev.egg-info/scm_file_list.json

@@ -1067,6 +1067,7 @@
     "tests/unit/test_performance.py",
     "tests/unit/test_queues.py",
     "tests/unit/test_remove_mcp.py",
+    "tests/unit/test_retry_backoff.py",
     "tests/unit/test_shallow_merge.py",
     "tests/unit/test_signals.py",
     "tests/unit/test_unit_load_mcp_tool.py",