gemcode 0.3.106__tar.gz → 0.3.108__tar.gz

{gemcode-0.3.106/src/gemcode.egg-info → gemcode-0.3.108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.106
+Version: 0.3.108
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -327,6 +327,17 @@ GemCode combines:
 Reference:
 - [`../docs/tools-and-permissions.md`](../docs/tools-and-permissions.md)
 
+### Super mode (fully autonomous)
+
+Use when you want GemCode to run without GemCode’s own confirmation prompts (mutations, shell, ADK confirmation handoffs, AFC stdin prompt, attachment gate, auto-trust on CLI, and non-interactive `get_user_choice` = first option).
+
+- **CLI:** `gemcode -C . --super "your task"`
+- **Env:** `GEMCODE_SUPER_MODE=1`
+- **REPL/TUI:** `/super` (use `/super off` to clear the flag only)
+- **Kaira:** `gemcode kaira -C . --super`
+
+Details and safety notes: [`../docs/tools-and-permissions.md`](../docs/tools-and-permissions.md#super-mode-fully-autonomous).
+
 ## Common commands
 
 ### Inspect models
@@ -410,6 +421,7 @@ Status note:
 | `/review` | Run a review workflow |
 | `/eval` | Run evaluation gates |
 | `/kaira` | Show scheduler usage help |
+| `/super` | Super mode: auto-approve tools, no GemCode HITL · `/super off` |
 
 Detailed behavior:
 - [`../docs/cli-and-repl.md`](../docs/cli-and-repl.md)

{gemcode-0.3.106 → gemcode-0.3.108}/README.md

@@ -135,6 +135,17 @@ GemCode combines:
 Reference:
 - [`../docs/tools-and-permissions.md`](../docs/tools-and-permissions.md)
 
+### Super mode (fully autonomous)
+
+Use when you want GemCode to run without GemCode’s own confirmation prompts (mutations, shell, ADK confirmation handoffs, AFC stdin prompt, attachment gate, auto-trust on CLI, and non-interactive `get_user_choice` = first option).
+
+- **CLI:** `gemcode -C . --super "your task"`
+- **Env:** `GEMCODE_SUPER_MODE=1`
+- **REPL/TUI:** `/super` (use `/super off` to clear the flag only)
+- **Kaira:** `gemcode kaira -C . --super`
+
+Details and safety notes: [`../docs/tools-and-permissions.md`](../docs/tools-and-permissions.md#super-mode-fully-autonomous).
+
 ## Common commands
 
 ### Inspect models
@@ -218,6 +229,7 @@ Status note:
 | `/review` | Run a review workflow |
 | `/eval` | Run evaluation gates |
 | `/kaira` | Show scheduler usage help |
+| `/super` | Super mode: auto-approve tools, no GemCode HITL · `/super off` |
 
 Detailed behavior:
 - [`../docs/cli-and-repl.md`](../docs/cli-and-repl.md)

{gemcode-0.3.106 → gemcode-0.3.108}/pyproject.toml

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

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/agent.py

@@ -76,6 +76,8 @@ def build_global_instruction() -> str:
     "You are GemCode, an expert software engineering agent powered by Google Gemini. "
     "Think deeply about what the person actually wants before you do anything. "
     "Use exactly as many tools as the task genuinely requires — no more. "
+    "When routing or capabilities change between turns, still prefer minimal tools, "
+    "repo-grounded evidence, and verification before claiming done. "
     "Act fully and autonomously when action is needed. "
     "Always use read-only tools before shell or write tools. "
     "Never create CLAUDE.md or AGENTS.md; use GEMINI.md for project instructions."
@@ -353,6 +355,79 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 - **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}{veomem_section}"""
 
 
+def _build_calibration_section(cfg: GemCodeConfig) -> str:
+  """
+  Meta-instruction for "smart" behavior under dynamic routing (auto model/capability mode,
+  orchestration tools, etc.). Kept compact to limit prompt bloat.
+  """
+  mm = (getattr(cfg, "model_mode", "") or "").strip().lower()
+  cm = (getattr(cfg, "capability_mode", "") or "").strip().lower()
+  bits: list[str] = []
+  if mm == "auto":
+    bits.append("`model_mode=auto` (model may shift per turn for speed vs depth)")
+  if cm == "auto":
+    bits.append("`capability_mode=auto` (deep research / extras may attach per turn)")
+  session_note = ""
+  if bits:
+    session_note = (
+      "\n**This session uses dynamic routing:** "
+      + " · ".join(bits)
+      + ". Defaults are **hints** — override with judgment when the task clearly needs more or less depth.\n"
+    )
+
+  return f"""## Calibration and dynamic routing (all modes)
+
+Infer **intent → depth → tools** without fixed buckets (requests vary):
+
+| Stance | Move |
+| --- | --- |
+| **Explain / review** | Read-only recon first; cite **paths**; avoid unrelated edits. |
+| **Implement / fix** | Recon → plan (`todo_write` when 3+ steps) → smallest change → **verify** (tests, lint, build slice, or read-back). |
+| **Debug** | One hypothesis per iteration; change one variable between tries; never repeat the same failing command verbatim. |
+| **External facts** | Use web/research tools when the answer is outside the repo (docs, APIs, CVEs). Prefer **repo files** for how *this* codebase behaves. |
+
+**Evidence:** tie non-obvious claims about this workspace to **files or command output** you actually saw.
+
+**Orchestration:** use `spawn_subtasks`, org delegation, or background jobs only when work is **parallel** or **role-split**. Merge into **one** answer with a single recommendation; skip fan-out for small linear tasks.
+
+**Anti-patterns:** tool spam; “done” without verification on risky edits; searching the web when the source file is already in-tree; repeating identical failures.{session_note}"""
+
+
+def _engineering_discipline_instruction_enabled() -> bool:
+  """Extra prompt section: cautious change quality. Opt out with GEMCODE_ENGINEERING_DISCIPLINE=0."""
+  import os
+
+  v = os.environ.get("GEMCODE_ENGINEERING_DISCIPLINE", "1").strip().lower()
+  return v not in ("0", "false", "no", "off")
+
+
+def _build_engineering_discipline_section(cfg: GemCodeConfig) -> str:
+  """Prompt block for minimal, evidence-grounded edits; trivial fixes need not dwell on it."""
+  _ = cfg  # reserved for future project-scoped tuning
+  return """## Engineering discipline (change quality)
+
+**Tradeoff:** biases toward careful, minimal diffs over speed. For trivial edits, use judgment.
+
+### Ambiguity
+- Briefly state **what you understood** before substantial implementation. If several readings fit, outline them or ask **one** precise question — do not silently pick and run.
+- Prefer **evidence from this repo** (reads, grep, tests) over guessed APIs, paths, or behaviour.
+
+### Scope and simplicity
+- Deliver **what was asked**, not a roadmap of extras. Avoid speculative features, abstraction layers, or configurability “for later” unless the user requested flexibility.
+- Prefer the **smallest** correct change. Expand structure only when complexity is already present or clearly required.
+
+### Surgical edits
+- Change **only** what is necessary for the outcome; match surrounding **style and patterns** unless project docs say otherwise.
+- Do not refactor, rename, or reformat unrelated code in the same pass. Note worthwhile cleanups separately if helpful.
+- Remove **orphans your edit introduced** (e.g. unused imports from your change). Leave pre-existing dead code unless the user asks to remove it.
+
+### When to call it done
+- Turn fuzzy requests into **checkable** outcomes where it matters (e.g. bug → reproduce → fix → same checks green).
+- After material edits, run the **cheapest** falsifying step you can: targeted test, lint, build, or re-read the critical path — not guess-and-hope.
+
+"""
+
+
 def _build_memory_section(cfg: GemCodeConfig) -> str:
   """Injected when enable_memory=True so the agent understands and uses memory."""
   mem_path = cfg.project_root / ".gemcode" / "memories.jsonl"
@@ -559,6 +634,12 @@ def build_instruction(cfg: GemCodeConfig) -> str:
     "on",
   )
 
+  discipline_block = (
+    _build_engineering_discipline_section(cfg)
+    if _engineering_discipline_instruction_enabled()
+    else ""
+  )
+
   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.
 
@@ -610,6 +691,8 @@ You have native deep thinking capability — use it actively:
 - 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.
 
+{_build_calibration_section(cfg)}
+{discipline_block}
 ## Tool selection guide (only when needed)
 
 Keep tool usage minimal. Prefer short, targeted calls and keep tool outputs small.
@@ -1013,9 +1096,11 @@ def build_root_agent(
     tools = [preload_memory, *tools]
 
   # ADK built-in interactive + artifact tools — always available when ADK supports them.
+  # In super mode, ``get_user_choice`` auto-picks the first option (no UI).
   try:
-    from google.adk.tools import get_user_choice, load_artifacts, exit_loop
-    tools = [*tools, get_user_choice, load_artifacts, exit_loop]
+    from gemcode.tools.user_choice import append_user_choice_load_artifacts_exit_loop
+
+    append_user_choice_load_artifacts_exit_loop(cfg, tools)
   except Exception:
     pass
 

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/cli.py

@@ -13,7 +13,7 @@ import uuid
 import warnings
 from pathlib import Path
 
-from gemcode.config import GemCodeConfig, load_cli_environment
+from gemcode.config import GemCodeConfig, apply_super_mode, load_cli_environment
 from gemcode.tools_inspector import inspect_tools, smoke_tools
 from gemcode.invoke import run_turn
 from gemcode.model_routing import pick_effective_model
@@ -43,6 +43,11 @@ def _maybe_prompt_trust(cfg: GemCodeConfig) -> None:
   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.
   """
+  if getattr(cfg, "super_mode", False):
+    root = cfg.project_root.resolve()
+    if not is_trusted_root(root):
+      trust_root(root, trusted=True)
+    return
   # Non-interactive sessions can't answer prompts.
   if not (hasattr(sys.stdin, "isatty") and sys.stdin.isatty()):
     return
@@ -220,7 +225,9 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       "on",
     ):
       try:
-        if (
+        if getattr(cfg, "super_mode", False):
+          pass
+        elif (
           hasattr(sys.stdin, "isatty")
           and sys.stdin.isatty()
           and not cfg.yes_to_all
@@ -922,6 +929,11 @@ def main() -> None:
       action="store_true",
       help="Allow write_file / search_replace (disables interactive HITL prompts).",
     )
+    kaira_parser.add_argument(
+      "--super",
+      action="store_true",
+      help="Fully autonomous jobs: auto-approve tools/shell, no HITL (implies --yes).",
+    )
     kaira_parser.add_argument(
       "--interactive-ask",
       action="store_true",
@@ -978,7 +990,11 @@ def main() -> None:
         cfg.model_mode = "fast"
 
     cfg.yes_to_all = bool(args.yes)
-    if args.interactive_ask:
+    if getattr(args, "super", False):
+      cfg.super_mode = True
+    if cfg.super_mode:
+      apply_super_mode(cfg)
+    elif args.interactive_ask:
       cfg.interactive_permission_ask = True
     else:
       if "GEMCODE_INTERACTIVE_PERMISSION_ASK" not in os.environ:
@@ -1023,6 +1039,11 @@ def main() -> None:
   parser.add_argument("-C", "--directory", type=Path, default=Path.cwd(), help="Project root")
   parser.add_argument("--session", default=None, help="Session id for SQLite-backed history")
   parser.add_argument("--yes", action="store_true", help="Allow write_file / search_replace")
+  parser.add_argument(
+    "--super",
+    action="store_true",
+    help="Super mode: auto-approve all tool/shell use, skip HITL and AFC prompts (implies --yes).",
+  )
   parser.add_argument(
     "--interactive-ask",
     action="store_true",
@@ -1096,7 +1117,11 @@ def main() -> None:
     if args.model_mode is None:
       cfg.model_mode = "fast"
   cfg.yes_to_all = args.yes
-  if args.interactive_ask:
+  if args.super:
+    cfg.super_mode = True
+  if cfg.super_mode:
+    apply_super_mode(cfg)
+  elif args.interactive_ask:
     cfg.interactive_permission_ask = True
   else:
     # If user didn't explicitly set env, default to HITL when we're in a TTY.

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/config.py

@@ -374,6 +374,13 @@ class GemCodeConfig:
     default_factory=lambda: _truthy_env("GEMCODE_BACKGROUND_LEARNER", default=False)
   )
 
+  # "Super" mode: fully autonomous session — auto-approve mutating/shell tools,
+  # skip interactive HITL and AFC tool-mode prompts, and prefer non-blocking UX.
+  # Enable with ``GEMCODE_SUPER_MODE=1`` or ``gemcode --super``.
+  super_mode: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_SUPER_MODE", default=False)
+  )
+
   def __post_init__(self) -> None:
     self.project_root = self.project_root.resolve()
     # Default agentic depth when env omits GEMCODE_MAX_LLM_CALLS (was: None → SDK default).
@@ -479,6 +486,24 @@ class GemCodeConfig:
             "tar",
           )
         )
