@thanhthi2895/luna-ai 2.16.2

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

@@ -0,0 +1,122 @@
+---
+name: lu:cook
+author: luna
+description: "Implement features end-to-end. Pass task description for simple tasks (cook handles planning internally), or pass plan.md path to execute existing plan phases directly."
+version: 2.1.1
+argument-hint: "[task|plan-path] [--interactive|--fast|--parallel|--auto|--no-test]"
+---
+
+# Cook - Smart Feature Implementation
+
+End-to-end implementation with automatic workflow detection.
+
+**Principles:** YAGNI, KISS, DRY | Token efficiency | Concise reports
+
+## Usage
+
+```
+/cook <natural language task OR plan path>
+```
+
+**IMPORTANT:** If no flag is provided, the skill will use the `interactive` mode by default for the workflow.
+
+**Optional flags to select the workflow mode:**
+
+- `--interactive`: Full workflow with user input (**default**)
+- `--fast`: Skip research, ccc-first discovery→plan→code
+- `--parallel`: Multi-agent execution
+- `--no-test`: Skip testing step
+- `--auto`: Auto-approve all steps
+
+**Example:**
+
+```
+/cook "Add user authentication to the app" --fast
+/cook path/to/plan.md --auto
+```
+
+## Smart Intent Detection
+
+| Input Pattern                     | Detected Mode | Behavior                       |
+| --------------------------------- | ------------- | ------------------------------ |
+| Path to `plan.md` or `phase-*.md` | code          | Execute existing plan          |
+| Contains "fast", "quick"          | fast          | Skip research, scout→plan→code |
+| Contains "trust me", "auto"       | auto          | Auto-approve all steps         |
+| Lists 3+ features OR "parallel"   | parallel      | Multi-agent execution          |
+| Contains "no test", "skip test"   | no-test       | Skip testing step              |
+| Default                           | interactive   | Full workflow with user input  |
+
+See `references/intent-detection.md` for detection logic.
+
+## Workflow Overview
+
+```
+[Intent Detection] → [Research?] → [Review] → [Plan] → [Review] → [Implement] → [Review] → [Test?] → [Review] → [Finalize]
+```
+
+**Default (non-auto):** Stops at `[Review]` gates for human approval before each major step.
+**Auto mode (`--auto`):** Skips human review gates, implements all phases continuously.
+**Claude Tasks:** Utilize all these tools `TaskCreate`, `TaskUpdate`, `TaskGet` and `TaskList` during implementation step.
+
+Code-search routing: start semantic discovery with `ccc search`; use `lu:scout` only for broad file discovery; use lexical tools (Glob/Grep/find_by_name/grep_search) for deterministic narrowing; run `ccc index` when stale or after major code changes.
+
+| Mode        | Research | Testing | Review Gates                   | Phase Progression      |
+| ----------- | -------- | ------- | ------------------------------ | ---------------------- |
+| interactive | ✓        | ✓       | **User approval at each step** | One at a time          |
+| auto        | ✓        | ✓       | Auto if score≥9.5              | All at once (no stops) |
+| fast        | ✗        | ✓       | **User approval at each step** | One at a time          |
+| parallel    | Optional | ✓       | **User approval at each step** | Parallel groups        |
+| no-test     | ✓        | ✗       | **User approval at each step** | One at a time          |
+| code        | ✗        | ✓       | **User approval at each step** | Per plan               |
+
+## Step Output Format
+
+```
+✓ Step [N]: [Brief status] - [Key metrics]
+```
+
+## Blocking Gates (Non-Auto Mode)
+
+Human review required at these checkpoints (skipped with `--auto`):
+
+- **Post-Research:** Review findings before planning
+- **Post-Plan:** Approve plan before implementation
+- **Post-Implementation:** Approve code before testing
+- **Post-Testing:** 100% pass + approve before finalize
+
+**Always enforced (all modes):**
+
+- **Testing:** 100% pass required (unless no-test mode)
+- **Code Review:** User approval OR auto-approve (score≥9.5, 0 critical)
+- **Finalize (MANDATORY - never skip):**
+  1. `project-manager` subagent → run full plan sync-back (all completed tasks/steps across all `phase-XX-*.md`, not only current phase), then update `plan.md` status/progress
+  2. `docs-manager` subagent → update `./docs` if changes warrant
+  3. `TaskUpdate` → mark all Claude Tasks complete after sync-back verification
+  4. Invoke `archive` skill to move plan to `plans/archive/` and clear active plan pointer
+  5. Ask user if they want to commit via `git-manager` subagent
+
+## Required Subagents (MANDATORY)
+
+| Phase    | Subagent                                         | Requirement           |
+| -------- | ------------------------------------------------ | --------------------- |
+| Research | `researcher`                                     | Optional in fast/code |
+| Scout    | `scout`                                          | Optional in code      |
+| Plan     | `planner`                                        | Optional in code      |
+| UI Work  | `ui-ux-designer`                                 | If frontend work      |
+| Testing  | `tester`, `debugger`                             | **MUST** spawn        |
+| Review   | `code-reviewer`                                  | **MUST** spawn        |
+| Finalize | `project-manager`, `docs-manager`, `git-manager` | **MUST** spawn all 3  |
+
+**CRITICAL ENFORCEMENT:**
+
+- Steps 4, 5, 6 **MUST** use Task tool to spawn subagents
+- DO NOT implement testing, review, or finalization yourself - DELEGATE
+- If workflow ends with 0 Task tool calls, it is INCOMPLETE
+- Pattern: `Task(subagent_type="[type]", prompt="[task]", description="[brief]")`
+
+## References
+
+- `references/intent-detection.md` - Detection rules and routing logic
+- `references/workflow-steps.md` - Detailed step definitions for all modes
+- `references/review-cycle.md` - Interactive and auto review processes
+- `references/subagent-patterns.md` - Subagent invocation patterns

