gemcode 0.3.65__py3-none-any.whl → 0.3.67__py3-none-any.whl

gemcode/agent.py

@@ -462,6 +462,14 @@ key_combination(["control+c"])  # copy
 
 
 def build_instruction(cfg: GemCodeConfig) -> str:
+  import os as _os
+  verbose_tools_guide = _os.environ.get("GEMCODE_VERBOSE_INSTRUCTIONS", "").lower() in (
+    "1",
+    "true",
+    "yes",
+    "on",
+  )
+
   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.
 
@@ -509,6 +517,21 @@ You have native deep thinking capability — use it actively:
 - When something fails, diagnose (re-read the error, check assumptions) before switching strategy. Do not repeat the same failed call.
 - When asked to analyse or explain something: read the actual files, produce concrete findings, not hypotheses.
 
+## Token efficiency without losing intelligence
+- Prefer **small, targeted tool outputs** by default (saves context, improves accuracy).
+- If a tool output was **offloaded** (you see a `tool_result:<sha>` reference), and you need details, call `load_tool_result(ref)` and extract only the relevant slice.
+
+## Tool selection guide (only when needed)
+
+Keep tool usage minimal. Prefer short, targeted calls and keep tool outputs small.
+If you need more tool usage examples, set `GEMCODE_VERBOSE_INSTRUCTIONS=1`.
+
+"""
+
+  if not verbose_tools_guide:
+    return base.strip() + "\n"
+
+  tool_guide = r"""
 ## Tool selection guide
 
 ### Shell execution (critical — use these for real work)
@@ -864,6 +887,7 @@ def build_root_agent(
             pre-built list that excludes run_subtask itself, preventing recursion).
             When set, build_function_tools() is NOT called.
   """
+  return (base + tool_guide).strip() + "\n"
   if _tools is not None:
     tools = list(_tools)
   else:

gemcode/callbacks.py

@@ -311,20 +311,50 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     tool_response: dict,
   ) -> dict | None:
     truncated = False
-    if isinstance(tool_response, dict) and getattr(cfg, "tool_result_max_chars", 0) > 0:
+    offloaded = False
+    name = getattr(tool, "name", None) or ""
+
+    # Offload oversized tool outputs to disk (stable refs) before truncation.
+    # Dynamic caps for tool inline payload size.
+    effective_tool_chars = int(getattr(cfg, "tool_result_max_chars", 0) or 0)
+    try:
+      from gemcode.dynamic_policy import get_dynamic_caps
+      effective_tool_chars = get_dynamic_caps(cfg).tool_inline_chars
+    except Exception:
+      pass
+
+    if (
+      isinstance(tool_response, dict)
+      and getattr(cfg, "tool_result_offload_enabled", False)
+      and effective_tool_chars > 0
+    ):
+      try:
+        from gemcode.tool_result_store import maybe_offload_tool_result
+        new_payload, did = maybe_offload_tool_result(
+          project_root=cfg.project_root,
+          tool_name=name,
+          payload=tool_response,
+          max_inline_chars=int(effective_tool_chars),
+        )
+        if did and isinstance(new_payload, dict):
+          tool_response = new_payload
+          offloaded = True
+      except Exception:
+        pass
+
+    if isinstance(tool_response, dict) and effective_tool_chars > 0:
       new_d, did = truncate_tool_result_dict(
-          tool_response, int(cfg.tool_result_max_chars)
+          tool_response, int(effective_tool_chars)
       )
       if did:
         tool_response = new_d
         truncated = True
-    name = getattr(tool, "name", None) or ""
     if tool_context is None:
-      return tool_response if truncated else None
+      return tool_response if (truncated or offloaded) else None
     try:
       st = tool_context.state
     except Exception:
-      return tool_response if truncated else None
+      return tool_response if (truncated or offloaded) else None
     err = isinstance(tool_response, dict) and tool_response.get("error")
     err_kind = (
       isinstance(tool_response, dict) and tool_response.get("error_kind")
@@ -409,6 +439,8 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         pass
     if truncated:
       return tool_response
+    if offloaded:
+      return tool_response
     return None
 
   return after_tool
@@ -508,6 +540,14 @@ def make_after_model_callback(cfg: GemCodeConfig):
         st[_LAST_PROMPT_TOKENS] = pt
         st[_LAST_CONTEXT_PCT] = cw.get("percent_left")
         st[_LAST_CONTEXT_LEVEL] = level
+        # Expose to tool layer (dynamic token policy).
+        try:
+          pct = cw.get("percent_left")
+          if isinstance(pct, int):
+            object.__setattr__(cfg, "_context_percent_left", pct)
+          object.__setattr__(cfg, "_context_alert_level", int(level))
+        except Exception:
+          pass
         append_audit(
             cfg.project_root,
             {

gemcode/config.py

@@ -130,6 +130,19 @@ class GemCodeConfig:
         int(os.environ.get("GEMCODE_TOOL_RESULT_MAX_CHARS", "12000")),
     )
   )
+
+  # When enabled, oversized tool outputs are offloaded to disk under
+  # .gemcode/tool-results/ and replaced in history with stable refs + previews.
+  # This reduces context bloat and improves prompt-cache stability.
+  tool_result_offload_enabled: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_TOOL_RESULT_OFFLOAD", default=True)
+  )
+
+  # Dynamic token policy: adapt tool output caps to context pressure so we stay
+  # cheap when context is tight, but remain evidence-rich when there's room.
+  dynamic_token_policy: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_DYNAMIC_TOKEN_POLICY", default=True)
+  )
   # Trim oldest text in llm_request.contents when over budget (see context_budget.py).
   context_shrink_enabled: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_CONTEXT_SHRINK", default=True)

gemcode/dynamic_policy.py

@@ -0,0 +1,117 @@
+"""
+Dynamic token budgeting / caps.
+
+Optimization must not make the agent dumb:
+- When context pressure is low, allow richer tool outputs and wider reads.
+- When context pressure is high, tighten caps and offload aggressively.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+def _truthy(v: Any, *, default: bool = False) -> bool:
+  if v is None:
+    return default
+  if isinstance(v, bool):
+    return v
+  if isinstance(v, str):
+    return v.lower() in ("1", "true", "yes", "on")
+  return bool(v)
+
+
+def _pct_left(cfg) -> int | None:
+  try:
+    v = getattr(cfg, "_context_percent_left", None)
+    if isinstance(v, int):
+      return v
+  except Exception:
+    return None
+  return None
+
+
+@dataclass(frozen=True)
+class DynamicCaps:
+  tool_inline_chars: int
+  read_file_max_bytes: int
+  web_fetch_max_chars: int
+  bash_stdout_chars: int
+  bash_stderr_chars: int
+  run_stdout_chars: int
+  run_stderr_chars: int
+  grep_max_matches: int
+
+
+def get_dynamic_caps(cfg) -> DynamicCaps:
+  """
+  Compute caps based on current context pressure.
+
+  Policy:
+  - Healthy (>=45% left): generous caps (better evidence, less re-asking).
+  - Warning (20-44%): moderate caps.
+  - Tight (<20%): strict caps + prefer offload.
+  """
+  # cfg can be None in some tool contexts; treat as enabled with defaults.
+  enabled = _truthy(getattr(cfg, "dynamic_token_policy", True) if cfg is not None else True, default=True)
+  if not enabled:
+    # Essentially "no-op" high caps; tools still apply their explicit maxes.
+    return DynamicCaps(
+      tool_inline_chars=int(getattr(cfg, "tool_result_max_chars", 12000) or 12000),
+      read_file_max_bytes=200_000,
+      web_fetch_max_chars=40_000,
+      bash_stdout_chars=80_000,
+      bash_stderr_chars=20_000,
+      run_stdout_chars=50_000,
+      run_stderr_chars=50_000,
+      grep_max_matches=80,
+    )
+
+  pct = _pct_left(cfg) if cfg is not None else None
+  if pct is None:
+    pct = 35
+
+  # Base knobs from config (so users can still tune globally).
+  base_tool = int(getattr(cfg, "tool_result_max_chars", 12000) or 12000) if cfg is not None else 12000
+  base_tool = max(1000, base_tool)
+
+  if pct >= 45:
+    mult = 1.4
+    return DynamicCaps(
+      tool_inline_chars=min(24_000, int(base_tool * mult)),
+      read_file_max_bytes=140_000,
+      web_fetch_max_chars=30_000,
+      bash_stdout_chars=30_000,
+      bash_stderr_chars=15_000,
+      run_stdout_chars=30_000,
+      run_stderr_chars=30_000,
+      grep_max_matches=60,
+    )
+
+  if pct >= 20:
+    mult = 1.0
+    return DynamicCaps(
+      tool_inline_chars=min(18_000, int(base_tool * mult)),
+      read_file_max_bytes=80_000,
+      web_fetch_max_chars=20_000,
+      bash_stdout_chars=20_000,
+      bash_stderr_chars=10_000,
+      run_stdout_chars=20_000,
+      run_stderr_chars=20_000,
+      grep_max_matches=40,
+    )
+
+  # Tight
+  mult = 0.6
+  return DynamicCaps(
+    tool_inline_chars=max(2000, int(base_tool * mult)),
+    read_file_max_bytes=35_000,
+    web_fetch_max_chars=10_000,
+    bash_stdout_chars=10_000,
+    bash_stderr_chars=8_000,
+    run_stdout_chars=10_000,
+    run_stderr_chars=10_000,
+    grep_max_matches=20,
+  )
+

