tribunal-kit 4.2.0 → 4.3.1

package/.agent/scripts/lint_runner.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * lint_runner.js — Standalone lint runner for the Tribunal Agent Kit.
+ *
+ * Usage:
+ *   node .agent/scripts/lint_runner.js .
+ *   node .agent/scripts/lint_runner.js . --fix
+ *   node .agent/scripts/lint_runner.js . --files src/index.ts src/utils.ts
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { RED, GREEN, YELLOW, BLUE, BOLD, RESET } = require('./colors.js');
+
+function header(title) {
+    console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`);
+}
+
+function ok(msg) {
+    console.log(`  ${GREEN}✅ ${msg}${RESET}`);
+}
+
+function fail(msg) {
+    console.log(`  ${RED}❌ ${msg}${RESET}`);
+}
+
+function skip(msg) {
+    console.log(`  ${YELLOW}⏭️  ${msg}${RESET}`);
+}
+
+function runLinter(label, cmd, cwd) {
+    try {
+        const executable = process.platform === 'win32' && cmd[0] === 'npx' ? 'npx.cmd' : cmd[0];
+        const result = spawnSync(executable, cmd.slice(1), {
+            cwd,
+            encoding: 'utf8',
+            timeout: 120000,
+            shell: process.platform === 'win32'
+        });
+
+        if (result.status === 0) {
+            ok(`${label} — clean`);
+            return true;
+        }
+
+        fail(`${label} — issues found`);
+        if (result.error) {
+            console.log(`    Error: ${result.error.message}`);
+        }
+        const out = result.stdout ? result.stdout.toString() : '';
+        const err = result.stderr ? result.stderr.toString() : '';
+        const output = (out + "\n" + err).trim();
+        if (output) {
+            const lines = output.split('\n');
+            for (const line of lines.slice(0, 15)) {
+                console.log(`    ${line}`);
+            }
+            if (lines.length > 15) {
+                console.log(`    ... and ${lines.length - 15} more lines`);
+            }
+        }
+        return false;
+    } catch {
+        skip(`${label} — tool not installed`);
+        return true;
+    }
+}
+
+function detectLinters(projectRoot) {
+    const available = {};
+    const pkgJson = path.join(projectRoot, "package.json");
+    
+    if (fs.existsSync(pkgJson)) {
+        const eslintFiles = [".eslintrc", ".eslintrc.js", ".eslintrc.json", ".eslintrc.yml", "eslint.config.js", "eslint.config.mjs"];
+        available.eslint = eslintFiles.some(f => fs.existsSync(path.join(projectRoot, f))); 
+        
+        const prettierFiles = [".prettierrc", ".prettierrc.js", ".prettierrc.json", "prettier.config.js"];
+        available.prettier = prettierFiles.some(f => fs.existsSync(path.join(projectRoot, f)));
+    }
+
+    available.ruff = fs.existsSync(path.join(projectRoot, "pyproject.toml")) || fs.existsSync(path.join(projectRoot, "ruff.toml"));
+    available.flake8 = fs.existsSync(path.join(projectRoot, ".flake8")) || fs.existsSync(path.join(projectRoot, "setup.cfg"));
+
+    return available;
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    let targetPath = null;
+    let fixFlag = false;
+    let fileArgs = [];
+
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === '--fix') fixFlag = true;
+        else if (args[i] === '--files') {
+            i++;
+            while (i < args.length && !args[i].startsWith('--')) {
+                fileArgs.push(args[i++]);
+            }
+            continue;
+        } else if (!targetPath && !args[i].startsWith('-')) {
+            targetPath = args[i];
+        }
+        i++;
+    }
+
+    if (!targetPath) {
+        console.log("Usage: node lint_runner.js <path> [--fix] [--files <file1> <file2> ...]");
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(targetPath);
+    if (!fs.existsSync(projectRoot) || !fs.statSync(projectRoot).isDirectory()) {
+        fail(`Directory not found: ${projectRoot}`);
+        process.exit(1);
+    }
+
+    console.log(`${BOLD}Tribunal — lint_runner.js${RESET}`);
+    console.log(`Project: ${projectRoot}`);
+
+    const available = detectLinters(projectRoot);
+    if (!Object.values(available).some(Boolean)) {
+        skip("No linter configuration detected in this project");
+        process.exit(0);
+    }
+
+    let failures = 0;
+
+    if (available.eslint) {
+        header("ESLint");
+        const cmd = ["npx", "eslint"];
+        if (fixFlag) cmd.push("--fix");
+        if (fileArgs.length) cmd.push(...fileArgs);
+        else cmd.push(".", "--max-warnings=0");
+        if (!runLinter("ESLint", cmd, projectRoot)) failures++;
+    }
+
+    if (available.prettier) {
+        header("Prettier");
+        const cmd = ["npx", "prettier"];
+        if (fixFlag) cmd.push("--write");
+        else cmd.push("--check");
+        if (fileArgs.length) cmd.push(...fileArgs);
+        else cmd.push(".");
+        if (!runLinter("Prettier", cmd, projectRoot)) failures++;
+    }
+
+    if (available.ruff) {
+        header("Ruff (Python)");
+        const cmd = ["ruff", "check"];
+        if (fixFlag) cmd.push("--fix");
+        if (fileArgs.length) cmd.push(...fileArgs);
+        else cmd.push(".");
+        if (!runLinter("Ruff", cmd, projectRoot)) failures++;
+    }
+
+    if (available.flake8 && !available.ruff) {
+        header("Flake8 (Python)");
+        const cmd = ["flake8"];
+        if (fileArgs.length) cmd.push(...fileArgs);
+        else cmd.push(".");
+        if (!runLinter("Flake8", cmd, projectRoot)) failures++;
+    }
+
+    if (fs.existsSync(path.join(projectRoot, "tsconfig.json"))) {
+        header("TypeScript");
+        if (!runLinter("TypeScript", ["npx", "tsc", "--noEmit"], projectRoot)) failures++;
+    }
+
+    console.log(`\n${BOLD}━━━ Lint Summary ━━━${RESET}`);
+    if (failures === 0) {
+        ok("All linters passed");
+    } else {
+        fail(`${failures} linter(s) reported issues`);
+    }
+
+    process.exit(failures > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/minify_context.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * minify_context.js
+ * Minifies markdown documentation in the .agent directory to save tokens.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function minifyMarkdown(filePath) {
+    let content = fs.readFileSync(filePath, 'utf8');
+    const originalLen = content.length;
+
+    // 1. Strip repetitive Output Format templates
+    content = content.replace(/## Output Format\n\n```[\s\S]*?```\n/g, '');
+
+    // 2. Convert bloated Cross-Workflow Navigation tables to dense YAML lists
+    content = content.replace(/## Cross-Workflow Navigation\n\n\|.*?\|[\s\S]*?(?=\n## |\Z)/g, match => {
+        const lines = match.trim().split('\n');
+        const out = [];
+        for (const line of lines) {
+            if (line.startsWith('|') && !line.startsWith('|:') && !line.startsWith('| After')) {
+                const parts = line.split('|').map(p => p.trim()).filter(Boolean);
+                if (parts.length >= 2) {
+                    out.push(`- ${parts[0]} -> ${parts[1]}`);
+                }
+            }
+        }
+        return '## Cross-Workflow Navigation\n' + out.join('\n') + '\n';
+    });
+
+    // 3. Collapse multiple empty lines into a single one
+    content = content.replace(/\n{3,}/g, '\n\n');
+
+    // 4. Remove padding from remaining tables to save space tokens
+    content = content.replace(/^\|.+|$/gm, match => {
+        let line = match;
+        // remove spaces around |
+        line = line.replace(/\s+\|\s+/g, '|');
+        line = line.replace(/\|\s+/g, '|');
+        line = line.replace(/\s+\|/g, '|');
+        return line;
+    });
+
+    // 5. Remove conversational blockquotes > if they don't contain WARNING/NOTE/IMPORTANT
+    content = content.replace(/^>.*$/gm, match => {
+        if (match.includes('⚠️') || match.includes('WARNING') || match.includes('CRITICAL') || match.includes('!')) {
+            return match;
+        }
+        return match.replace(/> /g, '').replace(/>/g, '');
+    });
+
+    // 6. Dense Examples (convert ❌ Bad: and ✅ Good: blocks to single lines)
+    content = content.replace(/\n❌ Bad:/g, ' ❌');
+    content = content.replace(/\n✅ Good:/g, ' ✅');
+
+    fs.writeFileSync(filePath, content, 'utf8');
+    return [originalLen, content.length];
+}
+
+function walkDir(dir, callback) {
+    if (!fs.existsSync(dir)) return;
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+        const fullPath = path.join(dir, item.name);
+        if (item.isDirectory()) {
+            walkDir(fullPath, callback);
+        } else {
+            callback(fullPath);
+        }
+    }
+}
+
+function main() {
+    const agentDir = path.join('.agent');
+    let totalOriginal = 0;
+    let totalNew = 0;
+
+    walkDir(agentDir, file => {
+        if (file.endsWith('.md')) {
+            const [orig, newLen] = minifyMarkdown(file);
+            totalOriginal += orig;
+            totalNew += newLen;
+        }
+    });
+
+    const saved = totalOriginal - totalNew;
+    const percent = totalOriginal > 0 ? (saved / totalOriginal * 100) : 0;
+    
+    console.log("Minification Complete.");
+    console.log(`Original size: ${totalOriginal} bytes`);
+    console.log(`New size: ${totalNew} bytes`);
+    console.log(`Saved: ${saved} bytes (${percent.toFixed(1)}%)`);
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/patch_skills_meta.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * patch_skills_meta.js — Injects version/freshness metadata into SKILL.md frontmatter.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { RED, GREEN, YELLOW, BLUE, BOLD, RESET } = require('./colors.js');
+
+const META_FIELDS = {
+    "version": "1.0.0",
+    "last-updated": "2026-03-12",
+    "applies-to-model": "gemini-2.5-pro, claude-3-7-sonnet"
+};
+
+function header(title) { console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`); }
+function ok(msg) { console.log(`  ${GREEN}✅ ${msg}${RESET}`); }
+function skip(msg) { console.log(`  ${YELLOW}⏭️  ${msg}${RESET}`); }
+function warn(msg) { console.log(`  ${YELLOW}⚠️  ${msg}${RESET}`); }
+function fail(msg) { console.log(`  ${RED}❌ ${msg}${RESET}`); }
+
+function patchFrontmatter(content) {
+    const added = [];
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+
+    if (!fmMatch) {
+        const newFmLines = ["---"];
+        for (const [key, value] of Object.entries(META_FIELDS)) {
+            newFmLines.push(`${key}: ${value}`);
+            added.push(key);
+        }
+        newFmLines.push("---");
+        return [newFmLines.join("\n") + "\n\n" + content, added];
+    }
+
+    const fmText = fmMatch[1];
+    const fmEnd = fmMatch[0].length;
+    
+    const existingKeys = new Set();
+    const lines = fmText.split("\n");
+    for (const line of lines) {
+        const m = line.match(/^([a-zA-Z0-9_-]+)\s*:/);
+        if (m) existingKeys.add(m[1]);
+    }
+
+    const newFmLines = fmText.trimEnd().split("\n");
+    for (const [key, value] of Object.entries(META_FIELDS)) {
+        if (!existingKeys.has(key)) {
+            newFmLines.push(`${key}: ${value}`);
+            added.push(key);
+        }
+    }
+
+    if (added.length === 0) return [content, []];
+
+    const patched = "---\n" + newFmLines.join("\n") + "\n---" + content.slice(fmEnd);
+    return [patched, added];
+}
+
+function processSkill(skillPath, dryRun) {
+    const skillName = path.basename(path.dirname(skillPath));
+    try {
+        const content = fs.readFileSync(skillPath, 'utf8');
+        const [patched, added] = patchFrontmatter(content);
+
+        if (added.length === 0) {
+            skip(`${skillName} — all meta fields present`);
+            return "skipped";
+        }
+
+        const fieldList = added.join(', ');
+        if (dryRun) {
+            warn(`[DRY RUN] ${skillName} — would add: ${fieldList}`);
+            return "updated";
+        }
+
+        fs.writeFileSync(skillPath, patched, 'utf8');
+        ok(`${skillName} — added: ${fieldList}`);
+        return "updated";
+    } catch (e) {
+        fail(`${skillName} — ${e.message}`);
+        return "error";
+    }
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    let targetPath = null;
+    let dryRun = false;
+    let skillArg = null;
+
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === '--dry-run') dryRun = true;
+        else if (args[i] === '--skill' && i + 1 < args.length) skillArg = args[++i];
+        else if (args[i] === '-h' || args[i] === '--help') {
+            console.log("Usage: node patch_skills_meta.js <path> [--dry-run] [--skill <name>]");
+            process.exit(0);
+        } else if (!args[i].startsWith('-') && !targetPath) {
+            targetPath = args[i];
+        }
+        i++;
+    }
+
+    if (!targetPath) {
+        console.log("Usage: node patch_skills_meta.js <path> [--dry-run] [--skill <name>]");
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(targetPath);
+    const skillsDir = path.join(projectRoot, ".agent", "skills");
+
+    if (!fs.existsSync(skillsDir) || !fs.statSync(skillsDir).isDirectory()) {
+        fail(`Skills directory not found: ${skillsDir}`);
+        process.exit(1);
+    }
+
+    console.log(`${BOLD}Tribunal — patch_skills_meta.js${RESET}`);
+    if (dryRun) console.log(`  ${YELLOW}DRY RUN — no files will be written${RESET}`);
+    console.log(`Skills dir: ${skillsDir}\n`);
+
+    const counts = { updated: 0, skipped: 0, error: 0 };
+    header("Patching Frontmatter");
+
+    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
+    dirs.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        if (skillArg && dir.name !== skillArg) continue;
+
+        const skillMd = path.join(skillsDir, dir.name, "SKILL.md");
+        if (!fs.existsSync(skillMd)) {
+            warn(`${dir.name} — no SKILL.md found`);
+            continue;
+        }
+
+        const result = processSkill(skillMd, dryRun);
+        counts[result]++;
+    }
+
+    console.log(`\n${BOLD}━━━ Summary ━━━${RESET}`);
+    console.log(`  ${GREEN}✅ Updated:  ${counts.updated}${RESET}`);
+    console.log(`  ${YELLOW}⏭️  Skipped:  ${counts.skipped}${RESET}`);
+    if (counts.error > 0) console.log(`  ${RED}❌ Errors:   ${counts.error}${RESET}`);
+    if (dryRun) console.log(`  ${YELLOW}(dry-run — nothing written)${RESET}`);
+
+    process.exit(counts.error > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+    main();
+}

