kynjal-cli 3.1.3 → 4.0.0

package/dist/src/init/executor.js

@@ -2,14 +2,70 @@
  * Init Executor
  * Main execution logic for V3 initialization
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { dirname } from 'path';
 // ESM-compatible __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
 import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
@@ -19,7 +75,7 @@ import { generateClaudeMd } from './claudemd-generator.js';
 /**
  * Skills to copy based on configuration
  */
-const SKILLS_MAP = {
+var SKILLS_MAP = {
     core: [
         'swarm-orchestration',
         'swarm-advanced',
@@ -30,8 +86,8 @@ const SKILLS_MAP = {
         'stream-chain',
         'skill-builder',
     ],
-    browser: ['browser'], // agent-browser integration
-    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
+    browser: ['browser'],
+    dualMode: ['dual-mode'],
     agentdb: [
         'agentdb-advanced',
         'agentdb-learning',
@@ -53,6 +109,7 @@ const SKILLS_MAP = {
         'flow-nexus-platform',
         'flow-nexus-swarm',
     ],
+    design: ['ui-ux-pro-max'],
     v3: [
         'v3-cli-modernization',
         'v3-core-implementation',
@@ -63,12 +120,12 @@ const SKILLS_MAP = {
         'v3-performance-optimization',
         'v3-security-overhaul',
         'v3-swarm-coordination',
-    ],
+    ]
 };
 /**
  * Commands to copy based on configuration
  */
-const COMMANDS_MAP = {
+var COMMANDS_MAP = {
     core: ['claude-flow-help.md', 'claude-flow-swarm.md', 'claude-flow-memory.md'],
     analysis: ['analysis'],
     automation: ['automation'],
@@ -76,20 +133,20 @@ const COMMANDS_MAP = {
     hooks: ['hooks'],
     monitoring: ['monitoring'],
     optimization: ['optimization'],
-    sparc: ['sparc'],
+    sparc: ['sparc']
 };
 /**
  * Agents to copy based on configuration
  */
-const AGENTS_MAP = {
+var AGENTS_MAP = {
     core: ['core'],
     consensus: ['consensus'],
     github: ['github'],
     hiveMind: ['hive-mind'],
     sparc: ['sparc'],
     swarm: ['swarm'],
-    browser: ['browser'], // agent-browser integration
-    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
+    browser: ['browser'],
+    dualMode: ['dual-mode'],
     // V3-specific agents
     v3: ['v3'],
     optimization: ['optimization'],
@@ -107,12 +164,13 @@ const AGENTS_MAP = {
     sona: ['sona'],
     payments: ['payments'],
     data: ['data'],
-    custom: ['custom'],
+    design: ['design'],
+    custom: ['custom']
 };
 /**
  * Directory structure to create
  */
-const DIRECTORIES = {
+var DIRECTORIES = {
     claude: [
         '.claude',
         '.claude/skills',
@@ -128,82 +186,115 @@ const DIRECTORIES = {
         '.claude-flow/hooks',
         '.claude-flow/agents',
         '.claude-flow/workflows',
-    ],
+    ]
 };
 /**
  * Execute initialization
  */
-export async function executeInit(options) {
-    // Detect platform
-    const platform = detectPlatform();
-    const result = {
-        success: true,
-        platform,
-        created: {
-            directories: [],
-            files: [],
-        },
-        skipped: [],
-        errors: [],
-        summary: {
-            skillsCount: 0,
-            commandsCount: 0,
-            agentsCount: 0,
-            hooksEnabled: 0,
-        },
-    };
-    const targetDir = options.targetDir;
-    try {
-        // Create directory structure
-        await createDirectories(targetDir, options, result);
-        // Generate and write settings.json
-        if (options.components.settings) {
-            await writeSettings(targetDir, options, result);
-        }
-        // Generate and write .mcp.json
-        if (options.components.mcp) {
-            await writeMCPConfig(targetDir, options, result);
-        }
-        // Copy skills
-        if (options.components.skills) {
-            await copySkills(targetDir, options, result);
-        }
-        // Copy commands
-        if (options.components.commands) {
-            await copyCommands(targetDir, options, result);
-        }
-        // Copy agents
-        if (options.components.agents) {
-            await copyAgents(targetDir, options, result);
-        }
-        // Generate helpers
-        if (options.components.helpers) {
-            await writeHelpers(targetDir, options, result);
-        }
-        // Generate statusline
-        if (options.components.statusline) {
-            await writeStatusline(targetDir, options, result);
-        }
-        // Generate runtime config
-        if (options.components.runtime) {
-            await writeRuntimeConfig(targetDir, options, result);
-        }
-        // Create initial metrics for statusline (prevents "all zeros" display)
-        if (options.components.statusline) {
-            await writeInitialMetrics(targetDir, options, result);
-        }
-        // Generate CLAUDE.md
-        if (options.components.claudeMd) {
-            await writeClaudeMd(targetDir, options, result);
-        }
-        // Count enabled hooks
-        result.summary.hooksEnabled = countEnabledHooks(options);
-    }
-    catch (error) {
-        result.success = false;
-        result.errors.push(error instanceof Error ? error.message : String(error));
-    }
-    return result;
+export function executeInit(options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var platform, result, targetDir, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    platform = detectPlatform();
+                    result = {
+                        success: true,
+                        platform: platform,
+                        created: {
+                            directories: [],
+                            files: []
+                        },
+                        skipped: [],
+                        errors: [],
+                        summary: {
+                            skillsCount: 0,
+                            commandsCount: 0,
+                            agentsCount: 0,
+                            hooksEnabled: 0
+                        }
+                    };
+                    targetDir = options.targetDir;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 23, , 24]);
+                    // Create directory structure
+                    return [4 /*yield*/, createDirectories(targetDir, options, result)];
+                case 2:
+                    // Create directory structure
+                    _a.sent();
+                    if (!options.components.settings) return [3 /*break*/, 4];
+                    return [4 /*yield*/, writeSettings(targetDir, options, result)];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4:
+                    if (!options.components.mcp) return [3 /*break*/, 6];
+                    return [4 /*yield*/, writeMCPConfig(targetDir, options, result)];
+                case 5:
+                    _a.sent();
+                    _a.label = 6;
+                case 6:
+                    if (!options.components.skills) return [3 /*break*/, 8];
+                    return [4 /*yield*/, copySkills(targetDir, options, result)];
+                case 7:
+                    _a.sent();
+                    _a.label = 8;
+                case 8:
+                    if (!options.components.commands) return [3 /*break*/, 10];
+                    return [4 /*yield*/, copyCommands(targetDir, options, result)];
+                case 9:
+                    _a.sent();
+                    _a.label = 10;
+                case 10:
+                    if (!options.components.agents) return [3 /*break*/, 12];
+                    return [4 /*yield*/, copyAgents(targetDir, options, result)];
+                case 11:
+                    _a.sent();
+                    _a.label = 12;
+                case 12:
+                    if (!options.components.helpers) return [3 /*break*/, 14];
+                    return [4 /*yield*/, writeHelpers(targetDir, options, result)];
+                case 13:
+                    _a.sent();
+                    _a.label = 14;
+                case 14:
+                    if (!options.components.statusline) return [3 /*break*/, 16];
+                    return [4 /*yield*/, writeStatusline(targetDir, options, result)];
+                case 15:
+                    _a.sent();
+                    _a.label = 16;
+                case 16:
+                    if (!options.components.runtime) return [3 /*break*/, 18];
+                    return [4 /*yield*/, writeRuntimeConfig(targetDir, options, result)];
+                case 17:
+                    _a.sent();
+                    _a.label = 18;
+                case 18:
+                    if (!options.components.statusline) return [3 /*break*/, 20];
+                    return [4 /*yield*/, writeInitialMetrics(targetDir, options, result)];
+                case 19:
+                    _a.sent();
+                    _a.label = 20;
+                case 20:
+                    if (!options.components.claudeMd) return [3 /*break*/, 22];
+                    return [4 /*yield*/, writeClaudeMd(targetDir, options, result)];
+                case 21:
+                    _a.sent();
+                    _a.label = 22;
+                case 22:
+                    // Count enabled hooks
+                    result.summary.hooksEnabled = countEnabledHooks(options);
+                    return [3 /*break*/, 24];
+                case 23:
+                    error_1 = _a.sent();
+                    result.success = false;
+                    result.errors.push(error_1 instanceof Error ? error_1.message : String(error_1));
+                    return [3 /*break*/, 24];
+                case 24: return [2 /*return*/, result];
+            }
+        });
+    });
 }
 /**
  * Merge new settings into existing settings.json
@@ -211,63 +302,57 @@ export async function executeInit(options) {
  * Uses platform-specific commands for Mac, Linux, and Windows
  */
 function mergeSettingsForUpgrade(existing) {
-    const merged = { ...existing };
-    const platform = detectPlatform();
-    const isWindows = platform.os === 'windows';
+    var _a, _b, _c;
+    var merged = __assign({}, existing);
+    var platform = detectPlatform();
+    var isWindows = platform.os === 'windows';
     // Platform-specific command wrappers
     // Windows: Use PowerShell-compatible commands
     // Mac/Linux: Use bash-compatible commands with 2>/dev/null
-    const teammateIdleCmd = isWindows
-        ? 'npx @kynjal/cli@latest hooks teammate-idle --auto-assign true 2>$null; exit 0'
-        : 'npx @kynjal/cli@latest hooks teammate-idle --auto-assign true 2>/dev/null || true';
-    const taskCompletedCmd = isWindows
-        ? 'if ($env:TASK_ID) { npx @kynjal/cli@latest hooks task-completed --task-id $env:TASK_ID --train-patterns true 2>$null }; exit 0'
-        : '[ -n "$TASK_ID" ] && npx @kynjal/cli@latest hooks task-completed --task-id "$TASK_ID" --train-patterns true 2>/dev/null || true';
+    // NOTE: teammateIdleCmd and taskCompletedCmd were removed.
+    // TeammateIdle/TaskCompleted are not valid Claude Code hook events and caused warnings.
+    // Agent Teams hook config lives in claudeFlow.agentTeams.hooks instead.
     // 1. Merge env vars (preserve existing, add new)
-    const existingEnv = existing.env || {};
-    merged.env = {
-        ...existingEnv,
-        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-        CLAUDE_FLOW_V3_ENABLED: existingEnv.CLAUDE_FLOW_V3_ENABLED || 'true',
-        CLAUDE_FLOW_HOOKS_ENABLED: existingEnv.CLAUDE_FLOW_HOOKS_ENABLED || 'true',
-    };
+    var existingEnv = existing.env || {};
+    merged.env = __assign(__assign({}, existingEnv), { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1', CLAUDE_FLOW_V3_ENABLED: existingEnv.CLAUDE_FLOW_V3_ENABLED || 'true', CLAUDE_FLOW_HOOKS_ENABLED: existingEnv.CLAUDE_FLOW_HOOKS_ENABLED || 'true' });
     // 2. Merge hooks (preserve existing, add new Agent Teams + auto-memory hooks)
-    const existingHooks = existing.hooks || {};
-    merged.hooks = { ...existingHooks };
-    // Platform-specific auto-memory hook commands
-    const autoMemoryImportCmd = isWindows
-        ? 'node .claude/helpers/auto-memory-hook.mjs import 2>$null; exit 0'
-        : 'node .claude/helpers/auto-memory-hook.mjs import 2>/dev/null || true';
-    const autoMemorySyncCmd = isWindows
-        ? 'node .claude/helpers/auto-memory-hook.mjs sync 2>$null; exit 0'
-        : 'node .claude/helpers/auto-memory-hook.mjs sync 2>/dev/null || true';
+    var existingHooks = existing.hooks || {};
+    merged.hooks = __assign({}, existingHooks);
+    // Cross-platform auto-memory hook commands that resolve paths via git root.
+    // Uses node -e with git rev-parse so hooks work regardless of CWD (#1259, #1284).
+    var gitRootResolver = "var c=require('child_process'),p=require('path'),u=require('url'),r;"
+        + "try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}"
+        + 'catch(e){r=process.cwd()}';
+    var autoMemoryScript = '.claude/helpers/auto-memory-hook.mjs';
+    var autoMemoryImportCmd = "node -e \"" + gitRootResolver + "var f=p.join(r,'" + autoMemoryScript + "');import(u.pathToFileURL(f).href)\" import";
+    var autoMemorySyncCmd = "node -e \"" + gitRootResolver + "var f=p.join(r,'" + autoMemoryScript + "');import(u.pathToFileURL(f).href)\" sync";
     // Add auto-memory import to SessionStart (if not already present)
-    const sessionStartHooks = existingHooks.SessionStart;
-    const hasAutoMemoryImport = sessionStartHooks?.some(group => group.hooks?.some(h => h.command?.includes('auto-memory-hook')));
+    var sessionStartHooks = existingHooks.SessionStart;
+    var hasAutoMemoryImport = sessionStartHooks === null || sessionStartHooks === void 0 ? void 0 : sessionStartHooks.some(function (group) { var _a; return (_a = group.hooks) === null || _a === void 0 ? void 0 : _a.some(function (h) { var _a; return (_a = h.command) === null || _a === void 0 ? void 0 : _a.includes('auto-memory-hook'); }); });
     if (!hasAutoMemoryImport) {
-        const startHooks = merged.hooks;
+        var startHooks = merged.hooks;
         if (!startHooks.SessionStart) {
             startHooks.SessionStart = [{ hooks: [] }];
         }
-        const startGroup = startHooks.SessionStart[0];
+        var startGroup = startHooks.SessionStart[0];
         if (!startGroup.hooks)
             startGroup.hooks = [];
         startGroup.hooks.push({
             type: 'command',
             command: autoMemoryImportCmd,
             timeout: 6000,
-            continueOnError: true,
+            continueOnError: true
         });
     }
     // Add auto-memory sync to SessionEnd (if not already present)
-    const sessionEndHooks = existingHooks.SessionEnd;
-    const hasAutoMemorySync = sessionEndHooks?.some(group => group.hooks?.some(h => h.command?.includes('auto-memory-hook')));
+    var sessionEndHooks = existingHooks.SessionEnd;
+    var hasAutoMemorySync = sessionEndHooks === null || sessionEndHooks === void 0 ? void 0 : sessionEndHooks.some(function (group) { var _a; return (_a = group.hooks) === null || _a === void 0 ? void 0 : _a.some(function (h) { var _a; return (_a = h.command) === null || _a === void 0 ? void 0 : _a.includes('auto-memory-hook'); }); });
     if (!hasAutoMemorySync) {
-        const endHooks = merged.hooks;
+        var endHooks = merged.hooks;
         if (!endHooks.SessionEnd) {
             endHooks.SessionEnd = [{ hooks: [] }];
         }
-        const endGroup = endHooks.SessionEnd[0];
+        var endGroup = endHooks.SessionEnd[0];
         if (!endGroup.hooks)
             endGroup.hooks = [];
         // Insert at beginning so sync runs before other cleanup
@@ -275,47 +360,28 @@ function mergeSettingsForUpgrade(existing) {
             type: 'command',
             command: autoMemorySyncCmd,
             timeout: 8000,
-            continueOnError: true,
+            continueOnError: true
         });
     }
-    // Add TeammateIdle hook if not present
-    if (!existingHooks.TeammateIdle) {
-        merged.hooks.TeammateIdle = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: teammateIdleCmd,
-                        timeout: 5000,
-                        continueOnError: true,
-                    },
-                ],
-            },
-        ];
-    }
-    // Add TaskCompleted hook if not present
-    if (!existingHooks.TaskCompleted) {
-        merged.hooks.TaskCompleted = [
-            {
-                hooks: [
-                    {
-                        type: 'command',
-                        command: taskCompletedCmd,
-                        timeout: 5000,
-                        continueOnError: true,
-                    },
-                ],
-            },
-        ];
+    // NOTE: TeammateIdle and TaskCompleted are NOT valid Claude Code hook events.
+    // They cause warnings when present in settings.json hooks.
+    // Remove them if they exist from a previous init.
+    delete merged.hooks.TeammateIdle;
+    delete merged.hooks.TaskCompleted;
+    // Their configuration lives in claudeFlow.agentTeams.hooks instead.
+    // 3. Fix statusLine config (remove invalid fields, ensure correct format)
+    // Claude Code only supports: type, command, padding
+    var existingStatusLine = existing.statusLine;
+    if (existingStatusLine) {
+        merged.statusLine = {
+            type: 'command',
+            command: existingStatusLine.command || "node -e \"var c=require('child_process'),p=require('path'),r;try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}catch(e){r=process.cwd()}var s=p.join(r,'.claude/helpers/statusline.cjs');process.argv.splice(1,0,s);require(s)\""
+        };
     }
-    // 3. Merge claudeFlow settings (preserve existing, add agentTeams + memory)
-    const existingClaudeFlow = existing.claudeFlow || {};
-    const existingMemory = existingClaudeFlow.memory || {};
-    merged.claudeFlow = {
-        ...existingClaudeFlow,
-        version: existingClaudeFlow.version || '3.0.0',
-        enabled: existingClaudeFlow.enabled !== false,
-        agentTeams: {
+    // 4. Merge claudeFlow settings (preserve existing, add agentTeams + memory)
+    var existingClaudeFlow = existing.claudeFlow || {};
+    var existingMemory = existingClaudeFlow.memory || {};
+    merged.claudeFlow = __assign(__assign({}, existingClaudeFlow), { version: existingClaudeFlow.version || '3.0.0', enabled: existingClaudeFlow.enabled !== false, agentTeams: {
             enabled: true,
             teammateMode: 'auto',
             taskListEnabled: true,
@@ -324,20 +390,13 @@ function mergeSettingsForUpgrade(existing) {
                 autoAssignOnIdle: true,
                 trainPatternsOnComplete: true,
                 notifyLeadOnComplete: true,
-                sharedMemoryNamespace: 'agent-teams',
+                sharedMemoryNamespace: 'agent-teams'
             },
             hooks: {
                 teammateIdle: { enabled: true, autoAssign: true, checkTaskList: true },
-                taskCompleted: { enabled: true, trainPatterns: true, notifyLead: true },
-            },
-        },
-        memory: {
-            ...existingMemory,
-            learningBridge: existingMemory.learningBridge ?? { enabled: true },
-            memoryGraph: existingMemory.memoryGraph ?? { enabled: true },
-            agentScopes: existingMemory.agentScopes ?? { enabled: true },
-        },
-    };
+                taskCompleted: { enabled: true, trainPatterns: true, notifyLead: true }
+            }
+        }, memory: __assign(__assign({}, existingMemory), { learningBridge: (_a = existingMemory.learningBridge) !== null && _a !== void 0 ? _a : { enabled: true }, memoryGraph: (_b = existingMemory.memoryGraph) !== null && _b !== void 0 ? _b : { enabled: true }, agentScopes: (_c = existingMemory.agentScopes) !== null && _c !== void 0 ? _c : { enabled: true } }) });
     return merged;
 }
 /**
@@ -346,200 +405,190 @@ function mergeSettingsForUpgrade(existing) {
  * @param targetDir - Target directory
  * @param upgradeSettings - If true, merge new settings into existing settings.json
  */