gemcode/memory/embedding_memory_service.py

@@ -54,6 +54,28 @@ def _concat_text(content: Any) -> str:
   return "\n".join(pieces)
 
 
+def _distill_memory_text(text: str, *, max_chars: int = 1200) -> str:
+  t = (text or "").strip()
+  if not t:
+    return ""
+  t = t[:50_000]
+  lines = [ln.strip() for ln in t.splitlines() if ln.strip()]
+  keep: list[str] = []
+  for ln in lines:
+    if any(x in ln for x in (".py", ".ts", ".tsx", ".js", ".json", ".yml", ".yaml", "src/", "gemcode/")):
+      keep.append(ln)
+    elif ln.startswith(("-", "*")) and len(ln) <= 200:
+      keep.append(ln)
+    elif any(k in ln.lower() for k in ("fix", "bug", "root cause", "decision", "constraint", "todo", "note")):
+      keep.append(ln)
+    if sum(len(x) + 1 for x in keep) >= max_chars:
+      break
+  if not keep:
+    return t[:max_chars]
+  out = "\n".join(keep)
+  return out[:max_chars]
+
+
 def _cosine_similarity(a: list[float], b: list[float]) -> float:
   if not a or not b or len(a) != len(b):
     return -1.0
@@ -166,6 +188,9 @@ class EmbeddingFileMemoryService(BaseMemoryService):
       text = _concat_text(content)
       if not text.strip():
         continue
+      distilled = _distill_memory_text(text)
+      if not distilled.strip():
+        continue
 
       ev_id = getattr(ev, "id", None)
       if not isinstance(ev_id, str) or not ev_id:
@@ -176,7 +201,7 @@ class EmbeddingFileMemoryService(BaseMemoryService):
       ts = getattr(ev, "timestamp", None)
       ts_out = ts if isinstance(ts, str) else None
 
-      truncated = text[: self.embedding_max_chars]
+      truncated = distilled[: self.embedding_max_chars]
       rec: dict[str, Any] = {
         "id": ev_id,
         "app_name": app_name,
@@ -184,7 +209,8 @@ class EmbeddingFileMemoryService(BaseMemoryService):
         "session_id": session_id,
         "author": author if isinstance(author, str) else None,
         "timestamp": ts_out,
-        "text": text,
+        "text": distilled,
+        "raw_truncated": text[:4000],
         "embedding_text": truncated,
         "embedding": None,
       }

gemcode/memory/file_memory_service.py

@@ -49,6 +49,37 @@ def _concat_text(content: Any) -> str:
   return "\n".join(pieces)
 
 
+def _distill_memory_text(text: str, *, max_chars: int = 1200) -> str:
+  """
+  Distill verbose conversational text into a compact memory payload.
+
+  This is deliberately non-LLM (fast, deterministic) and focuses on:
+  - explicit decisions / constraints
+  - paths / symbols / commands
+  - short summaries
+  """
+  t = (text or "").strip()
+  if not t:
+    return ""
+  # Keep only the first N chars; then try to keep high-signal lines.
+  t = t[:50_000]
+  lines = [ln.strip() for ln in t.splitlines() if ln.strip()]
+  keep: list[str] = []
+  for ln in lines:
+    if any(x in ln for x in (".py", ".ts", ".tsx", ".js", ".json", ".yml", ".yaml", "src/", "gemcode/")):
+      keep.append(ln)
+    elif ln.startswith(("-", "*")) and len(ln) <= 200:
+      keep.append(ln)
+    elif any(k in ln.lower() for k in ("fix", "bug", "root cause", "decision", "constraint", "todo", "note")):
+      keep.append(ln)
+    if sum(len(x) + 1 for x in keep) >= max_chars:
+      break
+  if not keep:
+    return t[:max_chars]
+  out = "\n".join(keep)
+  return out[:max_chars]
+
+
 class FileMemoryService(BaseMemoryService):
   """JSONL-backed memory service with naive keyword matching."""
 
@@ -108,6 +139,9 @@ class FileMemoryService(BaseMemoryService):
       text = _concat_text(content)
       if not text.strip():
         continue
+      distilled = _distill_memory_text(text)
+      if not distilled.strip():
+        continue
 
       ev_id = getattr(ev, "id", None)
       if not isinstance(ev_id, str) or not ev_id:
@@ -127,7 +161,8 @@ class FileMemoryService(BaseMemoryService):
           "session_id": session_id,
           "author": author,
           "timestamp": ts_out,
-          "text": text,
+          "text": distilled,
+          "raw_truncated": text[:4000],
         }
       )
       existing_ids.add(ev_id)

gemcode/tool_result_store.py

