@thanhthi2895/luna-ai 2.16.2

package/agentic/antigravity/.agents/skills/react-structure/schemas/component-props-schema.md

@@ -0,0 +1,84 @@
+# Component Props Schema (TypeScript)
+
+## Rule
+
+**MANDATORY:** Every View component MUST have an explicit TypeScript interface for its props. No `any`, no implicit types.
+
+## View Props Interface
+
+```tsx
+// UserCardView.tsx
+import { memo } from 'react';
+
+interface UserCardViewProps {
+  // Data
+  user: User;
+  isLoading: boolean;
+  // Handlers (callbacks from Container — MUST be wrapped in useCallback)
+  onEdit: (id: string) => void;
+  onDelete: (id: string) => void;
+}
+
+// MANDATORY: View MUST use arrow function + React.memo()
+export const UserCardView = memo(({ user, isLoading, onEdit, onDelete }: UserCardViewProps) => {
+  return (
+    <div>
+      <h2>{user.name}</h2>
+      <button onClick={() => onEdit(user.id)}>Edit</button>
+    </div>
+  );
+});
+
+UserCardView.displayName = 'UserCardView';
+```
+
+## Naming Convention
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| View props | `<Name>ViewProps` | `UserCardViewProps` |
+| Container props | `<Name>ContainerProps` | `UserCardContainerProps` |
+| Hook return | `use<Name>Return` | `useUserDataReturn` |
+
+## Container Props Interface
+
+Only define if Container receives external props (from parent).
+**MUST** wrap all callbacks in `useCallback` and derived data in `useMemo` before passing to View.
+
+```tsx
+// UserCardContainer.tsx
+import { useCallback, useMemo } from 'react';
+
+interface UserCardContainerProps {
+  userId: string;               // from parent
+  onNavigate?: (path: string) => void; // optional callback from parent
+}
+
+export const UserCardContainer = ({ userId, onNavigate }: UserCardContainerProps) => {
+  const { data, handlers } = useUserData(userId);
+
+  // MANDATORY: wrap callbacks with useCallback
+  const handleEdit = useCallback((id: string) => {
+    handlers.handleEdit(id);
+  }, [handlers.handleEdit]);
+
+  // MANDATORY: wrap derived data with useMemo
+  const formattedUser = useMemo(() => ({
+    ...data.user,
+    displayName: `${data.user?.firstName} ${data.user?.lastName}`,
+  }), [data.user]);
+
+  return <UserCardView user={formattedUser} onEdit={handleEdit} />;
+};
+```
+
+## Exporting Types
+
+Export from `index.ts` only what consumers need:
+
+```ts
+// index.ts
+export { UserCardContainer as default } from './UserCardContainer';
+export type { UserCardContainerProps } from './UserCardContainer';
+// Do NOT export ViewProps — internal only
+```

package/agentic/antigravity/.agents/skills/requirements.txt

@@ -0,0 +1,18 @@
+# Luna AI Skills — Python Dependencies
+# Python 3.10+ required
+
+# Google Gemini API (ai-multimodal skill)
+google-genai>=0.2.0
+
+# Image processing (ai-multimodal skill)
+Pillow>=10.0.0
+
+# PDF processing (ai-multimodal skill)
+pypdf>=4.0.0
+
+# Document processing (ai-multimodal skill)
+python-docx>=1.0.0
+markdown>=3.5.0
+
+# Environment variable management
+python-dotenv>=1.0.0

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

