diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index 6f29b6b..774ed9b 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -1670,6 +1670,29 @@
         "security",
         "compliance"
       ]
+    },
+    {
+      "name": "antigravity",
+      "source": "./plugins/antigravity",
+      "description": "A local NotebookLM for Claude Code. /agy:notebook sweeps a whole folder of documents (PDFs, scans, images, docx) through Google's Antigravity CLI (agy / Gemini 3.x, multimodal) and writes per-document summaries, a relevance index, a cited master synthesis, a timeline and an entity sheet; /agy:notebook-ask answers questions over them with citations — keeping the heavy reading off Claude's context. Also transcribes audio/video (/agy:transcribe, /agy:media), deep web research, browser-walkthrough recording, web scraping, document-to-markdown and design review. No Node runtime.",
+      "version": "0.7.0",
+      "author": {
+        "name": "Marcos Nahuel Albornoz",
+        "email": "contact@traidai.com"
+      },
+      "category": "Documentation",
+      "homepage": "https://github.com/MarcosNahuel/antigravity-plugin-cc",
+      "keywords": [
+        "notebooklm",
+        "document-analysis",
+        "rag",
+        "audio-transcription",
+        "video-summarization",
+        "multimodal",
+        "deep-research",
+        "gemini",
+        "agy"
+      ]
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/plugins/antigravity/.claude-plugin/plugin.json b/plugins/antigravity/.claude-plugin/plugin.json
new file mode 100644
index 0000000..0c9a915
--- /dev/null
+++ b/plugins/antigravity/.claude-plugin/plugin.json
@@ -0,0 +1,57 @@
+{
+  "name": "antigravity",
+  "version": "0.7.2",
+  "description": "Antigravity plugin for Claude Code with TRAID Design System: 5 canonical HTML templates (traid-dark, traid-light, stripe-press, notion-docs, magazine) for branded report generation from markdown. Plus audio & video transcription (/agy:transcribe, /agy:media), a local NotebookLM (/agy:notebook — sweep a folder of documents into objective-driven summaries + a relevance index + a cited master synthesis, with all heavy reading offloaded to agy), quick one-shot prompts, git-diff code review, deep web research with citations, code rescue, task delegation, browser walkthrough recording, structured web scraping, document-to-markdown conversion, and visual/UX design review via Google Antigravity CLI (agy / Gemini 3.x). Fifteen slash commands — /agy:notebook, /agy:notebook-ask, /agy:transcribe, /agy:media, /agy:model, /agy:report, /agy:ask, /agy:review, /agy:research, /agy:rescue, /agy:record, /agy:scrape, /agy:doc-to-md, /agy:design-review, /agy:setup — with `--background` support on long-running modes, --template and --images (native/external/none) on /agy:report, full issue #76 handling (write_file workaround + transcript.jsonl recovery + headless auth-timeout detection + stdin-hang fix), and Windows rename-bug mitigation (pre-flight .tmp sweep + retry on output-file miss). No Node.js runtime.",
+  "author": {
+    "name": "Marcos Nahuel Albornoz",
+    "email": "contact@traidai.com",
+    "url": "https://github.com/MarcosNahuel"
+  },
+  "homepage": "https://github.com/MarcosNahuel/antigravity-plugin-cc",
+  "repository": "https://github.com/MarcosNahuel/antigravity-plugin-cc",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "antigravity",
+    "agy",
+    "gemini",
+    "gemini-3-5",
+    "deep-research",
+    "web-search",
+    "research-tool",
+    "ai-agents",
+    "llm-tools",
+    "agentic-engineering",
+    "anthropic",
+    "subagent",
+    "task-delegation",
+    "browser-recording",
+    "screencast",
+    "demo-video",
+    "web-scraping",
+    "structured-extraction",
+    "pdf-to-markdown",
+    "docx-to-markdown",
+    "multimodal-conversion",
+    "design-review",
+    "ux-audit",
+    "visual-audit",
+    "code-review",
+    "git-diff",
+    "background-tasks",
+    "html-report",
+    "infographic",
+    "imagen",
+    "markdown-to-html",
+    "windows-mitigation",
+    "design-system",
+    "traid-brand",
+    "template-gallery",
+    "notebooklm",
+    "notebooklm-alternative",
+    "document-summary",
+    "local-rag",
+    "expediente"
+  ]
+}
diff --git a/plugins/antigravity/agents/agy-rescue.md b/plugins/antigravity/agents/agy-rescue.md
new file mode 100644
index 0000000..320ebb1
--- /dev/null
+++ b/plugins/antigravity/agents/agy-rescue.md
@@ -0,0 +1,1112 @@
+---
+name: agy-rescue
+description: Forwards a coding/diagnosis/research/recording/scraping/conversion/design-review/code-review/one-shot-ask request to the Google Antigravity CLI (agy) via --print mode. Use proactively when Claude should hand a substantial task, a quick one-shot prompt, a git-diff code review, deep web research, a browser walkthrough recording, structured web scraping, document-to-markdown conversion, or visual/UX design review to agy (Gemini 3.x with native web search, browser subagent, multimodal vision, and agentic tools).
+tools: Bash, Write
+---
+
+You are a thin forwarding wrapper around `agy --print`. Your job is to invoke `agy` once with the prepared prompt and return its result to the caller.
+
+## Resolving the agy binary
+
+Resolve the binary in this order (first one that exists wins):
+
+1. The `AGY_BIN` environment variable, if set.
+2. `agy` on PATH (Linux, macOS, and Windows once the installer has updated PATH).
+3. Windows fallback: `${LOCALAPPDATA}/agy/bin/agy.exe` (or its POSIX form `/c/Users/<user>/AppData/Local/agy/bin/agy.exe` if you are invoking from Git Bash).
+4. macOS/Linux fallback: `${HOME}/.local/bin/agy`.
+
+If none of these exist, stop and tell the caller to install Antigravity (see https://antigravity.google/cli). Do NOT try to install it yourself.
+
+Prefer using `agy` directly if PATH resolves it — that's the cross-platform default.
+
+## Invocation contract (CRITICAL — flag order matters)
+
+Use exactly ONE `Bash` call for the agy invocation. The base command shape is:
+
+```bash
+agy --dangerously-skip-permissions [--add-dir <CWD>] --print-timeout <TIMEOUT> [--continue] --print "<PROMPT>" < /dev/null
+```
+
+**Flag order rules (LEARNED THE HARD WAY):**
+
+- **`--print` MUST be the LAST flag before the prompt.** Go's flag parser treats `--print` as a value-taking flag (it consumes the next token as the prompt). If you put `--print` anywhere other than at the end, it will eat the next flag (e.g., `--print --dangerously-skip-permissions` parses as `--print="--dangerously-skip-permissions"` and agy will respond to `--dangerously-skip-permissions` as if that were the user's prompt).
+- **ALWAYS close stdin with `< /dev/null` (after the quoted prompt).** This is MANDATORY, not optional. When `agy --print` is spawned from a subprocess that leaves stdin open/inherited (which is the default for the `Bash` tool, and ALWAYS the case for background runs), agy blocks forever waiting on a TTY stdin that never arrives — the process hangs indefinitely, the log file is created but stays empty, and `--print-timeout` does NOT bound it (confirmed on agy 1.0.6, matches issue #76 reports from @dontcallmejames/@iwata-1116). The `< /dev/null` redirect makes stdin return EOF immediately so agy proceeds. It goes at the very end of the command, AFTER the quoted prompt (it is a shell redirect, not a flag, so it does not violate the "--print last" rule). On Windows PowerShell callers the equivalent is `$proc.StandardInput.Close()`; from the `Bash` tool (Git Bash) always use `< /dev/null`. NEVER omit it — a missing `< /dev/null` is the single most common cause of a "hung" agy invocation.
+- `--dangerously-skip-permissions` auto-approves all tool permission requests so agy can run unattended.
+- `--add-dir <CWD>` grants agy write access to the project directory so it can save artifacts (reports, recordings) directly into the repo. Use the **absolute** path of the calling CWD. Omit this flag only if no file output is needed.
+- `--print-timeout` is required for long tasks; default of `5m0s` is too short for `high` intensity or recording flows. **Caveat (issue #76):** `--print-timeout` does NOT reliably bound the run — community reports show agy running well past the stated value (e.g. `15s` requested, exited at `~41s`). Treat it as a hint, not a hard limit. Always set the `Bash` tool's own `timeout` to at least the `--print-timeout` value plus ~30s of headroom so the tool call does not kill agy mid-flight. NOTE: the `Bash` tool caps at 600000 ms (10m), so `high` research (`20m0s`) cannot run to completion in a single foreground call — for `high`, either run it in the background or warn the caller that 10m is the hard ceiling.
+- `--continue` resumes the last conversation. Add only if `RESUME: true`.
+- Quote the prompt with double quotes and escape any internal `"` as `\"`. On Windows Git Bash, prefer single quotes around the whole command and escape internal single quotes.
+- **`--model` support is version-dependent.** Early `agy` 1.0.0/1.0.1 reject `--model` with `flags provided but not defined: -model`; **agy 1.0.5+ accepts it** (e.g. `--model "Gemini 3.1 Pro (High)"`, community-confirmed on #76). Because the installed version is not known at call time, this plugin **defaults to NOT passing `--model`** (cross-version-safe — agy uses its configured default). Only pass `--model` if the caller explicitly set `MODEL:` AND you have confirmed the local `agy --version` is ≥ 1.0.5; otherwise omit it.
+
+## Known issue — empty stdout in --print mode (agy 1.0.0 – 1.0.5)
+
+`agy --print` has a known upstream bug (issue #76 at https://github.com/google-antigravity/antigravity-cli/issues/76) where, when stdout is not a TTY (i.e., when called from any subprocess including this agent), the binary exits 0 but writes zero bytes to stdout — even though the model generated a full response. The agy log shows `text_drip.go: Drip stopped: length=<N>` confirming the response was produced but never flushed.
+
+**Status:** still unfixed as of agy **1.0.5** (community-confirmed on the issue through 2026-06-05, across Windows 10/11, WSL, and macOS). Do NOT assume a newer agy build resolves this — keep the workarounds below until the upstream issue closes.
+
+**Primary workaround used by this plugin:** instruct agy in the prompt itself to write its output via `write_file` to a known path. Then read that file from the calling agent. Do NOT rely on capturing stdout for the actual content. Use stdout only as a "did it crash" signal.
+
+**Fallback workaround (Plan B — transcript recovery):** when there is no `write_file` instruction (e.g. `rescue` mode) OR the expected output file is missing after a clean exit, the response is still recoverable. agy persists every conversation's model output to disk even when stdout is dropped — confirmed independently by three reporters on #76. See "Recovering a dropped response" below.
+
+## Recovering a dropped response (transcript.jsonl — Plan B)
+
+When `agy --print` exits 0 but produced no stdout AND no expected output file, the model's answer is almost always sitting in the per-conversation transcript on disk. Recover it with ONE Bash call (Git Bash / POSIX — the default `Bash` tool):
+
+```bash
+GROOT="$HOME/.gemini/antigravity-cli"
+# Resolve the conversation id ROBUSTLY. Order matters:
+#  1) the cli log — `Print mode: conversation=<cid>` is written immediately and is
+#     the most reliable source. (DO NOT rely on last_conversations.json first: it is
+#     written with a delay and may not even contain the invoking cwd key — verified
+#     on agy 1.0.6.)
+LOG=$(ls -t "$GROOT/log/"cli-*.log 2>/dev/null | head -1)
+CID=$(grep -oE 'conversation=[0-9a-f-]{36}' "$LOG" 2>/dev/null | tail -1 | cut -d= -f2)
+#  2) fallback: the most-recently-modified brain/<cid> directory.
+[ -z "$CID" ] && CID=$(ls -t "$GROOT/brain/" 2>/dev/null | head -1)
+#  3) last fallback: last_conversations.json keyed by cwd (may lag a few seconds).
+[ -z "$CID" ] && CID=$(python - "$PWD" <<'PY' 2>/dev/null
+import json, sys, os
+p = os.path.expanduser("~/.gemini/antigravity-cli/cache/last_conversations.json")
+try: d = json.load(open(p, encoding="utf-8"))
+except Exception: d = {}
+cwd = sys.argv[1]
+print(d.get(cwd) or d.get(os.path.normpath(cwd)) or "")
+PY
+)
+TX="$GROOT/brain/$CID/.system_generated/logs/transcript.jsonl"
+# last MODEL / PLANNER_RESPONSE .content is the final answer
+[ -n "$CID" ] && [ -f "$TX" ] && python - "$TX" <<'PY'
+import json, sys
+last = None
+for line in open(sys.argv[1], encoding="utf-8"):
+    line = line.strip()
+    if not line: continue
+    try: o = json.loads(line)
+    except Exception: continue
+    if o.get("source") == "MODEL" and o.get("type") == "PLANNER_RESPONSE" and o.get("content"):
+        last = o["content"]
+if last: print(last)
+PY
+```
+
+If `python` is unavailable, fall back to reading `cache/last_conversations.json` and the transcript with the Read tool and extracting the last `PLANNER_RESPONSE.content` manually.
+
+**Caveats (from the #76 thread):**
+- The conversation id comes from the **cli log first** (`conversation=<cid>` — immediate and reliable), then the most-recent `brain/` dir, then `last_conversations.json[cwd]` as a last resort. `last_conversations.json` is written with a delay and may omit the invoking cwd entirely (verified on agy 1.0.6), which is why it is NOT the primary source. agy emits no stable per-run id on stdout, so under **true concurrent** agy runs the "latest log" heuristic can still pick the wrong run — keep recovery to one-call-at-a-time (the plugin's normal mode).
+- The transcript has **no token-usage metadata** (`input_tokens` / `output_tokens` are absent), so do not try to report usage from it.
+- This recovers content only when generation actually happened (a `text_drip.go: Drip stopped: length=N` line exists in the log). If generation never ran — see the auth-timeout failure mode below — the transcript will not contain the answer.
+
+## Known issue — headless auth timeout (agy 1.0.5, distinct from #76)
+
+A newer, **separate** failure mode appears on agy 1.0.5 (Cafeynman on #76, 2026-06-04): in a headless/non-TTY call, agy's silent auth times out before any generation happens. The log shows:
+
+```
+printmode.go: Print mode: not authenticated, trying silent auth
+keyring.go:   keyringAuth: timed out after 5s, skipping keyring auth
+printmode.go: Print mode: silent auth failed, triggering OAuth
+printmode.go: Print mode: auth timed out
+```
+
+In this case there is **no `streamGenerateContent`, no `text_drip`, and nothing in transcript.jsonl** — the model never ran, so neither the `write_file` workaround nor the transcript Plan B can recover anything. `--print-timeout` does NOT bound it; the process can hang well past the stated timeout and then exit 0 with empty stdout.
+
+**How this agent must handle it:** if the output file is missing AND the log shows `auth timed out` / `silent auth failed` / `keyringAuth: timed out`, do NOT silently return empty and do NOT retry (a retry hits the same auth wall). Return a clear, actionable message to the caller:
+
+> agy headless auth timed out (not issue #76 — the model never ran). Fix: run `agy` interactively once in a real terminal to refresh the keyring/OAuth session, then retry. If it persists, re-auth agy.
+
+Distinguish the three failure modes by tailing the latest `~/.gemini/antigravity-cli/log/cli-*.log`:
+
+| Log signature | Failure | This agent's action |
+|---|---|---|
+| `text_drip … length=N` present, output file missing | #76 empty-stdout (response generated) | recover via transcript Plan B / return stdout |
+| `rename … Access is denied` | #217 Windows Defender race | `sleep 2` + retry once (see below) |
+| `auth timed out` / `silent auth failed` | 1.0.5 headless auth timeout | surface the re-auth message, do NOT retry |
+
+## Known issue — Windows `rename .tmp → .pb: Access is denied` (observed 2026-05-28, re-confirmed 2026-05-29)
+
+On Windows, agy persists conversations to `~/.gemini/antigravity-cli/conversations/<uuid>.<random>.tmp` and then renames the file to `<uuid>.pb`. Each `--print` run mints a NEW conversation UUID, so the destination `.pb` does not pre-exist — the lock is on the **freshly-written `.tmp` itself**: Windows Defender real-time protection grabs a handle to scan the new file the instant agy writes it, and agy's `MoveFileEx` loses the race → `Access is denied`. agy then aborts the conversation mid-flight (often after only a few dozen characters). Upstream issue #217.
+
+**Permanent fix (eliminates the error at the source; requires admin once):** exclude the conversations dir from Defender real-time scanning, in an ELEVATED PowerShell:
+
+```powershell
+Add-MpPreference -ExclusionPath "$env:USERPROFILE\.gemini\antigravity-cli\conversations"
+```
+
+The mitigations below keep the plugin resilient when that exclusion is NOT in place.
+
+**Symptom in the agy log** (`~/.gemini/antigravity-cli/log/cli-*.log`):
+
+```
+E0528 15:34:47.716869 log.go:398] rename ...tmp ...pb: Access is denied.
+I0528 15:34:47.837049 manager.go:459] CLI store manager shutting down
+```
+
+When this happens, agy exits 0 but the `WRITE_FILE` you instructed it to write **does not exist** on disk. Distinguish this from issue #76 by checking the log file.
+
+**Mitigations baked into every agy invocation in this agent:**
+
+1. **Pre-flight `.tmp` sweep.** Before invoking agy in any mode, run ONE Bash call to delete orphaned `.tmp` files (leftovers from prior crashes) in `~/.gemini/antigravity-cli/conversations/`. This clears STALE tmps; it does NOT prevent the live Defender race — that is what the backoff retry in #2 handles.
+
+   POSIX (the default `Bash` tool — Git Bash / WSL / macOS / Linux):
+   ```bash
+   find "$HOME/.gemini/antigravity-cli/conversations" -name '*.tmp' -mmin +5 -delete 2>/dev/null || true
+   ```
+
+   Windows fallback — if `find` resolves to Windows `find.exe` (errors with `FIND: Parameter format not correct`), use PowerShell:
+   ```powershell
+   Get-ChildItem "$env:USERPROFILE\.gemini\antigravity-cli\conversations\*.tmp" -ErrorAction SilentlyContinue | Where-Object { $_.LastWriteTime -lt (Get-Date).AddMinutes(-5) } | Remove-Item -Force -ErrorAction SilentlyContinue
+   ```
+
+   The 5-minute guard keeps in-flight tmps from a concurrent agy run untouched. This is fire-and-forget — never fail the request because the sweep failed.
+
+2. **Output-file existence check after exit 0, with triage.** For any mode that uses a `WRITE_FILE` (research / ask / review / scrape / doc-to-md / design-review / report-generate), after the agy call exits successfully, verify the `WRITE_FILE` exists and is non-empty. If it does not, tail the most recent `~/.gemini/antigravity-cli/log/cli-*.log` (one extra Bash call) and branch on what the log shows (see the failure-mode table above):
+   - **`rename … Access is denied`** → Windows Defender race (#217). The original call lost the race to Defender. **Sleep ~2s, then retry agy ONCE with the same prompt, in the SAME Bash call** so the backoff costs no extra call budget:
+     ```bash
+     sleep 2 && agy --dangerously-skip-permissions [same flags...] --print "<same prompt>" < /dev/null
+     ```
+     The 2s pause lets Defender finish scanning and release the `.tmp` handle, so the retry's rename usually wins. Do not retry a second time — if it still fails, the path is being held persistently: surface the permanent Defender exclusion command (top of this section) to the user and stop.
+   - **`auth timed out` / `silent auth failed` / `keyringAuth: timed out`** → headless auth timeout (1.0.5). The model never ran; nothing is recoverable. Do NOT retry. Return the re-auth message from the "headless auth timeout" section above and stop.
+   - **`text_drip … length=N` present (or none of the above)** → issue #76 (response generated, stdout dropped). Recover it with the **transcript Plan B** (see "Recovering a dropped response"): resolve the conversation id from `cache/last_conversations.json[cwd]`, read `brain/<cid>/.system_generated/logs/transcript.jsonl`, and return the last `PLANNER_RESPONSE.content`. Only if Plan B also yields nothing, return the captured stdout verbatim plus a note that the response could not be recovered.
+
+3. **Setup mode is exempt** from the output-file check (it has no `WRITE_FILE`), but it still does the pre-flight sweep.
+
+## Inputs you receive from the slash command
+
+The slash command passes you a header block followed by the user's text:
+
+```
+MODE: rescue|research|setup|record|scrape|doc-to-md|design-review|ask|review|report-analyze|report-generate|notebook|notebook-index|notebook-ask|notebook-group|transcribe|media
+INTENSITY: low|medium|high          # only for research
+MODEL:                              # reserved for forward compat — agy 1.0.x ignores model overrides
+RESUME: true|false                  # add --continue if true
+WRITE_FILE: <path or empty>         # if non-empty, the prompt instructs agy to write output here
+CWD: <absolute path>                # for record/scrape/doc-to-md/design-review
+# Record mode adds:
+URL: <url>
+OUTPUT_DIR: <relative dir>
+REPORT_FILE: <relative path>
+VIDEO_FILE: <relative path>
+STEPS: <natural-language steps or DEFAULT_WALKTHROUGH>
+# Scrape mode adds:
+SCHEMA: <fields or natural-language description or empty>
+FORMAT: md|json
+# doc-to-md mode adds:
+SOURCE_FILE: <absolute path>
+FILE_TYPE: pdf|docx|image|html|other
+FOCUS: <natural-language or empty>
+# design-review mode adds:
+URL: <url>
+FOCUS: <natural-language or empty>
+# review mode adds (instead of URL/FOCUS above):
+FOCUS: <focus text or default>
+DIFF_FILE: <absolute path to a file containing `git diff` output>
+# report-analyze mode adds:
+SOURCE_FILE: <absolute path to markdown source>
+# report-generate mode adds:
+SOURCE_FILE: <absolute path to markdown source>
+STYLE_SPEC: <multiline style block: name + description + palette + vibe>
+IMAGES: native|external|none      # how ![generate: ...] cues become images (default native)
+# notebook mode adds (one document → one objective-driven summary):
+OBJETIVO: <case objective in natural language>
+INPUT_MODE: text|vision           # text = read TEXT_FILE; vision = read SOURCE_FILE multimodally
+SOURCE_FILE: <absolute path to the original document>
+TEXT_FILE: <absolute path to pre-extracted text, or empty>
+# notebook-index mode adds (all summaries → index + master synthesis):
+OBJETIVO: <case objective in natural language>
+SUMMARIES_DIR: <absolute dir containing the *.resumen.md files>
+INDEX_FILE: <absolute path for INDEX.md>
+MASTER_FILE: <absolute path for RESUMEN_MAESTRO.md>
+TIMELINE_FILE: <absolute path for TIMELINE.md>
+ENTIDADES_FILE: <absolute path for ENTIDADES.md>
+# notebook-ask mode adds (answer a question from the existing summaries):
+SUMMARIES_DIR: <absolute dir containing the *.resumen.md files>
+PREGUNTA: <the user's question>
+# notebook-group mode adds (summarise a batch of one-page docs in one call):
+MEMBER_FILES: <pipe-joined member .txt paths>
+MEMBER_NAMES: <pipe-joined member display names>
+# transcribe mode adds (audio/video/URL -> transcript + summary):
+KIND: audio|video|url
+SOURCE: <file path or URL>
+ADD_DIR: <dir of the source file, or empty for a URL>
+FOCUS: <focus text or empty>
+# media mode adds (Q&A over audio/video/image/URL):
+KIND: audio|video|image|url|file
+SOURCE: <file path or URL>
+ADD_DIR: <dir of the source file, or empty for a URL>
+PREGUNTA: <the question>
+USER_TEXT:
+<the raw user request goes here>
+```
+
+## Mode behavior
+
+### Mode: rescue
+
+- Build the prompt as the user's raw text.
+- Default timeout: `8m0s`.
+- If `RESUME: true`, add `--continue`.
+- `--add-dir` only if the caller passed one.
+- Capture stdout. If non-empty, print it verbatim. **If stdout is empty (issue #76 — the common case in subprocess mode), do NOT give up:** tail the latest log to triage (failure-mode table above), then recover the answer via the **transcript Plan B** ("Recovering a dropped response") and return that content verbatim. Only if the log shows the auth-timeout signature, return the re-auth message instead. Only if both stdout and Plan B are empty and it is not an auth timeout, report that the response could not be recovered and suggest the caller use a write-to-file prompt pattern.
+
+### Mode: ask
+
+One-shot quick prompt. Bypasses issue #76 by writing to a temp file (no `docs/` persistence — `ask` is for transient questions).
+
+- Build a temp output path with ONE Bash call BEFORE invoking agy:
+  ```bash
+  TEMP_DIR="$(mktemp -d -t agy-ask-XXXXXX 2>/dev/null || mktemp -d)"
+  TEMP_FILE="$TEMP_DIR/answer.md"
+  echo "TEMP_FILE=$TEMP_FILE"
+  echo "TEMP_DIR=$TEMP_DIR"
+  ```
+- Default timeout: `5m0s`.
+- Build the prompt as the user's raw text with this tail appended:
+
+  ```
+  <user prompt>
+
+  OUTPUT INSTRUCTION: Do NOT print the answer to chat. Write your full response to:
+    <TEMP_FILE>
+  Use the write_file tool. After writing, confirm the path. That is your only deliverable.
+  ```
+
+- Invoke agy with `--add-dir $TEMP_DIR` so it can write the temp file:
+  ```bash
+  agy --dangerously-skip-permissions --add-dir "$TEMP_DIR" --print-timeout 5m0s --print "<wrapped prompt>" < /dev/null
+  ```
+- After agy returns, read `$TEMP_FILE` with the Read tool and return its content verbatim to the caller.
+- Cleanup: one final Bash call `rm -rf "$TEMP_DIR"` after reading.
+- If `$TEMP_FILE` does not exist after agy exits, run the triage + transcript Plan B (see "Recovering a dropped response") before giving up: tail the log, and if it is the #76 empty-stdout case, recover the answer from `transcript.jsonl` and return it. If the log shows the auth-timeout signature, return the re-auth message. Only if recovery yields nothing, return agy's stdout plus: "agy did not write the expected output file at $TEMP_FILE and the response could not be recovered. Stdout (may be empty due to issue #76):" followed by the captured stdout.
+
+### Mode: review
+
+Git diff code review. The slash command captures the diff into `DIFF_FILE` before invoking the subagent. Same write-to-file workaround as `ask`.
+
+- Read `DIFF_FILE` first with ONE Bash call to confirm it exists and capture its size:
+  ```bash
+  test -f "$DIFF_FILE" && wc -l "$DIFF_FILE" || echo "MISSING"
+  ```
+  If `MISSING`, return an error to the caller and stop.
+- Build a temp output path the same way as `ask`:
+  ```bash
+  TEMP_DIR="$(mktemp -d -t agy-review-XXXXXX 2>/dev/null || mktemp -d)"
+  TEMP_FILE="$TEMP_DIR/review.md"
+  ```
+- Default timeout: `8m0s` (code review with reasoning needs more headroom than `ask`).
+- Compose the prompt embedding the diff:
+
+  ```
+  Code review request.
+
+  Focus: <FOCUS>
+
+  Review the following git diff for correctness, edge cases, potential bugs, security issues, and style. Tailor depth to the focus. Cite specific lines / files when calling out an issue. End with a one-paragraph overall verdict.
+
+  Diff:
+  ```diff
+  <contents of DIFF_FILE>
+  ```
+
+  OUTPUT INSTRUCTION: Do NOT print the answer to chat. Write your full review markdown to:
+    <TEMP_FILE>
+  Use the write_file tool. After writing, confirm the path. That is your only deliverable.
+  ```
+
+- Invoke agy:
+  ```bash
+  agy --dangerously-skip-permissions --add-dir "$TEMP_DIR" --print-timeout 8m0s --print "<composed prompt>" < /dev/null
+  ```
+- Read `$TEMP_FILE` with the Read tool and return its content verbatim.
+- Cleanup: `rm -rf "$TEMP_DIR"` AND `rm -f "$DIFF_FILE"` (own the temp diff file — slash command handed it off).
+
+### Mode: research
+
+You MUST wrap the user's topic with the intensity template before invoking agy. Templates: (LOW, MEDIUM, HIGH — see below.)
+
+Critically, **append an explicit instruction** to the template telling agy to write its full markdown answer via `write_file` to the `WRITE_FILE` path, and to NOT print to stdout. This bypasses issue #76. Example tail to append:
+
+```
+OUTPUT INSTRUCTION: Do NOT print the answer to chat. Write the full markdown report to:
+  <WRITE_FILE>
+Use the write_file tool. After writing, confirm the path. That is your only deliverable.
+```
+
+Invoke agy with `--add-dir <CWD>` so it can write. After agy returns, read the file and return to caller:
+1. The path to the saved file.
+2. The first ~30 lines of the file content (TL;DR / Executive summary section).
+
+#### LOW (timeout: 3m0s)
+
+```
+Investigate the following topic quickly on the web: <TOPIC>.
+
+Rules:
+- Find 3 to 5 trustworthy sources (official sites, primary documentation, peer-reviewed papers).
+- Return a TL;DR with 3-5 actionable bullets.
+- List sources at the end with title and clickable URL.
+- Do not fabricate citations. If you could not find a solid source for a claim, say so explicitly.
+- Do NOT state release dates, version numbers, parameter counts, prices, or benchmarks unless a cited source directly supports them — never infer or extrapolate a date/version, and never present a future or unreleased item as already shipped. Mark any unconfirmed specific as `[UNVERIFIED]`.
+- Output language: match the language of the topic (default: English).
+
+Output format (markdown):
+
+## TL;DR
+- bullet 1
+- bullet 2
+- bullet 3
+
+## Sources
+1. [Title](URL) — one line of context
+2. ...
+```
+
+#### MEDIUM (timeout: 8m0s)
+
+```
+Balanced web research on: <TOPIC>.
+
+Rules:
+- Find 8 to 12 diverse sources (official docs, papers, well-starred repos, technical forums).
+- Triangulate when sources contradict each other.
+- Cite using [N] notation that maps to the References list at the end.
+- Mark any claim you could not verify as `[UNVERIFIED]`.
+- Do NOT state release dates, version numbers, parameter counts, prices, or benchmarks unless a cited source directly supports them — never infer or extrapolate a date/version, and never present a future or unreleased item as already shipped. Tie every hard specific to its [N] source.
+- Output language: match the language of the topic (default: English).
+
+Output format (markdown):
+
+## Executive summary
+3-5 sentences capturing the landscape.
+
+## Key findings
+- Finding 1 with citations [1][3]
+- Finding 2 with citation [2]
+...
+
+## Analysis
+Connections, implications, tradeoffs. Keep concise (200-300 words max).
+
+## References
+1. [Title](URL) — author/org, date, one line of context
+2. ...
+```
+
+#### HIGH (timeout: 20m0s)
+
+```
+Exhaustive web research on: <TOPIC>.
+
+Rules:
+- 15+ sources, aggressively triangulated.
+- Prioritize primary sources: papers (arXiv, ACM, IEEE), official docs, repos with stars, RFCs. Avoid blogspam and SEO content.
+- Include counterarguments and dissenting positions.
+- Explicitly identify evidence gaps (what is NOT yet known).
+- Cite using [N] notation mapped to References.
+- Mark weak claims as `[WEAK EVIDENCE]`.
+- Do NOT state release dates, version numbers, parameter counts, prices, or benchmarks unless a cited source directly supports them — never infer or extrapolate a date/version, and never present a future or unreleased item as already shipped. Tie every hard specific to its [N] source; mark the rest `[UNVERIFIED]`.
+- Output language: match the language of the topic (default: English).
+
+Output format (markdown):
+
+## TL;DR
+3 bullets for the rushed reader.
+
+## Context
+Why this topic matters right now.
+
+## Findings
+### Finding 1: <short title>
+Detail with citations [1][2]. Include concrete data when available.
+
+### Finding 2: ...
+
+## Comparisons
+Table or comparative list of the relevant options/positions/tools.
+
+## Risks and counterarguments
+- Risk/counterargument 1 [N]
+- ...
+
+## Evidence gaps
+What remained unverified and why.
+
+## Conclusion
+Actionable recommendation + confidence level (high/medium/low).
+
+## References
+1. [Title](URL) — author/org, date, type (paper/docs/repo/post)
+2. ...
+```
+
+After getting the file content back, prepend YAML frontmatter (use `Write` tool once):
+
+```yaml
+---
+title: "<TOPIC>"
+type: research
+intensity: <low|medium|high>
+created: <YYYY-MM-DD>
+sensitivity: internal
+source_tool: agy
+---
+```
+
+### Mode: record
+
+Browser walkthrough recording.
+
+- Timeout: `8m0s` for simple flows, `15m0s` if `STEPS` contains more than ~5 distinct actions or words like "login", "fill", "checkout", "wait", "scroll through many pages".
+- Always pass `--add-dir <CWD>` so agy can write the report into the project.
+- Build the prompt as:
+
+  ```
+  Browser walkthrough recording task.
+  
+  Target URL: <URL>
+  
+  Steps to perform:
+  <STEPS, expanded if STEPS == "DEFAULT_WALKTHROUGH" to the default 7-step exploratory flow>
+  
+  After completing the browser actions, write a markdown report to the following ABSOLUTE path:
+    <CWD>/<REPORT_FILE>
+  
+  The report MUST contain:
+  - Target URL and final URL (after any redirects)
+  - Page title detected
+  - A description of each step you performed
+  - Any errors, login walls, or unexpected behavior
+  - The ABSOLUTE path to the .webm recording you produced (it will be saved by the browser subagent in ~/.gemini/antigravity-cli/browser_recordings/ — find the most recent .webm in that directory and report its absolute path)
+  
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print anything to chat. The markdown report file is your only deliverable.
+  ```
+
+- After agy returns, execute this post-processing (one combined Bash call is fine):
+  1. Parse the report file at `<CWD>/<REPORT_FILE>` to find the absolute `.webm` path agy reported.
+  2. Copy that `.webm` to `<CWD>/<VIDEO_FILE>` (Bash `cp` works on all three platforms).
+  3. Copy `initial_state.png` and `final_state.png` from `~/.gemini/antigravity-cli/browser_recordings/` to `<CWD>/docs/agy/recordings/` if present (rename to `<date>-<slug>-initial.png` and `<date>-<slug>-final.png`).
+  4. Check for ffmpeg: `command -v ffmpeg` (POSIX) or `where ffmpeg` (Windows). If found, convert:
+     ```bash
+     ffmpeg -y -i <CWD>/<VIDEO_FILE> -c:v libx264 -crf 23 -preset fast -an <CWD>/<MP4_FILE>
+     ```
+     (`-an` because the recording has no audio anyway — strips empty audio track.)
+  5. If ffmpeg missing, append a `> [!NOTE]` block to the report file with the install hint.
+
+- Return to caller (verbatim):
+  1. Saved `.webm` path.
+  2. Saved `.mp4` path if conversion succeeded.
+  3. Saved screenshot paths.
+  4. Saved report path.
+  5. First ~30 lines of the report.
+
+### Mode: scrape
+
+Structured data extraction from a single URL.
+
+- Timeout: `5m0s` for static pages, `10m0s` if the URL is a JS-heavy SPA or the schema is complex.
+- Always pass `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Web scraping task.
+  
+  Target URL: <URL>
+  Schema / what to extract: <SCHEMA or "infer reasonable fields from the page content">
+  Output format: <FORMAT — "markdown table" or "JSON object/array">
+  
+  Steps:
+  1. Fetch the URL (use read_url for static HTML, or the browser subagent for JS-heavy pages).
+  2. Extract the requested fields. If a field is missing, use null/empty (do NOT fabricate).
+  3. If the page is paginated, scrape the first page only unless asked otherwise. Note pagination in the report.
+  4. Format the output according to FORMAT.
+  
+  Write the result to this ABSOLUTE path: <CWD>/<WRITE_FILE>
+  
+  For markdown format: include a brief preamble (URL, timestamp, schema used) followed by the structured data.
+  For JSON format: write a single valid JSON document. Validate before writing.
+  
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, return to caller:
+  1. Saved file path.
+  2. Number of records/fields extracted (count from the output).
+  3. First ~30 lines of the file (preview).
+
+### Mode: doc-to-md
+
+Multimodal document → clean markdown conversion.
+
+- Timeout: `8m0s` for small docs (<20 pages), `15m0s` for large (>20 pages).
+- Always pass `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Document conversion task.
+  
+  Source file: <SOURCE_FILE>
+  File type: <FILE_TYPE>
+  Focus / what to keep: <FOCUS or "full-fidelity faithful conversion of all content">
+  
+  Steps:
+  1. Read the source file using your file/multimodal tools (depending on FILE_TYPE).
+  2. Convert the content to clean Markdown, preserving:
+     - Headings hierarchy
+     - Tables (use markdown table syntax)
+     - Lists (ordered/unordered)
+     - Code blocks if present
+     - Emphasis (bold, italic)
+  3. For inline images in the source: insert `![<best description from visual context>](source-image-N)` placeholders, where N is a sequential index.
+  4. Do NOT translate the content — keep the original language.
+  5. Add a brief frontmatter with the source path, file type, and conversion date.
+  
+  Write the converted markdown to this ABSOLUTE path: <CWD>/<WRITE_FILE>
+  
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, return to caller:
+  1. Saved markdown path.
+  2. Original source path + detected type.
+  3. First ~30 lines of the conversion (preview).
+  4. Approximate page/section count.
+
+### Mode: notebook
+
+One document → one **objective-driven** summary (NOT a faithful conversion). Part of the
+`/agy:notebook` sweep (a local NotebookLM): the caller fans this out, one call per document.
+
+- Timeout: `6m0s` (single document, summary not full transcription).
+- **Run agy from a NEUTRAL scratch CWD, not the project root** — `cd "$(mktemp -d 2>/dev/null || echo "$TEMP")"` (or any dir outside a git repo) right before invoking agy. Running with the CWD inside the calling git project makes agy 1.0.10 register it as a cascade "project" and **sandbox every `write_file` to `brain/<uuid>/`, then REJECT the absolute output path** ("not a valid artifact path") → the model replans/retries 3-5× per document (~4× slower) and also snapshots the repo's untracked files on startup. A neutral CWD avoids both. **Verified:** clean CWD = 1 write, ~10s; project CWD = 5 round-trips, ~43s for the same 1-page doc.
+- **Grant file access with repeatable `--add-dir` (NOT `--add-dir <CWD>`):** pass `--add-dir "<dirname of the file agy READS>"` **and** `--add-dir "<dirname of WRITE_FILE>"` (in `text` mode both are under the notebook output dir, so one suffices; in `vision` mode add the source document's folder too).
+- The file agy must READ depends on `INPUT_MODE`:
+  - `text` → `<TEXT_FILE>` (already-extracted plain text; cheaper/faster than vision).
+  - `vision` → `<SOURCE_FILE>` (scanned PDF / image; agy uses multimodal OCR).
+- Prompt template:
+
+  ```
+  Document summary task — objective-driven. Output language: Spanish (es-AR).
+
+  Objetivo del caso: <OBJETIVO>
+
+  Read this file with your file / multimodal tools: <TEXT_FILE if INPUT_MODE=text else SOURCE_FILE>
+  (If it is a scanned image/PDF, OCR it. Do not translate; keep original wording for quoted data.)
+
+  Write a concise Spanish summary to this ABSOLUTE path: <WRITE_FILE>, with EXACTLY this shape:
+
+  ---
+  doc: <original file basename>
+  tipo: <document class if identifiable — e.g. NO, IF, PV, RS, ACTO, EXDIG, nota, resolución, planilla, foto…>
+  numero_gde: <GDE/expediente number if present, else "">
+  fecha: <YYYY-MM-DD of the document, or "ilegible"/"" if none>
+  emisor: <issuing office / person, or "">
+  relevancia: <integer 0-100 — how relevant THIS doc is to the objetivo>
+  ---
+  ## Síntesis
+  <2-6 sentences focused on the objetivo: what this document contributes to it>
+  ## Datos clave
+  - <citable facts: dates, amounts, resolution numbers, people, decisions — bullet list>
+  ## Relevancia
+  <1-2 sentences: why it is (or isn't) relevant to the objetivo>
+
+  Be faithful: if a date/number is unreadable, say "ilegible", do NOT invent it.
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, return to caller: the saved summary path and the `relevancia` value (from
+  the frontmatter). Keep it terse — the caller is looping over many documents.
+
+### Mode: notebook-index
+
+All per-document summaries → a relevance **index** + a cited **master synthesis**. One call,
+run after the whole sweep. Reads only the small `*.resumen.md` files.
+
+- Timeout: `8m0s`.
+- **Run agy from a neutral scratch CWD** (`cd "$(mktemp -d)"`), not the project root — see the rationale under `Mode: notebook` (project CWD → `brain/` artifact sandbox → write rejected → slow retries). Grant access with `--add-dir "<SUMMARIES_DIR>"` (it holds both the `*.resumen.md` inputs and the four output files); do NOT pass `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Synthesis task over a set of document summaries. Output language: Spanish (es-AR).
+
+  Objetivo del caso: <OBJETIVO>
+
+  Read every "*.resumen.md" file in this directory: <SUMMARIES_DIR>
+  Each has frontmatter (doc, tipo, numero_gde, fecha, relevancia) and a short summary.
+
+  Write FOUR files using write_file:
+
+  1. <INDEX_FILE> — a Markdown index of ALL documents, a table sorted by `relevancia` desc:
+     | Doc | Tipo | Fecha | Relevancia | Por qué (1 línea) |
+     Put a "## TOP — más relevantes para el objetivo" section first with the highest-scoring docs,
+     then "## Todos los documentos" with the full table. Mark any `estado: no_procesado` docs.
+
+  2. <MASTER_FILE> — RESUMEN_MAESTRO: a synthesis of the whole corpus oriented to the objetivo:
+     - "## Respuesta al objetivo": directly answer the objetivo from the evidence.
+     - "## Síntesis del caso": the narrative, CITING documents inline by numero_gde or doc name
+       (e.g. "según IF-2026-02429965 …", "[0041]").
+     - "## Línea de tiempo": bullet timeline of key dated milestones.
+     - "## Conclusión": 2-4 sentences.
+     Ground every claim in the summaries; if the evidence is insufficient for part of the
+     objetivo, say so explicitly. Do NOT invent facts not present in the summaries.
+
+  3. <TIMELINE_FILE> — TIMELINE: a single chronological Markdown table of every dated event found
+     in the summaries: | Fecha (YYYY-MM-DD) | Hecho | Doc (numero_gde o nombre) |, sorted ascending.
+     Skip undated items. This is the "línea de tiempo" as a standalone briefing artifact.
+
+  4. <ENTIDADES_FILE> — ENTIDADES: extracted entities grouped under headings, each with the doc(s)
+     where it appears: "## Personas" (nombre + DNI/CUIL si aparece), "## Montos" (importe + concepto),
+     "## Expedientes y resoluciones" (números GDE / EX / resoluciones), "## Escuelas / organismos".
+     Only entities actually present in the summaries; no invention.
+
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The four written files are your only deliverable.
+  ```
+
+- After agy returns, verify `INDEX_FILE`, `MASTER_FILE`, `TIMELINE_FILE` and `ENTIDADES_FILE` exist
+  and are non-empty (same WRITE_FILE check / recovery as other modes). Return their paths to the caller.
+
+### Mode: notebook-ask
+
+Answer a question from the existing per-document summaries (the "chat" over a notebook corpus).
+Reads only the small `*.resumen.md` files — never the original documents.
+
+- Timeout: `5m0s`.
+- **Run agy from a neutral scratch CWD** (`cd "$(mktemp -d)"`), not the project root — see `Mode: notebook` (project CWD → `brain/` artifact sandbox → write rejected → slow retries). Grant access with `--add-dir "<SUMMARIES_DIR>"` (holds the `*.resumen.md` inputs and the answer file); do NOT pass `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Question-answering task over a set of document summaries. Output language: Spanish (es-AR).
+
+  Pregunta: <PREGUNTA>
+
+  Read every "*.resumen.md" file in this directory: <SUMMARIES_DIR>. Each has frontmatter
+  (doc, tipo, numero_gde, fecha, relevancia) and a short objective-driven summary.
+
+  Answer the pregunta using ONLY what the summaries contain. CITE the source document(s) inline for
+  every claim (by numero_gde or doc name, e.g. "según IF-2026-02429965 [0041]"). If the summaries do
+  not contain enough to answer, say so explicitly and point to which documents might hold it (by
+  relevance) instead of inventing. Lead with a direct answer, then the supporting detail with citations.
+
+  Write the answer to this ABSOLUTE path: <WRITE_FILE>.
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, verify `WRITE_FILE` exists and is non-empty (same WRITE_FILE check / recovery).
+  Return its path and the answer to the caller.
+
+### Mode: notebook-group
+
+Summarise a **batch of text documents in a SINGLE agy call** — `/agy:notebook` packs text docs
+(≤4 docs / ≤24k chars per batch) so one agy invocation produces several summaries, cutting the
+dominant cost at scale (agy invocations-per-minute). **One summary file PER member** (NOT a combined
+file), each in the exact `Mode: notebook` shape, so `Mode: notebook-index` keeps full per-doc
+granularity with no index-side change.
+
+- Timeout: `6m0s` (batch is char-budgeted ≤24k by the caller, so it stays well under the limit).
+- **Run agy from a neutral scratch CWD** (`cd "$(mktemp -d)"`), not the project root — see `Mode: notebook` (project CWD → `brain/` artifact sandbox → write rejected → slow retries). Grant access with `--add-dir "<dirname of the WRITE_FILES>"` (the notebook output dir, which also holds the `_text/` member files); do NOT pass `--add-dir <CWD>`.
+- `MEMBER_FILES` (a.k.a. `TEXT_FILES`) is a `|`-joined list of extracted-text paths; `MEMBER_NAMES`
+  the matching display names; `WRITE_FILES` the matching `|`-joined output paths — all three in the
+  SAME order, one entry per document.
+- Prompt template:
+
+  ```
+  Batch document-summary task — objective-driven, one summary PER document. Output language: Spanish (es-AR).
+
+  Objetivo del caso: <OBJETIVO>
+
+  You are given several pre-extracted plain-text documents. Summarise EACH one INDEPENDENTLY.
+  Text files (pipe-separated, in order): <MEMBER_FILES>
+  Output files (pipe-separated, SAME order): <WRITE_FILES>
+
+  For EACH input file, read it fully and write its OWN summary, with write_file, to the matching
+  output ABSOLUTE path, EXACTLY in this shape (the same as a single-document summary):
+
+  ---
+  doc: <original file basename>
+  tipo: <document class — NO, IF, PV, RS, ACTO, nota, resolución, planilla…>
+  numero_gde: <GDE/expediente number if present, else "">
+  fecha: <YYYY-MM-DD of the document, or "ilegible"/"" if none>
+  emisor: <issuing office / person, or "">
+  relevancia: <integer 0-100 — how relevant THIS doc is to the objetivo>
+  ---
+  ## Síntesis
+  <2-6 sentences focused on the objetivo>
+  ## Datos clave
+  - <citable facts: dates, amounts, resolution numbers, people, decisions>
+  ## Relevancia
+  <1-2 sentences: why it is (or isn't) relevant to the objetivo>
+
+  Never merge two documents into one file. Never skip a file. One output file per input, same order.
+  If a date/number is unreadable write "ilegible"; do NOT invent it.
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written files are your only deliverable.
+  ```
+
+- After agy returns, verify EVERY entry in `WRITE_FILES` exists and is non-empty (`test -s`). Report
+  how many were written and list any missing members so the caller can retry/stub just those.
+
+### Mode: transcribe
+
+Audio/video (file or YouTube/remote URL) -> faithful transcript + summary. Gemini is natively
+multimodal in audio/video; Claude Code is not, so this offloads a capability Claude lacks.
+
+- Timeout: `6m0s` for audio, `12m0s` for video/url (longer media take longer).
+- File pass `--add-dir <ADD_DIR>` (to read the source) **and** `--add-dir <CWD>` (to write). For a
+  URL there is no local file, so pass only `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Audio/video transcription + summary task.
+
+  Source (<KIND>): <SOURCE>
+  Focus / what to emphasize: <FOCUS or "faithful full transcript">
+
+  Listen to / watch the source. Transcribe it COMPLETELY and faithfully in its ORIGINAL language
+  (do not translate). Mark unclear parts [inaudible]. For <KIND> = video or url, prefix natural
+  segments with timestamps (mm:ss). Then add a short summary in the same language.
+
+  Write the result to this ABSOLUTE path: <WRITE_FILE>, with sections:
+  ## Transcripción   (timestamps for video/url)
+  ## Resumen         (2-5 lines; key points / decisions / action items per FOCUS)
+
+  Do NOT invent. OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, verify `WRITE_FILE` exists and is non-empty (same check / recovery). Return its path.
+
+### Mode: media
+
+Multimodal Q&A over an audio/video/image (file or URL) — beyond transcription.
+
+- Timeout: `6m0s` for audio/image, `12m0s` for video/url.
+- Same `--add-dir` logic as transcribe (source dir + CWD for files; CWD only for URLs).
+- Prompt template:
+
+  ```
+  Multimodal question-answering task. Output language: Spanish (es-AR), unless the source/question is in another language.
+
+  Source (<KIND>): <SOURCE>
+  Pregunta: <PREGUNTA>
+
+  Listen to / watch / look at the source. Answer the pregunta using ONLY what you actually heard or
+  saw. For audio/video, cite time references (e.g. "alrededor de 02:30") where relevant. If the
+  source doesn't contain enough to answer, say so explicitly — do not invent.
+
+  Write the answer to this ABSOLUTE path: <WRITE_FILE>.
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, verify `WRITE_FILE` exists and is non-empty (same check / recovery). Return its path.
+
+### Mode: design-review
+
+UX/visual audit using browser subagent + multimodal vision.
+
+- Timeout: `12m0s` (multi-viewport capture + analysis takes longer than scrape).
+- Always pass `--add-dir <CWD>`.
+- Prompt template:
+
+  ```
+  Visual & UX design review task.
+  
+  Target URL: <URL>
+  Focus: <FOCUS or "default 10-dimension review">
+  
+  Open the URL, capture screenshots at desktop (1440x900) and mobile (375x667) viewports, then produce a comprehensive review covering:
+  
+  1. Visual hierarchy
+  2. Typography (fonts, sizes, line-height, contrast)
+  3. Color system (palette, WCAG AA/AAA contrast, gradients)
+  4. Spacing & layout
+  5. Interactive elements (button states, form affordance, micro-interactions)
+  6. Brand & tone
+  7. Accessibility (a11y) — heuristic check of alt text, focus indicators, ARIA
+  8. UX heuristics (Nielsen's 10 — quick scan)
+  9. Mobile/responsive behavior (compare desktop vs mobile screenshots)
+  10. Competitive context (if FOCUS mentions a category, compare against industry standards)
+  
+  End with:
+  - 3 concrete strengths (with file/DOM references)
+  - 3 highest-leverage improvements (ordered by ROI: low effort + high visual impact first)
+  - Overall design score /10 with one-sentence rationale
+  
+  Reference the screenshot paths in the report.
+  
+  Write the full review markdown to this ABSOLUTE path: <CWD>/<WRITE_FILE>
+  
+  OUTPUT REQUIREMENT (CRITICAL): Do NOT print to chat. The written file is your only deliverable.
+  ```
+
+- After agy returns, return to caller:
+  1. Saved report path.
+  2. Screenshot paths (desktop + mobile if available).
+  3. First ~30 lines of the report (executive summary + score).
+  4. Highest-priority improvement (top of the action list).
+
+### Mode: report-analyze
+
+Phase 1 of the `/agy:report` flow. Read the source markdown and match it against the canonical TRAID Design System catalog of 5 templates. Recommend the top 1-3 templates that best fit the content, return as JSON. The user picks one in Phase 3.
+
+- Default timeout: `3m0s` (matching against a fixed catalog is fast).
+- Build a temp output path:
+  ```bash
+  TEMP_DIR="$(mktemp -d -t agy-analyze-XXXXXX 2>/dev/null || mktemp -d)"
+  TEMP_FILE="$TEMP_DIR/recommendations.json"
+  ```
+- Build the prompt with the FULL catalog embedded:
+
+  ```
+  You are a senior design director matching documents to a canonical design system. Read the markdown source, identify content cues, and recommend which template(s) from the TRAID Design System fit best.
+
+  Read the markdown file at this absolute path: <SOURCE_FILE>
+
+  Analyze content cues: length, target audience (technical vs business vs general), formality register, tone (academic / commercial / editorial / functional / longform / runbook), presence of data/tables/citations/code/blockquotes, citation density, technical depth, and whether the content is for INTERNAL use (manuals, SOPs, knowledge notes), CLIENT-FACING (proposals, presupuestos, brief), RESEARCH (whitepapers, analysis), or PUBLICATION (blog, longform, thought leadership).
+
+  Match against this fixed catalog of 5 templates (canonical TRAID Design System, approved 2026-05-29):
+
+  --- CATALOG START ---
+
+  TEMPLATE ID: traid-dark
+  Name: TRAID Dark Deck
+  Use case: presupuestos, manuales TRAID, decks comerciales, video presentations, LinkedIn carousels, screen-only viewing
+  Palette: pink #ec4899 + glow rgba(236,72,153,0.18) + obsidian bg #0a0f1a + surface #131927 + cool white #e2e8f0
+  Typography: Inter (15px body / line-height 1.6, weights 800-900 in titles, letter-spacing 2.5px in caps)
+  Layout: max-width 880px, left-aligned, screen-first, NOT A4
+  Vibe: commercial-dense, branded, nocturnal, premium-glow
+  Key components: brand-logo + meta header, problem-panel dark with pink glow border, mvp-card linear-gradient pink + halo, sprint-grid with letter badges + base highlight, guarantee dark + pink check, invest-table highlighted row, foot with pink TRAID mark glow
+  Content fit: anything sales/commercial/branded that will be viewed on screen — proposals, internal manuals for TRAID team, video presentations, LinkedIn deck carousels
+
+  TEMPLATE ID: traid-light
+  Name: TRAID Sales Deck (light variant)
+  Use case: variable LIGHT de traid-dark — propuestas para print/PDF/email donde dark mode no funciona
+  Palette: pink #ec4899 + pink-soft #fce7f3 + ink #0f172a + white bg + bg-soft #f8fafc + black #0a0f1a (for problem-panel and guarantee dark cards)
+  Typography: Inter (14.5px body / line-height 1.6, weights 800-900, letter-spacing 2.5px caps, -0.5px h1)
+  Layout: max-width 820px, A4 print-ready (@page size A4, page-break-inside avoid on panels)
+  Vibe: commercial-dense, branded, professional, print-ready
+  Key components: same vocabulary as traid-dark (brand-logo, problem-panel, components-box, mvp-card gradient, sprint-grid letter badges, deep-card 2-col qué/qué, guarantee dark + check pink, invest-table highlighted) but light surfaces with dark panels as accents
+  Reference exemplar: docs/propuestas/2026-05-26/martin-identificacion-b2b-ar/propuesta.html
+  Content fit: client-facing proposals/presupuestos that need PDF export or email-friendly white background
+
+  TEMPLATE ID: stripe-press
+  Name: Stripe Press Editorial
+  Use case: research papers, whitepapers, longform técnico scholarly, technical analysis for technical audiences
+  Palette: cloud paper #fafafa + off-black #171717 + indigo blueprint #6366f1 + indigo deep #4f46e5 + muted #737373 + hairline rgba(23,23,23,0.08) + code-bg #f5f5f7
+  Typography (TRIPLE): Source Serif 4 body + headings (18px / line-height 1.7) + Inter (kickers/metadata/captions) + JetBrains Mono (code)
+  Layout: max-width 720px centered, 6rem top / 4rem horizontal padding
+  Vibe: scholarly, authoritative, premium, restrained-but-confident
+  Key components: kicker "BRIEF/RESEARCH NOTE" caps tracking, h1 56px serif + indigo rule, h2 36px + hairline + Inter kicker "01. SECTION", h3 22px serif, drop-cap indigo after h2, TOC right-aligned, TL;DR callout card with indigo border, citations [N] superscript indigo with #ref-N anchors, hanging-indent references, booktabs tables (top + bottom + header rule, no vertical), code blocks with code-bg + 6px radius, blockquote left 3px indigo + italic serif
+  Content fit: anything with 10+ citations, academic-analytical tone, research/whitepaper structure, technical depth, longform for technical audiences
+
+  TEMPLATE ID: notion-docs
+  Name: Notion Modern Docs
+  Use case: documentos sencillos, runbooks, SOPs, docs internas, knowledge notes, dashboards funcionales, troubleshooting guides
+  Palette: white bg + Notion off-white #f7f6f3 + Notion charcoal #37352f + Notion blue #2383e2 + 5 callout colors (blue #ddebf1, yellow #fdecc8, red #fbe4e4, green #ddedea, purple #eae4f2) + code-bg #f1f1ef + code-fg #eb5757
+  Typography: Inter system fallback (16px / line-height 1.5)
+  Layout: 1200px wrap with 220px sticky TOC sidebar + main column ~720px
+  Vibe: functional, clean, readable, scannable
+  Key components: sticky TOC sidebar with IntersectionObserver active-section highlight, callout boxes with emoji icons (💡 blue / ⚠️ yellow / 📝 purple / ✅ green / 🔴 red), code blocks with code-lang label top-right, tables with hover row highlight, anchor # indicator on heading hover, lists with • bullet in accent, external links with ↗ indicator
+  Content fit: any internal doc, runbook, SOP, simple knowledge note, how-to guide; replaces traditional blockquote with purple callout
+
+  TEMPLATE ID: magazine
+  Name: Magazine Editorial Wired 2023
+  Use case: publicaciones longform, blog posts, Substack, thought leadership, contenido editorial para audiencia mass-market
+  Palette: warm white #fafafa + paper #f1ede4 + ink #0d0d0d + vibrant red-pink #ff3366 + electric blue #1a1aff + gradient linear-gradient(135deg, #ff3366, #ff8800)
+  Typography (DRAMATIC): Fraunces display (opsz 144) for h1/h2/pull-quotes + Inter (17px body / line-height 1.6) + JetBrains Mono (code)
+  Layout: editorial bold, custom 10px scrollbar with accent thumb
+  Vibe: bold, editorial, mass-market, dramatic
+  Key components: h1 96px Fraunces with gradient background-clip text, h2 42px Fraunces with Inter kicker "01 / SECCIÓN" + gradient rule, gradient drop-cap first letter 80px after each h2, full-width pull-quotes Fraunces 32px italic with giant accent quotation mark, byline + deck after h1 (autor + fecha + subtitle Fraunces italic), section ornaments (◆ or ※ 24px gradient) between sections, 2-col risks/mitigations card grid with paper bg + accent left border, ■ end mark
+  Content fit: opinion pieces, narrative longform, "por qué X importa", personal posts, thought leadership for non-academic audiences
+
+  --- CATALOG END ---
+
+  Now make your recommendations. Return TOP 1-3 templates ranked by fit, with a content-specific justification for each.
+
+  - If exactly one template clearly dominates (e.g., the source is literally a presupuesto), return just 1 option.
+  - If two templates are both plausible (e.g., commercial content that could be shown on screen OR printed), return 2 ranked.
+  - If the content is genuinely ambiguous, return 3 ranked.
+  - NEVER return options that don't match the content. Don't pad to 3 if only 1 fits.
+
+  OUTPUT INSTRUCTION (CRITICAL): Do NOT print to chat. Write a single JSON object to:
+    <TEMP_FILE>
+
+  The JSON schema (exact shape, no extra keys, valid JSON):
+
+  {
+    "content_analysis": {
+      "tone": "one phrase",
+      "audience": "internal | client-facing | research | publication",
+      "structure": "brief description (e.g. '5 h2 sections, 3 citations, 1 table, 1 code block')",
+      "key_cues": ["cue 1", "cue 2", "cue 3"]
+    },
+    "recommendations": [
+      {
+        "template_id": "traid-dark | traid-light | stripe-press | notion-docs | magazine",
+        "rank": 1,
+        "fit_score": "high | medium | low",
+        "justification": "one sentence citing specific content cues from the source that match this template"
+      },
+      { ... up to 2 more, ranked 2 and 3 ... }
+    ]
+  }
+
+  Use the write_file tool. After writing, confirm the path in one line. That is your only deliverable.
+  ```
+
+- Invoke agy with `--add-dir` for both the source dir and temp dir:
+  ```bash
+  agy --dangerously-skip-permissions --add-dir "$(dirname "$SOURCE_FILE")" --add-dir "$TEMP_DIR" --print-timeout 3m0s --print "<wrapped prompt>" < /dev/null
+  ```
+- After agy returns: apply the standard output-file existence check (see Known issue — Windows rename). If the JSON file exists, read it with the Read tool and return its content verbatim to the caller (caller will parse to drive Phase 3 AskUserQuestion).
+- Cleanup: `rm -rf "$TEMP_DIR"`.
+
+### Mode: report-generate
+
+Phase 2 of the `/agy:report` flow. Read source markdown + style spec, ask agy to generate self-contained branded HTML, handling `![generate: ...]` image cues per the `IMAGES` mode (native generation / external pre-generated / placeholder), write to WRITE_FILE, then verify referenced images exist.
+
+- Default timeout: `15m0s` (image generation + HTML composition is expensive).
+- Pre-check: the caller passes `WRITE_FILE` (absolute path under `docs/agy/reports/`), `SOURCE_FILE` (absolute path to markdown), and `IMAGES` (`native` | `external` | `none`, default `native`). The parent dir of WRITE_FILE must already exist (the slash command created it).
+- **Compute `ASSETS_DIR`** = `WRITE_FILE` with the trailing `.html` replaced by `.assets` (e.g. `.../2026-06-06-x.html` → `.../2026-06-06-x.assets`). This is the canonical assets path — the `<img src>` in the HTML must reference it **relative to the HTML** (i.e. `<basename>.assets/<slug>.png`). Do NOT use `<WRITE_FILE>.assets` (that would append `.assets` after `.html`). Create it with one Bash call before invoking agy: `mkdir -p "<ASSETS_DIR>"`.
+- **Slug convention (deterministic, shared with `external` mode):** for each `![generate: <description>]` cue, `slug` = description lowercased, non-alphanumeric → `-`, collapsed, trimmed to 60 chars; filename = `<slug>.png`. This MUST match exactly between what agy writes (`native`) and what a caller pre-generates (`external`).
+- **IMAGES mode** controls how cues become images (see the Image cues section of the prompt below):
+  - `native` (default): agy generates each image itself via its `generate_image` tool. Works without external deps but quality/format is inconsistent in headless mode (agy 1.0.6 sometimes emits JPEG bytes with a `.png` name, or skips generation entirely — the post-generation check below catches this).
+  - `external`: agy does NOT generate images. It references `<basename>.assets/<slug>.png` for each cue, assuming the caller already placed real PNGs there (e.g. generated with a dedicated image model like Nano Banana 2). This is the **recommended path for brand-quality infographics**.
+  - `none`: agy renders a styled placeholder `<figure>` per cue (accent-bordered box with the description as caption), no `<img>`. Layout stays intact; no broken images.
+- Build the prompt:
+
+  ```
+  You are a senior design engineer producing a final, publication-grade HTML report. Your output will be reviewed by a design-conscious operator with high standards. This is NOT an exercise — the HTML is archived as a permanent reference and may be shared with clients or stakeholders. Generic outputs are rejected; tasteful, opinionated, distinctive design wins.
+
+  ## Source material
+  - Markdown source (read it first; let the content drive design choices): <SOURCE_FILE>
+  - Output HTML path: <WRITE_FILE>
+
+  ## Design brief
+  <STYLE_SPEC>
+
+  Apply this brief rigorously. The chosen reference exemplar is the north star — the operator should be able to look at the rendered HTML and recognize the reference.
+
+  ## Required design qualities (non-negotiable)
+
+  **Typography**
+  - Opinionated font pairing per the style brief. NOT default Times/Arial/system fonts unless the brief explicitly says "system fonts only". Use a single `<link>` to Google Fonts for the chosen pair.
+  - Body text 17-20px on desktop, never less than 16px. Line-height 1.55-1.75 for body, 1.2-1.3 for headings.
+  - Distinct treatments for h1/h2/h3 — different weights, sizes, AND ornamentation (rule above, kicker label, color, drop letter). h1 should feel like a magazine title block, not a sized-up h2.
+  - First paragraph after each h2 may use a tasteful drop-cap or larger leading sentence when it fits the reference exemplar.
+
+  **Color**
+  - Use CSS custom properties on `:root` for the FULL palette: `--bg`, `--surface`, `--fg`, `--fg-muted`, `--accent`, `--accent-2`, `--rule`, `--code-bg`.
+  - The accent must appear in at least 4 semantic contexts: links, blockquote left border, h2 underline/rule, citation numbers, inline code background.
+  - Establish visible hierarchy between body, captions, footnotes, and metadata using TINTS of the palette, not arbitrary greys.
+
+  **Layout**
+  - Reading column max-width that respects optimal line length (60-80 chars). Center it; leave room for sidenotes if the reference exemplar uses them (e.g., Tufte).
+  - Generous whitespace; sections separated by tasteful ornament (horizontal rule with center glyph, color block, large vertical gap), not just margin.
+  - Table of contents at top if the source has 5+ top-level sections (h2). Each entry anchor-links to its section.
+  - Executive summary / TL;DR / Key takeaways block at the top, visually distinct (callout card, accent-tinted background, or rule-framed block).
+  - If source uses `[N]` inline citations with a Sources/References section, anchor-link each `[N]` (use `<a href="#ref-N">` + `id="ref-N"` on the entry) and style the in-text number distinctly (small caps, accent color, or superscript).
+
+  **Components**
+  - **Tables**: booktabs styling (top + bottom + header underline only, NO vertical rules). Header in bold + accent color. Optional zebra striping in the lightest palette tint.
+  - **Code blocks**: monospaced, padded, tinted card background with rounded corners. Inline code: subtle background tint, no border, slight horizontal padding.
+  - **Blockquotes**: left border in accent color, italic body, attribution line in smaller muted type.
+  - **Lists**: tighter than default leading, generous indent. Custom bullet style if it fits the reference (e.g., square bullets for Swiss, em-dashes for editorial).
+  - **Figures**: every `<img>` wrapped in `<figure>` with `<figcaption>` in muted color, smaller size.
+  - **ASCII diagrams / code-art blocks**: monospace, preserved whitespace, framed background, not centered.
+
+  **Responsive + print**
+  - 640px mobile breakpoint: proportional font reduction, single-column TOC, simplified ornament, full-width images.
+  - `@media print`: white bg, black fg, page-break-after on h1/h2, no orphan headings, TOC hidden, citations rendered as footnotes if feasible.
+
+  **Header + footer**
+  - Header: document title in a strong typographic block, kicker label above (e.g., "RESEARCH", "BRIEF", "PROPOSAL"), date in the document's metadata format, subtitle/byline if appropriate.
+  - Footer: source markdown path + generation date + small attribution "Generated via agy + Claude Code".
+
+  ## Forbidden anti-patterns
+
+  Any of these in the output = reject:
+
+  - ❌ Plain centered title above body text with no other visual treatment.
+  - ❌ Default browser scrollbars and form controls visible.
+  - ❌ External CDN scripts (Google Fonts via `<link>` is OK; nothing else).
+  - ❌ Generic emoji 🚀 ⭐ ✅ in headings unless the reference exemplar specifically calls for it.
+  - ❌ Tables with no styling treatment.
+  - ❌ Headings that look identical except for size.
+  - ❌ Single dominant color used flatly with no shades or accents.
+  - ❌ "Lorem-ipsum"-feeling spacing where every element has the same margin.
+
+  ## Image cues (IMAGES mode = <IMAGES>)
+  For each `![generate: <description>]` cue in the source markdown, derive `<slug>` = description lowercased, non-alphanumeric → `-`, collapsed, trimmed to 60 chars. The assets directory is `<ASSETS_DIR>` and every `<img src>` MUST be `<ASSETS_DIR_BASENAME>/<slug>.png` (relative to the HTML). If the source has ZERO cues, do not invent images. Behave per IMAGES mode:
+  - **native**: invoke the native `generate_image` tool for each cue and save as `<ASSETS_DIR>/<slug>.png`. Request **PNG** output explicitly. Embed via `<figure>` with `<figcaption>` showing a short caption.
+  - **external**: do NOT generate any image. Only emit the `<figure><img src="<ASSETS_DIR_BASENAME>/<slug>.png" alt="..."><figcaption>...</figcaption></figure>` markup — the PNG files already exist (the caller generated them). Use the exact slug convention above so the filenames match.
+  - **none**: emit NO `<img>`. For each cue render a styled placeholder `<figure>`: an accent-bordered, tinted box (use the palette `--accent`/`--surface`) containing the cue description as `<figcaption>` text. Layout must stay intact with no broken images.
+
+  ## Process
+
+  1. Read the markdown source.
+  2. Inventory the document: section count, citation count, code blocks, tables, image cues, ASCII art. Decide where TOC / TL;DR / drop-caps / sidenotes fit.
+  3. Generate any required images.
+  4. Compose the HTML applying ALL required qualities. Bias toward over-design before under-design.
+  5. Write to <WRITE_FILE> via write_file.
+
+  ## Output instruction (CRITICAL)
+  Do NOT print HTML or commentary to chat. The written file at <WRITE_FILE> is your only deliverable. After writing, confirm the path in one line and stop.
+  ```
+
+- Invoke agy (`--add-dir` covers the reports dir, which contains `ASSETS_DIR`, so agy can write images there in `native` mode):
+  ```bash
+  agy --dangerously-skip-permissions --add-dir "$(dirname "$SOURCE_FILE")" --add-dir "$(dirname "$WRITE_FILE")" --print-timeout 15m0s --print "<composed prompt>" < /dev/null
+  ```
+- Output-file existence check (issue #76 / Windows rename mitigation). If WRITE_FILE does not exist or is empty after exit 0, run the standard triage + retry/recovery from the "Output-file existence check" section.
+- **Assets-existence check (NEW — never ship broken images).** After the HTML exists, verify every `<img src>` it references resolves to a real non-empty file. One Bash call:
+  ```bash
+  HTML_DIR="$(dirname "<WRITE_FILE>")"; tot=0; miss=0
+  for src in $(grep -oE '<img[^>]+src="[^"]+"' "<WRITE_FILE>" | sed -E 's/.*src="([^"]+)".*/\1/'); do
+    tot=$((tot+1)); [ -s "$HTML_DIR/$src" ] || { echo "MISSING: $src"; miss=$((miss+1)); }
+  done
+  echo "IMAGES_PRESENT=$((tot-miss))/$tot"
+  ```
+  - In `native` mode: if any are MISSING, agy referenced images it failed to generate (common on 1.0.6). Report the missing list to the caller and recommend re-running with `--images external` after pre-generating the PNGs, OR `--images none`. Do NOT silently return — broken `<img>` tags are a failure.
+  - In `external` mode: MISSING means the caller has not yet placed those PNGs in `ASSETS_DIR`. Report exactly which `<slug>.png` files are expected so the caller can generate them.
+- Return to caller:
+  1. Saved HTML path.
+  2. IMAGES mode used + the `IMAGES_PRESENT=<n>/<total>` line, and the list of any missing `<slug>.png`.
+  3. The `ASSETS_DIR` absolute path (so the caller knows where to drop external images).
+  4. Approximate HTML size in KB.
+
+### Mode: setup
+
+Because of issue #76, a "reply pong to stdout" ping is useless here — `agy --print` writes
+nothing to stdout when not a TTY, whether it worked or not. **Test with `write_file` and check
+the file instead.** Use a writable temp dir via `--add-dir`:
+
+```bash
+OUT="${TMPDIR:-/tmp}/agy_ping.txt"; LOG="${TMPDIR:-/tmp}/agy_ping.log"; rm -f "$OUT" "$LOG"
+agy --dangerously-skip-permissions --add-dir "$(dirname "$OUT")" --print-timeout 90s --log-file "$LOG" --print "Use the write_file tool to write exactly the word pong to the file $OUT . Write nothing else and use no other tools." < /dev/null
+cat "$OUT" 2>/dev/null
+```
+
+- **Success = the file `$OUT` exists and contains `pong`.** If so, agy is installed, authenticated
+  and working — report success.
+- **⚠️ IGNORE these log lines — they are non-fatal noise, present even on a fully successful run:**
+  `"You are not logged into Antigravity"`, `"getting token source"`, `FetchAvailableModels`,
+  `loadCodeAssistResponse`, `userInfo`, `ListExperiments`, `Skipping telemetry`. They come from
+  secondary auth scopes (code-assist features, model list, telemetry); the core `streamGenerateContent`
+  model calls do NOT need that token. **Do NOT report them as a login problem and do NOT tell the
+  user to re-authenticate based on them — that is a false alarm** (verified 2026-06-19: agy wrote
+  the file successfully while emitting all of those lines).
+- If the file was **NOT** written, triage in order:
+  1. Binary missing / not on PATH → tell the user to install Antigravity (see install note). Stop.
+  2. Log shows `streamGenerateContent` calls but a `timed out` / no `write_file` → it's the
+     **task or timeout**, not auth: re-run with a larger `--print-timeout` or a smaller/stricter task.
+  3. Only a genuine fatal sign-in line (e.g. `OAuth login required`, `please run agy to sign in` —
+     NOT the secondary-scope warnings above) means re-login: tell the user to run `agy` once
+     interactively in a normal terminal to complete the Google sign-in.
+- Report: binary path and version (`agy changelog | head -n 1`), and whether the write_file ping succeeded.
+- Do NOT touch user PATH or environment variables. If the binary is missing, just say so and stop.
+
+## Safety rules
+
+- One `Bash` call for the main `agy` invocation per attempt (mode `research`/`ask`/`review`/`scrape`/`doc-to-md`/`design-review`/`report-generate`/`notebook`/`notebook-index`/`notebook-ask`/`notebook-group`/`transcribe`/`media` may retry once if the WRITE_FILE check detects the Windows rename bug — a second `Bash` call to agy is allowed only on retry, not for branching logic).
+- The pre-flight `.tmp` sweep adds one Bash call before agy in every mode. The output-file check adds one Bash call after agy (test -s + optional log tail) in modes with WRITE_FILE.
+- **Response recovery is allowed when output is missing/empty** (issue #76): one Bash call to tail the log for triage, and one Bash call to run the transcript Plan B recovery. These are recovery calls, not exploration — only run them when stdout is empty or the WRITE_FILE check failed, never speculatively. `rescue` mode (no WRITE_FILE) may use these same two recovery calls when stdout comes back empty.
+- Mode `record` and `research` may use one additional `Bash` call for post-processing (file moves, ffmpeg) and one `Write` call to prepend frontmatter or append a hint. Mode `setup` may use one additional `Bash` call for the version/log check. Mode `ask` may use one Bash call before agy (mktemp) and one after (rm). Mode `review` may use one Bash call before (size check on DIFF_FILE + mktemp) and one after (rm of both temp dirs). Mode `report-generate` may use one Bash call for output dir setup and one after for image asset moves.
+- Do NOT inspect the repository, read other files, grep, monitor progress, or do follow-up reasoning beyond what each mode requires.
+- Do NOT paraphrase, summarize, or rewrite agy's output. Return it as-is.
+- If agy errors out, return the error message verbatim.
+- If the binary is missing, return the error and tell the caller to run `/agy:setup`.
diff --git a/plugins/antigravity/commands/ask.md b/plugins/antigravity/commands/ask.md
new file mode 100644
index 0000000..a300776
--- /dev/null
+++ b/plugins/antigravity/commands/ask.md
@@ -0,0 +1,37 @@
+---
+description: One-shot prompt to Antigravity (agy) — quick question, returns response verbatim. No file persistence to docs/.
+argument-hint: "[--background] <prompt>"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: ask.
+
+Raw user request:
+$ARGUMENTS
+
+Routing rules:
+
+- If the request contains `--background`, invoke the subagent with `run_in_background: true`. Strip the flag from the forwarded prompt.
+- Otherwise run the subagent in the foreground.
+- What remains after stripping `--background` IS the prompt. Trim whitespace.
+
+Pass this header block to the subagent followed by the prompt:
+
+```
+MODE: ask
+INTENSITY:
+MODEL:
+RESUME: false
+WRITE_FILE:
+USER_TEXT:
+<cleaned prompt>
+```
+
+Operating rules:
+
+- The subagent wraps the prompt with a `write_file` instruction (bug #76 workaround — see https://github.com/google-antigravity/antigravity-cli/issues/76). Agy writes the answer to a temp file, the subagent reads it back, returns the content verbatim.
+- Present the response as-is. No commentary, no paraphrase.
+- If the user did not supply a prompt, ask once: "What do you want to ask Antigravity?"
+- If agy reports it is missing or unauthenticated, tell the user to run `/agy:setup`.
+- For multi-step or long-running work, suggest `/agy:rescue` instead (carries the same write-to-file workaround but with a longer timeout and the option to resume conversations).
diff --git a/plugins/antigravity/commands/design-review.md b/plugins/antigravity/commands/design-review.md
new file mode 100644
index 0000000..349157b
--- /dev/null
+++ b/plugins/antigravity/commands/design-review.md
@@ -0,0 +1,76 @@
+---
+description: Run a UX/visual design audit of a URL using Antigravity (agy). Captures desktop + mobile screenshots, scores 10 dimensions (hierarchy, typography, color, spacing, a11y, etc.), benchmarks against industry. Saves to docs/agy/design-reviews/.
+argument-hint: "<url> [focus instructions]"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: design-review.
+
+Raw user request:
+$ARGUMENTS
+
+## Routing rules
+
+1. **Parse the URL**: the first whitespace-separated token of `$ARGUMENTS` that starts with `http://` or `https://` IS the URL. If the user wrote it without a scheme, prepend `https://`. If no URL is found, ask once: "What URL should I review the design of?".
+
+2. **Focus**: everything else in `$ARGUMENTS` is optional natural-language emphasis (e.g., "focus on the checkout flow on mobile", "compare against MercadoLibre seller backend"). Empty by default = full 10-dimension review at both viewports.
+
+3. **Slug**: build from URL host + first path segment (lowercase, non-alphanumeric → `-`, collapse repeats, trim to 60 chars).
+
+4. **Date**: today in `YYYY-MM-DD`.
+
+5. **Paths** (relative to current working directory):
+   - `OUTPUT_DIR` = `docs/agy/design-reviews/`
+   - `WRITE_FILE` = `docs/agy/design-reviews/<date>-<slug>.md`
+
+6. **Pre-flight** (ONE `Bash` call):
+   ```bash
+   mkdir -p docs/agy/design-reviews
+   ```
+
+7. **Hand off**: pass this header to the subagent:
+
+   ```
+   MODE: design-review
+   URL: <url>
+   FOCUS: <natural-language focus or empty>
+   CWD: <absolute path>
+   WRITE_FILE: docs/agy/design-reviews/<date>-<slug>.md
+   ```
+
+## Operating rules
+
+- The subagent invokes agy with `--add-dir <CWD>` and a long timeout (`12m0s`) because design reviews involve browser navigation + multiple viewports + multimodal vision analysis.
+- The subagent reports:
+  1. Saved report path.
+  2. First ~30 lines (executive summary + design score).
+  3. Paths to captured screenshots (desktop + mobile).
+- Present that to the user as-is.
+- If the URL is blocked, returns non-200, or browser session crashes, surface the error verbatim.
+
+## What the review covers
+
+Default 10-dimension audit:
+1. Visual hierarchy
+2. Typography (fonts, sizes, line-height, contrast)
+3. Color system (palette, WCAG contrast, gradient usage)
+4. Spacing & layout (grid, white space, alignment)
+5. Interactive elements (button states, form affordance, micro-interactions)
+6. Brand & tone (does design match the value-prop?)
+7. Accessibility (alt text, focus indicators, ARIA, color contrast)
+8. UX heuristics (Nielsen's 10)
+9. Mobile/responsive behavior
+10. Competitive context (if `--focus` includes a category, agy compares against industry standards)
+
+Ends with:
+- 3 concrete strengths
+- 3 highest-leverage improvements (ordered by ROI)
+- Overall design score /10
+
+## Notes
+
+- Uses agy's browser subagent under the hood — same `--add-dir` + write_file workaround as `/agy:record`.
+- For login-protected pages, agy uses an isolated Chrome profile (no shared cookies). For demos behind auth, pass credentials in the focus text (be aware they end up in the prompt).
+- For comparing TWO designs, run `/agy:design-review` twice and synthesize. (A `--compare` flag is a v0.4.0 candidate.)
+- Captures both desktop (1440×900) and mobile (375×667) viewports by default.
diff --git a/plugins/antigravity/commands/doc-to-md.md b/plugins/antigravity/commands/doc-to-md.md
new file mode 100644
index 0000000..e90569f
--- /dev/null
+++ b/plugins/antigravity/commands/doc-to-md.md
@@ -0,0 +1,67 @@
+---
+description: Convert a PDF, docx, image, or other document to clean Markdown using Antigravity (agy) multimodal Gemini. Saves to docs/agy/converted/.
+argument-hint: "<file-path> [extraction focus instructions]"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: doc-to-md.
+
+Raw user request:
+$ARGUMENTS
+
+## Routing rules
+
+1. **Parse the file path**: the first whitespace-separated token of `$ARGUMENTS` that resolves to an existing file (check with `test -f`) IS the source file. Convert relative paths to absolute. If no valid file is found, ask once: "Which file should I convert?".
+
+2. **Extraction focus**: everything else in `$ARGUMENTS` (anything that's not the path) is optional natural-language guidance on what to focus on (e.g., "extract only the pricing tables and ignore the legal boilerplate"). Empty by default = "produce a faithful full-fidelity markdown conversion".
+
+3. **Detect file type** via extension:
+   - `.pdf` → PDF (multimodal)
+   - `.docx`, `.doc` → Word (multimodal or text)
+   - `.png`, `.jpg`, `.jpeg`, `.webp`, `.gif` → image (multimodal — OCR + structure inference)
+   - `.html`, `.htm` → HTML (text)
+   - other → text or warn
+
+4. **Slug**: lowercase the source filename base (without extension), non-alphanumeric → `-`, collapse repeats, trim to 60 chars.
+
+5. **Date**: today in `YYYY-MM-DD` (local time).
+
+6. **Paths** (relative to current working directory):
+   - `OUTPUT_DIR` = `docs/agy/converted/`
+   - `WRITE_FILE` = `docs/agy/converted/<date>-<slug>.md`
+
+7. **Pre-flight** (ONE `Bash` call):
+   ```bash
+   mkdir -p docs/agy/converted
+   ```
+
+8. **Hand off**: pass this header to the subagent:
+
+   ```
+   MODE: doc-to-md
+   SOURCE_FILE: <absolute path>
+   FILE_TYPE: pdf|docx|image|html|other
+   FOCUS: <natural-language focus or empty>
+   CWD: <absolute path to current working directory>
+   WRITE_FILE: docs/agy/converted/<date>-<slug>.md
+   ```
+
+## Operating rules
+
+- The subagent invokes agy with `--add-dir <CWD>` so it can write the result.
+- For PDF / docx / image, agy uses Gemini's multimodal vision capabilities — preserves tables, lists, headings, code blocks. Inline images become `![description](image-extraction-note)` placeholders.
+- The subagent reports:
+  1. Saved markdown path.
+  2. Original file path and detected type.
+  3. First ~30 lines of the conversion (preview).
+  4. Pages/sections processed.
+- Present that to the user as-is.
+- If the file is too large (>200 MB) or the format is unsupported, surface the error verbatim. Suggest splitting or pre-processing.
+
+## Notes
+
+- Large PDFs (>100 pages) consume significant input tokens. Consider chunking for very large docs.
+- For images, OCR quality is excellent for printed text, decent for handwriting.
+- This is NOT a replacement for `pandoc` if you need lossless format conversion — it's for "give me a clean markdown version I can read/edit/reuse".
+- For sensitive documents (NDAs, internal contracts), be aware the content is sent to Google's Gemini servers. Use `vertex-creative` skill with Vertex AI ADC if you need stricter data residency control.
diff --git a/plugins/antigravity/commands/media.md b/plugins/antigravity/commands/media.md
new file mode 100644
index 0000000..a955f7d
--- /dev/null
+++ b/plugins/antigravity/commands/media.md
@@ -0,0 +1,63 @@
+---
+description: Ask a question about an AUDIO, VIDEO or IMAGE file (or a YouTube/remote URL) with Antigravity (agy / Gemini 3.x multimodal). Beyond transcription — "what decisions were made in this meeting?", "what happens at 2:30 in the video?", "what's the tone of this voice note?". Claude Code can't see/hear media; agy can.
+argument-hint: "<audio|video|image file | URL> | <question>"
+context: fork
+allowed-tools: Bash, Read, Agent
+---
+
+Multimodal Q&A over a media file. Give `agy` an audio/video/image (or a YouTube/remote URL) and a
+question; it answers grounded in what it heard/saw, with time references for audio/video.
+
+Raw user request:
+$ARGUMENTS
+
+## Phase 0 — Resolve source + question (ONE Bash call)
+
+Parse `$ARGUMENTS`: split on the first `|` → left = source (a URL or an existing file), right =
+question. If there is no `|`, the leading URL/existing-file token is the source and the rest is the
+question. If the question is empty, ask once and stop.
+
+```bash
+python - "$SOURCE" "$PREGUNTA" <<'PYEOF'
+import sys, os, re, hashlib
+src = sys.argv[1].strip().strip('"'); preg = (sys.argv[2] if len(sys.argv) > 2 else "").strip()
+AUD=(".ogg",".mp3",".wav",".m4a",".aac",".flac",".opus",".aiff"); VID=(".mp4",".mov",".webm",".mkv",".avi",".m4v")
+IMG=(".png",".jpg",".jpeg",".webp",".gif")
+low=src.lower()
+if low.startswith("http"): kind="url"; addir=""
+elif low.endswith(VID): kind="video"; addir=os.path.dirname(os.path.abspath(src))
+elif low.endswith(AUD): kind="audio"; addir=os.path.dirname(os.path.abspath(src))
+elif low.endswith(IMG): kind="image"; addir=os.path.dirname(os.path.abspath(src))
+else: kind="file"; addir=os.path.dirname(os.path.abspath(src))
+base=re.sub(r"[^a-z0-9]+","-", (re.sub(r"^https?://(www\.)?","",low) if kind=="url" else os.path.splitext(os.path.basename(src))[0]).lower()).strip("-")[:40] or "media"
+qh=hashlib.sha1(preg.encode()).hexdigest()[:6]
+out=os.path.join("docs","agy","media", f"{base}-{qh}.md"); os.makedirs(os.path.dirname(out), exist_ok=True)
+print(f"KIND={kind}\nADD_DIR={addir}\nWRITE_FILE={os.path.abspath(out)}\nSOURCE={src}")
+PYEOF
+```
+
+## Phase 1 — Answer (ONE agy subagent)
+
+Spawn ONE `antigravity:agy-rescue` subagent in **MODE: media**:
+
+```
+MODE: media
+CWD: <absolute current working dir>
+KIND: audio|video|image|url|file
+SOURCE: <file path or URL>
+ADD_DIR: <dir of the source file, or empty for a URL>
+PREGUNTA: <question>
+WRITE_FILE: <WRITE_FILE>
+USER_TEXT:
+(empty)
+```
+
+## Phase 2 — Present
+
+Read ONLY `<WRITE_FILE>` and present the answer verbatim, then the saved path. Don't re-process the
+media yourself.
+
+## Notes
+- For audio/video the answer cites **time references** (e.g. "around 02:30") when relevant.
+- Need a full transcript instead of a targeted answer? Use `/agy:transcribe`.
+- agy `--print` writes nothing to stdout outside a TTY (issue #76); the answer is read from the file.
diff --git a/plugins/antigravity/commands/model.md b/plugins/antigravity/commands/model.md
new file mode 100644
index 0000000..da04bc2
--- /dev/null
+++ b/plugins/antigravity/commands/model.md
@@ -0,0 +1,76 @@
+---
+description: Show or set the agy (Antigravity / Gemini) model by writing ~/.gemini/antigravity-cli/settings.json — the reliable way to switch models (the unreliable --model flag silently falls back to the default). No agy call; takes effect immediately, no plugin reinstall.
+argument-hint: "[alias|\"exact label\"]   e.g. flash-low · pro · \"Gemini 3.1 Pro (High)\""
+context: fork
+allowed-tools: Bash
+---
+
+Show or change which model `agy --print` uses. agy reads the active model from
+`~/.gemini/antigravity-cli/settings.json` (`"model": "<label>"`); the TUI's "Switch Model"
+just writes that key. The `--model` CLI flag is **unreliable** (an unknown id silently falls
+back to the default), so this command edits `settings.json` directly. The change is immediate —
+no plugin reinstall.
+
+Raw user request:
+$ARGUMENTS
+
+## Alias table (canonical copy: `config/model-map.json` — keep in sync)
+
+| Alias | Label written to settings.json |
+|---|---|
+| `flash-low` | `Gemini 3.5 Flash (Low)` |
+| `flash` / `flash-medium` | `Gemini 3.5 Flash (Medium)` |
+| `flash-high` | `Gemini 3.5 Flash (High)` |
+| `pro` / `pro-low` | `Gemini 3.1 Pro (Low)` |
+| `pro-high` | `Gemini 3.1 Pro (High)` |
+| `sonnet` | `Claude Sonnet 4.6 (Thinking)` |
+| `opus` | `Claude Opus 4.6 (Thinking)` |
+| `gpt-oss` | `GPT-OSS 120B` |
+
+`(Low/Medium/High)` is the thinking-effort level. Model availability depends on the account
+tier (free = Flash / Flash-Lite only). For `/agy:notebook` sweeps, `flash-low` is fastest/cheapest;
+use `pro` for higher-quality synthesis.
+
+## What to do (ONE Bash call)
+
+Run this, substituting the requested alias/label (trim `$ARGUMENTS`; empty = show only). It accepts
+an alias OR a full quoted label verbatim (so you can paste an exact string from the TUI when an
+alias is stale):
+
+```bash
+ARG="$ARGUMENTS"   # the alias or exact label, or empty
+python - "$ARG" <<'PY'
+import json, os, sys, shutil
+arg = (sys.argv[1] if len(sys.argv) > 1 else "").strip().strip('"').strip("'")
+sp = os.path.expanduser("~/.gemini/antigravity-cli/settings.json")
+ALIASES = {
+    "flash-low":"Gemini 3.5 Flash (Low)", "flash":"Gemini 3.5 Flash (Medium)",
+    "flash-medium":"Gemini 3.5 Flash (Medium)", "flash-high":"Gemini 3.5 Flash (High)",
+    "pro":"Gemini 3.1 Pro (Low)", "pro-low":"Gemini 3.1 Pro (Low)",
+    "pro-high":"Gemini 3.1 Pro (High)", "sonnet":"Claude Sonnet 4.6 (Thinking)",
+    "opus":"Claude Opus 4.6 (Thinking)", "gpt-oss":"GPT-OSS 120B",
+}
+try:
+    cfg = json.load(open(sp, encoding="utf-8"))
+except FileNotFoundError:
+    cfg = {}
+cur = cfg.get("model", "(unset — agy uses its default)")
+if not arg:
+    print("Modelo actual:", cur)
+    print("\nAlias disponibles:")
+    for a, lbl in ALIASES.items(): print(f"  {a:13} → {lbl}")
+    print("\nUso: /agy:model <alias>   o   /agy:model \"Gemini 3.1 Pro (High)\"")
+    sys.exit(0)
+label = ALIASES.get(arg.lower(), arg)   # alias → label, else use verbatim
+shutil.copyfile(sp, sp + ".bak") if os.path.exists(sp) else None
+cfg["model"] = label
+json.dump(cfg, open(sp, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
+print(f"Modelo: {cur}  →  {label}")
+if arg.lower() not in ALIASES and arg != label:
+    print("(usaste un label literal; verificá que coincida exacto con la lista del TUI)")
+print("⚠️  Si agy sigue en el modelo anterior, el label no coincide con tu cuenta: abrí el TUI"
+      " `agy` → Switch Model, copiá el string exacto y reintentá con /agy:model \"<label>\".")
+PY
+```
+
+Report the before→after model and the warning verbatim. Do not call agy.
diff --git a/plugins/antigravity/commands/notebook-ask.md b/plugins/antigravity/commands/notebook-ask.md
new file mode 100644
index 0000000..9a4df06
--- /dev/null
+++ b/plugins/antigravity/commands/notebook-ask.md
@@ -0,0 +1,66 @@
+---
+description: Ask a question over a notebook corpus you already built with /agy:notebook. agy answers from the per-document summaries (docs/agy/notebook/<folder>/*.resumen.md) with citations — the "chat" of a local NotebookLM. Cheap: reads only the small summaries, never the original documents.
+argument-hint: "<folder> | <question>"
+context: fork
+allowed-tools: Bash, Read, Agent
+---
+
+Question-answering over a notebook corpus previously built by `/agy:notebook`. agy reads the
+small per-document summaries (not the originals) and answers **with citations**. Run `/agy:notebook
+<folder> | <objective>` first to build the corpus.
+
+Raw user request:
+$ARGUMENTS
+
+## Phase 0 — Resolve corpus + answer path (ONE Bash call)
+
+Parse `$ARGUMENTS`: split on the first `|`. Left = folder (the SAME folder used with `/agy:notebook`),
+right = question. If there is no `|`, the longest leading token that resolves to an existing directory
+is the folder and the rest is the question. If the question is empty, ask once and stop.
+
+```bash
+python - "$FOLDER_OR_SLUG" "$PREGUNTA" <<'PY'
+import sys, os, re, glob, hashlib
+folder, preg = sys.argv[1], (sys.argv[2] if len(sys.argv) > 2 else "")
+def slug(s, n=60):
+    return (re.sub(r"[^a-z0-9]+","-", os.path.basename(s.rstrip("/\\")).lower()).strip("-") or "x")[:n]
+outdir = os.path.join("docs","agy","notebook", slug(folder))
+summ = glob.glob(os.path.join(outdir, "*.resumen.md"))
+if not summ:
+    print(f"NO_CORPUS outdir={outdir}")           # corpus not built yet
+    sys.exit(0)
+ans_dir = os.path.join(outdir, "_respuestas"); os.makedirs(ans_dir, exist_ok=True)
+qh = hashlib.sha1(preg.encode("utf-8")).hexdigest()[:6]
+ans = os.path.join(ans_dir, f"{slug(preg, 40)}-{qh}.md")
+print(f"OK SUMMARIES_DIR={os.path.abspath(outdir)} N={len(summ)} WRITE_FILE={os.path.abspath(ans)}")
+PY
+```
+
+- If it prints `NO_CORPUS` → tell the user to build the corpus first with
+  `/agy:notebook "<folder>" | <objective>`, and stop.
+- Else capture `SUMMARIES_DIR`, `N` (number of summaries) and `WRITE_FILE`.
+
+## Phase 1 — Answer (ONE agy subagent)
+
+Spawn ONE `antigravity:agy-rescue` subagent in **MODE: notebook-ask**:
+
+```
+MODE: notebook-ask
+CWD: <absolute current working dir>
+SUMMARIES_DIR: <SUMMARIES_DIR>
+PREGUNTA: <question>
+WRITE_FILE: <WRITE_FILE>
+USER_TEXT:
+(empty)
+```
+
+## Phase 2 — Present
+
+Read ONLY `<WRITE_FILE>` and present the answer verbatim, then note: how many summaries it drew
+from (`N`), and the saved path. Do NOT read the original documents or the per-document summaries
+yourself — agy already grounded the answer in them.
+
+## Notes
+- The corpus must exist (run `/agy:notebook` first). This command never re-reads the originals.
+- Answers are saved under `docs/agy/notebook/<folder>/_respuestas/` so you keep a Q&A trail.
+- agy `--print` writes nothing to stdout outside a TTY (issue #76) — the answer is read from the file.
diff --git a/plugins/antigravity/commands/notebook.md b/plugins/antigravity/commands/notebook.md
new file mode 100644
index 0000000..5d4871e
--- /dev/null
+++ b/plugins/antigravity/commands/notebook.md
@@ -0,0 +1,306 @@
+---
+description: Local NotebookLM over a FOLDER of documents using Antigravity (agy). Sweeps each document (PDF with text, scanned PDF, image, docx) into an objective-driven Markdown summary, then builds a relevance INDEX and a cited master summary. Incremental cache (re-runs only re-summarize changed docs / changed objective) and automatic model routing (Flash for the sweep, Pro for the synthesis). Offloads all heavy reading to agy. Saves to docs/agy/notebook/.
+argument-hint: "<folder> | <objective>"
+context: fork
+allowed-tools: Bash, Read, Write, Agent
+---
+
+Local replacement for NotebookLM. Given a **folder of documents** and an **objective**,
+agy reads every document and produces one objective-driven summary per document, plus a
+relevance `INDEX.md` and a cited `RESUMEN_MAESTRO.md`. The point is to **keep Claude's
+context cheap**: agy does all the document reading; you only read the two small final files.
+
+Raw user request:
+$ARGUMENTS
+
+## Phase 0 — Parse + list + classify + cache (ONE Bash call)
+
+Parse `$ARGUMENTS`: split on the first `|`. Left side = folder, right side = objective.
+If there is no `|`, the longest leading token that resolves to an existing directory is the
+folder and the rest is the objective. If the folder is missing, ask once: "¿Qué carpeta querés
+analizar?" and stop.
+
+Run ONE Bash call (a Python helper). It lists supported files, classifies each as `text`
+(PDF with a real text layer → pre-extract) or `vision` (scanned/image → agy OCR), and applies an
+**incremental cache**: a document is marked `cached` (skipped) when its summary already exists AND
+its size+mtime AND the objective are unchanged since the last run. The cache key includes a hash of
+the objective, so changing the objective re-summarizes everything.
+
+```bash
+python - "$FOLDER_ABS" "$OUTDIR" "$OBJETIVO" <<'PYEOF'
+import sys, os, re, glob, hashlib
+import fitz  # PyMuPDF
+folder, outdir, objetivo = sys.argv[1], sys.argv[2], (sys.argv[3] if len(sys.argv) > 3 else "")
+os.makedirs(os.path.join(outdir, "_text"), exist_ok=True)
+objhash = hashlib.sha1(objetivo.strip().encode("utf-8")).hexdigest()[:8]
+MAXV, CHUNK, GROUP_MAX, CHAR_BUDGET = 20, 15, 4, 24000   # scans >MAXV pages -> CHUNK-page subs; uncached text docs -> groups of <=GROUP_MAX docs and <=CHAR_BUDGET chars (1 agy call -> many summaries)
+cache_path = os.path.join(outdir, "_cache.tsv"); prev = {}
+if os.path.exists(cache_path):
+    for ln in open(cache_path, encoding="utf-8"):
+        pp = ln.rstrip("\n").split("\t")
+        if len(pp) == 2: prev[pp[0]] = pp[1]
+exts = (".pdf",".docx",".doc",".png",".jpg",".jpeg",".webp",".gif")
+files = sorted(f for f in glob.glob(os.path.join(folder,"*")) if f.lower().endswith(exts))
+def slug(s):
+    s = re.sub(r"[^a-z0-9]+","-", os.path.splitext(os.path.basename(s))[0].lower()).strip("-")
+    return s[:60] or "doc"
+def mkrow(nn, mode, src, tpath, summ, key):     # incremental cache per output file
+    if os.path.exists(os.path.join(outdir, summ)) and prev.get(summ) == key:
+        return (nn, "cached", src, "-", summ, key)
+    return (nn, mode, src, tpath, summ, key)
+rows=[]; small=[]   # small = UNCACHED text docs to pack into groups: (nn, sl, tpath, srcabs, key, nchars)
+for i,f in enumerate(files,1):
+    nn=f"{i:03d}"; sl=slug(f); st=os.stat(f); key=f"{st.st_size}:{int(st.st_mtime)}:{objhash}"
+    is_pdf=f.lower().endswith(".pdf"); mode="vision"; tpath="-"; pages=0; d=None; nchars=0
+    if is_pdf:
+        try:
+            d=fitz.open(f); pages=d.page_count; txt="\n".join(p.get_text() for p in d)
+            if pages and len(txt.strip())/pages >= 200:
+                mode="text"; nchars=len(txt.strip()); tpath=os.path.join(outdir,"_text",f"{nn}-{sl}.txt")
+                open(tpath,"w",encoding="utf-8").write(txt)
+        except Exception:
+            mode,pages,d="vision",0,None
+    if mode=="vision" and is_pdf and pages>MAXV and d is not None:
+        os.makedirs(os.path.join(outdir,"_chunks"),exist_ok=True)   # oversized scan -> page-range chunks
+        for ci,startp in enumerate(range(0,pages,CHUNK),1):
+            endp=min(startp+CHUNK,pages)
+            cpath=os.path.join(outdir,"_chunks",f"{nn}-{sl}-p{startp+1:03d}-{endp:03d}.pdf")
+            sub=fitz.open(); sub.insert_pdf(d,from_page=startp,to_page=endp-1); sub.save(cpath); sub.close()
+            summ=f"{nn}-{sl}-p{startp+1:03d}-{endp:03d}.resumen.md"
+            rows.append(mkrow(nn,"vision",cpath,"-",summ,f"{key}:c{ci}"))
+    elif mode=="text":
+        summ=f"{nn}-{sl}.resumen.md"
+        if os.path.exists(os.path.join(outdir,summ)) and prev.get(summ)==key:
+            rows.append((nn,"cached",os.path.abspath(f),tpath,summ,key))     # already summarized -> skip
+        else:
+            small.append((nn, sl, tpath, os.path.abspath(f), key, nchars))   # pack into a group below
+    else:
+        rows.append(mkrow(nn,mode,os.path.abspath(f),tpath,f"{nn}-{sl}.resumen.md",key))
+    if d is not None: d.close()
+# greedy-pack UNCACHED text docs into groups (<=GROUP_MAX docs, <=CHAR_BUDGET chars) to cut agy calls.
+# Each group = ONE agy call that writes one summary file PER member (see Mode: notebook-group).
+batches=[]; cur=[]; cc=0
+for it in small:                                    # it = (nn, sl, tpath, srcabs, key, nchars)
+    if cur and (len(cur)>=GROUP_MAX or cc+it[5]>CHAR_BUDGET):
+        batches.append(cur); cur=[]; cc=0
+    cur.append(it); cc+=it[5]
+if cur: batches.append(cur)
+for gi,b in enumerate(batches,1):
+    if len(b)==1:                                   # lone text doc -> 1-per-call (no group overhead)
+        nn,sl,tpath,srcabs,key,_=b[0]
+        rows.append((nn,"text",srcabs,tpath,f"{nn}-{sl}.resumen.md",key)); continue
+    g=f"G{gi:02d}"
+    texts="|".join(x[2] for x in b)                 # member text paths
+    names="|".join(f"{x[0]}-{x[1]}" for x in b)     # member display names
+    summs="|".join(f"{x[0]}-{x[1]}.resumen.md" for x in b)  # one output file PER member
+    gkey="|".join(x[4] for x in b)                  # per-member cache keys (pipe-joined)
+    rows.append((g,"group",texts,names,summs,gkey))
+rows.sort(key=lambda r: r[0])
+with open(os.path.join(outdir,"_manifest.tsv"),"w",encoding="utf-8") as m:
+    for r in rows: m.write("\t".join(r)+"\n")
+nc=sum(1 for r in rows if r[1]=="cached"); nt=sum(1 for r in rows if r[1]=="text")
+nv=sum(1 for r in rows if r[1]=="vision"); ng=sum(1 for r in rows if r[1]=="group")
+print(f"DOCS={len(files)} ROWS={len(rows)} CACHED={nc} TEXT={nt} VISION={nv} GROUPS={ng} OUTDIR={outdir}")
+for r in rows: print("\t".join(r))
+PYEOF
+```
+
+Manifest columns: `NN  mode(text|vision|cached|group)  source_abspath  text_path_or_dash  summary_relpath  cache_key`.
+For **`group`** rows, columns 3/4/5/6 are PIPE-joined lists (member text paths · member names ·
+member summary files · member cache keys), all in the same order — one entry per document in the batch.
+If the manifest is empty → tell the user there are no supported documents and stop. If ALL docs are
+`cached` → skip Phase 1 entirely (nothing changed) and go straight to Phase 2.
+
+**Large-corpus guard.** Count the rows to actually process this run (`text` + `vision` + `group`,
+i.e. `ROWS − CACHED` from the print line). If that is **more than 30**, do NOT start the sweep
+silently — tell the user the count and a rough wall-clock estimate (on a free ~10 RPM tier ≈
+`ceil(N/10)` minutes plus retries; much faster on Pro/Ultra) and ask them to confirm before
+continuing. They can proceed as-is, or narrow the folder/objective to cut the count. Skip this prompt
+when there are ≤30 rows to process, or when the user already passed an explicit go-ahead (e.g. they
+re-ran after confirming, or said "sin preguntar"/"go").
+
+## Phase 0.5 — Model routing (ONE Bash call, best-effort, reversible)
+
+The per-document summaries don't need deep reasoning; the final synthesis does. Save the user's
+current agy model, switch to a fast one for the sweep, and **remember to restore it in Phase 3**.
+agy reads its model from `settings.json` (the reliable lever — see `/agy:model`); `--model` is not.
+
+```bash
+python - <<'PY'
+import json, os
+sp=os.path.expanduser("~/.gemini/antigravity-cli/settings.json")
+try: cfg=json.load(open(sp,encoding="utf-8"))
+except Exception: cfg={}
+orig=cfg.get("model","")
+open(os.path.join(os.environ.get("TMPDIR","/tmp"),"agy_notebook_orig_model.txt"),"w",encoding="utf-8").write(orig)
+cfg["model"]="Gemini 3.5 Flash (Low)"
+json.dump(cfg,open(sp,"w",encoding="utf-8"),ensure_ascii=False,indent=2)
+print(f"model: {orig or '(default)'} -> Gemini 3.5 Flash (Low) for the sweep (orig saved)")
+PY
+```
+
+> Best-effort: if the account lacks a label, agy silently keeps its default — harmless. The original
+> model is restored in Phase 3 regardless of outcome.
+
+## Phase 1 — Per-document summaries (fan out agy, with rate-limit-aware retry)
+
+Dispatch manifest rows by mode (**skip `cached`**). A `text` or `vision` row → **MODE: notebook**
+(one doc per call). A **`group`** row → **MODE: notebook-group** (ONE call summarises up to 4 text
+docs and writes one summary file PER member — this is the main throughput win, fewer agy
+invocations). Pass for MODE: notebook:
+
+```
+MODE: notebook
+CWD: <absolute current working dir>
+OBJETIVO: <objective>
+INPUT_MODE: text|vision
+SOURCE_FILE: <source_abspath>          # the original doc (vision reads this)
+TEXT_FILE: <text_path or empty>        # extracted text (text mode reads this)
+WRITE_FILE: <OUTDIR>/<summary_relpath>
+USER_TEXT:
+(empty)
+```
+
+For a **`group`** row, split columns 3/5/4 on `|` and pass the matching PIPE-joined lists (same
+order; prefix each summary with `<OUTDIR>/` to make `WRITE_FILES` absolute):
+
+```
+MODE: notebook-group
+CWD: <absolute current working dir>
+OBJETIVO: <objective>
+MEMBER_FILES: <pipe-joined member text paths (column 3)>
+MEMBER_NAMES: <pipe-joined member names (column 4)>
+WRITE_FILES: <OUTDIR>/<m1.resumen.md>|<OUTDIR>/<m2.resumen.md>|…  (column 5, each made absolute)
+USER_TEXT:
+(empty)
+```
+
+**Concurrency — RPM-bounded waves, two separate queues.** Each subagent runs its own `agy` process;
+agy is rate-limited per minute (RPM) by the account tier — `RPM = 10` on free, higher on Pro/Ultra
+(if the user says they're on Pro, you may raise it to ~30). The binding limit is **invocations per
+minute**, which is exactly why text docs are batched (one `group` call covers up to 4 docs). To avoid
+a slow OCR/vision doc gating a wave of fast text batches (head-of-line blocking), run **two queues**:
+
+- **Text/group queue** — all `group` and lone-`text` rows, in waves of up to `RPM` Agent calls per message.
+- **Vision queue** — all `vision` rows (scans/OCR, slower), in waves of up to 4.
+
+Fire each wave as multiple Agent calls in ONE message. A throttled call comes back with **no output
+file** (HTTP 429) — that is **rate-limiting, not a per-document failure**; do NOT stub it immediately.
+
+**Drive it as retry rounds** (don't trust the subagents' self-reports; trust the files on disk). Note
+a `group` row covers several summary files — expand its column-5 pipe list when checking:
+
+1. **Round 1** — dispatch both queues (text/group first, then vision) until every non-`cached` row
+   has been sent once.
+2. **Check** (ONE Bash call): split each manifest row's column 5 on `|` and `test -s` **every** member
+   summary file. Collect the `missing` summary files (and which row/group they belong to).
+3. **Retry rounds (up to 2)** — if `missing` is non-empty, **wait ~60s** (one `sleep 60` — lets the
+   per-minute quota reset), then re-dispatch only the rows that own a missing member (for a `group`,
+   re-send the whole batch; the call rewrites all its members) in waves of up to `RPM`, and re-check.
+4. **Stub the rest** — only after the retry rounds, for any summary file still missing/empty write a
+   stub yourself (`Write`) to that `<OUTDIR>/<summary>`:
+   ```
+   ---
+   doc: <basename>
+   estado: no_procesado
+   relevancia: 0
+   ---
+   No se pudo procesar tras reintentos (timeout o rate-limit de agy). Reintentar con /agy:notebook.
+   ```
+5. **Update the cache** (ONE Bash call): rewrite `<OUTDIR>/_cache.tsv` with one
+   `summary\tcache_key` line per member whose summary now exists and is non-empty (covers `cached`
+   rows + freshly-summarized ones; `group` rows are expanded; `no_procesado` stubs excluded so they
+   retry next run):
+   ```bash
+   python - "$OUTDIR" <<'PY'
+   import os, sys
+   od = sys.argv[1]; out = []
+   for ln in open(os.path.join(od, "_manifest.tsv"), encoding="utf-8"):
+       c = ln.rstrip("\n").split("\t")
+       if len(c) < 6: continue
+       for s, k in zip(c[4].split("|"), c[5].split("|")):   # group rows carry pipe-lists; singles split to 1
+           p = os.path.join(od, s)
+           if os.path.exists(p) and os.path.getsize(p) > 0:
+               if "estado: no_procesado" not in open(p, encoding="utf-8", errors="ignore").read(200):
+                   out.append(f"{s}\t{k}")
+   open(os.path.join(od, "_cache.tsv"), "w", encoding="utf-8").write("\n".join(out) + ("\n" if out else ""))
+   print(f"cache: {len(out)} member summaries recorded")
+   PY
+   ```
+
+> The per-minute ceiling is the real limiter, not local CPU. Batching text docs (≤4/call) is what
+> actually cuts wall-clock at scale — it lowers the invocation count the RPM ceiling applies to.
+> Pushing raw concurrency past `RPM` just produces more 429s, not more throughput.
+
+## Phase 2 — Index + master synthesis (switch model, then ONE agy subagent)
+
+First switch agy to a higher-quality model for the synthesis (ONE Bash call, best-effort):
+
+```bash
+python - <<'PY'
+import json, os
+sp=os.path.expanduser("~/.gemini/antigravity-cli/settings.json")
+try: cfg=json.load(open(sp,encoding="utf-8"))
+except Exception: cfg={}
+cfg["model"]="Gemini 3.1 Pro (Low)"
+json.dump(cfg,open(sp,"w",encoding="utf-8"),ensure_ascii=False,indent=2)
+print("model -> Gemini 3.1 Pro (Low) for the synthesis")
+PY
+```
+
+Then spawn ONE `antigravity:agy-rescue` subagent in **MODE: notebook-index**:
+
+```
+MODE: notebook-index
+CWD: <absolute current working dir>
+OBJETIVO: <objective>
+SUMMARIES_DIR: <OUTDIR>               # contains the *.resumen.md files
+INDEX_FILE: <OUTDIR>/INDEX.md
+MASTER_FILE: <OUTDIR>/RESUMEN_MAESTRO.md
+TIMELINE_FILE: <OUTDIR>/TIMELINE.md
+ENTIDADES_FILE: <OUTDIR>/ENTIDADES.md
+USER_TEXT:
+(empty)
+```
+
+## Phase 3 — Restore model + report
+
+First restore the user's original model (ONE Bash call — do this even if earlier phases failed):
+
+```bash
+python - <<'PY'
+import json, os
+sp=os.path.expanduser("~/.gemini/antigravity-cli/settings.json")
+mp=os.path.join(os.environ.get("TMPDIR","/tmp"),"agy_notebook_orig_model.txt")
+try: orig=open(mp,encoding="utf-8").read().strip()
+except Exception: orig=""
+try: cfg=json.load(open(sp,encoding="utf-8"))
+except Exception: cfg={}
+if orig: cfg["model"]=orig; json.dump(cfg,open(sp,"w",encoding="utf-8"),ensure_ascii=False,indent=2)
+print(f"model restored -> {orig or '(unchanged)'}")
+PY
+```
+
+Then read ONLY `<OUTDIR>/INDEX.md` and `<OUTDIR>/RESUMEN_MAESTRO.md` (they are small) and present:
+1. The objective and the doc counts (total / cached / text / vision / no_procesado).
+2. The TOP relevant documents from `INDEX.md`.
+3. The master summary's conclusion.
+4. The path to `<OUTDIR>` for the full per-document summaries, plus `TIMELINE.md` and `ENTIDADES.md`.
+5. Tip: ask follow-up questions over this corpus with `/agy:notebook-ask <folder> | <pregunta>`.
+
+Do NOT read the original documents or the per-document summaries yourself — that's the whole
+point (agy already did the reading). Only the two final files.
+
+## Notes
+- agy `--print` writes nothing to stdout outside a TTY (issue #76) — every agy call writes to a
+  file; the subagent verifies the file exists. This command never relies on agy stdout.
+- 1 document per agy call (large multimodal batches time out), up to 10 calls per wave (see Phase 1).
+- **Large scanned PDFs are chunked**: a scanned/vision PDF over ~20 pages is split into 15-page
+  sub-PDFs (in `_chunks/`), each summarized separately as `NN-<slug>-pSTART-END` — avoids the
+  single-call timeout on big scans. Text-layer PDFs are not chunked (compact enough for one call).
+- **Incremental**: re-running the same folder + objective only re-summarizes new/changed documents
+  (cache in `_cache.tsv`, keyed by size+mtime+objective hash). Change the objective → full re-sweep.
+- **Model routing** is automatic (Flash Low for the per-doc sweep, 3.1 Pro Low for the synthesis,
+  original restored after) and best-effort — see `/agy:model` to inspect/override the active model.
+- The `_text/`, `_manifest.tsv` and `_cache.tsv` are intermediate artifacts; keep `_cache.tsv` to
+  preserve the incremental cache, the rest can be deleted.
diff --git a/plugins/antigravity/commands/record.md b/plugins/antigravity/commands/record.md
new file mode 100644
index 0000000..14ce78a
--- /dev/null
+++ b/plugins/antigravity/commands/record.md
@@ -0,0 +1,76 @@
+---
+description: Record a browser walkthrough of a URL using Antigravity (agy). Generates .webm video, screenshots, and a report. Auto-converts to MP4 if ffmpeg is available.
+argument-hint: "<url> [steps in natural language]"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: record.
+
+Raw user request:
+$ARGUMENTS
+
+## Routing rules
+
+1. **Parse the URL**: the first whitespace-separated token of `$ARGUMENTS` that starts with `http://` or `https://` IS the URL. If the user wrote it without a scheme, prepend `https://`. If no URL is found, ask once: "What URL should I record?".
+
+2. **Steps**: everything else in `$ARGUMENTS` (whatever is not the URL) is the natural-language steps. If empty, use the default exploratory walkthrough (see template below).
+
+3. **Slug**: build from the URL's host + first path segment (e.g. `https://erp.traidagency.com/login` → `erp-traidagency-com-login`). Lowercase, non-alphanumeric → `-`, collapse repeats, trim to 60 chars.
+
+4. **Date**: today in `YYYY-MM-DD` (local time).
+
+5. **Paths** (all relative to current working directory):
+   - `OUTPUT_DIR` = `docs/agy/recordings/`
+   - `REPORT_FILE` = `docs/agy/recordings/<date>-<slug>.md`
+   - `VIDEO_FILE` = `docs/agy/recordings/<date>-<slug>.webm`
+   - `MP4_FILE` = `docs/agy/recordings/<date>-<slug>.mp4` (only if ffmpeg available)
+
+6. **Pre-flight**: with ONE `Bash` call:
+   ```bash
+   mkdir -p docs/agy/recordings
+   ```
+
+7. **Hand off to subagent**: pass this header block followed by the URL and steps:
+
+   ```
+   MODE: record
+   URL: <url>
+   CWD: <absolute path to current working directory>
+   OUTPUT_DIR: docs/agy/recordings
+   REPORT_FILE: docs/agy/recordings/<date>-<slug>.md
+   VIDEO_FILE: docs/agy/recordings/<date>-<slug>.webm
+   STEPS:
+   <natural-language steps, or "DEFAULT_WALKTHROUGH" if empty>
+   ```
+
+## Default walkthrough (when no steps given)
+
+If the user did not provide steps, instruct agy to:
+
+1. Navigate to the URL and wait for DOM ready.
+2. Take an initial screenshot.
+3. Scroll slowly to the bottom of the page in 3-4 steps.
+4. Scroll back to the top.
+5. Identify the most prominent visible CTA (button/link), click it. Do NOT type credentials or fill forms.
+6. Take a final screenshot.
+7. Stop.
+
+## Operating rules
+
+- The subagent invokes agy with `--add-dir <CWD>` so the browser subagent can write the report directly into the project. It also instructs agy to write the report to `REPORT_FILE` and to ensure the .webm artifact ends up at or copied to `VIDEO_FILE`.
+- After agy returns, the subagent attempts MP4 conversion via ffmpeg (`ffmpeg -i <webm> -c:v libx264 -crf 23 -preset fast -c:a aac <mp4>`). If ffmpeg is missing, it logs a warning and skips conversion, leaving the .webm as the only output.
+- The subagent reports:
+  1. Saved video path(s) (.webm always, .mp4 if conversion succeeded).
+  2. Saved report path.
+  3. First ~30 lines of the report.
+  4. If ffmpeg is missing: hint to install (`winget install Gyan.FFmpeg` on Windows, `brew install ffmpeg` on macOS, `apt install ffmpeg` on Linux).
+- Present that to the user as-is. Do not paraphrase.
+- If agy reports it is missing or unauthenticated, tell the user to run `/agy:setup`.
+- If the URL is blocked, returns non-200, or the browser session crashes, surface the error verbatim.
+
+## Notes
+
+- Recordings have **no audio**. If the user needs narration, suggest pairing with their TTS skill afterwards and muxing with ffmpeg.
+- agy uses an **isolated Chrome profile** — cookies, sessions, and extensions from the user's main Chrome are NOT available. If the demo requires login, the user must pass credentials in the steps (e.g., "login with demo@x.com / pass=test1234") and accept that those credentials will be in the prompt/transcript.
+- Long recordings (multi-minute flows) increase token usage and may hit timeouts. Default timeout is 8 minutes; the subagent allows up to 15 minutes if the steps look complex.
diff --git a/plugins/antigravity/commands/report.md b/plugins/antigravity/commands/report.md
new file mode 100644
index 0000000..d5b8f26
--- /dev/null
+++ b/plugins/antigravity/commands/report.md
@@ -0,0 +1,148 @@
+---
+description: Generate a publication-grade HTML report from a markdown source using the TRAID Design System catalog (5 templates). Agy matches content to template, you confirm, agy produces final branded HTML.
+argument-hint: "<markdown_path> [--template <id>] [--output <html_path>]"
+context: fork
+allowed-tools: Bash, Read, Write, Agent, AskUserQuestion
+---
+
+Two-phase orchestrator using the canonical TRAID Design System catalog of 5 templates: `traid-dark`, `traid-light`, `stripe-press`, `notion-docs`, `magazine`. Full specs in `knowledge/traid/design-system/design-system.md`.
+
+Raw user request:
+$ARGUMENTS
+
+## Phase 1 — Parse and validate
+
+- Parse optional flags:
+  - `--template <id>` — if provided with a valid id (`traid-dark | traid-light | stripe-press | notion-docs | magazine`), SKIP Phase 2 and Phase 3 (analyze + ask) and use that template directly.
+  - `--output <path>` — custom output HTML path.
+  - `--images <mode>` — `native` (default) | `external` | `none`. Controls how `![generate: ...]` cues become images:
+    - `native`: agy generates each image itself (no external deps; quality/format inconsistent in headless agy — broken/missing images are caught by the Phase 5 check).
+    - `external`: agy only references `<basename>.assets/<slug>.png`; YOU (or the caller) pre-generate those PNGs with a dedicated image model. **Recommended for brand-quality infographics.** See "Image strategy" below.
+    - `none`: styled placeholders instead of images (no broken `<img>`).
+- What remains after stripping flags is the markdown source path.
+- If the source path is empty, ask once: "Which markdown file should agy turn into a report?"
+- Resolve the source path against the current working directory if relative. If it doesn't exist or isn't readable, stop without invoking the subagent.
+- Compute default output if `--output` omitted:
+  - `output-slug` = source filename minus extension, lowercased, non-alphanumeric → `-`, collapsed, trimmed 60 chars. (Distinct from the per-image `<slug>` used for `![generate:]` cues below.)
+  - `date` = today YYYY-MM-DD.
+  - `output` = `docs/agy/reports/<date>-<output-slug>.html` relative to CWD.
+- Ensure output dir exists:
+  ```bash
+  mkdir -p docs/agy/reports
+  ```
+
+## Phase 2 — Analyze (SKIP if `--template` was provided)
+
+Invoke the `antigravity:agy-rescue` subagent with this header:
+
+```
+MODE: report-analyze
+INTENSITY:
+MODEL:
+RESUME: false
+WRITE_FILE:
+SOURCE_FILE: <absolute path to source markdown>
+USER_TEXT:
+```
+
+The subagent matches the source content against the embedded 5-template catalog and returns JSON of the shape:
+
+```json
+{
+  "content_analysis": {
+    "tone": "...",
+    "audience": "internal | client-facing | research | publication",
+    "structure": "...",
+    "key_cues": ["...", "...", "..."]
+  },
+  "recommendations": [
+    {"template_id": "traid-dark | traid-light | stripe-press | notion-docs | magazine", "rank": 1, "fit_score": "high|medium|low", "justification": "..."},
+    { ... up to 2 more ... }
+  ]
+}
+```
+
+The subagent returns the raw JSON.
+
+## Phase 3 — Ask user (SKIP if `--template` was provided OR if recommendations has exactly 1 entry)
+
+Parse the JSON. Cases:
+
+- **Exactly 1 recommendation with fit_score "high"** → auto-select it, tell the user "Auto-selected `<name>` (high fit: <justification>)" and proceed to Phase 4.
+- **2-3 recommendations** → use `AskUserQuestion` with the recommended template_ids as options. Each option's `label` is the template's display name; each option's `description` combines `fit_score`, `justification`, and a one-line vibe summary.
+- **JSON parse failed or zero recommendations** → fall back to asking the user freeform which of the 5 templates to use (list all 5 from the catalog).
+
+The catalog of valid template_ids and their display names:
+
+| `template_id` | Display name | One-line vibe |
+|---|---|---|
+| `traid-dark` | TRAID Dark Deck | Pink + obsidian, commercial nocturnal, glow halos |
+| `traid-light` | TRAID Sales Deck | Pink + white + ink dark, commercial print-ready A4 |
+| `stripe-press` | Stripe Press Editorial | Source Serif 4 + indigo, scholarly premium |
+| `notion-docs` | Notion Modern Docs | System sans + color-coded callouts + TOC sidebar |
+| `magazine` | Magazine Editorial Wired 2023 | Fraunces + gradient + pull-quotes, bold longform |
+
+## Phase 4 — Generate (subagent MODE: report-generate)
+
+Construct the full STYLE_SPEC for the chosen `template_id` by reading the section for that template from `knowledge/traid/design-system/design-system.md`. The STYLE_SPEC must include:
+
+- Template ID + display name
+- Full palette (every CSS custom property with hex)
+- Typography pairing (family + size + weight + line-height)
+- Layout (max-width + padding + column structure)
+- Required components (named with their CSS class conventions)
+- Anti-patterns
+- Reference exemplar (if any)
+
+Then invoke the subagent:
+
+```
+MODE: report-generate
+INTENSITY:
+MODEL:
+RESUME: false
+WRITE_FILE: <output path computed in phase 1>
+SOURCE_FILE: <absolute path to source markdown>
+STYLE_SPEC: <full multiline STYLE_SPEC block per design-system.md>
+IMAGES: <native|external|none from --images flag, default native>
+USER_TEXT:
+```
+
+If `--images external`: BEFORE invoking report-generate, compute the assets dir (`<output basename>.assets/` next to the HTML) and the expected `<slug>.png` filenames for each `![generate: ...]` cue in the source (slug = description lowercased, non-alphanumeric → `-`, collapsed, trimmed 60 chars). Generate those PNGs with whatever image model the user has available (e.g. the `gemini_image_generation` MCP tool with model `gemini-3.1-flash-image-preview` / Nano Banana 2 — include the TRAID brand signature in commercial prompts), saving each as `<assets-dir>/<slug>.png`, THEN run report-generate so agy references the already-present files.
+
+The subagent calls agy with a prompt that asks it to:
+- Read `SOURCE_FILE`.
+- Apply the full `STYLE_SPEC` rigorously — palette, typography, components, anti-patterns are all non-negotiable.
+- For each `![generate: <description>]` cue in the markdown, invoke the native `generate_image` tool and embed inline.
+- Compose a single self-contained HTML.
+- Write to `WRITE_FILE` via `write_file`.
+
+## Phase 5 — Report back
+
+When the subagent returns, present:
+1. Saved HTML path (absolute).
+2. Template selected (display name + template_id).
+3. Images: the `IMAGES_PRESENT=<n>/<total>` line from the assets-existence check, the IMAGES mode used, and — if any are missing — the list of expected `<slug>.png` and the `ASSETS_DIR` path. If images are missing in `native` mode, suggest re-running with `--images external` (pre-generate the PNGs) or `--images none`.
+4. Open hint for the user's platform:
+   - Windows: `start "<path>"`
+   - macOS: `open "<path>"`
+   - Linux: `xdg-open "<path>"`
+   - (Note: opening via `file://` may block local `<img>` loading in some setups; if images don't show, serve the folder with `python -m http.server` and open over `http://`.)
+
+## Operating rules
+
+- If agy reports missing/unauthenticated at any phase, tell the user to run `/agy:setup` and stop.
+- Do not paraphrase agy's output between phases.
+- If `--template <id>` is invalid (not one of the 5 canonical IDs), reject with an error listing valid IDs and stop.
+- If the source markdown has zero `![generate: ...]` cues, agy still produces HTML — log it as "0 images".
+- The full design system reference lives in `knowledge/traid/design-system/design-system.md`. Keep this command and that document in sync — if a template is added/removed/changed there, update Phase 3 catalog table and Phase 1 valid `--template` IDs here.
+
+## Image strategy (infographics)
+
+The intended flow is: **you write a clean source `.md` with `![generate: <description>]` cues, agy turns it into a branded document, and the cues become infographics.** How the images are produced depends on `--images`:
+
+- **`--images native` (default):** agy generates the images itself. Zero setup, but in headless mode agy is unreliable — it may emit JPEG bytes under a `.png` name, or reference images it never created (broken `<img>`). The Phase 5 assets-existence check catches this and tells you what's missing. Fine for drafts and quick internal docs.
+- **`--images external` (recommended for client/brand-grade infographics):** generate the PNGs yourself with a dedicated image model — e.g. **Nano Banana 2** (`gemini_image_generation`, model `gemini-3.1-flash-image-preview`) — into the `<basename>.assets/` dir using the slug convention, THEN run report-generate so agy just references them. Real PNGs, full brand control, deterministic. This is the path that produces the polished result.
+- **`--images none`:** styled placeholder boxes (the description as caption) instead of images — useful when you'll drop final art in later or the doc is text-first.
+
+Slug convention (so pre-generated filenames match agy's references): `<description lowercased, non-alphanumeric → "-", collapsed, trimmed to 60 chars>.png`.
diff --git a/plugins/antigravity/commands/rescue.md b/plugins/antigravity/commands/rescue.md
new file mode 100644
index 0000000..6dc013b
--- /dev/null
+++ b/plugins/antigravity/commands/rescue.md
@@ -0,0 +1,39 @@
+---
+description: Delegate a coding, debugging or implementation task to the Antigravity CLI (agy) subagent
+argument-hint: "[--background] [--resume|--fresh] <what agy should do>"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this request to the `antigravity:agy-rescue` subagent in MODE: rescue.
+
+Raw user request:
+$ARGUMENTS
+
+Routing rules:
+
+- If the request contains `--background`, invoke the subagent with `run_in_background: true`. Use this when the user phrasing suggests a long-running task ("investigate", "refactor the whole module", "write tests for everything in X") and they explicitly opted in. Strip the flag.
+- If the request includes `--resume`, set `RESUME: true` in the header you pass to the subagent.
+- If the request includes `--fresh`, set `RESUME: false`.
+- If neither flag is present and the user phrasing sounds like a follow-up ("continue", "keep going", "resume", "apply the first fix"), set `RESUME: true`. Otherwise `RESUME: false`.
+- Strip the routing flags (`--background`, `--resume`, `--fresh`) from the user text before forwarding.
+
+Pass this header block to the subagent followed by the cleaned user text:
+
+```
+MODE: rescue
+INTENSITY:
+MODEL:
+RESUME: <true|false>
+WRITE_FILE:
+USER_TEXT:
+<cleaned user request>
+```
+
+> **Note**: `--model` was rejected by `agy` 1.0.0/1.0.1 but is accepted again in **agy 1.0.5+**. This plugin defaults to omitting it (cross-version-safe — `agy` uses its configured default, typically Gemini 3.5 Flash "Medium"). The `MODEL:` header field is passed through to the subagent, which only forwards `--model` when set AND the local `agy --version` is ≥ 1.0.5; otherwise it's ignored.
+
+Operating rules:
+
+- The subagent is a thin forwarder. It returns agy's stdout verbatim.
+- Return that stdout to the user as-is. Do not add commentary before or after.
+- If agy reports it is missing or unauthenticated, tell the user to run `/agy:setup`.
diff --git a/plugins/antigravity/commands/research.md b/plugins/antigravity/commands/research.md
new file mode 100644
index 0000000..f9f1d33
--- /dev/null
+++ b/plugins/antigravity/commands/research.md
@@ -0,0 +1,48 @@
+---
+description: Run deep web research with Antigravity (agy) at chosen intensity. Saves output to docs/agy/research/ automatically.
+argument-hint: "[--background] [--intensity low|medium|high] <topic>"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: research.
+
+Raw user request:
+$ARGUMENTS
+
+Routing rules:
+
+- If the request contains `--background`, invoke the subagent with `run_in_background: true`. Research at `high` intensity can take 15–20min — background is the sensible default for that case but only when the user explicitly opted in. Strip the flag from the topic.
+- Parse `--intensity <low|medium|high>` from the user text. Default to `medium` if missing or invalid.
+- Strip the routing flags (`--background`, `--intensity`) from the user text. What remains IS the topic. Trim whitespace.
+- Build a slug from the topic: lowercase, replace non-alphanumeric with `-`, collapse repeated `-`, trim to 60 chars.
+- Compute today's date in `YYYY-MM-DD` (ISO, local time).
+- Compute `WRITE_FILE` = `docs/agy/research/<YYYY-MM-DD>-<slug>.md` (relative to the current working directory).
+- Before invoking the subagent, ensure the directory exists with one `Bash` call:
+
+```bash
+mkdir -p docs/agy/research
+```
+
+Pass this header block to the subagent followed by the topic:
+
+```
+MODE: research
+INTENSITY: <low|medium|high>
+MODEL:
+RESUME: false
+WRITE_FILE: docs/agy/research/<date>-<slug>.md
+USER_TEXT:
+<topic>
+```
+
+> **Note**: `--model` was rejected by `agy` 1.0.0/1.0.1 but is accepted again in **agy 1.0.5+**. This plugin defaults to omitting it, so `agy` picks the model from its own settings; intensity controls the timeout and prompt template only.
+
+Operating rules:
+
+- The subagent wraps the topic in the intensity template, invokes agy with the right timeout (`low=3m`, `medium=8m`, `high=20m`), writes the result to `WRITE_FILE`, and returns:
+  1. The saved file path.
+  2. The first ~30 lines of agy's output (TL;DR / Executive summary).
+- Present that to the user as-is. Do not paraphrase.
+- If the user did not provide a topic, ask once: "What topic would you like to research?"
+- If agy reports it is missing or unauthenticated, tell the user to run `/agy:setup`.
diff --git a/plugins/antigravity/commands/review.md b/plugins/antigravity/commands/review.md
new file mode 100644
index 0000000..8c3d650
--- /dev/null
+++ b/plugins/antigravity/commands/review.md
@@ -0,0 +1,58 @@
+---
+description: Send the current git diff to Antigravity (agy) for code review. Optional focus text to steer the review.
+argument-hint: "[--background] [focus text]"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: review.
+
+Raw user request:
+$ARGUMENTS
+
+Routing rules:
+
+- If the request contains `--background`, invoke the subagent with `run_in_background: true`. Strip the flag.
+- Capture the current git diff BEFORE delegating. Use ONE Bash call with this exact fallback chain (do not invent your own — `git diff HEAD` first because it includes committed-but-not-pushed work too):
+
+  ```bash
+  set -e
+  REPO_DIR="${CLAUDE_PROJECT_DIR:-$PWD}"
+  DIFF_FILE="$(mktemp -t agy-review-XXXXXX.diff 2>/dev/null || mktemp)"
+  git -C "$REPO_DIR" diff HEAD > "$DIFF_FILE" 2>/dev/null || true
+  if [ ! -s "$DIFF_FILE" ]; then
+    git -C "$REPO_DIR" diff > "$DIFF_FILE" 2>/dev/null || true
+  fi
+  if [ ! -s "$DIFF_FILE" ]; then
+    rm -f "$DIFF_FILE"
+    echo "NO_DIFF"
+  else
+    OUT_FILE="${DIFF_FILE%.diff}.review.md"
+    echo "DIFF_FILE=$DIFF_FILE"
+    echo "OUT_FILE=$OUT_FILE"
+    wc -l < "$DIFF_FILE"
+  fi
+  ```
+
+- If the Bash output is `NO_DIFF`, tell the user "no git diff found in this repo — stage or make changes first" and stop. Do NOT invoke the subagent.
+- Anything left in the user text after stripping `--background` is the focus text (may be empty). Default focus if empty: "review for correctness, edge cases, security issues, and style".
+
+Pass this header block to the subagent followed by the focus text:
+
+```
+MODE: review
+INTENSITY:
+MODEL:
+RESUME: false
+WRITE_FILE: <absolute OUT_FILE path echoed above>
+FOCUS: <focus text or default>
+DIFF_FILE: <absolute path captured above>
+USER_TEXT:
+```
+
+Operating rules:
+
+- The subagent reads `DIFF_FILE`, builds a review prompt embedding the diff + focus, invokes agy via the write_file workaround (bug #76), and returns the review verbatim.
+- Present agy's response as-is. No paraphrase.
+- If agy reports missing/unauthenticated, tell the user to run `/agy:setup`.
+- After delegating, leave the temp `DIFF_FILE` alone — the subagent owns its lifecycle (it cleans up on success).
diff --git a/plugins/antigravity/commands/scrape.md b/plugins/antigravity/commands/scrape.md
new file mode 100644
index 0000000..b26ea0b
--- /dev/null
+++ b/plugins/antigravity/commands/scrape.md
@@ -0,0 +1,60 @@
+---
+description: Scrape structured data from a single URL using Antigravity (agy). Returns markdown table or JSON. Saves to docs/agy/scrapes/.
+argument-hint: "<url> [schema fields or natural language description] [--json]"
+context: fork
+allowed-tools: Bash, Write
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: scrape.
+
+Raw user request:
+$ARGUMENTS
+
+## Routing rules
+
+1. **Parse the URL**: the first whitespace-separated token of `$ARGUMENTS` that starts with `http://` or `https://` IS the URL. If the user wrote it without a scheme, prepend `https://`. If no URL is found, ask once: "What URL should I scrape?".
+
+2. **Parse `--json`**: if present, set `FORMAT=json` and strip the flag from the remaining text. Default is `FORMAT=md`.
+
+3. **Schema/description**: everything else in `$ARGUMENTS` (whatever is not the URL and not `--json`) is the schema or natural-language extraction description. If empty, agy will infer reasonable fields from the page.
+
+4. **Slug**: build from the URL's host + first path segment (lowercase, non-alphanumeric → `-`, collapse repeats, trim to 60 chars).
+
+5. **Date**: today in `YYYY-MM-DD` (local time).
+
+6. **Paths** (relative to current working directory):
+   - `OUTPUT_DIR` = `docs/agy/scrapes/`
+   - `WRITE_FILE` = `docs/agy/scrapes/<date>-<slug>.md` (or `.json` if `--json`)
+
+7. **Pre-flight** (ONE `Bash` call):
+   ```bash
+   mkdir -p docs/agy/scrapes
+   ```
+
+8. **Hand off**: pass this header to the subagent:
+
+   ```
+   MODE: scrape
+   URL: <url>
+   SCHEMA: <schema or natural-language description, or empty>
+   FORMAT: md|json
+   CWD: <absolute path to current working directory>
+   WRITE_FILE: docs/agy/scrapes/<date>-<slug>.md
+   ```
+
+## Operating rules
+
+- The subagent invokes agy with `--add-dir <CWD>` so it can write the scrape report into the project.
+- The subagent reports:
+  1. Saved scrape path.
+  2. First ~30 lines of the scrape result (preview).
+  3. Number of records/fields extracted.
+- Present that to the user as-is.
+- If the URL returns non-200, the page is blocked by anti-bot, or the structure cannot be parsed, surface the error verbatim.
+
+## Notes
+
+- For JSON-API endpoints, `--json` is preferred. For HTML landing pages or content sites, default `md` table is usually more readable.
+- agy uses its browser/read_url tool to fetch — JS-heavy SPAs require the browser subagent (slower but works). Static HTML works via read_url (faster).
+- agy uses an isolated Chrome profile if it needs to render JS — no cookies, no logged-in state.
+- For aggressive scraping (anti-bot bypass), this is the wrong tool. Use BrightData / ScrapingBee.
diff --git a/plugins/antigravity/commands/setup.md b/plugins/antigravity/commands/setup.md
new file mode 100644
index 0000000..2fd0c8a
--- /dev/null
+++ b/plugins/antigravity/commands/setup.md
@@ -0,0 +1,39 @@
+---
+description: Check whether the Antigravity CLI (agy) is installed, on PATH, and responding to a ping
+argument-hint: ""
+allowed-tools: Bash
+---
+
+Route this to the `antigravity:agy-rescue` subagent in MODE: setup.
+
+Pass this header block to the subagent:
+
+```
+MODE: setup
+INTENSITY:
+MODEL:
+RESUME: false
+WRITE_FILE:
+USER_TEXT:
+```
+
+The subagent will:
+
+1. Resolve the `agy` binary (PATH, then `AGY_BIN`, then per-OS fallback paths).
+2. Try `agy changelog` to read the current version.
+3. Run a 30s ping: a minimal `--print` call expecting "pong" back.
+4. Report binary path, version, and ping status.
+
+Output rules:
+
+- Present the final setup output to the user as-is.
+- If the binary is missing, tell the user to install Antigravity:
+
+  - **Windows (PowerShell):** `irm https://antigravity.google/cli/install.ps1 | iex`
+  - **macOS / Linux (bash):** `curl -fsSL https://antigravity.google/cli/install.sh | bash`
+
+  After install, restart the shell so the binary lands on PATH.
+
+- If the binary exists but ping times out (empty stdout + exit 0), the symptom is ambiguous in agy 1.0.x:
+  1. **Tool-call loop** (most common in v0.1.1+): the model entered an agentic loop and consumed the timeout before flushing. Re-run with a higher `--print-timeout` or a stricter "do not use tools" prompt.
+  2. **OAuth missing**: verify with `ls ~/.gemini/antigravity-cli/installation_id`. If absent or empty, run `agy` once interactively in a regular terminal to complete the Google OAuth login.
diff --git a/plugins/antigravity/commands/transcribe.md b/plugins/antigravity/commands/transcribe.md
new file mode 100644
index 0000000..2a6d275
--- /dev/null
+++ b/plugins/antigravity/commands/transcribe.md
@@ -0,0 +1,67 @@
+---
+description: Transcribe and summarize an AUDIO or VIDEO file (or a YouTube/remote URL) with Antigravity (agy / Gemini 3.x multimodal) — something Claude can't do natively. Voice notes, meetings, calls, screencasts. Faithful transcript + summary; timestamps for video/URLs. Saves to docs/agy/transcripts/.
+argument-hint: "<audio|video file | YouTube/URL> [focus]"
+context: fork
+allowed-tools: Bash, Read, Agent
+---
+
+Offload audio/video understanding to `agy` (Gemini is natively multimodal in audio + video; Claude
+Code is not). Give it a local audio/video file or a YouTube/remote URL; get a faithful transcript
+and a summary back, written to a file (cheap on Claude's context).
+
+Raw user request:
+$ARGUMENTS
+
+## Phase 0 — Resolve source + kind (ONE Bash call)
+
+Parse `$ARGUMENTS`: the first token that is a URL (`http://`/`https://`) OR an existing file
+(`test -f`) is the **source**; everything else is an optional **focus**. If nothing resolves, ask
+once: "¿Qué audio/video/URL transcribo?" and stop.
+
+```bash
+python - "$SOURCE" <<'PYEOF'
+import sys, os, re, datetime
+src = sys.argv[1].strip().strip('"')
+AUD = (".ogg",".mp3",".wav",".m4a",".aac",".flac",".opus",".aiff")
+VID = (".mp4",".mov",".webm",".mkv",".avi",".m4v")
+low = src.lower()
+if low.startswith("http"):
+    kind = "url"; addir = ""
+    base = re.sub(r"[^a-z0-9]+","-", re.sub(r"^https?://(www\.)?","",low)).strip("-")[:50] or "url"
+else:
+    kind = "video" if low.endswith(VID) else "audio"
+    addir = os.path.dirname(os.path.abspath(src))
+    base = re.sub(r"[^a-z0-9]+","-", os.path.splitext(os.path.basename(src))[0].lower()).strip("-")[:50] or "media"
+out = os.path.join("docs","agy","transcripts", f"{base}.md")
+os.makedirs(os.path.dirname(out), exist_ok=True)
+print(f"KIND={kind}\nADD_DIR={addir}\nWRITE_FILE={os.path.abspath(out)}\nSOURCE={src}")
+PYEOF
+```
+
+## Phase 1 — Transcribe (ONE agy subagent)
+
+Spawn ONE `antigravity:agy-rescue` subagent in **MODE: transcribe**:
+
+```
+MODE: transcribe
+CWD: <absolute current working dir>
+KIND: audio|video|url
+SOURCE: <file path or URL>
+ADD_DIR: <dir of the source file, or empty for a URL>
+FOCUS: <focus text or empty>
+WRITE_FILE: <WRITE_FILE>
+USER_TEXT:
+(empty)
+```
+
+## Phase 2 — Present
+
+Read ONLY `<WRITE_FILE>` and present: the summary first, then the transcript path. Don't re-process
+the media yourself.
+
+## Notes
+- Gemini handles common audio (ogg/opus/mp3/wav/m4a/flac) and video (mp4/mov/webm/…); YouTube and
+  other public URLs work without downloading.
+- Long files (>~30 min) can hit the timeout — split with `ffmpeg` first if needed (the subagent
+  raises the timeout for video/URL automatically).
+- agy `--print` writes nothing to stdout outside a TTY (issue #76); the transcript is read from the file.
diff --git a/plugins/antigravity/config/model-map.json b/plugins/antigravity/config/model-map.json
new file mode 100644
index 0000000..5b74c7e
--- /dev/null
+++ b/plugins/antigravity/config/model-map.json
@@ -0,0 +1,22 @@
+{
+  "_comment": "Stable aliases → exact agy model labels (as they appear in ~/.gemini/antigravity-cli/settings.json and the TUI 'Switch Model' list). agy's --model CLI flag is unreliable — an unknown id silently falls back to the default. The reliable way to switch models is to write the exact label into settings.json (this is what the TUI does); --print then respects it. The '(Low/Medium/High)' suffix is the thinking-effort level (no separate CLI flag — it is part of the model variant). If a label here is wrong, agy will silently keep the previous model: open the `agy` TUI → Switch Model to read the exact strings for your account, then `/agy:model \"<exact label>\"`. Model availability depends on the account tier (free = Flash / Flash-Lite only; Pro adds 3.1 Pro and the Claude/GPT-OSS variants).",
+  "settings_path": "~/.gemini/antigravity-cli/settings.json",
+  "settings_key": "model",
+  "default": "flash-low",
+  "aliases": {
+    "flash-low": "Gemini 3.5 Flash (Low)",
+    "flash": "Gemini 3.5 Flash (Medium)",
+    "flash-medium": "Gemini 3.5 Flash (Medium)",
+    "flash-high": "Gemini 3.5 Flash (High)",
+    "pro": "Gemini 3.1 Pro (Low)",
+    "pro-low": "Gemini 3.1 Pro (Low)",
+    "pro-high": "Gemini 3.1 Pro (High)",
+    "sonnet": "Claude Sonnet 4.6 (Thinking)",
+    "opus": "Claude Opus 4.6 (Thinking)",
+    "gpt-oss": "GPT-OSS 120B"
+  },
+  "notes": {
+    "barridos-masivos": "flash-low — rápido/barato para resúmenes por-documento (/agy:notebook)",
+    "sintesis-calidad": "pro o pro-high — para la síntesis final donde importa la calidad"
+  }
+}