gemcode 0.3.28__py3-none-any.whl → 0.3.30__py3-none-any.whl

gemcode/agent.py

@@ -66,6 +66,8 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 
   # ── Active capabilities ──────────────────────────────────────────────────
   caps: list[str] = []
+  if getattr(cfg, "enable_web_search", False) and not getattr(cfg, "enable_deep_research", False):
+    caps.append("web_search ON (tool: google_search — standalone search without full deep_research)")
   if getattr(cfg, "enable_deep_research", False):
     dr_extras = " + google_maps_grounding" if getattr(cfg, "enable_maps_grounding", False) else ""
     caps.append(f"deep_research ON (tools: google_search, url_context{dr_extras})")
@@ -77,8 +79,12 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
     caps.append(f"memory ON ({mem_kind}, stored at {mem_path}; ADK preload_memory injects relevant memories before each turn)")
   if getattr(cfg, "enable_computer_use", False):
     caps.append("computer_use ON (tools: navigate, click_at, type_text_at, browser_screenshot, browser_find_element, etc.)")
+  if getattr(cfg, "enable_code_executor", False):
+    caps.append("code_executor ON — you can write Python code blocks and they will be executed safely via Gemini's built-in sandboxed executor; results appear as code_execution_result events. Use this for math, data processing, quick tests, and anything that would otherwise require a shell command.")
+  if getattr(cfg, "enable_artifacts", True):
+    caps.append("artifacts ON — use save_artifact(filename, bytes, mime_type) / load_artifact(filename) to store large/binary outputs (screenshots, PDFs, generated files) outside session history. Artifacts are keyed by filename; prefix 'user:' for cross-session persistence.")
   if not caps:
-    caps.append("none enabled (use /research on, /embeddings on, /memory on, /computer on to enable)")
+    caps.append("none enabled (use /research on, /embeddings on, /memory on, /computer on, /code on to enable)")
   caps_text = "\n".join(f"  - {c}" for c in caps)
 
   # ── Limits ───────────────────────────────────────────────────────────────
