gemcode 0.3.110__tar.gz → 0.3.111__tar.gz

{gemcode-0.3.110/src/gemcode.egg-info → gemcode-0.3.111}/PKG-INFO

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

{gemcode-0.3.110 → gemcode-0.3.111}/pyproject.toml

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

gemcode-0.3.111/src/gemcode/automations.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AutomationTrigger:
+  kind: str  # interval|cron|daily
+  every_seconds: int | None = None
+  cron: str | None = None
+  at_hhmm: str | None = None
+
+  def key(self) -> str:
+    if self.kind == "interval":
+      return f"interval:{self.every_seconds}"
+    if self.kind == "cron":
+      return f"cron:{self.cron}"
+    if self.kind == "daily":
+      return f"daily:{self.at_hhmm}"
+    return self.kind
+
+
+@dataclass(frozen=True)
+class Automation:
+  name: str
+  prompt: str
+  priority: int = 0
+  enabled: bool = True
+  session_id: str | None = None
+  triggers: tuple[AutomationTrigger, ...] = ()
+
+
+def automations_dir(project_root: Path) -> Path:
+  return project_root / ".gemcode" / "automations"
+
+
+def automations_state_path(project_root: Path) -> Path:
+  return automations_dir(project_root) / "state.json"
+
+
+def load_automations(project_root: Path) -> list[Automation]:
+  root = automations_dir(project_root)
+  if not root.is_dir():
+    return []
+  out: list[Automation] = []
+  for p in sorted(root.glob("*.json")):
+    try:
+      data = json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+      continue
+    try:
+      a = _parse_automation(data)
+    except Exception:
+      continue
+    out.append(a)
+  return out
+
+
+def _parse_automation(data: dict[str, Any]) -> Automation:
+  name = str(data.get("name") or "").strip()
+  prompt = str(data.get("prompt") or "").strip()
+  if not name or not prompt:
+    raise ValueError("missing name/prompt")
+  enabled = bool(data.get("enabled", True))
+  priority = int(data.get("priority") or 0)
+  session_id = (str(data.get("session_id")).strip() if data.get("session_id") else None)
+
+  triggers_raw = data.get("triggers") or []
+  if isinstance(triggers_raw, dict):
+    triggers_raw = [triggers_raw]
+  triggers: list[AutomationTrigger] = []
+  for t in triggers_raw:
+    if not isinstance(t, dict):
+      continue
+    kind = str(t.get("kind") or t.get("type") or "").strip().lower()
+    if kind in ("interval", "every"):
+      every = int(t.get("every_seconds") or t.get("every") or 0)
+      if every <= 0:
+        continue
+      triggers.append(AutomationTrigger(kind="interval", every_seconds=every))
+      continue
+    if kind == "hourly":
+      triggers.append(AutomationTrigger(kind="interval", every_seconds=3600))
+      continue
+    if kind in ("nightly", "daily"):
+      at = str(t.get("at") or "02:00").strip()
+      triggers.append(AutomationTrigger(kind="daily", at_hhmm=at))
+      continue
+    if kind == "cron":
+      cron = str(t.get("cron") or "").strip()
+      if not cron:
+        continue
+      triggers.append(AutomationTrigger(kind="cron", cron=cron))
+      continue
+
+  return Automation(
+    name=name,
+    prompt=prompt,
+    priority=priority,
+    enabled=enabled,
+    session_id=session_id,
+    triggers=tuple(triggers),
+  )
+
+
+def load_automation_state(project_root: Path) -> dict[str, float]:
+  p = automations_state_path(project_root)
+  if not p.is_file():
+    return {}
+  try:
+    data = json.loads(p.read_text(encoding="utf-8"))
+    if isinstance(data, dict):
+      return {str(k): float(v) for k, v in data.items()}
+  except Exception:
+    pass
+  return {}
+
+
+def save_automation_state(project_root: Path, state: dict[str, float]) -> None:
+  d = automations_dir(project_root)
+  d.mkdir(parents=True, exist_ok=True)
+  p = automations_state_path(project_root)
+  try:
+    p.write_text(json.dumps(state, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+  except Exception:
+    pass
+
+
+def is_due(*, now_s: float, last_s: float | None, trig: AutomationTrigger) -> bool:
+  if trig.kind == "interval":
+    if not trig.every_seconds or trig.every_seconds <= 0:
+      return False
+    if last_s is None:
+      return True
+    return (now_s - last_s) >= float(trig.every_seconds)
+  if trig.kind == "daily":
+    at = trig.at_hhmm or "02:00"
+    try:
+      hh, mm = at.split(":", 1)
+      h = int(hh)
+      m = int(mm)
+      if not (0 <= h <= 23 and 0 <= m <= 59):
+        return False
+    except Exception:
+      return False
+    # Compute today's fire time in local epoch seconds.
+    lt = time.localtime(now_s)
+    fire_today = time.mktime((lt.tm_year, lt.tm_mon, lt.tm_mday, h, m, 0, lt.tm_wday, lt.tm_yday, lt.tm_isdst))
+    # If we already passed today's fire time, next is tomorrow.
+    fire_s = fire_today if now_s >= fire_today else fire_today - 86400.0
+    # Due if we crossed the boundary since last_s.
+    if last_s is None:
+      return now_s >= fire_today
+    return last_s < fire_today <= now_s
+  if trig.kind == "cron":
+    return _cron_due(now_s=now_s, last_s=last_s, cron=str(trig.cron or ""))
+  return False
+
+
+def _cron_due(*, now_s: float, last_s: float | None, cron: str) -> bool:
+  # Minimal cron: "M H * * *" with *, */N, or integer for M/H.
+  parts = (cron or "").split()
+  if len(parts) != 5:
+    return False
+  m_s, h_s, dom, mon, dow = parts
+  if dom != "*" or mon != "*" or dow != "*":
+    return False
+
+  def _match(field: str, val: int, *, min_v: int, max_v: int) -> bool:
+    if field == "*":
+      return True
+    if field.startswith("*/"):
+      try:
+        step = int(field[2:])
+        if step <= 0:
+          return False
+        return (val - min_v) % step == 0
+      except Exception:
+        return False
+    try:
+      x = int(field)
+      return x == val and min_v <= x <= max_v
+    except Exception:
+      return False
+
+  lt = time.localtime(now_s)
+  if not (_match(m_s, lt.tm_min, min_v=0, max_v=59) and _match(h_s, lt.tm_hour, min_v=0, max_v=23)):
+    return False
+  # Trigger only once per matching minute.
+  minute_start = now_s - float(lt.tm_sec)
+  if last_s is None:
+    return True
+  return last_s < minute_start <= now_s
+

{gemcode-0.3.110 → gemcode-0.3.111}/src/gemcode/cli.py

@@ -977,6 +977,23 @@ def main() -> None:
       metavar="N",
       help="Cap model↔tool iterations for each job message (ADK RunConfig.max_llm_calls).",
     )
+    kaira_parser.add_argument(
+      "--automations",
+      action="store_true",
+      help="Enable local scheduled automations from .gemcode/automations/*.json.",
+    )
+    kaira_parser.add_argument(
+      "--heartbeat-every-s",
+      type=int,
+      default=0,
+      metavar="N",
+      help="Optional heartbeat job interval (seconds). Enqueues heartbeat prompt repeatedly.",
+    )
+    kaira_parser.add_argument(
+      "--heartbeat-prompt",
+      default=None,
+      help="Prompt text for heartbeat jobs (used with --heartbeat-every-s).",
+    )
 
     args = kaira_parser.parse_args(sys.argv[2:])
     load_cli_environment()
@@ -1013,6 +1030,16 @@ def main() -> None:
     if args.max_llm_calls is not None:
       cfg.max_llm_calls = args.max_llm_calls
 
+    # Local automations / heartbeat configuration (implemented in KairaDaemon loop).
+    if getattr(args, "automations", False):
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+    hb_every = int(getattr(args, "heartbeat_every_s", 0) or 0)
+    if hb_every > 0:
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+      os.environ["GEMCODE_KAIRA_HEARTBEAT_EVERY_S"] = str(hb_every)
+      if getattr(args, "heartbeat_prompt", None):
+        os.environ["GEMCODE_KAIRA_HEARTBEAT_PROMPT"] = str(args.heartbeat_prompt)
+
     _maybe_prompt_trust(cfg)
     _maybe_prompt_google_api_key()
     require_google_api_key()

{gemcode-0.3.110 → gemcode-0.3.111}/src/gemcode/kaira_daemon.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import sys
+import time
 import uuid
 from dataclasses import dataclass
 from typing import Awaitable, Callable
@@ -222,6 +223,65 @@ class KairaDaemon:
     # We'll implement dynamic resizing once the rest of the control plane is stable.
     return int(self.concurrency)
 
+  async def _automations_loop(
+    self,
+    *,
+    session_id: str,
+    heartbeat_every_s: int | None = None,
+    heartbeat_prompt: str | None = None,
+  ) -> None:
+    """
+    Run saved scheduled automations from `.gemcode/automations/*.json`.
+
+    This is a simple local scheduler. It is intentionally conservative:
+    - interval triggers can be as fast as seconds
+    - cron/daily triggers are minute-level
+    """
+    import os
+
+    from gemcode.automations import (
+      is_due,
+      load_automation_state,
+      load_automations,
+      save_automation_state,
+    )
+
+    state = load_automation_state(self.cfg.project_root)
+    hb_last: float | None = None
+    while not self._stop_event.is_set():
+      try:
+        if os.environ.get("GEMCODE_AUTOMATIONS", "0").strip().lower() not in ("1", "true", "yes", "on"):
+          await asyncio.sleep(1.0)
+          continue
+        now_s = time.time()
+
+        # Heartbeat (ephemeral; CLI-configured).
+        if heartbeat_every_s and heartbeat_every_s > 0:
+          if hb_last is None or (now_s - hb_last) >= float(heartbeat_every_s):
+            hb_last = now_s
+            p = (heartbeat_prompt or "Heartbeat: summarize running jobs and system status.").strip()
+            if p:
+              self.enqueue_prompt(prompt=p, priority=self.default_priority, session_id=session_id)
+
+        autos = load_automations(self.cfg.project_root)
+        changed = False
+        for a in autos:
+          if not a.enabled:
+            continue
+          for trig in a.triggers:
+            key = f"{a.name}:{trig.key()}"
+            last_s = state.get(key)
+            if is_due(now_s=now_s, last_s=last_s, trig=trig):
+              state[key] = now_s
+              changed = True
+              sid = a.session_id or session_id
+              self.enqueue_prompt(prompt=a.prompt, priority=a.priority, session_id=sid)
+        if changed:
+          save_automation_state(self.cfg.project_root, state)
+      except Exception:
+        pass
+      await asyncio.sleep(5.0)
+
   def enqueue_prompt(
     self,
     *,
@@ -667,13 +727,22 @@ class KairaDaemon:
       self._ipc = None
       print(f"[kaira] ipc disabled: {e}", file=sys.stderr, flush=True)
 
+    import os as _os
+
     scheduler_task = asyncio.create_task(self._scheduler_loop())
+    automations_task = asyncio.create_task(
+      self._automations_loop(
+        session_id=session_id,
+        heartbeat_every_s=int(_os.environ.get("GEMCODE_KAIRA_HEARTBEAT_EVERY_S", "0") or "0") or None,
+        heartbeat_prompt=_os.environ.get("GEMCODE_KAIRA_HEARTBEAT_PROMPT", None),
+      )
+    )
     stdin_task = None
     if enable_stdin:
       stdin_task = asyncio.create_task(self._stdin_loop(session_id=session_id))
 
     # Wait for either scheduler to stop (shouldn't happen) or stdin loop to end.
-    wait_set = {scheduler_task}
+    wait_set = {scheduler_task, automations_task}
     if stdin_task is not None:
       wait_set.add(stdin_task)
     done, pending = await asyncio.wait(

{gemcode-0.3.110 → gemcode-0.3.111}/src/gemcode/repl_commands.py

@@ -381,6 +381,10 @@ def slash_help_lines() -> list[str]:
       "  /mcp                  MCP status (reads .gemcode/mcp.json; shows loaded toolsets)",
       "  /mcp list             List configured MCP servers",
       "  /mcp reload           Rebuild runner to reload MCP toolsets",
+      "  /automations          Local scheduled automations (Kaira) + heartbeat",
+      "  /automations list     List .gemcode/automations/*.json",
+      "  /automations run <n>  Enqueue an automation now (needs Kaira IPC running)",
+      "  /afc                  AFC prompt defaults (avoid afc> prompt)",
       "  /eval [llm]           Run tools_smoke (+ pytest if tests/ exist); optional LLM goldens",
       "  /autotune init <tag>  Git branch autotune/<tag> for experiment tracking",
       "  /autotune eval [llm]  Eval + append .gemcode/evals/autotune_ledger.jsonl",

{gemcode-0.3.110 → gemcode-0.3.111}/src/gemcode/repl_slash.py

@@ -1336,6 +1336,257 @@ async def process_repl_slash(
       out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /automations (local scheduled jobs for Kaira) ──────────────────────────
+  if name in ("automations", "automation", "auto"):
+    args_a = (sc.args or "").strip()
+    parts = args_a.split() if args_a else []
+    sub = (parts[0].strip().lower() if parts else "status")
+    a_dir = cfg.project_root / ".gemcode" / "automations"
+    a_state = a_dir / "state.json"
+
+    def _bool_env(name: str) -> bool:
+      return os.environ.get(name, "0").strip().lower() in ("1", "true", "yes", "on")
+
+    if sub in ("help", "?"):
+      out("Usage:")
+      out("  /automations                 Status (enabled, count, state file)")
+      out("  /automations list            List .gemcode/automations/*.json")
+      out("  /automations on|off          Enable/disable local scheduling (sets GEMCODE_AUTOMATIONS)")
+      out("  /automations init <name>     Create a starter automation json")
+      out("  /automations run <name>      Enqueue an automation now via Kaira IPC (if running)")
+      out("  /automations heartbeat off")
+      out("  /automations heartbeat <seconds> [prompt...]   Set heartbeat interval + optional prompt")
+      out()
+      out("Paths:")
+      out(f"  dir  : {a_dir}")
+      out(f"  state: {a_state}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub in ("on", "enable", "enabled"):
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+      out("automations: on  (GEMCODE_AUTOMATIONS=1)")
+      out("Note: requires a running Kaira daemon (external or embedded) to execute.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+    if sub in ("off", "disable", "disabled"):
+      os.environ["GEMCODE_AUTOMATIONS"] = "0"
+      out("automations: off  (GEMCODE_AUTOMATIONS=0)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub == "heartbeat":
+      if len(parts) >= 2 and parts[1].strip().lower() in ("off", "disable", "clear", "0"):
+        os.environ["GEMCODE_KAIRA_HEARTBEAT_EVERY_S"] = "0"
+        os.environ.pop("GEMCODE_KAIRA_HEARTBEAT_PROMPT", None)
+        out("heartbeat: off")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      if len(parts) < 2:
+        cur = int(os.environ.get("GEMCODE_KAIRA_HEARTBEAT_EVERY_S", "0") or "0")
+        pr = os.environ.get("GEMCODE_KAIRA_HEARTBEAT_PROMPT", "") or ""
+        out(f"heartbeat_every_s: {cur}")
+        if pr:
+          out(f"heartbeat_prompt:  {pr}")
+        out()
+        out("Set: /automations heartbeat 240 Heartbeat: summarise running jobs")
+        out("Off: /automations heartbeat off")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      try:
+        seconds = int(parts[1])
+      except ValueError:
+        seconds = 0
+      if seconds <= 0:
+        out("heartbeat: invalid seconds (use integer > 0)")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+      os.environ["GEMCODE_KAIRA_HEARTBEAT_EVERY_S"] = str(seconds)
+      rest = args_a.split(None, 2)
+      if len(rest) >= 3 and rest[2].strip():
+        os.environ["GEMCODE_KAIRA_HEARTBEAT_PROMPT"] = rest[2].strip()
+      out(f"heartbeat: on  (every {seconds}s)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub in ("init", "new") and len(parts) >= 2:
+      name_raw = parts[1].strip().lower()
+      import re
+
+      if not re.fullmatch(r"[a-z0-9][a-z0-9-_]{0,63}", name_raw):
+        out("Invalid name. Use lowercase letters/numbers plus - or _ (max 64 chars).")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      a_dir.mkdir(parents=True, exist_ok=True)
+      p = a_dir / f"{name_raw}.json"
+      if p.exists():
+        out(f"Already exists: {p}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      template = {
+        "name": name_raw,
+        "enabled": True,
+        "priority": 0,
+        "prompt": "Describe exactly what to do and what success looks like.",
+        "triggers": [{"kind": "nightly", "at": "02:00"}],
+      }
+      try:
+        import json
+
+        p.write_text(json.dumps(template, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+      except Exception as e:
+        out(f"Failed to write: {e}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      out(f"Created: {p}")
+      out("Enable runner-side execution with: gemcode kaira --automations (or GEMCODE_AUTOMATIONS=1)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub in ("run",) and len(parts) >= 2:
+      target = parts[1].strip().lower()
+      cfgs = {}
+      try:
+        from gemcode.automations import load_automations
+
+        for a in load_automations(cfg.project_root):
+          cfgs[a.name.lower()] = a
+      except Exception:
+        cfgs = {}
+      a = cfgs.get(target)
+      if a is None:
+        out(f"Unknown automation: {target}")
+        out("Tip: /automations list")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      # Enqueue via Kaira IPC.
+      sock = os.environ.get("GEMCODE_KAIRA_SOCKET") or str(cfg.project_root / ".gemcode" / "ipc.sock")
+      try:
+        from gemcode.kaira_client import KairaIpcClient
+
+        client = await KairaIpcClient.connect(socket_path=sock)
+        try:
+          res = await client.request(action="enqueue", prompt=a.prompt, priority=a.priority, session_id=(a.session_id or session_id))
+        finally:
+          await client.close()
+        if not res.get("ok"):
+          out(f"[kaira] {res.get('error') or 'enqueue failed'}")
+        else:
+          out(f"[kaira] enqueued: {res.get('job_id')}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      except Exception as e:
+        out(f"[kaira] IPC unavailable: {type(e).__name__}: {e}")
+        out("Start Kaira with: gemcode kaira -C . --automations")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+
+    if sub in ("list", "ls", "show"):
+      try:
+        from gemcode.automations import load_automations
+
+        autos = load_automations(cfg.project_root)
+      except Exception:
+        autos = []
+      out(f"automations_enabled: {_bool_env('GEMCODE_AUTOMATIONS')}")
+      out(f"dir: {a_dir} ({'exists' if a_dir.is_dir() else 'missing'})")
+      out(f"state: {a_state} ({'exists' if a_state.is_file() else 'missing'})")
+      if not autos:
+        out("(no automation configs found)")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      out("Configs:")
+      for a in autos[:200]:
+        trig = ", ".join(t.key() for t in a.triggers) if a.triggers else "(no triggers)"
+        out(f"  - {a.name}\tenabled={a.enabled}\tpriority={a.priority}\t{trig}")
+      if len(autos) > 200:
+        out(f"  … (+{len(autos) - 200} more)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    # status default
+    try:
+      from gemcode.automations import load_automations
+
+      autos2 = load_automations(cfg.project_root)
+    except Exception:
+      autos2 = []
+    out(f"automations_enabled: {_bool_env('GEMCODE_AUTOMATIONS')}")
+    out(f"configs: {len(autos2)}  (dir: {a_dir})")
+    out(f"state_file: {a_state} ({'exists' if a_state.is_file() else 'missing'})")
+    out()
+    out("Tip: /automations list  ·  Enable: gemcode kaira --automations  ·  Help: /automations help")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
+  # ── /afc (Automatic Function Calling UX) ───────────────────────────────────
+  if name == "afc":
+    args_f = (sc.args or "").strip()
+    parts = args_f.split() if args_f else []
+    sub = (parts[0].strip().lower() if parts else "status")
+
+    def _norm(v: str) -> str:
+      return (v or "").strip().lower()
+
+    if sub in ("help", "?"):
+      out("Usage:")
+      out("  /afc                 Show AFC prompt settings")
+      out("  /afc default all|callables|clear   Set GEMCODE_AFC_DEFAULT")
+      out("  /afc prompt on|off                Set GEMCODE_AFC_PROMPT")
+      out()
+      out("Notes:")
+      out("  These affect runner construction; GemCode will rebuild runner on next turn.")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if sub == "default":
+      if len(parts) < 2:
+        out(f"GEMCODE_AFC_DEFAULT: {os.environ.get('GEMCODE_AFC_DEFAULT', '(unset)')}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      v = _norm(parts[1])
+      if v in ("clear", "unset", "off", "none"):
+        os.environ.pop("GEMCODE_AFC_DEFAULT", None)
+        out("GEMCODE_AFC_DEFAULT: (unset)")
+        out("Runner will rebuild on next turn.")
+        out()
+        return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+      if v not in ("all", "callables"):
+        out("Invalid. Use: all|callables|clear")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      os.environ["GEMCODE_AFC_DEFAULT"] = v
+      out(f"GEMCODE_AFC_DEFAULT: {v}")
+      out("Runner will rebuild on next turn.")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    if sub == "prompt":
+      if len(parts) < 2:
+        out(f"GEMCODE_AFC_PROMPT: {os.environ.get('GEMCODE_AFC_PROMPT', '(unset => default on)')}")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      v2 = _norm(parts[1])
+      if v2 in ("on", "1", "true", "yes"):
+        os.environ["GEMCODE_AFC_PROMPT"] = "1"
+      elif v2 in ("off", "0", "false", "no"):
+        os.environ["GEMCODE_AFC_PROMPT"] = "0"
+      else:
+        out("Invalid. Use: on|off")
+        out()
+        return ReplSlashResult(skip_model_turn=True)
+      out(f"GEMCODE_AFC_PROMPT: {os.environ.get('GEMCODE_AFC_PROMPT')}")
+      out("Runner will rebuild on next turn.")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+    out("AFC:")
+    out(f"  GEMCODE_AFC_PROMPT : {os.environ.get('GEMCODE_AFC_PROMPT', '(unset => default on)')}")
+    out(f"  GEMCODE_AFC_DEFAULT: {os.environ.get('GEMCODE_AFC_DEFAULT', '(unset)')}")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   if name == "tools":
     args_t = (sc.args or "").strip().lower()
     if args_t in ("smoke", "decl", "declarations"):

{gemcode-0.3.110 → gemcode-0.3.111/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.110 → gemcode-0.3.111}/src/gemcode.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/gemcode/__main__.py
 src/gemcode/agent.py
 src/gemcode/audit.py
 src/gemcode/autocompact.py
+src/gemcode/automations.py
 src/gemcode/autotune.py
 src/gemcode/callbacks.py
 src/gemcode/capability_routing.py
@@ -126,6 +127,7 @@ src/gemcode/web/web_sse_compat.py
 tests/test_add_dir.py
 tests/test_agent_instruction.py
 tests/test_autocompact.py
+tests/test_automations.py
 tests/test_capability_routing.py
 tests/test_checkpoint_diff_command.py
 tests/test_cli_init.py