kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/guidance.js

@@ -2,425 +2,316 @@
  * V3 CLI Guidance Command
  * Guidance Control Plane - compile, retrieve, enforce, optimize
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../output.js';
 // compile subcommand
-var compileCommand = {
+const compileCommand = {
     name: 'compile',
     description: 'Compile CLAUDE.md into a policy bundle (constitution + shards + manifest)',
     options: [
-        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', "default": './CLAUDE.md' },
+        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', default: './CLAUDE.md' },
         { name: 'local', short: 'l', type: 'string', description: 'Local guidance overlay file path' },
         { name: 'output', short: 'o', type: 'string', description: 'Output directory for compiled bundle' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow guidance compile', description: 'Compile default CLAUDE.md' },
         { command: 'claude-flow guidance compile -r ./CLAUDE.md -l ./CLAUDE.local.md', description: 'Compile with local overlay' },
         { command: 'claude-flow guidance compile --json', description: 'Output compiled bundle as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var rootPath, localPath, jsonOutput, readFile, existsSync, rootContent, localContent, GuidanceCompiler, compiler, bundle, _i, _a, rule, risk, error_1, msg;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    rootPath = ctx.flags.root || './CLAUDE.md';
-                    localPath = ctx.flags.local;
-                    jsonOutput = ctx.flags.json === true;
-                    output.writeln();
-                    output.writeln(output.bold('Guidance Compiler'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 8, , 9]);
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 2:
-                    readFile = (_b.sent()).readFile;
-                    return [4 /*yield*/, import('node:fs')];
-                case 3:
-                    existsSync = (_b.sent()).existsSync;
-                    if (!existsSync(rootPath)) {
-                        output.writeln(output.error("Root guidance file not found: " + rootPath));
-                        return [2 /*return*/, { success: false, message: "File not found: " + rootPath }];
-                    }
-                    return [4 /*yield*/, readFile(rootPath, 'utf-8')];
-                case 4:
-                    rootContent = _b.sent();
-                    localContent = void 0;
-                    if (!(localPath && existsSync(localPath))) return [3 /*break*/, 6];
-                    return [4 /*yield*/, readFile(localPath, 'utf-8')];
-                case 5:
-                    localContent = _b.sent();
-                    _b.label = 6;
-                case 6: return [4 /*yield*/, import('@claude-flow/guidance/compiler')];
-                case 7:
-                    GuidanceCompiler = (_b.sent()).GuidanceCompiler;
-                    compiler = new GuidanceCompiler();
-                    bundle = compiler.compile(rootContent, localContent);
-                    if (jsonOutput) {
-                        output.writeln(JSON.stringify(bundle, null, 2));
-                    }
-                    else {
-                        output.writeln(output.success('Compiled successfully'));
-                        output.writeln();
-                        output.writeln("  Constitution rules: " + output.bold(String(bundle.constitution.rules.length)));
-                        output.writeln("  Constitution hash:  " + output.dim(bundle.constitution.hash));
-                        output.writeln("  Shard count:        " + output.bold(String(bundle.shards.length)));
-                        output.writeln("  Total rules:        " + output.bold(String(bundle.manifest.totalRules)));
-                        output.writeln("  Compiled at:        " + output.dim(new Date(bundle.manifest.compiledAt).toISOString()));
-                        if (localContent) {
-                            output.writeln("  Local overlay:      " + output.success('applied'));
-                        }
-                        output.writeln();
-                        output.writeln(output.dim('Rule summary:'));
-                        for (_i = 0, _a = bundle.manifest.rules.slice(0, 10); _i < _a.length; _i++) {
-                            rule = _a[_i];
-                            risk = rule.riskClass === 'critical' ? output.error(rule.riskClass) :
-                                rule.riskClass === 'high' ? output.warning(rule.riskClass) :
-                                    output.dim(rule.riskClass);
-                            output.writeln("  " + output.bold(rule.id) + " [" + risk + "] " + rule.source.slice(0, 60) + (rule.source.length > 60 ? '...' : ''));
-                        }
-                        if (bundle.manifest.rules.length > 10) {
-                            output.writeln(output.dim("  ... and " + (bundle.manifest.rules.length - 10) + " more"));
-                        }
-                    }
-                    return [2 /*return*/, { success: true, data: bundle }];
-                case 8:
-                    error_1 = _b.sent();
-                    msg = error_1 instanceof Error ? error_1.message : String(error_1);
-                    output.writeln(output.error("Compilation failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 9: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const rootPath = ctx.flags.root || './CLAUDE.md';
+        const localPath = ctx.flags.local;
+        const jsonOutput = ctx.flags.json === true;
+        output.writeln();
+        output.writeln(output.bold('Guidance Compiler'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { readFile } = await import('node:fs/promises');
+            const { existsSync } = await import('node:fs');
+            if (!existsSync(rootPath)) {
+                output.writeln(output.error(`Root guidance file not found: ${rootPath}`));
+                return { success: false, message: `File not found: ${rootPath}` };
+            }
+            const rootContent = await readFile(rootPath, 'utf-8');
+            let localContent;
+            if (localPath && existsSync(localPath)) {
+                localContent = await readFile(localPath, 'utf-8');
+            }
+            const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
+            const compiler = new GuidanceCompiler();
+            const bundle = compiler.compile(rootContent, localContent);
+            if (jsonOutput) {
+                output.writeln(JSON.stringify(bundle, null, 2));
+            }
+            else {
+                output.writeln(output.success('Compiled successfully'));
+                output.writeln();
+                output.writeln(`  Constitution rules: ${output.bold(String(bundle.constitution.rules.length))}`);
+                output.writeln(`  Constitution hash:  ${output.dim(bundle.constitution.hash)}`);
+                output.writeln(`  Shard count:        ${output.bold(String(bundle.shards.length))}`);
+                output.writeln(`  Total rules:        ${output.bold(String(bundle.manifest.totalRules))}`);
+                output.writeln(`  Compiled at:        ${output.dim(new Date(bundle.manifest.compiledAt).toISOString())}`);
+                if (localContent) {
+                    output.writeln(`  Local overlay:      ${output.success('applied')}`);
+                }
+                output.writeln();
+                output.writeln(output.dim('Rule summary:'));
+                for (const rule of bundle.manifest.rules.slice(0, 10)) {
+                    const risk = rule.riskClass === 'critical' ? output.error(rule.riskClass) :
+                        rule.riskClass === 'high' ? output.warning(rule.riskClass) :
+                            output.dim(rule.riskClass);
+                    output.writeln(`  ${output.bold(rule.id)} [${risk}] ${rule.source.slice(0, 60)}${rule.source.length > 60 ? '...' : ''}`);
+                }
+                if (bundle.manifest.rules.length > 10) {
+                    output.writeln(output.dim(`  ... and ${bundle.manifest.rules.length - 10} more`));
+                }
+            }
+            return { success: true, data: bundle };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`Compilation failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // retrieve subcommand
-var retrieveCommand = {
+const retrieveCommand = {
     name: 'retrieve',
     description: 'Retrieve task-relevant guidance shards for a given task description',
     options: [
         { name: 'task', short: 't', type: 'string', description: 'Task description', required: true },
-        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', "default": './CLAUDE.md' },
+        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', default: './CLAUDE.md' },
         { name: 'local', short: 'l', type: 'string', description: 'Local overlay file path' },
-        { name: 'max-shards', short: 'n', type: 'number', description: 'Maximum number of shards to retrieve', "default": '5' },
+        { name: 'max-shards', short: 'n', type: 'number', description: 'Maximum number of shards to retrieve', default: '5' },
         { name: 'intent', short: 'i', type: 'string', description: 'Override detected intent' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow guidance retrieve -t "Fix SQL injection in user search"', description: 'Retrieve guidance for a security task' },
         { command: 'claude-flow guidance retrieve -t "Add unit tests" -n 3', description: 'Retrieve top 3 shards for testing' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var task, rootPath, localPath, maxShards, intentOverride, jsonOutput, readFile, existsSync, GuidanceCompiler, _a, ShardRetriever, HashEmbeddingProvider, rootContent, localContent, compiler, bundle, retriever, result, _i, _b, shard, lines, _c, lines_1, line, error_2, msg;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    task = ctx.flags.task;
-                    rootPath = ctx.flags.root || './CLAUDE.md';
-                    localPath = ctx.flags.local;
-                    maxShards = parseInt(ctx.flags['max-shards'] || '5', 10);
-                    intentOverride = ctx.flags.intent;
-                    jsonOutput = ctx.flags.json === true;
-                    if (!task) {
-                        output.writeln(output.error('Task description is required (-t "...")'));
-                        return [2 /*return*/, { success: false, message: 'Missing task description' }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Guidance Retriever'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 11, , 12]);
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 2:
-                    readFile = (_d.sent()).readFile;
-                    return [4 /*yield*/, import('node:fs')];
-                case 3:
-                    existsSync = (_d.sent()).existsSync;
-                    return [4 /*yield*/, import('@claude-flow/guidance/compiler')];
-                case 4:
-                    GuidanceCompiler = (_d.sent()).GuidanceCompiler;
-                    return [4 /*yield*/, import('@claude-flow/guidance/retriever')];
-                case 5:
-                    _a = _d.sent(), ShardRetriever = _a.ShardRetriever, HashEmbeddingProvider = _a.HashEmbeddingProvider;
-                    if (!existsSync(rootPath)) {
-                        output.writeln(output.error("Root guidance file not found: " + rootPath));
-                        return [2 /*return*/, { success: false, message: "File not found: " + rootPath }];
-                    }
-                    return [4 /*yield*/, readFile(rootPath, 'utf-8')];
-                case 6:
-                    rootContent = _d.sent();
-                    localContent = void 0;
-                    if (!(localPath && existsSync(localPath))) return [3 /*break*/, 8];
-                    return [4 /*yield*/, readFile(localPath, 'utf-8')];
-                case 7:
-                    localContent = _d.sent();
-                    _d.label = 8;
-                case 8:
-                    compiler = new GuidanceCompiler();
-                    bundle = compiler.compile(rootContent, localContent);
-                    retriever = new ShardRetriever(new HashEmbeddingProvider(128));
-                    return [4 /*yield*/, retriever.loadBundle(bundle)];
-                case 9:
-                    _d.sent();
-                    return [4 /*yield*/, retriever.retrieve({
-                            taskDescription: task,
-                            maxShards: maxShards,
-                            intent: intentOverride
-                        })];
-                case 10:
-                    result = _d.sent();
-                    if (jsonOutput) {
-                        output.writeln(JSON.stringify(result, null, 2));
-                    }
-                    else {
-                        output.writeln("  Detected intent: " + output.bold(result.detectedIntent));
-                        output.writeln("  Retrieval time:  " + output.dim(result.latencyMs + 'ms'));
-                        output.writeln("  Constitution:    " + output.bold(String(result.constitution.rules.length)) + " rules");
-                        output.writeln("  Shards:          " + output.bold(String(result.shards.length)) + " retrieved");
-                        output.writeln();
-                        if (result.shards.length > 0) {
-                            output.writeln(output.dim('Retrieved shards:'));
-                            for (_i = 0, _b = result.shards; _i < _b.length; _i++) {
-                                shard = _b[_i];
-                                output.writeln("  " + output.bold(shard.shard.rule.id) + " [" + shard.shard.rule.riskClass + "] " + shard.shard.rule.text.slice(0, 60));
-                            }
-                        }
-                        output.writeln();
-                        output.writeln(output.dim('Policy text preview:'));
-                        lines = result.policyText.split('\n').slice(0, 15);
-                        for (_c = 0, lines_1 = lines; _c < lines_1.length; _c++) {
-                            line = lines_1[_c];
-                            output.writeln("  " + line);
-                        }
-                        if (result.policyText.split('\n').length > 15) {
-                            output.writeln(output.dim('  ...'));
-                        }
+    action: async (ctx) => {
+        const task = ctx.flags.task;
+        const rootPath = ctx.flags.root || './CLAUDE.md';
+        const localPath = ctx.flags.local;
+        const maxShards = parseInt(ctx.flags['max-shards'] || '5', 10);
+        const intentOverride = ctx.flags.intent;
+        const jsonOutput = ctx.flags.json === true;
+        if (!task) {
+            output.writeln(output.error('Task description is required (-t "...")'));
+            return { success: false, message: 'Missing task description' };
+        }
+        output.writeln();
+        output.writeln(output.bold('Guidance Retriever'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { readFile } = await import('node:fs/promises');
+            const { existsSync } = await import('node:fs');
+            const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
+            const { ShardRetriever, HashEmbeddingProvider } = await import('@claude-flow/guidance/retriever');
+            if (!existsSync(rootPath)) {
+                output.writeln(output.error(`Root guidance file not found: ${rootPath}`));
+                return { success: false, message: `File not found: ${rootPath}` };
+            }
+            const rootContent = await readFile(rootPath, 'utf-8');
+            let localContent;
+            if (localPath && existsSync(localPath)) {
+                localContent = await readFile(localPath, 'utf-8');
+            }
+            const compiler = new GuidanceCompiler();
+            const bundle = compiler.compile(rootContent, localContent);
+            const retriever = new ShardRetriever(new HashEmbeddingProvider(128));
+            await retriever.loadBundle(bundle);
+            const result = await retriever.retrieve({
+                taskDescription: task,
+                maxShards,
+                intent: intentOverride,
+            });
+            if (jsonOutput) {
+                output.writeln(JSON.stringify(result, null, 2));
+            }
+            else {
+                output.writeln(`  Detected intent: ${output.bold(result.detectedIntent)}`);
+                output.writeln(`  Retrieval time:  ${output.dim(result.latencyMs + 'ms')}`);
+                output.writeln(`  Constitution:    ${output.bold(String(result.constitution.rules.length))} rules`);
+                output.writeln(`  Shards:          ${output.bold(String(result.shards.length))} retrieved`);
+                output.writeln();
+                if (result.shards.length > 0) {
+                    output.writeln(output.dim('Retrieved shards:'));
+                    for (const shard of result.shards) {
+                        output.writeln(`  ${output.bold(shard.shard.rule.id)} [${shard.shard.rule.riskClass}] ${shard.shard.rule.text.slice(0, 60)}`);
                     }
-                    return [2 /*return*/, { success: true, data: result }];
-                case 11:
-                    error_2 = _d.sent();
-                    msg = error_2 instanceof Error ? error_2.message : String(error_2);
-                    output.writeln(output.error("Retrieval failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 12: return [2 /*return*/];
-            }
-        });
-    }); }
+                }
+                output.writeln();
+                output.writeln(output.dim('Policy text preview:'));
+                const lines = result.policyText.split('\n').slice(0, 15);
+                for (const line of lines) {
+                    output.writeln(`  ${line}`);
+                }
+                if (result.policyText.split('\n').length > 15) {
+                    output.writeln(output.dim('  ...'));
+                }
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`Retrieval failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // gates subcommand
-var gatesCommand = {
+const gatesCommand = {
     name: 'gates',
     description: 'Evaluate enforcement gates against a command or content',
     options: [
         { name: 'command', short: 'c', type: 'string', description: 'Command to evaluate' },
         { name: 'content', type: 'string', description: 'Content to check for secrets' },
         { name: 'tool', short: 't', type: 'string', description: 'Tool name to check against allowlist' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow guidance gates -c "rm -rf /tmp"', description: 'Check if a command is destructive' },
         { command: 'claude-flow guidance gates --content "api_key=sk-abc123..."', description: 'Check content for secrets' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var command, content, tool, jsonOutput, EnforcementGates, gates, results, gateResults, secretResult, toolResult, _i, results_1, _a, type, result, _b, result_1, r, color, color, error_3, msg;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    command = ctx.flags.command;
-                    content = ctx.flags.content;
-                    tool = ctx.flags.tool;
-                    jsonOutput = ctx.flags.json === true;
-                    output.writeln();
-                    output.writeln(output.bold('Enforcement Gates'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('@claude-flow/guidance/gates')];
-                case 2:
-                    EnforcementGates = (_c.sent()).EnforcementGates;
-                    gates = new EnforcementGates();
-                    results = [];
-                    if (command) {
-                        gateResults = gates.evaluateCommand(command);
-                        results.push({ type: 'command', result: gateResults });
-                    }
-                    if (content) {
-                        secretResult = gates.evaluateSecrets(content);
-                        results.push({ type: 'secrets', result: secretResult });
-                    }
-                    if (tool) {
-                        toolResult = gates.evaluateToolAllowlist(tool);
-                        results.push({ type: 'tool-allowlist', result: toolResult });
-                    }
-                    if (results.length === 0) {
-                        output.writeln(output.warning('No input provided. Use -c, --content, or -t to evaluate.'));
-                        return [2 /*return*/, { success: false, message: 'No input' }];
-                    }
-                    if (jsonOutput) {
-                        output.writeln(JSON.stringify(results, null, 2));
+    action: async (ctx) => {
+        const command = ctx.flags.command;
+        const content = ctx.flags.content;
+        const tool = ctx.flags.tool;
+        const jsonOutput = ctx.flags.json === true;
+        output.writeln();
+        output.writeln(output.bold('Enforcement Gates'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { EnforcementGates } = await import('@claude-flow/guidance/gates');
+            const gates = new EnforcementGates();
+            const results = [];
+            if (command) {
+                const gateResults = gates.evaluateCommand(command);
+                results.push({ type: 'command', result: gateResults });
+            }
+            if (content) {
+                const secretResult = gates.evaluateSecrets(content);
+                results.push({ type: 'secrets', result: secretResult });
+            }
+            if (tool) {
+                const toolResult = gates.evaluateToolAllowlist(tool);
+                results.push({ type: 'tool-allowlist', result: toolResult });
+            }
+            if (results.length === 0) {
+                output.writeln(output.warning('No input provided. Use -c, --content, or -t to evaluate.'));
+                return { success: false, message: 'No input' };
+            }
+            if (jsonOutput) {
+                output.writeln(JSON.stringify(results, null, 2));
+            }
+            else {
+                for (const { type, result } of results) {
+                    output.writeln(`  ${output.bold(type)}:`);
+                    if (result === null) {
+                        output.writeln(`    ${output.success('ALLOW')} - No gate triggered`);
                     }
-                    else {
-                        for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
-                            _a = results_1[_i], type = _a.type, result = _a.result;
-                            output.writeln("  " + output.bold(type) + ":");
-                            if (result === null) {
-                                output.writeln("    " + output.success('ALLOW') + " - No gate triggered");
-                            }
-                            else if (Array.isArray(result)) {
-                                if (result.length === 0) {
-                                    output.writeln("    " + output.success('ALLOW') + " - All gates passed");
-                                }
-                                else {
-                                    for (_b = 0, result_1 = result; _b < result_1.length; _b++) {
-                                        r = result_1[_b];
-                                        color = r.decision === 'block' ? output.error.bind(output) :
-                                            r.decision === 'require-confirmation' ? output.warning.bind(output) :
-                                                output.dim.bind(output);
-                                        output.writeln("    " + color(r.decision.toUpperCase()) + " [" + r.gateName + "] " + r.reason);
-                                        if (r.remediation) {
-                                            output.writeln("      Remediation: " + output.dim(r.remediation));
-                                        }
-                                    }
-                                }
-                            }
-                            else {
-                                color = result.decision === 'block' ? output.error.bind(output) :
-                                    result.decision === 'require-confirmation' ? output.warning.bind(output) :
+                    else if (Array.isArray(result)) {
+                        if (result.length === 0) {
+                            output.writeln(`    ${output.success('ALLOW')} - All gates passed`);
+                        }
+                        else {
+                            for (const r of result) {
+                                const color = r.decision === 'block' ? output.error.bind(output) :
+                                    r.decision === 'require-confirmation' ? output.warning.bind(output) :
                                         output.dim.bind(output);
-                                output.writeln("    " + color(result.decision.toUpperCase()) + " [" + result.gateName + "] " + result.reason);
-                                if (result.remediation) {
-                                    output.writeln("      Remediation: " + output.dim(result.remediation));
+                                output.writeln(`    ${color(r.decision.toUpperCase())} [${r.gateName}] ${r.reason}`);
+                                if (r.remediation) {
+                                    output.writeln(`      Remediation: ${output.dim(r.remediation)}`);
                                 }
                             }
                         }
                     }
-                    return [2 /*return*/, { success: true, data: results }];
-                case 3:
-                    error_3 = _c.sent();
-                    msg = error_3 instanceof Error ? error_3.message : String(error_3);
-                    output.writeln(output.error("Gate evaluation failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
+                    else {
+                        const color = result.decision === 'block' ? output.error.bind(output) :
+                            result.decision === 'require-confirmation' ? output.warning.bind(output) :
+                                output.dim.bind(output);
+                        output.writeln(`    ${color(result.decision.toUpperCase())} [${result.gateName}] ${result.reason}`);
+                        if (result.remediation) {
+                            output.writeln(`      Remediation: ${output.dim(result.remediation)}`);
+                        }
+                    }
+                }
+            }
+            return { success: true, data: results };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`Gate evaluation failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // status subcommand
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Show guidance control plane status and metrics',
     options: [
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var jsonOutput, existsSync, rootExists, localExists, statusData, readFile, GuidanceCompiler, rootContent, compiler, bundle, error_4, msg;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    jsonOutput = ctx.flags.json === true;
-                    output.writeln();
-                    output.writeln(output.bold('Guidance Control Plane Status'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 8, , 9]);
-                    return [4 /*yield*/, import('node:fs')];
-                case 2:
-                    existsSync = (_a.sent()).existsSync;
-                    rootExists = existsSync('./CLAUDE.md');
-                    localExists = existsSync('./CLAUDE.local.md');
-                    statusData = {
-                        rootGuidance: rootExists ? 'found' : 'not found',
-                        localOverlay: localExists ? 'found' : 'not configured',
-                        dataDir: existsSync('./.claude-flow/guidance') ? 'exists' : 'not created'
-                    };
-                    if (!jsonOutput) return [3 /*break*/, 3];
-                    output.writeln(JSON.stringify(statusData, null, 2));
-                    return [3 /*break*/, 7];
-                case 3:
-                    output.writeln("  Root guidance:  " + (rootExists ? output.success('CLAUDE.md found') : output.warning('CLAUDE.md not found')));
-                    output.writeln("  Local overlay:  " + (localExists ? output.success('CLAUDE.local.md found') : output.dim('not configured')));
-                    output.writeln("  Data directory: " + (statusData.dataDir === 'exists' ? output.success('exists') : output.dim('not created')));
-                    if (!rootExists) return [3 /*break*/, 7];
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 4:
-                    readFile = (_a.sent()).readFile;
-                    return [4 /*yield*/, import('@claude-flow/guidance/compiler')];
-                case 5:
-                    GuidanceCompiler = (_a.sent()).GuidanceCompiler;
-                    return [4 /*yield*/, readFile('./CLAUDE.md', 'utf-8')];
-                case 6:
-                    rootContent = _a.sent();
-                    compiler = new GuidanceCompiler();
-                    bundle = compiler.compile(rootContent);
+    action: async (ctx) => {
+        const jsonOutput = ctx.flags.json === true;
+        output.writeln();
+        output.writeln(output.bold('Guidance Control Plane Status'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { existsSync } = await import('node:fs');
+            const rootExists = existsSync('./CLAUDE.md');
+            const localExists = existsSync('./CLAUDE.local.md');
+            const statusData = {
+                rootGuidance: rootExists ? 'found' : 'not found',
+                localOverlay: localExists ? 'found' : 'not configured',
+                dataDir: existsSync('./.claude-flow/guidance') ? 'exists' : 'not created',
+            };
+            if (jsonOutput) {
+                output.writeln(JSON.stringify(statusData, null, 2));
+            }
+            else {
+                output.writeln(`  Root guidance:  ${rootExists ? output.success('CLAUDE.md found') : output.warning('CLAUDE.md not found')}`);
+                output.writeln(`  Local overlay:  ${localExists ? output.success('CLAUDE.local.md found') : output.dim('not configured')}`);
+                output.writeln(`  Data directory: ${statusData.dataDir === 'exists' ? output.success('exists') : output.dim('not created')}`);
+                if (rootExists) {
+                    const { readFile } = await import('node:fs/promises');
+                    const { GuidanceCompiler } = await import('@claude-flow/guidance/compiler');
+                    const rootContent = await readFile('./CLAUDE.md', 'utf-8');
+                    const compiler = new GuidanceCompiler();
+                    const bundle = compiler.compile(rootContent);
                     output.writeln();
                     output.writeln(output.dim('Compiled bundle:'));
-                    output.writeln("  Constitution rules: " + output.bold(String(bundle.constitution.rules.length)));
-                    output.writeln("  Shard count:        " + output.bold(String(bundle.shards.length)));
-                    output.writeln("  Total rules:        " + output.bold(String(bundle.manifest.totalRules)));
-                    output.writeln("  Hash:               " + output.dim(bundle.constitution.hash));
-                    _a.label = 7;
-                case 7: return [2 /*return*/, { success: true, data: statusData }];
-                case 8:
-                    error_4 = _a.sent();
-                    msg = error_4 instanceof Error ? error_4.message : String(error_4);
-                    output.writeln(output.error("Status check failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 9: return [2 /*return*/];
-            }
-        });
-    }); }
+                    output.writeln(`  Constitution rules: ${output.bold(String(bundle.constitution.rules.length))}`);
+                    output.writeln(`  Shard count:        ${output.bold(String(bundle.shards.length))}`);
+                    output.writeln(`  Total rules:        ${output.bold(String(bundle.manifest.totalRules))}`);
+                    output.writeln(`  Hash:               ${output.dim(bundle.constitution.hash)}`);
+                }
+            }
+            return { success: true, data: statusData };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`Status check failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // optimize subcommand
-var optimizeCommand = {
+const optimizeCommand = {
     name: 'optimize',
     description: 'Analyze and optimize a CLAUDE.md file for structure, coverage, and enforceability',
     options: [
-        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', "default": './CLAUDE.md' },
+        { name: 'root', short: 'r', type: 'string', description: 'Root guidance file path', default: './CLAUDE.md' },
         { name: 'local', short: 'l', type: 'string', description: 'Local overlay file path' },
-        { name: 'apply', short: 'a', type: 'boolean', description: 'Apply optimizations to the file', "default": 'false' },
-        { name: 'context-size', short: 's', type: 'string', description: 'Target context size: compact, standard, full', "default": 'standard' },
-        { name: 'target-score', type: 'number', description: 'Target composite score (0-100)', "default": '90' },
-        { name: 'max-iterations', type: 'number', description: 'Maximum optimization iterations', "default": '5' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'apply', short: 'a', type: 'boolean', description: 'Apply optimizations to the file', default: 'false' },
+        { name: 'context-size', short: 's', type: 'string', description: 'Target context size: compact, standard, full', default: 'standard' },
+        { name: 'target-score', type: 'number', description: 'Target composite score (0-100)', default: '90' },
+        { name: 'max-iterations', type: 'number', description: 'Maximum optimization iterations', default: '5' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow guidance optimize', description: 'Analyze current CLAUDE.md and show suggestions' },
@@ -428,121 +319,102 @@ var optimizeCommand = {
         { command: 'claude-flow guidance optimize -s compact --apply', description: 'Optimize for compact context window' },
         { command: 'claude-flow guidance optimize --target-score 95', description: 'Optimize until score reaches 95' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var rootPath, localPath, applyChanges, contextSize, targetScore, maxIterations, jsonOutput, _a, readFile, writeFile, existsSync, rootContent, localContent, _b, analyze, formatReport, optimizeForSize, formatBenchmark, analysis, result, _i, _c, step, error_5, msg;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    rootPath = ctx.flags.root || './CLAUDE.md';
-                    localPath = ctx.flags.local;
-                    applyChanges = ctx.flags.apply === true;
-                    contextSize = (ctx.flags['context-size'] || 'standard');
-                    targetScore = parseInt(ctx.flags['target-score'] || '90', 10);
-                    maxIterations = parseInt(ctx.flags['max-iterations'] || '5', 10);
-                    jsonOutput = ctx.flags.json === true;
-                    output.writeln();
-                    output.writeln(output.bold('Guidance Optimizer'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 11, , 12]);
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 2:
-                    _a = _d.sent(), readFile = _a.readFile, writeFile = _a.writeFile;
-                    return [4 /*yield*/, import('node:fs')];
-                case 3:
-                    existsSync = (_d.sent()).existsSync;
-                    if (!existsSync(rootPath)) {
-                        output.writeln(output.error("Root guidance file not found: " + rootPath));
-                        return [2 /*return*/, { success: false, message: "File not found: " + rootPath }];
-                    }
-                    return [4 /*yield*/, readFile(rootPath, 'utf-8')];
-                case 4:
-                    rootContent = _d.sent();
-                    localContent = void 0;
-                    if (!(localPath && existsSync(localPath))) return [3 /*break*/, 6];
-                    return [4 /*yield*/, readFile(localPath, 'utf-8')];
-                case 5:
-                    localContent = _d.sent();
-                    _d.label = 6;
-                case 6: return [4 /*yield*/, import('@claude-flow/guidance/analyzer')];
-                case 7:
-                    _b = _d.sent(), analyze = _b.analyze, formatReport = _b.formatReport, optimizeForSize = _b.optimizeForSize, formatBenchmark = _b.formatBenchmark;
-                    analysis = analyze(rootContent, localContent);
-                    if (jsonOutput && !applyChanges) {
-                        output.writeln(JSON.stringify(analysis, null, 2));
-                        return [2 /*return*/, { success: true, data: analysis }];
-                    }
-                    // Show current analysis
-                    output.writeln(formatReport(analysis));
-                    output.writeln();
-                    if (analysis.compositeScore >= targetScore) {
-                        output.writeln(output.success("Score " + analysis.compositeScore + "/100 already meets target " + targetScore + ". No optimization needed."));
-                        return [2 /*return*/, { success: true, data: analysis }];
-                    }
-                    // Step 2: Run optimization
-                    output.writeln(output.dim("Optimizing (target: " + targetScore + ", context: " + contextSize + ", max iterations: " + maxIterations + ")..."));
-                    result = optimizeForSize(rootContent, {
-                        contextSize: contextSize,
-                        localContent: localContent,
-                        maxIterations: maxIterations,
-                        targetScore: targetScore
-                    });
-                    if (jsonOutput) {
-                        output.writeln(JSON.stringify({
-                            before: analysis,
-                            after: result.benchmark.after,
-                            delta: result.benchmark.delta,
-                            steps: result.appliedSteps
-                        }, null, 2));
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    // Show benchmark comparison
-                    output.writeln();
-                    output.writeln(formatBenchmark(result.benchmark));
-                    output.writeln();
-                    if (result.appliedSteps.length > 0) {
-                        output.writeln("Applied " + output.bold(String(result.appliedSteps.length)) + " optimization steps:");
-                        for (_i = 0, _c = result.appliedSteps; _i < _c.length; _i++) {
-                            step = _c[_i];
-                            output.writeln("  " + output.success('+') + " " + step);
-                        }
-                        output.writeln();
-                    }
-                    if (!applyChanges) return [3 /*break*/, 9];
-                    return [4 /*yield*/, writeFile(rootPath, result.optimized, 'utf-8')];
-                case 8:
-                    _d.sent();
-                    output.writeln(output.success("Optimized CLAUDE.md written to " + rootPath));
-                    output.writeln("  Before: " + analysis.compositeScore + "/100 (" + analysis.grade + ")");
-                    output.writeln("  After:  " + result.benchmark.after.compositeScore + "/100 (" + result.benchmark.after.grade + ")");
-                    output.writeln("  Delta:  " + (result.benchmark.delta >= 0 ? '+' : '') + result.benchmark.delta);
-                    return [3 /*break*/, 10];
-                case 9:
-                    output.writeln(output.warning('Dry run - use --apply to write changes.'));
-                    output.writeln("  Projected: " + analysis.compositeScore + " \u2192 " + result.benchmark.after.compositeScore + "/100");
-                    _d.label = 10;
-                case 10: return [2 /*return*/, { success: true, data: result }];
-                case 11:
-                    error_5 = _d.sent();
-                    msg = error_5 instanceof Error ? error_5.message : String(error_5);
-                    output.writeln(output.error("Optimization failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 12: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const rootPath = ctx.flags.root || './CLAUDE.md';
+        const localPath = ctx.flags.local;
+        const applyChanges = ctx.flags.apply === true;
+        const contextSize = (ctx.flags['context-size'] || 'standard');
+        const targetScore = parseInt(ctx.flags['target-score'] || '90', 10);
+        const maxIterations = parseInt(ctx.flags['max-iterations'] || '5', 10);
+        const jsonOutput = ctx.flags.json === true;
+        output.writeln();
+        output.writeln(output.bold('Guidance Optimizer'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { readFile, writeFile } = await import('node:fs/promises');
+            const { existsSync } = await import('node:fs');
+            if (!existsSync(rootPath)) {
+                output.writeln(output.error(`Root guidance file not found: ${rootPath}`));
+                return { success: false, message: `File not found: ${rootPath}` };
+            }
+            const rootContent = await readFile(rootPath, 'utf-8');
+            let localContent;
+            if (localPath && existsSync(localPath)) {
+                localContent = await readFile(localPath, 'utf-8');
+            }
+            // Step 1: Analyze current state
+            const { analyze, formatReport, optimizeForSize, formatBenchmark } = await import('@claude-flow/guidance/analyzer');
+            const analysis = analyze(rootContent, localContent);
+            if (jsonOutput && !applyChanges) {
+                output.writeln(JSON.stringify(analysis, null, 2));
+                return { success: true, data: analysis };
+            }
+            // Show current analysis
+            output.writeln(formatReport(analysis));
+            output.writeln();
+            if (analysis.compositeScore >= targetScore) {
+                output.writeln(output.success(`Score ${analysis.compositeScore}/100 already meets target ${targetScore}. No optimization needed.`));
+                return { success: true, data: analysis };
+            }
+            // Step 2: Run optimization
+            output.writeln(output.dim(`Optimizing (target: ${targetScore}, context: ${contextSize}, max iterations: ${maxIterations})...`));
+            const result = optimizeForSize(rootContent, {
+                contextSize,
+                localContent,
+                maxIterations,
+                targetScore,
+            });
+            if (jsonOutput) {
+                output.writeln(JSON.stringify({
+                    before: analysis,
+                    after: result.benchmark.after,
+                    delta: result.benchmark.delta,
+                    steps: result.appliedSteps,
+                }, null, 2));
+                return { success: true, data: result };
+            }
+            // Show benchmark comparison
+            output.writeln();
+            output.writeln(formatBenchmark(result.benchmark));
+            output.writeln();
+            if (result.appliedSteps.length > 0) {
+                output.writeln(`Applied ${output.bold(String(result.appliedSteps.length))} optimization steps:`);
+                for (const step of result.appliedSteps) {
+                    output.writeln(`  ${output.success('+')} ${step}`);
+                }
+                output.writeln();
+            }
+            // Step 3: Apply if requested
+            if (applyChanges) {
+                await writeFile(rootPath, result.optimized, 'utf-8');
+                output.writeln(output.success(`Optimized CLAUDE.md written to ${rootPath}`));
+                output.writeln(`  Before: ${analysis.compositeScore}/100 (${analysis.grade})`);
+                output.writeln(`  After:  ${result.benchmark.after.compositeScore}/100 (${result.benchmark.after.grade})`);
+                output.writeln(`  Delta:  ${result.benchmark.delta >= 0 ? '+' : ''}${result.benchmark.delta}`);
+            }
+            else {
+                output.writeln(output.warning('Dry run - use --apply to write changes.'));
+                output.writeln(`  Projected: ${analysis.compositeScore} → ${result.benchmark.after.compositeScore}/100`);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`Optimization failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // ab-test subcommand
-var abTestCommand = {
+const abTestCommand = {
     name: 'ab-test',
     description: 'Run A/B behavioral comparison between two CLAUDE.md versions',
     options: [
         { name: 'config-a', short: 'a', type: 'string', description: 'Path to Config A (baseline CLAUDE.md). Defaults to no guidance.' },
-        { name: 'config-b', short: 'b', type: 'string', description: 'Path to Config B (candidate CLAUDE.md)', "default": './CLAUDE.md' },
+        { name: 'config-b', short: 'b', type: 'string', description: 'Path to Config B (candidate CLAUDE.md)', default: './CLAUDE.md' },
         { name: 'tasks', short: 't', type: 'string', description: 'Path to custom task JSON file (array of ABTask objects)' },
         { name: 'work-dir', short: 'w', type: 'string', description: 'Working directory for test execution' },
-        { name: 'json', type: 'boolean', description: 'Output as JSON', "default": 'false' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow guidance ab-test', description: 'Run default A/B test (no guidance vs ./CLAUDE.md)' },
@@ -550,120 +422,103 @@ var abTestCommand = {
         { command: 'claude-flow guidance ab-test --tasks custom-tasks.json', description: 'Run with custom test tasks' },
         { command: 'claude-flow guidance ab-test --json', description: 'Output full report as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var configAPath, configBPath, tasksPath, workDir, jsonOutput, readFile, existsSync, _a, abBenchmark, getDefaultABTasks, configBContent, configALabel, customTasks, tasksJson, report, delta, error_6, msg;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    configAPath = ctx.flags['config-a'];
-                    configBPath = ctx.flags['config-b'] || './CLAUDE.md';
-                    tasksPath = ctx.flags.tasks;
-                    workDir = ctx.flags['work-dir'];
-                    jsonOutput = ctx.flags.json === true;
-                    output.writeln();
-                    output.writeln(output.bold('A/B Behavioral Benchmark'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 9, , 10]);
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 2:
-                    readFile = (_b.sent()).readFile;
-                    return [4 /*yield*/, import('node:fs')];
-                case 3:
-                    existsSync = (_b.sent()).existsSync;
-                    return [4 /*yield*/, import('@claude-flow/guidance/analyzer')];
-                case 4:
-                    _a = _b.sent(), abBenchmark = _a.abBenchmark, getDefaultABTasks = _a.getDefaultABTasks;
-                    // Load Config B (candidate) content
-                    if (!existsSync(configBPath)) {
-                        output.writeln(output.error("Config B file not found: " + configBPath));
-                        return [2 /*return*/, { success: false, message: "File not found: " + configBPath }];
-                    }
-                    return [4 /*yield*/, readFile(configBPath, 'utf-8')];
-                case 5:
-                    configBContent = _b.sent();
-                    configALabel = 'No control plane (baseline)';
-                    if (configAPath) {
-                        if (!existsSync(configAPath)) {
-                            output.writeln(output.error("Config A file not found: " + configAPath));
-                            return [2 /*return*/, { success: false, message: "File not found: " + configAPath }];
-                        }
-                        configALabel = configAPath;
-                    }
-                    customTasks = void 0;
-                    if (!tasksPath) return [3 /*break*/, 7];
-                    if (!existsSync(tasksPath)) {
-                        output.writeln(output.error("Tasks file not found: " + tasksPath));
-                        return [2 /*return*/, { success: false, message: "File not found: " + tasksPath }];
-                    }
-                    return [4 /*yield*/, readFile(tasksPath, 'utf-8')];
-                case 6:
-                    tasksJson = _b.sent();
-                    customTasks = JSON.parse(tasksJson);
-                    output.writeln("  Custom tasks: " + output.bold(String(customTasks.length)) + " loaded from " + tasksPath);
-                    _b.label = 7;
-                case 7:
-                    output.writeln("  Config A: " + output.dim(configALabel));
-                    output.writeln("  Config B: " + output.dim(configBPath));
-                    output.writeln("  Tasks:    " + output.dim(customTasks ? customTasks.length + " custom" : getDefaultABTasks().length + " default"));
-                    output.writeln();
-                    output.writeln(output.dim('Running benchmark...'));
-                    return [4 /*yield*/, abBenchmark(configBContent, {
-                            tasks: customTasks,
-                            workDir: workDir
-                        })];
-                case 8:
-                    report = _b.sent();
-                    if (jsonOutput) {
-                        output.writeln(JSON.stringify({
-                            configA: { label: configALabel, metrics: report.configA.metrics },
-                            configB: { label: configBPath, metrics: report.configB.metrics },
-                            compositeDelta: report.compositeDelta,
-                            classDeltas: report.classDeltas,
-                            categoryShift: report.categoryShift,
-                            taskResults: {
-                                configA: report.configA.taskResults.map(function (r) { return ({
-                                    taskId: r.taskId, taskClass: r.taskClass, passed: r.passed,
-                                    violations: r.violations.length, toolCalls: r.toolCalls
-                                }); }),
-                                configB: report.configB.taskResults.map(function (r) { return ({
-                                    taskId: r.taskId, taskClass: r.taskClass, passed: r.passed,
-                                    violations: r.violations.length, toolCalls: r.toolCalls
-                                }); })
-                            }
-                        }, null, 2));
-                        return [2 /*return*/, { success: true, data: report }];
-                    }
-                    // Print formatted report
-                    output.writeln(report.report);
-                    output.writeln();
-                    delta = report.compositeDelta;
-                    if (delta > 0.05) {
-                        output.writeln(output.success("Config B is better (+" + delta + " composite delta)"));
-                    }
-                    else if (delta < -0.05) {
-                        output.writeln(output.error("Config B is worse (" + delta + " composite delta)"));
-                    }
-                    else {
-                        output.writeln(output.warning("No significant difference (" + delta + " composite delta)"));
-                    }
-                    if (report.categoryShift) {
-                        output.writeln(output.success('Category shift detected: 3+ task classes improved by 20%+'));
-                    }
-                    return [2 /*return*/, { success: true, data: report }];
-                case 9:
-                    error_6 = _b.sent();
-                    msg = error_6 instanceof Error ? error_6.message : String(error_6);
-                    output.writeln(output.error("A/B benchmark failed: " + msg));
-                    return [2 /*return*/, { success: false, message: msg }];
-                case 10: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const configAPath = ctx.flags['config-a'];
+        const configBPath = ctx.flags['config-b'] || './CLAUDE.md';
+        const tasksPath = ctx.flags.tasks;
+        const workDir = ctx.flags['work-dir'];
+        const jsonOutput = ctx.flags.json === true;
+        output.writeln();
+        output.writeln(output.bold('A/B Behavioral Benchmark'));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { readFile } = await import('node:fs/promises');
+            const { existsSync } = await import('node:fs');
+            const { abBenchmark, getDefaultABTasks } = await import('@claude-flow/guidance/analyzer');
+            // Load Config B (candidate) content
+            if (!existsSync(configBPath)) {
+                output.writeln(output.error(`Config B file not found: ${configBPath}`));
+                return { success: false, message: `File not found: ${configBPath}` };
+            }
+            const configBContent = await readFile(configBPath, 'utf-8');
+            // Optionally load Config A for display context
+            let configALabel = 'No control plane (baseline)';
+            if (configAPath) {
+                if (!existsSync(configAPath)) {
+                    output.writeln(output.error(`Config A file not found: ${configAPath}`));
+                    return { success: false, message: `File not found: ${configAPath}` };
+                }
+                configALabel = configAPath;
+            }
+            // Load custom tasks if provided
+            let customTasks;
+            if (tasksPath) {
+                if (!existsSync(tasksPath)) {
+                    output.writeln(output.error(`Tasks file not found: ${tasksPath}`));
+                    return { success: false, message: `File not found: ${tasksPath}` };
+                }
+                const tasksJson = await readFile(tasksPath, 'utf-8');
+                customTasks = JSON.parse(tasksJson);
+                output.writeln(`  Custom tasks: ${output.bold(String(customTasks.length))} loaded from ${tasksPath}`);
+            }
+            output.writeln(`  Config A: ${output.dim(configALabel)}`);
+            output.writeln(`  Config B: ${output.dim(configBPath)}`);
+            output.writeln(`  Tasks:    ${output.dim(customTasks ? `${customTasks.length} custom` : `${getDefaultABTasks().length} default`)}`);
+            output.writeln();
+            output.writeln(output.dim('Running benchmark...'));
+            // Run the A/B benchmark
+            const report = await abBenchmark(configBContent, {
+                tasks: customTasks,
+                workDir,
+            });
+            if (jsonOutput) {
+                output.writeln(JSON.stringify({
+                    configA: { label: configALabel, metrics: report.configA.metrics },
+                    configB: { label: configBPath, metrics: report.configB.metrics },
+                    compositeDelta: report.compositeDelta,
+                    classDeltas: report.classDeltas,
+                    categoryShift: report.categoryShift,
+                    taskResults: {
+                        configA: report.configA.taskResults.map(r => ({
+                            taskId: r.taskId, taskClass: r.taskClass, passed: r.passed,
+                            violations: r.violations.length, toolCalls: r.toolCalls,
+                        })),
+                        configB: report.configB.taskResults.map(r => ({
+                            taskId: r.taskId, taskClass: r.taskClass, passed: r.passed,
+                            violations: r.violations.length, toolCalls: r.toolCalls,
+                        })),
+                    },
+                }, null, 2));
+                return { success: true, data: report };
+            }
+            // Print formatted report
+            output.writeln(report.report);
+            output.writeln();
+            // Summary verdict
+            const delta = report.compositeDelta;
+            if (delta > 0.05) {
+                output.writeln(output.success(`Config B is better (+${delta} composite delta)`));
+            }
+            else if (delta < -0.05) {
+                output.writeln(output.error(`Config B is worse (${delta} composite delta)`));
+            }
+            else {
+                output.writeln(output.warning(`No significant difference (${delta} composite delta)`));
+            }
+            if (report.categoryShift) {
+                output.writeln(output.success('Category shift detected: 3+ task classes improved by 20%+'));
+            }
+            return { success: true, data: report };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            output.writeln(output.error(`A/B benchmark failed: ${msg}`));
+            return { success: false, message: msg };
+        }
+    },
 };
 // Main guidance command
-export var guidanceCommand = {
+export const guidanceCommand = {
     name: 'guidance',
     description: 'Guidance Control Plane - compile, retrieve, enforce, and optimize guidance rules',
     aliases: ['guide', 'policy'],
@@ -684,24 +539,22 @@ export var guidanceCommand = {
         { command: 'claude-flow guidance optimize', description: 'Analyze and optimize CLAUDE.md' },
         { command: 'claude-flow guidance ab-test', description: 'Run A/B behavioral comparison' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Guidance Control Plane'));
-            output.writeln(output.dim('─'.repeat(50)));
-            output.writeln();
-            output.writeln('Available subcommands:');
-            output.writeln("  " + output.bold('compile') + "   Compile CLAUDE.md into policy bundle");
-            output.writeln("  " + output.bold('retrieve') + "  Retrieve task-relevant guidance shards");
-            output.writeln("  " + output.bold('gates') + "     Evaluate enforcement gates");
-            output.writeln("  " + output.bold('status') + "    Show control plane status");
-            output.writeln("  " + output.bold('optimize') + "  Analyze and optimize CLAUDE.md");
-            output.writeln("  " + output.bold('ab-test') + "   Run A/B behavioral comparison");
-            output.writeln();
-            output.writeln(output.dim('Use claude-flow guidance <subcommand> --help for details'));
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async (ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Guidance Control Plane'));
+        output.writeln(output.dim('─'.repeat(50)));
+        output.writeln();
+        output.writeln('Available subcommands:');
+        output.writeln(`  ${output.bold('compile')}   Compile CLAUDE.md into policy bundle`);
+        output.writeln(`  ${output.bold('retrieve')}  Retrieve task-relevant guidance shards`);
+        output.writeln(`  ${output.bold('gates')}     Evaluate enforcement gates`);
+        output.writeln(`  ${output.bold('status')}    Show control plane status`);
+        output.writeln(`  ${output.bold('optimize')}  Analyze and optimize CLAUDE.md`);
+        output.writeln(`  ${output.bold('ab-test')}   Run A/B behavioral comparison`);
+        output.writeln();
+        output.writeln(output.dim('Use claude-flow guidance <subcommand> --help for details'));
+        return { success: true };
+    },
 };
 export default guidanceCommand;
 //# sourceMappingURL=guidance.js.map