moflo 4.10.24 → 4.10.25

package/dist/src/cli/hooks/workers/index.js

@@ -1,7 +1,7 @@
 /**
  * V3 Workers System - Cross-Platform Background Workers
  *
- * Optimizes Claude Flow with non-blocking, scheduled workers.
+ * Optimizes MoFlo with non-blocking, scheduled workers.
  * Works on Linux, macOS, and Windows.
  */
 import { EventEmitter } from 'events';

package/dist/src/cli/hooks/workers/session-hook.js

@@ -4,7 +4,6 @@
  * Auto-starts workers when Claude Code session begins.
  */
 import { createWorkerManager } from './index.js';
-import * as path from 'path';
 import { errorDetail } from '../../shared/utils/error-detail.js';
 // ============================================================================
 // Session Hook Functions
@@ -104,45 +103,6 @@ export function formatSessionStartOutput(result) {
     return lines.join('\n');
 }
 // ============================================================================
-// Shell Script Generator
-// ============================================================================
-/**
- * Generate a shell hook script for integration with .claude/settings.json
- */
-export function generateShellHook(projectRoot) {
-    const hookPath = path.join(projectRoot, 'v3', '@claude-flow', 'hooks');
-    return `#!/bin/bash
-# Claude Flow V3 Workers - Session Start Hook
-# Auto-generated - do not edit manually
-
-set -euo pipefail
-
-PROJECT_ROOT="${projectRoot}"
-HOOKS_PATH="${hookPath}"
-
-# Run worker initialization via Node.js
-node --experimental-specifier-resolution=node -e "
-const { onSessionStart, formatSessionStartOutput } = require('\${HOOKS_PATH}/dist/workers/session-hook.js');
-
-async function main() {
-  const result = await onSessionStart({
-    projectRoot: '\${PROJECT_ROOT}',
-    autoStart: true,
-    runInitialScan: true,
-    workers: ['health', 'security', 'git'],
-  });
-
-  console.log(formatSessionStartOutput(result));
-}
-
-main().catch(err => {
-  console.error('[Workers] Error:', err.message);
-  process.exit(1);
-});
-"
-`;
-}
-// ============================================================================
 // Integration Helper
 // ============================================================================
 /**

package/dist/src/cli/index.js

@@ -490,14 +490,14 @@ export class CLI {
             ? spawn(`"${process.execPath}" ${spawnArgs.map(a => `"${a}"`).join(' ')}`, [], {
                 cwd: projectRoot,
                 stdio: ['ignore', openSync(logFile, 'a'), openSync(logFile, 'a')],
-                env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
+                env: { ...process.env, MOFLO_DAEMON: '1' },
                 shell: true, windowsHide: true,
             })
             : spawn(process.execPath, spawnArgs, {
                 cwd: projectRoot,
                 detached: true,
                 stdio: ['ignore', openSync(logFile, 'a'), openSync(logFile, 'a')],
-                env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
+                env: { ...process.env, MOFLO_DAEMON: '1' },
             });
         child.unref();
         // Register the spawned daemon PID with the shared ProcessManager so that

package/dist/src/cli/init/executor.js

@@ -21,6 +21,7 @@ import { writeEnvrc } from './envrc-generator.js';
 import { repairHookWiring } from '../services/hook-wiring.js';
 import { locateMofloRootPath } from '../services/moflo-require.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { readMofloEnv } from '../services/env-compat.js';
 /**
  * Skills to copy based on configuration. Exported for integrity tests.
  */
