gemcode 0.3.81__tar.gz → 0.3.85__tar.gz

{gemcode-0.3.81/src/gemcode.egg-info → gemcode-0.3.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.81
+Version: 0.3.85
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -381,6 +381,7 @@ State is **project-local** (unless noted).
 | `policy.json` | Self-tuning profile for dynamic token / evidence budgets. |
 | `memories.jsonl` | Embedding-backed memory when `GEMCODE_ENABLE_MEMORY=1`. |
 | `notes.md` | Agent notes surfaced via `/notes`. |
+| `wal.jsonl` | Write-ahead log for curated memory + compression actions (metadata only). |
 | `evals/last_eval.json` | Latest `gemcode eval` record. |
 | `evals/autotune_ledger.jsonl` | Rows from `gemcode autotune eval`. |
 | `skills/<name>/SKILL.md` | **GemSkills** (project-scoped; see [GemSkills](#gemskills)). |
@@ -573,10 +574,16 @@ The TUI (when `GEMCODE_TUI=1` and terminal supports it) provides **slash complet
 - **Discovery:** Only **metadata** (name + description) is preloaded into context for token efficiency. Full body loads **on demand** via `/skill <name>`, `/<name>`, or tools `load_skill` / `list_skills`.
 - **Built-in:** **`batch`** — parallel large-change workflow (map → units → `run_subtask` → verify). Exposed as `/batch <goal>`; not auto-invoked by the model (`disable_model_invocation`).
 
-- **`/create gemskill <name>`** — create a new skill directory.
+- **`/create gemskill <name>`** — create a new skill directory (scaffold).
+- **Interactive wizard (CLI)**: if you type something like “I want to make a new skill” in the REPL, GemCode will switch into a short **GemSkill wizard** (name/description/spec) and then generate the full skill folder for you.
 - **`/gemskill <name>`** — pin the full skill body into the system prompt for this session.
 - **`/append gemskill <name> <text>`** — one-shot turn for the model to revise that skill on disk.
 
+### Frontmatter notes (compatibility)
+GemCode supports common YAML frontmatter styles including multi-line scalars like:
+- `description: >` (folded)
+- `description: |` (literal)
+
 ---
 
 ## Curated memory
@@ -590,6 +597,13 @@ Legacy filenames **`.gemcode/MEMORY.md`** and **`.gemcode/USER.md`** are still r
 
 Content is **sanitized** before append (length and sensitivity heuristics). The REPL command **`/curated`** prints a bounded snapshot of what would be injected. When the **memory** capability is enabled, curated material can be combined with broader memory tools—see **`remember_fact`**, **`read_curated_memory`** in the [function tools](#function-tools-catalog) table.
 
+### Query sanitization (tooling)
+
+Some tools sanitize long “contaminated” queries (e.g. accidental system-prompt prefixes) down to a short, likely-intended query. This currently applies to:
+
+- `web_search(query=...)`
+- `semantic_search_files(query=...)` (when `--embeddings` is on)
+
 ---
 
 ## Workspace trust

{gemcode-0.3.81 → gemcode-0.3.85}/README.md

@@ -192,6 +192,7 @@ State is **project-local** (unless noted).
 | `policy.json` | Self-tuning profile for dynamic token / evidence budgets. |
 | `memories.jsonl` | Embedding-backed memory when `GEMCODE_ENABLE_MEMORY=1`. |
 | `notes.md` | Agent notes surfaced via `/notes`. |
+| `wal.jsonl` | Write-ahead log for curated memory + compression actions (metadata only). |
 | `evals/last_eval.json` | Latest `gemcode eval` record. |
 | `evals/autotune_ledger.jsonl` | Rows from `gemcode autotune eval`. |
 | `skills/<name>/SKILL.md` | **GemSkills** (project-scoped; see [GemSkills](#gemskills)). |
@@ -384,10 +385,16 @@ The TUI (when `GEMCODE_TUI=1` and terminal supports it) provides **slash complet
 - **Discovery:** Only **metadata** (name + description) is preloaded into context for token efficiency. Full body loads **on demand** via `/skill <name>`, `/<name>`, or tools `load_skill` / `list_skills`.
 - **Built-in:** **`batch`** — parallel large-change workflow (map → units → `run_subtask` → verify). Exposed as `/batch <goal>`; not auto-invoked by the model (`disable_model_invocation`).
 
-- **`/create gemskill <name>`** — create a new skill directory.
+- **`/create gemskill <name>`** — create a new skill directory (scaffold).
+- **Interactive wizard (CLI)**: if you type something like “I want to make a new skill” in the REPL, GemCode will switch into a short **GemSkill wizard** (name/description/spec) and then generate the full skill folder for you.
 - **`/gemskill <name>`** — pin the full skill body into the system prompt for this session.
 - **`/append gemskill <name> <text>`** — one-shot turn for the model to revise that skill on disk.
 
+### Frontmatter notes (compatibility)
+GemCode supports common YAML frontmatter styles including multi-line scalars like:
+- `description: >` (folded)
+- `description: |` (literal)
+
 ---
 
 ## Curated memory
@@ -401,6 +408,13 @@ Legacy filenames **`.gemcode/MEMORY.md`** and **`.gemcode/USER.md`** are still r
 
 Content is **sanitized** before append (length and sensitivity heuristics). The REPL command **`/curated`** prints a bounded snapshot of what would be injected. When the **memory** capability is enabled, curated material can be combined with broader memory tools—see **`remember_fact`**, **`read_curated_memory`** in the [function tools](#function-tools-catalog) table.
 
+### Query sanitization (tooling)
+
+Some tools sanitize long “contaminated” queries (e.g. accidental system-prompt prefixes) down to a short, likely-intended query. This currently applies to:
+
+- `web_search(query=...)`
+- `semantic_search_files(query=...)` (when `--embeddings` is on)
+
 ---
 
 ## Workspace trust

{gemcode-0.3.81 → gemcode-0.3.85}/pyproject.toml

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

{gemcode-0.3.81 → gemcode-0.3.85}/src/gemcode/agent.py

@@ -303,6 +303,20 @@ 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"
+        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 +330,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-0.3.81 → gemcode-0.3.85}/src/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-0.3.81 → gemcode-0.3.85}/src/gemcode/cli.py

@@ -7,6 +7,7 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import uuid
 import warnings
@@ -262,6 +263,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 +369,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-0.3.81 → gemcode-0.3.85}/src/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-0.3.81 → gemcode-0.3.85}/src/gemcode/curated_memory.py

@@ -22,6 +22,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
+from gemcode.wal import append_wal_event, wal_text_fingerprint
+
 
 _SUSPICIOUS = [
   "api_key",
@@ -106,5 +108,15 @@ def append_fact(project_root: Path, *, target: str, text: str) -> dict[str, Any]
   ts = datetime.now().strftime("%Y-%m-%d %H:%M")
   entry = f"\n<!-- {ts} -->\n- {stripped}\n"
   p.write_text(cur + entry, encoding="utf-8")
+  # Best-effort WAL: do not store raw text.
+  append_wal_event(
+    project_root,
+    type="curated_memory.append_fact",
+    data={
+      "target": (target or "").strip().lower() or "memory",
+      "path": str(p),
+      "fingerprint": wal_text_fingerprint(stripped),
+    },
+  )
   return {"status": "appended", "path": str(p)}
 

{gemcode-0.3.81 → gemcode-0.3.85}/src/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-0.3.81 → gemcode-0.3.85}/src/gemcode/modality_tools.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import Any
 
 from gemcode.config import GemCodeConfig
+from gemcode.query_sanitizer import sanitize_tool_query
 
 
 def _get_embedding_client():
@@ -76,6 +77,10 @@ async def semantic_search_files(
   """
   if not isinstance(query, str) or not query.strip():
     return {"error": "query must be a non-empty string"}
+  s = sanitize_tool_query(query)
+  query = str(s.get("clean_query") or "").strip()
+  if not query:
+    return {"error": "query must be a non-empty string"}
 
   root = Path(project_root).resolve() if project_root else None
   if root is None:
@@ -165,7 +170,13 @@ async def semantic_search_files(
     snippet = chunks[idx][:500].replace("\n", " ")
     matches.append({"path": rel, "snippet": snippet, "score": score})
 
-  return {"query": query, "backend": "embeddings", "matches": matches}
+  return {
+    "query": query,
+    "query_sanitized": bool(s.get("was_sanitized")),
+    "query_sanitizer_method": str(s.get("method")),
+    "backend": "embeddings",
+    "matches": matches,
+  }
 
 
 def build_extra_tools(cfg: GemCodeConfig) -> list[Any]:

{gemcode-0.3.81 → gemcode-0.3.85}/src/gemcode/output_styles.py

@@ -16,11 +16,18 @@ def _is_valid_name(name: str) -> bool:
   return bool(re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", name or ""))
 
 
+def _builtin_style_dir() -> Path:
+  # Built-in styles shipped with GemCode (lowest priority).
+  # Located under the python package so they work out-of-the-box.
+  return Path(__file__).resolve().parent / "builtin" / "output-styles"
+
+
 def _style_dirs_for_project(project_root: Path) -> list[Path]:
-  # Project has priority over personal.
+  # Priority (highest last): project > personal > built-in.
   return [
     project_root / ".gemcode" / "output-styles",
     Path.home() / ".gemcode" / "output-styles",
+    _builtin_style_dir(),
   ]
 
 

{gemcode-0.3.81 → gemcode-0.3.85}/src/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-0.3.85/src/gemcode/query_sanitizer.py

@@ -0,0 +1,87 @@
+"""
+Mitigate "system prompt contamination" in tool queries.
+
+Inspired by MemPalace's query sanitizer. Goal: prevent catastrophic search degradation
+when an agent accidentally prefixes a long system instruction to a short query.
+"""
+
+from __future__ import annotations
+
+import re
+
+MAX_QUERY_LENGTH = 250
+SAFE_QUERY_LENGTH = 200
+MIN_QUERY_LENGTH = 10
+
+_SENTENCE_SPLIT = re.compile(r"[.!?。！？\n]+")
+_QUESTION_MARK = re.compile(r'[?？]\s*["\']?\s*$')
+_QUOTE_CHARS = {"'", '"'}
+
+
+def sanitize_tool_query(raw_query: str) -> dict[str, object]:
+  """
+  Return a best-effort clean query.
+
+  Returns dict:
+    clean_query: str
+    was_sanitized: bool
+    method: str
+  """
+  if not raw_query or not str(raw_query).strip():
+    return {"clean_query": "", "was_sanitized": False, "method": "empty"}
+
+  raw_query = str(raw_query).strip()
+  n = len(raw_query)
+
+  def _strip_wrapping_quotes(s: str) -> str:
+    s = (s or "").strip()
+    while len(s) >= 2 and s[:1] in _QUOTE_CHARS and s[:1] == s[-1:]:
+      s = s[1:-1].strip()
+    if not s:
+      return ""
+    if s[:1] in _QUOTE_CHARS:
+      s = s[1:].strip()
+    if s[-1:] in _QUOTE_CHARS:
+      s = s[:-1].strip()
+    return s
+
+  def _trim_candidate(s: str) -> str:
+    s = _strip_wrapping_quotes(s)
+    if len(s) <= MAX_QUERY_LENGTH:
+      return s
+    frags = [_strip_wrapping_quotes(x) for x in _SENTENCE_SPLIT.split(s) if x.strip()]
+    for frag in reversed(frags):
+      if MIN_QUERY_LENGTH <= len(frag) <= MAX_QUERY_LENGTH:
+        return frag
+    return s[-MAX_QUERY_LENGTH:].strip()
+
+  if n <= SAFE_QUERY_LENGTH:
+    return {"clean_query": raw_query, "was_sanitized": False, "method": "passthrough"}
+
+  # Prefer last question-looking segment.
+  segments = [s.strip() for s in raw_query.split("\n") if s.strip()]
+  question_candidates: list[str] = []
+  for seg in reversed(segments):
+    if _QUESTION_MARK.search(seg):
+      question_candidates.append(seg)
+  if not question_candidates:
+    sentences = [s.strip() for s in _SENTENCE_SPLIT.split(raw_query) if s.strip()]
+    for sent in reversed(sentences):
+      if "?" in sent or "？" in sent:
+        question_candidates.append(sent)
+
+  if question_candidates:
+    cand = _trim_candidate(question_candidates[0])
+    if len(cand) >= MIN_QUERY_LENGTH:
+      return {"clean_query": cand, "was_sanitized": True, "method": "question_extraction"}
+
+  # Otherwise take the last meaningful segment.
+  for seg in reversed(segments):
+    cand = _trim_candidate(seg)
+    if len(cand) >= MIN_QUERY_LENGTH:
+      return {"clean_query": cand, "was_sanitized": True, "method": "tail_sentence"}
+
+  # Fallback: tail truncation.
+  cand = raw_query[-MAX_QUERY_LENGTH:].strip()
+  return {"clean_query": cand, "was_sanitized": True, "method": "tail_truncation"}
+

{gemcode-0.3.81 → gemcode-0.3.85}/src/gemcode/repl_commands.py

@@ -208,6 +208,8 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("audit",       "Tail audit.log  ·  /logs same"),
     ("autotune",    "Branch + eval ledger  ·  /autotune init <tag>  ·  /autotune eval"),
     ("batch",       "Built-in batch GemSkill (large parallel changes)"),
+    ("caveman",     "Terse output mode  ·  /caveman lite|full|ultra|wenyan|off"),
+    ("caveman:compress", "Compress memory file  ·  /caveman:compress <path> [lite|full|ultra]"),
     ("budget",      "Per-turn token budget  ·  /token-budget same"),
     ("caps",        "Capabilities  ·  /capabilities /capability same"),
     ("clear",       "Fresh session  ·  same as /session new"),
@@ -335,9 +337,11 @@ 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",
+      "  /caveman [level]|off    Terse output mode (like caveman-speak). Levels: lite|full|ultra|wenyan-lite|wenyan|wenyan-ultra",
       "  /style                List available output styles",
       "  /style <name>|off     Activate an output style for this session",
       "  /rules                Show loaded rule files (from .gemcode/rules/)",