gemcode 0.4.13__tar.gz → 0.4.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.13
+Version: 0.4.15
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -398,7 +398,7 @@ The LLM calls `transfer_to_agent(agent_name='verifier')` → ADK routes natively
 
 For background work: `org_delegate("kaira", "run tests")` → mesh runs kaira as a full GemCode session → result flows back via fleet reports.
 
-**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. See [`../docs/configuration.md`](../docs/configuration.md) and [`../docs/orchestration.md`](../docs/orchestration.md).
+**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. Fleet auto-continue digests the inbox after **assistant** turns; while idle at ❯, use **`/fleet`** / **`/fleet show`** or any message — see **`GEMCODE_FLEET_TUI_NOTIFY`** in [`../docs/configuration.md`](../docs/configuration.md). See [`../docs/orchestration.md`](../docs/orchestration.md).
 
 Docs:
 - [`../docs/orchestration.md`](../docs/orchestration.md)

{gemcode-0.4.13 → gemcode-0.4.15}/README.md

@@ -205,7 +205,7 @@ The LLM calls `transfer_to_agent(agent_name='verifier')` → ADK routes natively
 
 For background work: `org_delegate("kaira", "run tests")` → mesh runs kaira as a full GemCode session → result flows back via fleet reports.
 
-**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. See [`../docs/configuration.md`](../docs/configuration.md) and [`../docs/orchestration.md`](../docs/orchestration.md).
+**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. Fleet auto-continue digests the inbox after **assistant** turns; while idle at ❯, use **`/fleet`** / **`/fleet show`** or any message — see **`GEMCODE_FLEET_TUI_NOTIFY`** in [`../docs/configuration.md`](../docs/configuration.md). See [`../docs/orchestration.md`](../docs/orchestration.md).
 
 Docs:
 - [`../docs/orchestration.md`](../docs/orchestration.md)

{gemcode-0.4.13 → gemcode-0.4.15}/pyproject.toml

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

{gemcode-0.4.13 → gemcode-0.4.15}/src/gemcode/agent_habits.py

@@ -324,9 +324,11 @@ def make_habits_tools(cfg: GemCodeConfig) -> list:
     They fire as long as GemCode is open (REPL/TUI session).
 
     Results go to the fleet inbox (.gemcode/fleet_reports.jsonl). Fleet auto-continue
-    (GEMCODE_FLEET_REPORTS_AUTO_CONTINUE, default on) can inject digest turns after each assistant
-    reply so the main agent summarizes habit output. Set GEMCODE_FLEET_REPORTS_AUTO_CONTINUE=0 to
-    only drain on your next normal message.
+    (GEMCODE_FLEET_REPORTS_AUTO_CONTINUE, default on) runs digest turns **after each assistant
+    reply** when the inbox still has entries — it does **not** wake the model while the TUI is
+    idle at the prompt. While waiting at ❯, use **`/fleet`** (digest) or **`/fleet show`** (peek),
+    or send any message; the TUI also prints a throttled hint when mesh jobs finish
+    (GEMCODE_FLEET_TUI_NOTIFY).
 
     Args:
       name: Unique name for this habit (e.g., "test-watch", "nightly-audit").

{gemcode-0.4.13 → gemcode-0.4.15}/src/gemcode/agent_mesh.py

@@ -16,8 +16,10 @@ Slash **`/agent assign`** / **`trigger`** publish `org.assign` over IPC when the
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import copy
 import os
+import threading
 import time
 import uuid
 from dataclasses import dataclass, field
@@ -42,6 +44,8 @@ class AgentJob:
   result: str = ""
   error: str = ""
   created_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+  # When set, completed with this AgentJob from the mesh thread (cross-thread wait).
+  completion_future: concurrent.futures.Future | None = None
 
 
 def _apply_mesh_worker_unattended_policy(cfg: GemCodeConfig) -> None:
@@ -80,6 +84,11 @@ class AgentMesh:
     self._sem = asyncio.Semaphore(self.max_concurrency)
     self._running: dict[str, asyncio.Task] = {}
     self._completed: list[AgentJob] = []
