@alecsibilia/luca 13.0.0-alpha.1

package/dist/claude/skills/phase-research/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: phase-research
+description: Conduct comprehensive ecosystem research for niche or complex technical domains.
+---
+
+<main>
+# Luca Research Phase
+
+Comprehensive ecosystem research for niche/complex domains.
+
+**Arguments:** `<phase number>`
+
+## When to Use
+
+Use for:
+
+- 3D, games, audio, shaders, ML
+- Specialized domains with non-obvious patterns
+- Tech stacks you're unfamiliar with
+
+Goes beyond "which library" to ecosystem knowledge:
+
+- Standard architectures in the domain
+- Expected features and behaviors
+- Common pitfalls and anti-patterns
+
+## Process
+
+1. **Load phase context:**
+
+   - Read `.luca/roadmap.md` for phase goal
+   - Recall project identity from MuninnDB (`brain:project-identity`) for project context
+   - Read existing research at `.luca/phases/<slug>/research.md` (if any)
+
+2. **Spawn researcher:**
+
+   - Use lu-phase-researcher agent
+   - Focus on ecosystem knowledge for the domain
+
+3. **Create research.md:**
+
+   - Location: `.luca/phases/XX-name/{phase}-research.md`
+   - Include: stack recommendations, architecture patterns, pitfalls
+
+4. **Present findings:**
+
+   ```
+   ## Research Complete
+
+   **Domain:** {domain}
+   **File:** .luca/phases/XX-name/{phase}-research.md
+
+   ### Key Findings
+
+   **Stack:** {recommended approach}
+   **Patterns:** {standard architecture}
+   **Watch Out:** {common pitfalls}
+
+   ## ▶ Next Up
+
+   /phase-plan {N} — plan with research context
+   ```
+
+## Success Criteria
+
+- [ ] Phase context loaded
+- [ ] Researcher agent spawned
+- [ ] research.md created with domain knowledge
+- [ ] Stack recommendations specific and versioned
+- [ ] Pitfalls actionable with prevention strategies
+
+## Next Steps
+
+**Primary:** `/phase-plan {phase}` — Create plans using research findings
+
+**Also available:**
+
+- `/phase-assumptions {phase}` — Review what AI plans to do
+- `/progress` — Check overall project status
+</main>

package/dist/claude/skills/post-init-tour/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: post-init-tour
+description: "Guide new users through Luca's core concepts after project initialization."
+---
+
+<main>
+# Post-Init Interactive Tour
+
+Walk the user through Luca's core concepts after /project-new completes.
+
+## Behavior
+
+1. Welcome the user and explain this is a quick orientation
+2. Present each tour step below in order, pausing briefly between steps
+3. For each step, display the **title** as a heading and the **content** as explanation
+4. After all steps, ask if the user has questions or wants to start planning
+
+## Tour Steps
+
+### Step 1: MuninnDB -- Project Memory
+
+MuninnDB is Luca's memory system. It stores your project's identity (stack, architecture, conventions), long-term learnings (patterns, decisions, pitfalls), and session context. All memory is semantically searchable with entity graphs and temporal decay. Run /seed-memory to populate it from existing project knowledge.
+
+### Step 2: Skills -- Interactive Workflows
+
+Skills are user-invocable workflows triggered by /commands (e.g., /phase-plan, /phase-execute, /debug). They handle multi-step reasoning and require judgment. Run /help to see all available skills.
+
+### Step 3: Agents -- Specialized AI Workers
+
+Agents are specialized sub-agents that handle focused tasks: lu-router classifies complexity, lu-executor runs code changes, lu-verifier validates results, and reviewers audit code quality. They are spawned automatically during workflow execution.
+
+### Step 4: Phases -- Structured Development
+
+Work is organized into phases listed in `.luca/roadmap.md`. Each phase has a plan (`plan.md`) with waves of tasks. Use /phase-plan to create plans and /phase-execute to run them. Phases keep work focused and context-efficient.
+
+### Step 5: Rules -- Automatic Enforcement
+
+Rules are always-on guidelines loaded automatically based on file context. They enforce conventions like kebab-case naming, Bun preference, and schema-first parsing without requiring user action.
+
+### Step 6: Hooks -- Deterministic Quality Gates
+
+Hooks run automatically on events like file edits and commits. They handle type-checking, formatting, and pre-commit validation. Unlike skills, hooks are fast, deterministic, and cannot be skipped.
+
+### Step 7: Getting Started
+
+Your project is initialized. Common next steps:
+- /phase-plan 1 -- Create a plan for your first phase
+- /progress -- Check project status
+- /help -- See all available commands
+- /config-settings -- Configure workflow preferences
+
+## Presentation Guidelines
+
+- Keep explanations concise and practical
+- Use the tour step content as-is; do not embellish
+- After presenting all steps, suggest /phase-plan 1 as the natural next action
+- If the user interrupts with a question, answer it and resume the tour
+</main>

