qualia-framework-v2 2.0.0

package/guide.md

@@ -0,0 +1,63 @@
+# Qualia Developer Guide
+
+> Follow the road. Type the commands. The framework handles the rest.
+
+## The Road
+
+```
+/qualia-new          ← Set up project (once)
+     ↓
+For each phase:
+  /qualia-plan       ← Plan it (planner agent)
+  /qualia-build      ← Build it (builder subagents)
+  /qualia-verify     ← Verify it works (verifier agent)
+     ↓
+/qualia-polish       ← Design pass
+/qualia-ship         ← Deploy to production
+/qualia-handoff      ← Deliver to client
+     ↓
+Done.
+```
+
+## The 10 Commands
+
+| When | Command | What it does |
+|------|---------|-------------|
+| Starting | `/qualia-new` | Set up project from scratch |
+| Building | `/qualia-plan` | Plan the current phase |
+| | `/qualia-build` | Build it (parallel tasks) |
+| | `/qualia-verify` | Check it actually works |
+| Quick fix | `/qualia-quick` | Skip planning, just do it |
+| Finishing | `/qualia-polish` | Design and UX pass |
+| | `/qualia-ship` | Deploy to production |
+| | `/qualia-handoff` | Deliver to client |
+| Reporting | `/qualia-report` | Log what you did (mandatory) |
+| **Lost?** | **`/qualia`** | **Tells you the exact next command** |
+
+## Rules
+
+1. **Feature branches only** — never push to main
+2. **Read before write** — don't edit files you haven't read
+3. **MVP first** — build what's asked, nothing extra
+4. **`/qualia` is your friend** — lost? type it
+
+## When You're Stuck
+
+```
+/qualia       ← "what's next?"
+```
+
+If that doesn't help, paste the error and ask Claude directly. If Claude can't fix it, tell Fawzi.
+
+## Session Start / End
+
+**Start:** Claude loads your project context automatically.
+**End:** Run `/qualia-report` — this is mandatory before clock-out.
+
+## How It Works (you don't need to know this, but if curious)
+
+- **Context isolation:** Each task runs in a fresh AI brain. Task 50 gets the same quality as Task 1.
+- **Goal-backward verification:** The verifier doesn't trust "I built it." It greps the code to check if things actually work.
+- **Plans are prompts:** The plan file IS what the builder reads. No translation loss.
+- **Wave execution:** Independent tasks run in parallel. Dependent tasks wait.
+- **tracking.json:** Updated on every push. The ERP reads it automatically.

package/hooks/block-env-edit.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# Prevent Claude from editing .env files
+
+FILE="$1"
+if [[ "$FILE" == *.env* ]] || [[ "$FILE" == *".env.local"* ]] || [[ "$FILE" == *".env.production"* ]]; then
+  echo "BLOCKED: Cannot edit environment files. Ask Fawzi to update secrets."
+  exit 1
+fi

package/hooks/branch-guard.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Block non-OWNER push to main/master
+
+BRANCH=$(git branch --show-current 2>/dev/null)
+ROLE=$(grep -m1 "^## Role:" ~/.claude/CLAUDE.md 2>/dev/null | sed 's/^## Role: *//')
+
+if [[ "$BRANCH" == "main" || "$BRANCH" == "master" ]]; then
+  if [[ "$ROLE" != "OWNER" ]]; then
+    echo "BLOCKED: Employees cannot push to $BRANCH. Create a feature branch first."
+    echo "Run: git checkout -b feature/your-feature-name"
+    exit 1
+  fi
+fi

package/hooks/pre-compact.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+# Save state before context compression
+
+if [ -f ".planning/STATE.md" ]; then
+  echo "QUALIA: Saving state before compaction..."
+  # State is in git — just ensure it's committed
+  if git diff --name-only .planning/STATE.md 2>/dev/null | grep -q STATE; then
+    git add .planning/STATE.md
+    git commit -m "state: pre-compaction save" 2>/dev/null
+  fi
+fi

package/hooks/pre-deploy-gate.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Quality gates before production deploy
+
+echo "◆ Pre-deploy gate..."
+
+# TypeScript check
+if [ -f "tsconfig.json" ]; then
+  if ! npx tsc --noEmit 2>/dev/null; then
+    echo "BLOCKED: TypeScript errors. Fix before deploying."
+    exit 1
+  fi
+  echo "  ✓ TypeScript"
+fi
+
+# Build check
+if [ -f "package.json" ] && grep -q '"build"' package.json; then
+  if ! npm run build 2>/dev/null; then
+    echo "BLOCKED: Build failed. Fix before deploying."
+    exit 1
+  fi
+  echo "  ✓ Build"
+fi
+
+# Security: no service_role in client code
+LEAKS=$(grep -r "service_role" app/ components/ src/ 2>/dev/null | grep -v node_modules | grep -v ".server." | wc -l)
+if [ "$LEAKS" -gt 0 ]; then
+  echo "BLOCKED: service_role found in client code. Remove before deploying."
+  exit 1
+fi
+echo "  ✓ Security"
+
+echo "◆ All gates passed."

package/hooks/pre-push.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Update tracking.json from STATE.md before push
+
+TRACKING=".planning/tracking.json"
+STATE=".planning/STATE.md"
+
+if [ -f "$STATE" ] && [ -f "$TRACKING" ]; then
+  # Extract current phase from STATE.md
+  PHASE=$(grep "^Phase:" "$STATE" | head -1 | sed 's/Phase: *//' | cut -d' ' -f1)
+  STATUS=$(grep "^Status:" "$STATE" | head -1 | sed 's/Status: *//')
+  LAST_COMMIT=$(git log --oneline -1 --format="%h" 2>/dev/null)
+  NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+  # Update tracking.json with current values
+  if command -v python3 &>/dev/null; then
+    python3 -c "
+import json
+with open('$TRACKING', 'r') as f:
+    t = json.load(f)
+t['phase'] = int('${PHASE:-0}') if '${PHASE:-0}'.isdigit() else t.get('phase', 0)
+t['status'] = '${STATUS:-unknown}'.lower().replace(' ', '_')
+t['last_commit'] = '${LAST_COMMIT}'
+t['last_updated'] = '${NOW}'
+with open('$TRACKING', 'w') as f:
+    json.dump(t, f, indent=2)
+" 2>/dev/null
+    git add "$TRACKING" 2>/dev/null
+  fi
+fi

package/hooks/session-start.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Qualia session start — load project context
+# Triggered on Claude Code session start
+
+STATE=".planning/STATE.md"
+TRACKING=".planning/tracking.json"
+
+if [ -f "$STATE" ]; then
+  PHASE=$(grep "^Phase:" "$STATE" 2>/dev/null | head -1)
+  STATUS=$(grep "^Status:" "$STATE" 2>/dev/null | head -1)
+  echo "QUALIA: Project loaded. $PHASE | $STATUS"
+  echo "QUALIA: Run /qualia for next step."
+elif [ -f ".continue-here.md" ]; then
+  echo "QUALIA: Handoff file found. Read .continue-here.md to resume."
+else
+  echo "QUALIA: No project detected. Run /qualia-new to start."
+fi

package/install.sh

@@ -0,0 +1,223 @@
+#!/bin/bash
+# Qualia Framework v2 — Installer
+# Installs skills, agents, rules, hooks, templates, status line, and configures settings.json
+
+set -e
+
+FRAMEWORK_DIR="$(cd "$(dirname "$0")" && pwd)"
+CLAUDE_DIR="$HOME/.claude"
+
+echo "◆ Qualia Framework v2"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  Installing to $CLAUDE_DIR"
+echo ""
+
+# Skills
+echo "  Installing skills..."
+for skill_dir in "$FRAMEWORK_DIR"/skills/*/; do
+  skill_name=$(basename "$skill_dir")
+  mkdir -p "$CLAUDE_DIR/skills/$skill_name"
+  cp "$skill_dir/SKILL.md" "$CLAUDE_DIR/skills/$skill_name/SKILL.md"
+  echo "    ✓ $skill_name"
+done
+
+# Agents
+echo "  Installing agents..."
+mkdir -p "$CLAUDE_DIR/agents"
+for agent in "$FRAMEWORK_DIR"/agents/*.md; do
+  cp "$agent" "$CLAUDE_DIR/agents/"
+  echo "    ✓ $(basename "$agent")"
+done
+
+# Rules
+echo "  Installing rules..."
+mkdir -p "$CLAUDE_DIR/rules"
+for rule in "$FRAMEWORK_DIR"/rules/*.md; do
+  cp "$rule" "$CLAUDE_DIR/rules/"
+  echo "    ✓ $(basename "$rule")"
+done
+
+# Hook scripts
+echo "  Installing hook scripts..."
+mkdir -p "$CLAUDE_DIR/hooks"
+for hook in "$FRAMEWORK_DIR"/hooks/*.sh; do
+  cp "$hook" "$CLAUDE_DIR/hooks/"
+  chmod +x "$CLAUDE_DIR/hooks/$(basename "$hook")"
+  echo "    ✓ $(basename "$hook")"
+done
+
+# Status line
+echo "  Installing status line..."
+cp "$FRAMEWORK_DIR/statusline.sh" "$CLAUDE_DIR/statusline.sh"
+chmod +x "$CLAUDE_DIR/statusline.sh"
+echo "    ✓ statusline.sh"
+
+# Templates
+echo "  Installing templates..."
+mkdir -p "$CLAUDE_DIR/qualia-templates"
+for tmpl in "$FRAMEWORK_DIR"/templates/*; do
+  cp "$tmpl" "$CLAUDE_DIR/qualia-templates/"
+  echo "    ✓ $(basename "$tmpl")"
+done
+
+# CLAUDE.md (user-level — applies to all projects)
+echo "  Installing CLAUDE.md..."
+cp "$FRAMEWORK_DIR/CLAUDE.md" "$CLAUDE_DIR/CLAUDE.md"
+echo "    ✓ CLAUDE.md"
+
+# Guide
+cp "$FRAMEWORK_DIR/guide.md" "$CLAUDE_DIR/qualia-guide.md"
+echo "    ✓ guide.md"
+
+# Configure settings.json with hooks, status line, and env
+echo ""
+echo "  Configuring settings.json..."
+
+python3 << 'PYEOF'
+import json, os
+
+settings_path = os.path.expanduser("~/.claude/settings.json")
+
+# Load existing settings or start fresh
+if os.path.exists(settings_path):
+    with open(settings_path) as f:
+        settings = json.load(f)
+else:
+    settings = {}
+
+# Env vars
+settings.setdefault("env", {})
+settings["env"].update({
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY": "0",
+    "MAX_MCP_OUTPUT_TOKENS": "25000",
+    "CLAUDE_CODE_NO_FLICKER": "1"
+})
+
+# Status line — teal branded, 2-line
+settings["statusLine"] = {
+    "type": "command",
+    "command": "~/.claude/statusline.sh"
+}
+
+# Spinner verbs — Qualia branded
+settings["spinnerVerbs"] = {
+    "mode": "replace",
+    "verbs": [
+        "Qualia-fying", "Solution-ing", "Teal-crafting", "Vibe-forging",
+        "Shipping", "Wiring", "Polishing", "Verifying",
+        "Orchestrating", "Architecting", "Deploying", "Hardening"
+    ]
+}
+
+# Spinner tips — Qualia tips
+settings["spinnerTipsOverride"] = {
+    "excludeDefault": True,
+    "tips": [
+        "◆ Lost? Type /qualia for the next step",
+        "◆ Small fix? Use /qualia-quick to skip planning",
+        "◆ End of day? /qualia-report before you clock out",
+        "◆ Context isolation: every task gets a fresh AI brain",
+        "◆ The verifier doesn't trust claims — it greps the code",
+        "◆ Plans are prompts — the plan IS what the builder reads",
+        "◆ Feature branches only — never push to main",
+        "◆ Read before write — no exceptions",
+        "◆ MVP first — build what's asked, nothing extra",
+        "◆ tracking.json syncs to ERP on every push"
+    ]
+}
+
+# Hooks
+hooks_dir = os.path.expanduser("~/.claude/hooks")
+settings["hooks"] = {
+    "PreToolUse": [
+        {
+            "matcher": "Bash",
+            "hooks": [{
+                "type": "command",
+                "if": "Bash(git push*)",
+                "command": f"{hooks_dir}/branch-guard.sh",
+                "timeout": 10,
+                "statusMessage": "◆ Checking branch permissions..."
+            }]
+        },
+        {
+            "matcher": "Edit|Write",
+            "hooks": [{
+                "type": "command",
+                "if": "Edit(*.env*)",
+                "command": f"{hooks_dir}/block-env-edit.sh",
+                "timeout": 5,
+                "statusMessage": "◆ Checking file permissions..."
+            }]
+        }
+    ],
+    "PostToolUse": [
+        {
+            "matcher": "Bash",
+            "hooks": [{
+                "type": "command",
+                "if": "Bash(vercel --prod*)",
+                "command": f"{hooks_dir}/pre-deploy-gate.sh",
+                "timeout": 120,
+                "statusMessage": "◆ Running quality gates..."
+            }]
+        }
+    ],
+    "PreCompact": [
+        {
+            "matcher": "compact",
+            "hooks": [{
+                "type": "command",
+                "command": f"{hooks_dir}/pre-compact.sh",
+                "timeout": 15,
+                "statusMessage": "◆ Saving state..."
+            }]
+        }
+    ],
+    "SubagentStart": [
+        {
+            "matcher": ".*",
+            "hooks": [{
+                "type": "command",
+                "command": "echo '{\"additionalContext\": \"◆ Qualia agent spawned\"}'"
+            }]
+        }
+    ]
+}
+
+# Permissions
+settings.setdefault("permissions", {})
+settings["permissions"].setdefault("allow", [])
+settings["permissions"].setdefault("deny", [
+    "Read(./.env)",
+    "Read(./.env.*)",
+    "Read(./secrets/**)"
+])
+
+# Effort level
+settings["effortLevel"] = "high"
+
+with open(settings_path, "w") as f:
+    json.dump(settings, f, indent=2)
+
+print("    ✓ Hooks registered (branch-guard, env-block, deploy-gate, pre-compact, subagent-label)")
+print("    ✓ Status line configured (2-line teal branded)")
+print("    ✓ Spinner verbs: Qualia branded")
+print("    ✓ Spinner tips: Qualia tips")
+print("    ✓ Environment variables set")
+PYEOF
+
+echo ""
+echo "◆ Installed ✓"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  Skills:       10"
+echo "  Agents:       3 (planner, builder, verifier)"
+echo "  Hooks:        4 (branch-guard, env-block, deploy-gate, pre-compact)"
+echo "  Rules:        3 (security, frontend, deployment)"
+echo "  Templates:    4"
+echo "  Status line:  ✓"
+echo "  CLAUDE.md:    ✓ (user-level)"
+echo ""
+echo "  Restart Claude Code, then type /qualia in any project."
+echo ""

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "qualia-framework-v2",
+  "version": "2.0.0",
+  "description": "Claude Code workflow framework by Qualia Solutions. Plan, build, verify, ship.",
+  "bin": {
+    "qualia-framework-v2": "./bin/install.js"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "ai",
+    "framework",
+    "workflow",
+    "qualia",
+    "agents",
+    "automation"
+  ],
+  "author": "Qualia Solutions <hello@qualia.solutions>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qualia-solutions/qualia-framework-v2"
+  },
+  "homepage": "https://github.com/qualia-solutions/qualia-framework-v2#readme",
+  "files": [
+    "bin/",
+    "agents/",
+    "hooks/",
+    "rules/",
+    "skills/",
+    "templates/",
+    "CLAUDE.md",
+    "guide.md",
+    "statusline.sh",
+    "install.sh"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/rules/deployment.md

@@ -0,0 +1,30 @@
+---
+globs: ["vercel.json", "next.config.*", "wrangler.*", "Dockerfile"]
+---
+
+# Deployment (MANDATORY - Every Project)
+
+When work on a project is **done**, ALWAYS execute these steps in order:
+
+## 1. Push to GitHub
+Commit and push all changes to the remote repository.
+
+## 2. Redeploy to Vercel
+Deploy through the Vercel CLI (`vercel --prod`) or project-appropriate method (e.g., `wrangler deploy` for Cloudflare Workers).
+
+## 3. Verify Supabase
+Confirm Supabase is configured correctly via CLI or Management API (check tables, RLS, migrations are applied).
+
+## 4. Post-Deploy Verification Checklist
+
+After deployment, verify all 5 checks pass:
+
+- [ ] **HTTP 200** — Homepage loads successfully (`curl -s -o /dev/null -w "%{http_code}" <url>` returns 200)
+- [ ] **Auth flow** — Login/signup endpoint responds correctly (test auth callback URL)
+- [ ] **Console errors** — No critical JS errors in browser console on homepage load
+- [ ] **API latency** — Key API endpoints respond under 500ms (`curl -w "%{time_total}" <api-url>`)
+- [ ] **UptimeRobot** — Verify monitor shows UP on https://stats.uptimerobot.com/bKudHy1pLs
+
+If any check fails, investigate and fix before considering deployment complete.
+
+This applies to **every project, every time**. No exceptions. Don't ask — just do it.

package/rules/frontend.md

@@ -0,0 +1,33 @@
+---
+globs: ["*.tsx", "*.jsx", "*.css", "*.scss", "tailwind.config.*"]
+---
+
+# Frontend Aesthetics
+
+- Distinctive fonts (not Inter/Arial)
+- Cohesive color palette with sharp accents
+- CSS transitions, staggered animations
+- Layered backgrounds, subtle gradients
+- Avoid: card grids, generic heroes, blue-purple gradients
+- Full-width layouts — no hardcoded 1200px/1280px caps. Use fluid widths that fill the viewport with sensible padding.
+
+Note: Qualia agents MUST follow these rules when building any frontend component. These are Fawzi's brand standards, not suggestions.
+
+## Impeccable Design Skills (global)
+Use these `/commands` for design refinement on any frontend work:
+- `/polish` — Final detail pass before shipping (spacing, alignment, consistency)
+- `/bolder` — Amplify safe/boring designs to be more striking
+- `/design-quieter` — Tone down overly aggressive designs
+- `/animate` — Add purposeful micro-interactions and motion
+- `/colorize` — Inject strategic color into monochrome UIs
+- `/clarify` — Fix unclear UX copy, labels, error messages
+- `/critique` — Design director-level review (run before shipping)
+- `/distill` — Strip unnecessary complexity
+- `/delight` — Add memorable touches and personality
+- `/harden` — Edge cases, overflow, i18n robustness
+- `/onboard` — First-time user experience flows
+- `/normalize` — Align with project design system
+- `/responsive` — Cross-device responsive adaptation
+
+### Recommended workflow
+1. Build feature → 2. `/critique` → 3. `/polish` → 4. `/harden` → ship

package/rules/security.md

@@ -0,0 +1,12 @@
+---
+globs: ["**/api/**", "**/actions/**", "**/lib/supabase/**", "**/*.sql", "**/middleware.*"]
+---
+
+# Security Rules
+
+- Always check auth server-side. Never trust client IDs. Derive user from `auth.uid()`.
+- Enable RLS on every table. Write policies checking `auth.uid()`. Never expose `service_role` key client-side.
+- Validate with Zod. Never use `dangerouslySetInnerHTML`. Never use `eval()`.
+- Never hardcode keys. Never commit `.env`.
+- Audit that service role key is never imported in any client component.
+- Use `lib/supabase/server.ts` for mutations, never `lib/supabase/client.ts`.

package/skills/qualia/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: qualia
+description: "Router — reads STATE.md and tells you the exact next command. Use whenever you type /qualia, 'what next', 'next', or are lost."
+---
+
+# /qualia — What's Next?
+
+Read project state. Tell the employee the exact next command. No analysis, no advice — just routing.
+
+## Process
+
+### 1. Read State
+
+```bash
+echo "---STATE---"
+cat .planning/STATE.md 2>/dev/null || echo "NO_STATE"
+echo "---TRACKING---"
+cat .planning/tracking.json 2>/dev/null || echo "NO_TRACKING"
+echo "---PHASE_PLANS---"
+ls .planning/phase-*-plan.md 2>/dev/null || echo "NO_PLANS"
+echo "---VERIFICATIONS---"
+ls .planning/phase-*-verification.md 2>/dev/null || echo "NO_VERIFICATIONS"
+```
+
+### 2. Route
+
+| Condition | Command |
+|-----------|---------|
+| No `.planning/` | → `/qualia-new` |
+| Phase N has no plan | → `/qualia-plan {N}` |
+| Phase N has plan, not built | → `/qualia-build {N}` |
+| Phase N built, not verified | → `/qualia-verify {N}` |
+| Phase N verified with FAIL | → `/qualia-plan {N} --gaps` |
+| Phase N verified PASS, more phases | → `/qualia-plan {N+1}` |
+| All phases verified PASS | → `/qualia-polish` |
+| Polish done | → `/qualia-ship` |
+| Shipped | → `/qualia-handoff` |
+| Handed off | → Done. Run `/qualia-report` |
+
+### 3. Display
+
+```
+◆ QUALIA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Project    {name}
+  Phase      {N} of {total} — {name}
+  Status     {status}
+  Progress   {bar} {percent}%
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  → Run: /qualia-{next command}
+```
+
+That's it. One command. One answer.

package/skills/qualia-build/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: qualia-build
+description: "Execute the current phase — spawns builder subagents per task with wave-based parallelization. Fresh context per task."
+---
+
+# /qualia-build — Build a Phase
+
+Execute the phase plan. Each task runs in a fresh subagent context. Independent tasks run in parallel.
+
+## Usage
+`/qualia-build` — build the current planned phase
+`/qualia-build {N}` — build specific phase
+
+## Process
+
+### 1. Load Plan
+
+```bash
+cat .planning/phase-{N}-plan.md
+```
+
+Parse: tasks, waves, file references.
+
+### 2. Execute Waves
+
+```
+◆ QUALIA ► BUILDING Phase {N}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**For each wave (sequential):**
+
+```
+  ◆ Wave {W} ({count} tasks)
+```
+
+**For each task in the wave (parallel if multiple):**
+
+Spawn a fresh builder subagent:
+
+```
+Agent(prompt="
+Read your role: @agents/builder.md
+
+Project context:
+@.planning/PROJECT.md
+
+YOUR TASK:
+{paste the single task block from the plan — title, files, action, context refs, done-when}
+
+Execute this task. Read all @file references before writing. Commit when done.
+", subagent_type="general-purpose", description="Task {N}: {title}")
+```
+
+**After each task completes:**
+- Verify the commit exists: `git log --oneline -1`
+- Show result:
+```
+    ✓ Task {N}: {title}  ({commit hash})
+```
+
+**After each wave completes:**
+- Move to next wave
+- Show wave summary
+
+### 3. Wave Completion
+
+After all waves complete:
+
+```
+◆ QUALIA ► Phase {N} Built
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Tasks:  {done}/{total} ✓
+  Commits: {count}
+  Waves:  {count}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### 4. Handle Failures
+
+If a builder subagent returns a deviation or blocker:
+- **Minor deviation:** Log it, continue
+- **Major deviation:** Show to employee, ask how to proceed
+- **Blocker:** Show the blocker, suggest fix or escalation
+
+### 5. Update State
+
+Update STATE.md: status → "built", tasks completed
+Update tracking.json: tasks_done, wave, status
+
+```
+  → Run: /qualia-verify {N}
+```