package/agentic/antigravity/.agents/skills/cook/references/intent-detection.md

@@ -0,0 +1,101 @@
+# Intent Detection Logic
+
+Detect user intent from natural language and route to appropriate workflow.
+
+## Detection Algorithm
+
+```
+FUNCTION detectMode(input):
+  # Priority 1: Explicit flags (override all)
+  IF input contains "--fast": RETURN "fast"
+  IF input contains "--parallel": RETURN "parallel"
+  IF input contains "--auto": RETURN "auto"
+  IF input contains "--no-test": RETURN "no-test"
+
+  # Priority 2: Plan path detection
+  IF input matches path pattern (./plans/*, plan.md, phase-*.md):
+    RETURN "code"
+
+  # Priority 3: Keyword detection (case-insensitive)
+  keywords = lowercase(input)
+
+  IF keywords contains ["fast", "quick", "rapidly", "asap"]:
+    RETURN "fast"
+
+  IF keywords contains ["trust me", "auto", "yolo", "just do it"]:
+    RETURN "auto"
+
+  IF keywords contains ["no test", "skip test", "without test"]:
+    RETURN "no-test"
+
+  # Priority 4: Complexity detection
+  features = extractFeatures(input)  # comma-separated or "and"-joined items
+  IF count(features) >= 3 OR keywords contains "parallel":
+    RETURN "parallel"
+
+  # Default: interactive workflow
+  RETURN "interactive"
+```
+
+## Feature Extraction
+
+Detect multiple features from natural language:
+
+```
+"implement auth, payments, and notifications" → ["auth", "payments", "notifications"]
+"add login + signup + password reset"        → ["login", "signup", "password reset"]
+"create dashboard with charts and tables"    → single feature (dashboard)
+```
+
+**Parallel trigger:** 3+ distinct features = parallel mode
+
+## Mode Behaviors
+
+| Mode | Skip Research | Skip Test | Review Gates | Auto-Approve | Parallel Exec |
+|------|---------------|-----------|--------------|--------------|---------------|
+| interactive | ✗ | ✗ | **Yes (stops)** | ✗ | ✗ |
+| auto | ✗ | ✗ | **No (skips)** | ✓ (score≥9.5) | ✓ (all phases) |
+| fast | ✓ | ✗ | Yes (stops) | ✗ | ✗ |
+| parallel | Optional | ✗ | Yes (stops) | ✗ | ✓ |
+| no-test | ✗ | ✓ | Yes (stops) | ✗ | ✗ |
+| code | ✓ | ✗ | Yes (stops) | Per plan | Per plan |
+
+**Review Gates:** Human approval checkpoints between major steps (see `workflow-steps.md`).
+- All modes EXCEPT `auto` stop at review gates for human approval.
+- `auto` mode is the only mode that runs continuously without stopping.
+
+## Examples
+
+```
+"/cook implement user auth"
+→ Mode: interactive (default, stops at review gates)
+
+"/cook plans/260120-auth/phase-02-api.md"
+→ Mode: code (path detected, stops at review gates)
+
+"/cook quick fix for the login bug"
+→ Mode: fast ("quick" keyword, stops at review gates)
+
+"/cook implement auth, payments, notifications, shipping"
+→ Mode: parallel (4 features, stops at review gates)
+
+"/cook implement dashboard --fast"
+→ Mode: fast (explicit flag, stops at review gates)
+
+"/cook implement everything --auto"
+→ Mode: auto (NO STOPS, implements all phases continuously)
+
+"/cook implement dashboard trust me"
+→ Mode: auto ("trust me" keyword, NO STOPS)
+```
+
+**Note:** Only `--auto` flag or "trust me"/"auto"/"yolo" keywords enable continuous execution.
+
+## Conflict Resolution
+
+When multiple signals detected, priority order:
+1. Explicit flags (`--fast`, `--auto`, etc.)
+2. Path detection (plan files)
+3. Keywords in text
+4. Feature count analysis
+5. Default (interactive)

