@ruaruababa/vibe-kit 1.0.0

package/dist/dist/src/cli/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import path from 'path';
+const program = new Command();
+program
+    .name('vibe')
+    .description('Vibe Kit CLI - Manage your AI agent vibes')
+    .version('1.0.0');
+program
+    .command('list')
+    .description('List all available vibes')
+    .action(async () => {
+    const catalogPath = path.join(process.cwd(), 'catalog.json');
+    if (!fs.existsSync(catalogPath)) {
+        console.error(chalk.red('❌ Catalog not found. Run npm run build:catalog first.'));
+        return;
+    }
+    const catalog = await fs.readJSON(catalogPath);
+    console.log(chalk.bold('\nAvailable Vibes:'));
+    catalog.skills.forEach((skill) => {
+        console.log(`${chalk.green('•')} ${chalk.bold(skill.name)} - ${skill.description}`);
+    });
+});
+program.parse();

package/dist/lib/skill-utils.js

@@ -0,0 +1,158 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const yaml = require('yaml');
+function stripQuotes(value) {
+    if (typeof value !== 'string')
+        return value;
+    if (value.length < 2)
+        return value.trim();
+    const first = value[0];
+    const last = value[value.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+        return value.slice(1, -1).trim();
+    }
+    if (first === '"' || first === "'") {
+        return value.slice(1).trim();
+    }
+    if (last === '"' || last === "'") {
+        return value.slice(0, -1).trim();
+    }
+    return value.trim();
+}
+function parseInlineList(raw) {
+    if (typeof raw !== 'string')
+        return [];
+    const value = raw.trim();
+    if (!value.startsWith('[') || !value.endsWith(']'))
+        return [];
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return [];
+    return inner
+        .split(',')
+        .map(item => stripQuotes(item.trim()))
+        .filter(Boolean);
+}
+function isPlainObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value);
+}
+function parseFrontmatter(content) {
+    const sanitized = content.replace(/^\uFEFF/, '');
+    const lines = sanitized.split(/\r?\n/);
+    if (!lines.length || lines[0].trim() !== '---') {
+        return { data: {}, body: content, errors: [], hasFrontmatter: false };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i].trim() === '---') {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        return {
+            data: {},
+            body: content,
+            errors: ['Missing closing frontmatter delimiter (---).'],
+            hasFrontmatter: true,
+        };
+    }
+    const errors = [];
+    const fmText = lines.slice(1, endIndex).join('\n');
+    let data = {};
+    try {
+        const doc = yaml.parseDocument(fmText, { prettyErrors: false });
+        if (doc.errors && doc.errors.length) {
+            errors.push(...doc.errors.map(error => error.message));
+        }
+        data = doc.toJS();
+    }
+    catch (err) {
+        errors.push(err.message);
+        data = {};
+    }
+    if (!isPlainObject(data)) {
+        errors.push('Frontmatter must be a YAML mapping/object.');
+        data = {};
+    }
+    const body = lines.slice(endIndex + 1).join('\n');
+    return { data, body, errors, hasFrontmatter: true };
+}
+function tokenize(value) {
+    if (!value)
+        return [];
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .split(' ')
+        .map(token => token.trim())
+        .filter(Boolean);
+}
+function unique(list) {
+    const seen = new Set();
+    const result = [];
+    for (const item of list) {
+        if (!item || seen.has(item))
+            continue;
+        seen.add(item);
+        result.push(item);
+    }
+    return result;
+}
+function readSkill(skillDir, skillId) {
+    const skillPath = path.join(skillDir, skillId, 'SKILL.md');
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const { data } = parseFrontmatter(content);
+    const name = typeof data.name === 'string' && data.name.trim()
+        ? data.name.trim()
+        : skillId;
+    const description = typeof data.description === 'string'
+        ? data.description.trim()
+        : '';
+    let tags = [];
+    if (Array.isArray(data.tags)) {
+        tags = data.tags.map(tag => String(tag).trim());
+    }
+    else if (typeof data.tags === 'string' && data.tags.trim()) {
+        const parts = data.tags.includes(',')
+            ? data.tags.split(',')
+            : data.tags.split(/\s+/);
+        tags = parts.map(tag => tag.trim());
+    }
+    else if (isPlainObject(data.metadata) && data.metadata.tags) {
+        const rawTags = data.metadata.tags;
+        if (Array.isArray(rawTags)) {
+            tags = rawTags.map(tag => String(tag).trim());
+        }
+        else if (typeof rawTags === 'string' && rawTags.trim()) {
+            const parts = rawTags.includes(',')
+                ? rawTags.split(',')
+                : rawTags.split(/\s+/);
+            tags = parts.map(tag => tag.trim());
+        }
+    }
+    tags = tags.filter(Boolean);
+    return {
+        id: skillId,
+        name,
+        description,
+        tags,
+        path: skillPath,
+        content,
+    };
+}
+function listSkillIds(skillsDir) {
+    return fs.readdirSync(skillsDir)
+        .filter(entry => !entry.startsWith('.') && fs.statSync(path.join(skillsDir, entry)).isDirectory())
+        .sort();
+}
+module.exports = {
+    listSkillIds,
+    parseFrontmatter,
+    parseInlineList,
+    readSkill,
+    stripQuotes,
+    tokenize,
+    unique,
+};

