gemcode 0.3.82__py3-none-any.whl → 0.3.86__py3-none-any.whl

gemcode/agent.py

@@ -103,14 +103,15 @@ def _chain_before_model_callbacks(*callbacks):
 
 def _load_gemini_md(project_root: Path) -> str:
   """
-  Load GEMINI.md / .gemcode/NOTES.md from a interactive CLI–style hierarchy.
+  Load project instruction markdown / .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)
-    2. Walk UP from project_root: each directory's GEMINI.md / .gemcode/GEMINI.md
+    2. Walk UP from project_root: each directory's `gemcode.md` / `GEMINI.md`
        (org-level files at higher dirs, project-level at project_root)
-    3. project_root/GEMINI.md         — the primary project instructions
-    4. project_root/.gemcode/GEMINI.md — alternative location
+    3. project_root/gemcode.md        — the primary project instructions
+    4. project_root/GEMINI.md         — backward-compatible legacy location
+    5. project_root/.gemcode/GEMINI.md — alternative location
     5. project_root/.gemcode/notes.md  — agent auto-generated notes (read-only context)
 
   Max total: 80,000 chars.  Each file is capped at 30,000 chars.
@@ -118,7 +119,14 @@ def _load_gemini_md(project_root: Path) -> str:
   """
   import re
 
-  _NAMES = ("GEMINI.md", "gemini.md", ".gemcode/GEMINI.md")
+  _NAMES = (
+    "gemcode.md",
+    "GEMCODE.md",
+    "GEMINI.md",
+    "gemini.md",
+    ".gemcode/GEMINI.md",
+    ".gemcode/gemini.md",
+  )
   _FILE_CAP = 30_000
   _TOTAL_CAP = 80_000
   _COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
@@ -162,8 +170,15 @@ def _load_gemini_md(project_root: Path) -> str:
     for name in _NAMES:
       _add(ancestor / name)
 
-  # 3+4. Project-root level instructions (primary location)
-  for name in ("GEMINI.md", "gemini.md", ".gemcode/GEMINI.md", ".gemcode/gemini.md"):
+  # 3+5. Project-root level instructions (primary location + compatibility)
+  for name in (
+    "gemcode.md",
+    "GEMCODE.md",
+    "GEMINI.md",
+    "gemini.md",
+    ".gemcode/GEMINI.md",
+    ".gemcode/gemini.md",
+  ):
     _add(project_root / name)
 
   # 5. Agent-generated notes (informational context, not instructions)
@@ -303,6 +318,25 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
   except Exception:
     curated_section = ""
 
+  # ── VeoMem recall (optional) ─────────────────────────────────────────────
+  veomem_section = ""
+  try:
+    t = getattr(cfg, "_veomem_wakeup_text", None)
+    if isinstance(t, str) and t.strip():
+      veomem_section = (
+        "\n\n## VeoMem recall (auto-captured, progressive)\n"
+        "This section is automatically generated from prior tool usage and summaries. "
+        "Treat it as helpful context; do not restate it verbatim to the user.\n"
+        "If you need deeper details about a specific prior observation, use the "
+        "3-step retrieval flow with tools:\n"
+        "- `veomem_search(query=...)` → get an index of relevant observation IDs\n"
+        "- `veomem_timeline(id=...)` → get compact neighbors around an anchor ID\n"
+        "- `veomem_get_observations(ids=...)` → fetch full text for selected IDs\n"
+        f"{t.strip()}\n"
+      )
+  except Exception:
+    veomem_section = ""
+
   return f"""## Runtime facts (authoritative for this session)
 - **Today's date:** {today}
 - **Project root** — every filesystem tool path is relative to: `{root}`
@@ -316,7 +350,7 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 {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}"""
+- **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_memory_section(cfg: GemCodeConfig) -> str:

gemcode/callbacks.py

@@ -525,6 +525,26 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     except Exception:
       pass
 
