gemcode 0.4.5__tar.gz → 0.4.7__tar.gz

{gemcode-0.4.5/src/gemcode.egg-info → gemcode-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.5
+Version: 0.4.7
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.4.5 → gemcode-0.4.7}/pyproject.toml

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

{gemcode-0.4.5 → gemcode-0.4.7}/src/gemcode/agent_mesh.py

@@ -66,7 +66,11 @@ class AgentMesh:
     self._running: dict[str, asyncio.Task] = {}
     self._completed: list[AgentJob] = []
     self._scheduler_task: asyncio.Task | None = None
-    self._stop = asyncio.Event()
+    self._stop: asyncio.Event | None = None  # Created in background loop
+    self._bg_thread: "threading.Thread | None" = None
+    self._bg_loop: asyncio.AbstractEventLoop | None = None
+    # _stop is created lazily in the background loop
+    self._stop_flag = False
 
     # Subscribe to org.assign messages on the bus
     self._bus.subscribe(
@@ -112,25 +116,69 @@ class AgentMesh:
     return self._bus
 
   def start(self) -> None:
-    """Start the background scheduler loop and trigger engine."""
-    if self._scheduler_task is None or self._scheduler_task.done():
-      self._scheduler_task = asyncio.create_task(self._scheduler_loop())
-    # Start self-triggering agents
+    """Start the mesh in a dedicated background thread with its own event loop.
+
+    This is critical: the TUI's event loop is blocked on user input most of the
+    time. If we run mesh jobs on the same loop, they can only execute during the
+    brief moments prompt_toolkit yields control — not enough for a full agent turn.
+
+    By running in a separate thread, mesh jobs execute independently. Results are
+    written to fleet_reports.jsonl and picked up on the next user turn, or printed
+    to the terminal via the notification callback.
+    """
+    if self._bg_thread is not None and self._bg_thread.is_alive():
+      return  # Already running
+
+    import threading
+
+    def _run_bg_loop():
+      """Background thread entry: create a new event loop and run the scheduler."""
+      self._bg_loop = asyncio.new_event_loop()
+      asyncio.set_event_loop(self._bg_loop)
+      try:
+        self._bg_loop.run_until_complete(self._bg_main())
+      except Exception:
+        pass
+      finally:
+        try:
+          self._bg_loop.close()
+        except Exception:
+          pass
+
+    self._bg_thread = threading.Thread(target=_run_bg_loop, daemon=True, name="gemcode-mesh")
+    self._bg_thread.start()
+
+  async def _bg_main(self) -> None:
+    """Main coroutine for the background event loop."""
+    self._stop = asyncio.Event()  # Create in the correct loop
+
+    # Start all sub-systems in this loop
+    self._scheduler_task = asyncio.create_task(self._scheduler_loop())
+
     if self._trigger_engine is not None:
       self._trigger_engine.start()
-    # Start habit scheduler (cron/interval recurring tasks)
     if self._habit_scheduler is not None:
       self._habit_scheduler.start()
 
+    # Wait until stopped
+    await self._stop.wait()
+
   def stop(self) -> None:
     """Stop the scheduler and trigger engine."""
-    self._stop.set()
+    if self._stop is not None:
+      self._stop.set()
     if self._scheduler_task and not self._scheduler_task.done():
       self._scheduler_task.cancel()
     if self._trigger_engine is not None:
       self._trigger_engine.stop()
     if self._habit_scheduler is not None:
       self._habit_scheduler.stop()
+    # Signal the background loop to exit
+    if self._bg_loop is not None:
+      try:
+        self._bg_loop.call_soon_threadsafe(self._bg_loop.stop)
+      except Exception:
+        pass
 
   def enqueue(
     self,
@@ -141,7 +189,7 @@ class AgentMesh:
     member_name: str = "",
     meta: dict[str, Any] | None = None,
   ) -> str:
-    """Enqueue a job and return its job_id."""
+    """Enqueue a job and return its job_id. Thread-safe."""
     job_id = f"mesh_{uuid.uuid4().hex[:10]}"
     self._seq += 1
     job = AgentJob(
@@ -163,13 +211,9 @@ class AgentMesh:
       payload={"job_id": job_id, "member": member_name, "priority": priority},
     ))
 
