@thanhthi2895/luna-ai 2.16.2

package/agentic/antigravity/.agents/skills/debugger/references/systematic-debugging.md

@@ -0,0 +1,91 @@
+# Systematic Debugging
+
+Four-phase debugging framework that ensures root cause investigation before attempting fixes.
+
+## The Iron Law
+
+```
+NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST
+```
+
+If haven't completed Phase 1, cannot propose fixes.
+
+## The Four Phases
+
+Must complete each phase before proceeding to next.
+
+### Phase 1: Root Cause Investigation
+
+**BEFORE attempting ANY fix:**
+
+1. **Read Error Messages Carefully** - Don't skip past errors/warnings, read stack traces completely
+2. **Reproduce Consistently** - Can trigger reliably? Exact steps? If not reproducible → gather more data
+3. **Check Recent Changes** - What changed? Git diff, recent commits, new dependencies, config changes
+4. **Gather Evidence in Multi-Component Systems**
+   - For EACH component boundary: log data entering/exiting, verify environment propagation
+   - Run once to gather evidence showing WHERE it breaks
+   - THEN analyze to identify failing component
+5. **Trace Data Flow** - Where does bad value originate? Trace up call stack until finding source (see root-cause-tracing.md)
+
+### Phase 2: Pattern Analysis
+
+**Find pattern before fixing:**
+
+1. **Find Working Examples** - Locate similar working code in same codebase
+2. **Compare Against References** - Read reference implementation COMPLETELY, understand fully before applying
+3. **Identify Differences** - List every difference however small, don't assume "that can't matter"
+4. **Understand Dependencies** - What other components, settings, config, environment needed?
+
+### Phase 3: Hypothesis and Testing
+
+**Scientific method:**
+
+1. **Form Single Hypothesis** - "I think X is root cause because Y", be specific not vague
+2. **Test Minimally** - SMALLEST possible change to test hypothesis, one variable at a time
+3. **Verify Before Continuing** - Worked? → Phase 4. Didn't work? → NEW hypothesis. DON'T add more fixes
+4. **When Don't Know** - Say "I don't understand X", don't pretend, ask for help
+
+### Phase 4: Implementation
+
+**Fix root cause, not symptom:**
+
+1. **Create Failing Test Case** - Simplest reproduction, automated if possible, MUST have before fixing
+2. **Implement Single Fix** - Address root cause identified, ONE change, no "while I'm here" improvements
+3. **Verify Fix** - Test passes? No other tests broken? Issue actually resolved?
+4. **If Fix Doesn't Work**
+   - STOP. Count: How many fixes tried?
+   - If < 3: Return to Phase 1, re-analyze with new information
+   - **If ≥ 3: STOP and question architecture**
+5. **If 3+ Fixes Failed: Question Architecture**
+   - Pattern: Each fix reveals new shared state/coupling problem elsewhere
+   - STOP and question fundamentals: Is pattern sound? Wrong architecture?
+   - Discuss with human partner before more fixes
+
+## Red Flags - STOP and Follow Process
+
+If catch yourself thinking:
+- "Quick fix for now, investigate later"
+- "Just try changing X and see if it works"
+- "Add multiple changes, run tests"
+- "Skip the test, I'll manually verify"
+- "It's probably X, let me fix that"
+- "I don't fully understand but this might work"
+- "One more fix attempt" (when already tried 2+)
+
+**ALL mean:** STOP. Return to Phase 1.
+
+## Common Rationalizations
+
+| Excuse | Reality |
+|--------|---------|
+| "Issue is simple, don't need process" | Simple issues have root causes too |
+| "Emergency, no time for process" | Systematic is FASTER than guess-and-check |
+| "Just try this first, then investigate" | First fix sets pattern. Do right from start |
+| "One more fix attempt" (after 2+ failures) | 3+ failures = architectural problem |
+
+## Real-World Impact
+
+- Systematic approach: 15-30 minutes to fix
+- Random fixes approach: 2-3 hours of thrashing
+- First-time fix rate: 95% vs 40%
+- New bugs introduced: Near zero vs common

package/agentic/antigravity/.agents/skills/debugger/references/task-management-debugging.md