@@ -147,6 +153,40 @@ Memory is **ON** ({kind}). Stored at: `{mem_path}`
 """
 
 
+def _build_plan_mode_section() -> str:
+  """Injected when plan_mode=True — instructs agent to write explicit plans first."""
+  return """
+## PLAN MODE IS ACTIVE
+
+You are currently in **Plan Mode**. Before executing ANY tools that modify files or run shell commands, you MUST:
+
+1. **Write a numbered plan** in your response text — list every step you intend to take.
+   Example:
+   ```
+   Plan:
+   1. Read src/auth/login.ts to understand the current flow
+   2. Read src/types/user.ts for the User interface
+   3. Add `lastLogin: Date` field to User interface
+   4. Update login handler to set lastLogin on successful auth
+   5. Run `npm run build` to verify no TypeScript errors
+   ```
+
+2. **Pause after the plan** — do not immediately execute tools. Present the plan and wait for the user to confirm ("go", "proceed", "looks good") before starting.
+
+3. **Stick to the plan** — if you discover the plan needs changing mid-execution, note the update before proceeding.
+
+4. **Report completion** against the plan — when done, confirm each step as completed.
+
+**Why plan mode?**
+- Prevents unintended side effects from premature tool execution
+- Gives you and the user visibility into the full scope before any changes
+- Makes complex multi-file tasks reviewable and reversible
+- Catches scope creep early
+
+**To turn off plan mode**, type `/plan off` at the prompt.
+"""
+
+
 def _build_computer_use_section(cfg: GemCodeConfig) -> str:
   """Rich computer use guidance, only injected when enable_computer_use=True."""
   w = getattr(cfg, "_cfg", None)
@@ -426,6 +466,41 @@ Use `run_subtask` when the work is better done in an isolated context:
 
 The sub-agent inherits your permission settings and returns its final text as `result`. Treat it as a trusted colleague returning a written summary.
 
+## ADK Special Tools (always available when ADK supports them)
+
+### `get_user_choice`
+Present the user with a structured multi-option prompt rather than open-ended questions.
+Use when you need the user to pick from 2–6 specific options (e.g. "Which framework would you like?", "Choose migration strategy: A, B, or C").
+This provides a better UX than asking them to type a free-form answer.
+
+### `load_artifacts`
+Load binary/large artifacts that were saved in a previous turn or by a sub-agent.
+Artifacts are keyed by filename (e.g. "report.pdf", "screenshot.png", "output.json").
+Use `user:filename` prefix for user-scoped artifacts that persist across sessions.
+After loading, the artifact bytes are available for further processing (display, analysis, transformation).
+
+### `exit_loop`
+Signal the surrounding LoopAgent to stop iterating and return the final result.
+Only meaningful when this agent is running inside an ADK LoopAgent pipeline.
+Call this when the task is complete and no further iterations are needed.
+
+## Artifacts — storing large outputs
+When `artifacts ON` (see Runtime facts above):
+- **Save** large generated content as artifacts instead of printing them inline:
+  - Screenshots from computer_use: save as "screenshot.png" artifact
+  - Generated reports/PDFs: save as "report.pdf" artifact
+  - Large JSON data: save as "data.json" artifact
+- **Reference** artifacts in instructions via `{artifact.filename?}` template syntax
+- Artifacts are keyed by filename; `user:` prefix = cross-session persistence
+
+## Code Executor (sandboxed Python)
+When `code_executor ON` (see Runtime facts above):
+- You can write Python code blocks in your response and the Gemini API executes them safely
+- The result appears as a `code_execution_result` event with stdout and the outcome
+- Best for: math calculations, data transformation, unit testing logic, quick experiments
+- The sandbox does NOT have internet access or filesystem access — use for pure computation
+- For file I/O or shell commands, use the standard tools (`bash`, `write_file`, etc.)
+
 ## Evaluator-optimizer loop
 For tasks where quality matters:
 1. Complete the task (execute tools, write code, run commands)
@@ -461,6 +536,9 @@ All file tools use paths **relative to the project root** (where GemCode was sta
   if getattr(cfg, "enable_memory", False):
     base = f"{base}\n\n{_build_memory_section(cfg)}"
 
+  if getattr(cfg, "plan_mode", False):
+    base = f"{base}\n\n{_build_plan_mode_section()}"
+
   tool_manifest = build_tool_manifest(cfg)
   if tool_manifest:
     base = f"{base}\n\n{tool_manifest}"
@@ -470,6 +548,17 @@ All file tools use paths **relative to the project root** (where GemCode was sta
   return base
 
 
+def _build_code_executor(cfg: GemCodeConfig):
+  """Return an ADK BuiltInCodeExecutor when enable_code_executor=True, else None."""
+  if not getattr(cfg, "enable_code_executor", False):
+    return None
+  try:
+    from google.adk.code_executors import BuiltInCodeExecutor
+    return BuiltInCodeExecutor()
+  except Exception:
+    return None
+
+
 def build_root_agent(
   cfg: GemCodeConfig,
   extra_tools: list | None = None,
@@ -488,12 +577,19 @@ def build_root_agent(
   if _tools is not None:
     tools = list(_tools)
   else:
-  tools = build_function_tools(cfg)
+    tools = build_function_tools(cfg)
   if getattr(cfg, "enable_memory", False):
     # ADK preload_memory injects retrieved memories into the next llm_request.
     from google.adk.tools import preload_memory
-
     tools = [preload_memory, *tools]
+
+  # ADK built-in interactive + artifact tools — always available when ADK supports them.
+  try:
+    from google.adk.tools import get_user_choice, load_artifacts, exit_loop
+    tools = [*tools, get_user_choice, load_artifacts, exit_loop]
+  except Exception:
+    pass
+
   if extra_tools:
     tools = [*tools, *extra_tools]
 
@@ -548,15 +644,31 @@ def build_root_agent(
       tool_config=tool_cfg,
     )
 
-  return LlmAgent(
+  # global_instruction applies to the entire agent tree (including sub-agents
+  # spawned via run_subtask or multi-agent delegation).  Keep it short — it's
+  # prepended to every agent's effective instruction.
+  global_instr = (
+    "You are GemCode, an expert software engineering agent powered by Google Gemini. "
+    "Act, don't advise. Complete tasks fully and autonomously. "
+    "Think before destructive actions. Use read-only tools before shell/write tools."
+  )
+
+  agent_kwargs: dict = dict(
       model=cfg.model,
       name="gemcode",
       instruction=build_instruction(cfg),
+      global_instruction=global_instr,
       tools=tools,
       generate_content_config=gen_cfg,
       **cb_kwargs,
   )
 
+  code_executor = _build_code_executor(cfg)
+  if code_executor is not None:
+    agent_kwargs["code_executor"] = code_executor
+
+  return LlmAgent(**agent_kwargs)
+
 
 def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None):
   """Backward-compatible: prefer `gemcode.session_runtime.create_runner`."""

gemcode/callbacks.py

@@ -141,6 +141,22 @@ def make_before_tool_callback(cfg: GemCodeConfig):
     record = {"tool": name, "args": _redact_args(name, args)}
     append_audit(cfg.project_root, record)
 
+    # ── Shell hooks: pre_tool_use ─────────────────────────────────────────
+    # If the project has a .gemcode/hooks/pre_tool_use.sh, run it now.
+    # Non-zero exit or {"decision":"deny"} stdout will block the tool call.
+    try:
+      from gemcode.hooks import run_pre_tool_use_hook
+      hook_result = run_pre_tool_use_hook(
+          cfg.project_root,
+          model=getattr(cfg, "model", "") or "",
+          tool_name=name,
+          args=args or {},
+      )
+      if hook_result is not None:
+        return hook_result
+    except Exception:
+      pass
+
     streak = 0
     if tool_context is not None:
       try:
@@ -316,6 +332,19 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         st[_STATE_FAILURE_KEY] = 0
     else:
       st[_STATE_FAILURE_KEY] = 0
+    # ── Shell hooks: post_tool_use ────────────────────────────────────────
+    try:
+      from gemcode.hooks import run_post_tool_use_hook
+      run_post_tool_use_hook(
+          cfg.project_root,
+          model=getattr(cfg, "model", "") or "",
+          tool_name=name,
+          args=args or {},
+          result=tool_response if isinstance(tool_response, dict) else {},
+      )
+    except Exception:
+      pass
+
     if _maybe_tool_summary_enabled():
       summary: dict[str, Any] = {
         "phase": "tool_result",
@@ -399,6 +428,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
           "candidates_token_count",
           "cached_content_token_count",
           "total_token_count",
+          "thoughts_token_count",
       ):
         if hasattr(um, attr):
           v = getattr(um, attr)
@@ -407,6 +437,44 @@ def make_after_model_callback(cfg: GemCodeConfig):
     if d:
       append_audit(cfg.project_root, {"phase": "model_usage", **d})
 
+    # ── Expose live token stats to the TUI ───────────────────────────────────
+    # The TUI reads cfg._last_turn_stats after each turn to display token counts
+    # and estimated cost in the footer (like OpenClaude's spinner token display).
+    try:
+      in_tok  = d.get("prompt_token_count", 0) or 0
+      out_tok = d.get("candidates_token_count", 0) or 0
+      think_tok = d.get("thoughts_token_count", 0) or 0
+      cache_tok = d.get("cached_content_token_count", 0) or 0
+      total_tok = d.get("total_token_count", 0) or 0
+
+      prev_session_tokens = int(st.get(SESSION_TOTAL_TOKENS_KEY, 0) or 0)
+      session_total = prev_session_tokens + total_tok
+
+      from gemcode.pricing import estimate_cost
+      turn_cost = estimate_cost(
+          getattr(cfg, "model", "") or "",
+          input_tokens=in_tok,
+          output_tokens=out_tok,
+      )
+      # Accumulate session cost
+      prev_cost = getattr(cfg, "_session_cost_usd", 0.0) or 0.0
+      session_cost = prev_cost + (turn_cost or 0.0)
+      object.__setattr__(cfg, "_session_cost_usd", session_cost)
+
+      stats: dict[str, Any] = {
+          "in": in_tok,
+          "out": out_tok,
+          "think": think_tok,
+          "cache": cache_tok,
+          "total": total_tok,
+          "session_total": session_total,
+          "turn_cost": turn_cost,
+          "session_cost": session_cost,
+      }
+      object.__setattr__(cfg, "_last_turn_stats", stats)
+    except Exception:
+      pass
+
     pt = d.get("prompt_token_count")
     if isinstance(pt, int) and pt >= 0:
       try:

gemcode/config.py

@@ -251,6 +251,37 @@ class GemCodeConfig:
     default_factory=lambda: _truthy_env("GEMCODE_SHOW_FULL_THINKING", default=False)
   )
 
+  # Enable ADK BuiltInCodeExecutor for safe sandboxed Python execution via
+  # Gemini's code execution API. When on, the agent can write and run Python
+  # snippets inline (math, data processing, quick tests) without requiring
+  # bash/shell permissions. Requires a Gemini model that supports code execution
+  # (gemini-2.5-flash, gemini-2.5-pro, gemini-3.x).
+  enable_code_executor: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_ENABLE_CODE_EXECUTOR", default=False)
+  )
+
+  # Enable ADK artifact service for storing large/binary outputs (screenshots,
+  # generated files, reports) outside of session history.
+  # When on, the agent can save_artifact / load_artifact keyed by filename.
+  enable_artifacts: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_ENABLE_ARTIFACTS", default=True)
+  )
+
+  # Plan mode: when ON, the agent explicitly writes out a numbered plan
+  # BEFORE executing any tools, then checks the plan before reporting done.
+  # Like OpenClaude's EnterPlanMode — great for complex, multi-file tasks.
+  # Toggle at runtime with /plan on|off.
+  plan_mode: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_PLAN_MODE", default=False)
+  )
+
+  # Always-on web search (independent of deep_research / research mode).
+  # When True, google_search is available as a basic tool without enabling
+  # the full deep_research capability suite (url_context, maps, etc.).
+  enable_web_search: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_ENABLE_WEB_SEARCH", default=False)
+  )
+
   def __post_init__(self) -> None:
     self.project_root = self.project_root.resolve()
     # Default agentic depth when env omits GEMCODE_MAX_LLM_CALLS (was: None → SDK default).

gemcode/hooks.py

@@ -0,0 +1,194 @@
+"""
+GemCode shell hooks — scriptable lifecycle events inspired by OpenClaude.
+
+Hooks are shell scripts stored under ``<project_root>/.gemcode/hooks/``.
+They receive a JSON payload on stdin and can:
+  - pre_tool_use.sh:  return non-zero exit to DENY the tool call, or
+                      print JSON {"decision":"deny","reason":"..."} to stderr.
+  - post_tool_use.sh: informational; return value ignored.
+  - session_start.sh: runs when a new GemCode session starts.
+  - session_stop.sh:  runs when the session ends.
+
+HOOK ENVIRONMENT
+  All hooks receive these env vars:
+    GEMCODE_HOOK_TYPE       — "pre_tool_use" | "post_tool_use" | "session_start" | "session_stop"
+    GEMCODE_PROJECT_ROOT    — absolute path to the project root
+    GEMCODE_MODEL           — active model id
+
+HOOK STDIN (pre_tool_use, post_tool_use)
+  JSON object with:
+    { "tool": "<tool_name>",
+      "args": { ...tool_args... },
+      "type": "pre_tool_use" | "post_tool_use",
+      "result": { ...tool_result... }   // post only
+    }
+
+PRE_TOOL_USE DECISION
+  If exit code is non-zero → the tool is DENIED.
+  If exit code is 0 → the tool proceeds normally.
+  If stdout starts with '{' and contains "decision": "deny" → the tool is denied.
+
+EXAMPLE HOOKS
+  # .gemcode/hooks/pre_tool_use.sh
+  #!/bin/bash
+  # Deny all delete_file calls
+  HOOK=$(cat)
+  TOOL=$(echo "$HOOK" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['tool'])")
+  if [ "$TOOL" = "delete_file" ]; then
+    echo "delete_file blocked by hook" >&2
+    exit 1
+  fi
+
+  # .gemcode/hooks/session_start.sh
+  #!/bin/bash
+  echo "[gemcode hook] session started in $GEMCODE_PROJECT_ROOT" >> /tmp/gemcode-audit.log
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+_HOOKS_DIR = ".gemcode/hooks"
+_TIMEOUT_PRE = 5.0   # seconds — pre_tool_use must respond quickly
+_TIMEOUT_POST = 10.0  # seconds — post_tool_use has more budget
+
+
+def _find_hook(project_root: Path, name: str) -> Path | None:
+    """Return the hook file path if it exists and is executable, else None."""
+    hooks_dir = project_root / _HOOKS_DIR
+    for ext in ("", ".sh", ".py", ".bash"):
+        candidate = hooks_dir / f"{name}{ext}"
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return candidate
+    return None
+
+
+def _run_hook(
+    hook_path: Path,
+    project_root: Path,
+    model: str,
+    hook_type: str,
+    stdin_data: dict | None = None,
+    timeout: float = 5.0,
+) -> tuple[int, str, str]:
+    """
+    Run a hook script.
+
+    Returns (exit_code, stdout, stderr).
+    Never raises — all exceptions are caught and logged.
+    """
+    try:
+        env = {
+            **os.environ,
+            "GEMCODE_HOOK_TYPE": hook_type,
+            "GEMCODE_PROJECT_ROOT": str(project_root),
+            "GEMCODE_MODEL": model or "",
+        }
+        stdin_bytes = (
+            json.dumps(stdin_data, ensure_ascii=False).encode() if stdin_data else b""
+        )
+        result = subprocess.run(
+            [str(hook_path)],
+            input=stdin_bytes,
+            capture_output=True,
+            timeout=timeout,
+            env=env,
+            cwd=str(project_root),
+        )
+        return result.returncode, result.stdout.decode(errors="replace"), result.stderr.decode(errors="replace")
+    except subprocess.TimeoutExpired:
+        log.warning("[hooks] %s timed out after %.1fs", hook_path.name, timeout)
+        return 1, "", f"hook timed out after {timeout}s"
+    except Exception as exc:
+        log.debug("[hooks] failed to run %s: %s", hook_path.name, exc)
+        return 1, "", str(exc)
+
+
+def run_pre_tool_use_hook(
+    project_root: Path,
+    model: str,
+    tool_name: str,
+    args: dict[str, Any],
+) -> dict | None:
+    """
+    Run the pre_tool_use hook (if it exists).
+
+    Returns:
+        None  → tool is allowed (default)
+        dict  → {"error": "...", "error_kind": "hook_denied"} to deny the tool
+    """
+    hook = _find_hook(project_root, "pre_tool_use")
+    if hook is None:
+        return None
+
+    payload = {"tool": tool_name, "args": args, "type": "pre_tool_use"}
+    rc, stdout, stderr = _run_hook(
+        hook, project_root, model, "pre_tool_use", payload, timeout=_TIMEOUT_PRE
+    )
+
+    if rc != 0:
+        reason = stderr.strip() or stdout.strip() or f"hook exited {rc}"
+        log.info("[hooks] pre_tool_use denied %s: %s", tool_name, reason[:200])
+        return {
+            "error": f"Tool denied by pre_tool_use hook: {reason[:400]}",
+            "error_kind": "hook_denied",
+        }
+
+    # Check if stdout contains an explicit deny decision.
+    if stdout.strip().startswith("{"):
+        try:
+            decision = json.loads(stdout.strip())
+            if str(decision.get("decision", "")).lower() == "deny":
+                reason = decision.get("reason", "hook denied")
+                log.info("[hooks] pre_tool_use JSON-denied %s: %s", tool_name, reason)
+                return {
+                    "error": f"Tool denied by hook: {reason}",
+                    "error_kind": "hook_denied",
+                }
+        except Exception:
+            pass
+
+    return None  # allowed
+
+
+def run_post_tool_use_hook(
+    project_root: Path,
+    model: str,
+    tool_name: str,
+    args: dict[str, Any],
+    result: dict[str, Any],
+) -> None:
+    """Run the post_tool_use hook if it exists. Return value is ignored."""
+    hook = _find_hook(project_root, "post_tool_use")
+    if hook is None:
+        return
+    payload = {
+        "tool": tool_name,
+        "args": args,
+        "result": result,
+        "type": "post_tool_use",
+    }
+    _run_hook(hook, project_root, model, "post_tool_use", payload, timeout=_TIMEOUT_POST)
+
+
+def run_session_start_hook(project_root: Path, model: str) -> None:
+    """Run the session_start hook if it exists."""
+    hook = _find_hook(project_root, "session_start")
+    if hook is None:
+        return
+    _run_hook(hook, project_root, model, "session_start", timeout=10.0)
+
+
+def run_session_stop_hook(project_root: Path, model: str) -> None:
+    """Run the session_stop hook if it exists."""
+    hook = _find_hook(project_root, "session_stop")
+    if hook is None:
+        return
+    _run_hook(hook, project_root, model, "session_stop", timeout=10.0)

