cecli-dev 1.8.1rc2__tar.gz → 1.8.1rc3__tar.gz

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.1rc2
+Version: 1.8.1rc3
 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.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.1rc2'
-__version_tuple__ = version_tuple = (1, 8, 1, 'rc2')
+__version__ = version = '1.8.1rc3'
+__version_tuple__ = version_tuple = (1, 8, 1, 'rc3')
 
-__commit_id__ = commit_id = 'g9c5114f1f'
+__commit_id__ = commit_id = 'gb07a9f6ad'

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/args.py

@@ -440,13 +440,9 @@ def get_parser(default_config_files, git_root):
     )
     group.add_argument(
         "--scheduler",
-        action=argparse.BooleanOptionalAction,
+        metavar="SCHEDULER_CONFIG_JSON",
+        help="Specify scheduler configuration as a JSON string",
         default=None,
-        help=(
-            "Force the workflow scheduler on (--scheduler) or off (--no-scheduler) for"
-            " this session. (default: auto, on when any enabled scheduled workflow"
-            " exists)"
-        ),
     )
     group.add_argument(
         "--system-one",

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/coders/base_coder.py

@@ -2717,7 +2717,7 @@ class Coder(metaclass=UsageMeta):
     async def check_tokens(self, messages):
         """Check if the messages will fit within the model's token limits."""
         input_tokens = self.get_active_model().token_count(messages)
-        max_input_tokens = self.get_active_model().info.get("max_input_tokens") or 0
+        max_input_tokens = self.get_active_model().info.get("max_input_tokens") or 128000
 
         if max_input_tokens and input_tokens >= max_input_tokens:
             if (
@@ -2728,7 +2728,7 @@ class Coder(metaclass=UsageMeta):
                     f"Estimated chat context of {input_tokens:,} tokens exceeds the"
                     f" {max_input_tokens:,} token limit. Attempting to compact..."
                 )
-                await self.compact_context_if_needed(force=True)
+                await self.compact_context_if_needed()
 
                 # After compaction, re-format messages and re-check tokens
                 messages = self.format_messages()

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/helpers/agents/service.py

@@ -6,6 +6,7 @@ that tracks sub-agent info and handles invoke/spawn/wait lifecycle.
 
 import asyncio
 import logging
+import threading
 import time
 import weakref
 from dataclasses import dataclass
@@ -80,8 +81,22 @@ class AgentService:
     _uuid_coder_map: Dict[str, weakref.ref] = {}
     # Lock pools keyed by parent UUID — created lazily so only parents that
     # actually use them allocate a lock.
-    _spawn_locks: Dict[str, asyncio.Lock] = {}
-    _conversation_locks: Dict[str, asyncio.Lock] = {}
+    #
+    # Plain ``threading.Lock`` (not ``asyncio.Lock``): an ``asyncio.Lock`` binds
+    # itself to the event loop of its first *waiting* acquirer and raises
+    # ``RuntimeError('... is bound to a different event loop')`` when awaited
+    # from another loop. Spawn, reap and conversation writes all reach these
+    # pools from both the TUI main (Textual) loop and the coder worker-thread
+    # loop, and the pools are class-level, so a lock created before a hot reload
+    # outlives the loop it bound to. Every guarded section is fully synchronous,
+    # so a thread lock gives true cross-loop mutual exclusion with no loop
+    # affinity and is immune to task cancellation.
+    #
+    # Invariant: never hold one of these locks across an ``await`` — the guarded
+    # sections must stay synchronous, or the blocking acquire could stall the
+    # event loop.
+    _spawn_locks: Dict[str, threading.Lock] = {}
+    _conversation_locks: Dict[str, threading.Lock] = {}
     _primary_agent_uuid: str = None
 
     # ------------------------------------------------------------------ #
@@ -305,10 +320,15 @@ class AgentService:
     # ------------------------------------------------------------------ #
     # Internal helpers
     @classmethod
-    def _get_lock(cls, pool: Dict[str, asyncio.Lock], uuid: str) -> asyncio.Lock:
-        """Return a lock for *uuid* from *pool*, creating one if absent."""
+    def _get_lock(cls, pool: Dict[str, threading.Lock], uuid: str) -> threading.Lock:
+        """Return a lock for *uuid* from *pool*, creating one if absent.
+
+        Locks are ``threading.Lock`` rather than ``asyncio.Lock`` (see the pool
+        declarations): the guarded sections are synchronous and correct locking
+        must work from any event loop.
+        """
         if uuid not in pool:
-            pool[uuid] = asyncio.Lock()
+            pool[uuid] = threading.Lock()
         return pool[uuid]
 
     @staticmethod
@@ -444,7 +464,7 @@ class AgentService:
         # Acquire the spawn lock for the primary coder to serialise with
         # concurrent spawn operations that also hold this lock.
         parent_coder = parent if parent is not None else self.coder
-        async with self._get_lock(self._spawn_locks, parent_coder.uuid):
+        with self._get_lock(self._spawn_locks, parent_coder.uuid):
             for coder_uuid in list(self._sub_agent_order):
                 info = self.sub_agents.get(coder_uuid)
                 if (
@@ -593,7 +613,7 @@ class AgentService:
         # tried to acquire the same lock).
         parent_coder = parent if parent is not None else self.coder
 
-        async with self._get_lock(self._spawn_locks, parent_coder.uuid):
+        with self._get_lock(self._spawn_locks, parent_coder.uuid):
             self._check_max_sub_agents()
             new_uuid = str(uuid4()).split("-")[0]
 
@@ -686,7 +706,7 @@ class AgentService:
 
         # Re-acquire the lock to register — we must re-check max agents since
         # the lock was released and other spawns may have registered in between.
-        async with self._get_lock(self._spawn_locks, parent_coder.uuid):
+        with self._get_lock(self._spawn_locks, parent_coder.uuid):
             self._check_max_sub_agents()
 
             # Register in global coder lookup
@@ -952,7 +972,7 @@ class AgentService:
         else:
             return
 
-        async with self._get_lock(self._conversation_locks, info.parent_uuid):
+        with self._get_lock(self._conversation_locks, info.parent_uuid):
             ConversationService.get_manager(parent_coder).add_message(
                 message_dict={"role": "user", "content": user_content},
                 tag=MessageTag.CUR,
@@ -1200,8 +1220,11 @@ def _tui_notify(tui, callback, *args):
     """Invoke *callback* on the TUI app, from either thread.
 
     ``call_from_thread`` only works when the caller is not the app's own
-    thread; scheduler dispatch runs on the primary (app) event loop, so fall
-    back to calling directly, which is correct when already on that thread.
+    thread. Scheduler-dispatched workflow runs now execute on the coder's own
+    loop (the TUI worker-thread loop — see ``SchedulerService._on_coder_loop``),
+    so notifications originate from the worker thread and ``call_from_thread``
+    applies; when we are already on the app thread (or the TUI is unavailable),
+    fall back to calling directly.
     """
 
     try:

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/helpers/io_proxy.py

@@ -183,7 +183,28 @@ class IOProxy(Generic[T]):
 
     async def confirm_ask(self, *args, **kwargs):
         """Forward confirm_ask — per-coder queue iteration is handled by
-        TextualInputOutput which now iterates all per-coder queues."""
+        TextualInputOutput which now iterates all per-coder queues.
+
+        Coders configured with ``skip_cli_confirmations`` (unattended ``wf:``
+        workflow and ``ws:`` workspace workers) are auto-confirmed. They run
+        with nobody watching, and — more importantly — a blocking prompt has
+        to be awaited from whatever loop the coder happens to run on. A
+        scheduler-dispatched workflow runs on the main (Textual) loop, so
+        blocking there used to rebind ``queues``' global input-wake slot and
+        strand the primary coder's input pump.
+        """
+        coder_ref = getattr(self, "_coder", None)
+        coder = coder_ref() if coder_ref is not None else None
+
+        if coder is not None and getattr(coder, "skip_cli_confirmations", False):
+            question = args[0] if args else kwargs.get("question", "")
+            logger.debug(
+                "auto-confirming %r for unattended coder %s (skip_cli_confirmations)",
+                question,
+                self._coder_uuid,
+            )
+            return True
+
         if "coder_uuid" not in kwargs:
             kwargs["coder_uuid"] = self._coder_uuid
         return await self._target.confirm_ask(*args, **kwargs)

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/helpers/queues.py

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import queue
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 # Global registry: coder_uuid → queue.Queue for sending input to that coder
 _per_coder_queues: dict[str, "queue.Queue"] = {}
 
@@ -19,6 +22,13 @@ _primary_coder_id: str | None = None
 _input_loop: asyncio.AbstractEventLoop | None = None
 _input_wake: asyncio.Event | None = None
 
+# Dedicated wake events for consumers parked on a loop *other* than the primary
+# input loop (for example a scheduler-dispatched workflow asking for input while
+# the scheduler ticks on the main/Textual loop). They get their own slot so a
+# foreign-loop consumer can never steal the primary binding and strand the
+# primary coder's input pump.
+_input_wakes: dict[asyncio.AbstractEventLoop, asyncio.Event] = {}
+
 
 def register_coder_queue(coder_uuid: str, q: "queue.Queue") -> None:
     """Register a per-coder input queue.
@@ -83,6 +93,9 @@ def set_input_loop(loop: asyncio.AbstractEventLoop) -> None:
     global _input_loop, _input_wake
     _input_loop = loop
     _input_wake = asyncio.Event()
+    # This loop now owns the primary slot, so drop any dedicated wake it may
+    # have registered while it was still a foreign consumer.
+    _input_wakes.pop(loop, None)
 
 
 def wake_input_waiters() -> None:
@@ -95,39 +108,73 @@ def wake_input_waiters() -> None:
     coder worker loop), the stale binding is dropped so the next
     wait_for_input() rebinds to the current loop instead of raising
     "Event loop is closed".
+
+    Every loop with a parked consumer is woken, not just the primary one:
+    a consumer on a foreign loop has its own event (see ``_input_wakes``) so
+    the primary binding is never stolen from it.
     """
     global _input_loop, _input_wake
 
     loop = _input_loop
-    if loop is None or _input_wake is None:
-        return
 
-    if loop.is_closed():
-        _input_loop = None
-        _input_wake = None
-        return
+    if loop is not None:
+        if _input_wake is None:
+            _input_loop = None
+        elif loop.is_closed():
+            _input_loop = None
+            _input_wake = None
+        else:
+            loop.call_soon_threadsafe(_input_wake.set)
+
+    for other, wake in list(_input_wakes.items()):
+        if other.is_closed():
+            _input_wakes.pop(other, None)
+            continue
 
-    loop.call_soon_threadsafe(_input_wake.set)
+        try:
+            other.call_soon_threadsafe(wake.set)
+        except RuntimeError:
+            # Loop stopped accepting callbacks between the check and the call.
+            _input_wakes.pop(other, None)
 
 
 async def wait_for_input() -> None:
     """Await the next input push without polling.
 
-    Must be called from the input loop (the coder worker loop). Consumers
-    sweep the payload queues first, then block here until wake_input_waiters()
-    fires. Initializes the wake state from the running loop on first use and
-    rebinds whenever the previous loop was closed or is no longer the
-    running loop (which happens across a hot reload).
+    Intended to be called from the input loop (the coder worker loop).
+    Consumers sweep the payload queues first, then block here until
+    wake_input_waiters() fires. Initializes the wake state from the running
+    loop on first use and rebinds whenever the previous loop was closed (which
+    happens across a hot reload).
+
+    A caller on a *different*, still-live loop no longer rebinds the primary
+    slot: it gets a dedicated wake event instead. Rebinding used to strand the
+    primary coder's input pump on the orphaned event, which froze the TUI
+    (prompts, slash commands and ``/exit`` all unresponsive; only Ctrl-Q
+    worked) whenever a scheduler-dispatched workflow needed input or a
+    confirmation and therefore ran on the main (Textual) loop.
     """
     loop = asyncio.get_running_loop()
 
-    if (
-        _input_loop is None
-        or _input_wake is None
-        or _input_loop.is_closed()
-        or _input_loop is not loop
-    ):
+    if _input_loop is None or _input_wake is None or _input_loop.is_closed():
         set_input_loop(loop)
 
-    _input_wake.clear()
-    await _input_wake.wait()
+    if _input_loop is loop:
+        _input_wake.clear()
+        await _input_wake.wait()
+        return
+
+    logger.warning(
+        "wait_for_input() called from a non-input loop (%r); using a dedicated"
+        " wake event instead of rebinding the primary input loop",
+        loop,
+    )
+
+    wake = _input_wakes.get(loop)
+
+    if wake is None:
+        wake = asyncio.Event()
+        _input_wakes[loop] = wake
+
+    wake.clear()
+    await wake.wait()

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/helpers/scheduler/service.py

@@ -173,7 +173,9 @@ class SchedulerService:
             renewal = asyncio.create_task(renewal)
 
         try:
-            result = await execute_workflow(self.coder, wf, source="scheduler")
+            result = await self._on_coder_loop(
+                lambda: execute_workflow(self.coder, wf, source="scheduler")
+            )
             await self.db.finish(lease, result)
             await self._log_tasks(lease, result)
         except asyncio.CancelledError:
@@ -191,6 +193,43 @@ class SchedulerService:
             nxt = self._successor(wf, slot, now, next_run)
             await self.db.advance(wf.name, nxt)
 
+    def _coder_loop(self) -> Optional[asyncio.AbstractEventLoop]:
+        """Best-effort discovery of the loop the interactive coder runs on.
+
+        In TUI mode the coder lives on a worker-thread loop while the scheduler
+        ticks on the main (Textual) loop, so the two differ. Returns ``None``
+        when the coder's loop cannot be determined (linear/one-shot sessions,
+        tests), in which case callers stay on the current loop.
+        """
+
+        tui_ref = getattr(self.coder, "tui", None)
+
+        try:
+            tui = tui_ref() if callable(tui_ref) else tui_ref
+        except Exception:
+            tui = None
+
+        worker = getattr(tui, "worker", None)
+        loop = getattr(worker, "loop", None)
+
+        return loop if isinstance(loop, asyncio.AbstractEventLoop) else None
+
+    async def _on_coder_loop(self, make_coro: Any) -> Any:
+        """Await ``make_coro()`` on the coder's own event loop.
+
+        A workflow run owns coder I/O (prompts, confirmations, tool output),
+        which is bound to the loop the coder actually runs on.
+        """
+
+        target = self._coder_loop()
+        running = asyncio.get_running_loop()
+
+        if target is None or target is running or target.is_closed():
+            return await make_coro()
+
+        future = asyncio.run_coroutine_threadsafe(make_coro(), target)
+        return await asyncio.wrap_future(future)
+
     async def _log_tasks(self, lease: Any, result: Any) -> None:
         """Mirror the runner's per-task outcomes into the DB ``task_log``."""
 

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/main.py

@@ -173,6 +173,7 @@ YAML_TO_JSON_ARG_KEYS = {
     "system_one": "system-one",
     "server_config": "server-config",
     "workflows": "workflows",
+    "scheduler": "scheduler",
 }
 
 
@@ -1212,6 +1213,16 @@ async def main_async(
     lint_cmds = parse_lint_cmds(args.lint_cmd, io)
     if lint_cmds is None:
         return await graceful_exit(None, 1)
+
+    # Create/attach the git repo before the coder is built. The coder resolves
+    # its repo, root, and repo_map at construction; if the repo is created
+    # afterwards the coder keeps repo=None for the whole session and
+    # repo-backed tools (Grep, git_*, ...) fail with "Not in a git repository."
+    if args.git and not (suppress_pre_init or args.workspaces or args.workspace_name):
+        git_root = await setup_git(git_root, pre_init_io)
+        if args.gitignore:
+            await check_gitignore(git_root, pre_init_io)
+
     repo = None
     if args.git:
         try:
@@ -1382,10 +1393,6 @@ async def main_async(
                     pre_init_io.tool_output()
                 except KeyboardInterrupt:
                     return await graceful_exit(coder, 1)
-        if args.git and not (suppress_pre_init or args.workspaces or args.workspace_name):
-            git_root = await setup_git(git_root, pre_init_io)
-            if args.gitignore:
-                await check_gitignore(git_root, pre_init_io)
     except UnknownEditFormat as err:
         pre_init_io.tool_error(str(err))
         await pre_init_io.offer_url(
@@ -1539,17 +1546,17 @@ async def main_async(
     # --message/--exit paths above return before the scheduler can tick.
     # Auto mode turns it on iff at least one enabled scheduled workflow
     # exists, so nothing ever touches the coordination DB otherwise.
-    _scheduler_cfg = merged_config.get("scheduler") or {}
-    if _workflows and _scheduler_enabled(args, _scheduler_cfg, _workflows):
+    _scheduler_cfg = _scheduler_config(args)
+    if _workflows and _scheduler_enabled(_scheduler_cfg, _workflows):
         from cecli.helpers.scheduler import SchedulerService
 
         coder.scheduler = SchedulerService(
             coder,
             _workflows,
             io,
-            tick_seconds=_scheduler_cfg.get("tick_seconds", 60),
-            catch_up=_scheduler_cfg.get("catch_up", True),
-            max_catchup=_scheduler_cfg.get("max_catchup", 1),
+            tick_seconds=_scheduler_cfg["tick_seconds"],
+            catch_up=_scheduler_cfg["catch_up"],
+            max_catchup=_scheduler_cfg["max_catchup"],
         )
         await coder.scheduler.start()
 
@@ -1685,18 +1692,46 @@ async def main_async(
             raise
 
 
-def _scheduler_enabled(args, scheduler_cfg, workflows):
-    """Resolve whether the scheduler should run: CLI flag > config > auto."""
+def _scheduler_enabled(scheduler_cfg, workflows):
+    """Resolve whether the scheduler should run: explicit ``enabled`` > auto."""
 
-    if getattr(args, "scheduler", None) is not None:
-        return bool(args.scheduler)
-
-    if scheduler_cfg.get("enabled", None) is not None:
-        return bool(scheduler_cfg.get("enabled"))
+    if scheduler_cfg.get("enabled") is not None:
+        return bool(scheduler_cfg["enabled"])
 
     return any(getattr(wf, "schedule", None) and getattr(wf, "enabled", True) for wf in workflows)
 
 
+def _scheduler_config(args):
+    """Resolve the ``scheduler`` config object, defaults layered underneath.
+
+    ``args.scheduler`` is a JSON string (the CLI ``--scheduler`` value deep-merged
+    over the config-file object) or ``None`` when unset, in which case the
+    documented defaults apply and ``enabled`` stays ``None`` (auto).
+    """
+
+    defaults = {
+        "enabled": None,
+        "tick_seconds": 60,
+        "catch_up": True,
+        "max_catchup": 1,
+    }
+
+    raw = getattr(args, "scheduler", None)
+
+    if not raw:
+        return dict(defaults)
+
+    try:
+        parsed = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        return dict(defaults)
+
+    if not isinstance(parsed, dict):
+        return dict(defaults)
+
+    return {**defaults, **parsed}
+
+
 async def _stop_scheduler_quietly(coder):
     """Best-effort scheduler shutdown used by reload/exit paths."""
 

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/watch.py

@@ -322,6 +322,12 @@ class FileWatcher:
         # before this scan can share the threshold tick and must not be re-found.
         threshold = self.last_scan_time
         found = set()
+        # Track the newest filesystem mtime observed during this scan. On
+        # Windows the wall clock (time.time) is coarser than file mtimes, so a
+        # file written just before this scan can carry an mtime slightly ahead
+        # of scan_started; advancing the threshold from the filesystem clock
+        # instead of the wall clock keeps such a file from being re-found.
+        max_mtime = threshold
 
         for root in self.get_roots_to_watch():
             root_path = Path(root)
@@ -335,12 +341,15 @@ class FileWatcher:
 
             for path in candidates:
                 try:
+                    max_mtime = max(max_mtime, path.stat().st_mtime)
                     if self.filter_func(None, str(path)):
                         found.add(str(path.absolute()))
                 except Exception:
                     continue
 
-        self.last_scan_time = scan_started
+        # Advance to the newest filesystem timestamp we saw so the next scan's
+        # threshold is never behind a file's mtime (see note above).
+        self.last_scan_time = max(scan_started, max_mtime)
 
         if found:
             self.changed_files.update(found)

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/website/docs/config/scheduler.md

@@ -9,14 +9,7 @@ The [scheduler](workflows.html) is the component that turns a [workflow](workflo
 
 ## Running it
 
-The scheduler starts automatically in any interactive cecli session that has at least one enabled, scheduled workflow. Control it explicitly per session with:
-
-```bash
-cecli --scheduler       # force on for this session
-cecli --no-scheduler    # force off (workflows are still usable via /workflows run)
-```
-
-or persistently in `.cecli.conf.yml`:
+The scheduler starts automatically in any interactive cecli session that has at least one enabled, scheduled workflow. It is configured as an object in `.cecli.conf.yml`:
 
 ```yaml
 scheduler:
@@ -26,7 +19,9 @@ scheduler:
   max_catchup: 1              # how many missed slots to replay before skipping ahead
 ```
 
-Resolution order for whether it runs: the CLI flag (`--scheduler` / `--no-scheduler`) wins, then `scheduler.enabled` from config, then auto — on when any enabled workflow has a `schedule:`, off otherwise. Nothing touches the coordination database when no scheduled workflow exists, and one-shot (`--message`) runs return before the scheduler can tick.
+`--scheduler <json>` overrides it for a single session with the same object, e.g. `cecli --scheduler '{"enabled": false}'`. Disabling is always expressed through the object's `enabled` key — there is no separate off switch — and workflows remain usable manually via `/workflows run`.
+
+Resolution order for whether it runs: `enabled` (from the CLI `--scheduler <json>` deep-merged over the `scheduler:` config key) decides on/off; when `enabled` is omitted the mode is auto — on when any enabled workflow has a `schedule:`, off otherwise. Nothing touches the coordination database when no scheduled workflow exists, and one-shot (`--message`) runs return before the scheduler can tick.
 
 The `catch_up` pair controls what happens after downtime (e.g. a sleeping laptop):
 
@@ -35,10 +30,6 @@ The `catch_up` pair controls what happens after downtime (e.g. a sleeping laptop
 
 An individual workflow may override the global setting with its own top-level `catch_up: true|false` key (see [Workflows](workflows.html)); unset means "follow the scheduler".
 
-A headless daemon mode (scheduling on a server with no interactive session) is planned but not yet available; today scheduled runs only fire while a cecli session is alive.
-
-In TUI mode the scheduler ticks and dispatches on the primary event loop while the interactive coder runs on the TUI worker-thread loop. Scheduled runs still get their own sub-agent pane: the container notifications handle being called from the app's own thread. Workflow dispatch itself is loop-safe (the DB is threaded, sub-agent spawning marshals through `AgentService`), but a run's worker conversation shares MCP connections across loops; prefer linear (non-TUI) sessions or a dedicated `--scheduler` instance for production schedules until a `run_coroutine_threadsafe` bridge lands.
-
 ## Multi-instance coordination
 
 You can safely run **many** cecli instances at once (same machine, or one shared `~/.cecli` on a network filesystem — see caveats). They cooperate through a global SQLite database:
@@ -68,5 +59,6 @@ Scheduler state is visible from any session with the [workflow commands](workflo
 
 ## Arguments
 
-- `--scheduler` / `--no-scheduler`: Force the workflow scheduler on or off for this session.
+- `--scheduler <json>`: Override scheduler configuration for this session (same object as the `scheduler:` config key).
 - `--workflows <json|yaml>`: Workflow definitions the scheduler will consider (see [Workflows](workflows.html)).
+- To disable the scheduler, pass `--scheduler '{"enabled": false}'` (or set `enabled: false` under the `scheduler:` config key).

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli/website/docs/config/workflows.md

@@ -154,4 +154,4 @@ tasks:
 ## Arguments
 
 - `--workflows <json|yaml>`: Provide an inline workflows configuration or a path to a workflows file, overriding all file-based sources.
-- `--scheduler` / `--no-scheduler`: Force the [scheduler](scheduler.html) on or off for this session.
+- `--scheduler <json>`: Override [scheduler](scheduler.html) configuration for this session (same object as the `scheduler:` config key).

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.1rc2
+Version: 1.8.1rc3
 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.8.1rc2 → cecli_dev-1.8.1rc3}/cecli_dev.egg-info/SOURCES.txt

@@ -708,6 +708,7 @@ tests/basic/test_repomap.py
 tests/basic/test_retry_config.py
 tests/basic/test_run_cmd.py
 tests/basic/test_sanity_check_repo.py
+tests/basic/test_scheduler_config.py
 tests/basic/test_scripting.py
 tests/basic/test_select_selector.py
 tests/basic/test_sendchat.py

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/cecli_dev.egg-info/scm_file_list.json

@@ -948,6 +948,7 @@
     "tests/basic/test_retry_config.py",
     "tests/basic/test_run_cmd.py",
     "tests/basic/test_sanity_check_repo.py",
+    "tests/basic/test_scheduler_config.py",
     "tests/basic/test_scripting.py",
     "tests/basic/test_select_selector.py",
     "tests/basic/test_sendchat.py",

cecli_dev-1.8.1rc3/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.8.1rc3",
+  "distance": 0,
+  "node": "gb07a9f6ade6f7b329efc64426f6411f275318357",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-16"
+}

{cecli_dev-1.8.1rc2 → cecli_dev-1.8.1rc3}/tests/basic/test_agent_config_merge.py

@@ -113,6 +113,7 @@ def test_all_yaml_to_json_args_deep_merge_with_config_file():
         "system_one",
         "server_config",
         "workflows",
+        "scheduler",
     }
     assert all("_" not in key for key in YAML_TO_JSON_ARG_KEYS.values())