gemcode 0.4.22__tar.gz → 0.4.24__tar.gz

{gemcode-0.4.22/src/gemcode.egg-info → gemcode-0.4.24}/PKG-INFO

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

{gemcode-0.4.22 → gemcode-0.4.24}/pyproject.toml

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

{gemcode-0.4.22 → gemcode-0.4.24}/src/gemcode/agent_habits.py

@@ -66,6 +66,10 @@ class Habit:
   every_seconds: int | None = None  # interval in seconds
   cron: str | None = None  # "M H * * *" (minute, hour)
   daily_at: str | None = None  # "HH:MM"
+  # Trigger chain (fires when another habit's mesh job completes)
+  trigger_after: str | None = None  # upstream habit name
+  trigger_on: str = "finished"  # finished | failed | any
+  trigger_cooldown_s: float = 0.0
   # Metadata
   priority: int = 0
   max_runs: int | None = None  # None = unlimited
@@ -82,6 +86,9 @@ class Habit:
       "every_seconds": self.every_seconds,
       "cron": self.cron,
       "daily_at": self.daily_at,
+      "trigger_after": self.trigger_after,
+      "trigger_on": self.trigger_on,
+      "trigger_cooldown_s": self.trigger_cooldown_s,
       "priority": self.priority,
       "max_runs": self.max_runs,
       "run_count": self.run_count,
@@ -123,6 +130,9 @@ def load_habits(project_root: Path) -> list[Habit]:
         every_seconds=item.get("every_seconds"),
         cron=item.get("cron"),
         daily_at=item.get("daily_at"),
+        trigger_after=(str(item.get("trigger_after") or "").strip().lower() or None),
+        trigger_on=str(item.get("trigger_on") or "finished").strip().lower() or "finished",
+        trigger_cooldown_s=float(item.get("trigger_cooldown_s") or 0),
         priority=int(item.get("priority") or 0),
         max_runs=item.get("max_runs"),
         run_count=int(item.get("run_count") or 0),
@@ -143,9 +153,11 @@ def save_habits(project_root: Path, habits: list[Habit]) -> None:
 
 
 def _is_due(habit: Habit, now_s: float) -> bool:
-  """Check if a habit is due to run."""
+  """Check if a timer-based habit is due to run (trigger-only habits are never due here)."""
   if not habit.enabled:
     return False
+  if (habit.trigger_after or "").strip():
+    return False
   if habit.max_runs is not None and habit.run_count >= habit.max_runs:
     return False
 

{gemcode-0.4.22 → gemcode-0.4.24}/src/gemcode/agent_mesh.py

@@ -124,6 +124,13 @@ class AgentMesh:
     except Exception:
       pass
 
+    self._habit_chain_engine = None
+    try:
+      from gemcode.habit_chains import HabitChainEngine
+      self._habit_chain_engine = HabitChainEngine(cfg)
+    except Exception:
+      pass
+
     # Initialize delegation learning
     self._learner = None
     try:
@@ -213,6 +220,8 @@ class AgentMesh:
 
     if self._trigger_engine is not None:
       self._trigger_engine.start()
+    if self._habit_chain_engine is not None:
+      self._habit_chain_engine.start()
     if self._habit_scheduler is not None:
       self._habit_scheduler.start()
 
@@ -227,6 +236,8 @@ class AgentMesh:
       self._scheduler_task.cancel()
     if self._trigger_engine is not None:
       self._trigger_engine.stop()
+    if self._habit_chain_engine is not None:
+      self._habit_chain_engine.stop()
     if self._habit_scheduler is not None:
       self._habit_scheduler.stop()
     # Signal the background loop to exit
@@ -628,6 +639,23 @@ class AgentMesh:
         if isinstance(hm, dict):
           pl["habit"] = hm
         maybe_append_job_report(fleet_root, pl)
+        try:
+          from gemcode.habit_runs import append_habit_run
+
+          hm = job.meta.get("habit") if isinstance(job.meta, dict) else None
+          if isinstance(hm, dict) and hm.get("name"):
+            append_habit_run(
+              fleet_root,
+              habit_name=str(hm.get("name") or ""),
+              agent=str(hm.get("agent") or job.member_name or ""),
+              job_id=job.job_id,
+              status="finished",
+              report=result_text,
+              duration_ms=duration_ms,
+              session_id=job.session_id,
+            )
+        except Exception:
+          pass
       except Exception:
         pass
 