package/agentic/antigravity/.agents/skills/cook/references/review-cycle.md

@@ -0,0 +1,75 @@
+# Code Review Cycle
+
+Interactive review-fix cycle used in code workflows.
+
+## Interactive Cycle (max 3 cycles)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings, suggestions
+
+  2. DISPLAY FINDINGS:
+     ┌─────────────────────────────────────────┐
+     │ Code Review Results: [score]/10         │
+     ├─────────────────────────────────────────┤
+     │ Summary: [what implemented], tests      │
+     │ [X/X passed]                            │
+     ├─────────────────────────────────────────┤
+     │ Critical Issues ([N]): MUST FIX         │
+     │  - [issue] at [file:line]               │
+     │ Warnings ([N]): SHOULD FIX              │
+     │  - [issue] at [file:line]               │
+     │ Suggestions ([N]): NICE TO HAVE         │
+     │  - [suggestion]                         │
+     └─────────────────────────────────────────┘
+
+  3. Ask user in response (header: "Review & Approve"):
+     IF critical_count > 0:
+       - "Fix critical issues" → fix, re-run tests, cycle++, LOOP
+       - "Fix all issues" → fix all, re-run tests, cycle++, LOOP
+       - "Approve anyway" → PROCEED
+       - "Abort" → stop
+     ELSE:
+       - "Approve" → PROCEED
+       - "Fix warnings/suggestions" → fix, cycle++, LOOP
+       - "Abort" → stop
+
+  4. IF cycle >= 3 AND user selects fix:
+     → "⚠ 3 review cycles completed. Final decision required."
+     → Ask user: "Approve with noted issues" / "Abort workflow"
+```
+
+## Auto-Handling Cycle (for auto modes)
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → score, critical_count, warnings
+
+  2. IF score >= 9.5 AND critical_count == 0:
+     → Auto-approve, PROCEED
+
+  3. ELSE IF critical_count > 0 AND cycle < 3:
+     → Auto-fix critical issues
+     → Re-run tester
+     → cycle++, LOOP
+
+  4. ELSE IF critical_count > 0 AND cycle >= 3:
+     → ESCALATE TO USER
+
+  5. ELSE (no critical, score < 9.5):
+     → Approve with warnings logged, PROCEED
+```
+
+## Critical Issues Definition
+- Security: XSS, SQL injection, OWASP vulnerabilities
+- Performance: bottlenecks, inefficient algorithms
+- Architecture: violations of patterns, coupling
+- Principles: YAGNI, KISS, DRY violations
+
+## Output Formats
+- Waiting: `⏸ Step 4: Code reviewed - [score]/10 - WAITING for approval`
+- After fix: `✓ Step 4: [old]/10 → Fixed [N] issues → [new]/10 - Approved`
+- Auto-approved: `✓ Step 4: Code reviewed - 9.8/10 - Auto-approved`
+- Approved: `✓ Step 4: Code reviewed - [score]/10 - User approved`

