gemcode 0.3.22__tar.gz → 0.3.24__tar.gz

{gemcode-0.3.22/src/gemcode.egg-info → gemcode-0.3.24}/PKG-INFO

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

{gemcode-0.3.22 → gemcode-0.3.24}/pyproject.toml

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

{gemcode-0.3.22 → gemcode-0.3.24}/src/gemcode/agent.py

@@ -71,6 +71,143 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Working in subfolders** — use tools: e.g. `list_directory("Desktop")`, `glob_files("**/query.ts")`, `read_file("testing/ai-edtech-app/src/app/page.tsx")`, or `run_command` with `cwd_subdir`. Never claim the sandbox cannot reach a subpath unless a tool returned an explicit error."""
 
 
+def _build_computer_use_section(cfg: GemCodeConfig) -> str:
+  """Rich computer use guidance, only injected when enable_computer_use=True."""
+  w = getattr(cfg, "_cfg", None)
+  viewport_w = 1280
+  viewport_h = 720
+  try:
+    import os
+    viewport_w = int(os.environ.get("GEMCODE_BROWSER_WIDTH", "1280"))
+    viewport_h = int(os.environ.get("GEMCODE_BROWSER_HEIGHT", "720"))
+  except Exception:
+    pass
+  return f"""
+## Browser Computer Use
+You have full browser automation capabilities via a real Chromium instance ({viewport_w}×{viewport_h} px).
+
+### Available tools
+
+**Navigation:**
+- `navigate(url)` — Load a URL, wait for DOM, return screenshot + URL
+- `go_back()` / `go_forward()` — Browser history
+- `search()` — Open Google homepage
+
+**Mouse:**
+- `click_at(x, y)` — Left-click at pixel coordinates (0,0 = top-left corner)
+- `double_click_at(x, y)` — Double-click
+- `right_click_at(x, y)` — Right-click (opens context menus)
+- `hover_at(x, y)` — Hover to reveal tooltips / dropdown menus
+- `drag_and_drop(x, y, dest_x, dest_y)` — Click-drag
+
+**Keyboard:**
+- `type_text_at(x, y, text, press_enter=True, clear_before_typing=True)` — Click field then type
+- `key_combination(keys)` — Press combos: `["control+a"]`, `["control+c"]`, `["control+v"]`, `["escape"]`, `["tab"]`
+
+**Scroll:**
+- `scroll_document(direction)` — Scroll whole page: `"up"`, `"down"`, `"left"`, `"right"`
+- `scroll_at(x, y, direction, magnitude)` — Scroll at a specific coordinate (for panels)
+
+**Wait:**
+- `wait(seconds)` — Pause for dynamic content (SPAs, animations, lazy-loading)
+- `browser_wait_for_navigation(timeout_seconds)` — Wait for a page transition to complete
+
+**Read-only inspection (NO side effects — always safe to call):**
+- `browser_screenshot()` — Take screenshot, save to file, return path + URL + title
+- `browser_get_text(max_chars)` — Extract ALL visible text from page (best for data extraction)
+- `browser_get_url()` — Get current URL and page title
+- `browser_find_element(selector_or_text, selector_type)` — Find element position by CSS or text; returns center (x, y) for clicking
+
+### Human-like execution strategy — ALWAYS follow this loop
+
+Every computer use task MUST follow this exact loop:
+
+1. **THINK** — call `think` first. Reason through: What is the goal? What page do I need? What sequence of actions?
+2. **NAVIGATE** — go to the right URL with `navigate(url)`
+3. **LOOK** — call `browser_screenshot()` to see the current page state
+4. **ANALYZE** — study the screenshot carefully: Where are the buttons? Inputs? Text? What are their approximate pixel coordinates?
+5. **FIND** — use `browser_find_element(text_or_selector)` to get precise coordinates for important elements
+6. **ACT** — execute ONE action (`click_at`, `type_text_at`, etc.)
+7. **VERIFY** — study the new screenshot returned by the action. Did it work?
+8. **ADAPT** — if unexpected result, reconsider; try different coordinates or approach
+9. **REPEAT** — continue until the task is fully done
+
+### Critical rules
+
+- **ALWAYS call `think` before a sequence of computer actions** — plan the exact steps before touching the browser
+- **Coordinates are (x, y) from the top-left corner (0, 0)** — viewport is {viewport_w}×{viewport_h} px
+- **Use `browser_find_element` for precision** — do not guess coordinates; find elements by their visible text
+- **Click THEN verify** — every action returns a screenshot; always analyze it before the next action
+- **For slow pages** — call `wait(2)` after navigation if content is still loading in the screenshot
+- **For forms** — click each field individually, then type; `type_text_at` handles this automatically
+- **For data extraction** — use `browser_get_text()` instead of trying to read screenshot text
+- **If a click misses** — take `browser_screenshot()`, analyze coordinates more carefully, try again
+- **For menus** — `hover_at` first (to reveal), then `click_at` the menu item
+
+### Common patterns
+
+**Web search for information:**
+```
+think("I need to search Google for X")
+navigate("https://www.google.com")
+browser_screenshot()  # verify Google loaded
+type_text_at(640, 360, "your query", press_enter=True)
+browser_screenshot()  # see search results
+browser_get_text()    # extract text of results
+click_at(x, y)        # click most relevant result
+browser_get_text()    # extract the article
+```
+
+**Fill and submit a form:**
+```
+think("I need to fill in: field1=value1, field2=value2, then submit")
+navigate("https://example.com/form")
+browser_screenshot()  # see the form layout
+browser_find_element("Email", selector_type="text")  # get input coords
+type_text_at(x, y, "user@email.com", press_enter=False)
+browser_find_element("Password", selector_type="text")
+type_text_at(x, y, "password", press_enter=False)
+browser_find_element("Submit", selector_type="text")
+click_at(center_x, center_y)
+browser_screenshot()  # verify submission
+```
+
+**Log in to a website:**
+```
+navigate("https://example.com/login")
+browser_screenshot()
+browser_find_element("input[type='email']", selector_type="css")
+type_text_at(x, y, "user@email.com", press_enter=False)
+browser_find_element("input[type='password']", selector_type="css")
+type_text_at(x, y, "password", press_enter=True)
+browser_screenshot()  # verify login success
+```
+
+**Extract data from a page:**
+```
+navigate("https://example.com/data")
+wait(2)  # allow dynamic content to load
+browser_get_text()  # get all visible text — parse it to extract what you need
+```
+
+**Copy text from page to use elsewhere:**
+```
+browser_find_element("the text I want", selector_type="text")
+# Note the coordinates, then use key_combination to select
+click_at(x, y)
+key_combination(["control+a"])  # select all text in the field
+key_combination(["control+c"])  # copy
+```
+
+### Error recovery
+- **Page didn't load**: try `wait(3)` then `browser_screenshot()` to check
+- **Element not found by selector**: use `browser_get_text()` to find the exact text, then use `browser_find_element` with that text
+- **Click had no effect**: double-check coordinates from screenshot, try `browser_find_element` to get precise position
+- **Form submission failed**: `browser_get_text()` to read error messages, fix and resubmit
+- **Unexpected page**: `browser_get_url()` to confirm where you are, `go_back()` if needed
+"""
+
+
 def build_instruction(cfg: GemCodeConfig) -> str:
   base = f"""You are GemCode, an expert software engineering agent powered by Google Gemini.
 You run locally via the GemCode CLI. You are the same agent the user launched — not a hosted portal.
