gemcode 0.4.15__tar.gz → 0.4.17__tar.gz

{gemcode-0.4.15/src/gemcode.egg-info → gemcode-0.4.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.15
+Version: 0.4.17
 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.15 → gemcode-0.4.17}/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.15 → gemcode-0.4.17}/pyproject.toml

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

{gemcode-0.4.15 → gemcode-0.4.17}/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.15 → gemcode-0.4.17}/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,
     *,
@@ -395,7 +463,10 @@ class AgentMesh:
 
     # Nested wait=True from inside a running mesh job would deadlock the scheduler
     # (parent holds a concurrency slot while the child waits for another slot).
-    if self._mesh_job_depth > 0:
+    # Only use the inline path on the mesh thread: the manager runs on a different
+    # event loop; _mesh_job_depth can be >0 while a habit runs, but inline
+    # _run_job_inner must not run there (asyncio locks / ADK are mesh-loop-local).
+    if self._is_on_mesh_thread() and self._mesh_job_depth > 0:
       job_id = f"mesh_{uuid.uuid4().hex[:10]}"
       with self._enqueue_lock:
         self._seq += 1
@@ -600,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:
@@ -868,12 +942,41 @@ class AgentMesh:
 _global_mesh: AgentMesh | None = None
 
 
+def _sync_mesh_cfg_project_root(mesh: AgentMesh, cfg: GemCodeConfig) -> None:
+  """
+  Keep the singleton aligned with the active manager ``cfg.project_root``.
+
+  If the mesh was created from a different cwd than a later ``ensure_mesh`` /
+  ``get_mesh`` (e.g. ``-C``), habits/triggers/fleet would otherwise read the
+  wrong ``.gemcode/`` tree while the UI used another.
+  """
+  try:
+    cur = Path(mesh.cfg.project_root).resolve()
+    nxt = Path(cfg.project_root).resolve()
+    if cur == nxt:
+      return
+    mesh.cfg.project_root = cfg.project_root
+    if mesh._trigger_engine is not None:
+      mesh._trigger_engine.cfg = mesh.cfg
+      mesh._trigger_engine.reload()
+    if mesh._habit_scheduler is not None:
+      mesh._habit_scheduler.cfg = mesh.cfg
+    if mesh._learner is not None:
+      mesh._learner.cfg = mesh.cfg
+    if mesh._self_healing is not None:
+      mesh._self_healing.cfg = mesh.cfg
+  except Exception:
+    pass
+
+
 def get_mesh(cfg: GemCodeConfig | None = None) -> AgentMesh | None:
   """Get or create the global agent mesh."""
   global _global_mesh
   if _global_mesh is None and cfg is not None:
     concurrency = int(os.environ.get("GEMCODE_MESH_CONCURRENCY", "3"))
     _global_mesh = AgentMesh(cfg, max_concurrency=concurrency)
+  elif _global_mesh is not None and cfg is not None:
+    _sync_mesh_cfg_project_root(_global_mesh, cfg)
   return _global_mesh
 
 
@@ -883,6 +986,8 @@ def ensure_mesh(cfg: GemCodeConfig) -> AgentMesh:
   if _global_mesh is None:
     concurrency = int(os.environ.get("GEMCODE_MESH_CONCURRENCY", "3"))
     _global_mesh = AgentMesh(cfg, max_concurrency=concurrency)
+  else:
+    _sync_mesh_cfg_project_root(_global_mesh, cfg)
   return _global_mesh
 
 

{gemcode-0.4.15 → gemcode-0.4.17}/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.15 → gemcode-0.4.17}/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.15 → gemcode-0.4.17}/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.15 → gemcode-0.4.17/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.15
+Version: 0.4.17
 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.15 → gemcode-0.4.17}/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")