claude-flow 3.5.54 → 3.5.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.54",
+  "version": "3.5.56",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/benchmarks/pretrain/index.js

@@ -330,7 +330,7 @@ export async function benchmarkPretrainPipeline(config) {
             id: `pattern-${i}`,
             type: 'code-structure',
             embedding: embeddings[i],
-            confidence: 0.85 + Math.random() * 0.1,
+            confidence: embeddings[i] ? 1.0 : 0, // real: has embedding = confident
         }));
         return { files: files.length, patterns: patterns.length };
     };

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

@@ -69,24 +69,25 @@ const getCommand = {
     ],
     action: async (ctx) => {
         const key = ctx.flags.key || ctx.args[0];
-        // Default config values (loaded from actual config when available)
-        const configValues = {
-            'version': '3.0.0',
-            'v3Mode': true,
-            'swarm.topology': 'hybrid',
-            'swarm.maxAgents': 15,
-            'swarm.autoScale': true,
-            'memory.backend': 'hybrid',
-            'memory.cacheSize': 256,
-            'mcp.transport': 'stdio',
-            'agents.defaultType': 'coder',
-            'agents.maxConcurrent': 15
-        };
         if (!key) {
-            // Show all config
+            // Show all config from actual config file (fall back to defaults)
+            const config = configManager.getConfig(ctx.cwd);
+            const flatEntries = {};
+            const flatten = (obj, prefix = '') => {
+                for (const [k, v] of Object.entries(obj)) {
+                    const fullKey = prefix ? `${prefix}.${k}` : k;
+                    if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+                        flatten(v, fullKey);
+                    }
+                    else {
+                        flatEntries[fullKey] = v;
+                    }
+                }
+            };
+            flatten(config);
             if (ctx.flags.format === 'json') {
-                output.printJson(configValues);
-                return { success: true, data: configValues };
+                output.printJson(flatEntries);
+                return { success: true, data: flatEntries };
             }
             output.writeln();
             output.writeln(output.bold('Current Configuration'));
@@ -96,11 +97,11 @@ const getCommand = {
                     { key: 'key', header: 'Key', width: 25 },
                     { key: 'value', header: 'Value', width: 30 }
                 ],
-                data: Object.entries(configValues).map(([k, v]) => ({ key: k, value: String(v) }))
+                data: Object.entries(flatEntries).map(([k, v]) => ({ key: k, value: String(v) }))
             });
-            return { success: true, data: configValues };
+            return { success: true, data: flatEntries };
         }