@@ -0,0 +1,148 @@
+# Debug Task Management Patterns
+
+Track investigation and debugging pipelines with Antigravity-native tools (`run_command`, `view_file`, `replace_file_content`) and `lu:team` for parallel debug work.
+
+## When to Create Tasks
+
+| Debug Scope | Tasks? | Rationale |
+|-------------|--------|-----------|
+| Single bug, one file | No | Systematic debugging handles directly |
+| Multi-component investigation (3+ steps) | Yes | Track assess → collect → analyze → fix → verify in `/tmp/debug-log.md` |
+| Parallel log/data collection agents | Yes | Coordinate independent evidence gathering via `lu:team` debug template |
+| Performance investigation with multiple layers | Yes | Track bottleneck analysis per layer in a shared markdown log |
+| CI/CD pipeline failure with 3+ possible causes | Yes | Track hypothesis elimination with explicit state updates |
+
+**3-Step Rule:** Skip formal tracking when investigation has < 3 meaningful steps.
+
+## Investigation Pipeline as Tasks
+
+```
+# Initialize investigation log
+run_command: "cat > /tmp/debug-log.md <<'EOF'
+# Debug Investigation Log
+
+- [ ] Assess incident scope
+- [ ] Collect logs and evidence
+- [ ] Analyze root cause
+- [ ] Implement fix
+- [ ] Verify fix resolves issue
+EOF"
+
+# Read current pipeline state
+view_file: "/tmp/debug-log.md"
+```
+
+Maps to investigation-methodology.md 5-step process. Update each checkbox/status as steps complete.
+
+## Task Schemas
+
+### Assess Task
+```
+# Evidence-first commands for scope assessment
+run_command: "rg -n \"{incident_keyword}\" ."
+run_command: "grep -Rni \"{service_or_error}\" logs/"
+
+# Mark stage progress in log
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Assess incident scope"
+  newString: "- [x] Assess incident scope (owner: debugger, effort: 5m)"
+```
+
+### Collect Task
+```
+# Collect logs, CI output, metrics snapshots
+run_command: "cat /var/log/{service}.log"
+run_command: "rg -n \"(ERROR|FATAL|panic|timeout)\" /var/log/{service}.log"
+run_command: "cat .github/workflows/{pipeline}.yml"
+
+# Sync collection completion
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Collect logs and evidence"
+  newString: "- [x] Collect logs and evidence (sources: app, ci, db, effort: 10m)"
+```
+
+### Analyze Task
+```
+# Correlate evidence and trace execution
+run_command: "rg -n \"{suspect_function}|{error_code}\" src/"
+run_command: "rg -n \"{incident_id}|{request_id}\" logs/"
+
+# Record root-cause hypothesis state
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Analyze root cause"
+  newString: "- [x] Analyze root cause (hypothesis: {root_cause_hypothesis}, confidence: medium)"
+```
+
+### Fix Task
+```
+# Implement patch and verify changed surface
+run_command: "rg -n \"{patched_symbol}\" src/"
+
+# Update fix status in the log
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Implement fix"
+  newString: "- [x] Implement fix (summary: {root_cause_summary}, effort: 20m)"
+```
+
+### Verify Task
+```
+# Validate with fresh evidence
+run_command: "rg -n \"(ERROR|FATAL|panic|timeout)\" /var/log/{service}.log"
+run_command: "cat /tmp/debug-log.md"
+
+# Close verification stage with evidence pointer
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Verify fix resolves issue"
+  newString: "- [x] Verify fix resolves issue (evidence: {test_or_log_reference}, effort: 5m)"
+```
+
+## Parallel Evidence Collection
+
+For multi-source investigations, spawn parallel collection agents:
+
+```
+# Use lu:team debug template to run opencode subprocesses in parallel
+Skill("lu:team")
+
+# Team lanes (example)
+- lane-1: collect CI/CD pipeline logs
+- lane-2: collect application server logs
+- lane-3: query database anomalies
+
+# Merge evidence from all lanes into shared log
+replace_file_content:
+  filePath: "/tmp/debug-log.md"
+  oldString: "- [ ] Analyze root cause"
+  newString: "- [ ] Analyze root cause (blocked until lane-1, lane-2, lane-3 evidence merged)"
+```
+
+## Re-Investigation Cycle
+
+When fix doesn't resolve → new analyze-fix-verify cycle:
+
+```
+# Append a new cycle entry and reset analyze/fix/verify states
+run_command: "cat >> /tmp/debug-log.md <<'EOF'
+
+## Re-Investigation Cycle {N}
+- Trigger: verify failed for cycle {N-1}
+- [ ] Analyze root cause (cycle {N})
+- [ ] Implement fix (cycle {N})
+- [ ] Verify fix resolves issue (cycle {N})
+EOF"
+
+view_file: "/tmp/debug-log.md"
+```
+
+Limit to 3 cycles. After cycle 3 → question architecture (systematic-debugging.md Phase 4.5).
+
+## Report Sync-Back
+
+After investigation, write diagnostic report per reporting-standards.md.
+
+Use `/tmp/debug-log.md` as the active session tracker during execution, then sync key findings into the final diagnostic report as durable source of truth.