+    if self.super_mode:
+      apply_super_mode(self)
+
+
+def apply_super_mode(cfg: GemCodeConfig) -> None:
+  """
+  Apply super-mode policy: no interactive tool HITL, auto-approve GemCode gates,
+  keep all toolsets (skip AFC stdin prompt via ``_afc_choice``), relax strict
+  permission mode so shell tools can run.
+  """
+  if not getattr(cfg, "super_mode", False):
+    return
+  cfg.yes_to_all = True
+  cfg.interactive_permission_ask = False
+  if getattr(cfg, "permission_mode", "") == "strict":
+    cfg.permission_mode = "default"
+  object.__setattr__(cfg, "_afc_choice", "all")
+  object.__setattr__(cfg, "_attachments_allowed", True)
 
 
 def load_dotenv_optional() -> None:

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/invoke.py

@@ -18,11 +18,6 @@ from google.adk.runners import Runner
 from google.genai import types
 
 
-# Delays (seconds) between successive transient-error retries: 2s, 5s, 12s.
-# Three retries = up to ~19 seconds of total wait before giving up.
-_TRANSIENT_RETRY_DELAYS = [2.0, 5.0, 12.0]
-
-
 _HITL_PROMPT_LOCK = Lock()
 
 async def _maybe_enqueue_kaira_autopilot(*, cfg: "GemCodeConfig", session_id: str) -> None:
@@ -423,14 +418,14 @@ async def run_turn(
             next_message=current_message, do_reset=do_reset
           )
         except Exception as _exc:
-          from gemcode.model_errors import is_transient_error
-          if is_transient_error(_exc) and transient_attempts < len(_TRANSIENT_RETRY_DELAYS):
-            delay = _TRANSIENT_RETRY_DELAYS[transient_attempts]
+          from gemcode.model_errors import API_TRANSIENT_RETRY_DELAYS_SEC, is_transient_error
+          if is_transient_error(_exc) and transient_attempts < len(API_TRANSIENT_RETRY_DELAYS_SEC):
+            delay = API_TRANSIENT_RETRY_DELAYS_SEC[transient_attempts]
             transient_attempts += 1
             _tui_active = os.environ.get("GEMCODE_TUI_ACTIVE", "0").lower() in ("1", "true", "yes", "on")
             _msg = (
               f"\n[gemcode] Transient API error ({type(_exc).__name__}). "
-              f"Retrying in {delay:.0f}s (attempt {transient_attempts}/{len(_TRANSIENT_RETRY_DELAYS)})...\n"
+              f"Retrying in {delay:.0f}s (attempt {transient_attempts}/{len(API_TRANSIENT_RETRY_DELAYS_SEC)})...\n"
             )
             print(_msg, file=sys.stderr)
             # Surface retry notice in TUI if available.
