@thanhthi2895/luna-ai 2.16.2

package/agentic/claude/.claude/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/claude/.claude/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/claude/.claude/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.

package/agentic/claude/.claude/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/claude/.claude/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 `~/.claude/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 `~/.claude/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/claude/.claude/skills/test/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: lu:test
+author: luna
+description: "Run unit, integration, e2e, and UI tests. Use for test execution, coverage analysis, build verification, visual regression, and QA reports."
+version: 1.0.0
+argument-hint: "[context] OR ui [url]"
+---
+
+# Testing & Quality Assurance
+
+Comprehensive testing framework covering unit/integration/e2e tests, UI/visual testing, coverage analysis, and structured QA reporting.
+
+## Default (No Arguments)
+
+If invoked without arguments, use `AskUserQuestion`:
+
+| Operation | Description |
+|-----------|-------------|
+| `(default)` | Run unit/integration/e2e tests |
+| `ui` | Run UI tests on a website |
+
+## Core Principle
+
+**NEVER IGNORE FAILING TESTS.** Fix root causes, not symptoms. No mocks/cheats to pass builds.
+
+## When to Use
+
+- **After implementation**: Validate new features or bug fixes
+- **Coverage checks**: Ensure coverage meets project thresholds (80%+)
+- **UI verification**: Visual regression, responsive layout, accessibility
+- **Build validation**: Verify build process, CI/CD compatibility
+- **Pre-commit/push**: Final quality gate
+
+## Workflows
+
+### 1. Code Testing (`references/test-execution-workflow.md`)
+Execute test suites, analyze results, generate coverage. Supports JS/TS (Jest/Vitest/Mocha), Python (pytest), Go, Rust, Flutter.
+
+**Load when:** Running unit/integration/e2e tests, checking coverage
+
+### 2. UI Testing (`references/ui-testing-workflow.md`)
+Browser-based visual testing via `chrome-devtools` skill. Screenshots, responsive checks, accessibility, console errors.
+
+**Load when:** Visual regression testing, UI bugs, responsive layout checks
+
+### 3. Report Format (`references/report-format.md`)
+Structured QA report template: results overview, coverage metrics, failed tests, recommendations.
+
+**Load when:** Generating test summary reports
+
+## Working Process
+
+1. Identify testing scope from recent changes
+2. Run typecheck/analyze commands first (catch syntax errors early)
+3. Execute appropriate test suites
+4. Analyze results — focus on failures
+5. Generate coverage reports if applicable
+6. For frontend: use `chrome-devtools` skill for UI testing
+7. Produce structured summary report
+
+## Tools Integration
+
+- **Test runners**: Jest, Vitest, pytest, go test, cargo test, flutter test
+- **Coverage**: Istanbul/c8, pytest-cov, go cover
+- **Browser**: `chrome-devtools` skill for visual testing
+- **Debugging**: `debugger` skill when tests reveal bugs requiring investigation
+- **Analysis**: `sequential-thinking` skill for complex test failure analysis
+
+## Quality Standards
+
+- All critical paths must have test coverage
+- Validate happy path AND error scenarios
+- Ensure test isolation — no interdependencies
+- Tests must be deterministic and reproducible
+- Never ignore failing tests to pass the build