@thanhthi2895/luna-ai 2.16.2

package/agentic/antigravity/.agents/skills/sequential-thinking/references/core-patterns.md

@@ -0,0 +1,95 @@
+# Core Sequential Thinking Patterns
+
+Essential revision and branching patterns.
+
+## Revision Patterns
+
+### Assumption Challenge
+Early assumption proves invalid with new data.
+```
+Thought 1/5: Assume X is bottleneck
+Thought 4/5 [REVISION of Thought 1]: X adequate; Y is actual bottleneck
+```
+
+### Scope Expansion
+Problem larger than initially understood.
+```
+Thought 1/4: Fix bug
+Thought 4/5 [REVISION of scope]: Architectural redesign needed, not patch
+```
+
+### Approach Shift
+Initial strategy inadequate for requirements.
+```
+Thought 2/6: Optimize query
+Thought 5/6 [REVISION of Thought 2]: Optimization + cache layer required
+```
+
+### Understanding Deepening
+Later insight fundamentally changes interpretation.
+```
+Thought 1/5: Feature broken
+Thought 4/5 [REVISION of Thought 1]: Not bug—UX confusion issue
+```
+
+## Branching Patterns
+
+### Trade-off Evaluation
+Compare approaches with different trade-offs.
+```
+Thought 3/7: Choose between X and Y
+Thought 4/7 [BRANCH A]: X—simpler, less scalable
+Thought 4/7 [BRANCH B]: Y—complex, scales better
+Thought 5/7: Choose Y for long-term needs
+```
+
+### Risk Mitigation
+Prepare backup for high-risk primary approach.
+```
+Thought 2/6: Primary: API integration
+Thought 3/6 [BRANCH A]: API details
+Thought 3/6 [BRANCH B]: Fallback: webhook
+Thought 4/6: Implement A with B contingency
+```
+
+### Parallel Exploration
+Investigate independent concerns separately.
+```
+Thought 3/8: Two unknowns—DB schema & API design
+Thought 4/8 [BRANCH DB]: DB options
+Thought 4/8 [BRANCH API]: API patterns
+Thought 5/8: Integrate findings
+```
+
+### Hypothesis Testing
+Test multiple explanations systematically.
+```
+Thought 2/6: Could be A, B, or C
+Thought 3/6 [BRANCH A]: Test A—not cause
+Thought 3/6 [BRANCH B]: Test B—confirmed
+Thought 4/6: Root cause via Branch B
+```
+
+## Adjustment Guidelines
+
+**Expand when**: Complexity discovered, multiple aspects identified, verification needed, alternatives require exploration.
+
+**Contract when**: Key insight solves earlier, problem simpler, steps merge naturally.
+
+**Example**:
+```
+Thought 1/5: Initial
+Thought 3/7: Complexity (5→7)
+Thought 5/8: Another aspect (7→8)
+Thought 8/8 [FINAL]: Complete
+```
+
+## Anti-Patterns
+
+**Premature Completion**: Rushing without verification → Add verification thoughts.
+
+**Revision Cascade**: Repeated revisions without understanding why → Identify root cause.
+
+**Branching Explosion**: Too many branches → Limit to 2-3, converge before more.
+
+**Context Loss**: Ignoring earlier insights → Reference previous thoughts explicitly.

package/agentic/antigravity/.agents/skills/team/SKILL.md

