opencommand 0.1.2__tar.gz → 0.1.4__tar.gz

{opencommand-0.1.2 → opencommand-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opencommand
-Version: 0.1.2
+Version: 0.1.4
 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

{opencommand-0.1.2 → opencommand-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opencommand"
-version = "0.1.2"
+version = "0.1.4"
 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.2 → opencommand-0.1.4}/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.1")
+@click.version_option(version="0.1.4")
 @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."""
@@ -70,7 +73,7 @@ def cli(verbose: bool) -> None:
 def workspace(path: str | None) -> None:
     """Show workspace info and embedded engine status."""
     cfg = _load_cfg(path)
-    engine = Engine(model_dir=cfg.workspace / "models")
+    engine = Engine(model_dir=cfg.workspace / "models", device_map=cfg.device_map)
     click.echo(f"Workspace: {cfg.workspace}")
     click.echo(f"Platform: {describe()}")
     click.echo(engine.status())
@@ -149,6 +152,8 @@ def _build_rebuild_command(cmake_args: str) -> tuple:
 @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")
@@ -175,10 +180,42 @@ def config(path: str | None) -> None:
     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)
+        "GPU layers to offload (0=CPU, -1=all) [legacy default for unpinned roles]",
+        type=int, default=cfg.n_gpu_layers)
     cfg.goal_file = click.prompt(
         "Session goal spec file name", default=cfg.goal_file)
 
+    # --- Per-role device placement ---------------------------------------
+    click.echo(click.style("\nModel device placement", fg="cyan", bold=True))
+    click.echo("Pin each model role to GPU (offload all layers) or CPU+RAM.")
+    click.echo("Example: Commander=GPU, Workers=CPU, VL model=GPU (low VRAM host).")
+    dm = dict(cfg.device_map)
+    for role in ("commander", "worker", "vision", "vision_small"):
+        cur = dm.get(role, "default")
+        choice = click.prompt(
+            f"  {role} device", type=click.Choice(["gpu", "cpu", "default"]),
+            default=cur)
+        if choice == "default":
+            dm.pop(role, None)
+        else:
+            dm[role] = choice
+    cfg.device_map = dm
+
+    # --- 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"))
 
@@ -267,6 +304,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:
@@ -374,7 +438,8 @@ def run(goal: str | None, path: str | None, goal_file: str | None, max_iter: int
         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)
+                    pool_size=pool or cfg.max_workers,
+                    device_map=cfg.device_map)
     sup = Supervisor(max_retries=cfg.max_retries)
     tools = _build_tools(engine, cfg)
     commander = Commander(engine, sup, tools, cfg.workspace)

{opencommand-0.1.2 → opencommand-0.1.4}/src/opencommand/core/config.py

@@ -22,8 +22,17 @@ class OpenCommandConfig:
     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
+    n_gpu_layers: int = 0  # 0 = CPU; -1 = all GPU layers (legacy global default)
     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
+    # --- Per-role device placement -----------------------------------------
+    # Maps a model role to "gpu" (offload all layers) or "cpu" (RAM only).
+    # Roles: commander, worker, vision, vision_small. Any role not present
+    # falls back to the legacy `n_gpu_layers` (GPU if -1, else CPU). This is
+    # how a low-VRAM host keeps the Commander on the GPU while Workers run in
+    # RAM, and the VL model stays on the GPU for the desktop agent.
+    device_map: dict = field(default_factory=dict)  # empty -> all roles use n_gpu_layers
 
     def save(self) -> None:
         self._path().parent.mkdir(parents=True, exist_ok=True)
@@ -45,6 +54,8 @@ class OpenCommandConfig:
             "batch_size": self.batch_size,
             "n_gpu_layers": self.n_gpu_layers,
             "goal_file": self.goal_file,
+            "desktop_policy": self.desktop_policy,
+            "device_map": self.device_map,
         }, indent=2)
 
     @classmethod
@@ -68,11 +79,28 @@ class OpenCommandConfig:
             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", {}),
+            device_map=d.get("device_map", {}),
         )
 
     def _path(self) -> Path:
         return self.workspace / ".opencommand" / "config.json"
 
+    def n_gpu_layers_for(self, role: str) -> int:
+        """Resolve GPU offload layers for a model role.
+
+        If ``device_map`` pins the role to "gpu" -> -1 (all layers offloaded);
+        if pinned to "cpu" -> 0 (RAM only). When the role is absent from
+        ``device_map`` we fall back to the legacy global ``n_gpu_layers`` so
+        existing configs keep working.
+        """
+        dev = self.device_map.get(role)
+        if dev == "gpu":
+            return -1
+        if dev == "cpu":
+            return 0
+        return self.n_gpu_layers
+
     @classmethod
     def from_host(cls, workspace: Path) -> "OpenCommandConfig":
         """Build a config tuned to the current host via platform autodetection."""
@@ -81,4 +109,8 @@ class OpenCommandConfig:
         cfg = cls(workspace=workspace)
         for k, v in rec["config"].items():
             setattr(cfg, k, v)
+        # device_map is a nested dict; apply it explicitly so it isn't
+        # clobbered by the flat setattr loop above.
+        if "device_map" in rec["config"]:
+            cfg.device_map = dict(rec["config"]["device_map"])
         return cfg

{opencommand-0.1.2 → opencommand-0.1.4}/src/opencommand/engine/__init__.py

@@ -18,18 +18,34 @@ class Engine:
     dedicated instance per worker index for true parallelism.
     """
 
-    def __init__(self, model_dir: Path | None = None, pool_size: int = 4) -> None:
+    def __init__(self, model_dir: Path | None = None, pool_size: int = 4,
+                 device_map: dict | None = None) -> None:
         self.model_dir = model_dir or DEFAULT_MODEL_DIR
         self.pool_size = max(1, pool_size)
+        # device_map pins a role to "gpu" (-1 layers) or "cpu" (0 layers);
+        # roles absent fall back to the legacy global n_gpu_layers (set per-runner
+        # via set_gpu_layers). Kept as a dict so callers can mutate it live.
+        self.device_map = dict(device_map or {})
         self._runners: dict[str, LocalRunner] = {}
         self._pools: dict[str, list[LocalRunner]] = {}
 
+    def _gpu_layers(self, role: str) -> int:
+        """Resolve GPU offload layers for a role from the device map."""
+        dev = self.device_map.get(role)
+        if dev == "gpu":
+            return -1
+        if dev == "cpu":
+            return 0
+        return 0  # default: CPU/RAM unless a runner overrides via set_gpu_layers
+
     def runner(self, role: str) -> LocalRunner:
         if role not in self._runners:
             spec = CATALOG.get(role)
             if spec is None:
                 raise KeyError(f"No built-in model for role '{role}'")
-            self._runners[role] = LocalRunner(spec, self.model_dir / role)
+            r = LocalRunner(spec, self.model_dir / role)
+            r.set_gpu_layers(self._gpu_layers(role))
+            self._runners[role] = r
         return self._runners[role]
 
     def worker_runner(self, role: str, index: int = 0) -> LocalRunner:
@@ -40,7 +56,9 @@ class Engine:
         pool = self._pools.setdefault(role, [])
         i = index % self.pool_size
         while len(pool) <= i:
-            pool.append(LocalRunner(spec, self.model_dir / role))
+            r = LocalRunner(spec, self.model_dir / role)
+            r.set_gpu_layers(self._gpu_layers(role))
+            pool.append(r)
         return pool[i]
 
     def ensure_downloaded(self, role: str) -> Path:
@@ -62,5 +80,8 @@ class Engine:
                 state = "instantiated (lazy)"
             else:
                 state = "loaded"
-            lines.append(f"  - {role}: {spec.repo_id} [{spec.kind}] {state}")
+            dev = self.device_map.get(role, "default")
+            dev_label = f"device={dev}" if dev != "default" else "device=default"
+            lines.append(f"  - {role}: {spec.repo_id} [{spec.kind}] "
+                         f"{state} ({dev_label})")
         return "\n".join(lines)

{opencommand-0.1.2 → opencommand-0.1.4}/src/opencommand/engine/runner.py

@@ -87,6 +87,19 @@ class LocalRunner:
         self.model_dir = model_dir
         self._llm = None
         self._lock = threading.Lock()
+        # Per-runner GPU offload override. The Engine sets this from the
+        # device_map (role -> "gpu"|"cpu"); -1 = all layers, 0 = CPU/RAM.
+        self._gpu_layers = spec.n_gpu_layers
+
+    def set_gpu_layers(self, n: int) -> None:
+        """Override how many layers to offload to the GPU for this runner.
+
+        Must be called before the model is loaded. -1 offloads all layers
+        (GPU mode); 0 keeps everything in RAM (CPU mode).
+        """
+        if self._llm is not None:
+            raise RuntimeError("cannot change GPU layers after the model is loaded")
+        self._gpu_layers = n
 
     def download(self) -> Path:
         """Ensure weights exist locally; return the model path (no load)."""
@@ -123,6 +136,21 @@ class LocalRunner:
                 pass
         return Path(path)
 
+    def unload(self) -> None:
+        """Release the mapped weights so the RAM/VRAM is freed.
+
+        Used by the Commander to drop itself from the GPU while the VL desktop
+        agent runs, then re-load on demand. Safe to call when not loaded.
+        """
+        with self._lock:
+            if self._llm is not None:
+                log.info("unloading model role=%s", self.spec.role)
+                try:
+                    self._llm.close()
+                except Exception:  # noqa: BLE001
+                    pass
+                self._llm = None
+
     def _ensure_loaded(self) -> None:
         # Guard construction with the lock so concurrent first-use from multiple
         # worker threads can't build two Llama instances into the same slot.
@@ -135,7 +163,7 @@ class LocalRunner:
             kwargs: dict[str, Any] = {
                 "model_path": str(self._resolve_path()),
                 "n_ctx": self.spec.n_ctx,
-                "n_gpu_layers": self.spec.n_gpu_layers,
+                "n_gpu_layers": self._gpu_layers,
                 "verbose": False,
             }
             if self.spec.kind == "vision":

opencommand-0.1.4/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.4/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.4/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.2 → opencommand-0.1.4}/src/opencommand/modules/system/automatic.py