package/dist/scripts/build-catalog.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+async function run() {
+    const skillsDir = path.resolve(process.cwd(), 'skills');
+    const items = await fs.readdir(skillsDir);
+    const skills = [];
+    for (const item of items) {
+        const skillPath = path.join(skillsDir, item);
+        if (!(await fs.stat(skillPath)).isDirectory())
+            continue;
+        const skillMdPath = path.join(skillPath, 'SKILL.md');
+        if (!fs.existsSync(skillMdPath))
+            continue;
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+            const yamlLines = frontmatterMatch[1].split('\n');
+            const frontmatter = {};
+            for (const line of yamlLines) {
+                const [key, ...valueParts] = line.split(':');
+                if (key && valueParts.length > 0) {
+                    frontmatter[key.trim()] = valueParts.join(':').trim();
+                }
+            }
+            skills.push({
+                name: frontmatter.name || item,
+                description: frontmatter.description || '',
+                path: `skills/${item}`,
+            });
+        }
+    }
+    const catalog = {
+        lastUpdated: new Date().toISOString(),
+        skills,
+    };
+    await fs.writeJSON(path.join(process.cwd(), 'catalog.json'), catalog, { spaces: 2 });
+    console.log(chalk.blue(`📂 catalog.json built with ${skills.length} skills.`));
+    // Generate CATALOG.md
+    let markdown = `# Vibe Kit Catalog\n\n`;
+    markdown += `Explore our curated collection of ${skills.length} vibes. Last updated: ${new Date().toLocaleDateString()}\n\n`;
+    markdown += `| Name | Description | Path |\n`;
+    markdown += `|------|-------------|------|\n`;
+    for (const skill of skills) {
+        markdown += `| **${skill.name}** | ${skill.description} | [View](./${skill.path}) |\n`;
+    }
+    await fs.writeFile(path.join(process.cwd(), 'CATALOG.md'), markdown);
+    console.log(chalk.magenta(`📝 CATALOG.md generated.`));
+}
+run();

package/dist/scripts/normalize-frontmatter.js

