opencode-skills-collection 3.0.21 → 3.0.23

package/bundled-skills/subagent-orchestrator/README.md

@@ -0,0 +1,99 @@
+# Subagent Orchestrator — Antigravity 2.0 Skill
+
+A quota-aware, parallel subagent coordination skill for Antigravity 2.0.
+
+Turns one big task into a set of isolated, efficient agent missions — without burning your weekly quota in 30 minutes.
+
+---
+
+## What it does
+
+- Splits complex tasks into isolated agent missions before any code is written
+- Routes tasks to the cheapest model that can handle them (Flash by default)
+- Runs independent agents in parallel, not in sequence
+- Monitors quota usage throughout and pauses if limits are approaching
+- Recovers from agent failures without re-running the whole mission
+- Runs a final integration check before declaring the mission complete
+
+---
+
+## Install
+
+**One command (Windows PowerShell):**
+```powershell
+node scripts/install.js
+```
+
+**Manual install — copy this folder to:**
+```
+Windows: %APPDATA%\.gemini\antigravity\skills\subagent-orchestrator\
+Mac/Linux: ~/.gemini/antigravity/skills/subagent-orchestrator/
+```
+
+Then restart your Antigravity session.
+
+---
+
+## Usage
+
+The skill auto-activates when your task:
+- Spans 3+ files or components
+- Needs parallel agents (UI + API, planner + builder, etc.)
+- Has quota risk (large codebase, many tool calls expected)
+
+Or trigger it manually:
+```
+"Use subagent-orchestrator to build the auth flow"
+```
+
+---
+
+## Folder structure
+
+```
+subagent-orchestrator/
+├── SKILL.md                          ← Main skill (auto-loaded by Antigravity)
+├── scripts/
+│   └── install.js                    ← Installer script
+├── examples/
+│   ├── nextjs-feature.md             ← 3-agent parallel Next.js feature
+│   ├── api-plus-frontend.md          ← Backend + frontend parallel build
+│   └── debug-mission.md              ← Minimal quota repair mission
+└── resources/
+    ├── mission-brief-template.md     ← Copy-paste template for any mission
+    └── quota-reference.md            ← Cost estimates for every action type
+```
+
+---
+
+## Quota reference (quick)
+
+| Model | Cost |
+|-------|------|
+| Gemini Flash | 1x (default for all subagents) |
+| Claude Sonnet | ~4x (max 1 per mission) |
+| Claude Opus | Never use in subagents |
+
+| Mission size | Est. sprint used |
+|-------------|-----------------|
+| 1-file repair | < 5% |
+| Single feature | 15–25% |
+| Full flow (auth, API, UI) | 30–45% |
+
+---
+
+## Contributing
+
+This skill was built to fill a real gap — the community's existing subagent skills had no quota management, no parallel coordination, and no error recovery.
+
+PRs welcome. Follow the SKILL.md format from the Antigravity docs.
+Submit to: https://github.com/sickn33/antigravity-awesome-skills
+
+---
+
+## Compatibility
+
+- Antigravity 2.0+ (CLI and IDE)
+- Claude Code
+- Cursor (via SKILL.md standard)
+- OpenCode