-        const value = configValues[key];
+        const value = configManager.get(ctx.cwd, key);
         if (value === undefined) {
             output.printError(`Configuration key not found: ${key}`);
             return { success: false, exitCode: 1 };
@@ -187,12 +188,83 @@ const providersCommand = {
         }
     ],
     action: async (ctx) => {
-        const providers = [
+        const defaultProviders = [
             { name: 'anthropic', model: 'claude-3-5-sonnet-20241022', priority: 1, enabled: true, status: 'Active' },
             { name: 'openrouter', model: 'claude-3.5-sonnet', priority: 2, enabled: false, status: 'Disabled' },
             { name: 'ollama', model: 'llama3.2', priority: 3, enabled: false, status: 'Disabled' },
             { name: 'gemini', model: 'gemini-2.0-flash', priority: 4, enabled: false, status: 'Disabled' }
         ];
+        // Handle mutation flags
+        const addProvider = ctx.flags.add;
+        const removeProvider = ctx.flags.remove;
+        const enableProvider = ctx.flags.enable;
+        const disableProvider = ctx.flags.disable;
+        if (addProvider || removeProvider || enableProvider || disableProvider) {
+            // Read current providers from config
+            let currentProviders = configManager.get(ctx.cwd, 'providers') || [];
+            if (!Array.isArray(currentProviders))
+                currentProviders = [];
+            if (addProvider) {
+                const exists = currentProviders.some((p) => p.name === addProvider);
+                if (exists) {
+                    output.printError(`Provider '${addProvider}' already exists`);
+                    return { success: false, exitCode: 1 };
+                }
+                currentProviders.push({ name: addProvider, enabled: true, priority: currentProviders.length + 1 });
+                output.writeln(output.success(`Added provider: ${addProvider}`));
+            }
+            if (removeProvider) {
+                const before = currentProviders.length;
+                currentProviders = currentProviders.filter((p) => p.name !== removeProvider);
+                if (currentProviders.length === before) {
+                    output.printError(`Provider '${removeProvider}' not found`);
+                    return { success: false, exitCode: 1 };
+                }
+                output.writeln(output.success(`Removed provider: ${removeProvider}`));
+            }
+            if (enableProvider) {
+                const p = currentProviders.find((p) => p.name === enableProvider);
+                if (p) {
+                    p.enabled = true;
+                    output.writeln(output.success(`Enabled provider: ${enableProvider}`));
+                }
+                else {
+                    output.printError(`Provider '${enableProvider}' not found`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            if (disableProvider) {
+                const p = currentProviders.find((p) => p.name === disableProvider);
+                if (p) {
+                    p.enabled = false;
+                    output.writeln(output.success(`Disabled provider: ${disableProvider}`));
+                }
+                else {
+                    output.printError(`Provider '${disableProvider}' not found`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            try {
+                configManager.set(ctx.cwd, 'providers', currentProviders);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                output.printError(`Failed to save providers: ${message}`);
+                return { success: false, exitCode: 1 };
+            }
+            return { success: true, data: currentProviders };
+        }
+        // Read providers from config, fall back to defaults
+        const configuredProviders = configManager.get(ctx.cwd, 'providers');
+        const providers = (Array.isArray(configuredProviders) && configuredProviders.length > 0)
+            ? configuredProviders.map((p, i) => ({
+                name: String(p.name || ''),
+                model: String(p.model || ''),
+                priority: Number(p.priority || i + 1),
+                enabled: p.enabled !== false,
+                status: p.enabled !== false ? 'Active' : 'Disabled',
+            }))
+            : defaultProviders;
         if (ctx.flags.format === 'json') {
             output.printJson(providers);
             return { success: true, data: providers };

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

@@ -237,49 +237,88 @@ const monitorCommand = {
         const format = ctx.flags?.format || 'dashboard';
         const watch = ctx.flags?.watch === true;
         const alerts = ctx.flags?.alerts !== false;
-        // Default monitoring data (updated by real process stats when available)
+        // Gather real system metrics where possible
+        const os = await import('node:os');
+        const memUsage = process.memoryUsage();
+        const loadAvg = os.loadavg();
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        const usedMemMB = Math.round((totalMem - freeMem) / 1024 / 1024);
+        const totalMemMB = Math.round(totalMem / 1024 / 1024);
+        // Try to read agent and task counts from local store files
+        let agentCount = 0;
+        let taskCounts = { running: 0, queued: 0, completed: 0, failed: 0 };
+        try {
+            const agentStorePath = resolve('.claude-flow/agents/store.json');
+            if (existsSync(agentStorePath)) {
+                const agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                const agents = Array.isArray(agentStore) ? agentStore : Object.values(agentStore.agents || agentStore || {});
+                agentCount = agents.length;
+            }
+        }
+        catch { /* no agent store */ }
+        try {
+            const taskStorePath = resolve('.claude-flow/tasks/store.json');
+            if (existsSync(taskStorePath)) {
+                const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
+                const tasks = Array.isArray(taskStore) ? taskStore : Object.values(taskStore.tasks || taskStore || {});
+                for (const t of tasks) {
+                    if (t.status === 'running')
+                        taskCounts.running++;
+                    else if (t.status === 'queued' || t.status === 'pending')
+                        taskCounts.queued++;
+                    else if (t.status === 'completed' || t.status === 'done')
+                        taskCounts.completed++;
+                    else if (t.status === 'failed' || t.status === 'error')
+                        taskCounts.failed++;
+                }
+            }
+        }
+        catch { /* no task store */ }
         const metrics = {
             timestamp: new Date().toISOString(),
             system: {
-                cpuUsage: Math.random() * 30 + 5,
-                memoryUsed: Math.floor(Math.random() * 500) + 100,
-                memoryTotal: 2048,
-                uptime: Math.floor(Math.random() * 86400),
+                cpuLoadAvg1m: loadAvg[0] !== undefined ? parseFloat(loadAvg[0].toFixed(2)) : null,
+                cpuLoadAvg5m: loadAvg[1] !== undefined ? parseFloat(loadAvg[1].toFixed(2)) : null,
+                cpuCount: os.cpus().length,
+                memoryUsedMB: usedMemMB,
+                memoryTotalMB: totalMemMB,
+                processRssMB: Math.round(memUsage.rss / 1024 / 1024),
+                processHeapMB: Math.round(memUsage.heapUsed / 1024 / 1024),
+                uptime: Math.floor(process.uptime()),
             },
             agents: {
-                active: Math.floor(Math.random() * 5),
-                idle: Math.floor(Math.random() * 3),
-                total: 0,
-                poolSize: 10,
+                total: agentCount,
+                _note: agentCount === 0 ? 'No agent store found at .claude-flow/agents/store.json' : null,
             },
             tasks: {
-                running: Math.floor(Math.random() * 3),
-                queued: Math.floor(Math.random() * 5),
-                completed: Math.floor(Math.random() * 100) + 50,
-                failed: Math.floor(Math.random() * 5),
+                ...taskCounts,
+                _note: (taskCounts.running + taskCounts.queued + taskCounts.completed + taskCounts.failed) === 0
+                    ? 'No task store found at .claude-flow/tasks/store.json' : null,
             },
             memory: {
-                vectorCount: Math.floor(Math.random() * 10000) + 1000,
-                indexSize: Math.floor(Math.random() * 50) + 10,
-                cacheHitRate: Math.random() * 0.3 + 0.65,
-                avgSearchTime: Math.random() * 5 + 1,
+                vectorCount: null,
+                indexSize: null,
+                cacheHitRate: null,
+                avgSearchTime: null,
+                _note: 'Memory service metrics not available from process monitor. Use "memory stats" command.',
             },
             network: {
-                mcpConnections: Math.floor(Math.random() * 3) + 1,
-                requestsPerMin: Math.floor(Math.random() * 100) + 20,
-                avgLatency: Math.random() * 50 + 10,
+                mcpConnections: null,
+                requestsPerMin: null,
+                avgLatency: null,
+                _note: 'Network metrics not available from process monitor. Use "mcp status" command.',
             },
         };
-        metrics.agents.total = metrics.agents.active + metrics.agents.idle;
         if (format === 'json') {
             console.log(JSON.stringify(metrics, null, 2));
             return { success: true, data: metrics };
         }
         if (format === 'compact') {
             console.log('\n📊 Process Monitor (compact)\n');
-            console.log(`CPU: ${metrics.system.cpuUsage.toFixed(1)}% | Memory: ${metrics.system.memoryUsed}MB/${metrics.system.memoryTotal}MB`);
-            console.log(`Agents: ${metrics.agents.active}/${metrics.agents.total} active | Tasks: ${metrics.tasks.running} running, ${metrics.tasks.queued} queued`);
-            console.log(`Memory: ${metrics.memory.vectorCount} vectors | Cache: ${(metrics.memory.cacheHitRate * 100).toFixed(1)}%`);
+            const loadStr = metrics.system.cpuLoadAvg1m !== null ? `load ${metrics.system.cpuLoadAvg1m.toFixed(2)}` : 'n/a';
+            console.log(`CPU: ${loadStr} (${metrics.system.cpuCount} cores) | Memory: ${metrics.system.memoryUsedMB}MB/${metrics.system.memoryTotalMB}MB`);
+            console.log(`Agents: ${metrics.agents.total} total | Tasks: ${metrics.tasks.running} running, ${metrics.tasks.queued} queued`);
             return { success: true, data: metrics };
         }
         // Dashboard format
@@ -288,15 +327,17 @@ const monitorCommand = {
         console.log('╠══════════════════════════════════════════════════════════════╣');
         // System metrics
         console.log('║  SYSTEM                                                      ║');
-        const cpuBar = '█'.repeat(Math.floor(metrics.system.cpuUsage / 5)) + '░'.repeat(20 - Math.floor(metrics.system.cpuUsage / 5));
-        const memPercent = (metrics.system.memoryUsed / metrics.system.memoryTotal) * 100;
+        const cpuDisplay = metrics.system.cpuLoadAvg1m !== null ? metrics.system.cpuLoadAvg1m : 0;
+        const cpuPercent = Math.min(100, (cpuDisplay / (metrics.system.cpuCount || 1)) * 100);
+        const cpuBar = '█'.repeat(Math.floor(cpuPercent / 5)) + '░'.repeat(20 - Math.floor(cpuPercent / 5));
+        const memPercent = (metrics.system.memoryUsedMB / metrics.system.memoryTotalMB) * 100;
         const memBar = '█'.repeat(Math.floor(memPercent / 5)) + '░'.repeat(20 - Math.floor(memPercent / 5));
-        console.log(`║  CPU:    [${cpuBar}] ${metrics.system.cpuUsage.toFixed(1).padStart(5)}%            ║`);
-        console.log(`║  Memory: [${memBar}] ${metrics.system.memoryUsed}MB/${metrics.system.memoryTotal}MB      ║`);
+        console.log(`║  CPU:    [${cpuBar}] load ${cpuDisplay.toFixed(2).padStart(5)}          ║`);
+        console.log(`║  Memory: [${memBar}] ${metrics.system.memoryUsedMB}MB/${metrics.system.memoryTotalMB}MB      ║`);
         console.log('╠══════════════════════════════════════════════════════════════╣');
         // Agents
         console.log('║  AGENTS                                                      ║');
-        console.log(`║  Active: ${metrics.agents.active.toString().padEnd(3)} Idle: ${metrics.agents.idle.toString().padEnd(3)} Pool: ${metrics.agents.poolSize.toString().padEnd(3)}                     ║`);
+        console.log(`║  Total: ${metrics.agents.total.toString().padEnd(5)}                                              ║`);
         console.log('╠══════════════════════════════════════════════════════════════╣');
         // Tasks
         console.log('║  TASKS                                                       ║');
@@ -304,18 +345,16 @@ const monitorCommand = {
         console.log('╠══════════════════════════════════════════════════════════════╣');
         // Memory service
         console.log('║  MEMORY SERVICE                                              ║');
-        console.log(`║  Vectors: ${metrics.memory.vectorCount.toString().padEnd(7)} Index: ${metrics.memory.indexSize}MB                          ║`);
-        console.log(`║  Cache Hit: ${(metrics.memory.cacheHitRate * 100).toFixed(1)}%  Avg Search: ${metrics.memory.avgSearchTime.toFixed(2)}ms                   ║`);
+        console.log('║  Metrics not available. Use "memory stats" command.          ║');
         console.log('╠══════════════════════════════════════════════════════════════╣');
         // Network
         console.log('║  NETWORK                                                     ║');
-        console.log(`║  MCP Connections: ${metrics.network.mcpConnections}  Requests/min: ${metrics.network.requestsPerMin.toString().padEnd(5)}             ║`);
-        console.log(`║  Avg Latency: ${metrics.network.avgLatency.toFixed(1)}ms                                        ║`);
+        console.log('║  Metrics not available. Use "mcp status" command.            ║');
         console.log('╚══════════════════════════════════════════════════════════════╝');
         if (alerts) {
             console.log('\n📢 Alerts:');
-            if (metrics.system.cpuUsage > 80) {
-                console.log('  ⚠️  High CPU usage detected');
+            if (cpuPercent > 80) {
+                console.log('  ⚠️  High CPU load detected');
             }
             if (memPercent > 80) {
                 console.log('  ⚠️  High memory usage detected');
@@ -323,10 +362,7 @@ const monitorCommand = {
             if (metrics.tasks.failed > 10) {
                 console.log('  ⚠️  Elevated task failure rate');
             }
-            if (metrics.memory.cacheHitRate < 0.5) {
-                console.log('  ⚠️  Low cache hit rate');
-            }
-            if (metrics.system.cpuUsage <= 80 && memPercent <= 80 && metrics.tasks.failed <= 10 && metrics.memory.cacheHitRate >= 0.5) {
+            if (cpuPercent <= 80 && memPercent <= 80 && metrics.tasks.failed <= 10) {
                 console.log('  ✅ All systems nominal');
             }
         }
@@ -558,38 +594,56 @@ const logsCommand = {
         console.log(`\n📜 Process Logs (${source})\n`);
         console.log(`  Level: ${level}+ | Lines: ${tail}${since ? ` | Since: ${since}` : ''}${grep ? ` | Filter: ${grep}` : ''}`);
         console.log('─'.repeat(70));
-        // Default log entries (loaded from actual logs when available)
-        const levels = ['debug', 'info', 'warn', 'error'];
+        // Read actual log files from .claude-flow/logs/ if they exist
+        const logsDir = resolve('.claude-flow/logs');
+        let logEntries = [];
         const levelIcons = {
             debug: '🔍',
             info: 'ℹ️ ',
             warn: '⚠️ ',
             error: '❌',
         };
-        const sources = ['daemon', 'worker-task', 'worker-memory', 'coordinator'];
-        const messages = [
-            'Processing task queue...',
-            'Agent spawned successfully',
-            'Memory index optimized',
-            'Configuration reloaded',
-            'MCP connection established',
-            'Task completed: 42ms',
-            'Cache hit rate: 87%',
-            'Swarm topology updated',
-            'Health check passed',
-            'Neural pattern learned',
-        ];
+        const levels = ['debug', 'info', 'warn', 'error'];
         const minLevelIdx = levels.indexOf(level);
-        const now = Date.now();
-        for (let i = 0; i < Math.min(tail, 15); i++) {
-            const logLevel = levels[Math.floor(Math.random() * (levels.length - minLevelIdx)) + minLevelIdx];
-            const logSource = sources[Math.floor(Math.random() * sources.length)];
-            const message = messages[Math.floor(Math.random() * messages.length)];
-            const timestamp = new Date(now - (tail - i) * 1000 * 60).toISOString().substring(11, 23);
-            if (grep && !message.toLowerCase().includes(grep.toLowerCase())) {
-                continue;
+        if (existsSync(logsDir)) {
+            try {
+                const { readdirSync } = await import('node:fs');
+                const logFiles = readdirSync(logsDir)
+                    .filter(f => f.endsWith('.log'))
+                    .filter(f => source === 'all' || f.includes(source));
+                for (const file of logFiles) {
+                    try {
+                        const content = readFileSync(resolve(logsDir, file), 'utf-8');
+                        const lines = content.split('\n').filter(l => l.trim());
+                        for (const line of lines) {
+                            // Filter by log level if detectable
+                            const lineLower = line.toLowerCase();
+                            const lineLevel = levels.find(l => lineLower.includes(`[${l}]`) || lineLower.includes(l));
+                            if (lineLevel && levels.indexOf(lineLevel) < minLevelIdx)
+                                continue;
+                            if (grep && !lineLower.includes(grep.toLowerCase()))
+                                continue;
+                            logEntries.push(line);
+                        }
+                    }
+                    catch { /* skip unreadable files */ }
+                }
+            }
+            catch { /* skip if dir unreadable */ }
+        }
+        if (logEntries.length === 0) {
+            console.log('  No log entries found.');
+            console.log(`  Log directory: ${logsDir}`);
+            if (!existsSync(logsDir)) {
+                console.log('  (directory does not exist)');
+            }
+        }
+        else {
+            // Show the last N entries
+            const entriesToShow = logEntries.slice(-tail);
+            for (const entry of entriesToShow) {
+                console.log(entry);
             }
-            console.log(`${timestamp} ${levelIcons[logLevel]} [${logSource.padEnd(14)}] ${message}`);
         }
         console.log('─'.repeat(70));
         if (follow) {

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

@@ -111,8 +111,8 @@ async function getSystemStatus() {
             performance: {
                 cpuUsage: getProcessCpuUsage(),
                 memoryUsage: getProcessMemoryUsage(),
-                flashAttention: '2.8x speedup',
-                searchSpeed: '150x faster'
+                flashAttention: 'not measured',
+                searchSpeed: 'not measured'
             }
         };
     }

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

@@ -457,8 +457,6 @@ export const agentTools = [
             const degradedAgents = agents.filter(a => a.health >= 0.3 && a.health < threshold);
             const unhealthyAgents = agents.filter(a => a.health < 0.3);
             const avgHealth = agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 1;
-            const avgCpu = agents.length > 0 ? 35 + Math.random() * 30 : 0; // Simulated CPU
-            const avgMemory = avgHealth * 0.6; // Correlated with health
             return {
                 // CLI expected fields
                 agents: agents.map(a => {
@@ -468,19 +466,17 @@ export const agentTools = [
                         type: a.agentType,
                         health: a.health >= threshold ? 'healthy' : (a.health >= 0.3 ? 'degraded' : 'unhealthy'),
                         uptime,
-                        memory: { used: Math.floor(256 * (1 - a.health * 0.3)), limit: 512 },
-                        cpu: 20 + Math.floor(a.health * 40),
                         tasks: { active: a.taskCount > 0 ? 1 : 0, queued: 0, completed: a.taskCount, failed: 0 },
-                        latency: { avg: 50 + Math.floor((1 - a.health) * 100), p99: 150 + Math.floor((1 - a.health) * 200) },
-                        errors: { count: a.health < threshold ? 1 : 0 },
+                        _note: 'Per-agent OS metrics not available — use system_metrics for real CPU/memory',
                     };
                 }),
                 overall: {
                     healthy: healthyAgents.length,
                     degraded: degradedAgents.length,
                     unhealthy: unhealthyAgents.length,
-                    avgCpu,
-                    avgMemory,
+                    cpu: null,
+                    memory: null,
+                    _note: 'Per-agent CPU/memory not available — use system_metrics for real OS-level stats',
                     score: Math.round(avgHealth * 100),
                     issues: unhealthyAgents.length,
                 },

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

@@ -710,6 +710,21 @@ export const claimsTools = [
                     }
                 }
             }
+            // When not a dry run, execute the suggested moves
+            if (!dryRun) {
+                for (const suggestion of suggestions) {
+                    const claim = store.claims[suggestion.issueId];
+                    if (claim) {
+                        const newOwner = parseClaimant(suggestion.to);
+                        if (newOwner) {
+                            claim.claimant = newOwner;
+                            claim.statusChangedAt = new Date().toISOString();
+                            store.claims[suggestion.issueId] = claim;
+                        }
+                    }
+                }
+                saveClaims(store);
+            }
             return {
                 success: true,
                 dryRun,

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

@@ -633,22 +633,29 @@ export const coordinationTools = [
             const activeNodes = nodes.filter(n => n.status === 'active');
             const metrics = {
                 latency: {
-                    avg: 25 + Math.random() * 20,
-                    p50: 20 + Math.random() * 15,
-                    p95: 50 + Math.random() * 30,
-                    p99: 100 + Math.random() * 50,
+                    avg: null,
+                    p50: null,
+                    p95: null,
+                    p99: null,
                     unit: 'ms',
+                    _note: 'Real-time latency metrics not available — coordination is state-tracking only',
                 },
                 throughput: {
-                    current: Math.floor(Math.random() * 1000) + 500,
-                    peak: Math.floor(Math.random() * 2000) + 1000,
-                    avg: Math.floor(Math.random() * 800) + 400,
+                    current: null,
+                    peak: null,
+                    avg: null,
                     unit: 'ops/s',
+                    _note: 'Real-time throughput metrics not available — coordination is state-tracking only',
                 },
                 availability: {
-                    uptime: 99.9 + Math.random() * 0.09,
+                    uptime: null,
+                    _note: 'Uptime not tracked — coordination store has no persistent start time',
                     activeNodes: activeNodes.length,
                     totalNodes: nodes.length,
+                    syncCount: store.sync.syncCount,
+                    lastSync: store.sync.lastSync,
+                    conflicts: store.sync.conflicts,
+                    pendingChanges: store.sync.pendingChanges,
                     syncStatus: store.sync.conflicts === 0 ? 'healthy' : 'conflicts',
                 },
             };