qualia-framework 6.2.10 → 6.4.0

package/skills/qualia-hook-gen/SKILL.md

@@ -1,206 +0,0 @@
----
-name: qualia-hook-gen
-description: "Take a project's CLAUDE.md or rules/*.md instruction and convert it deterministically into a Claude Code pre-tool-use hook. Generates block-{cmd}.sh + the settings.json patch + activation steps. Lets users actually shrink their CLAUDE.md instead of just hearing the instruction-budget advice. Trigger on 'qualia-hook-gen', 'turn this rule into a hook', 'enforce this deterministically', 'block npm', 'force pnpm', 'convert claude.md to hooks', 'shrink my instruction budget'."
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
-  - Grep
-  - Glob
-argument-hint: "[--rule \"text\"] [--from CLAUDE.md] [--name HOOK_NAME] [--scope global|project] [--dry-run]"
----
-
-# /qualia-hook-gen — Convert instructions → deterministic hooks
-
-LLMs have a realistic instruction budget of ~300-500 instructions before quality degrades (Matt Pocock). A line in CLAUDE.md like "use pnpm not npm" burns budget on EVERY request — even when the task has nothing to do with package management. Worse, it's non-deterministic: the model can still run `npm install` if it forgets.
-
-The fix: convert that instruction into a deterministic `pre-tool-use` hook. The hook blocks the wrong command (or rewrites it to the right one) at execution time, frees the instruction budget, and works regardless of context window state.
-
-## When to use
-
-- Your CLAUDE.md has 50+ lines and you want to slim it
-- A specific instruction is enforceable as a CLI rule (use X not Y, never run Z, redirect A to B)
-- You want a hook for a specific failure mode (e.g., "always use --force-with-lease, never --force")
-
-## What it does NOT do
-
-- Hooks for stylistic guidance (e.g., "prefer composition over inheritance") — that's not enforceable by command match. Stays in skills.
-- Hooks for non-deterministic checks (e.g., "validate the design feel"). Use `/qualia-polish` instead.
-- Hooks that need state across multiple commands. Use Qualia's existing state.js machinery.
-
-## Process
-
-### 1. Identify the rule
-
-Three input modes:
-
-| Mode | Source |
-|---|---|
-| `--rule "..."` | Direct argument (e.g. `--rule "use pnpm not npm"`) |
-| `--from CLAUDE.md` | Pull instructions from the file, list them, let user pick |
-| (no arg) | Read CLAUDE.md, scan for enforceable rules, propose top 3 candidates |
-
-### 2. Classify enforceability
-
-For the chosen rule, classify into one of three patterns:
-
-| Pattern | Example | Hook shape |
-|---|---|---|
-| **Block** | "never use `git push --force` to main" | exit 2 with message if pattern matches |
-| **Rewrite** | "use pnpm not npm" | exit 2 with message guiding to alternative |
-| **Warn** | "prefer next/image over <img>" | exit 0 but print warning to stderr |
-
-If the rule isn't classifiable as any of these — i.e. it's stylistic or judgment-based — HALT with: "This rule isn't deterministically enforceable. Keep it in CLAUDE.md or move to a skill. Examples of enforceable rules: package-manager redirects, destructive-command blocks, file-path enforcement."
-
-### 3. Generate the hook script
-
-Write to `hooks/block-{name}.js` (Node, cross-platform — same shape as existing hooks):
-
-```javascript
-#!/usr/bin/env node
-// hooks/block-{name}.js — auto-generated by /qualia-hook-gen
-// Original instruction: "{rule text}"
-// Pattern: {block | rewrite | warn}
-// Generated: {ISO date}
-
-const { readFileSync } = require("fs");
-let payload;
-try { payload = JSON.parse(readFileSync(0, "utf8")); } catch { process.exit(0); }
-const cmd = (payload.tool_input && payload.tool_input.command) || "";
-
-// Match condition (regex from rule classification)
-if (!/{matcher}/i.test(cmd)) process.exit(0);  // not our concern
-
-// Action
-console.error("⚠ Qualia hook ({name}): {message}");
-console.error("   Suggested: {suggested_alt}");
-process.exit(2);  // 2 = BLOCK in Claude Code hook protocol
-```
-
-The exact matcher + message + suggestion are filled by the synthesizer based on the rule classification.
-
-### 4. Generate the settings.json patch
-
-```json
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "if": "Bash({if-condition})",
-            "command": "node \"${HOME}/.claude/hooks/block-{name}.js\"",
-            "timeout": 5,
-            "statusMessage": "⬢ Checking {what}..."
-          }
-        ]
-      }
-    ]
-  }
-}
-```
-
-The `if` condition narrows when the hook fires (e.g., `Bash(npm*)` to fire only on npm). Saves cycles by skipping the hook entirely on irrelevant commands.
-
-### 5. Test the hook
-
-```bash
-# Simulate a triggering command
-echo '{"tool_input":{"command":"{triggering_example}"}}' | \
-  node hooks/block-{name}.js
-echo "Exit: $?"   # should be 2
-
-# Simulate a non-triggering command
-echo '{"tool_input":{"command":"{safe_example}"}}' | \
-  node hooks/block-{name}.js
-echo "Exit: $?"   # should be 0
-```
-
-If the test passes, proceed. If not, debug the matcher regex.
-
-### 6. Activate
-
-Two scopes:
-
-| Scope | Action |
-|---|---|
-| `--scope project` (default for project rules) | Add the patch to `.claude/settings.json` in the project root |
-| `--scope global` | Add to `${QUALIA_HOME}/settings.json`. Use only if rule applies to ALL projects |
-
-Use the existing settings-merge logic from `bin/install.js:756-778` (preserves user fields, atomic write, backup-before-overwrite).
-
-### 7. Suggest CLAUDE.md slim
-
-After activating, scan CLAUDE.md / `rules/*.md` for the original instruction. If found, suggest the user remove it (don't auto-remove — let the user verify the hook works first):
-
-```
-✓ Hook installed: hooks/block-{name}.js
-✓ Settings patched: .claude/settings.json
-ℹ You can now remove this line from CLAUDE.md (the hook enforces it deterministically):
-    > "{original instruction}"
-ℹ Test with: echo '{"tool_input":{"command":"{triggering_example}"}}' | node hooks/block-{name}.js
-```
-
-### 8. Commit
-
-```bash
-git add hooks/block-{name}.js .claude/settings.json
-git -c user.name="Qualia Solutions" -c user.email="info@qualiasolutions.net" \
-  commit -m "feat(hook): block-{name} — enforces \"{rule}\" deterministically"
-```
-
-## Examples
-
-**Block npm in favor of pnpm:**
-```
-/qualia-hook-gen --rule "use pnpm not npm"
-→ hooks/block-npm.js  (matches /^\s*npm\s+(install|i|run|exec)/, exit 2)
-→ .claude/settings.json  (PreToolUse > Bash > if: Bash(npm*))
-→ "npm install" now blocks with: "Use pnpm not npm. Run: pnpm install"
-```
-
-**Block destructive git on main:**
-```
-/qualia-hook-gen --rule "never push --force to main"
-→ hooks/block-force-push-main.js  (matches /git push.*--force.*main/)
-→ Already covered by hooks/git-guardrails.js — surface this overlap and skip
-```
-
-**Force /server/ for service_role usage:**
-```
-/qualia-hook-gen --rule "service_role only in lib/server/*"
-→ Not enforceable as a CLI hook (it's a code-level rule).
-→ HALT with recommendation: ESLint rule or pre-deploy-gate.js entry instead.
-```
-
-## Token discipline
-
-This skill itself is short by design (~150 lines SKILL.md). REFERENCE.md (if added later) only carries verbatim hook templates. The whole point of `/qualia-hook-gen` is to REDUCE token cost across a project, not add to it.
-
-Per-invocation: ~3K tokens for the rule-classification + hook-template synthesis. Net savings: every subsequent request saves the ~50-200 tokens that the moved CLAUDE.md instruction was costing.
-
-## Failure modes
-
-| Symptom | Cause | Action |
-|---|---|---|
-| Rule isn't a CLI command | Stylistic / judgment-based | HALT with recommendation: skill or ESLint rule |
-| Matcher would catch too much | Regex too greedy | Tighten with `--name` and explicit pattern; user-confirm before write |
-| Hook conflicts with existing | Same command already hooked | Surface the conflict; refuse to overwrite without `--force` |
-| Settings.json malformed | Pre-existing bad JSON | Refuse to patch; ask user to fix settings.json first |
-| `node` not on hook PATH | Cross-platform issue | Use `process.execPath` resolution; framework's existing hooks handle this |
-
-## Rules
-
-1. **Hook is determinism, skill is guidance.** Hooks can only block/rewrite/warn on CLI patterns. Stylistic rules stay in skills.
-2. **Never overwrite an existing hook silently.** If `hooks/block-{name}.js` exists, surface and ask.
-3. **Test before committing.** The hook must pass the trigger + non-trigger smoke tests before commit.
-4. **Suggest CLAUDE.md cleanup.** After install, surface the now-redundant CLAUDE.md line. Don't auto-delete — user verifies the hook works first.
-5. **Match Qualia's hook shape.** All hooks are pure Node, cross-platform, exit 0/2. No `.sh` scripts (Windows compat).
-
-## Pairs with
-
-- `/qualia-optimize --deepen` — runs sometimes after a hook-gen pass when CLAUDE.md gets short enough that the codebase architecture becomes the next bottleneck
-- Existing hooks: `git-guardrails.js`, `pre-deploy-gate.js`, `vercel-account-guard.js`, `env-empty-guard.js`, `supabase-destructive-guard.js`. New hooks generated by this skill follow the same conventions.

package/skills/qualia-issues/SKILL.md

@@ -1,151 +0,0 @@
----
-name: qualia-issues
-description: "Break a phase plan into independent vertical-slice GitHub issues with needs-triage label. Each issue is demoable end-to-end (schema → API → UI → tests). Dependency-ordered. Externalizes Qualia work to the open queue so other agents, sessions, or human contributors can pull from it. Use when user says 'create issues from this plan', 'externalize the phase', 'turn this into GitHub issues', 'qualia-issues', 'split into tickets', or after /qualia-plan when the work should be parallelizable. Hard dependency: requires tracker config — run /qualia-map first if .planning/agents/tracker.md is missing."
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
-  - Grep
-  - Glob
-  - AskUserQuestion
----
-
-# /qualia-issues — Phase Plan → Independent Vertical-Slice GH Issues
-
-Externalizes a phase plan to the GitHub issue queue. Each issue is a thin slice that delivers a complete demoable behavior end-to-end. Other Qualia sessions, autonomous agents, or human contributors can then pull from the queue.
-
-## Why vertical slices
-
-ANTI-PATTERN: chop the plan horizontally (issue 1 = "all schema work", issue 2 = "all API work", issue 3 = "all UI"). This creates dependencies that block parallelism, and no single issue is demoable on its own.
-
-CORRECT: each issue traverses every layer (schema → API → UI → tests) for one narrow user-facing behavior. Many thin slices > few thick ones.
-
-## Hard dependencies (per Matt Pocock's ADR-0001)
-
-This skill cannot work meaningfully without:
-- `.planning/agents/tracker.md` — tells it where to file issues (GH, GL, local)
-- `.planning/agents/labels.md` — tells it the canonical-role-to-existing-label mapping
-- `gh` CLI authenticated (if tracker is GitHub)
-
-**If any are missing, halt and tell the user:** "Run `/qualia-map` first — it scans your repo and writes the adapter config so Qualia honors your existing tracker conventions."
-
-## Process
-
-### 1. Determine phase
-
-Phase number from `$ARGUMENTS` if provided, else current from `node ${QUALIA_BIN}/state.js check`.
-
-### 2. Load substrate
-
-```bash
-cat .planning/agents/tracker.md
-cat .planning/agents/labels.md
-cat .planning/phase-{N}-plan.md
-cat .planning/CONTEXT.md 2>/dev/null
-cat .planning/PROJECT.md
-```
-
-If `phase-{N}-plan.md` is missing, halt: "No plan exists for phase {N}. Run `/qualia-plan {N}` first."
-
-### 3. Decompose into vertical slices
-
-Read the phase plan tasks. Group/split into slices where each slice:
-- Delivers ONE user-facing behavior end-to-end
-- Touches every relevant layer (schema, server, client, tests) needed for that behavior
-- Is independently demoable or verifiable
-- Has explicit blocking-dependencies on other slices (kept minimal)
-
-Use **CONTEXT.md domain language** in titles and descriptions. Don't say "user table" if the glossary says "AuthUser" or "Customer."
-
-### 4. Show proposed slices to user
-
-```
-Proposed slices for phase {N}:
-
-Slice 1: {title in domain language}
-  Behavior: {one sentence}
-  Touches: schema, server-action, page route, test
-  Blocks: none
-
-Slice 2: ...
-  Blocks: Slice 1 (needs the schema migration)
-```
-
-Use `AskUserQuestion`:
-- header: "Approve slices?"
-- question: "File these {N} issues?"
-- options: "File them" / "Re-decompose" / "Cancel"
-
-### 5. File issues in dependency order
-
-For each approved slice (in dependency order so blocking slices exist when blockees are filed):
-
-```bash
-# Write the body to a temp file FIRST — never heredoc-interpolate user content into shell.
-# Plan content (titles, behaviors, criteria) is user-controlled; shell metacharacters or a
-# rogue 'EOF' line in the plan would break out of the heredoc. --body-file eliminates the risk.
-BODY_FILE=$(mktemp -t qualia-issue.XXXXXX.md)
-cat > "$BODY_FILE" <<EOF_TEMPLATE
-## End-to-end behavior
-{one paragraph}
-
-## Acceptance criteria
-- [ ] {criterion 1 — observable behavior, not implementation detail}
-- [ ] {criterion 2}
-- [ ] tests pass for the slice
-
-## Blocks
-- {issue # of any blocking slice, or "none"}
-
-## Domain terms touched
-{terms from CONTEXT.md this slice involves}
-
-## Phase context
-Part of phase {N} ({phase name}). Plan: .planning/phase-{N}-plan.md.
-EOF_TEMPLATE
-
-gh issue create \
-  --title "{title in domain language}" \
-  --body-file "$BODY_FILE" \
-  --label "needs-triage,enhancement"
-
-rm -f "$BODY_FILE"
-```
-
-Capture the returned issue number for use in subsequent slices' "Blocks" fields.
-
-**Why temp file, not heredoc:** plan files (`.planning/phase-{N}-plan.md`) and CONTEXT.md are project repo content — anyone with commit access can write them. A crafted plan with shell metacharacters or a literal `EOF` line in the content could break out of an inline heredoc and execute arbitrary shell. `--body-file` reads the body as raw bytes, no shell expansion. The `EOF_TEMPLATE` token (vs the standard `EOF`) is also more resistant to accidental collisions.
-
-### 6. Write summary
-
-`.planning/phase-{N}-issues.md`:
-
-```markdown
-# Phase {N} — Issue Queue
-
-Filed {date}. Status: open queue.
-
-| # | Slice | Issue | Blocks |
-|---|---|---|---|
-| 1 | {title} | #123 | none |
-| 2 | {title} | #124 | #123 |
-```
-
-### 7. Commit and route
-
-```bash
-git add .planning/phase-{N}-issues.md
-git commit -m "docs(phase-{N}): externalize {N_slices} slices to GH issue queue"
-
-node ${QUALIA_BIN}/qualia-ui.js end "QUEUE FILED" "/qualia-triage"
-```
-
-## Rules
-
-1. **Each issue is demoable on its own.** If a "completed" issue can't be shown as working behavior, the slicing was wrong.
-2. **CONTEXT.md language is mandatory.** Issue titles use domain terms, not implementation jargon.
-3. **No file paths or line numbers in issue bodies.** Issues describe behavior. Implementation details live in the phase plan.
-4. **Acceptance criteria are observable behaviors.** "Form validates email format" not "regex.test() returns true".
-5. **Dependencies kept minimal.** If slice A blocks slice B blocks slice C blocks slice D, the slicing collapsed to horizontal — re-decompose.
-6. **`needs-triage` is the default label.** `/qualia-triage` will route from there.

package/skills/qualia-pause/SKILL.md

@@ -1,68 +0,0 @@
----
-name: qualia-pause
-description: "Save session context for seamless handoff. Creates .continue-here.md so the next session picks up exactly where you left off. Trigger on 'pause', 'stop for now', 'save progress', 'continue later', 'pick up tomorrow'."
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
----
-
-# /qualia-pause — Session Handoff
-
-Save context so the next session picks up where you left off.
-
-## Process
-
-```bash
-node ${QUALIA_BIN}/qualia-ui.js banner pause
-```
-
-### 1. Read State
-
-```bash
-cat .planning/STATE.md 2>/dev/null
-git status --short 2>/dev/null
-git log --oneline -5 2>/dev/null
-```
-
-### 2. Create `.continue-here.md`
-
-```markdown
-# Continue Here
-
-## Session Summary
-{What was accomplished — from conversation context + git log}
-
-## Current Phase
-Phase {N}: {name} — {status}
-
-## In Progress
-- {What's partially done}
-- {Where exactly work stopped}
-
-## Next Steps
-1. {Immediate next action}
-2. {Following action}
-
-## Decisions Made
-- {Decision and rationale}
-
-## Blockers
-- {Any unresolved issues}
-
-## Files Modified
-- {List from git status/diff}
-```
-
-### 3. Commit
-
-```bash
-git add .continue-here.md {any uncommitted work files}
-git commit -m "WIP: {phase name} — session handoff"
-```
-
-```bash
-node ${QUALIA_BIN}/state.js transition --to note --notes "Session paused — see .continue-here.md"
-```
-Do NOT manually edit STATE.md or tracking.json — state.js handles both.

package/skills/qualia-resume/SKILL.md

@@ -1,52 +0,0 @@
----
-name: qualia-resume
-description: "Restore context from a previous session. Reads .continue-here.md or STATE.md, summarizes where you left off, routes to next action. Trigger on 'resume', 'continue', 'pick up where I left off', 'what was I doing'."
-allowed-tools:
-  - Bash
-  - Read
----
-
-# /qualia-resume — Resume Work
-
-Restore context and route to the right next action.
-
-## Process
-
-### 1. Find Context (priority order)
-
-1. `.continue-here.md` — richest source, from `/qualia-pause`
-2. `.planning/STATE.md` — project state
-3. Git history — `git log --oneline -10` + `git diff --stat`
-
-### 2. Restore
-
-**If `.continue-here.md` exists:** Read fully. Summarize: what was done, what's in progress, next steps, blockers.
-
-**If only STATE.md:** Read STATE.md + tracking.json. Show current phase and status.
-
-**If neither:** Reconstruct from git. Present findings, ask user to confirm.
-
-### 3. Detect Incomplete Work
-
-- Phase has plan but no verification → execution may be incomplete
-- Uncommitted changes → `git status --short`
-- Phase marked in-progress in STATE.md
-
-### 4. Present and Route
-
-```bash
-node ${QUALIA_BIN}/qualia-ui.js banner resume
-node ${QUALIA_BIN}/qualia-ui.js info "Last session: {summary}"
-```
-
-If uncommitted changes:
-```bash
-node ${QUALIA_BIN}/qualia-ui.js warn "{N} uncommitted files"
-```
-
-End with the next command:
-```bash
-node ${QUALIA_BIN}/qualia-ui.js next "{next command}"
-```
-
-Clean up `.continue-here.md` after restoration (or offer to keep it).

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

@@ -1,173 +0,0 @@
----
-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."
-allowed-tools:
-  - Bash
-  - Read
-  - Write
-  - Edit
-  - AskUserQuestion
----
-
-# /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 ${QUALIA_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 repo. Everyone gets it on next update."
-  - label: "Local skill (just me)"
-    description: "Lives only in ${QUALIA_SKILLS}/. Not shared."
-  - label: "Agent instead of a skill"
-    description: "This is a subagent role, not a slash command. Creates agents/{name}.md."
-```
-
-### 1a. Resolve framework directory
-
-If the user chose **Framework skill** or a framework-scoped **Agent**, resolve `${FRAMEWORK_DIR}` — the checkout path of this user's qualia-framework repo — BEFORE computing any target paths. Never hardcode `/home/<user>/...`; different teammates and operating systems have different paths.
-
-```bash
-# Priority order: env var → git detection → ask user
-FRAMEWORK_DIR="${QUALIA_FRAMEWORK_DIR:-}"
-if [ -z "$FRAMEWORK_DIR" ] && git -C . rev-parse --show-toplevel >/dev/null 2>&1; then
-  ORIGIN=$(git -C . config --get remote.origin.url 2>/dev/null)
-  case "$ORIGIN" in
-    *qualia-framework*) FRAMEWORK_DIR=$(git -C . rev-parse --show-toplevel) ;;
-  esac
-fi
-echo "${FRAMEWORK_DIR:-UNRESOLVED}"
-```
-
-If the command prints `UNRESOLVED`, ask the user: *"Where is your qualia-framework checkout? (absolute path, or type 'local' to save only to ${QUALIA_HOME}/)"*. If they type `local`, downgrade the scope to Local. Otherwise store the answer as `${FRAMEWORK_DIR}` for the rest of the session.
-
-**Framework** → target: `${FRAMEWORK_DIR}/skills/{name}/SKILL.md`
-**Local** → target: `${QUALIA_SKILLS}/{name}/SKILL.md`
-**Agent** → target: `${FRAMEWORK_DIR}/agents/{name}.md` (framework) or `${QUALIA_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 ${QUALIA_SKILLS}/qualia-learn/SKILL.md
-
-# Skill-that-spawns-an-agent reference:
-cat ${QUALIA_SKILLS}/qualia-plan/SKILL.md
-
-# Interactive wizard reference:
-cat ${QUALIA_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 ${QUALIA_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: @${QUALIA_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
-mkdir -p ${QUALIA_SKILLS}/{name}
-cp "${FRAMEWORK_DIR}/skills/{name}/SKILL.md" ${QUALIA_SKILLS}/{name}/SKILL.md
-
-# Verify it parses
-node -e "const fs=require('fs');const os=require('os');const path=require('path');const c=fs.readFileSync(path.join(os.homedir(),'.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 "${FRAMEWORK_DIR}"
-git add skills/{name}/
-git commit -m "feat: add /{name} skill"
-```
-
-Remind the user to run `npx qualia-framework@latest update` on their other machines (always pin `@latest` — npx caches aggressively), 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 `${QUALIA_HOME}/` 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