package/bundled-skills/subagent-orchestrator/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: subagent-orchestrator
+risk: safe
+source: community
+description: Coordinate quota-aware parallel subagents for large, multi-file Antigravity tasks.
+version: 1.0.0
+author: community
+tags: [subagents, orchestration, quota, parallel, multi-agent]
+---
+
+# Subagent Orchestrator
+
+A quota-aware, parallel subagent coordination skill for Antigravity 2.0. Turns one big task into a set of isolated, efficient agent missions — without burning your weekly quota.
+
+---
+
+## Use this skill when
+- A task spans 3+ files or components
+- You want multiple agents working at the same time
+- You've hit quota issues mid-task before
+- The task involves both planning AND building
+- You need browser agent + code agent + terminal agent running together
+
+## Do not use this skill when
+- Editing a single file or fixing one bug
+- Writing a quick script under 50 lines
+- Asking a question or generating a plan only
+
+---
+
+## Phase 1 — DECOMPOSE (before any agent runs)
+
+Before spawning any subagent, the orchestrator MUST produce a Mission Brief. Announce:
+> "Running subagent-orchestrator skill. Decomposing task into isolated missions."
+
+Then output a Mission Brief in this format:
+
+```
+MISSION BRIEF
+─────────────────────────────────────────
+Goal: [one sentence, what done looks like]
+Total Agents: [N]
+Quota Strategy: [FLASH / SONNET / MIXED]
+Expected Token Cost: [LOW / MEDIUM / HIGH]
+
+AGENTS:
+[1] ID: agent-001
+    Role: [e.g. Planner / Builder / Tester / Browser]
+    Scope: [exact files or URLs this agent touches]
+    Model: [Gemini Flash / Claude Sonnet]
+    Input: [what it receives]
+    Output: [what it produces]
+    Depends on: [none / agent-001]
+
+[2] ...
+─────────────────────────────────────────
+```
+
+**Wait for user to approve the Mission Brief before proceeding.**
+If the user edits it, update and re-confirm. Never skip this step.
+
+---
+
+## Phase 2 — QUOTA ROUTING
+
+Before assigning models, apply this decision tree:
+
+```
+Is this task > 20 files OR > 500 lines of new code?
+  YES → Use Gemini Flash for all agents. Reserve Sonnet for final review only.
+  NO  → Is this task creative UI / complex logic / API design?
+          YES → Use Sonnet for builder agent, Flash for all others.
+          NO  → Use Gemini Flash for everything.
+```
+
+**Model cost rules (never violate these):**
+- Claude Opus → NEVER use in subagents. Too expensive.
+- Claude Sonnet → Max 1 subagent per mission.
+- Gemini Flash → Default for all subagents. Fast, cheap, separate quota pool.
+- Browser subagent → Always runs on its own pool. Use sparingly (1 per mission max).
+
+---
+
+## Phase 3 — CONTEXT ISOLATION
+
+Each subagent gets a scoped context packet. Never give all agents the full codebase.
+
+For each agent, prepare:
+```
+AGENT CONTEXT PACKET — agent-[ID]
+Files to read: [list only what this agent needs]
+Files to write: [list only what this agent will create/edit]
+Do NOT read: [explicitly exclude irrelevant files]
+Knowledge: [paste only the relevant section of GEMINI.md]
+```
+
+Rule: If an agent doesn't need `node_modules`, `package-lock.json`, `.next/`, or `dist/` — add them to a `.antigravityignore` before the agent runs.
+
+---
+
+## Phase 4 — PARALLEL EXECUTION
+
+Spawn agents in dependency order:
+
+```
+Round 1 (no dependencies): Run agents in parallel
+Round 2 (depends on Round 1): Wait for all Round 1 outputs, then run
+Round 3 (final): Integrate + verify
+```
+
+Between rounds, the orchestrator MUST:
+1. Collect each agent's output artifact
+2. Run a 3-point spot check:
+   - Did the agent stay within its assigned scope?
+   - Are there any import/export conflicts with other agents' outputs?
+   - Did any agent produce a placeholder ("TODO", "implement later")?
+3. If any check fails → re-run that agent with corrected context. Do NOT continue.
+
+---
+
+## Phase 5 — ERROR RECOVERY
+
+If a subagent fails or produces broken output:
+
+```
+RECOVERY PROTOCOL
+─────────────────────────────────────────
+1. Do NOT re-run the full mission.
+2. Identify the exact failure point.
+3. Spawn a single repair agent with:
+   - Only the broken file(s) as scope
+   - The error message as context
+   - Model: Gemini Flash (cheapest for repairs)
+4. Validate the repair before continuing.
+─────────────────────────────────────────
+```
+
+Never cascade a broken output to the next agent. Always fix before moving forward.
+
+---
+
+## Phase 6 — INTEGRATION CHECK
+
+After all agents complete, run a final integration sweep:
+
+- [ ] All imports resolve correctly
+- [ ] No duplicate function/variable names across files
+- [ ] No hardcoded values that should be env variables
+- [ ] No `console.log` left in production files
+- [ ] Types are consistent across components (TypeScript)
+- [ ] Build would succeed (`npm run build` mentally verified)
+
+If any check fails, spawn one final repair agent scoped to the exact issue.
+
+---
+
+## Quota Monitoring Rules
+
+Track estimated usage throughout the mission:
+
+| Event | Quota Impact |
+|-------|-------------|
+| Agent spawned | LOW (setup) |
+| File indexed (each) | LOW |
+| Tool call (file read/write) | MEDIUM |
+| Terminal command | MEDIUM |
+| Browser subagent activated | HIGH |
+| Thinking mode enabled | VERY HIGH |
+
+If estimated usage crosses 60% of sprint quota mid-mission:
+- Pause and report: "Quota checkpoint: ~60% of sprint used. Continue or defer remaining agents?"
+- Switch remaining agents to Gemini Flash
+- Disable browser subagent if not yet started
+
+---
+
+## Communication Rules
+
+- Announce which agent is running at all times
+- Show a compact progress bar between rounds:
+  ```
+  Mission Progress: ████████░░ 4/5 agents complete
+  Quota Status: ▓▓▓▓░░░░░░ ~40% sprint used
+  ```
+- Never go silent for more than one agent turn
+- If blocked, say why explicitly — never just stop
+
+---
+
+## Examples
+
+See `examples/` folder:
+- `nextjs-feature.md` — Building a full Next.js feature with 3 parallel agents
+- `api-plus-frontend.md` — Backend API agent + Frontend UI agent running in parallel
+- `debug-mission.md` — Repair mission for a broken build using minimal quota
+
+## Limitations
+
+- This skill coordinates agent planning; it does not provide a runtime scheduler or enforce quota limits automatically.
+- Parallel agents still need explicit scoping, review, and integration by the parent agent.
+- Do not use it when a single focused edit or direct answer would be faster and clearer.

