gemcode 0.4.12__tar.gz → 0.4.14__tar.gz

{gemcode-0.4.12/src/gemcode.egg-info → gemcode-0.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.12
+Version: 0.4.14
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -398,6 +398,8 @@ 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. 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.12 → gemcode-0.4.14}/README.md

@@ -205,6 +205,8 @@ 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. 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.12 → gemcode-0.4.14}/pyproject.toml

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

{gemcode-0.4.12 → gemcode-0.4.14}/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.12 → gemcode-0.4.14}/src/gemcode/agent_mesh.py

@@ -24,7 +24,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from gemcode.config import GemCodeConfig
+from gemcode.config import GemCodeConfig, _truthy_env
 from gemcode.event_bus import BusMessage, EventBus, get_bus
 from gemcode.org import OrgMember, find_member, list_members, resolve_fleet_root
 
@@ -44,6 +44,21 @@ class AgentJob:
   created_ms: int = field(default_factory=lambda: int(time.time() * 1000))
 
 
+def _apply_mesh_worker_unattended_policy(cfg: GemCodeConfig) -> None:
+  """
+  Mesh jobs run on a background thread: there is no human at a separate keyboard.
+  When enabled (default), treat the worker like ``--yes`` and disable in-run HITL so
+  shell / org_delegate / write tools from habits and workers do not block the main TUI.
+
+  Opt out: ``GEMCODE_MESH_WORKER_UNATTENDED=0`` (mesh workers then inherit the
+  manager's ``yes_to_all`` / ``interactive_permission_ask`` as before).
+  """
+  if not _truthy_env("GEMCODE_MESH_WORKER_UNATTENDED", default=True):
+    return
+  cfg.yes_to_all = True
+  cfg.interactive_permission_ask = False
+
+
 class AgentMesh:
   """
   In-process agent orchestration mesh.
@@ -72,6 +87,12 @@ class AgentMesh:
     # _stop is created lazily in the background loop
     self._stop_flag = False
 
+    # Serialize ADK SqliteSessionService writes per (db, user_id, session_id).
+    # Concurrent mesh jobs for the same agent share one session row; interleaved
+    # append_event calls hit optimistic-lock checks and raise "stale session".
+    self._mesh_sqlite_session_locks: dict[str, asyncio.Lock] = {}
+    self._mesh_sqlite_session_locks_guard = asyncio.Lock()
+
     # Subscribe to org.assign messages on the bus
     self._bus.subscribe(
       topic="org.assign",
@@ -115,6 +136,22 @@ class AgentMesh:
   def bus(self) -> EventBus:
     return self._bus
 
+  async def _lock_sqlite_session(
+      self,
+      *,
+      db_path: Path,
+      user_id: str,
+      session_id: str,
+  ) -> asyncio.Lock:
+    """Return the asyncio lock for this ADK SQLite session (create if needed)."""
+    key = f"{db_path.resolve()}\0{user_id}\0{session_id}"
+    async with self._mesh_sqlite_session_locks_guard:
+      lock = self._mesh_sqlite_session_locks.get(key)
+      if lock is None:
+        lock = asyncio.Lock()
+        self._mesh_sqlite_session_locks[key] = lock
+      return lock
+
   def start(self) -> None:
     """Start the mesh in a dedicated background thread with its own event loop.
 
