qualia-framework-v2 2.5.0 → 2.7.0

package/skills/qualia-skill-new/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: qualia-skill-new
+description: "Author a new Qualia skill or agent. Use when the user says 'create a new skill', 'add a skill', 'I want to build a skill', 'make this a reusable command', 'turn this into a skill'. Generates the SKILL.md, registers it in the right location, and optionally ships to the framework repo."
+---
+
+# /qualia-skill-new — Author a New Skill
+
+You are about to create a reusable slash command. Skills are the leverage of the Qualia framework — if the team does something twice, it probably belongs here.
+
+## Process
+
+```bash
+node ~/.claude/bin/qualia-ui.js banner skill-new
+```
+
+### 1. Scope Decision
+
+Ask the user with AskUserQuestion:
+
+```
+question: "Where should this skill live?"
+header: "Scope"
+options:
+  - label: "Framework skill (ships to the team)"
+    description: "Edit qualia-framework-v2 repo. Everyone gets it on next update."
+  - label: "Local skill (just me)"
+    description: "Lives only in ~/.claude/skills/. Not shared."
+  - label: "Agent instead of a skill"
+    description: "This is a subagent role, not a slash command. Creates agents/{name}.md."
+```
+
+**Framework** → target: `/home/qualia/Projects/qualia/qualia-framework-v2/skills/{name}/SKILL.md`
+**Local** → target: `~/.claude/skills/{name}/SKILL.md`
+**Agent** → target: `/home/qualia/Projects/qualia/qualia-framework-v2/agents/{name}.md` (framework) or `~/.claude/agents/{name}.md` (local)
+
+### 2. Gather Requirements
+
+Ask the user — one question at a time, natural conversation:
+
+1. **"What's the name?"** — kebab-case, prefix with `qualia-` for framework skills. E.g., `qualia-seed-db`.
+2. **"What does it do?"** — one sentence, used as the description.
+3. **"How does the user invoke it?"** — trigger phrases they'd naturally say. E.g., "seed the database", "load test data", "populate dev db".
+4. **"Does it need planning / building / verification?"** — if yes, it probably should spawn an agent. If no, it's a direct-action skill.
+5. **"What files does it read or write?"** — tells you what tools to restrict to.
+
+### 3. Read Reference Skills
+
+Before writing, read two existing skills that are structurally similar:
+
+```bash
+# Short direct-action skill reference:
+cat ~/.claude/skills/qualia-learn/SKILL.md
+
+# Skill-that-spawns-an-agent reference:
+cat ~/.claude/skills/qualia-plan/SKILL.md
+
+# Interactive wizard reference:
+cat ~/.claude/skills/qualia-new/SKILL.md
+```
+
+Pick the closest pattern and copy its structure.
+
+### 4. Write the SKILL.md
+
+Every SKILL.md MUST have:
+
+```markdown
+---
+name: {kebab-case-name}
+description: "{one sentence}. {trigger phrases}"
+---
+
+# /{name} — {Human Title}
+
+{one-paragraph explanation}
+
+## Usage
+
+`/{name}` — {default behavior}
+`/{name} {arg}` — {with argument}
+
+## Process
+
+### 1. {First Step}
+{specifics}
+
+### 2. {Second Step}
+{specifics}
+
+### N. Update State (only if this skill changes project state)
+
+```bash
+node ~/.claude/bin/state.js transition --to {status} ...
+```
+Do NOT manually edit STATE.md or tracking.json.
+```
+
+**Description field rules:**
+- MUST include trigger phrases the user would naturally say
+- The Claude Code router matches user messages against descriptions — if you don't list triggers, the skill never fires
+- Bad: `"Manages database seeding."` (no triggers)
+- Good: `"Seed the database with test data. Trigger on 'seed db', 'load test data', 'populate dev'."`
+
+### 5. Test the Skill
+
+Spawn a fresh subagent to simulate running the skill — does it make sense without the context you have right now?
+
+```
+Agent(prompt="
+Read this skill: @~/.claude/skills/{name}/SKILL.md
+
+Pretend the user just said '{one of the trigger phrases}'. Walk through what you would do, step by step. Flag anything ambiguous or missing.
+", subagent_type="general-purpose", description="Test skill {name}")
+```
+
+Fix any ambiguity the test agent found.
+
+### 6. Install (if framework skill)
+
+```bash
+# Framework skill — copy to local .claude for immediate testing
+cp /home/qualia/Projects/qualia/qualia-framework-v2/skills/{name}/SKILL.md ~/.claude/skills/{name}/SKILL.md
+
+# Verify it parses
+node -e "const fs=require('fs');const c=fs.readFileSync('/home/qualia/.claude/skills/{name}/SKILL.md','utf8');if(!c.includes('---'))throw new Error('missing frontmatter');if(!c.match(/^name:\s*\S/m))throw new Error('missing name');if(!c.match(/^description:\s*\S/m))throw new Error('missing description');console.log('OK')"
+```
+
+### 7. Commit (framework skills only)
+
+Do NOT commit unless the user explicitly says "commit" or "ship it".
+
+When they do:
+```bash
+cd /home/qualia/Projects/qualia/qualia-framework-v2
+git add skills/{name}/
+git commit -m "feat: add /{name} skill"
+```
+
+Remind the user to run `npx qualia-framework-v2 update` on their other machines, or bump the version and `npm publish`.
+
+## Anti-Patterns
+
+- ❌ **Description without triggers** — the skill won't fire
+- ❌ **Multiple commands in one skill** — split into two skills
+- ❌ **Direct file writes instead of state.js** — always use state.js for STATE.md/tracking.json
+- ❌ **Hardcoded project paths** — use `.planning/` relative or `~/.claude/` absolute, never `/home/specific-user/`
+- ❌ **Skills that spawn agents without passing PROJECT.md and STATE.md context** — agents are blind by default
+- ❌ **Skills longer than ~150 lines** — split or move logic to an agent

package/skills/qualia-task/SKILL.md

@@ -43,13 +43,11 @@ If "Large" — suggest `/qualia-plan` instead. Ask if they want to proceed anywa
 
 Write a quick task spec (don't save to file, just confirm with user):
 
-```
-◆ QUALIA ► TASK
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  What:    {what to build}
-  Files:   {files to create/modify}
-  Done:    {what "done" looks like}
+```bash
+node ~/.claude/bin/qualia-ui.js banner task
+node ~/.claude/bin/qualia-ui.js info "What: {what to build}"
+node ~/.claude/bin/qualia-ui.js info "Files: {files to create/modify}"
+node ~/.claude/bin/qualia-ui.js info "Done: {what done looks like}"
 ```
 
 Ask: **"Good to build?"**
@@ -79,14 +77,12 @@ After the builder finishes:
 
 ### 5. Report
 
-```
-◆ QUALIA ► TASK COMPLETE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  Task      {description}
-  Files     {files changed}
-  Commit    {commit hash}
-  Status    ✓ Done
+```bash
+node ~/.claude/bin/qualia-ui.js divider
+node ~/.claude/bin/qualia-ui.js ok "Task: {description}"
+node ~/.claude/bin/qualia-ui.js ok "Files: {files changed}"
+node ~/.claude/bin/qualia-ui.js ok "Commit: {commit hash}"
+node ~/.claude/bin/qualia-ui.js end "TASK COMPLETE"
 ```
 
 ```bash

package/skills/qualia-verify/SKILL.md

@@ -24,10 +24,9 @@ cat .planning/phase-{N}-verification.md 2>/dev/null || echo "NONE"
 
 ### 2. Spawn Verifier (Fresh Context)
 
-```
-◆ QUALIA ► VERIFYING Phase {N}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Spawning verifier...
+```bash
+node ~/.claude/bin/qualia-ui.js banner verify {N} "{phase name}"
+node ~/.claude/bin/qualia-ui.js spawn verifier "Goal-backward check..."
 ```
 
 ```
@@ -44,33 +43,55 @@ Verify this phase. Write report to .planning/phase-{N}-verification.md
 ", subagent_type="qualia-verifier", description="Verify phase {N}")
 ```
 
-### 3. Present Results
+### 2b. Browser QA (if phase touched frontend)
 
-Read the verification report. Present:
+If the phase plan's Files section includes any `.tsx`, `.jsx`, `.css`, `.scss`, or `app/`/`pages/`/`components/` paths, ALSO spawn the browser QA agent in parallel:
+
+```bash
+# Detect frontend touch
+grep -l "\.tsx\|\.jsx\|\.css\|app/\|components/\|pages/" .planning/phase-{N}-plan.md && FRONTEND=true
+```
+
+If frontend:
 
-**If PASS:**
 ```
-◆ QUALIA ► Phase {N} VERIFIED ✓
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Agent(prompt="
+Read your role: @agents/qa-browser.md
 
-  All {count} criteria passed.
+Phase plan: @.planning/phase-{N}-plan.md
+Existing verification: @.planning/phase-{N}-verification.md
 
-  → Run: /qualia-plan {N+1}
+Drive the running dev server and test the routes this phase touched. Append a '## Browser QA' section to the verification file.
+", subagent_type="qualia-qa-browser", description="Browser QA phase {N}")
 ```
 
-**If FAIL:**
+Wait for both the main verifier and the QA browser agent before moving to step 3. If Playwright MCP is unavailable, the QA browser agent returns BLOCKED — that's not a phase failure, just a note in the report.
+
+### 3. Present Results
+
+Read the verification report. Present:
+
+**If PASS:**
+```bash
+node ~/.claude/bin/qualia-ui.js ok "All {count} criteria passed"
+node ~/.claude/bin/qualia-ui.js end "PHASE {N} VERIFIED" "/qualia-plan {N+1}"
 ```
-◆ QUALIA ► Phase {N} GAPS FOUND
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+(If phase == total phases, use `/qualia-polish` as the next command.)
 
-  Passed: {pass_count}
-  Failed: {fail_count}
+**If FAIL:**
+```bash
+node ~/.claude/bin/qualia-ui.js ok "Passed: {pass_count}"
+node ~/.claude/bin/qualia-ui.js fail "Failed: {fail_count}"
+```
 
-  Gaps:
-    ✗ {gap 1 — specific description}
-    ✗ {gap 2 — specific description}
+Then for each gap:
+```bash
+node ~/.claude/bin/qualia-ui.js fail "{gap description}"
+```
 
-  → Run: /qualia-plan {N} --gaps
+End:
+```bash
+node ~/.claude/bin/qualia-ui.js end "PHASE {N} GAPS FOUND" "/qualia-plan {N} --gaps"
 ```
 
 ### 4. Update State
@@ -82,3 +103,11 @@ If PASS and more phases: state.js auto-advances to the next phase.
 If FAIL and gap_cycles >= 2: state.js returns GAP_CYCLE_LIMIT — tell the employee to escalate.
 If FAIL and gap_cycles < 2: proceed to `/qualia-plan {N} --gaps`.
 Do NOT manually edit STATE.md or tracking.json — state.js handles both.
+
+### 5. Passive Knowledge Capture (on FAIL)
+
+When verification fails, after showing the gaps, ask the user:
+
+> *"Was any of this a recurring issue worth saving to common-fixes.md? (yes / no / which ones)"*
+
+If yes, for each flagged gap spawn a brief `/qualia-learn` flow with type=`fix` — the gap title and fix direction from the verification report become the entry. Do NOT save every failure automatically — only the ones the user flags. The point is to build a real knowledge base, not a log of every mistake.

package/tests/hooks.test.sh

@@ -1,10 +1,12 @@
 #!/bin/bash
-# Qualia Framework v2 — Hook Tests
+# Qualia Framework v2 — Hook Tests (cross-platform Node.js hooks)
 # Run: bash tests/hooks.test.sh
 
 PASS=0
 FAIL=0
-HOOKS_DIR="$(dirname "$0")/../hooks"
+# Resolve HOOKS_DIR to an ABSOLUTE path so `cd` inside subshells doesn't break it.
+HOOKS_DIR="$(cd "$(dirname "$0")/../hooks" && pwd)"
+NODE="${NODE:-node}"
 
 assert_exit() {
   local name="$1" expected="$2" actual="$3"
@@ -17,127 +19,189 @@ assert_exit() {
   fi
 }
 
-echo "=== Hook Tests ==="
+echo "=== Hook Tests (Node.js) ==="
 echo ""
 
-# --- block-env-edit.sh ---
+# --- All hooks are syntactically valid Node.js ---
+echo "syntax:"
+for f in "$HOOKS_DIR"/*.js; do
+  if $NODE -c "$f" 2>/dev/null; then
+    echo "  ✓ $(basename "$f")"
+    PASS=$((PASS + 1))
+  else
+    echo "  ✗ $(basename "$f")"
+    FAIL=$((FAIL + 1))
+  fi
+done
+
+# --- block-env-edit.js ---
+echo ""
 echo "block-env-edit:"
 
-echo '{"tool_input":{"file_path":".env.local"}}' | bash "$HOOKS_DIR/block-env-edit.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":".env.local"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
 assert_exit "blocks .env.local" 2 $?
 
-echo '{"tool_input":{"file_path":".env.production"}}' | bash "$HOOKS_DIR/block-env-edit.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":".env.production"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
 assert_exit "blocks .env.production" 2 $?
 
-echo '{"tool_input":{"file_path":".env"}}' | bash "$HOOKS_DIR/block-env-edit.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":".env"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
 assert_exit "blocks .env" 2 $?
 
-echo '{"tool_input":{"file_path":"src/app.tsx"}}' | bash "$HOOKS_DIR/block-env-edit.sh" > /dev/null 2>&1
+# Windows-style path with backslashes (normalized by the hook)
+echo '{"tool_input":{"file_path":"C:\\project\\.env.local"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
+assert_exit "blocks windows .env.local" 2 $?
+
+echo '{"tool_input":{"file_path":"src/app.tsx"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
 assert_exit "allows src/app.tsx" 0 $?
 
-echo '{"tool_input":{"file_path":"components/Footer.tsx"}}' | bash "$HOOKS_DIR/block-env-edit.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"components/Footer.tsx"}}' | $NODE "$HOOKS_DIR/block-env-edit.js" > /dev/null 2>&1
 assert_exit "allows components/Footer.tsx" 0 $?
 
-# --- migration-guard.sh ---
+# --- migration-guard.js ---
 echo ""
 echo "migration-guard:"
 
-echo '{"tool_input":{"file_path":"migrations/001.sql","content":"DROP TABLE users;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/001.sql","content":"DROP TABLE users;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "blocks DROP TABLE without IF EXISTS" 2 $?
 
-echo '{"tool_input":{"file_path":"migrations/001.sql","content":"DROP TABLE IF EXISTS old_users;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/001.sql","content":"DROP TABLE IF EXISTS old_users;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "allows DROP TABLE IF EXISTS" 0 $?
 
-echo '{"tool_input":{"file_path":"migrations/002.sql","content":"DELETE FROM users;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/002.sql","content":"DELETE FROM users;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "blocks DELETE without WHERE" 2 $?
 
-echo '{"tool_input":{"file_path":"migrations/003.sql","content":"TRUNCATE TABLE sessions;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/003.sql","content":"TRUNCATE TABLE sessions;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "blocks TRUNCATE" 2 $?
 
-echo '{"tool_input":{"file_path":"migrations/004.sql","content":"CREATE TABLE users (id uuid);"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/004.sql","content":"CREATE TABLE users (id uuid);"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "blocks CREATE TABLE without RLS" 2 $?
 
-echo '{"tool_input":{"file_path":"migrations/005.sql","content":"ALTER TABLE users ADD COLUMN email text;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"migrations/005.sql","content":"ALTER TABLE users ADD COLUMN email text;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "allows safe ALTER TABLE" 0 $?
 
-echo '{"tool_input":{"file_path":"src/app.tsx","content":"DROP TABLE users;"}}' | bash "$HOOKS_DIR/migration-guard.sh" > /dev/null 2>&1
+echo '{"tool_input":{"file_path":"src/app.tsx","content":"DROP TABLE users;"}}' | $NODE "$HOOKS_DIR/migration-guard.js" > /dev/null 2>&1
 assert_exit "skips non-migration files" 0 $?
 
-# --- branch-guard.sh ---
+# --- branch-guard.js (grep-based — full run needs git + real config) ---
 echo ""
 echo "branch-guard:"
 
-if [ -f "$HOOKS_DIR/branch-guard.sh" ]; then
-  echo "  ✓ branch-guard.sh exists"
+if grep -q '.qualia-config.json' "$HOOKS_DIR/branch-guard.js"; then
+  echo "  ✓ reads role from .qualia-config.json"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ branch-guard.sh missing"
+  echo "  ✗ not reading from .qualia-config.json"
   FAIL=$((FAIL + 1))
 fi
 
-if grep -q 'ROLE' "$HOOKS_DIR/branch-guard.sh"; then
-  echo "  ✓ checks ROLE variable"
+if grep -q 'branch --show-current' "$HOOKS_DIR/branch-guard.js"; then
+  echo "  ✓ checks current git branch"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing ROLE check"
+  echo "  ✗ missing branch check"
   FAIL=$((FAIL + 1))
 fi
 
-if grep -q 'z "$ROLE"' "$HOOKS_DIR/branch-guard.sh"; then
-  echo "  ✓ defaults to deny on missing ROLE"
+if grep -q 'OWNER' "$HOOKS_DIR/branch-guard.js"; then
+  echo "  ✓ enforces OWNER role"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing empty-ROLE deny"
+  echo "  ✗ missing OWNER check"
   FAIL=$((FAIL + 1))
 fi
 
-# --- pre-push.sh ---
+# --- pre-push.js ---
 echo ""
 echo "pre-push:"
 
-if grep -q 'command -v python3' "$HOOKS_DIR/pre-push.sh"; then
-  echo "  ✓ checks for python3 availability"
+if grep -q 'tracking.json' "$HOOKS_DIR/pre-push.js"; then
+  echo "  ✓ updates tracking.json"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing python3 check"
+  echo "  ✗ missing tracking.json update"
   FAIL=$((FAIL + 1))
 fi
 
-if grep -q 'qualia-push-err' "$HOOKS_DIR/pre-push.sh"; then
-  echo "  ✓ captures python3 errors"
+if grep -q 'last_commit' "$HOOKS_DIR/pre-push.js"; then
+  echo "  ✓ stamps last_commit"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing python3 error capture"
+  echo "  ✗ missing last_commit stamp"
   FAIL=$((FAIL + 1))
 fi
 
-# --- pre-deploy-gate.sh ---
+# Run pre-push.js in a dir with no tracking.json — must exit 0 cleanly
+TMP=$(mktemp -d)
+(cd "$TMP" && $NODE "$HOOKS_DIR/pre-push.js" >/dev/null 2>&1)
+assert_exit "exits 0 with no tracking.json" 0 $?
+rm -rf "$TMP"
+
+# --- pre-deploy-gate.js ---
 echo ""
 echo "pre-deploy-gate:"
 
-if [ -f "$HOOKS_DIR/pre-deploy-gate.sh" ]; then
-  echo "  ✓ pre-deploy-gate.sh exists"
+if grep -q 'tsc' "$HOOKS_DIR/pre-deploy-gate.js"; then
+  echo "  ✓ runs TypeScript check"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ pre-deploy-gate.sh missing"
+  echo "  ✗ missing TypeScript check"
   FAIL=$((FAIL + 1))
 fi
 
-if grep -q 'tsc --noEmit' "$HOOKS_DIR/pre-deploy-gate.sh"; then
-  echo "  ✓ runs TypeScript check"
+if grep -q 'service_role' "$HOOKS_DIR/pre-deploy-gate.js"; then
+  echo "  ✓ checks for service_role leaks"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing TypeScript check"
+  echo "  ✗ missing service_role check"
   FAIL=$((FAIL + 1))
 fi
 
-if grep -q 'service_role' "$HOOKS_DIR/pre-deploy-gate.sh"; then
-  echo "  ✓ checks for service_role leaks"
+# --- session-start.js — must exit 0 always ---
+echo ""
+echo "session-start:"
+
+TMP=$(mktemp -d)
+(cd "$TMP" && $NODE "$HOOKS_DIR/session-start.js" >/dev/null 2>&1)
+assert_exit "exits 0 with no project" 0 $?
+
+# Simulate a project with STATE.md
+mkdir -p "$TMP/.planning"
+cat > "$TMP/.planning/STATE.md" <<'EOF'
+# Project State
+Phase: 1 of 3 — Foundation
+Status: setup
+EOF
+(cd "$TMP" && $NODE "$HOOKS_DIR/session-start.js" >/dev/null 2>&1)
+assert_exit "exits 0 with STATE.md" 0 $?
+rm -rf "$TMP"
+
+# --- pre-compact.js ---
+echo ""
+echo "pre-compact:"
+
+TMP=$(mktemp -d)
+(cd "$TMP" && $NODE "$HOOKS_DIR/pre-compact.js" >/dev/null 2>&1)
+assert_exit "exits 0 with no STATE.md" 0 $?
+rm -rf "$TMP"
+
+# --- auto-update.js ---
+echo ""
+echo "auto-update:"
+
+TMP=$(mktemp -d)
+mkdir -p "$TMP/.claude"
+echo '{"code":"QS-FAWZI-01","version":"99.99.99"}' > "$TMP/.claude/.qualia-config.json"
+HOME="$TMP" $NODE "$HOOKS_DIR/auto-update.js" >/dev/null 2>&1
+assert_exit "exits 0 (fast path)" 0 $?
+# Should now have cache file
+if [ -f "$TMP/.claude/.qualia-last-update-check" ]; then
+  echo "  ✓ writes cache timestamp"
   PASS=$((PASS + 1))
 else
-  echo "  ✗ missing service_role check"
+  echo "  ✗ missing cache timestamp"
   FAIL=$((FAIL + 1))
 fi
+rm -rf "$TMP"
 
 echo ""
 echo "=== Results: $PASS passed, $FAIL failed ==="

package/hooks/auto-update.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-# Qualia auto-update — checks once per day, updates silently in background
-# Runs as PreToolUse hook. Cached so it's a no-op most of the time.
-
-CLAUDE_DIR="$HOME/.claude"
-CACHE_FILE="$CLAUDE_DIR/.qualia-last-update-check"
-CONFIG_FILE="$CLAUDE_DIR/.qualia-config.json"
-LOCK_FILE="$CLAUDE_DIR/.qualia-updating"
-MAX_AGE=86400  # 24 hours in seconds
-
-# Exit fast if recently checked (most common path — single stat call)
-if [ -f "$CACHE_FILE" ]; then
-  LAST_CHECK=$(cat "$CACHE_FILE" 2>/dev/null || echo 0)
-  NOW=$(date +%s)
-  AGE=$((NOW - LAST_CHECK))
-  if [ "$AGE" -lt "$MAX_AGE" ]; then
-    exit 0
-  fi
-fi
-
-# Exit if already updating
-[ -f "$LOCK_FILE" ] && exit 0
-
-# Update cache timestamp immediately (prevents concurrent checks)
-date +%s > "$CACHE_FILE"
-
-# Run the actual check + update in background so we don't block the user
-(
-  trap 'rm -f "$LOCK_FILE"' EXIT
-  touch "$LOCK_FILE"
-
-  # Get installed version
-  INSTALLED=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$CONFIG_FILE','utf8')).version)}catch{console.log('0.0.0')}" 2>/dev/null)
-  [ -z "$INSTALLED" ] && INSTALLED="0.0.0"
-
-  # Get latest from npm (5s timeout)
-  LATEST=$(npm view qualia-framework-v2 version 2>/dev/null)
-  [ -z "$LATEST" ] && exit 0
-
-  # Compare versions
-  NEEDS_UPDATE=$(node -e "
-    const a='$LATEST'.split('.').map(Number), b='$INSTALLED'.split('.').map(Number);
-    for(let i=0;i<3;i++){if(a[i]>b[i]){console.log('yes');process.exit()}if(a[i]<b[i]){process.exit()}}
-  " 2>/dev/null)
-
-  if [ "$NEEDS_UPDATE" = "yes" ]; then
-    # Get saved install code
-    CODE=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$CONFIG_FILE','utf8')).code)}catch{}" 2>/dev/null)
-    [ -z "$CODE" ] && exit 0
-
-    # Run silent update
-    npx qualia-framework-v2@latest install <<< "$CODE" > /dev/null 2>&1
-  fi
-) &
-
-exit 0

package/hooks/block-env-edit.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-# Prevent Claude from editing .env files
-# Claude Code hooks receive JSON on stdin with tool_input.file_path
-
-INPUT=$(cat)
-FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.command // ""' 2>/dev/null)
-
-if [[ "$FILE" == *.env* ]] || [[ "$FILE" == *".env.local"* ]] || [[ "$FILE" == *".env.production"* ]]; then
-  echo "BLOCKED: Cannot edit environment files. Ask Fawzi to update secrets."
-  exit 2
-fi

package/hooks/branch-guard.sh

@@ -1,18 +0,0 @@
-#!/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 [ -z "$ROLE" ]; then
-  echo "BLOCKED: Cannot determine role — ~/.claude/CLAUDE.md missing or malformed. Defaulting to deny."
-  exit 1
-fi
-
-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