@@ -241,8 +378,11 @@ For tasks where quality matters:
 ## Workspace scope
 All file tools use paths **relative to the project root** (where GemCode was started). The root may be the home folder — subfolders like `Desktop`, `Desktop/code`, `Documents` are inside the sandbox. Call `list_directory("Desktop")` or `glob_files("**/*name*.ts")` instead of assuming access is blocked. Only treat access as denied when a tool returns an explicit `error`."""
 
-  tool_manifest = build_tool_manifest(cfg)
+  # Inject computer use strategy when the browser is enabled.
+  if getattr(cfg, "enable_computer_use", False):
+    base = f"{base}\n\n{_build_computer_use_section(cfg)}"
 
+  tool_manifest = build_tool_manifest(cfg)
   if tool_manifest:
     base = f"{base}\n\n{tool_manifest}"
   extra = _load_gemini_md(cfg.project_root)

gemcode-0.3.24/src/gemcode/computer_use/browser_computer.py

@@ -0,0 +1,361 @@
+"""
+Playwright-backed browser automation (ADK ComputerUse).
+
+Implements Google ADK's BaseComputer so the LLM can call computer-use tools
+like navigate, click_at, type_text_at, scroll_at, key_combination, etc.
+
+Every action returns a ComputerState (viewport PNG screenshot + current URL)
+so the model always sees the current page state after each action.
+"""
+
+from __future__ import annotations
+
+import platform
+import sys
+from dataclasses import dataclass
+from typing import Literal
+from typing import Tuple
+
+from google.adk.tools.computer_use.base_computer import BaseComputer
+from google.adk.tools.computer_use.base_computer import ComputerEnvironment
+from google.adk.tools.computer_use.base_computer import ComputerState
+
+
+@dataclass(frozen=True)
+class BrowserComputerConfig:
+  headless: bool = True
+  viewport_width: int = 1280
+  viewport_height: int = 720
+  navigation_timeout_ms: int = 30_000
+  # Extra ms to wait after load for dynamic content (SPAs, lazy-loading, etc.)
+  post_load_wait_ms: int = 400
+
+
+_IS_MACOS = platform.system() == "Darwin"
+
+# On macOS, many "select all / copy / paste" shortcuts use Cmd (Meta) instead
+# of Ctrl.  In a Chromium browser Ctrl+A still works for web inputs, but some
+# OS-level UI elements need Meta.  We expose both and let the agent decide.
+_MOD_MAP = {
+    "control": "Control", "ctrl": "Control",
+    "shift": "Shift",
+    "alt": "Alt", "option": "Alt",
+    "meta": "Meta", "command": "Meta", "cmd": "Meta", "super": "Meta",
+}
+
+
+class BrowserComputer(BaseComputer):
+  """
+  A single Chromium page controlled by Playwright.
+
+  Usage flow:
+    1. LLM calls ``navigate(url)`` to open a page.
+    2. LLM reads the screenshot returned by each action.
+    3. LLM calls ``click_at``, ``type_text_at``, etc. to interact.
+    4. Each action returns a new ``ComputerState`` (screenshot + URL).
+  """
+
+  def __init__(
+    self,
+    *,
+    headless: bool = True,
+    viewport_size: Tuple[int, int] = (1280, 720),
+    navigation_timeout_ms: int = 30_000,
+    post_load_wait_ms: int = 400,
+  ):
+    self._cfg = BrowserComputerConfig(
+      headless=headless,
+      viewport_width=viewport_size[0],
+      viewport_height=viewport_size[1],
+      navigation_timeout_ms=navigation_timeout_ms,
+      post_load_wait_ms=post_load_wait_ms,
+    )
+    self._playwright = None
+    self._browser = None
+    self._context = None
+    self._page = None
+
+  # ── Lifecycle ─────────────────────────────────────────────────────────────
+
+  async def initialize(self) -> None:
+    """Lazy-start Playwright Chromium. Called automatically before every action."""
+    if self._page is not None:
+      return
+    try:
+      from playwright.async_api import async_playwright
+    except ImportError as exc:
+      raise RuntimeError(
+        "Browser computer requires Playwright.\n"
+        "  pip install playwright\n"
+        "  playwright install chromium"
+      ) from exc
+
+    self._playwright = await async_playwright().start()
+    self._browser = await self._playwright.chromium.launch(headless=self._cfg.headless)
+    self._context = await self._browser.new_context(
+      viewport={
+        "width": self._cfg.viewport_width,
+        "height": self._cfg.viewport_height,
+      }
+    )
+    self._page = await self._context.new_page()
+    self._page.set_default_navigation_timeout(self._cfg.navigation_timeout_ms)
+
+  async def close(self) -> None:
+    """Shut down the Playwright process (called by session_runtime on runner close)."""
+    for attr in ("_context", "_browser", "_playwright"):
+      obj = getattr(self, attr, None)
+      if obj is not None:
+        try:
+          await obj.close() if attr != "_playwright" else await obj.stop()
+        except Exception:
+          pass
+    self._playwright = None
+    self._browser = None
+    self._context = None
+    self._page = None
+
+  # ── ADK BaseComputer interface ─────────────────────────────────────────────
+
+  async def environment(self) -> ComputerEnvironment:
+    return ComputerEnvironment.ENVIRONMENT_BROWSER
+
+  async def screen_size(self) -> tuple[int, int]:
+    await self.initialize()
+    return (self._cfg.viewport_width, self._cfg.viewport_height)
+
+  async def current_state(self) -> ComputerState:
+    """Return viewport PNG + current URL (called after every action)."""
+    await self.initialize()
+    screenshot = await self._page.screenshot(type="png", full_page=False)
+    url = self._page.url
+    return ComputerState(screenshot=screenshot, url=url)
+
+  # ── Navigation ─────────────────────────────────────────────────────────────
+
+  async def open_web_browser(self) -> ComputerState:
+    await self.initialize()
+    await self._page.goto("about:blank")
+    return await self.current_state()
+
+  async def navigate(self, url: str) -> ComputerState:
+    """Navigate to a URL. Waits for DOM content, then an extra grace period."""
+    await self.initialize()
+    try:
+      await self._page.goto(url, wait_until="domcontentloaded")
+    except Exception:
+      # Best-effort on timeout/error; still return current state.
+      pass
+    await self._page.wait_for_timeout(self._cfg.post_load_wait_ms)
+    return await self.current_state()
+
+  async def go_back(self) -> ComputerState:
+    await self.initialize()
+    try:
+      await self._page.go_back(wait_until="domcontentloaded")
+    except Exception:
+      pass
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def go_forward(self) -> ComputerState:
+    await self.initialize()
+    try:
+      await self._page.go_forward(wait_until="domcontentloaded")
+    except Exception:
+      pass
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def search(self) -> ComputerState:
+    return await self.navigate("https://www.google.com")
+
+  # ── Mouse actions ──────────────────────────────────────────────────────────
+
+  async def click_at(self, x: int, y: int) -> ComputerState:
+    """Left-click at pixel coordinates (0,0 = top-left)."""
+    await self.initialize()
+    await self._page.mouse.click(x, y)
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def double_click_at(self, x: int, y: int) -> ComputerState:
+    """Double-click at pixel coordinates."""
+    await self.initialize()
+    await self._page.mouse.dblclick(x, y)
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def right_click_at(self, x: int, y: int) -> ComputerState:
+    """Right-click (context menu) at pixel coordinates."""
+    await self.initialize()
+    await self._page.mouse.click(x, y, button="right")
+    await self._page.wait_for_timeout(150)
+    return await self.current_state()
+
+  async def hover_at(self, x: int, y: int) -> ComputerState:
+    """Hover mouse (reveals tooltips and dropdowns)."""
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    await self._page.wait_for_timeout(200)
+    return await self.current_state()
+
+  async def drag_and_drop(
+    self, x: int, y: int, destination_x: int, destination_y: int
+  ) -> ComputerState:
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    await self._page.mouse.down()
+    await self._page.mouse.move(destination_x, destination_y, steps=10)
+    await self._page.mouse.up()
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  # ── Scroll ─────────────────────────────────────────────────────────────────
+
+  async def scroll_document(
+    self, direction: Literal["up", "down", "left", "right"]
+  ) -> ComputerState:
+    """Scroll the whole page by a fixed amount."""
+    await self.initialize()
+    dx, dy = self._direction_delta(direction, magnitude=700)
+    await self._page.mouse.wheel(dx=dx, dy=dy)
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  async def scroll_at(
+    self,
+    x: int,
+    y: int,
+    direction: Literal["up", "down", "left", "right"],
+    magnitude: int,
+  ) -> ComputerState:
+    """Scroll at a specific (x, y) coordinate (for scrollable panels)."""
+    await self.initialize()
+    await self._page.mouse.move(x, y)
+    dx, dy = self._direction_delta(direction, magnitude=abs(magnitude))
+    await self._page.mouse.wheel(dx=dx, dy=dy)
+    await self._page.wait_for_timeout(250)
+    return await self.current_state()
+
+  @staticmethod
+  def _direction_delta(
+    direction: str, magnitude: int
+  ) -> tuple[int, int]:
+    if direction == "up":
+      return 0, -magnitude
+    if direction == "down":
+      return 0, magnitude
+    if direction == "left":
+      return -magnitude, 0
+    return magnitude, 0
+
+  # ── Keyboard ───────────────────────────────────────────────────────────────
+
+  async def type_text_at(
+    self,
+    x: int,
+    y: int,
+    text: str,
+    press_enter: bool = True,
+    clear_before_typing: bool = True,
+  ) -> ComputerState:
+    """
+    Click a field, optionally clear it, then type text.
+
+    On macOS browsers Ctrl+A selects all text in web inputs correctly.
+    For native OS dialogs use key_combination(["Meta+a"]) instead.
+    """
+    await self.initialize()
+    await self._page.mouse.click(x, y)
+    await self._page.wait_for_timeout(100)
+    if clear_before_typing:
+      select_all = "Meta+A" if _IS_MACOS else "Control+A"
+      await self._page.keyboard.press(select_all)
+      await self._page.keyboard.press("Backspace")
+    await self._page.keyboard.type(text, delay=30)
+    if press_enter:
+      await self._page.keyboard.press("Enter")
+    return await self.current_state()
+
+  async def key_combination(self, keys: list[str]) -> ComputerState:
+    """
+    Press key combinations.
+
+    Each element in ``keys`` is a combo string like ``"control+c"`` or
+    ``"shift+enter"``.  Modifier names: control/ctrl, shift, alt/option,
+    meta/command/cmd.
+
+    Example: ``key_combination(["control+a", "control+c"])``
+    """
+    await self.initialize()
+    for combo in keys:
+      await self._press_combo(combo)
+    await self._page.wait_for_timeout(100)
+    return await self.current_state()
+
+  async def _press_combo(self, combo: str) -> None:
+    """Press a single key combination string (e.g. 'control+shift+t')."""
+    parts = combo.strip().lower().replace(" ", "").split("+")
+    if len(parts) == 1:
+      await self._page.keyboard.press(parts[0])
+      return
+    mods = parts[:-1]
+    key = parts[-1]
+    for m in mods:
+      pw = _MOD_MAP.get(m)
+      if pw:
+        await self._page.keyboard.down(pw)
+    await self._page.keyboard.press(key)
+    for m in reversed(mods):
+      pw = _MOD_MAP.get(m)
+      if pw:
+        await self._page.keyboard.up(pw)
+
+  # ── Waiting ────────────────────────────────────────────────────────────────
+
+  async def wait(self, seconds: int) -> ComputerState:
+    """Wait N seconds (use when page is loading dynamic content)."""
+    await self.initialize()
+    await self._page.wait_for_timeout(max(1, int(seconds)) * 1000)
+    return await self.current_state()
+
+  async def wait_for_text(self, text: str, timeout_seconds: int = 10) -> ComputerState:
+    """Wait until a specific text appears on the page."""
+    await self.initialize()
+    try:
+      await self._page.wait_for_function(
+        f"document.body.innerText.includes({repr(text)})",
+        timeout=timeout_seconds * 1000,
+      )
+    except Exception:
+      pass
+    return await self.current_state()
+
+  # ── Page inspection ────────────────────────────────────────────────────────
+
+  async def get_page_text(self) -> str:
+    """Extract all visible text from the current page (for data extraction)."""
+    await self.initialize()
+    try:
+      return await self._page.evaluate("() => document.body.innerText")
+    except Exception as e:
+      return f"(error reading page text: {e})"
+
+  async def get_page_title(self) -> str:
+    """Return the current page <title>."""
+    await self.initialize()
+    try:
+      return await self._page.title()
+    except Exception:
+      return ""
+
+  async def get_current_url(self) -> str:
+    """Return the current page URL."""
+    await self.initialize()
+    return self._page.url or ""
+
+  async def screenshot_bytes(self) -> bytes:
+    """Return the current viewport as a PNG bytes object (no action)."""
+    await self.initialize()
+    return await self._page.screenshot(type="png", full_page=False)

{gemcode-0.3.22 → gemcode-0.3.24}/src/gemcode/config.py

@@ -244,6 +244,13 @@ class GemCodeConfig:
     default_factory=lambda: _opt_int("GEMCODE_THINKING_BUDGET")
   )
 
+  # Controls how the TUI renders model thinking: True = full Rich Markdown,
+  # False = collapsed one-line excerpt (default, like OpenClaude).
+  # Toggled at runtime via /thinking verbose|brief.
+  show_full_thinking: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_SHOW_FULL_THINKING", 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-0.3.22 → gemcode-0.3.24}/src/gemcode/repl_commands.py

@@ -162,9 +162,11 @@ def slash_help_lines() -> list[str]:
       "Slash commands:",
       "  (CLI) gemcode -C DIR  Use a project folder as root (recommended vs. ~ )",
       "  (CLI) gemcode login   Save or change API key (~/.gemcode/credentials.json)",
+      "",
+      "  Session:",
       "  /help                 Show this help",
-      "  /status               Show current session/model info",
-      "  /config               Show key GemCode env/config toggles",
+      "  /status               Full status: model, capabilities, thinking, limits",
+      "  /config               All active config fields (model, caps, context, thinking)",
       "  /session              Print current session id",
       "  /session new          Start a new session id (history reset)",
       "  /clear                Alias for /session new",
@@ -173,9 +175,29 @@ def slash_help_lines() -> list[str]:
       "  /audit [N]            Tail of .gemcode/audit.log (default 40 lines)",
       "  /tools                List tool inventory for this config",
       "  /doctor               Environment sanity check",
+      "  /version              Print GemCode version hint",
+      "  /exit                 Exit the REPL",
+      "",
+      "  Model:",
       "  /model                Show model routing info",
       "  /model use <id>       Override model for this REPL session",
-      "  /model list            List available Gemini model IDs",
+      "  /model list           List available Gemini model IDs",
+      "  /mode                 Show current model_mode",
+      "  /mode <fast|balanced|quality|auto>  Set model selection strategy",
+      "",
+      "  Capabilities (all require runner rebuild — shown automatically):",
+      "  /computer             Show browser automation status (Playwright Chromium)",
+      "  /computer on|off      Enable/disable browser computer use",
+      "  /computer url         Show current browser URL",
+      "  /research             Show deep-research status",
+      "  /research on|off      Enable/disable Google Search + URL Context tools",
+      "  /embeddings on|off    Enable/disable semantic file search (Embeddings API)",
+      "  /caps                 View all capability flags",
+      "  /caps <research|embeddings|all|reset>  Bulk capability control",
+      "  /memory               Show persistent memory status",
+      "  /memory on|off        Enable/disable session memory",
+      "",
+      "  Thinking:",
       "  /thinking             Show current thinking config",
       "  /thinking verbose     Show full thinking text each turn",
       "  /thinking brief       Show collapsed one-line excerpt (default)",
@@ -183,9 +205,14 @@ def slash_help_lines() -> list[str]:
       "  /thinking on          Re-enable thinking (auto budget/level)",
       "  /thinking budget <N>  Set thinking token budget (Gemini 2.5, 0=off, -1=dynamic)",
       "  /thinking level <L>   Set thinking level: minimal|low|medium|high (Gemini 3.x)",
+      "",
+      "  Limits:",
+      "  /limits               Show all execution limits",
+      "  /limits calls <N>     Set max LLM calls per turn",
+      "  /budget               Show per-turn token budget",
+      "  /budget <N>|off       Set or clear per-turn token budget",
+      "",
+      "  Other:",
       "  /permissions          Show permission / HITL settings",
-      "  /memory               Show persistent memory settings",
       "  /hooks                Show post-turn hook configuration",
-      "  /version              Print GemCode version hint",
-      "  /exit                 Exit the REPL",
   ]