opencommand 0.1.1__tar.gz → 0.1.3__tar.gz

{opencommand-0.1.1 → opencommand-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opencommand
-Version: 0.1.1
+Version: 0.1.3
 Summary: Local-first swarm agent framework: a Commander plans and dispatches a swarm of Workers that research, code, test, and interactively drive the computer to complete long-horizon codebase goals.
 Author: DSiENT
 Author-email: DSiENT <w.caskey7@gmail.com>
@@ -16,6 +16,7 @@ Requires-Dist: llama-cpp-python>=0.3.33
 Requires-Dist: huggingface-hub>=0.30.0
 Requires-Dist: watchdog>=6.0.0
 Requires-Dist: ntfy>=2.7.1
+Requires-Dist: yara-python>=4.5.0
 Requires-Python: >=3.14
 Project-URL: Homepage, https://github.com/D5-Interactive/OpenCommand
 Project-URL: Repository, https://github.com/D5-Interactive/OpenCommand
@@ -55,12 +56,26 @@ playwright install   # optional, for the playwright tool
 ```bash
 opencommand models list                 # list built-in embedded models
 opencommand models pull all             # download GGUF models into ./models
+opencommand config                      # interactive menu: workers, batch size, GPU, etc.
 opencommand run "Add unit tests for the engine module."
+opencommand run --goal-file Goal.md    # run from a Goal.md spec (intended state)
 opencommand run "Build a Panda3D FPS" --pipeline advanced --verify "uv run pytest -q"
 opencommand tui                         # live swarm dashboard
 opencommand cron add healthcheck "every 1h" "echo ok"
 ```
 
+### Goal.md spec
+
+Instead of an inline goal, point `run` at a `Goal.md` file that defines the
+intended end state / requirements for the session. Its contents become the goal
+fed to the swarm (and the advanced pipeline's review gate checks against it):
+
+```bash
+opencommand run --goal-file Goal.md
+```
+
+The file name is configurable via `opencommand config` (default `Goal.md`).
+
 ## Built-in models
 
 | Role          | Model                                  |

{opencommand-0.1.1 → opencommand-0.1.3}/README.md

@@ -32,12 +32,26 @@ playwright install   # optional, for the playwright tool
 ```bash
 opencommand models list                 # list built-in embedded models
 opencommand models pull all             # download GGUF models into ./models
+opencommand config                      # interactive menu: workers, batch size, GPU, etc.
 opencommand run "Add unit tests for the engine module."
+opencommand run --goal-file Goal.md    # run from a Goal.md spec (intended state)
 opencommand run "Build a Panda3D FPS" --pipeline advanced --verify "uv run pytest -q"
 opencommand tui                         # live swarm dashboard
 opencommand cron add healthcheck "every 1h" "echo ok"
 ```
 
+### Goal.md spec
+
+Instead of an inline goal, point `run` at a `Goal.md` file that defines the
+intended end state / requirements for the session. Its contents become the goal
+fed to the swarm (and the advanced pipeline's review gate checks against it):
+
+```bash
+opencommand run --goal-file Goal.md
+```
+
+The file name is configurable via `opencommand config` (default `Goal.md`).
+
 ## Built-in models
 
 | Role          | Model                                  |

{opencommand-0.1.1 → opencommand-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opencommand"
-version = "0.1.1"
+version = "0.1.3"
 description = "Local-first swarm agent framework: a Commander plans and dispatches a swarm of Workers that research, code, test, and interactively drive the computer to complete long-horizon codebase goals."
 readme = "README.md"
 authors = [
@@ -20,6 +20,7 @@ dependencies = [
     "huggingface_hub>=0.30.0",
     "watchdog>=6.0.0",
     "ntfy>=2.7.1",
+    "yara-python>=4.5.0",
 ]
 
 [project.scripts]

{opencommand-0.1.1 → opencommand-0.1.3}/src/opencommand/cli.py

@@ -47,7 +47,10 @@ def _build_tools(engine: Engine, cfg: OpenCommandConfig) -> ToolRegistry:
     reg.register(PlaywrightTool())
     reg.register(SystemTool())
     vision_role = cfg.vision_model if cfg.vision else None
-    reg.register(DesktopTool(engine.runner(vision_role) if vision_role else None))
+    from .modules.tools.desktop_safety import DesktopPolicy
+    desktop_policy = DesktopPolicy.from_dict(cfg.desktop_policy)
+    reg.register(DesktopTool(engine.runner(vision_role) if vision_role else None,
+                             policy=desktop_policy))
     return reg
 
 
@@ -57,7 +60,7 @@ def _load_cfg(path: str | None) -> OpenCommandConfig:
 
 
 @click.group()
-@click.version_option(version="0.1.0")
+@click.version_option(version="0.1.3")
 @click.option("-v", "--verbose", is_flag=True, help="Enable verbose (DEBUG) logging.")
 def cli(verbose: bool) -> None:
     """OpenCommand  -  all-in-one local model runner & command center."""
@@ -145,6 +148,61 @@ def _build_rebuild_command(cmake_args: str) -> tuple:
     return base, False, dict(os.environ, CMAKE_ARGS=cmake_args)
 
 
+@cli.command()
+@click.argument("path", required=False)
+def config(path: str | None) -> None:
+    """Interactive menu to set advanced swarm settings (persisted to config.json)."""
+    from .modules.tools.desktop_safety import DesktopPolicy
+
+    cfg = _load_cfg(path)
+    click.echo(click.style("OpenCommand configuration", fg="cyan", bold=True))
+    click.echo(f"Workspace: {cfg.workspace}\n")
+
+    cfg.vision = click.confirm("Enable vision / desktop tool?", default=cfg.vision)
+    cfg.vision_model = click.prompt(
+        "Vision model role", type=click.Choice(["vision", "vision_small"]),
+        default=cfg.vision_model)
+    cfg.max_workers = click.prompt(
+        "Max workers (concurrent model pool size)", type=int, default=cfg.max_workers)
+    cfg.batch_size = click.prompt(
+        "Workers per swarm batch", type=int, default=cfg.batch_size)
+    cfg.max_retries = click.prompt(
+        "Max retries per worker", type=int, default=cfg.max_retries)
+    cfg.pipeline = click.prompt(
+        "Pipeline", type=click.Choice(["standard", "advanced"]), default=cfg.pipeline)
+    cfg.live_verify = click.confirm(
+        "Enable live-verify (interactive desktop check after tests pass)?",
+        default=cfg.live_verify)
+    cfg.max_iterations = click.prompt(
+        "Max automatic-mode iterations", type=int, default=cfg.max_iterations)
+    cfg.max_research_loops = click.prompt(
+        "Max research refinement loops / phase", type=int, default=cfg.max_research_loops)
+    cfg.max_test_loops = click.prompt(
+        "Max test+debug fix loops / phase", type=int, default=cfg.max_test_loops)
+    cfg.n_gpu_layers = click.prompt(
+        "GPU layers to offload (0=CPU, -1=all)", type=int, default=cfg.n_gpu_layers)
+    cfg.goal_file = click.prompt(
+        "Session goal spec file name", default=cfg.goal_file)
+
+    # --- Desktop takeover safety policy ------------------------------------
+    click.echo(click.style("\nDesktop takeover safety policy", fg="cyan", bold=True))
+    click.echo("Defines exactly what the desktop agent is allowed to do.")
+    pol = DesktopPolicy.from_dict(cfg.desktop_policy)
+    pol.allow_mouse = click.confirm("  Allow mouse control (click)?", default=pol.allow_mouse)
+    pol.allow_keyboard = click.confirm("  Allow keyboard control (key)?", default=pol.allow_keyboard)
+    pol.allow_type = click.confirm("  Allow typing text?", default=pol.allow_type)
+    pol.require_confirm = click.confirm(
+        "  Require confirmation for risky-but-permitted actions?", default=pol.require_confirm)
+    pol.max_steps = click.prompt(
+        "  Max desktop interaction steps per run", type=int, default=pol.max_steps)
+    pol.pause_seconds = click.prompt(
+        "  Pause (seconds) between actions", type=float, default=pol.pause_seconds)
+    cfg.desktop_policy = pol.to_dict()
+
+    cfg.save()
+    click.echo(click.style(f"\nSaved config -> {cfg._path()}", fg="green"))
+
+
 @cli.group()
 def models() -> None:
     """Manage built-in embedded models."""
@@ -229,6 +287,33 @@ def cron_remove(name: str, path: str | None) -> None:
     click.echo(f"Removed cron job '{name}'.")
 
 
+@cron.command("edit")
+@click.argument("name")
+@click.option("--schedule", default=None, help="New schedule expression.")
+@click.option("--command", default=None, help="New shell command.")
+@click.option("--goal", default=None, help="New swarm goal (replaces command).")
+@click.option("--path", default=None, help="Workspace directory.")
+def cron_edit(name: str, schedule: str | None, command: str | None,
+              goal: str | None, path: str | None) -> None:
+    """Edit an existing cron job NAME (change schedule/command/goal)."""
+    from .modules.system.cron import CronScheduler
+
+    if schedule is None and command is None and goal is None:
+        click.echo("Nothing to change: pass --schedule, --command, or --goal.")
+        return
+    cfg = _load_cfg(path)
+    cron_file = cfg.workspace / ".opencommand" / "cron.json"
+    sched = CronScheduler.load(cron_file)
+    try:
+        sched.edit(name, schedule=schedule, command=command, goal=goal)
+    except KeyError:
+        click.echo(f"No cron job named '{name}'.")
+        return
+    sched.save(cron_file)
+    click.echo(f"Updated cron job '{name}'.")
+    click.echo(f"Persisted to {cron_file}")
+
+
 @cron.command("status")
 @click.option("--path", default=None, help="Workspace directory.")
 def cron_status(path: str | None) -> None:
@@ -274,11 +359,15 @@ def cron_start(path: str | None) -> None:
 
 
 @cli.command()
-@click.argument("goal")
+@click.argument("goal", required=False)
 @click.option("--path", default=None, help="Workspace directory.")
-@click.option("--max-iter", default=5, help="Automatic-mode iterations.")
+@click.option("--goal-file", default=None,
+              help="Path to a Goal.md spec defining the intended state/goal. "
+                   "If omitted, the configured goal_file in the workspace is used.")
+@click.option("--max-iter", default=None, type=int, help="Automatic-mode iterations.")
 @click.option("--verify", default=None, help="Shell command to verify success (e.g. 'pytest -q').")
 @click.option("--pool", default=None, type=int, help="Worker model pool size (parallelism).")
+@click.option("--batch-size", default=None, type=int, help="Workers spawned per swarm batch.")
 @click.option("--no-vision", is_flag=True, help="Disable the desktop/vision tool.")
 @click.option("--vision-model", default=None,
               type=click.Choice(["vision", "vision_small"]),
@@ -290,10 +379,16 @@ def cron_start(path: str | None) -> None:
                    "(Phase 6: scaffold + research-context + commander review gate).")
 @click.option("--live-verify", is_flag=True,
               help="After tests pass, run the desktop tool to interactively verify UI goals.")
-def run(goal: str, path: str | None, max_iter: int, verify: str | None,
-        pool: int | None, no_vision: bool, vision_model: str | None,
-        pipeline: str | None, live_verify: bool) -> None:
-    """Run a GOAL autonomously using embedded models."""
+def run(goal: str | None, path: str | None, goal_file: str | None, max_iter: int | None,
+        verify: str | None, pool: int | None, batch_size: int | None,
+        no_vision: bool, vision_model: str | None, pipeline: str | None,
+        live_verify: bool) -> None:
+    """Run a GOAL autonomously using embedded models.
+
+    The GOAL may be passed inline, or defined in a Goal.md spec file (see
+    --goal-file) that describes the intended end state / requirements for the
+    session. When a goal file is used, its contents become the goal.
+    """
     import asyncio
 
     from .modules.system.automatic import run_automatic
@@ -308,6 +403,23 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
         cfg.pipeline = pipeline
     if live_verify:
         cfg.live_verify = True
+    if max_iter is not None:
+        cfg.max_iterations = max_iter
+    if batch_size is not None:
+        cfg.batch_size = batch_size
+
+    # Resolve the goal: inline arg wins; otherwise load from a Goal.md spec.
+    goal_path = Path(goal_file or cfg.goal_file)
+    if goal is None:
+        if not goal_path.is_absolute():
+            goal_path = cfg.workspace / goal_path
+        if not goal_path.exists():
+            raise click.UsageError(
+                f"No goal provided and no spec file found at {goal_path}. "
+                "Pass a GOAL argument or create a Goal.md spec.")
+        goal = goal_path.read_text(encoding="utf-8").strip()
+        click.echo(click.style(f"Loaded goal spec: {goal_path}", fg="green"))
+
     engine = Engine(model_dir=cfg.workspace / "models",
                     pool_size=pool or cfg.max_workers)
     sup = Supervisor(max_retries=cfg.max_retries)
@@ -320,8 +432,9 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
     cron = CronScheduler.load(cron_file)
     if cron._jobs:
         cron.on_goal = lambda g: run_automatic(
-            commander, g, max_iterations=max_iter, verify_cmd=verify,
-            pipeline=cfg.pipeline, live_verify=cfg.live_verify)
+            commander, g, max_iterations=cfg.max_iterations, verify_cmd=verify,
+            pipeline=cfg.pipeline, live_verify=cfg.live_verify,
+            batch_size=cfg.batch_size)
         click.echo(click.style(f"Loaded {len(cron._jobs)} cron job(s).", fg="green"))
 
     async def _main() -> str:
@@ -329,8 +442,9 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
             cron.start()
         try:
             return await run_automatic(
-                commander, goal, max_iterations=max_iter, verify_cmd=verify,
-                pipeline=cfg.pipeline, live_verify=cfg.live_verify)
+                commander, goal, max_iterations=cfg.max_iterations, verify_cmd=verify,
+                pipeline=cfg.pipeline, live_verify=cfg.live_verify,
+                batch_size=cfg.batch_size)
         finally:
             cron.stop()
             sup.shutdown()
@@ -338,6 +452,8 @@ def run(goal: str, path: str | None, max_iter: int, verify: str | None,
     click.echo(f"OpenCommand on {describe()}")
     click.echo(click.style(f"Pipeline: {cfg.pipeline}"
                            + (" + live-verify" if cfg.live_verify else ""), fg="cyan"))
+    click.echo(click.style(f"Batch size: {cfg.batch_size}  Pool: {pool or cfg.max_workers}",
+                           fg="cyan"))
     click.echo(click.style("Loading embedded models...", fg="cyan"))
     click.echo(click.style("Running automatic mode...", fg="cyan"))
     report = asyncio.run(_main())

{opencommand-0.1.1 → opencommand-0.1.3}/src/opencommand/core/config.py

@@ -17,6 +17,15 @@ class OpenCommandConfig:
     max_retries: int = 3
     pipeline: str = "standard"  # standard | advanced (Phase 6)
     live_verify: bool = False  # interactive desktop check after verify passes
+    # --- Advanced settings (config menu / Goal.md) -------------------------
+    max_iterations: int = 5  # outer automatic-mode iterations
+    max_research_loops: int = 3  # research refinement loops per phase
+    max_test_loops: int = 5  # test+debug fix loops per phase
+    batch_size: int = 4  # workers spawned per swarm batch
+    n_gpu_layers: int = 0  # 0 = CPU; -1 = all GPU layers
+    goal_file: str = "Goal.md"  # session goal spec file name
+    # --- Desktop takeover safety policy (see modules/tools/desktop_safety.py) -
+    desktop_policy: dict = field(default_factory=dict)  # empty -> safe defaults
 
     def save(self) -> None:
         self._path().parent.mkdir(parents=True, exist_ok=True)
@@ -32,6 +41,13 @@ class OpenCommandConfig:
             "max_retries": self.max_retries,
             "pipeline": self.pipeline,
             "live_verify": self.live_verify,
+            "max_iterations": self.max_iterations,
+            "max_research_loops": self.max_research_loops,
+            "max_test_loops": self.max_test_loops,
+            "batch_size": self.batch_size,
+            "n_gpu_layers": self.n_gpu_layers,
+            "goal_file": self.goal_file,
+            "desktop_policy": self.desktop_policy,
         }, indent=2)
 
     @classmethod
@@ -49,6 +65,13 @@ class OpenCommandConfig:
             max_retries=d.get("max_retries", 3),
             pipeline=d.get("pipeline", "standard"),
             live_verify=d.get("live_verify", False),
+            max_iterations=d.get("max_iterations", 5),
+            max_research_loops=d.get("max_research_loops", 3),
+            max_test_loops=d.get("max_test_loops", 5),
+            batch_size=d.get("batch_size", 4),
+            n_gpu_layers=d.get("n_gpu_layers", 0),
+            goal_file=d.get("goal_file", "Goal.md"),
+            desktop_policy=d.get("desktop_policy", {}),
         )
 
     def _path(self) -> Path:

opencommand-0.1.3/src/opencommand/modules/skills/desktop_linux.md

@@ -0,0 +1,41 @@
+---
+name: desktop-linux
+category: desktop-safety
+updated: 2026-07-12
+tags: [desktop, linux, safety, pyautogui]
+---
+
+# Desktop Agent — Safe Operation on Linux
+
+Guidance for the OpenCommand desktop takeover agent when driving a **Linux**
+host (X11/Wayland). The goal is to accomplish UI goals without destabilizing
+the session.
+
+## Hard rules (enforced by policy, do not bypass)
+- Never trigger `Ctrl+Alt+Del`/`Ctrl+Alt+Backspace` (session kill),
+  `Ctrl+Alt+F1..F12` (VT switch), or `Super+L` (lock) unless the goal requires it.
+- Never type destructive shell commands: `rm -rf`, `dd if=`, `mkfs`, `shutdown`,
+  `reboot`, `:(){:|:&};:` (fork bomb), or anything piped to `| sh` / `| bash`.
+- Do not escalate to root (no `sudo`, no `pkexec`). If a polkit prompt appears,
+  STOP and report.
+
+## pyautogui on Linux
+- `pyautogui.FAILSAFE = True` is always on: move the mouse to the top-left
+  corner to abort. Respect that escape hatch.
+- Screenshot support needs `scrot` (or `gnome-screenshot`); install it if
+  `locateOnScreen` is needed. Wayland may require `gnome-screenshot`/`grim`
+  instead of `scrot`.
+- `type()` targets the focused window. Click into the field first and confirm
+  focus before typing.
+- Prefer `click(x, y)` via image matching over blind key combos.
+
+## Safe interaction patterns
+1. Capture screen → locate the target control (image match or window title).
+2. Click the control; `wait(1)` for the UI to settle.
+3. For text entry, click the field, then `type()` a small specific string.
+4. Verify with another capture before `done`.
+
+## Verification before `done`
+- Confirm the intended window/state is visible and no error dialog is open.
+- If an unexpected confirmation/save dialog appeared, report it rather than
+  dismissing system dialogs blindly.

opencommand-0.1.3/src/opencommand/modules/skills/desktop_macos.md

@@ -0,0 +1,42 @@
+---
+name: desktop-macos
+category: desktop-safety
+updated: 2026-07-12
+tags: [desktop, macos, safety, pyautogui]
+---
+
+# Desktop Agent — Safe Operation on macOS
+
+Guidance for the OpenCommand desktop takeover agent when driving a **macOS**
+host. The goal is to accomplish UI goals without destabilizing the session.
+
+## Hard rules (enforced by policy, do not bypass)
+- Never trigger `Cmd+Q` (quit all / app), `Cmd+Shift+Q` (log out),
+  `Cmd+Ctrl+Power` (force restart), `Ctrl+Power` (dialog), or `Cmd+Option+Esc`
+  (force quit) unless the goal explicitly requires it.
+- Never type destructive shell commands: `rm -rf`, `sudo`, `diskutil erase`,
+  `shutdown`, `reboot`, or anything piped to `| sh` / `| bash`.
+- Do not approve a Touch ID / admin password prompt on the agent's behalf. If
+  one appears, STOP and report.
+
+## pyautogui on macOS
+- `pyautogui.FAILSAFE = True` is always on: move the mouse to the top-left
+  corner to abort. Respect that escape hatch.
+- macOS key names differ: use `command` (not `cmd`), `option` (not `alt`),
+  `control`, `shift`, `return`, `escape`, `space`, `delete` (backspace),
+  `backspace` (forward delete). The policy normalizes these.
+- `type()` targets the focused window. Click into the field first and confirm
+  focus before typing. Note `typewrite` is the underlying call; accented
+  characters may need explicit key names.
+- Prefer `click(x, y)` via image matching over blind key combos.
+
+## Safe interaction patterns
+1. Capture screen → locate the target control (image match or window title).
+2. Click the control; `wait(1)` for the UI to settle.
+3. For text entry, click the field, then `type()` a small specific string.
+4. Verify with another capture before `done`.
+
+## Verification before `done`
+- Confirm the intended window/state is visible and no error dialog is open.
+- If an unexpected confirmation/save dialog appeared, report it rather than
+  dismissing system dialogs blindly.

opencommand-0.1.3/src/opencommand/modules/skills/desktop_windows.md

@@ -0,0 +1,44 @@
+---
+name: desktop-windows
+category: desktop-safety
+updated: 2026-07-12
+tags: [desktop, windows, safety, pyautogui]
+---
+
+# Desktop Agent — Safe Operation on Windows
+
+Guidance for the OpenCommand desktop takeover agent when driving a **Windows**
+host. The goal is to accomplish UI goals without ever destabilizing the system.
+
+## Hard rules (enforced by policy, do not bypass)
+- Never trigger `Win+L` (lock), `Win+R` (Run), `Win+X` (admin menu), `Win+I`
+  (Settings), `Alt+F4` on the desktop/shell, or `Ctrl+Alt+Del`.
+- Never type destructive shell commands: `rmdir /s`, `del /q`, `format`,
+  `shutdown`, `deltree`, or anything piped to `iex`/`powershell -enc`.
+- Never open an admin/UAC prompt on the agent's own behalf. If a UAC dialog
+  appears, STOP and report — do not click "Yes".
+
+## pyautogui on Windows
+- `pyautogui.FAILSAFE = True` is always on: a human can slam the mouse into the
+  top-left corner to abort the agent instantly. Respect that escape hatch.
+- `pyautogui.PAUSE` is set (default 0.5s) so actions are paced and interruptible.
+- Use `click(x, y)` with coordinates from `locateOnScreen`/`locateCenterOnScreen`
+  rather than blind `key` combos wherever possible.
+- Prefer `pyautogui.hotkey('ctrl', 'c')` over `key('ctrl+c')` for combos; the
+  policy only permits safe combos.
+- `type()` writes to whatever has focus — only type after you have clicked into
+  the correct field and confirmed focus.
+
+## Safe interaction patterns
+1. Capture screen → identify the target control by image match or by reading
+   the window.
+2. Click the control (single left click). Wait for the UI to settle (use
+   `wait(1)`).
+3. If text entry is needed, click the field first, then `type()` a small,
+   specific string. Avoid pasting long shell one-liners.
+4. Verify the result with another screen capture before declaring done.
+
+## Verification before `done`
+- Confirm the intended window/state is visible and no error dialog is open.
+- If a confirmation or save dialog appeared unexpectedly, report it; do not
+  dismiss system dialogs blindly.

{opencommand-0.1.1 → opencommand-0.1.3}/src/opencommand/modules/system/automatic.py

@@ -28,12 +28,13 @@ log = get_logger("system.automatic")
 
 async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5,
                         verify_cmd: str | None = None, pipeline: str = "standard",
-                        live_verify: bool = False) -> str:
+                        live_verify: bool = False, batch_size: int = 4) -> str:
     """Iteratively execute the goal, auto-fixing failures, until 100% met.
 
     ``pipeline`` is "standard" or "advanced" (scaffold + research loop +
     commander review gate + test/debug loop). ``live_verify`` runs the desktop
     tool as a final interactive check when the goal is UI/UX facing.
+    ``batch_size`` is the number of workers spawned per swarm batch.
 
     The loop only returns success when BOTH the exit-code verify gate AND the
     Commander review gate pass (and, if enabled, the live-verify check). If the
@@ -47,10 +48,11 @@ async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5
                               tags=["rocket", "opencommand"])
     last = ""
     for i in range(max_iterations):
-        log.info("iteration=%d/%d goal=%r pipeline=%s", i + 1, max_iterations,
-                 original_goal, pipeline)
+        log.info("iteration=%d/%d goal=%r pipeline=%s batch=%d", i + 1,
+                 max_iterations, original_goal, pipeline, batch_size)
         last = await _execute(commander, original_goal, pipeline,
-                              verify_cmd=verify_cmd, live_verify=live_verify)
+                              verify_cmd=verify_cmd, live_verify=live_verify,
+                              batch_size=batch_size)
         # Exit-code gate (real verification, not string matching).
         if verify_cmd:
             rc, out = _verify(commander, verify_cmd)
@@ -98,11 +100,13 @@ async def run_automatic(commander: Commander, goal: str, max_iterations: int = 5
 
 
 async def _execute(commander: Commander, goal: str, pipeline: str,
-                   verify_cmd: str | None = None, live_verify: bool = False) -> str:
+                   verify_cmd: str | None = None, live_verify: bool = False,
+                   batch_size: int = 4) -> str:
     if pipeline == "advanced":
         return await commander.execute_advanced(
-            goal, verify_cmd=verify_cmd, live_verify=live_verify)
-    return await commander.execute(goal)
+            goal, verify_cmd=verify_cmd, live_verify=live_verify,
+            batch_size=batch_size)
+    return await commander.execute(goal, batch_size=batch_size)
 
 
 def _fix_prompt(original_goal: str, last: str) -> str:

{opencommand-0.1.1 → opencommand-0.1.3}/src/opencommand/modules/system/cron.py

@@ -131,6 +131,25 @@ class CronScheduler:
         job.goal = goal
         return job
 
+    def edit(self, name: str, schedule: str | None = None,
+             command: str | None = None, goal: str | None = None) -> CronJob:
+        """Edit an existing job's schedule/command/goal in place.
+
+        Returns the updated job, or raises KeyError if no such job exists.
+        At least one of schedule/command/goal must be provided.
+        """
+        for job in self._jobs:
+            if job.name == name:
+                if schedule is not None:
+                    job.schedule = schedule
+                    job._parse()
+                if command is not None:
+                    job.command = command
+                if goal is not None:
+                    job.goal = goal
+                return job
+        raise KeyError(f"No cron job named {name!r}")
+
     def save(self, path: Path) -> None:
         """Persist serializable jobs to <workspace>/.opencommand/cron.json."""
         path.parent.mkdir(parents=True, exist_ok=True)