@@ -0,0 +1,144 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const yaml = require('yaml');
+const { listSkillIds, parseFrontmatter } = require('../lib/skill-utils');
+const ROOT = path.resolve(__dirname, '..');
+const SKILLS_DIR = path.join(ROOT, 'skills');
+const ALLOWED_FIELDS = new Set([
+    'name',
+    'description',
+    'license',
+    'compatibility',
+    'metadata',
+    'allowed-tools',
+]);
+function isPlainObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value);
+}
+function coerceToString(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value.trim();
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        const simple = value.every(item => ['string', 'number', 'boolean'].includes(typeof item));
+        return simple ? value.map(item => String(item).trim()).filter(Boolean).join(', ') : JSON.stringify(value);
+    }
+    if (isPlainObject(value)) {
+        return JSON.stringify(value);
+    }
+    return String(value).trim();
+}
+function appendMetadata(metadata, key, value) {
+    const nextValue = coerceToString(value);
+    if (!nextValue)
+        return;
+    if (!metadata[key]) {
+        metadata[key] = nextValue;
+        return;
+    }
+    if (metadata[key].includes(nextValue))
+        return;
+    metadata[key] = `${metadata[key]}, ${nextValue}`;
+}
+function collectAllowedTools(value, toolSet) {
+    if (!value)
+        return;
+    if (typeof value === 'string') {
+        value
+            .split(/[\s,]+/)
+            .map(token => token.trim())
+            .filter(Boolean)
+            .forEach(token => toolSet.add(token));
+        return;
+    }
+    if (Array.isArray(value)) {
+        value
+            .map(token => String(token).trim())
+            .filter(Boolean)
+            .forEach(token => toolSet.add(token));
+    }
+}
+function normalizeSkill(skillId) {
+    const skillPath = path.join(SKILLS_DIR, skillId, 'SKILL.md');
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const { data, body, hasFrontmatter } = parseFrontmatter(content);
+    if (!hasFrontmatter)
+        return false;
+    let modified = false;
+    const updated = { ...data };
+    const metadata = isPlainObject(updated.metadata) ? { ...updated.metadata } : {};
+    if (updated.metadata !== undefined && !isPlainObject(updated.metadata)) {
+        appendMetadata(metadata, 'legacy_metadata', updated.metadata);
+        modified = true;
+    }
+    const allowedTools = new Set();
+    collectAllowedTools(updated['allowed-tools'], allowedTools);
+    collectAllowedTools(updated.tools, allowedTools);
+    collectAllowedTools(updated.tool_access, allowedTools);
+    if (updated.tools !== undefined) {
+        delete updated.tools;
+        modified = true;
+    }
+    if (updated.tool_access !== undefined) {
+        delete updated.tool_access;
+        modified = true;
+    }
+    for (const key of Object.keys(updated)) {
+        if (ALLOWED_FIELDS.has(key))
+            continue;
+        if (key === 'tags') {
+            appendMetadata(metadata, 'tags', updated[key]);
+        }
+        else {
+            appendMetadata(metadata, key, updated[key]);
+        }
+        delete updated[key];
+        modified = true;
+    }
+    if (allowedTools.size) {
+        updated['allowed-tools'] = Array.from(allowedTools).join(' ');
+        modified = true;
+    }
+    else if (updated['allowed-tools'] !== undefined) {
+        delete updated['allowed-tools'];
+        modified = true;
+    }
+    if (Object.keys(metadata).length) {
+        updated.metadata = metadata;
+        modified = true;
+    }
+    else if (updated.metadata !== undefined) {
+        delete updated.metadata;
+        modified = true;
+    }
+    if (!modified)
+        return false;
+    const ordered = {};
+    for (const key of ['name', 'description', 'license', 'compatibility', 'allowed-tools', 'metadata']) {
+        if (updated[key] !== undefined) {
+            ordered[key] = updated[key];
+        }
+    }
+    const fm = yaml.stringify(ordered).trimEnd();
+    const bodyPrefix = body.length && (body.startsWith('\n') || body.startsWith('\r\n')) ? '' : '\n';
+    const next = `---\n${fm}\n---${bodyPrefix}${body}`;
+    fs.writeFileSync(skillPath, next);
+    return true;
+}
+function run() {
+    const skillIds = listSkillIds(SKILLS_DIR);
+    let updatedCount = 0;
+    for (const skillId of skillIds) {
+        if (normalizeSkill(skillId))
+            updatedCount += 1;
+    }
+    console.log(`Normalized frontmatter for ${updatedCount} skills.`);
+}
+if (require.main === module) {
+    run();
+}
+module.exports = { run };

package/dist/scripts/validate-skills.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { SkillFrontmatterSchema } from '../src/types/index.js';
+async function validateSkill(skillPath) {
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+        console.error(chalk.red(`❌ Missing SKILL.md in ${skillPath}`));
+        return false;
+    }
+    try {
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!frontmatterMatch) {
+            console.error(chalk.red(`❌ No frontmatter found in ${skillMdPath}`));
+            return false;
+        }
+        const yamlLines = frontmatterMatch[1].split('\n');
+        const frontmatter = {};
+        for (const line of yamlLines) {
+            const [key, ...valueParts] = line.split(':');
+            if (key && valueParts.length > 0) {
+                frontmatter[key.trim()] = valueParts.join(':').trim();
+            }
+        }
+        const result = SkillFrontmatterSchema.safeParse(frontmatter);
+        if (!result.success) {
+            console.error(chalk.red(`❌ Validation failed for ${skillMdPath}:`));
+            console.error(result.error.issues);
+            return false;
+        }
+        console.log(chalk.green(`✅ ${frontmatter.name} validated.`));
+        return true;
+    }
+    catch (err) {
+        console.error(chalk.red(`❌ Error reading ${skillMdPath}:`), err);
+        return false;
+    }
+}
+async function run() {
+    const skillsDir = path.resolve(process.cwd(), 'skills');
+    const items = await fs.readdir(skillsDir);
+    let allValid = true;
+    for (const item of items) {
+        const fullPath = path.join(skillsDir, item);
+        if ((await fs.stat(fullPath)).isDirectory()) {
+            const isValid = await validateSkill(fullPath);
+            if (!isValid)
+                allValid = false;
+        }
+    }
+    if (!allValid) {
+        process.exit(1);
+    }
+}
+run();