package/agentic/antigravity/.agents/skills/debugger/references/verification.md

@@ -0,0 +1,80 @@
+# Verification Before Completion
+
+Run verification commands and confirm output before claiming success.
+
+## The Iron Law
+
+```
+NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
+```
+
+If haven't run verification command in this message, cannot claim it passes.
+
+## The Gate Function
+
+```
+BEFORE claiming any status or expressing satisfaction:
+
+1. IDENTIFY: What command proves this claim?
+2. RUN: Execute FULL command (fresh, complete)
+3. READ: Full output, check exit code, count failures
+4. VERIFY: Does output confirm claim?
+   - If NO: State actual status with evidence
+   - If YES: State claim WITH evidence
+5. ONLY THEN: Make claim
+```
+
+## Common Failures
+
+| Claim | Requires | Not Sufficient |
+|-------|----------|----------------|
+| Tests pass | Test command output: 0 failures | Previous run, "should pass" |
+| Linter clean | Linter output: 0 errors | Partial check, extrapolation |
+| Build succeeds | Build command: exit 0 | Linter passing, logs look good |
+| Bug fixed | Test original symptom: passes | Code changed, assumed fixed |
+| Agent completed | VCS diff shows changes | Agent reports "success" |
+
+## Red Flags - STOP
+
+- Using "should", "probably", "seems to"
+- Expressing satisfaction before verification ("Great!", "Perfect!", "Done!")
+- About to commit/push/PR without verification
+- Trusting agent success reports
+- Relying on partial verification
+
+## Key Patterns
+
+**Tests:**
+```
+✅ [Run test command] → [See: 34/34 pass] → "All tests pass"
+❌ "Should pass now" / "Looks correct"
+```
+
+**Regression tests (TDD Red-Green):**
+```
+✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)
+❌ "I've written regression test" (without red-green verification)
+```
+
+**Build:**
+```
+✅ [Run build] → [See: exit 0] → "Build passes"
+❌ "Linter passed" (linter doesn't check compilation)
+```
+
+**Agent delegation:**
+```
+✅ Agent reports success → Check VCS diff → Verify changes → Report actual state
+❌ Trust agent report without independent verification
+```
+
+## When To Apply
+
+**ALWAYS before:**
+- ANY success/completion claims
+- ANY expression of satisfaction
+- Committing, PR creation, task completion
+- Moving to next task
+- Delegating to agents
+
+**Non-negotiable.** Run command. Read output. THEN claim result.