@@ -354,18 +391,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
@@ -422,17 +463,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
@@ -475,14 +520,17 @@ class AgentMesh:
     This means agents build up context over time — they remember past tasks,
     learn from their history, and maintain their own notes.
     """
+    import hashlib
+
     from gemcode.invoke import run_turn
-    from gemcode.session_runtime import create_runner
+    from gemcode.session_runtime import create_runner, session_db_path
     from gemcode.capability_routing import apply_capability_routing
     from gemcode.model_routing import pick_effective_model
 
     # Resolve the agent's workspace as their project root
     # This gives them their own .gemcode/ directory, sessions, memory, etc.
     agent_cfg = copy.deepcopy(self.cfg)
+    _apply_mesh_worker_unattended_policy(agent_cfg)
     fleet_root = resolve_fleet_root(self.cfg.project_root)
 
     if job.member_name:
@@ -507,54 +555,56 @@ class AgentMesh:
     parent_tools = self._build_parent_access_tools(fleet_root)
     all_extra = (mesh_tools or []) + (parent_tools or [])
 
-    # Create a FULL runner rooted at the agent's workspace
-    # This gives them their own SQLite session DB, their own memory, etc.
-    runner = create_runner(agent_cfg, extra_tools=all_extra or None)
+    # Stable session ID per agent (same id across jobs = durable history).
+    stable_session_id = (job.session_id or "").strip()
+    if job.member_name:
+      stable_session_id = f"agent_{hashlib.sha256(job.member_name.encode()).hexdigest()[:12]}"
+    mesh_user_id = job.member_name or "mesh"
 
-    try:
-      # Use a stable session ID per agent so they accumulate history
-      # (not a random UUID — the same agent keeps the same session across jobs)
-      stable_session_id = job.session_id
-      if job.member_name:
-        # Stable session = agent name hash (persists across jobs)
-        import hashlib
-        stable_session_id = f"agent_{hashlib.sha256(job.member_name.encode()).hexdigest()[:12]}"
-
-      # Execute the turn with full power
-      max_calls = min(int(self.cfg.max_llm_calls or 128), 128)
-      events = await run_turn(
-        runner,
-        user_id=job.member_name or "mesh",
+    sqlite_lock = await self._lock_sqlite_session(
+        db_path=session_db_path(agent_cfg),
+        user_id=mesh_user_id,
         session_id=stable_session_id,
-        prompt=job.prompt,
-        max_llm_calls=max_calls,
-        cfg=agent_cfg,
-        consume_fleet_reports=False,
-      )
+    )
 
-      # Extract text from events
-      parts: list[str] = []
-      for ev in events:
-        try:
-          if not ev.content or not ev.content.parts:
-            continue
-          if getattr(ev, "author", None) == "user":
-            continue
-          for part in ev.content.parts:
-            t = getattr(part, "text", None)
-            is_thought = getattr(part, "thought", None)
-            if isinstance(t, str) and t.strip() and not is_thought:
-              parts.append(t)
-        except Exception:
-          continue
+    async with sqlite_lock:
+      # One runner + turn at a time per session row — avoids ADK "stale session"
+      # when habits or overlapping delegations write events concurrently.
+      runner = create_runner(agent_cfg, extra_tools=all_extra or None)
 
-      return "".join(parts).strip() or "(no output)"
-    finally:
-      # Clean up the runner
       try:
-        await runner.close()
-      except Exception:
-        pass
+        max_calls = min(int(self.cfg.max_llm_calls or 128), 128)
+        events = await run_turn(
+          runner,
+          user_id=mesh_user_id,
+          session_id=stable_session_id,
+          prompt=job.prompt,
+          max_llm_calls=max_calls,
+          cfg=agent_cfg,
+          consume_fleet_reports=False,
+        )
+
+        parts: list[str] = []
+        for ev in events:
+          try:
+            if not ev.content or not ev.content.parts:
+              continue
+            if getattr(ev, "author", None) == "user":
+              continue
+            for part in ev.content.parts:
+              t = getattr(part, "text", None)
+              is_thought = getattr(part, "thought", None)
+              if isinstance(t, str) and t.strip() and not is_thought:
+                parts.append(t)
+          except Exception:
+            continue
+
+        return "".join(parts).strip() or "(no output)"
+      finally:
+        try:
+          await runner.close()
+        except Exception:
+          pass
 
   def _build_parent_access_tools(self, fleet_root: Path) -> list:
     """

{gemcode-0.4.12 → gemcode-0.4.14}/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.12 → gemcode-0.4.14}/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.12 → gemcode-0.4.14}/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.12 → gemcode-0.4.14}/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.12 → gemcode-0.4.14/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.12
+Version: 0.4.14
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -398,6 +398,8 @@ 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. 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.12 → gemcode-0.4.14}/tests/test_agent_mesh.py

@@ -3,11 +3,18 @@
 from __future__ import annotations
 
 import asyncio
+import os
 from pathlib import Path
 
 import pytest
 
-from gemcode.agent_mesh import AgentMesh, ensure_mesh, get_mesh, reset_mesh
+from gemcode.agent_mesh import (
+  AgentMesh,
+  _apply_mesh_worker_unattended_policy,
+  ensure_mesh,
+  get_mesh,
+  reset_mesh,
+)
 from gemcode.config import GemCodeConfig
 from gemcode.event_bus import BusMessage, get_bus, reset_bus
 
@@ -21,6 +28,26 @@ def _reset():
   reset_bus()
 
 