+    self._completed_lock = threading.Lock()
+    self._enqueue_lock = threading.Lock()
+    self._bg_thread_ident: int | None = None
+    # >0 while executing a mesh job on the background loop (nested delegate avoids deadlock).
+    self._mesh_job_depth: int = 0
     self._scheduler_task: asyncio.Task | None = None
     self._stop: asyncio.Event | None = None  # Created in background loop
     self._bg_thread: "threading.Thread | None" = None
@@ -172,6 +181,7 @@ class AgentMesh:
       """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)
+      self._bg_thread_ident = threading.current_thread().ident
       try:
         self._bg_loop.run_until_complete(self._bg_main())
       except Exception:
@@ -190,7 +200,9 @@ class AgentMesh:
     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())
+    # Tests can set PYTEST_GEMCODE_MESH_SCHEDULER=0 to inspect the queue without workers consuming it.
+    if os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER", "").strip() != "0":
+      self._scheduler_task = asyncio.create_task(self._scheduler_loop())
 
     if self._trigger_engine is not None:
       self._trigger_engine.start()
@@ -217,6 +229,40 @@ class AgentMesh:
       except Exception:
         pass
 
+  def _is_on_mesh_thread(self) -> bool:
+    ident = threading.current_thread().ident
+    return self._bg_thread_ident is not None and ident == self._bg_thread_ident
+
+  def _wait_bg_loop_ready(self, timeout_s: float = 5.0) -> bool:
+    """Wait until the background thread has assigned ``_bg_loop``."""
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+      if self._bg_loop is not None:
+        return True
+      if self._bg_thread is not None and not self._bg_thread.is_alive():
+        return False
+      time.sleep(0.001)
+    return self._bg_loop is not None
+
+  def wait_for_pending_enqueues(self, timeout: float = 5.0) -> None:
+    """
+    Block until callbacks scheduled with ``call_soon_threadsafe`` (for enqueues
+    from other threads) have run on the mesh loop. Useful in tests.
+    """
+    if self._bg_loop is None:
+      return
+    fut: concurrent.futures.Future[None] = concurrent.futures.Future()
+
+    def _poke() -> None:
+      if not fut.done():
+        try:
+          fut.set_result(None)
+        except Exception:
+          pass
+
+    self._bg_loop.call_soon_threadsafe(_poke)
+    fut.result(timeout=timeout)
+
   def enqueue(
     self,
     *,
@@ -225,10 +271,13 @@ class AgentMesh:
     session_id: str = "",
     member_name: str = "",
     meta: dict[str, Any] | None = None,
+    completion_future: concurrent.futures.Future | None = None,
   ) -> str:
-    """Enqueue a job and return its job_id. Thread-safe."""
+    """Enqueue a job and return its job_id. Safe to call from any thread."""
     job_id = f"mesh_{uuid.uuid4().hex[:10]}"
-    self._seq += 1
+    with self._enqueue_lock:
+      self._seq += 1
+      seq = self._seq
     job = AgentJob(
       job_id=job_id,
       prompt=prompt,
@@ -236,22 +285,45 @@ class AgentMesh:
       session_id=session_id or str(uuid.uuid4()),
       member_name=member_name,
       meta=meta or {},
+      completion_future=completion_future,
     )
-    # Higher priority = runs first (negate for min-heap)
-    self._queue.put_nowait((-priority, self._seq, job))
+    item = (-priority, seq, job)
 
-    # Publish queued event
-    self._bus.publish_sync(BusMessage(
-      topic="job.queued",
-      from_addr="mesh",
-      to_addr="manager",
-      payload={"job_id": job_id, "member": member_name, "priority": priority},
-    ))
+    def do_put() -> None:
+      try:
+        self._queue.put_nowait(item)
+      except Exception as e:
+        fut = job.completion_future
+        if fut is not None and not fut.done():
+          try:
+            fut.set_exception(e)
+          except Exception:
+            pass
+        return
+      self._bus.publish_sync(BusMessage(
+        topic="job.queued",
+        from_addr="mesh",
+        to_addr="manager",
+        payload={"job_id": job_id, "member": member_name, "priority": priority},
+      ))
 
-    # Auto-start the background thread if not running
     if self._bg_thread is None or not self._bg_thread.is_alive():
       self.start()
 
+    if not self._wait_bg_loop_ready():
+      fut = job.completion_future
+      if fut is not None and not fut.done():
+        try:
+          fut.set_exception(RuntimeError("mesh background loop failed to start"))
+        except Exception:
+          pass
+      return job_id
+
+    if self._is_on_mesh_thread():
+      do_put()
+    else:
+      self._bg_loop.call_soon_threadsafe(do_put)
+
     return job_id
 
   async def delegate_to_member(
@@ -303,39 +375,60 @@ class AgentMesh:
     if context:
       full_prompt += "\n\nContext:\n" + context
 
+    org_meta = {
+      "org": {
+        "member": m.to_dict() if hasattr(m, "to_dict") else {},
+        "task": task,
+        "context": context,
+      }
+    }
+
+    if not wait:
+      job_id = self.enqueue(
+        prompt=full_prompt,
+        priority=priority,
+        session_id="",
+        member_name=m.name,
+        meta=org_meta,
+      )
+      return {"ok": True, "job_id": job_id, "delegated_to": m.name, "async": True}
+
+    # 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:
+      job_id = f"mesh_{uuid.uuid4().hex[:10]}"
+      with self._enqueue_lock:
+        self._seq += 1
+      inline_job = AgentJob(
+        job_id=job_id,
+        prompt=full_prompt,
+        priority=priority,
+        session_id="",
+        member_name=m.name,
+        meta=org_meta,
+      )
+      await self._run_job_inner(inline_job)
+      if inline_job.status == "finished":
+        return {"ok": True, "job_id": job_id, "result": inline_job.result}
+      return {"ok": False, "job_id": job_id, "error": inline_job.error}
+
+    loop = asyncio.get_running_loop()
+    fut: concurrent.futures.Future[AgentJob] = concurrent.futures.Future()
     job_id = self.enqueue(
       prompt=full_prompt,
       priority=priority,
       session_id="",
       member_name=m.name,
-      meta={
-        "org": {
-          "member": m.to_dict() if hasattr(m, "to_dict") else {},
-          "task": task,
-          "context": context,
-        }
-      },
+      meta=org_meta,
+      completion_future=fut,
     )
-
-    if not wait:
-      return {"ok": True, "job_id": job_id, "delegated_to": m.name, "async": True}
-
-    # Wait for completion
-    result = await self._wait_for_job(job_id, timeout=300.0)
-    return result
-
-  async def _wait_for_job(self, job_id: str, timeout: float = 300.0) -> dict[str, Any]:
-    """Wait for a specific job to complete."""
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-      for job in self._completed:
-        if job.job_id == job_id:
-          if job.status == "finished":
-            return {"ok": True, "job_id": job_id, "result": job.result}
-          else:
-            return {"ok": False, "job_id": job_id, "error": job.error}
-      await asyncio.sleep(0.1)
-    return {"ok": False, "job_id": job_id, "error": "timeout"}
+    try:
+      job = await asyncio.wait_for(asyncio.wrap_future(fut, loop=loop), timeout=300.0)
+    except asyncio.TimeoutError:
+      return {"ok": False, "job_id": job_id, "error": "timeout"}
+    if job.status == "finished":
+      return {"ok": True, "job_id": job_id, "result": job.result}
+    return {"ok": False, "job_id": job_id, "error": job.error}
 
   async def _handle_org_assign(self, msg: BusMessage) -> None:
     """Handle org.assign bus messages (A2A-style delegation)."""
@@ -373,6 +466,14 @@ class AgentMesh:
 
   async def _run_job(self, job: AgentJob) -> None:
     """Execute a single job using a fresh ADK Runner."""
+    self._mesh_job_depth += 1
+    try:
+      await self._run_job_inner(job)
+    finally:
+      self._mesh_job_depth -= 1
+
+  async def _run_job_inner(self, job: AgentJob) -> None:
+    """Full job lifecycle (shared by the scheduler and nested inline delegation)."""
     job.status = "running"
     start_ms = int(time.time() * 1000)
 
@@ -391,18 +492,22 @@ class AgentMesh:
       duration_ms = int(time.time() * 1000) - start_ms
 
       # Publish completion
+      _jr_finished: dict[str, Any] = {
+        "job_id": job.job_id,
+        "session_id": job.session_id,
+        "status": "finished",
+        "member": job.member_name,
+        "report": result_text[:8000],
+        "duration_ms": duration_ms,
+      }
+      _hm0 = job.meta.get("habit") if isinstance(job.meta, dict) else None
+      if isinstance(_hm0, dict):
+        _jr_finished["habit"] = _hm0
       await self._bus.publish(BusMessage(
         topic="job.report",
         from_addr=job.member_name or "mesh",
         to_addr="manager",
-        payload={
-          "job_id": job.job_id,
-          "session_id": job.session_id,
-          "status": "finished",
-          "member": job.member_name,
-          "report": result_text[:8000],
-          "duration_ms": duration_ms,
-        },
+        payload=_jr_finished,
       ))
 
       # Also publish org.report if this was an org delegation
@@ -459,17 +564,21 @@ class AgentMesh:
       job.status = "failed"
       job.error = f"{type(e).__name__}: {e}"
 
+      _jr_failed: dict[str, Any] = {
+        "job_id": job.job_id,
+        "session_id": job.session_id,
+        "status": "failed",
+        "member": job.member_name,
+        "error": job.error,
+      }
+      _hm1 = job.meta.get("habit") if isinstance(job.meta, dict) else None
+      if isinstance(_hm1, dict):
+        _jr_failed["habit"] = _hm1
       await self._bus.publish(BusMessage(
         topic="job.report",
         from_addr=job.member_name or "mesh",
         to_addr="manager",
-        payload={
-          "job_id": job.job_id,
-          "session_id": job.session_id,
-          "status": "failed",
-          "member": job.member_name,
-          "error": job.error,
-        },
+        payload=_jr_failed,
       ))
 
       # Persist failure to fleet reports
@@ -491,10 +600,17 @@ class AgentMesh:
         pass
 
     finally:
-      self._completed.append(job)
-      # Keep completed list bounded
-      if len(self._completed) > 200:
-        self._completed = self._completed[-100:]
+      cf = job.completion_future
+      if cf is not None and not cf.done():
+        try:
+          cf.set_result(job)
+        except Exception:
+          pass
+      with self._completed_lock:
+        self._completed.append(job)
+        # Keep completed list bounded
+        if len(self._completed) > 200:
+          self._completed = self._completed[-100:]
 
   async def _execute_agent_turn(self, job: AgentJob) -> str:
     """