package/agentic/antigravity/.agents/skills/debugger/scripts/find-polluter.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Bisection script to find which test creates unwanted files/state
+# Usage: ./find-polluter.sh <file_or_dir_to_check> <test_pattern>
+# Example: ./find-polluter.sh '.git' 'src/**/*.test.ts'
+
+set -e
+
+if [ $# -ne 2 ]; then
+  echo "Usage: $0 <file_to_check> <test_pattern>"
+  echo "Example: $0 '.git' 'src/**/*.test.ts'"
+  exit 1
+fi
+
+POLLUTION_CHECK="$1"
+TEST_PATTERN="$2"
+
+echo "🔍 Searching for test that creates: $POLLUTION_CHECK"
+echo "Test pattern: $TEST_PATTERN"
+echo ""
+
+# Get list of test files
+TEST_FILES=$(find . -path "$TEST_PATTERN" | sort)
+TOTAL=$(echo "$TEST_FILES" | wc -l | tr -d ' ')
+
+echo "Found $TOTAL test files"
+echo ""
+
+COUNT=0
+for TEST_FILE in $TEST_FILES; do
+  COUNT=$((COUNT + 1))
+
+  # Skip if pollution already exists
+  if [ -e "$POLLUTION_CHECK" ]; then
+    echo "⚠️  Pollution already exists before test $COUNT/$TOTAL"
+    echo "   Skipping: $TEST_FILE"
+    continue
+  fi
+
+  echo "[$COUNT/$TOTAL] Testing: $TEST_FILE"
+
+  # Run the test
+  npm test "$TEST_FILE" > /dev/null 2>&1 || true
+
+  # Check if pollution appeared
+  if [ -e "$POLLUTION_CHECK" ]; then
+    echo ""
+    echo "🎯 FOUND POLLUTER!"
+    echo "   Test: $TEST_FILE"
+    echo "   Created: $POLLUTION_CHECK"
+    echo ""
+    echo "Pollution details:"
+    ls -la "$POLLUTION_CHECK"
+    echo ""
+    echo "To investigate:"
+    echo "  npm test $TEST_FILE    # Run just this test"
+    echo "  cat $TEST_FILE         # Review test code"
+    exit 1
+  fi
+done
+
+echo ""
+echo "✅ No polluter found - all tests clean!"
+exit 0

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

@@ -0,0 +1,55 @@
+---
+name: lu:docs
+author: luna
+description: "Analyze codebase and manage project documentation — init, update, summarize."
+argument-hint: "init|update|summarize"
+---
+
+# Documentation Management
+
+Analyze codebase and manage project documentation through scouting, analysis, and structured doc generation.
+
+## Default (No Arguments)
+
+If invoked without arguments, use `AskUserQuestion` to present available documentation operations:
+
+| Operation | Description |
+|-----------|-------------|
+| `init` | Analyze codebase & create initial docs |
+| `update` | Analyze changes & update docs |
+| `summarize` | Quick codebase summary |
+
+Present as options via `AskUserQuestion` with header "Documentation Operation", question "What would you like to do?".
+
+## Subcommands
+
+| Subcommand | Reference | Purpose |
+|------------|-----------|---------|
+| `/lu:docs init` | `references/init-workflow.md` | Analyze codebase and create initial documentation |
+| `/lu:docs update` | `references/update-workflow.md` | Analyze codebase and update existing documentation |
+| `/lu:docs summarize` | `references/summarize-workflow.md` | Quick analysis and update of codebase summary |
+
+## Routing
+
+Parse `$ARGUMENTS` first word:
+- `init` → Load `references/init-workflow.md`
+- `update` → Load `references/update-workflow.md`
+- `summarize` → Load `references/summarize-workflow.md`
+- empty/unclear → AskUserQuestion (do not auto-run `init`)
+
+## Shared Context
+
+Documentation lives in `./docs` directory. **Check `./docs` for actual existing files** — do not assume a fixed list. Common files may include:
+
+```
+./docs
+├── project-overview-pdr.md
+├── code-standards.md
+├── codebase-summary.md
+├── system-architecture.md
+└── ... (project-specific files — read CLAUDE.md for definitive list)
+```
+
+Use `./docs` directory as the source of truth. If `CLAUDE.md` defines a docs structure, that takes priority.
+
+**IMPORTANT**: **Do not** start implementing code.

package/agentic/antigravity/.agents/skills/docs/references/init-workflow.md

@@ -0,0 +1,32 @@
+# Init Workflow
+
+## Phase 1: Parallel Codebase Scouting
+
+1. Scan the codebase and calculate the number of files with LOC in each directory (skip credentials, cache or external modules directories, such as `.claude`, `.opencode`, `.git`, `tests`, `node_modules`, `__pycache__`, `secrets`, etc.)
+2. Target directories **that actually exist** - adapt to project structure, don't hardcode paths
+3. Activate `scout` skill to explore the code base and return detailed summary reports to the main agent
+4. Merge scout reports into context summary
+
+## Phase 2: Documentation Creation (docs-manager Agent)
+
+**CRITICAL:** You MUST spawn `docs-manager` agent via Task tool with merged reports. Do not wait for user input.
+
+Pass the gathered context to docs-manager agent to create initial documentation:
+- `README.md`: Update README with initial documentation (keep it under 300 lines)
+- `docs/project-overview-pdr.md`: Project overview and PDR (Product Development Requirements)
+- `docs/codebase-summary.md`: Codebase summary
+- `docs/code-standards.md`: Codebase structure and code standards
+- `docs/system-architecture.md`: System architecture
+- `docs/project-roadmap.md`: Project roadmap
+- `docs/deployment-guide.md` [optional]: Deployment guide
+- `docs/design-guidelines.md` [optional]: Design guidelines
+
+## Phase 3: Size Check (Post-Generation)
+
+After docs-manager completes:
+1. Run `wc -l docs/*.md 2>/dev/null | sort -rn` to check LOC
+2. Use `docs.maxLoc` from session context (default: 800)
+3. For files exceeding limit:
+   - Report which files exceed and by how much
+   - docs-manager should have already split proactively
+   - If still oversized, ask user: split now or accept as-is?

package/agentic/antigravity/.agents/skills/docs/references/summarize-workflow.md

@@ -0,0 +1,18 @@
+# Summarize Workflow
+
+Activate `scout` skill to analyze the codebase and update `docs/codebase-summary.md` and respond with a summary report.
+
+## Arguments
+$1: Focused topics (default: all)
+$2: Should scan codebase (`Boolean`, default: `false`)
+
+## Focused Topics
+<focused_topics>$1</focused_topics>
+
+## Should Scan Codebase
+<should_scan_codebase>$2</should_scan_codebase>
+
+## Important
+- Use `docs/` directory as the source of truth for documentation.
+- Do not scan the entire codebase unless the user explicitly requests it.
+- **Do not** start implementing.

package/agentic/antigravity/.agents/skills/docs/references/update-workflow.md

@@ -0,0 +1,49 @@
+# Update Workflow
+
+## Phase 1: Scout Codebase
+
+Search policy: start semantic discovery with `ccc search`; use `find_by_name` + `grep_search` only for deterministic narrowing; run `ccc index` when stale or after major code changes.
+
+1. Scan directory structure: `run_command find . -maxdepth 3 -not -path "*/node_modules/*" -not -path "*/.git/*" | sort`
+2. Count files per dir: `run_command find . -maxdepth 2 -name "*.md" -o -name "*.ts" -o -name "*.js" | head -100`
+3. Run `ccc search` for changed concepts/components, then use `find_by_name` + `grep_search` in parallel across key directories to narrow exact files
+
+## Phase 2: Read Current Docs
+
+```bash
+wc -l docs/*.md 2>/dev/null | sort -rn
+```
+
+Read each doc file via `view_file` (read them in parallel if 4+ files):
+- Extract: purpose, key sections, areas that are out of date
+
+## Phase 3: Update Documentation
+
+Update each doc directly via `replace_file_content` (targeted edits) or `write_to_file` (full rewrites):
+
+- `docs/project-overview-pdr.md` — Project overview and PDR
+- `docs/codebase-summary.md` — Codebase structure summary
+- `docs/system-architecture.md` — System architecture
+- `docs/code-standards.md` — Code standards
+
+Update strategy:
+- **Replace specific sections** with `replace_file_content` when only parts are stale
+- **Full rewrite** with `write_to_file` when structure needs to change
+- Keep each doc under 800 lines
+
+## Additional requests
+<additional_requests>
+  $ARGUMENTS
+</additional_requests>
+
+## Phase 4: Size Check
+
+```bash
+wc -l docs/*.md 2>/dev/null | sort -rn
+```
+
+Flag any file exceeding 800 lines — ask user whether to trim or split.
+
+## Important
+- Use `docs/` directory as the source of truth.
+- **Do not** start implementing code.

package/agentic/antigravity/.agents/skills/docs-seeker/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: lu:docs-seeker
+author: luna
+description: "Search library/framework documentation via llms.txt (context7.com). Use for API docs, GitHub repository analysis, technical documentation lookup, latest library features."
+version: 1.0.0
+argument-hint: "[library-name] [topic]"
+---
+
+# Documentation Discovery
+
+**Script-first** documentation discovery using llms.txt standard via context7.com.
+
+## Primary Workflow
+
+**ALWAYS execute scripts in this order:**
+
+```bash
+SKILL_DIR=""
+if [ -d "agentic/antigravity/.agents/skills/docs-seeker/scripts" ]; then
+  SKILL_DIR="agentic/antigravity/.agents/skills/docs-seeker/scripts"
+elif [ -d "$HOME/.gemini/antigravity/skills/docs-seeker/scripts" ]; then
+  SKILL_DIR="$HOME/.gemini/antigravity/skills/docs-seeker/scripts"
+fi
+
+# 1. DETECT query type
+node "$SKILL_DIR/detect-topic.js" "<user query>"
+
+# 2. FETCH documentation
+node "$SKILL_DIR/fetch-docs.js" "<user query>"
+
+# 3. ANALYZE results (if multiple URLs)
+cat llms.txt | node "$SKILL_DIR/analyze-llms-txt.js" -
+```
+
+## Scripts
+
+**`detect-topic.js`** — Classify query type
+- Identifies topic-specific vs general queries
+- Returns JSON: `{topic, library, isTopicSpecific}`
+
+**`fetch-docs.js`** — Retrieve documentation
+- Constructs context7.com URLs automatically
+- Handles fallback: topic → general → error
+- Outputs llms.txt content
+
+**`analyze-llms-txt.js`** — Process llms.txt
+- Categorizes URLs (critical/important/supplementary)
+- Recommends agent distribution (1, 3, 7 agents, or phased)
+- Returns JSON with strategy
+
+## Quick Start
+
+**Topic query:** "How do I use date picker in shadcn?"
+```bash
+node "$SKILL_DIR/detect-topic.js" "<query>"  # → {topic, library, isTopicSpecific}
+node "$SKILL_DIR/fetch-docs.js" "<query>"    # → 2-3 URLs
+# Read URLs with WebFetch
+```
+
+**General query:** "Documentation for Next.js"
+```bash
+node "$SKILL_DIR/detect-topic.js" "<query>"          # → {isTopicSpecific: false}
+node "$SKILL_DIR/fetch-docs.js" "<query>"            # → 8+ URLs
+cat llms.txt | node "$SKILL_DIR/analyze-llms-txt.js" -  # → agent strategy
+# Deploy parallel agents per recommendation
+```
+
+## References
+
+- `references/context7-patterns.md` — URL patterns, known repositories
+- `references/errors.md` — Error handling, fallback strategies
+- `references/advanced.md` — Edge cases, versioning, multi-language

package/agentic/antigravity/.agents/skills/docs-seeker/references/advanced.md

@@ -0,0 +1,79 @@
+# Advanced Scenarios & Edge Cases
+
+## Multi-Language Documentation
+
+**Challenge:** Docs in multiple languages
+
+**Approach:**
+1. Identify target language from user
+2. Search for language-specific llms.txt
+   - `llms-es.txt`, `llms-ja.txt`
+3. Fallback to English if not found
+4. Note language limitations in report
+
+## Version-Specific Documentation
+
+**Latest (default):**
+- Use base llms.txt URL
+- No version specifier needed
+
+**Specific version:**
+```
+WebSearch: "[library] v[version] llms.txt"
+Check paths:
+- /v2/llms.txt
+- /docs/v2/llms.txt
+- /{version}/llms.txt
+
+For repos:
+git checkout v[version] or tags/[version]
+```
+
+## Framework with Plugins
+
+**Challenge:** Core framework + 50 plugins
+
+**Strategy:**
+1. Focus on core framework first
+2. Ask user which plugins needed
+3. Launch targeted search for specific plugins
+4. Note available plugins in report
+5. Don't document everything upfront
+
+## Documentation Under Construction
+
+**Signs:**
+- New release with incomplete docs
+- Many "Coming soon" pages
+- GitHub issues requesting docs
+
+**Approach:**
+1. Note status upfront in report
+2. Combine available docs + repo analysis
+3. Check tests/ and examples/ directories
+4. Clearly mark "inferred from code"
+5. Link to GitHub issues for updates
+
+## Conflicting Information
+
+**When sources disagree:**
+1. Identify primary official source
+2. Note version differences
+3. Present both approaches with context
+4. Recommend official/latest
+5. Explain why conflict exists
+
+**Priority order:**
+1. Official docs (latest version)
+2. Official docs (versioned)
+3. GitHub README
+4. Community tutorials
+5. Stack Overflow
+
+## Rate Limiting
+
+**If hitting API limits:**
+- Use CONTEXT7_API_KEY from .env
+- Implement exponential backoff
+- Cache results in session
+- Batch requests where possible