package/bundled-skills/subagent-orchestrator/examples/api-plus-frontend.md

@@ -0,0 +1,76 @@
+# Example: Backend API Agent + Frontend UI Agent in Parallel
+
+## Scenario
+User prompt: "Build a proposal generator — form on frontend, AI call on backend, result displayed on screen."
+
+## This is the ProposalKit core feature pattern.
+
+---
+
+## Mission Brief
+
+```
+MISSION BRIEF
+─────────────────────────────────────────
+Goal: Working proposal generator with form input, API processing, and result display.
+Total Agents: 2 + 1 integration
+Quota Strategy: MIXED — Flash for backend, Sonnet for frontend UI
+Expected Token Cost: MEDIUM
+
+AGENTS:
+[1] ID: agent-001
+    Role: Builder — Backend API
+    Scope: /app/api/generate/route.ts
+    Model: Gemini Flash
+    Input: NVIDIA API key env name, prompt template from resources/prompt-template.md
+    Output: POST route that accepts {clientName, projectType, budget}, returns {proposal: string}
+    Depends on: none
+
+[2] ID: agent-002
+    Role: Builder — Frontend Form + Display
+    Scope: /components/ProposalForm.tsx, /components/ProposalResult.tsx, /app/page.tsx
+    Model: Claude Sonnet (UI needs quality)
+    Input: API contract from agent-001 spec (input/output shape only — not the code)
+    Output: Form component, result display, wired to /api/generate
+    Depends on: none (uses spec, not agent-001 output directly)
+
+[3] ID: agent-003
+    Role: Integrator
+    Scope: review only — no new files
+    Model: Gemini Flash
+    Input: Outputs from agent-001 and agent-002
+    Output: List of any mismatches between API contract and frontend calls
+    Depends on: agent-001, agent-002
+─────────────────────────────────────────
+```
+
+---
+
+## Key Pattern: Spec-First Parallelism
+
+agents 001 and 002 run at the same time because:
+- agent-002 receives the **API contract** (input/output shape) not the actual code
+- The contract is defined before either agent runs
+- Both agents work from the same agreed spec
+
+This avoids agent-002 waiting for agent-001 to finish, saving significant time and quota.
+
+**Always define the API contract before spawning parallel agents:**
+```typescript
+// Agree on this before agents run:
+// POST /api/generate
+// Input:  { clientName: string, projectType: string, budget: number }
+// Output: { proposal: string, error?: string }
+```
+
+---
+
+## Quota Log
+
+| Event | Impact |
+|-------|--------|
+| agent-001 (Flash, 1 file) | LOW |
+| agent-002 (Sonnet, 3 files) | MEDIUM |
+| agent-003 (Flash, review only) | LOW |
+| 0 browser agents | NONE |
+| **Total estimated** | **~30% sprint** |

package/bundled-skills/subagent-orchestrator/examples/debug-mission.md