-    # Auto-start scheduler if not running
-    try:
-      loop = asyncio.get_running_loop()
-      if self._scheduler_task is None or self._scheduler_task.done():
-        self._scheduler_task = loop.create_task(self._scheduler_loop())
-    except RuntimeError:
-      pass
+    # Auto-start the background thread if not running
+    if self._bg_thread is None or not self._bg_thread.is_alive():
+      self.start()
 
     return job_id
 
@@ -267,7 +311,7 @@ class AgentMesh:
 
   async def _scheduler_loop(self) -> None:
     """Continuously dequeue and run jobs."""
-    while not self._stop.is_set():
+    while self._stop is None or not self._stop.is_set():
       try:
         await self._sem.acquire()
         try:

{gemcode-0.4.5 → gemcode-0.4.7}/src/gemcode/invoke.py

@@ -111,10 +111,7 @@ async def run_turn(
     try:
       from gemcode.agent_mesh import ensure_mesh
       mesh = ensure_mesh(cfg)
-      try:
-        mesh.start()
-      except Exception:
-        pass
+      mesh.start()  # Starts background thread if not already running
     except Exception:
       pass
 

{gemcode-0.4.5 → gemcode-0.4.7}/src/gemcode/org.py

@@ -336,6 +336,25 @@ def hire_member(
   root = resolve_fleet_root(project_root)
   org = load_org(root)
   members = list(org.get("members") or [])
+
+  # Prevent duplicate names — ADK sub_agents require unique names
+  clean_name = name.strip().lower()
+  for existing in members:
+    if str(existing.get("name", "")).strip().lower() == clean_name:
+      # Return the existing member instead of creating a duplicate
+      return OrgMember(
+        id=str(existing.get("id") or ""),
+        name=str(existing.get("name") or ""),
+        title=str(existing.get("title") or title),
+        kind=str(existing.get("kind") or kind),
+        address=str(existing.get("address") or ""),
+        workspace_rel=str(existing.get("workspace_rel") or ""),
+        reports_to=str(existing.get("reports_to") or ""),
+        skill_name=str(existing.get("skill_name") or ""),
+        description=str(existing.get("description") or description),
+        created_ms=int(existing.get("created_ms") or 0),
+      )
+
   now = _now_ms()
   mid = f"m_{uuid.uuid4().hex[:10]}"
   m = OrgMember(

{gemcode-0.4.5 → gemcode-0.4.7}/src/gemcode/repl_slash.py

@@ -2964,7 +2964,27 @@ async def process_repl_slash(
         out()
         return ReplSlashResult(skip_model_turn=True)
       except Exception as e:
-        out(f"[agent] agent runtime not reachable at {sock}: {type(e).__name__}: {e}")
+        # Fallback: use the mesh to run the prompt for this agent
+        out(f"[agent] runtime not reachable, using mesh fallback")
+        try:
+          from gemcode.tools.org_tools import make_org_tools
+          org_delegate = None
+          for t in make_org_tools(cfg):
+            if getattr(t, "__name__", "") == "org_delegate":
+              org_delegate = t
+              break
+          if org_delegate is not None:
+            d = await org_delegate(member=m.name, task=prompt, context="")
+            if isinstance(d, dict) and d.get("ok"):
+              out(f"[agent] delegated via mesh: member={m.name}")
+              if d.get("result"):
+                out(str(d.get("result"))[:2000])
+            else:
+              out(f"[agent] mesh delegation failed: {d.get('error') if isinstance(d, dict) else d}")
+          else:
+            out("[agent] org_delegate tool not available")
+        except Exception as e2:
+          out(f"[agent] fallback failed: {type(e2).__name__}: {e2}")
         out()
         return ReplSlashResult(skip_model_turn=True)
 

{gemcode-0.4.5 → gemcode-0.4.7/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.5
+Version: 0.4.7
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License