+@pytest.mark.asyncio
+async def test_lock_sqlite_session_same_key_reuses_lock(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path)
+  mesh = AgentMesh(cfg)
+  db = tmp_path / ".gemcode" / "sessions.sqlite"
+  a = await mesh._lock_sqlite_session(db_path=db, user_id="agent_x", session_id="sess1")
+  b = await mesh._lock_sqlite_session(db_path=db, user_id="agent_x", session_id="sess1")
+  assert a is b
+
+
+@pytest.mark.asyncio
+async def test_lock_sqlite_session_different_session_distinct_locks(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path)
+  mesh = AgentMesh(cfg)
+  db = tmp_path / ".gemcode" / "sessions.sqlite"
+  a = await mesh._lock_sqlite_session(db_path=db, user_id="agent_x", session_id="sess1")
+  b = await mesh._lock_sqlite_session(db_path=db, user_id="agent_x", session_id="sess2")
+  assert a is not b
+
+
 def test_mesh_creation(tmp_path: Path) -> None:
   cfg = GemCodeConfig(project_root=tmp_path)
   mesh = ensure_mesh(cfg)
@@ -76,6 +103,40 @@ def test_mesh_bus_integration(tmp_path: Path) -> None:
   assert received[0].payload["member"] == "test"
 
 
+def test_apply_mesh_worker_unattended_default_on(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path)
+  cfg.yes_to_all = False
+  cfg.interactive_permission_ask = True
+  old = os.environ.get("GEMCODE_MESH_WORKER_UNATTENDED")
+  try:
+    os.environ.pop("GEMCODE_MESH_WORKER_UNATTENDED", None)
+    _apply_mesh_worker_unattended_policy(cfg)
+  finally:
+    if old is None:
+      os.environ.pop("GEMCODE_MESH_WORKER_UNATTENDED", None)
+    else:
+      os.environ["GEMCODE_MESH_WORKER_UNATTENDED"] = old
+  assert cfg.yes_to_all is True
+  assert cfg.interactive_permission_ask is False
+
+
+def test_apply_mesh_worker_unattended_off_inherits_manager(tmp_path: Path) -> None:
+  cfg = GemCodeConfig(project_root=tmp_path)
+  cfg.yes_to_all = False
+  cfg.interactive_permission_ask = True
+  old = os.environ.get("GEMCODE_MESH_WORKER_UNATTENDED")
+  try:
+    os.environ["GEMCODE_MESH_WORKER_UNATTENDED"] = "0"
+    _apply_mesh_worker_unattended_policy(cfg)
+  finally:
+    if old is None:
+      os.environ.pop("GEMCODE_MESH_WORKER_UNATTENDED", None)
+    else:
+      os.environ["GEMCODE_MESH_WORKER_UNATTENDED"] = old
+  assert cfg.yes_to_all is False
+  assert cfg.interactive_permission_ask is True
+
+
 def test_mesh_priority_ordering(tmp_path: Path) -> None:
   """Higher priority jobs should be dequeued first."""
   cfg = GemCodeConfig(project_root=tmp_path)

{gemcode-0.4.12 → gemcode-0.4.14}/tests/test_fleet_reports.py

@@ -12,6 +12,7 @@ from gemcode.fleet_reports import (
   has_pending_fleet_reports,
   inject_enabled,
   maybe_append_org_report,
+  preview_fleet_inbox,
 )
 from gemcode.org import resolve_fleet_root
 
@@ -98,3 +99,24 @@ def test_inject_disabled_skips_append(tmp_path: Path, monkeypatch: pytest.Monkey
   append_fleet_report(tmp_path, topic="org.report", payload={"status": "finished"})
   p = tmp_path / ".gemcode" / "fleet_reports.jsonl"
   assert not p.exists()
+
+
+def test_preview_fleet_inbox_does_not_clear(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+  monkeypatch.setenv("GEMCODE_FLEET_REPORTS_INJECT", "1")
+  (tmp_path / ".gemcode").mkdir()
+  maybe_append_org_report(
+      tmp_path,
+      {
+          "status": "finished",
+          "job_id": "j-preview",
+          "task": "t",
+          "member": {"name": "w"},
+          "result": {"report": "hello"},
+      },
+  )
+  p = tmp_path / ".gemcode" / "fleet_reports.jsonl"
+  assert p.read_text(encoding="utf-8").strip()
+  prev = preview_fleet_inbox(tmp_path)
+  assert "preview" in prev.lower() or "Fleet / agent reports" in prev
+  assert "hello" in prev
+  assert p.read_text(encoding="utf-8").strip()