@@ -0,0 +1,162 @@
+"""
+Disk-backed storage for oversized tool outputs.
+
+Why:
+- Large tool outputs (stdout, file contents, web pages) are the biggest driver of
+  context bloat and cache misses in long agent sessions.
+- Instead of truncating blobs inline (which still mutates history repeatedly),
+  we store the full payload on disk and replace it with a stable reference +
+  short preview. This matches OpenClaude's "tool result storage" pattern.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+_REF_PREFIX = "tool_result:"
+
+
+def _store_dir(project_root: Path) -> Path:
+  d = project_root / ".gemcode" / "tool-results"
+  d.mkdir(parents=True, exist_ok=True)
+  return d
+
+
+def _sha256_bytes(b: bytes) -> str:
+  h = hashlib.sha256()
+  h.update(b)
+  return h.hexdigest()
+
+
+def _preview(text: str, max_chars: int) -> str:
+  if max_chars <= 0:
+    return ""
+  if len(text) <= max_chars:
+    return text
+  if max_chars <= 40:
+    return text[:max_chars]
+  return text[: max_chars - 20] + "\n… [offloaded; preview truncated]\n"
+
+
+def offload_text(
+  *,
+  project_root: Path,
+  tool_name: str,
+  field: str,
+  text: str,
+  preview_max_chars: int,
+) -> dict[str, Any]:
+  """
+  Persist `text` to disk and return a compact reference dict.
+
+  The ref is content-addressed (sha256 of bytes) so repeated identical outputs
+  map to the same ref, improving cache stability.
+  """
+  b = text.encode("utf-8", errors="replace")
+  sha = _sha256_bytes(b)
+  ref = f"{_REF_PREFIX}{sha}"
+  p = _store_dir(project_root) / f"{sha}.txt"
+  if not p.exists():
+    # Write once; keep deterministic content for stable cache behavior.
+    p.write_bytes(b)
+    meta = {
+      "ref": ref,
+      "sha256": sha,
+      "tool": tool_name,
+      "field": field,
+      "bytes": len(b),
+      "chars": len(text),
+      "created_at": int(time.time()),
+    }
+    ( _store_dir(project_root) / f"{sha}.json" ).write_text(
+      json.dumps(meta, ensure_ascii=False, indent=2),
+      encoding="utf-8",
+      errors="replace",
+    )
+  return {
+    "offloaded": True,
+    "ref": ref,
+    "preview": _preview(text, preview_max_chars),
+    "chars": len(text),
+    "hint": "Use load_tool_result(ref) to view the full content.",
+  }
+
+
+def maybe_offload_tool_result(
+  *,
+  project_root: Path,
+  tool_name: str,
+  payload: Any,
+  max_inline_chars: int,
+) -> tuple[Any, bool]:
+  """
+  Walk a tool-result payload and offload large text fields.
+
+  Returns (new_payload, changed).
+  """
+  if max_inline_chars <= 0:
+    return payload, False
+
+  changed = False
+
+  def _walk(obj: Any, *, field: str) -> Any:
+    nonlocal changed
+    if isinstance(obj, str) and len(obj) > max_inline_chars:
+      changed = True
+      return offload_text(
+        project_root=project_root,
+        tool_name=tool_name,
+        field=field,
+        text=obj,
+        preview_max_chars=max_inline_chars,
+      )
+
+    if isinstance(obj, list):
+      out_list: list[Any] = []
+      for i, item in enumerate(obj):
+        out_list.append(_walk(item, field=f"{field}[{i}]"))
+      if out_list != obj:
+        changed = True
+      return out_list
+
+    if isinstance(obj, dict):
+      out_dict: dict[str, Any] = {}
+      for k, v in obj.items():
+        out_dict[k] = _walk(v, field=str(k))
+      if out_dict != obj:
+        changed = True
+      return out_dict
+
+    return obj
+
+  # Only dict payloads are expected from our tools, but handle any.
+  return _walk(payload, field="payload"), changed
+
+
+def load_tool_result_text(
+  *,
+  project_root: Path,
+  ref: str,
+  max_chars: int = 40_000,
+  tail: bool = True,
+) -> dict[str, Any]:
+  if not isinstance(ref, str) or not ref.startswith(_REF_PREFIX):
+    return {"error": "Invalid ref. Expected 'tool_result:<sha256>'."}
+  sha = ref[len(_REF_PREFIX) :].strip()
+  if not sha or any(c not in "0123456789abcdef" for c in sha) or len(sha) < 32:
+    return {"error": "Invalid ref sha."}
+  p = _store_dir(project_root) / f"{sha}.txt"
+  if not p.exists():
+    return {"error": f"Not found: {ref}"}
+  text = p.read_text(encoding="utf-8", errors="replace")
+  truncated = False
+  if max_chars is not None and isinstance(max_chars, int) and max_chars > 0:
+    if len(text) > max_chars:
+      truncated = True
+      text = ("… [truncated; showing tail]\n" + text[-max_chars:]) if tail else (text[:max_chars] + "\n… [truncated]")
+  return {"ref": ref, "text": text, "truncated": truncated, "chars": len(text)}
+

gemcode/tools/__init__.py

@@ -7,6 +7,7 @@ from gemcode.tools.bash import make_bash_tool
 from gemcode.tools.edit import make_edit_tools
 from gemcode.tools.filesystem import make_filesystem_tools
 from gemcode.tools.notebook import make_notebook_tools
+from gemcode.tools.repo_map import make_repo_map_tool
 from gemcode.tools.search import make_grep_tool
 from gemcode.tools.shell import make_run_command
 from gemcode.tools.subtask import make_run_subtask_tool
@@ -31,6 +32,26 @@ def _get_load_memory_tool():
     return None
 
 
+def _make_load_tool_result_tool(cfg: GemCodeConfig):
+  def load_tool_result(ref: str, max_chars: int = 40_000, tail: bool = True) -> dict:
+    """
+    Load a previously offloaded tool output by reference.
+
+    Offloaded outputs are created automatically when GEMCODE_TOOL_RESULT_OFFLOAD=1.
+    References look like: tool_result:<sha256>.
+    """
+    from gemcode.tool_result_store import load_tool_result_text
+
+    return load_tool_result_text(
+      project_root=cfg.project_root,
+      ref=ref,
+      max_chars=max_chars,
+      tail=tail,
+    )
+
+  return load_tool_result
+
+
 def _wrap_long_running(fn):
   """
   Wrap a function tool with ADK's LongRunningFunctionTool so that long-running
@@ -60,6 +81,14 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
   web_search = make_web_search_tool()
   notebook_read, notebook_edit = make_notebook_tools(cfg)
   list_tasks, kill_task, task_output = make_task_tools(cfg)
+  load_tool_result = _make_load_tool_result_tool(cfg)
+  repo_map = make_repo_map_tool(cfg)
+
+  # Attach cfg for dynamic policy inside web_fetch (no cfg param in signature).
+  try:
+    setattr(web_fetch, "_cfg", cfg)
+  except Exception:
+    pass
 
   # bash and run_command are the most common long-running tools (builds, tests,
   # installs). Wrap them with LongRunningFunctionTool so ADK can handle slow
@@ -77,6 +106,7 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
     list_directory,
     glob_files,
     grep_content,
+    repo_map,
     # Notebooks
     notebook_read,
     notebook_edit,
@@ -95,6 +125,8 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
     # Web / research
     web_search,
     web_fetch,
+    # Tool output offload loader
+    load_tool_result,
   ]
 
   # ADK load_memory: explicit on-demand memory search (complements preload_memory).

gemcode/tools/bash.py

@@ -182,8 +182,21 @@ def make_bash_tool(cfg: GemCodeConfig):
                 env=env,
                 check=False,
             )
