gemcode 0.3.76__py3-none-any.whl → 0.3.78__py3-none-any.whl

gemcode/agent.py

@@ -1,5 +1,5 @@
 """
-Root LlmAgent definition (Claude Code: agent config + tool list, analogous to tools.ts + prompts).
+Root LlmAgent definition (agent config + tool list, analogous to a tools registry + prompts).
 
 See `session_runtime.py` for Runner/session wiring (outer layer).
 See `tool_registry.py` for tool categories (read vs mutating vs shell).
@@ -27,11 +27,49 @@ from gemcode.limits import make_before_model_limits_callback, make_before_model_
 from gemcode.thinking import build_thinking_config
 from gemcode.tools import build_function_tools
 from gemcode.tool_prompt_manifest import build_tool_manifest
-from gemcode.skills import build_skill_manifest_text
+from gemcode.skills import (
+  build_skill_manifest_text,
+  expand_skill_text,
+  list_supporting_files,
+  load_skill,
+)
 from gemcode.output_styles import build_output_style_section
 from gemcode.rules import build_rules_section
 
 
+def _build_session_loaded_skills_section(cfg: GemCodeConfig) -> str:
+  """Full bodies for GemSkills the user loaded with /gemskill (session-scoped)."""
+  names = list(getattr(cfg, "session_loaded_skill_names", None) or [])
+  if not names:
+    return ""
+  sid = getattr(cfg, "session_skill_expand_session_id", None) or ""
+  chunks: list[str] = []
+  seen: set[str] = set()
+  for raw in names:
+    sk_name = (raw or "").strip().lower()
+    if not sk_name or sk_name in seen:
+      continue
+    seen.add(sk_name)
+    s = load_skill(cfg.project_root, sk_name)
+    if s is None:
+      continue
+    expanded = expand_skill_text(s, arguments="", session_id=sid)
+    files = list_supporting_files(s)
+    head = f"### GemSkill: `/{s.meta.name}` (loaded for this session)\n\n"
+    chunk = head + expanded
+    if files:
+      chunk += f"\n\nSupporting files: {', '.join(files)}"
+    chunks.append(chunk)
+  if not chunks:
+    return ""
+  return (
+      "## Loaded GemSkills (this session)\n"
+      "The user explicitly loaded these skills with `/gemskill`. Follow their workflows "
+      "when the task matches their purpose; do not force them on unrelated requests.\n\n"
+      + "\n\n---\n\n".join(chunks)
+  )
+
+
 def build_global_instruction() -> str:
   """Global instruction applied to the entire agent tree (via ADK plugin)."""
   return (
@@ -64,7 +102,7 @@ def _chain_before_model_callbacks(*callbacks):
 
 def _load_gemini_md(project_root: Path) -> str:
   """
-  Load GEMINI.md / .gemcode/NOTES.md from a Claude Code–style hierarchy.
+  Load GEMINI.md / .gemcode/NOTES.md from a interactive CLI–style hierarchy.
 
   Priority (later entries override earlier ones, all are concatenated):
     1. ~/.gemcode/GEMINI.md           — user-global instructions (all projects)
@@ -89,7 +127,7 @@ def _load_gemini_md(project_root: Path) -> str:
       return ""
     try:
       raw = p.read_text(encoding="utf-8", errors="replace")[:_FILE_CAP]
-      # Strip HTML comments (like Claude Code does — saves tokens)
+      # Strip HTML comments (saves tokens)
       return _COMMENT_RE.sub("", raw).strip()
     except OSError:
       return ""
@@ -140,7 +178,7 @@ def _get_git_context(root) -> str:
   """
   Run a quick git snapshot at session start — branch, recent commits, diff-stat.
   Returns a formatted string or empty string if not a git repo.
-  Mirrors OpenClaude's getGitStatus() pattern.
+  Mirrors Reference UI getGitStatus() pattern.
   """
   import subprocess
   import shutil
@@ -232,18 +270,18 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
   if max_session_tokens:
     budget_line += f" · max_session_tokens={max_session_tokens:,}"
 
-  # ── Kairos ────────────────────────────────────────────────────────────────
-  # The user can run `gemcode kairos -C <project>` in a separate terminal to
+  # ── Kaira ────────────────────────────────────────────────────────────────
+  # The user can run `gemcode kaira -C <project>` in a separate terminal to
   # launch a long-lived scheduler. Jobs submitted to it run concurrently with
   # the current session. This is useful for background / parallel heavy work.
