codymaster 4.8.0 → 7.0.0

package/dist/token-budget.js

@@ -8,6 +8,10 @@ exports.loadBudget = loadBudget;
 exports.checkBudget = checkBudget;
 exports.estimateTokens = estimateTokens;
 exports.generateBudgetReport = generateBudgetReport;
+exports.getDefaultTierBudgets = getDefaultTierBudgets;
+exports.checkTierBudget = checkTierBudget;
+exports.generateTierReport = generateTierReport;
+exports.formatSavingsReport = formatSavingsReport;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -106,3 +110,87 @@ function generateBudgetReport(budget) {
     lines.push(`${'TOTAL'.padEnd(25)} ${sum.toLocaleString().padStart(10)} ${(((sum / total) * 100).toFixed(2) + '%').padStart(10)}`);
     return lines.join('\n');
 }
+// ─── Per-Tier Budgets (Smart Brain Router integration) ───────────────────────
+/**
+ * Default per-tier token budgets for the 5-Tier Brain architecture.
+ * Used by SmartBrainRouter to enforce tier-level spending limits.
+ */
+function getDefaultTierBudgets() {
+    return [
+        { tier: 1, label: 'Sensory', soft: 0, hard: 0 }, // Always on, zero cost
+        { tier: 2, label: 'Working', soft: 500, hard: 1000 }, // CONTINUITY.md
+        { tier: 3, label: 'Long-term', soft: 500, hard: 3000 }, // Learnings/decisions
+        { tier: 4, label: 'Semantic', soft: 0, hard: 2000 }, // qmd vector search
+        { tier: 5, label: 'Structural', soft: 0, hard: 4000 }, // CodeGraph AST
+    ];
+}
+/**
+ * Check if a tier's token usage is within budget.
+ */
+function checkTierBudget(tierBudgets, tier, tokenCount, enforcement = 'soft') {
+    const budget = tierBudgets.find(tb => tb.tier === tier);
+    if (!budget) {
+        return { allowed: false, remaining: 0, suggestion: `Unknown tier ${tier}` };
+    }
+    const limit = enforcement === 'hard' ? budget.hard : budget.soft;
+    if (limit === 0) {
+        // Tier is disabled by default (soft=0), but allowed up to hard limit
+        if (tokenCount <= budget.hard) {
+            return { allowed: true, remaining: budget.hard - tokenCount };
+        }
+        return {
+            allowed: false,
+            remaining: budget.hard - tokenCount,
+            suggestion: `Tier ${tier} (${budget.label}) exceeds hard limit of ${budget.hard} tokens.`,
+        };
+    }
+    const remaining = limit - tokenCount;
+    if (remaining >= 0) {
+        return { allowed: true, remaining };
+    }
+    return {
+        allowed: enforcement !== 'hard',
+        remaining,
+        suggestion: `Tier ${tier} (${budget.label}) over by ~${Math.abs(remaining)} tokens. Consider L0 loading.`,
+    };
+}
+/**
+ * Generate a tier-level budget report.
+ */
+function generateTierReport(tierBudgets) {
+    const lines = [
+        `Brain Tier Budget Report`,
+        '─'.repeat(60),
+        `${'Tier'.padEnd(6)} ${'Label'.padEnd(12)} ${'Soft'.padStart(8)} ${'Hard'.padStart(8)} ${'Status'.padStart(10)}`,
+        '─'.repeat(60),
+    ];
+    for (const tb of tierBudgets) {
+        const status = tb.soft === 0 ? 'off/demand' : 'active';
+        lines.push(`${String(tb.tier).padEnd(6)} ${tb.label.padEnd(12)} ${tb.soft.toLocaleString().padStart(8)} ${tb.hard.toLocaleString().padStart(8)} ${status.padStart(10)}`);
+    }
+    const totalSoft = tierBudgets.reduce((s, tb) => s + tb.soft, 0);
+    const totalHard = tierBudgets.reduce((s, tb) => s + tb.hard, 0);
+    lines.push('─'.repeat(60));
+    lines.push(`${'TOTAL'.padEnd(18)} ${totalSoft.toLocaleString().padStart(8)} ${totalHard.toLocaleString().padStart(8)}`);
+    return lines.join('\n');
+}
+/**
+ * Format token savings report for CLI display.
+ */
+function formatSavingsReport(savings) {
+    const lines = [
+        `💰 Token Savings Report`,
+        '─'.repeat(50),
+        `Brain routing:       ~${savings.brainRoutingSaved.toLocaleString()} tokens saved`,
+        `Cache hits:          ~${savings.cacheHitsSaved.toLocaleString()} tokens saved`,
+        `Progressive loading: ~${savings.progressiveLoadSaved.toLocaleString()} tokens saved`,
+        '─'.repeat(50),
+        `Total saved:         ~${savings.totalSaved.toLocaleString()} tokens`,
+        `Tasks this session:  ${savings.sessionTasks}`,
+    ];
+    if (savings.sessionTasks > 0) {
+        const avgSaved = Math.round(savings.totalSaved / savings.sessionTasks);
+        lines.push(`Avg saved per task:  ~${avgSaved.toLocaleString()} tokens`);
+    }
+    return lines.join('\n');
+}