@@ -0,0 +1,72 @@
+# Example: Repair Mission for a Broken Build
+
+## Scenario
+User: "My Vercel deploy is failing. Build error: Cannot find module '@/components/ProposalResult'"
+
+This is a targeted repair — minimum agents, minimum quota.
+
+---
+
+## Mission Brief
+
+```
+MISSION BRIEF
+─────────────────────────────────────────
+Goal: Fix broken import causing Vercel build failure. Do not touch anything else.
+Total Agents: 1
+Quota Strategy: FLASH only
+Expected Token Cost: LOW
+
+AGENTS:
+[1] ID: repair-001
+    Role: Repair Agent
+    Scope: ONLY the file containing the broken import + the missing file (if it needs creating)
+    Model: Gemini Flash
+    Input: Exact error message, file path of the import
+    Output: Fixed import OR created missing file — nothing else
+    Depends on: none
+─────────────────────────────────────────
+```
+
+---
+
+## Repair Protocol
+
+```
+Step 1: Read the exact error — don't assume context
+  Error: "Cannot find module '@/components/ProposalResult'"
+
+Step 2: Check if the file exists
+  → If exists: fix the import path (casing issue, wrong alias, etc.)
+  → If missing: create the minimum viable file (even if empty with correct export)
+
+Step 3: Verify the fix compiles mentally
+  → Check all other files that import the same module
+  → Confirm tsconfig.json paths alias is correct
+
+Step 4: Report what was changed and why — one sentence each
+```
+
+---
+
+## What NOT to do in a repair mission
+
+- Do NOT re-read the entire codebase to "understand context"
+- Do NOT refactor adjacent files while you're in there
+- Do NOT switch to a more powerful model "just to be safe"
+- Do NOT open a browser agent to check Vercel dashboard
+- Do NOT spawn additional agents for a single broken import
+
+---
+
+## Quota Log
+
+| Event | Impact |
+|-------|--------|
+| 1 Flash agent | LOW |
+| 2–3 files read | LOW |
+| 1–2 files written | LOW |
+| **Total estimated** | **< 5% sprint** |
+
+> Repair missions should almost never exceed 10% sprint quota.
+> If a repair is growing complex, stop — decompose it as a new full mission instead.

package/bundled-skills/subagent-orchestrator/examples/nextjs-feature.md

@@ -0,0 +1,87 @@
+# Example: Building a Full Next.js Feature with 3 Parallel Agents
+
+## Scenario
+User prompt: "Add a user authentication flow — login page, signup page, and a protected dashboard route."
+
+---
+
+## Mission Brief (what orchestrator produces)
+
+```
+MISSION BRIEF
+─────────────────────────────────────────
+Goal: Auth flow with login, signup, and protected dashboard — all wired and working.
+Total Agents: 3
+Quota Strategy: FLASH for all, Sonnet for integration review only
+Expected Token Cost: MEDIUM
+
+AGENTS:
+[1] ID: agent-001
+    Role: Builder — Auth UI
+    Scope: /app/login/page.tsx, /app/signup/page.tsx
+    Model: Gemini Flash
+    Input: Design system from GEMINI.md, form fields spec
+    Output: Two complete page components with Tailwind styling
+    Depends on: none
+
+[2] ID: agent-002
+    Role: Builder — API Routes
+    Scope: /app/api/auth/login/route.ts, /app/api/auth/signup/route.ts
+    Model: Gemini Flash
+    Input: Auth logic spec, env variable names from .env.example
+    Output: Two API route handlers with error responses
+    Depends on: none
+
+[3] ID: agent-003
+    Role: Builder — Protected Route
+    Scope: /app/dashboard/page.tsx, /middleware.ts
+    Model: Gemini Flash
+    Input: Output from agent-001 (session shape), output from agent-002 (token format)
+    Output: Dashboard page + middleware redirect logic
+    Depends on: agent-001, agent-002
+─────────────────────────────────────────
+```
+
+---
+
+## Execution Flow
+
+```
+Round 1 (parallel):
+  agent-001 → builds login + signup UI
+  agent-002 → builds API routes
+
+  [Spot check after Round 1]
+  ✓ agent-001 stayed in /app/login and /app/signup only
+  ✓ agent-002 used correct env variable names
+  ✓ No TODOs left in either output
+
+Round 2 (sequential, depends on Round 1):
+  agent-003 → builds dashboard + middleware
+              receives session shape from agent-001
+              receives token format from agent-002
+
+  [Spot check after Round 2]
+  ✓ Middleware correctly references session cookie name
+  ✓ Dashboard imports resolve to existing components
+  ✓ No hardcoded redirect URLs
+
+Integration Check:
+  ✓ All imports resolve
+  ✓ No duplicate type definitions
+  ✓ Build mentally verified
+```
+
+---
+
+## Quota Log
+
+| Event | Impact |
+|-------|--------|
+| 3 agents spawned | LOW |
+| ~12 files indexed total | LOW |
+| ~18 tool calls across all agents | MEDIUM |
+| 0 browser agents used | NONE |
+| **Total estimated** | **~25% sprint** |
+
+> Tip: This mission costs ~25% sprint quota. You can run 3–4 missions like this per day on the free tier.

