kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/guidance.js

@@ -2,316 +2,425 @@
  * 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
-const compileCommand = {
+var 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: 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 };
-        }
-    },
+    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*/];
+            }
+        });
+    }); }
 };
 // retrieve subcommand
-const retrieveCommand = {
+var 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: 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)}`);
+    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.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 };
-        }
-    },
+                    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('  ...'));
+                        }
+                    }
+                    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*/];
+            }
+        });
+    }); }
 };
 // gates subcommand
-const gatesCommand = {
+var 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: 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`);
+    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 });
                     }
-                    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) :
+                    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));
+                    }
+                    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) :
                                         output.dim.bind(output);
-                                output.writeln(`    ${color(r.decision.toUpperCase())} [${r.gateName}] ${r.reason}`);
-                                if (r.remediation) {
-                                    output.writeln(`      Remediation: ${output.dim(r.remediation)}`);
+                                output.writeln("    " + color(result.decision.toUpperCase()) + " [" + result.gateName + "] " + result.reason);
+                                if (result.remediation) {
+                                    output.writeln("      Remediation: " + output.dim(result.remediation));
                                 }
                             }
                         }
                     }
-                    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 };
-        }
-    },
+                    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*/];
+            }
+        });
+    }); }
 };
 // status subcommand
-const statusCommand = {
+var 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: 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);
+    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);
                     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)}`);
-                }
-            }
-            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 };
-        }
-    },
+                    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*/];
+            }
+        });
+    }); }
 };
 // optimize subcommand
-const optimizeCommand = {
+var 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' },
@@ -319,102 +428,121 @@ const 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: 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 };
-        }
-    },
+    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*/];
+            }
+        });
+    }); }
 };
 // ab-test subcommand
-const abTestCommand = {
+var 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)' },
@@ -422,103 +550,120 @@ const 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: 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 };
-        }
-    },
+    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*/];
+            }
+        });
+    }); }
 };
 // Main guidance command
-export const guidanceCommand = {
+export var guidanceCommand = {
     name: 'guidance',
     description: 'Guidance Control Plane - compile, retrieve, enforce, and optimize guidance rules',
     aliases: ['guide', 'policy'],
@@ -539,22 +684,24 @@ export const 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: 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 };
-    },
+    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 }];
+        });
+    }); }
 };
 export default guidanceCommand;
 //# sourceMappingURL=guidance.js.map