@@ -0,0 +1,74 @@
+---
+name: lu:research
+author: luna
+description: Explore codebase and collect context to create researcher reports.
+---
+
+# Research 🔍
+
+> **Reference**: Fully follow workflow in `agentic/antigravity/.agents/rules/researcher.md`
+
+## Process
+
+### 1. Understand Architecture
+
+Read `STRUCTURE.md` to identify related modules.
+If not available → scan project directly with `find . -maxdepth 3 | sort`. User preferences are in auto-loaded MEMORY.md context.
+
+Code-search routing: start semantic discovery with `ccc search`; use `lu:scout` only for broad file discovery; use Glob/Grep for deterministic narrowing; run `ccc index` when stale or after major code changes.
+
+> **Stop Early**: If STRUCTURE.md provides enough information → NO need to read additional original files.
+
+### 2. Explore Codebase
+
+Find files/modules related to request. Identify stack (`package.json`, `requirements.txt`...).
+
+**Knowledge Distillation** — when reading files >150 lines:
+
+- DO NOT paste entire file — only extract relevant logic segments
+- Write summary: `"Function X (lines 10-50): Handles Y, receives Z, returns W"`
+
+### 3. Parallel Discovery (When Request is Complex)
+
+**Before spawning agents** — create a task for each stream (for visibility in `/tasks`):
+
+```
+TaskCreate("Research: <topic-1>") → taskId_1
+TaskCreate("Research: <topic-2>") → taskId_2
+TaskCreate("Research: <topic-3>") → taskId_3  (if needed)
+```
+
+Then spawn all streams simultaneously (multiple Task tool calls in one response), passing the taskId to each agent:
+
+```
+Stream 1: Scan internal codebase         (pass taskId_1)
+  → `ccc search` first, then Grep/Glob for exact symbols, imports, and call sites
+
+Stream 2: Lookup external documentation  (pass taskId_2)
+  → Web search for external docs (official docs, tutorials, compatibility)
+
+Stream 3: Impact analysis (if needed)    (pass taskId_3)
+  → `gkg` identify cascading impact area
+```
+
+### 4. Clarify Ambiguities
+
+Ask user if anything is unclear → wait for response before continuing.
+
+## Research Depth Reference
+
+| Depth | Source                               | Speed     | Use When                      |
+| ----- | ------------------------------------ | --------- | ----------------------------- |
+| L1    | `STRUCTURE.md`, `README.md`, `docs/` | ⚡ Fast   | Overview, find module         |
+| L2    | Codebase (`ccc search` + Glob/Grep/Read) | 🔍 Medium | Semantic discovery + specific implementation |
+| L3    | Git history, external docs, Web      | 🐢 Slow   | History, new technology       |
+
+## Output: Create research report
+
+- Follow the structure used by existing Antigravity researcher reports in `plans/` and include all required sections; do not omit sections.
+- Save at: `plans/<YYYY-MM-DD>-<feature>/research/researcher-<N>-report.md` (N = sequential number, 01, 02, ...)
+- When multiple researchers run in parallel, each saves its own numbered report.
+- Fill completely: Codebase Analysis, Risks, External Research, Implementation Proposal.
+- Record technology versions (from `package.json` or equivalent).
+
+After creation: if clear → automatically proceed to Step 3 (Planning); if ambiguous → wait for user confirmation.

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