@@ -0,0 +1,282 @@
+---
+name: lu:team
+author: luna
+description: "Orchestrate Agent Teams for parallel multi-session collaboration. Use for research, implementation, review, and debug workflows requiring independent teammates."
+version: 2.1.0
+argument-hint: "<template> <context> [--devs|--researchers|--reviewers N] [--delegate]"
+---
+
+# Agent Teams - Luna Orchestration Engine
+
+Coordinate multiple independent Claude Code sessions. Each teammate has own context window, loads project context (CLAUDE.md, skills, agents), communicates via shared task list and messaging.
+
+**Requires:** Agent Teams enabled. Set `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.json env if using Claude Code < 2.1.33. May be GA in 2.1.33+.
+
+## Usage
+
+```
+/team <template> <context> [flags]
+```
+
+**Templates:** `research`, `cook`, `review`, `debugger`
+
+**Flags:**
+- `--devs N` | `--researchers N` | `--reviewers N` | `--debuggers N` — team size
+- `--plan-approval` / `--no-plan-approval` — plan gate (default: on for cook)
+- `--delegate` — lead only coordinates, never touches code
+
+## Execution Protocol
+
+**Pre-flight (MANDATORY — merged into step 2 of every template):**
+1. Step 2 of every template calls `TeamCreate(team_name: "...", ...)`. Do NOT check whether the tool exists first — just call it.
+2. If the call SUCCEEDS: continue with the template.
+3. If the call returns an ERROR or is unrecognized: **STOP. Tell user:** "Agent Teams requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in settings.json. Team mode is not available."
+4. Do NOT fall back to subagents. `/team` MUST use Agent Teams or abort.
+5. All teammate spawns MUST include `team_name` parameter — never spawn Task without it.
+
+When activated, IMMEDIATELY execute the matching template sequence below.
+Do NOT ask for confirmation. Do NOT explain what you're about to do.
+Execute the tool calls in order. Report progress after each major step.
+
+---
+
+## Luna Context Block
+
+Every teammate spawn prompt MUST include this context at the end:
+
+```
+Luna Context:
+- Work dir: {LUNA_PROJECT_ROOT or CWD}
+- Reports: {LUNA_REPORTS_PATH or "plans/reports/"}
+- Plans: {LUNA_PLANS_PATH or "plans/"}
+- Branch: {LUNA_GIT_BRANCH or current branch}
+- Naming: {LUNA_NAME_PATTERN or "YYMMDD-HHMM"}
+- Active plan: {LUNA_ACTIVE_PLAN or "none"}
+- Commits: conventional (feat:, fix:, docs:, refactor:, test:, chore:)
+- Refer to teammates by NAME, not agent ID
+```
+
+---
+
+## ON `/team research <topic>` [--researchers N]:
+
+*Wraps /research skill — scope, gather, analyze, report.*
+
+IMMEDIATELY execute in order:
+
+1. **Derive N angles** from `<topic>` (default N=3):
+   - Angle 1: Architecture, patterns, proven approaches
+   - Angle 2: Alternatives, competing solutions, trade-offs
+   - Angle 3: Risks, edge cases, failure modes, security
+   - (If N>3, derive additional angles from topic context)
+
+2. **CALL** `TeamCreate(team_name: "<topic-slug>")`
+
+3. **CALL** `TaskCreate` x N — one per angle:
+   - Subject: `Research: <angle-title>`
+   - Description: `Investigate <angle> for topic: <topic>. Save report to: {LUNA_REPORTS_PATH}/researcher-{N}-{LUNA_NAME_PATTERN}-{topic-slug}.md. Format: Executive summary, key findings, evidence, recommendations. Mark task completed when done. Send findings summary to lead.`
+
+4. **CALL** `Task` x N to spawn researcher teammates:
+   - `subagent_type: "researcher"`, `team_name: "<topic-slug>"`, `model: "haiku"`
+   - `name: "researcher-{N}"`
+   - Prompt: task description + Luna Context Block
+
+5. **MONITOR** via TaskCompleted hook events + TaskList fallback:
+   - TaskCompleted events auto-notify when researchers finish
+   - Fallback: Check TaskList if no event received in 60s
+   - If stuck >5 min, message teammate directly
+
+6. **READ** all researcher reports from `{LUNA_REPORTS_PATH}/`
+
+7. **SYNTHESIZE** into: `{LUNA_REPORTS_PATH}/research-summary-{LUNA_NAME_PATTERN}-{topic-slug}.md`
+   Format: exec summary, key findings, comparative analysis, recommendations, unresolved questions.
+
+8. **SHUTDOWN**: `SendMessage(type: "shutdown_request")` to each teammate
+
+9. **CLEANUP**: `TeamDelete` (no parameters — just call it)
+
+10. **REPORT**: Tell user `Research complete. Summary: {path}. N reports generated.`
+
+---
+
+## ON `/team cook <plan-path-or-description>` [--devs N]:
+
+*Wraps /cook skill — plan, code, test, review, finalize.*
+
+IMMEDIATELY execute in order:
+
+1. **READ** plan (if path provided) OR create via planner teammate:
+   - If description only: spawn `Task(subagent_type: "planner")` to create plan first
+   - Parse plan into N independent task groups with file ownership boundaries
+
+2. **CALL** `TeamCreate(team_name: "<feature-slug>")`
+
+3. **CALL** `TaskCreate` x (N + 1) — N dev tasks + 1 tester task:
+   - Dev tasks: include `File ownership: <glob patterns>` — NO overlap between devs
+   - Tester task: `addBlockedBy` all dev task IDs
+   - Each task description includes: implementation scope, file ownership, acceptance criteria
+
+4. **CALL** `Task` x N to spawn developer teammates:
+   - `subagent_type: "fullstack-developer"`, `mode: "plan"`
+   - `model: "sonnet"`, `name: "dev-{N}"`
+   - Prompt: task description + Luna Context Block
+   - REVIEW and APPROVE each developer's plan via `plan_approval_response`
+
+5. **MONITOR** dev completion via TaskCompleted events:
+   - TaskCompleted hook notifies when each dev task finishes
+   - When all N dev tasks show completed, spawn tester immediately
+   - TeammateIdle events confirm devs are available for shutdown
+   - Fallback: Check TaskList if no events received in 60s
+   - `Task(subagent_type: "tester", model: "haiku", name: "tester")`
+   - Tester runs full test suite, reports pass/fail
+
+6. **FINALIZE** (MANDATORY — mirrors /cook finalize):
+   - Spawn `Task(subagent_type: "project-manager", name: "project-manager")` — sync plan statuses
+   - Spawn `Task(subagent_type: "docs-manager", name: "docs-manager")` — update `./docs` if impacted
+   - Spawn `Task(subagent_type: "git-manager", name: "git-manager")` — commit + PR
+
+7. **DOCS SYNC EVAL** (MANDATORY for cook — from /cook finalize):
+   ```
+   Docs impact: [none|minor|major]
+   Action: [no update needed — <reason>] | [updated <page>] | [needs separate PR]
+   ```
+
+8. **SHUTDOWN** all teammates via `SendMessage(type: "shutdown_request")`
+9. **CLEANUP**: `TeamDelete` (no parameters — just call it)
+
+10. **REPORT**: Tell user what was cooked, test results, docs impact.
+
+---
+
+## ON `/team review <scope>` [--reviewers N]:
+
+*Wraps /review skill — scout, review, synthesize with evidence gates.*
+
+IMMEDIATELY execute in order:
+
+1. **DERIVE** N review focuses from `<scope>` (default N=3):
+   - Focus 1: Security — vulnerabilities, auth, input validation, OWASP
+   - Focus 2: Performance — bottlenecks, memory, complexity, scaling
+   - Focus 3: Test coverage — gaps, edge cases, error paths
+   - (If N>3, derive from scope: architecture, DX, accessibility, etc.)
+
+2. **CALL** `TeamCreate(team_name: "review-<scope-slug>")`
+
+3. **CALL** `TaskCreate` x N — one per focus:
+   - Subject: `Review: <focus-title>`
+   - Description: `Review <scope> for <focus>. Output severity-rated findings only. Format: [CRITICAL|IMPORTANT|MODERATE] <finding> — <evidence> — <recommendation>. No "seems" or "probably" — concrete evidence only. Save to: {LUNA_REPORTS_PATH}/reviewer-{N}-{LUNA_NAME_PATTERN}-{scope-slug}.md. Mark task completed when done.`
+
+4. **CALL** `Task` x N to spawn reviewers:
+   - `subagent_type: "code-reviewer"`, `model: "haiku"`, `name: "reviewer-{N}"`
+   - Prompt: task description + Luna Context Block
+
+5. **MONITOR** via TaskCompleted hook events + TaskList fallback:
+   - TaskCompleted events auto-notify when reviewers finish
+   - Fallback: Check TaskList if no event received in 60s
+
+6. **SYNTHESIZE** into: `{LUNA_REPORTS_PATH}/review-{scope-slug}.md`
+   - Deduplicate findings across reviewers
+   - Prioritize by severity: CRITICAL > IMPORTANT > MODERATE
+   - Create action items list with owners
+
+7. **SHUTDOWN** all teammates via `SendMessage(type: "shutdown_request")`
+8. **CLEANUP**: `TeamDelete` (no parameters — just call it)
+
+9. **REPORT**: Tell user `Review complete. {X} findings ({Y} critical). Report: {path}.`
+
+---
+
+## ON `/team debug <issue>` [--debuggers N]:
+
+*Wraps /fix skill — root-cause-first, adversarial hypotheses, disprove to converge.*
+
+IMMEDIATELY execute in order:
+
+1. **GENERATE** N competing hypotheses from `<issue>` (default N=3):
+   - Each hypothesis must be independently testable
+   - Each must predict different observable symptoms
+   - Frame as: "If <cause>, then we should see <evidence>"
+
+2. **CALL** `TeamCreate(team_name: "debug-<issue-slug>")`
+
+3. **CALL** `TaskCreate` x N — one per hypothesis:
+   - Subject: `Debug: Test hypothesis — <theory>`
+   - Description: `Investigate hypothesis: <theory>. For issue: <issue>. ADVERSARIAL: actively try to disprove other theories. Message other debuggers to challenge findings. Report evidence FOR and AGAINST your theory. Save findings to: {LUNA_REPORTS_PATH}/debugger-{N}-{LUNA_NAME_PATTERN}-{issue-slug}.md. Mark task completed when done.`
+
+4. **CALL** `Task` x N to spawn debugger teammates:
+   - `subagent_type: "debugger"`, `model: "sonnet"`, `name: "debugger-{N}"`
+   - Prompt: task description + Luna Context Block
+
+5. **MONITOR** via TaskCompleted events. Debuggers should message each other — let them converge.
+   - TaskCompleted events notify as each hypothesis is tested
+   - TeammateIdle events indicate debugger awaiting peer input
+   - Fallback: Check TaskList if no events in 60s
+
+6. **READ** all debugger reports. Identify surviving theory as root cause.
+
+7. **WRITE** root cause report: `{LUNA_REPORTS_PATH}/debug-{issue-slug}.md`
+   Format: Root cause, evidence chain, disproven hypotheses, recommended fix.
+
+8. **SHUTDOWN** all teammates via `SendMessage(type: "shutdown_request")`
+9. **CLEANUP**: `TeamDelete` (no parameters — just call it)
+
+10. **REPORT**: Tell user `Debug complete. Root cause: <summary>. Report: {path}.`
+
+---
+
+## Agent Memory
+
+Agents with `memory: project` retain learnings across team sessions. Memory persists in `.claude/agent-memory/<name>/` (gitignored). Useful for:
+- Code reviewer remembering project conventions
+- Debugger recalling past failure patterns
+- Tester tracking flaky tests and coverage gaps
+
+---
+
+## When to Use Agent Teams vs Subagents
+
+| Scenario | Subagents (Task tool) | Agent Teams |
+|----------|----------------------|-------------|
+| Focused task (test, lint, single review) | **Yes** | Overkill |
+| Sequential chain (plan → code → test) | **Yes** | No |
+| 3+ independent parallel workstreams | Maybe | **Yes** |
+| Competing debug hypotheses | No | **Yes** |
+| Cross-layer work (FE + BE + tests) | Maybe | **Yes** |
+| Workers need to discuss/challenge findings | No | **Yes** |
+| Token budget is tight | **Yes** | No (high cost) |
+
+## Token Budget
+
+| Template | Estimated Tokens | Model Strategy |
+|----------|-----------------|----------------|
+| Research (3) | ~150K-300K | haiku for all |
+| Cook (4) | ~400K-800K | sonnet for devs, haiku for tester |
+| Review (3) | ~100K-200K | haiku for all |
+| Debug (3) | ~200K-400K | sonnet for all |
+
+## Error Recovery
+
+1. **Check status**: `Shift+Up/Down` (in-process) or click pane (split)
+2. **Redirect**: Send direct message with corrective instructions
+3. **Replace**: Shut down failed teammate, spawn replacement for same task
+4. **Reassign**: `TaskUpdate` stuck task to unblock dependents
+
+## Abort Team
+
+```
+Shut down all teammates. Then call TeamDelete (no parameters).
+```
+
+If unresponsive: close terminal or kill session. Clean orphaned configs at `~/.gemini/antigravity/teams/` manually.
+
+## Display Modes
+
+- **auto** (default): split panes if in tmux, otherwise in-process
+- **in-process**: all in one terminal. `Shift+Up/Down` navigate. `Ctrl+T` task list.
+- **tmux/split**: each teammate own pane. Requires tmux or iTerm2.
+
+## Rules Reference
+
+See `~/.gemini/antigravity/rules/team-coordination-rules.md` for teammate behavior rules.
+
+> v2.1.0: Event-driven orchestration via TaskCompleted/TeammateIdle hooks. Agent memory + Task restrictions.

package/agentic/antigravity/.agents/skills/team/references/opencode-runner.md

@@ -0,0 +1,115 @@
+# OpenCode Runner — Subprocess Pattern Reference
+
+How to use `spawn-team.sh` to run parallel `opencode` agents from within `lu:team`.
+
+## Usage Pattern
+
+```bash
+bash agentic/antigravity/.agents/skills/team/scripts/spawn-team.sh \
+  <output-dir> \
+  <timeout-seconds> \
+  <prompt-file-1> [<prompt-file-2> ...]
+```
+
+**Arguments:**
+- `output-dir` — directory where agent reports are written (e.g., `plans/reports/team-{timestamp}/`)
+- `timeout-seconds` — max seconds per agent before watchdog kills it (default: 300)
+- `prompt-file-N` — text files containing each agent's full prompt
+
+## Step-by-Step from lu:team Skill
+
+### Step 1 — Write prompt files
+
+Use `write_to_file` for each agent role:
+
+```
+write_to_file /tmp/luna-team-researcher-1.txt  ← researcher prompt
+write_to_file /tmp/luna-team-researcher-2.txt  ← researcher prompt
+```
+
+Prompt files must be plain text. Use templates from `references/prompt-researcher.md`, `references/prompt-reviewer.md`, `references/prompt-debugger.md`.
+
+### Step 2 — Spawn agents
+
+Use `run_command`:
+
+```bash
+bash agentic/antigravity/.agents/skills/team/scripts/spawn-team.sh \
+  plans/reports/team-$(date +%y%m%d-%H%M) \
+  300 \
+  /tmp/luna-team-researcher-1.txt \
+  /tmp/luna-team-researcher-2.txt
+```
+
+The script will:
+- Spawn all agents with `opencode run` in parallel (`&`)
+- Stagger spawns by 2s (rate limit protection)
+- Start watchdog subprocess per agent (macOS-compatible timeout)
+- Wait for all agents, report ✓/✗ per agent
+- Cap each output at 500 lines
+- Print summary table with file sizes
+
+### Step 3 — Read results
+
+After `run_command` exits (exit 0 = all OK, exit 1 = some failed):
+
+```
+view_file plans/reports/team-{timestamp}/agent-1.md
+view_file plans/reports/team-{timestamp}/agent-2.md
+...
+```
+
+Read in parallel — issue all `view_file` calls in one response block.
+
+### Step 4 — Synthesize
+
+Write synthesis to `plans/reports/` using `write_to_file`:
+
+```
+plans/reports/research-summary-{timestamp}-{topic}.md
+plans/reports/review-{scope}.md
+plans/reports/debug-{issue}.md
+```
+
+### Step 5 — Cleanup
+
+```bash
+run_command: rm /tmp/luna-team-*.txt
+```
+
+## Output Format Notes
+
+Each agent output starts with OpenCode header (strip if needed):
+```
+> build · gpt-5.3-codex
+
+[actual content]
+```
+
+Strip with: `tail -n +3` or `grep -v "^> build"`
+
+## Timeout Values by Template
+
+| Template | Recommended Timeout |
+|----------|-------------------|
+| research | 300s (5 min) |
+| review | 240s (4 min) |
+| debug | 360s (6 min) |
+| cook | N/A — sequential |
+
+## Model Recommendations
+
+| Role | Recommended | Flag |
+|------|-------------|------|
+| researcher | default (gpt-5.3-codex) | (none) |
+| reviewer | default | (none) |
+| debugger | default | (none) |
+| Override | specific model | `--model provider/model` |
+
+Note: `--model` flag must be added to `opencode run` call inside `spawn-team.sh` if needed.
+
+## Error Handling
+
+- **Exit 0**: All agents succeeded → proceed to synthesis
+- **Exit 1**: One or more failed → check individual `agent-N.md` for error messages → decide whether to retry or proceed with partial results
+- **Exit 2**: opencode not in PATH → tell user to install opencode

package/agentic/antigravity/.agents/skills/team/references/prompt-debugger.md

@@ -0,0 +1,74 @@
+# Debugger Prompt Template
+
+Use this template for debugger agents in `/team debug`.
+
+Fill in `{variables}` before writing to `/tmp/luna-team-debugger-N.txt`.
+
+---
+
+```
+You are a debugger testing a specific hypothesis.
+
+ISSUE: {issue_description}
+YOUR HYPOTHESIS: {hypothesis}
+PROJECT DIR: {project_dir}
+
+Your job: PROVE or DISPROVE your hypothesis using concrete evidence.
+Be adversarial to yourself — actively look for evidence that contradicts your hypothesis.
+
+Steps:
+1. Look for evidence SUPPORTING your hypothesis (read files, check patterns)
+2. Actively look for evidence DISPROVING your hypothesis
+3. Make a final verdict
+
+Write a markdown report with EXACTLY these sections:
+
+# Hypothesis
+{restate your hypothesis in one sentence}
+
+# Supporting Evidence
+(concrete: file:line, command output, or pattern found)
+- Evidence 1
+- Evidence 2
+
+# Contradicting Evidence
+(what DISPROVES your hypothesis — be honest)
+- Evidence 1 (or "None found")
+
+# Verdict
+CONFIRMED / DISPROVED / INCONCLUSIVE
+
+# If CONFIRMED — Recommended Fix
+(specific: which file, what to change, why)
+
+# If DISPROVED — Alternative Hypothesis
+(what seems more likely based on what you found)
+
+RULES:
+- No "seems" or "probably" — only verifiable evidence
+- Output ONLY the markdown report
+- Max 300 lines
+- Project files are in: {project_dir}
+```
+
+---
+
+## Variable Reference
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{issue_description}` | The bug/problem being debugged | "lu:team references TeamCreate which doesn't exist" |
+| `{hypothesis}` | This debugger's theory | "The SKILL.md was never updated when migrating from Claude Code" |
+| `{project_dir}` | Absolute path | "/Users/user/my-project" |
+
+## Hypothesis Generation Guide
+
+For N=3 debuggers, generate hypotheses that:
+- Are **mutually exclusive** (different root causes)
+- Are **independently testable** (different evidence to look for)
+- Cover **different layers** (e.g., config vs code vs environment)
+
+**Example for "API calls failing":**
+- Hypothesis 1: Authentication token is expired or invalid
+- Hypothesis 2: API endpoint URL has changed
+- Hypothesis 3: Network/firewall blocking outbound requests