-            stdout = proc.stdout[:80_000]
-            stderr = proc.stderr[:20_000]
+            try:
+                from gemcode.dynamic_policy import get_dynamic_caps
+                caps = get_dynamic_caps(cfg)
+                stdout_cap = caps.bash_stdout_chars
+                stderr_cap = caps.bash_stderr_chars
+            except Exception:
+                stdout_cap = 20_000
+                stderr_cap = 10_000
+
+            # Keep more stderr when failing; it is usually the most informative.
+            if proc.returncode != 0:
+                stderr_cap = max(stderr_cap, 12_000)
+
+            stdout = proc.stdout[:stdout_cap]
+            stderr = proc.stderr[:stderr_cap]
             result: dict = {
                 "command": command,
                 "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",

gemcode/tools/filesystem.py

@@ -16,7 +16,7 @@ def make_filesystem_tools(cfg: GemCodeConfig):
 
   def read_file(
     path: str,
-    max_bytes: int = 200_000,
+    max_bytes: int = 80_000,
     start_line: int = 1,
     end_line: int | None = None,
   ) -> dict:
@@ -43,6 +43,15 @@ def make_filesystem_tools(cfg: GemCodeConfig):
       return {"error": str(e)}
     if not p.is_file():
       return {"error": f"Not a file: {path}"}
+
+    # Dynamic caps: allow bigger reads when context is healthy, tighten when tight.
+    try:
+      from gemcode.dynamic_policy import get_dynamic_caps
+      caps = get_dynamic_caps(cfg)
+      if isinstance(max_bytes, int) and max_bytes > caps.read_file_max_bytes:
+        max_bytes = caps.read_file_max_bytes
+    except Exception:
+      pass
     total_bytes = p.stat().st_size
     data = p.read_bytes()
     text_full = data.decode("utf-8", errors="replace")

gemcode/tools/repo_map.py

@@ -0,0 +1,132 @@
+"""
+Repo map tool: lightweight symbol-first context for large repos.
+
+Inspired by Aider's "repo map" approach: provide a compact overview (files +
+top-level symbols) under a strict token/char budget, then read specific files
+on demand.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from gemcode.config import GemCodeConfig
+from gemcode.paths import PathEscapeError, resolve_under_root
+from gemcode.trust import is_trusted_root
+
+
+_PY_DEF = re.compile(r"^\s*(def|class)\s+([A-Za-z_][A-Za-z0-9_]*)")
+_TS_DEF = re.compile(
+  r"^\s*(export\s+)?(async\s+)?(function|class|interface|type)\s+([A-Za-z_][A-Za-z0-9_]*)"
+)
+
+
+def _iter_files(root: Path, include_glob: str) -> list[Path]:
+  out: list[Path] = []
+  for p in root.glob(include_glob):
+    if not p.is_file():
+      continue
+    if "/.git/" in str(p):
+      continue
+    # Skip huge files; repo_map is meant to be cheap.
+    try:
+      if p.stat().st_size > 300_000:
+        continue
+    except OSError:
+      continue
+    out.append(p)
+    if len(out) >= 800:
+      break
+  return out
+
+
+def _symbols_for_file(p: Path, *, max_lines: int = 400) -> list[str]:
+  try:
+    text = p.read_text(encoding="utf-8", errors="ignore")
+  except OSError:
+    return []
+  lines = text.splitlines()[:max_lines]
+  syms: list[str] = []
+  for ln in lines:
+    m = _PY_DEF.match(ln)
+    if m:
+      syms.append(f"{m.group(1)} {m.group(2)}")
+      continue
+    m2 = _TS_DEF.match(ln)
+    if m2:
+      syms.append(f"{m2.group(3)} {m2.group(4)}")
+  # Deduplicate while preserving order
+  seen: set[str] = set()
+  out: list[str] = []
+  for s in syms:
+    if s in seen:
+      continue
+    seen.add(s)
+    out.append(s)
+    if len(out) >= 40:
+      break
+  return out
+
+
+def make_repo_map_tool(cfg: GemCodeConfig):
+  root = cfg.project_root
+  trusted = is_trusted_root(root)
+
+  def repo_map(
+    path: str = ".",
+    include_glob: str = "**/*.{py,ts,tsx,js,jsx,md,txt,json,yml,yaml}",
+    max_chars: int = 18_000,
+    max_files: int = 200,
+    include_symbols: bool = True,
+  ) -> dict[str, Any]:
+    """
+    Return a compact overview of a repo subtree under a strict char budget.
+
+    Best for: large codebases where sending many full files is expensive.
+    Use this, then `read_file` for specific files.
+    """
+    if not trusted:
+      return {"error": "Project folder is not trusted. Re-run GemCode and approve folder trust."}
+    try:
+      base = resolve_under_root(root, path)
+    except PathEscapeError as e:
+      return {"error": str(e)}
+    if not base.is_dir():
+      return {"error": f"Not a directory: {path}"}
+
+    files = _iter_files(base, include_glob)
+    # Make paths relative to project root for stable references
+    rels: list[str] = []
+    for p in files:
+      try:
+        rels.append(str(p.resolve().relative_to(root)))
+      except ValueError:
+        continue
+      if len(rels) >= max_files:
+        break
+
+    # Build a char-budgeted map string.
+    lines: list[str] = []
+    lines.append(f"Repo map for: {path} (files={len(rels)})")
+    lines.append("")
+    for rel in rels:
+      if sum(len(x) + 1 for x in lines) >= max_chars:
+        break
+      lines.append(rel)
+      if include_symbols and rel.endswith((".py", ".ts", ".tsx", ".js", ".jsx")):
+        sym = _symbols_for_file(root / rel)
+        for s in sym:
+          if sum(len(x) + 1 for x in lines) >= max_chars:
+            break
+          lines.append(f"  - {s}")
+
+    out = "\n".join(lines)
+    truncated = len(out) > max_chars
+    if truncated:
+      out = out[:max_chars] + "\n… [truncated]"
+    return {"path": path, "map": out, "truncated": truncated}
+
+  return repo_map
+

gemcode/tools/search.py

@@ -33,7 +33,7 @@ def make_grep_tool(cfg: GemCodeConfig):
     def grep_content(
         pattern: str,
         path_glob: str = "**/*",
-        max_matches: int = 80,
+        max_matches: int = 40,
         context_lines: int = 0,
         case_sensitive: bool = True,
     ) -> dict:
@@ -61,6 +61,15 @@ def make_grep_tool(cfg: GemCodeConfig):
         Issue multiple grep_content calls in the same turn when searching for
         different patterns — they run in parallel.
         """
+        # Dynamic caps: allow richer search when context is healthy.
+        try:
+            from gemcode.dynamic_policy import get_dynamic_caps
+            caps = get_dynamic_caps(cfg)
+            if isinstance(max_matches, int) and max_matches > caps.grep_max_matches:
+                max_matches = caps.grep_max_matches
+        except Exception:
+            pass
+
         if max_matches < 1:
             max_matches = 1
         if max_matches > 500:

gemcode/tools/shell.py

@@ -157,12 +157,20 @@ def make_run_command(cfg: GemCodeConfig):
           env=child_env,
           check=False,
       )
