opencommand 0.1.3__tar.gz → 0.1.4__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "opencommand"
-version = "0.1.3"
+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 = [

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

@@ -60,7 +60,7 @@ def _load_cfg(path: str | None) -> OpenCommandConfig:
 
 
 @click.group()
-@click.version_option(version="0.1.3")
+@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."""
@@ -73,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())
@@ -180,10 +180,27 @@ 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.")
@@ -421,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.3 → opencommand-0.1.4}/src/opencommand/core/config.py

@@ -22,10 +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)
@@ -48,6 +55,7 @@ class OpenCommandConfig:
             "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
@@ -72,11 +80,27 @@ class OpenCommandConfig:
             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."""
@@ -85,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.3 → 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.3 → 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.3 → 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.3 → 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},