moflo 4.6.12 → 4.7.1

package/src/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -2,8 +2,8 @@
  * Hooks MCP Tools
  * Provides intelligent hooks functionality via MCP protocol
  */
-import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
-import { dirname, join, resolve } from 'path';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, readdirSync } from 'fs';
+import { dirname, join, resolve, extname } from 'path';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -1107,21 +1107,9 @@ export const hooksPostTask = {
             }
             catch { /* non-critical */ }
         }
-        // Optionally store in memory DB for cross-session vector retrieval
-        if (params.storeDecisions && taskText && agent) {
-            try {
-                const storeFn = await getRealStoreFunction();
-                if (storeFn) {
-                    await storeFn({
-                        key: `routing-decision:${taskId}`,
-                        namespace: 'patterns',
-                        value: JSON.stringify({ task: taskText, agent, success, quality, keywords: outcomeKeywords }),
-                        tags: ['routing-decision'],
-                    });
-                }
-            }
-            catch { /* non-critical */ }
-        }
+        // Routing learnings are persisted via the file-based routing-outcomes.json above.
+        // No redundant write to the memory DB — the JSON file is the authoritative source
+        // for the routing loop (loadRoutingOutcomes → learnedPatternsFromOutcomes → route).
         const duration = Date.now() - startTime;
         return {
             taskId,
@@ -1204,6 +1192,209 @@ export const hooksExplain = {
     },
 };
 // Pretrain hook - repository analysis for intelligence bootstrap