package/agentic/antigravity/.agents/skills/cook/references/subagent-patterns.md

@@ -0,0 +1,76 @@
+# Execution Patterns
+
+Standard patterns for executing work in skill workflows.
+
+## Research
+
+```
+search_web(query="[topic]")
+read_url_content(Url="https://...")
+view_file(AbsolutePath="[relevant local file]")
+```
+- Run multiple searches in parallel for different angles
+- Keep reports ≤150 lines with citations
+
+## Scout / File Exploration
+
+```
+find_by_name(SearchDirectory="./src", Pattern="*[keyword]*")
+grep_search(SearchPath="./src", Query="[keyword]")
+view_file(AbsolutePath="[file path]")
+```
+
+## Planning
+
+- Read research outputs
+- Create `plan.md` + `phase-XX-*.md` files directly using `write_to_file`
+
+## UI Implementation
+
+- Implement frontend work directly in main context
+- Use `write_to_file` / `replace_file_content`
+- Follow `./docs/` design guidelines
+
+## Testing
+
+```bash
+# Run via run_command:
+npm test
+npm run test:unit
+pytest
+```
+- Analyze failures directly via `view_file` + `grep_search`
+
+## Code Review
+
+- Review changed files directly via `view_file`
+- Check: security, performance, YAGNI/KISS/DRY
+- Return score (X/10), critical issues, warnings, suggestions
+
+## Project Management (plan sync)
+
+- Read all `phase-XX-*.md` files via `view_file`
+- Mark completed items `[ ] → [x]` via `replace_file_content`
+- Update `plan.md` status/progress inline
+
+## Documentation Update
+
+```
+write_to_file / replace_file_content → ./docs/<file>.md
+```
+
+## Git Operations
+
+```bash
+# All via run_command:
+git add <file1> <file2> ...
+git diff --cached --stat
+git commit -m "type(scope): description"
+git push -u origin <branch>
+```
+
+## Implementation (fullstack)
+
+- Implement phases directly in main context
+- Use `write_to_file` / `replace_file_content`
+- Respect file ownership boundaries between phases

package/agentic/antigravity/.agents/skills/cook/references/workflow-steps.md

