@alecsibilia/luca 13.0.0-alpha.1

package/dist/claude/skills/milestone-gaps/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: milestone-gaps
+description: Create phases to close gaps identified by a milestone audit.
+---
+
+<main>
+# Luca Plan Milestone Gaps
+
+Create phases to close gaps identified by milestone audit.
+
+## Process
+
+1. **Load audit:**
+   - Read `.luca/milestones/v{version}-audit.md`
+   - Extract gaps section
+
+2. **Group gaps into phases:**
+   - Group related gaps together
+   - Prioritize by requirement priority (must/should/nice)
+   - Create coherent phase boundaries
+
+3. **Add phases to roadmap:**
+   - Use `/phase-add` pattern for each new phase
+   - Include gap references in phase description
+
+4. **Update audit status:**
+   - Mark gaps as "planned"
+   - Reference new phase numbers
+
+5. **Present plan:**
+
+   ```
+   ## Gap Closure Phases
+   
+   | Phase | Gaps Addressed | Priority |
+   |-------|----------------|----------|
+   | {N}   | {gap 1, gap 2} | Must     |
+   | {N+1} | {gap 3}        | Should   |
+   
+   ## ▶ Next Up
+   
+   /phase-plan {N} — plan first gap closure phase
+   ```
+
+## Success Criteria
+
+- [ ] Audit gaps loaded
+- [ ] Gaps grouped into coherent phases
+- [ ] Phases added to `.luca/roadmap.md`
+- [ ] Audit file updated with planning status
+- [ ] User knows next steps
+
+## Next Steps
+
+**Primary:** `/phase-execute {gap-phase}` — Execute the gap closure plans
+
+**Also available:**
+- `/progress` — Review gap closure phases
+- `/milestone-audit` — Re-audit after fixes
+</main>

