moflo 4.12.3 → 4.12.4-rc.2

package/dist/src/cli/commands/performance.js

@@ -2,17 +2,18 @@
  * V3 CLI Performance Command
  * Performance profiling, benchmarking, optimization, metrics
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
+import { readLoadAverage, NOT_MEASURED } from '../shared/utils/load-average.js';
 // Benchmark subcommand - REAL measurements
 const benchmarkCommand = {
     name: 'benchmark',
     description: 'Run performance benchmarks',
     options: [
         { name: 'suite', short: 's', type: 'string', description: 'Benchmark suite: all, wasm, neural, memory, search', default: 'all' },
-        { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', default: '100' },
-        { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', default: 100 },
+        { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: 10 },
         { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json, csv', default: 'text' },
     ],
     examples: [
@@ -213,7 +214,7 @@ const profileCommand = {
     description: 'Profile application performance',
     options: [
         { name: 'type', short: 't', type: 'string', description: 'Profile type: cpu, memory, io, all', default: 'all' },
-        { name: 'duration', short: 'd', type: 'number', description: 'Duration in seconds', default: '30' },
+        { name: 'duration', short: 'd', type: 'number', description: 'Duration in seconds', default: 30 },
         { name: 'output', short: 'o', type: 'string', description: 'Output file for profile data' },
     ],
     examples: [
@@ -302,7 +303,10 @@ const metricsCommand = {
         const memUsage = process.memoryUsage();
         const cpuUsage = process.cpuUsage();
         const uptime = process.uptime();
-        const loadAvg = os.loadavg();
+        // null where the platform has none (#1358). Rendered as "not measured"
+        // below rather than as 0.00 — a reading that does not exist must not read
+        // as an idle machine.
+        const loadAvg = readLoadAverage(os.loadavg(), os.platform());
         const freeMem = os.freemem();
         const totalMem = os.totalmem();
         // Calculate real metrics
@@ -454,7 +458,10 @@ const metricsCommand = {
             ],
         });
         output.writeln();
-        output.writeln(output.dim(`Load Average: ${loadAvg.map(l => l.toFixed(2)).join(', ')}`));
+        const loadAvgLine = loadAvg === null
+            ? `${NOT_MEASURED} (${os.platform()} has no load average)`
+            : loadAvg.map(l => l.toFixed(2)).join(', ');
+        output.writeln(output.dim(`Load Average: ${loadAvgLine}`));
         output.writeln(output.dim(`CPUs: ${os.cpus().length} | Platform: ${os.platform()} ${os.release()}`));
         return { success: true };
     },
@@ -571,7 +578,7 @@ export const performanceCommand = {
             'Memory: Int8 quantized weight storage',
         ]);
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by motailz.com'));
+        output.writeln(output.dim('Created with ❤️ by cielolimitada.com'));
         return { success: true };
     },
 };

package/dist/src/cli/commands/plugins.js

@@ -3,7 +3,7 @@
  * Plugin management, installation, and lifecycle
  * Now uses IPFS-based decentralized registry for discovery
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
 import { createPluginDiscoveryService, searchPlugins, getPluginSearchSuggestions, getFeaturedPlugins, getOfficialPlugins, } from '../plugins/store/index.js';
@@ -807,7 +807,7 @@ export const pluginsCommand = {
         ]);
         output.writeln();
         output.writeln(output.dim('Run "flo plugins list --official" to see all official plugins'));
-        output.writeln(output.dim('Created with ❤️ by motailz.com'));
+        output.writeln(output.dim('Created with ❤️ by cielolimitada.com'));
         return { success: true };
     },
 };

package/dist/src/cli/commands/providers.js

@@ -2,7 +2,7 @@
  * V3 CLI Providers Command
  * Manage AI providers, models, and configurations
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
 // List subcommand
@@ -224,7 +224,7 @@ export const providersCommand = {
             'Agentic Flow (optimized ONNX with SIMD)',
         ]);
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by motailz.com'));
+        output.writeln(output.dim('Created with ❤️ by cielolimitada.com'));
         return { success: true };
     },
 };

package/dist/src/cli/commands/retire.js

@@ -13,7 +13,7 @@
  * `retired-files.json` live at the moflo package root and don't ship to
  * consumer projects.
  *
- * Created with motailz.com
+ * Created with cielolimitada.com
  */
 import { output } from '../output.js';
 import { spawnSync } from 'child_process';

package/dist/src/cli/commands/route.js

