gemcode 0.3.65__tar.gz → 0.3.67__tar.gz

{gemcode-0.3.65/src/gemcode.egg-info → gemcode-0.3.67}/PKG-INFO

@@ -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 → gemcode-0.3.67}/pyproject.toml

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

{gemcode-0.3.65 → gemcode-0.3.67}/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.67/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.67/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.65 → gemcode-0.3.67}/src/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-0.3.65 → gemcode-0.3.67}/src/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")