package/dist/claude/skills/progress/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: progress
+description: Check project progress, show current state, and suggest the next action to take.
+---
+
+<main>
+# Luca Progress
+
+Check project progress, summarize recent work and what's ahead, then intelligently route to the next action - either executing an existing plan or creating the next one.
+
+Provides situational awareness before continuing work.
+
+## Process
+
+### Step 1: Verify Planning Structure Exists
+
+Use Bash (not Glob) to check—Glob respects .gitignore but .luca/ is often gitignored:
+
+```bash
+test -d .planning && echo "exists" || echo "missing"
+```
+
+If no `.luca/` directory:
+
+```
+No planning structure found.
+
+Run /project-new to start a new project.
+```
+
+Exit.
+
+If missing `.luca/state.json`: suggest `/project-new`.
+
+**If `.luca/roadmap.md` missing but `.luca/state.json` exists:**
+This means a milestone was completed and archived. Go to **Route F** (between milestones).
+
+### Step 2: Load Full Project Context
+
+- Read workflow state via the `luca` CLI:
+
+```bash
+STATE_JSON=$(luca state read 2>/dev/null || echo '{"initialized":false}')
+```
+
+- Read `.luca/roadmap.md` for phase structure and objectives
+- Read `.luca/config.json` for settings (model_profile, workflow toggles)
+- Recall project identity from MuninnDB (`brain:project-identity` in repo vault) for the canonical project tree — What This Is, Core Value, Requirements live as engrams in v13.
+
+### Step 3: Gather Recent Work Context
+
+- Find the 2-3 most recent `.luca/phases/<slug>/execute/summary.md` files
+- Extract from each: what was accomplished, key decisions, any issues logged
+- This shows "what we've been working on"
+
+### Step 4: Parse Current Position
+
+- From the workflow state JSON: pipelineStep, currentPhase, totalPhases, iteration, complexity
+- Calculate: total plans, completed plans, remaining plans (cross-reference roadmap)
+- Note any blockers or concerns
+- Check for `context.md`: For phases without `plan.md`, check if `.luca/phases/<slug>/context.md` exists
+- Count pending todos: `luca todo list --status pending 2>/dev/null | wc -l`
+- Check for active debug sessions via MuninnDB recall (`session:debug-*` in repo vault)
+
+**Check for PR with unaddressed comments:**
+
+```bash
+# Check if current branch has an open PR
+PR_JSON=$(gh pr view --json number,url,title,reviewDecision 2>/dev/null)
+
+if [ -n "$PR_JSON" ]; then
+  PR_NUMBER=$(echo "$PR_JSON" | jq -r '.number')
+  PR_TITLE=$(echo "$PR_JSON" | jq -r '.title')
+  REVIEW_DECISION=$(echo "$PR_JSON" | jq -r '.reviewDecision // "PENDING"')
+
+  # Count comments
+  REPO=$(gh repo view --json nameWithOwner -q '.nameWithOwner')
+  REVIEW_COMMENTS=$(gh api "/repos/${REPO}/pulls/${PR_NUMBER}/comments" --jq 'length' 2>/dev/null || echo "0")
+  ISSUE_COMMENTS=$(gh api "/repos/${REPO}/issues/${PR_NUMBER}/comments" --jq '[.[] | select(.user.type != "Bot")] | length' 2>/dev/null || echo "0")
+
+  TOTAL_PR_COMMENTS=$((REVIEW_COMMENTS + ISSUE_COMMENTS))
+  HAS_PR_COMMENTS=$( [ "$TOTAL_PR_COMMENTS" -gt 0 ] && echo "true" || echo "false" )
+else
+  HAS_PR_COMMENTS=false
+  TOTAL_PR_COMMENTS=0
+fi
+```
+
+### Step 5: Present Rich Status Report
+
+```
+# [Project Name]
+
+**Progress:** [████████░░] 8/10 plans complete
+**Profile:** [quality/balanced/budget]
+**Complexity:** [TRIVIAL/MODERATE/COMPLEX] (if active task)
+
+## Git Context
+- **Ticket:** [TICKET-ID or None]
+- **Branch:** [TICKET-ID--description] → [RELEASE-ID--release]
+- **Issue:** [#123 or None]
+
+## PR Status (if open PR exists)
+- **PR:** #[number] - [title]
+- **Review:** [Changes requested | Approved | Pending]
+- **Comments:** [N] unaddressed ([inline] review, [general] discussion)
+- **Action:** `/pr-address` to process
+
+## Recent Work
+- [Phase X, Plan Y]: [what was accomplished - 1 line]
+- [Phase X, Plan Z]: [what was accomplished - 1 line]
+
+## Current Position
+Phase [N] of [total]: [phase-name]
+Plan [M] of [phase-total]: [status]
+CONTEXT: [✓ if context.md exists | - if not]
+
+## Key Decisions Made
+- [decision 1 from MuninnDB `decision:*` engrams + confidence-journal entries]
+- [decision 2]
+
+## Blockers/Concerns
+- [any blockers or concerns from MuninnDB `session:*` engrams + per-phase audits]
+
+## What's Next
+[Next phase/plan objective from ROADMAP]
+```
+
+**Note:** The PR Status section only appears if the current branch has an open PR. If comments exist, it prompts the user to run `/pr-address`.
+
+### Step 6: Route to Next Action
+
+| Condition                       | Meaning                     | Action          |
+| ------------------------------- | --------------------------- | --------------- |
+| uat_with_gaps > 0               | UAT gaps need fix plans     | Route E         |
+| HAS_PR_COMMENTS = true          | PR has unaddressed feedback | Route G         |
+| summaries < plans               | Unexecuted plans exist      | Route A         |
+| summaries = plans AND plans > 0 | Phase complete              | Check milestone |
+| plans = 0                       | Phase not yet planned       | Route B         |
+
+**Route G: PR comments need attention** (NEW)
+
+```
+## ⚠ PR Feedback Pending
+
+**PR #{PR_NUMBER}** has {TOTAL_PR_COMMENTS} unaddressed comments.
+
+Review decision: {REVIEW_DECISION}
+
+| Type    | Count             |
+| ------- | ----------------- |
+| Review  | {REVIEW_COMMENTS} |
+| General | {ISSUE_COMMENTS}  |
+
+**Process with agent swarm:**
+`/pr-address`
+
+**Or process specific category:**
+`/pr-address --category=security`
+
+**Skip for now:**
+`/progress --skip-pr` (continue to normal routing)
+```
+
+**Route A: Unexecuted plan exists**
+
+```
+## ▶ Next Up
+
+**{phase}-{plan}: [Plan Name]** — [objective summary from plan.md]
+
+`/phase-execute {phase}`
+```
+
+**Route B: Phase needs planning**
+
+If context.md exists:
+
+```
+## ▶ Next Up
+
+**Phase {N}: {Name}** — {Goal from roadmap.md}
+✓ Context gathered, ready to plan
+
+`/phase-plan {phase-number}`
+```
+
+If context.md does NOT exist:
+
+```
+## ▶ Next Up
+
+**Phase {N}: {Name}** — {Goal from roadmap.md}
+
+`/phase-discuss {phase}` — gather context and clarify approach
+
+**Also available:**
+- `/phase-plan {phase}` — skip discussion, plan directly
+```
+
+**Route C: Phase complete, more phases remain**
+
+```
+## ✓ Phase {Z} Complete
+
+## ▶ Next Up
+
+**Phase {Z+1}: {Name}** — {Goal from roadmap.md}
+
+`/phase-discuss {Z+1}` — gather context and clarify approach
+```
+
+**Route D: Milestone complete**
+
+```
+## 🎉 Milestone Complete
+
+All {N} phases finished!
+
+## ▶ Next Up
+
+**Complete Milestone** — archive and prepare for next
+
+`/milestone-complete`
+```
+
+**Route E: UAT gaps need fix plans**
+
+```
+## ⚠ UAT Gaps Found
+
+**{phase}-UAT.md** has {N} gaps requiring fixes.
+
+`/phase-plan {phase} --gaps`
+```
+
+**Route F: Between milestones**
+
+```
+## ✓ Milestone v{X.Y} Complete
+
+Ready to plan the next milestone.
+
+## ▶ Next Up
+
+**Start Next Milestone** — questioning → research → requirements → roadmap
+
+`/milestone-new`
+```
+
+## Success Criteria
+
+- [ ] Rich context provided (recent work, decisions, issues)
+- [ ] Current position clear with visual progress
+- [ ] PR status checked and displayed (if open PR exists)
+- [ ] PR comments surfaced with Route G (if unaddressed comments exist)
+- [ ] What's next clearly explained
+- [ ] Smart routing: /phase-execute if plans exist, /phase-plan if not
+- [ ] User confirms before any action
+- [ ] Seamless handoff to appropriate vlcn command
+
+## Next Steps
+
+This skill provides intelligent routing based on project state. The "Route" sections above determine the primary action.
+
+**Common follow-ups:**
+
+- `/help` — See all available commands
+- `/config-settings` — Adjust workflow configuration
+- `/session-pause` — Create handoff if stopping work
+</main>