+      try:
+        from gemcode.dynamic_policy import get_dynamic_caps
+        caps = get_dynamic_caps(cfg)
+        out_cap = caps.run_stdout_chars
+        err_cap = caps.run_stderr_chars
+      except Exception:
+        out_cap = 20_000
+        err_cap = 20_000
       return {
           "command": [exe, *args],
           "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",
           "exit_code": proc.returncode,
-          "stdout": proc.stdout[:50_000],
-          "stderr": proc.stderr[:50_000],
+          "stdout": proc.stdout[:out_cap],
+          "stderr": proc.stderr[:err_cap],
       }
     except subprocess.TimeoutExpired:
       return {"error": f"Timeout after {timeout_seconds}s"}

gemcode/tools/subtask.py

@@ -153,9 +153,24 @@ def make_run_subtask_tool(cfg: GemCodeConfig):
         sub_session_id = str(uuid.uuid4())
 
         # Compose the sub-agent prompt.
-        prompt = task.strip()
-        if context and context.strip():
-            prompt = f"{task.strip()}\n\nAdditional context:\n{context.strip()}"
+        task_clean = task.strip()
+        ctx_clean = (context or "").strip()
+        prompt = task_clean
+        if ctx_clean:
+            prompt = f"{task_clean}\n\nAdditional context:\n{ctx_clean}"
+
+        # Enforce a compact response contract to protect the parent context.
+        prompt = (
+            "Return a concise result using this exact structure:\n"
+            "## Summary\n"
+            "- <3-7 bullets>\n\n"
+            "## Findings\n"
+            "- <key technical findings>\n\n"
+            "## Evidence (paths / commands)\n"
+            "- <file paths, symbols, or commands you used>\n\n"
+            "Do NOT include long code blocks or raw logs. If something is long, summarize it.\n\n"
+            + prompt
+        )
 
         # Sub-agents get a higher cap than before (64 vs 48) since they now
         # carry a richer tool surface (research, notes, etc.)
@@ -197,6 +212,28 @@ def make_run_subtask_tool(cfg: GemCodeConfig):
                 "that asks the sub-agent to summarise its findings.)"
             )
 
+        # Hard-cap sub-agent output; offload the full text if it exceeds the cap.
+        max_chars = 8_000
+        if len(result_text) > max_chars:
+            try:
+                from gemcode.tool_result_store import offload_text
+                ref_obj = offload_text(
+                    project_root=cfg.project_root,
+                    tool_name="run_subtask",
+                    field="result",
+                    text=result_text,
+                    preview_max_chars=max_chars,
+                )
+                return {
+                    "result": ref_obj.get("preview", "") or "",
+                    "offloaded": True,
+                    "ref": ref_obj.get("ref"),
+                    "note": "Subtask output was long; full text offloaded. Use load_tool_result(ref).",
+                }
+            except Exception:
+                result_text = result_text[:max_chars] + "\n… [truncated]"
+                return {"result": result_text, "truncated": True}
+
         return {"result": result_text}
 
     return run_subtask

gemcode/tools/web.py

@@ -53,7 +53,7 @@ def _html_to_text(html: str) -> str:
 
 
 def make_web_fetch_tool():
-    def web_fetch(url: str, max_chars: int = 40_000, raw: bool = False) -> dict:
+    def web_fetch(url: str, max_chars: int = 20_000, raw: bool = False) -> dict:
         """
         Fetch content from a URL and return it as text.
 
@@ -64,13 +64,25 @@ def make_web_fetch_tool():
         - Reading READMEs, changelogs, or issue trackers online
 
         Set raw=True to get the raw HTML/JSON instead of extracted text.
-        max_chars caps the returned content (default 40 000 chars).
+        max_chars caps the returned content (default 20 000 chars).
         """
         if not url or not url.strip():
             return {"error": "url must not be empty"}
         url = url.strip()
         if not url.startswith(("http://", "https://")):
             return {"error": "Only http:// and https:// URLs are supported"}
+        try:
+            from gemcode.dynamic_policy import get_dynamic_caps
+            caps = get_dynamic_caps(getattr(web_fetch, "_cfg", None) or None)  # type: ignore[arg-type]
+        except Exception:
+            caps = None
+        try:
+            # make_web_fetch_tool() has no cfg, so we attach one in the builder.
+            # If present, apply the dynamic cap.
+            if caps is not None and max_chars > getattr(caps, "web_fetch_max_chars", 20_000):
+                max_chars = int(getattr(caps, "web_fetch_max_chars", 20_000))
+        except Exception:
+            pass
         if max_chars < 1000:
             max_chars = 1000
         if max_chars > 200_000:

{gemcode-0.3.65.dist-info → gemcode-0.3.67.dist-info}/METADATA

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

{gemcode-0.3.65.dist-info → gemcode-0.3.67.dist-info}/RECORD

@@ -1,16 +1,17 @@
 gemcode/__init__.py,sha256=l0DCRYqK7KM7Fb7u49fqh-5_SlpeIL7r3LjMeJWMgSg,112
 gemcode/__main__.py,sha256=EX2s1hxq2Yvli_-tnBN3w5Qv4bOjsBBbjyISF0pDIQw,37
-gemcode/agent.py,sha256=Yrali2aW95nq6jCBTrs5j_5kH5X4923YUkJn9h6sa8k,51236
+gemcode/agent.py,sha256=yft-8lLJbX4abM_bUW156JWfVT3b4OHO-_hIoKdVaOs,52032
 gemcode/audit.py,sha256=bh9uhXaeh8wqxqoZtz3ZAowd8Ndk1ss-mw9993Vlrgo,469
 gemcode/autocompact.py,sha256=77h5tgFzJ2rjrhlCL2oIc28IHwLbP4Pqlo7cSNgDwiA,6727
-gemcode/callbacks.py,sha256=VSxV9EbjkrF8fguiEPfKrO0JZ5LvfclMEAQuuV1ZFCE,24800
+gemcode/callbacks.py,sha256=7kPMDsc2vvY98Ogoi4D0XHB96qh_kx4l4CRsRtePNdk,26171
 gemcode/capability_routing.py,sha256=yvQXwKtrfHXbgbNunU0Dxh9GCDN4cbySXIeccrdzr2o,3471
 gemcode/cli.py,sha256=kBXb4b4JCG3u0XewCJn8lCyOT62Y8bOvlVoDc2R-GKQ,25320
 gemcode/compaction.py,sha256=9YtA_qa23_8dHWVHx7AJwUduuI7jJQtq-m6sT8jgPWI,1186
-gemcode/config.py,sha256=nygtUWCo0iBocXFHq8mpQC-BRvtYg5F0ChlmkgC6R0g,14059
+gemcode/config.py,sha256=bCo_Qz4oI_Sfi0EzptULCjfTbtYNhHtMeXTil2vUi8M,14697
 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/dynamic_policy.py,sha256=0ZYv3nzMsEN4kPpjhMbXVSMoTvA_IArbMfe3fF7hhzw,3158
 gemcode/hitl_session.py,sha256=oNiI7odFJGUcmqPavjKLJOEumZKrgklLvwjjrIG9GPg,281
 gemcode/hooks.py,sha256=FHz175d_18j-4ByZZVdEIagmdOvLHcjDjo7HD2Cikf4,6339
 gemcode/intent_classifier.py,sha256=YfRVEe8gHeKlRkjuSWef1bZ0MPBwyYMp5jymP5Vig5U,8507
@@ -39,6 +40,7 @@ gemcode/slash_commands.py,sha256=Qylzsj1notk0xN_hvd3CR4HD8g-l99UENDMcg1pKeBA,794
 gemcode/thinking.py,sha256=RanBf_x9fKv1o4DNyNXPLfOdn2xT0KybJb65nYgmMEE,4885
 gemcode/tool_prompt_manifest.py,sha256=MS_eSJg2BTp6yv1Ih2p93okPmnK3B2dYAMjnG6yaEVY,8695
 gemcode/tool_registry.py,sha256=ifqxtr2uLwEUwnJLKYLza_tIz-paaZediJa75y9MiyA,1795
+gemcode/tool_result_store.py,sha256=Wfm_JHLdYAI4jfjTLHOEAeK2yho9OCLUF_qErhj-wV0,4428
 gemcode/tools_inspector.py,sha256=okmu4PDYAQQ7nthDvuzSHmy2zArFTG4ftIPRadzLnxA,4100
 gemcode/trust.py,sha256=fxe57Xg6aL_KU24bQDUtD-rXjsNpaq7g-eQTInZnudE,1336
 gemcode/version.py,sha256=uwynYS-RmK8CDoqGtt8976kFkJv0zELkEAlwebnp_io,380
@@ -47,8 +49,8 @@ gemcode/workspace_hints.py,sha256=WQFwyoGnVrzzYSl0s5MNcd1-UP11Ao8KGgrdFIB5m9g,62
 gemcode/computer_use/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gemcode/computer_use/browser_computer.py,sha256=bWXXgj7K6ZrDqT49iPEcnBd_ZJBwRxSgKhzKaJpn4cQ,13212
 gemcode/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gemcode/memory/embedding_memory_service.py,sha256=45mp4dDXMxdtafIq6LBPbFs5iij6lRnp4M9Zinvw9eY,8544
-gemcode/memory/file_memory_service.py,sha256=LLe-aRnEzyZ9FYPb4z_czwkR8D16ACwhCspbUc_BSM4,4909
+gemcode/memory/embedding_memory_service.py,sha256=4iMZUw80GY8SPrJcuT4CwOsTmZ600SOuYkm-nv2c634,9422
+gemcode/memory/file_memory_service.py,sha256=yAXCspfSPBfQXDrwPX8ZZsqaprnC_CKvgmN_GiQVzuo,6092
 gemcode/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gemcode/plugins/terminal_hooks_plugin.py,sha256=zxmWuEHyZ6-C7yhu27v9YJUI6ZZQaJJyP4JLMbX-7YA,5673
 gemcode/plugins/tool_recovery_plugin.py,sha256=N3nMDMuthwGJNqpV3tjXLdCYjUl9Dlwf-xtzZ5QkqZA,3876
