moflo 4.12.3 → 4.12.4-rc.2

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

@@ -2,7 +2,7 @@
  * V3 CLI Completions Command
  * Shell completions for bash, zsh, fish, powershell
  *
- * Created with motailz.com
+ * Created with cielolimitada.com
  */
 import { output } from '../output.js';
 // Get all top-level commands for completions

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

@@ -1,9 +1,58 @@
 /**
  * V3 CLI Config Command
  * Configuration management
+ *
+ * Every subcommand here reads and writes a real file — see
+ * `../config/cli-config-store.ts` for the store and for why that is worth
+ * stating: this family used to print "Creating ..." and "Configuration
+ * updated" without touching the filesystem, which made `flo doctor --fix`
+ * report the `Config File` warning as fixed forever.
+ *
+ * `show` and `generate` are the odd pair out: they operate on **moflo.yaml**
+ * via `../config/moflo-config.ts`, not on the JSON config.
  */
+import { existsSync, readFileSync } from 'node:fs';
+import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
+import { resolveStateRoot } from '../services/project-root.js';
+import { CliConfigParseError, RESETTABLE_SECTIONS, cliConfigPath, defaultCliConfig, findCliConfigFile, flattenConfig, getConfigValue, loadCliConfig, resetSection, saveCliConfig, setConfigValue, writeJsonFile, writeTextFile, } from '../config/cli-config-store.js';
+/**
+ * Anchor config reads/writes at the state root — `resolveStateRoot`, not
+ * `findProjectRoot`, because this command CREATES `.moflo/` content and must
+ * land on the monorepo's canonical anchor rather than minting an island in a
+ * sub-workspace (#1315).
+ */
+function configRoot(ctx) {
+    return resolveStateRoot({ cwd: ctx.cwd || process.cwd() });
+}
+/**
+ * Path relative to the project root, for display. Builds the `./` prefix from
+ * `path.sep` so Windows shows `.\.moflo\config.json` rather than a mixed
+ * `./.moflo\config.json`.
+ */
+function displayPath(root, target) {
+    const rel = relative(root, target);
+    return rel && !rel.startsWith('..') ? `.${sep}${rel}` : target;
+}
+/**
+ * Load config, printing the parse error and returning `null` when the file on
+ * disk is corrupt. Callers exit 1 on `null` rather than silently falling back
+ * to defaults — a config that cannot be read is a failure, not a default.
+ */
+function loadOrReport(root) {
+    try {
+        return loadCliConfig(root);
+    }
+    catch (err) {
+        if (err instanceof CliConfigParseError) {
+            output.printError(err.message);
+            output.writeln(output.dim('  Fix the JSON syntax, or run `flo config init --force` to rewrite it.'));
+            return null;
+        }
+        throw err;
+    }
+}
 // Init configuration
 const initCommand = {
     name: 'init',
@@ -32,54 +81,27 @@ const initCommand = {
     action: async (ctx) => {
         const sparc = ctx.flags.sparc;
         const v3 = ctx.flags.v3;
+        const force = ctx.flags.force;
+        const root = configRoot(ctx);
+        const existing = findCliConfigFile(root);
+        if (existing && !force) {
+            output.printError(`Configuration already exists: ${displayPath(root, existing)}`);
+            output.writeln(output.dim('  Re-run with --force to overwrite it.'));
+            return { success: false, exitCode: 1 };
+        }
         output.writeln();
         output.printInfo('Initializing MoFlo configuration...');
         output.writeln();
-        // Create default configuration
-        const config = {
-            version: '3.0.0',
-            v3Mode: v3,
-            sparc: sparc,
-            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', priority: 1, enabled: true },
-                { name: 'openrouter', priority: 2, enabled: false },
-                { name: 'ollama', priority: 3, enabled: false }
-            ]
-        };
-        output.writeln(output.dim('  Creating claude-flow.config.json...'));
-        output.writeln(output.dim('  Creating .moflo/ directory...'));
-        if (sparc) {
-            output.writeln(output.dim('  Initializing SPARC methodology...'));
-            output.writeln(output.dim('  Creating SPARC workflow files...'));
-        }
-        if (v3) {
-            output.writeln(output.dim('  Enabling V3 15-agent coordination...'));
-            output.writeln(output.dim('  Configuring AgentDB integration...'));
-            output.writeln(output.dim('  Setting up Flash Attention optimization...'));
+        const config = defaultCliConfig({ v3, sparc });
+        const target = existing ?? cliConfigPath(root);
+        try {
+            saveCliConfig(root, config, { path: target });
         }
+        catch (err) {
+            output.printError(`Failed to write ${displayPath(root, target)}: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln(output.dim(`  Wrote ${displayPath(root, target)}`));
         output.writeln();
         output.printTable({
             columns: [
@@ -98,7 +120,7 @@ const initCommand = {
         });
         output.writeln();
         output.printSuccess('Configuration initialized');
-        output.writeln(output.dim('  Config file: ./claude-flow.config.json'));
+        output.writeln(output.dim(`  Config file: ${displayPath(root, target)}`));
         return { success: true, data: config };
     }
 };
@@ -120,39 +142,32 @@ 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
-        };
+        const root = configRoot(ctx);
+        const loaded = loadOrReport(root);
+        if (!loaded)
+            return { success: false, exitCode: 1 };
+        const { config, path } = loaded;
         if (!key) {
-            // Show all config
+            const configValues = flattenConfig(config);
             if (ctx.flags.format === 'json') {
                 output.printJson(configValues);
                 return { success: true, data: configValues };
             }
             output.writeln();
             output.writeln(output.bold('Current Configuration'));
+            output.writeln(output.dim(path ? `  ${displayPath(root, path)}` : '  (no config file — showing defaults)'));
             output.writeln();
             output.printTable({
                 columns: [
-                    { key: 'key', header: 'Key', width: 25 },
+                    { key: 'key', header: 'Key', width: 30 },
                     { key: 'value', header: 'Value', width: 30 }
                 ],
                 data: Object.entries(configValues).map(([k, v]) => ({ key: k, value: String(v) }))
             });
             return { success: true, data: configValues };
         }
-        const value = configValues[key];
-        if (value === undefined) {
+        const { found, value } = getConfigValue(config, key);
+        if (!found) {
             output.printError(`Configuration key not found: ${key}`);
             return { success: false, exitCode: 1 };
         }
@@ -160,7 +175,7 @@ const getCommand = {
             output.printJson({ key, value });
         }
         else {
-            output.writeln(`${key} = ${value}`);
+            output.writeln(`${key} = ${typeof value === 'object' ? JSON.stringify(value) : String(value)}`);
         }
         return { success: true, data: { key, value } };
     }
@@ -170,19 +185,21 @@ const setCommand = {
     name: 'set',
     description: 'Set configuration value',
     options: [
+        // Not `required` at the parser level: these are also accepted
+        // positionally (`flo config set swarm.maxAgents 20`, this command's own
+        // documented example), and a parser-level requirement rejects that form
+        // before the action can read ctx.args. The action validates instead.
         {
             name: 'key',
             short: 'k',
             description: 'Configuration key',
-            type: 'string',
-            required: true
+            type: 'string'
         },
         {
             name: 'value',
             short: 'v',
             description: 'Configuration value',
-            type: 'string',
-            required: true
+            type: 'string'
         }
     ],
     examples: [
@@ -196,9 +213,27 @@ const setCommand = {
             output.printError('Both key and value are required');
             return { success: false, exitCode: 1 };
         }
-        output.printInfo(`Setting ${key} = ${value}`);
-        output.printSuccess('Configuration updated');
-        return { success: true, data: { key, value } };
+        const root = configRoot(ctx);
+        const loaded = loadOrReport(root);
+        if (!loaded)
+            return { success: false, exitCode: 1 };
+        const { config } = loaded;
+        const result = setConfigValue(config, key, String(value));
+        if (!result.ok) {
+            output.printError(`Cannot set ${key}: ${result.error}`);
+            return { success: false, exitCode: 1 };
+        }
+        let target;
+        try {
+            target = saveCliConfig(root, config, { path: loaded.path ?? undefined });
+        }
+        catch (err) {
+            output.printError(`Failed to write configuration: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Setting ${key} = ${String(result.value)}`);
+        output.printSuccess(`Configuration updated (${displayPath(root, target)})`);
+        return { success: true, data: { key, value: result.value } };
     }
 };
 // List providers
@@ -230,12 +265,58 @@ const providersCommand = {
         }
     ],
     action: async (ctx) => {
-        const providers = [
-            { 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' }
-        ];
+        const root = configRoot(ctx);
+        const loaded = loadOrReport(root);
+        if (!loaded)
+            return { success: false, exitCode: 1 };
+        const { config } = loaded;
+        const add = ctx.flags.add;
+        const remove = ctx.flags.remove;
+        const enable = ctx.flags.enable;
+        const disable = ctx.flags.disable;
+        const find = (name) => config.providers.find((p) => p.name.toLowerCase() === name.toLowerCase());
+        let mutated = false;
+        if (add) {
+            if (find(add)) {
+                output.printError(`Provider already exists: ${add}`);
+                return { success: false, exitCode: 1 };
+            }
+            const priority = config.providers.reduce((max, p) => Math.max(max, p.priority), 0) + 1;
+            config.providers.push({ name: add, priority, enabled: false });
+            mutated = true;
+        }
+        for (const [name, action] of [[remove, 'remove'], [enable, 'enable'], [disable, 'disable']]) {
+            if (!name)
+                continue;
+            const provider = find(name);
+            if (!provider) {
+                output.printError(`Provider not found: ${name}`);
+                return { success: false, exitCode: 1 };
+            }
+            if (action === 'remove') {
+                config.providers = config.providers.filter((p) => p !== provider);
+            }
+            else {
+                provider.enabled = action === 'enable';
+            }
+            mutated = true;
+        }
+        if (mutated) {
+            let target;
+            try {
+                target = saveCliConfig(root, config, { path: loaded.path ?? undefined });
+            }
+            catch (err) {
+                output.printError(`Failed to write configuration: ${err.message}`);
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Providers updated (${displayPath(root, target)})`);
+        }
+        const providers = config.providers.map((p) => ({
+            ...p,
+            model: p.model ?? '',
+            status: p.enabled ? 'Active' : 'Disabled'
+        }));
         if (ctx.flags.format === 'json') {
             output.printJson(providers);
             return { success: true, data: providers };
@@ -277,12 +358,17 @@ const resetCommand = {
             name: 'section',
             description: 'Reset specific section only',
             type: 'string',
-            choices: ['agents', 'swarm', 'memory', 'mcp', 'providers', 'all']
+            choices: [...RESETTABLE_SECTIONS]
         }
     ],
     action: async (ctx) => {
         const force = ctx.flags.force;
-        const section = ctx.flags.section || 'all';
+        const section = (ctx.flags.section || 'all');
+        if (!RESETTABLE_SECTIONS.includes(section)) {
+            output.printError(`Unknown section: ${section}`);
+            output.writeln(output.dim(`  Valid sections: ${RESETTABLE_SECTIONS.join(', ')}`));
+            return { success: false, exitCode: 1 };
+        }
         if (!force && ctx.interactive) {
             const confirmed = await confirm({
                 message: `Reset ${section} configuration to defaults?`,
@@ -293,9 +379,21 @@ const resetCommand = {
                 return { success: true };
             }
         }
+        const root = configRoot(ctx);
+        const loaded = loadOrReport(root);
+        if (!loaded)
+            return { success: false, exitCode: 1 };
         output.printInfo(`Resetting ${section} configuration...`);
-        output.printSuccess('Configuration reset to defaults');
-        return { success: true, data: { section, reset: true } };
+        let target;
+        try {
+            target = saveCliConfig(root, resetSection(loaded.config, section), { path: loaded.path ?? undefined });
+        }
+        catch (err) {
+            output.printError(`Failed to write configuration: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printSuccess(`Configuration reset to defaults (${displayPath(root, target)})`);
+        return { success: true, data: { section, reset: true, path: target } };
     }
 };
 // Export configuration
@@ -319,20 +417,39 @@ const exportCommand = {
         }
     ],
     action: async (ctx) => {
-        const outputPath = ctx.flags.output || './claude-flow.config.export.json';
-        const config = {
-            version: '3.0.0',
-            exportedAt: new Date().toISOString(),
-            agents: { defaultType: 'coder', maxConcurrent: 15 },
-            swarm: { topology: 'hybrid', maxAgents: 15 },
-            memory: { backend: 'hybrid', cacheSize: 256 },
-            mcp: { transport: 'stdio', tools: 'all' }
-        };
-        output.printInfo(`Exporting configuration to ${outputPath}...`);
-        output.printJson(config);
+        const format = ctx.flags.format || 'json';
+        if (format !== 'json' && format !== 'yaml') {
+            output.printError(`Unsupported export format: ${format}`);
+            output.writeln(output.dim('  Valid formats: json, yaml'));
+            return { success: false, exitCode: 1 };
+        }
+        const root = configRoot(ctx);
+        const loaded = loadOrReport(root);
+        if (!loaded)
+            return { success: false, exitCode: 1 };
+        const requested = ctx.flags.output;
+        const defaultName = `moflo.config.export.${format === 'yaml' ? 'yaml' : 'json'}`;
+        const outputPath = requested
+            ? (isAbsolute(requested) ? requested : resolve(root, requested))
+            : resolve(root, defaultName);
+        const config = { ...loaded.config, exportedAt: new Date().toISOString() };
+        output.printInfo(`Exporting configuration to ${displayPath(root, outputPath)}...`);
+        try {
+            if (format === 'yaml') {
+                const { dump } = await import('js-yaml');
+                writeTextFile(outputPath, dump(config));
+            }
+            else {
+                writeJsonFile(outputPath, config);
+            }
+        }
+        catch (err) {
+            output.printError(`Failed to write ${displayPath(root, outputPath)}: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
         output.writeln();
         output.printSuccess('Configuration exported');
-        return { success: true, data: { path: outputPath, config } };
+        return { success: true, data: { path: outputPath, format, config } };
     }
 };
 // Import configuration
@@ -340,12 +457,13 @@ const importCommand = {
     name: 'import',
     description: 'Import configuration',
     options: [
+        // Also accepted positionally (`flo config import ./cfg.json`) — see the
+        // note on `set`.
         {
             name: 'file',
             short: 'f',
             description: 'Configuration file path',
-            type: 'string',
-            required: true
+            type: 'string'
         },
         {
             name: 'merge',
@@ -361,15 +479,57 @@ const importCommand = {
             output.printError('File path is required');
             return { success: false, exitCode: 1 };
         }
+        const root = configRoot(ctx);
+        const source = isAbsolute(file) ? file : resolve(root, file);
+        if (!existsSync(source)) {
+            output.printError(`Configuration file not found: ${file}`);
+            return { success: false, exitCode: 1 };
+        }
+        let incoming;
+        try {
+            const raw = readFileSync(source, 'utf8');
+            if (extname(source).toLowerCase() === '.yaml' || extname(source).toLowerCase() === '.yml') {
+                const { load } = await import('js-yaml');
+                incoming = load(raw);
+            }
+            else {
+                incoming = JSON.parse(raw);
+            }
+        }
+        catch (err) {
+            output.printError(`Could not parse ${file}: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
+        if (typeof incoming !== 'object' || incoming === null || Array.isArray(incoming)) {
+            output.printError(`Not a configuration object: ${file}`);
+            return { success: false, exitCode: 1 };
+        }
         output.printInfo(`Importing configuration from ${file}...`);
+        // Merge mode layers the file over what is on disk; replace mode layers it
+        // over defaults, so an incomplete file still yields a complete config.
+        let base;
         if (merge) {
+            const loaded = loadOrReport(root);
+            if (!loaded)
+                return { success: false, exitCode: 1 };
+            base = loaded.config;
             output.writeln(output.dim('  Merging with existing configuration...'));
         }
         else {
+            base = defaultCliConfig();
             output.writeln(output.dim('  Replacing existing configuration...'));
         }
-        output.printSuccess('Configuration imported');
-        return { success: true, data: { file, merge, imported: true } };
+        const imported = { ...base, ...incoming };
+        let target;
+        try {
+            target = saveCliConfig(root, imported);
+        }
+        catch (err) {
+            output.printError(`Failed to write configuration: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printSuccess(`Configuration imported (${displayPath(root, target)})`);
+        return { success: true, data: { file, merge, imported: true, path: target } };
     }
 };
 // Show moflo project config (merged with defaults)

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

@@ -2,7 +2,7 @@
  * V3 CLI Deployment Command
  * Deployment management, environments, rollbacks
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
 // Deploy subcommand
@@ -14,7 +14,7 @@ const deployCommand = {
         { name: 'version', short: 'v', type: 'string', description: 'Version to deploy', default: 'latest' },
         { name: 'dry-run', short: 'd', type: 'boolean', description: 'Simulate deployment without changes' },
         { name: 'force', short: 'f', type: 'boolean', description: 'Force deployment without checks' },
-        { name: 'rollback-on-fail', type: 'boolean', description: 'Auto rollback on failure', default: 'true' },
+        { name: 'rollback-on-fail', type: 'boolean', description: 'Auto rollback on failure', default: true },
     ],
     examples: [
         { command: 'flo deployment deploy -e prod', description: 'Deploy to production' },
@@ -100,7 +100,7 @@ const rollbackCommand = {
     options: [
         { name: 'env', short: 'e', type: 'string', description: 'Environment to rollback', required: true },
         { name: 'version', short: 'v', type: 'string', description: 'Specific version to rollback to' },
-        { name: 'steps', short: 's', type: 'number', description: 'Number of versions to rollback', default: '1' },
+        { name: 'steps', short: 's', type: 'number', description: 'Number of versions to rollback', default: 1 },
     ],
     examples: [
         { command: 'flo deployment rollback -e prod', description: 'Rollback production' },
@@ -141,7 +141,7 @@ const historyCommand = {
     description: 'View deployment history',
     options: [
         { name: 'env', short: 'e', type: 'string', description: 'Filter by environment' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Number of entries', default: '10' },
+        { name: 'limit', short: 'l', type: 'number', description: 'Number of entries', default: 10 },
     ],
     examples: [
         { command: 'flo deployment history', description: 'Show all history' },
@@ -214,7 +214,7 @@ const logsCommand = {
         { name: 'deployment', short: 'd', type: 'string', description: 'Deployment ID' },
         { name: 'env', short: 'e', type: 'string', description: 'Environment' },
         { name: 'follow', short: 'f', type: 'boolean', description: 'Follow log output' },
-        { name: 'lines', short: 'n', type: 'number', description: 'Number of lines', default: '50' },
+        { name: 'lines', short: 'n', type: 'number', description: 'Number of lines', default: 50 },
     ],
     examples: [
         { command: 'flo deployment logs -e prod', description: 'View production logs' },
@@ -281,7 +281,7 @@ export const deploymentCommand = {
             'Deployment previews for PRs',
         ]);
         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/diagnose.js

@@ -8,7 +8,7 @@
  *
  * All test data is cleaned up after each test — no code or state is left behind.
  *
- * Created with motailz.com
+ * Created with cielolimitada.com
  */
 import { output } from '../output.js';
 import { errorDetail } from '../shared/utils/error-detail.js';

package/dist/src/cli/commands/doctor-checks-config.js

@@ -10,41 +10,37 @@ import { findProjectDaemonPids, getDaemonLockHolder, getDaemonLockPayload, } fro
 import { resolveClientPort, LEGACY_DEFAULT_PORT, probeDaemonHealthWithRetry as probeDaemonHealthIdentity, normalizeProjectRoot, } from '../services/daemon-port.js';
 import { COMMON_WALK_SKIP_NAMES, LEGACY_SWARM_DIR, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
 import { probeDbIntegrity } from '../services/memory-db-integrity-repair.js';
+import { CLI_CONFIG_CANDIDATES, CLI_CONFIG_YAML_CANDIDATES } from '../config/cli-config-store.js';
 import { findProjectRoot, resolveStateRoot } from '../services/project-root.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 export async function checkConfigFile() {
-    // JSON configs (parse-validated). LEGACY-CONFIG: `.claude-flow.json` and
-    // `claude-flow.config.json` filenames are still recognised so consumers
-    // upgrading from pre-#699 moflo builds keep working
-    // without manual rename. Drift guard exempts these via LEGACY-CONFIG marker.
-    const jsonPaths = [
-        '.moflo/config.json',
-        'moflo.config.json',
-        'claude-flow.config.json', // LEGACY-CONFIG: pre-#699 fallback
-        '.claude-flow.json', // LEGACY-CONFIG: pre-#699 fallback
-    ];
-    for (const configPath of jsonPaths) {
+    // Resolve against the state root, not the bare cwd: running `flo doctor`
+    // from a subdirectory used to report "no config file" for a project that has
+    // one, and the auto-fix (which writes at the state root) could never clear
+    // the warning it raised. Same anchor as `flo config` (#1315).
+    const root = resolveStateRoot();
+    // JSON configs (parse-validated). The candidate list lives in the config
+    // store so this check, `flo config`, and the doctor auto-fix all agree on
+    // which files count. LEGACY-CONFIG: `claude-flow.*` names are still
+    // recognised there so consumers upgrading from pre-#699 moflo builds keep
+    // working without a manual rename.
+    for (const candidate of CLI_CONFIG_CANDIDATES) {
+        const configPath = join(root, candidate);
         if (existsSync(configPath)) {
             try {
                 const content = readFileSync(configPath, 'utf8');
                 JSON.parse(content);
-                return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
+                return { name: 'Config File', status: 'pass', message: `Found: ${candidate}` };
             }
             catch {
-                return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${configPath}`, fix: 'Fix JSON syntax in config file' };
+                return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${candidate}`, fix: 'Fix JSON syntax in config file' };
             }
         }
     }
     // YAML configs (existence-checked only — no heavy yaml parser dependency).
-    const yamlPaths = [
-        '.moflo/config.yaml',
-        '.moflo/config.yml',
-        'moflo.config.yaml',
-        'claude-flow.config.yaml', // LEGACY-CONFIG: pre-#699 fallback
-    ];
-    for (const configPath of yamlPaths) {
-        if (existsSync(configPath)) {
-            return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
+    for (const candidate of CLI_CONFIG_YAML_CANDIDATES) {
+        if (existsSync(join(root, candidate))) {
+            return { name: 'Config File', status: 'pass', message: `Found: ${candidate}` };
         }
     }
     return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'npx moflo config init' };

package/dist/src/cli/commands/doctor-checks-deep.js

@@ -11,7 +11,7 @@
  * so these checks work both in the dev repo AND in consumer projects where
  * moflo is installed under node_modules/moflo/.
  *
- * Created with motailz.com
+ * Created with cielolimitada.com
  */
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';