gemcode 0.3.64__tar.gz → 0.3.66__tar.gz

{gemcode-0.3.64/src/gemcode.egg-info → gemcode-0.3.66}/PKG-INFO

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

{gemcode-0.3.64 → gemcode-0.3.66}/pyproject.toml

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

{gemcode-0.3.64 → gemcode-0.3.66}/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,17 @@ 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.
 
+## 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 +883,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.64 → gemcode-0.3.66}/src/gemcode/callbacks.py

@@ -311,6 +311,29 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     tool_response: dict,
   ) -> dict | None:
     truncated = False
+    offloaded = False
+    name = getattr(tool, "name", None) or ""
+
+    # Offload oversized tool outputs to disk (stable refs) before truncation.
+    if (
+      isinstance(tool_response, dict)
+      and getattr(cfg, "tool_result_offload_enabled", False)
+      and getattr(cfg, "tool_result_max_chars", 0) > 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(cfg.tool_result_max_chars),
+        )
+        if did and isinstance(new_payload, dict):
+          tool_response = new_payload
+          offloaded = True
+      except Exception:
+        pass
+
     if isinstance(tool_response, dict) and getattr(cfg, "tool_result_max_chars", 0) > 0:
       new_d, did = truncate_tool_result_dict(
           tool_response, int(cfg.tool_result_max_chars)
@@ -318,13 +341,12 @@ def make_after_tool_callback(cfg: GemCodeConfig):
       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 +431,8 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         pass
     if truncated:
       return tool_response
+    if offloaded:
+      return tool_response
     return None
 
   return after_tool

{gemcode-0.3.64 → gemcode-0.3.66}/src/gemcode/config.py

@@ -130,6 +130,13 @@ 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)
+  )
   # 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)
@@ -245,10 +252,10 @@ class GemCodeConfig:
   )
 
   # Controls how the TUI renders model thinking: True = full Rich Markdown,
-  # False = collapsed one-line excerpt (default, like OpenClaude).
+  # False = collapsed one-line excerpt.
   # Toggled at runtime via /thinking verbose|brief.
   show_full_thinking: bool = field(
-    default_factory=lambda: _truthy_env("GEMCODE_SHOW_FULL_THINKING", default=False)
+    default_factory=lambda: _truthy_env("GEMCODE_SHOW_FULL_THINKING", default=True)
   )
 
   # Enable ADK BuiltInCodeExecutor for safe sandboxed Python execution via

{gemcode-0.3.64 → gemcode-0.3.66}/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.64 → gemcode-0.3.66}/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.64 → gemcode-0.3.66}/src/gemcode/repl_commands.py

@@ -253,7 +253,7 @@ def slash_help_lines() -> list[str]:
       "  Thinking:",
       "  /thinking             Show current thinking config",
       "  /thinking verbose     Show full thinking text each turn",
-      "  /thinking brief       Show collapsed one-line excerpt (default)",
+      "  /thinking brief       Show collapsed one-line excerpt",
       "  /thinking off         Disable model thinking",
       "  /thinking on          Re-enable thinking (auto budget/level)",
       "  /thinking budget <N>  Set thinking token budget (Gemini 2.5, 0=off, -1=dynamic)",

{gemcode-0.3.64 → gemcode-0.3.66}/src/gemcode/repl_slash.py

@@ -1001,7 +1001,7 @@ async def process_repl_slash(
         out("  /thinking level <minimal|low|medium|high>")
       out("Display commands (all models):")
       out("  /thinking verbose  — show full thinking text each turn")
-      out("  /thinking brief    — show collapsed one-line excerpt (default)")
+      out("  /thinking brief    — show collapsed one-line excerpt")
       out()
       return ReplSlashResult(skip_model_turn=True)
 
@@ -1016,7 +1016,7 @@ async def process_repl_slash(
 
     if sub in ("brief", "short", "collapsed"):
       cfg.show_full_thinking = False
-      out("thinking display: brief — collapsed one-line excerpt (default)")
+      out("thinking display: brief — collapsed one-line excerpt")
       out()
       return ReplSlashResult(skip_model_turn=True)
 

gemcode-0.3.66/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.64 → gemcode-0.3.66}/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,8 @@ 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)
 
   # 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 +100,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 +119,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.64 → gemcode-0.3.66}/src/gemcode/tools/bash.py

@@ -182,8 +182,8 @@ def make_bash_tool(cfg: GemCodeConfig):
                 env=env,
                 check=False,
             )
-            stdout = proc.stdout[:80_000]
-            stderr = proc.stderr[:20_000]
+            stdout = proc.stdout[:20_000]
+            stderr = proc.stderr[:10_000]
             result: dict = {
                 "command": command,
                 "cwd": str(exec_cwd.relative_to(root)) if exec_cwd != root else ".",

{gemcode-0.3.64 → gemcode-0.3.66}/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:

gemcode-0.3.66/src/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-0.3.64 → gemcode-0.3.66}/src/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:

{gemcode-0.3.64 → gemcode-0.3.66}/src/gemcode/tools/shell.py

@@ -161,8 +161,8 @@ def make_run_command(cfg: GemCodeConfig):
           "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[:20_000],
+          "stderr": proc.stderr[:20_000],
       }
     except subprocess.TimeoutExpired:
       return {"error": f"Timeout after {timeout_seconds}s"}

{gemcode-0.3.64 → gemcode-0.3.66}/src/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-0.3.64 → gemcode-0.3.66}/src/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,7 +64,7 @@ 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"}

{gemcode-0.3.64 → gemcode-0.3.66/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.64 → gemcode-0.3.66}/src/gemcode.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ src/gemcode/slash_commands.py
 src/gemcode/thinking.py
 src/gemcode/tool_prompt_manifest.py
 src/gemcode/tool_registry.py
+src/gemcode/tool_result_store.py
 src/gemcode/tools_inspector.py
 src/gemcode/trust.py
 src/gemcode/version.py
@@ -76,6 +77,7 @@ src/gemcode/tools/edit.py
 src/gemcode/tools/filesystem.py
 src/gemcode/tools/notebook.py
 src/gemcode/tools/notes.py
+src/gemcode/tools/repo_map.py
 src/gemcode/tools/search.py
 src/gemcode/tools/shell.py
 src/gemcode/tools/shell_gate.py