@@ -667,6 +695,23 @@ class AgentMesh:
         if isinstance(hm, dict):
           plf["habit"] = hm
         maybe_append_job_report(fleet_root, plf)
+        try:
+          from gemcode.habit_runs import append_habit_run
+
+          hm = job.meta.get("habit") if isinstance(job.meta, dict) else None
+          if isinstance(hm, dict) and hm.get("name"):
+            append_habit_run(
+              fleet_root,
+              habit_name=str(hm.get("name") or ""),
+              agent=str(hm.get("agent") or job.member_name or ""),
+              job_id=job.job_id,
+              status="failed",
+              report="",
+              error=job.error,
+              session_id=job.session_id,
+            )
+        except Exception:
+          pass
       except Exception:
         pass
 
@@ -959,6 +1004,9 @@ def _sync_mesh_cfg_project_root(mesh: AgentMesh, cfg: GemCodeConfig) -> None:
     if mesh._trigger_engine is not None:
       mesh._trigger_engine.cfg = mesh.cfg
       mesh._trigger_engine.reload()
+    if mesh._habit_chain_engine is not None:
+      mesh._habit_chain_engine.cfg = mesh.cfg
+      mesh._habit_chain_engine.reload()
     if mesh._habit_scheduler is not None:
       mesh._habit_scheduler.cfg = mesh.cfg
     if mesh._learner is not None:

gemcode-0.4.24/src/gemcode/habit_chains.py