package/dist/claude/skills/milestone-new/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: milestone-new
+description: Start a new milestone cycle with requirements gathering and roadmap generation.
+---
+
+<main>
+# Luca New Milestone
+
+Start a new milestone through unified flow: questioning → research (optional) → requirements → roadmap.
+
+This is the brownfield equivalent of new-project. The project exists, the `brain:project-identity` MuninnDB tree has history. This command gathers "what's next", evolves `brain:project-identity`, then continues through the full requirements → roadmap cycle.
+
+**Arguments:** `[milestone name, e.g., 'v1.1 Notifications']`
+
+## Creates/Updates
+
+- MuninnDB `brain:project-identity` — updated with new milestone marker + goals
+- MuninnDB `brain:project-requirements` — scoped requirements for this milestone (REQ-IDs continue from prior milestone)
+- MuninnDB `research:milestone-<slug>:*` — domain research (optional, focuses on NEW features)
+- `.luca/roadmap.md` — phase structure (continues numbering, written via `luca roadmap create` if resetting or hand-edited if extending)
+- `.luca/state.json` — reset for new milestone via `luca workflow reset`
+
+**After this command:** Run `/phase-plan [N]` to start execution.
+
+## Process
+
+1. **Load Context** — Read project identity from MuninnDB (`brain:project-identity`), prior milestone snapshots under `.luca/milestones/`, and the current workflow state:
+
+   ```bash
+   STATE_JSON=$(luca state read 2>/dev/null || echo '{"initialized":false}')
+   ```
+
+2. **Gather Milestone Goals** — Recall any per-milestone discussion context from MuninnDB (`milestone:<slug>`), or question user
+3. **Determine Milestone Version** — Parse last version from `.luca/milestones/` snapshots, suggest next
+4. **Update project identity in MuninnDB** — Store the current milestone marker:
+
+   ```
+   mcp__muninn__muninn_remember(vault: "<repo_vault>", concept: "milestone:v{version}", content: "<milestone goals + scope>", tags: ["milestone","active"])
+   ```
+
+5. **Reset workflow state for new milestone:**
+
+   ```bash
+   luca workflow reset 2>/dev/null || true
+   # The freshly reset state defaults to pipelineStep=triage. The milestone identifier is captured via MuninnDB (above), not as a state field.
+   ```
+
+6. **Research Decision** — Spawn researchers if selected (milestone-aware context)
+7. **Define Requirements** — Present features, scope each category
+8. **Create Roadmap** — Use `luca roadmap create` (continues phase numbering)
+9. **GitHub Issue & Branch Decision** — See below
+10. **Done** — Present completion with next steps
+
+## GitHub Issue & Branch Decision (Step 9)
+
+After roadmap creation, present the user with tracking options:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Luca ► MILESTONE TRACKING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+How should this milestone be tracked on GitHub?
+
+1. **New issue & branch** — Create dedicated issue for this milestone
+2. **Continue on #{existing}** — Keep using existing issue/branch
+3. **No tracking** — Skip GitHub integration (not recommended)
+```
+
+**If "New issue & branch" selected:**
+
+1. Generate issue body from MuninnDB recall (`brain:project-identity` current-milestone child + `brain:project-requirements` v-current scope)
+2. Create issue: `gh issue create --title "feat({scope}): {milestone-name}" --body "{body}"`
+3. Create branch: `git checkout -b {issue_number}--{milestone-slug}`
+4. Push branch: `git push -u origin {branch_name}`
+5. Record the issue/branch references in MuninnDB so the active session has durable context:
+
+   ```
+   mcp__muninn__muninn_remember(
+     vault: "<repo_vault>",
+     concept: "session:milestone-v{version}",
+     content: "GitHub issue #{issue_number} / branch {branch_name} — milestone v{version}",
+     tags: ["session","milestone","github"]
+   )
+   ```
+
+**If "Continue on existing" selected:**
+
+1. Verify existing issue still open: `gh issue view {number} --json state`
+2. Add comment to existing issue noting new milestone started
+3. Keep existing issue/branch references in MuninnDB (no state update needed)
+
+**If "No tracking" selected:**
+
+1. Warn user: commits won't reference issues, PR creation will require manual setup
+2. Note: GitHub Issue: None (user opted out) — no bridge update needed
+
+## Success Criteria
+
+- [ ] MuninnDB `brain:project-identity` updated with current-milestone marker
+- [ ] `.luca/state.json` reset for new milestone (via `luca workflow reset`)
+- [ ] Prior milestone-context engrams consumed (recalled into the new milestone's planning)
+- [ ] Research completed (if selected) — 4 parallel agents spawned, milestone-aware
+- [ ] Requirements gathered (from research or conversation)
+- [ ] User scoped each category
+- [ ] MuninnDB `brain:project-requirements` updated with new milestone's REQ-IDs
+- [ ] `.luca/roadmap.md` created with phases continuing from previous milestone
+- [ ] GitHub tracking decision made (new issue, continue existing, or opt-out)
+- [ ] Issue/branch tracking captured in MuninnDB `session:milestone-*` engram (when tracking opted in)
+
+## Next Steps
+
+| Condition | Action | Command |
+|-----------|--------|---------|
+| Milestone created | Discuss first phase | `/phase-discuss {N}` |
+| Want to skip discussion | Plan directly | `/phase-plan {N}` |
+| Need codebase context | Map the codebase | `/codebase-map` |
+
+**Primary:** `/phase-discuss {N}` — Gather context for first phase of milestone
+
+**Also available:**
+
+- `/phase-plan {N}` — Skip discussion, plan directly
+- `/progress` — Check milestone setup
+</main>

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

@@ -0,0 +1,162 @@
+---
+name: note
+description: Add a new phase to the roadmap (default), or queue a developer note with --next/--whenever.
+---
+
+<main>
+# Luca Developer Note
+
+Capture ideas as roadmap phases (default) or queue notes for agent pickup.
+
+**Arguments:** `[--next|--whenever] <message>`
+
+- **Default (phase):** Creates a new phase in the roadmap for the message
+- `--next` flag: Queue an urgent note (picked up within 60 seconds via context-check hook)
+- `--whenever` flag: Queue a deferred note (picked up at commit boundaries only)
+
+---
+
+## Default Mode — Add Phase
+
+When no flag is provided, the message becomes a new phase in the current milestone.
+
+### Process
+
+1. **Parse arguments:**
+   - If first argument is `--next` or `--whenever`, use note mode (see below)
+   - Otherwise, all arguments become the phase description
+   - Error if no arguments provided
+
+2. **Load roadmap:**
+   - Read `.luca/roadmap.md` (or call `luca roadmap read` for a typed view)
+   - Error if not found
+
+3. **Find current milestone:**
+   - Locate "## Current Milestone:" heading
+   - Extract milestone name and version
+   - Identify all phases under this milestone
+
+4. **Calculate next phase:**
+   - Find highest integer phase number (ignore decimals)
+   - Add 1 to get next phase number
+   - Format as two-digit
+
+5. **Generate slug:**
+   - Convert description to kebab-case
+   - Example: "Add authentication" → `07-add-authentication`
+
+6. **Create phase directory:**
+
+   ```bash
+   mkdir -p ".luca/phases/${phase_num}-${slug}"
+   ```
+
+7. **Update roadmap:**
+   - Insert new phase entry after last phase in current milestone
+   - Include Goal, Depends on, Plans placeholders
+
+8. **Update roadmap:**
+
+   \`\`\`bash
+   # The roadmap is the durable view; the workflow state machine in .luca/state.json
+   # is updated separately by the pipeline when a phase becomes active.
+   luca roadmap create --file <payload.json>   # if creating a fresh roadmap
+   # or edit .luca/roadmap.md directly for incremental additions, then read it back via
+   luca roadmap read 2>/dev/null || true
+   \`\`\`
+
+9. **Emit observer event:**
+
+   \`\`\`bash
+   luca telemetry emit --kind=phase.added --data='{"phase":"<N>","description":"<message>","directory":"<path>"}' 2>/dev/null || true
+   \`\`\`
+
+10. **Confirm:**
+
+    ```
+    Phase {N} added to current milestone:
+    - Description: {description}
+    - Directory: .luca/phases/{phase-num}-{slug}/
+
+    Next: /phase-plan {N}
+    ```
+
+### Anti-Patterns
+
+See `/phase-add` for detailed anti-patterns. Key rules:
+- Don't modify phases outside current milestone
+- Don't renumber existing phases
+- Don't use decimal numbering (that's `/phase-insert`)
+- Don't create plans yet (that's `/phase-plan`)
+- Don't commit changes (user decides when to commit)
+
+---
+
+## `--next` Mode — Urgent Note
+
+Queue a note as a high-priority MuninnDB-backed todo. The context-check hook surfaces high-priority todos into the agent context.
+
+### Process
+
+1. **Parse arguments:**
+   - Strip `--next` flag
+   - Remaining text is the note body
+
+2. **Persist to the MuninnDB-backed backlog:**
+
+   \`\`\`bash
+   luca todo add --title "<first-line>" --area "note" --priority high --source note --body "<full message>"
+   \`\`\`
+
+3. **Emit observer event:**
+
+   \`\`\`bash
+   luca telemetry emit --kind=note.added --data='{"priority":"next","title":"<first-line>"}' 2>/dev/null || true
+   \`\`\`
+
+4. **Confirm:**
+
+   ```
+   Note queued: {message preview}
+
+   Priority: high (next)
+   Backlog: MuninnDB todo backlog (see `luca todo list`)
+   ```
+
+### Consumption
+
+High-priority todos surface in the agent context via the context-refresher / context-check hooks and via `luca todo list`. There is no separate `.luca/notes/` filesystem layer — the canonical backlog is the MuninnDB todo store.
+
+---
+
+## `--whenever` Mode — Deferred Note
+
+Queue a low-priority MuninnDB-backed todo picked up at commit / phase boundaries only.
+
+### Process
+
+Same as `--next` mode except:
+- `--priority low` (instead of `high`)
+- The todo surfaces in `luca todo list` but is not pushed into the active agent context.
+
+### Consumption
+
+Advisory backlog entry. Not auto-consumed — agent reads via `luca todo list` and acts on them manually.
+
+---
+
+## Summary
+
+| Mode | Trigger | Output | Event |
+|------|---------|--------|-------|
+| Default (phase) | No flag | Roadmap phase + directory | `phase.added` |
+| `--next` | `--next` flag | MuninnDB todo (priority high) | `note.added` |
+| `--whenever` | `--whenever` flag | MuninnDB todo (priority low) | `note.added` |
+
+## Success Criteria
+
+- [ ] Phase mode: directory created, roadmap updated, state updated
+- [ ] Note modes: MuninnDB todo created via `luca todo add`
+- [ ] Observer event emitted (fire-and-forget)
+- [ ] User sees confirmation with appropriate next steps
+</main>

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

@@ -0,0 +1,91 @@
+---
+name: phase-add
+description: Append a new phase to the end of the current milestone roadmap.
+---
+
+<main>
+# Luca Add Phase
+
+Add a new integer phase to the end of the current milestone in the roadmap.
+
+**Arguments:** `<description>` (e.g., "Add authentication", "Fix critical performance issues")
+
+**Purpose:** Add planned work discovered during execution that belongs at the end of current milestone.
+
+## Process
+
+1. **Parse arguments:**
+
+   - All arguments become the phase description
+   - Error if no arguments provided
+
+2. **Load roadmap:**
+
+   - Read `.luca/roadmap.md` (or call `luca roadmap read`)
+   - Error if not found
+
+3. **Find current milestone:**
+
+   - Locate "## Current Milestone:" heading
+   - Extract milestone name and version
+   - Identify all phases under this milestone
+
+4. **Calculate next phase:**
+
+   - Find highest integer phase number (ignore decimals)
+   - Add 1 to get next phase number
+   - Format as two-digit
+
+5. **Generate slug:**
+
+   - Convert description to kebab-case
+   - Example: "Add authentication" → `07-add-authentication`
+
+6. **Create phase directory:**
+
+   ```bash
+   mkdir -p ".luca/phases/${phase_num}-${slug}"
+   ```
+
+7. **Update roadmap:**
+
+   - Insert new phase entry after last phase in current milestone
+   - Include Goal, Depends on, Plans placeholders
+
+8. **Roadmap update:**
+
+   The roadmap edit is the durable change. Read it back via `luca roadmap read` to confirm the new phase appears. The workflow state machine in `.luca/state.json` updates separately when the pipeline transitions into that phase.
+
+9. **Present completion:**
+
+   ```
+   Phase {N} added to current milestone:
+   - Description: {description}
+   - Directory: .luca/phases/{phase-num}-{slug}/
+   ```
+
+## Next Steps
+
+**Primary:** `/phase-plan {N}` — Create execution plans for the new phase
+
+**Also available:**
+
+- `/phase-discuss {N}` — Gather context before planning
+- `/progress` — Check overall project status
+
+## Anti-Patterns
+
+- Don't modify phases outside current milestone
+- Don't renumber existing phases
+- Don't use decimal numbering (that's `/phase-insert`)
+- Don't create plans yet (that's `/phase-plan`)
+- Don't commit changes (user decides when to commit)
+
+## Success Criteria
+
+- [ ] Phase directory created
+- [ ] Roadmap updated with new phase entry
+- [ ] `.luca/state.json` reflects the new phase (read back via `luca state read` to confirm)
+- [ ] New phase appears at end of current milestone
+- [ ] Next phase number calculated correctly
+</main>

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

@@ -0,0 +1,92 @@
+---
+name: phase-assumptions
+description: Preview AI planning assumptions for a phase before committing to execution.
+---
+
+<main>
+# Luca List Phase Assumptions
+
+See what AI is planning to do before it starts.
+
+**Arguments:** `<phase number>`
+
+Shows AI's intended approach for a phase so you can course-correct if needed.
+
+**No files created** - conversational output only.
+
+## Process
+
+1. **Load phase context:**
+   - Read `.luca/roadmap.md` for phase goal
+   - Recall mapped requirements from MuninnDB (`brain:project-requirements`)
+   - Read `.luca/phases/<slug>/research.md` (if exists)
+   - Read `.luca/phases/<slug>/context.md` (if exists)
+
+2. **Generate assumptions:**
+   Based on phase goal and requirements, list:
+   - **Technical approach:** Libraries, patterns, architecture choices
+   - **Scope interpretation:** What's in, what's out
+   - **Dependencies:** What the phase assumes exists
+   - **Risks:** Potential challenges
+
+3. **Present assumptions:**
+
+   ```
+   ## Phase {N}: {Name} - AI Assumptions
+   
+   ### Technical Approach
+   - Will use {X} for {purpose}
+   - Following pattern from {existing code}
+   - Targeting {specific outcome}
+   
+   ### Scope
+   **In scope:**
+   - {item 1}
+   - {item 2}
+   
+   **Out of scope:**
+   - {item 3}
+   - {item 4}
+   
+   ### Dependencies
+   - Assumes {X} exists from Phase {Y}
+   - Requires {Z} to be configured
+   
+   ### Potential Risks
+   - {risk 1}
+   - {risk 2}
+   
+   ---
+   
+   Does this match your expectations?
+   
+   - **Yes** → /phase-plan {N}
+   - **Adjust** → /phase-discuss {N} to clarify
+   ```
+
+4. **No files created:**
+   - This is conversational output only
+   - Use `/phase-discuss` to capture corrections
+
+## Success Criteria
+
+- [ ] Phase goal and requirements loaded
+- [ ] Technical assumptions clearly stated
+- [ ] Scope boundaries explicit
+- [ ] Dependencies identified
+- [ ] User can validate before planning
+
+## Next Steps
+
+| Condition | Action | Command |
+|-----------|--------|---------|
+| Assumptions look good | Plan the phase | `/phase-plan {phase}` |
+| Assumptions need clarification | Discuss the phase | `/phase-discuss {phase}` |
+| Need more research | Research the domain | `/phase-research {phase}` |
+
+**Primary:** `/phase-plan {phase}` — Proceed with planning
+
+**Also available:**
+- `/phase-discuss {phase}` — Clarify vision if assumptions seem off
+- `/progress` — Check overall project status
+</main>

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

@@ -0,0 +1,165 @@
+---
+name: phase-discuss
+description: Gather phase context through adaptive questioning before creating execution plans.
+---
+
+<main>
+# Luca Discuss Phase
+
+Extract implementation decisions that downstream agents need — researcher and planner will use context.md to know what to investigate and what choices are locked.
+
+**Arguments:** `<phase> [--auto]`
+
+## How It Works
+
+### Interactive Mode (default)
+
+1. Analyze the phase to identify gray areas (UI, UX, behavior, etc.)
+2. Present gray areas — user selects which to discuss
+3. Deep-dive each selected area until satisfied
+4. Create context.md with decisions that guide research and planning
+
+### Auto Mode (`--auto` flag)
+
+1. Analyze the phase to identify gray areas (same as interactive)
+2. Auto-select ALL gray areas (no user prompt)
+3. Load project tech stack from MuninnDB
+4. Spawn `lu-discuss-researcher` agent per gray area question (web research)
+5. Present research summary with citations before writing
+6. Offer user override: accept all / override some / switch to interactive
+7. Create context.md with researched decisions (annotated with source provenance)
+
+Auto mode is useful when running via `/autopilot` or when the user wants AI-researched decisions instead of manual discussion.
+
+**Output:** `{phase}-context.md` — decisions clear enough that downstream agents can act without asking the user again
+
+## Process
+
+### Complexity-Aware Discussion
+
+Read complexity from the canonical workflow state:
+
+```bash
+COMPLEXITY=$(luca state read 2>/dev/null | jq -r '.complexity // "MODERATE"')
+```
+
+**Always runs.** Discussion depth and model tier scale with complexity:
+
+| Complexity | Discussion Depth | Model Tier (lu-discuss-researcher) |
+|------------|-----------------|-------------------------------------|
+| TRIVIAL | Light (2 questions per area) | fast |
+| SIMPLE | Light (2 questions per area) | balanced |
+| MODERATE | Standard (4 questions per area) | balanced |
+| COMPLEX | Extended (4+ questions per area) | capable |
+| CRITICAL | Thorough (6+ questions per area) | capable |
+
+The lu-discuss-researcher model tier is resolved via `resolveModelForAgent("lu-discuss-researcher", complexity)` from the centralized routing table.
+
+1. **Validate phase number** (error if missing or not in roadmap)
+2. **Check if context.md exists** (offer update/view/skip if yes)
+3. **Detect mode** — If `--auto` flag is present, use auto mode (steps 4a-8a). Otherwise, use interactive mode (steps 4-7).
+
+**Interactive Mode (default):**
+
+4. **Analyze phase** — Identify domain and generate phase-specific gray areas
+5. **Present gray areas** — Multi-select: which to discuss? (NO skip option)
+6. **Deep-dive each area** — 4 questions per area, then offer more/next
+7. **Write context.md** — Sections match areas discussed
+8. **Offer next steps** (research or plan)
+
+**Auto Mode (`--auto`):**
+
+4a. **Analyze phase** — Same gray area identification as interactive mode
+5a. **Auto-select all gray areas** — No user prompt, select everything
+6a. **Load project identity from MuninnDB** — Extract project tech stack (languages, frameworks, conventions) via `muninn_recall_tree(vault: "default", id: "brain:project-identity")`
+7a. **Spawn lu-discuss-researcher per question** — For each gray area:
+    - Formulate a focused question from the gray area topic
+    - Spawn `lu-discuss-researcher` via Task() with: question, phase context, tech stack from MuninnDB
+    - Collect the `<research_result>` response with recommendation, confidence, and sources
+    - If `researchable: false`: flag for user input (even in auto mode)
+8a. **Present research summary** — Show consolidated results:
+    ```
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     Luca ► AUTO-DISCUSS RESULTS
+    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+    | # | Gray Area | Recommendation | Confidence | Sources |
+    |---|-----------|---------------|------------|---------|
+    | 1 | {area}    | {rec}         | HIGH       | 2 cited |
+    | 2 | {area}    | {rec}         | MEDIUM     | 1 cited |
+    | 3 | {area}    | Not researchable | N/A     | —       |
+    ```
+
+    **Non-researchable items:** {list questions that need user input}
+9a. **User override** — Even in auto mode, give user a chance to adjust:
+    - Accept all: Use all researched recommendations
+    - Override some: User provides answers for specific questions
+    - Discuss instead: Switch to interactive mode for remaining items
+10a. **Write context.md** — Include provenance annotations:
+    - `[researched]` — Decision from web research with cited sources
+    - `[user-override]` — User overrode the researched recommendation
+    - `[user-input]` — Non-researchable item answered by user
+11a. **Offer next steps** (research or plan)
+
+## Critical: Scope Guardrail
+
+- Phase boundary from roadmap.md is FIXED
+- Discussion clarifies HOW to implement, not WHETHER to add more
+- If user suggests new capabilities: "That's its own phase. I'll note it for later."
+- Capture deferred ideas — don't lose them, don't act on them
+
+## Domain-Aware Gray Areas
+
+Gray areas depend on what's being built. Analyze the phase goal:
+
+- Something users SEE → layout, density, interactions, states
+- Something users CALL → responses, errors, auth, versioning
+- Something users RUN → output format, flags, modes, error handling
+- Something users READ → structure, tone, depth, flow
+- Something being ORGANIZED → criteria, grouping, naming, exceptions
+
+Generate 3-4 **phase-specific** gray areas, not generic categories.
+
+## Probing Depth
+
+Scale probing depth by complexity:
+- MODERATE: 4 questions per area (standard)
+- COMPLEX: 4-6 questions per area (extended)
+- CRITICAL: 6+ questions per area (thorough)
+
+Default:
+- Ask 4 questions per area before checking
+- "More questions about [area], or move to next?"
+- If more → ask 4 more, check again
+- After all areas → "Ready to create context?"
+
+## Do NOT Ask About (AI handles these)
+
+- Technical implementation
+- Architecture choices
+- Performance concerns
+- Scope expansion
+
+## Success Criteria
+
+- [ ] Gray areas identified through intelligent analysis
+- [ ] User chose which areas to discuss
+- [ ] Each selected area explored until satisfied
+- [ ] Scope creep redirected to deferred ideas
+- [ ] context.md captures decisions, not vague vision
+
+## Next Steps
+
+| Condition                         | Action              | Command                                 |
+| --------------------------------- | ------------------- | --------------------------------------- |
+| Context gathered, niche domain    | Research the domain | `/phase-research {phase}`         |
+| Context gathered, standard domain | Plan the phase      | `/phase-plan {phase}`             |
+| Want to review assumptions        | List assumptions    | `/phase-assumptions {phase}` |
+
+**Primary:** `/phase-plan {phase}` — Create execution plans using gathered context
+
+**Also available:**
+
+- `/phase-research {phase}` — Deep research for niche/complex domains
+- `/progress` — Check overall project status
+</main>