package/dist/ui/onboarding.js

@@ -121,34 +121,70 @@ function runOnboarding(version) {
             profile.firstRunAt = new Date().toISOString();
             (0, hooks_1.saveProfile)(profile);
         }
-        // ─── STEP 2: Platform ──────────────────────────
+        // ─── STEP 2: Platform(s) + Install ─────────────
         if (startStep < 2) {
             console.log('');
             console.log(`    ${(0, theme_1.success)('✓')} ${(0, theme_1.dim)('Nice to meet you,')} ${(0, theme_1.brand)(profile.userName)}${(0, theme_1.dim)('!')}`);
             console.log('');
             console.log((0, box_1.renderStepProgress)(2, TOTAL_STEPS));
             console.log('');
-            const platformResult = yield p.select({
-                message: 'Where do you code?',
+            const { detectPlatforms, installToMany } = yield Promise.resolve().then(() => __importStar(require('../install/engine')));
+            const detected = detectPlatforms();
+            const installedIds = detected.filter((d) => d.installed).map((d) => d.platform.id);
+            const platformsResult = yield p.multiselect({
+                message: 'Which AI coding platforms do you use? (space to toggle, enter to confirm)',
+                options: detected.map((d) => ({
+                    label: `${d.platform.emoji}  ${d.platform.name}`,
+                    value: d.platform.id,
+                    hint: d.installed ? 'detected' : undefined,
+                })),
+                initialValues: installedIds.length > 0 ? installedIds : undefined,
+                required: true,
+            });
+            if (p.isCancel(platformsResult)) {
+                profile.onboardingStep = 1;
+                (0, hooks_1.saveProfile)(profile);
+                console.log((0, theme_1.dim)('\n  No worries! Run cm again to continue. 👋\n'));
+                process.exit(0);
+            }
+            const chosenPlatforms = platformsResult;
+            const profileResult = yield p.select({
+                message: 'Pick a skill profile (you can change later):',
                 options: [
-                    { label: '✦  Google Antigravity (Gemini)', value: 'gemini', hint: 'recommended' },
-                    { label: '🟣 Claude Code', value: 'claude', hint: 'plugin system' },
-                    { label: '⬡  Cursor', value: 'cursor', hint: 'rules directory' },
-                    { label: '🌊 Windsurf', value: 'windsurf', hint: 'rules directory' },
-                    { label: '🔶 Cline / RooCode', value: 'cline', hint: 'skills directory' },
-                    { label: '📦 OpenCode', value: 'opencode', hint: 'skills directory' },
-                    { label: '🪁 Kiro', value: 'kiro', hint: 'steering docs' },
-                    { label: '🤖 GitHub Copilot', value: 'copilot', hint: 'auto-context' },
-                    { label: '🔧 Other / Not sure', value: 'other', hint: 'auto-detect' },
+                    { label: 'Core', value: 'core', hint: 'planning + tdd + debugging + deploy (recommended)' },
+                    { label: 'Growth', value: 'growth', hint: 'content + ads + CRO + booking' },
+                    { label: 'Design', value: 'design', hint: 'UI preview + UX laws + design system' },
+                    { label: 'Knowledge', value: 'knowledge', hint: 'docs + memory + continuity' },
+                    { label: 'Full', value: 'full', hint: 'everything (~56 skills)' },
                 ],
+                initialValue: 'core',
             });
-            if (p.isCancel(platformResult)) {
+            if (p.isCancel(profileResult)) {
                 profile.onboardingStep = 1;
                 (0, hooks_1.saveProfile)(profile);
-                console.log((0, theme_1.dim)('\n  No worries! Run cm again to continue. 👋\n'));
                 process.exit(0);
             }
-            profile.platform = platformResult;
+            const skillProfile = profileResult;
+            const spinner = p.spinner();
+            spinner.start(`Installing skills to ${chosenPlatforms.length} platform(s)...`);
+            let results = [];
+            try {
+                results = yield installToMany(chosenPlatforms, {
+                    scope: 'user',
+                    profile: skillProfile,
+                });
+                spinner.stop(`Installed to ${chosenPlatforms.length} platform(s).`);
+            }
+            catch (err) {
+                spinner.stop(`Install failed: ${err.message}`);
+            }
+            for (const r of results) {
+                console.log(`    ${(0, theme_1.success)('✓')} ${(0, theme_1.brand)(r.platform)} ${(0, theme_1.dim)('→ ' + r.targetPath)} ${(0, theme_1.dim)(`(${r.installed.length} skills)`)}`);
+            }
+            console.log('');
+            profile.platform = chosenPlatforms[0] || '';
+            profile.platforms = chosenPlatforms;
+            profile.skillProfile = skillProfile;
             profile.onboardingStep = 2;
             (0, hooks_1.saveProfile)(profile);
         }

package/dist/utils/cli-utils.js

@@ -25,8 +25,13 @@ function padRight(str, len) {
  */
 function openUrl(url) {
     const plat = os_1.default.platform();
-    const command = plat === 'darwin' ? 'open' : plat === 'win32' ? 'start' : 'xdg-open';
-    (0, child_process_1.exec)(`${command} "${url}"`);
+    if (plat === 'win32') {
+        (0, child_process_1.execFile)('cmd.exe', ['/c', 'start', '""', url]);
+    }
+    else {
+        const command = plat === 'darwin' ? 'open' : 'xdg-open';
+        (0, child_process_1.execFile)(command, [url]);
+    }
 }
 /**
  * Formats a date string relative to now (e.g. "2m ago", "1h ago").

package/dist/utils/design-taste.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Design taste memory — per-project log of approved/rejected design choices
+ * (color, font, layout). Each entry decays 5 % per week so old taste does
+ * not lock in stale aesthetics; entries with weight < 0.1 are dropped on read.
+ *
+ * Storage: `.cm/design-taste.json` (JSON, not JSONL — small file, full rewrite).
+ *
+ * Consumed by cm-design-system and cm-ui-preview to bias token / prompt
+ * generation toward what the user has already approved.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tastePath = tastePath;
+exports.recordTaste = recordTaste;
+exports.decayEntries = decayEntries;
+exports.loadTaste = loadTaste;
+exports.topTaste = topTaste;
+exports.compactTaste = compactTaste;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const FILENAME = path_1.default.join('.cm', 'design-taste.json');
+const DECAY_PER_WEEK = 0.05;
+const MIN_WEIGHT = 0.1;
+const MS_PER_WEEK = 7 * 24 * 60 * 60 * 1000;
+function tastePath(projectPath) {
+    return path_1.default.join(projectPath, FILENAME);
+}
+function readRaw(p) {
+    if (!fs_1.default.existsSync(p))
+        return { version: 1, entries: [] };
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+        if (!raw || raw.version !== 1 || !Array.isArray(raw.entries)) {
+            return { version: 1, entries: [] };
+        }
+        return raw;
+    }
+    catch (_a) {
+        return { version: 1, entries: [] };
+    }
+}
+function writeRaw(p, file) {
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(file, null, 2) + '\n');
+}
+function recordTaste(projectPath, input, now = new Date()) {
+    const p = tastePath(projectPath);
+    const file = readRaw(p);
+    // Idempotent on (dimension, value, verdict): refresh ts/weight instead of duplicating.
+    const existing = file.entries.find(e => e.dimension === input.dimension && e.value === input.value && e.verdict === input.verdict);
+    const entry = {
+        dimension: input.dimension,
+        value: input.value,
+        verdict: input.verdict,
+        weight: 1.0,
+        ts: now.toISOString(),
+    };
+    if (existing) {
+        existing.weight = 1.0;
+        existing.ts = entry.ts;
+    }
+    else {
+        file.entries.push(entry);
+    }
+    writeRaw(p, file);
+    return existing !== null && existing !== void 0 ? existing : entry;
+}
+/**
+ * Apply exponential decay (5 %/week) and drop entries below MIN_WEIGHT.
+ * Pure: does not write back.
+ */
+function decayEntries(entries, now = new Date()) {
+    const nowMs = now.getTime();
+    const out = [];
+    for (const e of entries) {
+        const ageWeeks = Math.max(0, (nowMs - new Date(e.ts).getTime()) / MS_PER_WEEK);
+        const decayed = e.weight * Math.pow(1 - DECAY_PER_WEEK, ageWeeks);
+        if (decayed >= MIN_WEIGHT) {
+            out.push(Object.assign(Object.assign({}, e), { weight: Number(decayed.toFixed(4)) }));
+        }
+    }
+    return out;
+}
+function loadTaste(projectPath, now = new Date()) {
+    return decayEntries(readRaw(tastePath(projectPath)).entries, now);
+}
+function topTaste(projectPath, dimension, n = 5, now = new Date()) {
+    const live = loadTaste(projectPath, now).filter(e => e.dimension === dimension);
+    const sortDesc = (a, b) => b.weight - a.weight;
+    return {
+        approved: live.filter(e => e.verdict === 'approved').sort(sortDesc).slice(0, n),
+        rejected: live.filter(e => e.verdict === 'rejected').sort(sortDesc).slice(0, n),
+    };
+}
+/**
+ * Rewrite the file with decayed entries, dropping stale ones.
+ * Cm-continuity or a periodic task can call this; not required for reads.
+ */
+function compactTaste(projectPath, now = new Date()) {
+    const p = tastePath(projectPath);
+    const before = readRaw(p).entries;
+    const after = decayEntries(before, now);
+    writeRaw(p, { version: 1, entries: after });
+    return before.length - after.length;
+}

package/dist/utils/output-compress.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Output compression middleware — pure helpers that strip noise from common
+ * CLI outputs before they enter the model context. Keep them deterministic
+ * and side-effect free so cm-terminal can reference them by name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPRESSORS = void 0;
+exports.compressGitStatus = compressGitStatus;
+exports.compressNpmTest = compressNpmTest;
+exports.collapseRepeatedLines = collapseRepeatedLines;
+exports.summarizeBuildLog = summarizeBuildLog;
+exports.compressFor = compressFor;
+const STATUS_LINE = /^(?:\s*)([MADRCU?!]{1,2}|\?\?)\s+(.+)$/;
+function compressGitStatus(stdout) {
+    const lines = stdout.split('\n');
+    const kept = [];
+    let branch = null;
+    for (const raw of lines) {
+        const line = raw.replace(/\r$/, '');
+        if (line.startsWith('On branch ')) {
+            branch = line;
+            continue;
+        }
+        if (STATUS_LINE.test(line)) {
+            kept.push(line.trim());
+        }
+    }
+    if (kept.length === 0) {
+        return branch ? `${branch}\n(clean)` : '(clean)';
+    }
+    const head = branch ? `${branch}\n` : '';
+    return `${head}${kept.join('\n')}\n(${kept.length} changed)`;
+}
+const TEST_FAIL_PATTERNS = [
+    /^\s*FAIL\s/,
+    /^\s*✗\s/,
+    /^\s*×\s/,
+    /^\s*✘\s/,
+    /\bAssertionError\b/,
+    /^\s*Error:/,
+    /^\s*Expected /,
+    /^\s*at .+\(.+:\d+:\d+\)/,
+];
+const TEST_SUMMARY_PATTERNS = [
+    /Tests?:\s+\d+\s+(failed|passed|skipped)/i,
+    /Test Files\s+/i,
+    /\d+\s+passing/,
+    /\d+\s+failing/,
+    /Duration\s+/i,
+    /Snapshots:/i,
+];
+function compressNpmTest(stdout) {
+    const lines = stdout.split('\n');
+    const kept = [];
+    let inFailureBlock = false;
+    for (const raw of lines) {
+        const line = raw.replace(/\r$/, '');
+        const isFailLike = TEST_FAIL_PATTERNS.some(re => re.test(line));
+        const isSummary = TEST_SUMMARY_PATTERNS.some(re => re.test(line));
+        if (isFailLike) {
+            kept.push(line);
+            inFailureBlock = true;
+            continue;
+        }
+        if (inFailureBlock && line.trim() === '') {
+            kept.push(line);
+            inFailureBlock = false;
+            continue;
+        }
+        if (inFailureBlock) {
+            kept.push(line);
+            continue;
+        }
+        if (isSummary) {
+            kept.push(line);
+        }
+    }
+    if (kept.length === 0)
+        return '(no failures detected)';
+    return kept.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+function collapseRepeatedLines(stdout, threshold = 3) {
+    if (threshold < 2)
+        threshold = 2;
+    const lines = stdout.split('\n');
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        let j = i + 1;
+        while (j < lines.length && lines[j] === lines[i])
+            j++;
+        const run = j - i;
+        if (run >= threshold) {
+            out.push(`${lines[i]}  … (× ${run})`);
+        }
+        else {
+            for (let k = i; k < j; k++)
+                out.push(lines[k]);
+        }
+        i = j;
+    }
+    return out.join('\n');
+}
+const BUILD_KEEP = [
+    /\berror\b/i,
+    /\bwarning\b/i,
+    /\bfailed\b/i,
+    /\bsucceeded\b/i,
+    /\bbuilt\b/i,
+    /\bcompiled\b/i,
+    /\bDone in\b/i,
+    /^\s*✓\s/,
+    /^\s*✗\s/,
+];
+function summarizeBuildLog(stdout) {
+    const lines = stdout.split('\n');
+    const kept = lines.filter(l => BUILD_KEEP.some(re => re.test(l)));
+    if (kept.length === 0) {
+        const tail = lines.slice(-5).filter(Boolean);
+        return tail.join('\n') || '(empty build output)';
+    }
+    return collapseRepeatedLines(kept.join('\n'), 3);
+}
+exports.COMPRESSORS = {
+    'git status': compressGitStatus,
+    'git status --porcelain': compressGitStatus,
+    'npm test': compressNpmTest,
+    'npm run test': compressNpmTest,
+    'vitest': compressNpmTest,
+    'jest': compressNpmTest,
+    'npm run build': summarizeBuildLog,
+    'npm build': summarizeBuildLog,
+    'tsc': summarizeBuildLog,
+};
+function compressFor(command, stdout) {
+    const cmd = command.trim().toLowerCase();
+    for (const key of Object.keys(exports.COMPRESSORS)) {
+        if (cmd.startsWith(key))
+            return exports.COMPRESSORS[key](stdout);
+    }
+    return collapseRepeatedLines(stdout, 3);
+}

package/dist/vibecoding-index.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Vibecoding Index — score code-change quality 0–100.
+ *
+ * Formula:
+ *   intent     × 0.30   (clear goal, scope, design notes)
+ *   ownership  × 0.25   (author attribution, AI disclosure)
+ *   context    × 0.20   (links to plan/handoff, why-not-what)
+ *   tests      × 0.15   (added/passing test coverage)
+ *   review     × 0.10   (review evidence)
+ *
+ * Each input is normalized 0..1 before weighting.
+ *
+ * Modes (governance enforcement):
+ *   OFF      → no print, no block
+ *   WARNING  → print score + advice, never blocks (default)
+ *   SOFT     → print score; warn loudly if score < 60
+ *   FULL     → fail (exit 1) if score < 70
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIBE_WEIGHTS = void 0;
+exports.computeVibeIndex = computeVibeIndex;
+exports.applyVibeMode = applyVibeMode;
+exports.formatVibeReport = formatVibeReport;
+exports.VIBE_WEIGHTS = {
+    intent: 0.30,
+    ownership: 0.25,
+    context: 0.20,
+    tests: 0.15,
+    review: 0.10,
+};
+const MODE_THRESHOLDS = {
+    OFF: { warn: 0, block: null },
+    WARNING: { warn: 60, block: null },
+    SOFT: { warn: 60, block: null },
+    FULL: { warn: 60, block: 70 },
+};
+function clamp01(n) {
+    if (Number.isNaN(n) || !Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(1, n));
+}
+function computeVibeIndex(raw) {
+    var _a, _b, _c, _d, _e;
+    const components = {
+        intent: clamp01((_a = raw.intent) !== null && _a !== void 0 ? _a : 0),
+        ownership: clamp01((_b = raw.ownership) !== null && _b !== void 0 ? _b : 0),
+        context: clamp01((_c = raw.context) !== null && _c !== void 0 ? _c : 0),
+        tests: clamp01((_d = raw.tests) !== null && _d !== void 0 ? _d : 0),
+        review: clamp01((_e = raw.review) !== null && _e !== void 0 ? _e : 0),
+    };
+    const weighted = {
+        intent: components.intent * exports.VIBE_WEIGHTS.intent * 100,
+        ownership: components.ownership * exports.VIBE_WEIGHTS.ownership * 100,
+        context: components.context * exports.VIBE_WEIGHTS.context * 100,
+        tests: components.tests * exports.VIBE_WEIGHTS.tests * 100,
+        review: components.review * exports.VIBE_WEIGHTS.review * 100,
+    };
+    const score = Math.round(weighted.intent + weighted.ownership + weighted.context + weighted.tests + weighted.review);
+    const advice = [];
+    if (components.intent < 0.7)
+        advice.push('Clarify intent — link plan/spec, state in/out of scope.');
+    if (components.ownership < 0.7)
+        advice.push('Add ownership — attribute author, disclose AI usage.');
+    if (components.context < 0.7)
+        advice.push('Add context — link handoff/issue, write WHY (not WHAT).');
+    if (components.tests < 0.7)
+        advice.push('Increase test coverage on changed lines.');
+    if (components.review < 0.5)
+        advice.push('Get a review or second-opinion before merge.');
+    let band = 'POOR';
+    if (score >= 85)
+        band = 'GREAT';
+    else if (score >= 70)
+        band = 'GOOD';
+    else if (score >= 50)
+        band = 'FAIR';
+    return { score, components, weighted, band, advice };
+}
+function applyVibeMode(result, mode) {
+    if (mode === 'OFF') {
+        return { result, mode, status: 'pass', message: '' };
+    }
+    const t = MODE_THRESHOLDS[mode];
+    if (t.block !== null && result.score < t.block) {
+        return {
+            result,
+            mode,
+            status: 'block',
+            message: `Vibecoding Index ${result.score} < ${t.block} — blocked by ${mode} mode`,
+        };
+    }
+    if (result.score < t.warn) {
+        return {
+            result,
+            mode,
+            status: 'warn',
+            message: `Vibecoding Index ${result.score} (${result.band}) — below ${t.warn}, see advice`,
+        };
+    }
+    return {
+        result,
+        mode,
+        status: 'pass',
+        message: `Vibecoding Index ${result.score} (${result.band})`,
+    };
+}
+function formatVibeReport(result) {
+    const lines = [
+        `Vibecoding Index: ${result.score}/100 (${result.band})`,
+        `  intent     ${pct(result.components.intent)}  →  ${result.weighted.intent.toFixed(1)} pts`,
+        `  ownership  ${pct(result.components.ownership)}  →  ${result.weighted.ownership.toFixed(1)} pts`,
+        `  context    ${pct(result.components.context)}  →  ${result.weighted.context.toFixed(1)} pts`,
+        `  tests      ${pct(result.components.tests)}  →  ${result.weighted.tests.toFixed(1)} pts`,
+        `  review     ${pct(result.components.review)}  →  ${result.weighted.review.toFixed(1)} pts`,
+    ];
+    if (result.advice.length) {
+        lines.push('Advice:');
+        for (const a of result.advice)
+            lines.push(`  • ${a}`);
+    }
+    return lines.join('\n');
+}
+function pct(n) {
+    return `${(n * 100).toFixed(0).padStart(3, ' ')}%`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codymaster",
-  "version": "4.8.0",
-  "description": "68+ Skills. Ship 10x faster. AI-powered coding skill kit for Claude, Cursor, Gemini & more.",
+  "version": "7.0.0",
+  "description": "CodyMaster v7.0 — 50+ AI agent skills with Browse Hybrid Bridge (agent-browser + Playwright), a11y snapshots, structured error collection, video recording. Hybrid browser automation for visual QA and testing.",
   "main": "dist/index.js",
   "repository": {
     "type": "git",
@@ -33,6 +33,16 @@
     "validate:skills": "node scripts/validate-skills.mjs",
     "build:skills": "node scripts/build-skills.mjs",
     "check:skills": "node scripts/build-skills.mjs --check",
+    "build:platforms": "node scripts/build-skills.mjs --platforms cursor,codex,opencode",
+    "check:platforms": "node scripts/build-skills.mjs --platforms cursor,codex,opencode --check",
+    "sync:all": "node scripts/build-skills.mjs --all-platforms",
+    "sync:all:check": "node scripts/build-skills.mjs --all-platforms --check",
+    "changelog": "bash scripts/update-changelog.sh",
+    "changelog:dry": "bash scripts/update-changelog.sh --dry-run",
+    "update": "cm update --full",
+    "update:sync": "cm update --sync",
+    "update:changelog": "cm update --changelog",
+    "upgrade": "cm upgrade",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs"
@@ -56,31 +66,35 @@
     "dist/",
     "scripts/",
     "skills/",
-    "adapters/",
     "commands/",
     "public/",
     "README.md",
-    "CHANGELOG.md",
-    "install.sh"
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
+    "async-mutex": "^0.5.0",
     "better-sqlite3": "^12.8.0",
     "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3",
     "express": "^5.2.1",
     "prompts": "^2.4.2",
-    "yaml": "^2.8.3"
+    "ws": "^8.20.0",
+    "yaml": "^2.8.3",
+    "ajv": "^8.20.0",
+    "pino": "^10.0.0",
+    "pino-http": "^11.0.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "@types/prompts": "^2.4.9",
+    "@types/ws": "^8.18.1",
     "acorn": "^8.16.0",
     "jsdom": "^29.0.1",
     "playwright": "^1.50.0",