qualia-framework 2.6.0 → 3.1.0

package/framework/skills/qualia-pause-work/SKILL.md

@@ -1,96 +0,0 @@
----
-name: qualia-pause-work
-description: "Save session context for seamless handoff between Claude sessions. Use this skill whenever the user says 'pause', 'save progress', 'stop for now', 'pause work', 'handoff', 'save thoughts', or wants to preserve their current working state before ending a session. Also trigger when user mentions 'continue later', 'pick up tomorrow', or needs to create a checkpoint of current work. Supports both full project handoff and lightweight thoughts mode."
----
-
-# Qualia Pause Work — Session Handoff
-
-Save current session context so the next session can pick up exactly where you left off.
-
-## Usage
-
-`/qualia-pause-work` — Full project-aware handoff (creates `.continue-here.md`)
-`/qualia-pause-work --thoughts` — Lightweight thought dump (saves to `~/.claude/thoughts/`)
-
-## Default Mode (Project Handoff)
-
-### 1. Read Current State
-
-Load `.planning/STATE.md` and check current phase status.
-
-Reference: `~/.claude/qualia-framework/workflows/pause-work.md`
-
-### 2. Create `.continue-here.md`
-
-Write a handoff file at the project root with:
-
-```markdown
-# Continue Here
-
-## Session Summary
-What was accomplished this session.
-
-## Current Phase
-Phase X: [name] — [status]
-
-## In Progress
-- What's partially done
-- Where exactly work stopped
-
-## Next Steps
-1. Immediate next action
-2. Following actions
-
-## Key Decisions Made
-- Decision 1 and rationale
-- Decision 2 and rationale
-
-## Blockers / Open Questions
-- Any unresolved issues
-
-## Files Modified
-- List of changed files with brief description
-```
-
-### 3. Git Commit
-
-Stage and commit with a descriptive message (add only modified files, never `git add -A`):
-```bash
-git add <list of modified files>
-git commit -m "WIP: [phase name] - [brief description of state]"
-```
-
-## Thoughts Mode (`--thoughts`)
-
-Lightweight handoff for non-project work or quick brainstorming sessions.
-
-### Save Location
-`~/.claude/thoughts/handoff-{timestamp}.md`
-
-### Structure
-```markdown
-# Handoff — {date}
-
-## Accomplished
-- What got done
-
-## Current State
-- Where things stand
-
-## In Progress
-- Partially complete work
-
-## Next Steps
-1. What to do next
-
-## Key Decisions
-- Important choices made
-
-## Blockers
-- What's stuck
-
-## Commands to Resume
-- Specific commands or files to look at
-```
-
-No git commit in thoughts mode — it's just a text dump for context restoration.

package/framework/skills/qualia-plan-milestone-gaps/SKILL.md

@@ -1,57 +0,0 @@
----
-name: qualia-plan-milestone-gaps
-description: "Create fix phases from milestone audit gaps — reads the most recent audit report and generates ROADMAP.md entries for all identified gaps. Use this skill whenever the user says 'plan gaps', 'fix gaps', 'plan milestone gaps', 'create fix phases', or wants to turn audit findings into actionable phases. Also trigger after a milestone audit reveals gaps that need addressing."
----
-
-# Qualia Plan Milestone Gaps — Gap-to-Phase Conversion
-
-Read the most recent milestone audit report and create ROADMAP.md phases to close all identified gaps.
-
-## Usage
-
-`/qualia-plan-milestone-gaps` — Auto-detect latest audit, create fix phases
-
-## Process
-
-### 1. Find Latest Audit
-
-```bash
-ls -t .planning/v*-MILESTONE-AUDIT.md | head -1
-```
-
-Read the most recent `v*-MILESTONE-AUDIT.md` file.
-
-Reference: `~/.claude/qualia-framework/workflows/plan-milestone-gaps.md`
-
-### 2. Load Project Context
-
-Read these files for full context:
-- `.planning/PROJECT.md`
-- `.planning/REQUIREMENTS.md`
-- `.planning/ROADMAP.md`
-- `.planning/STATE.md`
-
-### 3. Extract and Group Gaps
-
-From the audit report, extract all gaps (items marked as failing or incomplete). Group related gaps into logical phases:
-- Group by feature area or component
-- Keep phases small (completable in 1-2 sessions)
-- Order by dependency — fix foundations before features
-
-### 4. Create ROADMAP.md Entries
-
-Append new phases to ROADMAP.md. Each gap-fix phase should include:
-- Phase number (continuing from existing phases)
-- Name: `Fix: [area]`
-- Description of what gaps it closes
-- Status: `not started`
-- Reference to specific audit gaps being addressed
-
-### 5. Update STATE.md
-
-Update the phase table in STATE.md to reflect the new fix phases.
-
-### 6. Report
-
-Tell the user how many gaps were found, how many fix phases were created, and suggest:
-> "Fix phases created. Run `/qualia-plan-phase [next-phase-number]` to plan the first fix."

package/framework/skills/qualia-plan-phase/SKILL.md

@@ -1,104 +0,0 @@
----
-name: qualia-plan-phase
-description: "Create detailed execution plans for a project phase with optional research and verification. Use this skill whenever the user says 'plan phase', 'plan next phase', 'create plan', or wants to plan out how a specific phase of work should be executed. Also trigger when user mentions 'PLAN.md', 'phase planning', or needs to break a roadmap phase into concrete implementation steps. Supports research integration, gap closure planning, and plan verification."
----
-
-# Qualia Plan Phase — Phase Planning
-
-Create detailed PLAN.md files for a project phase, with optional research and verification loop.
-
-## Usage
-
-`/qualia-plan-phase 3` — Plan phase 3
-`/qualia-plan-phase` — Auto-detect next unplanned phase
-`/qualia-plan-phase 3 --research` — Force research before planning
-`/qualia-plan-phase 3 --skip-research` — Skip research even if recommended
-`/qualia-plan-phase 3 --gaps` — Plan gap closure (after verify-work found issues)
-`/qualia-plan-phase 3 --skip-verify` — Skip plan verification step
-
-## Process
-
-### 1. Identify Target Phase
-
-If phase number provided, use it. Otherwise, scan ROADMAP.md for the first phase with status `not started` or `planned` without a PLAN.md.
-
-Reference: `~/.claude/qualia-framework/workflows/plan-phase.md`
-
-### 2. Research (if needed)
-
-Research is recommended when:
-- Phase involves unfamiliar tech or APIs
-- Phase has complex architectural decisions
-- User passes `--research` flag
-
-Skip if `--skip-research` is passed or if research already exists at `.planning/phases/{phase}-{slug}/{phase}-RESEARCH.md`.
-
-If research is needed, use the qualia-research-phase skill first.
-
-### 3. Create PLAN.md
-
-Write to `.planning/phases/{phase}-{slug}/PLAN.md`:
-
-```markdown
-# Phase {N}: {Name} — Execution Plan
-
-## Objective
-What this phase accomplishes.
-
-## Prerequisites
-- What must be done/ready before starting
-
-## Implementation Steps
-
-### Step 1: {description}
-- Files to create/modify
-- Key implementation details
-- Acceptance criteria
-
-### Step 2: {description}
-...
-
-## Verification Checklist
-- [ ] Each testable outcome
-- [ ] Integration points work
-- [ ] No regressions
-
-## Risks & Mitigations
-- Risk 1 → Mitigation
-```
-
-For `--gaps` mode, the plan focuses specifically on closing gaps identified by verify-work, referencing the UAT.md findings.
-
-### 4. Verify Plan (unless --skip-verify)
-
-Spawn the qualia-plan-checker agent to review the plan for:
-- Completeness against requirements
-- Realistic scope
-- Clear acceptance criteria
-- No missing dependencies
-
-Reference: `~/.claude/agents/qualia-plan-checker.md`
-
-If checker finds issues, revise the plan and re-verify.
-
-### 5. Update State
-
-Update `.planning/STATE.md` to reflect the phase is now `planned`.
-
-Reference UI/brand guidelines: `~/.claude/qualia-framework/references/ui-brand.md`
-
-For complex phases touching multiple subsystems, consider `/deep-research` before phase research to establish architectural direction.
-
-### 6. Next Step
-
-> "Phase {N} planned. Run `/qualia-execute-phase {N}` to begin execution."
-
-### Agents Used
-| Agent | File | Role |
-|-------|------|------|
-| `qualia-planner` | `~/.claude/agents/qualia-planner.md` | Creates PLAN.md with goal-backward methodology |
-| `qualia-plan-checker` | `~/.claude/agents/qualia-plan-checker.md` | Validates plan completeness |
-| `qualia-phase-researcher` | `~/.claude/agents/qualia-phase-researcher.md` | Phase research (when --research) |
-
----
-> Stuck? Type `/qualia-idk` · Lost? Type `/qualia-help`

package/framework/skills/qualia-progress/SKILL.md

@@ -1,53 +0,0 @@
----
-name: qualia-progress
-description: "Check project progress and get routed to the right next action. Use this skill whenever the user says 'progress', 'how far along', 'what happened', 'show progress', or wants a summary of what's been done and what comes next. Also trigger when user seems to need situational awareness about their project state before deciding what to do. Routes to the most logical next step based on current state."
----
-
-# Qualia Progress — Progress Check & Routing
-
-Check current progress, summarize state, and route to the most logical next action.
-
-## Usage
-
-`/qualia-progress` — Check progress and get next-step recommendation
-
-## Process
-
-### 1. Load State
-
-Read `.planning/STATE.md`, `.planning/ROADMAP.md`, and check `git status --short`.
-
-Reference: `~/.claude/qualia-framework/workflows/progress.md`
-
-### 2. Summarize Progress
-
-Present a concise summary:
-- Current milestone and phase
-- Phases completed vs total
-- Current phase status
-- Any uncommitted changes
-- Recent activity
-
-### 3. Route to Next Action
-
-Based on current state, recommend one of these routes:
-
-**Route A** — Phase needs planning:
-> "Phase {N} is next and unplanned. Run `/qualia-plan-phase {N}`."
-
-**Route B** — Phase is planned, needs execution:
-> "Phase {N} is planned and ready. Run `/qualia-execute-phase {N}`."
-
-**Route C** — Phase is executed, needs verification:
-> "Phase {N} is done but unverified. Run `/qualia-verify-work {N}`."
-
-**Route D** — Verification found gaps:
-> "Phase {N} has gaps from verification. Run `/qualia-plan-phase {N} --gaps`."
-
-**Route E** — All phases complete:
-> "All phases done! Run `/qualia-audit-milestone` to verify the milestone."
-
-**Route F** — Milestone audit complete:
-> "Milestone audit passed. Run `/qualia-complete-milestone` to archive and tag."
-
-Keep the output concise — this is a quick status check with routing, not a detailed report.

package/framework/skills/qualia-quick/SKILL.md

@@ -1,89 +0,0 @@
----
-name: qualia-quick
-description: "Execute quick tasks with Qualia quality guarantees — atomic commits, STATE.md tracking, minimal overhead. Use this skill whenever the user says 'quick task', 'quick fix', 'just do this quickly', 'small change', 'hotfix', or wants to make a small change outside the normal phase workflow. Also trigger when user mentions 'quick bug fix', '--fix', or needs a fast targeted change with proper tracking. Supports no-plan mode and bug-fix mode with minimal-change discipline."
----
-
-# Qualia Quick — Quick Tasks with Guarantees
-
-Execute small tasks outside the normal phase workflow while maintaining Qualia quality standards: atomic commits, state tracking, and verification.
-
-## Usage
-
-`/qualia-quick "Add loading spinner to dashboard"` — Quick task with planning
-`/qualia-quick --no-plan "Update footer copyright year"` — Skip planner, just do it
-`/qualia-quick --fix "Login button not responding on mobile"` — Bug fix mode (implies --no-plan)
-
-## Process
-
-### 1. Load Context
-
-Read `.planning/STATE.md` for current project state.
-
-Reference: `~/.claude/qualia-framework/workflows/quick.md`
-
-### 2. Complexity Check
-
-Before planning or executing, classify the task:
-
-| Signal | Classification | Action |
-|--------|---------------|--------|
-| Single file change, familiar codebase | **Quick** | Proceed directly (no confirmation) |
-| `--no-plan` or `--fix` flag | **Quick** | Proceed directly (no confirmation) |
-| Typo, config, or copy change | **Quick** | Proceed directly (no confirmation) |
-| Multi-file change | **Non-trivial** | Present understanding, wait for confirmation |
-| Architectural impact (new table, new service, new API) | **Non-trivial** | Present understanding, wait for confirmation |
-| Unfamiliar codebase (first time working in this project) | **Non-trivial** | Present understanding, wait for confirmation |
-
-**If Non-trivial:** Before making changes, present:
-> "Here's what I understand: [1-2 sentence summary]. I'll modify [file list]. Correct?"
-
-Wait for user confirmation. Capture any corrections for the session.
-
-**If Quick:** Skip confirmation and proceed to Step 3.
-
-### 3. Plan (unless --no-plan or --fix)
-
-Quick-plan the task:
-- What files need changing
-- What the change looks like
-- How to verify it works
-
-Quick tasks do NOT create PLAN.md files — planning is lightweight and inline.
-
-### 4. Execute
-
-Implement the change. Quick tasks live in `.planning/quick/` — they're separate from planned phases.
-
-#### Fix Mode (`--fix`)
-Bug fix mode enforces minimal-change discipline:
-1. **Locate** — Find the exact source of the bug
-2. **Root Cause** — Understand why it's happening
-3. **Smallest Fix** — Make the minimum change that fixes it
-4. **Verify** — Confirm the fix works and nothing else broke
-
-Fix mode skips planning entirely (implies `--no-plan`).
-
-### 5. Verify
-
-Run the change and verify it works:
-- Does the feature/fix work as expected?
-- No console errors?
-- No regressions in related functionality?
-
-### 6. Track
-
-Update `.planning/STATE.md` — add entry to the "Quick Tasks Completed" table:
-
-| Date | Task | Status |
-|------|------|--------|
-| YYYY-MM-DD | Description | ✅ Done |
-
-**Important**: Quick tasks update STATE.md only, NOT ROADMAP.md. They're tracked separately from planned phases.
-
-### 7. Commit
-
-Atomic commit with descriptive message:
-```bash
-git add [specific files]
-git commit -m "quick: [description of change]"
-```

package/framework/skills/qualia-report/SKILL.md

@@ -1,166 +0,0 @@
----
-name: qualia-report
-description: "Generate a session work report as a branded DOCX — simple summary of what was done. Use this skill whenever the user says 'report', 'done for today', 'session report', 'log my work', 'what did I do', 'end of day', 'wrapping up', 'signing off', or finishes a working session. Also trigger when user mentions 'daily report', 'status update', 'work summary', or wants to document what they accomplished."
----
-
-# Qualia Report — Session DOCX Report
-
-Generate a clean, branded DOCX report of what was done in this session. Simple and clear — what happened, not every detail.
-
-## Usage
-
-`/qualia-report` — Generate DOCX report for current session
-`/qualia-report --week` — Aggregate weekly DOCX report
-
-## Process
-
-### 1. Gather Session Data
-
-Run a **single** bash command to collect everything:
-
-```bash
-echo "---GIT---"
-LAST_REPORT=$(ls -t .planning/reports/report-*.docx .planning/reports/report-*.md 2>/dev/null | head -1)
-if [ -n "$LAST_REPORT" ]; then
-  SINCE_DATE=$(stat -c %Y "$LAST_REPORT" 2>/dev/null)
-  SINCE=$(date -d "@$SINCE_DATE" '+%Y-%m-%d %H:%M' 2>/dev/null || echo "8 hours ago")
-else
-  SINCE="8 hours ago"
-fi
-echo "SINCE:$SINCE"
-echo "---COMMITS---"
-git log --oneline --since="$SINCE" 2>/dev/null | head -20
-echo "---STATS---"
-COMMIT_COUNT=$(git log --oneline --since="$SINCE" 2>/dev/null | wc -l)
-echo "COUNT:$COMMIT_COUNT"
-FIRST=$(git log --format="%ar" --since="$SINCE" 2>/dev/null | tail -1)
-LAST=$(git log --format="%ar" --since="$SINCE" 2>/dev/null | head -1)
-echo "FIRST:$FIRST"
-echo "LAST:$LAST"
-echo "---PROJECT---"
-echo "DIR:$(basename $(pwd))"
-echo "BRANCH:$(git branch --show-current 2>/dev/null)"
-echo "---STATE---"
-test -f .planning/STATE.md && head -20 .planning/STATE.md || echo "no-state"
-echo "---PHASE---"
-test -f .planning/ROADMAP.md && grep -A2 "^## Phase" .planning/ROADMAP.md | head -6 || echo "no-roadmap"
-```
-
-### 2. Synthesize — Keep It Simple
-
-From the gathered data, build a **concise** summary. The report should answer:
-
-1. **What was done?** — 3-6 bullet points summarizing accomplishments in plain language. Group related commits into single items. Don't list every file changed.
-2. **Any deviations?** — Only include if something was done differently from the plan. Skip this section entirely if everything went as planned.
-3. **Any blockers?** — Only include if something is actually blocked. Skip if none.
-4. **What's next?** — 1-3 clear next actions.
-
-**Tone:** Write for a busy founder reviewing work. Clear, factual, no filler. Each bullet should start with a verb: "Built...", "Fixed...", "Added...", "Refactored..."
-
-### 3. Generate DOCX
-
-Build a JSON object and pipe it to the generator:
-
-```bash
-mkdir -p .planning/reports
-
-cat <<'REPORT_JSON' | python3 ~/.claude/qualia-framework/bin/generate-report-docx.py ".planning/reports/report-$(date +%Y-%m-%d-%H%M).docx"
-{
-    "project": "<project-name>",
-    "user": "<git config user.name or 'Fawzi Goussous'>",
-    "date": "<YYYY-MM-DD>",
-    "time": "<HH:MM>",
-    "branch": "<current-branch>",
-    "duration": "<estimated from first to last commit, e.g. ~3 hours>",
-    "phase": "<Phase N of M — name, or omit if no .planning>",
-    "done": [
-        "<accomplishment 1>",
-        "<accomplishment 2>",
-        "<accomplishment 3>"
-    ],
-    "deviations": [],
-    "blockers": [],
-    "next": [
-        "<next action 1>",
-        "<next action 2>"
-    ],
-    "commits": [
-        "<hash> <message>",
-        "<hash> <message>"
-    ]
-}
-REPORT_JSON
-```
-
-**Important:** The JSON must be valid. Escape any quotes in commit messages. Omit `deviations` and `blockers` arrays if empty (the generator handles missing keys gracefully).
-
-### 4. Commit & Auto-Upload to ERP
-
-```bash
-# Commit the report
-git add .planning/reports/report-*.docx
-git commit -m "report: session report $(date +%Y-%m-%d) — $(basename $(pwd))"
-```
-
-Then **auto-upload** the report to the ERP so it's linked to the employee's active work session. This is mandatory and happens automatically — employees cannot skip or edit the report before it reaches the ERP.
-
-```bash
-# Auto-upload to ERP
-REPORT_FILE=$(ls -t .planning/reports/report-*.docx 2>/dev/null | head -1)
-EMPLOYEE_EMAIL=$(git config user.email)
-PROJECT_NAME=$(basename $(pwd))
-ERP_URL="https://portal.qualiasolutions.net/api/claude/report-upload"
-API_KEY=$(cat ~/.claude/.env 2>/dev/null | grep CLAUDE_API_KEY | cut -d= -f2 || echo "")
-
-if [ -z "$API_KEY" ]; then
-  # Try from project env
-  API_KEY=$(grep CLAUDE_API_KEY .env.local 2>/dev/null | cut -d= -f2 || echo "")
-fi
-
-if [ -n "$REPORT_FILE" ] && [ -n "$API_KEY" ]; then
-  UPLOAD_RESULT=$(curl -s -X POST "$ERP_URL" \
-    -H "x-api-key: $API_KEY" \
-    -F "file=@$REPORT_FILE" \
-    -F "employee_email=$EMPLOYEE_EMAIL" \
-    -F "project_name=$PROJECT_NAME")
-  echo "ERP upload: $UPLOAD_RESULT"
-else
-  echo "WARNING: Could not auto-upload report to ERP (missing API key or report file)"
-fi
-```
-
-Then tell the user:
-
-> Report saved to `.planning/reports/report-{date}.docx` and **auto-uploaded to ERP**.
->
-> Your report is now linked to your active work session. When you clock out, it will already be attached.
->
-> Want to save session context too? Run `/qualia-pause-work`
-
-### 5. Update STATE.md (if exists)
-
-Update `Last activity` and `Last worked by` fields.
-
-## Weekly Report (`--week`)
-
-When run with `--week`:
-
-1. Read all reports from the last 7 days (check `.planning/reports/`)
-2. Read git log for the full week
-3. Build an aggregate JSON with:
-   - `"project"` — project name
-   - `"date"` — current date with "Weekly" suffix
-   - `"duration"` — "Week of {date} to {date}"
-   - `"done"` — combined accomplishments from all sessions, deduplicated
-   - `"next"` — forward-looking items from the most recent report
-   - `"commits"` — full week's commits
-4. Pipe to the same generator, save as `weekly-{date}.docx`
-
-## Generator Location
-
-`~/.claude/qualia-framework/bin/generate-report-docx.py`
-
-Requires: `python-docx` (pre-installed). Uses Qualia logo from `~/.claude/qualia-framework/assets/qualia-logo.png`.
-
----
-> Stuck? Type `/qualia-idk` · Lost? Type `/qualia-help`

package/framework/skills/qualia-research-phase/SKILL.md

@@ -1,88 +0,0 @@
----
-name: qualia-research-phase
-description: "Conduct standalone research for a project phase — ecosystem analysis, feasibility studies, implementation patterns, comparisons. Use this skill whenever the user says 'research', 'research phase', 'investigate options', 'tech research', or wants to explore technical options before planning a phase. Also trigger when user mentions 'feasibility study', 'compare frameworks', 'what stack should we use', or needs structured research output that feeds into phase planning."
----
-
-# Qualia Research Phase — Phase Research
-
-Conduct structured research for a project phase, producing a RESEARCH.md that feeds directly into phase planning.
-
-## Usage
-
-`/qualia-research-phase 3` — Research for phase 3 (default: ecosystem mode)
-`/qualia-research-phase 3 --mode=feasibility` — Feasibility study
-`/qualia-research-phase 3 --mode=implementation` — Implementation patterns
-`/qualia-research-phase 3 --mode=comparison` — Compare alternatives
-
-## Research Modes
-
-- **ecosystem** (default) — Survey the landscape: what libraries, APIs, patterns exist for this problem
-- **feasibility** — Can we do this? What are the blockers? What's the effort?
-- **implementation** — How should we build this? Concrete patterns and examples
-- **comparison** — Compare 2-3 approaches side by side with tradeoffs
-
-## Process
-
-### 1. Initialize
-
-Use `qualia-tools.js` for state management:
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js phase-op <phase>
-```
-
-Validate the phase exists in ROADMAP.md. Check if research already exists at `.planning/phases/{phase}-{slug}/{phase}-RESEARCH.md`.
-
-### 2. Gather Context
-
-Read project context:
-- `.planning/PROJECT.md` — tech stack, constraints
-- `.planning/ROADMAP.md` — phase description and dependencies
-- Phase CONTEXT.md if it exists (from discuss-phase)
-
-### 3. Spawn Researcher
-
-Spawn the `qualia-phase-researcher` agent with full context.
-
-Reference: `~/.claude/agents/qualia-phase-researcher.md`
-
-Model resolution:
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js resolve-model qualia-phase-researcher
-```
-
-### 4. Research Output
-
-The researcher produces `.planning/phases/{phase}-{slug}/{phase}-RESEARCH.md` with sections designed for downstream consumption by plan-phase:
-
-- **Standard Stack** — Recommended libraries and tools
-- **Architecture Patterns** — How to structure the implementation
-- **Don't Hand-Roll** — Things to use existing solutions for
-- **Common Pitfalls** — What to watch out for
-- **Code Examples** — Concrete snippets showing key patterns
-
-### 5. Handle Return
-
-The researcher returns one of:
-- **COMPLETE** — Research done, ready for planning
-- **CHECKPOINT** — Partial results, needs more investigation (spawn continuation)
-- **INCONCLUSIVE** — Couldn't determine best approach, present options to user
-
-### When to Use /deep-research Instead
-
-| Use `/qualia-research-phase` | Use `/deep-research` |
-|------------------------------|----------------------|
-| Phase-specific technical research | Whole-project architectural analysis |
-| Output feeds into `/qualia-plan-phase` | Output is a standalone report |
-| 1 researcher agent, fast | 6 parallel Opus agents, thorough |
-| "How should we build phase 3?" | "Is this codebase production-ready?" |
-
-Both can be combined: `/deep-research` for architectural context, then `/qualia-research-phase` for the specific phase.
-
-### 6. Next Step
-
-> "Research complete for phase {N}. Run `/qualia-plan-phase {N}` to create the execution plan."
-
-### Agents Used
-| Agent | File | Role |
-|-------|------|------|
-| `qualia-phase-researcher` | `~/.claude/agents/qualia-phase-researcher.md` | Conducts phase-specific research |