@@ -59,21 +61,22 @@ gemcode/query/engine.py,sha256=GPuvUgTRpWmyA39I_3ayVEADlHVFhPrC2FGW_yKs2yw,1420
 gemcode/query/stop_hooks.py,sha256=jaXMN2OptwHeGXF8o630zIVr62T8jVg-eIyREG0GyxA,1847
 gemcode/query/token_budget.py,sha256=JTq2TrGkFY5t5KOs-P9XQPqahyjcdTzN3wctZ1JxFV0,2973
 gemcode/query/transitions.py,sha256=vJ77cv4cFwdvsxyGr7MxXz6uGVB5IDqOClqR1MkWvqw,933
-gemcode/tools/__init__.py,sha256=SiNU28a3wZ-022Mf1NeZGWs4N_0M_LRbkViV0OquoYg,3665
-gemcode/tools/bash.py,sha256=aW-sCrT1GJOcFEB-cKqImuInv9atWNeu5rTZqsVtB84,12248
+gemcode/tools/__init__.py,sha256=nSHcbts_cgAPGa2izrvczXJAHqtPjah8YhzbzERoGTI,4608
+gemcode/tools/bash.py,sha256=u9z7OI3iBGl5Df_GGipDsR8i3OcN59juw1hQHbO1PPk,12765
 gemcode/tools/browser.py,sha256=StWRttiyGkR4qaG5urRviJgdoj2hiFB2OuHPItaVzJY,7250
 gemcode/tools/edit.py,sha256=1fo-wlRT6fyuib0JnmUbPVG3cpjKNJsnmj9jxTgrZTs,3182
-gemcode/tools/filesystem.py,sha256=1taQpeGM4JlrjPdj56MIOCGbSQ0heYn969YmKG6QTi4,6124
+gemcode/tools/filesystem.py,sha256=LfdPcGciW4z1-fKgfwjQC7cvMlfCNymCNtGh8-vEdKc,6466
 gemcode/tools/notebook.py,sha256=zR-bVU6mniJYI9u2RUgm0BmnHmTc-TmEETzLBsXzueA,9197
 gemcode/tools/notes.py,sha256=7Rp7eJPANELDBKfwNPzi4pco_uP3GP07vNun9YJxOCw,4544
-gemcode/tools/search.py,sha256=SAK88xq-VvGD2ZmEZjipUPNA87ZmiNaen7uavprYHtc,5618
-gemcode/tools/shell.py,sha256=0F0MpUIC3zbbCmBfyQhNAKaEctlb-8ECH7ZK99pAsho,5403
+gemcode/tools/repo_map.py,sha256=hFjLcuZpJrlj08kJd2iXKIpTQRYAJQyaKPnuVNemZbQ,3650
+gemcode/tools/search.py,sha256=1I41K5galCa8hTHLZTc7OsFWGz0e92QsEyd7Jw6veUQ,5986
+gemcode/tools/shell.py,sha256=K9wstCKAasCxNTuu_s3w7yDZ_esXe-fgGH7UKcadOvc,5667
 gemcode/tools/shell_gate.py,sha256=8wLfdjBsfgH8PnMaEIjdJWMJMtvLMGjgP93lFMcbFqE,929
-gemcode/tools/subtask.py,sha256=qyMH-hYBgE7h-rs15ERHX2h2IxaXqQTc-SH2_UCc0XA,8500
+gemcode/tools/subtask.py,sha256=mmuVp7BazlZiJQk-sI72TmtSBq7omC4H43jQ-X8YJ3I,10070
 gemcode/tools/tasks.py,sha256=sPb9Ru0BBBcx_BMqLJBeOws6OR_-R0gyHAaotulsBBk,7657
 gemcode/tools/think.py,sha256=WrNATR-bi97aLkbSsOFOYYAGxbzihe9AnPDZfw3z5-Q,1704
 gemcode/tools/todo.py,sha256=jzhqu-lczlO0-576zZsv4rJqpxZi_Gx46JBLNGugt1w,5810
-gemcode/tools/web.py,sha256=ULg1e3inG4FjPSUCYI8dVBzTrcCHINNRo76SIU9qw-A,4489
+gemcode/tools/web.py,sha256=Oect8wEX6jOcrIESxb6k3NSHlMPyv4OoHupttjDuoJ4,5078
 gemcode/tools/web_search.py,sha256=oD6dXyvaalYlzZxiURETpUekpJBo3F3K5TYGx_wrrH0,8816
 gemcode/tui/input_handler.py,sha256=Off7hBXXqw7JxkKzlmtMHtg25Y9dkO275dC35brK-TE,10676
 gemcode/tui/scrollback.py,sha256=4_dKi_k43Pz7c-Kpm7pM35494piQiDL4ZZpuTdqwpdk,33079
@@ -83,9 +86,9 @@ gemcode/tui/welcome_rich.py,sha256=8FEZzLXrzqly5JWiDgV9ooRV1LNXDk-CXV1a7K6ua-U,4
 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.65.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
-gemcode-0.3.65.dist-info/METADATA,sha256=xSz_xChNe0HbpI1ThKlNNNbM1EvvLkRBo2t0-khUdGo,23695
-gemcode-0.3.65.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gemcode-0.3.65.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
-gemcode-0.3.65.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
-gemcode-0.3.65.dist-info/RECORD,,
+gemcode-0.3.67.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
+gemcode-0.3.67.dist-info/METADATA,sha256=rZb2AHzSETy2XUb5L5w88ECMQWXoQmNKhKOJ78SyGcs,23695
+gemcode-0.3.67.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gemcode-0.3.67.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
+gemcode-0.3.67.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
+gemcode-0.3.67.dist-info/RECORD,,