@claude-flow/cli 3.25.4 → 3.25.6

package/.claude/helpers/helpers.manifest.json

@@ -1,12 +1,12 @@
 {
   "manifest": {
-    "version": "3.25.4",
+    "version": "3.25.6",
     "files": {
       "auto-memory-hook.mjs": "68be7e9a9eba7bf9c4e8a230db7bf61a243b965639f8504842799d6c6ca28762",
       "hook-handler.cjs": "bc4d2d26823d49b3ab1dded2946b66369f1f67bd76b4c30dca9f3b6df3cca8f0",
       "intelligence.cjs": "bd1f8e4b034944aee1df0391dc47ac2e8cc4b3aa542c65407a59d49620bbf76b"
     }
   },
-  "signature": "F3TIRoNcQTCkNeMEk5Isah5CWkV/zddUKR/6pieOlAWoYgI2BEUO7avQj8B8UP4vhvgT9TSgbYsis2UnnnQyBg==",
+  "signature": "3D6EGXwOvFuWMNrgRU9zcNzvyxyzmDMdsCaOOs74M9sTouS2soV0yrNhyybgbqFf8bhy08KDLW0O7tohDYLbBg==",
   "algorithm": "ed25519"
 }

package/dist/src/commands/doctor.js

@@ -442,53 +442,98 @@ async function checkMcpServers() {
         '.mcp.json',
     ];
     const isRufloKey = (k) => k === 'ruflo' || k === 'ruflo_alpha' || k === 'claude-flow' || k === 'claude-flow_alpha';