package/.agent/scripts/patch_skills_output.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * patch_skills_output.js — Adds structured Output Format sections to SKILL.md files.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { RED, GREEN, YELLOW, BLUE, BOLD, RESET } = require('./colors.js');
+
+const CODE_QUALITY_TEMPLATE = `\\
+## Output Format
+
+When this skill produces or reviews code, structure your output as follows:
+
+\`\`\`
+━━━ {skill_name} Report ━━━━━━━━━━━━━━━━━━━━━━━━
+Skill:       {skill_name}
+Language:    [detected language / framework]
+Scope:       [N files · N functions]
+─────────────────────────────────────────────────
+✅ Passed:   [checks that passed, or "All clean"]
+⚠️  Warnings: [non-blocking issues, or "None"]
+❌ Blocked:  [blocking issues requiring fix, or "None"]
+─────────────────────────────────────────────────
+VBC status:  PENDING → VERIFIED
+Evidence:    [test output / lint pass / compile success]
+\`\`\`
+
+**VBC (Verification-Before-Completion) is mandatory.**
+Do not mark status as VERIFIED until concrete terminal evidence is provided.
+
+`;
+
+const DECISION_CARD_TEMPLATE = `\\
+## Output Format
+
+When this skill produces a recommendation or design decision, structure your output as:
+
+\`\`\`
+━━━ {skill_name} Recommendation ━━━━━━━━━━━━━━━━
+Decision:    [what was chosen / proposed]
+Rationale:   [why — one concise line]
+Trade-offs:  [what is consciously accepted]
+Next action: [concrete next step for the user]
+─────────────────────────────────────────────────
+Pre-Flight:  ✅ All checks passed
+             or ❌ [blocking item that must be resolved first]
+\`\`\`
+
+`;
+
+const GENERIC_TEMPLATE = `\\
+## Output Format
+
+When this skill completes a task, structure your output as:
+
+\`\`\`
+━━━ {skill_name} Output ━━━━━━━━━━━━━━━━━━━━━━━━
+Task:        [what was performed]
+Result:      [outcome summary — one line]
+─────────────────────────────────────────────────
+Checks:      ✅ [N passed] · ⚠️  [N warnings] · ❌ [N blocked]
+VBC status:  PENDING → VERIFIED
+Evidence:    [link to terminal output, test result, or file diff]
+\`\`\`
+
+`;
+
+const CODE_GEN_SKILLS = new Set([
+    "python-pro", "clean-code", "dotnet-core-expert", "rust-pro",
+    "nextjs-react-expert", "vue-expert", "react-specialist",
+    "csharp-developer", "nodejs-best-practices", "python-patterns",
+    "tailwind-patterns", "bash-linux", "powershell-windows",
+    "llm-engineering", "mcp-builder", "game-development",
+    "edge-computing", "local-first", "realtime-patterns",
+    "tdd-workflow", "testing-patterns", "lint-and-validate",
+]);
+
+const DECISION_SKILLS = new Set([
+    "api-patterns", "database-design", "architecture", "observability",
+    "devops-engineer", "platform-engineer", "deployment-procedures",
+    "server-management", "security-auditor", "vulnerability-scanner",
+    "red-team-tactics", "performance-profiling", "i18n-localization",
+    "geo-fundamentals", "seo-fundamentals", "sql-pro",
+    "brainstorming", "plan-writing", "behavioral-modes",
+    "app-builder", "intelligent-routing", "mobile-design",
+    "frontend-design", "ui-ux-pro-max", "ui-ux-researcher",
+    "web-design-guidelines", "trend-researcher",
+]);
+
+const ALREADY_HAVE_OUTPUT = new Set([
+    "whimsy-injector", "workflow-optimizer",
+]);
+
+const EXISTING_OUTPUT_MARKERS = [
+    "## Output Format",
+    "## Output\n",
+    "## Report Format",
+    "## Output Card",
+    "Whimsy Injection Report",
+    "Workflow Optimization Report",
+];
+
+function getTemplate(skillName) {
+    if (CODE_GEN_SKILLS.has(skillName)) return CODE_QUALITY_TEMPLATE;
+    if (DECISION_SKILLS.has(skillName)) return DECISION_CARD_TEMPLATE;
+    return GENERIC_TEMPLATE;
+}
+
+function hasOutputSection(content) {
+    return EXISTING_OUTPUT_MARKERS.some(m => content.includes(m));
+}
+
+function getSkillNameFromFrontmatter(content) {
+    const match = content.match(/^name:\s*(.+)$/m);
+    return match ? match[1].trim() : null;
+}
+
+function buildBlock(template, skillName) {
+    const display = skillName.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+    // Handle the slash escaping issue using regular replace
+    const tplStr = template.replace(/^\\/, '');
+    return tplStr.replace(/{skill_name}/g, display);
+}
+
+function injectOutputBlock(content, block) {
+    const tribunalMarkers = [
+        "## 🏛️ Tribunal Integration",
+        "## Tribunal Integration",
+    ];
+    for (const marker of tribunalMarkers) {
+        const idx = content.indexOf(marker);
+        if (idx !== -1) {
+            return content.substring(0, idx) + block + "\n---\n\n" + content.substring(idx);
+        }
+    }
+    return content.trimEnd() + "\n\n---\n\n" + block;
+}
+
+function header(title) { console.log(`\n${BOLD}${BLUE}━━━ ${title} ━━━${RESET}`); }
+function ok(msg) { console.log(`  ${GREEN}✅ ${msg}${RESET}`); }
+function skip(msg) { console.log(`  ${YELLOW}⏭️  ${msg}${RESET}`); }
+function warn(msg) { console.log(`  ${YELLOW}⚠️  ${msg}${RESET}`); }
+function fail(msg) { console.log(`  ${RED}❌ ${msg}${RESET}`); }
+
+function processSkill(skillDir, dryRun) {
+    const skillName = path.basename(skillDir);
+    const skillMd = path.join(skillDir, "SKILL.md");
+
+    if (!fs.existsSync(skillMd)) return "skipped";
+
+    try {
+        const content = fs.readFileSync(skillMd, 'utf8');
+
+        if (ALREADY_HAVE_OUTPUT.has(skillName) || hasOutputSection(content)) {
+            skip(`${skillName} — output format already present`);
+            return "skipped";
+        }
+
+        const displayName = getSkillNameFromFrontmatter(content) || skillName;
+        const template = getTemplate(skillName);
+        const block = buildBlock(template, displayName);
+        const patched = injectOutputBlock(content, block);
+
+        const templateType = CODE_GEN_SKILLS.has(skillName) ? "Code Quality" : (DECISION_SKILLS.has(skillName) ? "Decision Card" : "Generic");
+
+        if (dryRun) {
+            warn(`[DRY RUN] ${skillName} — would add Output Format (${templateType})`);
+            return "updated";
+        }
+
+        fs.writeFileSync(skillMd, patched, 'utf8');
+        ok(`${skillName} — added Output Format (${templateType})`);
+        return "updated";
+    } catch (e) {
+        fail(`${skillName} — ${e.message}`);
+        return "error";
+    }
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    let targetPath = null;
+    let dryRun = false;
+    let skillArg = null;
+
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === '--dry-run') dryRun = true;
+        else if (args[i] === '--skill' && i + 1 < args.length) skillArg = args[++i];
+        else if (args[i] === '-h' || args[i] === '--help') {
+            console.log("Usage: node patch_skills_output.js <path> [--dry-run] [--skill <name>]");
+            process.exit(0);
+        } else if (!args[i].startsWith('-') && !targetPath) {
+            targetPath = args[i];
+        }
+        i++;
+    }
+
+    if (!targetPath) {
+        console.log("Usage: node patch_skills_output.js <path> [--dry-run] [--skill <name>]");
+        process.exit(1);
+    }
+
+    const projectRoot = path.resolve(targetPath);
+    const skillsDir = path.join(projectRoot, ".agent", "skills");
+
+    if (!fs.existsSync(skillsDir) || !fs.statSync(skillsDir).isDirectory()) {
+        fail(`Skills directory not found: ${skillsDir}`);
+        process.exit(1);
+    }
+
+    console.log(`${BOLD}Tribunal — patch_skills_output.js${RESET}`);
+    if (dryRun) console.log(`  ${YELLOW}DRY RUN — no files will be written${RESET}`);
+    console.log(`Skills dir: ${skillsDir}\n`);
+
+    const counts = { updated: 0, skipped: 0, error: 0 };
+    header("Patching Output Format Sections");
+
+    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
+    dirs.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        if (skillArg && dir.name !== skillArg) continue;
+        const result = processSkill(path.join(skillsDir, dir.name), dryRun);
+        counts[result]++;
+    }
+
+    console.log(`\n${BOLD}━━━ Summary ━━━${RESET}`);
+    console.log(`  ${GREEN}✅ Updated:  ${counts.updated}${RESET}`);
+    console.log(`  ${YELLOW}⏭️  Skipped:  ${counts.skipped}${RESET}`);
+    if (counts.error > 0) console.log(`  ${RED}❌ Errors:   ${counts.error}${RESET}`);
+    if (dryRun) console.log(`  ${YELLOW}(dry-run — nothing written)${RESET}`);
+
+    process.exit(counts.error > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+    main();
+}