@@ -0,0 +1,219 @@
+"""Habit chains — scheduled tasks that fire when another habit completes."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from typing import Any
+
+from gemcode.agent_habits import Habit, load_habits, save_habits
+from gemcode.config import GemCodeConfig
+from gemcode.event_bus import BusMessage, get_bus
+
+
+def _enabled() -> bool:
+  return os.environ.get("GEMCODE_HABIT_CHAINS", "1").strip().lower() in (
+    "1",
+    "true",
+    "yes",
+    "on",
+  )
+
+
+def _status_matches(trigger_on: str, actual: str) -> bool:
+  want = (trigger_on or "finished").strip().lower()
+  got = (actual or "").strip().lower()
+  if want in ("", "any", "*"):
+    return True
+  return got == want
+
+
+def render_chain_prompt(
+  prompt: str,
+  *,
+  source_habit: str,
+  source_status: str,
+  source_report: str = "",
+  source_error: str = "",
+) -> str:
+  """Substitute template vars from the upstream habit run."""
+  body = (source_report or source_error or "").strip()
+  out = (prompt or "").replace("{{source_habit}}", source_habit)
+  out = out.replace("{{source_status}}", source_status)
+  out = out.replace("{{source_report}}", body)
+  out = out.replace("{{report}}", body)
+  if body and "{{" not in prompt and body not in prompt:
+    out = (
+      f"{out.rstrip()}\n\n"
+      f"---\n"
+      f"Output from upstream task `{source_habit}` ({source_status}):\n"
+      f"{body}"
+    )
+  return out
+
+
+def habits_watching(source_name: str, habits: list[Habit] | None = None) -> list[Habit]:
+  """Return enabled trigger-habits that listen for ``source_name`` completions."""
+  src = (source_name or "").strip().lower()
+  if not src:
+    return []
+  if habits is None:
+    return []
+  out: list[Habit] = []
+  for h in habits:
+    if not h.enabled:
+      continue
+    after = (h.trigger_after or "").strip().lower()
+    if after and after == src:
+      out.append(h)
+  return out
+
+
+def would_create_habit_cycle(
+  habits: list[Habit],
+  *,
+  name: str,
+  trigger_after: str,
+) -> bool:
+  """True if adding ``name`` → ``trigger_after`` closes a directed cycle."""
+  nm = (name or "").strip().lower()
+  after = (trigger_after or "").strip().lower()
+  if not nm or not after:
+    return False
+
+  edges: dict[str, str] = {}
+  for h in habits:
+    if h.name == nm:
+      continue
+    ta = (h.trigger_after or "").strip().lower()
+    if ta:
+      edges[h.name] = ta
+  edges[nm] = after
+
+  visited: set[str] = set()
+  stack: set[str] = set()
+
+  def dfs(node: str) -> bool:
+    if node in stack:
+      return True
+    if node in visited:
+      return False
+    visited.add(node)
+    stack.add(node)
+    nxt = edges.get(node)
+    if nxt and dfs(nxt):
+      return True
+    stack.remove(node)
+    return False
+
+  return dfs(nm)
+
+
+class HabitChainEngine:
+  """
+  When a habit-backed mesh job finishes, enqueue downstream trigger-habits.
+
+  Watches ``job.report`` on the in-process bus (same as agent triggers).
+  """
+
+  def __init__(self, cfg: GemCodeConfig) -> None:
+    self.cfg = cfg
+    self._bus = get_bus()
+    self._active = False
+    self._last_fired: dict[str, float] = {}
+    self._sub = self._bus.subscribe(topic="job.report", callback=self._on_job_report)
+
+  def start(self) -> None:
+    self._active = _enabled()
+
+  def stop(self) -> None:
+    self._active = False
+    self._sub.unsubscribe()
+
+  def reload(self) -> None:
+    self._last_fired.clear()
+
+  async def _on_job_report(self, msg: BusMessage) -> None:
+    if not self._active:
+      return
+    payload = msg.payload if isinstance(msg.payload, dict) else {}
+    hab = payload.get("habit")
+    if not isinstance(hab, dict):
+      return
+    source_name = str(hab.get("name") or "").strip().lower()
+    if not source_name:
+      return
+
+    status = str(payload.get("status") or "").strip().lower()
+    habits = load_habits(self.cfg.project_root)
+    watchers = habits_watching(source_name, habits)
+    if not watchers:
+      return
+
+    now = time.time()
+    changed = False
+    fired: list[str] = []
+
+    for target in watchers:
+      if not _status_matches(target.trigger_on, status):
+        continue
+      cd = max(0.0, float(target.trigger_cooldown_s or 0))
+      last = self._last_fired.get(target.name, 0.0)
+      if cd and (now - last) < cd:
+        continue
+      if target.max_runs is not None and target.run_count >= target.max_runs:
+        continue
+
+      prompt = render_chain_prompt(
+        target.prompt,
+        source_habit=source_name,
+        source_status=status,
+        source_report=str(payload.get("report") or ""),
+        source_error=str(payload.get("error") or ""),
+      )
+
+      try:
+        from gemcode.agent_mesh import get_mesh
+
+        mesh = get_mesh(self.cfg)
+        if mesh is None:
+          continue
+
+        mesh.enqueue(
+          prompt=prompt,
+          priority=max(target.priority, 1),
+          member_name=target.agent,
+          meta={
+            "habit": {"name": target.name, "agent": target.agent},
+            "chain": {
+              "after": source_name,
+              "on_status": status,
+              "source_job_id": str(payload.get("job_id") or ""),
+            },
+          },
+        )
+        target.last_run_ms = int(now * 1000)
+        target.run_count += 1
+        self._last_fired[target.name] = now
+        changed = True
+        fired.append(target.name)
+      except Exception:
+        pass
+
+    if changed:
+      save_habits(self.cfg.project_root, habits)
+      try:
+        await self._bus.publish(
+          BusMessage(
+            topic="habit.chain",
+            from_addr="habit-chain",
+            payload={
+              "source": source_name,
+              "status": status,
+              "triggered": fired,
+            },
+          )
+        )
+      except Exception:
+        pass

gemcode-0.4.24/src/gemcode/habit_runs.py

@@ -0,0 +1,137 @@
+"""Persistent audit log for scheduled habit (mesh job) completions."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+
+def _habit_runs_path(fleet_root: Path) -> Path:
+  return fleet_root / ".gemcode" / "habit_runs.jsonl"
+
+
+def append_habit_run(
+  fleet_root: Path,
+  *,
+  habit_name: str,
+  agent: str = "",
+  job_id: str = "",
+  status: str = "",
+  report: str = "",
+  error: str = "",
+  duration_ms: int | None = None,
+  session_id: str = "",
+  ts_ms: int | None = None,
+) -> None:
+  """Append one habit run record (never drained — unlike fleet_reports.jsonl)."""
+  nm = (habit_name or "").strip().lower()
+  if not nm:
+    return
+  try:
+    p = _habit_runs_path(fleet_root)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    rec: dict[str, Any] = {
+      "ts_ms": int(ts_ms or int(time.time() * 1000)),
+      "habit_name": nm,
+      "agent": (agent or "").strip(),
+      "job_id": (job_id or "").strip(),
+      "status": (status or "").strip().lower() or "unknown",
+      "report": (report or "").strip()[:12_000],
+      "error": (error or "").strip()[:4000],
+      "session_id": (session_id or "").strip(),
+    }
+    if duration_ms is not None:
+      rec["duration_ms"] = int(duration_ms)
+    line = json.dumps(rec, ensure_ascii=False, default=str) + "\n"
+    with open(p, "a", encoding="utf-8") as f:
+      f.write(line)
+      f.flush()
+  except OSError:
+    pass
+
+
+def _habit_name_from_payload(payload: dict[str, Any]) -> str:
+  hab = payload.get("habit")
+  if isinstance(hab, dict):
+    return str(hab.get("name") or "").strip().lower()
+  return ""
+
+
+def _record_from_job_report(rec: dict[str, Any]) -> dict[str, Any] | None:
+  if str(rec.get("topic") or "") != "job.report":
+    return None
+  payload = rec.get("payload")
+  if not isinstance(payload, dict):
+    return None
+  habit_name = _habit_name_from_payload(payload)
+  if not habit_name:
+    return None
+  hab = payload.get("habit") if isinstance(payload.get("habit"), dict) else {}
+  return {
+    "ts_ms": int(rec.get("ts_ms") or int(time.time() * 1000)),
+    "habit_name": habit_name,
+    "agent": str(hab.get("agent") or payload.get("member") or "").strip(),
+    "job_id": str(payload.get("job_id") or "").strip(),
+    "status": str(payload.get("status") or "").strip().lower() or "unknown",
+    "report": str(payload.get("report") or "").strip()[:12_000],
+    "error": str(payload.get("error") or "").strip()[:4000],
+    "session_id": str(payload.get("session_id") or "").strip(),
+    "duration_ms": payload.get("duration_ms"),
+    "pending_inbox": True,
+  }
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+  if not path.is_file():
+    return []
+  try:
+    raw = path.read_text(encoding="utf-8", errors="replace")
+  except OSError:
+    return []
+  out: list[dict[str, Any]] = []
+  for line in raw.splitlines():
+    line = line.strip()
+    if not line:
+      continue
+    try:
+      rec = json.loads(line)
+    except json.JSONDecodeError:
+      continue
+    if isinstance(rec, dict):
+      out.append(rec)
+  return out
+
+
+def list_habit_runs(
+  fleet_root: Path,
+  *,
+  habit_name: str,
+  limit: int = 50,
+) -> list[dict[str, Any]]:
+  """Return recent runs for one habit, newest first. Merges audit log + pending inbox."""
+  nm = (habit_name or "").strip().lower()
+  if not nm:
+    return []
+
+  limit = max(1, min(200, int(limit)))
+  by_job: dict[str, dict[str, Any]] = {}
+
+  for rec in _read_jsonl(_habit_runs_path(fleet_root)):
+    if str(rec.get("habit_name") or "").strip().lower() != nm:
+      continue
+    jid = str(rec.get("job_id") or "").strip() or f"run-{rec.get('ts_ms')}"
+    by_job[jid] = {k: v for k, v in rec.items() if k != "pending_inbox"}
+
+  inbox_path = fleet_root / ".gemcode" / "fleet_reports.jsonl"
+  for rec in _read_jsonl(inbox_path):
+    row = _record_from_job_report(rec)
+    if row is None or row["habit_name"] != nm:
+      continue
+    jid = row["job_id"] or f"pending-{row['ts_ms']}"
+    if jid not in by_job:
+      by_job[jid] = row
+
+  runs = sorted(by_job.values(), key=lambda r: int(r.get("ts_ms") or 0), reverse=True)
+  return runs[:limit]