-  kairos_section = (
-    "- **Kairos background scheduler** — `gemcode kairos -C <project>` launches a "
+  kaira_section = (
+    "- **Kaira background scheduler** — `gemcode kaira -C <project>` launches a "
     "long-lived daemon that reads prompts from stdin and runs each as an isolated job "
-    "(up to N concurrently). Each job gets `kairos_sleep_ms(ms)` and "
-    "`kairos_enqueue_prompt(prompt, priority, session_id)` tools so the model can "
+    "(up to N concurrently). Each job gets `kaira_sleep_ms(ms)` and "
+    "`kaira_enqueue_prompt(prompt, priority, session_id)` tools so the model can "
     "schedule follow-up work itself. Useful for: bulk file processing, repeated "
     "polling loops, parallelising large independent tasks. "
-    "Tell the user to open a second terminal and run `gemcode kairos` if a task "
+    "Tell the user to open a second terminal and run `gemcode kaira` if a task "
     "would benefit from background parallelism."
   )
 
@@ -274,7 +312,7 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **Capability routing** (`capability_mode={getattr(cfg, 'capability_mode', 'auto')}`): in `auto` mode, GemCode automatically enables deep_research when it detects research-intent keywords in your prompt each turn. You can also type `/research on`, `/embeddings on`, `/memory on`, `/computer on` at the prompt.
 - **Your tool palette can grow mid-session:** if the user enables a capability via a slash command, the runner rebuilds and you get new tools on the next turn.
 - **Memory system:** when `memory ON`, ADK automatically searches `.gemcode/memories.jsonl` and injects relevant past context before each turn. Facts the user tells you in one session can appear in future sessions. You do not need to manage memory explicitly — it is loaded automatically.
-{kairos_section}
+{kaira_section}
 - **UI banner** phrases like "GemCode Pro" are terminal marketing, not a separate API tier.
 - **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the OS process that launched gemcode. Pasting `VAR=1` in chat does NOT reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
 - **Working in subfolders** — call `list_directory(\"Desktop\")`, `glob_files(\"**/query.ts\")`, `read_file(\"testing/ai-edtech-app/src/app/page.tsx\")` directly. Never claim access is blocked unless a tool returned an explicit error.{git_section}{curated_section}"""
@@ -680,7 +718,7 @@ Concrete patterns:
 - Grepping different patterns → multiple `grep_content` in one response
 - `list_directory` + `glob_files` → both at once
 
-**Parallel sub-agent exploration (OpenClaude pattern):**
+**Parallel sub-agent exploration (reference terminal UI pattern):**
 When a task requires understanding several subsystems before acting:
 1. Spawn parallel `run_subtask` workers, one per subsystem
 2. Wait for all results to return in the same turn
@@ -844,7 +882,7 @@ Use `gh pr create` via `bash`. When asked to create a PR:
 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`.
 
 ## Agent notes (.gemcode/notes.md)
-You have two tools to persist project insights across sessions, like Claude Code's auto-memory:
+You have two tools to persist project insights across sessions (auto-memory style):
 
 - **`append_project_note(note)`** — write a note to `.gemcode/notes.md`. Use this proactively when you discover something worth remembering:
   - Build/test/lint commands you discover ("Build: `npm run build` — requires Node 20")
@@ -888,6 +926,9 @@ You have two tools to persist project insights across sessions, like Claude Code
   skill_manifest = build_skill_manifest_text(cfg.project_root)
   if skill_manifest:
     base = f"{base}\n\n{skill_manifest}"
+  loaded_skills = _build_session_loaded_skills_section(cfg)
+  if loaded_skills:
+    base = f"{base}\n\n{loaded_skills}"
   extra = _load_gemini_md(cfg.project_root)
   if extra.strip():
     return f"{base}\n\n## Project instructions (GEMINI.md)\n{extra}"
@@ -936,7 +977,7 @@ def build_root_agent(
   except Exception:
     pass
 
-  # Agent auto-notes: write project insights to .gemcode/notes.md (Claude Code MEMORY.md equivalent)
+  # Agent auto-notes: write project insights to .gemcode/notes.md (project notes file)
   try:
     from gemcode.tools.notes import build_notes_tools
     notes_tools = build_notes_tools(cfg.project_root)
@@ -964,7 +1005,7 @@ def build_root_agent(
   if before_model is not None:
     cb_kwargs["before_model_callback"] = before_model
 
-  # Claude-like thinking: enabled by default (Gemini dynamic), but allow
+  # familiar thinking: enabled by default (Gemini dynamic), but allow
   # explicit overrides for disable/budgets/levels.
   gen_cfg = None
   thinking_cfg = build_thinking_config(cfg)

gemcode/autocompact.py

@@ -1,5 +1,5 @@
 """
-Claude Code–style autocompact for ADK/Gemini.
+interactive CLI–style autocompact for ADK/Gemini.
 
 GemCode already has:
 - bounded tool output (after_tool truncation)
@@ -41,7 +41,7 @@ def _autocompact_enabled(cfg: GemCodeConfig) -> bool:
 
 
 def _autocompact_threshold_chars(cfg: GemCodeConfig) -> int:
-  # Claude Code uses token windows; we use a character proxy budget since
+  # uses token windows; we use a character proxy budget since
   # Gemini tokenizers vary and ADK does not expose a cheap exact counter.
   max_chars = int(getattr(cfg, "max_context_chars", 0) or 0)
   if max_chars <= 0:

gemcode/autotune.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import subprocess
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
+from gemcode.config import GemCodeConfig
 from gemcode.evals.harness import run_eval_suite, write_eval_record
 
 
@@ -47,11 +48,24 @@ def init_autotune(*, project_root: Path, tag: str) -> dict[str, Any]:
   return {"status": "created", "branch": branch}
 
 
-def run_autotune_eval(*, project_root: Path, include_llm: bool, model: str | None = None) -> dict[str, Any]:
+def run_autotune_eval(
+  *,
+  project_root: Path,
+  include_llm: bool,
+  model: str | None = None,
+  session_cfg: GemCodeConfig | None = None,
+  extra_tools: Iterable[Any] | None = None,
+) -> dict[str, Any]:
   """
   Run eval suite and persist last result to .gemcode/evals/last_eval.json.
   """
-  res = run_eval_suite(project_root=project_root, include_llm=include_llm, model=model)
+  res = run_eval_suite(
+    project_root=project_root,
+    include_llm=include_llm,
+    model=model,
+    session_cfg=session_cfg,
+    extra_tools=extra_tools,
+  )
   meta = {
     "ts": time.time(),
     "git_sha": _git_head_sha(project_root),

gemcode/callbacks.py

@@ -1,7 +1,7 @@
 """
 ADK callbacks: permissions, audit, tool failure circuit breaker, usage logging.
 
-Maps to Claude Code patterns:
+Maps to patterns:
 - before_tool / after_tool ≈ permission gates + telemetry around tool execution
 - after_model ≈ cost / usage hooks (see cost-tracker.ts role)
 - Session state for streak counters ≈ autoCompact failure tracking (MVP: tool errors)
@@ -60,7 +60,7 @@ def _truthy_env(name: str, *, default: bool = False) -> bool:
 
 
 def _maybe_tool_summary_enabled() -> bool:
-  # Mirrors Claude's "emit tool use summaries" gate conceptually.
+  # Mirrors optional "emit tool use summaries" gating.
   return _truthy_env("GEMCODE_EMIT_TOOL_USE_SUMMARIES", default=False)
 
 
@@ -344,7 +344,7 @@ def make_before_tool_callback(cfg: GemCodeConfig):
 
 
 def make_after_tool_callback(cfg: GemCodeConfig):
-  """Track consecutive tool failures in session state (Claude-style circuit breaker)."""
+  """Track consecutive tool failures in session state (conventional circuit breaker)."""
 
   def after_tool(
     tool: BaseTool,
@@ -548,7 +548,7 @@ def make_after_tool_callback(cfg: GemCodeConfig):
               summary[k] = v
       append_audit(cfg.project_root, summary)
       # Also print a concise, user-visible summary in CLI contexts.
-      # (Claude Code renders tool cards; this is the lightweight equivalent.)
+      # (renders tool cards; this is the lightweight equivalent.)
       try:
         # Full-screen TUIs get corrupted by stray stderr prints.
         if _truthy_env("GEMCODE_TUI_ACTIVE", default=False):
@@ -621,7 +621,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
 
     # ── Expose live token stats to the TUI ───────────────────────────────────
     # The TUI reads cfg._last_turn_stats after each turn to display token counts
-    # and estimated cost in the footer (like OpenClaude's spinner token display).
+    # and estimated cost in the footer (like Reference UI spinner token display).
     try:
       in_tok  = d.get("prompt_token_count", 0) or 0
       out_tok = d.get("candidates_token_count", 0) or 0
@@ -762,7 +762,7 @@ def make_after_model_callback(cfg: GemCodeConfig):
 
 
 def make_on_tool_error_callback(cfg: GemCodeConfig):
-  """Turn tool exceptions into structured tool results (Claude-like is_error)."""
+  """Turn tool exceptions into structured tool results (familiar is_error)."""
 
   async def on_tool_error(
     *, tool: BaseTool, args: dict[str, Any], tool_context, error: Exception

gemcode/capability_routing.py

@@ -1,8 +1,8 @@
 """
-Capability-based routing (Claude Code style conceptually).
+Capability-based routing (style conceptually).
 
 This layer decides which *capabilities* to enable (deep research tools,
-embeddings retrieval, computer-use tools) and leaves the existing Claude-like
+embeddings retrieval, computer-use tools) and leaves the existing familiar
 outer/inner loops intact.
 
 It is intentionally conservative:

gemcode/cli.py

@@ -37,7 +37,7 @@ def _events_to_text(events) -> str:
 
 def _maybe_prompt_trust(cfg: GemCodeConfig) -> None:
   """
-  Claude Code–style workspace trust prompt.
+  interactive CLI–style workspace trust prompt.
 
   On first use in a project root, ask the user to trust the folder so file,
   shell, and git tools can run. If not trusted, we exit before any tool runs.
@@ -70,7 +70,7 @@ def _maybe_prompt_trust(cfg: GemCodeConfig) -> None:
 
 def _maybe_prompt_google_api_key() -> None:
   """
-  One-time interactive prompt for ``GOOGLE_API_KEY`` (like ``claude login`` / first-run).
+  One-time interactive prompt for ``GOOGLE_API_KEY`` (like ``gemcode login`` / first-run).
 
   Skipped when the key is already set, stdin is not a TTY, or
   ``GEMCODE_NO_LOGIN_PROMPT=1``.
@@ -125,7 +125,7 @@ def _initialize_gemcode_project(cfg: GemCodeConfig) -> None:
   Create ``<project>/.gemcode/`` and print a short banner the first time it appears.
 
   Runs after workspace trust + API key are satisfied so a bare ``gemcode`` REPL
-  feels like a guided first-run (Claude Code–style).
+  feels like a guided first-run (interactive CLI–style).
   """
   root = cfg.project_root.resolve()
   gem_dir = root / ".gemcode"
@@ -174,7 +174,7 @@ async def _run_prompt(
 
 async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> None:
   """
-  Interactive REPL mode (Claude Code-like): keep the session open for multiple turns.
+  Interactive REPL mode (multi-turn REPL): keep the session open for multiple turns.
   """
   load_cli_environment()
   _maybe_prompt_trust(cfg)
@@ -245,6 +245,13 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
               file=sys.stderr,
           )
 
+    try:
+      from gemcode.repl_commands import install_readline_slash_completion
+
+      install_readline_slash_completion()
+    except Exception:
+      pass
+
     print(
       "GemCode CLI is running. Type your prompt and press Enter. (Ctrl+D to exit)",
       file=sys.stderr,
@@ -261,6 +268,7 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       if prompt_text in (":q", "quit", "exit", "/exit"):
         break
 
+      cfg.session_skill_expand_session_id = session_id
       slash = await process_repl_slash(
           cfg=cfg,
           runner=runner,
@@ -273,7 +281,16 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
           break
         if slash.new_session_id is not None:
           session_id = slash.new_session_id
+          cfg.session_skill_expand_session_id = session_id
         if slash.skip_model_turn:
+          if slash.force_rebuild_runner:
+            try:
+              _c = runner.close()
+              if asyncio.iscoroutine(_c):
+                await _c
+            except Exception:
+              pass
+            runner = create_runner(cfg, extra_tools=None)
           continue
         prompt_text = slash.model_prompt or prompt_text
 
@@ -356,7 +373,7 @@ def main() -> None:
       return
     raise SystemExit("Usage: gemcode ide --stdio")
 
-  # Persist or rotate API key (Claude Code–style `claude login`).
+  # Persist or rotate API key (interactive CLI–style `gemcode login`).
   if len(sys.argv) > 1 and sys.argv[1] == "login":
     load_cli_environment()
     if not (hasattr(sys.stdin, "isatty") and sys.stdin.isatty()):
@@ -598,78 +615,78 @@ def main() -> None:
     print(f"\n[gemcode live-audio] session_id={session_id}", file=sys.stderr)
     return
 
-  # Kairos proactive scheduler daemon.
-  if len(sys.argv) > 1 and sys.argv[1] == "kairos":
-    kairos_parser = argparse.ArgumentParser(
-      prog="gemcode kairos",
-      description="Kairos-like proactive scheduler daemon (stdin -> queued jobs).",
+  # Kaira proactive scheduler daemon.
+  if len(sys.argv) > 1 and sys.argv[1] == "kaira":
+    kaira_parser = argparse.ArgumentParser(
+      prog="gemcode kaira",
+      description="Background proactive scheduler daemon (stdin -> queued jobs).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "-C",
       "--directory",
       type=Path,
       default=Path.cwd(),
       help="Project root",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--session",
       default=None,
       help="Session id for SQLite-backed history (optional; defaults to a new uuid).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--concurrency",
       type=int,
       default=2,
       help="Max number of concurrent queued jobs.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--default-priority",
       type=int,
       default=0,
       help="Priority used for stdin-enqueued jobs.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--yes",
       action="store_true",
       help="Allow write_file / search_replace (disables interactive HITL prompts).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--interactive-ask",
       action="store_true",
       help="Prompt in-run for mutating tool confirmations (HITL).",
     )
-    kairos_parser.add_argument("--model", default=None, help="Override GEMCODE_MODEL")
-    kairos_parser.add_argument(
+    kaira_parser.add_argument("--model", default=None, help="Override GEMCODE_MODEL")
+    kaira_parser.add_argument(
       "--model-mode",
       default=None,
       help="Model mode: auto|fast|balanced|quality (overrides GEMCODE_MODEL_MODE).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--deep-research",
       action="store_true",
       help="Enable deep research tools + routing.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--maps-grounding",
       action="store_true",
       help="Opt-in to Google Maps grounding tool inside deep-research.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--embeddings",
       action="store_true",
       help="Enable embeddings-based semantic retrieval.",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--capability-mode",
       default=None,
       help="Capability routing: auto|research|embeddings|computer|audio|all (enables tools and routes models).",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--tool-combination-mode",
       default=None,
       help="Gemini 3 tool context circulation: deep_research|always|never|auto",
     )
-    kairos_parser.add_argument(
+    kaira_parser.add_argument(
       "--max-llm-calls",
       type=int,
       default=None,
@@ -677,7 +694,7 @@ def main() -> None:
       help="Cap model↔tool iterations for each job message (ADK RunConfig.max_llm_calls).",
     )
 
-    args = kairos_parser.parse_args(sys.argv[2:])
+    args = kaira_parser.parse_args(sys.argv[2:])
     load_cli_environment()
 
     cfg = GemCodeConfig(project_root=args.directory)
@@ -713,15 +730,15 @@ def main() -> None:
     require_google_api_key()
 
     session_id = args.session or str(uuid.uuid4())
-    from gemcode.kairos_daemon import KairosDaemon
+    from gemcode.kaira_daemon import KairaDaemon
 
-    daemon = KairosDaemon(
+    daemon = KairaDaemon(
       cfg=cfg,
       concurrency=args.concurrency,
       default_priority=args.default_priority,
     )
     asyncio.run(daemon.run_forever(session_id=session_id))
-    print(f"\n[gemcode kairos] session_id={session_id}", file=sys.stderr)
+    print(f"\n[gemcode kaira] session_id={session_id}", file=sys.stderr)
     return
 
   parser = argparse.ArgumentParser(prog="gemcode", description="Gemini + ADK coding agent")

gemcode/config.py

@@ -49,7 +49,7 @@ def _truthy_env(name: str, *, default: bool = False) -> bool:
 
 
 def token_budget_invocation_reset() -> dict:
-  """Reset per-user-message token budget tracker (matches new `query()` in Claude)."""
+  """Reset per-user-message token budget tracker when starting a new user turn."""
   import time
 
   t = int(time.time() * 1000)
@@ -212,6 +212,12 @@ class GemCodeConfig:
     default_factory=lambda: os.environ.get("GEMCODE_OUTPUT_STYLE") or None
   )
 
+  # GemSkills explicitly loaded via /gemskill — full bodies injected into the
+  # system instruction until cleared or the session is reset/resumed.
+  session_loaded_skill_names: list[str] = field(default_factory=list)
+  # Substitutes ${GEMCODE_SESSION_ID} when expanding loaded skills for prompts.
+  session_skill_expand_session_id: str | None = None
+
   # Modality toggles (tool injection + routing).
   enable_deep_research: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_ENABLE_DEEP_RESEARCH", default=False)
@@ -285,9 +291,9 @@ class GemCodeConfig:
   # role-based routing from overriding their selection.
   model_overridden: bool = False
 
-  # Gemini thinking controls (Claude-like intent, Gemini-specific knobs).
+  # Gemini thinking controls (familiar intent, Gemini-specific knobs).
   #
-  # Claude Code enables thinking by default and only forces disable/budgets
+  # enables thinking by default and only forces disable/budgets
   # when explicitly configured. We match that by returning "None" unless the
   # user asks for explicit overrides below.
   #
@@ -333,7 +339,7 @@ class GemCodeConfig:
 
   # Plan mode: when ON, the agent explicitly writes out a numbered plan
   # BEFORE executing any tools, then checks the plan before reporting done.
-  # Like OpenClaude's EnterPlanMode — great for complex, multi-file tasks.
+  # Like Reference UI EnterPlanMode — great for complex, multi-file tasks.
   # Toggle at runtime with /plan on|off.
   plan_mode: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_PLAN_MODE", default=False)

gemcode/context_budget.py

@@ -1,5 +1,5 @@
 """
-Bounded tool output and soft prompt-size limits (Claude Code–style context hygiene).
+Bounded tool output and soft prompt-size limits (interactive CLI–style context hygiene).
 
 - Truncate oversized tool result dicts before they enter history (`after_tool`).
 - Before each LLM call, trim oldest text parts until estimated char total is under
@@ -169,7 +169,7 @@ def shrink_contents_text_inplace(contents: Any, max_total_chars: int) -> bool:
         # Choose a max string size that should reduce at least some of the excess.
         if excess >= max_len:
           # Extreme overage: clearing oldest tool payload is closer to
-          # Claude Code's microcompact behavior and guarantees progress.
+          # microcompact behavior and guarantees progress.
           cleared = {"[Old tool result content cleared]": True}
           if getattr(part, "tool_response", None) is not None:
             part.tool_response.response = cleared

gemcode/context_warning.py

@@ -1,8 +1,8 @@
 """
-Claude Code–style context pressure signals (cf. `autoCompact.ts` / `calculateTokenWarningState`).
+Context pressure signals for autocompact and warnings (token-based thresholds).
 
 Uses API `prompt_token_count` when available; thresholds are token-based with
-env overrides. Mirrors Claude’s buffer constants where practical.
+env overrides. Mirrors common buffer constants where practical.
 """
 
 from __future__ import annotations
@@ -11,7 +11,7 @@ import os
 
 from gemcode.config import GemCodeConfig
 
-# Claude `autoCompact.ts` defaults
+# Reference auto-compact defaults
 AUTOCOMPACT_BUFFER_TOKENS = 13_000
 WARNING_THRESHOLD_BUFFER_TOKENS = 20_000
 ERROR_THRESHOLD_BUFFER_TOKENS = 20_000
@@ -40,12 +40,12 @@ def get_effective_context_window_tokens(model: str) -> int:
 
 
 def get_reserved_summary_tokens(model: str) -> int:
-  """Claude reserves headroom for compaction summary output; we use a small cap."""
+  """Reserve headroom for compaction summary output; we use a small cap."""
   return min(_opt_int("GEMCODE_AUTOCOMPACT_RESERVED_OUTPUT_TOKENS", 20_000), 20_000)
 
 
 def get_effective_context_window_size_tokens(model: str) -> int:
-  """`effectiveContextWindow` ≈ window minus reserved output (Claude `getEffectiveContextWindowSize`)."""
+  """`effectiveContextWindow` ≈ window minus reserved output for summaries."""
   w = get_effective_context_window_tokens(model)
   return max(10_000, w - get_reserved_summary_tokens(model))
 
@@ -70,7 +70,7 @@ def calculate_context_warning_state(
     cfg: GemCodeConfig | None = None,
 ) -> dict[str, object]:
   """
-  Returns keys aligned with Claude’s `calculateTokenWarningState`:
+  Returns keys aligned with typical token-warning state helpers:
   - percent_left
   - is_above_warning_threshold
   - is_above_error_threshold

gemcode/credentials.py

@@ -1,4 +1,4 @@
-"""Persisted Google API credentials (Claude Code–style: save once, override via env)."""
+"""Persisted Google API credentials (interactive CLI–style: save once, override via env)."""
 
 from __future__ import annotations