@@ -460,11 +455,20 @@ async def run_turn(
           and hasattr(sys.stdin, "isatty")
           and sys.stdin.isatty()
         )
+        auto_ok = bool(
+          cfg is not None
+          and (
+            bool(getattr(cfg, "yes_to_all", False))
+            or bool(getattr(cfg, "super_mode", False))
+          )
+        )
 
         parts: list[types.Part] = []
         for fc in confirmation_fcs:
           tool_name, hint = _extract_hint_and_tool(fc)
-          if interactive_enabled:
+          if auto_ok:
+            ok = True
+          elif interactive_enabled:
             suffix = f"\n  Hint: {hint}" if hint else ""
             ok = _prompt_yes_no(
               f"\n[gemcode HITL] Approve tool call '{tool_name}'? [y/N]{suffix}\n> "

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/kaira_daemon.py

@@ -491,8 +491,12 @@ class KairaDaemon:
       parts: list[types.Part] = []
       for fc in confirmation_fcs:
         tool_name, hint = _extract_hint_and_tool(fc)
-        ok = False
-        if self._ipc is not None:
+        auto_ok = bool(
+          getattr(self.cfg, "yes_to_all", False)
+          or getattr(self.cfg, "super_mode", False)
+        )
+        ok = bool(auto_ok)
+        if not ok and self._ipc is not None:
           try:
             ok = await self._ipc.request_confirmation(
               job_id=job.job_id,

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/model_errors.py

@@ -4,6 +4,9 @@ from __future__ import annotations
 
 import re
 
+# Seconds between retries for transient API failures (shared by invoke.py and TUI).
+API_TRANSIENT_RETRY_DELAYS_SEC: tuple[float, ...] = (2.0, 5.0, 12.0)
+
 
 def is_transient_error(error: Exception) -> bool:
   """Return True for HTTP 503 / 429 and similar transient API errors that are safe to retry.
@@ -29,6 +32,21 @@ def is_transient_error(error: Exception) -> bool:
     return True
 
   msg = str(error)
+  ml = msg.lower()
+
+  # httpx / google-genai often raise ``ServerError`` for HTTP 500 without ``APIError.code``.
+  if et == "ServerError" or "ServerError" in et:
+    if any(code in msg for code in ("500", "502", "503", "504")):
+      return True
+
+  # Gemini REST body shape: ``'code': 500`` / ``"INTERNAL"`` / "Internal error encountered."
+  if ("'code': 500" in msg or '"code": 500' in msg or re.search(r"\b500\b", msg)) and any(
+    p in ml for p in ("internal", "unavailable", "try again", "deadline", "timeout", "backend")
+  ):
+    return True
+  if "internal error encountered" in ml:
+    return True
+
   # Match the specific phrases Gemini uses in 503 responses
   if "503" in msg and any(p in msg for p in ("high demand", "service unavailable", "overloaded")):
     return True

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/repl_commands.py

@@ -257,6 +257,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("skills",      "List GemSkills"),
     ("status",      "Model, capabilities, thinking, limits"),
     ("style",       "Output styles  ·  /style <name>|off"),
+    ("super",       "Super mode  ·  auto-approve tools/shell, no HITL  ·  /super off"),
     ("summarise",   "Summarise current session, persist key points, then reset  ·  /summarize same"),
     ("thinking",    "Thinking verbose/brief/off, budget, level"),
     ("tools",       "Tool inventory  ·  /tools smoke"),
@@ -334,6 +335,7 @@ def slash_help_lines() -> list[str]:
       "                        Aliases: /image /img /file",
       "  /trust                Show workspace trust status (file/shell tools)",
       "  /trust on|off         Trust or revoke trust for this project root (~/.gemcode/trust.json)",
+      "  /super                Fully autonomous session (auto-approve tools; no HITL). /super off to disable flag only",
       "  /init                 Analyze project structure and generate GEMINI.md",
       "  /init force           Regenerate GEMINI.md even if it already exists",
       "  /cost                 Show token usage and estimated cost for this session",

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/repl_slash.py

@@ -616,6 +616,23 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True)
 
+  # ── /super (fully autonomous: no HITL, auto-approve tools) ─────────────────
+  if name == "super":
+    from gemcode.config import apply_super_mode
+
+    args_s = (sc.args or "").strip().lower()
+    if args_s in ("off", "0", "false", "no"):
+      cfg.super_mode = False
+      out("Super mode: off (yes_to_all unchanged; restart or adjust flags to change approvals).")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+    cfg.super_mode = True
+    apply_super_mode(cfg)
+    out("Super mode: on — mutating/shell tools and ADK confirmations auto-approved; no AFC stdin prompt.")
+    out("Equivalent: gemcode --super  or  GEMCODE_SUPER_MODE=1")
+    out()
+    return ReplSlashResult(skip_model_turn=True)
+
   # ── /add-dir (safe multi-root access) ──────────────────────────────────────
   if name in ("add-dir", "add_dir", "adddir"):
     args = (sc.args or "").strip()

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/tool_prompt_manifest.py

@@ -55,6 +55,14 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
   yes_to_all = bool(getattr(cfg, "yes_to_all", False))
   interactive_ask_on = bool(getattr(cfg, "interactive_permission_ask", False))
   sticky_hitl = bool(getattr(cfg, "interactive_hitl_sticky_session", True))
+  super_on = bool(getattr(cfg, "super_mode", False))
+  guc_manifest = (
+    "- **`get_user_choice(options)`** — (super mode) returns the **first** option immediately with no user prompt. "
+    "Put the preferred default first."
+    if super_on
+    else "- **`get_user_choice(options)`** — present the user with a structured list of options (2–6 items). "
+    "Returns the user's selected option. Use instead of open-ended questions when responses are bounded."
+  )
 
   # Core custom tools.
   read_only = sorted(READ_ONLY_TOOLS)
@@ -97,6 +105,30 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
 
   memory_on = bool(getattr(cfg, "enable_memory", False))
 
+  mm = (getattr(cfg, "model_mode", "") or "").strip().lower()
+  cm = (getattr(cfg, "capability_mode", "") or "").strip().lower()
+  auto_routing_note = ""
+  if mm == "auto" or cm == "auto":
+    auto_routing_note = (
+      f"\n- **Dynamic routing:** `model_mode={mm}`, `capability_mode={cm}` — per-turn defaults are **hints**; "
+      "still pick the smallest depth/toolset that fits the ask.\n"
+    )
+
+  calibration_manifest = f"""### Calibration (aligned with main instruction)
+- **Repo vs external:** ground claims about *this repo* with reads/grep/tests; use research/web for **external** docs, APIs, or facts outside the tree.
+- **Orchestration:** use `run_subtask` / `spawn_subtasks` only for **parallel independent** work or explicit verification; merge into **one** answer; skip fan-out for trivial linear tasks.
+- **Finish line:** verify risky edits (test/lint/read-back) before declaring done.{auto_routing_note}"""
+
+  _disc = os.environ.get("GEMCODE_ENGINEERING_DISCIPLINE", "1").strip().lower()
+  discipline_manifest = ""
+  if _disc not in ("0", "false", "no", "off"):
+    discipline_manifest = """
+
+### Engineering discipline (aligned with main instruction)
+- **Ambiguity:** state what you understood or ask **one** precise question; prefer repo evidence over guesses.
+- **Scope:** deliver the ask with the **smallest** adequate change; skip speculative extras.
+- **Surgical:** touch only what you must; match local style; clean up orphans **your** edit introduced."""
+
   manifest = f"""## Tool system (GemCode)
 
 ### Execution model
@@ -104,6 +136,8 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
 - **Reason end-to-end autonomously.** The user expects complete tasks, not a questionnaire. Use `think` before complex actions, `todo_write` to track multi-step work.
 - **Never stop after the first tool call succeeds.** Keep going until the full task is done or you hit a genuine blocker.
 
+{calibration_manifest}{discipline_manifest}
+
 ### Permission policy
 | Setting | Value |
 |---------|-------|
@@ -126,7 +160,7 @@ def build_tool_manifest(cfg: GemCodeConfig) -> str | None:
   - Returns the sub-agent's final text as `result`.
   - Use for: context-heavy exploration (reading 50+ files), parallel investigation of independent subsystems, verification passes after you finish work.
   - Always give the sub-agent enough context to work independently; end the task with "Summarise your findings clearly."
-- **`get_user_choice(question, choices)`** — present the user with a structured list of options (2–6 items). Returns the user's selected option. Use instead of open-ended questions when the set of valid responses is known and bounded (e.g. framework choice, migration strategy, naming convention).
+{guc_manifest}
 - **`load_artifacts(filenames)`** — load one or more named artifacts (binary/large files) saved in this or a previous session. Returns the content of each. Use `user:filename` prefix for cross-session artifacts.
 - **`exit_loop()`** — signal the surrounding LoopAgent to stop iterating and emit the final result. Only relevant when running inside a LoopAgent pipeline (e.g. the `/refine` write→test→fix loop).
 

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/tool_registry.py

@@ -38,7 +38,9 @@ SHELL_TOOLS: frozenset[str] = frozenset({"run_command", "bash"})
 # Session planning only (no disk / shell; no extra permission)
 # think — in-context reasoning scratchpad (no-op, no side effects)
 # run_subtask — spawns a sub-agent; inherits parent permission settings
-PLANNING_TOOLS: frozenset[str] = frozenset({"todo_write", "think", "run_subtask"})
+PLANNING_TOOLS: frozenset[str] = frozenset(
+  {"todo_write", "think", "run_subtask", "spawn_subtasks"}
+)
 
 ToolConcurrency = Literal["parallel_safe", "serial_mutating", "shell"]
 

{gemcode-0.3.106 → gemcode-0.3.108}/src/gemcode/tools/subtask.py

@@ -43,8 +43,9 @@ def _build_sub_tools(cfg: GemCodeConfig) -> list:
 
     # ADK special interactive tools — always try to include.
     try:
-        from google.adk.tools import get_user_choice, load_artifacts, exit_loop
-        tools = [*tools, get_user_choice, load_artifacts, exit_loop]
+        from gemcode.tools.user_choice import append_user_choice_load_artifacts_exit_loop
+
+        append_user_choice_load_artifacts_exit_loop(cfg, tools)
     except Exception:
         pass
 

gemcode-0.3.108/src/gemcode/tools/user_choice.py

@@ -0,0 +1,58 @@
+"""User-choice tool: interactive (ADK) vs automatic (super mode)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+  from gemcode.config import GemCodeConfig
+
+
+def make_super_get_user_choice_tool(cfg: GemCodeConfig):
+  """
+  Non-interactive stand-in for ADK ``get_user_choice`` when ``cfg.super_mode``.
+
+  ADK's built-in tool is a LongRunningFunctionTool that returns ``None`` and
+  waits for UI; in super mode we return the first non-empty option immediately.
+  """
+
+  def get_user_choice(options: list[str], tool_context: Any) -> str | None:
+    """Pick the first option without blocking on human input (super mode)."""
+    try:
+      tool_context.actions.skip_summarization = True
+    except Exception:
+      pass
+    for opt in options or []:
+      s = str(opt).strip()
+      if s:
+        return s
+    return None
+
+  get_user_choice.__name__ = "get_user_choice"
+  return get_user_choice
+
+
+def append_user_choice_load_artifacts_exit_loop(
+  cfg: GemCodeConfig, tools: list,
+) -> None:
+  """
+  Append ``get_user_choice``, ``load_artifacts``, ``exit_loop`` like ADK defaults.
+
+  When ``cfg.super_mode``, ``get_user_choice`` is a plain function that auto-picks
+  the first option; otherwise the ADK LongRunningFunctionTool is used.
+  """
+  if getattr(cfg, "super_mode", False):
+    tools.append(make_super_get_user_choice_tool(cfg))
+  else:
+    try:
+      from google.adk.tools import get_user_choice as adk_get_user_choice
+
+      tools.append(adk_get_user_choice)
+    except Exception:
+      pass
+  try:
+    from google.adk.tools import exit_loop, load_artifacts
+
+    tools.extend([load_artifacts, exit_loop])
+  except Exception:
+    pass