+    // Canonical MCP-server key is `claude-flow` — matches the `mcp__claude-flow__*`
+    // prefix that ~166 plugin tool references depend on (#2206). A `ruflo`-keyed
+    // entry pointing at the same binary is the legacy duplicate created by
+    // pre-rename setup docs that #2612 tracks; doctor treats it as removable.
+    const isCurrentRufloKey = (k) => k === 'claude-flow' || k === 'claude-flow_alpha';
+    const isLegacyRufloKey = (k) => k === 'ruflo' || k === 'ruflo_alpha';
+    const isRufloServer = (server) => {
+        if (!server || typeof server !== 'object')
+            return false;
+        const entry = server;
+        const command = typeof entry.command === 'string' ? entry.command : '';
+        const args = Array.isArray(entry.args)
+            ? entry.args.filter((arg) => typeof arg === 'string')
+            : [];
+        const haystack = [command, ...args].join(' ');
+        return /\b(?:ruflo|claude-flow|@claude-flow\/cli)(?:@[\w.-]+)?\b/.test(haystack);
+    };
+    let totalServersSeen = 0;
+    const rufloLocations = [];
+    const duplicateLocations = [];
+    const legacyLocations = [];
+    const currentLocations = [];
+    const inspectServers = (servers, location) => {
+        if (!servers || typeof servers !== 'object')
+            return { total: 0, hasRuflo: false };
+        const entries = Object.entries(servers);
+        const activeRufloEntries = entries.filter(([key, server]) => isRufloKey(key) && isRufloServer(server));
+        const hasLegacy = activeRufloEntries.some(([key]) => isLegacyRufloKey(key));
+        const hasCurrent = activeRufloEntries.some(([key]) => isCurrentRufloKey(key));
+        if (activeRufloEntries.length > 0) {
+            rufloLocations.push(`${location}: ${activeRufloEntries.map(([key]) => key).join(', ')}`);
+        }
+        if (hasLegacy && hasCurrent) {
+            duplicateLocations.push(`${location}: ${activeRufloEntries.map(([key]) => key).join(' + ')}`);
+        }
+        for (const [key] of activeRufloEntries) {
+            if (isLegacyRufloKey(key))
+                legacyLocations.push(`${location}: ${key}`);
+            if (isCurrentRufloKey(key))
+                currentLocations.push(`${location}: ${key}`);
+        }
+        return { total: entries.length, hasRuflo: activeRufloEntries.length > 0 };
+    };
     for (const configPath of mcpConfigPaths) {
         if (!existsSync(configPath))
             continue;
         try {
             const content = JSON.parse(readFileSync(configPath, 'utf8'));
             // Top-level mcpServers (legacy / desktop form)
-            const topServers = content.mcpServers || content.servers || {};
-            const topServerKeys = Object.keys(topServers);
-            const topHasRuflo = topServerKeys.some(isRufloKey);
+            const topResult = inspectServers(content.mcpServers || content.servers || {}, `${configPath} top-level`);
+            totalServersSeen += topResult.total;
             // Project-scoped (Claude Code shape): projects[*].mcpServers.ruflo
-            let projectHits = 0;
-            let projectScannedServers = 0;
             if (content.projects && typeof content.projects === 'object') {
-                for (const projectVal of Object.values(content.projects)) {
+                for (const [projectKey, projectVal] of Object.entries(content.projects)) {
                     const pm = projectVal?.mcpServers;
                     if (pm && typeof pm === 'object') {
-                        const keys = Object.keys(pm);
-                        projectScannedServers += keys.length;
-                        if (keys.some(isRufloKey))
-                            projectHits += 1;
+                        const projectResult = inspectServers(pm, `${configPath} projects[${projectKey}]`);
+                        totalServersSeen += projectResult.total;
                     }
                 }
             }
-            const totalServers = topServerKeys.length + projectScannedServers;
-            if (topHasRuflo || projectHits > 0) {
-                const where = topHasRuflo
-                    ? 'top-level'
-                    : `${projectHits} project-scoped`;
-                return {
-                    name: 'MCP Servers',
-                    status: 'pass',
-                    message: `${totalServers} servers (ruflo configured: ${where})`,
-                };
-            }
-            if (totalServers > 0) {
-                return {
-                    name: 'MCP Servers',
-                    status: 'warn',
-                    message: `${totalServers} servers (ruflo not found)`,
-                    fix: 'claude mcp add ruflo -- npx -y ruflo@latest mcp start',
-                };
-            }
         }
         catch {
             // continue to next path
         }
     }
+    if (duplicateLocations.length > 0 || (legacyLocations.length > 0 && currentLocations.length > 0)) {
+        const locations = duplicateLocations.length > 0
+            ? duplicateLocations.join('; ')
+            : `legacy ${legacyLocations.join('; ')} + current ${currentLocations.join('; ')}`;
+        return {
+            name: 'MCP Servers',
+            status: 'warn',
+            message: `Duplicate Ruflo MCP registrations found (${locations}) — Claude Code will start both tool schemas`,
+            fix: 'Remove the legacy `ruflo`-keyed MCP registration (pre-rename duplicate) and keep the canonical `claude-flow` entry: `claude mcp add claude-flow -- npx -y ruflo@latest mcp start`. The canonical key stays `claude-flow` so the ~166 `mcp__claude-flow__*` plugin tool references keep resolving (#2206).',
+        };
+    }
+    if (rufloLocations.length > 0) {
+        return {
+            name: 'MCP Servers',
+            status: 'pass',
+            message: `${totalServersSeen} servers (ruflo configured: ${rufloLocations.join('; ')})`,
+        };
+    }
+    if (totalServersSeen > 0) {
+        return {
+            name: 'MCP Servers',
+            status: 'warn',
+            message: `${totalServersSeen} servers (ruflo not found)`,
+            fix: 'claude mcp add claude-flow -- npx -y ruflo@latest mcp start',
+        };
+    }
     return {
         name: 'MCP Servers',
         status: 'warn',

package/dist/src/commands/neural.js

@@ -1516,8 +1516,12 @@ const benchmarkCommand = {
         const spinner = output.createSpinner({ text: 'Running benchmarks...', spinner: 'dots' });
         spinner.start();
         try {
+            // Indirect the specifier through a string variable so tsc doesn't
+            // statically resolve this optional dependency at build time (TS2307
+            // when it isn't installed — install-safety / Build V3 pattern from #2586).
+            const attentionPkg = '@ruvector/attention';
             // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic import of optional native WASM module with no type declarations
-            const attention = await import('@ruvector/attention');
+            const attention = await import(attentionPkg);
             // Manual benchmark since benchmarkAttention has a binding bug
             const benchmarkMechanism = async (name, mechanism) => {
                 const query = new Float32Array(dim);
@@ -1591,13 +1595,16 @@ const benchmarkCommand = {
             // Also benchmark MicroLoRA
             spinner.start();
             spinner.setText('Benchmarking MicroLoRA adaptation...');
-            // Load WASM file directly (Node.js compatible)
+            // Load WASM file directly (Node.js compatible). Indirect the specifier
+            // through a string variable so tsc doesn't statically resolve this
+            // optional dependency at build time (TS2307 when absent — #2586 pattern).
             const fs = await import('fs');
             const { createRequire } = await import('module');
             const require = createRequire(import.meta.url);
-            const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+            const learningWasmPkg = '@ruvector/learning-wasm';
+            const wasmPath = require.resolve(`${learningWasmPkg}/ruvector_learning_wasm_bg.wasm`);
             const wasmBuffer = fs.readFileSync(wasmPath);
-            const learningWasm = await import('@ruvector/learning-wasm');
+            const learningWasm = await import(learningWasmPkg);
             learningWasm.initSync({ module: wasmBuffer });
             const lora = new learningWasm.WasmMicroLoRA(dim, 0.1, 0.01);
             const gradient = new Float32Array(dim);
@@ -1697,9 +1704,15 @@ const routerTrainCommand = {
         const corpusPath = ctx.flags.corpus;
         const outPath = ctx.flags.out || './router.krr.json';
         const qualityBar = parseFloat(ctx.flags['quality-bar'] || '0.8') || 0.8;
+        // Indirect the optional-dep specifier through a string variable so tsc
+        // doesn't statically resolve `@metaharness/router` at build time (TS2307
+        // when it isn't installed — #2586 pattern). The dep is optional at
+        // runtime; the catch below emits a clear operator message.
+        const metaharnessRouterPkg = '@metaharness/router';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic import of optional dep; call surface is fluid across upstream versions
         let mh;
         try {
-            mh = await import('@metaharness/router');
+            mh = await import(metaharnessRouterPkg);
         }
         catch {
             output.printError('@metaharness/router is not installed. `npm install @metaharness/router@^0.3.2` then re-run.');

package/dist/src/init/executor.js

@@ -807,7 +807,7 @@ async function writeSettings(targetDir, options, result) {
  * "same MCP server twice under two different prefixes" duplication the
  * issue describes.
  *
- * Returns the path of the file that already declares `ruflo` (so we can
+ * Returns the path of the file that already declares `ruflo`/`claude-flow` (so we can
  * surface it in the skipped-message), or null if none found.
  */
 function detectExistingRufloMCP(targetDir) {
@@ -840,10 +840,9 @@ function detectExistingRufloMCP(targetDir) {
             if (!parsed || typeof parsed !== 'object')
                 continue;
             // (a) Top-level mcpServers (legacy / global form).
-            // #2207: accept BOTH the old 'ruflo' key AND the new 'claude-flow' key so that
-            // a prior install with either key is correctly detected as already-initialized.
-            // This also avoids the reverse problem: after #2206 fixed the generator to write
-            // 'claude-flow', a second `ruflo init` must still recognise the existing install.
+            // Accept BOTH names so init does not add a second server for the same
+            // binary when a project carries a pre-rename `claude-flow` registration
+            // and the current generator would write `ruflo` (#2612).
             if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
                 const servers = parsed.mcpServers;
                 // #2369: also recognise the legacy dist-tag keys generated by
@@ -859,10 +858,9 @@ function detectExistingRufloMCP(targetDir) {
             }
             // (b) #1840: Claude Code project-scoped registrations under
             //     parsed.projects[<projectPath>].mcpServers. Match by
-            //     normalized path against targetDir or any of its ancestors so
-            //     a `claude mcp add claude-flow` (or legacy `ruflo`) in this repo is
+            //     normalized path against targetDir or any of its ancestors so an
+            //     existing `claude-flow` or `ruflo` registration in this repo is
             //     detected even when Claude stored the key with different casing/slash style.
-            // #2207: accept both keys here too.
             if (parsed.projects && typeof parsed.projects === 'object') {
                 for (const [projectKey, projectVal] of Object.entries(parsed.projects)) {
                     if (!projectVal || typeof projectVal !== 'object')
@@ -925,16 +923,18 @@ async function writeMCPConfig(targetDir, options, result) {
         result.skipped.push('.mcp.json');
         return;
     }
-    // #1779 — Skip writing if the user already has a `ruflo`-keyed MCP
-    // server registered elsewhere (parent .mcp.json, ~/.claude.json, etc).
-    // Writing our `claude-flow`-keyed entry on top of that produces the
-    // duplicate-registration the issue describes (~250 duplicate tools).
-    // Force-mode (`--force`) bypasses this guard for users who actually
-    // want both registrations.
+    // #1779/#2612 — Skip writing if the user already has this MCP server
+    // registered elsewhere (parent .mcp.json, ~/.claude.json, etc). The
+    // canonical key is `claude-flow` (per #2206 — matches mcp__claude-flow__*
+    // plugin tool refs); a stray `ruflo`-keyed entry pointing at the same
+    // binary is the legacy-duplicate form that #2612 healed. Writing our
+    // fresh `claude-flow` entry on top of either variant starts the same
+    // binary twice under two tool namespaces. Force-mode (`--force`)
+    // bypasses this guard for users who actually want both registrations.
     if (!options.force) {
         const existingRufloPath = detectExistingRufloMCP(targetDir);
         if (existingRufloPath) {
-            result.skipped.push(`.mcp.json (existing 'ruflo' MCP registration found at ${existingRufloPath} — would create duplicate; pass --force to write anyway)`);
+            result.skipped.push(`.mcp.json (existing ruflo/claude-flow MCP registration found at ${existingRufloPath} — would create duplicate; pass --force to write anyway)`);
             return;
         }
     }
@@ -1880,7 +1880,7 @@ npx @claude-flow/cli@latest hive-mind consensus --propose "task"
 ### MCP Server Setup
 \`\`\`bash
 # Add Ruflo MCP
-claude mcp add ruflo -- npx -y ruflo@latest
+claude mcp add ruflo -- npx -y ruflo@latest mcp start
 
 # Optional servers
 claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start

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

@@ -40,10 +40,15 @@ export function generateMCPConfig(options) {
     const npmEnv = {
         npm_config_update_notifier: 'false',
     };
-    // Ruflo MCP server (core) — uses ruflo wrapper for portable npm-resolved invocation.
-    // #2206: key MUST be 'claude-flow' so all plugins resolve as mcp__claude-flow__*.
-    // The command args (ruflo@latest mcp start) are the correct wrapper invocation — only the
-    // registration KEY changes here.
+    // Ruflo MCP server (core) — the registration KEY is intentionally
+    // `claude-flow` (not `ruflo`) because #2206 established that all ~166
+    // plugin tool references use `mcp__claude-flow__*`. The invoked binary
+    // is `ruflo@latest` (the post-rename wrapper) — only the registration
+    // name stays legacy so plugin tool resolution keeps working.
+    // #2612 (duplicate `claude-flow` + `ruflo` registrations after users
+    // followed pre-rename setup docs) is healed by `ruflo doctor`, which
+    // detects the duplicate and instructs the operator to remove the
+    // extra `ruflo`-keyed entry — NOT by flipping the canonical key here.
     if (config.claudeFlow) {
         mcpServers['claude-flow'] = createMCPServerEntry(['ruflo@latest', 'mcp', 'start'], {
             ...npmEnv,
@@ -79,7 +84,7 @@ export function generateMCPCommands(options) {
     const config = options.mcp;
     if (isWindows()) {
         if (config.claudeFlow) {
-            // #2206: registration name must be 'claude-flow' to match mcp__claude-flow__* tool naming
+            // #2206: registration name must be `claude-flow` to match mcp__claude-flow__* plugin tool references
             commands.push('claude mcp add claude-flow -- cmd /c npx -y ruflo@latest mcp start');
         }
         if (config.ruvSwarm) {
@@ -91,7 +96,7 @@ export function generateMCPCommands(options) {
     }
     else {
         if (config.claudeFlow) {
-            // #2206: registration name must be 'claude-flow' to match mcp__claude-flow__* tool naming
+            // #2206: registration name must be `claude-flow` to match mcp__claude-flow__* plugin tool references
             commands.push("claude mcp add claude-flow -- npx -y ruflo@latest mcp start");
         }
         if (config.ruvSwarm) {

package/dist/src/ruvector/index.js

@@ -60,7 +60,11 @@ export async function isRuvectorAvailable() {
  */
 export async function isWasmBackendAvailable() {
     try {
-        const wasm = await import('@ruvector/learning-wasm');
+        // Indirect the specifier through a string variable so tsc doesn't
+        // statically resolve this optional dep at build time (TS2307 when
+        // absent — #2586 pattern). Same runtime behaviour: try/catch guards.
+        const learningWasmPkg = '@ruvector/learning-wasm';
+        const wasm = (await import(learningWasmPkg));
         return typeof wasm.WasmMicroLoRA === 'function' && typeof wasm.initSync === 'function';
     }
     catch {

package/dist/src/ruvector/neural-router.js

@@ -183,10 +183,14 @@ function loadSeedCorpus(path) {
     }
 }
 async function resolveBackend(cfg) {
-    // 1. Optional dep present?
+    // 1. Optional dep present? Indirect the specifier through a string variable
+    //    so tsc doesn't statically resolve `@metaharness/router` at build time
+    //    (TS2307 when the optional dep isn't installed — #2586 pattern).
+    const metaharnessRouterPkg = '@metaharness/router';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- optional dep; surface is fluid across upstream versions
     let mh;
     try {
-        mh = await import('@metaharness/router');
+        mh = await import(metaharnessRouterPkg);
     }
     catch {
         return { available: false, router: null, routedBy: null, reason: '@metaharness/router not installed' };

package/dist/src/services/ruvector-training.js

@@ -231,9 +231,14 @@ export async function initializeTraining(config = {}) {
         const fs = await import('fs');
         const { createRequire } = await import('module');
         const require = createRequire(import.meta.url);
-        const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+        // Indirect the optional-dep specifier through a string variable so tsc
+        // doesn't statically resolve `@ruvector/learning-wasm` at build time
+        // (TS2307 when the optional dep is absent — #2586 pattern).
+        const learningWasmPkg = '@ruvector/learning-wasm';
+        const wasmPath = require.resolve(`${learningWasmPkg}/ruvector_learning_wasm_bg.wasm`);
         const wasmBuffer = fs.readFileSync(wasmPath);
-        const learningWasm = await import('@ruvector/learning-wasm');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- optional-dep dynamic import
+        const learningWasm = await import(learningWasmPkg);
         learningWasm.initSync({ module: wasmBuffer });
         microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
         features.push(`MicroLoRA/WASM (${dim}-dim, <1μs adaptation)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.25.4",
+  "version": "3.25.6",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

package/plugins/ruflo-metaharness/.claude-flow/daemon-state.json

@@ -0,0 +1,178 @@
+{
+  "running": true,
+  "startedAt": "2026-07-09T13:44:14.858Z",
+  "workers": {
+    "map": {
+      "runCount": 3,
+      "successCount": 3,
+      "failureCount": 0,
+      "averageDurationMs": 2,
+      "isRunning": false,
+      "nextRun": "2026-07-09T14:29:14.860Z",
+      "lastStartedAt": "2026-07-09T14:14:14.854Z",
+      "lastRun": "2026-07-09T14:14:14.858Z"
+    },
+    "audit": {
+      "runCount": 3,
+      "successCount": 3,
+      "failureCount": 0,
+      "averageDurationMs": 181799,
+      "isRunning": false,
+      "nextRun": "2026-07-09T14:12:48.865Z",
+      "lastStartedAt": "2026-07-09T14:12:48.864Z",
+      "lastRun": "2026-07-09T14:15:20.256Z"
+    },
+    "optimize": {
+      "runCount": 2,
+      "successCount": 2,
+      "failureCount": 0,
+      "averageDurationMs": 243440.5,
+      "isRunning": false,
+      "nextRun": "2026-07-09T14:26:21.738Z",
+      "lastStartedAt": "2026-07-09T14:05:34.528Z",
+      "lastRun": "2026-07-09T14:11:21.737Z"
+    },
+    "consolidate": {
+      "runCount": 1,
+      "successCount": 1,
+      "failureCount": 0,
+      "averageDurationMs": 0,
+      "isRunning": false,
+      "nextRun": "2026-07-09T14:20:14.861Z",
+      "lastStartedAt": "2026-07-09T13:50:14.860Z",
+      "lastRun": "2026-07-09T13:50:14.860Z"
+    },
+    "testgaps": {
+      "runCount": 1,
+      "successCount": 1,
+      "failureCount": 0,
+      "averageDurationMs": 181886,
+      "isRunning": true,
+      "nextRun": "2026-07-09T14:15:16.745Z",
+      "lastStartedAt": "2026-07-09T14:15:16.740Z",
+      "lastRun": "2026-07-09T13:55:16.744Z"
+    },
+    "backup": {
+      "runCount": 1,
+      "successCount": 1,
+      "failureCount": 0,
+      "averageDurationMs": 4,
+      "isRunning": false,
+      "nextRun": "2026-07-10T13:54:14.862Z",
+      "lastStartedAt": "2026-07-09T13:54:14.856Z",
+      "lastRun": "2026-07-09T13:54:14.860Z"
+    },
+    "harness": {
+      "runCount": 1,
+      "successCount": 1,
+      "failureCount": 0,
+      "averageDurationMs": 7,
+      "isRunning": false,
+      "nextRun": "2026-07-09T19:56:14.864Z",
+      "lastStartedAt": "2026-07-09T13:56:14.856Z",
+      "lastRun": "2026-07-09T13:56:14.863Z"
+    },
+    "predict": {
+      "runCount": 0,
+      "successCount": 0,
+      "failureCount": 0,
+      "averageDurationMs": 0,
+      "isRunning": false
+    },
+    "document": {
+      "runCount": 0,
+      "successCount": 0,
+      "failureCount": 0,
+      "averageDurationMs": 0,
+      "isRunning": false
+    }
+  },
+  "config": {
+    "autoStart": false,
+    "logDir": "/Users/cohen/Projects/ruflo/plugins/ruflo-metaharness/.claude-flow/logs",
+    "stateFile": "/Users/cohen/Projects/ruflo/plugins/ruflo-metaharness/.claude-flow/daemon-state.json",
+    "maxConcurrent": 2,
+    "workerTimeoutMs": 960000,
+    "resourceThresholds": {
+      "maxCpuLoad": 9.600000000000001,
+      "minFreeMemoryPercent": 5
+    },
+    "ttlMs": 43200000,
+    "idleShutdownMs": 0,
+    "workers": [
+      {
+        "type": "map",
+        "intervalMs": 900000,
+        "offsetMs": 0,
+        "priority": "normal",
+        "description": "Codebase mapping",
+        "enabled": true
+      },
+      {
+        "type": "audit",
+        "intervalMs": 600000,
+        "offsetMs": 120000,
+        "priority": "critical",
+        "description": "Security analysis",
+        "enabled": true
+      },
+      {
+        "type": "optimize",
+        "intervalMs": 900000,
+        "offsetMs": 240000,
+        "priority": "high",
+        "description": "Performance optimization",
+        "enabled": true
+      },
+      {
+        "type": "consolidate",
+        "intervalMs": 1800000,
+        "offsetMs": 360000,
+        "priority": "low",
+        "description": "Memory distillation (ADR-174)",
+        "enabled": true
+      },
+      {
+        "type": "testgaps",
+        "intervalMs": 1200000,
+        "offsetMs": 480000,
+        "priority": "normal",
+        "description": "Test coverage analysis",
+        "enabled": true
+      },
+      {
+        "type": "backup",
+        "intervalMs": 86400000,
+        "offsetMs": 600000,
+        "priority": "low",
+        "description": "Nightly memory DB backup (WAL-safe, rotated)",
+        "enabled": true
+      },
+      {
+        "type": "harness",
+        "intervalMs": 21600000,
+        "offsetMs": 720000,
+        "priority": "low",
+        "description": "Self-optimizing harness loop (opt-in RUFLO_HARNESS_LOOP, $0-default)",
+        "enabled": true
+      },
+      {
+        "type": "predict",
+        "intervalMs": 600000,
+        "offsetMs": 0,
+        "priority": "low",
+        "description": "Predictive preloading",
+        "enabled": false
+      },
+      {
+        "type": "document",
+        "intervalMs": 3600000,
+        "offsetMs": 0,
+        "priority": "low",
+        "description": "Auto-documentation",
+        "enabled": false
+      }
+    ]
+  },
+  "savedAt": "2026-07-09T14:15:20.256Z"
+}

package/plugins/ruflo-metaharness/.claude-flow/daemon.pid

@@ -0,0 +1 @@
+22169

package/plugins/ruflo-metaharness/.claude-flow/logs/daemon.log

@@ -0,0 +1,43 @@
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled map (interval: 900s, first run in 0s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled audit (interval: 600s, first run in 120s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled optimize (interval: 900s, first run in 240s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled consolidate (interval: 1800s, first run in 360s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled testgaps (interval: 1200s, first run in 480s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled backup (interval: 86400s, first run in 600s)
+[2026-07-09T13:44:14.859Z] [INFO] Scheduled harness (interval: 21600s, first run in 720s)
+[2026-07-09T13:44:14.859Z] [INFO] Lifecycle monitor active (ttl=43200s)
+[2026-07-09T13:44:14.860Z] [INFO] Daemon started (PID: 22169, CPUs: 12, workers: 7, maxCpuLoad: 9.600000000000001, minFreeMemoryPercent: 5%)
+[2026-07-09T13:44:14.860Z] [INFO] Claude Code headless mode available - AI workers enabled
+[2026-07-09T13:44:14.860Z] [INFO] Starting worker: map (1/2 concurrent)
+[2026-07-09T13:44:14.861Z] [INFO] Worker map completed in 1ms
+[2026-07-09T13:46:14.862Z] [INFO] Starting worker: audit (1/2 concurrent)
+[2026-07-09T13:46:14.863Z] [INFO] Running audit in headless mode (Claude Code AI)
+[2026-07-09T13:48:14.860Z] [INFO] Starting worker: optimize (2/2 concurrent)
+[2026-07-09T13:48:14.860Z] [INFO] Running optimize in headless mode (Claude Code AI)
+[2026-07-09T13:48:33.588Z] [INFO] Worker audit completed in 138728ms
+[2026-07-09T13:50:14.860Z] [INFO] Starting worker: consolidate (2/2 concurrent)
+[2026-07-09T13:50:14.860Z] [INFO] Consolidate worker: distillation skipped (no-db)
+[2026-07-09T13:50:14.860Z] [INFO] Worker consolidate completed in 0ms
+[2026-07-09T13:50:34.530Z] [INFO] Worker optimize completed in 139672ms
+[2026-07-09T13:52:14.860Z] [INFO] Starting worker: testgaps (1/2 concurrent)
+[2026-07-09T13:52:14.860Z] [INFO] Running testgaps in headless mode (Claude Code AI)
+[2026-07-09T13:54:14.858Z] [INFO] Starting worker: backup (2/2 concurrent)
+[2026-07-09T13:54:14.860Z] [INFO] Worker backup completed in 4ms
+[2026-07-09T13:55:16.744Z] [INFO] Worker testgaps completed in 181886ms
+[2026-07-09T13:56:14.857Z] [INFO] Starting worker: harness (1/2 concurrent)
+[2026-07-09T13:56:14.863Z] [INFO] Worker harness completed in 7ms
+[2026-07-09T13:58:33.587Z] [INFO] Starting worker: audit (1/2 concurrent)
+[2026-07-09T13:58:33.587Z] [INFO] Running audit in headless mode (Claude Code AI)
+[2026-07-09T13:59:14.859Z] [INFO] Starting worker: map (2/2 concurrent)
+[2026-07-09T13:59:14.859Z] [INFO] Worker map completed in 1ms
+[2026-07-09T14:02:48.864Z] [INFO] Worker audit completed in 255277ms
+[2026-07-09T14:05:34.531Z] [INFO] Starting worker: optimize (1/2 concurrent)
+[2026-07-09T14:05:34.531Z] [INFO] Running optimize in headless mode (Claude Code AI)
+[2026-07-09T14:11:21.737Z] [INFO] Worker optimize completed in 347209ms
+[2026-07-09T14:12:48.866Z] [INFO] Starting worker: audit (1/2 concurrent)
+[2026-07-09T14:12:48.867Z] [INFO] Running audit in headless mode (Claude Code AI)
+[2026-07-09T14:14:14.857Z] [INFO] Starting worker: map (2/2 concurrent)
+[2026-07-09T14:14:14.858Z] [INFO] Worker map completed in 4ms
+[2026-07-09T14:15:16.742Z] [INFO] Starting worker: testgaps (2/2 concurrent)
+[2026-07-09T14:15:16.743Z] [INFO] Running testgaps in headless mode (Claude Code AI)
+[2026-07-09T14:15:20.256Z] [INFO] Worker audit completed in 151392ms

package/plugins/ruflo-metaharness/.claude-flow/logs/headless/audit_1783604774864_ozbujc_prompt.log

@@ -0,0 +1,19 @@
+[2026-07-09T13:46:14.882Z] PROMPT
+============================================================
+Analyze this codebase for security vulnerabilities:
+- Check for hardcoded secrets (API keys, passwords)
+- Identify SQL injection risks
+- Find XSS vulnerabilities
+- Check for insecure dependencies
+- Identify authentication/authorization issues
+
+Provide a JSON report with:
+{
+  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
+  "riskScore": 0-100,
+  "recommendations": ["..."]
+}
+
+## Instructions
+
+Analyze the codebase and provide your response following the format specified in the task.