moflo 4.12.3 → 4.12.4-rc.2

package/bin/generate-code-map.mjs

@@ -168,7 +168,7 @@ function readCodeMapConfig() {
   const defaults = {
     directories: ['src'],
     extensions: [
-      '.ts', '.tsx', '.js', '.mjs', '.jsx',         // JS/TS
+      '.ts', '.tsx', '.js', '.mjs', '.cjs', '.jsx', // JS/TS
       '.py', '.pyi',                                  // Python
       '.go',                                           // Go
       '.java', '.kt', '.kts',                         // JVM
@@ -210,6 +210,18 @@ function readCodeMapConfig() {
   } catch { return defaults; }
 }
 
+/**
+ * Extension of `p`, lowercased.
+ *
+ * Rule #1: NTFS (Windows) and APFS (macOS) are case-insensitive by default, so a
+ * file committed as `Foo.MJS` is routine there. `extname()` returns the literal
+ * `.MJS` on every platform — including Linux — so an exact compare against a
+ * lowercase list silently skips the file everywhere. Normalise both sides. (#1337)
+ */
+function normExt(p) {
+  return extname(p).toLowerCase();
+}
+
 /** Walk a directory tree collecting source files (filesystem fallback). */
 function walkDir(dir, extensions, excludeSet, maxDepth = 8, depth = 0) {
   if (depth > maxDepth) return [];
@@ -225,8 +237,7 @@ function walkDir(dir, extensions, excludeSet, maxDepth = 8, depth = 0) {
     if (entry.isDirectory()) {
       results.push(...walkDir(rel, extensions, excludeSet, maxDepth, depth + 1));
     } else if (entry.isFile()) {
-      const ext = extname(entry.name);
-      if (extensions.has(ext)) results.push(rel);
+      if (extensions.has(normExt(entry.name))) results.push(rel);
     }
   }
   return results;
@@ -234,11 +245,18 @@ function walkDir(dir, extensions, excludeSet, maxDepth = 8, depth = 0) {
 
 function getSourceFiles() {
   const config = readCodeMapConfig();
-  const extSet = new Set(config.extensions);
+  // Lowercase the configured list too, so `extensions: [".MJS"]` in a consumer's
+  // moflo.yaml still matches the normalised extension of a scanned file.
+  const extSet = new Set(config.extensions.map(e => e.toLowerCase()));
   const excludeSet = new Set(config.exclude);
 
-  // Build git glob patterns from configured extensions
-  const gitGlobArgs = config.extensions.map(ext => `*${ext}`);
+  // Build git glob patterns from configured extensions.
+  // `:(icase)` is required, not cosmetic: git pathspec globs are case-sensitive
+  // regardless of `core.ignorecase` (verified on git 2.43 with the setting both
+  // on and off), so a bare `*.mjs` misses a committed `Foo.MJS` on every
+  // platform. This is the primary enumeration path — normalising `extname()` in
+  // the filesystem fallback alone would leave it broken. (#1337)
+  const gitGlobArgs = config.extensions.map(ext => `:(icase)*${ext}`);
 
   // Try git ls-files first (fast, respects .gitignore)
   try {
@@ -415,19 +433,48 @@ const EXT_TO_LANG = {
 
 const ENTITY_DECORATOR = /@Entity\s*\(/;
 
-function extractTypes(filePath) {
+/**
+ * Dispatch-command string literals (`case 'check-before-done':`).
+ *
+ * Symbol extraction alone leaves command routers unsearchable: in `bin/gate.cjs`
+ * the gate names exist only as `case` labels, so the one token a agent would
+ * actually query on ("check-before-done") never reached the index. Indexing the
+ * file made it present but still unfindable. (#1337)
+ *
+ * Deliberately narrow — `case` labels only, and only those bearing an internal
+ * separator, so it adds routing vocabulary without pulling in arbitrary strings.
+ */
+const DISPATCH_CASE = /\bcase\s+['"`]([A-Za-z][\w.:-]{2,60})['"`]\s*:/g;
+const MAX_COMMANDS = 40;
+
+function extractDispatchCommands(content) {
+  const found = new Set();
+  for (const m of content.matchAll(DISPATCH_CASE)) {
+    // Internal separator required: skips bare enum-ish words (`case 'open':`)
+    // while keeping real command names (`check-before-pr`, `hooks:post-edit`).
+    if (/[.:-]/.test(m[1])) found.add(m[1]);
+    if (found.size >= MAX_COMMANDS) break;
+  }
+  return [...found];
+}
+
+/**
+ * Read a source file once and extract both its type declarations and its
+ * dispatch-command literals. Single read: `generateFileEntries` used to
+ * re-open every file for commands, doubling I/O across the whole tree.
+ */
+function extractFileFacts(filePath) {
   const fullPath = resolve(projectRoot, filePath);
-  if (!existsSync(fullPath)) return [];
+  if (!existsSync(fullPath)) return { types: [], commands: [] };
 
   let content;
   try {
     content = readFileSync(fullPath, 'utf-8');
   } catch {
-    return [];
+    return { types: [], commands: [] };
   }
 
-  const ext = extname(filePath);
-  const lang = EXT_TO_LANG[ext] || 'ts';
+  const lang = EXT_TO_LANG[normExt(filePath)] || 'ts';
   const patterns = LANG_PATTERNS[lang] || LANG_PATTERNS.ts;
 
   const lines = content.split('\n');
@@ -471,7 +518,7 @@ function extractTypes(filePath) {
     }
   }
 
-  return types;
+  return { types, commands: extractDispatchCommands(content) };
 }
 
 function detectKind(line, name, lang) {
@@ -516,7 +563,6 @@ function getDirDescription(dirName) {
 }
 
 function detectLanguage(filePath) {
-  const ext = extname(filePath);
   const langMap = {
     '.tsx': 'React/TypeScript', '.jsx': 'React/JavaScript',
     '.ts': 'TypeScript', '.mjs': 'ESM', '.cjs': 'CommonJS', '.js': 'JavaScript',
@@ -530,7 +576,7 @@ function detectLanguage(filePath) {
     '.php': 'PHP',
     '.c': 'C', '.h': 'C/C++ Header', '.cpp': 'C++', '.hpp': 'C++ Header', '.cc': 'C++',
   };
-  return langMap[ext] || 'Unknown';
+  return langMap[normExt(filePath)] || 'Unknown';
 }
 
 // ---------------------------------------------------------------------------
@@ -714,7 +760,7 @@ function generateTypeIndex(allTypes) {
  * This enables precise semantic search: a query for "CompanyAuditLog" will match
  * the specific file entry rather than being diluted across a batch of 80 types.
  */
-function generateFileEntries(typesByFile) {
+function generateFileEntries(typesByFile, commandsByFile) {
   const chunks = [];
 
   for (const [filePath, types] of Object.entries(typesByFile)) {
@@ -744,6 +790,11 @@ function generateFileEntries(typesByFile) {
       content += '\nSource file (no detected exports)\n';
     }
 
+    const commands = commandsByFile[filePath];
+    if (commands && commands.length > 0) {
+      content += `\nHandles commands: ${commands.join(', ')}\n`;
+    }
+
     // Build tags for filtering
     const tags = ['file', project];
     if (types.some(t => t.isEntity)) tags.push('entity');
@@ -833,17 +884,19 @@ async function main() {
   const typesByProject = {};
   const typesByDir = {};
   const typesByFile = {};
+  const commandsByFile = {};
 
   for (const file of files) {
     const project = getProjectName(file);
     if (!filesByProject[project]) filesByProject[project] = [];
     filesByProject[project].push(file);
 
-    const types = extractTypes(file);
+    const { types, commands } = extractFileFacts(file);
 
     // Track ALL files for file-level entries (not just those with types)
     // This ensures plain JS projects without explicit exports still get indexed
     typesByFile[file] = types;
+    if (commands.length > 0) commandsByFile[file] = commands;
 
     for (const t of types) {
       allTypes.push(t);
@@ -866,7 +919,7 @@ async function main() {
   const dirChunks = generateDirectoryDetails(typesByDir);
   const ifaceChunks = generateInterfaceMaps(allTypes);
   const typeIdxChunks = generateTypeIndex(allTypes);
-  const fileChunks = generateFileEntries(typesByFile);
+  const fileChunks = generateFileEntries(typesByFile, commandsByFile);
 
   const allChunks = [...projectChunks, ...dirChunks, ...ifaceChunks, ...typeIdxChunks, ...fileChunks];
 

package/bin/index-all.mjs

@@ -24,6 +24,7 @@ import {
   computeStepFingerprint,
   saveStepFingerprint,
   cleanupLegacyFingerprint,
+  FORCE_ENV,
 } from './lib/index-fingerprint.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
 
@@ -42,6 +43,43 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // during development but gets synced to .claude/scripts/ in consumer projects,
 // so __dirname-relative paths break. findProjectRoot() (lib/moflo-paths.mjs)
 // works in both locations and resolves identically to the TS bridge.
+/**
+ * Parse argv (#1323). This script previously read NO arguments at all, so
+ * `index-all.mjs --force` was accepted and did nothing — a no-op that looks
+ * exactly like a successful forced reindex, which is how guidance staleness
+ * got misdiagnosed in the first place. `--force` is now an alias for the
+ * documented `FLO_FORCE_INDEX=1`, and anything unrecognised exits non-zero
+ * rather than being silently dropped.
+ */
+function parseArgs(argv) {
+  const unknown = [];
+  let force = false;
+  for (const arg of argv) {
+    if (arg === '--force' || arg === '-f') force = true;
+    else if (arg === '--help' || arg === '-h') return { help: true, force, unknown };
+    else unknown.push(arg);
+  }
+  return { help: false, force, unknown };
+}
+
+const USAGE = `Usage: index-all.mjs [--force] [--help]
+
+  --force, -f   Bypass every per-step gate (equivalent to ${FORCE_ENV}=1)
+  --help,  -h   Show this message
+`;
+
+const cliArgs = parseArgs(process.argv.slice(2));
+if (cliArgs.help) {
+  process.stdout.write(USAGE);
+  process.exit(0);
+}
+if (cliArgs.unknown.length > 0) {
+  process.stderr.write(`index-all: unknown argument(s): ${cliArgs.unknown.join(', ')}\n${USAGE}`);
+  process.exit(2);
+}
+// Set before any gate decision is computed — decideStepGate reads the env var.
+if (cliArgs.force) process.env[FORCE_ENV] = '1';
+
 const projectRoot = findProjectRoot();
 const LOG_PATH = resolve(projectRoot, '.moflo', 'logs', 'hooks.log');
 try { mkdirSync(dirname(LOG_PATH), { recursive: true }); } catch { /* best effort */ }

package/bin/index-guidance.mjs

@@ -30,6 +30,7 @@ import { openBackend } from './lib/get-backend.mjs';
 import { applyIncrementalChunks } from './lib/incremental-write.mjs';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
 import { createProcessManager } from './lib/process-manager.mjs';
+import { readGuidanceConfig } from './lib/guidance-config.mjs';
 
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -49,47 +50,13 @@ const DB_PATH = memoryDbPath(projectRoot);
 function loadGuidanceDirs() {
   const dirs = [];
 
-  // 1. Read moflo.yaml / moflo.config.json for user-configured directories
-  let configDirs = null;
-  // #1294 — configurable SDD spec/plan location (default .moflo/specs). Parsed
-  // here alongside the guidance dirs so step 6 can honor it and skip a
-  // double-index when it sits inside a guidance dir.
-  let specsDirConfig = null;
-  const yamlPath = resolve(projectRoot, 'moflo.yaml');
-  const jsonPath = resolve(projectRoot, 'moflo.config.json');
-
-  if (existsSync(yamlPath)) {
-    try {
-      const content = readFileSync(yamlPath, 'utf-8');
-      // sdd.specs_dir (snake_case or camelCase, quoted or bare). Two-step:
-      // isolate the top-level `sdd:` block (up to the next column-0 key, blank
-      // lines included — a naive contiguous-line regex would break on natural
-      // whitespace between keys, #1294 review), then find specs_dir within it.
-      const sddBlock = content.match(/(?:^|\n)[ \t]*sdd:[ \t]*\n([\s\S]*?)(?=\n\S|$)/);
-      if (sddBlock) {
-        const m = sddBlock[1].match(/(?:^|\n)[ \t]+specs_?[dD]ir:[ \t]*["']?([^"'\n#]+)/);
-        if (m && m[1].trim()) specsDirConfig = m[1].trim();
-      }
-      // Simple YAML array extraction — avoids needing js-yaml at runtime
-      // Matches:  guidance:\n    directories:\n      - .claude/guidance\n      - docs/guides
-      const guidanceBlock = content.match(/guidance:\s*\n\s+directories:\s*\n((?:\s+-\s+.+\n?)+)/);
-      if (guidanceBlock) {
-        const items = guidanceBlock[1].match(/-\s+(.+)/g);
-        if (items && items.length > 0) {
-          configDirs = items.map(item => item.replace(/^-\s+/, '').trim());
-        }
-      }
-    } catch { /* ignore parse errors, fall through to defaults */ }
-  } else if (existsSync(jsonPath)) {
-    try {
-      const raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
-      if (raw.guidance?.directories && Array.isArray(raw.guidance.directories)) {
-        configDirs = raw.guidance.directories;
-      }
-      const sd = raw.sdd?.specs_dir ?? raw.sdd?.specsDir;
-      if (typeof sd === 'string' && sd.trim()) specsDirConfig = sd.trim();
-    } catch { /* ignore parse errors */ }
-  }
+  // 1. Read moflo.yaml / moflo.config.json for user-configured directories.
+  //     Delegated to lib/guidance-config.mjs so the step GATE fingerprints
+  //     exactly the directories this indexer walks — they disagreed before
+  //     #1323, which left every non-default directory permanently stale.
+  //     #1294 — specs_dir comes from the same read so step 6 can honor it and
+  //     skip a double-index when it sits inside a guidance dir.
+  const { directories: configDirs, specsDir: specsDirConfig } = readGuidanceConfig(projectRoot);
 
   // Use config dirs or fall back to defaults
   // Each directory gets a unique prefix derived from its path to avoid key collisions

package/bin/index-patterns.mjs

@@ -48,7 +48,7 @@ const statsOnly = args.includes('--stats');
 function log(msg) { console.log(`[index-patterns] ${msg}`); }
 function debug(msg) { if (verbose) console.log(`[index-patterns]   ${msg}`); }
 
-const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.py', '.go', '.rs']);
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs']);
 const EXCLUDE_DIRS = new Set([
   'node_modules', 'dist', 'build', '.next', 'coverage',
   '.claude', '.swarm', '.moflo', '.git', 'template',
@@ -123,7 +123,7 @@ function collectSourceFiles(dir, maxDepth = 8, depth = 0) {
     const fullPath = resolve(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectSourceFiles(fullPath, maxDepth, depth + 1));
-    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(extname(entry.name))) {
+    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
       files.push(fullPath);
     }
   }

package/bin/index-tests.mjs

@@ -58,7 +58,7 @@ const TEST_FILE_PATTERNS = [
   /\.test-\w+\.\w+$/,
 ];
 
-const TEST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs']);
+const TEST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
 
 const EXCLUDE_DIRS = new Set([
   'node_modules', 'dist', 'build', '.next', 'coverage',
@@ -193,8 +193,10 @@ function getTestFiles() {
   // Strategy 1: git ls-files for tracked test files
   let gitFiles = [];
   try {
+    // `:(icase)` — git pathspec globs are case-sensitive regardless of
+    // core.ignorecase, so `Foo.Test.mjs` would otherwise be skipped (#1337).
     const raw = execFileSync(
-      'git', ['ls-files', '--', '*.test.*', '*.spec.*', '*.test-*'],
+      'git', ['ls-files', '--', ':(icase)*.test.*', ':(icase)*.spec.*', ':(icase)*.test-*'],
       { cwd: projectRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, windowsHide: true }
     ).trim();
 
@@ -207,7 +209,7 @@ function getTestFiles() {
             if (f.startsWith(ex + '/')) return false;
           }
           // Only include recognized extensions
-          const ext = extname(f);
+          const ext = extname(f).toLowerCase();
           return TEST_EXTENSIONS.has(ext);
         });
     }
@@ -239,7 +241,7 @@ function walkTestFiles(dir, results) {
           walkTestFiles(resolve(dir, entry.name), results);
         }
       } else if (entry.isFile()) {
-        const ext = extname(entry.name);
+        const ext = extname(entry.name).toLowerCase();
         if (!TEST_EXTENSIONS.has(ext)) continue;
 
         // Include if it matches test patterns OR if it's inside a test directory

package/bin/lib/guidance-config.mjs

@@ -0,0 +1,119 @@
+/**
+ * Single source of truth for reading the `guidance:` block out of a project's
+ * moflo.yaml / moflo.config.json.
+ *
+ * Why this is shared rather than parsed per-caller (#1323): the guidance
+ * INDEXER honoured `guidance.directories` while the guidance step GATE
+ * fingerprinted a hardcoded `.claude/guidance`. Any configured directory
+ * beyond that default was indexed but never fingerprinted, so edits there
+ * never invalidated the gate and the guidance namespace went stale
+ * indefinitely — with embeddings regenerated from the same stale rows, so
+ * nothing downstream detected the drift. Two components disagreeing about one
+ * config key is the bug; duplicating the parse a third time would re-create it.
+ *
+ * Contract: never throws. A missing, unreadable, or malformed config yields
+ * `{ directories: null, specsDir: null }` and callers apply their own defaults.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+
+/** Default guidance directories when nothing is configured. */
+export const DEFAULT_GUIDANCE_DIRS = ['.claude/guidance', 'docs/guides'];
+
+// Parsing is cheap but the gate calls this twice per step (pre + post), and
+// `index-all` runs several steps per session-start. Cache per project root.
+const _configCache = new Map();
+
+function parseYaml(content) {
+  let directories = null;
+  let specsDir = null;
+
+  // sdd.specs_dir (snake_case or camelCase, quoted or bare). Two-step: isolate
+  // the top-level `sdd:` block (up to the next column-0 key, blank lines
+  // included — a naive contiguous-line regex breaks on whitespace between
+  // keys, #1294 review), then find specs_dir within it.
+  const sddBlock = content.match(/(?:^|\n)[ \t]*sdd:[ \t]*\n([\s\S]*?)(?=\n\S|$)/);
+  if (sddBlock) {
+    const m = sddBlock[1].match(/(?:^|\n)[ \t]+specs_?[dD]ir:[ \t]*["']?([^"'\n#]+)/);
+    if (m && m[1].trim()) specsDir = m[1].trim();
+  }
+
+  // Simple YAML array extraction — avoids needing js-yaml at runtime.
+  // Matches:  guidance:\n    directories:\n      - .claude/guidance\n      - docs/guides
+  const guidanceBlock = content.match(/guidance:\s*\n\s+directories:\s*\n((?:\s+-\s+.+\n?)+)/);
+  if (guidanceBlock) {
+    const items = guidanceBlock[1].match(/-\s+(.+)/g);
+    if (items && items.length > 0) {
+      const parsed = items
+        .map(item => item.replace(/^-\s+/, '').trim())
+        // Strip inline comments and surrounding quotes; drop empties so a
+        // malformed entry can't produce a directory that resolves to the root.
+        .map(d => d.replace(/\s+#.*$/, '').replace(/^["']|["']$/g, '').trim())
+        .filter(Boolean);
+      if (parsed.length > 0) directories = parsed;
+    }
+  }
+
+  return { directories, specsDir };
+}
+
+function parseJson(raw) {
+  let directories = null;
+  let specsDir = null;
+
+  if (Array.isArray(raw?.guidance?.directories)) {
+    const parsed = raw.guidance.directories
+      .filter(d => typeof d === 'string')
+      .map(d => d.trim())
+      .filter(Boolean);
+    if (parsed.length > 0) directories = parsed;
+  }
+
+  const sd = raw?.sdd?.specs_dir ?? raw?.sdd?.specsDir;
+  if (typeof sd === 'string' && sd.trim()) specsDir = sd.trim();
+
+  return { directories, specsDir };
+}
+
+/**
+ * Read the guidance config for `projectRoot`.
+ *
+ * @returns {{ directories: string[] | null, specsDir: string | null }}
+ *   `directories` is null when unset or malformed — callers decide the default.
+ */
+export function readGuidanceConfig(projectRoot) {
+  const cached = _configCache.get(projectRoot);
+  if (cached) return cached;
+
+  let result = { directories: null, specsDir: null };
+  try {
+    const yamlPath = resolve(projectRoot, 'moflo.yaml');
+    const jsonPath = resolve(projectRoot, 'moflo.config.json');
+    if (existsSync(yamlPath)) {
+      result = parseYaml(readFileSync(yamlPath, 'utf-8'));
+    } else if (existsSync(jsonPath)) {
+      result = parseJson(JSON.parse(readFileSync(jsonPath, 'utf-8')));
+    }
+  } catch {
+    // Malformed config must not break indexing or gating — fall back to
+    // defaults rather than throwing out of a session-start hook.
+  }
+
+  _configCache.set(projectRoot, result);
+  return result;
+}
+
+/**
+ * Guidance directories for `projectRoot`, with defaults applied.
+ * Always returns a non-empty array of repo-relative paths.
+ */
+export function resolveGuidanceDirs(projectRoot) {
+  const { directories } = readGuidanceConfig(projectRoot);
+  return directories && directories.length > 0 ? directories : [...DEFAULT_GUIDANCE_DIRS];
+}
+
+/** Test seam — drop memoised config (the file is read once per process). */
+export function _resetGuidanceConfigCache() {
+  _configCache.clear();
+}

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

@@ -690,94 +690,6 @@ const healthCommand = {
         }
     }
 };
-// Agent logs subcommand
-const logsCommand = {
-    name: 'logs',
-    description: 'Show agent activity logs',
-    options: [
-        {
-            name: 'id',
-            short: 'i',
-            description: 'Agent ID',
-            type: 'string'
-        },
-        {
-            name: 'tail',
-            short: 'n',
-            description: 'Number of recent entries',
-            type: 'number',
-            default: 50
-        },
-        {
-            name: 'level',
-            short: 'l',
-            description: 'Minimum log level',
-            type: 'string',
-            choices: ['debug', 'info', 'warn', 'error'],
-            default: 'info'
-        },
-        {
-            name: 'follow',
-            short: 'f',
-            description: 'Follow log output',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'since',
-            description: 'Show logs since (e.g., "1h", "30m")',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'flo agent logs -i agent-001', description: 'Show agent logs' },
-        { command: 'flo agent logs -i agent-001 -f', description: 'Follow agent logs' },
-        { command: 'flo agent logs -l error --since 1h', description: 'Show errors from last hour' }
-    ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags.id;
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level;
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', {
-                agentId,
-                tail,
-                level,
-                since: ctx.flags.since,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                const levelStr = formatLogLevel(entry.level);
-                output.writeln(`${output.dim(time)} ${levelStr} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Logs error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 function formatLogLevel(level) {
     switch (level) {
         case 'debug':
@@ -796,7 +708,7 @@ function formatLogLevel(level) {
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand],
     options: [],
     examples: [
         { command: 'flo agent spawn -t coder', description: 'Spawn a coder agent' },

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

@@ -11,7 +11,7 @@
  * - Module communities using Louvain algorithm
  * - Circular dependency detection
  *
- * Created with motailz.com
+ * Created with cielolimitada.com
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';

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

@@ -18,11 +18,14 @@ const pretrainCommand = {
     name: 'pretrain',
     description: 'Benchmark self-learning pre-training system (SONA, EWC++, MoE)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark 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', default: 'text' },
         { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', default: 'false' },
+        // Boolean default, not the string 'false' — this option shadows the global
+        // --verbose, so its default is the one the parser applies, and 'false' is
+        // a truthy string that would turn verbose ON by default.
+        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', default: false },
     ],
     examples: [
         { command: 'flo benchmark pretrain', description: 'Run pre-training benchmarks' },
@@ -82,9 +85,9 @@ const neuralCommand = {
     name: 'neural',
     description: 'Benchmark neural operations (embeddings, WASM, Flash Attention)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', default: '384' },
-        { name: 'vectors', short: 'n', type: 'number', description: 'Number of test vectors', default: '1000' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: 100 },
+        { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', default: 384 },
+        { name: 'vectors', short: 'n', type: 'number', description: 'Number of test vectors', default: 1000 },
         { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
     ],
     examples: [
@@ -242,7 +245,7 @@ const memoryCommand = {
     name: 'memory',
     description: 'Benchmark memory operations (HNSW search, store, retrieve)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: 100 },
         { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
     ],
     examples: [
@@ -356,7 +359,7 @@ const allCommand = {
     name: 'all',
     description: 'Run all benchmark suites',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '50' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: 50 },
         { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
         { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
     ],

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

@@ -2,7 +2,7 @@
  * V3 CLI Claims Command
  * Claims-based authorization, permissions, and access control
  *
- * Created with ❤️ by motailz.com
+ * Created with ❤️ by cielolimitada.com
  */
 import { output } from '../output.js';
 import os from 'os';
@@ -366,7 +366,7 @@ export const claimsCommand = {
             'admin:*   - Administrative operations',
         ]);
         output.writeln();
-        output.writeln(output.dim('Created with ❤️ by motailz.com'));
+        output.writeln(output.dim('Created with ❤️ by cielolimitada.com'));
         return { success: true };
     },
 };