@thanhthi2895/luna-ai 2.16.2

package/agentic/antigravity/.agents/skills/problem-solving/references/simplification-cascades.md

@@ -0,0 +1,80 @@
+# Simplification Cascades
+
+Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."
+
+## Core Principle
+
+**Everything is a special case of...** collapses complexity dramatically.
+
+One powerful abstraction > ten clever hacks.
+
+## When to Use
+
+| Symptom | Action |
+|---------|--------|
+| Same thing implemented 5+ ways | Abstract the common pattern |
+| Growing special case list | Find the general case |
+| Complex rules with exceptions | Find rule with no exceptions |
+| Excessive config options | Find defaults working for 95% |
+
+## The Pattern
+
+**Look for:**
+- Multiple implementations of similar concepts
+- Special case handling everywhere
+- "We need to handle A, B, C, D differently..."
+- Complex rules with many exceptions
+
+**Ask:** "What if they're all the same thing underneath?"
+
+## Examples
+
+### Example 1: Stream Abstraction
+- **Before:** Separate handlers for batch/real-time/file/network data
+- **Insight:** "All inputs are streams - just different sources"
+- **After:** One stream processor, multiple stream sources
+- **Eliminated:** 4 separate implementations
+
+### Example 2: Resource Governance
+- **Before:** Session tracking, rate limiting, file validation, connection pooling (all separate)
+- **Insight:** "All are per-entity resource limits"
+- **After:** One ResourceGovernor with 4 resource types
+- **Eliminated:** 4 custom enforcement systems
+
+### Example 3: Immutability
+- **Before:** Defensive copying, locking, cache invalidation, temporal coupling
+- **Insight:** "Treat everything as immutable data + transformations"
+- **After:** Functional programming patterns
+- **Eliminated:** Entire classes of synchronization problems
+
+## Process
+
+1. **List variations** - What's implemented multiple ways?
+2. **Find essence** - What's the same underneath?
+3. **Extract abstraction** - What's the domain-independent pattern?
+4. **Test fit** - Do all cases fit cleanly?
+5. **Measure cascade** - How many things become unnecessary?
+
+## Red Flags
+
+Signs you're missing a cascade:
+- "Just need to add one more case..." (repeating forever)
+- "These are similar but different" (maybe they're the same?)
+- Refactoring feels like whack-a-mole (fix one, break another)
+- Growing configuration file
+- "Don't touch that, it's complicated" (complexity hiding pattern)
+
+## Success Metrics
+
+- **10x wins, not 10% improvements**
+- Measure in "how many things can we delete?"
+- Lines of code removed > lines added
+- Configuration options eliminated
+- Special cases unified
+
+## Remember
+
+- The pattern is usually already there, just needs recognition
+- Valid cascades feel obvious in retrospect
+- Test with "can this handle all existing cases?"
+- Document the insight for future reference

package/agentic/antigravity/.agents/skills/problem-solving/references/when-stuck.md

@@ -0,0 +1,72 @@
+# When Stuck - Problem-Solving Dispatch
+
+Different stuck-types need different techniques. Match stuck-symptom to technique.
+
+## Dispatch Flowchart
+
+```
+YOU'RE STUCK
+│
+├─ Complexity spiraling? Same thing 5+ ways? Growing special cases?
+│  └─→ USE: Simplification Cascades
+│
+├─ Can't find fitting approach? Conventional solutions inadequate?
+│  └─→ USE: Collision-Zone Thinking
+│
+├─ Same issue different places? Reinventing wheels? Feels familiar?
+│  └─→ USE: Meta-Pattern Recognition
+│
+├─ Solution feels forced? "Must be done this way"? Stuck on assumptions?
+│  └─→ USE: Inversion Exercise
+│
+├─ Will this work at production? Edge cases unclear? Unsure of limits?
+│  └─→ USE: Scale Game
+│
+└─ Code broken? Wrong behavior? Test failing?
+   └─→ USE: Debugging skill (systematic-debugging)
+```
+
+## Stuck-Type → Technique Map
+
+| How You're Stuck | Symptom Details | Use This |
+|------------------|-----------------|----------|
+| **Complexity spiraling** | Same thing 5+ ways, growing special cases, excessive if/else | simplification-cascades.md |
+| **Need innovation** | Conventional inadequate, can't find fitting approach, need breakthrough | collision-zone-thinking.md |
+| **Recurring patterns** | Same issue different places, reinventing wheels, déjà vu feeling | meta-pattern-recognition.md |
+| **Forced by assumptions** | "Must be done this way", can't question premise, forced solution | inversion-exercise.md |
+| **Scale uncertainty** | Production unclear, edge cases unknown, unsure of limits | scale-game.md |
+| **Code broken** | Wrong behavior, test failing, unexpected output | debugging skill |
+
+## Process
+
+1. **Identify stuck-type** - What symptom matches above?
+2. **Load that technique** - Read the specific reference file
+3. **Apply technique** - Follow its process
+4. **Document attempt** - What worked/failed?
+5. **If still stuck** - Try different technique or combine
+
+## Combining Techniques
+
+Some problems need multiple techniques:
+
+- **Simplification + Meta-pattern** - Find pattern → simplify all instances
+- **Collision + Inversion** - Force metaphor → invert assumptions
+- **Scale + Simplification** - Test extremes → reveal what to eliminate
+- **Meta-pattern + Scale** - Universal pattern → test at extremes
+
+## When Nothing Works
+
+If no technique helps:
+1. **Reframe problem** - Are you solving the right problem?
+2. **Get fresh perspective** - Explain to someone else
+3. **Take break** - Distance often reveals solution
+4. **Simplify scope** - Solve smaller version first
+5. **Question constraints** - Are they real or assumed?
+
+## Remember
+
+- Match symptom to technique
+- One technique at a time
+- Combine if first doesn't work
+- Document what you tried
+- Not stuck forever, just temporarily

package/agentic/antigravity/.agents/skills/project-management/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: lu:project-management
+description: "Track progress, update plan statuses, manage plan files, generate reports, coordinate docs updates. Use for project oversight, status checks, plan completion, cross-session continuity."
+argument-hint: "[task: status, hydrate, sync, report]"
+---
+
+# Project Management
+
+Project oversight and coordination using persistent plan files.
+
+**Principles:** Token efficiency | Concise reports | Data-driven insights
+
+## When to Use
+
+- Checking project status or progress across plans
+- Updating plan statuses after feature completion
+- Hydrating/syncing plan files across sessions
+- Generating status reports or summaries
+- Coordinating documentation updates after milestones
+- Verifying task completeness against acceptance criteria
+- Cross-session resume of multi-phase work
+
+## Core Capabilities
+
+### 1. Plan File Operations
+Load: `references/task-operations.md`
+
+Task management in this skill means plan-file management, not session tasks.
+- Read `plan.md` and `phase-XX-*.md` via `view_file` to assess status
+- Update phase checkboxes (`[ ]` -> `[x]`) via `replace_file_content`
+- Keep YAML frontmatter status in sync with real completion
+- Use `run_command` for repository-wide scans/report generation when needed
+
+### 2. Cross-Session Resume
+Load: `references/hydration-workflow.md`
+
+- Read unchecked `[ ]` items from plan files to resume context
+- Implement and keep progress reflected in phase files
+- Reconcile completed work: update `[ ]` → `[x]`, update YAML frontmatter status
+
+### 3. Progress Tracking
+Load: `references/progress-tracking.md`
+
+- Scan `./plans/*/plan.md` for active plans
+- Parse YAML frontmatter for status, priority, effort
+- Count `[x]` vs `[ ]` in phase files for completion %
+- Cross-reference completed work against planned tasks
+- Verify acceptance criteria met before marking complete
+
+### 4. Documentation Coordination
+Load: `references/documentation-triggers.md`
+
+Trigger `./docs` updates when:
+- Phase status changes, major features complete
+- API contracts change, architecture decisions made
+- Security patches applied, breaking changes occur
+
+Delegate to `docs-manager` subagent for actual updates.
+
+### 5. Status Reporting
+Load: `references/reporting-patterns.md`
+
+Generate reports: session summaries, plan completion, multi-plan overviews.
+- Use naming: `{reports-path}/pm-{date}-{time}-{slug}.md`
+- Sacrifice grammar for brevity; use tables over prose
+- List unresolved questions at end
+
+## Workflow
+
+```
+[Scan Plans] -> [Hydrate Context] -> [Track Progress] -> [Update Status] -> [Generate Report] -> [Trigger Doc Updates]
+```
+
+1. Read `plan.md` and all `phase-XX-*.md` files via `view_file`
+2. Hydrate context from unchecked plan items (`[ ]`)
+3. During work: keep checklist status current in phase files via `replace_file_content`
+4. On completion: run full-plan sync-back (all phase files, including backfill for earlier phases), then update YAML frontmatter
+5. Generate status report to reports directory
+6. Delegate doc updates if changes warrant
+
+## Mandatory Sync-Back Guard
+
+When updating plan status, NEVER mark only the currently active phase.
+
+1. Sweep all `phase-XX-*.md` files under the target plan directory.
+2. Reconcile every completed work item to phase metadata (`phase` / `phaseFile`) and phase checkboxes.
+3. Backfill stale checkboxes in earlier phases before marking later phases done.
+4. Update `plan.md` status/progress from real checkbox counts.
+5. If any completed task cannot be mapped to a phase file, report unresolved mappings and do not claim full completion.
+
+## Plan YAML Frontmatter
+
+All `plan.md` files MUST have:
+
+```yaml
+---
+title: Feature name
+status: in-progress  # pending | in-progress | completed
+priority: P1
+effort: medium
+branch: feature-branch
+tags: [auth, api]
+created: 2026-02-05
+---
+```
+
+Update `status` when plan state changes.
+
+## Quality Standards
+
+- All analysis data-driven, referencing specific plans and reports
+- Focus on business value delivery and actionable insights
+- Highlight critical issues requiring immediate attention
+- Maintain traceability between requirements and implementation
+
+## Related Skills
+
+- `lu:plan` — Creates implementation plans (planning phase)
+- `lu:cook` — Implements plans (execution phase, invokes project-manager at finalize)
+- `lu:plans-kanban` — Visual dashboard for plan viewing

package/agentic/antigravity/.agents/skills/project-management/references/documentation-triggers.md

@@ -0,0 +1,58 @@
+# Documentation Triggers
+
+## When to Update Docs
+
+MUST update project documentation in `./docs` when:
+
+| Trigger | Which Docs | Action |
+|---------|-----------|--------|
+| Phase status changes | project-roadmap.md | Update progress %, milestone status |
+| Major feature complete | project-roadmap.md, codebase-summary.md | Add feature, update architecture |
+| Bug fix (significant) | project-roadmap.md | Document fix, severity, impact |
+| Security patch | project-roadmap.md, system-architecture.md | Record improvement |
+| API contract changes | system-architecture.md, code-standards.md | Update endpoints, schemas |
+| Architecture decision | system-architecture.md | Document decision + rationale |
+| Scope/timeline change | project-roadmap.md | Adjust phases, dates |
+| Dependencies updated | system-architecture.md | Record version changes |
+| Breaking changes | code-standards.md | Document migration path |
+
+## Documentation Files
+
+```
+./docs/
+├── project-overview-pdr.md     # Product requirements
+├── code-standards.md           # Coding conventions
+├── codebase-summary.md         # Architecture overview
+├── design-guidelines.md        # UI/UX standards
+├── deployment-guide.md         # Deploy procedures
+├── system-architecture.md      # System design
+└── project-roadmap.md          # Milestones & progress
+```
+
+## Update Protocol
+
+1. **Read current state:** Always read target doc before editing
+2. **Analyze reports:** Review agent reports in plan reports directory
+3. **Update content:** Modify progress %, statuses, dates, descriptions
+4. **Cross-reference:** Ensure consistency across docs
+5. **Validate:** Verify dates, versions, references accurate
+
+## Quality Standards
+
+- **Consistency:** Same formatting, versioning across all docs
+- **Accuracy:** Progress %, dates, statuses reflect reality
+- **Completeness:** Sufficient detail for stakeholder communication
+- **Timeliness:** Update within same session as significant changes
+- **Traceability:** Clear links between roadmap items and implementation
+
+## Update Execution
+
+Update docs directly via `replace_file_content` or `write_to_file`:
+
+```
+replace_file_content(
+  TargetFile="./docs/<file>.md",
+  TargetContent="...",
+  ReplacementContent="..."
+)
+```

package/agentic/antigravity/.agents/skills/project-management/references/hydration-workflow.md

@@ -0,0 +1,76 @@
+# Cross-Session Plan Resume
+
+## Flow Diagram
+
+```
+┌──────────────────┐  Hydrate   ┌───────────────────┐
+│ Plan Files       │ ─────────► │ Session Context   │
+│ (persistent)     │            │ (in-memory work)  │
+│ [ ] Phase 1      │            │ Remaining items   │
+│ [ ] Phase 2      │            │ Dependencies      │
+└──────────────────┘            └───────────────────┘
+                                        │ Work
+                                        ▼
+┌──────────────────┐  Sync-back ┌───────────────────┐
+│ Plan Files       │ ◄───────── │ File Updates      │
+│ (updated)        │            │ replace_file_...  │
+│ [x] Phase 1      │            │ Checklist changes │
+│ [ ] Phase 2      │            │ Frontmatter sync  │
+└──────────────────┘            └───────────────────┘
+```
+
+## Session Start: Hydration
+
+1. Read plan files: `plan.md` + `phase-XX-*.md`
+2. Identify unchecked `[ ]` items = remaining work
+3. Build a session work queue from unchecked items (phase, priority, effort, planDir, phaseFile)
+4. Track dependencies from phase ordering and checklist structure
+5. Already-checked `[x]` items = done, skip
+
+**Check first:** `view_file` current phase files to avoid duplicating completed checklist work.
+
+## During Work
+
+- Mark active checklist items as in progress in your session notes
+- Use `replace_file_content` to flip `[ ]` -> `[x]` immediately after completion
+- Parallel agents coordinate through shared plan files
+- Dependencies clear as upstream phase checkboxes are completed
+
+## Session End: Sync-Back
+
+1. Collect completed work items with metadata (`phase`, `phaseFile`, `planDir`).
+2. Sweep all `phase-XX-*.md` files in the target plan directory.
+3. Reconcile and backfill: update `[ ]` → `[x]` for all completed items across every phase file (including earlier phases).
+4. Update `plan.md` frontmatter: status field (pending → in-progress → completed).
+5. Update progress percentages in `plan.md` overview from real checkbox counts.
+6. Report unresolved mappings when completed items cannot be matched to a phase file.
+7. Git commit captures state transition for next session.
+
+## Cross-Session Resume
+
+When user runs `/lu:cook path/to/plan.md` in a new session:
+1. Read plan files with `view_file`
+2. Re-hydrate from unchecked `[ ]` items
+3. Already-checked `[x]` = done; only remaining items are queued
+4. Dependency chain reconstructed from phase ordering
+
+
+
+## YAML Frontmatter Sync
+
+Plan files MUST have frontmatter with these fields:
+
+```yaml
+---
+title: Feature name
+description: Brief description
+status: in-progress  # pending | in-progress | completed
+priority: P1
+effort: medium
+branch: feature-branch
+tags: [auth, api]
+created: 2026-02-05
+---
+```
+
+Update `status` field during sync-back when plan state changes.

package/agentic/antigravity/.agents/skills/project-management/references/progress-tracking.md

@@ -0,0 +1,94 @@
+# Progress Tracking
+
+## Plan Analysis Workflow
+
+1. **Read plans directory:** Glob `./plans/*/plan.md` to discover all plans
+2. **Parse YAML frontmatter:** Extract status, priority, effort, branch, tags
+3. **Scan phase files:** Count `[x]` (done) vs `[ ]` (remaining) in each phase
+4. **Reconcile completed tasks:** Ensure all completed task metadata is reflected in phase files (backfill stale earlier phases first)
+5. **Calculate progress:** `completed / total * 100` per plan
+6. **Cross-reference:** Compare plan tasks against actual implementation
+
+## Status Update Protocol
+
+### Plan-Level Status
+
+Update `plan.md` frontmatter `status` field:
+
+| Condition | Status |
+|-----------|--------|
+| No phases started | `pending` |
+| Any phase in progress | `in-progress` |
+| All phases complete | `completed` |
+
+### Phase-Level Status
+
+Each `phase-XX-*.md` tracks with checkboxes:
+- `[ ]` = pending
+- `[x]` = completed
+- Count ratio for progress percentage
+
+
+
+### Reconciliation Rule
+
+If a later phase is marked done while earlier phases still contain stale unchecked completed items, backfill earlier phases in the same sync pass before final status reporting.
+
+## Verification Checklist
+
+When verifying task completeness:
+
+1. **Acceptance criteria met?** — Check against plan requirements
+2. **Code quality validated?** — code-reviewer agent report available?
+3. **Tests passing?** — tester agent report confirms 100% pass?
+4. **Documentation updated?** — docs match implementation?
+5. **No regressions?** — Existing functionality intact?
+
+## Report Generation
+
+### Status Summary Template
+
+```markdown
+## Project Status: [Date]
+
+### Active Plans
+| Plan | Progress | Priority | Status | Branch |
+|------|----------|----------|--------|--------|
+| [name] | [X]% | P[N] | [status] | [branch] |
+
+### Completed This Session
+- [x] [description]
+
+### Blockers & Risks
+- [ ] [description] — [mitigation]
+
+### Next Steps
+1. [Priority action]
+2. [Follow-up]
+```
+
+### Detailed Report Template
+
+```markdown
+## [Plan Name] - Detailed Status
+
+### Achievements
+- Completed features, resolved issues, delivered value
+
+### Testing Status
+- Components needing validation, test scenarios, quality gates
+
+### Risk Assessment
+- Potential blockers, technical debt, mitigation strategies
+
+### Recommendations
+- Prioritized next steps, resource needs, timeline projections
+```
+
+## Metrics to Track
+
+- **Phase completion %** — How much of each phase is done
+- **Blocker count** — Open blockers preventing progress
+- **Dependency chain health** — Any circular or stale dependencies
+- **Time since last update** — Identify stale plans needing attention
+- **Test coverage** — Per-feature test pass rates

package/agentic/antigravity/.agents/skills/project-management/references/reporting-patterns.md

@@ -0,0 +1,94 @@
+# Reporting Patterns
+
+## Report Types
+
+### 1. Session Status Report
+
+Quick summary of work done in current session.
+
+```markdown
+## Session Report: [Date]
+
+### Work Completed
+- [x] [Task/feature description]
+- [x] [Task/feature description]
+
+### In Progress
+- [ ] [Task description] — [% complete, blocker if any]
+
+### Tasks Created
+- [N] tasks hydrated from [plan]
+- [M] completed, [K] remaining
+
+### Next Session
+1. [Priority item]
+2. [Follow-up item]
+```
+
+### 2. Plan Completion Report
+
+Comprehensive summary when a plan reaches completion.
+
+```markdown
+## Plan Complete: [Plan Name]
+
+### Summary
+- **Duration:** [start] → [end]
+- **Phases:** [N] completed
+- **Files changed:** [count]
+- **Tests:** [pass/total]
+
+### Achievements
+- [Feature/capability delivered]
+
+### Known Limitations
+- [Any caveats or future work needed]
+
+### Documentation Updates
+- [Which docs were updated]
+```
+
+### 3. Progress Report (Multi-Plan)
+
+Overview across all active plans.
+
+```markdown
+## Project Progress: [Date]
+
+| Plan | Status | Progress | Priority | Next Action |
+|------|--------|----------|----------|-------------|
+| [name] | [status] | [%] | P[N] | [action] |
+
+### Highlights
+- [Key achievement or milestone]
+
+### Risks
+- [Risk] — [Mitigation]
+
+### Blockers
+- [Blocker] — [Resolution path]
+```
+
+## Report Naming
+
+Use pattern from `## Naming` section injected by hooks:
+`{reports-path}/pm-{date}-{time}-{slug}.md`
+
+Example: `plans/reports/pm-260205-2221-auth-progress.md`
+
+## Report Generation Workflow
+
+1. Glob `./plans/*/plan.md` → scan all active plans
+2. `view_file plan.md` → check status + phase list for each
+3. Read phase files → count `[x]` vs `[ ]` checkboxes
+4. Compile metrics into report template
+5. Write to reports directory via `write_to_file`
+6. Highlight: achievements, blockers, risks, next steps
+
+## Concision Rules
+
+- Sacrifice grammar for brevity
+- Use tables over paragraphs where possible
+- List unresolved questions at end
+- Metrics > prose (use numbers, percentages)
+- Skip obvious context; focus on actionable insights

package/agentic/antigravity/.agents/skills/project-management/references/task-operations.md

@@ -0,0 +1,62 @@
+# Plan File Operations Reference
+
+Task management in Antigravity project-management means updating `plan.md` and `phase-XX-*.md` files.
+
+## Read Current Plan State
+
+Use `view_file` to inspect:
+- `plan.md` frontmatter (`status`, `priority`, `effort`)
+- phase checklists (`[ ]` pending, `[x]` completed)
+
+```
+view_file("plans/260205-auth/plan.md")
+view_file("plans/260205-auth/phase-02-api.md")
+```
+
+
+
+## Update Checklist Progress
+
+Use `replace_file_content` to mark completed work.
+
+```
+replace_file_content(
+  "plans/260205-auth/phase-02-api.md",
+  "- [ ] Add JWT validation middleware",
+  "- [x] Add JWT validation middleware"
+)
+```
+
+
+
+## Update Plan Frontmatter
+
+After checkbox updates, sync `plan.md` status with real progress:
+- `pending`: no completed items
+- `in-progress`: mixed `[ ]` and `[x]`
+- `completed`: all required items checked
+
+```
+replace_file_content(
+  "plans/260205-auth/plan.md",
+  "status: in-progress",
+  "status: completed"
+)
+```
+
+## Cross-Phase Reconciliation
+
+When closing a phase or plan:
+1. Sweep all `phase-XX-*.md` files in the plan directory.
+2. Backfill stale `[ ]` -> `[x]` for already delivered work.
+3. Recompute status/progress from checkbox counts.
+4. Update `plan.md` frontmatter to match actual completion.
+
+## Parallel Agent Coordination
+
+1. Assign each agent a phase or file scope.
+2. Each agent updates only designated checklist items.
+3. Merge all checklist updates into the same plan directory.
+4. Final pass reconciles all phase files and syncs `plan.md` status.
+
+Use `run_command` for repository scans or report generation, and keep plan markdown files as the canonical source of progress.