package/agentic/antigravity/.agents/skills/team/references/prompt-researcher.md

@@ -0,0 +1,62 @@
+# Researcher Prompt Template
+
+Use this template to generate prompt files for researcher agents in `/team research`.
+
+Fill in `{variables}` before writing to `/tmp/luna-team-researcher-N.txt`.
+
+---
+
+```
+You are a technical researcher. Your task:
+
+TOPIC: {topic}
+RESEARCH ANGLE: {angle_description}
+PROJECT DIR: {project_dir}
+
+Research this angle thoroughly using available tools (read files, search web, analyze code).
+
+Write a markdown report with EXACTLY these sections:
+
+# Executive Summary
+(2-3 sentences: what you found and why it matters)
+
+# Key Findings
+(bullet list — concrete facts only, no "seems" or "probably")
+- Finding 1
+- Finding 2
+- ...
+
+# Evidence
+(code samples, file references as file:line, links, or codebase patterns found)
+
+# Recommendations
+(actionable, specific — what to do based on findings)
+
+# Open Questions
+(what remains unclear or needs further investigation)
+
+RULES:
+- Output ONLY the markdown report — no preamble, no "Here is my report:"
+- Be concrete — every claim needs evidence
+- Max 400 lines total
+- If reading project files, they are in: {project_dir}
+```
+
+---
+
+## Variable Reference
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{topic}` | Full topic from user | "parallel AI agent orchestration" |
+| `{angle_description}` | This researcher's specific angle | "Architecture and proven patterns" |
+| `{project_dir}` | Absolute path to project | "/Users/user/my-project" |
+
+## Angle Suggestions by N
+
+| N | Angles |
+|---|--------|
+| 2 | Architecture + Risks |
+| 3 | Architecture + Alternatives + Risks |
+| 4 | Architecture + Alternatives + Risks + Implementation |
+| 5 | Architecture + Alternatives + Risks + Implementation + Security |

package/agentic/antigravity/.agents/skills/team/references/prompt-reviewer.md

@@ -0,0 +1,54 @@
+# Reviewer Prompt Template
+
+Use this template for reviewer agents in `/team review`.
+
+Fill in `{variables}` before writing to `/tmp/luna-team-reviewer-N.txt`.
+
+---
+
+```
+You are a code reviewer with focus on: {focus_area}
+
+SCOPE: {scope_description}
+PROJECT DIR: {project_dir}
+
+Review the codebase for {focus_area} issues. Read relevant files, run analysis.
+
+For each finding use EXACTLY this format:
+[{SEVERITY}] {finding} — {evidence} — {recommendation}
+
+Where SEVERITY is one of:
+- CRITICAL: blocks release, must fix now
+- IMPORTANT: should fix before next release
+- MODERATE: nice to have, technical debt
+
+Start your output with a 2-line summary:
+Total findings: {N} ({X} CRITICAL, {Y} IMPORTANT, {Z} MODERATE)
+Focus area: {focus_area}
+
+Then list findings, CRITICAL first.
+
+RULES:
+- Evidence MUST be concrete: file:line or specific command output
+- NO "seems", "probably", "might" — only what you can verify
+- Max 50 findings total
+- Output ONLY the findings list + summary header — no preamble
+```
+
+---
+
+## Variable Reference
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `{focus_area}` | Review focus | "Security", "Performance", "Test Coverage" |
+| `{scope_description}` | What to review | "agentic/antigravity/.agents/skills/ — check for stale references" |
+| `{project_dir}` | Absolute path | "/Users/user/my-project" |
+
+## Default Focus Areas (3 reviewers)
+
+| Reviewer | Focus | Key Checks |
+|----------|-------|------------|
+| 1 | Security | OWASP top 10, auth gaps, secrets in code, input validation |
+| 2 | Performance | N+1 queries, memory leaks, O(n²) algorithms, blocking I/O |
+| 3 | Test Coverage | Untested paths, missing edge cases, flaky tests, no error path tests |