-export async function executeUpgrade(targetDir, upgradeSettings = false) {
-    const result = {
-        success: true,
-        updated: [],
-        created: [],
-        preserved: [],
-        errors: [],
-        settingsUpdated: [],
-    };
-    try {
-        // Ensure required directories exist
-        const dirs = [
-            '.claude/helpers',
-            '.claude-flow/metrics',
-            '.claude-flow/security',
-            '.claude-flow/learning',
-        ];
-        for (const dir of dirs) {
-            const fullPath = path.join(targetDir, dir);
-            if (!fs.existsSync(fullPath)) {
-                fs.mkdirSync(fullPath, { recursive: true });
-            }
-        }
-        // 0. ALWAYS update critical helpers (force overwrite)
-        const sourceHelpersForUpgrade = findSourceHelpersDir();
-        if (sourceHelpersForUpgrade) {
-            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
-            for (const helperName of criticalHelpers) {
-                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
-                const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
-                if (fs.existsSync(sourcePath)) {
-                    if (fs.existsSync(targetPath)) {
-                        result.updated.push(`.claude/helpers/${helperName}`);
+export function executeUpgrade(targetDir, upgradeSettings) {
+    if (upgradeSettings === void 0) { upgradeSettings = false; }
+    return __awaiter(this, void 0, Promise, function () {
+        var result, dirs, _i, dirs_1, dir, fullPath, sourceHelpersForUpgrade, criticalHelpers, _a, criticalHelpers_1, helperName, targetPath, sourcePath, generatedCritical, _b, _c, _d, helperName, content, targetPath, statuslinePath, upgradeOptions, statuslineContent, metricsDir, securityDir, progressPath, progress, activityPath, activity, learningPath, learning, auditPath, audit, settingsPath, existingSettings, mergedSettings, defaultSettings;
+        return __generator(this, function (_e) {
+            result = {
+                success: true,
+                updated: [],
+                created: [],
+                preserved: [],
+                errors: [],
+                settingsUpdated: []
+            };
+            try {
+                dirs = [
+                    '.claude/helpers',
+                    '.claude-flow/metrics',
+                    '.claude-flow/security',
+                    '.claude-flow/learning',
+                ];
+                for (_i = 0, dirs_1 = dirs; _i < dirs_1.length; _i++) {
+                    dir = dirs_1[_i];
+                    fullPath = path.join(targetDir, dir);
+                    if (!fs.existsSync(fullPath)) {
+                        fs.mkdirSync(fullPath, { recursive: true });
                     }
-                    else {
-                        result.created.push(`.claude/helpers/${helperName}`);
+                }
+                sourceHelpersForUpgrade = findSourceHelpersDir();
+                if (sourceHelpersForUpgrade) {
+                    criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
+                    for (_a = 0, criticalHelpers_1 = criticalHelpers; _a < criticalHelpers_1.length; _a++) {
+                        helperName = criticalHelpers_1[_a];
+                        targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                        sourcePath = path.join(sourceHelpersForUpgrade, helperName);
+                        if (fs.existsSync(sourcePath)) {
+                            if (fs.existsSync(targetPath)) {
+                                result.updated.push(".claude/helpers/" + helperName);
+                            }
+                            else {
+                                result.created.push(".claude/helpers/" + helperName);
+                            }
+                            fs.copyFileSync(sourcePath, targetPath);
+                            try {
+                                fs.chmodSync(targetPath, '755');
+                            }
+                            catch (_f) { }
+                        }
                     }
-                    fs.copyFileSync(sourcePath, targetPath);
-                    try {
-                        fs.chmodSync(targetPath, '755');
+                }
+                else {
+                    generatedCritical = {
+                        'hook-handler.cjs': generateHookHandler(),
+                        'intelligence.cjs': generateIntelligenceStub(),
+                        'auto-memory-hook.mjs': generateAutoMemoryHook()
+                    };
+                    for (_b = 0, _c = Object.entries(generatedCritical); _b < _c.length; _b++) {
+                        _d = _c[_b], helperName = _d[0], content = _d[1];
+                        targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
+                        if (fs.existsSync(targetPath)) {
+                            result.updated.push(".claude/helpers/" + helperName);
+                        }
+                        else {
+                            result.created.push(".claude/helpers/" + helperName);
+                        }
+                        fs.writeFileSync(targetPath, content, 'utf-8');
+                        try {
+                            fs.chmodSync(targetPath, '755');
+                        }
+                        catch (_g) { }
                     }
-                    catch { }
                 }
-            }
-        }
-        else {
-            // Source not found (npx with broken paths) — use generated fallbacks
-            const generatedCritical = {
-                'hook-handler.cjs': generateHookHandler(),
-                'intelligence.cjs': generateIntelligenceStub(),
-                'auto-memory-hook.mjs': generateAutoMemoryHook(),
-            };
-            for (const [helperName, content] of Object.entries(generatedCritical)) {
-                const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
-                if (fs.existsSync(targetPath)) {
-                    result.updated.push(`.claude/helpers/${helperName}`);
+                statuslinePath = path.join(targetDir, '.claude', 'helpers', 'statusline.cjs');
+                upgradeOptions = __assign(__assign({}, DEFAULT_INIT_OPTIONS), { targetDir: targetDir, force: true, statusline: __assign(__assign({}, DEFAULT_INIT_OPTIONS.statusline), { refreshInterval: 5000 }) });
+                statuslineContent = generateStatuslineScript(upgradeOptions);
+                if (fs.existsSync(statuslinePath)) {
+                    result.updated.push('.claude/helpers/statusline.cjs');
                 }
                 else {
-                    result.created.push(`.claude/helpers/${helperName}`);
+                    result.created.push('.claude/helpers/statusline.cjs');
                 }
-                fs.writeFileSync(targetPath, content, 'utf-8');
-                try {
-                    fs.chmodSync(targetPath, '755');
+                fs.writeFileSync(statuslinePath, statuslineContent, 'utf-8');
+                metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
+                securityDir = path.join(targetDir, '.claude-flow', 'security');
+                progressPath = path.join(metricsDir, 'v3-progress.json');
+                if (!fs.existsSync(progressPath)) {
+                    progress = {
+                        version: '3.0.0',
+                        initialized: new Date().toISOString(),
+                        domains: { completed: 0, total: 5, status: 'INITIALIZING' },
+                        ddd: { progress: 0, modules: 0, totalFiles: 0, totalLines: 0 },
+                        swarm: { activeAgents: 0, maxAgents: 15, topology: 'hierarchical-mesh' },
+                        learning: { status: 'READY', patternsLearned: 0, sessionsCompleted: 0 },
+                        _note: 'Metrics will update as you use Ruflo'
+                    };
+                    fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
+                    result.created.push('.claude-flow/metrics/v3-progress.json');
                 }
-                catch { }
-            }
-        }
-        // 1. ALWAYS update statusline helper (force overwrite)
-        const statuslinePath = path.join(targetDir, '.claude', 'helpers', 'statusline.cjs');
-        // Use default options with statusline config
-        const upgradeOptions = {
-            ...DEFAULT_INIT_OPTIONS,
-            targetDir,
-            force: true,
-            statusline: {
-                ...DEFAULT_INIT_OPTIONS.statusline,
-                refreshInterval: 5000,
-            },
-        };
-        const statuslineContent = generateStatuslineScript(upgradeOptions);
-        if (fs.existsSync(statuslinePath)) {
-            result.updated.push('.claude/helpers/statusline.cjs');
-        }
-        else {
-            result.created.push('.claude/helpers/statusline.cjs');
-        }
-        fs.writeFileSync(statuslinePath, statuslineContent, 'utf-8');
-        // 2. Create MISSING metrics files only (preserve existing data)
-        const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
-        const securityDir = path.join(targetDir, '.claude-flow', 'security');
-        // v3-progress.json
-        const progressPath = path.join(metricsDir, 'v3-progress.json');
-        if (!fs.existsSync(progressPath)) {
-            const progress = {
-                version: '3.0.0',
-                initialized: new Date().toISOString(),
-                domains: { completed: 0, total: 5, status: 'INITIALIZING' },
-                ddd: { progress: 0, modules: 0, totalFiles: 0, totalLines: 0 },
-                swarm: { activeAgents: 0, maxAgents: 15, topology: 'hierarchical-mesh' },
-                learning: { status: 'READY', patternsLearned: 0, sessionsCompleted: 0 },
-                _note: 'Metrics will update as you use KynjalFlow'
-            };
-            fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/v3-progress.json');
-        }
-        else {
-            result.preserved.push('.claude-flow/metrics/v3-progress.json');
-        }
-        // swarm-activity.json
-        const activityPath = path.join(metricsDir, 'swarm-activity.json');
-        if (!fs.existsSync(activityPath)) {
-            const activity = {
-                timestamp: new Date().toISOString(),
-                processes: { agentic_flow: 0, mcp_server: 0, estimated_agents: 0 },
-                swarm: { active: false, agent_count: 0, coordination_active: false },
-                integration: { agentic_flow_active: false, mcp_active: false },
-                _initialized: true
-            };
-            fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/swarm-activity.json');
-        }
-        else {
-            result.preserved.push('.claude-flow/metrics/swarm-activity.json');
-        }
-        // learning.json
-        const learningPath = path.join(metricsDir, 'learning.json');
-        if (!fs.existsSync(learningPath)) {
-            const learning = {
-                initialized: new Date().toISOString(),
-                routing: { accuracy: 0, decisions: 0 },
-                patterns: { shortTerm: 0, longTerm: 0, quality: 0 },
-                sessions: { total: 0, current: null },
-                _note: 'Intelligence grows as you use KynjalFlow'
-            };
-            fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
-            result.created.push('.claude-flow/metrics/learning.json');
-        }
-        else {
-            result.preserved.push('.claude-flow/metrics/learning.json');
-        }
-        // audit-status.json
-        const auditPath = path.join(securityDir, 'audit-status.json');
-        if (!fs.existsSync(auditPath)) {
-            const audit = {
-                initialized: new Date().toISOString(),
-                status: 'PENDING',
-                cvesFixed: 0,
-                totalCves: 3,
-                lastScan: null,
-                _note: 'Run: npx @kynjal/cli@latest security scan'
-            };
-            fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
-            result.created.push('.claude-flow/security/audit-status.json');
-        }
-        else {
-            result.preserved.push('.claude-flow/security/audit-status.json');
-        }
-        // 3. Merge settings if requested
-        if (upgradeSettings) {
-            const settingsPath = path.join(targetDir, '.claude', 'settings.json');
-            if (fs.existsSync(settingsPath)) {
-                try {
-                    const existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                    const mergedSettings = mergeSettingsForUpgrade(existingSettings);
-                    fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
-                    result.updated.push('.claude/settings.json');
-                    result.settingsUpdated = [
-                        'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
-                        'hooks.SessionStart (auto-memory import)',
-                        'hooks.SessionEnd (auto-memory sync)',
-                        'hooks.TeammateIdle',
-                        'hooks.TaskCompleted',
-                        'claudeFlow.agentTeams',
-                        'claudeFlow.memory (learningBridge, memoryGraph, agentScopes)',
-                    ];
+                else {
+                    result.preserved.push('.claude-flow/metrics/v3-progress.json');
+                }
+                activityPath = path.join(metricsDir, 'swarm-activity.json');
+                if (!fs.existsSync(activityPath)) {
+                    activity = {
+                        timestamp: new Date().toISOString(),
+                        processes: { agentic_flow: 0, mcp_server: 0, estimated_agents: 0 },
+                        swarm: { active: false, agent_count: 0, coordination_active: false },
+                        integration: { agentic_flow_active: false, mcp_active: false },
+                        _initialized: true
+                    };
+                    fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
+                    result.created.push('.claude-flow/metrics/swarm-activity.json');
+                }
+                else {
+                    result.preserved.push('.claude-flow/metrics/swarm-activity.json');
+                }
+                learningPath = path.join(metricsDir, 'learning.json');
+                if (!fs.existsSync(learningPath)) {
+                    learning = {
+                        initialized: new Date().toISOString(),
+                        routing: { accuracy: 0, decisions: 0 },
+                        patterns: { shortTerm: 0, longTerm: 0, quality: 0 },
+                        sessions: { total: 0, current: null },
+                        _note: 'Intelligence grows as you use Ruflo'
+                    };
+                    fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
+                    result.created.push('.claude-flow/metrics/learning.json');
+                }
+                else {
+                    result.preserved.push('.claude-flow/metrics/learning.json');
+                }
+                auditPath = path.join(securityDir, 'audit-status.json');
+                if (!fs.existsSync(auditPath)) {
+                    audit = {
+                        initialized: new Date().toISOString(),
+                        status: 'PENDING',
+                        cvesFixed: 0,
+                        totalCves: 3,
+                        lastScan: null,
+                        _note: 'Run: npx @claude-flow/cli@latest security scan'
+                    };
+                    fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
+                    result.created.push('.claude-flow/security/audit-status.json');
                 }
-                catch (settingsError) {
-                    result.errors.push(`Settings merge failed: ${settingsError instanceof Error ? settingsError.message : String(settingsError)}`);
+                else {
+                    result.preserved.push('.claude-flow/security/audit-status.json');
+                }
+                // 3. Merge settings if requested
+                if (upgradeSettings) {
+                    settingsPath = path.join(targetDir, '.claude', 'settings.json');
+                    if (fs.existsSync(settingsPath)) {
+                        try {
+                            existingSettings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                            mergedSettings = mergeSettingsForUpgrade(existingSettings);
+                            fs.writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2), 'utf-8');
+                            result.updated.push('.claude/settings.json');
+                            result.settingsUpdated = [
+                                'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS',
+                                'hooks.SessionStart (auto-memory import)',
+                                'hooks.SessionEnd (auto-memory sync)',
+                                'hooks.TeammateIdle (removed — not a valid Claude Code hook)',
+                                'hooks.TaskCompleted (removed — not a valid Claude Code hook)',
+                                'claudeFlow.agentTeams',
+                                'claudeFlow.memory (learningBridge, memoryGraph, agentScopes)',
+                            ];
+                        }
+                        catch (settingsError) {
+                            result.errors.push("Settings merge failed: " + (settingsError instanceof Error ? settingsError.message : String(settingsError)));
+                        }
+                    }
+                    else {
+                        defaultSettings = generateSettings(DEFAULT_INIT_OPTIONS);
+                        fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2), 'utf-8');
+                        result.created.push('.claude/settings.json');
+                        result.settingsUpdated = ['Created new settings.json with Agent Teams'];
+                    }
                 }
             }
-            else {
-                // Create new settings.json with defaults
-                const defaultSettings = generateSettings(DEFAULT_INIT_OPTIONS);
-                fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2), 'utf-8');
-                result.created.push('.claude/settings.json');
-                result.settingsUpdated = ['Created new settings.json with Agent Teams'];
+            catch (error) {
+                result.success = false;
+                result.errors.push(error instanceof Error ? error.message : String(error));
             }
-        }
-    }
-    catch (error) {
-        result.success = false;
-        result.errors.push(error instanceof Error ? error.message : String(error));
-    }
-    return result;
+            return [2 /*return*/, result];
+        });
+    });
 }
 /**
  * Execute upgrade with --add-missing flag
@@ -547,308 +596,351 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
  * @param targetDir - Target directory
  * @param upgradeSettings - If true, merge new settings into existing settings.json
  */
-export async function executeUpgradeWithMissing(targetDir, upgradeSettings = false) {
-    // First do the normal upgrade (pass through upgradeSettings)
-    const result = await executeUpgrade(targetDir, upgradeSettings);
-    if (!result.success) {
-        return result;
-    }
-    // Initialize tracking arrays
-    result.addedSkills = [];
-    result.addedAgents = [];
-    result.addedCommands = [];
-    try {
-        // Ensure target directories exist
-        const skillsDir = path.join(targetDir, '.claude', 'skills');
-        const agentsDir = path.join(targetDir, '.claude', 'agents');
-        const commandsDir = path.join(targetDir, '.claude', 'commands');
-        for (const dir of [skillsDir, agentsDir, commandsDir]) {
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-        }
-        // Find source directories
-        const sourceSkillsDir = findSourceDir('skills');
-        const sourceAgentsDir = findSourceDir('agents');
-        const sourceCommandsDir = findSourceDir('commands');
-        // Debug: Log source directories found
-        if (process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG) {
-            console.log('[DEBUG] Source directories:');
-            console.log(`  Skills: ${sourceSkillsDir || 'NOT FOUND'}`);
-            console.log(`  Agents: ${sourceAgentsDir || 'NOT FOUND'}`);
-            console.log(`  Commands: ${sourceCommandsDir || 'NOT FOUND'}`);
-        }
-        // Add missing skills
-        if (sourceSkillsDir) {
-            const allSkills = Object.values(SKILLS_MAP).flat();
-            const debugMode = process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG;
-            if (debugMode) {
-                console.log(`[DEBUG] Checking ${allSkills.length} skills from SKILLS_MAP`);
-            }
-            for (const skillName of [...new Set(allSkills)]) {
-                const sourcePath = path.join(sourceSkillsDir, skillName);
-                const targetPath = path.join(skillsDir, skillName);
-                const sourceExists = fs.existsSync(sourcePath);
-                const targetExists = fs.existsSync(targetPath);
-                if (debugMode) {
-                    console.log(`[DEBUG] Skill '${skillName}': source=${sourceExists}, target=${targetExists}`);
-                }
-                if (sourceExists && !targetExists) {
-                    copyDirRecursive(sourcePath, targetPath);
-                    result.addedSkills.push(skillName);
-                    result.created.push(`.claude/skills/${skillName}`);
-                }
-            }
-        }
-        // Add missing agents
-        if (sourceAgentsDir) {
-            const allAgents = Object.values(AGENTS_MAP).flat();
-            for (const agentCategory of [...new Set(allAgents)]) {
-                const sourcePath = path.join(sourceAgentsDir, agentCategory);
-                const targetPath = path.join(agentsDir, agentCategory);
-                if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
-                    copyDirRecursive(sourcePath, targetPath);
-                    result.addedAgents.push(agentCategory);
-                    result.created.push(`.claude/agents/${agentCategory}`);
-                }
-            }
-        }
-        // Add missing commands
-        if (sourceCommandsDir) {
-            const allCommands = Object.values(COMMANDS_MAP).flat();
-            for (const cmdName of [...new Set(allCommands)]) {
-                const sourcePath = path.join(sourceCommandsDir, cmdName);
-                const targetPath = path.join(commandsDir, cmdName);
-                if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
-                    if (fs.statSync(sourcePath).isDirectory()) {
-                        copyDirRecursive(sourcePath, targetPath);
+export function executeUpgradeWithMissing(targetDir, upgradeSettings) {
+    if (upgradeSettings === void 0) { upgradeSettings = false; }
+    return __awaiter(this, void 0, Promise, function () {
+        var result, skillsDir, agentsDir, commandsDir, _i, _a, dir, sourceSkillsDir, sourceAgentsDir, sourceCommandsDir, allSkills, debugMode, _b, _c, skillName, sourcePath, targetPath, sourceExists, targetExists, allAgents, _d, _e, agentCategory, sourcePath, targetPath, allCommands, _f, _g, cmdName, sourcePath, targetPath;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0: return [4 /*yield*/, executeUpgrade(targetDir, upgradeSettings)];
+                case 1:
+                    result = _h.sent();
+                    if (!result.success) {
+                        return [2 /*return*/, result];
                     }
-                    else {
-                        fs.copyFileSync(sourcePath, targetPath);
+                    // Initialize tracking arrays
+                    result.addedSkills = [];
+                    result.addedAgents = [];
+                    result.addedCommands = [];
+                    try {
+                        skillsDir = path.join(targetDir, '.claude', 'skills');
+                        agentsDir = path.join(targetDir, '.claude', 'agents');
+                        commandsDir = path.join(targetDir, '.claude', 'commands');
+                        for (_i = 0, _a = [skillsDir, agentsDir, commandsDir]; _i < _a.length; _i++) {
+                            dir = _a[_i];
+                            if (!fs.existsSync(dir)) {
+                                fs.mkdirSync(dir, { recursive: true });
+                            }
+                        }
+                        sourceSkillsDir = findSourceDir('skills');
+                        sourceAgentsDir = findSourceDir('agents');
+                        sourceCommandsDir = findSourceDir('commands');
+                        // Debug: Log source directories found
+                        if (process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG) {
+                            console.log('[DEBUG] Source directories:');
+                            console.log("  Skills: " + (sourceSkillsDir || 'NOT FOUND'));
+                            console.log("  Agents: " + (sourceAgentsDir || 'NOT FOUND'));
+                            console.log("  Commands: " + (sourceCommandsDir || 'NOT FOUND'));
+                        }
+                        // Add missing skills
+                        if (sourceSkillsDir) {
+                            allSkills = Object.values(SKILLS_MAP).flat();
+                            debugMode = process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG;
+                            if (debugMode) {
+                                console.log("[DEBUG] Checking " + allSkills.length + " skills from SKILLS_MAP");
+                            }
+                            for (_b = 0, _c = __spreadArray([], new Set(allSkills), true); _b < _c.length; _b++) {
+                                skillName = _c[_b];
+                                sourcePath = path.join(sourceSkillsDir, skillName);
+                                targetPath = path.join(skillsDir, skillName);
+                                sourceExists = fs.existsSync(sourcePath);
+                                targetExists = fs.existsSync(targetPath);
+                                if (debugMode) {
+                                    console.log("[DEBUG] Skill '" + skillName + "': source=" + sourceExists + ", target=" + targetExists);
+                                }
+                                if (sourceExists && !targetExists) {
+                                    copyDirRecursive(sourcePath, targetPath);
+                                    result.addedSkills.push(skillName);
+                                    result.created.push(".claude/skills/" + skillName);
+                                }
+                            }
+                        }
+                        // Add missing agents
+                        if (sourceAgentsDir) {
+                            allAgents = Object.values(AGENTS_MAP).flat();
+                            for (_d = 0, _e = __spreadArray([], new Set(allAgents), true); _d < _e.length; _d++) {
+                                agentCategory = _e[_d];
+                                sourcePath = path.join(sourceAgentsDir, agentCategory);
+                                targetPath = path.join(agentsDir, agentCategory);
+                                if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
+                                    copyDirRecursive(sourcePath, targetPath);
+                                    result.addedAgents.push(agentCategory);
+                                    result.created.push(".claude/agents/" + agentCategory);
+                                }
+                            }
+                        }
+                        // Add missing commands
+                        if (sourceCommandsDir) {
+                            allCommands = Object.values(COMMANDS_MAP).flat();
+                            for (_f = 0, _g = __spreadArray([], new Set(allCommands), true); _f < _g.length; _f++) {
+                                cmdName = _g[_f];
+                                sourcePath = path.join(sourceCommandsDir, cmdName);
+                                targetPath = path.join(commandsDir, cmdName);
+                                if (fs.existsSync(sourcePath) && !fs.existsSync(targetPath)) {
+                                    if (fs.statSync(sourcePath).isDirectory()) {
+                                        copyDirRecursive(sourcePath, targetPath);
+                                    }
+                                    else {
+                                        fs.copyFileSync(sourcePath, targetPath);
+                                    }
+                                    result.addedCommands.push(cmdName);
+                                    result.created.push(".claude/commands/" + cmdName);
+                                }
+                            }
+                        }
                     }
-                    result.addedCommands.push(cmdName);
-                    result.created.push(`.claude/commands/${cmdName}`);
-                }
+                    catch (error) {
+                        result.errors.push("Add missing failed: " + (error instanceof Error ? error.message : String(error)));
+                    }
+                    return [2 /*return*/, result];
             }
-        }
-    }
-    catch (error) {
-        result.errors.push(`Add missing failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return result;
+        });
+    });
 }
 /**
  * Create directory structure
  */
-async function createDirectories(targetDir, options, result) {
-    const dirs = [
-        ...DIRECTORIES.claude,
-        ...(options.components.runtime ? DIRECTORIES.runtime : []),
-    ];
-    for (const dir of dirs) {
-        const fullPath = path.join(targetDir, dir);
-        if (!fs.existsSync(fullPath)) {
-            fs.mkdirSync(fullPath, { recursive: true });
-            result.created.directories.push(dir);
-        }
-    }
+function createDirectories(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var dirs, _i, dirs_2, dir, fullPath;
+        return __generator(this, function (_a) {
+            dirs = __spreadArray(__spreadArray([], DIRECTORIES.claude, true), (options.components.runtime ? DIRECTORIES.runtime : []), true);
+            for (_i = 0, dirs_2 = dirs; _i < dirs_2.length; _i++) {
+                dir = dirs_2[_i];
+                fullPath = path.join(targetDir, dir);
+                if (!fs.existsSync(fullPath)) {
+                    fs.mkdirSync(fullPath, { recursive: true });
+                    result.created.directories.push(dir);
+                }
+            }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Write settings.json
  */
-async function writeSettings(targetDir, options, result) {
-    const settingsPath = path.join(targetDir, '.claude', 'settings.json');
-    if (fs.existsSync(settingsPath) && !options.force) {
-        result.skipped.push('.claude/settings.json');
-        return;
-    }
-    const content = generateSettingsJson(options);
-    fs.writeFileSync(settingsPath, content, 'utf-8');
-    result.created.files.push('.claude/settings.json');
+function writeSettings(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var settingsPath, content;
+        return __generator(this, function (_a) {
+            settingsPath = path.join(targetDir, '.claude', 'settings.json');
+            if (fs.existsSync(settingsPath) && !options.force) {
+                result.skipped.push('.claude/settings.json');
+                return [2 /*return*/];
+            }
+            content = generateSettingsJson(options);
+            fs.writeFileSync(settingsPath, content, 'utf-8');
+            result.created.files.push('.claude/settings.json');
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Write .mcp.json
  */
-async function writeMCPConfig(targetDir, options, result) {
-    const mcpPath = path.join(targetDir, '.mcp.json');
-    if (fs.existsSync(mcpPath) && !options.force) {
-        result.skipped.push('.mcp.json');
-        return;
-    }
-    const content = generateMCPJson(options);
-    fs.writeFileSync(mcpPath, content, 'utf-8');
-    result.created.files.push('.mcp.json');
+function writeMCPConfig(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var mcpPath, content;
+        return __generator(this, function (_a) {
+            mcpPath = path.join(targetDir, '.mcp.json');
+            if (fs.existsSync(mcpPath) && !options.force) {
+                result.skipped.push('.mcp.json');
+                return [2 /*return*/];
+            }
+            content = generateMCPJson(options);
+            fs.writeFileSync(mcpPath, content, 'utf-8');
+            result.created.files.push('.mcp.json');
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Copy skills from source
  */
-async function copySkills(targetDir, options, result) {
-    const skillsConfig = options.skills;
-    const targetSkillsDir = path.join(targetDir, '.claude', 'skills');
-    // Determine which skills to copy
-    const skillsToCopy = [];
-    if (skillsConfig.all) {
-        // Copy all available skills
-        Object.values(SKILLS_MAP).forEach(skills => skillsToCopy.push(...skills));
-    }
-    else {
-        if (skillsConfig.core)
-            skillsToCopy.push(...SKILLS_MAP.core);
-        if (skillsConfig.agentdb)
-            skillsToCopy.push(...SKILLS_MAP.agentdb);
-        if (skillsConfig.github)
-            skillsToCopy.push(...SKILLS_MAP.github);
-        if (skillsConfig.flowNexus)
-            skillsToCopy.push(...SKILLS_MAP.flowNexus);
-        if (skillsConfig.browser)
-            skillsToCopy.push(...SKILLS_MAP.browser);
-        if (skillsConfig.v3)
-            skillsToCopy.push(...SKILLS_MAP.v3);
-        if (skillsConfig.dualMode)
-            skillsToCopy.push(...SKILLS_MAP.dualMode);
-    }
-    // Find source skills directory
-    const sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
-    if (!sourceSkillsDir) {
-        result.errors.push('Could not find source skills directory');
-        return;
-    }
-    // Copy each skill
-    for (const skillName of [...new Set(skillsToCopy)]) {
-        const sourcePath = path.join(sourceSkillsDir, skillName);
-        const targetPath = path.join(targetSkillsDir, skillName);
-        if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                copyDirRecursive(sourcePath, targetPath);
-                result.created.files.push(`.claude/skills/${skillName}`);
-                result.summary.skillsCount++;
+function copySkills(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var skillsConfig, targetSkillsDir, skillsToCopy, sourceSkillsDir, _i, _a, skillName, sourcePath, targetPath;
+        return __generator(this, function (_b) {
+            skillsConfig = options.skills;
+            targetSkillsDir = path.join(targetDir, '.claude', 'skills');
+            skillsToCopy = [];
+            if (skillsConfig.all) {
+                // Copy all available skills
+                Object.values(SKILLS_MAP).forEach(function (skills) { return skillsToCopy.push.apply(skillsToCopy, skills); });
             }
             else {
-                result.skipped.push(`.claude/skills/${skillName}`);
+                if (skillsConfig.core)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.core);
+                if (skillsConfig.agentdb)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.agentdb);
+                if (skillsConfig.github)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.github);
+                if (skillsConfig.flowNexus)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.flowNexus);
+                if (skillsConfig.browser)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.browser);
+                if (skillsConfig.v3)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.v3);
+                if (skillsConfig.dualMode)
+                    skillsToCopy.push.apply(skillsToCopy, SKILLS_MAP.dualMode);
+                if (skillsConfig.design)
+                    skillsToCopy.push.apply(skillsToCopy, (SKILLS_MAP.design || []));
             }
-        }
-    }
+            sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
+            if (!sourceSkillsDir) {
+                result.errors.push('Could not find source skills directory');
+                return [2 /*return*/];
+            }
+            // Copy each skill
+            for (_i = 0, _a = __spreadArray([], new Set(skillsToCopy), true); _i < _a.length; _i++) {
+                skillName = _a[_i];
+                sourcePath = path.join(sourceSkillsDir, skillName);
+                targetPath = path.join(targetSkillsDir, skillName);
+                if (fs.existsSync(sourcePath)) {
+                    if (!fs.existsSync(targetPath) || options.force) {
+                        copyDirRecursive(sourcePath, targetPath);
+                        result.created.files.push(".claude/skills/" + skillName);
+                        result.summary.skillsCount++;
+                    }
+                    else {
+                        result.skipped.push(".claude/skills/" + skillName);
+                    }
+                }
+            }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Copy commands from source
  */
-async function copyCommands(targetDir, options, result) {
-    const commandsConfig = options.commands;
-    const targetCommandsDir = path.join(targetDir, '.claude', 'commands');
-    // Determine which commands to copy
-    const commandsToCopy = [];
-    if (commandsConfig.all) {
-        Object.values(COMMANDS_MAP).forEach(cmds => commandsToCopy.push(...cmds));
-    }
-    else {
-        if (commandsConfig.core)
-            commandsToCopy.push(...COMMANDS_MAP.core);
-        if (commandsConfig.analysis)
-            commandsToCopy.push(...COMMANDS_MAP.analysis);
-        if (commandsConfig.automation)
-            commandsToCopy.push(...COMMANDS_MAP.automation);
-        if (commandsConfig.github)
-            commandsToCopy.push(...COMMANDS_MAP.github);
-        if (commandsConfig.hooks)
-            commandsToCopy.push(...COMMANDS_MAP.hooks);
-        if (commandsConfig.monitoring)
-            commandsToCopy.push(...COMMANDS_MAP.monitoring);
-        if (commandsConfig.optimization)
-            commandsToCopy.push(...COMMANDS_MAP.optimization);
-        if (commandsConfig.sparc)
-            commandsToCopy.push(...COMMANDS_MAP.sparc);
-    }
-    // Find source commands directory
-    const sourceCommandsDir = findSourceDir('commands', options.sourceBaseDir);
-    if (!sourceCommandsDir) {
-        result.errors.push('Could not find source commands directory');
-        return;
-    }
-    // Copy each command/directory
-    for (const cmdName of [...new Set(commandsToCopy)]) {
-        const sourcePath = path.join(sourceCommandsDir, cmdName);
-        const targetPath = path.join(targetCommandsDir, cmdName);
-        if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                if (fs.statSync(sourcePath).isDirectory()) {
-                    copyDirRecursive(sourcePath, targetPath);
-                }
-                else {
-                    fs.copyFileSync(sourcePath, targetPath);
-                }
-                result.created.files.push(`.claude/commands/${cmdName}`);
-                result.summary.commandsCount++;
+function copyCommands(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var commandsConfig, targetCommandsDir, commandsToCopy, sourceCommandsDir, _i, _a, cmdName, sourcePath, targetPath;
+        return __generator(this, function (_b) {
+            commandsConfig = options.commands;
+            targetCommandsDir = path.join(targetDir, '.claude', 'commands');
+            commandsToCopy = [];
+            if (commandsConfig.all) {
+                Object.values(COMMANDS_MAP).forEach(function (cmds) { return commandsToCopy.push.apply(commandsToCopy, cmds); });
             }
             else {
-                result.skipped.push(`.claude/commands/${cmdName}`);
+                if (commandsConfig.core)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.core);
+                if (commandsConfig.analysis)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.analysis);
+                if (commandsConfig.automation)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.automation);
+                if (commandsConfig.github)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.github);
+                if (commandsConfig.hooks)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.hooks);
+                if (commandsConfig.monitoring)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.monitoring);
+                if (commandsConfig.optimization)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.optimization);
+                if (commandsConfig.sparc)
+                    commandsToCopy.push.apply(commandsToCopy, COMMANDS_MAP.sparc);
             }
-        }
-    }
+            sourceCommandsDir = findSourceDir('commands', options.sourceBaseDir);
+            if (!sourceCommandsDir) {
+                result.errors.push('Could not find source commands directory');
+                return [2 /*return*/];
+            }
+            // Copy each command/directory
+            for (_i = 0, _a = __spreadArray([], new Set(commandsToCopy), true); _i < _a.length; _i++) {
+                cmdName = _a[_i];
+                sourcePath = path.join(sourceCommandsDir, cmdName);
+                targetPath = path.join(targetCommandsDir, cmdName);
+                if (fs.existsSync(sourcePath)) {
+                    if (!fs.existsSync(targetPath) || options.force) {
+                        if (fs.statSync(sourcePath).isDirectory()) {
+                            copyDirRecursive(sourcePath, targetPath);
+                        }
+                        else {
+                            fs.copyFileSync(sourcePath, targetPath);
+                        }
+                        result.created.files.push(".claude/commands/" + cmdName);
+                        result.summary.commandsCount++;
+                    }
+                    else {
+                        result.skipped.push(".claude/commands/" + cmdName);
+                    }
+                }
+            }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Copy agents from source
  */
-async function copyAgents(targetDir, options, result) {
-    const agentsConfig = options.agents;
-    const targetAgentsDir = path.join(targetDir, '.claude', 'agents');
-    // Determine which agents to copy
-    const agentsToCopy = [];
-    if (agentsConfig.all) {
-        Object.values(AGENTS_MAP).forEach(agents => agentsToCopy.push(...agents));
-    }
-    else {
-        if (agentsConfig.core)
-            agentsToCopy.push(...AGENTS_MAP.core);
-        if (agentsConfig.consensus)
-            agentsToCopy.push(...AGENTS_MAP.consensus);
-        if (agentsConfig.github)
-            agentsToCopy.push(...AGENTS_MAP.github);
-        if (agentsConfig.hiveMind)
-            agentsToCopy.push(...AGENTS_MAP.hiveMind);
-        if (agentsConfig.sparc)
-            agentsToCopy.push(...AGENTS_MAP.sparc);
-        if (agentsConfig.swarm)
-            agentsToCopy.push(...AGENTS_MAP.swarm);
-        if (agentsConfig.browser)
-            agentsToCopy.push(...AGENTS_MAP.browser);
-        // V3-specific agent categories
-        if (agentsConfig.v3)
-            agentsToCopy.push(...(AGENTS_MAP.v3 || []));
-        if (agentsConfig.optimization)
-            agentsToCopy.push(...(AGENTS_MAP.optimization || []));
-        if (agentsConfig.testing)
-            agentsToCopy.push(...(AGENTS_MAP.testing || []));
-        // Dual-mode agents (Claude Code + Codex hybrid)
-        if (agentsConfig.dualMode)
-            agentsToCopy.push(...(AGENTS_MAP.dualMode || []));
-        // Custom agents (always included)
-        if (agentsConfig.custom !== false)
-            agentsToCopy.push(...(AGENTS_MAP.custom || []));
-    }
-    // Find source agents directory
-    const sourceAgentsDir = findSourceDir('agents', options.sourceBaseDir);
-    if (!sourceAgentsDir) {
-        result.errors.push('Could not find source agents directory');
-        return;
-    }
-    // Copy each agent category
-    for (const agentCategory of [...new Set(agentsToCopy)]) {
-        const sourcePath = path.join(sourceAgentsDir, agentCategory);
-        const targetPath = path.join(targetAgentsDir, agentCategory);
-        if (fs.existsSync(sourcePath)) {
-            if (!fs.existsSync(targetPath) || options.force) {
-                copyDirRecursive(sourcePath, targetPath);
-                // Count agent files (.yaml and .md)
-                const yamlFiles = countFiles(sourcePath, '.yaml');
-                const mdFiles = countFiles(sourcePath, '.md');
-                result.summary.agentsCount += yamlFiles + mdFiles;
-                result.created.files.push(`.claude/agents/${agentCategory}`);
+function copyAgents(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var agentsConfig, targetAgentsDir, agentsToCopy, sourceAgentsDir, _i, _a, agentCategory, sourcePath, targetPath, yamlFiles, mdFiles;
+        return __generator(this, function (_b) {
+            agentsConfig = options.agents;
+            targetAgentsDir = path.join(targetDir, '.claude', 'agents');
+            agentsToCopy = [];
+            if (agentsConfig.all) {
+                Object.values(AGENTS_MAP).forEach(function (agents) { return agentsToCopy.push.apply(agentsToCopy, agents); });
             }
             else {
-                result.skipped.push(`.claude/agents/${agentCategory}`);
+                if (agentsConfig.core)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.core);
+                if (agentsConfig.consensus)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.consensus);
+                if (agentsConfig.github)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.github);
+                if (agentsConfig.hiveMind)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.hiveMind);
+                if (agentsConfig.sparc)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.sparc);
+                if (agentsConfig.swarm)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.swarm);
+                if (agentsConfig.browser)
+                    agentsToCopy.push.apply(agentsToCopy, AGENTS_MAP.browser);
+                // V3-specific agent categories
+                if (agentsConfig.v3)
+                    agentsToCopy.push.apply(agentsToCopy, (AGENTS_MAP.v3 || []));
+                if (agentsConfig.optimization)
+                    agentsToCopy.push.apply(agentsToCopy, (AGENTS_MAP.optimization || []));
+                if (agentsConfig.testing)
+                    agentsToCopy.push.apply(agentsToCopy, (AGENTS_MAP.testing || []));
+                // Design agents (design-architect, ux-researcher, ui-developer, accessibility-auditor)
+                if (agentsConfig.design)
+                    agentsToCopy.push.apply(agentsToCopy, (AGENTS_MAP.design || []));
+                // Dual-mode agents (Claude Code + Codex hybrid)
+                if (agentsConfig.dualMode)
+                    agentsToCopy.push.apply(agentsToCopy, (AGENTS_MAP.dualMode || []));
             }
-        }
-    }
+            sourceAgentsDir = findSourceDir('agents', options.sourceBaseDir);
+            if (!sourceAgentsDir) {
+                result.errors.push('Could not find source agents directory');
+                return [2 /*return*/];
+            }
+            // Copy each agent category
+            for (_i = 0, _a = __spreadArray([], new Set(agentsToCopy), true); _i < _a.length; _i++) {
+                agentCategory = _a[_i];
+                sourcePath = path.join(sourceAgentsDir, agentCategory);
+                targetPath = path.join(targetAgentsDir, agentCategory);
+                if (fs.existsSync(sourcePath)) {
+                    if (!fs.existsSync(targetPath) || options.force) {
+                        copyDirRecursive(sourcePath, targetPath);
+                        yamlFiles = countFiles(sourcePath, '.yaml');
+                        mdFiles = countFiles(sourcePath, '.md');
+                        result.summary.agentsCount += yamlFiles + mdFiles;
+                        result.created.files.push(".claude/agents/" + agentCategory);
+                    }
+                    else {
+                        result.skipped.push(".claude/agents/" + agentCategory);
+                    }
+                }
+            }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Find source helpers directory.
@@ -856,45 +948,46 @@ async function copyAgents(targetDir, options, result) {
  * returning the target directory or an incomplete source.
  */
 function findSourceHelpersDir(sourceBaseDir) {
-    const possiblePaths = [];
-    const SENTINEL_FILE = 'hook-handler.cjs'; // Must exist in valid source
+    var possiblePaths = [];
+    var SENTINEL_FILE = 'hook-handler.cjs'; // Must exist in valid source
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
         possiblePaths.push(path.join(sourceBaseDir, '.claude', 'helpers'));
     }
     // Strategy 1: require.resolve to find package root (most reliable for npx)
     try {
-        const esmRequire = createRequire(import.meta.url);
-        const pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
-        const pkgRoot = path.dirname(pkgJsonPath);
+        var esmRequire = createRequire(import.meta.url);
+        var pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
+        var pkgRoot = path.dirname(pkgJsonPath);
         possiblePaths.push(path.join(pkgRoot, '.claude', 'helpers'));
     }
-    catch {
+    catch (_a) {
         // Not installed as a package — skip
     }
     // Strategy 2: __dirname-based (dist/src/init -> package root)
-    const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageHelpers = path.join(packageRoot, '.claude', 'helpers');
+    var packageRoot = path.resolve(__dirname, '..', '..', '..');
+    var packageHelpers = path.join(packageRoot, '.claude', 'helpers');
     possiblePaths.push(packageHelpers);
     // Strategy 3: Walk up from __dirname looking for package root
-    let currentDir = __dirname;
-    for (let i = 0; i < 10; i++) {
-        const parentDir = path.dirname(currentDir);
+    var currentDir = __dirname;
+    for (var i = 0; i < 10; i++) {
+        var parentDir = path.dirname(currentDir);
         if (parentDir === currentDir)
             break; // hit filesystem root
-        const helpersPath = path.join(parentDir, '.claude', 'helpers');
+        var helpersPath = path.join(parentDir, '.claude', 'helpers');
         possiblePaths.push(helpersPath);
         currentDir = parentDir;
     }
     // Strategy 4: Check cwd-relative paths (for local dev)
-    const cwdBased = [
+    var cwdBased = [
         path.join(process.cwd(), '.claude', 'helpers'),
         path.join(process.cwd(), '..', '.claude', 'helpers'),
         path.join(process.cwd(), '..', '..', '.claude', 'helpers'),
     ];
-    possiblePaths.push(...cwdBased);
+    possiblePaths.push.apply(possiblePaths, cwdBased);
     // Return first path that exists AND contains the sentinel file
-    for (const p of possiblePaths) {
+    for (var _i = 0, possiblePaths_1 = possiblePaths; _i < possiblePaths_1.length; _i++) {
+        var p = possiblePaths_1[_i];
         if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
             return p;
         }
@@ -904,90 +997,97 @@ function findSourceHelpersDir(sourceBaseDir) {
 /**
  * Write helper scripts
  */
-async function writeHelpers(targetDir, options, result) {
-    const helpersDir = path.join(targetDir, '.claude', 'helpers');
-    // Find source helpers directory (works for npm package and local dev)
-    const sourceHelpersDir = findSourceHelpersDir(options.sourceBaseDir);
-    // Try to copy existing helpers from source first
-    if (sourceHelpersDir && fs.existsSync(sourceHelpersDir)) {
-        const helperFiles = fs.readdirSync(sourceHelpersDir);
-        let copiedCount = 0;
-        for (const file of helperFiles) {
-            const sourcePath = path.join(sourceHelpersDir, file);
-            const destPath = path.join(helpersDir, file);
-            // Skip directories and only copy files
-            if (!fs.statSync(sourcePath).isFile())
-                continue;
-            if (!fs.existsSync(destPath) || options.force) {
-                fs.copyFileSync(sourcePath, destPath);
-                // Make shell scripts and mjs files executable
-                if (file.endsWith('.sh') || file.endsWith('.mjs')) {
-                    fs.chmodSync(destPath, '755');
+function writeHelpers(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var helpersDir, sourceHelpersDir, helperFiles, copiedCount, _i, helperFiles_1, file, sourcePath, destPath, helpers, _a, _b, _c, name, content, filePath;
+        return __generator(this, function (_d) {
+            helpersDir = path.join(targetDir, '.claude', 'helpers');
+            sourceHelpersDir = findSourceHelpersDir(options.sourceBaseDir);
+            // Try to copy existing helpers from source first
+            if (sourceHelpersDir && fs.existsSync(sourceHelpersDir)) {
+                helperFiles = fs.readdirSync(sourceHelpersDir);
+                copiedCount = 0;
+                for (_i = 0, helperFiles_1 = helperFiles; _i < helperFiles_1.length; _i++) {
+                    file = helperFiles_1[_i];
+                    sourcePath = path.join(sourceHelpersDir, file);
+                    destPath = path.join(helpersDir, file);
+                    // Skip directories and only copy files
+                    if (!fs.statSync(sourcePath).isFile())
+                        continue;
+                    if (!fs.existsSync(destPath) || options.force) {
+                        fs.copyFileSync(sourcePath, destPath);
+                        // Make shell scripts and mjs files executable
+                        if (file.endsWith('.sh') || file.endsWith('.mjs')) {
+                            fs.chmodSync(destPath, '755');
+                        }
+                        result.created.files.push(".claude/helpers/" + file);
+                        copiedCount++;
+                    }
+                    else {
+                        result.skipped.push(".claude/helpers/" + file);
+                    }
+                }
+                if (copiedCount > 0) {
+                    return [2 /*return*/]; // Skip generating if we copied from source
                 }
-                result.created.files.push(`.claude/helpers/${file}`);
-                copiedCount++;
-            }
-            else {
-                result.skipped.push(`.claude/helpers/${file}`);
             }
-        }
-        if (copiedCount > 0) {
-            return; // Skip generating if we copied from source
-        }
-    }
-    // Fall back to generating helpers if source not available
-    const helpers = {
-        'pre-commit': generatePreCommitHook(),
-        'post-commit': generatePostCommitHook(),
-        'session.js': generateSessionManager(),
-        'router.js': generateAgentRouter(),
-        'memory.js': generateMemoryHelper(),
-        'hook-handler.cjs': generateHookHandler(),
-        'intelligence.cjs': generateIntelligenceStub(),
-        'auto-memory-hook.mjs': generateAutoMemoryHook(),
-    };
-    for (const [name, content] of Object.entries(helpers)) {
-        const filePath = path.join(helpersDir, name);
-        if (!fs.existsSync(filePath) || options.force) {
-            fs.writeFileSync(filePath, content, 'utf-8');
-            // Make shell scripts executable
-            if (!name.endsWith('.js')) {
-                fs.chmodSync(filePath, '755');
+            helpers = {
+                'pre-commit': generatePreCommitHook(),
+                'post-commit': generatePostCommitHook(),
+                'session.js': generateSessionManager(),
+                'router.js': generateAgentRouter(),
+                'memory.js': generateMemoryHelper(),
+                'hook-handler.cjs': generateHookHandler(),
+                'intelligence.cjs': generateIntelligenceStub(),
+                'auto-memory-hook.mjs': generateAutoMemoryHook()
+            };
+            for (_a = 0, _b = Object.entries(helpers); _a < _b.length; _a++) {
+                _c = _b[_a], name = _c[0], content = _c[1];
+                filePath = path.join(helpersDir, name);
+                if (!fs.existsSync(filePath) || options.force) {
+                    fs.writeFileSync(filePath, content, 'utf-8');
+                    // Make shell scripts executable
+                    if (!name.endsWith('.js')) {
+                        fs.chmodSync(filePath, '755');
+                    }
+                    result.created.files.push(".claude/helpers/" + name);
+                }
+                else {
+                    result.skipped.push(".claude/helpers/" + name);
+                }
             }
-            result.created.files.push(`.claude/helpers/${name}`);
-        }
-        else {
-            result.skipped.push(`.claude/helpers/${name}`);
-        }
-    }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Find source .claude directory for statusline files
  */
 function findSourceClaudeDir(sourceBaseDir) {
-    const possiblePaths = [];
+    var possiblePaths = [];
     // If explicit source base directory is provided, check it first
     if (sourceBaseDir) {
         possiblePaths.push(path.join(sourceBaseDir, '.claude'));
     }
     // IMPORTANT: Check the package's own .claude directory
     // Go up 3 levels: dist/src/init -> dist/src -> dist -> root
-    const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageClaude = path.join(packageRoot, '.claude');
+    var packageRoot = path.resolve(__dirname, '..', '..', '..');
+    var packageClaude = path.join(packageRoot, '.claude');
     if (fs.existsSync(packageClaude)) {
         possiblePaths.unshift(packageClaude); // Add to beginning (highest priority)
     }
     // From dist/src/init -> go up to project root
-    let currentDir = __dirname;
-    for (let i = 0; i < 10; i++) {
-        const parentDir = path.dirname(currentDir);
-        const claudePath = path.join(parentDir, '.claude');
+    var currentDir = __dirname;
+    for (var i = 0; i < 10; i++) {
+        var parentDir = path.dirname(currentDir);
+        var claudePath = path.join(parentDir, '.claude');
         if (fs.existsSync(claudePath)) {
             possiblePaths.push(claudePath);
         }
         currentDir = parentDir;
     }
-    for (const p of possiblePaths) {
+    for (var _i = 0, possiblePaths_2 = possiblePaths; _i < possiblePaths_2.length; _i++) {
+        var p = possiblePaths_2[_i];
         if (fs.existsSync(p)) {
             return p;
         }
@@ -997,664 +1097,235 @@ function findSourceClaudeDir(sourceBaseDir) {
 /**
  * Write statusline configuration
  */
-async function writeStatusline(targetDir, options, result) {
-    const claudeDir = path.join(targetDir, '.claude');
-    const helpersDir = path.join(targetDir, '.claude', 'helpers');
-    // Find source .claude directory (works for npm package and local dev)
-    const sourceClaudeDir = findSourceClaudeDir(options.sourceBaseDir);
-    // Try to copy existing advanced statusline files from source
-    const advancedStatuslineFiles = [
-        { src: 'statusline.sh', dest: 'statusline.sh', dir: claudeDir },
-        { src: 'statusline.mjs', dest: 'statusline.mjs', dir: claudeDir },
-    ];
-    if (sourceClaudeDir) {
-        for (const file of advancedStatuslineFiles) {
-            const sourcePath = path.join(sourceClaudeDir, file.src);
-            const destPath = path.join(file.dir, file.dest);
-            if (fs.existsSync(sourcePath)) {
-                if (!fs.existsSync(destPath) || options.force) {
-                    fs.copyFileSync(sourcePath, destPath);
-                    // Make shell scripts and mjs executable
-                    if (file.src.endsWith('.sh') || file.src.endsWith('.mjs')) {
-                        fs.chmodSync(destPath, '755');
+function writeStatusline(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var claudeDir, helpersDir, sourceClaudeDir, advancedStatuslineFiles, _i, advancedStatuslineFiles_1, file, sourcePath, destPath, statuslineScript, statuslinePath;
+        return __generator(this, function (_a) {
+            claudeDir = path.join(targetDir, '.claude');
+            helpersDir = path.join(targetDir, '.claude', 'helpers');
+            sourceClaudeDir = findSourceClaudeDir(options.sourceBaseDir);
+            advancedStatuslineFiles = [
+                { src: 'statusline.sh', dest: 'statusline.sh', dir: claudeDir },
+                { src: 'statusline.mjs', dest: 'statusline.mjs', dir: claudeDir },
+            ];
+            if (sourceClaudeDir) {
+                for (_i = 0, advancedStatuslineFiles_1 = advancedStatuslineFiles; _i < advancedStatuslineFiles_1.length; _i++) {
+                    file = advancedStatuslineFiles_1[_i];
+                    sourcePath = path.join(sourceClaudeDir, file.src);
+                    destPath = path.join(file.dir, file.dest);
+                    if (fs.existsSync(sourcePath)) {
+                        if (!fs.existsSync(destPath) || options.force) {
+                            fs.copyFileSync(sourcePath, destPath);
+                            // Make shell scripts and mjs executable
+                            if (file.src.endsWith('.sh') || file.src.endsWith('.mjs')) {
+                                fs.chmodSync(destPath, '755');
+                            }
+                            result.created.files.push(".claude/" + file.dest);
+                        }
+                        else {
+                            result.skipped.push(".claude/" + file.dest);
+                        }
                     }
-                    result.created.files.push(`.claude/${file.dest}`);
-                }
-                else {
-                    result.skipped.push(`.claude/${file.dest}`);
                 }
             }
-        }
-    }
-    // ALWAYS generate statusline.cjs — settings.json references this path
-    // regardless of whether advanced statusline files were also copied.
-    const statuslineScript = generateStatuslineScript(options);
-    const statuslinePath = path.join(helpersDir, 'statusline.cjs');
-    if (!fs.existsSync(statuslinePath) || options.force) {
-        fs.writeFileSync(statuslinePath, statuslineScript, 'utf-8');
-        result.created.files.push('.claude/helpers/statusline.cjs');
-    }
-    else {
-        result.skipped.push('.claude/helpers/statusline.cjs');
-    }
+            statuslineScript = generateStatuslineScript(options);
+            statuslinePath = path.join(helpersDir, 'statusline.cjs');
+            fs.writeFileSync(statuslinePath, statuslineScript, 'utf-8');
+            result.created.files.push('.claude/helpers/statusline.cjs');
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Write runtime configuration (.claude-flow/)
  */
-async function writeRuntimeConfig(targetDir, options, result) {
-    const configPath = path.join(targetDir, '.claude-flow', 'config.yaml');
-    if (fs.existsSync(configPath) && !options.force) {
-        result.skipped.push('.claude-flow/config.yaml');
-        return;
-    }
-    const config = `# KynjalFlow V3 Runtime Configuration
-# Generated: ${new Date().toISOString()}
-
-version: "3.0.0"
-
-swarm:
-  topology: ${options.runtime.topology}
-  maxAgents: ${options.runtime.maxAgents}
-  autoScale: true
-  coordinationStrategy: consensus
-
-memory:
-  backend: ${options.runtime.memoryBackend}
-  enableHNSW: ${options.runtime.enableHNSW}
-  persistPath: .claude-flow/data
-  cacheSize: 100
-  # ADR-049: Self-Learning Memory
-  learningBridge:
-    enabled: ${options.runtime.enableLearningBridge ?? options.runtime.enableNeural}
-    sonaMode: balanced
-    confidenceDecayRate: 0.005
-    accessBoostAmount: 0.03
-    consolidationThreshold: 10
-  memoryGraph:
-    enabled: ${options.runtime.enableMemoryGraph ?? true}
-    pageRankDamping: 0.85
-    maxNodes: 5000
-    similarityThreshold: 0.8
-  agentScopes:
-    enabled: ${options.runtime.enableAgentScopes ?? true}
-    defaultScope: project
-
-neural:
-  enabled: ${options.runtime.enableNeural}
-  modelPath: .claude-flow/neural
-
-hooks:
-  enabled: true
-  autoExecute: true
-
-mcp:
-  autoStart: ${options.mcp.autoStart}
-  port: ${options.mcp.port}
-`;
-    fs.writeFileSync(configPath, config, 'utf-8');
-    result.created.files.push('.claude-flow/config.yaml');
-    // Write .gitignore
-    const gitignorePath = path.join(targetDir, '.claude-flow', '.gitignore');
-    const gitignore = `# KynjalFlow runtime files
-data/
-logs/
-sessions/
-neural/
-*.log
-*.tmp
-`;
-    if (!fs.existsSync(gitignorePath) || options.force) {
-        fs.writeFileSync(gitignorePath, gitignore, 'utf-8');
-        result.created.files.push('.claude-flow/.gitignore');
-    }
-    // Write CAPABILITIES.md with full system overview
-    await writeCapabilitiesDoc(targetDir, options, result);
+function writeRuntimeConfig(targetDir, options, result) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, Promise, function () {
+        var configPath, config, gitignorePath, gitignore;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    configPath = path.join(targetDir, '.claude-flow', 'config.yaml');
+                    if (fs.existsSync(configPath) && !options.force) {
+                        result.skipped.push('.claude-flow/config.yaml');
+                        return [2 /*return*/];
+                    }
+                    config = "# RuFlo V3 Runtime Configuration\n# Generated: " + new Date().toISOString() + "\n\nversion: \"3.0.0\"\n\nswarm:\n  topology: " + options.runtime.topology + "\n  maxAgents: " + options.runtime.maxAgents + "\n  autoScale: true\n  coordinationStrategy: consensus\n\nmemory:\n  backend: " + options.runtime.memoryBackend + "\n  enableHNSW: " + options.runtime.enableHNSW + "\n  persistPath: .claude-flow/data\n  cacheSize: 100\n  # ADR-049: Self-Learning Memory\n  learningBridge:\n    enabled: " + ((_a = options.runtime.enableLearningBridge) !== null && _a !== void 0 ? _a : options.runtime.enableNeural) + "\n    sonaMode: balanced\n    confidenceDecayRate: 0.005\n    accessBoostAmount: 0.03\n    consolidationThreshold: 10\n  memoryGraph:\n    enabled: " + ((_b = options.runtime.enableMemoryGraph) !== null && _b !== void 0 ? _b : true) + "\n    pageRankDamping: 0.85\n    maxNodes: 5000\n    similarityThreshold: 0.8\n  agentScopes:\n    enabled: " + ((_c = options.runtime.enableAgentScopes) !== null && _c !== void 0 ? _c : true) + "\n    defaultScope: project\n\nneural:\n  enabled: " + options.runtime.enableNeural + "\n  modelPath: .claude-flow/neural\n\nhooks:\n  enabled: true\n  autoExecute: true\n\nmcp:\n  autoStart: " + options.mcp.autoStart + "\n  port: " + options.mcp.port + "\n";
+                    fs.writeFileSync(configPath, config, 'utf-8');
+                    result.created.files.push('.claude-flow/config.yaml');
+                    gitignorePath = path.join(targetDir, '.claude-flow', '.gitignore');
+                    gitignore = "# Claude Flow runtime files\ndata/\nlogs/\nsessions/\nneural/\n*.log\n*.tmp\n";
+                    if (!fs.existsSync(gitignorePath) || options.force) {
+                        fs.writeFileSync(gitignorePath, gitignore, 'utf-8');
+                        result.created.files.push('.claude-flow/.gitignore');
+                    }
+                    // Write CAPABILITIES.md with full system overview
+                    return [4 /*yield*/, writeCapabilitiesDoc(targetDir, options, result)];
+                case 1:
+                    // Write CAPABILITIES.md with full system overview
+                    _d.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Write initial metrics files for statusline
  * Creates baseline data so statusline shows meaningful state instead of all zeros
  */
-async function writeInitialMetrics(targetDir, options, result) {
-    const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
-    const learningDir = path.join(targetDir, '.claude-flow', 'learning');
-    const securityDir = path.join(targetDir, '.claude-flow', 'security');
-    // Ensure directories exist
-    for (const dir of [metricsDir, learningDir, securityDir]) {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-    }
-    // Create initial v3-progress.json
-    const progressPath = path.join(metricsDir, 'v3-progress.json');
-    if (!fs.existsSync(progressPath) || options.force) {
-        const progress = {
-            version: '3.0.0',
-            initialized: new Date().toISOString(),
-            domains: {
-                completed: 0,
-                total: 5,
-                status: 'INITIALIZING'
-            },
-            ddd: {
-                progress: 0,
-                modules: 0,
-                totalFiles: 0,
-                totalLines: 0
-            },
-            swarm: {
-                activeAgents: 0,
-                maxAgents: options.runtime.maxAgents,
-                topology: options.runtime.topology
-            },
-            learning: {
-                status: 'READY',
-                patternsLearned: 0,
-                sessionsCompleted: 0
-            },
-            _note: 'Metrics will update as you use KynjalFlow. Run: npx @kynjal/cli@latest daemon start'
-        };
-        fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/v3-progress.json');
-    }
-    // Create initial swarm-activity.json
-    const activityPath = path.join(metricsDir, 'swarm-activity.json');
-    if (!fs.existsSync(activityPath) || options.force) {
-        const activity = {
-            timestamp: new Date().toISOString(),
-            processes: {
-                agentic_flow: 0,
-                mcp_server: 0,
-                estimated_agents: 0
-            },
-            swarm: {
-                active: false,
-                agent_count: 0,
-                coordination_active: false
-            },
-            integration: {
-                agentic_flow_active: false,
-                mcp_active: false
-            },
-            _initialized: true
-        };
-        fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/swarm-activity.json');
-    }
-    // Create initial learning.json
-    const learningPath = path.join(metricsDir, 'learning.json');
-    if (!fs.existsSync(learningPath) || options.force) {
-        const learning = {
-            initialized: new Date().toISOString(),
-            routing: {
-                accuracy: 0,
-                decisions: 0
-            },
-            patterns: {
-                shortTerm: 0,
-                longTerm: 0,
-                quality: 0
-            },
-            sessions: {
-                total: 0,
-                current: null
-            },
-            _note: 'Intelligence grows as you use KynjalFlow'
-        };
-        fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/metrics/learning.json');
-    }
-    // Create initial audit-status.json
-    const auditPath = path.join(securityDir, 'audit-status.json');
-    if (!fs.existsSync(auditPath) || options.force) {
-        const audit = {
-            initialized: new Date().toISOString(),
-            status: 'PENDING',
-            cvesFixed: 0,
-            totalCves: 3,
-            lastScan: null,
-            _note: 'Run: npx @kynjal/cli@latest security scan'
-        };
-        fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
-        result.created.files.push('.claude-flow/security/audit-status.json');
-    }
+function writeInitialMetrics(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var metricsDir, learningDir, securityDir, _i, _a, dir, progressPath, progress, activityPath, activity, learningPath, learning, auditPath, audit;
+        return __generator(this, function (_b) {
+            metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
+            learningDir = path.join(targetDir, '.claude-flow', 'learning');
+            securityDir = path.join(targetDir, '.claude-flow', 'security');
+            // Ensure directories exist
+            for (_i = 0, _a = [metricsDir, learningDir, securityDir]; _i < _a.length; _i++) {
+                dir = _a[_i];
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+            }
+            progressPath = path.join(metricsDir, 'v3-progress.json');
+            if (!fs.existsSync(progressPath) || options.force) {
+                progress = {
+                    version: '3.0.0',
+                    initialized: new Date().toISOString(),
+                    domains: {
+                        completed: 0,
+                        total: 5,
+                        status: 'INITIALIZING'
+                    },
+                    ddd: {
+                        progress: 0,
+                        modules: 0,
+                        totalFiles: 0,
+                        totalLines: 0
+                    },
+                    swarm: {
+                        activeAgents: 0,
+                        maxAgents: options.runtime.maxAgents,
+                        topology: options.runtime.topology
+                    },
+                    learning: {
+                        status: 'READY',
+                        patternsLearned: 0,
+                        sessionsCompleted: 0
+                    },
+                    _note: 'Metrics will update as you use Ruflo. Run: npx ruflo@latest daemon start'
+                };
+                fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
+                result.created.files.push('.claude-flow/metrics/v3-progress.json');
+            }
+            activityPath = path.join(metricsDir, 'swarm-activity.json');
+            if (!fs.existsSync(activityPath) || options.force) {
+                activity = {
+                    timestamp: new Date().toISOString(),
+                    processes: {
+                        agentic_flow: 0,
+                        mcp_server: 0,
+                        estimated_agents: 0
+                    },
+                    swarm: {
+                        active: false,
+                        agent_count: 0,
+                        coordination_active: false
+                    },
+                    integration: {
+                        agentic_flow_active: false,
+                        mcp_active: false
+                    },
+                    _initialized: true
+                };
+                fs.writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
+                result.created.files.push('.claude-flow/metrics/swarm-activity.json');
+            }
+            learningPath = path.join(metricsDir, 'learning.json');
+            if (!fs.existsSync(learningPath) || options.force) {
+                learning = {
+                    initialized: new Date().toISOString(),
+                    routing: {
+                        accuracy: 0,
+                        decisions: 0
+                    },
+                    patterns: {
+                        shortTerm: 0,
+                        longTerm: 0,
+                        quality: 0
+                    },
+                    sessions: {
+                        total: 0,
+                        current: null
+                    },
+                    _note: 'Intelligence grows as you use Ruflo'
+                };
+                fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
+                result.created.files.push('.claude-flow/metrics/learning.json');
+            }
+            auditPath = path.join(securityDir, 'audit-status.json');
+            if (!fs.existsSync(auditPath) || options.force) {
+                audit = {
+                    initialized: new Date().toISOString(),
+                    status: 'PENDING',
+                    cvesFixed: 0,
+                    totalCves: 3,
+                    lastScan: null,
+                    _note: 'Run: npx @claude-flow/cli@latest security scan'
+                };
+                fs.writeFileSync(auditPath, JSON.stringify(audit, null, 2), 'utf-8');
+                result.created.files.push('.claude-flow/security/audit-status.json');
+            }
+            return [2 /*return*/];
+        });
+    });
 }
 /**
- * Write CAPABILITIES.md - comprehensive overview of all KynjalFlow features
+ * Write CAPABILITIES.md - comprehensive overview of all Ruflo features
  */
-async function writeCapabilitiesDoc(targetDir, options, result) {
-    const capabilitiesPath = path.join(targetDir, '.claude-flow', 'CAPABILITIES.md');
-    if (fs.existsSync(capabilitiesPath) && !options.force) {
-        result.skipped.push('.claude-flow/CAPABILITIES.md');
-        return;
-    }
-    const capabilities = `# KynjalFlow V3 - Complete Capabilities Reference
-> Generated: ${new Date().toISOString()}
-> Full documentation: https://github.com/KingJune28/claude-flow
-
-## 📋 Table of Contents
-
-1. [Overview](#overview)
-2. [Swarm Orchestration](#swarm-orchestration)
-3. [Available Agents (60+)](#available-agents)
-4. [CLI Commands (26 Commands, 140+ Subcommands)](#cli-commands)
-5. [Hooks System (27 Hooks + 12 Workers)](#hooks-system)
-6. [Memory & Intelligence (RuVector)](#memory--intelligence)
-7. [Hive-Mind Consensus](#hive-mind-consensus)
-8. [Performance Targets](#performance-targets)
-9. [Integration Ecosystem](#integration-ecosystem)
-
----
-
-## Overview
-
-KynjalFlow V3 is a domain-driven design architecture for multi-agent AI coordination with:
-
-- **15-Agent Swarm Coordination** with hierarchical and mesh topologies
-- **HNSW Vector Search** - 150x-12,500x faster pattern retrieval
-- **SONA Neural Learning** - Self-optimizing with <0.05ms adaptation
-- **Byzantine Fault Tolerance** - Queen-led consensus mechanisms
-- **MCP Server Integration** - Model Context Protocol support
-
-### Current Configuration
-| Setting | Value |
-|---------|-------|
-| Topology | ${options.runtime.topology} |
-| Max Agents | ${options.runtime.maxAgents} |
-| Memory Backend | ${options.runtime.memoryBackend} |
-| HNSW Indexing | ${options.runtime.enableHNSW ? 'Enabled' : 'Disabled'} |
-| Neural Learning | ${options.runtime.enableNeural ? 'Enabled' : 'Disabled'} |
-| LearningBridge | ${options.runtime.enableLearningBridge ? 'Enabled (SONA + ReasoningBank)' : 'Disabled'} |
-| Knowledge Graph | ${options.runtime.enableMemoryGraph ? 'Enabled (PageRank + Communities)' : 'Disabled'} |
-| Agent Scopes | ${options.runtime.enableAgentScopes ? 'Enabled (project/local/user)' : 'Disabled'} |
-
----
-
-## Swarm Orchestration
-
-### Topologies
-| Topology | Description | Best For |
-|----------|-------------|----------|
-| \`hierarchical\` | Queen controls workers directly | Anti-drift, tight control |
-| \`mesh\` | Fully connected peer network | Distributed tasks |
-| \`hierarchical-mesh\` | V3 hybrid (recommended) | 10+ agents |
-| \`ring\` | Circular communication | Sequential workflows |
-| \`star\` | Central coordinator | Simple coordination |
-| \`adaptive\` | Dynamic based on load | Variable workloads |
-
-### Strategies
-- \`balanced\` - Even distribution across agents
-- \`specialized\` - Clear roles, no overlap (anti-drift)
-- \`adaptive\` - Dynamic task routing
-
-### Quick Commands
-\`\`\`bash
-# Initialize swarm
-npx @kynjal/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized
-
-# Check status
-npx @kynjal/cli@latest swarm status
-
-# Monitor activity
-npx @kynjal/cli@latest swarm monitor
-\`\`\`
-
----
-
-## Available Agents
-
-### Core Development (5)
-\`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
-
-### V3 Specialized (4)
-\`security-architect\`, \`security-auditor\`, \`memory-specialist\`, \`performance-engineer\`
-
-### Swarm Coordination (5)
-\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`, \`collective-intelligence-coordinator\`, \`swarm-memory-manager\`
-
-### Consensus & Distributed (7)
-\`byzantine-coordinator\`, \`raft-manager\`, \`gossip-coordinator\`, \`consensus-builder\`, \`crdt-synchronizer\`, \`quorum-manager\`, \`security-manager\`
-
-### Performance & Optimization (5)
-\`perf-analyzer\`, \`performance-benchmarker\`, \`task-orchestrator\`, \`memory-coordinator\`, \`smart-agent\`
-
-### GitHub & Repository (9)
-\`github-modes\`, \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`, \`workflow-automation\`, \`project-board-sync\`, \`repo-architect\`, \`multi-repo-swarm\`
-
-### SPARC Methodology (6)
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\`, \`refinement\`
-
-### Specialized Development (8)
-\`backend-dev\`, \`mobile-dev\`, \`ml-developer\`, \`cicd-engineer\`, \`api-docs\`, \`system-architect\`, \`code-analyzer\`, \`base-template-generator\`
-
-### Testing & Validation (2)
-\`tdd-london-swarm\`, \`production-validator\`
-
-### Agent Routing by Task
-| Task Type | Recommended Agents | Topology |
-|-----------|-------------------|----------|
-| Bug Fix | researcher, coder, tester | mesh |
-| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
-| Refactoring | architect, coder, reviewer | mesh |
-| Performance | researcher, perf-engineer, coder | hierarchical |
-| Security | security-architect, auditor, reviewer | hierarchical |
-| Docs | researcher, api-docs | mesh |
-
----
-
-## CLI Commands
-
-### Core Commands (12)
-| Command | Subcommands | Description |
-|---------|-------------|-------------|
-| \`init\` | 4 | Project initialization |
-| \`agent\` | 8 | Agent lifecycle management |
-| \`swarm\` | 6 | Multi-agent coordination |
-| \`memory\` | 11 | AgentDB with HNSW search |
-| \`mcp\` | 9 | MCP server management |
-| \`task\` | 6 | Task assignment |
-| \`session\` | 7 | Session persistence |
-| \`config\` | 7 | Configuration |
-| \`status\` | 3 | System monitoring |
-| \`workflow\` | 6 | Workflow templates |
-| \`hooks\` | 17 | Self-learning hooks |
-| \`hive-mind\` | 6 | Consensus coordination |
-
-### Advanced Commands (14)
-| Command | Subcommands | Description |
-|---------|-------------|-------------|
-| \`daemon\` | 5 | Background workers |
-| \`neural\` | 5 | Pattern training |
-| \`security\` | 6 | Security scanning |
-| \`performance\` | 5 | Profiling & benchmarks |
-| \`providers\` | 5 | AI provider config |
-| \`plugins\` | 5 | Plugin management |
-| \`deployment\` | 5 | Deploy management |
-| \`embeddings\` | 4 | Vector embeddings |
-| \`claims\` | 4 | Authorization |
-| \`migrate\` | 5 | V2→V3 migration |
-| \`process\` | 4 | Process management |
-| \`doctor\` | 1 | Health diagnostics |
-| \`completions\` | 4 | Shell completions |
-
-### Example Commands
-\`\`\`bash
-# Initialize
-npx @kynjal/cli@latest init --wizard
-
-# Spawn agent
-npx @kynjal/cli@latest agent spawn -t coder --name my-coder
-
-# Memory operations
-npx @kynjal/cli@latest memory store --key "pattern" --value "data" --namespace patterns
-npx @kynjal/cli@latest memory search --query "authentication"
-
-# Diagnostics
-npx @kynjal/cli@latest doctor --fix
-\`\`\`
-
----
-
-## Hooks System
-
-### 27 Available Hooks
-
-#### Core Hooks (6)
-| Hook | Description |
-|------|-------------|
-| \`pre-edit\` | Context before file edits |
-| \`post-edit\` | Record edit outcomes |
-| \`pre-command\` | Risk assessment |
-| \`post-command\` | Command metrics |
-| \`pre-task\` | Task start + agent suggestions |
-| \`post-task\` | Task completion learning |
-
-#### Session Hooks (4)
-| Hook | Description |
-|------|-------------|
-| \`session-start\` | Start/restore session |
-| \`session-end\` | Persist state |
-| \`session-restore\` | Restore previous |
-| \`notify\` | Cross-agent notifications |
-
-#### Intelligence Hooks (5)
-| Hook | Description |
-|------|-------------|
-| \`route\` | Optimal agent routing |
-| \`explain\` | Routing decisions |
-| \`pretrain\` | Bootstrap intelligence |
-| \`build-agents\` | Generate configs |
-| \`transfer\` | Pattern transfer |
-
-#### Coverage Hooks (3)
-| Hook | Description |
-|------|-------------|
-| \`coverage-route\` | Coverage-based routing |
-| \`coverage-suggest\` | Improvement suggestions |
-| \`coverage-gaps\` | Gap analysis |
-
-### 12 Background Workers
-| Worker | Priority | Purpose |
-|--------|----------|---------|
-| \`ultralearn\` | normal | Deep knowledge |
-| \`optimize\` | high | Performance |
-| \`consolidate\` | low | Memory consolidation |
-| \`predict\` | normal | Predictive preload |
-| \`audit\` | critical | Security |
-| \`map\` | normal | Codebase mapping |
-| \`preload\` | low | Resource preload |
-| \`deepdive\` | normal | Deep analysis |
-| \`document\` | normal | Auto-docs |
-| \`refactor\` | normal | Suggestions |
-| \`benchmark\` | normal | Benchmarking |
-| \`testgaps\` | normal | Coverage gaps |
-
----
-
-## Memory & Intelligence
-
-### RuVector Intelligence System
-- **SONA**: Self-Optimizing Neural Architecture (<0.05ms)
-- **MoE**: Mixture of Experts routing
-- **HNSW**: 150x-12,500x faster search
-- **EWC++**: Prevents catastrophic forgetting
-- **Flash Attention**: 2.49x-7.47x speedup
-- **Int8 Quantization**: 3.92x memory reduction
-
-### 4-Step Intelligence Pipeline
-1. **RETRIEVE** - HNSW pattern search
-2. **JUDGE** - Success/failure verdicts
-3. **DISTILL** - LoRA learning extraction
-4. **CONSOLIDATE** - EWC++ preservation
-
-### Self-Learning Memory (ADR-049)
-
-| Component | Status | Description |
-|-----------|--------|-------------|
-| **LearningBridge** | ${options.runtime.enableLearningBridge ? '✅ Enabled' : '⏸ Disabled'} | Connects insights to SONA/ReasoningBank neural pipeline |
-| **MemoryGraph** | ${options.runtime.enableMemoryGraph ? '✅ Enabled' : '⏸ Disabled'} | PageRank knowledge graph + community detection |
-| **AgentMemoryScope** | ${options.runtime.enableAgentScopes ? '✅ Enabled' : '⏸ Disabled'} | 3-scope agent memory (project/local/user) |
-
-**LearningBridge** - Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay. Consolidation runs the JUDGE/DISTILL/CONSOLIDATE pipeline.
-
-**MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.
-
-**AgentMemoryScope** - Maps Claude Code 3-scope directories:
-- \`project\`: \`<gitRoot>/.claude/agent-memory/<agent>/\`
-- \`local\`: \`<gitRoot>/.claude/agent-memory-local/<agent>/\`
-- \`user\`: \`~/.claude/agent-memory/<agent>/\`
-
-High-confidence insights (>0.8) can transfer between agents.
-
-### Memory Commands
-\`\`\`bash
-# Store pattern
-npx @kynjal/cli@latest memory store --key "name" --value "data" --namespace patterns
-
-# Semantic search
-npx @kynjal/cli@latest memory search --query "authentication"
-
-# List entries
-npx @kynjal/cli@latest memory list --namespace patterns
-
-# Initialize database
-npx @kynjal/cli@latest memory init --force
-\`\`\`
-
----
-
-## Hive-Mind Consensus
-
-### Queen Types
-| Type | Role |
-|------|------|
-| Strategic Queen | Long-term planning |
-| Tactical Queen | Execution coordination |
-| Adaptive Queen | Dynamic optimization |
-
-### Worker Types (8)
-\`researcher\`, \`coder\`, \`analyst\`, \`tester\`, \`architect\`, \`reviewer\`, \`optimizer\`, \`documenter\`
-
-### Consensus Mechanisms
-| Mechanism | Fault Tolerance | Use Case |
-|-----------|-----------------|----------|
-| \`byzantine\` | f < n/3 faulty | Adversarial |
-| \`raft\` | f < n/2 failed | Leader-based |
-| \`gossip\` | Eventually consistent | Large scale |
-| \`crdt\` | Conflict-free | Distributed |
-| \`quorum\` | Configurable | Flexible |
-
-### Hive-Mind Commands
-\`\`\`bash
-# Initialize
-npx @kynjal/cli@latest hive-mind init --queen-type strategic
-
-# Status
-npx @kynjal/cli@latest hive-mind status
-
-# Spawn workers
-npx @kynjal/cli@latest hive-mind spawn --count 5 --type worker
-
-# Consensus
-npx @kynjal/cli@latest hive-mind consensus --propose "task"
-\`\`\`
-
----
-
-## Performance Targets
-
-| Metric | Target | Status |
-|--------|--------|--------|
-| HNSW Search | 150x-12,500x faster | ✅ Implemented |
-| Memory Reduction | 50-75% | ✅ Implemented (3.92x) |
-| SONA Integration | Pattern learning | ✅ Implemented |
-| Flash Attention | 2.49x-7.47x | 🔄 In Progress |
-| MCP Response | <100ms | ✅ Achieved |
-| CLI Startup | <500ms | ✅ Achieved |
-| SONA Adaptation | <0.05ms | 🔄 In Progress |
-| Graph Build (1k) | <200ms | ✅ 2.78ms (71.9x headroom) |
-| PageRank (1k) | <100ms | ✅ 12.21ms (8.2x headroom) |
-| Insight Recording | <5ms/each | ✅ 0.12ms (41x headroom) |
-| Consolidation | <500ms | ✅ 0.26ms (1,955x headroom) |
-| Knowledge Transfer | <100ms | ✅ 1.25ms (80x headroom) |
-
----
-
-## Integration Ecosystem
-
-### Integrated Packages
-| Package | Version | Purpose |
-|---------|---------|---------|
-| agentic-flow | 2.0.1-alpha | Core coordination |
-| agentdb | 2.0.0-alpha.3.4 | Vector database |
-| @ruvector/attention | 0.1.3 | Flash attention |
-| @ruvector/sona | 0.1.5 | Neural learning |
-
-### Optional Integrations
-| Package | Command |
-|---------|---------|
-| ruv-swarm | \`npx ruv-swarm mcp start\` |
-| flow-nexus | \`npx flow-nexus@latest mcp start\` |
-| agentic-jujutsu | \`npx agentic-jujutsu@latest\` |
-
-### MCP Server Setup
-\`\`\`bash
-# Add KynjalFlow MCP
-claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
-
-# Optional servers
-claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start
-claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start
-\`\`\`
-
----
-
-## Quick Reference
-
-### Essential Commands
-\`\`\`bash
-# Setup
-npx @kynjal/cli@latest init --wizard
-npx @kynjal/cli@latest daemon start
-npx @kynjal/cli@latest doctor --fix
-
-# Swarm
-npx @kynjal/cli@latest swarm init --topology hierarchical --max-agents 8
-npx @kynjal/cli@latest swarm status
-
-# Agents
-npx @kynjal/cli@latest agent spawn -t coder
-npx @kynjal/cli@latest agent list
-
-# Memory
-npx @kynjal/cli@latest memory search --query "patterns"
-
-# Hooks
-npx @kynjal/cli@latest hooks pre-task --description "task"
-npx @kynjal/cli@latest hooks worker dispatch --trigger optimize
-\`\`\`
-
-### File Structure
-\`\`\`
-.claude-flow/
-├── config.yaml      # Runtime configuration
-├── CAPABILITIES.md  # This file
-├── data/            # Memory storage
-├── logs/            # Operation logs
-├── sessions/        # Session state
-├── hooks/           # Custom hooks
-├── agents/          # Agent configs
-└── workflows/       # Workflow templates
-\`\`\`
-
----
-
-**Full Documentation**: https://github.com/KingJune28/claude-flow
-**Issues**: https://github.com/KingJune28/claude-flow/issues
-`;
-    fs.writeFileSync(capabilitiesPath, capabilities, 'utf-8');
-    result.created.files.push('.claude-flow/CAPABILITIES.md');
+function writeCapabilitiesDoc(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var capabilitiesPath, capabilities;
+        return __generator(this, function (_a) {
+            capabilitiesPath = path.join(targetDir, '.claude-flow', 'CAPABILITIES.md');
+            if (fs.existsSync(capabilitiesPath) && !options.force) {
+                result.skipped.push('.claude-flow/CAPABILITIES.md');
+                return [2 /*return*/];
+            }
+            capabilities = "# RuFlo V3 - Complete Capabilities Reference\n> Generated: " + new Date().toISOString() + "\n> Full documentation: https://github.com/ruvnet/claude-flow\n\n## \uD83D\uDCCB Table of Contents\n\n1. [Overview](#overview)\n2. [Swarm Orchestration](#swarm-orchestration)\n3. [Available Agents (60+)](#available-agents)\n4. [CLI Commands (26 Commands, 140+ Subcommands)](#cli-commands)\n5. [Hooks System (27 Hooks + 12 Workers)](#hooks-system)\n6. [Memory & Intelligence (RuVector)](#memory--intelligence)\n7. [Hive-Mind Consensus](#hive-mind-consensus)\n8. [Performance Targets](#performance-targets)\n9. [Integration Ecosystem](#integration-ecosystem)\n\n---\n\n## Overview\n\nRuFlo V3 is a domain-driven design architecture for multi-agent AI coordination with:\n\n- **15-Agent Swarm Coordination** with hierarchical and mesh topologies\n- **HNSW Vector Search** - 150x-12,500x faster pattern retrieval\n- **SONA Neural Learning** - Self-optimizing with <0.05ms adaptation\n- **Byzantine Fault Tolerance** - Queen-led consensus mechanisms\n- **MCP Server Integration** - Model Context Protocol support\n\n### Current Configuration\n| Setting | Value |\n|---------|-------|\n| Topology | " + options.runtime.topology + " |\n| Max Agents | " + options.runtime.maxAgents + " |\n| Memory Backend | " + options.runtime.memoryBackend + " |\n| HNSW Indexing | " + (options.runtime.enableHNSW ? 'Enabled' : 'Disabled') + " |\n| Neural Learning | " + (options.runtime.enableNeural ? 'Enabled' : 'Disabled') + " |\n| LearningBridge | " + (options.runtime.enableLearningBridge ? 'Enabled (SONA + ReasoningBank)' : 'Disabled') + " |\n| Knowledge Graph | " + (options.runtime.enableMemoryGraph ? 'Enabled (PageRank + Communities)' : 'Disabled') + " |\n| Agent Scopes | " + (options.runtime.enableAgentScopes ? 'Enabled (project/local/user)' : 'Disabled') + " |\n\n---\n\n## Swarm Orchestration\n\n### Topologies\n| Topology | Description | Best For |\n|----------|-------------|----------|\n| `hierarchical` | Queen controls workers directly | Anti-drift, tight control |\n| `mesh` | Fully connected peer network | Distributed tasks |\n| `hierarchical-mesh` | V3 hybrid (recommended) | 10+ agents |\n| `ring` | Circular communication | Sequential workflows |\n| `star` | Central coordinator | Simple coordination |\n| `adaptive` | Dynamic based on load | Variable workloads |\n\n### Strategies\n- `balanced` - Even distribution across agents\n- `specialized` - Clear roles, no overlap (anti-drift)\n- `adaptive` - Dynamic task routing\n\n### Quick Commands\n```bash\n# Initialize swarm\nnpx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8 --strategy specialized\n\n# Check status\nnpx @claude-flow/cli@latest swarm status\n\n# Monitor activity\nnpx @claude-flow/cli@latest swarm monitor\n```\n\n---\n\n## Available Agents\n\n### Core Development (5)\n`coder`, `reviewer`, `tester`, `planner`, `researcher`\n\n### V3 Specialized (4)\n`security-architect`, `security-auditor`, `memory-specialist`, `performance-engineer`\n\n### Swarm Coordination (5)\n`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`, `swarm-memory-manager`\n\n### Consensus & Distributed (7)\n`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`, `crdt-synchronizer`, `quorum-manager`, `security-manager`\n\n### Performance & Optimization (5)\n`perf-analyzer`, `performance-benchmarker`, `task-orchestrator`, `memory-coordinator`, `smart-agent`\n\n### GitHub & Repository (9)\n`github-modes`, `pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`, `workflow-automation`, `project-board-sync`, `repo-architect`, `multi-repo-swarm`\n\n### SPARC Methodology (6)\n`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`\n\n### Specialized Development (8)\n`backend-dev`, `mobile-dev`, `ml-developer`, `cicd-engineer`, `api-docs`, `system-architect`, `code-analyzer`, `base-template-generator`\n\n### Testing & Validation (2)\n`tdd-london-swarm`, `production-validator`\n\n### Agent Routing by Task\n| Task Type | Recommended Agents | Topology |\n|-----------|-------------------|----------|\n| Bug Fix | researcher, coder, tester | mesh |\n| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |\n| Refactoring | architect, coder, reviewer | mesh |\n| Performance | researcher, perf-engineer, coder | hierarchical |\n| Security | security-architect, auditor, reviewer | hierarchical |\n| Docs | researcher, api-docs | mesh |\n\n---\n\n## CLI Commands\n\n### Core Commands (12)\n| Command | Subcommands | Description |\n|---------|-------------|-------------|\n| `init` | 4 | Project initialization |\n| `agent` | 8 | Agent lifecycle management |\n| `swarm` | 6 | Multi-agent coordination |\n| `memory` | 11 | AgentDB with HNSW search |\n| `mcp` | 9 | MCP server management |\n| `task` | 6 | Task assignment |\n| `session` | 7 | Session persistence |\n| `config` | 7 | Configuration |\n| `status` | 3 | System monitoring |\n| `workflow` | 6 | Workflow templates |\n| `hooks` | 17 | Self-learning hooks |\n| `hive-mind` | 6 | Consensus coordination |\n\n### Advanced Commands (14)\n| Command | Subcommands | Description |\n|---------|-------------|-------------|\n| `daemon` | 5 | Background workers |\n| `neural` | 5 | Pattern training |\n| `security` | 6 | Security scanning |\n| `performance` | 5 | Profiling & benchmarks |\n| `providers` | 5 | AI provider config |\n| `plugins` | 5 | Plugin management |\n| `deployment` | 5 | Deploy management |\n| `embeddings` | 4 | Vector embeddings |\n| `claims` | 4 | Authorization |\n| `migrate` | 5 | V2\u2192V3 migration |\n| `process` | 4 | Process management |\n| `doctor` | 1 | Health diagnostics |\n| `completions` | 4 | Shell completions |\n\n### Example Commands\n```bash\n# Initialize\nnpx @claude-flow/cli@latest init --wizard\n\n# Spawn agent\nnpx @claude-flow/cli@latest agent spawn -t coder --name my-coder\n\n# Memory operations\nnpx @claude-flow/cli@latest memory store --key \"pattern\" --value \"data\" --namespace patterns\nnpx @claude-flow/cli@latest memory search --query \"authentication\"\n\n# Diagnostics\nnpx @claude-flow/cli@latest doctor --fix\n```\n\n---\n\n## Hooks System\n\n### 27 Available Hooks\n\n#### Core Hooks (6)\n| Hook | Description |\n|------|-------------|\n| `pre-edit` | Context before file edits |\n| `post-edit` | Record edit outcomes |\n| `pre-command` | Risk assessment |\n| `post-command` | Command metrics |\n| `pre-task` | Task start + agent suggestions |\n| `post-task` | Task completion learning |\n\n#### Session Hooks (4)\n| Hook | Description |\n|------|-------------|\n| `session-start` | Start/restore session |\n| `session-end` | Persist state |\n| `session-restore` | Restore previous |\n| `notify` | Cross-agent notifications |\n\n#### Intelligence Hooks (5)\n| Hook | Description |\n|------|-------------|\n| `route` | Optimal agent routing |\n| `explain` | Routing decisions |\n| `pretrain` | Bootstrap intelligence |\n| `build-agents` | Generate configs |\n| `transfer` | Pattern transfer |\n\n#### Coverage Hooks (3)\n| Hook | Description |\n|------|-------------|\n| `coverage-route` | Coverage-based routing |\n| `coverage-suggest` | Improvement suggestions |\n| `coverage-gaps` | Gap analysis |\n\n### 12 Background Workers\n| Worker | Priority | Purpose |\n|--------|----------|---------|\n| `ultralearn` | normal | Deep knowledge |\n| `optimize` | high | Performance |\n| `consolidate` | low | Memory consolidation |\n| `predict` | normal | Predictive preload |\n| `audit` | critical | Security |\n| `map` | normal | Codebase mapping |\n| `preload` | low | Resource preload |\n| `deepdive` | normal | Deep analysis |\n| `document` | normal | Auto-docs |\n| `refactor` | normal | Suggestions |\n| `benchmark` | normal | Benchmarking |\n| `testgaps` | normal | Coverage gaps |\n\n---\n\n## Memory & Intelligence\n\n### RuVector Intelligence System\n- **SONA**: Self-Optimizing Neural Architecture (<0.05ms)\n- **MoE**: Mixture of Experts routing\n- **HNSW**: 150x-12,500x faster search\n- **EWC++**: Prevents catastrophic forgetting\n- **Flash Attention**: 2.49x-7.47x speedup\n- **Int8 Quantization**: 3.92x memory reduction\n\n### 4-Step Intelligence Pipeline\n1. **RETRIEVE** - HNSW pattern search\n2. **JUDGE** - Success/failure verdicts\n3. **DISTILL** - LoRA learning extraction\n4. **CONSOLIDATE** - EWC++ preservation\n\n### Self-Learning Memory (ADR-049)\n\n| Component | Status | Description |\n|-----------|--------|-------------|\n| **LearningBridge** | " + (options.runtime.enableLearningBridge ? '✅ Enabled' : '⏸ Disabled') + " | Connects insights to SONA/ReasoningBank neural pipeline |\n| **MemoryGraph** | " + (options.runtime.enableMemoryGraph ? '✅ Enabled' : '⏸ Disabled') + " | PageRank knowledge graph + community detection |\n| **AgentMemoryScope** | " + (options.runtime.enableAgentScopes ? '✅ Enabled' : '⏸ Disabled') + " | 3-scope agent memory (project/local/user) |\n\n**LearningBridge** - Insights trigger learning trajectories. Confidence evolves: +0.03 on access, -0.005/hour decay. Consolidation runs the JUDGE/DISTILL/CONSOLIDATE pipeline.\n\n**MemoryGraph** - Builds a knowledge graph from entry references. PageRank identifies influential insights. Communities group related knowledge. Graph-aware ranking blends vector + structural scores.\n\n**AgentMemoryScope** - Maps Claude Code 3-scope directories:\n- `project`: `<gitRoot>/.claude/agent-memory/<agent>/`\n- `local`: `<gitRoot>/.claude/agent-memory-local/<agent>/`\n- `user`: `~/.claude/agent-memory/<agent>/`\n\nHigh-confidence insights (>0.8) can transfer between agents.\n\n### Memory Commands\n```bash\n# Store pattern\nnpx @claude-flow/cli@latest memory store --key \"name\" --value \"data\" --namespace patterns\n\n# Semantic search\nnpx @claude-flow/cli@latest memory search --query \"authentication\"\n\n# List entries\nnpx @claude-flow/cli@latest memory list --namespace patterns\n\n# Initialize database\nnpx @claude-flow/cli@latest memory init --force\n```\n\n---\n\n## Hive-Mind Consensus\n\n### Queen Types\n| Type | Role |\n|------|------|\n| Strategic Queen | Long-term planning |\n| Tactical Queen | Execution coordination |\n| Adaptive Queen | Dynamic optimization |\n\n### Worker Types (8)\n`researcher`, `coder`, `analyst`, `tester`, `architect`, `reviewer`, `optimizer`, `documenter`\n\n### Consensus Mechanisms\n| Mechanism | Fault Tolerance | Use Case |\n|-----------|-----------------|----------|\n| `byzantine` | f < n/3 faulty | Adversarial |\n| `raft` | f < n/2 failed | Leader-based |\n| `gossip` | Eventually consistent | Large scale |\n| `crdt` | Conflict-free | Distributed |\n| `quorum` | Configurable | Flexible |\n\n### Hive-Mind Commands\n```bash\n# Initialize\nnpx @claude-flow/cli@latest hive-mind init --queen-type strategic\n\n# Status\nnpx @claude-flow/cli@latest hive-mind status\n\n# Spawn workers\nnpx @claude-flow/cli@latest hive-mind spawn --count 5 --type worker\n\n# Consensus\nnpx @claude-flow/cli@latest hive-mind consensus --propose \"task\"\n```\n\n---\n\n## Performance Targets\n\n| Metric | Target | Status |\n|--------|--------|--------|\n| HNSW Search | 150x-12,500x faster | \u2705 Implemented |\n| Memory Reduction | 50-75% | \u2705 Implemented (3.92x) |\n| SONA Integration | Pattern learning | \u2705 Implemented |\n| Flash Attention | 2.49x-7.47x | \uD83D\uDD04 In Progress |\n| MCP Response | <100ms | \u2705 Achieved |\n| CLI Startup | <500ms | \u2705 Achieved |\n| SONA Adaptation | <0.05ms | \uD83D\uDD04 In Progress |\n| Graph Build (1k) | <200ms | \u2705 2.78ms (71.9x headroom) |\n| PageRank (1k) | <100ms | \u2705 12.21ms (8.2x headroom) |\n| Insight Recording | <5ms/each | \u2705 0.12ms (41x headroom) |\n| Consolidation | <500ms | \u2705 0.26ms (1,955x headroom) |\n| Knowledge Transfer | <100ms | \u2705 1.25ms (80x headroom) |\n\n---\n\n## Integration Ecosystem\n\n### Integrated Packages\n| Package | Version | Purpose |\n|---------|---------|---------|\n| agentic-flow | 3.0.0-alpha.1 | Core coordination + ReasoningBank + Router |\n| agentdb | 3.0.0-alpha.10 | Vector database + 8 controllers |\n| @ruvector/attention | 0.1.3 | Flash attention |\n| @ruvector/sona | 0.1.5 | Neural learning |\n\n### Optional Integrations\n| Package | Command |\n|---------|---------|\n| ruv-swarm | `npx ruv-swarm mcp start` |\n| flow-nexus | `npx flow-nexus@latest mcp start` |\n| agentic-jujutsu | `npx agentic-jujutsu@latest` |\n\n### MCP Server Setup\n```bash\n# Add Ruflo MCP\nclaude mcp add ruflo -- npx -y ruflo@latest\n\n# Optional servers\nclaude mcp add ruv-swarm -- npx -y ruv-swarm mcp start\nclaude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start\n```\n\n---\n\n## Quick Reference\n\n### Essential Commands\n```bash\n# Setup\nnpx ruflo@latest init --wizard\nnpx ruflo@latest daemon start\nnpx ruflo@latest doctor --fix\n\n# Swarm\nnpx ruflo@latest swarm init --topology hierarchical --max-agents 8\nnpx ruflo@latest swarm status\n\n# Agents\nnpx ruflo@latest agent spawn -t coder\nnpx ruflo@latest agent list\n\n# Memory\nnpx ruflo@latest memory search --query \"patterns\"\n\n# Hooks\nnpx ruflo@latest hooks pre-task --description \"task\"\nnpx ruflo@latest hooks worker dispatch --trigger optimize\n```\n\n### File Structure\n```\n.claude-flow/\n\u251C\u2500\u2500 config.yaml      # Runtime configuration\n\u251C\u2500\u2500 CAPABILITIES.md  # This file\n\u251C\u2500\u2500 data/            # Memory storage\n\u251C\u2500\u2500 logs/            # Operation logs\n\u251C\u2500\u2500 sessions/        # Session state\n\u251C\u2500\u2500 hooks/           # Custom hooks\n\u251C\u2500\u2500 agents/          # Agent configs\n\u2514\u2500\u2500 workflows/       # Workflow templates\n```\n\n---\n\n**Full Documentation**: https://github.com/ruvnet/claude-flow\n**Issues**: https://github.com/ruvnet/claude-flow/issues\n";
+            fs.writeFileSync(capabilitiesPath, capabilities, 'utf-8');
+            result.created.files.push('.claude-flow/CAPABILITIES.md');
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Write CLAUDE.md with swarm guidance
  */
-async function writeClaudeMd(targetDir, options, result) {
-    const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
-    if (fs.existsSync(claudeMdPath) && !options.force) {
-        result.skipped.push('CLAUDE.md');
-        return;
-    }
-    // Determine template: explicit option > infer from components > 'standard'
-    const inferredTemplate = (!options.components.commands && !options.components.agents) ? 'minimal' : undefined;
-    const content = generateClaudeMd(options, inferredTemplate);
-    fs.writeFileSync(claudeMdPath, content, 'utf-8');
-    result.created.files.push('CLAUDE.md');
+function writeClaudeMd(targetDir, options, result) {
+    return __awaiter(this, void 0, Promise, function () {
+        var claudeMdPath, inferredTemplate, content;
+        return __generator(this, function (_a) {
+            claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+            if (fs.existsSync(claudeMdPath) && !options.force) {
+                result.skipped.push('CLAUDE.md');
+                return [2 /*return*/];
+            }
+            inferredTemplate = (!options.components.commands && !options.components.agents) ? 'minimal' : undefined;
+            content = generateClaudeMd(options, inferredTemplate);
+            fs.writeFileSync(claudeMdPath, content, 'utf-8');
+            result.created.files.push('CLAUDE.md');
+            return [2 /*return*/];
+        });
+    });
 }
 /**
  * Find source directory for skills/commands/agents
  */
 function findSourceDir(type, sourceBaseDir) {
     // Build list of possible paths to check
-    const possiblePaths = [];
+    var possiblePaths = [];
     // If explicit source base directory is provided, use it first
     if (sourceBaseDir) {
         possiblePaths.push(path.join(sourceBaseDir, '.claude', type));
@@ -1663,37 +1334,38 @@ function findSourceDir(type, sourceBaseDir) {
     // This is the primary path when running as an npm package
     // __dirname is typically /path/to/node_modules/@claude-flow/cli/dist/src/init
     // We need to go up 3 levels to reach the package root (dist/src/init -> dist/src -> dist -> root)
-    const packageRoot = path.resolve(__dirname, '..', '..', '..');
-    const packageDotClaude = path.join(packageRoot, '.claude', type);
+    var packageRoot = path.resolve(__dirname, '..', '..', '..');
+    var packageDotClaude = path.join(packageRoot, '.claude', type);
     if (fs.existsSync(packageDotClaude)) {
         possiblePaths.unshift(packageDotClaude); // Add to beginning (highest priority)
     }
     // From dist/src/init -> go up to project root
-    const distPath = __dirname;
+    var distPath = __dirname;
     // Try to find the project root by looking for .claude directory
-    let currentDir = distPath;
-    for (let i = 0; i < 10; i++) {
-        const parentDir = path.dirname(currentDir);
-        const dotClaudePath = path.join(parentDir, '.claude', type);
+    var currentDir = distPath;
+    for (var i = 0; i < 10; i++) {
+        var parentDir = path.dirname(currentDir);
+        var dotClaudePath = path.join(parentDir, '.claude', type);
         if (fs.existsSync(dotClaudePath)) {
             possiblePaths.push(dotClaudePath);
         }
         currentDir = parentDir;
     }
     // Also check relative to process.cwd() for development
-    const cwdBased = [
+    var cwdBased = [
         path.join(process.cwd(), '.claude', type),
         path.join(process.cwd(), '..', '.claude', type),
         path.join(process.cwd(), '..', '..', '.claude', type),
     ];
-    possiblePaths.push(...cwdBased);
+    possiblePaths.push.apply(possiblePaths, cwdBased);
     // Check v2 directory for agents
     if (type === 'agents') {
         possiblePaths.push(path.join(process.cwd(), 'v2', '.claude', type), path.join(process.cwd(), '..', 'v2', '.claude', type));
     }
     // Plugin directory
     possiblePaths.push(path.join(process.cwd(), 'plugin', type), path.join(process.cwd(), '..', 'plugin', type));
-    for (const p of possiblePaths) {
+    for (var _i = 0, possiblePaths_3 = possiblePaths; _i < possiblePaths_3.length; _i++) {
+        var p = possiblePaths_3[_i];
         if (fs.existsSync(p)) {
             return p;
         }
@@ -1705,10 +1377,11 @@ function findSourceDir(type, sourceBaseDir) {
  */
 function copyDirRecursive(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
+    var entries = fs.readdirSync(src, { withFileTypes: true });
+    for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+        var entry = entries_1[_i];
+        var srcPath = path.join(src, entry.name);
+        var destPath = path.join(dest, entry.name);
         if (entry.isDirectory()) {
             copyDirRecursive(srcPath, destPath);
         }
@@ -1721,10 +1394,11 @@ function copyDirRecursive(src, dest) {
  * Count files with extension in directory
  */
 function countFiles(dir, ext) {
-    let count = 0;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
+    var count = 0;
+    var entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+        var entry = entries_2[_i];
+        var fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             count += countFiles(fullPath, ext);
         }
@@ -1738,8 +1412,8 @@ function countFiles(dir, ext) {
  * Count enabled hooks
  */
 function countEnabledHooks(options) {
-    const hooks = options.hooks;
-    let count = 0;
+    var hooks = options.hooks;
+    var count = 0;
     if (hooks.preToolUse)
         count++;
     if (hooks.postToolUse)