@@ -206,15 +207,19 @@ function mergeSettingsForUpgrade(existing) {
     // Mac/Linux: Use bash-compatible commands with 2>/dev/null
     // 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.
+    // Agent Teams hook config lives in moflo.agentTeams.hooks instead.
     // 1. Merge env vars (preserve existing, add new)
     const existingEnv = existing.env || {};
     const newEnv = {
         ...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',
+        // #1209 — emit MOFLO_* names; carry any pre-rebrand value forward, then
+        // drop the legacy keys so a consumer's settings.json ends up clean.
+        MOFLO_V3_ENABLED: existingEnv.MOFLO_V3_ENABLED || existingEnv.CLAUDE_FLOW_V3_ENABLED || 'true',
+        MOFLO_HOOKS_ENABLED: existingEnv.MOFLO_HOOKS_ENABLED || existingEnv.CLAUDE_FLOW_HOOKS_ENABLED || 'true',
     };
+    delete newEnv.CLAUDE_FLOW_V3_ENABLED;
+    delete newEnv.CLAUDE_FLOW_HOOKS_ENABLED;
     // Remove stale PATH override — ${PATH} isn't expanded by Claude Code,
     // which replaces the inherited PATH and breaks node resolution in hooks.
     delete newEnv.PATH;
@@ -269,7 +274,7 @@ function mergeSettingsForUpgrade(existing) {
     // 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.
+    // Their configuration lives in moflo.agentTeams.hooks instead.
     // 3. Fix statusLine config (remove invalid fields, ensure correct format)
     // Claude Code only supports: type, command, padding
     // Always ensure statusLine is present — add it if missing (e.g. from older inits)
@@ -279,13 +284,19 @@ function mergeSettingsForUpgrade(existing) {
         command: existingStatusLine?.command || `node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs"`,
         // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
     };
-    // 4. 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,
+    // 4. Merge moflo settings (preserve existing, add agentTeams + memory).
+    // #1209 — read the canonical `moflo.*` tree, falling back to the pre-rebrand
+    // `claudeFlow.*` tree, write `moflo.*`, then drop the legacy tree so the
+    // consumer's settings.json migrates in place. The `hooks.locked` escape
+    // hatch survives the move via the spread.
+    const existingMofloTree = existing.moflo ||
+        existing.claudeFlow ||
+        {};
+    const existingMemory = existingMofloTree.memory || {};
+    merged.moflo = {
+        ...existingMofloTree,
+        version: existingMofloTree.version || '3.0.0',
+        enabled: existingMofloTree.enabled !== false,
         agentTeams: {
             enabled: true,
             teammateMode: 'auto',
@@ -309,6 +320,8 @@ function mergeSettingsForUpgrade(existing) {
             agentScopes: existingMemory.agentScopes ?? { enabled: true },
         },
     };
+    // Drop the pre-rebrand tree now that its content lives under `moflo.*`.
+    delete merged.claudeFlow;
     // 5. Repair any missing required hook wirings (same logic doctor --fix uses)
     repairHookWiring(merged);
     return merged;
@@ -579,15 +592,18 @@ export async function executeUpgrade(targetDir, _upgradeSettings = false) {
         else {
             result.preserved.push('.moflo/security/audit-status.json');
         }
-        // 3. Fix .mcp.json — replace stale @moflo/cli references with moflo
+        // 3. Fix .mcp.json — migrate any legacy CLI package spec to moflo.
+        // Consumers may carry an older scoped CLI package — the pre-#586 `claude-flow/cli`
+        // or the transient post-#586 `@moflo/cli`; both collapse to the `moflo` package.
+        // (Prior code checked one scope but replaced the other, so it never fired.)
         const mcpPath = path.join(targetDir, '.mcp.json');
         if (fs.existsSync(mcpPath)) {
             try {
                 const mcpRaw = fs.readFileSync(mcpPath, 'utf-8');
-                if (mcpRaw.includes('@moflo/cli')) {
-                    const mcpFixed = mcpRaw.replace(/@claude-flow\/cli(@latest)?/g, 'moflo');
+                const mcpFixed = mcpRaw.replace(/@(?:claude-flow|moflo)\/cli(@latest)?/g, 'moflo');
+                if (mcpFixed !== mcpRaw) {
                     fs.writeFileSync(mcpPath, mcpFixed, 'utf-8');
-                    result.updated.push('.mcp.json (replaced @moflo/cli with moflo)');
+                    result.updated.push('.mcp.json (migrated legacy CLI package spec to moflo)');
                 }
             }
             catch {
@@ -612,8 +628,8 @@ export async function executeUpgrade(targetDir, _upgradeSettings = false) {
                         'hooks.TeammateIdle (removed — not a valid Claude Code hook)',
                         'hooks.TaskCompleted (removed — not a valid Claude Code hook)',
                         'hooks (repaired missing gate wirings)',
-                        'claudeFlow.agentTeams',
-                        'claudeFlow.memory (learningBridge, memoryGraph, agentScopes)',
+                        'moflo.agentTeams',
+                        'moflo.memory (learningBridge, memoryGraph, agentScopes)',
                         'statusLine',
                     ];
                 }
@@ -721,7 +737,7 @@ export async function executeUpgradeWithMissing(targetDir, _upgradeSettings = fa
         const sourceAgentsDir = findSourceDir('agents');
         const sourceCommandsDir = findSourceDir('commands');
         // Debug: Log source directories found
-        if (process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG) {
+        if (process.env.DEBUG || readMofloEnv('DEBUG')) {
             console.log('[DEBUG] Source directories:');
             console.log(`  Skills: ${sourceSkillsDir || 'NOT FOUND'}`);
             console.log(`  Agents: ${sourceAgentsDir || 'NOT FOUND'}`);
@@ -730,7 +746,7 @@ export async function executeUpgradeWithMissing(targetDir, _upgradeSettings = fa
         // Add missing skills
         if (sourceSkillsDir) {
             const allSkills = Object.values(SKILLS_MAP).flat();
-            const debugMode = process.env.DEBUG || process.env.CLAUDE_FLOW_DEBUG;
+            const debugMode = process.env.DEBUG || readMofloEnv('DEBUG');
             if (debugMode) {
                 console.log(`[DEBUG] Checking ${allSkills.length} skills from SKILLS_MAP`);
             }
@@ -1419,7 +1435,7 @@ async function writeInitialMetrics(targetDir, options, result) {
     }
 }
 /**
- * Write CAPABILITIES.md - comprehensive overview of all Claude Flow features
+ * Write CAPABILITIES.md - comprehensive overview of all MoFlo features
  */
 async function writeCapabilitiesDoc(targetDir, options, result) {
     const capabilitiesPath = path.join(targetDir, '.moflo', 'CAPABILITIES.md');

package/dist/src/cli/init/mcp-generator.js

@@ -57,16 +57,18 @@ export function generateMCPConfig(options) {
     // When toolDefer is true, emit "deferred" so Claude Code loads schemas on
     // demand via ToolSearch instead of putting 150+ schemas into context at startup.
     const deferProps = config.toolDefer ? { toolDefer: 'deferred' } : {};
+    // #1209 — write MOFLO_* into the consumer's .mcp.json; the runtime readers
+    // (loader.ts etc.) still accept the pre-rebrand CLAUDE_FLOW_* names.
     const mcpEnv = {
         ...npmEnv,
-        CLAUDE_FLOW_MODE: 'v3',
-        CLAUDE_FLOW_HOOKS_ENABLED: 'true',
-        CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
-        CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
-        CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
+        MOFLO_MODE: 'v3',
+        MOFLO_HOOKS_ENABLED: 'true',
+        MOFLO_TOPOLOGY: options.runtime.topology,
+        MOFLO_MAX_AGENTS: String(options.runtime.maxAgents),
+        MOFLO_MEMORY_BACKEND: options.runtime.memoryBackend,
     };
-    // Claude Flow MCP server (core) — use direct node when locally installed
-    if (config.claudeFlow) {
+    // moflo MCP server (core) — use direct node when locally installed
+    if (config.moflo) {
         const projectRoot = options.targetDir ?? process.cwd();
         const localCli = findMofloCli(projectRoot);
         if (localCli) {
@@ -100,7 +102,7 @@ export function generateMCPCommands(options) {
     const commands = [];
     const config = options.mcp;
     const cmdPrefix = isWindows ? 'cmd /c ' : '';
-    if (config.claudeFlow) {
+    if (config.moflo) {
         const projectRoot = options.targetDir ?? process.cwd();
         const localCli = findMofloCli(projectRoot);
         if (localCli) {

package/dist/src/cli/init/settings-generator.js

@@ -39,20 +39,23 @@ export function generateSettings(options) {
         pr: '🤖 Generated with [moflo](https://github.com/eric-cielo/moflo)',
     };
     // Note: Claude Code expects 'model' to be a string, not an object
-    // Model preferences are stored in claudeFlow settings instead
+    // Model preferences are stored in moflo settings instead
     // settings.model = 'claude-sonnet-4-5-20250929'; // Uncomment if you want to set a default model
     // Add Agent Teams configuration (experimental feature)
     settings.env = {
         // Enable Claude Code Agent Teams for multi-agent coordination
         CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-        // Claude Flow specific environment
-        CLAUDE_FLOW_V3_ENABLED: 'true',
-        CLAUDE_FLOW_HOOKS_ENABLED: 'true',
+        // moflo-specific environment (#1209 — emit MOFLO_*; readers still accept
+        // the pre-rebrand CLAUDE_FLOW_* names as a fallback via env-compat.ts)
+        MOFLO_V3_ENABLED: 'true',
+        MOFLO_HOOKS_ENABLED: 'true',
     };
     // Detect platform for platform-aware configuration
     const platform = detectPlatform();
-    // Add V3-specific settings
-    settings.claudeFlow = {
+    // Add V3-specific settings (#1209 — canonical `moflo.*` tree; the pre-rebrand
+    // `claudeFlow.*` tree is still read as a fallback by hook-block-hash + the
+    // upgrade merge for consumers who haven't re-run init yet)
+    settings.moflo = {
         version: '3.0.0',
         enabled: true,
         platform: {
@@ -434,7 +437,7 @@ function generateHooksConfig(config) {
         ];
     }
     // NOTE: TeammateIdle and TaskCompleted are NOT valid Claude Code hook events.
-    // Their configuration lives in claudeFlow.agentTeams.hooks instead (see generateSettings).
+    // Their configuration lives in moflo.agentTeams.hooks instead (see generateSettings).
     return hooks;
 }
 /**

package/dist/src/cli/init/types.js

@@ -109,7 +109,7 @@ export const DEFAULT_INIT_OPTIONS = {
         refreshInterval: 5000,
     },
     mcp: {
-        claudeFlow: true,
+        moflo: true,
         ruvSwarm: false,
         flowNexus: false,
         autoStart: false,
@@ -230,7 +230,7 @@ export const FULL_INIT_OPTIONS = {
         all: true,
     },
     mcp: {
-        claudeFlow: true,
+        moflo: true,
         ruvSwarm: true,
         flowNexus: true,
         autoStart: false,

package/dist/src/cli/mcp-server.js

@@ -25,6 +25,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { errorDetail } from './shared/utils/error-detail.js';
 import { findProjectRoot } from './services/project-root.js';
+import { readMofloEnv } from './services/env-compat.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -205,7 +206,7 @@ export class MCPServerManager extends EventEmitter {
             // No PID file found. Detect if we are running in stdio mode
             // (e.g., launched by Claude Code via `claude mcp add`).
             const isStdio = !process.stdin.isTTY;
-            const envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+            const envTransport = readMofloEnv('MCP_TRANSPORT');
             if (isStdio || envTransport === 'stdio' || this.options.transport === 'stdio') {
                 return {
                     running: true,

package/dist/src/cli/memory/bridge-loader.js

@@ -0,0 +1,42 @@
+/**
+ * Lazy AgentDB v3 bridge loader (ADR-053).
+ *
+ * Extracted from `memory-initializer.ts` (#1203 decomposition) so the
+ * HNSW, embedding, entry-CRUD, and init modules share ONE process-wide
+ * bridge singleton instead of each holding their own. Behaviour is
+ * identical to the pre-split inline `getBridge()`: first call attempts the
+ * dynamic import; a failure caches `null` so subsequent calls short-circuit.
+ *
+ * @module memory/bridge-loader
+ */
+// ADR-053: Lazy import of AgentDB v3 bridge.
+// `undefined` = not yet attempted; `null` = attempted and failed (cached).
+let _bridge;
+/**
+ * Return the lazily-loaded memory-bridge module, or `null` if it (or its
+ * native deps) can't be loaded. Result is memoized — a failed load caches
+ * `null` so we don't retry the import on every call.
+ */
+export async function getBridge() {
+    if (_bridge === null)
+        return null;
+    if (_bridge)
+        return _bridge;
+    try {
+        _bridge = await import('./memory-bridge.js');
+        return _bridge;
+    }
+    catch {
+        _bridge = null;
+        return null;
+    }
+}
+/**
+ * True once the bridge module has been successfully loaded. Lets callers
+ * (e.g. `getHNSWStatus`) report AgentDB-v3 availability without forcing a
+ * load. Mirrors the pre-split `_bridge && _bridge !== null` check.
+ */
+export function isBridgeLoaded() {
+    return !!_bridge;
+}
+//# sourceMappingURL=bridge-loader.js.map

package/dist/src/cli/memory/embedding-model.js

@@ -0,0 +1,157 @@
+/**
+ * Neural embedding model manager.
+ *
+ * Extracted from `memory-initializer.ts` (#1203 decomposition). Lazily loads
+ * the fastembed-backed embedding service (ONNX all-MiniLM-L6-v2) and generates
+ * embeddings. There is NO hash fallback — a failed model load throws (hash
+ * embeddings were removed in epic #527).
+ *
+ * @module memory/embedding-model
+ */
+import { formatEmbeddingError } from './embedding-errors.js';
+import { getBridge } from './bridge-loader.js';
+let embeddingModelState = null;
+/**
+ * Lazy-load the neural embedding service.
+ *
+ * Delegates to the local fastembed-backed service. Returns a diagnostic
+ * result for callers that want to report status; if model loading fails later
+ * on first `embed()`, that throws from `generateEmbedding`.
+ */
+export async function loadEmbeddingModel(options) {
+    const { verbose = false } = options || {};
+    const startTime = Date.now();
+    if (embeddingModelState?.loaded) {
+        return {
+            success: true,
+            dimensions: embeddingModelState.dimensions,
+            modelName: 'cached',
+            loadTime: 0,
+        };
+    }
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeLoadEmbeddingModel();
+        if (bridgeResult && bridgeResult.success) {
+            embeddingModelState = {
+                loaded: true,
+                service: null, // Bridge handles embedding
+                dimensions: bridgeResult.dimensions,
+                modelName: bridgeResult.modelName || 'bridge',
+            };
+            return bridgeResult;
+        }
+    }
+    if (verbose) {
+        console.log('Preparing neural embedding runtime (fastembed / all-MiniLM-L6-v2)...');
+    }
+    const { createEmbeddingService } = await import('../embeddings/embedding-service.js');
+    const service = createEmbeddingService({
+        provider: 'fastembed',
+        dimensions: 384,
+    });
+    embeddingModelState = {
+        loaded: true,
+        service,
+        dimensions: 384,
+        modelName: 'fastembed/all-MiniLM-L6-v2',
+    };
+    return {
+        success: true,
+        dimensions: 384,
+        modelName: 'fastembed/all-MiniLM-L6-v2',
+        loadTime: Date.now() - startTime,
+    };
+}
+/**
+ * Generate a neural embedding for text.
+ *
+ * Uses the fastembed-backed service from cli's embeddings module. Throws on model
+ * load / inference failure — there is no hash fallback.
+ */
+export async function generateEmbedding(text) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGenerateEmbedding(text);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    if (!embeddingModelState?.loaded) {
+        const load = await loadEmbeddingModel();
+        if (!load.success) {
+            throw new Error(formatEmbeddingError(load.error ?? 'unknown error'));
+        }
+    }
+    const state = embeddingModelState;
+    if (!state.service) {
+        throw new Error(`Embedding model state has no active service. Bridge-backed state requires ` +
+            `bridge.bridgeGenerateEmbedding(); hash fallback was removed in epic #527.`);
+    }
+    let result;
+    try {
+        result = await state.service.embed(text);
+    }
+    catch (err) {
+        throw new Error(formatEmbeddingError(err));
+    }
+    const embedding = Array.from(result.embedding);
+    return {
+        embedding,
+        dimensions: embedding.length,
+        model: state.modelName,
+    };
+}
+/**
+ * Generate embeddings for multiple texts
+ * Uses parallel execution for API-based providers (2-4x faster)
+ * Note: Local ONNX inference is CPU-bound, so parallelism has limited benefit
+ *
+ * @param texts - Array of texts to embed
+ * @param options - Batch options
+ * @returns Array of embedding results with timing info
+ */
+export async function generateBatchEmbeddings(texts, options) {
+    const { concurrency = texts.length, onProgress } = options || {};
+    const startTime = Date.now();
+    // Ensure model is loaded first (prevents cold start in parallel)
+    if (!embeddingModelState?.loaded) {
+        await loadEmbeddingModel();
+    }
+    // Process in parallel with optional concurrency limit
+    if (concurrency >= texts.length) {
+        // Full parallelism
+        const embeddings = await Promise.all(texts.map(async (text, i) => {
+            const result = await generateEmbedding(text);
+            onProgress?.(i + 1, texts.length);
+            return { text, ...result };
+        }));
+        const totalTime = Date.now() - startTime;
+        return {
+            results: embeddings,
+            totalTime,
+            avgTime: totalTime / texts.length
+        };
+    }
+    // Limited concurrency using chunking
+    const results = [];
+    let completed = 0;
+    for (let i = 0; i < texts.length; i += concurrency) {
+        const chunk = texts.slice(i, i + concurrency);
+        const chunkResults = await Promise.all(chunk.map(async (text) => {
+            const result = await generateEmbedding(text);
+            completed++;
+            onProgress?.(completed, texts.length);
+            return { text, ...result };
+        }));
+        results.push(...chunkResults);
+    }
+    const totalTime = Date.now() - startTime;
+    return {
+        results,
+        totalTime,
+        avgTime: totalTime / texts.length
+    };
+}
+//# sourceMappingURL=embedding-model.js.map