gemcode/modality_tools.py

@@ -172,9 +172,23 @@ def build_extra_tools(cfg: GemCodeConfig) -> list[Any]:
   """Return ADK tool unions to expose for enabled modalities."""
   extra: list[Any] = []
 
+  # ── Web search (standalone, no full deep_research needed) ────────────────
+  # enable_web_search=True adds google_search alone.
+  # enable_deep_research=True adds google_search + url_context + optional maps.
+  # If both are on, avoid adding google_search twice.
+  web_search_added = False
+  if getattr(cfg, "enable_web_search", False) and not getattr(cfg, "enable_deep_research", False):
+    try:
+      from google.adk.tools import google_search
+      extra.append(google_search)
+      web_search_added = True
+    except Exception:
+      pass
+
   if getattr(cfg, "enable_deep_research", False):
     from google.adk.tools import google_search, url_context
-    extra.append(google_search)
+    if not web_search_added:
+      extra.append(google_search)
     extra.append(url_context)
     # Google Maps grounding can be incompatible with other built-in tools
     # (e.g., google_search) depending on the request/model tooling layer.

gemcode/pricing.py

@@ -0,0 +1,76 @@
+"""
+Per-model token pricing for cost estimation.
+
+All prices are USD per 1 million tokens (input / output separately).
+Sources: Google AI Studio / Vertex AI pricing pages as of 2026.
+
+Usage:
+    from gemcode.pricing import estimate_cost
+    usd = estimate_cost("gemini-2.5-flash", input_tokens=5000, output_tokens=1200)
+"""
+
+from __future__ import annotations
+
+# Format: model_prefix → (input_$/M, output_$/M)
+# Matches are done by checking if the model id STARTS WITH any key (longest first).
+_PRICING_TABLE: dict[str, tuple[float, float]] = {
+    # ── Gemini 2.5 ──────────────────────────────────────────────────────────
+    "gemini-2.5-pro":         (3.50, 10.50),   # standard context ≤200k
+    "gemini-2.5-flash":       (0.15,  0.60),   # standard context
+    "gemini-2.5-flash-8b":    (0.037, 0.15),   # 8B lite variant
+    # ── Gemini 2.0 ──────────────────────────────────────────────────────────
+    "gemini-2.0-flash":       (0.10,  0.40),
+    "gemini-2.0-flash-lite":  (0.075, 0.30),
+    "gemini-2.0-pro":         (3.50, 10.50),
+    # ── Gemini 1.5 ──────────────────────────────────────────────────────────
+    "gemini-1.5-flash":       (0.075, 0.30),
+    "gemini-1.5-pro":         (1.25,  5.00),
+    # ── Gemini experimental / preview ───────────────────────────────────────
+    "gemini-exp":             (0.00,  0.00),   # free during preview
+    "gemini-3":               (0.30,  1.20),   # approximate future pricing
+}
+
+
+def estimate_cost(
+    model: str,
+    *,
+    input_tokens: int = 0,
+    output_tokens: int = 0,
+) -> float | None:
+    """
+    Return estimated USD cost for a model turn, or None if pricing is unknown.
+
+    Args:
+        model: Model id string (e.g. "gemini-2.5-flash").
+        input_tokens: Prompt/input token count.
+        output_tokens: Candidates/output token count.
+    """
+    if not model:
+        return None
+    model_lower = model.lower().strip()
+    # Match longest prefix first for specificity.
+    for prefix in sorted(_PRICING_TABLE, key=len, reverse=True):
+        if model_lower.startswith(prefix):
+            in_rate, out_rate = _PRICING_TABLE[prefix]
+            return (input_tokens * in_rate + output_tokens * out_rate) / 1_000_000
+    return None
+
+
+def format_cost(usd: float | None) -> str:
+    """Human-readable cost string, e.g. '$0.0012' or '$1.23'."""
+    if usd is None:
+        return ""
+    if usd < 0.0001:
+        return f"<$0.0001"
+    if usd < 0.01:
+        return f"${usd:.4f}"
+    return f"${usd:.3f}"
+
+
+def format_tokens(n: int) -> str:
+    """Format a token count compactly: 1234 → '1.2k', 12345678 → '12.3M'."""
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f}k"
+    return str(n)