@@ -0,0 +1,91 @@
+---
+name: lu:scout
+author: luna
+description: "Fast codebase scouting using parallel agents. Use for file discovery, task context gathering, quick searches across directories. Supports internal (Explore) and external (Gemini/OpenCode) agents."
+version: 1.0.0
+argument-hint: "[search-target] [ext]"
+---
+
+# Scout
+
+Fast, token-efficient codebase scouting using parallel agents to find files needed for tasks.
+
+## Arguments
+- Default: Scout using built-in Explore subagents in parallel (`./references/internal-scouting.md`)
+- `ext`: Scout using external Gemini/OpenCode CLI tools in parallel (`./references/external-scouting.md`)
+
+## When to Use
+
+- Beginning work on feature spanning multiple directories
+- User mentions needing to "find", "locate", or "search for" files
+- Starting debugging session requiring file relationships understanding
+- User asks about project structure or where functionality lives
+- Before changes that might affect multiple codebase parts
+
+## Quick Start
+
+1. Analyze user prompt to identify search targets
+2. Start with `ccc search` for semantic discovery, then use Grep/Glob for deterministic narrowing and scale estimation
+3. Spawn parallel agents with divided directories
+4. Collect results into concise report
+
+## Configuration
+
+Read from `.claude/.luna.json`:
+- `gemini.model` - Gemini model (default: `gemini-3-flash-preview`)
+
+## Workflow
+
+### 1. Analyze Task
+- Parse user prompt for search targets
+- Identify key directories, patterns, file types, lines of code
+- Determine optimal SCALE value of subagents to spawn
+
+### 2. Divide and Conquer
+- Split codebase into logical segments per agent
+- Assign each agent specific directories or patterns
+- Ensure no overlap, maximize coverage
+
+### 3. Register Scout Tasks
+- **Skip if:** Agent count ≤ 2 (overhead exceeds benefit)
+- `TaskList` first — check for existing scout tasks in session
+- If not found, `TaskCreate` per agent with scope metadata
+- See `references/task-management-scouting.md` for patterns and examples
+
+### 4. Spawn Parallel Agents
+Load appropriate reference based on decision tree:
+- **Internal (Default):** `references/internal-scouting.md` (Explore subagents)
+- **Policy:** `ccc search` first; Explore/lexical scouting is follow-up for broad discovery
+- **External:** `references/external-scouting.md` (Gemini/OpenCode)
+
+**Notes:**
+- `TaskUpdate` each task to `in_progress` before spawning its agent
+- Prompt detailed instructions for each subagent with exact directories or files it should read
+- Remember that each subagent has less than 200K tokens of context window
+- Amount of subagents to-be-spawned depends on the current system resources available and amount of files to be scanned
+- Each subagent must return a detailed summary report to a main agent
+
+### 5. Collect Results
+- Timeout: 3 minutes per agent (skip non-responders)
+- `TaskUpdate` completed tasks; log timed-out agents in report
+- Aggregate findings into single report
+- List unresolved questions at end
+
+## Report Format
+
+```markdown
+# Scout Report
+
+## Relevant Files
+- `path/to/file.ts` - Brief description
+- ...
+
+## Unresolved Questions
+- Any gaps in findings
+```
+
+## References
+
+- `references/internal-scouting.md` - Using Explore subagents
+- `references/external-scouting.md` - Using Gemini/OpenCode CLI
+- `references/task-management-scouting.md` - Claude Task patterns for scout coordination

package/agentic/antigravity/.agents/skills/scout/references/external-scouting.md

@@ -0,0 +1,93 @@
+# External Scouting with Gemini/OpenCode
+
+Use external CLI tools for faster searches with large context windows (1M+ tokens).
+
+## Tool Selection
+
+```
+SCALE <= 3  → gemini CLI
+SCALE 4-5   → opencode CLI
+SCALE >= 6  → Use internal scouting instead (internal-scouting.md)
+```
+
+## Configuration
+
+Read from `.luna.json`:
+```json
+{
+  "gemini": {
+    "model": "gemini-3-flash-preview"
+  }
+}
+```
+
+Default model: `gemini-3-flash-preview`
+
+## Gemini CLI (SCALE <= 3)
+
+### Command
+```bash
+gemini -y -m <model> "[prompt]"
+```
+
+### Example
+```bash
+gemini -y -m gemini-3-flash-preview "Search src/ for authentication files. List paths with brief descriptions."
+```
+
+## OpenCode CLI (SCALE 4-5)
+
+### Command
+```bash
+opencode run "[prompt]" --model opencode/grok-code
+```
+
+### Example
+```bash
+opencode run "Find all payment-related files in lib/ and api/" --model opencode/grok-code
+```
+
+## Installation Check
+
+Before using, verify tools installed:
+```bash
+which gemini
+which opencode
+```
+
+If not installed, ask user:
+1. **Yes** — Provide installation instructions
+2. **No** — Fall back to internal scouting (`internal-scouting.md`)
+
+## Parallel Execution
+
+Run multiple CLI commands in parallel via multiple `run_command` calls in the same response:
+
+```
+run_command("gemini -y -m gemini-3-flash-preview 'Search db/, migrations/ for migration files'")
+run_command("gemini -y -m gemini-3-flash-preview 'Search lib/, src/ for database schema files'")
+run_command("gemini -y -m gemini-3-flash-preview 'Search config/ for database configuration'")
+```
+
+## Prompt Guidelines
+
+- Be specific about directories to search
+- Request file paths with descriptions
+- Set clear scope boundaries
+- Ask for patterns/relationships if relevant
+
+## Reading File Content
+
+Use `view_file` with StartLine/EndLine for large files:
+
+### Chunking Decision Tree
+```
+File < 500 lines    → view_file (no range)
+File 500-1500 lines → 2-3 view_file chunks
+File > 1500 lines   → ceil(lines/500) view_file chunks
+```
+
+## Timeout and Error Handling
+
+- If CLI command hangs, terminate and fall back to internal scouting
+- On persistent failures, run `ccc search` first; if still insufficient, fall back to internal scouting (`internal-scouting.md`)