package/bundled-skills/subagent-orchestrator/resources/mission-brief-template.md

@@ -0,0 +1,43 @@
+# Mission Brief Template
+
+Copy this before every multi-agent task. Fill it in, share with the orchestrator, wait for confirmation.
+
+```
+MISSION BRIEF
+─────────────────────────────────────────
+Goal: 
+Total Agents: 
+Quota Strategy: [ FLASH-ONLY | MIXED | SONNET-LEAD ]
+Expected Token Cost: [ LOW | MEDIUM | HIGH ]
+
+AGENTS:
+[1] ID: agent-001
+    Role: 
+    Scope: 
+    Model: [ Gemini Flash | Claude Sonnet ]
+    Input: 
+    Output: 
+    Depends on: [ none | agent-XXX ]
+
+[2] ID: agent-002
+    Role: 
+    Scope: 
+    Model: 
+    Input: 
+    Output: 
+    Depends on: 
+
+─────────────────────────────────────────
+EXCLUSIONS (files agents must not touch):
+- node_modules/
+- .next/
+- dist/
+- package-lock.json
+- [add project-specific exclusions]
+
+API CONTRACT (if agents share data):
+  Endpoint: 
+  Input shape:  { }
+  Output shape: { }
+─────────────────────────────────────────
+```

package/bundled-skills/subagent-orchestrator/resources/quota-reference.md

@@ -0,0 +1,73 @@
+# Quota Reference Card
+
+Quick reference for estimating and managing quota in every mission.
+
+---
+
+## Sprint vs Weekly Limits
+
+| Limit | Size | Resets |
+|-------|------|--------|
+| Sprint limit | 250 units | Every 5 hours |
+| Weekly baseline | 2,800 units | Once per week (hard cap) |
+
+The 5-hour refresh only refills the sprint — NOT the weekly baseline.
+
+---
+
+## Estimated Cost Per Event
+
+| Action | Approx Units |
+|--------|-------------|
+| Spawning 1 agent | 1–2 |
+| Reading 1 file (small) | 1 |
+| Reading 1 file (large, e.g. 500+ lines) | 3–5 |
+| Writing/editing 1 file | 2–4 |
+| Terminal command | 2–3 |
+| Browser subagent session | 15–30 |
+| Enabling thinking/reasoning mode | 10–20 extra |
+| Re-running a failed agent | same as original |
+
+---
+
+## Model Multipliers (relative cost)
+
+| Model | Cost Multiplier |
+|-------|----------------|
+| Gemini Flash | 1x (baseline) |
+| Claude Sonnet | ~4x |
+| Claude Opus | ~8x (avoid in subagents) |
+
+---
+
+## Mission Size Guide
+
+| Mission Size | Agents | Est. Sprint % | Safe? |
+|-------------|--------|---------------|-------|
+| Tiny (1 file fix) | 1 Flash | < 5% | Always |
+| Small (1 feature) | 2–3 Flash | 15–25% | Yes |
+| Medium (full flow) | 3–4 Mixed | 30–45% | Yes |
+| Large (whole module) | 5+ Mixed | 50–70% | Careful |
+| XL (full app build) | 6+ | 70–100% | Split across days |
+
+---
+
+## Quota Saving Moves
+
+1. **`.antigravityignore`** → biggest single saving. Do this first always.
+2. **New conversation per mission** → prevents history bloat eating tokens.
+3. **Spec-first parallelism** → agents run at same time instead of waiting in sequence.
+4. **Flash for repairs** → never use Sonnet to fix a small bug.
+5. **Skip browser agent** → unless the task literally requires a live webpage.
+6. **Sideload AI Studio key** → free Gemini quota when weekly limit hits.
+
+---
+
+## Sideload Free Quota (when you hit the wall)
+
+1. Go to https://aistudio.google.com
+2. Create a free API key (Gemini Flash, free tier)
+3. In Antigravity → Settings → Models → Paste API key
+4. Now running on your own separate quota pool
+
+Works great for continuation after weekly baseline runs out.