@@ -732,15 +848,18 @@ class AgentMesh:
 
   def status(self) -> dict[str, Any]:
     """Get mesh status for debugging/display."""
+    with self._completed_lock:
+      recent = [
+        {"job_id": j.job_id, "member": j.member_name, "status": j.status}
+        for j in self._completed[-10:]
+      ]
+      n_completed = len(self._completed)
     return {
       "running_jobs": len(self._running),
       "queued_jobs": self._queue.qsize(),
-      "completed_jobs": len(self._completed),
+      "completed_jobs": n_completed,
       "max_concurrency": self.max_concurrency,
-      "recent_completed": [
-        {"job_id": j.job_id, "member": j.member_name, "status": j.status}
-        for j in self._completed[-10:]
-      ],
+      "recent_completed": recent,
     }
 
 

{gemcode-0.4.13 → gemcode-0.4.15}/src/gemcode/fleet_reports.py

@@ -366,3 +366,60 @@ def drain_for_prompt(project_root: Path, *, max_chars: int | None = None) -> str
       "increase GEMCODE_FLEET_REPORTS_MAX_CHARS to drain more per turn)"
     )
   return header + body
+
+
+def preview_fleet_inbox(project_root: Path, *, max_chars: int | None = None) -> str:
+  """
+  Format pending fleet inbox lines without draining the file (for ``/fleet show``).
+  """
+  if max_chars is None:
+    try:
+      max_chars = int(os.environ.get("GEMCODE_FLEET_REPORTS_MAX_CHARS", "14000"))
+    except Exception:
+      max_chars = 14_000
+  try:
+    from gemcode.org import resolve_fleet_root
+
+    fleet_root = resolve_fleet_root(project_root)
+  except Exception:
+    fleet_root = project_root
+  p = _fleet_reports_path(fleet_root)
+  if not p.is_file():
+    return "(no `.gemcode/fleet_reports.jsonl` yet — background jobs append here when they finish)"
+  try:
+    raw = p.read_text(encoding="utf-8", errors="replace")
+  except Exception:
+    return "(could not read fleet_reports.jsonl)"
+  if not raw.strip():
+    return "(fleet inbox is empty)"
+
+  lines_in = [ln.strip() for ln in raw.splitlines() if ln.strip()]
+  blocks: list[str] = []
+  total = 0
+  truncated = False
+  for line in lines_in:
+    try:
+      rec = json.loads(line)
+    except Exception:
+      continue
+    if not isinstance(rec, dict):
+      continue
+    b = _format_record(rec)
+    if not b:
+      continue
+    need = len(b) + 2
+    if total + need > max_chars:
+      truncated = True
+      break
+    blocks.append(b)
+    total += need
+
+  if not blocks:
+    return "(fleet inbox has no readable entries)"
+  header = "Fleet / agent reports (preview — inbox not cleared):\n\n"
+  body = "\n\n".join(blocks)
+  if truncated:
+    body += (
+      "\n\n… (truncated; increase GEMCODE_FLEET_REPORTS_MAX_CHARS or run /fleet show after /fleet digest)"
+    )
+  return header + body