@@ -8,7 +8,7 @@
  * - Confidence scoring
  * - Learning from feedback
  *
- * Created with love by motailz.com
+ * Created with love by cielolimitada.com
  */
 import { output } from '../output.js';
 import { errorDetail } from '../shared/utils/error-detail.js';

package/dist/src/cli/commands/security.js

@@ -2,7 +2,7 @@
  * V3 CLI Security Command
  * Security scanning, CVE detection, threat modeling, vulnerability management
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
 // Scan subcommand
@@ -331,7 +331,7 @@ const auditCommand = {
     description: 'Security audit logging and compliance',
     options: [
         { name: 'action', short: 'a', type: 'string', description: 'Action: log, list, export, clear', default: 'list' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Number of entries to show', default: '20' },
+        { name: 'limit', short: 'l', type: 'number', description: 'Number of entries to show', default: 20 },
         { name: 'filter', short: 'f', type: 'string', description: 'Filter by event type' },
     ],
     examples: [
@@ -412,7 +412,7 @@ const defendCommand = {
         { name: 'input', short: 'i', type: 'string', description: 'Input text to scan for threats' },
         { name: 'file', short: 'f', type: 'string', description: 'File to scan for threats' },
         { name: 'quick', short: 'Q', type: 'boolean', description: 'Quick scan (faster, less detailed)' },
-        { name: 'learn', short: 'l', type: 'boolean', description: 'Enable learning mode', default: 'true' },
+        { name: 'learn', short: 'l', type: 'boolean', description: 'Enable learning mode', default: true },
         { name: 'stats', short: 's', type: 'boolean', description: 'Show detection statistics' },
         { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
     ],
@@ -566,7 +566,7 @@ export const securityCommand = {
         output.writeln();
         output.writeln('Use --help with subcommands for more info');
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by motailz.com'));
+        output.writeln(output.dim('Created with ❤️ by cielolimitada.com'));
         return { success: true };
     },
 };

package/dist/src/cli/commands/status.js

@@ -79,8 +79,11 @@ async function getSystemStatus() {
         catch {
             // MCP not running
         }
-        // Get memory status
-        const memoryStatus = await callMCPTool('memory_stats', {});
+        // #1349 — this used to call `memory_stats`, which returns none of
+        // `entries` / `size` / `performance`; dereferencing `.performance` threw
+        // and dropped the whole command into its all-zeros fallback. Use the
+        // detailed-stats tool, whose shape this actually needs.
+        const memoryStatus = await callMCPTool('memory_detailed-stats', {});
         // Get task status
         const taskStatus = await callMCPTool('task_summary', {});
         return {
@@ -103,8 +106,7 @@ async function getSystemStatus() {
                 size: formatBytes(memoryStatus.size),
                 backend: memoryStatus.backend,
                 performance: {
-                    searchTime: memoryStatus.performance.avgSearchTime,
-                    cacheHitRate: memoryStatus.performance.cacheHitRate
+                    searchTime: memoryStatus.performance.avgSearchTime
                 }
             },
             tasks: taskStatus,
@@ -131,7 +133,7 @@ async function getSystemStatus() {
                 entries: 0,
                 size: '0 B',
                 backend: 'none',
-                performance: { searchTime: 0, cacheHitRate: 0 }
+                performance: { searchTime: null }
             },
             tasks: { total: 0, pending: 0, running: 0, completed: 0, failed: 0 },
             performance: {
@@ -211,8 +213,8 @@ function displayStatus(status) {
             { property: 'Backend', value: status.memory.backend },
             { property: 'Entries', value: status.memory.entries },
             { property: 'Size', value: status.memory.size },
-            { property: 'Search Time', value: `${status.memory.performance.searchTime.toFixed(2)}ms` },
-            { property: 'Cache Hit Rate', value: `${(status.memory.performance.cacheHitRate * 100).toFixed(1)}%` }
+            // null means the probe never ran — say so rather than print 0.00ms.
+            { property: 'Search Time', value: status.memory.performance.searchTime === null ? 'not measured' : `${status.memory.performance.searchTime.toFixed(2)}ms` }
         ]
     });
     output.writeln();
@@ -456,7 +458,9 @@ const tasksCommand = {
                     { key: 'progress', header: 'Progress', width: 10 }
                 ],
                 data: result.tasks.map(t => ({
-                    id: t.id,
+                    // task_list projects the coordinator id as `taskId`; reading `id`
+                    // left the ID column blank on every row (#1349).
+                    id: t.taskId,
                     type: t.type,
                     status: formatHealth(t.status),
                     priority: t.priority,
@@ -483,7 +487,7 @@ const memoryCommand = {
     description: 'Show detailed memory status',
     action: async (ctx) => {
         try {
-            const result = await callMCPTool('memory_detailed-stats', {});
+            const result = await callMCPTool('memory_detailed-stats', { measureLatency: true });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -500,7 +504,7 @@ const memoryCommand = {
                     { property: 'Backend', value: result.backend },
                     { property: 'Total Entries', value: result.entries.toLocaleString() },
                     { property: 'Storage Size', value: formatBytes(result.size) },
-                    { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Enabled' : 'Disabled' }
+                    { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Active' : 'Not built (search falls back to scan)' }
                 ]
             });
             output.writeln();
@@ -511,9 +515,10 @@ const memoryCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Avg Search Time', value: `${result.performance.avgSearchTime.toFixed(2)}ms` },
-                    { metric: 'Avg Write Time', value: `${result.performance.avgWriteTime.toFixed(2)}ms` },
-                    { metric: 'Cache Hit Rate', value: `${(result.performance.cacheHitRate * 100).toFixed(1)}%` }
+                    // Only metrics the store actually measures — write latency and
+                    // cache hit rate are not tracked anywhere, so they are not shown.
+                    { metric: 'Avg Search Time', value: result.performance.avgSearchTime === null ? 'unavailable' : `${result.performance.avgSearchTime.toFixed(2)}ms` },
+                    { metric: 'Indexed Vectors', value: result.performance.indexedVectors.toLocaleString() }
                 ]
             });
             return { success: true, data: result };

package/dist/src/cli/commands/task.js

@@ -594,6 +594,14 @@ const retryCommand = {
                 taskId,
                 resetState
             });
+            // The handler reports an unknown/unretryable task by returning
+            // success:false, not by throwing — so the catch below never sees it.
+            // Without this check, `task retry does-not-exist` printed
+            // "Task retried / New task ID: undefined" and exited 0 (#1349).
+            if (!result.success) {
+                output.printError(`Failed to retry task: ${result.error ?? 'unknown error'}`);
+                return { success: false, exitCode: 1, data: result };
+            }
             output.writeln();
             output.printSuccess(`Task ${taskId} retried`);
             output.printInfo(`New task ID: ${result.newTaskId}`);

package/dist/src/cli/config/cli-config-store.js

@@ -0,0 +1,326 @@
+/**
+ * CLI JSON config store — the file behind `flo config init|get|set|reset|
+ * export|import|providers`, and the file the healer's `Config File` check
+ * looks for.
+ *
+ * Two neighbouring config surfaces exist; this module is deliberately none of
+ * them:
+ *   - `src/cli/config/moflo-config.ts` owns **moflo.yaml** (gates, sdd,
+ *     daemon, memory backend). `flo config show|generate` operate on that.
+ *   - `src/cli/shared/core/config/loader.ts` owns the `SystemConfig` schema
+ *     loaded from bare `moflo.config.json`-style files in cwd / `~/.moflo`.
+ *
+ * This module owns the project-local `.moflo/config.json` — the first entry in
+ * the doctor's `Config File` candidate list and the path its auto-fix creates.
+ *
+ * Before this module existed the whole `flo config` family was display-only:
+ * `init` printed "Creating claude-flow.config.json..." and returned
+ * `success: true` without a single filesystem call, so `flo doctor --fix`
+ * reported the `Config File` warning as fixed on every run while the warning
+ * never cleared. Same defect class as the synthetic MCP responses labelled at
+ * the call site in #1324/#1325: a success report for work that never happened.
+ *
+ * @module moflo/cli/config/cli-config-store
+ */
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { atomicWriteFileSync } from '../shared/utils/atomic-file-write.js';
+import { mofloDir } from '../services/moflo-paths.js';
+/**
+ * Candidate filenames, canonical first. `doctor-checks-config.ts:checkConfigFile`
+ * imports this list rather than keeping its own, so the healer's check and this
+ * store cannot disagree about whether a config exists — the mismatch that let
+ * the old auto-fix "succeed" against a file the check couldn't see.
+ *
+ * `claude-flow.*` entries are LEGACY-CONFIG: pre-#699 names, still read so
+ * consumers upgrading from older moflo builds keep their existing file.
+ */
+export const CLI_CONFIG_CANDIDATES = [
+    join('.moflo', 'config.json'),
+    'moflo.config.json',
+    'claude-flow.config.json', // LEGACY-CONFIG: pre-#699 fallback
+    '.claude-flow.json', // LEGACY-CONFIG: pre-#699 fallback
+];
+/**
+ * YAML config filenames. Existence-checked only — no yaml parse — and shared
+ * with the doctor for the same anti-drift reason as the JSON list above.
+ */
+export const CLI_CONFIG_YAML_CANDIDATES = [
+    join('.moflo', 'config.yaml'),
+    join('.moflo', 'config.yml'),
+    'moflo.config.yaml',
+    'claude-flow.config.yaml', // LEGACY-CONFIG: pre-#699 fallback
+];
+/** Absolute path of the canonical config file for a project root. */
+export function cliConfigPath(projectRoot) {
+    return join(mofloDir(projectRoot), 'config.json');
+}
+/**
+ * Absolute path of the config file that actually exists, canonical first, or
+ * `null` when the project has none.
+ */
+export function findCliConfigFile(projectRoot) {
+    for (const candidate of CLI_CONFIG_CANDIDATES) {
+        const path = join(projectRoot, candidate);
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}
+/** Default configuration. Values match what `flo config` reported pre-fix. */
+export function defaultCliConfig(opts = {}) {
+    return {
+        version: '3.0.0',
+        v3Mode: opts.v3 ?? true,
+        sparc: opts.sparc ?? false,
+        agents: {
+            defaultType: 'coder',
+            maxConcurrent: 15,
+            autoSpawn: true,
+            timeout: 300,
+        },
+        swarm: {
+            topology: 'hybrid',
+            maxAgents: 15,
+            autoScale: true,
+            coordinationStrategy: 'consensus',
+        },
+        memory: {
+            backend: 'hybrid',
+            path: './data/memory',
+            cacheSize: 256,
+            enableHNSW: true,
+        },
+        mcp: {
+            transport: 'stdio',
+            autoStart: true,
+            tools: 'all',
+        },
+        providers: [
+            { name: 'anthropic', model: 'claude-sonnet-5', priority: 1, enabled: true },
+            { name: 'openrouter', model: 'claude-sonnet-5', priority: 2, enabled: false },
+            { name: 'ollama', model: 'llama3.2', priority: 3, enabled: false },
+            { name: 'gemini', model: 'gemini-2.0-flash', priority: 4, enabled: false },
+        ],
+    };
+}
+/** Thrown when a config file exists but cannot be parsed. */
+export class CliConfigParseError extends Error {
+    path;
+    constructor(path, cause) {
+        super(`Invalid JSON in ${path}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.path = path;
+        this.name = 'CliConfigParseError';
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Deep-merge `patch` over `base`. Arrays are replaced wholesale, not merged. */
+function deepMerge(base, patch) {
+    if (!isPlainObject(patch))
+        return base;
+    if (!isPlainObject(base))
+        return patch;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
+        const current = result[key];
+        result[key] = isPlainObject(value) && isPlainObject(current) ? deepMerge(current, value) : value;
+    }
+    return result;
+}
+/**
+ * Load the project's config, merged over defaults. `path` is `null` when no
+ * file exists — callers get usable defaults either way, and can tell the
+ * difference.
+ *
+ * @throws {CliConfigParseError} when a config file exists but is not valid JSON.
+ */
+export function loadCliConfig(projectRoot) {
+    const path = findCliConfigFile(projectRoot);
+    if (!path)
+        return { config: defaultCliConfig(), path: null };
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        throw new CliConfigParseError(path, err);
+    }
+    return { config: coerceShape(deepMerge(defaultCliConfig(), parsed)), path };
+}
+/**
+ * Restore any section whose type the file contradicts. `deepMerge` is
+ * structural, not validating, so a hand-edited `"providers": "x"` would
+ * survive as a `CliConfig` that lies about its own type and throws the first
+ * time something calls `.find` on it. Falling back to the default for just the
+ * malformed section keeps the rest of the user's file intact.
+ */
+function coerceShape(config) {
+    const defaults = defaultCliConfig();
+    const repaired = { ...config };
+    if (!Array.isArray(repaired.providers))
+        repaired.providers = defaults.providers;
+    for (const section of ['agents', 'swarm', 'memory', 'mcp']) {
+        if (!isPlainObject(repaired[section])) {
+            repaired[section] = defaults[section];
+        }
+    }
+    return repaired;
+}
+/**
+ * Write `config` and return the path written. Writes to the existing file when
+ * there is one (so a consumer's root-level `moflo.config.json` keeps being the
+ * file they edit), otherwise creates the canonical `.moflo/config.json`.
+ */
+export function saveCliConfig(projectRoot, config, opts = {}) {
+    const target = opts.path ?? findCliConfigFile(projectRoot) ?? cliConfigPath(projectRoot);
+    writeJsonFile(target, config);
+    return target;
+}
+/** Write `content` to `path` atomically, creating parent dirs as needed. */
+export function writeTextFile(path, content) {
+    // recursive mkdir is already idempotent — no existence check needed.
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWriteFileSync(path, content);
+}
+/** Serialize `value` as pretty JSON to `path`, creating parent dirs. */
+export function writeJsonFile(path, value) {
+    writeTextFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+/**
+ * Split a dot-notation key, rejecting prototype-polluting segments and empty
+ * ones. Empty segments are rejected rather than filtered out: silently
+ * accepting `swarm..topology` contradicts the loud-failure contract that
+ * `setConfigValue` relies on to catch typos.
+ */
+function splitKey(key) {
+    const segments = key.split('.');
+    if (segments.length === 0 || segments.some((s) => s.length === 0))
+        return null;
+    if (segments.some((s) => s === '__proto__' || s === 'constructor' || s === 'prototype'))
+        return null;
+    return segments;
+}
+/**
+ * Read a dot-notation key (`swarm.topology`, `providers.0.enabled`).
+ * `found: false` for keys the config does not define.
+ */
+export function getConfigValue(config, key) {
+    const segments = splitKey(key);
+    if (!segments)
+        return { found: false };
+    let current = config;
+    for (const segment of segments) {
+        if (current === null || typeof current !== 'object')
+            return { found: false };
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length)
+                return { found: false };
+            current = current[index];
+        }
+        else {
+            if (!Object.prototype.hasOwnProperty.call(current, segment))
+                return { found: false };
+            current = current[segment];
+        }
+    }
+    return { found: true, value: current };
+}
+/**
+ * Coerce a CLI string to the type of the value already at that key, so
+ * `flo config set swarm.maxAgents 20` stores the number 20, not "20".
+ */
+function coerceValue(raw, current) {
+    if (typeof current === 'number') {
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed))
+            return { ok: false, error: `expected a number, got "${raw}"` };
+        return { ok: true, value: parsed };
+    }
+    if (typeof current === 'boolean') {
+        if (/^(true|1|yes|on)$/i.test(raw))
+            return { ok: true, value: true };
+        if (/^(false|0|no|off)$/i.test(raw))
+            return { ok: true, value: false };
+        return { ok: false, error: `expected a boolean, got "${raw}"` };
+    }
+    if (typeof current === 'object' && current !== null) {
+        return { ok: false, error: 'is a section, not a value — set one of its keys instead' };
+    }
+    return { ok: true, value: raw };
+}
+/**
+ * Set a dot-notation key in place. Rejects keys the config does not already
+ * define — a typo should fail loudly, not silently create a key nothing reads.
+ */
+export function setConfigValue(config, key, raw) {
+    const segments = splitKey(key);
+    if (!segments)
+        return { ok: false, error: `invalid key: "${key}"` };
+    const existing = getConfigValue(config, key);
+    if (!existing.found)
+        return { ok: false, error: `unknown key: ${key}` };
+    const coerced = coerceValue(raw, existing.value);
+    if (!coerced.ok)
+        return coerced;
+    const parentSegments = segments.slice(0, -1);
+    const leaf = segments[segments.length - 1];
+    const parent = parentSegments.length === 0
+        ? { found: true, value: config }
+        : getConfigValue(config, parentSegments.join('.'));
+    if (!parent.found || parent.value === null || typeof parent.value !== 'object') {
+        return { ok: false, error: `unknown key: ${key}` };
+    }
+    if (Array.isArray(parent.value)) {
+        parent.value[Number(leaf)] = coerced.value;
+    }
+    else {
+        parent.value[leaf] = coerced.value;
+    }
+    return { ok: true, value: coerced.value };
+}
+/**
+ * Flatten to dotted leaf keys for tabular display. An EMPTY object or array is
+ * itself a leaf — recursing over zero entries would otherwise drop the key
+ * entirely, so `providers: []` would vanish from `flo config get` and read as
+ * "not configured" rather than "configured empty".
+ */
+export function flattenConfig(value, prefix = '') {
+    const flat = {};
+    const key = prefix.replace(/\.$/, '');
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            flat[key] = '[]';
+            return flat;
+        }
+        value.forEach((item, index) => Object.assign(flat, flattenConfig(item, `${prefix}${index}.`)));
+        return flat;
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            flat[key] = '{}';
+            return flat;
+        }
+        for (const [childKey, child] of entries) {
+            Object.assign(flat, flattenConfig(child, `${prefix}${childKey}.`));
+        }
+        return flat;
+    }
+    flat[key] = value;
+    return flat;
+}
+/** Config sections `flo config reset --section` accepts. */
+export const RESETTABLE_SECTIONS = ['agents', 'swarm', 'memory', 'mcp', 'providers', 'all'];
+/** Return `config` with `section` (or everything) restored to defaults. */
+export function resetSection(config, section) {
+    const defaults = defaultCliConfig({ v3: config.v3Mode, sparc: config.sparc });
+    if (section === 'all')
+        return defaults;
+    return { ...config, [section]: defaults[section] };
+}
+//# sourceMappingURL=cli-config-store.js.map

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

@@ -9,6 +9,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs/promises';
 import { errorDetail } from '../../shared/utils/error-detail.js';
+import { readLoadAverage } from '../../shared/utils/load-average.js';
 // ============================================================================
 // Security Constants
 // ============================================================================
@@ -502,7 +503,9 @@ export class WorkerManager extends EventEmitter {
                 issues: securityResult?.totalIssues ?? 0,
             },
             performance: {
-                speedup: perfResult?.speedup ?? '1.0x',
+                // Null both when the worker has not run yet and when the platform has
+                // no load average — in either case there is nothing measured to show.
+                loadAvg: perfResult?.cpu?.loadAvg ?? null,
             },
             alerts: this.alerts.filter(a => a.severity === AlertSeverity.Critical).slice(-5),
             lastUpdate: new Date().toISOString(),
@@ -537,8 +540,10 @@ export class WorkerManager extends EventEmitter {
         const secIcon = data.security.status === 'critical' ? '🚨' :
             data.security.status === 'warning' ? '⚠️' : '🛡️';
         parts.push(`${secIcon}${data.security.issues}`);
-        // Performance
-        parts.push(`⚡${data.performance.speedup}`);
+        // Performance — 'n/a' rather than a zero, for the same reason the field
+        // is nullable: a statusline is exactly where an unmeasured value gets
+        // read as a measured one.
+        parts.push(`⚡${data.performance.loadAvg ?? 'n/a'}`);
         return parts.join(' │ ');
     }
     // =========================================================================
@@ -770,9 +775,9 @@ export function createPerformanceWorker(projectRoot) {
         const totalMem = os.totalmem();
         const freeMem = os.freemem();
         const memPct = Math.round((1 - freeMem / totalMem) * 100);
-        // CPU load
+        // CPU load — null where the platform has none (#1358), never "0.00"
         const cpus = os.cpus();
-        const loadAvg = os.loadavg()[0];
+        const loadAvg = readLoadAverage(os.loadavg(), os.platform());
         return {
             worker: 'performance',
             success: true,
@@ -786,9 +791,8 @@ export function createPerformanceWorker(projectRoot) {
                 },
                 cpu: {
                     cores: cpus.length,
-                    loadAvg: loadAvg.toFixed(2),
+                    loadAvg: loadAvg === null ? null : loadAvg[0].toFixed(2),
                 },
-                speedup: '1.0x', // Placeholder
             },
         };
     };
@@ -800,7 +804,9 @@ export function createHealthWorker(projectRoot) {
         const freeMem = os.freemem();
         const memPct = Math.round((1 - freeMem / totalMem) * 100);
         const uptime = os.uptime();
-        const loadAvg = os.loadavg();
+        // null where the platform has none (#1358) — three zeros would read as an
+        // idle machine rather than as an absent reading.
+        const loadAvg = readLoadAverage(os.loadavg(), os.platform());
         // Disk space (cross-platform approximation)
         let diskPct = 0;
         let diskFree = 'N/A';
@@ -825,7 +831,7 @@ export function createHealthWorker(projectRoot) {
                 disk: { usedPct: diskPct, free: diskFree },
                 system: {
                     uptime: Math.round(uptime / 3600),
-                    loadAvg: loadAvg.map(l => l.toFixed(2)),
+                    loadAvg: loadAvg === null ? null : loadAvg.map(l => l.toFixed(2)),
                     platform: os.platform(),
                     arch: os.arch(),
                 },