qualia-framework 2.5.1 → 3.1.0

package/framework/skills/qualia-new-project/SKILL.md

@@ -1,232 +0,0 @@
----
-name: qualia-new-project
-description: "Initialize a new Qualia workflow project from scratch — questioning, research, requirements, roadmap, environment setup, design context. Use this skill whenever the user says 'new project', 'start project', 'init project', 'qualia new', or wants to begin a brand new project with the Qualia workflow. Also trigger when user mentions setting up .planning directory, creating a roadmap, or starting fresh on a new client project."
----
-
-# Qualia New Project — Full Project Initialization
-
-Initialize a new project with the complete Qualia workflow: questioning → research → requirements → roadmap → environment → design context. Produces everything needed for an employee to start building and carry through to client handoff.
-
-## Usage
-
-`/qualia-new-project` — Start new project initialization
-`/qualia-new-project "Build AI chatbot for client X"` — Start with initial description
-
-## Process
-
-Reference: `~/.claude/qualia-framework/workflows/new-project.md` (the full 1000+ line workflow — follow it exactly)
-
-### 0. Pre-flight
-
-**Initialize context:**
-```bash
-INIT=$(node /home/qualia/.claude/qualia-framework/bin/qualia-tools.js init new-project)
-```
-
-Parse JSON for: `researcher_model`, `synthesizer_model`, `roadmapper_model`, `project_exists`, `has_existing_code`, `needs_codebase_map`, `has_git`.
-
-- If `project_exists` is true → Error: "Project already initialized. Run `/qualia-progress` to see status."
-- If `has_git` is false → `git init`
-
-**Scan for uploaded files** (PDFs, docs, images). If they mention a non-Qualia stack, ask:
-> "The document mentions {stack}. Use the Qualia stack (Next.js + Supabase + Vercel) or the document's stack?"
-
-**Brownfield detection:** If existing code found without a codebase map, scan the codebase structure before proceeding.
-
-### 1. Deep Questioning
-
-Reference: `~/.claude/qualia-framework/references/questioning.md`
-
-**Start open:** "What do you want to build?"
-
-Then follow threads — dig into what they said. This is dream extraction, not an interview. Ask about:
-- What is it? Who is it for?
-- What problem does it solve?
-- What does "done" look like?
-- What are the constraints (timeline, budget, existing systems)?
-
-Use AskUserQuestion with concrete options to help them think. Challenge vagueness. Make abstract things concrete ("walk me through using this").
-
-**Decision gate:** When you have enough to write PROJECT.md, ask:
-> "I think I understand. Ready to create PROJECT.md, or want to explore more?"
-
-### 2. Detect Project Type & Load Template
-
-Based on questioning answers, detect the project type:
-
-| Signal | Type | Template |
-|--------|------|----------|
-| website, landing page, marketing, SaaS | `website` | `templates/projects/website.md` |
-| chatbot, AI assistant, chat agent | `ai-agent` | `templates/projects/ai-agent.md` |
-| voice agent, phone agent, call bot, Retell | `voice-agent` | `templates/projects/voice-agent.md` |
-| mobile app, iOS, Android, Expo | `mobile-app` | `templates/projects/mobile-app.md` |
-
-**Always load the matching template.** Read it from `~/.claude/qualia-framework/templates/projects/{type}.md`. This gives you the standard phase structure for this project type — the roadmap will use it as a scaffold.
-
-Ask the employee to confirm:
-> "This looks like a {type} project. I'll use the {type} template for the phase structure. Sound right?"
-
-If no type detected, build the roadmap from scratch.
-
-### 3. Write PROJECT.md
-
-Template: `~/.claude/qualia-framework/templates/project.md`
-
-Synthesize all context into `.planning/PROJECT.md`:
-- Project name, description, client
-- Core Value (the ONE thing that must work)
-- Requirements (Active = hypotheses until shipped)
-- Context, Constraints, Key Decisions
-- Tech stack decisions
-- Deploy target
-
-**Commit immediately:**
-```bash
-mkdir -p .planning
-node ~/.claude/qualia-framework/bin/qualia-tools.js commit "docs: initialize project" --files .planning/PROJECT.md
-```
-
-### 4. Workflow Preferences
-
-Use sensible defaults. Only ask ONE question:
-
-```
-"Use recommended settings? (Interactive mode, standard depth, all quality agents, balanced profile)"
-  → Yes (Recommended) — use all defaults
-  → Customize — show individual options
-```
-
-**Defaults** (written to `.planning/config.json`):
-- Mode: Interactive
-- Depth: Standard (5-8 phases)
-- Execution: Parallel
-- Researcher: enabled
-- Plan Checker: enabled
-- Verifier: enabled
-- Model Profile: Balanced
-
-**If "Customize":** Show the individual options as AskUserQuestion. Otherwise skip straight to config.json creation.
-
-Write `.planning/config.json` with all settings.
-
-**Commit:**
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js commit "chore: add project config" --files .planning/config.json
-```
-
-### 5. Research Phase (if selected)
-
-Spawn 4 parallel research agents:
-1. **Stack research** → `.planning/research/STACK.md`
-2. **Features research** → `.planning/research/FEATURES.md`
-3. **Architecture research** → `.planning/research/ARCHITECTURE.md`
-4. **Pitfalls research** → `.planning/research/PITFALLS.md`
-
-Then spawn synthesizer → `.planning/research/SUMMARY.md`
-
-Present key findings to employee before moving on.
-
-### 6. Define Requirements
-
-Load context from PROJECT.md and research (if exists).
-
-**If research exists:** Present features by category (table stakes vs differentiators). Let employee scope each category for v1 using AskUserQuestion with multiSelect.
-
-**If no research:** Gather requirements conversationally.
-
-Generate `.planning/REQUIREMENTS.md` with:
-- v1 Requirements grouped by category (with REQ-IDs like AUTH-01, CONT-02)
-- v2 Requirements (deferred)
-- Out of Scope (with reasons)
-- Traceability section (filled by roadmap)
-
-**Show full requirements list for approval.** Loop until employee confirms.
-
-**Commit:**
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js commit "docs: define v1 requirements" --files .planning/REQUIREMENTS.md
-```
-
-### 7. Create Roadmap
-
-Spawn qualia-roadmapper agent with PROJECT.md, REQUIREMENTS.md, research, config, and the project type template.
-
-**Roadmap contains FEATURE PHASES ONLY.** Do NOT add review, deploy, or handoff phases to the roadmap. The finish line system (`/qualia-complete-milestone` → polish → review → PR → deploy → handoff) handles the 70%-to-100% journey automatically after all feature phases are done. Adding them to the roadmap would cause employees to do them twice.
-
-**If using a project type template:** Use its phases as the feature scaffold.
-
-**Present roadmap to employee for approval.** Show phase table with goals, requirements mapped, and success criteria. Loop until approved.
-
-**Commit:**
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js commit "docs: create roadmap ([N] phases)" --files .planning/ROADMAP.md .planning/STATE.md .planning/REQUIREMENTS.md
-```
-
-### 8. Environment Setup
-
-Detect what's needed from PROJECT.md and stack:
-
-- **Supabase** → Link or create project, init schema
-- **Vercel** → Link project
-- **Environment variables** → Create `.env.local` with placeholders
-- **External services** → Note which API keys are needed (Stripe, Retell, OpenRouter, etc.)
-
-Walk the employee through setup. If they want to skip: note `env_setup: pending` in STATE.md.
-
-**Starter template:** If a matching starter exists at `~/Projects/qualia-erp/templates/{type}-starter/`, offer to scaffold from it.
-
-### 9. Design Context (frontend projects)
-
-If the project involves frontend work (detected from roadmap or project type), create `.planning/DESIGN.md` with a brief design consultation:
-
-Ask the employee 3 questions using AskUserQuestion:
-1. **Aesthetic direction** — "What feel should this project have?" (options: Clean/minimal, Bold/striking, Warm/friendly, Corporate/professional)
-2. **Color palette** — "Any brand colors or preferences?" (freeform — or offer to pick based on aesthetic)
-3. **Reference sites** — "Any websites you'd like it to look/feel like?" (freeform)
-
-Write `.planning/DESIGN.md` with the answers. This is read by the frontend guard before any UI work.
-
-**Do NOT run `/critique` here** — there's no code to critique yet. Design consultation creates the brief; `/critique` reviews implemented UI later.
-
-### 10. Done — Present Summary
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Qualia ► PROJECT INITIALIZED ✓
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**[Project Name]** — [type] project for [client]
-
-| Artifact       | Location                    |
-|----------------|-----------------------------|
-| Project        | .planning/PROJECT.md        |
-| Config         | .planning/config.json       |
-| Research       | .planning/research/         |
-| Requirements   | .planning/REQUIREMENTS.md   |
-| Roadmap        | .planning/ROADMAP.md        |
-| State          | .planning/STATE.md          |
-| Design         | .planning/DESIGN.md         |
-
-**[N] phases** | **[X] requirements** | Ready to build ✓
-
-## The Full Journey
-
-Phase 1-{N}: Feature phases (build the product)
-  ↓ after all phases verified
-Finish Line: Polish → Review → PR → Deploy → Handoff (automated by /qualia)
-
-## ▶ Next
-
-Run `/qualia-plan-phase 1` to plan the first phase.
-(Or `/qualia-discuss-phase 1` to discuss approach first.)
-```
-
-### Agents Used
-| Agent | File | Role |
-|-------|------|------|
-| `qualia-project-researcher` | `~/.claude/agents/qualia-project-researcher.md` | Domain ecosystem research (4 parallel) |
-| `qualia-research-synthesizer` | `~/.claude/agents/qualia-research-synthesizer.md` | Synthesizes parallel research |
-| `qualia-roadmapper` | `~/.claude/agents/qualia-roadmapper.md` | Creates ROADMAP.md with feature phases |
-
----
-> Stuck? Type `/qualia-idk` · Lost? Type `/qualia-help`

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

@@ -1,417 +0,0 @@
----
-name: qualia-optimize
-description: "Deep optimization pass — reads .planning/ AND codebase to find performance, design, UI, backend, and frontend issues. Spawns parallel specialist agents. Use this skill whenever the user says 'optimize', 'optimization pass', 'find issues', 'qualia-optimize', 'deep optimize', 'performance audit', 'design alignment check', 'speed up', 'slow', 'bundle size', or wants a comprehensive quality sweep. Supports --perf, --ui, --backend, --alignment, --fix flags."
----
-
-# Qualia Optimize — Deep Codebase + Planning Optimization
-
-Comprehensive optimization that reads BOTH `.planning/` docs AND the actual codebase. Never analyze one without the other.
-
-## Usage
-
-- `/qualia-optimize` — Full optimization (all 6 dimensions)
-- `/qualia-optimize --perf` — Performance only (queries, bundle, render, latency)
-- `/qualia-optimize --ui` — Frontend/design/UI only
-- `/qualia-optimize --backend` — Backend only (RLS, auth, queries, edge functions)
-- `/qualia-optimize --alignment` — Planning-code alignment check only
-- `/qualia-optimize --fix` — Auto-fix LOW/MEDIUM findings from existing OPTIMIZE.md
-
-## Process
-
-### Step 1: Parse Arguments
-
-Extract mode from $ARGUMENTS. Default to `full`.
-
-Supported modes: `full`, `perf`, `ui`, `backend`, `alignment`, `fix`.
-
-If `--fix`: skip to Step 9 (requires existing `.planning/OPTIMIZE.md`).
-
-### Step 2: Load Planning Context (MANDATORY — never skip)
-
-Read ALL of these (skip silently if file doesn't exist, but always attempt):
-
-```bash
-cat .planning/PROJECT.md 2>/dev/null || echo "NO_PROJECT"
-```
-
-```bash
-cat .planning/REQUIREMENTS.md 2>/dev/null || echo "NO_REQUIREMENTS"
-```
-
-```bash
-cat .planning/ROADMAP.md 2>/dev/null || echo "NO_ROADMAP"
-```
-
-```bash
-cat .planning/STATE.md 2>/dev/null || echo "NO_STATE"
-```
-
-```bash
-cat .planning/DESIGN.md 2>/dev/null || echo "NO_DESIGN"
-```
-
-Also read the rules:
-```bash
-cat ~/.claude/rules/frontend.md 2>/dev/null
-cat ~/.claude/rules/security.md 2>/dev/null
-```
-
-Store all content — you will inline it into agent prompts.
-
-**If NO planning docs exist at all**: warn the user but proceed. The optimization still works on raw codebase — it just can't check alignment.
-
-### Step 3: Discover Codebase
-
-```bash
-pwd && node -e "try{const p=require('./package.json');console.log(JSON.stringify({name:p.name,deps:Object.keys(p.dependencies||{}),devDeps:Object.keys(p.devDependencies||{})}))}catch(e){console.log('{}')}" 2>/dev/null
-```
-
-```bash
-git log --oneline -15 2>/dev/null
-```
-
-```bash
-git diff --stat HEAD~10..HEAD 2>/dev/null | tail -5
-```
-
-```bash
-# Project structure
-ls -d app/ src/ pages/ components/ lib/ actions/ hooks/ supabase/ types/ 2>/dev/null
-```
-
-Classify project type: `web` | `voice` | `mobile` | `agent` | `edge-functions` | `unknown`
-
-### Step 4: Spawn Wave 1 Agents (parallel)
-
-Based on mode, spawn agents in a **single message** with multiple Agent() calls.
-
-| Mode | Agents |
-|------|--------|
-| `full` | frontend-agent + backend-agent + performance-oracle (3 parallel) |
-| `perf` | performance-oracle only |
-| `ui` | frontend-agent only |
-| `backend` | backend-agent only |
-| `alignment` | general-purpose with alignment prompt |
-
-**CRITICAL**: Inline ALL planning context into each agent prompt. `@` references don't work across Agent() boundaries.
-
-#### Frontend Agent Prompt
-
-```
-Agent(
-  prompt="You are optimizing a project's frontend. Read the planning docs and codebase rules below, then analyze the actual code.
-
-<planning>
-{PROJECT.md content}
-{REQUIREMENTS.md content}
-{DESIGN.md content}
-</planning>
-
-<rules>
-{rules/frontend.md content}
-</rules>
-
-<task>
-Analyze the frontend codebase for issues in these categories:
-
-1. **UI Quality**
-   - Loading states: every async operation should show a loading indicator
-   - Error states: every data-fetching component should handle errors gracefully
-   - Empty states: lists/tables should handle zero items with helpful messaging
-   - Responsive: check for fixed pixel widths on containers, missing breakpoint handling
-   - Accessibility: alt text on images, ARIA labels on interactive elements, keyboard navigation
-
-2. **Design Alignment**
-   - Compare actual components against DESIGN.md decisions (colors, typography, spacing)
-   - Check rules/frontend.md compliance: distinctive fonts? sharp accents? transitions? No card grids or blue-purple gradients?
-   - Consistency: are the same patterns used throughout? (button styles, spacing, color usage)
-
-3. **Frontend Performance**
-   - Bundle: large library imports that could be tree-shaken or dynamically imported
-   - Images: using next/image? width/height set? lazy loading below fold?
-   - Fonts: using next/font? No render-blocking font loads?
-   - CSS: unused Tailwind classes? conflicting styles?
-   - Rendering: unnecessary re-renders, missing React.memo on list items, heavy computations in render
-
-For EVERY finding, output in this exact format:
-- **What**: [description]
-- **Where**: [file:line]
-- **Why**: [impact on users/performance]
-- **Fix**: [concrete fix suggestion]
-- **Severity**: CRITICAL | HIGH | MEDIUM | LOW
-</task>",
-  subagent_type="frontend-agent",
-  description="Frontend optimization analysis"
-)
-```
-
-#### Backend Agent Prompt
-
-```
-Agent(
-  prompt="You are optimizing a project's backend. Read the planning docs and security rules below, then analyze the actual code.
-
-<planning>
-{PROJECT.md content}
-{REQUIREMENTS.md content}
-</planning>
-
-<rules>
-{rules/security.md content}
-</rules>
-
-<task>
-Analyze the backend codebase for issues:
-
-1. **Security**
-   - RLS: every Supabase table must have ROW LEVEL SECURITY enabled with policies
-   - Service role: grep for service_role key usage in client-side code (app/, components/, src/) — should be ZERO
-   - Auth: all mutations use server-side auth check (supabase.auth.getUser())
-   - Validation: input validated with Zod before database operations
-   - No dangerouslySetInnerHTML or eval()
-
-2. **Data Access Patterns**
-   - Server actions vs client mutations: data writes should use 'use server' actions, not direct Supabase client calls
-   - Proper error handling: try/catch with meaningful error messages
-   - Revalidation: revalidatePath/revalidateTag after mutations
-
-3. **Edge Functions** (if supabase/functions/ exists)
-   - Cold start optimization: bundle size, dependency count
-   - Error handling and logging
-   - CORS configuration
-   - Timeout protection (maxDuration)
-
-4. **API Quality**
-   - Rate limiting on public endpoints
-   - Proper HTTP status codes
-   - Consistent error response format
-
-For EVERY finding, output:
-- **What**: [description]
-- **Where**: [file:line]
-- **Why**: [impact]
-- **Fix**: [concrete suggestion]
-- **Severity**: CRITICAL | HIGH | MEDIUM | LOW
-</task>",
-  subagent_type="backend-agent",
-  description="Backend optimization analysis"
-)
-```
-
-#### Performance Oracle Prompt
-
-```
-Agent(
-  prompt="You are analyzing cross-cutting performance issues. Read the project context, then analyze the codebase.
-
-<planning>
-{PROJECT.md content}
-</planning>
-
-<task>
-Analyze for performance issues across the full stack:
-
-1. **Database Queries**
-   - N+1 queries: Supabase .from() calls inside loops or .map()
-   - Missing indexes: .eq()/.filter()/.order() columns without corresponding indexes in migrations
-   - Sequential queries that could be parallel (Promise.all)
-   - Over-fetching: SELECT * when only specific columns needed
-
-2. **API Latency**
-   - Sequential API calls from client that could be batched
-   - Missing caching (SWR/React Query stale times, HTTP cache headers)
-   - Large payloads without pagination
-
-3. **Bundle Size**
-   - Barrel exports (index.ts re-exporting everything) preventing tree-shaking
-   - Large libraries imported for single functions (lodash, moment)
-   - Missing dynamic imports for heavy components (charts, editors, maps)
-
-4. **Render Performance**
-   - Expensive computations in render path without useMemo
-   - Event handlers recreated on every render without useCallback
-   - Large lists without virtualization
-   - Context providers causing unnecessary re-renders
-
-For EVERY finding, output:
-- **What**: [description]
-- **Where**: [file:line]
-- **Why**: [performance impact, quantified if possible]
-- **Fix**: [concrete suggestion]
-- **Severity**: CRITICAL | HIGH | MEDIUM | LOW
-</task>",
-  subagent_type="performance-oracle",
-  description="Performance optimization analysis"
-)
-```
-
-### Step 5: Spawn Wave 2 Agent (after Wave 1 completes)
-
-After all Wave 1 agents return, spawn the architecture strategist with their combined findings:
-
-```
-Agent(
-  prompt="You are synthesizing optimization findings from 3 specialist agents. Look for cross-cutting architectural issues.
-
-<wave1_findings>
-{All findings from frontend-agent, backend-agent, performance-oracle}
-</wave1_findings>
-
-<planning>
-{PROJECT.md content}
-{REQUIREMENTS.md content}
-</planning>
-
-<task>
-1. Identify patterns across findings — recurring issues that point to a structural problem
-2. Find coupling issues between frontend and backend
-3. Check for inconsistent patterns (e.g., some routes use server actions, others use API routes)
-4. Identify missing abstractions (same pattern repeated 3+ times)
-5. Check for dead code and unused exports
-
-Output:
-- **Structural findings** (architectural issues, not covered by Wave 1)
-- **Pattern consolidation** (where Wave 1 findings share a root cause)
-- Each finding in the same format: What/Where/Why/Fix/Severity
-</task>",
-  subagent_type="architecture-strategist",
-  description="Architecture synthesis"
-)
-```
-
-**Skip Wave 2 for single-mode runs** (`--perf`, `--ui`, `--backend`). Only run for `full` mode.
-
-### Step 6: Alignment Check (always runs in `full` and `alignment` modes)
-
-For `alignment` mode, this is the sole analysis. For `full` mode, run alongside Wave 1.
-
-Read REQUIREMENTS.md and ROADMAP.md. For each requirement marked "Complete" or mapped to a completed phase:
-
-```bash
-# Find completed requirements
-grep -E "Complete|✓" .planning/REQUIREMENTS.md 2>/dev/null
-```
-
-For each completed requirement:
-- Grep the codebase for evidence it actually exists (routes, components, API endpoints)
-- If not found: flag as "Claimed complete but not implemented"
-
-Then scan for orphan features:
-```bash
-# Find all routes/pages
-find app -name "page.tsx" -o -name "route.ts" 2>/dev/null
-# Find all API routes
-find app/api -name "route.ts" 2>/dev/null
-```
-
-Cross-reference with REQUIREMENTS.md — any route/feature NOT in requirements is flagged as "Undocumented feature".
-
-### Step 7: Collect and Score Findings
-
-After all agents return:
-1. Deduplicate (same file:line from multiple agents → keep the most detailed one)
-2. Sort by severity: CRITICAL first
-3. Group by dimension: Performance, Design Alignment, UI Quality, Backend, Frontend, Planning-Code Alignment, Architecture
-
-Count totals per severity.
-
-### Step 8: Write OPTIMIZE.md and Present Results
-
-Write to `.planning/OPTIMIZE.md`:
-
-```markdown
----
-date: {YYYY-MM-DD HH:MM}
-mode: {full|perf|ui|backend|alignment}
-critical: {N}
-high: {N}
-medium: {N}
-low: {N}
-status: {clean|needs_attention|critical_issues}
----
-
-# Optimization Report
-
-**Project:** {name} | **Mode:** {mode} | **Date:** {date}
-
-## Summary
-
-{2-3 sentence overview}
-
-{If status is clean: "No critical issues found. Project is in good shape."}
-
-## Critical Issues
-
-| # | Dimension | Finding | Location | Fix |
-|---|-----------|---------|----------|-----|
-{findings}
-
-## High Priority
-
-| # | Dimension | Finding | Location | Fix |
-|---|-----------|---------|----------|-----|
-{findings}
-
-## Medium Priority
-
-| # | Dimension | Finding | Location | Fix |
-|---|-----------|---------|----------|-----|
-{findings}
-
-## Low Priority
-
-| # | Dimension | Finding | Location | Fix |
-|---|-----------|---------|----------|-----|
-{findings}
-```
-
-Commit:
-```bash
-node ~/.claude/qualia-framework/bin/qualia-tools.js commit "docs: optimization report ({mode} mode, {critical} critical)" --files .planning/OPTIMIZE.md
-```
-
-**Present results:**
-
-If CRITICAL findings exist:
-```
-{critical} critical issues found. Options:
-
-1. Create a fix phase in ROADMAP.md for critical + high findings
-2. Auto-fix LOW/MEDIUM findings: /qualia-optimize --fix
-3. Review full report: cat .planning/OPTIMIZE.md
-```
-
-If no CRITICAL:
-```
-Optimization complete. {total} findings ({high} high, {medium} medium, {low} low).
-Report: .planning/OPTIMIZE.md
-
-Run /qualia-optimize --fix to auto-fix LOW/MEDIUM findings.
-```
-
-### Step 9: --fix Mode
-
-When `--fix` is provided:
-
-1. Read existing `.planning/OPTIMIZE.md` — if not found, error: "Run /qualia-optimize first"
-2. Filter to LOW and MEDIUM findings only
-3. For each finding with a clear, safe fix:
-   - Read the target file
-   - Apply the fix
-   - Verify it doesn't break (npx tsc --noEmit if TypeScript)
-4. Update OPTIMIZE.md: mark fixed findings, recount severities
-5. Commit changes
-6. Report what was fixed and what remains
-
-**Never auto-fix CRITICAL or HIGH** — those require human judgment.
-
-### Step 10: Gap Phase Creation (if user selects option 1 from Step 8)
-
-If user wants a fix phase for critical issues:
-
-1. Read ROADMAP.md, find current phase number
-2. Insert a decimal phase: `Phase {N}.1: Optimization Fixes (INSERTED)`
-3. Map CRITICAL and HIGH findings as success criteria
-4. Update STATE.md
-5. Commit
-6. Suggest: "Fix phase created. Run `/qualia-plan-phase {N}.1`"