moflo 4.6.5 → 4.6.7

package/.claude/helpers/statusline.cjs

@@ -31,6 +31,7 @@ function loadStatusLineConfig() {
   const defaults = {
     enabled: true,
     branding: 'Moflo V4',
+    show_dir: true,
     show_git: true,
     show_model: true,
     show_session: true,
@@ -42,7 +43,7 @@ function loadStatusLineConfig() {
     show_adrs: true,
     show_agentdb: true,
     show_tests: true,
-    mode: 'single-line',
+    mode: 'compact',
   };
 
   // Try moflo.yaml
@@ -159,38 +160,26 @@ function getGitInfo() {
     staged: 0, ahead: 0, behind: 0,
   };
 
-  // Single shell: get user.name, branch, porcelain status, and upstream diff
-  const script = [
-    'git config user.name 2>/dev/null || echo user',
-    'echo "---SEP---"',
-    'git branch --show-current 2>/dev/null',
-    'echo "---SEP---"',
-    'git status --porcelain 2>/dev/null',
-    'echo "---SEP---"',
-    'git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null || echo "0 0"',
-  ].join('; ');
-
-  const raw = safeExec(`sh -c '${script}'`, 3000);
-  if (!raw) return result;
-
-  const parts = raw.split('---SEP---').map(s => s.trim());
-  if (parts.length >= 4) {
-    result.name = parts[0] || 'user';
-    result.gitBranch = parts[1] || '';
-
-    // Parse porcelain status
-    if (parts[2]) {
-      for (const line of parts[2].split('\n')) {
-        if (!line || line.length < 2) continue;
-        const x = line[0], y = line[1];
-        if (x === '?' && y === '?') { result.untracked++; continue; }
-        if (x !== ' ' && x !== '?') result.staged++;
-        if (y !== ' ' && y !== '?') result.modified++;
-      }
+  // Individual git calls (cross-platform — sh -c fails on Windows)
+  result.name = safeExec('git config user.name', 2000) || 'user';
+  result.gitBranch = safeExec('git branch --show-current', 2000) || '';
+
+  // Parse porcelain status
+  const statusRaw = safeExec('git status --porcelain', 2000);
+  if (statusRaw) {
+    for (const line of statusRaw.split('\n')) {
+      if (!line || line.length < 2) continue;
+      const x = line[0], y = line[1];
+      if (x === '?' && y === '?') { result.untracked++; continue; }
+      if (x !== ' ' && x !== '?') result.staged++;
+      if (y !== ' ' && y !== '?') result.modified++;
     }
+  }
+
+  {
 
     // Parse ahead/behind
-    const ab = (parts[3] || '0 0').split(/\s+/);
+    const ab = (safeExec('git rev-list --left-right --count HEAD...@{upstream}', 2000) || '0 0').split(/\s+/);
     result.ahead = parseInt(ab[0]) || 0;
     result.behind = parseInt(ab[1]) || 0;
   }
@@ -669,26 +658,17 @@ function generateStatusline() {
 }
 
 // Multi-line dashboard (for --dashboard flag)
+// Respects show_* toggles from moflo.yaml status_line config
 function generateDashboard() {
   const git = getGitInfo();
-  const modelName = getModelName();
-  const progress = getV3Progress();
-  const security = getSecurityStatus();
-  const swarm = getSwarmStatus();
-  const system = getSystemMetrics();
-  const adrs = getADRStatus();
-  const hooks = getHooksStatus();
-  const agentdb = getAgentDBStats();
-  const tests = getTestStats();
   const session = getSessionStats();
-  const integration = getIntegrationStatus();
   const lines = [];
 
-  // Header
+  // Header: branding + dir + git
   let header = `${c.bold}${c.brightPurple}\u258A ${SL_CONFIG.branding}${c.reset}`;
-  header += `${swarm.coordinationActive ? c.brightCyan : c.dim}\u25CF ${c.brightCyan}${git.name}${c.reset}`;
-  if (git.gitBranch) {
-    header += `  ${c.dim}\u2502${c.reset}  ${c.brightBlue}\u23C7 ${git.gitBranch}${c.reset}`;
+  if (SL_CONFIG.show_dir) header += `  ${c.brightWhite}${path.basename(CWD)}${c.reset}`;
+  if (SL_CONFIG.show_git && git.gitBranch) {
+    header += `  ${c.brightBlue}\u23C7 ${git.gitBranch}${c.reset}`;
     const changes = git.modified + git.staged + git.untracked;
     if (changes > 0) {
       let ind = '';
@@ -700,82 +680,112 @@ function generateDashboard() {
     if (git.ahead > 0) header += ` ${c.brightGreen}\u2191${git.ahead}${c.reset}`;
     if (git.behind > 0) header += ` ${c.brightRed}\u2193${git.behind}${c.reset}`;
   }
-  header += `  ${c.dim}\u2502${c.reset}  ${c.purple}${modelName}${c.reset}`;
-  if (session.duration) header += `  ${c.dim}\u2502${c.reset}  ${c.cyan}\u23F1 ${session.duration}${c.reset}`;
+  if (SL_CONFIG.show_session && session.duration) {
+    header += `  ${c.dim}\u2502${c.reset}  ${c.cyan}\u23F1 ${session.duration}${c.reset}`;
+  }
   lines.push(header);
 
   // Separator
-  lines.push(`${c.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
-
-  // Line 1: DDD Domains + perf
-  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
-  let perfIndicator;
-  if (agentdb.hasHnsw && agentdb.vectorCount > 0) {
-    const speedup = agentdb.vectorCount > 10000 ? '12500x' : agentdb.vectorCount > 1000 ? '150x' : '10x';
-    perfIndicator = `${c.brightGreen}\u26A1 HNSW ${speedup}${c.reset}`;
-  } else if (progress.patternsLearned > 0) {
-    const pk = progress.patternsLearned >= 1000 ? `${(progress.patternsLearned / 1000).toFixed(1)}k` : String(progress.patternsLearned);
-    perfIndicator = `${c.brightYellow}\uD83D\uDCDA ${pk} patterns${c.reset}`;
-  } else {
-    perfIndicator = `${c.dim}\u26A1 target: 150x-12500x${c.reset}`;
-  }
-  lines.push(
-    `${c.brightCyan}\uD83C\uDFD7\uFE0F  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
-    `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ${perfIndicator}`
-  );
-
-  // Line 2: Swarm + Hooks + CVE + Memory + Intelligence
-  const swarmInd = swarm.coordinationActive ? `${c.brightGreen}\u25C9${c.reset}` : `${c.dim}\u25CB${c.reset}`;
-  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-  const secIcon = security.status === 'CLEAN' ? '\uD83D\uDFE2' : security.status === 'IN_PROGRESS' ? '\uD83D\uDFE1' : '\uD83D\uDD34';
-  const secColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
-  const hooksColor = hooks.enabled > 0 ? c.brightGreen : c.dim;
-  const intellColor = system.intelligencePct >= 80 ? c.brightGreen : system.intelligencePct >= 40 ? c.brightYellow : c.dim;
-
-  lines.push(
-    `${c.brightYellow}\uD83E\uDD16 Swarm${c.reset}  ${swarmInd} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
-    `${c.brightPurple}\uD83D\uDC65 ${system.subAgents}${c.reset}    ` +
-    `${c.brightBlue}\uD83E\uDE9D ${hooksColor}${hooks.enabled}${c.reset}/${c.brightWhite}${hooks.total}${c.reset}    ` +
-    `${secIcon} ${secColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}    ` +
-    `${c.brightCyan}\uD83D\uDCBE ${system.memoryMB}MB${c.reset}    ` +
-    `${intellColor}\uD83E\uDDE0 ${String(system.intelligencePct).padStart(3)}%${c.reset}`
-  );
-
-  // Line 3: Architecture
-  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
-  const adrColor = adrs.count > 0 ? (adrs.implemented === adrs.count ? c.brightGreen : c.yellow) : c.dim;
-  const adrDisplay = adrs.compliance > 0 ? `${adrColor}\u25CF${adrs.compliance}%${c.reset}` : `${adrColor}\u25CF${adrs.implemented}/${adrs.count}${c.reset}`;
-
-  lines.push(
-    `${c.brightPurple}\uD83D\uDD27 Architecture${c.reset}    ` +
-    `${c.cyan}ADRs${c.reset} ${adrDisplay}  ${c.dim}\u2502${c.reset}  ` +
-    `${c.cyan}DDD${c.reset} ${dddColor}\u25CF${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}\u2502${c.reset}  ` +
-    `${c.cyan}Security${c.reset} ${secColor}\u25CF${security.status}${c.reset}`
-  );
-
-  // Line 4: AgentDB, Tests, Integration
-  const hnswInd = agentdb.hasHnsw ? `${c.brightGreen}\u26A1${c.reset}` : '';
-  const sizeDisp = agentdb.dbSizeKB >= 1024 ? `${(agentdb.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdb.dbSizeKB}KB`;
-  const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
-  const testColor = tests.testFiles > 0 ? c.brightGreen : c.dim;
-
-  let integStr = '';
-  if (integration.mcpServers.total > 0) {
-    const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
-                   integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
-    integStr += `${c.cyan}MCP${c.reset} ${mcpCol}\u25CF${integration.mcpServers.enabled}/${integration.mcpServers.total}${c.reset}`;
-  }
-  if (integration.hasDatabase) integStr += (integStr ? '  ' : '') + `${c.brightGreen}\u25C6${c.reset}DB`;
-  if (integration.hasApi) integStr += (integStr ? '  ' : '') + `${c.brightGreen}\u25C6${c.reset}API`;
-  if (!integStr) integStr = `${c.dim}\u25CF none${c.reset}`;
-
-  lines.push(
-    `${c.brightCyan}\uD83D\uDCCA AgentDB${c.reset}    ` +
-    `${c.cyan}Vectors${c.reset} ${vectorColor}\u25CF${agentdb.vectorCount}${hnswInd}${c.reset}  ${c.dim}\u2502${c.reset}  ` +
-    `${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisp}${c.reset}  ${c.dim}\u2502${c.reset}  ` +
-    `${c.cyan}Tests${c.reset} ${testColor}\u25CF${tests.testFiles}${c.reset} ${c.dim}(~${tests.testCases} cases)${c.reset}  ${c.dim}\u2502${c.reset}  ` +
-    integStr
-  );
+  lines.push(`${c.dim}${'─'.repeat(53)}${c.reset}`);
+
+  // Swarm line (if enabled)
+  if (SL_CONFIG.show_swarm) {
+    const swarm = getSwarmStatus();
+    const system = getSystemMetrics();
+    const swarmInd = swarm.coordinationActive ? `${c.brightGreen}\u25C9${c.reset}` : `${c.dim}\u25CB${c.reset}`;
+    const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
+    lines.push(
+      `${c.brightYellow}\uD83E\uDD16 Swarm${c.reset}  ${swarmInd} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
+      `${c.brightPurple}\uD83D\uDC65 ${system.subAgents}${c.reset}    ` +
+      `${c.brightCyan}\uD83D\uDCBE ${system.memoryMB}MB${c.reset}`
+    );
+  }
+
+  // AgentDB + MCP line (if either enabled)
+  if (SL_CONFIG.show_agentdb || SL_CONFIG.show_mcp) {
+    const parts = [];
+    if (SL_CONFIG.show_agentdb) {
+      const agentdb = getAgentDBStats();
+      const hnswInd = agentdb.hasHnsw ? `${c.brightGreen}\u26A1${c.reset}` : '';
+      const sizeDisp = agentdb.dbSizeKB >= 1024 ? `${(agentdb.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdb.dbSizeKB}KB`;
+      const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
+      parts.push(`${c.cyan}Vectors${c.reset} ${vectorColor}\u25CF${agentdb.vectorCount}${hnswInd}${c.reset}`);
+      parts.push(`${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisp}${c.reset}`);
+    }
+    if (SL_CONFIG.show_mcp) {
+      const integration = getIntegrationStatus();
+      if (integration.mcpServers.total > 0) {
+        const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
+                       integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
+        parts.push(`${c.cyan}MCP${c.reset} ${mcpCol}\u25CF${integration.mcpServers.enabled}/${integration.mcpServers.total}${c.reset}`);
+      }
+      if (integration.hasDatabase) parts.push(`${c.brightGreen}\u25C6${c.reset}DB`);
+    }
+    if (parts.length > 0) {
+      lines.push(`${c.brightCyan}\uD83D\uDCCA AgentDB${c.reset}    ${parts.join(`  ${c.dim}\u2502${c.reset}  `)}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// Compact dashboard: header + single combined line
+function generateCompactDashboard() {
+  const git = getGitInfo();
+  const session = getSessionStats();
+  const lines = [];
+
+  // Header: branding + dir + git + session
+  let header = `${c.bold}${c.brightPurple}\u258A ${SL_CONFIG.branding}${c.reset}`;
+  if (SL_CONFIG.show_dir) header += `  ${c.brightWhite}${path.basename(CWD)}${c.reset}`;
+  if (SL_CONFIG.show_git && git.gitBranch) {
+    header += `  ${c.brightBlue}\u23C7 ${git.gitBranch}${c.reset}`;
+    const changes = git.modified + git.staged + git.untracked;
+    if (changes > 0) {
+      let ind = '';
+      if (git.staged > 0) ind += `${c.brightGreen}+${git.staged}${c.reset}`;
+      if (git.modified > 0) ind += `${c.brightYellow}~${git.modified}${c.reset}`;
+      if (git.untracked > 0) ind += `${c.dim}?${git.untracked}${c.reset}`;
+      header += ` ${ind}`;
+    }
+    if (git.ahead > 0) header += ` ${c.brightGreen}\u2191${git.ahead}${c.reset}`;
+    if (git.behind > 0) header += ` ${c.brightRed}\u2193${git.behind}${c.reset}`;
+  }
+  if (SL_CONFIG.show_session && session.duration) {
+    header += `  ${c.dim}\u2502${c.reset}  ${c.cyan}\u23F1 ${session.duration}${c.reset}`;
+  }
+  lines.push(header);
+
+  // Combined swarm + agentdb + mcp line
+  const segments = [];
+  if (SL_CONFIG.show_swarm) {
+    const swarm = getSwarmStatus();
+    const swarmInd = swarm.coordinationActive ? `${c.brightGreen}\u25C9${c.reset}` : `${c.dim}\u25CB${c.reset}`;
+    const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
+    segments.push(
+      `${c.brightYellow}\uD83E\uDD16${c.reset} ${swarmInd}[${agentsColor}${swarm.activeAgents}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]`
+    );
+  }
+  if (SL_CONFIG.show_agentdb) {
+    const agentdb = getAgentDBStats();
+    const hnswInd = agentdb.hasHnsw ? `\u26A1` : '';
+    const sizeDisp = agentdb.dbSizeKB >= 1024 ? `${(agentdb.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdb.dbSizeKB}KB`;
+    const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
+    segments.push(
+      `${c.brightCyan}\uD83D\uDCCA${c.reset} ${vectorColor}${agentdb.vectorCount}${hnswInd}${c.reset} ${c.dim}(${sizeDisp})${c.reset}`
+    );
+  }
+  if (SL_CONFIG.show_mcp) {
+    const integration = getIntegrationStatus();
+    if (integration.mcpServers.total > 0) {
+      const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
+                     integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
+      segments.push(`${c.cyan}MCP${c.reset} ${mcpCol}\u25CF${integration.mcpServers.enabled}/${integration.mcpServers.total}${c.reset}`);
+    }
+  }
+  if (segments.length > 0) {
+    lines.push(segments.join(`  ${c.dim}\u2502${c.reset}  `));
+  }
 
   return lines.join('\n');
 }
@@ -799,13 +809,23 @@ function generateJSON() {
 }
 
 // ─── Main ───────────────────────────────────────────────────────
-if (process.argv.includes('--json')) {
+// CLI flags take precedence over moflo.yaml mode
+const cliMode = process.argv.includes('--json') ? 'json'
+  : process.argv.includes('--json-compact') ? 'json-compact'
+  : process.argv.includes('--dashboard') ? 'dashboard'
+  : process.argv.includes('--compact') ? 'compact'
+  : process.argv.includes('--single-line') ? 'single-line'
+  : null;
+const mode = cliMode || SL_CONFIG.mode || 'compact';
+
+if (mode === 'json') {
   console.log(JSON.stringify(generateJSON(), null, 2));
-} else if (process.argv.includes('--compact')) {
+} else if (mode === 'json-compact') {
   console.log(JSON.stringify(generateJSON()));
-} else if (process.argv.includes('--dashboard') || SL_CONFIG.mode === 'dashboard') {
+} else if (mode === 'dashboard') {
   console.log(generateDashboard());
+} else if (mode === 'compact') {
+  console.log(generateCompactDashboard());
 } else {
-  // Default: single-line statusline
   console.log(generateStatusline());
 }

package/README.md

@@ -4,9 +4,9 @@
 
 # MoFlo
 
-**An opinionated, maintained fork of [Ruflo/Claude Flow](https://github.com/ruvnet/ruflo) that just works.**
+**An opinionated fork of [Ruflo/Claude Flow](https://github.com/ruvnet/ruflo), optimized for local development.**
 
-MoFlo adds automatic code and guidance cataloging along with memory gating on top of the original Claude Flow orchestration engine. Where the upstream project provides raw building blocks, MoFlo ships opinionated defaults — workflow gates that enforce memory-first patterns, semantic indexing that runs at session start, and learned routing that improves over time — so you get a productive setup from `flo init` without manual tuning.
+MoFlo adds automatic code and guidance cataloging along with memory gating on top of the original Ruflo/Claude Flow orchestration engine. Where the upstream project provides raw building blocks, MoFlo ships opinionated defaults — workflow gates that enforce memory-first patterns, semantic indexing that runs at session start, and learned routing that improves over time — so you get a productive setup from `flo init` without manual tuning.
 
 Install it as a dev dependency and run `flo init`.
 
@@ -23,29 +23,82 @@ Install it as a dev dependency and run `flo init`.
 | **Context Tracking** | Monitors context window usage (FRESH → MODERATE → DEPLETED → CRITICAL) and advises accordingly. |
 | **Cross-Platform** | Works on macOS, Linux, and Windows. |
 
-## Quick Start
+## Getting Started
+
+### 1. Install and init
 
 ```bash
-# Install as a dev dependency
 npm install --save-dev moflo
-
-# Initialize your project (generates config, hooks, skill, CLAUDE.md section)
 npx flo init
+```
+
+`flo init` automatically scans your project to find where your guidance and code live, then writes the results into `moflo.yaml`. It looks for:
+
+| What | Directories it checks | Default if none found |
+|------|----------------------|----------------------|
+| **Guidance** | `.claude/guidance`, `docs/guides`, `docs`, `architecture`, `adr`, `.cursor/rules` | `.claude/guidance` |
+| **Source code** | `src`, `packages`, `lib`, `app`, `apps`, `services`, `server`, `client` | `src` |
+| **Languages** | Scans detected source dirs for file extensions | `.ts`, `.tsx`, `.js`, `.jsx` |
+
+It also generates:
 
-# Index your project's knowledge base
-npx flo memory index-guidance
-npx flo memory code-map
+| Generated File | Purpose |
+|----------------|---------|
+| `moflo.yaml` | Project config with detected guidance/code locations |
+| `.claude/settings.json` | Workflow gate hooks for Claude Code |
+| `.claude/skills/flo/` | The `/flo` issue execution skill (also `/fl`) |
+| `CLAUDE.md` section | Teaches Claude how to use MoFlo |
+| `.gitignore` entries | Excludes MoFlo state directories |
 
-# Verify everything works
-npx flo doctor
+In interactive mode (`flo init` without `--yes`), it shows what it found and lets you confirm or adjust before writing.
+
+### 2. Review your guidance and code settings
+
+Open `moflo.yaml` to see what init detected. The two key sections:
+
+**Guidance** — documentation that helps Claude understand your project (conventions, architecture, domain context):
+
+```yaml
+guidance:
+  directories:
+    - .claude/guidance    # project rules, patterns, conventions
+    - docs                # general documentation
 ```
 
-That's it. `flo init` sets up everything:
-- `moflo.yaml` — project config (auto-detects source dirs, languages, guidance paths)
-- `.claude/settings.json` — workflow gate hooks
-- `.claude/skills/flo/` — the `/flo` issue execution skill (with `/fl` alias)
-- `CLAUDE.md` — appends a MoFlo workflow section so Claude knows how to use it
-- `.gitignore` — adds state directories
+**Code map** — source files to index for "where does X live?" navigation:
+
+```yaml
+code_map:
+  directories:
+    - src                 # your source code
+    - packages            # shared packages (monorepo)
+  extensions: [".ts", ".tsx"]
+  exclude: [node_modules, dist, .next, coverage]
+```
+
+MoFlo chunks your guidance files into semantic embeddings and indexes your code structure, so Claude searches your knowledge base before touching any files. Adjust these directories to match your project:
+
+```yaml
+# Monorepo with shared docs
+guidance:
+  directories: [.claude/guidance, docs, packages/shared/docs]
+code_map:
+  directories: [packages, apps, libs]
+
+# Backend + frontend
+code_map:
+  directories: [server/src, client/src]
+```
+
+### 3. Index and verify
+
+```bash
+npx flo memory index-guidance    # Index your guidance docs
+npx flo memory code-map          # Index your code structure
+npx flo doctor                   # Verify everything works
+```
+
+Both indexes run automatically at session start after this, so you only need to run them manually on first setup or after major structural changes.
 
 ## Commands
 
@@ -120,21 +173,22 @@ flo doctor                       # Health check
 flo --version                    # Show version
 ```
 
-## Configuration
 
-`flo init` generates a `moflo.yaml` at your project root:
+## Full Configuration Reference
+
+`flo init` generates a `moflo.yaml` at your project root. Here's the complete set of options:
 
 ```yaml
 project:
   name: "my-project"
 
 guidance:
-  directories: [.claude/guidance]    # Where your knowledge docs live
+  directories: [.claude/guidance]
   namespace: guidance
 
 code_map:
-  directories: [src, packages]       # Source dirs to index
-  extensions: [".ts", ".tsx"]        # Auto-detected from your project
+  directories: [src, packages]
+  extensions: [".ts", ".tsx"]
   exclude: [node_modules, dist]
   namespace: code-map
 
@@ -147,42 +201,37 @@ auto_index:
   guidance: true                     # Auto-index docs on session start
   code_map: true                     # Auto-index code on session start
 
-# Hook toggles (all on by default — disable to slim down)
 hooks:
   pre_edit: true                     # Track file edits for learning
-  post_edit: true                    # Record edit outcomes, train neural patterns
-  pre_task: true                     # Get agent routing before task spawn
+  post_edit: true                    # Record edit outcomes
+  pre_task: true                     # Agent routing before task spawn
   post_task: true                    # Record task results for learning
   gate: true                         # Workflow gate enforcement
-  route: true                        # Intelligent task routing on each prompt
+  route: true                        # Intelligent task routing
   stop_hook: true                    # Session-end persistence
   session_restore: true              # Restore session state on start
-  notification: true                 # Hook into Claude Code notifications
 
 models:
-  default: opus        # General tasks
-  research: sonnet     # Research/exploration agents
-  review: opus         # Code review agents
-  test: sonnet         # Test-writing agents
+  default: opus
+  research: sonnet
+  review: opus
+  test: sonnet
 
-# Optional: intelligent model routing (off by default)
 model_routing:
-  enabled: false                   # Set to true to enable
+  enabled: false                     # Set to true for automatic model selection
   confidence_threshold: 0.85
   cost_optimization: true
   circuit_breaker: true
 
-# Status line display
 status_line:
   enabled: true
-  branding: "Moflo V4"
-  mode: single-line                # single-line or dashboard
+  branding: "MoFlo V4"
+  mode: compact                      # single-line, compact, or dashboard
+  show_dir: true                      # current directory name (compact/dashboard only)
   show_git: true
-  show_model: true
   show_session: true
-  show_intelligence: true
   show_swarm: true
-  show_hooks: true
+  show_agentdb: true
   show_mcp: true
 ```
 
@@ -228,13 +277,54 @@ MoFlo installs Claude Code hooks that run on every tool call. Together, these ga
 
 All gates are configurable via `moflo.yaml` — you can disable any individual hook if it doesn't suit your workflow.
 
-### The Task System
+### Intelligent Agent Routing
+
+MoFlo ships with 12 built-in task patterns that map common work to the right agent type:
+
+| Pattern | Keywords | Primary Agent |
+|---------|----------|---------------|
+| security-task | auth, password, encryption, CVE | security-architect |
+| testing-task | test, spec, coverage, e2e | tester |
+| database-task | schema, migration, SQL, ORM | architect |
+| feature-task | implement, add, create, build | architect → coder |
+| bugfix-task | bug, fix, error, crash, debug | coder |
+| api-task | endpoint, REST, route, handler | architect → coder |
+| ... | | *(12 patterns total)* |
+
+When you route a task (`flo hooks route --task "..."` or via MCP), MoFlo runs semantic similarity against these patterns using HNSW vector search and returns a ranked recommendation with confidence scores.
+
+**The routing gets smarter over time.** Every time a task completes successfully, MoFlo's post-task hook records the outcome — the full task description, which agent handled it, and whether it succeeded. These learned patterns are combined with the built-in seeds on every future route call. Because learned patterns contain rich task descriptions (not just short keywords), they discriminate better as they accumulate.
 
-MoFlo integrates Claude Code's native Task tool with its own coordination layer:
+Routing outcomes are stored in `.claude-flow/routing-outcomes.json` and persist across sessions. You can inspect them with `flo hooks patterns` or transfer them between projects with `flo hooks transfer`.
 
-1. **Pre-task hook** — Before a sub-agent spawns, MoFlo records what's about to happen and can inject context (prior learnings, routing recommendations) into the agent's prompt.
-2. **Post-task hook** — After a sub-agent completes, MoFlo records the outcome. Successful patterns are stored in the memory database for future reference. Failed patterns feed into the routing circuit breaker.
-3. **The `/flo` skill** — Wraps the entire lifecycle of a GitHub issue: research the issue → enhance the ticket → implement the solution → run tests → simplify the code → create a PR. Each phase can use sub-agents, and all learning feeds back into memory.
+### The Two-Layer Task System
+
+MoFlo doesn't replace your AI client's task system — it wraps it. Your client (Claude Code, Cursor, or any MCP-capable tool) handles spawning agents and running code. MoFlo adds a coordination layer on top that handles memory, routing, and learning.
+
+```
+┌──────────────────────────────────────────────────┐
+│  YOUR AI CLIENT (Execution Layer)                │
+│  Spawns agents, runs code, streams output        │
+│  TaskCreate → Agent → TaskUpdate → results       │
+├──────────────────────────────────────────────────┤
+│  MOFLO (Knowledge Layer)                         │
+│  Routes tasks, gates agent spawns, stores        │
+│  patterns, learns from outcomes                  │
+└──────────────────────────────────────────────────┘
+```
+
+Here's how a typical task flows through both layers:
+
+1. **MoFlo routes** — Before work starts, MoFlo analyzes the prompt and recommends an agent type and model tier via hook or MCP tool.
+2. **MoFlo gates** — Before an agent can spawn, MoFlo verifies that memory was searched and a task was registered. This prevents blind exploration.
+3. **Your client executes** — The actual agent runs through your client's native task system. MoFlo doesn't manage the agent — your client handles execution, output, and completion.
+4. **MoFlo learns** — After the agent finishes, MoFlo records what worked (or didn't) in its memory database. Successful patterns feed into future routing.
+
+The key insight: **your client handles execution, MoFlo handles knowledge.** Your client is good at spawning agents and running code. MoFlo is good at remembering what happened, routing to the right agent, and ensuring prior knowledge is checked before exploring from scratch.
+
+For complex work, MoFlo structures tasks into waves — a research wave discovers context, then an implementation wave acts on it — with dependencies tracked through both the client's task system and MoFlo's coordination layer. The full integration pattern is documented in `.claude/guidance/task-swarm-integration.md`.
+
+The `/flo` skill ties both systems together for GitHub issues — driving a full workflow (research → enhance → implement → test → simplify → PR) with your client's agents for execution and MoFlo's memory for continuity.
 
 ### Memory & Knowledge Storage
 
@@ -262,18 +352,14 @@ When `flo init` runs, it appends a workflow section to your CLAUDE.md that teach
 
 ## Architecture
 
-MoFlo is a maintained fork of [ruflo 3.x](https://github.com/ruvnet/ruflo) with:
-
-- **3 patches applied to TypeScript source** (no more monkey-patching node_modules):
-  - 384-dim domain-aware embeddings for consistent CLI ↔ MCP search
-  - `windowsHide: true` on all spawn/exec calls (Windows UX)
-  - Routing learned patterns (task outcomes feed back into routing)
 - **7 standalone bin scripts** shipped with npm: `flo-search`, `flo-embeddings`, `flo-index`, `flo-codemap`, `flo-learn`, `flo-setup`, plus the main `flo` CLI
 - **Project config system**: `moflo.yaml` for per-project settings
 - **One-stop init**: `flo init` generates everything needed for OOTB operation
 
-Upstream remote preserved for cherry-picking future ruflo fixes.
+## Ruflo / Claude Flow
+
+MoFlo builds on top of the full [Ruflo/Claude Flow](https://github.com/ruvnet/ruflo) engine. For detailed documentation on the underlying capabilities — swarm topologies, hive-mind consensus, HNSW vector search, neural routing, MCP server internals, and more — check out the [Ruflo repository](https://github.com/ruvnet/ruflo).
 
 ## License
 
-MIT (inherited from [upstream](https://github.com/ruvnet/ruflo))
+MIT (inherited from [Ruflo/Claude Flow](https://github.com/ruvnet/ruflo))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",

package/src/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.6.5",
+  "version": "4.6.6",
   "type": "module",
   "description": "MoFlo CLI — AI agent orchestration with specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",