package/agentic/antigravity/.agents/skills/scout/references/internal-scouting.md

@@ -0,0 +1,77 @@
+# Internal Scouting
+
+Use native file tools to search codebase across multiple areas in parallel.
+
+## How It Works
+
+Run `ccc search` first for semantic discovery, then call `find_by_name` and `grep_search` with multiple calls in the same response to search different areas simultaneously.
+
+## Tools
+
+```
+find_by_name(SearchDirectory="[dir]", Pattern="*[keyword]*", Type="file")
+grep_search(SearchPath="[dir]", Query="[pattern]", Includes=["*.ts"])
+list_dir(DirectoryPath="[dir]")
+view_file(AbsolutePath="[file]")
+```
+
+## Parallel Search Strategy
+
+### Directory Division
+Split codebase logically across parallel tool calls:
+- `src/` — Source code
+- `lib/` — Libraries
+- `tests/` — Test files
+- `config/` — Configuration
+- `api/` — API routes
+
+### Pattern
+Run `ccc search` first, then make multiple `grep_search` + `find_by_name` calls in the **same response** targeting different directories:
+
+```
+# All in one response — executes in parallel:
+ccc search "[feature concept]"
+grep_search(SearchPath="./src/auth", Query="[keyword]")
+grep_search(SearchPath="./src/api", Query="[keyword]")
+find_by_name(SearchDirectory="./tests", Pattern="*auth*")
+find_by_name(SearchDirectory="./config", Pattern="*auth*")
+```
+
+## Example
+
+User prompt: "Find authentication-related files"
+
+```
+# One response, parallel execution:
+ccc search "authentication flow"
+find_by_name(SearchDirectory="./src", Pattern="*auth*")
+grep_search(SearchPath="./src/routes", Query="authentication")
+grep_search(SearchPath="./tests", Query="auth")
+grep_search(SearchPath="./lib", Query="authenticate")
+```
+
+## Reading File Content
+
+When file content needed, use `view_file` with StartLine/EndLine for large files:
+
+### Chunking Decision Tree
+```
+File < 500 lines    → view_file (no range)
+File 500-1500 lines → view_file with StartLine/EndLine in 2-3 chunks
+File > 1500 lines   → view_file in ceil(lines/500) chunks
+```
+
+### Example — Large File
+```
+view_file(AbsolutePath="/path/file.ts", StartLine=1, EndLine=500)
+view_file(AbsolutePath="/path/file.ts", StartLine=501, EndLine=1000)
+view_file(AbsolutePath="/path/file.ts", StartLine=1001, EndLine=1500)
+```
+
+## Result Aggregation
+
+Combine results from all tool calls:
+1. Deduplicate file paths
+2. Merge descriptions
+3. Note any coverage gaps
+4. List unresolved questions