+/** Recursively collect files matching given extensions up to a limit */
+function collectFiles(dir, extensions, limit, collected = []) {
+    if (collected.length >= limit)
+        return collected;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return collected;
+    }
+    for (const entry of entries) {
+        if (collected.length >= limit)
+            break;
+        const fullPath = join(dir, entry);
+        // Skip common non-source directories
+        if (entry === 'node_modules' || entry === '.git' || entry === 'dist' || entry === 'build' || entry === '.next' || entry === 'coverage')
+            continue;
+        try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                collectFiles(fullPath, extensions, limit, collected);
+            }
+            else if (stat.isFile() && extensions.has(extname(entry).slice(1))) {
+                collected.push(fullPath);
+            }
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return collected;
+}
+/** Simple hash for dedup */
+function simpleHash(str) {
+    let h = 0;
+    for (let i = 0; i < str.length; i++) {
+        h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+    }
+    return Math.abs(h).toString(36);
+}
+/** Extract code patterns from file contents */
+function extractPatterns(files) {
+    const importCounts = new Map();
+    const exportPatterns = { default: 0, named: 0 };
+    const errorPatterns = new Map();
+    const namingStyles = { camelCase: 0, snake_case: 0, PascalCase: 0 };
+    const structurePatterns = new Map();
+    const apiPatterns = new Map();
+    const functionSigs = [];
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(file, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Import patterns
+            const importMatch = trimmed.match(/^import\s+.*?from\s+['"]([^'"]+)['"]/);
+            if (importMatch) {
+                const mod = importMatch[1].startsWith('.') ? '<relative>' : importMatch[1].split('/')[0];
+                importCounts.set(mod, (importCounts.get(mod) || 0) + 1);
+            }
+            const requireMatch = trimmed.match(/require\(['"]([^'"]+)['"]\)/);
+            if (requireMatch) {
+                const mod = requireMatch[1].startsWith('.') ? '<relative>' : requireMatch[1].split('/')[0];
+                importCounts.set(mod, (importCounts.get(mod) || 0) + 1);
+            }
+            // Python imports
+            const pyImport = trimmed.match(/^(?:from\s+(\S+)\s+import|import\s+(\S+))/);
+            if (pyImport) {
+                const mod = (pyImport[1] || pyImport[2]).split('.')[0];
+                importCounts.set(mod, (importCounts.get(mod) || 0) + 1);
+            }
+            // Export patterns
+            if (/^export\s+default\b/.test(trimmed))
+                exportPatterns.default++;
+            else if (/^export\s+(?:const|function|class|interface|type|enum)\b/.test(trimmed))
+                exportPatterns.named++;
+            // Error handling patterns
+            if (/\bcatch\s*\(/.test(trimmed)) {
+                const errType = trimmed.match(/catch\s*\(\s*(\w+)/)?.[1] || 'generic';
+                errorPatterns.set(errType, (errorPatterns.get(errType) || 0) + 1);
+            }
+            if (/throw\s+new\s+(\w+)/.test(trimmed)) {
+                const errClass = trimmed.match(/throw\s+new\s+(\w+)/)?.[1] || 'Error';
+                errorPatterns.set(`throw:${errClass}`, (errorPatterns.get(`throw:${errClass}`) || 0) + 1);
+            }
+            // Function signatures (collect first 50)
+            if (functionSigs.length < 50) {
+                const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+                if (fnMatch)
+                    functionSigs.push(fnMatch[1]);
+                const arrowMatch = trimmed.match(/^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+                if (arrowMatch)
+                    functionSigs.push(arrowMatch[1]);
+            }
+            // Naming conventions from identifiers
+            const identifiers = trimmed.match(/\b[a-zA-Z_]\w{2,}\b/g) || [];
+            for (const id of identifiers.slice(0, 5)) {
+                if (/^[a-z][a-zA-Z0-9]*$/.test(id) && /[A-Z]/.test(id))
+                    namingStyles.camelCase++;
+                else if (/_/.test(id) && id === id.toLowerCase())
+                    namingStyles.snake_case++;
+                else if (/^[A-Z][a-zA-Z0-9]*$/.test(id) && /[a-z]/.test(id))
+                    namingStyles.PascalCase++;
+            }
+            // API/Route patterns
+            const routeMatch = trimmed.match(/\.(get|post|put|patch|delete|use)\s*\(\s*['"\/]/i);
+            if (routeMatch) {
+                const method = routeMatch[1].toUpperCase();
+                apiPatterns.set(method, (apiPatterns.get(method) || 0) + 1);
+            }
+            if (/router\.|app\.|@(Get|Post|Put|Delete|Patch)\b/.test(trimmed)) {
+                apiPatterns.set('route-definition', (apiPatterns.get('route-definition') || 0) + 1);
+            }
+            if (/middleware|\.use\(/.test(trimmed)) {
+                apiPatterns.set('middleware', (apiPatterns.get('middleware') || 0) + 1);
+            }
+            // Structure patterns
+            if (/return\s*\{\s*success/.test(trimmed)) {
+                structurePatterns.set('return-success-object', (structurePatterns.get('return-success-object') || 0) + 1);
+            }
+            if (/class\s+\w+Service\b/.test(trimmed)) {
+                structurePatterns.set('service-class', (structurePatterns.get('service-class') || 0) + 1);
+            }
+            if (/class\s+\w+Controller\b/.test(trimmed)) {
+                structurePatterns.set('controller-class', (structurePatterns.get('controller-class') || 0) + 1);
+            }
+            if (/class\s+\w+Repository\b/.test(trimmed)) {
+                structurePatterns.set('repository-class', (structurePatterns.get('repository-class') || 0) + 1);
+            }
+            if (/interface\s+\w+/.test(trimmed)) {
+                structurePatterns.set('typed-interface', (structurePatterns.get('typed-interface') || 0) + 1);
+            }
+        }
+    }
+    const patterns = [];
+    // Top imports by frequency
+    const sortedImports = [...importCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15);
+    if (sortedImports.length > 0) {
+        patterns.push({
+            type: 'import',
+            value: `Top modules: ${sortedImports.map(([m, c]) => `${m}(${c})`).join(', ')}`,
+            count: sortedImports.reduce((s, [, c]) => s + c, 0),
+            examples: sortedImports.slice(0, 5).map(([m]) => m),
+        });
+    }
+    // Export patterns
+    if (exportPatterns.default + exportPatterns.named > 0) {
+        patterns.push({
+            type: 'export',
+            value: `default:${exportPatterns.default} named:${exportPatterns.named}`,
+            count: exportPatterns.default + exportPatterns.named,
+            examples: exportPatterns.named > exportPatterns.default
+                ? ['Named exports preferred']
+                : ['Default exports preferred'],
+        });
+    }
+    // Error handling
+    const sortedErrors = [...errorPatterns.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+    if (sortedErrors.length > 0) {
+        patterns.push({
+            type: 'error-handling',
+            value: sortedErrors.map(([t, c]) => `${t}(${c})`).join(', '),
+            count: sortedErrors.reduce((s, [, c]) => s + c, 0),
+            examples: sortedErrors.slice(0, 3).map(([t]) => t),
+        });
+    }
+    // Naming conventions
+    const dominant = namingStyles.camelCase >= namingStyles.snake_case ? 'camelCase' : 'snake_case';
+    patterns.push({
+        type: 'naming',
+        value: `camelCase:${namingStyles.camelCase} snake_case:${namingStyles.snake_case} PascalCase:${namingStyles.PascalCase} dominant:${dominant}`,
+        count: namingStyles.camelCase + namingStyles.snake_case + namingStyles.PascalCase,
+        examples: functionSigs.slice(0, 5),
+    });
+    // Structure patterns
+    const sortedStructures = [...structurePatterns.entries()].sort((a, b) => b[1] - a[1]);
+    if (sortedStructures.length > 0) {
+        patterns.push({
+            type: 'structure',
+            value: sortedStructures.map(([t, c]) => `${t}(${c})`).join(', '),
+            count: sortedStructures.reduce((s, [, c]) => s + c, 0),
+            examples: sortedStructures.slice(0, 3).map(([t]) => t),
+        });
+    }
+    // API patterns
+    const sortedApi = [...apiPatterns.entries()].sort((a, b) => b[1] - a[1]);
+    if (sortedApi.length > 0) {
+        patterns.push({
+            type: 'api-pattern',
+            value: sortedApi.map(([t, c]) => `${t}(${c})`).join(', '),
+            count: sortedApi.reduce((s, [, c]) => s + c, 0),
+            examples: sortedApi.slice(0, 3).map(([t]) => t),
+        });
+    }
+    return patterns;
+}
 export const hooksPretrain = {
     name: 'hooks_pretrain',
     description: 'Analyze repository to bootstrap intelligence (4-step pipeline)',
@@ -1212,32 +1403,84 @@ export const hooksPretrain = {
         properties: {
             path: { type: 'string', description: 'Repository path' },
             depth: { type: 'string', description: 'Analysis depth (shallow, medium, deep)' },
+            fileTypes: { type: 'string', description: 'Comma-separated file extensions to scan (default: ts,js,py,md)' },
             skipCache: { type: 'boolean', description: 'Skip cached analysis' },
         },
     },
     handler: async (params) => {
-        const path = params.path || '.';
+        const repoPath = resolve(params.path || '.');
         const depth = params.depth || 'medium';
+        const fileTypesStr = params.fileTypes || 'ts,js,py,md';
         const startTime = Date.now();
-        // Scale analysis results by depth level
-        const multiplier = depth === 'deep' ? 3 : depth === 'shallow' ? 1 : 2;
+        // Determine file limit by depth
+        const fileLimit = depth === 'deep' ? 100 : depth === 'shallow' ? 30 : 60;
+        const extensions = new Set(fileTypesStr.split(',').map(e => e.trim()));
+        // Phase 1: Retrieve - collect source files
+        const retrieveStart = Date.now();
+        const files = collectFiles(repoPath, extensions, fileLimit);
+        const retrieveDuration = Date.now() - retrieveStart;
+        // Phase 2: Judge - extract patterns from files
+        const judgeStart = Date.now();
+        const patterns = extractPatterns(files);
+        const judgeDuration = Date.now() - judgeStart;
+        // Phase 3: Distill - store patterns in memory DB
+        const distillStart = Date.now();
+        let patternsStored = 0;
+        let storageErrors = 0;
+        const storeFn = await getRealStoreFunction();
+        if (storeFn) {
+            for (const pattern of patterns) {
+                const hash = simpleHash(`${pattern.type}:${pattern.value}`);
+                try {
+                    await storeFn({
+                        key: `pattern-${pattern.type}-${hash}`,
+                        value: JSON.stringify({
+                            type: pattern.type,
+                            value: pattern.value,
+                            count: pattern.count,
+                            examples: pattern.examples,
+                            filesAnalyzed: files.length,
+                            extractedAt: new Date().toISOString(),
+                        }),
+                        namespace: 'patterns',
+                        generateEmbeddingFlag: true,
+                        tags: [pattern.type, 'pretrain', `depth-${depth}`],
+                    });
+                    patternsStored++;
+                }
+                catch {
+                    storageErrors++;
+                }
+            }
+        }
+        const distillDuration = Date.now() - distillStart;
+        // Phase 4: Consolidate - summary
+        const consolidateStart = Date.now();
+        const consolidateDuration = Date.now() - consolidateStart;
         return {
-            path,
+            path: repoPath,
             depth,
+            fileTypes: fileTypesStr,
             stats: {
-                filesAnalyzed: 42 * multiplier,
-                patternsExtracted: 15 * multiplier,
-                strategiesLearned: 8 * multiplier,
-                trajectoriesEvaluated: 23 * multiplier,
-                contradictionsResolved: 3,
+                filesAnalyzed: files.length,
+                patternsExtracted: patterns.length,
+                patternsStored,
+                storageErrors,
+                patternTypes: patterns.map(p => p.type),
             },
+            patterns: patterns.map(p => ({
+                type: p.type,
+                summary: p.value,
+                count: p.count,
+                examples: p.examples,
+            })),
             pipeline: {
-                retrieve: { status: 'completed', duration: 120 * multiplier },
-                judge: { status: 'completed', duration: 180 * multiplier },
-                distill: { status: 'completed', duration: 90 * multiplier },
-                consolidate: { status: 'completed', duration: 60 * multiplier },
+                retrieve: { status: 'completed', filesFound: files.length, duration: retrieveDuration },
+                judge: { status: 'completed', patternsFound: patterns.length, duration: judgeDuration },
+                distill: { status: storeFn ? 'completed' : 'skipped', stored: patternsStored, errors: storageErrors, duration: distillDuration },
+                consolidate: { status: 'completed', duration: consolidateDuration },
             },
-            duration: Date.now() - startTime + (500 * multiplier),
+            duration: Date.now() - startTime,
         };
     },
 };
@@ -1993,7 +2236,7 @@ export const hooksPatternStore = {
                     storeResult = await storeFn({
                         key: patternId,
                         value: JSON.stringify({ pattern, type, confidence, metadata, timestamp }),
-                        namespace: 'pattern',
+                        namespace: 'patterns',
                         generateEmbeddingFlag: true,
                         tags: [type, `confidence-${Math.round(confidence * 100)}`, 'reasoning-pattern'],
                     });

package/src/@claude-flow/cli/dist/src/plugins/store/discovery.js

@@ -197,10 +197,10 @@ export class PluginDiscoveryService {
             totalPlugins: plugins.length,
             totalDownloads: plugins.reduce((sum, p) => sum + p.downloads, 0),
             totalAuthors: 1,
-            featured: ['@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims', '@claude-flow/teammate-plugin'],
-            trending: ['@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant'],
-            newest: ['@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant'],
-            official: ['@claude-flow/plugin-agentic-qe', '@claude-flow/plugin-prime-radiant', '@claude-flow/security', '@claude-flow/claims'],
+            featured: ['@claude-flow/security', '@claude-flow/claims'],
+            trending: [],
+            newest: [],
+            official: ['@claude-flow/security', '@claude-flow/claims'],
             compatibilityMatrix: [
                 { pluginId: '@claude-flow/neural', pluginVersion: '3.0.0', claudeFlowVersions: ['3.x'], tested: true },
                 { pluginId: '@claude-flow/security', pluginVersion: '3.0.0', claudeFlowVersions: ['3.x'], tested: true },
@@ -531,124 +531,6 @@ export class PluginDiscoveryService {
                 verified: true,
                 trustLevel: 'official',
             },
-            // Agentic QE - AI-powered quality engineering
-            {
-                id: '@claude-flow/plugin-agentic-qe',
-                name: '@claude-flow/plugin-agentic-qe',
-                displayName: 'Agentic Quality Engineering',
-                description: 'AI-powered quality engineering with 58 agents that write tests, find bugs, predict defects, scan security, and perform chaos engineering safely.',
-                version: '3.0.0-alpha.3',
-                cid: 'bafybeiagenticqeplugin2024',
-                size: 285000,
-                checksum: 'sha256:agenticqe2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml', 'devops', 'security'],
-                tags: ['testing', 'qe', 'tdd', 'security', 'chaos-engineering', 'coverage', 'defect-prediction', 'agents'],
-                keywords: ['quality', 'testing', 'agents', 'tdd', 'security'],
-                downloads: 1200,
-                rating: 4.8,
-                ratingCount: 24,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-20T00:00:00Z',
-                minClaudeFlowVersion: '3.0.0',
-                dependencies: [
-                    { name: '@claude-flow/core', version: '^3.0.0' },
-                ],
-                type: 'integration',
-                hooks: [
-                    'aqe:generate-tests',
-                    'aqe:analyze-coverage',
-                    'aqe:security-scan',
-                    'aqe:predict-defects',
-                    'aqe:chaos-inject',
-                ],
-                commands: [
-                    'aqe generate-tests',
-                    'aqe tdd-cycle',
-                    'aqe security-scan',
-                    'aqe predict-defects',
-                    'aqe chaos-inject',
-                    'aqe quality-gate',
-                    'aqe visual-regression',
-                ],
-                permissions: ['filesystem', 'network', 'memory'],
-                exports: [
-                    'TestGenerator',
-                    'CoverageAnalyzer',
-                    'SecurityScanner',
-                    'DefectPredictor',
-                    'ChaosInjector',
-                    'QualityGate',
-                ],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'claude-flow-security-team',
-                    auditDate: '2026-01-20T00:00:00Z',
-                    auditVersion: '3.0.0-alpha.3',
-                    passed: true,
-                    issues: [],
-                },
-            },
-            // Prime Radiant - Mathematical coherence and consensus verification
-            {
-                id: '@claude-flow/plugin-prime-radiant',
-                name: '@claude-flow/plugin-prime-radiant',
-                displayName: 'Prime Radiant',
-                description: 'Mathematical AI that catches contradictions, verifies consensus, prevents hallucinations, and analyzes swarm stability using sheaf cohomology and spectral graph theory.',
-                version: '0.1.5',
-                cid: 'bafybeiprimeradiantplugin2024',
-                size: 195000,
-                checksum: 'sha256:primeradiant2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml', 'agents'],
-                tags: ['coherence', 'consensus', 'mathematics', 'validation', 'hallucination-prevention', 'spectral', 'causal'],
-                keywords: ['coherence', 'consensus', 'validation', 'mathematics'],
-                downloads: 850,
-                rating: 4.9,
-                ratingCount: 18,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-20T00:00:00Z',
-                minClaudeFlowVersion: '3.0.0',
-                dependencies: [
-                    { name: '@claude-flow/core', version: '^3.0.0' },
-                ],
-                type: 'integration',
-                hooks: [
-                    'pr:pre-memory-store',
-                    'pr:pre-consensus',
-                    'pr:post-swarm-task',
-                    'pr:pre-rag-retrieval',
-                ],
-                commands: [
-                    'pr coherence-check',
-                    'pr consensus-verify',
-                    'pr spectral-analyze',
-                    'pr causal-infer',
-                    'pr memory-gate',
-                    'pr quantum-topology',
-                ],
-                permissions: ['memory', 'hooks'],
-                exports: [
-                    'CoherenceChecker',
-                    'ConsensusVerifier',
-                    'SpectralAnalyzer',
-                    'CausalInference',
-                    'MemoryGate',
-                    'QuantumTopology',
-                ],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'claude-flow-security-team',
-                    auditDate: '2026-01-20T00:00:00Z',
-                    auditVersion: '0.1.5',
-                    passed: true,
-                    issues: [],
-                },
-            },
             // Domain-specific plugins
             {
                 id: '@claude-flow/plugin-healthcare-clinical',
@@ -942,83 +824,6 @@ export class PluginDiscoveryService {
                 verified: true,
                 trustLevel: 'official',
             },
-            // Gas Town Bridge - Multi-agent orchestrator integration
-            {
-                id: '@claude-flow/plugin-gastown-bridge',
-                name: '@claude-flow/plugin-gastown-bridge',
-                displayName: 'Gas Town Bridge',
-                description: 'Gas Town orchestrator integration with WASM-accelerated formula parsing, Beads sync, convoy management, and graph analysis (352x faster).',
-                version: '0.1.0',
-                cid: 'bafybeigastownbridgeplugin2024',
-                size: 485000,
-                checksum: 'sha256:gastownbridge2024xyz',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['integrations', 'agents'],
-                tags: ['gastown', 'orchestration', 'beads', 'formulas', 'wasm', 'convoy', 'workflows'],
-                keywords: ['gastown', 'orchestration', 'beads'],
-                downloads: 0,
-                rating: 0,
-                ratingCount: 0,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-24T00:00:00Z',
-                minClaudeFlowVersion: '3.0.0',
-                dependencies: [{ name: '@claude-flow/core', version: '^3.0.0' }],
-                type: 'integration',
-                hooks: ['gastown:sync', 'gastown:formula', 'gastown:convoy'],
-                commands: ['gastown beads', 'gastown convoy', 'gastown formula', 'gastown sync'],
-                permissions: ['filesystem', 'memory', 'network'],
-                exports: ['BeadsBridge', 'ConvoyManager', 'FormulaEngine', 'GastownSync'],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'claude-flow-security-team',
-                    auditDate: '2026-01-24T00:00:00Z',
-                    auditVersion: '0.1.0',
-                    passed: true,
-                    issues: [],
-                },
-            },
-            // Teammate Plugin - Claude Code v2.1.19+ integration
-            {
-                id: '@claude-flow/teammate-plugin',
-                name: '@claude-flow/teammate-plugin',
-                displayName: 'Teammate Plugin',
-                description: 'Native TeammateTool integration for Claude Code v2.1.19+. Multi-agent team orchestration with plan approval workflows, delegation, messaging, and BMSSP-optimized topology routing. 21 MCP tools.',
-                version: '1.0.0-alpha.1',
-                cid: 'bafybeiteammateplugin2026',
-                size: 387000,
-                checksum: 'sha256:e335dd24ec2e68e8952c517794421a0b18dfb23f',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['agents', 'integrations'],
-                tags: ['teammate', 'claude-code', 'multi-agent', 'swarm', 'orchestration', 'bmssp'],
-                keywords: ['teammate', 'claude-code', 'multi-agent'],
-                downloads: 0,
-                rating: 0,
-                ratingCount: 0,
-                lastUpdated: baseTime,
-                createdAt: '2026-01-25T00:00:00Z',
-                minClaudeFlowVersion: '3.0.0',
-                dependencies: [
-                    { name: '@claude-flow/core', version: '^3.0.0' },
-                    { name: 'eventemitter3', version: '^5.0.1' },
-                ],
-                type: 'integration',
-                hooks: ['teammate:spawn', 'teammate:message', 'teammate:plan', 'teammate:delegate'],
-                commands: ['teammate spawn', 'teammate team', 'teammate message', 'teammate plan'],
-                permissions: ['filesystem', 'memory', 'network'],
-                exports: ['TeammateBridge', 'createTeammateBridge', 'TEAMMATE_MCP_TOOLS', 'TopologyOptimizer', 'SemanticRouter'],
-                verified: true,
-                trustLevel: 'official',
-                securityAudit: {
-                    auditor: 'claude-flow-security-team',
-                    auditDate: '2026-01-25T00:00:00Z',
-                    auditVersion: '1.0.0-alpha.1',
-                    passed: true,
-                    issues: [],
-                },
-            },
         ];
     }
     /**
@@ -1028,15 +833,12 @@ export class PluginDiscoveryService {
         const basePlugins = this.getDemoPlugins();
         // Only fetch stats for real npm packages
         const realNpmPackages = [
-            '@claude-flow/plugin-agentic-qe',
-            '@claude-flow/plugin-prime-radiant',
             '@claude-flow/claims',
             '@claude-flow/security',
             '@claude-flow/plugins',
             '@claude-flow/embeddings',
             '@claude-flow/neural',
             '@claude-flow/performance',
-            '@claude-flow/teammate-plugin',
             // Domain-specific plugins
             '@claude-flow/plugin-healthcare-clinical',
             '@claude-flow/plugin-financial-risk',
@@ -1050,8 +852,6 @@ export class PluginDiscoveryService {
             '@claude-flow/plugin-cognitive-kernel',
             '@claude-flow/plugin-quantum-optimizer',
             '@claude-flow/plugin-hyperbolic-reasoning',
-            // Gas Town Bridge
-            '@claude-flow/plugin-gastown-bridge',
         ];
         // Fetch stats in parallel
         const statsPromises = realNpmPackages.map(pkg => fetchNpmStats(pkg));

package/src/@claude-flow/cli/dist/src/plugins/tests/standalone-test.js

@@ -173,10 +173,10 @@ async function main() {
         console.log('  🎉 All tests passed! Plugin Store is working correctly.');
         console.log('');
         console.log('  Available CLI Commands:');
-        console.log('    npx @claude-flow/cli plugins list');
-        console.log('    npx @claude-flow/cli plugins list --official');
-        console.log('    npx @claude-flow/cli plugins search -q "plugin creator"');
-        console.log('    npx @claude-flow/cli plugins info -n plugin-creator');
+        console.log('    npx moflo plugins list');
+        console.log('    npx moflo plugins list --official');
+        console.log('    npx moflo plugins search -q "plugin creator"');
+        console.log('    npx moflo plugins info -n plugin-creator');
         console.log('');
     }
     process.exit(failed > 0 ? 1 : 0);

package/src/@claude-flow/cli/dist/src/runtime/headless.d.ts

@@ -4,9 +4,9 @@
  * Runs without TTY for daemon processes and scheduled tasks
  *
  * Usage:
- *   npx @claude-flow/cli headless --worker <type>
- *   npx @claude-flow/cli headless --daemon
- *   npx @claude-flow/cli headless --benchmark
+ *   npx moflo headless --worker <type>
+ *   npx moflo headless --daemon
+ *   npx moflo headless --benchmark
  *
  * Environment:
  *   CLAUDE_FLOW_HEADLESS=true