+    # ── VeoMem (optional): auto-capture tool usage ────────────────────────
+    try:
+      from gemcode.veomem_bridge import record_tool_use
+      sid = None
+      try:
+        if tool_context is not None and getattr(tool_context, "session", None) is not None:
+          sid = getattr(tool_context.session, "id", None)
+      except Exception:
+        sid = None
+      record_tool_use(
+        cfg.project_root,
+        session_id=str(sid) if sid else None,
+        tool_name=name,
+        args=args or {},
+        result=tool_response if isinstance(tool_response, dict) else {},
+        paths=(st.get(_RISK_FILES_TOUCHED, []) or []) if isinstance(st, dict) else None,
+      )
+    except Exception:
+      pass
+
     if _maybe_tool_summary_enabled():
       summary: dict[str, Any] = {
         "phase": "tool_result",

gemcode/cli.py

@@ -7,6 +7,7 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import uuid
 import warnings
@@ -129,18 +130,30 @@ def _initialize_gemcode_project(cfg: GemCodeConfig) -> None:
   """
   root = cfg.project_root.resolve()
   gem_dir = root / ".gemcode"
+  gemcode_md = root / "gemcode.md"
   already_there = gem_dir.is_dir()
   try:
     gem_dir.mkdir(parents=True, exist_ok=True)
   except OSError as e:
     print(f"[gemcode] warning: could not create {gem_dir}: {e}", file=sys.stderr)
     return
+  if not gemcode_md.exists():
+    try:
+      gemcode_md.write_text(
+        "# Project instructions\n\n"
+        "- Describe the project purpose here.\n"
+        "- Add build, test, and lint commands.\n"
+        "- Add architecture notes and conventions GemCode should follow.\n",
+        encoding="utf-8",
+      )
+    except OSError as e:
+      print(f"[gemcode] warning: could not create {gemcode_md}: {e}", file=sys.stderr)
   if not already_there:
     print(
         "\n── GemCode · Project folder ready ──\n"
         f"  Workspace: {root}\n"
         f"  Config & session data: {gem_dir}/\n"
-        "  Optional: add GEMINI.md in the repo root for project context.\n"
+        f"  Project instructions: {gemcode_md.name}\n"
         "── Ready. ──\n",
         file=sys.stderr,
     )
@@ -262,6 +275,100 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       "GemCode CLI is running. Type your prompt and press Enter. (Ctrl+D to exit)",
       file=sys.stderr,
     )
+
+    def _looks_like_new_skill_request(s: str) -> bool:
+      t = (s or "").strip().lower()
+      if not t or t.startswith("/"):
+        return False
+      # Natural language trigger: "make/create/build a new skill/gemskill"
+      return bool(
+        re.search(r"\b(new|create|make|build)\b", t)
+        and re.search(r"\b(gem\s*skill|gemskill|skill)\b", t)
+      )
+
+    def _prompt_nonempty(label: str, default: str | None = None) -> str:
+      while True:
+        try:
+          v = input(label).strip()
+        except EOFError:
+          return default or ""
+        if v:
+          return v
+        if default is not None:
+          return default
+
+    def _wizard_create_gemskill() -> str | None:
+      """
+      Interactive CLI wizard that collects a GemSkill spec, then returns a single
+      model prompt instructing the agent to generate the skill folder/files.
+      """
+      if not (hasattr(sys.stdin, "isatty") and sys.stdin.isatty()):
+        return None
+      print("\n── GemSkill wizard ──", file=sys.stderr)
+      print("We'll create a new skill under `.gemcode/skills/<name>/`.\n", file=sys.stderr)
+      name = _prompt_nonempty("skill name (kebab-case, e.g. api-review): ")
+      name = (name or "").strip().lower()
+      if not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", name):
+        print("Invalid name. Use lowercase letters/numbers/hyphens (max 64 chars).", file=sys.stderr)
+        return None
+      desc = _prompt_nonempty("one-line description: ")
+      when = _prompt_nonempty("when should it be used (1-2 sentences)? ")
+      inputs = _prompt_nonempty("inputs it should accept (bullets or short text): ", default="User request + $ARGUMENTS")
+      outputs = _prompt_nonempty("expected output format (short): ", default="Concise checklist + actionable steps")
+      tools_pref = _prompt_nonempty(
+        "tools: (a)uto, (r)ead-only, (w)eb-research-heavy? [a]: ",
+        default="a",
+      ).strip().lower()
+      use_web = tools_pref.startswith("w")
+      read_only = tools_pref.startswith("r")
+      examples = _prompt_nonempty("example command(s) user will type (optional): ", default="")
+
+      root = cfg.project_root.resolve()
+      skill_dir = root / ".gemcode" / "skills" / name
+      skill_md = skill_dir / "SKILL.md"
+
+      prompt_parts: list[str] = [
+        "You are creating a **GemCode GemSkill**. Generate a new skill folder and files.\n\n",
+        "## Target\n",
+        f"- Project root: {root}\n",
+        f"- Skill directory: {skill_dir}\n",
+        f"- Primary file: {skill_md}\n\n",
+        "## Requirements\n",
+        f"- Skill name: {name}\n",
+        f"- Description: {desc}\n",
+        f"- When to use: {when}\n",
+        f"- Inputs: {inputs}\n",
+        f"- Output expectations: {outputs}\n",
+      ]
+      if examples:
+        prompt_parts.append(f"- Example invocations: {examples}\n")
+      prompt_parts.extend(
+        [
+          "\n",
+          "- Write `SKILL.md` with YAML frontmatter using **multiline-friendly** fields when needed.\n",
+          "- Include: Purpose, When to use, When NOT to use (guardrails), Inputs, Output format, Workflow, Examples.\n",
+          "- Make it **token-efficient**: prefer short checklists and explicit decision gates.\n",
+          "- Avoid vague 'ALWAYS trigger' language; provide precise triggers.\n",
+          "- If you need templates/checklists, create supporting files in a `references/` subfolder and keep them small.\n",
+          "- Do not create CLAUDE.md/AGENTS.md or other vendor-specific files.\n\n",
+          "## Tooling / research policy\n",
+          (
+            "- You MAY use web research to find best practices, but only if it materially improves the skill.\n"
+            if use_web
+            else "- Avoid web research unless strictly necessary.\n"
+          ),
+          ("- Operate in read-only mode: do not write files.\n" if read_only else "- You are allowed to write the skill files.\n"),
+          "\n",
+          "## Execution steps\n",
+          "1. Create the skill directory if missing.\n",
+          "2. Write `SKILL.md` (and any supporting files).\n",
+          "3. Validate the YAML frontmatter parses and the skill is usable.\n",
+          f"4. Print a short confirmation: created files + how to invoke (e.g. `/skills list`, `/{name} ...`, `/gemskill {name}`).\n",
+        ]
+      )
+      prompt = "".join(prompt_parts)
+      return prompt
+
     while True:
       try:
         raw = input("> ")
@@ -274,6 +381,12 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       if prompt_text in (":q", "quit", "exit", "/exit"):
         break
 
+      # Natural language shortcut: "I want to make a new skill" => wizard.
+      if _looks_like_new_skill_request(prompt_text):
+        wizard_prompt = _wizard_create_gemskill()
+        if wizard_prompt:
+          prompt_text = wizard_prompt
+
       cfg.session_skill_expand_session_id = session_id
       slash = await process_repl_slash(
           cfg=cfg,

gemcode/config.py

@@ -232,7 +232,9 @@ class GemCodeConfig:
   # Deep research model id used when routing selects deep research.
   model_deep_research: str = field(
     default_factory=lambda: os.environ.get(
-      "GEMCODE_MODEL_DEEP_RESEARCH", "travel_explore"
+      # Leave empty by default so routing falls back to `cfg.model` unless the
+      # user explicitly configures a deep-research-capable model id.
+      "GEMCODE_MODEL_DEEP_RESEARCH", ""
     )
   )
 

gemcode/ide_stdio.py

@@ -322,7 +322,13 @@ async def run_stdio_loop() -> int:
           continue
       out_text = "".join(txt_parts).strip()
       if out_text:
-        emitter.send(make_event(event="text", id=req_id, text=out_text))
+        # Pseudo-streaming: emit deltas so IDE chat can feel alive even though
+        # we only have the final assistant text today.
+        emitter.send(make_event(event="text_start", id=req_id))
+        chunk_size = 450
+        for i in range(0, len(out_text), chunk_size):
+          emitter.send(make_event(event="text_delta", id=req_id, text=out_text[i : i + chunk_size]))
+        emitter.send(make_event(event="text_end", id=req_id))
       emitter.send(make_response(id=req_id, ok=True, session=session_id))
 
   finally:

gemcode/plugins/terminal_hooks_plugin.py

@@ -189,5 +189,36 @@ class GemCodeTerminalHooksPlugin(BasePlugin):
         {"phase": "post_turn_hook", "ok": False, "error": str(e)},
       )
 
+    # ── VeoMem (optional): store final assistant summary ───────────────────
+    try:
+      # Best-effort: extract last assistant text from session events.
+      txt = ""
+      try:
+        events = callback_context.session.events or []
+        for ev in reversed(events):
+          if getattr(ev, "author", None) == getattr(agent, "name", "gemcode"):
+            content = getattr(ev, "content", None)
+            parts = getattr(content, "parts", None) if content is not None else None
+            if parts:
+              out_parts = []
+              for p in parts:
+                t = getattr(p, "text", None)
+                if t:
+                  out_parts.append(t)
+              if out_parts:
+                txt = "".join(out_parts).strip()
+                break
+      except Exception:
+        txt = ""
+      if txt:
+        from gemcode.veomem_bridge import record_turn_summary
+        record_turn_summary(
+          self.cfg.project_root,
+          session_id=str(callback_context.session.id),
+          text=txt,
+        )
+    except Exception:
+      pass
+
     return None
 

gemcode/repl_commands.py

@@ -337,6 +337,7 @@ def slash_help_lines() -> list[str]:
       "  /notes clear          Delete all notes",
       "  /notes edit           Open notes in $EDITOR",
       "  /create gemskill <name> [description]  Create a new GemSkill (SKILL.md scaffold)",
+      "                        Tip: you can also type “I want to make a new skill” and follow the wizard",
       "  /gemskill <name>        Load an existing GemSkill into this session (system prompt)",
       "  /gemskill list|clear    List skills or unload all session-loaded skills",
       "  /append gemskill <name> <request>  Ask the agent to edit that skill file",

gemcode/repl_slash.py

@@ -8,8 +8,10 @@ Returns ``None`` when the line is not a slash command; otherwise a
 from __future__ import annotations
 
 import os
+import shlex
 import uuid
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable, Iterable
 
 from gemcode.config import GemCodeConfig
@@ -98,11 +100,26 @@ async def process_repl_slash(
       out("  /attach clear    Clear the queue")
       out("Aliases: /file, /image, /img — same queue.")
       out("Types: Gemini-supported MIME (e.g. images, PDF, audio, video, text). Default max ~20 MiB each.")
+      out("Inline prompt: /image <path> <prompt...>  (or use `--` before the prompt)")
       out("CLI:  gemcode -C . --attach ./doc.pdf \"Summarize this\"")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    low_i = raw_i.lower()
-    if low_i == "list":
+
+    # Parse args as:
+    # - list|clear (no further args)
+    # - <path> [--] <optional prompt...>
+    #
+    # We support quoted paths and best-effort unquoted paths with spaces by
+    # scanning for the longest prefix that resolves to an existing file.
+    try:
+      tokens = shlex.split(raw_i, posix=True)
+    except ValueError:
+      tokens = raw_i.split()
+
+    if not tokens:
+      return ReplSlashResult(skip_model_turn=True)
+
+    if len(tokens) == 1 and tokens[0].strip().lower() == "list":
       pend = cfg.pending_attachment_paths
       if not pend:
         out("(no attachments queued)")
@@ -112,15 +129,43 @@ async def process_repl_slash(
           out(f"  {i}. {p}")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    if low_i == "clear":
+    if len(tokens) == 1 and tokens[0].strip().lower() == "clear":
       cfg.pending_attachment_paths.clear()
       out("Attachment queue cleared.")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    resolved = resolve_attachment_path(raw_i, project_root=cfg.project_root)
+
+    # Find the longest token prefix that resolves to a real file.
+    best_i: int | None = None
+    best_resolved: Path | None = None
+    for i in range(1, len(tokens) + 1):
+      cand = " ".join(tokens[:i]).strip()
+      if not cand:
+        continue
+      resolved_try = resolve_attachment_path(cand, project_root=cfg.project_root)
+      if resolved_try.is_file():
+        best_i = i
+        best_resolved = resolved_try
+
+    # Fallback: treat first token as the path (keeps old behavior).
+    if best_i is None or best_resolved is None:
+      path_raw = tokens[0]
+      resolved = resolve_attachment_path(path_raw, project_root=cfg.project_root)
+      remainder_tokens = tokens[1:]
+    else:
+      path_raw = " ".join(tokens[:best_i]).strip()
+      resolved = best_resolved
+      remainder_tokens = tokens[best_i:]
+
+    if remainder_tokens and remainder_tokens[0] == "--":
+      remainder_tokens = remainder_tokens[1:]
+    trailing_prompt = " ".join(remainder_tokens).strip()
+
     if not resolved.is_file():
-      out(f"Not a file: {raw_i}")
+      out(f"Not a file: {path_raw}")
       out("(Resolved relative to cwd, then project root.)")
+      if trailing_prompt:
+        out("Tip: quote paths with spaces, e.g. /image \"./My File.png\" analyze this")
       out()
       return ReplSlashResult(skip_model_turn=True)
     if len(cfg.pending_attachment_paths) >= 16:
@@ -128,6 +173,11 @@ async def process_repl_slash(
       out()
       return ReplSlashResult(skip_model_turn=True)
     cfg.pending_attachment_paths.append(resolved)
+    if trailing_prompt:
+      out(f"Queued: {resolved} (attaching now)")
+      out()
+      return ReplSlashResult(model_prompt=trailing_prompt)
+
     out(f"Queued: {resolved}")
     out(f"  ({len(cfg.pending_attachment_paths)} file(s) — send your next message to attach)")
     out()
@@ -160,14 +210,22 @@ async def process_repl_slash(
       out("Tip: /skills list")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    expanded = expand_skill_text(s, arguments=sk_args, session_id=session_id)
+    # Token-efficient one-shot invocation: do NOT inline the full SKILL.md.
+    # Instead, point the model at the skill and require it to load/read it as needed.
     files = list_supporting_files(s)
-    prompt = (
-      f"Apply GemSkill `/{s.meta.name}`.\n\n"
-      f"## Skill instructions\n{expanded}\n\n"
-      + (f"## Skill supporting files\n{', '.join(files)}\n\n" if files else "")
-      + "Now carry out the user's request using the skill instructions."
-    )
+    prompt_parts = [
+      f"User invoked GemSkill `/{s.meta.name}`.\n\n",
+      f"## Arguments\n{sk_args or '(none)'}\n\n",
+      "## Instructions\n",
+      "1. Load the skill instructions using the `load_skill` tool (preferred) or by reading the SKILL.md file.\n",
+      "2. Only read supporting files if needed (keep it efficient).\n",
+      "3. Then carry out the user's request.\n\n",
+      f"## Skill file\n{s.skill_md}\n\n",
+    ]
+    if files:
+      prompt_parts.append(f"## Supporting files (optional)\n{', '.join(files)}\n\n")
+    prompt_parts.append("Now proceed.")
+    prompt = "".join(prompt_parts)
     return ReplSlashResult(model_prompt=prompt)
 
   # ── /gemskill (load full skill into session system prompt) ────────────────
@@ -1114,15 +1172,15 @@ async def process_repl_slash(
     return ReplSlashResult(skip_model_turn=True)
 
   if name == "init":
-    gemini_md = cfg.project_root / "GEMINI.md"
-    if gemini_md.exists() and (sc.args or "").strip().lower() not in ("force", "overwrite", "-f"):
-      out(f"GEMINI.md already exists at {gemini_md}.")
+    gemcode_md = cfg.project_root / "gemcode.md"
+    if gemcode_md.exists() and (sc.args or "").strip().lower() not in ("force", "overwrite", "-f"):
+      out(f"gemcode.md already exists at {gemcode_md}.")
       out("Use /init force to regenerate it, or edit it manually.")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    # Dispatch to the model to analyze the project and write GEMINI.md.
+    # Dispatch to the model to analyze the project and write gemcode.md.
     init_prompt = (
-      "Analyze this codebase and generate a GEMINI.md file for me.\n\n"
+      "Analyze this codebase and generate a gemcode.md file for me.\n\n"
       "To do this:\n"
       "1. Run `list_directory('.')` to understand the project structure\n"
       "2. Read `package.json`, `pyproject.toml`, `go.mod`, `Cargo.toml`, `README.md` "
@@ -1130,9 +1188,9 @@ async def process_repl_slash(
       "3. Look at the source directory structure (src/, lib/, app/, etc.)\n"
       "4. Check for test directories and test runner config\n"
       "5. Look for linting/formatting config files (.eslintrc, .prettierrc, ruff.toml, etc.)\n\n"
-      "Write **only** to `GEMINI.md` at the project root. Do **not** create "
+      "Write **only** to `gemcode.md` at the project root. Do **not** create "
       "`CLAUDE.md`, `AGENTS.md`, `.cursorrules`, or similar.\n\n"
-      "Then write a GEMINI.md file at the project root containing:\n"
+      "Then write a gemcode.md file at the project root containing:\n"
       "# Project Name\n"
       "One-sentence description.\n\n"
       "## Build & Test\n"
@@ -1150,10 +1208,10 @@ async def process_repl_slash(
       "## Workflow\n"
       "- Any git branching rules from README or CONTRIBUTING\n"
       "- PR/commit conventions\n\n"
-      "Keep it under 200 lines. Write the file to GEMINI.md now."
+      "Keep it under 200 lines. Write the file to gemcode.md now."
     )
-    out("Analyzing project to generate GEMINI.md…")
-    out("(GemCode will read the project structure and write a starting GEMINI.md)")
+    out("Analyzing project to generate gemcode.md…")
+    out("(GemCode will read the project structure and write a starting gemcode.md)")
     out()
     return ReplSlashResult(model_prompt=init_prompt)
 

gemcode/session_runtime.py

@@ -368,6 +368,21 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
   except Exception:
     pass
 
+  # VeoMem wake-up snapshot (optional): load once per session and keep stable.
+  try:
+    import os
+    if os.environ.get("GEMCODE_VEOMEM", "").strip().lower() in ("1", "true", "yes", "on"):
+      from veomem.wakeup import build_wake_up_context  # type: ignore[import-not-found]
+      # Ensure store exists; build_wake_up_context can work even if empty.
+      from veomem.store import init_store  # type: ignore[import-not-found]
+
+      init_store(cfg.project_root)
+      snap2 = build_wake_up_context(cfg.project_root, max_chars=5000, limit=30)
+      txt = (snap2.get("text") if isinstance(snap2, dict) else "") or ""
+      object.__setattr__(cfg, "_veomem_wakeup_text", txt.strip() if isinstance(txt, str) else "")
+  except Exception:
+    pass
+
   # ── MCP toolsets from .gemcode/mcp.json ─────────────────────────────────
   # Supports stdio, http (Streamable HTTP), and sse connection types.
   try:
@@ -389,6 +404,46 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
   except Exception:
     pass  # OpenAPIToolset not in this ADK version — continue without
 
+  # ── AFC compatibility prompt (optional) ───────────────────────────────────
+  # Gemini Automatic Function Calling (AFC) only works when the tool list is
+  # composed of Python callables. Some ADK toolsets (MCP/OpenAPI/built-in
+  # declarations) may be non-callable and cause AFC to be disabled.
+  #
+  # If we're in an interactive terminal and the user opted into prompting,
+  # ask whether to keep "all tools" (AFC disabled) or restrict to callables
+  # (AFC enabled).
+  try:
+    import os
+    import sys
+
+    prompt_afc = os.environ.get("GEMCODE_AFC_PROMPT", "1").strip().lower() in ("1", "true", "yes", "on")
+    if prompt_afc and hasattr(sys.stdin, "isatty") and sys.stdin.isatty():
+      tools_list = list(merged_extra_tools or [])
+      noncallable = [t for t in tools_list if not callable(t)]
+      if noncallable and getattr(cfg, "_afc_choice", None) not in ("all", "callables"):
+        print(
+          "\n[gemcode] AFC compatibility\n"
+          "Gemini Automatic Function Calling (AFC) works best with Python callables only.\n"
+          "Some enabled toolsets appear non-callable, which can disable AFC.\n\n"
+          "Choose tool mode for this session:\n"
+          "  [Enter] all tools (recommended; AFC may be disabled)\n"
+          "  c       callable-only tools (keeps AFC; disables MCP/OpenAPI/toolsets)\n",
+          file=sys.stderr,
+        )
+        try:
+          ans = input("afc> ").strip().lower()
+        except EOFError:
+          ans = ""
+        if ans.startswith("c"):
+          object.__setattr__(cfg, "_afc_choice", "callables")
+        else:
+          object.__setattr__(cfg, "_afc_choice", "all")
+
+      if getattr(cfg, "_afc_choice", None) == "callables":
+        merged_extra_tools = [t for t in tools_list if callable(t)] or None
+  except Exception:
+    pass
+
   # Computer-use: ADK ComputerUseToolset backed by our Playwright BrowserComputer.
   # Probe Playwright BEFORE building the agent so model routing (which runs
   # inside build_root_agent → pick_effective_model) never switches to

gemcode/skills.py

@@ -135,11 +135,16 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
 
   Supported:
   - key: value (single-line)
+  - key: >
+      multi-line
+    (folded; newlines become spaces)
+  - key: |
+      multi-line
+    (literal; newlines preserved)
   - key: [a, b]  (parsed as a string; caller can split if needed)
 
   Not supported:
   - nested objects
-  - multi-line scalars
   - full YAML spec
   """
   m = _FRONTMATTER_RE.match(text or "")
@@ -148,18 +153,58 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
   raw = m.group(1)
   body = (text or "")[m.end() :]
   d: dict[str, str] = {}
-  for line in raw.splitlines():
+  lines = raw.splitlines()
+  i = 0
+  while i < len(lines):
+    line = lines[i]
     if not line.strip() or line.strip().startswith("#"):
+      i += 1
       continue
     if ":" not in line:
+      i += 1
       continue
     k, v = line.split(":", 1)
     k = k.strip()
-    v = v.strip()
+    v = v.rstrip()
+    v_stripped = v.strip()
+
+    # Multi-line scalar blocks: `key: >` or `key: |` followed by indented lines.
+    if v_stripped in (">", "|"):
+      style = v_stripped
+      block: list[str] = []
+      i += 1
+      while i < len(lines):
+        nxt = lines[i]
+        # YAML block scalars require indentation. We accept 2+ spaces or a tab.
+        if not (nxt.startswith("  ") or nxt.startswith("\t")):
+          break
+        block.append(nxt.lstrip(" \t"))
+        i += 1
+      if style == ">":
+        # folded: join non-empty lines with spaces; keep paragraph breaks as newline.
+        paras: list[str] = []
+        cur: list[str] = []
+        for ln in block:
+          if not ln.strip():
+            if cur:
+              paras.append(" ".join(x.strip() for x in cur if x.strip()))
+              cur = []
+            continue
+          cur.append(ln)
+        if cur:
+          paras.append(" ".join(x.strip() for x in cur if x.strip()))
+        d[k.lower()] = "\n".join(paras).strip()
+      else:
+        d[k.lower()] = "\n".join(block).rstrip()
+      continue
+
+    # Single-line scalar
+    v2 = v_stripped
     # Strip simple surrounding quotes
-    if len(v) >= 2 and ((v[0] == v[-1] == '"') or (v[0] == v[-1] == "'")):
-      v = v[1:-1]
-    d[k.lower()] = v
+    if len(v2) >= 2 and ((v2[0] == v2[-1] == '"') or (v2[0] == v2[-1] == "'")):
+      v2 = v2[1:-1]
+    d[k.lower()] = v2
+    i += 1
   return d, body