package/dist/src/cli/index.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import ora from 'ora';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const KIT_ROOT = path.resolve(__dirname, '../../../');
+const ALIASES_PATH = path.join(KIT_ROOT, 'aliases.json');
+const BUNDLES_PATH = path.join(KIT_ROOT, 'bundles.json');
+const program = new Command();
+program
+    .name('vibe')
+    .description('Vibe Kit CLI - Manage your AI agent vibes')
+    .version('1.0.0');
+program
+    .command('list')
+    .description('List all available vibes')
+    .action(async () => {
+    const catalogPath = path.join(KIT_ROOT, 'catalog.json');
+    if (!fs.existsSync(catalogPath)) {
+        console.error(chalk.red(`❌ Catalog not found at ${catalogPath}. Run npm run build:catalog in kit root.`));
+        return;
+    }
+    const catalog = await fs.readJSON(catalogPath);
+    console.log(chalk.bold('\nAvailable Vibes:'));
+    catalog.skills.forEach((skill) => {
+        console.log(`${chalk.green('•')} ${chalk.bold(skill.name)} - ${skill.description}`);
+    });
+});
+program
+    .command('bundles')
+    .description('List available skill bundles')
+    .action(async () => {
+    if (!fs.existsSync(BUNDLES_PATH)) {
+        console.error(chalk.red('❌ bundles.json not found.'));
+        return;
+    }
+    const data = await fs.readJSON(BUNDLES_PATH);
+    console.log(chalk.bold('\nAvailable Bundles:'));
+    Object.entries(data.bundles).forEach(([name, bundle]) => {
+        console.log(`${chalk.cyan('•')} ${chalk.bold(name)}: ${bundle.description}`);
+        console.log(`  ${chalk.dim('Skills: ' + bundle.skills.slice(0, 5).join(', ') + (bundle.skills.length > 5 ? '...' : ''))}`);
+    });
+});
+program
+    .command('aliases')
+    .description('List skill aliases')
+    .action(async () => {
+    if (!fs.existsSync(ALIASES_PATH)) {
+        console.error(chalk.red('❌ aliases.json not found.'));
+        return;
+    }
+    const aliases = await fs.readJSON(ALIASES_PATH);
+    console.log(chalk.bold('\nSkill Aliases:'));
+    Object.entries(aliases).forEach(([alias, skill]) => {
+        console.log(`${chalk.yellow('•')} ${chalk.bold(alias)} ${chalk.dim('→')} ${skill}`);
+    });
+});
+program
+    .command('search <query>')
+    .description('Search for vibes in the catalog')
+    .action(async (query) => {
+    const catalogPath = path.join(KIT_ROOT, 'catalog.json');
+    if (!fs.existsSync(catalogPath)) {
+        console.error(chalk.red(`❌ Catalog not found at ${catalogPath}. Run npm run build:catalog in kit root.`));
+        return;
+    }
+    const catalog = await fs.readJSON(catalogPath);
+    const results = catalog.skills.filter(skill => skill.name.toLowerCase().includes(query.toLowerCase()) ||
+        skill.description.toLowerCase().includes(query.toLowerCase()));
+    if (results.length === 0) {
+        console.log(chalk.yellow(`\nNo vibes found matching "${query}"`));
+        return;
+    }
+    console.log(chalk.bold(`\nSearch Results for "${query}":`));
+    results.forEach((skill) => {
+        console.log(`${chalk.green('•')} ${chalk.bold(skill.name)} - ${skill.description}`);
+    });
+});
+program
+    .command('install <name>')
+    .description('Install a vibe or bundle to the current workspace')
+    .option('-b, --bundle', 'Install a bundle of skills')
+    .option('-g, --global', 'Install globally (not implemented)')
+    .action(async (name, options) => {
+    const catalogPath = path.join(KIT_ROOT, 'catalog.json');
+    if (!fs.existsSync(catalogPath)) {
+        console.error(chalk.red(`❌ Catalog not found at ${catalogPath}. Run npm run build:catalog in kit root.`));
+        return;
+    }
+    const catalog = await fs.readJSON(catalogPath);
+    if (options.bundle) {
+        if (!fs.existsSync(BUNDLES_PATH)) {
+            console.error(chalk.red('❌ bundles.json not found.'));
+            return;
+        }
+        const bundleData = await fs.readJSON(BUNDLES_PATH);
+        const bundle = bundleData.bundles[name];
+        if (!bundle) {
+            console.error(chalk.red(`❌ Bundle "${name}" not found.`));
+            return;
+        }
+        const spinner = ora(`Installing bundle: ${name}...`).start();
+        let count = 0;
+        for (const skillName of bundle.skills) {
+            const skill = catalog.skills.find(s => s.name === skillName);
+            if (skill) {
+                const destDir = path.join(process.cwd(), '.agent', 'skills', skillName);
+                const srcDir = path.join(KIT_ROOT, skill.path);
+                await fs.ensureDir(destDir);
+                await fs.copy(srcDir, destDir);
+                count++;
+            }
+        }
+        spinner.succeed(chalk.green(`Bundle "${name}" installed! (${count} skills)`));
+        return;
+    }
+    // Single skill install (with alias support)
+    let skillName = name;
+    if (fs.existsSync(ALIASES_PATH)) {
+        const aliases = await fs.readJSON(ALIASES_PATH);
+        if (aliases[name]) {
+            skillName = aliases[name];
+        }
+    }
+    const skill = catalog.skills.find(s => s.name === skillName);
+    if (!skill) {
+        console.error(chalk.red(`❌ Vibe "${skillName}" not found in catalog.`));
+        return;
+    }
+    const spinner = ora(`Installing vibe: ${skillName}...`).start();
+    try {
+        const destDir = path.join(process.cwd(), '.agent', 'skills', skillName);
+        const srcDir = path.join(KIT_ROOT, skill.path);
+        await fs.ensureDir(destDir);
+        await fs.copy(srcDir, destDir);
+        spinner.succeed(chalk.green(`Vibe "${skillName}" installed to .agent/skills/${skillName}`));
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Failed to install vibe: ${err.message}`));
+    }
+});
+program.parse();

package/dist/src/types/index.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export const SkillFrontmatterSchema = z.object({
+    name: z.string().min(1, "Skill name is required"),
+    description: z.string().min(1, "Description is required"),
+});
+export const CatalogItemSchema = SkillFrontmatterSchema.extend({
+    path: z.string(),
+    category: z.string().optional(),
+});
+export const CatalogSchema = z.object({
+    lastUpdated: z.string(),
+    skills: z.array(CatalogItemSchema),
+});

package/dist/src/utils/fs.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@ruaruababa/vibe-kit",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "bin": {
+    "vibe": "./bin/vibe.js"
+  },
+  "scripts": {
+    "build": "npx tsc && npm run build:catalog",
+    "build:catalog": "node --loader ts-node/esm scripts/build-catalog.ts",
+    "validate": "node --loader ts-node/esm scripts/validate-skills.ts",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "skills",
+    "catalog.json",
+    "CATALOG.md",
+    "bundles.json",
+    "aliases.json",
+    "README.md"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "fs-extra": "^11.3.3",
+    "ora": "^9.1.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  }
+}

package/skills/accessibility-compliance-accessibility-audit/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: accessibility-compliance-accessibility-audit
+description: "You are an accessibility expert specializing in WCAG compliance, inclusive design, and assistive technology compatibility. Conduct audits, identify barriers, and provide remediation guidance."
+---
+
+# Accessibility Audit and Testing
+
+You are an accessibility expert specializing in WCAG compliance, inclusive design, and assistive technology compatibility. Conduct comprehensive audits, identify barriers, provide remediation guidance, and ensure digital products are accessible to all users.
+
+## Use this skill when
+
+- Auditing web or mobile experiences for WCAG compliance
+- Identifying accessibility barriers and remediation priorities
+- Establishing ongoing accessibility testing practices
+- Preparing compliance evidence for stakeholders
+
+## Do not use this skill when
+
+- You only need a general UI design review without accessibility scope
+- The request is unrelated to user experience or compliance
+- You cannot access the UI, design artifacts, or content
+
+## Context
+
+The user needs to audit and improve accessibility to ensure compliance with WCAG standards and provide an inclusive experience for users with disabilities. Focus on automated testing, manual verification, remediation strategies, and establishing ongoing accessibility practices.
+
+## Requirements
+
+$ARGUMENTS
+
+## Instructions
+
+- Confirm scope (platforms, WCAG level, target pages, key user journeys).
+- Run automated scans to collect baseline violations and coverage gaps.
+- Perform manual checks (keyboard, screen reader, focus order, contrast).
+- Map findings to WCAG criteria, severity, and user impact.
+- Provide remediation steps and re-test after fixes.
+- If detailed procedures are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed audit steps, tooling, and remediation examples.