gemcode 0.4.16__tar.gz → 0.4.18__tar.gz

{gemcode-0.4.16/src/gemcode.egg-info → gemcode-0.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.16
+Version: 0.4.18
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -292,6 +292,12 @@ Every GemCode run is anchored to a project root. This determines:
 - what instruction files are loaded
 - which repo-local assets are active
 
+### Multi-agent habits, skills, and mesh runtime
+
+- **Habits** for the whole fleet live in **one** file: `.gemcode/habits.json` at the **fleet root**. Each row names which **org member** runs (`agent` field), on what schedule—different members can have different prompts and intervals at once.
+- **Skills** and **per-turn runtime** are **per member**: org `skill_name`, member skill under `.gemcode/skills/`, and optional **agent workspace** `.gemcode/agents/<id>-<slug>/` (own session DB, memory, local skills). Mesh jobs use that context automatically.
+- **Stopping automation:** removing a habit only stops *new* work. To cancel **queued** or **running** mesh jobs, use **`/mesh halt`** or the **`mesh_halt`** tool (see [`orchestration.md`](../docs/orchestration.md#stopping-background-work-habits-removed-but-jobs-still-finishing)).
+
 ### `.gemcode/`
 GemCode stores project-local state under `.gemcode/`, including:
 - sessions

{gemcode-0.4.16 → gemcode-0.4.18}/README.md

@@ -99,6 +99,12 @@ Every GemCode run is anchored to a project root. This determines:
 - what instruction files are loaded
 - which repo-local assets are active
 
+### Multi-agent habits, skills, and mesh runtime
+
+- **Habits** for the whole fleet live in **one** file: `.gemcode/habits.json` at the **fleet root**. Each row names which **org member** runs (`agent` field), on what schedule—different members can have different prompts and intervals at once.
+- **Skills** and **per-turn runtime** are **per member**: org `skill_name`, member skill under `.gemcode/skills/`, and optional **agent workspace** `.gemcode/agents/<id>-<slug>/` (own session DB, memory, local skills). Mesh jobs use that context automatically.
+- **Stopping automation:** removing a habit only stops *new* work. To cancel **queued** or **running** mesh jobs, use **`/mesh halt`** or the **`mesh_halt`** tool (see [`orchestration.md`](../docs/orchestration.md#stopping-background-work-habits-removed-but-jobs-still-finishing)).
+
 ### `.gemcode/`
 GemCode stores project-local state under `.gemcode/`, including:
 - sessions

{gemcode-0.4.16 → gemcode-0.4.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.4.16"
+version = "0.4.18"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/agent_habits.py

@@ -10,9 +10,18 @@ Examples:
 - "Nightly at 2am, run a full security audit"
 - "Every 5 minutes, check for new issues in the tracker"
 
-Habits are stored in `.gemcode/habits.json` and can be managed via tools
-or the REPL. Each habit specifies:
-- Which agent runs it (org member)
+Habits are stored in **one** fleet file, `.gemcode/habits.json` (next to `org.json`),
+and can be managed via tools or the REPL. That file holds **many** rows; each row is
+one schedule and names **which org member** runs it via the ``agent`` field—so
+different agents can have different prompts, intervals, and enablement at the same time.
+
+**Not** stored in habits: each member’s **skills** (org `skill_name`, workspace-local
+skills under `.gemcode/agents/<id>-<slug>/.gemcode/skills/`) and **runtime/session**
+(SQLite session, memory, routing). Those come from org membership and the mesh worker
+context when the habit fires.
+
+Each habit specifies:
+- Which agent runs it (org member name)
 - What they do (prompt)
 - When they do it (interval, cron, or daily)
 - Whether they're enabled
@@ -296,7 +305,7 @@ def make_habits_tools(cfg: GemCodeConfig) -> list:
   """Build tools for managing agent habits."""
 
   def habits_list() -> dict:
-    """List all configured agent habits (scheduled recurring tasks)."""
+    """List all fleet habits. Each entry targets one org member (`agent`); members differ by skills/workspace when the job runs."""
     habits = load_habits(cfg.project_root)
     return {
       "ok": True,
@@ -330,9 +339,14 @@ def make_habits_tools(cfg: GemCodeConfig) -> list:
     or send any message; the TUI also prints a throttled hint when mesh jobs finish
     (GEMCODE_FLEET_TUI_NOTIFY).
 
+    Removing a habit only stops **future** enqueues. Jobs already queued or running (including
+    verifier/trigger follow-ups) keep going until they finish unless you call **`mesh_halt`**
+    or **`/mesh halt`**.
+
     Args:
       name: Unique name for this habit (e.g., "test-watch", "nightly-audit").
-      agent: Org member name to run this (e.g., "kaira", "verifier").
+      agent: Org **member** name to run this (e.g., "kaira", "verifier", "tcs_analyst").
+             That member’s own skills, workspace, and ADK session apply when the habit runs—not the manager’s.
              Use "self" or "main" to run as the main GemCode agent.
       prompt: What the agent should do each time it wakes up.
       every_minutes: Run every N minutes (e.g., 30 = every half hour).
@@ -391,6 +405,11 @@ def make_habits_tools(cfg: GemCodeConfig) -> list:
     save_habits(cfg.project_root, habits)
     return {"ok": True, "removed": before - len(habits)}
 
+  def habits_clear_all() -> dict:
+    """Remove every habit from `.gemcode/habits.json` (nothing will re-enqueue until you add new habits)."""
+    save_habits(cfg.project_root, [])
+    return {"ok": True, "cleared": True}
+
   def habits_pause(name: str) -> dict:
     """Pause a habit (stop it from firing until resumed)."""
     habits = load_habits(cfg.project_root)
@@ -414,7 +433,8 @@ def make_habits_tools(cfg: GemCodeConfig) -> list:
   habits_list.__name__ = "habits_list"
   habits_add.__name__ = "habits_add"
   habits_remove.__name__ = "habits_remove"
+  habits_clear_all.__name__ = "habits_clear_all"
   habits_pause.__name__ = "habits_pause"
   habits_resume.__name__ = "habits_resume"
 
-  return [habits_list, habits_add, habits_remove, habits_pause, habits_resume]
+  return [habits_list, habits_add, habits_remove, habits_clear_all, habits_pause, habits_resume]

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/agent_mesh.py

@@ -9,6 +9,12 @@ that does not require **`gemcode runtime`** for **`org_delegate`**. It manages:
 3. Event routing (via the in-memory EventBus)
 4. Automatic result reporting (fleet reports + bus messages)
 
+Each queued job is bound to an **org member**. When it runs, that member gets their own
+effective ``project_root`` (agent workspace under ``.gemcode/agents/…`` when configured),
+their **skills** (member skill + workspace-local skills), **memory**, **SQLite session**,
+and capability/model routing—so different agents do not share one generic runtime even
+when habits or triggers are defined in the same fleet ``habits.json``.
+
 Optional **`gemcode runtime`** is a separate fleet-manager process (IPC, automations, stdin queue).
 Slash **`/agent assign`** / **`trigger`** publish `org.assign` over IPC when the socket is up; otherwise the REPL falls back to **`org_delegate`** (this mesh). The mesh also subscribes to **`org.assign`** on the in-process bus for the same payload shape.
 """
@@ -24,6 +30,7 @@ import time
 import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
+from collections.abc import Callable
 from typing import Any
 
 from gemcode.config import GemCodeConfig, _truthy_env
@@ -263,6 +270,67 @@ class AgentMesh:
     self._bg_loop.call_soon_threadsafe(_poke)
     fut.result(timeout=timeout)
 
+  def _call_on_mesh_loop(self, fn: Callable[[], Any], *, timeout: float = 30.0) -> Any:
+    """Run a sync callable on the mesh asyncio loop (safe from any thread)."""
+    if self._bg_thread is None or not self._bg_thread.is_alive():
+      self.start()
+    if not self._wait_bg_loop_ready():
+      raise RuntimeError("mesh background loop not available")
+    assert self._bg_loop is not None
+    fut: concurrent.futures.Future[Any] = concurrent.futures.Future()
+
+    def _wrap() -> None:
+      try:
+        fut.set_result(fn())
+      except Exception as e:
+        fut.set_exception(e)
+
+    self._bg_loop.call_soon_threadsafe(_wrap)
+    return fut.result(timeout=timeout)
+
+  def clear_pending_jobs(self) -> int:
+    """Remove jobs not yet started from the mesh queue. Returns how many were dropped."""
+
+    def _drain() -> int:
+      n = 0
+      while True:
+        try:
+          self._queue.get_nowait()
+          n += 1
+        except asyncio.QueueEmpty:
+          break
+      return n
+
+    return int(self._call_on_mesh_loop(_drain))
+
+  def cancel_running_jobs(self) -> int:
+    """Cancel in-flight mesh job tasks (habits, delegates, triggers). Returns cancel count."""
+
+    def _cancel() -> int:
+      n = 0
+      for _jid, task in list(self._running.items()):
+        if not task.done():
+          task.cancel()
+          n += 1
+      return n
+
+    return int(self._call_on_mesh_loop(_cancel))
+
+  def halt_jobs(
+      self,
+      *,
+      clear_queue: bool = True,
+      cancel_running: bool = True,
+  ) -> dict[str, Any]:
+    """Stop queued and/or running mesh work (does not edit ``habits.json``)."""
+    cleared = self.clear_pending_jobs() if clear_queue else 0
+    cancelled = self.cancel_running_jobs() if cancel_running else 0
+    return {
+      "ok": True,
+      "cleared_queued": cleared,
+      "cancelled_running": cancelled,
+    }
+
   def enqueue(
     self,
     *,
@@ -603,6 +671,9 @@ class AgentMesh:
         pass
 
     finally:
+      if job.status == "running":
+        job.status = "cancelled"
+        job.error = "cancelled"
       cf = job.completion_future
       if cf is not None and not cf.done():
         try:

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/repl_commands.py

@@ -237,6 +237,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("bus",         "Runtime bus — send/publish lightweight messages over IPC"),
     ("inbox",       "Bus inbox filters for this UI (to/topics)"),
     ("fleet",       "Fleet inbox — /fleet show | digest (habits / mesh reports)"),
+    ("mesh",        "In-process mesh — /mesh halt | status (stop queued/running jobs)"),
     ("agent",       "Create/manage a child agent workspace (folder + registry)"),
     # NOTE: /org and /delegate are deprecated aliases; keep working but do not list.
     ("limits",      "Execution limits (calls, context, …)"),

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/repl_slash.py

@@ -146,6 +146,66 @@ async def process_repl_slash(
       return ReplSlashResult(skip_model_turn=True)
     return ReplSlashResult(model_prompt=fleet_digest_prompt())
 
+  # ── /mesh (in-process agent mesh — cancel queued/running work) ─────────────
+  if name == "mesh":
+    from gemcode.agent_mesh import get_mesh
+
+    raw_m = (sc.args or "").strip()
+    parts_m = raw_m.lower().split()
+    first_m = parts_m[0] if parts_m else ""
+
+    m = get_mesh(cfg)
+    if m is None:
+      out("[mesh] not initialized.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first_m in ("help", "?"):
+      out("In-process agent mesh (habits, org_delegate, triggers):")
+      out("  /mesh              Show counts + short tip.")
+      out("  /mesh status       Queued / running job counts.")
+      out("  /mesh halt         Drop queued jobs and cancel running mesh tasks.")
+      out("  /mesh halt --habits   Same, and clear `.gemcode/habits.json` entirely.")
+      out("Note: `habits_remove` only stops *new* enqueues; queued or running jobs continue")
+      out("until they finish unless you `/mesh halt`. Orchestration is in this process")
+      out("(no separate daemon required for the mesh).")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first_m in ("halt", "stop", "kill"):
+      and_habits = "--habits" in parts_m
+      try:
+        h = m.halt_jobs(clear_queue=True, cancel_running=True)
+      except Exception as e:
+        out(f"[mesh] halt failed: {type(e).__name__}: {e}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      out(
+        f"[mesh] halted: cleared {h.get('cleared_queued', 0)} queued job(s), "
+        f"cancelled {h.get('cancelled_running', 0)} running task(s).",
+      )
+      if and_habits:
+        from gemcode.agent_habits import save_habits
+        save_habits(cfg.project_root, [])
+        out("[mesh] also cleared `.gemcode/habits.json` (all habits removed).")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if first_m in ("status", "") or not parts_m:
+      st = m.status()
+      out(
+        f"[mesh] queued={st['queued_jobs']}  running={st['running_jobs']}  "
+        f"completed_total={st['completed_jobs']}  max_concurrency={st['max_concurrency']}",
+      )
+      if not parts_m or first_m == "":
+        out("Tip: `/mesh halt` stops queued + running work · `/mesh help`")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    out("[mesh] unknown subcommand. Try `/mesh help`.")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /attach (queue files for the next user message: PDF, images, audio, …) ─
   if name in ("attach", "file", "image", "img"):
     raw_i = (sc.args or "").strip()

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/tools/__init__.py

@@ -206,8 +206,36 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
         return {"ok": False, "error": "mesh not initialized"}
       return {"ok": True, **m.status()}
 
+    def mesh_halt(
+      clear_queued_jobs: bool = True,
+      cancel_running_jobs: bool = True,
+      remove_all_habits: bool = False,
+    ) -> dict:
+      """
+      Stop background mesh work: drop jobs waiting in the queue, cancel jobs currently running,
+      and optionally wipe all habits. Use when habits were removed but work keeps finishing.
+
+      This is the in-process mesh (same GemCode session), not a separate ``gemcode runtime`` daemon.
+      """
+      m = get_mesh(cfg)
+      if m is None:
+        return {"ok": False, "error": "mesh not initialized"}
+      try:
+        out = m.halt_jobs(clear_queue=clear_queued_jobs, cancel_running=cancel_running_jobs)
+      except Exception as e:
+        return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+      if remove_all_habits:
+        from gemcode.agent_habits import save_habits
+        save_habits(cfg.project_root, [])
+        out["habits_cleared"] = True
+      else:
+        out["habits_cleared"] = False
+      return out
+
     mesh_status.__name__ = "mesh_status"
+    mesh_halt.__name__ = "mesh_halt"
     tools.append(mesh_status)
+    tools.append(mesh_halt)
   except Exception:
     pass
 

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/tools/bash.py

@@ -38,7 +38,7 @@ def make_bash_tool(cfg: GemCodeConfig):
             except Exception:
                 pass
 
-    def bash(
+    def _bash_sync(
         command: str,
         timeout_seconds: int = 120,
         cwd_subdir: str = ".",
@@ -232,6 +232,30 @@ def make_bash_tool(cfg: GemCodeConfig):
         except subprocess.TimeoutExpired:
             return {"error": f"Timeout after {timeout_seconds}s", "command": command}
 
+    async def bash(
+        command: str,
+        timeout_seconds: int = 120,
+        cwd_subdir: str = ".",
+        background: bool = False,
+    ) -> dict:
+        """
+        Async wrapper for bash execution.
+
+        Why: synchronous subprocess calls block the TUI event loop, freezing the
+        live spinner timers ("Running…", "Querying…"). We run blocking shell work
+        on a worker thread so the UI keeps updating.
+        """
+        if background:
+            # Background start is quick; keep it synchronous for simplicity.
+            return _bash_sync(command, timeout_seconds=timeout_seconds, cwd_subdir=cwd_subdir, background=True)
+        return await asyncio.to_thread(
+            _bash_sync,
+            command,
+            timeout_seconds,
+            cwd_subdir,
+            False,
+        )
+
     return bash
 
 

{gemcode-0.4.16 → gemcode-0.4.18}/src/gemcode/tools/shell.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import os
 import re
 import shutil
@@ -45,7 +46,7 @@ def make_run_command(cfg: GemCodeConfig):
       except Exception:
         pass
 
-  def run_command(
+  def _run_command_sync(
     command: str,
     args: list[str] | None = None,
     timeout_seconds: int = 120,
@@ -200,4 +201,43 @@ def make_run_command(cfg: GemCodeConfig):
     except subprocess.TimeoutExpired:
       return {"error": f"Timeout after {timeout_seconds}s"}
 
+  async def run_command(
+    command: str,
+    args: list[str] | None = None,
+    timeout_seconds: int = 120,
+    tool_context: ToolContext | None = None,
+    cwd_subdir: str = ".",
+    background: bool = False,
+    extra_env_keys: list[str] | None = None,
+    extra_env_values: list[str] | None = None,
+  ) -> dict:
+    """
+    Async wrapper for allowlisted subprocess execution.
+
+    Why: synchronous subprocess calls block the TUI event loop, freezing the live
+    spinner timers while tools run. We offload blocking work to a thread.
+    """
+    if background:
+      return _run_command_sync(
+        command,
+        args=args,
+        timeout_seconds=timeout_seconds,
+        tool_context=tool_context,
+        cwd_subdir=cwd_subdir,
+        background=True,
+        extra_env_keys=extra_env_keys,
+        extra_env_values=extra_env_values,
+      )
+    return await asyncio.to_thread(
+      _run_command_sync,
+      command,
+      args,
+      timeout_seconds,
+      tool_context,
+      cwd_subdir,
+      False,
+      extra_env_keys,
+      extra_env_values,
+    )
+
   return run_command

{gemcode-0.4.16 → gemcode-0.4.18/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.16
+Version: 0.4.18
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -292,6 +292,12 @@ Every GemCode run is anchored to a project root. This determines:
 - what instruction files are loaded
 - which repo-local assets are active
 
+### Multi-agent habits, skills, and mesh runtime
+
+- **Habits** for the whole fleet live in **one** file: `.gemcode/habits.json` at the **fleet root**. Each row names which **org member** runs (`agent` field), on what schedule—different members can have different prompts and intervals at once.
+- **Skills** and **per-turn runtime** are **per member**: org `skill_name`, member skill under `.gemcode/skills/`, and optional **agent workspace** `.gemcode/agents/<id>-<slug>/` (own session DB, memory, local skills). Mesh jobs use that context automatically.
+- **Stopping automation:** removing a habit only stops *new* work. To cancel **queued** or **running** mesh jobs, use **`/mesh halt`** or the **`mesh_halt`** tool (see [`orchestration.md`](../docs/orchestration.md#stopping-background-work-habits-removed-but-jobs-still-finishing)).
+
 ### `.gemcode/`
 GemCode stores project-local state under `.gemcode/`, including:
 - sessions

{gemcode-0.4.16 → gemcode-0.4.18}/tests/test_agent_mesh.py

@@ -173,6 +173,32 @@ def test_apply_mesh_worker_unattended_off_inherits_manager(tmp_path: Path) -> No
   assert cfg.interactive_permission_ask is True
 
 
+def test_mesh_halt_clears_pending_queue(tmp_path: Path) -> None:
+  old_s = os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER")
+  old_h = os.environ.get("GEMCODE_AGENT_HABITS")
+  os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = "0"
+  os.environ["GEMCODE_AGENT_HABITS"] = "0"
+  try:
+    cfg = GemCodeConfig(project_root=tmp_path)
+    mesh = AgentMesh(cfg, max_concurrency=2)
+    mesh.enqueue(prompt="a", priority=1, member_name="x")
+    mesh.enqueue(prompt="b", priority=1, member_name="y")
+    mesh.wait_for_pending_enqueues()
+    assert mesh._queue.qsize() == 2
+    h = mesh.halt_jobs(clear_queue=True, cancel_running=False)
+    assert h["cleared_queued"] == 2
+    assert mesh._queue.qsize() == 0
+  finally:
+    if old_s is None:
+      os.environ.pop("PYTEST_GEMCODE_MESH_SCHEDULER", None)
+    else:
+      os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = old_s
+    if old_h is None:
+      os.environ.pop("GEMCODE_AGENT_HABITS", None)
+    else:
+      os.environ["GEMCODE_AGENT_HABITS"] = old_h
+
+
 def test_mesh_priority_ordering(tmp_path: Path) -> None:
   """Higher priority jobs should be dequeued first."""
   old_s = os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER")

{gemcode-0.4.16 → gemcode-0.4.18}/tests/test_tools.py

@@ -2,6 +2,8 @@ from pathlib import Path
 import sys
 from unittest.mock import MagicMock
 
+import pytest
+
 from gemcode.hitl_session import HITL_STICKY_SESSION_KEY
 
 from gemcode.config import GemCodeConfig
@@ -43,7 +45,8 @@ def test_read_file(tmp_path: Path, monkeypatch) -> None:
   assert out["content"] == "hello"
 
 
-def test_run_command_allowlist_bypass_after_shell_gate(tmp_path: Path, monkeypatch) -> None:
+@pytest.mark.asyncio
+async def test_run_command_allowlist_bypass_after_shell_gate(tmp_path: Path, monkeypatch) -> None:
   """Interactive approval arms one shot: rm works without being on GEMCODE_ALLOW_COMMANDS."""
   monkeypatch.setenv("GEMCODE_HOME", str(tmp_path / ".gemstate"))
   trust_root(tmp_path, trusted=True)
@@ -53,22 +56,23 @@ def test_run_command_allowlist_bypass_after_shell_gate(tmp_path: Path, monkeypat
   tgt.write_text("hi", encoding="utf-8")
   arm_confirmed_shell_basename("rm")
   run_command = make_run_command(cfg)
-  out = run_command("rm", ["x.txt"])
+  out = await run_command("rm", ["x.txt"])
   assert out.get("exit_code") == 0
   assert not tgt.exists()
   # Gate is not consumed when a different executable runs first (still non-allowlisted).
   arm_confirmed_shell_basename("rm")
   assert "uname" not in cfg.allow_commands
-  wrong = run_command("uname", ["-a"])
+  wrong = await run_command("uname", ["-a"])
   assert "not in allowlist" in str(wrong.get("error", ""))
   tgt2 = tmp_path / "y.txt"
   tgt2.write_text("z", encoding="utf-8")
-  ok2 = run_command("rm", ["y.txt"])
+  ok2 = await run_command("rm", ["y.txt"])
   assert ok2.get("exit_code") == 0
   assert not tgt2.exists()
 
 
-def test_run_command_sticky_session_bypasses_allowlist(tmp_path: Path, monkeypatch) -> None:
+@pytest.mark.asyncio
+async def test_run_command_sticky_session_bypasses_allowlist(tmp_path: Path, monkeypatch) -> None:
   monkeypatch.setenv("GEMCODE_HOME", str(tmp_path / ".gemstate"))
   trust_root(tmp_path, trusted=True)
   cfg = GemCodeConfig(project_root=tmp_path)
@@ -76,12 +80,13 @@ def test_run_command_sticky_session_bypasses_allowlist(tmp_path: Path, monkeypat
   run_command = make_run_command(cfg)
   ctx = MagicMock()
   ctx.state = {HITL_STICKY_SESSION_KEY: True}
-  out = run_command("uname", ["-a"], tool_context=ctx)
+  out = await run_command("uname", ["-a"], tool_context=ctx)
   assert out.get("exit_code") == 0
   assert (out.get("stdout") or out.get("stderr") or "").strip()
 
 
-def test_run_command_cwd_subdir(tmp_path: Path, monkeypatch) -> None:
+@pytest.mark.asyncio
+async def test_run_command_cwd_subdir(tmp_path: Path, monkeypatch) -> None:
   monkeypatch.setenv("GEMCODE_HOME", str(tmp_path / ".gemstate"))
   trust_root(tmp_path, trusted=True)
   cfg = GemCodeConfig(project_root=tmp_path)
@@ -91,7 +96,7 @@ def test_run_command_cwd_subdir(tmp_path: Path, monkeypatch) -> None:
   run_command = make_run_command(cfg)
   ctx = MagicMock()
   ctx.state = {HITL_STICKY_SESSION_KEY: True}
-  out = run_command(
+  out = await run_command(
       "python3",
       ["-c", "print(open('marker.txt').read())"],
       cwd_subdir="nest",
@@ -101,14 +106,15 @@ def test_run_command_cwd_subdir(tmp_path: Path, monkeypatch) -> None:
   assert "in-nest" in (out.get("stdout") or "")
 
 
-def test_run_command_background_returns_pid(tmp_path: Path, monkeypatch) -> None:
+@pytest.mark.asyncio
+async def test_run_command_background_returns_pid(tmp_path: Path, monkeypatch) -> None:
   monkeypatch.setenv("GEMCODE_HOME", str(tmp_path / ".gemstate"))
   trust_root(tmp_path, trusted=True)
   cfg = GemCodeConfig(project_root=tmp_path)
   run_command = make_run_command(cfg)
   ctx = MagicMock()
   ctx.state = {HITL_STICKY_SESSION_KEY: True}
-  out = run_command(
+  out = await run_command(
       "python3",
       ["-c", "print(1)"],
       background=True,
@@ -118,14 +124,15 @@ def test_run_command_background_returns_pid(tmp_path: Path, monkeypatch) -> None
   assert isinstance(out.get("pid"), int)
 
 
-def test_run_command_extra_env_merges(tmp_path: Path, monkeypatch) -> None:
+@pytest.mark.asyncio
+async def test_run_command_extra_env_merges(tmp_path: Path, monkeypatch) -> None:
   monkeypatch.setenv("GEMCODE_HOME", str(tmp_path / ".gemstate"))
   trust_root(tmp_path, trusted=True)
   cfg = GemCodeConfig(project_root=tmp_path)
   run_command = make_run_command(cfg)
   ctx = MagicMock()
   ctx.state = {HITL_STICKY_SESSION_KEY: True}
-  out = run_command(
+  out = await run_command(
       "python3",
       ["-c", "import os; print(os.environ.get('GEMCODE_TEST_EXTRA', ''))"],
       extra_env_keys=["GEMCODE_TEST_EXTRA"],