{gemcode-0.4.22 → gemcode-0.4.24}/src/gemcode/invoke.py

@@ -247,15 +247,18 @@ async def run_turn(
   REQUEST_CONFIRMATION_FC = "adk_request_confirmation"
 
   def _get_confirmation_requests(events: list) -> list[types.FunctionCall]:
-    out: list[types.FunctionCall] = []
-    for ev in events:
+    """Return confirmation FCs from the last event in the batch that has any."""
+    for ev in reversed(events):
       try:
-        for fc in ev.get_function_calls() or []:
-          if getattr(fc, "name", None) == REQUEST_CONFIRMATION_FC:
-            out.append(fc)
+        fcs = [
+          fc for fc in (ev.get_function_calls() or [])
+          if getattr(fc, "name", None) == REQUEST_CONFIRMATION_FC
+        ]
+        if fcs:
+          return fcs
       except Exception:
         continue
-    return out
+    return []
 
   def _extract_hint_and_tool(fc: types.FunctionCall) -> tuple[str, str]:
     tool_name = "unknown_tool"

{gemcode-0.4.22 → gemcode-0.4.24}/src/gemcode/kaira_daemon.py

@@ -784,15 +784,17 @@ class KairaDaemon:
     )
 
     def _get_confirmation_requests(events: list) -> list:
-      out: list = []
-      for ev in events:
+      for ev in reversed(events):
         try:
-          for fc in ev.get_function_calls() or []:
-            if getattr(fc, "name", None) == REQUEST_CONFIRMATION_FC:
-              out.append(fc)
+          fcs = [
+            fc for fc in (ev.get_function_calls() or [])
+            if getattr(fc, "name", None) == REQUEST_CONFIRMATION_FC
+          ]
+          if fcs:
+            return fcs
         except Exception:
           continue
-      return out
+      return []
 
     def _extract_hint_and_tool(fc) -> tuple[str, str]:
       tool_name = "unknown_tool"

{gemcode-0.4.22 → gemcode-0.4.24}/src/gemcode/trust.py

@@ -15,6 +15,26 @@ def trust_json_path() -> Path:
   return _trust_file_path()
 
 
+def _hosted_tenant_root() -> Path | None:
+  """Locked workspace root when ``GEMCODE_HOSTED_TENANT_ROOT`` is set."""
+  raw = os.environ.get("GEMCODE_HOSTED_TENANT_ROOT", "").strip()
+  if not raw:
+    return None
+  return Path(raw).expanduser().resolve()
+
+
+def _is_within_root(root: Path, candidate: Path) -> bool:
+  try:
+    candidate.resolve().relative_to(root.resolve())
+    return True
+  except ValueError:
+    return candidate.resolve() == root.resolve()
+
+
+def is_hosted_mode() -> bool:
+  return _hosted_tenant_root() is not None
+
+
 def load_trusted_roots() -> set[str]:
   """
   Returns a set of resolved absolute paths (as strings) that are trusted.
@@ -44,8 +64,31 @@ def save_trusted_roots(roots: set[str]) -> None:
 
 
 def is_trusted_root(root: Path) -> bool:
-  r = str(root.resolve())
-  return r in load_trusted_roots()
+  r = root.resolve()
+  locked = _hosted_tenant_root()
+  if locked is not None and _is_within_root(locked, r):
+    return True
+  return str(r) in load_trusted_roots()
+
+
+def ensure_hosted_workspace_trust(root: Path | None = None) -> bool:
+  """
+  In hosted multi-tenant mode, trust the tenant workspace automatically.
+
+  Interactive folder-trust prompts are not used on shared infrastructure — the
+  platform already isolates each user to their PVC. Persists trust for tooling
+  that reads ``trust.json`` directly.
+  """
+  locked = _hosted_tenant_root()
+  if locked is None:
+    return False
+  target = (root or locked).resolve()
+  if not _is_within_root(locked, target):
+    target = locked
+  trust_root(locked, trusted=True)
+  if target != locked:
+    trust_root(target, trusted=True)
+  return True
 
 
 def trust_root(root: Path, *, trusted: bool) -> None: