@xgent-ai/skills 0.6.0 → 0.7.0

package/vendor/phoenix-ui/bundle/blobs/28e7a17e3f82679654a75cdf950703940946f6938c3f09923a2c8db28e215a5e

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const { main, shellQuote } = require('./phoenix-bootstrap.cjs');
+const provider = "dsh";
+process.env.PHOENIX_UI_PROVIDER_ID ||= provider;
+main(process.argv.slice(2), {
+  skillDir: path.resolve(__dirname, '..'),
+  self: `node ${shellQuote(__filename)}`,
+}).then(code => { process.exitCode = code; }).catch(error => {
+  process.stderr.write(`Phoenix UI: ${error.message}\n`);
+  process.exitCode = 4;
+});

package/vendor/phoenix-ui/bundle/blobs/291e5556000a273f55136bb708164dad8bbc78b7e928ab9c740069d837babc14

@@ -0,0 +1,42 @@
+{
+  "description": "Phoenix UI design detector: immediate-tier checks after Edit/Write on UI files, full-rule deep pass on Stop.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [ -f \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" ]; then \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" hook; else node -e '/* Embedded by hook emitters; it runs without any installed skill files. */ (() => { const fs = require('\"'\"'node:fs'\"'\"'); const os = require('\"'\"'node:os'\"'\"'); const path = require('\"'\"'node:path'\"'\"'); const crypto = require('\"'\"'node:crypto'\"'\"'); const env = process.env; const version = process.argv[1] || '\"'\"'missing-manifest'\"'\"'; const rawProvider = env.PHOENIX_UI_PROVIDER_ID || process.argv[2] || '\"'\"'source'\"'\"'; const provider = rawProvider === '\"'\"'claude-code'\"'\"' ? '\"'\"'claude'\"'\"' : rawProvider === '\"'\"'agents'\"'\"' ? '\"'\"'codex'\"'\"' : rawProvider; const launcher = process.argv[3]; if (process.platform === '\"'\"'win32'\"'\"' && launcher && fs.existsSync(launcher)) { const quote = String.fromCharCode(34); const command = quote + quote + launcher + quote + '\"'\"' '\"'\"' + (process.argv[4] || '\"'\"'hook'\"'\"') + quote; const child = require('\"'\"'node:child_process'\"'\"').spawnSync(env.ComSpec || '\"'\"'cmd.exe'\"'\"', ['\"'\"'/d'\"'\"', '\"'\"'/s'\"'\"', '\"'\"'/c'\"'\"', command], { stdio: '\"'\"'inherit'\"'\"', windowsVerbatimArguments: true, }); process.exit(child.status === null ? 1 : child.status); } let event = {}; try { const parsed = JSON.parse(fs.readFileSync(0, '\"'\"'utf8'\"'\"') || '\"'\"'{}'\"'\"'); if (parsed && typeof parsed === '\"'\"'object'\"'\"' && !Array.isArray(parsed)) event = parsed; } catch {} let project = process.cwd(); try { const initial = fs.realpathSync(path.resolve(env.CLAUDE_PROJECT_DIR || event.cwd || project)); let dir = initial; for (;;) { if (fs.existsSync(path.join(dir, '\"'\"'.phoenix-ui'\"'\"', '\"'\"'install'\"'\"', '\"'\"'active.json'\"'\"')) || fs.existsSync(path.join(dir, '\"'\"'.git'\"'\"'))) { project = dir; break; } const parent = path.dirname(dir); if (parent === dir) { project = initial; break; } dir = parent; } } catch {} const session = event.session_id || event.sessionId || env.CODEX_SESSION_ID || env.CLAUDE_SESSION_ID || '\"'\"''\"'\"'; const key = crypto.createHash('\"'\"'sha256'\"'\"').update(JSON.stringify([project, version, provider, session])).digest('\"'\"'hex'\"'\"'); const cache = path.resolve(env.PHOENIX_UI_HOME || path.join(os.homedir(), '\"'\"'.phoenix-ui'\"'\"')); const marker = path.join(cache, '\"'\"'unavailable'\"'\"', key + '\"'\"'.json'\"'\"'); try { fs.mkdirSync(path.dirname(marker), { recursive: true }); fs.writeFileSync(marker, JSON.stringify({ project, version, provider }), { flag: '\"'\"'wx'\"'\"', mode: 0o600 }); } catch (error) { if (error.code === '\"'\"'EEXIST'\"'\"') return; } const text = '\"'\"'Phoenix UI unavailable: the project launcher is missing. Reinstall the pinned @xgent-ai/skills package for this project.'\"'\"'; const eventName = [event.hook_event_name, event.hookEventName].find(name => typeof name === '\"'\"'string'\"'\"' && name) || '\"'\"'PostToolUse'\"'\"'; if (eventName.toLowerCase() === '\"'\"'stop'\"'\"') { process.stderr.write(text + '\"'\"'\\n'\"'\"'); return; } const output = provider === '\"'\"'cursor'\"'\"' ? { additional_context: text } : provider === '\"'\"'github'\"'\"' ? { additionalContext: text } : { hookSpecificOutput: { hookEventName: eventName, additionalContext: text } }; process.stdout.write(JSON.stringify(output) + '\"'\"'\\n'\"'\"'); })();' -- '0.1.0' 'claude' || :; fi",
+            "timeout": 5,
+            "statusMessage": "Preparing build session"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [ -f \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" ]; then \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" hook; else node -e '/* Embedded by hook emitters; it runs without any installed skill files. */ (() => { const fs = require('\"'\"'node:fs'\"'\"'); const os = require('\"'\"'node:os'\"'\"'); const path = require('\"'\"'node:path'\"'\"'); const crypto = require('\"'\"'node:crypto'\"'\"'); const env = process.env; const version = process.argv[1] || '\"'\"'missing-manifest'\"'\"'; const rawProvider = env.PHOENIX_UI_PROVIDER_ID || process.argv[2] || '\"'\"'source'\"'\"'; const provider = rawProvider === '\"'\"'claude-code'\"'\"' ? '\"'\"'claude'\"'\"' : rawProvider === '\"'\"'agents'\"'\"' ? '\"'\"'codex'\"'\"' : rawProvider; const launcher = process.argv[3]; if (process.platform === '\"'\"'win32'\"'\"' && launcher && fs.existsSync(launcher)) { const quote = String.fromCharCode(34); const command = quote + quote + launcher + quote + '\"'\"' '\"'\"' + (process.argv[4] || '\"'\"'hook'\"'\"') + quote; const child = require('\"'\"'node:child_process'\"'\"').spawnSync(env.ComSpec || '\"'\"'cmd.exe'\"'\"', ['\"'\"'/d'\"'\"', '\"'\"'/s'\"'\"', '\"'\"'/c'\"'\"', command], { stdio: '\"'\"'inherit'\"'\"', windowsVerbatimArguments: true, }); process.exit(child.status === null ? 1 : child.status); } let event = {}; try { const parsed = JSON.parse(fs.readFileSync(0, '\"'\"'utf8'\"'\"') || '\"'\"'{}'\"'\"'); if (parsed && typeof parsed === '\"'\"'object'\"'\"' && !Array.isArray(parsed)) event = parsed; } catch {} let project = process.cwd(); try { const initial = fs.realpathSync(path.resolve(env.CLAUDE_PROJECT_DIR || event.cwd || project)); let dir = initial; for (;;) { if (fs.existsSync(path.join(dir, '\"'\"'.phoenix-ui'\"'\"', '\"'\"'install'\"'\"', '\"'\"'active.json'\"'\"')) || fs.existsSync(path.join(dir, '\"'\"'.git'\"'\"'))) { project = dir; break; } const parent = path.dirname(dir); if (parent === dir) { project = initial; break; } dir = parent; } } catch {} const session = event.session_id || event.sessionId || env.CODEX_SESSION_ID || env.CLAUDE_SESSION_ID || '\"'\"''\"'\"'; const key = crypto.createHash('\"'\"'sha256'\"'\"').update(JSON.stringify([project, version, provider, session])).digest('\"'\"'hex'\"'\"'); const cache = path.resolve(env.PHOENIX_UI_HOME || path.join(os.homedir(), '\"'\"'.phoenix-ui'\"'\"')); const marker = path.join(cache, '\"'\"'unavailable'\"'\"', key + '\"'\"'.json'\"'\"'); try { fs.mkdirSync(path.dirname(marker), { recursive: true }); fs.writeFileSync(marker, JSON.stringify({ project, version, provider }), { flag: '\"'\"'wx'\"'\"', mode: 0o600 }); } catch (error) { if (error.code === '\"'\"'EEXIST'\"'\"') return; } const text = '\"'\"'Phoenix UI unavailable: the project launcher is missing. Reinstall the pinned @xgent-ai/skills package for this project.'\"'\"'; const eventName = [event.hook_event_name, event.hookEventName].find(name => typeof name === '\"'\"'string'\"'\"' && name) || '\"'\"'PostToolUse'\"'\"'; if (eventName.toLowerCase() === '\"'\"'stop'\"'\"') { process.stderr.write(text + '\"'\"'\\n'\"'\"'); return; } const output = provider === '\"'\"'cursor'\"'\"' ? { additional_context: text } : provider === '\"'\"'github'\"'\"' ? { additionalContext: text } : { hookSpecificOutput: { hookEventName: eventName, additionalContext: text } }; process.stdout.write(JSON.stringify(output) + '\"'\"'\\n'\"'\"'); })();' -- '0.1.0' 'claude' || :; fi",
+            "timeout": 5,
+            "statusMessage": "Checking UI changes"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [ -f \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" ]; then \"${CLAUDE_PROJECT_DIR}/.claude/skills/phoenix-ui/scripts/phoenix-ui\" hook; else node -e '/* Embedded by hook emitters; it runs without any installed skill files. */ (() => { const fs = require('\"'\"'node:fs'\"'\"'); const os = require('\"'\"'node:os'\"'\"'); const path = require('\"'\"'node:path'\"'\"'); const crypto = require('\"'\"'node:crypto'\"'\"'); const env = process.env; const version = process.argv[1] || '\"'\"'missing-manifest'\"'\"'; const rawProvider = env.PHOENIX_UI_PROVIDER_ID || process.argv[2] || '\"'\"'source'\"'\"'; const provider = rawProvider === '\"'\"'claude-code'\"'\"' ? '\"'\"'claude'\"'\"' : rawProvider === '\"'\"'agents'\"'\"' ? '\"'\"'codex'\"'\"' : rawProvider; const launcher = process.argv[3]; if (process.platform === '\"'\"'win32'\"'\"' && launcher && fs.existsSync(launcher)) { const quote = String.fromCharCode(34); const command = quote + quote + launcher + quote + '\"'\"' '\"'\"' + (process.argv[4] || '\"'\"'hook'\"'\"') + quote; const child = require('\"'\"'node:child_process'\"'\"').spawnSync(env.ComSpec || '\"'\"'cmd.exe'\"'\"', ['\"'\"'/d'\"'\"', '\"'\"'/s'\"'\"', '\"'\"'/c'\"'\"', command], { stdio: '\"'\"'inherit'\"'\"', windowsVerbatimArguments: true, }); process.exit(child.status === null ? 1 : child.status); } let event = {}; try { const parsed = JSON.parse(fs.readFileSync(0, '\"'\"'utf8'\"'\"') || '\"'\"'{}'\"'\"'); if (parsed && typeof parsed === '\"'\"'object'\"'\"' && !Array.isArray(parsed)) event = parsed; } catch {} let project = process.cwd(); try { const initial = fs.realpathSync(path.resolve(env.CLAUDE_PROJECT_DIR || event.cwd || project)); let dir = initial; for (;;) { if (fs.existsSync(path.join(dir, '\"'\"'.phoenix-ui'\"'\"', '\"'\"'install'\"'\"', '\"'\"'active.json'\"'\"')) || fs.existsSync(path.join(dir, '\"'\"'.git'\"'\"'))) { project = dir; break; } const parent = path.dirname(dir); if (parent === dir) { project = initial; break; } dir = parent; } } catch {} const session = event.session_id || event.sessionId || env.CODEX_SESSION_ID || env.CLAUDE_SESSION_ID || '\"'\"''\"'\"'; const key = crypto.createHash('\"'\"'sha256'\"'\"').update(JSON.stringify([project, version, provider, session])).digest('\"'\"'hex'\"'\"'); const cache = path.resolve(env.PHOENIX_UI_HOME || path.join(os.homedir(), '\"'\"'.phoenix-ui'\"'\"')); const marker = path.join(cache, '\"'\"'unavailable'\"'\"', key + '\"'\"'.json'\"'\"'); try { fs.mkdirSync(path.dirname(marker), { recursive: true }); fs.writeFileSync(marker, JSON.stringify({ project, version, provider }), { flag: '\"'\"'wx'\"'\"', mode: 0o600 }); } catch (error) { if (error.code === '\"'\"'EEXIST'\"'\"') return; } const text = '\"'\"'Phoenix UI unavailable: the project launcher is missing. Reinstall the pinned @xgent-ai/skills package for this project.'\"'\"'; const eventName = [event.hook_event_name, event.hookEventName].find(name => typeof name === '\"'\"'string'\"'\"' && name) || '\"'\"'PostToolUse'\"'\"'; if (eventName.toLowerCase() === '\"'\"'stop'\"'\"') { process.stderr.write(text + '\"'\"'\\n'\"'\"'); return; } const output = provider === '\"'\"'cursor'\"'\"' ? { additional_context: text } : provider === '\"'\"'github'\"'\"' ? { additionalContext: text } : { hookSpecificOutput: { hookEventName: eventName, additionalContext: text } }; process.stdout.write(JSON.stringify(output) + '\"'\"'\\n'\"'\"'); })();' -- '0.1.0' 'claude' || :; fi",
+            "timeout": 30,
+            "statusMessage": "Design deep pass"
+          }
+        ]
+      }
+    ]
+  }
+}

package/vendor/phoenix-ui/bundle/blobs/2932ada9af5f58a4fe8a0de58f1fe355fb273c4886f42e77a8ab38b0509bfe1d

@@ -0,0 +1,86 @@
+> **Additional context needed**: existing brand colors.
+
+Introduce color as hierarchy, meaning, and atmosphere. Preserve confirmed brand and semantic conventions; do not replace a visual world under the guise of colorizing it.
+
+---
+
+## Visitor mode
+
+- **Persuade + Experience:** color may carry the voice and own large regions when the selected world calls for it.
+- **Operate + Read:** color primarily encodes action, selection, status, wayfinding, and reading hierarchy. Rarity gives an accent force.
+
+## Audit before choosing
+
+Read DESIGN.md, tokens, assets, current themes, and representative states. Identify:
+
+- which colors are confirmed brand commitments;
+- current surface, text, action, and semantic roles;
+- places where grayscale obscures hierarchy or state;
+- contrast failures and color-only communication;
+- light/dark or data-visualization requirements;
+- whether the task asks for more color or a new identity.
+
+If a new identity is required, use [new-work.md](new-work.md). Ask only when a binding brand decision cannot be inferred.
+
+## Choose a strategy
+
+Name the intended emotional temperature, dominant relationship, contrast range, and color dosage before editing. The strategy may be restrained or immersive; it must follow the brief and selected world rather than a fixed percentage rule.
+
+Build roles, not a bag of swatches:
+
+- canvas and elevated surfaces;
+- primary and secondary text;
+- action, focus, and selection;
+- borders and separators;
+- success, warning, error, and information;
+- data categories or scales when needed.
+
+Use the project's existing color space. For a new web palette, prefer OKLCH because lightness and chroma can be adjusted predictably. Choose hue from product meaning and visual direction, never from a default category association.
+
+## Apply at system scale
+
+- Let the strongest color own a deliberate region or role instead of scattering tiny accents.
+- Keep the primary action easy to find; do not spend its color on decoration.
+- Tint neutrals only when the brand hue genuinely creates cohesion. Neutral gray is valid when it serves the world.
+- On colored surfaces, derive secondary text from the foreground or surface hue rather than using washed-out generic gray.
+- Keep semantic meanings consistent, but respect platform and domain conventions instead of assuming fixed hues.
+- For data, use distinct lightness, chroma, shape, label, or pattern so color is not the only code.
+- In dark mode, design surface elevation and contrast explicitly; do not invert the light theme mechanically.
+- Define primitive values and semantic tokens when the project has a token system. Theme changes should normally remap semantic roles.
+
+Decoration without a relationship to hierarchy, state, content, or the visual world is not a color strategy.
+
+## Contrast and perception
+
+Verify computed foreground/background pairs:
+
+| Content | WCAG AA minimum |
+|---|---|
+| body text | 4.5:1 |
+| large text | 3:1 |
+| controls, icons, focus indicators | 3:1 |
+
+Do not rely on eyesight alone. Check interactive states, overlays, text on images, disabled content, and both themes. Simulate common vision deficiencies. Information conveyed by color also needs text, shape, iconography, or position.
+
+When deriving OKLCH ramps, vary lightness and reduce chroma near white and black. Do not keep high chroma at extreme lightness merely to make the math uniform. Prefer explicit colors over chains of translucent overlays when alpha would make contrast context-dependent.
+
+## Verify
+
+- Every color has a stable role or a world-specific atmospheric purpose.
+- Attention lands on the intended action, content, or state.
+- The palette works across quiet, dense, interactive, error, and empty states.
+- Light and dark themes are each composed, not mechanically inverted.
+- Contrast and non-color cues pass in all relevant states.
+- The result is recognizably this product, not a generic “colorful” treatment.
+
+When the palette earns its place, hand off to `/phoenix-ui polish` for the final pass.
+
+## Live-mode signature params
+
+When invoked from live mode, every variant declares a `color-amount` parameter. Author CSS against `var(--p-color-amount, 0.5)` so the user can move from neutral to the variant's full color strategy without regeneration.
+
+```json
+{"id":"color-amount","kind":"range","min":0,"max":1,"step":0.05,"default":0.5,"label":"Color amount"}
+```
+
+Add at most two variant-specific parameters, such as palette, temperature, or tint behavior. Follow [live.md](live.md)'s parameter contract.

package/vendor/phoenix-ui/bundle/blobs/2941ddfe31c2601d4d895339d21f05abb38da52891a9844405bdaba548f1d08d

@@ -0,0 +1,54 @@
+Report and repair drift between this project's Phoenix UI artifacts and what the installed version reads: PRODUCT.md, DESIGN.md and its `.phoenix-ui/design.json` sidecar, `.phoenix-ui/config.json`, persisted surface briefs, and the design hook.
+
+This is maintenance, not design. Do not redesign anything, do not open files outside the ones the report names, and do not run any other command as a side effect.
+
+## What this owns, and what it does not
+
+Three kinds of drift travel under "out of date". Keep them apart:
+
+- **Tool version.** The installed skill is older than the published one. `phoenix-ui context` reports that at boot as `UPDATE_AVAILABLE` and `npx phoenix-ui update` fixes it. Not this command's job.
+- **Schema drift.** An artifact was written by an older Phoenix UI: fields nothing reads, fields now expected, files in retired locations. Mechanical, and this command repairs most of it.
+- **Truth drift.** The code moved on and the document no longer describes it. No file comparison settles this. `document` owns DESIGN.md, `init` owns PRODUCT.md, and this command's job is to hand them a specific gap rather than a vague suspicion.
+
+## Step 1: Run the pass
+
+```
+.hermes/skills/phoenix-ui/scripts/phoenix-ui doctor --json
+```
+
+Add `--target <path>` when the user named a workspace, file, or route in a monorepo. Without it the report describes the repo root, and in a monorepo that is often the wrong project.
+
+The output carries `findings` (each with `id`, `artifact`, `path`, `severity`, `summary`, `fix`) and, in a monorepo, `workspaces` with each app's product and design resolution. `ruleRegistryAvailable: false` means ignored rule ids could not be validated; say so rather than implying that list is clean.
+
+An empty `findings` array is the good outcome. Say so in one line and stop.
+
+## Step 2: Act by severity
+
+The severity says what should happen, not how bad it is.
+
+- **`auto`** carries no decision. Run `.hermes/skills/phoenix-ui/scripts/phoenix-ui doctor --fix` once to apply these, then report what it moved in one line. Do not ask permission first, and do not ask about them afterward.
+- **`mention`** needs the user to know but not to decide anything now. State each one in a sentence with its offered fix.
+- **`route`** needs a specific command. Name the command and the gap it would close. Run it only if the user asks in this turn; `init` and `document` are conversations, not repairs you perform unattended.
+
+Report all three groups in one pass. Findings are not errors and the command does not fail on them.
+
+## Step 3: Deprecated fields are binding
+
+A finding that reports a deprecated field (`## Register` is the current one) is not a style note. Treat that field as absent for every decision from here on, whatever value it holds, and offer to delete the section. Preserving it "just in case" is how a retired axis keeps steering current output.
+
+## Step 4: Do not overclaim on truth drift
+
+`design-md-drift` counts commits to the visual source directories since DESIGN.md was last edited. A commit count is not a contradiction. Report the number, say what it measures, and if the user wants to know whether the document is actually wrong, read DESIGN.md against the current tokens and components and answer from that. Never assert that DESIGN.md is stale because the number is large.
+
+The same restraint applies to `workspace-context-inherited`. Inheritance is a designed behavior. Whether one product record truthfully describes several apps is a question for the user, not a defect to fix.
+
+## Monorepo notes
+
+- `workspace-platform-native-evidence` is the finding that matters most here: a workspace carrying native build files while inheriting a root record that resolves to web gets web guidance for its whole life and never loads [ios.md](ios.md) or [android.md](android.md). The repair is a child PRODUCT.md in that workspace, because one inherited record cannot hold two platforms.
+- `config-project-roots-match-nothing` means every `projectRoots` glob missed, so the repo root is silently standing in as the active project. A renamed workspace directory is the usual cause. Report the patterns and ask which directories they should name.
+- `config-invalid-build-path` and `config-build-path-unset` both concern one key, `buildPath` in `.phoenix-ui/config.json` (or the gitignored `.phoenix-ui/config.local.json`, which wins for that developer). It holds `comp` or `code` and sets whether new surfaces are built from a generated comp or straight in code. An unread value does not fall back to the opposite path, so a project meaning `code` has been building comp-led; report the exact value. The unset finding fires only where a project has done direction work and never recorded a preference, and the offer belongs in it only when image generation exists in your tool surface. Without image generation there is nothing to choose and nothing to say.
+- Use the `workspaces` table to show the user which apps carry their own context, which inherit, and which have none, before proposing any change.
+
+## Opting out of the boot check
+
+`phoenix-ui context` reports the cheap subset of these findings at session start, throttled to once a week per project. Set `"stalenessCheck": false` in `.phoenix-ui/config.json` to silence that, or `PHOENIX_UI_NO_STALENESS_CHECK=1` for one session. This command still works with the check disabled, and that is the combination to suggest for a user who wants the report only when they ask for it.

package/vendor/phoenix-ui/bundle/blobs/29ef8f5f9cb6318b7c3e513654e169768369a95fa70ba4286aeedda7b6233dc6

@@ -0,0 +1,105 @@
+> **Additional context needed**: quality bar and shipping constraints.
+
+Polish is refinement, never concealed redesign. Preserve the incumbent visual world, content, behavior, and everything outside scope. If the concept itself is wrong, say so and recommend redesign or `bolder` instead of smuggling in a replacement.
+
+A detector result is defect evidence, not proof of quality. Inspect the rendered experience and real interaction path.
+
+## 1. Establish the system
+
+Read DESIGN.md and representative tokens, shared components, patterns, and neighboring flows. If no formal system exists, use coherent project conventions.
+
+Classify each drift before fixing it:
+
+- **missing token:** the system needs a reusable value;
+- **one-off implementation:** an existing shared component or pattern should replace it;
+- **conceptual mismatch:** the flow, information architecture, or hierarchy differs from comparable product areas;
+- **local defect:** the implementation is simply incomplete or inconsistent.
+
+Fix the cause at the narrowest correct level. Ask when a binding system principle cannot be inferred.
+
+## 2. Gather the evidence
+
+Use the feature yourself at the surface's representative sizes: desktop and mobile on the web; on a native platform (`ios` / `android` / `adaptive`), the shipped device classes on the simulator, emulator, or hardware, captured per the platform reference's Verifying the build section. Determine:
+
+- whether the path is functionally complete;
+- the intended quality bar and time available;
+- known constraints or deliberately unfinished work;
+- the states, content lengths, roles, and input methods users will actually encounter.
+
+If a prior critique exists, use it as one input:
+
+```bash
+.vibe/skills/phoenix-ui/scripts/phoenix-ui critique-storage latest "<resolved target>" --json
+```
+
+Exit 0 returns JSON with the latest snapshot's `body` and an exact `snapshot_file` identity. Retain `snapshot_file` until the end of the pass. For a local file target, the helper compares the file's exact current content fingerprint with the fingerprint captured by critique. Unchanged staged, unstaged, or untracked content remains current; any byte change, deletion, or replacement with a non-file closes the backlog it identified while preserving its trend history and exits 2. A URL target has no local fingerprint and remains current until explicitly closed. When current, incorporate relevant P0/P1 findings from `body` and name the snapshot read. Exit 2 means none exists or the target changed. Perform an independent pass either way.
+
+## 3. Triage
+
+Separate functional defects from cosmetic ones and fix in this order:
+
+1. broken or blocked tasks, data loss, misleading state, and inaccessible paths;
+2. missing loading, empty, error, success, disabled, and permission states;
+3. flow, hierarchy, responsive, and design-system drift;
+4. visual and motion inconsistencies;
+5. code and asset cleanup.
+
+Do not perfect one corner while leaving the rest below the same quality bar.
+
+## 4. Polish the whole path
+
+### Flow and hierarchy
+
+- Match neighboring mental models, terminology, disclosure, routing, save behavior, and optimistic or pessimistic patterns.
+- Make the primary task and current state obvious without flattening every element to equal weight.
+- Ensure arrival, transition, empty, and recovery paths connect instead of behaving as isolated screens.
+
+### Layout and type
+
+- Align to the project's grid and spacing scale; fix optical as well as mathematical alignment.
+- Group related content tightly and separate distinct groups generously.
+- Keep same-role typography consistent; test measure, wrapping, localization expansion, zoom, and font loading.
+- Verify every supported viewport rather than correcting only the current screenshot.
+
+### Color, imagery, and icons
+
+- Use semantic tokens and stable color meanings across themes.
+- Verify text, control, and focus contrast in every state.
+- Keep icon families, stroke/weight, sizing, and optical alignment coherent.
+- Prevent image layout shift; use correct aspect ratios, responsive sources, and useful alt text.
+
+### Interaction and state
+
+- Every control needs appropriate default, hover, focus, active, disabled, loading, error, and success behavior.
+- Preserve visible keyboard focus, logical tab order, labels, and platform-appropriate touch targets.
+- Keep motion coherent, interruptible, and performant. Do not add animation merely to make polish visible.
+- Validate long, missing, localized, offline, slow, and permission-limited content where the product can encounter it.
+
+### Content and code
+
+- Keep terminology, capitalization, punctuation, and factual copy consistent. Ask before changing claims.
+- Remove debug output, dead code, unused imports, obsolete styles, and polish-created duplication.
+- Replace custom implementations with shared components where the system owns the pattern.
+- Promote genuinely reusable values to tokens; do not create a system abstraction for one local exception.
+
+## 5. Verify and finish
+
+Walk the complete path again with mouse, keyboard, and touch where applicable. Check:
+
+- mobile, intermediate, and wide layouts on the web; phone and tablet size classes in both supported orientations on native;
+- loading, empty, error, success, disabled, long-content, and missing-content states;
+- zoom, contrast, focus, semantics, and screen-reader names;
+- console errors, layout shift, interaction latency, and image loading everywhere; supported browsers on the web; supported OS versions, runtime warnings, and dropped frames on native;
+- agreement with DESIGN.md, neighboring features, and the user's scope.
+
+Follow the quality guidance supplied by `phoenix-ui context` and hooks, then run any other relevant QA commands. Context requests a manual scan only when no automatic detector is active; never add another detector pass. Fix real defects and document only narrow intentional exceptions. A clean scan does not replace visual judgment.
+
+Finish with a source diff: remove accidental churn, orphaned code, redundant values, and temporary artifacts. Ship only when the feature is functionally complete and consistently finished across the path.
+
+When this pass clears every Priority Issue it took from a snapshot, close that snapshot:
+
+```bash
+.vibe/skills/phoenix-ui/scripts/phoenix-ui critique-storage close "<resolved target>" "<snapshot_file returned by latest>"
+```
+
+This closes only the snapshot this pass actually processed; if a newer critique landed meanwhile, its backlog stays live. Do not close when no snapshot was read, when `snapshot_file` was not retained, or when Priority Issues remain.

package/vendor/phoenix-ui/bundle/blobs/2a59b8e986f9d781fb2633e74b6abed4e0b2cdbfee6a52c829abebe943b69799

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const { main, shellQuote } = require('./phoenix-bootstrap.cjs');
+const provider = "trae";
+process.env.PHOENIX_UI_PROVIDER_ID ||= provider;
+main(process.argv.slice(2), {
+  skillDir: path.resolve(__dirname, '..'),
+  self: `node ${shellQuote(__filename)}`,
+}).then(code => { process.exitCode = code; }).catch(error => {
+  process.stderr.write(`Phoenix UI: ${error.message}\n`);
+  process.exitCode = 4;
+});

package/vendor/phoenix-ui/bundle/blobs/2b38a4edafd0f858381549bdeab1f3b7a604668e6d13b8814e2b219459b21444

@@ -0,0 +1,24 @@
+# Command guidance
+
+## Workflow questions
+
+Give advice without executing commands; the menu below is only for bare invocations. Consult relevant command references as needed for prerequisites and scope. Use the bundled [workflow guide](../SKILL.md). If the user also requests execution, follow that request.
+
+## No-argument routing: the context-aware menu
+
+Read this when the user invokes `/phoenix-ui` with no argument. They are asking "what should I do?" Make the menu context-aware instead of static.
+
+Setup has already run `phoenix-ui context`. If that reported `NO_PRODUCT_MD`, the project has no captured context yet: lead the menu with `/phoenix-ui init` as the top recommendation (one line on why) and still show the rest below; don't silently jump into init. Otherwise run `.cursor/skills/phoenix-ui/scripts/phoenix-ui signals` once and read its JSON, then lead with the **2-3 highest-value next commands**, each with a one-line reason pulled from the signals, followed by the full menu (the Commands table in SKILL.md, grouped by category). **Never auto-run a command; the recommendation is a suggestion the user confirms.**
+
+Reason over the signals; there is no score to obey:
+
+- `setup.hasDesign` false while `setup.hasCode` true → `document` (capture the visual system).
+- `critique.latest` is `null` → the project has never been critiqued; for a set-up project with a real surface, offering `/phoenix-ui critique <surface>` is a strong default.
+- `critique.latest` with a low `score` or non-zero `p0` / `p1` → `polish` (it reads that snapshot as its backlog and closes it when stale or cleared).
+- `git.changedFiles` pointing at one surface → scope `audit` or `polish` to those files specifically, naming them.
+- `devServer.running` true → `live` is available for in-browser iteration, and `generate` for one-shot variant runs on a named element; if false, don't lead with either. **`live`, `generate`, and the bundled `phoenix-ui detect` are web-only.** If `setup.platform` is `ios`, `android`, or `adaptive`, don't lead with any of them; the browser overlay and the HTML rule engine don't apply to native app code.
+- Otherwise group by intent (build new / improve what's there / iterate visually), tailored to the current surface and `setup.platform`.
+
+**If `scan.targets` is non-empty and `setup.platform` is not `ios`/`android`/`adaptive`, run `.cursor/skills/phoenix-ui/scripts/phoenix-ui detect --json <scan.targets joined by spaces>` once** (the bundled detector over local files: no network, no npx; it reads HTML/CSS, so skip it for native projects). `scan.via` tells you what they are: `git-changes` (the markup/style files in your dirty tree, the most relevant set), `source-dir` (e.g. `src`, `app`), `html`, or `root`. Fold the hits into your picks: many quality / contrast hits → `audit` or `polish`; a specific slop family → the matching command (gradient text or eyebrows → `quieter` / `typeset`, flat or gray palette → `colorize`, and so on). It's a real, current signal that beats guessing. If detect errors or the tree is large and slow, skip it and recommend the user run `audit` themselves; never block the suggestion on it.
+
+Keep it to 2-3 pointed picks with the exact command to type. The menu stays the fallback; the recommendation is the lede.

package/vendor/phoenix-ui/bundle/blobs/2c9f58ac42f72ee43d1038b918dbfc90c8c01028c961151d5f349abff8a3762a

@@ -0,0 +1,70 @@
+> **Additional context needed**: the brand's emotional range.
+
+Make the experience memorable at moments that earn it. Delight is not a layer of generic whimsy; it is product character revealed through a useful interaction, a humane response, or an unexpectedly considered detail.
+
+---
+
+## Visitor mode
+
+- **Persuade + Experience:** personality may run through voice, composition, motion, and discovery, provided the artifact remains the focus.
+- **Operate + Read:** concentrate delight at meaningful moments such as first use, completion, recovery, or mastery. Reliability carries everything else.
+
+## Find the opportunity
+
+Inspect the target, DESIGN.md, product voice, repeated-use frequency, and emotional context. Look for:
+
+- effort worth acknowledging;
+- waiting that can become informative;
+- an empty or first-use state that can orient;
+- an error or recovery moment that needs empathy;
+- an interaction whose physical or verbal response could express the brand;
+- a useful capability people might enjoy discovering.
+
+Do not manufacture a celebration for an ordinary click. Ask only when the brand's emotional range or the stakes cannot be inferred.
+
+## Define one delight thesis
+
+State in one sentence what the user should feel and why that feeling belongs to this product. Then choose the smallest system that can deliver it:
+
+- a distinctive response to a meaningful action;
+- product-specific language that clarifies while carrying voice;
+- an interaction or transition with a recognizable material behavior;
+- an illustration, sound, haptic, or environmental detail grounded in the product world;
+- a discovery reward that reveals real utility.
+
+Derive the treatment from product mechanism and visual world, not a stock catalog.
+
+## Build for the emotional moment
+
+- **Success:** match the response to the effort and consequence. Major milestones can expand; routine saves should simply feel certain.
+- **Waiting:** show truthful progress, useful context, or product-specific activity. Never fake work or delay completion to stage a flourish.
+- **Empty and first use:** make the next action clear before adding personality.
+- **Error and recovery:** lead with the problem and recovery. Warmth may reduce stress; jokes must not trivialize loss, money, privacy, or blocked work.
+- **Repeated interaction:** keep the response satisfying after the hundredth use. Variation is useful only when it remains coherent and predictable enough to trust.
+- **Discovery:** reward curiosity without hiding required functionality.
+
+Copy must use the product's language. Generic whimsy is worse than neutral clarity.
+
+## Protect the experience
+
+Delight must not:
+
+- delay, block, or obscure the primary task;
+- override platform conventions or accessibility;
+- add unrequested factual claims;
+- play sound without consent or ignore mute settings;
+- become mandatory, unskippable, or exhausting on repeat;
+- add a dependency or asset cost disproportionate to the moment.
+
+For authored motion, load [animate.md](animate.md). Respect screen readers, keyboard use, touch, localization, and cultural context. Nonessential loops stop when hidden. Make celebration intensity proportional to frequency and consequence.
+
+## Verify
+
+- The moment is specific enough that a neighboring product could not use it unchanged.
+- It improves comprehension, confidence, motivation, or emotional recovery.
+- The interface remains fast and obvious without the flourish.
+- Repetition does not turn charm into friction.
+- Muted, keyboard, touch, and localized paths work.
+- The result feels like the selected world, not a generic “delight” treatment.
+
+When the personality feels earned, hand off to `/phoenix-ui polish` for the final pass.

package/vendor/phoenix-ui/bundle/blobs/2d16e6cd514e98996f8cf4b58552eec71016b0c06695e8526eaffc396ff22dd7

@@ -0,0 +1,80 @@
+Typography carries information, hierarchy, and voice. Improve it inside the established visual world; do not replace the identity unless the user asked to.
+
+---
+
+## Visitor mode
+
+- **Persuade + Experience:** display type may carry the voice. Use decisive contrast and responsive scale when the composition benefits.
+- **Operate + Read:** stability, scanability, and measure come first. A single well-tuned family and fixed role scale are often right.
+- **Native:** follow [ios.md](ios.md) or [android.md](android.md), including platform scaling and accessibility behavior.
+
+If typography replacement would create a new identity, route through [new-work.md](new-work.md) and update DESIGN.md. Otherwise preserve confirmed families and improve their use.
+
+## Two isolated assessments
+
+When a sub-agent tool is available and permitted, run these independently; otherwise run them yourself in this order. Do not let detector findings anchor the design assessment.
+
+1. **Typographic assessment:** inspect representative pages and styles. Answer every question below with a file, selector, or computed value:
+   - **Authority and fit:** Which faces, weights, and roles are established? Do they fit the product and selected world, or are they unexamined defaults? Is every family necessary?
+   - **Hierarchy:** Can heading, body, label, metadata, and data roles be distinguished at a glance? Are adjacent sizes or weights too close to carry different jobs?
+   - **Scale and consistency:** Is there a deliberate role scale, or a collection of arbitrary values? Do repeated roles stay identical across screens and states?
+   - **Reading:** Does body copy stay within a comfortable 45–75 character measure? Are line height, paragraph rhythm, contrast, and tracking tuned to the actual face, width, language, and surface?
+   - **Stress:** What happens with long headings, localization expansion, zoom, narrow containers, missing weights, and font fallback?
+   - **Delivery:** Are only used assets loaded? Do fallback metrics, loading strategy, and variable-font settings avoid invisible text and disruptive reflow?
+2. **Mechanical scan:** run:
+
+```bash
+.hermes/skills/phoenix-ui/scripts/phoenix-ui detect --json --scope type [target files or dirs]
+```
+
+Also inspect dynamic or arbitrary font values the detector cannot interpret. Synthesize both assessments before editing, noting what each caught alone. A clean scan is a floor, not proof of good typography.
+
+## Set the system
+
+Before editing, state:
+
+- the roles the interface needs;
+- the intended contrast between those roles;
+- the reading measure and density;
+- which existing faces and weights are authoritative;
+- any performance, localization, or accessibility constraints.
+
+Use the fewest roles and families that make the hierarchy unmistakable. Combine size, weight, space, and tone deliberately instead of asking size alone to do all the work. Role names and tokens should describe purpose rather than values.
+
+## Apply
+
+- Keep body copy comfortably readable and zoomable. Use 1rem / 16px as the ordinary web body floor unless a dense role, platform convention, or user setting justifies otherwise.
+- Keep prose in the 45–75ch range. Tune line height inversely with measure: wider lines generally need more leading.
+- Compensate light text on dark surfaces on all three perceptual axes: slightly more line height, a touch more tracking, and one step more weight when the face needs it.
+- Tune line height to the face, width, language, and contrast, not a universal ratio.
+- Keep repeated roles consistent across screens and states.
+- Use numeric, tabular, code, and label features when their content benefits.
+- Load only used font assets and weights. Provide metric-compatible fallbacks and avoid blocking text.
+- Let marketing display type respond to available space when useful; keep dense product and reading surfaces spatially predictable.
+- Preserve browser zoom, user font settings, Dynamic Type, and platform text scaling.
+- Use paragraph spacing or first-line indentation as the primary paragraph rhythm; combining both usually double-marks the boundary.
+
+Do not make type decorative at the expense of comprehension, or introduce a second family without a clear role it alone can perform.
+
+## Verify
+
+- Primary, secondary, body, and metadata roles are recognizable without reading the copy.
+- Long text remains comfortable across relevant widths and languages.
+- The typography belongs to the product and its established world.
+- Loading does not create disruptive reflow or invisible text.
+- Zoom, text scaling, focus, contrast, and reduced viewport paths remain usable.
+- The final mechanical scan has no unexplained findings.
+
+Answer each item with rendered or source evidence, then rerun the scan. Do not substitute a bare “yes” for verification.
+
+When the hierarchy holds, hand off to `/phoenix-ui polish`.
+
+## Live-mode signature params
+
+Every variant declares a coarse `scale` parameter and authors its type ramp against `var(--p-scale, 1)`.
+
+```json
+{"id":"scale","kind":"range","min":0.85,"max":1.3,"step":0.05,"default":1,"label":"Scale"}
+```
+
+Add at most one pairing or weight parameter when it represents a real system choice. Follow [live.md](live.md)'s parameter contract.