moflo 4.8.9 → 4.8.11

package/src/@claude-flow/cli/dist/src/commands/hive-mind.js

@@ -50,96 +50,96 @@ function generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGr
     const queenType = flags.queenType || 'strategic';
     const consensusAlgorithm = flags.consensus || 'byzantine';
     const topology = flags.topology || 'hierarchical-mesh';
-    return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
-═══════════════════════════════════════════════
-
-You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
-
-HIVE MIND CONFIGURATION:
-📌 Swarm ID: ${swarmId}
-📌 Swarm Name: ${swarmName}
-🎯 Objective: ${objective}
-👑 Queen Type: ${queenType}
-🐝 Worker Count: ${workers.length}
-🔗 Topology: ${topology}
-🤝 Consensus Algorithm: ${consensusAlgorithm}
-⏰ Initialized: ${currentTime}
-
-WORKER DISTRIBUTION:
-${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
-
-🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
-
-1️⃣ **COLLECTIVE INTELLIGENCE**
-   mcp__claude-flow__hive-mind_consensus    - Democratic decision making
-   mcp__claude-flow__hive-mind_memory       - Share knowledge across the hive
-   mcp__claude-flow__hive-mind_broadcast    - Broadcast to all workers
-   mcp__claude-flow__neural_patterns        - Neural pattern recognition
-
-2️⃣ **QUEEN COORDINATION**
-   mcp__claude-flow__hive-mind_status       - Monitor swarm health
-   mcp__claude-flow__task_create            - Create and delegate tasks
-   mcp__claude-flow__task_orchestrate       - Orchestrate task distribution
-   mcp__claude-flow__agent_spawn            - Spawn additional workers
-
-3️⃣ **WORKER MANAGEMENT**
-   mcp__claude-flow__agent_list             - List all active agents
-   mcp__claude-flow__agent_status           - Check agent status
-   mcp__claude-flow__agent_metrics          - Track worker performance
-   mcp__claude-flow__hive-mind_join         - Add agent to hive
-   mcp__claude-flow__hive-mind_leave        - Remove agent from hive
-
-4️⃣ **TASK ORCHESTRATION**
-   mcp__claude-flow__task_create            - Create hierarchical tasks
-   mcp__claude-flow__task_status            - Track task progress
-   mcp__claude-flow__task_complete          - Mark tasks complete
-   mcp__claude-flow__workflow_create        - Create workflows
-
-5️⃣ **MEMORY & LEARNING**
-   mcp__claude-flow__memory_store           - Store collective knowledge
-   mcp__claude-flow__memory_retrieve        - Access shared memory
-   mcp__claude-flow__memory_search          - Search memory patterns
-   mcp__claude-flow__neural_train           - Learn from experiences
-   mcp__claude-flow__hooks_intelligence_pattern-store - Store patterns
-
-📋 HIVE MIND EXECUTION PROTOCOL:
-
-1. **INITIALIZATION PHASE**
-   - Verify all workers are online and responsive
-   - Establish communication channels
-   - Load previous session state if available
-   - Initialize shared memory space
-
-2. **TASK DISTRIBUTION PHASE**
-   - Analyze the objective and decompose into subtasks
-   - Assign tasks based on worker specializations
-   - Set up task dependencies and ordering
-   - Monitor parallel execution
-
-3. **COORDINATION PHASE**
-   - Use consensus for critical decisions
-   - Aggregate results from workers
-   - Resolve conflicts using ${consensusAlgorithm} consensus
-   - Share learnings across the hive
-
-4. **COMPLETION PHASE**
-   - Verify all subtasks are complete
-   - Consolidate results
-   - Store learnings in collective memory
-   - Report final status
-
-🎯 YOUR OBJECTIVE:
-${objective}
-
-💡 COORDINATION TIPS:
-• Use mcp__claude-flow__hive-mind_broadcast for swarm-wide announcements
-• Check worker status regularly with mcp__claude-flow__hive-mind_status
-• Store important decisions in shared memory for persistence
-• Use consensus for any decisions affecting multiple workers
-• Monitor task progress and reassign if workers are blocked
-
-🚀 BEGIN HIVE MIND COORDINATION NOW!
-Start by checking the current hive status and then proceed with the objective.
+    return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
+═══════════════════════════════════════════════
+
+You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
+
+HIVE MIND CONFIGURATION:
+📌 Swarm ID: ${swarmId}
+📌 Swarm Name: ${swarmName}
+🎯 Objective: ${objective}
+👑 Queen Type: ${queenType}
+🐝 Worker Count: ${workers.length}
+🔗 Topology: ${topology}
+🤝 Consensus Algorithm: ${consensusAlgorithm}
+⏰ Initialized: ${currentTime}
+
+WORKER DISTRIBUTION:
+${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
+
+🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
+
+1️⃣ **COLLECTIVE INTELLIGENCE**
+   mcp__moflo__hive-mind_consensus    - Democratic decision making
+   mcp__moflo__hive-mind_memory       - Share knowledge across the hive
+   mcp__moflo__hive-mind_broadcast    - Broadcast to all workers
+   mcp__moflo__neural_patterns        - Neural pattern recognition
+
+2️⃣ **QUEEN COORDINATION**
+   mcp__moflo__hive-mind_status       - Monitor swarm health
+   mcp__moflo__task_create            - Create and delegate tasks
+   mcp__moflo__task_orchestrate       - Orchestrate task distribution
+   mcp__moflo__agent_spawn            - Spawn additional workers
+
+3️⃣ **WORKER MANAGEMENT**
+   mcp__moflo__agent_list             - List all active agents
+   mcp__moflo__agent_status           - Check agent status
+   mcp__moflo__agent_metrics          - Track worker performance
+   mcp__moflo__hive-mind_join         - Add agent to hive
+   mcp__moflo__hive-mind_leave        - Remove agent from hive
+
+4️⃣ **TASK ORCHESTRATION**
+   mcp__moflo__task_create            - Create hierarchical tasks
+   mcp__moflo__task_status            - Track task progress
+   mcp__moflo__task_complete          - Mark tasks complete
+   mcp__moflo__workflow_create        - Create workflows
+
+5️⃣ **MEMORY & LEARNING**
+   mcp__moflo__memory_store           - Store collective knowledge
+   mcp__moflo__memory_retrieve        - Access shared memory
+   mcp__moflo__memory_search          - Search memory patterns
+   mcp__moflo__neural_train           - Learn from experiences
+   mcp__moflo__hooks_intelligence_pattern-store - Store patterns
+
+📋 HIVE MIND EXECUTION PROTOCOL:
+
+1. **INITIALIZATION PHASE**
+   - Verify all workers are online and responsive
+   - Establish communication channels
+   - Load previous session state if available
+   - Initialize shared memory space
+
+2. **TASK DISTRIBUTION PHASE**
+   - Analyze the objective and decompose into subtasks
+   - Assign tasks based on worker specializations
+   - Set up task dependencies and ordering
+   - Monitor parallel execution
+
+3. **COORDINATION PHASE**
+   - Use consensus for critical decisions
+   - Aggregate results from workers
+   - Resolve conflicts using ${consensusAlgorithm} consensus
+   - Share learnings across the hive
+
+4. **COMPLETION PHASE**
+   - Verify all subtasks are complete
+   - Consolidate results
+   - Store learnings in collective memory
+   - Report final status
+
+🎯 YOUR OBJECTIVE:
+${objective}
+
+💡 COORDINATION TIPS:
+• Use mcp__moflo__hive-mind_broadcast for swarm-wide announcements
+• Check worker status regularly with mcp__moflo__hive-mind_status
+• Store important decisions in shared memory for persistence
+• Use consensus for any decisions affecting multiple workers
+• Monitor task progress and reassign if workers are blocked
+
+🚀 BEGIN HIVE MIND COORDINATION NOW!
+Start by checking the current hive status and then proceed with the objective.
 `;
 }
 /**

package/src/@claude-flow/cli/dist/src/commands/index.d.ts

@@ -30,6 +30,7 @@ export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { diagnoseCommand } from './diagnose.js';
+export { githubCommand } from './github.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;

package/src/@claude-flow/cli/dist/src/commands/index.js

@@ -67,6 +67,8 @@ const commandLoaders = {
     gate: () => import('./gate.js'),
     // Feature Orchestrator
     orc: () => import('./orc.js'),
+    // GitHub Repository Setup
+    github: () => import('./github.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -137,6 +139,7 @@ import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
 import { applianceCommand } from './appliance.js';
 import { diagnoseCommand } from './diagnose.js';
+import { githubCommand } from './github.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -158,6 +161,7 @@ loadedCommands.set('ruvector', ruvectorCommand);
 loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
 loadedCommands.set('diagnose', diagnoseCommand);
+loadedCommands.set('github', githubCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
@@ -183,6 +187,7 @@ export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { diagnoseCommand } from './diagnose.js';
+export { githubCommand } from './github.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -233,6 +238,7 @@ export const commands = [
     hiveMindCommand,
     guidanceCommand,
     diagnoseCommand,
+    githubCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -282,6 +288,7 @@ export const commandsByCategory = {
         updateCommand,
         processCommand,
         applianceCommand,
+        githubCommand,
     ],
 };
 /**

package/src/@claude-flow/cli/dist/src/config-adapter.js

@@ -118,7 +118,7 @@ export function v3ConfigToSystemConfig(v3Config) {
             },
         },
         mcp: {
-            name: 'claude-flow',
+            name: 'moflo',
             version: '3.0.0',
             transport: {
                 type: v3Config.mcp.transportType,

package/src/@claude-flow/cli/dist/src/init/claudemd-generator.js

@@ -364,7 +364,7 @@ function setupAndBoundary() {
     return `## Quick Setup
 
 \`\`\`bash
-claude mcp add claude-flow -- npx -y moflo
+claude mcp add moflo -- npx -y moflo
 npx moflo daemon start
 npx moflo doctor --fix
 \`\`\`

package/src/@claude-flow/cli/dist/src/init/executor.js

@@ -14,7 +14,7 @@ import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
 import { generateStatuslineScript } from './statusline-generator.js';
-import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, generateGateScript, generateHookHandlerScript, } from './helpers-generator.js';
+import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, generateGateScript, generateGateHookScript, generatePromptHookScript, generateHookHandlerScript, } from './helpers-generator.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 /**
  * Skills to copy based on configuration
@@ -377,6 +377,8 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             const generatedCritical = {
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
                 'gate.cjs': generateGateScript(),
+                'gate-hook.mjs': generateGateHookScript(),
+                'prompt-hook.mjs': generatePromptHookScript(),
                 'hook-handler.cjs': generateHookHandlerScript(),
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
@@ -463,6 +465,22 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 }
             }
         }
+        // 1c. Build manifest of files we're installing, clean up stale ones
+        const manifestPath = path.join(targetDir, '.claude-flow', 'installed-files.json');
+        let previousManifest = [];
+        try {
+            previousManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch { /* ok */ }
+        const currentManifest = [];
+        // Collect everything we just synced into the manifest
+        for (const entry of [...result.created, ...result.updated]) {
+            // Strip annotations like " (removed, obsolete)" — keep only clean paths
+            const clean = entry.replace(/\s*\(.*\)$/, '');
+            if (clean.startsWith('.claude/') || clean.startsWith('.claude-flow/')) {
+                currentManifest.push(clean);
+            }
+        }
         // 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');
@@ -579,6 +597,39 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 result.settingsUpdated = ['Created new settings.json with Agent Teams'];
             }
         }
+        // ── Final: collect any additional generated files into manifest, then clean up stale ──
+        // Re-scan result arrays since metrics/security files were added after initial collection
+        for (const entry of [...result.created, ...result.updated]) {
+            const clean = entry.replace(/\s*\(.*\)$/, '');
+            if ((clean.startsWith('.claude/') || clean.startsWith('.claude-flow/')) && !currentManifest.includes(clean)) {
+                currentManifest.push(clean);
+            }
+        }
+        // Remove files that were in the OLD manifest but NOT in the new one.
+        // This only deletes files moflo previously installed — never user or runtime files.
+        if (previousManifest.length > 0) {
+            const currentSet = new Set(currentManifest);
+            for (const rel of previousManifest) {
+                if (!currentSet.has(rel)) {
+                    const abs = path.join(targetDir, rel);
+                    try {
+                        if (fs.existsSync(abs)) {
+                            fs.unlinkSync(abs);
+                            result.updated.push(`${rel} (removed, no longer shipped)`);
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                }
+            }
+        }
+        // Write manifest for next upgrade
+        try {
+            const cfDir = path.join(targetDir, '.claude-flow');
+            if (!fs.existsSync(cfDir))
+                fs.mkdirSync(cfDir, { recursive: true });
+            fs.writeFileSync(manifestPath, JSON.stringify(currentManifest, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal */ }
     }
     catch (error) {
         result.success = false;
@@ -713,12 +764,63 @@ async function writeSettings(targetDir, options, result) {
 }
 /**
  * Write .mcp.json
+ *
+ * If an existing config contains the legacy 'claude-flow' server key, prompt
+ * the user to migrate it to 'moflo', keep both side-by-side, or leave as-is.
  */
 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;
+    if (fs.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        const servers = existing?.mcpServers ?? {};
+        const hasLegacy = 'claude-flow' in servers;
+        const hasMoflo = 'moflo' in servers;
+        if (hasLegacy && !hasMoflo) {
+            // Interactive mode: prompt the user
+            if (process.stdin.isTTY && !options.force) {
+                const { select } = await import('../prompt.js');
+                const action = await select({
+                    message: "Found existing 'claude-flow' MCP server. How should we handle it?",
+                    options: [
+                        { value: 'migrate', label: 'Migrate to moflo', hint: 'Rename claude-flow → moflo (recommended)' },
+                        { value: 'side-by-side', label: 'Keep both', hint: 'Add moflo alongside existing claude-flow' },
+                        { value: 'skip', label: 'Skip', hint: 'Leave .mcp.json unchanged' },
+                    ],
+                    default: 'migrate',
+                });
+                if (action === 'skip') {
+                    result.skipped.push('.mcp.json');
+                    return;
+                }
+                if (action === 'migrate') {
+                    servers['moflo'] = servers['claude-flow'];
+                    delete servers['claude-flow'];
+                    existing.mcpServers = servers;
+                    fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+                    result.created.files.push('.mcp.json (migrated claude-flow → moflo)');
+                    return;
+                }
+                // side-by-side: fall through to generate new config and merge
+                const newConfig = JSON.parse(generateMCPJson(options));
+                Object.assign(servers, newConfig.mcpServers ?? {});
+                existing.mcpServers = servers;
+                fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+                result.created.files.push('.mcp.json (added moflo alongside claude-flow)');
+                return;
+            }
+            // Non-interactive (CI/pipe): auto-migrate silently
+            servers['moflo'] = servers['claude-flow'];
+            delete servers['claude-flow'];
+            existing.mcpServers = servers;
+            fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+            result.created.files.push('.mcp.json (auto-migrated claude-flow → moflo)');
+            return;
+        }
+        // Already has moflo or no legacy key — skip unless forced
+        if (!options.force) {
+            result.skipped.push('.mcp.json');
+            return;
+        }
     }
     const content = generateMCPJson(options);
     fs.writeFileSync(mcpPath, content, 'utf-8');
@@ -1012,6 +1114,8 @@ async function writeHelpers(targetDir, options, result) {
         'post-commit': generatePostCommitHook(),
         'auto-memory-hook.mjs': generateAutoMemoryHook(),
         'gate.cjs': generateGateScript(),
+        'gate-hook.mjs': generateGateHookScript(),
+        'prompt-hook.mjs': generatePromptHookScript(),
         'hook-handler.cjs': generateHookHandlerScript(),
     };
     for (const [name, content] of Object.entries(helpers)) {
@@ -1653,7 +1757,7 @@ npx moflo hive-mind consensus --propose "task"
 ### MCP Server Setup
 \`\`\`bash
 # Add Claude Flow MCP
-claude mcp add claude-flow -- npx -y moflo
+claude mcp add moflo -- npx -y moflo
 
 # Optional servers
 claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start

package/src/@claude-flow/cli/dist/src/init/helpers-generator.d.ts

@@ -28,6 +28,20 @@ export declare function generateHelpers(options: InitOptions): Record<string, st
  * on every tool call (~500ms npx overhead → ~20ms direct node).
  */
 export declare function generateGateScript(): string;
+/**
+ * Generate gate-hook.mjs — ESM wrapper that reads Claude Code stdin JSON
+ * and passes tool_name + tool_input to gate.cjs via environment variables.
+ *
+ * Claude Code hooks receive context as JSON on stdin but don't set env vars
+ * for tool input. This script bridges that gap. It also translates exit code 1
+ * from gate.cjs into exit code 2 (which Claude Code requires to block tools).
+ */
+export declare function generateGateHookScript(): string;
+/**
+ * Generate prompt-hook.mjs — reads user prompt from Claude Code stdin JSON,
+ * runs prompt classification via gate.cjs, and appends namespace hints.
+ */
+export declare function generatePromptHookScript(): string;
 /**
  * Generate lightweight hook-handler.cjs — hook dispatch without CLI bootstrap.
  * Handles routing, edit/task tracking, session lifecycle, and notifications.