{gemcode-0.4.13 → gemcode-0.4.15}/src/gemcode/repl_commands.py

@@ -236,6 +236,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("runtime",     "Fleet socket status · gemcode runtime · attach/connect"),
     ("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)"),
     ("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.13 → gemcode-0.4.15}/src/gemcode/repl_slash.py

@@ -91,6 +91,61 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /fleet (fleet_reports.jsonl — habits / mesh without waiting for a model turn) ─
+  if name in ("fleet", "fleet_reports", "reports"):
+    from gemcode.fleet_reports import (
+      fleet_digest_prompt,
+      has_pending_fleet_reports,
+      inject_enabled,
+      preview_fleet_inbox,
+    )
+
+    try:
+      object.__setattr__(cfg, "_fleet_auto_chain", 0)
+    except Exception:
+      pass
+
+    sub = (sc.args or "").strip()
+    sub_l = sub.lower()
+    first = sub_l.split()[0] if sub_l else ""
+
+    if sub_l in ("help", "?") or (not sub_l and not has_pending_fleet_reports(cfg.project_root)):
+      out("Fleet inbox (`.gemcode/fleet_reports.jsonl` at fleet root):")
+      out("  /fleet            If reports are pending: run a digest turn (drains inbox into the model).")
+      out("  /fleet digest     Same, when you want to force digest.")
+      out("  /fleet show       Print pending lines without draining (peek only).")
+      out("While the TUI is idle at ❯, auto-continue only runs after an assistant reply;")
+      out("mesh/habit completions still land in the inbox — use /fleet or any message to drain.")
+      if not inject_enabled():
+        out("  (GEMCODE_FLEET_REPORTS_INJECT=0 — inbox is not written.)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub_l in ("show", "peek", "cat") or first in ("show", "peek", "cat"):
+      out(preview_fleet_inbox(cfg.project_root))
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub_l in ("digest", "summarize", "sum") or first in ("digest", "summarize", "sum"):
+      if not has_pending_fleet_reports(cfg.project_root):
+        out("[fleet] no pending reports in inbox.")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      return ReplSlashResult(model_prompt=fleet_digest_prompt())
+
+    if not sub_l:
+      if has_pending_fleet_reports(cfg.project_root):
+        return ReplSlashResult(model_prompt=fleet_digest_prompt())
+      out("[fleet] no pending reports. Try `/fleet help`.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if not has_pending_fleet_reports(cfg.project_root):
+      out("[fleet] no pending reports in inbox.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+    return ReplSlashResult(model_prompt=fleet_digest_prompt())
+
   # ── /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.13 → gemcode-0.4.15}/src/gemcode/tui/scrollback.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import os
 import sys
+import time
 from dataclasses import dataclass
 
 from google.adk.agents.run_config import RunConfig
@@ -278,6 +279,84 @@ async def run_gemcode_scrollback_tui(
       get_cfg=lambda: cfg,
   )
 
+  # When mesh/habit jobs finish, fleet_reports.jsonl updates while we are idle at ❯.
+  # Auto-continue only runs after an *assistant* turn, so print a throttled hint.
+  _tui_loop = asyncio.get_running_loop()
+  _last_fleet_notify_s = [0.0]
+
+  def _on_mesh_job_report_notify(msg: object) -> None:
+    if os.environ.get("GEMCODE_FLEET_TUI_NOTIFY", "1").strip().lower() in (
+        "0", "false", "no", "off",
+    ):
+      return
+    try:
+      from gemcode.event_bus import BusMessage
+
+      if not isinstance(msg, BusMessage) or msg.topic != "job.report":
+        return
+      pl = msg.payload if isinstance(msg.payload, dict) else {}
+      if str(pl.get("status") or "").strip().lower() not in ("finished", "failed"):
+        return
+    except Exception:
+      return
+    try:
+      min_gap = float(os.environ.get("GEMCODE_FLEET_TUI_NOTIFY_MIN_S", "8") or "8")
+    except Exception:
+      min_gap = 8.0
+    now = time.time()
+    if now - _last_fleet_notify_s[0] < min_gap:
+      return
+    _last_fleet_notify_s[0] = now
+
+    def _print_hint() -> None:
+      try:
+        mem = ""
+        if isinstance(msg.payload, dict):
+          mem = str(msg.payload.get("member") or "").strip()
+        habit = ""
+        if isinstance(msg.payload, dict):
+          hm = msg.payload.get("habit")
+          if isinstance(hm, dict):
+            habit = str(hm.get("name") or "").strip()
+        bits = []
+        if mem:
+          bits.append(mem)
+        if habit:
+          bits.append(f"habit:{habit}")
+        extra = f" ({' · '.join(bits)})" if bits else ""
+        line = (
+            f"{ansi.dim}[gemcode] Background job finished{extra} — "
+            f"/fleet to summarize inbox (any message also drains).{ansi.reset}"
+        )
+        if input_handler.is_interactive():
+          try:
+            from prompt_toolkit.patch_stdout import patch_stdout
+
+            with patch_stdout():
+              print(line, flush=True)
+          except Exception:
+            print(line, flush=True)
+        else:
+          print(line, flush=True)
+      except Exception:
+        pass
+
+    try:
+      _tui_loop.call_soon_threadsafe(_print_hint)
+    except Exception:
+      pass
+
+  try:
+    from gemcode.event_bus import get_bus
+
+    get_bus().subscribe(
+        topic="job.report",
+        to_addr="manager",
+        callback=_on_mesh_job_report_notify,
+    )
+  except Exception:
+    pass
+
   # ── Optional: embed Kaira daemon in this TUI ─────────────────────────────
   # This enables continuous background automation without requiring a second
   # terminal. The TUI will also auto-subscribe to IPC events (below) so job

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.13
+Version: 0.4.15
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -398,7 +398,7 @@ The LLM calls `transfer_to_agent(agent_name='verifier')` → ADK routes natively
 
 For background work: `org_delegate("kaira", "run tests")` → mesh runs kaira as a full GemCode session → result flows back via fleet reports.
 
-**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. See [`../docs/configuration.md`](../docs/configuration.md) and [`../docs/orchestration.md`](../docs/orchestration.md).
+**Mesh / habits reliability:** overlapping jobs for the **same** org member serialize writes to that agent’s durable SQLite session so ADK does not raise “stale session” errors. Mesh workers default to **unattended tool approval** (env **`GEMCODE_MESH_WORKER_UNATTENDED`**, on by default) so background shell / delegation / writes do not block the main TUI on HITL. Fleet auto-continue digests the inbox after **assistant** turns; while idle at ❯, use **`/fleet`** / **`/fleet show`** or any message — see **`GEMCODE_FLEET_TUI_NOTIFY`** in [`../docs/configuration.md`](../docs/configuration.md). See [`../docs/orchestration.md`](../docs/orchestration.md).
 
 Docs:
 - [`../docs/orchestration.md`](../docs/orchestration.md)