package/agentic/antigravity/.agents/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: lu:sequential-thinking
+author: luna
+description: "Apply step-by-step analysis for complex problems with revision capability. Use for multi-step reasoning, hypothesis verification, adaptive planning, problem decomposition, course correction."
+version: 1.0.0
+argument-hint: "[problem to analyze step-by-step]"
+---
+
+# Sequential Thinking
+
+Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.
+
+## When to Apply
+
+- Complex problem decomposition
+- Adaptive planning with revision capability
+- Problems with unclear/emerging scope
+- Multi-step solutions requiring context maintenance
+- Hypothesis-driven investigation/debugging
+
+## Core Process
+
+### 1. Start with Loose Estimate
+```
+Thought 1/5: [Initial analysis]
+```
+Adjust dynamically as understanding evolves.
+
+### 2. Structure Each Thought
+- Build on previous context explicitly
+- Address one aspect per thought
+- State assumptions, uncertainties, realizations
+
+### 3. Apply Dynamic Adjustment
+- **Expand**: More complexity discovered → increase total
+- **Contract**: Simpler than expected → decrease total
+- **Revise**: New insight invalidates previous → mark revision
+- **Branch**: Multiple approaches → explore alternatives
+
+### 4. Use Revision When Needed
+```
+Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
+- Original: [What was stated]
+- Why revised: [New insight]
+- Impact: [What changes]
+```
+
+### 5. Branch for Alternatives
+```
+Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
+Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
+```
+
+### 6. Generate & Verify Hypotheses
+```
+Thought 6/9 [HYPOTHESIS]: [Proposed solution]
+Thought 7/9 [VERIFICATION]: [Test results]
+```
+
+### 7. Complete Only When Ready
+Mark final: `Thought N/N [FINAL]`
+
+## Application Modes
+
+**Explicit**: Use visible thought markers when complexity warrants visible reasoning.
+**Implicit**: Apply methodology internally for routine problem-solving.
+
+## References
+
+- `references/core-patterns.md` - Revision & branching patterns
+- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence
+- `references/advanced-strategies.md` - Uncertainty, revision cascades, meta-thinking

package/agentic/antigravity/.agents/skills/sequential-thinking/references/advanced-strategies.md

@@ -0,0 +1,79 @@
+# Advanced Sequential Thinking Strategies
+
+Additional sophisticated patterns for complex scenarios.
+
+## Uncertainty Management
+
+Handle incomplete information systematically.
+
+```
+Thought 2/7: Need to decide X
+Thought 3/7: Insufficient data—two scenarios possible
+Thought 4/7 [SCENARIO A if P true]: Analysis for A
+Thought 4/7 [SCENARIO B if P false]: Analysis for B
+Thought 5/7: Decision that works for both scenarios
+Thought 6/7: Or determine critical info needed
+Thought 7/7 [FINAL]: Robust solution or clear info requirement
+```
+
+**Use for**: Decisions under uncertainty, incomplete requirements.
+
+**Strategies**:
+- Find solution robust to uncertainty
+- Identify minimal info needed to resolve
+- Make safe assumptions with clear documentation
+
+## Revision Cascade Management
+
+Handle revisions that invalidate multiple subsequent thoughts.
+
+```
+Thought 1/8: Foundation assumption
+Thought 2/8: Build on Thought 1
+Thought 3/8: Further build
+Thought 4/8: Discover Thought 1 invalid
+Thought 5/8 [REVISION of Thought 1]: Corrected foundation
+Thought 6/8 [REASSESSMENT]: Which of 2-3 still valid?
+  - Thought 2: Partially valid, needs adjustment
+  - Thought 3: Completely invalid
+Thought 7/8: Rebuild from corrected Thought 5
+Thought 8/8 [FINAL]: Solution on correct foundation
+```
+
+**Key**: After major revision, explicitly assess downstream impact.
+
+## Meta-Thinking Calibration
+
+Monitor and adjust thinking process itself.
+
+```
+Thought 5/9: [Regular thought]
+Thought 6/9 [META]: Past 3 thoughts circling without progress
+  Analysis: Missing key information
+  Adjustment: Need to research X before continuing
+Thought 7/9: Research findings on X
+Thought 8/9: Now can proceed with informed decision
+Thought 9/9: [Resume productive path]
+```
+
+**Use when**: Stuck, circling, or unproductive pattern noticed.
+**Action**: Pause, identify issue, adjust strategy.
+
+## Parallel Constraint Satisfaction
+
+Handle multiple independent constraints simultaneously.
+
+```
+Thought 2/10: Solution must satisfy A, B, C
+Thought 3/10 [CONSTRAINT A]: Solutions satisfying A: {X, Y, Z}
+Thought 4/10 [CONSTRAINT B]: Solutions satisfying B: {Y, Z, W}
+Thought 5/10 [CONSTRAINT C]: Solutions satisfying C: {X, Z}
+Thought 6/10 [INTERSECTION]: Z satisfies all
+Thought 7/10: Verify Z feasible
+Thought 8/10 [BRANCH if infeasible]: Relax which constraint?
+Thought 9/10: Decision on constraint relaxation if needed
+Thought 10/10 [FINAL]: Optimal solution given constraints
+```
+
+**Use for**: Optimization problems, multi-criteria decisions.
+**Pattern**: Analyze independently → Find intersection → Verify feasibility.