gemcode/refine.py

@@ -0,0 +1,204 @@
+"""
+Iterative refinement pipelines using ADK LoopAgent + SequentialAgent.
+
+This module exposes factory functions for building multi-agent orchestration
+patterns that GemCode can invoke for complex, multi-step tasks:
+
+  - build_refine_loop(): LoopAgent that loops write→test→fix until tests pass
+    or max_iterations is reached (escalates via exit_loop tool).
+
+  - build_sequential_pipeline(): SequentialAgent that runs N specialist agents
+    in order, passing results through session state via output_key.
+
+  - build_parallel_research(): ParallelAgent that fans out N research sub-agents
+    then collects their outputs.
+
+These are "heavy" patterns; they are NOT wired by default — callers instantiate
+them on demand (e.g. via /refine slash command or run_subtask).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Guard: check what's available in the installed ADK version
+# ---------------------------------------------------------------------------
+try:
+    from google.adk.agents import LoopAgent, SequentialAgent, ParallelAgent, LlmAgent  # type: ignore
+    _ADK_WORKFLOW_AGENTS_OK = True
+except ImportError:
+    _ADK_WORKFLOW_AGENTS_OK = False
+    log.warning("google.adk workflow agents (LoopAgent/SequentialAgent/ParallelAgent) "
+                "not available — refine pipelines disabled.")
+
+
+def _require_workflow() -> None:
+    if not _ADK_WORKFLOW_AGENTS_OK:
+        raise RuntimeError(
+            "ADK workflow agents (LoopAgent / SequentialAgent / ParallelAgent) are not "
+            "available in the installed google-adk version. "
+            "Try: pip install -U google-adk"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Write → Test → Fix Loop
+# ---------------------------------------------------------------------------
+
+def build_refine_loop(
+    *,
+    model: str,
+    task_description: str,
+    test_command: str,
+    max_iterations: int = 8,
+    extra_tools: list | None = None,
+) -> Any:
+    """
+    Build a LoopAgent that iteratively writes code, runs tests, and fixes
+    failures until all tests pass or ``max_iterations`` is exhausted.
+
+    Architecture:
+      LoopAgent(max_iterations=N)
+        ├─ writer_agent   — writes / edits code based on current task + test output
+        ├─ tester_agent   — runs the test command via bash, stores result in state
+        └─ checker_agent  — inspects test result; calls exit_loop if tests pass
+
+    State keys used:
+      "task"          — original task description (seeded by caller)
+      "test_command"  — shell command to run tests
+      "test_output"   — stdout/stderr from last test run
+      "test_passed"   — "yes" if tests passed
+      "iteration"     — current loop count (auto-incremented by writer)
+
+    Returns the LoopAgent instance, ready to run via a Runner.
+
+    Example usage:
+      loop = build_refine_loop(model="gemini-2.5-flash",
+                               task_description="add unit tests for parser.py",
+                               test_command="pytest tests/test_parser.py -x")
+      runner = Runner(agent=loop, app_name="refine", session_service=...)
+      async for event in runner.run_async(...):
+          ...
+    """
+    _require_workflow()
+    from google.adk.tools import exit_loop  # type: ignore
+
+    from gemcode.tools import build_function_tools  # type: ignore
+
+    # Shared tools that the sub-agents may use (no run_subtask to avoid recursion)
+    tools = extra_tools or []
+
+    writer = LlmAgent(
+        model=model,
+        name="writer_agent",
+        description="Writes or edits source code to fulfil the task, using test failure output as feedback.",
+        instruction=(
+            "You are a coding agent. Your goal: {task}.\n\n"
+            "Test command: {test_command}\n"
+            "Last test output:\n{test_output?}\n\n"
+            "Write or fix code to make the tests pass. "
+            "After making your edits, update state key 'iteration' by incrementing it."
+        ),
+        tools=tools,
+        output_key="writer_notes",
+    )
+
+    tester = LlmAgent(
+        model=model,
+        name="tester_agent",
+        description="Runs the test suite and stores the output in session state.",
+        instruction=(
+            "Run the test command stored in state: {test_command}.\n"
+            "Use the bash tool to execute it. Store ALL stdout+stderr verbatim in "
+            "state key 'test_output'. "
+            "If the command exits with code 0 (success), set state key 'test_passed' to 'yes'. "
+            "If it fails, set 'test_passed' to 'no'."
+        ),
+        tools=tools,
+        output_key="test_output",
+    )
+
+    checker = LlmAgent(
+        model=model,
+        name="checker_agent",
+        description=(
+            "Checks whether tests passed. If yes, calls exit_loop to terminate the "
+            "refinement cycle. If no, does nothing (loop continues)."
+        ),
+        instruction=(
+            "Check the value of state key 'test_passed'.\n"
+            "If 'test_passed' is 'yes': call the exit_loop tool to stop the loop — "
+            "the task is complete.\n"
+            "If 'test_passed' is 'no': output a brief summary of the failures so the "
+            "writer knows what to fix next. Do NOT call exit_loop."
+        ),
+        tools=[exit_loop, *tools],
+    )
+
+    return LoopAgent(
+        name="refine_loop",
+        description=(
+            f"Iterative write→test→fix loop for: {task_description[:120]}"
+        ),
+        sub_agents=[writer, tester, checker],
+        max_iterations=max_iterations,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Sequential Pipeline
+# ---------------------------------------------------------------------------
+
+def build_sequential_pipeline(
+    agents: list[Any],
+    *,
+    name: str = "sequential_pipeline",
+    description: str = "Runs specialist agents sequentially, passing results via state.",
+) -> Any:
+    """
+    Wrap a list of LlmAgents in a SequentialAgent.
+
+    Each agent should set ``output_key`` so subsequent agents can read its output
+    via {key} template substitution in their instructions.
+
+    Example:
+      pipeline = build_sequential_pipeline([
+          planner_agent,   # output_key="plan"
+          coder_agent,     # reads {plan}, output_key="code"
+          reviewer_agent,  # reads {code}, output_key="review"
+      ])
+    """
+    _require_workflow()
+    return SequentialAgent(name=name, description=description, sub_agents=agents)
+
+
+# ---------------------------------------------------------------------------
+# Parallel Fan-Out
+# ---------------------------------------------------------------------------
+
+def build_parallel_research(
+    agents: list[Any],
+    *,
+    name: str = "parallel_research",
+    description: str = "Runs research agents in parallel, collecting results via state.",
+) -> Any:
+    """
+    Wrap a list of LlmAgents in a ParallelAgent.
+
+    Each agent MUST use a distinct ``output_key`` to avoid state key collisions.
+
+    Example:
+      research = build_parallel_research([
+          web_researcher,   # output_key="web_results"
+          code_searcher,    # output_key="code_results"
+          doc_reader,       # output_key="doc_results"
+      ])
+      # Wrap in a SequentialAgent to collect after:
+      pipeline = build_sequential_pipeline([research, synthesis_agent])
+    """
+    _require_workflow()
+    return ParallelAgent(name=name, description=description, sub_agents=agents)

gemcode/repl_commands.py

@@ -101,7 +101,8 @@ def format_memory_lines(cfg: GemCodeConfig) -> list[str]:
 
 def format_hooks_lines(cfg: GemCodeConfig) -> list[str]:
   env_hook = os.environ.get("GEMCODE_POST_TURN_HOOK")
-  default_hook = cfg.project_root / ".gemcode" / "hooks" / "post_turn"
+  hooks_dir = cfg.project_root / ".gemcode" / "hooks"
+  default_hook = hooks_dir / "post_turn"
   active: str | None = env_hook
   if not active and _is_executable(default_hook):
     active = str(default_hook)
@@ -115,6 +116,31 @@ def format_hooks_lines(cfg: GemCodeConfig) -> list[str]:
     lines.append(f"  active_hook: {active}")
   else:
     lines.append("  active_hook: (none — set env or chmod +x .gemcode/hooks/post_turn)")
+
+  # ── Shell lifecycle hooks (like OpenClaude PreToolUse / PostToolUse) ──────
+  lines.append("")
+  lines.append("Shell lifecycle hooks (.gemcode/hooks/):")
+  lines.append("  Scripts run at tool/session lifecycle points.")
+  lifecycle_hooks = [
+      ("pre_tool_use",   "Run BEFORE each tool call. Non-zero exit → tool denied."),
+      ("post_tool_use",  "Run AFTER each tool call. Informational; return ignored."),
+      ("session_start",  "Run when a GemCode session starts."),
+      ("session_stop",   "Run when a GemCode session ends."),
+  ]
+  for hook_name, description in lifecycle_hooks:
+    found = None
+    for ext in ("", ".sh", ".py", ".bash"):
+      p = hooks_dir / f"{hook_name}{ext}"
+      if p.is_file() and _is_executable(p):
+        found = p
+        break
+    status = f"✓ {found}" if found else "✗ not found (create and chmod +x to enable)"
+    lines.append(f"  {hook_name:20s}  {status}")
+    lines.append(f"  {'':20s}  {description}")
+  lines.append("")
+  lines.append(f"  Hook directory: {hooks_dir}")
+  lines.append("  Hooks receive JSON on stdin with tool name, args, and result.")
+  lines.append("  Set GEMCODE_HOOK_TYPE env var is set for each hook.")
   return lines
 
 
@@ -216,4 +242,6 @@ def slash_help_lines() -> list[str]:
       "  /permissions          Show permission / HITL settings",
       "  /hooks                Show post-turn hook configuration",
       "  /kairos               How to launch the background parallel job scheduler",
+      "  /code [on|off]        Toggle sandboxed Python executor (ADK BuiltInCodeExecutor)",
+      "  /plan [on|off]        Toggle plan mode — agent plans before executing tools",
   ]

gemcode/repl_slash.py

@@ -357,6 +357,75 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /plan ─────────────────────────────────────────────────────────────────
+  if name == "plan":
+    args_s = (sc.args or "").strip().lower()
+    if args_s in ("on", "enable", "1", "true"):
+      cfg.plan_mode = True
+      out("Plan mode: ON")
+      out("The agent will now write an explicit numbered plan BEFORE executing")
+      out("any tools. It will pause for your confirmation before proceeding.")
+      out()
+      out("Type /plan off to disable.")
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    elif args_s in ("off", "disable", "0", "false"):
+      cfg.plan_mode = False
+      out("Plan mode: OFF")
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    else:
+      status = "ON" if getattr(cfg, "plan_mode", False) else "OFF"
+      out(f"Plan mode: {status}")
+      out()
+      out("When ON, the agent writes a numbered plan and waits for your")
+      out("confirmation before executing any file or shell operations.")
+      out()
+      out("Best for: complex multi-file refactors, migrations, risky changes.")
+      out("Toggle: /plan on   /plan off")
+      return ReplSlashResult(skip_model_turn=True)
+
+  # ── /code ─────────────────────────────────────────────────────────────────
+  if name == "code":
+    args_s = (sc.args or "").strip().lower()
+    if args_s in ("on", "enable", "1", "true"):
+      cfg.enable_code_executor = True
+      out("Code executor: ON  (sandboxed Python via Gemini built-in executor)")
+      out("The agent can now write Python code blocks and execute them safely,")
+      out("without requiring bash/shell permission. Best for: math, data, quick tests.")
+      out()
+      out("Note: the sandbox has no internet/filesystem access — use bash for I/O.")
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    elif args_s in ("off", "disable", "0", "false"):
+      cfg.enable_code_executor = False
+      out("Code executor: OFF")
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    else:
+      # Status
+      status = "ON" if getattr(cfg, "enable_code_executor", False) else "OFF"
+      out(f"Code executor: {status}")
+      out()
+      out("ADK BuiltInCodeExecutor — safe sandboxed Python execution via Gemini API.")
+      out()
+      out("What it does:")
+      out("  When ON, the agent can write Python code blocks directly in its response")
+      out("  and the Gemini API executes them in a sandboxed environment. The output")
+      out("  (stdout, result) is sent back so the agent can use it for further reasoning.")
+      out()
+      out("Best for:")
+      out("  - Math and numerical calculations")
+      out("  - Data processing and transformations")
+      out("  - Quick tests of logic or algorithms")
+      out("  - Anything that doesn't need filesystem or network access")
+      out()
+      out("Not for:")
+      out("  - Shell commands (use bash)")
+      out("  - Reading/writing files (use read_file / write_file)")
+      out("  - Internet requests (use web_fetch)")
+      out()
+      out("Toggle: /code on   /code off")
+      out()
+      out("Supported models: gemini-2.5-flash, gemini-2.5-pro, gemini-3.x and newer.")
+      return ReplSlashResult(skip_model_turn=True)
+
   # ── /computer ────────────────────────────────────────────────────────────
   if name in ("computer", "browser"):
     args_s = (sc.args or "").strip().lower()
@@ -560,19 +629,23 @@ async def process_repl_slash(
   # ── /caps ─────────────────────────────────────────────────────────────────
   if name in ("caps", "capabilities", "capability"):
     args_s = (sc.args or "").strip().lower()
-    valid_caps = ("auto", "research", "embeddings", "computer", "all", "none", "reset")
+    valid_caps = ("auto", "research", "embeddings", "computer", "search", "all", "none", "reset")
     out("Active capabilities:")
+    out(f"  web_search:     {'on' if getattr(cfg, 'enable_web_search', False) else 'off'}")
     out(f"  deep_research:  {'on' if cfg.enable_deep_research else 'off'}")
     out(f"  embeddings:     {'on' if cfg.enable_embeddings else 'off'}")
     out(f"  memory:         {'on' if cfg.enable_memory else 'off'}")
     out(f"  computer_use:   {'on' if cfg.enable_computer_use else 'off'}")
     out(f"  maps_grounding: {'on' if cfg.enable_maps_grounding else 'off'}")
+    out(f"  code_executor:  {'on' if getattr(cfg, 'enable_code_executor', False) else 'off'}")
+    out(f"  plan_mode:      {'on' if getattr(cfg, 'plan_mode', False) else 'off'}")
     out(f"  capability_mode (auto-routing): {cfg.capability_mode}")
     out()
     if not args_s:
       out("Commands:")
       out("  /caps none      — turn all off, capability_mode=auto")
-      out("  /caps research  — enable_deep_research on")
+      out("  /caps search    — enable_web_search on (standalone google_search)")
+      out("  /caps research  — enable_deep_research on (search + url_context)")
       out("  /caps embeddings — enable_embeddings on")
       out("  /caps all       — all modalities on")
       out("  /caps reset     — reset to startup defaults (all off, auto mode)")
@@ -583,10 +656,18 @@ async def process_repl_slash(
       cfg.enable_embeddings = False
       cfg.enable_computer_use = False
       cfg.enable_maps_grounding = False
+      if hasattr(cfg, "enable_web_search"):
+        cfg.enable_web_search = False
       cfg.capability_mode = "auto"
       out("capabilities: reset to defaults (all off, auto mode)")
       out()
       return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    if args_s == "search":
+      if hasattr(cfg, "enable_web_search"):
+        cfg.enable_web_search = True
+      out("enable_web_search: on (google_search available without full deep_research)")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
     if args_s == "research":
       cfg.enable_deep_research = True
       out("enable_deep_research: on (runner rebuilding…)")
@@ -607,6 +688,8 @@ async def process_repl_slash(
       cfg.enable_deep_research = True
       cfg.enable_embeddings = True
       cfg.enable_computer_use = True
+      if hasattr(cfg, "enable_web_search"):
+        cfg.enable_web_search = True
       out("capabilities: all on (runner rebuilding…)")
       out()
       return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)

gemcode/session_runtime.py

@@ -30,6 +30,23 @@ def session_db_path(cfg: GemCodeConfig) -> Path:
   return cfg.project_root / ".gemcode" / "sessions.sqlite"
 
 
+def _build_artifact_service(cfg: GemCodeConfig):
+  """
+  Return an ADK ArtifactService for this session, or None if disabled.
+
+  Uses InMemoryArtifactService so artifacts are available within the session
+  without requiring GCS credentials. The agent can save screenshots, generated
+  files, large reports, etc. as artifacts to avoid bloating session history.
+  """
+  if not getattr(cfg, "enable_artifacts", True):
+    return None
+  try:
+    from google.adk.artifacts import InMemoryArtifactService
+    return InMemoryArtifactService()
+  except Exception:
+    return None
+
+
 def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner:
   """Construct Runner + SQLite session service + root LlmAgent."""
   modality_tools = build_modality_extra_tools(cfg)
@@ -86,7 +103,9 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
     else:
       memory_service = FileMemoryService(mem_path)
 
-  return Runner(
+  artifact_service = _build_artifact_service(cfg)
+
+  runner_kwargs: dict = dict(
       app_name="gemcode",
       agent=agent,
       session_service=session_service,
@@ -94,3 +113,7 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
       memory_service=memory_service,
       auto_create_session=True,
   )
+  if artifact_service is not None:
+    runner_kwargs["artifact_service"] = artifact_service
+
+  return Runner(**runner_kwargs)

gemcode/tool_prompt_manifest.py

@@ -126,6 +126,9 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
   - Returns the sub-agent's final text as `result`.
   - Use for: context-heavy exploration (reading 50+ files), parallel investigation of independent subsystems, verification passes after you finish work.
   - Always give the sub-agent enough context to work independently; end the task with "Summarise your findings clearly."
+- **`get_user_choice(question, choices)`** — present the user with a structured list of options (2–6 items). Returns the user's selected option. Use instead of open-ended questions when the set of valid responses is known and bounded (e.g. framework choice, migration strategy, naming convention).
+- **`load_artifacts(filenames)`** — load one or more named artifacts (binary/large files) saved in this or a previous session. Returns the content of each. Use `user:filename` prefix for cross-session artifacts.
+- **`exit_loop()`** — signal the surrounding LoopAgent to stop iterating and emit the final result. Only relevant when running inside a LoopAgent pipeline (e.g. the `/refine` write→test→fix loop).
 
 ### Read-only tools (no permission needed): {_fmt_list(read_only)}
 Use proactively. Never use bash/run_command just to list or read files — these are instant and require zero approval.

gemcode/tui/input_handler.py

@@ -56,6 +56,8 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("budget",      "Set per-turn token budget  ·  /budget <N>  ·  /budget off"),
     ("limits",      "Show/set execution limits (max_llm_calls, context, etc.)"),
     ("kairos",      "Background parallel job scheduler — how to run gemcode kairos"),
+    ("code",        "Toggle sandboxed Python code executor (ADK BuiltInCodeExecutor)"),
+    ("plan",        "Toggle plan mode — agent writes explicit plan before executing tools"),
     ("tools",       "List all tools and their permission categories"),
     ("config",      "Show full active configuration (all fields)"),
     ("permissions", "Show current permission mode (default / strict / yes)"),
@@ -113,10 +115,12 @@ class GemCodeInputHandler:
         ansi_enabled: bool = True,
         get_model: Callable[[], str] | None = None,
         get_session_id: Callable[[], str] | None = None,
+        get_cfg: Callable[[], object | None] | None = None,
     ) -> None:
         self._ansi = ansi_enabled
         self._get_model = get_model or (lambda: "gemini")
         self._get_session_id = get_session_id or (lambda: "")
+        self._get_cfg = get_cfg or (lambda: None)
         self._session: "PromptSession | None" = None
 
         if _PT_AVAILABLE and sys.stdin.isatty() and sys.stdout.isatty():
@@ -141,15 +145,30 @@ class GemCodeInputHandler:
 
         get_model = self._get_model
         get_session_id = self._get_session_id
+        get_cfg = self._get_cfg
 
         def bottom_toolbar() -> HTML:
             model = get_model() or "gemini"
             sid = get_session_id()
             sid_short = sid[:8] if len(sid) >= 8 else sid
+            cfg = get_cfg()
+            extras = ""
+            if cfg is not None:
+                flags = []
+                if getattr(cfg, "plan_mode", False):
+                    flags.append("PLAN")
+                if getattr(cfg, "enable_code_executor", False):
+                    flags.append("CODE")
+                if getattr(cfg, "enable_deep_research", False):
+                    flags.append("RESEARCH")
+                if getattr(cfg, "enable_computer_use", False):
+                    flags.append("BROWSER")
+                if flags:
+                    extras = "  ·  " + "  ".join(f"[{f}]" for f in flags)
             return HTML(
                 f'<style bg="#0d1f2d" fg="#5fafd7"><b> ◆ {model}</b></style>'
                 f'<style bg="#0d1f2d" fg="#3d6080">  ·  session {sid_short}'
-                f'  ·  / for commands</style>'
+                f'{extras}  ·  / for commands</style>'
             )
 
         kb = KeyBindings()

gemcode/tui/scrollback.py

@@ -204,6 +204,13 @@ async def run_gemcode_scrollback_tui(
   load_cli_environment()
   os.environ["GEMCODE_TUI_ACTIVE"] = "1"
 
+  # ── Session-start hook ──────────────────────────────────────────────────
+  try:
+    from gemcode.hooks import run_session_start_hook
+    run_session_start_hook(cfg.project_root, model=getattr(cfg, "model", "") or "")
+  except Exception:
+    pass
+
   ansi = _Ansi(
     enabled=(
       sys.stdout.isatty()
@@ -234,6 +241,7 @@ async def run_gemcode_scrollback_tui(
       ansi_enabled=ansi.enabled,
       get_model=lambda: getattr(cfg, "model", "gemini") or "gemini",
       get_session_id=lambda: _current_session_id_holder[0],
+      get_cfg=lambda: cfg,
   )
 
   async def typewrite(text: str) -> None:
@@ -437,10 +445,20 @@ async def run_gemcode_scrollback_tui(
       prompt = await input_handler.prompt_async()
     except EOFError:
       print("")
+      try:
+        from gemcode.hooks import run_session_stop_hook
+        run_session_stop_hook(cfg.project_root, model=getattr(cfg, "model", "") or "")
+      except Exception:
+        pass
       return
     if not prompt:
       continue
     if prompt in (":q", "quit", "exit", "/exit"):
+      try:
+        from gemcode.hooks import run_session_stop_hook
+        run_session_stop_hook(cfg.project_root, model=getattr(cfg, "model", "") or "")
+      except Exception:
+        pass
       return
 
     old_model = getattr(cfg, "model", "")
@@ -707,7 +725,32 @@ async def run_gemcode_scrollback_tui(
           else current_session_id
       )
       model = getattr(cfg, "model", "") or ""
-      print(f"{ansi.dim}  · {model} · session {sid}{ansi.reset}")
+      # ── Token / cost stats from last turn ──────────────────────────────────
+      stats = getattr(cfg, "_last_turn_stats", None)
+      token_part = ""
+      if stats:
+        try:
+          from gemcode.pricing import format_cost, format_tokens
+          in_tok  = stats.get("in", 0) or 0
+          out_tok = stats.get("out", 0) or 0
+          think_tok = stats.get("think", 0) or 0
+          session_total = stats.get("session_total", 0) or 0
+          turn_cost = stats.get("turn_cost")
+          session_cost = stats.get("session_cost")
+          parts_t: list[str] = []
+          parts_t.append(f"↑{format_tokens(in_tok)} ↓{format_tokens(out_tok)}")
+          if think_tok:
+            parts_t.append(f"✦{format_tokens(think_tok)}")
+          if turn_cost is not None:
+            parts_t.append(format_cost(turn_cost))
+          if session_total:
+            parts_t.append(f"session {format_tokens(session_total)}")
+          if session_cost and session_cost > 0.0001:
+            parts_t.append(f"total {format_cost(session_cost)}")
+          token_part = "  ·  " + "  ·  ".join(parts_t)
+        except Exception:
+          pass
+      print(f"{ansi.dim}  · {model} · session {sid}{token_part}{ansi.reset}")
     if os.environ.get("GEMCODE_TUI_TURN_RULE", "1").lower() in (
         "1",
         "true",

{gemcode-0.3.28.dist-info → gemcode-0.3.30.dist-info}/METADATA

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

{gemcode-0.3.28.dist-info → gemcode-0.3.30.dist-info}/RECORD

@@ -1,17 +1,18 @@
 gemcode/__init__.py,sha256=l0DCRYqK7KM7Fb7u49fqh-5_SlpeIL7r3LjMeJWMgSg,112
 gemcode/__main__.py,sha256=EX2s1hxq2Yvli_-tnBN3w5Qv4bOjsBBbjyISF0pDIQw,37
-gemcode/agent.py,sha256=etP0evf7_QSzxY9RqTvc3peVJXh6tcwBmcGqqfb2VDQ,29990
+gemcode/agent.py,sha256=DED-H1lYEYb3NpIiwVbcefmzfkl06XM1edM1qhXyUw8,35713
 gemcode/audit.py,sha256=bh9uhXaeh8wqxqoZtz3ZAowd8Ndk1ss-mw9993Vlrgo,469
 gemcode/autocompact.py,sha256=77h5tgFzJ2rjrhlCL2oIc28IHwLbP4Pqlo7cSNgDwiA,6727
-gemcode/callbacks.py,sha256=dxZhHsJDE-16nJ0OGe4udPkWRTOCVfSi2gBSR7MUWOM,20465
+gemcode/callbacks.py,sha256=g_1HgHzD7NRB1DN7eVc4MN5sT9g7ZB2dnu3nreXAz7I,23182
 gemcode/capability_routing.py,sha256=D8tvawmf_MSL94GVXgG9QhDvNaQVGqzA8tUFQ8XlftY,2894
 gemcode/cli.py,sha256=0b9hO86EILJ5xRg8fb1Sfmwh6vYi9Bp6tkOvsxOSIEU,25447
 gemcode/compaction.py,sha256=9YtA_qa23_8dHWVHx7AJwUduuI7jJQtq-m6sT8jgPWI,1186
-gemcode/config.py,sha256=xvvhJbMEBPjIotwnxoggTdXpfYaDPjVi5PCIy489610,12540
+gemcode/config.py,sha256=GKbze1nDf1U5O-i6AmKd9FYr92TklJ2Vhi3qdKrhqZw,14081
 gemcode/context_budget.py,sha256=Nhox9vFBtLbb7jtO7cyGW1MxtN7SVjlIeQ7d-cgGyKM,10544
 gemcode/context_warning.py,sha256=Q8mg5Vojj7EglPhsGAVL7vb8ROLuHVPgdzw25yw-Q2c,4263
 gemcode/credentials.py,sha256=04v-rLD8_Ams69FQdof2FwcL3ZgsroGUnMcHNQFuBZo,1296
 gemcode/hitl_session.py,sha256=oNiI7odFJGUcmqPavjKLJOEumZKrgklLvwjjrIG9GPg,281
+gemcode/hooks.py,sha256=FHz175d_18j-4ByZZVdEIagmdOvLHcjDjo7HD2Cikf4,6339
 gemcode/interactions.py,sha256=B0b3QNE_I2i5_HtiebX4ehhjlc4Nbqjf_XbvcTLyJT0,641
 gemcode/invoke.py,sha256=TakGUR8RweW0nKFCQeYFKwge24rVYHhwkO1erMuoMf8,7514
 gemcode/kairos_daemon.py,sha256=giINipslAIhBtdbqA0o4RYwt4fBsZjtkiKDjp4zSEvw,6980
@@ -19,18 +20,20 @@ gemcode/limits.py,sha256=1u7w3X13Uqw34ZOVYKa62pxfvlyLTY2Dne1kN8SKJlA,2524
 gemcode/live_audio_engine.py,sha256=Re1zS-9lcaK2qfU7ydPVQlI6tXxv384O6Bs1dhZ8Puo,3423
 gemcode/logging_config.py,sha256=nw_FyJbXM3StzaAx6b6BLLNvzuxsGg-sdQ3QRw7BWgs,1080
 gemcode/mcp_loader.py,sha256=0QRgYvI71YNAyehO0N9SgK-9jhiocXHVo0J5HQ8MZHo,1344
-gemcode/modality_tools.py,sha256=196Plk1lUgegPu-VeVoONkt3Zlxk5kXQnM8vlRFapn0,6261
+gemcode/modality_tools.py,sha256=Gx-hDXr5Y364jl2oiUvBNWOZj7Z6bUXxmwVHUpc1L44,6875
 gemcode/model_errors.py,sha256=6I2Gl2HbxINMmJOjSdM5rH6rCUDLA4ellGZsQrzy47Q,2948
 gemcode/model_routing.py,sha256=Q42HZtXQa6rao2O2vYMHxohrTgD-wq4t7qGxU4_38Jg,4881
 gemcode/paths.py,sha256=U6cEH9jfIcSc4NO8Ke0jniZSiJTfCIJPvSMue3hR0ZU,768
 gemcode/permissions.py,sha256=9FmwTP_LLflahxS9KXvY3VPSra4e-h3OariOqnWIKDI,177
+gemcode/pricing.py,sha256=pedyJg4i18NeZ9gvw3JObhmuEBaHJMKwQ5a17Q6Y-6s,3176
 gemcode/prompt_suggestions.py,sha256=h-W_9LlfagS91PyoMEjEjsCqoG4XmIh3QBypA59HyGw,2553
-gemcode/repl_commands.py,sha256=yYd1aXaY9wZzoiWNMlVhtFPK1KO2_tX-FUTTXrfHuhE,8270
-gemcode/repl_slash.py,sha256=epkMgUcjfY6u4XOpr_oGoN3UDIFTyhsGSmHvl46s590,31498
-gemcode/session_runtime.py,sha256=iasFwXJmrqbutNnZmSCbWmDerWiBf32_eloi3SKKu6c,4081
+gemcode/refine.py,sha256=BijEZ4Z32wGa9aK_WottyAhZF-j0xEqRg5UpjedNv2A,7653
+gemcode/repl_commands.py,sha256=VMqJVf9L-H3Qschia_VkqS-Sq7s4HNNnKIg7nfRSzC4,9676
+gemcode/repl_slash.py,sha256=2XT01vCx9rUaSI0_zJy-djZodlLBodEzqUh091pqXuc,35853
+gemcode/session_runtime.py,sha256=gXuBU-3kJlZ-_aBTCaCVnEVxz6RD-J7CRTMC1Z7JVSg,4845
 gemcode/slash_commands.py,sha256=Qylzsj1notk0xN_hvd3CR4HD8g-l99UENDMcg1pKeBA,794
 gemcode/thinking.py,sha256=RanBf_x9fKv1o4DNyNXPLfOdn2xT0KybJb65nYgmMEE,4885
-gemcode/tool_prompt_manifest.py,sha256=6Fy5vrzgMX-0SIOeenXe8I41RmKPwIoz0qMp9KcLDRM,7976
+gemcode/tool_prompt_manifest.py,sha256=MS_eSJg2BTp6yv1Ih2p93okPmnK3B2dYAMjnG6yaEVY,8695
 gemcode/tool_registry.py,sha256=ifqxtr2uLwEUwnJLKYLza_tIz-paaZediJa75y9MiyA,1795
 gemcode/tools_inspector.py,sha256=okmu4PDYAQQ7nthDvuzSHmy2zArFTG4ftIPRadzLnxA,4100
 gemcode/trust.py,sha256=fxe57Xg6aL_KU24bQDUtD-rXjsNpaq7g-eQTInZnudE,1336
@@ -64,17 +67,17 @@ gemcode/tools/subtask.py,sha256=ur_6jnwnNzHSBtW96mB2N2A6zmALpydSV24Nkx0T6UQ,5683
 gemcode/tools/think.py,sha256=WrNATR-bi97aLkbSsOFOYYAGxbzihe9AnPDZfw3z5-Q,1704
 gemcode/tools/todo.py,sha256=d9aXiyT04r1RFZIk6qdVif17-_Oc3oi4ymDnsPBRg68,3143
 gemcode/tools/web.py,sha256=ULg1e3inG4FjPSUCYI8dVBzTrcCHINNRo76SIU9qw-A,4489
-gemcode/tui/input_handler.py,sha256=nQEltM2U0Ks2GW_8KYyoww-S7x7Xjspig59r6yi_Pyo,8235
-gemcode/tui/scrollback.py,sha256=zc91bA1jPQdluwy5eUFX3-lElYhaaSBIyOKQ0bj-zbA,24521
+gemcode/tui/input_handler.py,sha256=M3TNo7EjcKVHvzIw_WbBPr6VNYVxbsGwwX_5vXWtXOs,9195
+gemcode/tui/scrollback.py,sha256=LrYjmu9g9oatFB22ZzN5CcVEzn2NQfTF3sV3_AAHpiw,26517
 gemcode/tui/spinner.py,sha256=AJrApG5od-Sh40-5uWcNM9RHb5ax7gr-NbgAZmTbIYY,4848
 gemcode/tui/welcome_banner.py,sha256=aocl1lnoyLIM6RN4f65g3i0wRA71RqUlgPrGsXeVLW4,4387
 gemcode/tui/welcome_rich.py,sha256=8FEZzLXrzqly5JWiDgV9ooRV1LNXDk-CXV1a7K6ua-U,4048
 gemcode/web/__init__.py,sha256=EysmUAWs6g-lmMk4VFljKfaHVrEgb_FiIzwQmBdORJc,40
 gemcode/web/claude_sse_adapter.py,sha256=HcNp0Lh4DdBZBLOpstsqa-VzfqAUrRngZ6FSuJ-mIMg,8609
 gemcode/web/terminal_repl.py,sha256=k2irvFGbCY8gDm_pbirR7b_cakaeafcctoTIvnJkVXk,3902
-gemcode-0.3.28.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
-gemcode-0.3.28.dist-info/METADATA,sha256=iwoh3k_b5G6pb68A58SBvkcfcobd9xok_br31HvZlT0,23695
-gemcode-0.3.28.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gemcode-0.3.28.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
-gemcode-0.3.28.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
-gemcode-0.3.28.dist-info/RECORD,,
+gemcode-0.3.30.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
+gemcode-0.3.30.dist-info/METADATA,sha256=rzb9o3zpt1S4CNHZF3YjcbG-1EazIWiPL7Xi5A5T-wI,23695
+gemcode-0.3.30.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gemcode-0.3.30.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
+gemcode-0.3.30.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
+gemcode-0.3.30.dist-info/RECORD,,