@@ -0,0 +1,154 @@
+# Unified Workflow Steps
+
+All modes share core steps with mode-specific variations.
+
+## Step 0: Intent Detection & Setup
+
+1. Parse input with `intent-detection.md` rules
+2. Log detected mode: `✓ Step 0: Mode [X] - [reason]`
+3. If mode=code: detect plan path, set active plan
+
+**Output:** `✓ Step 0: Mode [interactive|auto|fast|parallel|no-test|code] - [detection reason]`
+
+## Step 1: Research (skip if fast/code mode)
+
+**Interactive/Auto:**
+- Run multiple research passes via `search_web` + `read_url_content` in parallel
+- Start codebase search with `ccc search`; use `lu:scout` only for broad discovery; use `find_by_name` + `grep_search` for deterministic narrowing
+- Keep reports ≤150 lines
+
+**Parallel:**
+- Optional: max 2 research angles if complex
+
+**Output:** `✓ Step 1: Research complete - [N] reports gathered`
+
+### [Review Gate 1] Post-Research (skip if auto mode)
+- Present research summary to user
+- Ask in response: "Proceed to planning?" / "Request more research" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 2: Planning
+
+**Interactive/Auto/No-test:**
+- Use `planner` agent with research context
+- Create `plan.md` + `phase-XX-*.md` files
+
+**Fast:**
+- Use `/plan --fast` with scout results only
+- Minimal planning, focus on action
+
+**Parallel:**
+- Use `/plan --parallel` for dependency graph + file ownership matrix
+
+**Code:**
+- Skip — plan already exists
+- Parse existing plan for phases
+
+**Output:** `✓ Step 2: Plan created - [N] phases`
+
+### [Review Gate 2] Post-Plan (skip if auto mode)
+- Present plan overview with phases
+- Ask in response: "Validate the plan or approve to start implementation?" — "Validate" / "Approve" / "Abort" / "Other" (request revisions)
+  - "Validate": run `lu:plan validate`
+  - "Approve": continue to implementation
+  - "Abort": stop the workflow
+  - "Other": revise plan based on user feedback
+- **Auto mode:** Skip this gate
+
+## Step 3: Implementation
+
+**Implementation:**
+1. Read plan phases — all `phase-XX-*.md` via `view_file`
+2. Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
+3. Use `lu:ui-ux-pro-max` for frontend work
+4. Use `lu:ai-multimodal` for image assets
+5. Run type checking after each file via `run_command`
+
+**Output:** `✓ Step 3: Implemented [N] files`
+
+### [Review Gate 3] Post-Implementation (skip if auto mode)
+- Present implementation summary (files changed, key changes)
+- Ask in response: "Proceed to testing?" / "Request implementation changes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 4: Testing (skip if no-test mode)
+
+**All modes (except no-test):**
+- Write tests: happy path, edge cases, errors
+- Run test suite via `run_command` (e.g. `npm test`, `pytest`)
+- If failures: debug directly via `view_file` + `grep_search` → fix → re-run
+- Must achieve 100% pass rate before proceeding
+
+**Output:** `✓ Step 4: Tests [X/X passed]`
+
+### [Review Gate 4] Post-Testing (skip if auto mode)
+- Present test results summary
+- Ask in response: "Proceed to code review?" / "Request test fixes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 5: Code Review
+
+**All modes - MANDATORY:**
+- Review changed files directly via `view_file` + `grep_search`
+- Check: security, performance, YAGNI/KISS/DRY
+- Return score (X/10), critical issues, warnings, suggestions
+
+**Interactive/Parallel/Code/No-test:**
+- Interactive cycle (max 3): see `review-cycle.md`
+- Requires user approval
+
+**Auto:**
+- Auto-approve if score≥9.5 AND 0 critical
+- Auto-fix critical (max 3 cycles)
+- Escalate to user after 3 failed cycles
+
+**Fast:**
+- Simplified review, no fix loop
+- User approves or aborts
+
+**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved]`
+
+## Step 6: Finalize
+
+**All modes - MANDATORY (NON-NEGOTIABLE):**
+1. Plan sync-back — read all phase files, mark completed items:
+   - Sweep all `phase-XX-*.md` files via `view_file` (also check `phases/` subdirectory)
+   - Mark every completed item `[ ] → [x]` via `replace_file_content`
+   - Update `plan.md` status/progress (`pending`/`in-progress`/`completed`)
+2. Docs update — if changes impact `./docs/`, update via `replace_file_content`
+3. Invoke `lu:archive` skill to move plan to `plans/archive/`
+4. Onboarding check (API keys, env vars)
+5. Git commit — run via `run_command`:
+   ```bash
+   git add <changed files>
+   git commit -m "type(scope): description"
+   git push -u origin <branch>
+   ```
+
+**Auto mode:** Continue to next phase automatically, start from **Step 3**.
+**Others:** Ask user before next phase
+
+**Output:** `✓ Step 6: Finalized - sync-back complete - committed`
+
+## Mode-Specific Flow Summary
+
+Legend: `[R]` = Review Gate (human approval required)
+
+```
+interactive: 0 → 1 → [R] → 2 → [R] → 3 → [R] → 4 → [R] → 5(user) → 6
+auto:        0 → 1 → 2 → 3 → 4 → 5(auto) → 6 → next phase (NO stops)
+fast:        0 → skip → 2(fast) → [R] → 3 → [R] → 4 → [R] → 5(simple) → 6
+parallel:    0 → 1? → [R] → 2(parallel) → [R] → 3(multi-agent) → [R] → 4 → [R] → 5(user) → 6
+no-test:     0 → 1 → [R] → 2 → [R] → 3 → [R] → skip → 5(user) → 6
+code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6
+```
+
+**Key difference:** `auto` mode is the ONLY mode that skips all review gates.
+
+## Critical Rules
+
+- Never skip steps without mode justification
+- Step 4: run tests via `run_command`, debug via `view_file` + `grep_search`
+- Step 5: review directly via `view_file` + `grep_search`
+- Step 6: sync plan via `replace_file_content`, git via `run_command`
+- All step outputs follow format: `✓ Step [N]: [status] - [metrics]`

package/agentic/antigravity/.agents/skills/create-skill/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: lu:create-skill
+author: luna
+description: Create new Luna skills with proper structure, sync to ~/.gemini/antigravity/skills/, and register in GEMINI.md. Use when adding custom skills, extending Luna capabilities, building new workflows.
+argument-hint: "[skill-name or description]"
+---
+
+# Create Skill
+
+Scaffold, write, sync, and register new `lu:` skills end-to-end.
+
+**Scope:** Creates `lu:` skills in `agentic/antigravity/.agents/skills/`, syncs via hardlinks to `~/.gemini/antigravity/skills/`, registers in GEMINI.md.
+Does NOT handle: `npx skills` marketplace, plugin distribution.
+
+## Workflow
+
+### Step 1 — Gather requirements
+
+Ask the user in your response:
+- **Skill name** (kebab-case, e.g., `my-skill`)
+- **Purpose** (1-2 sentences: what it does)
+- **Trigger phrases** (when should it auto-activate?)
+- **Resources needed**: scripts? references? local config file?
+
+### Step 2 — Scaffold directory
+
+```bash
+node ~/.gemini/antigravity/skills/create-skill/scripts/scaffold.cjs <skill-name> [--local-config] [--scripts] [--references]
+```
+
+Creates:
+- `agentic/antigravity/.agents/skills/<name>/SKILL.md` (template with `lu:` prefix)
+- Optional: `references/`, `scripts/`, `<name>.local.example.json`
+
+### Step 3 — Write SKILL.md
+
+Follow `references/luna-skill-writing-guide.md` for patterns and conventions.
+
+Key rules:
+- Frontmatter: `name: lu:<name>`, `author: luna`, description < 200 chars
+- Body: under 150 lines, imperative form ("To do X, run Y")
+- No duplication: info in SKILL.md OR references, never both
+
+### Step 4 — Sync to ~/.gemini/antigravity/skills/
+
+```bash
+node ~/.gemini/antigravity/skills/create-skill/scripts/sync.cjs <skill-name>
+```
+
+Hardlinks all files from `agentic/antigravity/.agents/skills/<name>/` → `~/.gemini/antigravity/skills/<name>/`.
+Same inode = edits to either location are instantly reflected.
+
+### Step 5 — Register in GEMINI.md
+
+Update `agentic/antigravity/.agents/GEMINI.md`:
+1. Add to **Skills Catalog** section (update count + add entry)
+2. Add trigger row to **How to Use Skills** table
+
+Then sync global config:
+```bash
+cp agentic/antigravity/.agents/GEMINI.md ~/.gemini/antigravity/GEMINI.md
+```
+
+### Step 6 — Validate
+
+```bash
+node ~/.gemini/antigravity/skills/create-skill/scripts/validate.cjs <skill-name>
+```
+
+Checks: frontmatter, description length ≤200 chars, SKILL.md ≤150 lines, hardlink integrity.
+
+## Local Config (Optional)
+
+For skills needing user-specific config (like `clickup-task`):
+
+Use `--local-config` flag in Step 2. Creates `<name>.local.example.json`.
+Instruct users: `cp <name>.local.example.json <name>.local.json` and fill in values.
+Add `*.local.json` to `.gitignore`.
+
+## References
+
+- `references/luna-skill-writing-guide.md` — SKILL.md patterns, frontmatter, trigger phrases
+- `references/sync-and-registration.md` — hardlink sync + GEMINI.md update details
+
+## Security
+
+- Never expose API keys or secrets from local config files
+- Refuse to create skills enabling destructive or unauthorized actions
+- Keep `.local.json` files out of version control