package/agentic/antigravity/.agents/skills/sequential-thinking/references/advanced-techniques.md

@@ -0,0 +1,76 @@
+# Advanced Sequential Thinking Techniques
+
+Complex problem-solving patterns.
+
+## Spiral Refinement
+
+Return to concepts with progressively deeper understanding.
+
+```
+Thought 1/7: Initial design (surface)
+Thought 2/7: Discover constraint A
+Thought 3/7: Refine for A
+Thought 4/7: Discover constraint B
+Thought 5/7: Refine for both A and B
+Thought 6/7: Integration reveals edge case
+Thought 7/7: Final design addressing all constraints
+```
+
+**Use for**: Complex systems where constraints emerge iteratively.
+**Key**: Each return is refinement, not restart.
+
+## Hypothesis-Driven Investigation
+
+Systematic hypothesis generation and testing.
+
+```
+Thought 1/6: Observe symptoms
+Thought 2/6 [HYPOTHESIS]: Explanation X
+Thought 3/6 [VERIFICATION]: Test X—partial match
+Thought 4/6 [REFINED HYPOTHESIS]: Adjusted Y
+Thought 5/6 [VERIFICATION]: Test Y—confirmed
+Thought 6/6 [FINAL]: Solution based on verified Y
+```
+
+**Use for**: Debugging, root cause analysis, diagnostics.
+**Pattern**: Generate → Test → Refine → Re-test loop.
+
+## Multi-Branch Convergence
+
+Explore alternatives, then synthesize best approach.
+
+```
+Thought 2/8: Multiple viable approaches
+Thought 3/8 [BRANCH A]: Approach A benefits
+Thought 4/8 [BRANCH A]: Approach A drawbacks
+Thought 5/8 [BRANCH B]: Approach B benefits
+Thought 6/8 [BRANCH B]: Approach B drawbacks
+Thought 7/8 [CONVERGENCE]: Hybrid combining A's X with B's Y
+Thought 8/8 [FINAL]: Hybrid superior to either alone
+```
+
+**Use for**: Complex decisions where neither option clearly best.
+**Key**: Convergence often yields better solution than either branch.
+
+## Progressive Context Deepening
+
+Build understanding in layers from abstract to concrete.
+
+```
+Thought 1/9: High-level problem
+Thought 2/9: Identify major components
+Thought 3/9: Zoom into component A (detailed)
+Thought 4/9: Zoom into component B (detailed)
+Thought 5/9: Identify A-B interactions
+Thought 6/9: Discover emergent constraint
+Thought 7/9 [REVISION of 3-4]: Adjust for interaction
+Thought 8/9: Verify complete system
+Thought 9/9 [FINAL]: Integrated solution
+```
+
+**Use for**: System design, architecture, integration problems.
+**Pattern**: Abstract → Components → Details → Interactions → Integration.
+
+## Reference
+
+See `advanced-strategies.md` for: Uncertainty Management, Revision Cascade Management, Meta-Thinking Calibration, Parallel Constraint Satisfaction.