@@ -120,6 +120,12 @@ async def _live_verify(commander: Commander, goal: str) -> "LiveVerifyResult":
     Returns a LiveVerifyResult. Only meaningful when the desktop tool is wired
     and vision is enabled; otherwise reports a no-op pass so the pipeline can
     continue without a UI target.
+
+    Device-placement behavior: by default the Commander is unloaded from the
+    GPU while the VL desktop agent runs (freeing VRAM for the vision model),
+    then re-loaded so the Commander can review the agent's actions + report and
+    continue the loop. If the Commander is pinned to the same device as the VL
+    model (both GPU) we skip the unload to avoid an unnecessary reload churn.
     """
     from ...modules.tools.desktop import DesktopTool
 
@@ -128,11 +134,28 @@ async def _live_verify(commander: Commander, goal: str) -> "LiveVerifyResult":
     if desktop is None or not getattr(desktop, "vision", None):
         return LiveVerifyResult(ok=True, summary="no desktop tool/vision; skipped",
                                 detail="")
+    # Unload the Commander from the GPU while the VL agent drives the desktop,
+    # unless the Commander is itself pinned to CPU (nothing to free).
+    commander_runner = commander.provider
+    unloaded = False
     try:
+        if getattr(commander_runner, "spec", None) is not None:
+            role = getattr(commander_runner.spec, "role", None)
+            # Only unload if the Commander sits on the GPU (would compete with VL).
+            if commander.engine.device_map.get(role) == "gpu":
+                commander_runner.unload()
+                unloaded = True
         out = desktop.run(f"Verify the goal is satisfied on screen: {goal}", steps=8)
     except Exception as e:  # noqa: BLE001
         return LiveVerifyResult(ok=False, summary="desktop tool error",
                                 detail=str(e))
+    finally:
+        # Re-load the Commander so it can review the agent's report and continue.
+        if unloaded:
+            try:
+                commander_runner._ensure_loaded()
+            except Exception:  # noqa: BLE001
+                pass
     ok = "ERROR" not in out and "done" in out.lower()
     return LiveVerifyResult(ok=ok, summary="interactive check completed", detail=out)
 

{opencommand-0.1.2 → opencommand-0.1.4}/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)

{opencommand-0.1.2 → opencommand-0.1.4}/src/opencommand/modules/system/platform.py

@@ -179,7 +179,18 @@ def recommend_config(d: dict | None = None) -> dict:
     d = d or detect()
     cores = max(1, d["cores"])
     pool = max(1, min(cores - 1, 8))  # leave cores for OS; cap to avoid RAM blowup
-    n_gpu_layers = -1 if d["gpu"]["backend"] != "none" else 0
+    has_gpu = d["gpu"]["backend"] != "none"
+    n_gpu_layers = -1 if has_gpu else 0
+    # Per-role device placement heuristic. We don't know VRAM size from detect()
+    # alone, so we use a conservative split: if a GPU exists, put the small
+    # interactive models (commander planner + the VL desktop agent) on the GPU
+    # and keep the heavier worker pool in CPU+RAM (which scales with RAM, not
+    # VRAM). On a no-GPU host everything is CPU. This is the same split a
+    # low-VRAM host (e.g. 8GB VRAM / 32GB RAM) would pick by hand.
+    device_map = {}
+    if has_gpu:
+        device_map = {"commander": "gpu", "worker": "cpu", "vision": "gpu",
+                      "vision_small": "gpu"}
     build_flags = []
     if d["isa"]["avx512"]:
         build_flags.append("-DGGML_AVX512=ON")
@@ -188,7 +199,8 @@ def recommend_config(d: dict | None = None) -> dict:
     return {
         "config": {
             "max_workers": pool,
-            "vision": d["gpu"]["backend"] != "none" or cores >= 4,
+            "vision": has_gpu or cores >= 4,
+            "device_map": device_map,
         },
         "engine": {"pool_size": pool},
         "runner": {"n_gpu_layers": n_gpu_layers},